diff --git a/[refs] b/[refs] index a50eee942c9e..d19d93b29b5b 100644 --- a/[refs] +++ b/[refs] @@ -1,2 +1,2 @@ --- -refs/heads/master: 6c59f9d9fb95934bf3d7d64249b338ce79953b5b +refs/heads/master: 7063fbf2261194f72ee75afca67b3b38b554b5fa diff --git a/trunk/.gitignore b/trunk/.gitignore index a4b576eb9c00..5014bfa48ac1 100644 --- a/trunk/.gitignore +++ b/trunk/.gitignore @@ -23,7 +23,6 @@ Module.symvers # Generated include files # include/asm -include/asm-*/asm-offsets.h include/config include/linux/autoconf.h include/linux/compile.h diff --git a/trunk/CREDITS b/trunk/CREDITS index 521f00d1b549..1b4f8694fa48 100644 --- a/trunk/CREDITS +++ b/trunk/CREDITS @@ -1883,7 +1883,6 @@ N: Jaya Kumar E: jayalk@intworks.biz W: http://www.intworks.biz D: Arc monochrome LCD framebuffer driver, x86 reboot fixups -D: pirq addr, CS5535 alsa audio driver S: Gurgaon, India S: Kuala Lumpur, Malaysia diff --git a/trunk/Documentation/DocBook/usb.tmpl b/trunk/Documentation/DocBook/usb.tmpl index 320af25de3a2..15ce0f21e5e0 100644 --- a/trunk/Documentation/DocBook/usb.tmpl +++ b/trunk/Documentation/DocBook/usb.tmpl @@ -253,7 +253,6 @@ !Edrivers/usb/core/urb.c !Edrivers/usb/core/message.c !Edrivers/usb/core/file.c -!Edrivers/usb/core/driver.c !Edrivers/usb/core/usb.c !Edrivers/usb/core/hub.c diff --git a/trunk/Documentation/SubmittingPatches b/trunk/Documentation/SubmittingPatches index 1d47e6c09dc6..237d54c44bc5 100644 --- a/trunk/Documentation/SubmittingPatches +++ b/trunk/Documentation/SubmittingPatches @@ -158,7 +158,7 @@ Even if the maintainer did not respond in step #4, make sure to ALWAYS copy the maintainer when you change their code. For small patches you may want to CC the Trivial Patch Monkey -trivial@kernel.org managed by Adrian Bunk; which collects "trivial" +trivial@rustcorp.com.au set up by Rusty Russell; which collects "trivial" patches. Trivial patches must qualify for one of the following rules: Spelling fixes in documentation Spelling fixes which could break grep(1). @@ -171,7 +171,7 @@ patches. Trivial patches must qualify for one of the following rules: since people copy, as long as it's trivial) Any fix by the author/maintainer of the file. (ie. patch monkey in re-transmission mode) -URL: +URL: diff --git a/trunk/Documentation/block/biodoc.txt b/trunk/Documentation/block/biodoc.txt index 303c57a7fad9..0fe01c805480 100644 --- a/trunk/Documentation/block/biodoc.txt +++ b/trunk/Documentation/block/biodoc.txt @@ -31,7 +31,7 @@ The following people helped with review comments and inputs for this document: Christoph Hellwig Arjan van de Ven - Randy Dunlap + Randy Dunlap Andre Hedrick The following people helped with fixes/contributions to the bio patches diff --git a/trunk/Documentation/cpu-freq/governors.txt b/trunk/Documentation/cpu-freq/governors.txt index f4b8dc4237e6..933fae74c337 100644 --- a/trunk/Documentation/cpu-freq/governors.txt +++ b/trunk/Documentation/cpu-freq/governors.txt @@ -27,7 +27,6 @@ Contents: 2.2 Powersave 2.3 Userspace 2.4 Ondemand -2.5 Conservative 3. The Governor Interface in the CPUfreq Core @@ -111,64 +110,9 @@ directory. The CPUfreq govenor "ondemand" sets the CPU depending on the current usage. To do this the CPU must have the capability to -switch the frequency very quickly. There are a number of sysfs file -accessible parameters: - -sampling_rate: measured in uS (10^-6 seconds), this is how often you -want the kernel to look at the CPU usage and to make decisions on -what to do about the frequency. Typically this is set to values of -around '10000' or more. - -show_sampling_rate_(min|max): the minimum and maximum sampling rates -available that you may set 'sampling_rate' to. - -up_threshold: defines what the average CPU usaged between the samplings -of 'sampling_rate' needs to be for the kernel to make a decision on -whether it should increase the frequency. For example when it is set -to its default value of '80' it means that between the checking -intervals the CPU needs to be on average more than 80% in use to then -decide that the CPU frequency needs to be increased. - -sampling_down_factor: this parameter controls the rate that the CPU -makes a decision on when to decrease the frequency. When set to its -default value of '5' it means that at 1/5 the sampling_rate the kernel -makes a decision to lower the frequency. Five "lower rate" decisions -have to be made in a row before the CPU frequency is actually lower. -If set to '1' then the frequency decreases as quickly as it increases, -if set to '2' it decreases at half the rate of the increase. - -ignore_nice_load: this parameter takes a value of '0' or '1', when set -to '0' (its default) then all processes are counted towards towards the -'cpu utilisation' value. When set to '1' then processes that are -run with a 'nice' value will not count (and thus be ignored) in the -overal usage calculation. This is useful if you are running a CPU -intensive calculation on your laptop that you do not care how long it -takes to complete as you can 'nice' it and prevent it from taking part -in the deciding process of whether to increase your CPU frequency. - - -2.5 Conservative ----------------- - -The CPUfreq governor "conservative", much like the "ondemand" -governor, sets the CPU depending on the current usage. It differs in -behaviour in that it gracefully increases and decreases the CPU speed -rather than jumping to max speed the moment there is any load on the -CPU. This behaviour more suitable in a battery powered environment. -The governor is tweaked in the same manner as the "ondemand" governor -through sysfs with the addition of: - -freq_step: this describes what percentage steps the cpu freq should be -increased and decreased smoothly by. By default the cpu frequency will -increase in 5% chunks of your maximum cpu frequency. You can change this -value to anywhere between 0 and 100 where '0' will effectively lock your -CPU at a speed regardless of its load whilst '100' will, in theory, make -it behave identically to the "ondemand" governor. - -down_threshold: same as the 'up_threshold' found for the "ondemand" -governor but for the opposite direction. For example when set to its -default value of '20' it means that if the CPU usage needs to be below -20% between samples to have the frequency decreased. +switch the frequency very fast. + + 3. The Governor Interface in the CPUfreq Core ============================================= diff --git a/trunk/Documentation/feature-removal-schedule.txt b/trunk/Documentation/feature-removal-schedule.txt index 8ae8dad8e150..9b743198f77a 100644 --- a/trunk/Documentation/feature-removal-schedule.txt +++ b/trunk/Documentation/feature-removal-schedule.txt @@ -47,6 +47,17 @@ Who: Paul E. McKenney --------------------------- +What: IEEE1394 Audio and Music Data Transmission Protocol driver, + Connection Management Procedures driver +When: November 2005 +Files: drivers/ieee1394/{amdtp,cmp}* +Why: These are incomplete, have never worked, and are better implemented + in userland via raw1394 (see http://freebob.sourceforge.net/ for + example.) +Who: Jody McIntyre + +--------------------------- + What: raw1394: requests of type RAW1394_REQ_ISO_SEND, RAW1394_REQ_ISO_LISTEN When: November 2005 Why: Deprecated in favour of the new ioctl-based rawiso interface, which is diff --git a/trunk/Documentation/filesystems/00-INDEX b/trunk/Documentation/filesystems/00-INDEX index 7e17712f3229..628f8a7adb85 100644 --- a/trunk/Documentation/filesystems/00-INDEX +++ b/trunk/Documentation/filesystems/00-INDEX @@ -12,12 +12,16 @@ cifs.txt - description of the CIFS filesystem coda.txt - description of the CODA filesystem. +configfs/ + - directory containing configfs documentation and example code. cramfs.txt - info on the cram filesystem for small storage (ROMs etc) devfs/ - directory containing devfs documentation. ext2.txt - info, mount options and specifications for the Ext2 filesystem. +fat_cvf.txt + - info on the Compressed Volume Files extension to the FAT filesystem hpfs.txt - info and mount options for the OS/2 HPFS. isofs.txt diff --git a/trunk/Documentation/filesystems/configfs/configfs.txt b/trunk/Documentation/filesystems/configfs/configfs.txt new file mode 100644 index 000000000000..c4ff96b7c4e0 --- /dev/null +++ b/trunk/Documentation/filesystems/configfs/configfs.txt @@ -0,0 +1,434 @@ + +configfs - Userspace-driven kernel object configuation. + +Joel Becker + +Updated: 31 March 2005 + +Copyright (c) 2005 Oracle Corporation, + Joel Becker + + +[What is configfs?] + +configfs is a ram-based filesystem that provides the converse of +sysfs's functionality. Where sysfs is a filesystem-based view of +kernel objects, configfs is a filesystem-based manager of kernel +objects, or config_items. + +With sysfs, an object is created in kernel (for example, when a device +is discovered) and it is registered with sysfs. Its attributes then +appear in sysfs, allowing userspace to read the attributes via +readdir(3)/read(2). It may allow some attributes to be modified via +write(2). The important point is that the object is created and +destroyed in kernel, the kernel controls the lifecycle of the sysfs +representation, and sysfs is merely a window on all this. + +A configfs config_item is created via an explicit userspace operation: +mkdir(2). It is destroyed via rmdir(2). The attributes appear at +mkdir(2) time, and can be read or modified via read(2) and write(2). +As with sysfs, readdir(3) queries the list of items and/or attributes. +symlink(2) can be used to group items together. Unlike sysfs, the +lifetime of the representation is completely driven by userspace. The +kernel modules backing the items must respond to this. + +Both sysfs and configfs can and should exist together on the same +system. One is not a replacement for the other. + +[Using configfs] + +configfs can be compiled as a module or into the kernel. You can access +it by doing + + mount -t configfs none /config + +The configfs tree will be empty unless client modules are also loaded. +These are modules that register their item types with configfs as +subsystems. Once a client subsystem is loaded, it will appear as a +subdirectory (or more than one) under /config. Like sysfs, the +configfs tree is always there, whether mounted on /config or not. + +An item is created via mkdir(2). The item's attributes will also +appear at this time. readdir(3) can determine what the attributes are, +read(2) can query their default values, and write(2) can store new +values. Like sysfs, attributes should be ASCII text files, preferably +with only one value per file. The same efficiency caveats from sysfs +apply. Don't mix more than one attribute in one attribute file. + +Like sysfs, configfs expects write(2) to store the entire buffer at +once. When writing to configfs attributes, userspace processes should +first read the entire file, modify the portions they wish to change, and +then write the entire buffer back. Attribute files have a maximum size +of one page (PAGE_SIZE, 4096 on i386). + +When an item needs to be destroyed, remove it with rmdir(2). An +item cannot be destroyed if any other item has a link to it (via +symlink(2)). Links can be removed via unlink(2). + +[Configuring FakeNBD: an Example] + +Imagine there's a Network Block Device (NBD) driver that allows you to +access remote block devices. Call it FakeNBD. FakeNBD uses configfs +for its configuration. Obviously, there will be a nice program that +sysadmins use to configure FakeNBD, but somehow that program has to tell +the driver about it. Here's where configfs comes in. + +When the FakeNBD driver is loaded, it registers itself with configfs. +readdir(3) sees this just fine: + + # ls /config + fakenbd + +A fakenbd connection can be created with mkdir(2). The name is +arbitrary, but likely the tool will make some use of the name. Perhaps +it is a uuid or a disk name: + + # mkdir /config/fakenbd/disk1 + # ls /config/fakenbd/disk1 + target device rw + +The target attribute contains the IP address of the server FakeNBD will +connect to. The device attribute is the device on the server. +Predictably, the rw attribute determines whether the connection is +read-only or read-write. + + # echo 10.0.0.1 > /config/fakenbd/disk1/target + # echo /dev/sda1 > /config/fakenbd/disk1/device + # echo 1 > /config/fakenbd/disk1/rw + +That's it. That's all there is. Now the device is configured, via the +shell no less. + +[Coding With configfs] + +Every object in configfs is a config_item. A config_item reflects an +object in the subsystem. It has attributes that match values on that +object. configfs handles the filesystem representation of that object +and its attributes, allowing the subsystem to ignore all but the +basic show/store interaction. + +Items are created and destroyed inside a config_group. A group is a +collection of items that share the same attributes and operations. +Items are created by mkdir(2) and removed by rmdir(2), but configfs +handles that. The group has a set of operations to perform these tasks + +A subsystem is the top level of a client module. During initialization, +the client module registers the subsystem with configfs, the subsystem +appears as a directory at the top of the configfs filesystem. A +subsystem is also a config_group, and can do everything a config_group +can. + +[struct config_item] + + struct config_item { + char *ci_name; + char ci_namebuf[UOBJ_NAME_LEN]; + struct kref ci_kref; + struct list_head ci_entry; + struct config_item *ci_parent; + struct config_group *ci_group; + struct config_item_type *ci_type; + struct dentry *ci_dentry; + }; + + void config_item_init(struct config_item *); + void config_item_init_type_name(struct config_item *, + const char *name, + struct config_item_type *type); + struct config_item *config_item_get(struct config_item *); + void config_item_put(struct config_item *); + +Generally, struct config_item is embedded in a container structure, a +structure that actually represents what the subsystem is doing. The +config_item portion of that structure is how the object interacts with +configfs. + +Whether statically defined in a source file or created by a parent +config_group, a config_item must have one of the _init() functions +called on it. This initializes the reference count and sets up the +appropriate fields. + +All users of a config_item should have a reference on it via +config_item_get(), and drop the reference when they are done via +config_item_put(). + +By itself, a config_item cannot do much more than appear in configfs. +Usually a subsystem wants the item to display and/or store attributes, +among other things. For that, it needs a type. + +[struct config_item_type] + + struct configfs_item_operations { + void (*release)(struct config_item *); + ssize_t (*show_attribute)(struct config_item *, + struct configfs_attribute *, + char *); + ssize_t (*store_attribute)(struct config_item *, + struct configfs_attribute *, + const char *, size_t); + int (*allow_link)(struct config_item *src, + struct config_item *target); + int (*drop_link)(struct config_item *src, + struct config_item *target); + }; + + struct config_item_type { + struct module *ct_owner; + struct configfs_item_operations *ct_item_ops; + struct configfs_group_operations *ct_group_ops; + struct configfs_attribute **ct_attrs; + }; + +The most basic function of a config_item_type is to define what +operations can be performed on a config_item. All items that have been +allocated dynamically will need to provide the ct_item_ops->release() +method. This method is called when the config_item's reference count +reaches zero. Items that wish to display an attribute need to provide +the ct_item_ops->show_attribute() method. Similarly, storing a new +attribute value uses the store_attribute() method. + +[struct configfs_attribute] + + struct configfs_attribute { + char *ca_name; + struct module *ca_owner; + mode_t ca_mode; + }; + +When a config_item wants an attribute to appear as a file in the item's +configfs directory, it must define a configfs_attribute describing it. +It then adds the attribute to the NULL-terminated array +config_item_type->ct_attrs. When the item appears in configfs, the +attribute file will appear with the configfs_attribute->ca_name +filename. configfs_attribute->ca_mode specifies the file permissions. + +If an attribute is readable and the config_item provides a +ct_item_ops->show_attribute() method, that method will be called +whenever userspace asks for a read(2) on the attribute. The converse +will happen for write(2). + +[struct config_group] + +A config_item cannot live in a vaccum. The only way one can be created +is via mkdir(2) on a config_group. This will trigger creation of a +child item. + + struct config_group { + struct config_item cg_item; + struct list_head cg_children; + struct configfs_subsystem *cg_subsys; + struct config_group **default_groups; + }; + + void config_group_init(struct config_group *group); + void config_group_init_type_name(struct config_group *group, + const char *name, + struct config_item_type *type); + + +The config_group structure contains a config_item. Properly configuring +that item means that a group can behave as an item in its own right. +However, it can do more: it can create child items or groups. This is +accomplished via the group operations specified on the group's +config_item_type. + + struct configfs_group_operations { + struct config_item *(*make_item)(struct config_group *group, + const char *name); + struct config_group *(*make_group)(struct config_group *group, + const char *name); + int (*commit_item)(struct config_item *item); + void (*drop_item)(struct config_group *group, + struct config_item *item); + }; + +A group creates child items by providing the +ct_group_ops->make_item() method. If provided, this method is called from mkdir(2) in the group's directory. The subsystem allocates a new +config_item (or more likely, its container structure), initializes it, +and returns it to configfs. Configfs will then populate the filesystem +tree to reflect the new item. + +If the subsystem wants the child to be a group itself, the subsystem +provides ct_group_ops->make_group(). Everything else behaves the same, +using the group _init() functions on the group. + +Finally, when userspace calls rmdir(2) on the item or group, +ct_group_ops->drop_item() is called. As a config_group is also a +config_item, it is not necessary for a seperate drop_group() method. +The subsystem must config_item_put() the reference that was initialized +upon item allocation. If a subsystem has no work to do, it may omit +the ct_group_ops->drop_item() method, and configfs will call +config_item_put() on the item on behalf of the subsystem. + +IMPORTANT: drop_item() is void, and as such cannot fail. When rmdir(2) +is called, configfs WILL remove the item from the filesystem tree +(assuming that it has no children to keep it busy). The subsystem is +responsible for responding to this. If the subsystem has references to +the item in other threads, the memory is safe. It may take some time +for the item to actually disappear from the subsystem's usage. But it +is gone from configfs. + +A config_group cannot be removed while it still has child items. This +is implemented in the configfs rmdir(2) code. ->drop_item() will not be +called, as the item has not been dropped. rmdir(2) will fail, as the +directory is not empty. + +[struct configfs_subsystem] + +A subsystem must register itself, ususally at module_init time. This +tells configfs to make the subsystem appear in the file tree. + + struct configfs_subsystem { + struct config_group su_group; + struct semaphore su_sem; + }; + + int configfs_register_subsystem(struct configfs_subsystem *subsys); + void configfs_unregister_subsystem(struct configfs_subsystem *subsys); + + A subsystem consists of a toplevel config_group and a semaphore. +The group is where child config_items are created. For a subsystem, +this group is usually defined statically. Before calling +configfs_register_subsystem(), the subsystem must have initialized the +group via the usual group _init() functions, and it must also have +initialized the semaphore. + When the register call returns, the subsystem is live, and it +will be visible via configfs. At that point, mkdir(2) can be called and +the subsystem must be ready for it. + +[An Example] + +The best example of these basic concepts is the simple_children +subsystem/group and the simple_child item in configfs_example.c It +shows a trivial object displaying and storing an attribute, and a simple +group creating and destroying these children. + +[Hierarchy Navigation and the Subsystem Semaphore] + +There is an extra bonus that configfs provides. The config_groups and +config_items are arranged in a hierarchy due to the fact that they +appear in a filesystem. A subsystem is NEVER to touch the filesystem +parts, but the subsystem might be interested in this hierarchy. For +this reason, the hierarchy is mirrored via the config_group->cg_children +and config_item->ci_parent structure members. + +A subsystem can navigate the cg_children list and the ci_parent pointer +to see the tree created by the subsystem. This can race with configfs' +management of the hierarchy, so configfs uses the subsystem semaphore to +protect modifications. Whenever a subsystem wants to navigate the +hierarchy, it must do so under the protection of the subsystem +semaphore. + +A subsystem will be prevented from acquiring the semaphore while a newly +allocated item has not been linked into this hierarchy. Similarly, it +will not be able to acquire the semaphore while a dropping item has not +yet been unlinked. This means that an item's ci_parent pointer will +never be NULL while the item is in configfs, and that an item will only +be in its parent's cg_children list for the same duration. This allows +a subsystem to trust ci_parent and cg_children while they hold the +semaphore. + +[Item Aggregation Via symlink(2)] + +configfs provides a simple group via the group->item parent/child +relationship. Often, however, a larger environment requires aggregation +outside of the parent/child connection. This is implemented via +symlink(2). + +A config_item may provide the ct_item_ops->allow_link() and +ct_item_ops->drop_link() methods. If the ->allow_link() method exists, +symlink(2) may be called with the config_item as the source of the link. +These links are only allowed between configfs config_items. Any +symlink(2) attempt outside the configfs filesystem will be denied. + +When symlink(2) is called, the source config_item's ->allow_link() +method is called with itself and a target item. If the source item +allows linking to target item, it returns 0. A source item may wish to +reject a link if it only wants links to a certain type of object (say, +in its own subsystem). + +When unlink(2) is called on the symbolic link, the source item is +notified via the ->drop_link() method. Like the ->drop_item() method, +this is a void function and cannot return failure. The subsystem is +responsible for responding to the change. + +A config_item cannot be removed while it links to any other item, nor +can it be removed while an item links to it. Dangling symlinks are not +allowed in configfs. + +[Automatically Created Subgroups] + +A new config_group may want to have two types of child config_items. +While this could be codified by magic names in ->make_item(), it is much +more explicit to have a method whereby userspace sees this divergence. + +Rather than have a group where some items behave differently than +others, configfs provides a method whereby one or many subgroups are +automatically created inside the parent at its creation. Thus, +mkdir("parent) results in "parent", "parent/subgroup1", up through +"parent/subgroupN". Items of type 1 can now be created in +"parent/subgroup1", and items of type N can be created in +"parent/subgroupN". + +These automatic subgroups, or default groups, do not preclude other +children of the parent group. If ct_group_ops->make_group() exists, +other child groups can be created on the parent group directly. + +A configfs subsystem specifies default groups by filling in the +NULL-terminated array default_groups on the config_group structure. +Each group in that array is populated in the configfs tree at the same +time as the parent group. Similarly, they are removed at the same time +as the parent. No extra notification is provided. When a ->drop_item() +method call notifies the subsystem the parent group is going away, it +also means every default group child associated with that parent group. + +As a consequence of this, default_groups cannot be removed directly via +rmdir(2). They also are not considered when rmdir(2) on the parent +group is checking for children. + +[Committable Items] + +NOTE: Committable items are currently unimplemented. + +Some config_items cannot have a valid initial state. That is, no +default values can be specified for the item's attributes such that the +item can do its work. Userspace must configure one or more attributes, +after which the subsystem can start whatever entity this item +represents. + +Consider the FakeNBD device from above. Without a target address *and* +a target device, the subsystem has no idea what block device to import. +The simple example assumes that the subsystem merely waits until all the +appropriate attributes are configured, and then connects. This will, +indeed, work, but now every attribute store must check if the attributes +are initialized. Every attribute store must fire off the connection if +that condition is met. + +Far better would be an explicit action notifying the subsystem that the +config_item is ready to go. More importantly, an explicit action allows +the subsystem to provide feedback as to whether the attibutes are +initialized in a way that makes sense. configfs provides this as +committable items. + +configfs still uses only normal filesystem operations. An item is +committed via rename(2). The item is moved from a directory where it +can be modified to a directory where it cannot. + +Any group that provides the ct_group_ops->commit_item() method has +committable items. When this group appears in configfs, mkdir(2) will +not work directly in the group. Instead, the group will have two +subdirectories: "live" and "pending". The "live" directory does not +support mkdir(2) or rmdir(2) either. It only allows rename(2). The +"pending" directory does allow mkdir(2) and rmdir(2). An item is +created in the "pending" directory. Its attributes can be modified at +will. Userspace commits the item by renaming it into the "live" +directory. At this point, the subsystem recieves the ->commit_item() +callback. If all required attributes are filled to satisfaction, the +method returns zero and the item is moved to the "live" directory. + +As rmdir(2) does not work in the "live" directory, an item must be +shutdown, or "uncommitted". Again, this is done via rename(2), this +time from the "live" directory back to the "pending" one. The subsystem +is notified by the ct_group_ops->uncommit_object() method. + + diff --git a/trunk/Documentation/filesystems/configfs/configfs_example.c b/trunk/Documentation/filesystems/configfs/configfs_example.c new file mode 100644 index 000000000000..f3c6e4946f98 --- /dev/null +++ b/trunk/Documentation/filesystems/configfs/configfs_example.c @@ -0,0 +1,474 @@ +/* + * vim: noexpandtab ts=8 sts=0 sw=8: + * + * configfs_example.c - This file is a demonstration module containing + * a number of configfs subsystems. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + */ + +#include +#include +#include + +#include + + + +/* + * 01-childless + * + * This first example is a childless subsystem. It cannot create + * any config_items. It just has attributes. + * + * Note that we are enclosing the configfs_subsystem inside a container. + * This is not necessary if a subsystem has no attributes directly + * on the subsystem. See the next example, 02-simple-children, for + * such a subsystem. + */ + +struct childless { + struct configfs_subsystem subsys; + int showme; + int storeme; +}; + +struct childless_attribute { + struct configfs_attribute attr; + ssize_t (*show)(struct childless *, char *); + ssize_t (*store)(struct childless *, const char *, size_t); +}; + +static inline struct childless *to_childless(struct config_item *item) +{ + return item ? container_of(to_configfs_subsystem(to_config_group(item)), struct childless, subsys) : NULL; +} + +static ssize_t childless_showme_read(struct childless *childless, + char *page) +{ + ssize_t pos; + + pos = sprintf(page, "%d\n", childless->showme); + childless->showme++; + + return pos; +} + +static ssize_t childless_storeme_read(struct childless *childless, + char *page) +{ + return sprintf(page, "%d\n", childless->storeme); +} + +static ssize_t childless_storeme_write(struct childless *childless, + const char *page, + size_t count) +{ + unsigned long tmp; + char *p = (char *) page; + + tmp = simple_strtoul(p, &p, 10); + if (!p || (*p && (*p != '\n'))) + return -EINVAL; + + if (tmp > INT_MAX) + return -ERANGE; + + childless->storeme = tmp; + + return count; +} + +static ssize_t childless_description_read(struct childless *childless, + char *page) +{ + return sprintf(page, +"[01-childless]\n" +"\n" +"The childless subsystem is the simplest possible subsystem in\n" +"configfs. It does not support the creation of child config_items.\n" +"It only has a few attributes. In fact, it isn't much different\n" +"than a directory in /proc.\n"); +} + +static struct childless_attribute childless_attr_showme = { + .attr = { .ca_owner = THIS_MODULE, .ca_name = "showme", .ca_mode = S_IRUGO }, + .show = childless_showme_read, +}; +static struct childless_attribute childless_attr_storeme = { + .attr = { .ca_owner = THIS_MODULE, .ca_name = "storeme", .ca_mode = S_IRUGO | S_IWUSR }, + .show = childless_storeme_read, + .store = childless_storeme_write, +}; +static struct childless_attribute childless_attr_description = { + .attr = { .ca_owner = THIS_MODULE, .ca_name = "description", .ca_mode = S_IRUGO }, + .show = childless_description_read, +}; + +static struct configfs_attribute *childless_attrs[] = { + &childless_attr_showme.attr, + &childless_attr_storeme.attr, + &childless_attr_description.attr, + NULL, +}; + +static ssize_t childless_attr_show(struct config_item *item, + struct configfs_attribute *attr, + char *page) +{ + struct childless *childless = to_childless(item); + struct childless_attribute *childless_attr = + container_of(attr, struct childless_attribute, attr); + ssize_t ret = 0; + + if (childless_attr->show) + ret = childless_attr->show(childless, page); + return ret; +} + +static ssize_t childless_attr_store(struct config_item *item, + struct configfs_attribute *attr, + const char *page, size_t count) +{ + struct childless *childless = to_childless(item); + struct childless_attribute *childless_attr = + container_of(attr, struct childless_attribute, attr); + ssize_t ret = -EINVAL; + + if (childless_attr->store) + ret = childless_attr->store(childless, page, count); + return ret; +} + +static struct configfs_item_operations childless_item_ops = { + .show_attribute = childless_attr_show, + .store_attribute = childless_attr_store, +}; + +static struct config_item_type childless_type = { + .ct_item_ops = &childless_item_ops, + .ct_attrs = childless_attrs, + .ct_owner = THIS_MODULE, +}; + +static struct childless childless_subsys = { + .subsys = { + .su_group = { + .cg_item = { + .ci_namebuf = "01-childless", + .ci_type = &childless_type, + }, + }, + }, +}; + + +/* ----------------------------------------------------------------- */ + +/* + * 02-simple-children + * + * This example merely has a simple one-attribute child. Note that + * there is no extra attribute structure, as the child's attribute is + * known from the get-go. Also, there is no container for the + * subsystem, as it has no attributes of its own. + */ + +struct simple_child { + struct config_item item; + int storeme; +}; + +static inline struct simple_child *to_simple_child(struct config_item *item) +{ + return item ? container_of(item, struct simple_child, item) : NULL; +} + +static struct configfs_attribute simple_child_attr_storeme = { + .ca_owner = THIS_MODULE, + .ca_name = "storeme", + .ca_mode = S_IRUGO | S_IWUSR, +}; + +static struct configfs_attribute *simple_child_attrs[] = { + &simple_child_attr_storeme, + NULL, +}; + +static ssize_t simple_child_attr_show(struct config_item *item, + struct configfs_attribute *attr, + char *page) +{ + ssize_t count; + struct simple_child *simple_child = to_simple_child(item); + + count = sprintf(page, "%d\n", simple_child->storeme); + + return count; +} + +static ssize_t simple_child_attr_store(struct config_item *item, + struct configfs_attribute *attr, + const char *page, size_t count) +{ + struct simple_child *simple_child = to_simple_child(item); + unsigned long tmp; + char *p = (char *) page; + + tmp = simple_strtoul(p, &p, 10); + if (!p || (*p && (*p != '\n'))) + return -EINVAL; + + if (tmp > INT_MAX) + return -ERANGE; + + simple_child->storeme = tmp; + + return count; +} + +static void simple_child_release(struct config_item *item) +{ + kfree(to_simple_child(item)); +} + +static struct configfs_item_operations simple_child_item_ops = { + .release = simple_child_release, + .show_attribute = simple_child_attr_show, + .store_attribute = simple_child_attr_store, +}; + +static struct config_item_type simple_child_type = { + .ct_item_ops = &simple_child_item_ops, + .ct_attrs = simple_child_attrs, + .ct_owner = THIS_MODULE, +}; + + +static struct config_item *simple_children_make_item(struct config_group *group, const char *name) +{ + struct simple_child *simple_child; + + simple_child = kmalloc(sizeof(struct simple_child), GFP_KERNEL); + if (!simple_child) + return NULL; + + memset(simple_child, 0, sizeof(struct simple_child)); + + config_item_init_type_name(&simple_child->item, name, + &simple_child_type); + + simple_child->storeme = 0; + + return &simple_child->item; +} + +static struct configfs_attribute simple_children_attr_description = { + .ca_owner = THIS_MODULE, + .ca_name = "description", + .ca_mode = S_IRUGO, +}; + +static struct configfs_attribute *simple_children_attrs[] = { + &simple_children_attr_description, + NULL, +}; + +static ssize_t simple_children_attr_show(struct config_item *item, + struct configfs_attribute *attr, + char *page) +{ + return sprintf(page, +"[02-simple-children]\n" +"\n" +"This subsystem allows the creation of child config_items. These\n" +"items have only one attribute that is readable and writeable.\n"); +} + +static struct configfs_item_operations simple_children_item_ops = { + .show_attribute = simple_children_attr_show, +}; + +/* + * Note that, since no extra work is required on ->drop_item(), + * no ->drop_item() is provided. + */ +static struct configfs_group_operations simple_children_group_ops = { + .make_item = simple_children_make_item, +}; + +static struct config_item_type simple_children_type = { + .ct_item_ops = &simple_children_item_ops, + .ct_group_ops = &simple_children_group_ops, + .ct_attrs = simple_children_attrs, +}; + +static struct configfs_subsystem simple_children_subsys = { + .su_group = { + .cg_item = { + .ci_namebuf = "02-simple-children", + .ci_type = &simple_children_type, + }, + }, +}; + + +/* ----------------------------------------------------------------- */ + +/* + * 03-group-children + * + * This example reuses the simple_children group from above. However, + * the simple_children group is not the subsystem itself, it is a + * child of the subsystem. Creation of a group in the subsystem creates + * a new simple_children group. That group can then have simple_child + * children of its own. + */ + +struct simple_children { + struct config_group group; +}; + +static struct config_group *group_children_make_group(struct config_group *group, const char *name) +{ + struct simple_children *simple_children; + + simple_children = kmalloc(sizeof(struct simple_children), + GFP_KERNEL); + if (!simple_children) + return NULL; + + memset(simple_children, 0, sizeof(struct simple_children)); + + config_group_init_type_name(&simple_children->group, name, + &simple_children_type); + + return &simple_children->group; +} + +static struct configfs_attribute group_children_attr_description = { + .ca_owner = THIS_MODULE, + .ca_name = "description", + .ca_mode = S_IRUGO, +}; + +static struct configfs_attribute *group_children_attrs[] = { + &group_children_attr_description, + NULL, +}; + +static ssize_t group_children_attr_show(struct config_item *item, + struct configfs_attribute *attr, + char *page) +{ + return sprintf(page, +"[03-group-children]\n" +"\n" +"This subsystem allows the creation of child config_groups. These\n" +"groups are like the subsystem simple-children.\n"); +} + +static struct configfs_item_operations group_children_item_ops = { + .show_attribute = group_children_attr_show, +}; + +/* + * Note that, since no extra work is required on ->drop_item(), + * no ->drop_item() is provided. + */ +static struct configfs_group_operations group_children_group_ops = { + .make_group = group_children_make_group, +}; + +static struct config_item_type group_children_type = { + .ct_item_ops = &group_children_item_ops, + .ct_group_ops = &group_children_group_ops, + .ct_attrs = group_children_attrs, +}; + +static struct configfs_subsystem group_children_subsys = { + .su_group = { + .cg_item = { + .ci_namebuf = "03-group-children", + .ci_type = &group_children_type, + }, + }, +}; + +/* ----------------------------------------------------------------- */ + +/* + * We're now done with our subsystem definitions. + * For convenience in this module, here's a list of them all. It + * allows the init function to easily register them. Most modules + * will only have one subsystem, and will only call register_subsystem + * on it directly. + */ +static struct configfs_subsystem *example_subsys[] = { + &childless_subsys.subsys, + &simple_children_subsys, + &group_children_subsys, + NULL, +}; + +static int __init configfs_example_init(void) +{ + int ret; + int i; + struct configfs_subsystem *subsys; + + for (i = 0; example_subsys[i]; i++) { + subsys = example_subsys[i]; + + config_group_init(&subsys->su_group); + init_MUTEX(&subsys->su_sem); + ret = configfs_register_subsystem(subsys); + if (ret) { + printk(KERN_ERR "Error %d while registering subsystem %s\n", + ret, + subsys->su_group.cg_item.ci_namebuf); + goto out_unregister; + } + } + + return 0; + +out_unregister: + for (; i >= 0; i--) { + configfs_unregister_subsystem(example_subsys[i]); + } + + return ret; +} + +static void __exit configfs_example_exit(void) +{ + int i; + + for (i = 0; example_subsys[i]; i++) { + configfs_unregister_subsystem(example_subsys[i]); + } +} + +module_init(configfs_example_init); +module_exit(configfs_example_exit); +MODULE_LICENSE("GPL"); diff --git a/trunk/Documentation/filesystems/vfs.txt b/trunk/Documentation/filesystems/vfs.txt index e56e842847d3..ee4c0a8b8db7 100644 --- a/trunk/Documentation/filesystems/vfs.txt +++ b/trunk/Documentation/filesystems/vfs.txt @@ -162,8 +162,9 @@ get_sb() method fills in is the "s_op" field. This is a pointer to a "struct super_operations" which describes the next level of the filesystem implementation. -Usually, a filesystem uses one of the generic get_sb() implementations -and provides a fill_super() method instead. The generic methods are: +Usually, a filesystem uses generic one of the generic get_sb() +implementations and provides a fill_super() method instead. The +generic methods are: get_sb_bdev: mount a filesystem residing on a block device diff --git a/trunk/Documentation/kbuild/modules.txt b/trunk/Documentation/kbuild/modules.txt index 1c0db652b366..c91caf7eb303 100644 --- a/trunk/Documentation/kbuild/modules.txt +++ b/trunk/Documentation/kbuild/modules.txt @@ -38,7 +38,7 @@ included in the kernel tree. What is covered within this file is mainly information to authors of modules. The author of an external modules should supply a makefile that hides most of the complexity so one only has to type -'make' to build the module. A complete example will be present in +'make' to buld the module. A complete example will be present in chapter ¤. Creating a kbuild file for an external module". @@ -69,7 +69,7 @@ when building an external module. --- 2.2 Available targets - $KDIR refers to the path to the kernel source top-level directory + $KDIR refers to path to kernel source top-level directory make -C $KDIR M=`pwd` Will build the module(s) located in current directory. @@ -87,11 +87,11 @@ when building an external module. make -C $KDIR M=$PWD modules_install Install the external module(s). Installation default is in /lib/modules//extra, - but may be prefixed with INSTALL_MOD_PATH - see separate chapter. + but may be prefixed with INSTALL_MOD_PATH - see separate chater. make -C $KDIR M=$PWD clean Remove all generated files for the module - the kernel - source directory is not modified. + source directory is not moddified. make -C $KDIR M=`pwd` help help will list the available target when building external @@ -99,7 +99,7 @@ when building an external module. --- 2.3 Available options: - $KDIR refers to the path to the kernel source top-level directory + $KDIR refer to path to kernel src make -C $KDIR Used to specify where to find the kernel source. @@ -206,11 +206,11 @@ following files: KERNELDIR := /lib/modules/`uname -r`/build all:: - $(MAKE) -C $(KERNELDIR) M=`pwd` $@ + $(MAKE) -C $KERNELDIR M=`pwd` $@ # Module specific targets genbin: - echo "X" > 8123_bin.o_shipped + echo "X" > 8123_bini.o_shipped endif @@ -341,13 +341,13 @@ directory and therefore needs to deal with this in their kbuild file. EXTRA_CFLAGS := -Iinclude 8123-y := 8123_if.o 8123_pci.o 8123_bin.o - Note that in the assignment there is no space between -I and the path. - This is a kbuild limitation: there must be no space present. + Note that in the assingment there is no space between -I and the path. + This is a kbuild limitation and no space must be present. === 6. Module installation -Modules which are included in the kernel are installed in the directory: +Modules which are included in the kernel is installed in the directory: /lib/modules/$(KERNELRELEASE)/kernel @@ -365,7 +365,7 @@ External modules are installed in the directory: => Install dir: /frodo/lib/modules/$(KERNELRELEASE)/kernel INSTALL_MOD_PATH may be set as an ordinary shell variable or as in the - example above be specified on the command line when calling make. + example above be specified on the commandline when calling make. INSTALL_MOD_PATH has effect both when installing modules included in the kernel as well as when installing external modules. @@ -384,7 +384,7 @@ External modules are installed in the directory: === 7. Module versioning -Module versioning is enabled by the CONFIG_MODVERSIONS tag. +Module versioning are enabled by the CONFIG_MODVERSIONS tag. Module versioning is used as a simple ABI consistency check. The Module versioning creates a CRC value of the full prototype for an exported symbol and diff --git a/trunk/Documentation/kernel-parameters.txt b/trunk/Documentation/kernel-parameters.txt index 61a56b100c62..5dffcfefc3c7 100644 --- a/trunk/Documentation/kernel-parameters.txt +++ b/trunk/Documentation/kernel-parameters.txt @@ -633,14 +633,6 @@ running once the system is up. inport.irq= [HW] Inport (ATI XL and Microsoft) busmouse driver Format: - combined_mode= [HW] control which driver uses IDE ports in combined - mode: legacy IDE driver, libata, or both - (in the libata case, libata.atapi_enabled=1 may be - useful as well). Note that using the ide or libata - options may affect your device naming (e.g. by - changing hdc to sdb). - Format: combined (default), ide, or libata - inttest= [IA64] io7= [HW] IO7 for Marvel based alpha systems diff --git a/trunk/Documentation/networking/gianfar.txt b/trunk/Documentation/networking/gianfar.txt deleted file mode 100644 index ad474ea07d07..000000000000 --- a/trunk/Documentation/networking/gianfar.txt +++ /dev/null @@ -1,72 +0,0 @@ -The Gianfar Ethernet Driver -Sysfs File description - -Author: Andy Fleming -Updated: 2005-07-28 - -SYSFS - -Several of the features of the gianfar driver are controlled -through sysfs files. These are: - -bd_stash: -To stash RX Buffer Descriptors in the L2, echo 'on' or '1' to -bd_stash, echo 'off' or '0' to disable - -rx_stash_len: -To stash the first n bytes of the packet in L2, echo the number -of bytes to buf_stash_len. echo 0 to disable. - -WARNING: You could really screw these up if you set them too low or high! -fifo_threshold: -To change the number of bytes the controller needs in the -fifo before it starts transmission, echo the number of bytes to -fifo_thresh. Range should be 0-511. - -fifo_starve: -When the FIFO has less than this many bytes during a transmit, it -enters starve mode, and increases the priority of TX memory -transactions. To change, echo the number of bytes to -fifo_starve. Range should be 0-511. - -fifo_starve_off: -Once in starve mode, the FIFO remains there until it has this -many bytes. To change, echo the number of bytes to -fifo_starve_off. Range should be 0-511. - -CHECKSUM OFFLOADING - -The eTSEC controller (first included in parts from late 2005 like -the 8548) has the ability to perform TCP, UDP, and IP checksums -in hardware. The Linux kernel only offloads the TCP and UDP -checksums (and always performs the pseudo header checksums), so -the driver only supports checksumming for TCP/IP and UDP/IP -packets. Use ethtool to enable or disable this feature for RX -and TX. - -VLAN - -In order to use VLAN, please consult Linux documentation on -configuring VLANs. The gianfar driver supports hardware insertion and -extraction of VLAN headers, but not filtering. Filtering will be -done by the kernel. - -MULTICASTING - -The gianfar driver supports using the group hash table on the -TSEC (and the extended hash table on the eTSEC) for multicast -filtering. On the eTSEC, the exact-match MAC registers are used -before the hash tables. See Linux documentation on how to join -multicast groups. - -PADDING - -The gianfar driver supports padding received frames with 2 bytes -to align the IP header to a 16-byte boundary, when supported by -hardware. - -ETHTOOL - -The gianfar driver supports the use of ethtool for many -configuration options. You must run ethtool only on currently -open interfaces. See ethtool documentation for details. diff --git a/trunk/Documentation/networking/ip-sysctl.txt b/trunk/Documentation/networking/ip-sysctl.txt index 2b7cf19a06ad..ebc09a159f62 100644 --- a/trunk/Documentation/networking/ip-sysctl.txt +++ b/trunk/Documentation/networking/ip-sysctl.txt @@ -46,29 +46,6 @@ ipfrag_secret_interval - INTEGER for the hash secret) for IP fragments. Default: 600 -ipfrag_max_dist - INTEGER - ipfrag_max_dist is a non-negative integer value which defines the - maximum "disorder" which is allowed among fragments which share a - common IP source address. Note that reordering of packets is - not unusual, but if a large number of fragments arrive from a source - IP address while a particular fragment queue remains incomplete, it - probably indicates that one or more fragments belonging to that queue - have been lost. When ipfrag_max_dist is positive, an additional check - is done on fragments before they are added to a reassembly queue - if - ipfrag_max_dist (or more) fragments have arrived from a particular IP - address between additions to any IP fragment queue using that source - address, it's presumed that one or more fragments in the queue are - lost. The existing fragment queue will be dropped, and a new one - started. An ipfrag_max_dist value of zero disables this check. - - Using a very small value, e.g. 1 or 2, for ipfrag_max_dist can - result in unnecessarily dropping fragment queues when normal - reordering of packets occurs, which could lead to poor application - performance. Using a very large value, e.g. 50000, increases the - likelihood of incorrectly reassembling IP fragments that originate - from different IP datagrams, which could result in data corruption. - Default: 64 - INET peer storage: inet_peer_threshold - INTEGER diff --git a/trunk/Documentation/pcmcia/driver-changes.txt b/trunk/Documentation/pcmcia/driver-changes.txt index 97420f08c786..403e7b4dcdd4 100644 --- a/trunk/Documentation/pcmcia/driver-changes.txt +++ b/trunk/Documentation/pcmcia/driver-changes.txt @@ -1,16 +1,5 @@ This file details changes in 2.6 which affect PCMCIA card driver authors: -* Unify detach and REMOVAL event code, as well as attach and INSERTION - code (as of 2.6.16) - void (*remove) (struct pcmcia_device *dev); - int (*probe) (struct pcmcia_device *dev); - -* Move suspend, resume and reset out of event handler (as of 2.6.16) - int (*suspend) (struct pcmcia_device *dev); - int (*resume) (struct pcmcia_device *dev); - should be initialized in struct pcmcia_driver, and handle - (SUSPEND == RESET_PHYSICAL) and (RESUME == CARD_RESET) events - * event handler initialization in struct pcmcia_driver (as of 2.6.13) The event handler is notified of all events, and must be initialized as the event() callback in the driver's struct pcmcia_driver. diff --git a/trunk/Documentation/powerpc/eeh-pci-error-recovery.txt b/trunk/Documentation/powerpc/eeh-pci-error-recovery.txt index 67a11a36270c..e75d7474322c 100644 --- a/trunk/Documentation/powerpc/eeh-pci-error-recovery.txt +++ b/trunk/Documentation/powerpc/eeh-pci-error-recovery.txt @@ -115,7 +115,7 @@ Current PPC64 Linux EEH Implementation At this time, a generic EEH recovery mechanism has been implemented, so that individual device drivers do not need to be modified to support EEH recovery. This generic mechanism piggy-backs on the PCI hotplug -infrastructure, and percolates events up through the userspace/udev +infrastructure, and percolates events up through the hotplug/udev infrastructure. Followiing is a detailed description of how this is accomplished. @@ -172,7 +172,7 @@ A handler for the EEH notifier_block events is implemented in drivers/pci/hotplug/pSeries_pci.c, called handle_eeh_events(). It saves the device BAR's and then calls rpaphp_unconfig_pci_adapter(). This last call causes the device driver for the card to be stopped, -which causes uevents to go out to user space. This triggers +which causes hotplug events to go out to user space. This triggers user-space scripts that might issue commands such as "ifdown eth0" for ethernet cards, and so on. This handler then sleeps for 5 seconds, hoping to give the user-space scripts enough time to complete. @@ -258,30 +258,29 @@ rpa_php_unconfig_pci_adapter() { // in rpaphp_pci.c calls pci_destroy_dev (struct pci_dev *) { calls - device_unregister (&dev->dev) { // in /drivers/base/core.c + device_unregister (&dev->dev) { // in /drivers/base/core.c calls - device_del(struct device * dev) { // in /drivers/base/core.c + device_del(struct device * dev) { // in /drivers/base/core.c calls - kobject_del() { //in /libs/kobject.c + kobject_del() { //in /libs/kobject.c calls - kobject_uevent() { // in /libs/kobject.c + kobject_hotplug() { // in /libs/kobject.c calls - kset_uevent() { // in /lib/kobject.c + kset_hotplug() { // in /lib/kobject.c calls - kset->uevent_ops->uevent() // which is really just + kset->hotplug_ops->hotplug() which is really just a call to - dev_uevent() { // in /drivers/base/core.c + dev_hotplug() { // in /drivers/base/core.c calls - dev->bus->uevent() which is really just a call to - pci_uevent () { // in drivers/pci/hotplug.c + dev->bus->hotplug() which is really just a call to + pci_hotplug () { // in drivers/pci/hotplug.c which prints device name, etc.... } } - then kobject_uevent() sends a netlink uevent to userspace - --> userspace uevent - (during early boot, nobody listens to netlink events and - kobject_uevent() executes uevent_helper[], which runs the - event process /sbin/hotplug) + then kset_hotplug() calls + call_usermodehelper () with + argv[0]=hotplug_path[] which is "/sbin/hotplug" + --> event to userspace, } } kobject_del() then calls sysfs_remove_dir(), which would diff --git a/trunk/Documentation/scsi/ChangeLog.megaraid b/trunk/Documentation/scsi/ChangeLog.megaraid index 09f6300eda4b..5331d91432c7 100644 --- a/trunk/Documentation/scsi/ChangeLog.megaraid +++ b/trunk/Documentation/scsi/ChangeLog.megaraid @@ -1,38 +1,3 @@ -Release Date : Fri Nov 11 12:27:22 EST 2005 - Seokmann Ju -Current Version : 2.20.4.7 (scsi module), 2.20.2.6 (cmm module) -Older Version : 2.20.4.6 (scsi module), 2.20.2.6 (cmm module) - -1. Sorted out PCI IDs to remove megaraid support overlaps. - Based on the patch from Daniel, sorted out PCI IDs along with - charactor node name change from 'megadev' to 'megadev_legacy' to avoid - conflict. - --- - Hopefully we'll be getting the build restriction zapped much sooner, - but we should also be thinking about totally removing the hardware - support overlap in the megaraid drivers. - - This patch pencils in a date of Feb 06 for this, and performs some - printk abuse in hope that existing legacy users might pick up on what's - going on. - - Signed-off-by: Daniel Drake - --- - -2. Fixed a issue: megaraid always fails to reset handler. - --- - I found that the megaraid driver always fails to reset the - adapter with the following message: - megaraid: resetting the host... - megaraid mbox: reset sequence completed successfully - megaraid: fast sync command timed out - megaraid: reservation reset failed - when the "Cluster mode" of the adapter BIOS is enabled. - So, whenever the reset occurs, the adapter goes to - offline and just become unavailable. - - Jun'ichi Nomura [mailto:jnomura@mtc.biglobe.ne.jp] - --- - Release Date : Mon Mar 07 12:27:22 EST 2005 - Seokmann Ju Current Version : 2.20.4.6 (scsi module), 2.20.2.6 (cmm module) Older Version : 2.20.4.5 (scsi module), 2.20.2.5 (cmm module) diff --git a/trunk/Documentation/scsi/scsi_mid_low_api.txt b/trunk/Documentation/scsi/scsi_mid_low_api.txt index 8bbae3e1abdf..66565d42288f 100644 --- a/trunk/Documentation/scsi/scsi_mid_low_api.txt +++ b/trunk/Documentation/scsi/scsi_mid_low_api.txt @@ -150,8 +150,7 @@ scsi devices of which only the first 2 respond: LLD mid level LLD ===-------------------=========--------------------===------ scsi_host_alloc() --> -scsi_add_host() ----> -scsi_scan_host() -------+ +scsi_add_host() --------+ | slave_alloc() slave_configure() --> scsi_adjust_queue_depth() @@ -197,7 +196,7 @@ of the issues involved. See the section on reference counting below. The hotplug concept may be extended to SCSI devices. Currently, when an -HBA is added, the scsi_scan_host() function causes a scan for SCSI devices +HBA is added, the scsi_add_host() function causes a scan for SCSI devices attached to the HBA's SCSI transport. On newer SCSI transports the HBA may become aware of a new SCSI device _after_ the scan has completed. An LLD can use this sequence to make the mid level aware of a SCSI device: @@ -373,7 +372,7 @@ names all start with "scsi_". Summary: scsi_activate_tcq - turn on tag command queueing scsi_add_device - creates new scsi device (lu) instance - scsi_add_host - perform sysfs registration and set up transport class + scsi_add_host - perform sysfs registration and SCSI bus scan. scsi_adjust_queue_depth - change the queue depth on a SCSI device scsi_assign_lock - replace default host_lock with given lock scsi_bios_ptable - return copy of block device's partition table @@ -387,7 +386,6 @@ Summary: scsi_remove_device - detach and remove a SCSI device scsi_remove_host - detach and remove all SCSI devices owned by host scsi_report_bus_reset - report scsi _bus_ reset observed - scsi_scan_host - scan SCSI bus scsi_track_queue_full - track successive QUEUE_FULL events scsi_unblock_requests - allow further commands to be queued to given host scsi_unregister - [calls scsi_host_put()] @@ -427,10 +425,10 @@ void scsi_activate_tcq(struct scsi_device *sdev, int depth) * Might block: yes * * Notes: This call is usually performed internally during a scsi - * bus scan when an HBA is added (i.e. scsi_scan_host()). So it + * bus scan when an HBA is added (i.e. scsi_add_host()). So it * should only be called if the HBA becomes aware of a new scsi - * device (lu) after scsi_scan_host() has completed. If successful - * this call can lead to slave_alloc() and slave_configure() callbacks + * device (lu) after scsi_add_host() has completed. If successful + * this call we lead to slave_alloc() and slave_configure() callbacks * into the LLD. * * Defined in: drivers/scsi/scsi_scan.c @@ -441,7 +439,7 @@ struct scsi_device * scsi_add_device(struct Scsi_Host *shost, /** - * scsi_add_host - perform sysfs registration and set up transport class + * scsi_add_host - perform sysfs registration and SCSI bus scan. * @shost: pointer to scsi host instance * @dev: pointer to struct device of type scsi class * @@ -450,11 +448,7 @@ struct scsi_device * scsi_add_device(struct Scsi_Host *shost, * Might block: no * * Notes: Only required in "hotplug initialization model" after a - * successful call to scsi_host_alloc(). This function does not - * scan the bus; this can be done by calling scsi_scan_host() or - * in some other transport-specific way. The LLD must set up - * the transport template before calling this function and may only - * access the transport class data after this function has been called. + * successful call to scsi_host_alloc(). * * Defined in: drivers/scsi/hosts.c **/ @@ -565,7 +559,7 @@ void scsi_deactivate_tcq(struct scsi_device *sdev, int depth) * area for the LLD's exclusive use. * Both associated refcounting objects have their refcount set to 1. * Full registration (in sysfs) and a bus scan are performed later when - * scsi_add_host() and scsi_scan_host() are called. + * scsi_add_host() is called. * * Defined in: drivers/scsi/hosts.c . **/ @@ -704,19 +698,6 @@ int scsi_remove_host(struct Scsi_Host *shost) void scsi_report_bus_reset(struct Scsi_Host * shost, int channel) -/** - * scsi_scan_host - scan SCSI bus - * @shost: a pointer to a scsi host instance - * - * Might block: yes - * - * Notes: Should be called after scsi_add_host() - * - * Defined in: drivers/scsi/scsi_scan.c - **/ -void scsi_scan_host(struct Scsi_Host *shost) - - /** * scsi_track_queue_full - track successive QUEUE_FULL events on given * device to determine if and when there is a need @@ -1452,7 +1433,7 @@ The following people have contributed to this document: Christoph Hellwig Doug Ledford Andries Brouwer - Randy Dunlap + Randy Dunlap Alan Stern diff --git a/trunk/Documentation/sound/alsa/ALSA-Configuration.txt b/trunk/Documentation/sound/alsa/ALSA-Configuration.txt index d2578013e829..2f27f391c7cc 100644 --- a/trunk/Documentation/sound/alsa/ALSA-Configuration.txt +++ b/trunk/Documentation/sound/alsa/ALSA-Configuration.txt @@ -105,7 +105,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Each of top level sound card module takes the following options. index - index (slot #) of sound card - - Values: 0 through 31 or negative + - Values: 0 through 7 or negative - If nonnegative, assign that index number - if negative, interpret as a bitmask of permissible indices; the first free permitted index is assigned @@ -134,7 +134,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma2 - second DMA # for AD1816A chip (PnP setup) clockfreq - Clock frequency for AD1816A chip (default = 0, 33000Hz) - This module supports multiple cards, autoprobe and PnP. + Module supports up to 8 cards, autoprobe and PnP. Module snd-ad1848 ----------------- @@ -145,11 +145,9 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. irq - IRQ # for AD1848 chip dma1 - DMA # for AD1848 chip (0,1,3) - This module supports multiple cards. It does not support autoprobe + Module supports up to 8 cards. This module does not support autoprobe thus main port must be specified!!! Other ports are optional. - The power-management is supported. - Module snd-ad1889 ----------------- @@ -158,7 +156,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. ac97_quirk - AC'97 workaround for strange hardware See the description of intel8x0 module for details. - This module supports multiple cards. + This module supports up to 8 cards. Module snd-ali5451 ------------------ @@ -186,9 +184,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. mpu_irq - IRQ # for MPU-401 (PnP setup) fm_port - port # for OPL3 FM (PnP setup) - This module supports multiple cards, autoprobe and PnP. - - The power-management is supported. + Module supports up to 8 cards, autoprobe and PnP. Module snd-als4000 ------------------ @@ -198,9 +194,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. joystick_port - port # for legacy joystick support. 0 = disabled (default), 1 = auto-detect - This module supports multiple cards, autoprobe and PnP. - - The power-management is supported. + Module supports up to 8 cards, autoprobe and PnP. Module snd-atiixp ----------------- @@ -219,8 +213,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. implementation depends on the motherboard, and you'll need to choose the correct one via spdif_aclink module option. - The power-management is supported. - Module snd-atiixp-modem ----------------------- @@ -231,8 +223,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Note: The default index value of this module is -2, i.e. the first slot is excluded. - The power-management is supported. - Module snd-au8810, snd-au8820, snd-au8830 ----------------------------------------- @@ -273,10 +263,8 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma1 - 1st DMA # for AZT2320 (WSS) chip (PnP setup) dma2 - 2nd DMA # for AZT2320 (WSS) chip (PnP setup) - This module supports multiple cards, PnP and autoprobe. + Module supports up to 8 cards, PnP and autoprobe. - The power-management is supported. - Module snd-azt3328 ------------------ @@ -284,7 +272,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. joystick - Enable joystick (default off) - This module supports multiple cards. + Module supports up to 8 cards. Module snd-bt87x ---------------- @@ -294,7 +282,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. digital_rate - Override the default digital rate (Hz) load_all - Load the driver even if the card model isn't known - This module supports multiple cards. + Module supports up to 8 cards. Note: The default index value of this module is -2, i.e. the first slot is excluded. @@ -304,7 +292,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Module for Creative Audigy LS and SB Live 24bit - This module supports multiple cards. + Module supports up to 8 cards. Module snd-cmi8330 @@ -320,9 +308,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. sbdma8 - 8bit DMA # for CMI8330 chip (SB16) sbdma16 - 16bit DMA # for CMI8330 chip (SB16) - This module supports multiple cards and autoprobe. - - The power-management is supported. + Module supports up to 8 cards and autoprobe. Module snd-cmipci ----------------- @@ -335,10 +321,8 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. (default = 1) joystick_port - Joystick port address (0 = disable, 1 = auto-detect) - This module supports autoprobe and multiple cards. + Module supports autoprobe and multiple chips (max 8). - The power-management is supported. - Module snd-cs4231 ----------------- @@ -351,7 +335,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma1 - first DMA # for CS4231 chip dma2 - second DMA # for CS4231 chip - This module supports multiple cards. This module does not support autoprobe + Module supports up to 8 cards. This module does not support autoprobe thus main port must be specified!!! Other ports are optional. The power-management is supported. @@ -371,7 +355,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma2 - second DMA # for Yamaha CS4232 chip (0,1,3), -1 = disable isapnp - ISA PnP detection - 0 = disable, 1 = enable (default) - This module supports multiple cards. This module does not support autoprobe + Module supports up to 8 cards. This module does not support autoprobe thus main port must be specified!!! Other ports are optional. The power-management is supported. @@ -392,7 +376,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma2 - second DMA # for CS4236 chip (0,1,3), -1 = disable isapnp - ISA PnP detection - 0 = disable, 1 = enable (default) - This module supports multiple cards. This module does not support autoprobe + Module supports up to 8 cards. This module does not support autoprobe (if ISA PnP is not used) thus main port and control port must be specified!!! Other ports are optional. @@ -405,7 +389,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dual_codec - Secondary codec ID (0 = disable, default) - This module supports multiple cards. + Module supports up to 8 cards. The power-management is supported. @@ -419,20 +403,13 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. thinkpad - Force to enable Thinkpad's CLKRUN control. mmap_valid - Support OSS mmap mode (default = 0). - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Usually external amp and CLKRUN controls are detected automatically from PCI sub vendor/device ids. If they don't work, give the options above explicitly. The power-management is supported. - Module snd-cs5535audio - ---------------------- - - Module for multifunction CS5535 companion PCI device - - This module supports multiple cards. - Module snd-dt019x ----------------- @@ -446,11 +423,9 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. mpu_irq - IRQ # for MPU-401 (PnP setup) dma8 - DMA # (PnP setup) - This module supports multiple cards. This module is enabled only with + Module supports up to 8 cards. This module is enabled only with ISA PnP support. - The power-management is supported. - Module snd-dummy ---------------- @@ -458,8 +433,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. or input, but you may use this module for any application which requires a sound card (like RealPlayer). - The power-management is supported. - Module snd-emu10k1 ------------------ @@ -477,7 +450,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. given in MB unit. Default value is 128. enable_ir - enable IR - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Input & Output configurations [extin/extout] * Creative Card wo/Digital out [0x0003/0x1f03] @@ -493,14 +466,12 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. * Creative Card 5.1 (c) 2003 [0x3fc3/0x7cff] * Creative Card all ins and outs [0x3fff/0x7fff] - The power-management is supported. - Module snd-emu10k1x ------------------- Module for Creative Emu10k1X (SB Live Dell OEM version) - This module supports multiple cards. + Module supports up to 8 cards. Module snd-ens1370 ------------------ @@ -511,7 +482,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. joystick - Enable joystick (default off) - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Module snd-ens1371 ------------------ @@ -524,7 +495,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. joystick_port - port # for joystick (0x200,0x208,0x210,0x218), 0 = disable (default), 1 = auto-detect - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Module snd-es968 ---------------- @@ -535,10 +506,8 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. irq - IRQ # for ES968 (SB8) chip (PnP setup) dma1 - DMA # for ES968 (SB8) chip (PnP setup) - This module supports multiple cards, PnP and autoprobe. + Module supports up to 8 cards, PnP and autoprobe. - The power-management is supported. - Module snd-es1688 ----------------- @@ -550,7 +519,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. mpu_irq - IRQ # for MPU-401 port (5,7,9,10) dma8 - DMA # for ES-1688 chip (0,1,3) - This module supports multiple cards and autoprobe (without MPU-401 port). + Module supports up to 8 cards and autoprobe (without MPU-401 port). Module snd-es18xx ----------------- @@ -565,8 +534,8 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma2 - first DMA # for ES-18xx chip (0,1,3) isapnp - ISA PnP detection - 0 = disable, 1 = enable (default) - This module supports multiple cards, ISA PnP and autoprobe (without MPU-401 - port if native ISA PnP routines are not used). + Module supports up to 8 cards ISA PnP and autoprobe (without MPU-401 port + if native ISA PnP routines are not used). When dma2 is equal with dma1, the driver works as half-duplex. The power-management is supported. @@ -576,9 +545,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Module for sound cards based on ESS Solo-1 (ES1938,ES1946) chips. - This module supports multiple cards and autoprobe. - - The power-management is supported. + Module supports up to 8 cards and autoprobe. Module snd-es1968 ----------------- @@ -594,7 +561,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. enable_mpu - enable MPU401 (0 = off, 1 = on, 2 = auto (default)) joystick - enable joystick (default off) - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. The power-management is supported. @@ -610,10 +577,8 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. - High 16-bits are video (radio) device number + 1 - example: 0x10002 (MediaForte 256-PCPR, device 1) - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. - The power-management is supported. - Module snd-gusclassic --------------------- @@ -627,7 +592,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. voices - GF1 voices limit (14-32) pcm_voices - reserved PCM voices - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Module snd-gusextreme --------------------- @@ -646,7 +611,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. voices - GF1 voices limit (14-32) pcm_voices - reserved PCM voices - This module supports multiple cards and autoprobe (without MPU-401 port). + Module supports up to 8 cards and autoprobe (without MPU-401 port). Module snd-gusmax ----------------- @@ -661,7 +626,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. voices - GF1 voices limit (14-32) pcm_voices - reserved PCM voices - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Module snd-hda-intel -------------------- @@ -723,14 +688,12 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. (Usually SD_LPLIB register is more accurate than the position buffer.) - The power-management is supported. - Module snd-hdsp --------------- Module for RME Hammerfall DSP audio interface(s) - This module supports multiple cards. + Module supports up to 8 cards. Note: The firmware data can be automatically loaded via hotplug when CONFIG_FW_LOADER is set. Otherwise, you need to load @@ -788,7 +751,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. cs8427_timeout - reset timeout for the CS8427 chip (S/PDIF transciever) in msec resolution, default value is 500 (0.5 sec) - This module supports multiple cards and autoprobe. Note: The consumer part + Module supports up to 8 cards and autoprobe. Note: The consumer part is not used with all Envy24 based cards (for example in the MidiMan Delta serie). @@ -824,7 +787,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. aureon71, universe, k8x800, phase22, phase28, ms300, av710 - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Note: The supported board is detected by reading EEPROM or PCI SSID (if EEPROM isn't available). You can override the @@ -876,8 +839,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Note: The default index value of this module is -2, i.e. the first slot is excluded. - The power-management is supported. - Module snd-interwave -------------------- @@ -894,7 +855,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. effect - 1 = InterWave effects enable (default 0); requires 8 voices - This module supports multiple cards, autoprobe and ISA PnP. + Module supports up to 8 cards, autoprobe and ISA PnP. Module snd-interwave-stb ------------------------ @@ -914,14 +875,14 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. effect - 1 = InterWave effects enable (default 0); requires 8 voices - This module supports multiple cards, autoprobe and ISA PnP. + Module supports up to 8 cards, autoprobe and ISA PnP. Module snd-korg1212 ------------------- Module for Korg 1212 IO PCI card - This module supports multiple cards. + Module supports up to 8 cards. Module snd-maestro3 ------------------- @@ -933,7 +894,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. -1 for default pin (8 for allegro, 1 for others) - This module supports autoprobe and multiple chips. + Module supports autoprobe and multiple chips (max 8). Note: the binding of amplifier is dependent on hardware. If there is no sound even though all channels are unmuted, try to @@ -948,7 +909,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Module for Digigram miXart8 sound cards. - This module supports multiple cards. + Module supports multiple cards. Note: One miXart8 board will be represented as 4 alsa cards. See MIXART.txt for details. @@ -967,7 +928,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. irq - IRQ number or -1 (disable) pnp - PnP detection - 0 = disable, 1 = enable (default) - This module supports multiple devices and PnP. + Module supports multiple devices (max 8) and PnP. Module snd-mtpav ---------------- @@ -1053,7 +1014,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma2 - second DMA # for Yamaha OPL3-SA chip (0,1,3), -1 = disable isapnp - ISA PnP detection - 0 = disable, 1 = enable (default) - This module supports multiple cards and ISA PnP. It does not support + Module supports up to 8 cards and ISA PnP. This module does not support autoprobe (if ISA PnP is not used) thus all ports must be specified!!! The power-management is supported. @@ -1103,13 +1064,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. This module supports only one card, autoprobe and PnP. - Module snd-pcxhr - ---------------- - - Module for Digigram PCXHR boards - - This module supports multiple cards. - Module snd-powermac (on ppc only) --------------------------------- @@ -1130,22 +1084,20 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. For ARM architecture only. - The power-management is supported. - Module snd-rme32 ---------------- Module for RME Digi32, Digi32 Pro and Digi32/8 (Sek'd Prodif32, Prodif96 and Prodif Gold) sound cards. - This module supports multiple cards. + Module supports up to 8 cards. Module snd-rme96 ---------------- Module for RME Digi96, Digi96/8 and Digi96/8 PRO/PAD/PST sound cards. - This module supports multiple cards. + Module supports up to 8 cards. Module snd-rme9652 ------------------ @@ -1155,7 +1107,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. precise_ptr - Enable precise pointer (doesn't work reliably). (default = 0) - This module supports multiple cards. + Module supports up to 8 cards. Note: snd-page-alloc module does the job which snd-hammerfall-mem module did formerly. It will allocate the buffers in advance @@ -1172,8 +1124,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Module supports only one card. Module has no enable and index options. - The power-management is supported. - Module snd-sb8 -------------- @@ -1185,10 +1135,8 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. irq - IRQ # for SB DSP chip (5,7,9,10) dma8 - DMA # for SB DSP chip (1,3) - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. - The power-management is supported. - Module snd-sb16 and snd-sbawe ----------------------------- @@ -1207,7 +1155,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. csp - ASP/CSP chip support - 0 = disable (default), 1 = enable isapnp - ISA PnP detection - 0 = disable, 1 = enable (default) - This module supports multiple cards, autoprobe and ISA PnP. + Module supports up to 8 cards, autoprobe and ISA PnP. Note: To use Vibra16X cards in 16-bit half duplex mode, you must disable 16bit DMA with dma16 = -1 module parameter. @@ -1215,8 +1163,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. half duplex mode through 8-bit DMA channel by disabling their 16-bit DMA channel. - The power-management is supported. - Module snd-sgalaxy ------------------ @@ -1227,9 +1173,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. irq - IRQ # (7,9,10,11) dma1 - DMA # - This module supports multiple cards. - - The power-management is supported. + Module supports up to 8 cards. Module snd-sscape ----------------- @@ -1241,7 +1185,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. mpu_irq - MPU-401 IRQ # (PnP setup) dma - DMA # (PnP setup) - This module supports multiple cards. ISA PnP must be enabled. + Module supports up to 8 cards. ISA PnP must be enabled. You need sscape_ctl tool in alsa-tools package for loading the microcode. @@ -1250,21 +1194,21 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Module for AMD7930 sound chips found on Sparcs. - This module supports multiple cards. + Module supports up to 8 cards. Module snd-sun-cs4231 (on sparc only) ------------------------------------- Module for CS4231 sound chips found on Sparcs. - This module supports multiple cards. + Module supports up to 8 cards. Module snd-sun-dbri (on sparc only) ----------------------------------- Module for DBRI sound chips found on Sparcs. - This module supports multiple cards. + Module supports up to 8 cards. Module snd-wavefront -------------------- @@ -1284,7 +1228,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. dma2 - DMA2 # for CS4232 PCM interface. isapnp - ISA PnP detection - 0 = disable, 1 = enable (default) - This module supports multiple cards and ISA PnP. + Module supports up to 8 cards and ISA PnP. Module snd-sonicvibes --------------------- @@ -1296,7 +1240,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. - SoundCard must have onboard SRAM for this. mge - Mic Gain Enable - 1 = enable, 0 = disable (default) - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. Module snd-serial-u16550 ------------------------ @@ -1315,7 +1259,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. 0 = Soundcanvas, 1 = MS-124T, 2 = MS-124W S/A, 3 = MS-124W M/B, 4 = Generic - This module supports multiple cards. This module does not support autoprobe + Module supports up to 8 cards. This module does not support autoprobe thus the main port must be specified!!! Other options are optional. Module snd-trident @@ -1334,7 +1278,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. pcm_channels - max channels (voices) reserved for PCM wavetable_size - max wavetable size in kB (4-?kb) - This module supports multiple cards and autoprobe. + Module supports up to 8 cards and autoprobe. The power-management is supported. @@ -1346,14 +1290,14 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. vid - Vendor ID for the device (optional) pid - Product ID for the device (optional) - This module supports multiple devices, autoprobe and hotplugging. + This module supports up to 8 cards, autoprobe and hotplugging. Module snd-usb-usx2y -------------------- Module for Tascam USB US-122, US-224 and US-428 devices. - This module supports multiple devices, autoprobe and hotplugging. + This module supports up to 8 cards, autoprobe and hotplugging. Note: you need to load the firmware via usx2yloader utility included in alsa-tools and alsa-firmware packages. @@ -1412,8 +1356,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Note: for the MPU401 on VIA823x, use snd-mpu401 driver additionally. The mpu_port option is for VIA686 chips only. - The power-management is supported. - Module snd-via82xx-modem ------------------------ @@ -1426,8 +1368,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Note: The default index value of this module is -2, i.e. the first slot is excluded. - The power-management is supported. - Module snd-virmidi ------------------ @@ -1435,9 +1375,9 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. This module creates virtual rawmidi devices which communicate to the corresponding ALSA sequencer ports. - midi_devs - MIDI devices # (1-4, default=4) + midi_devs - MIDI devices # (1-8, default=4) - This module supports multiple cards. + Module supports up to 8 cards. Module snd-vx222 ---------------- @@ -1447,7 +1387,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. mic - Enable Microphone on V222 Mic (NYI) ibl - Capture IBL size. (default = 0, minimum size) - This module supports multiple cards. + Module supports up to 8 cards. When the driver is compiled as a module and the hotplug firmware is supported, the firmware data is loaded via hotplug automatically. @@ -1466,8 +1406,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. size is chosen. The possible IBL values can be found in /proc/asound/cardX/vx-status proc file. - The power-management is supported. - Module snd-vxpocket ------------------- @@ -1475,7 +1413,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. ibl - Capture IBL size. (default = 0, minimum size) - This module supports multiple cards. The module is compiled only when + Module supports up to 8 cards. The module is compiled only when PCMCIA is supported on kernel. With the older 2.6.x kernel, to activate the driver via the card @@ -1496,8 +1434,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Note2: snd-vxp440 driver is merged to snd-vxpocket driver since ALSA 1.0.10. - The power-management is supported. - Module snd-ymfpci ----------------- @@ -1511,7 +1447,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. 1 (auto-detect) rear_switch - enable shared rear/line-in switch (bool) - This module supports autoprobe and multiple chips. + Module supports autoprobe and multiple chips (max 8). The power-management is supported. @@ -1522,8 +1458,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. Note: the driver is build only when CONFIG_ISA is set. - The power-management is supported. - AC97 Quirk Option ================= @@ -1540,7 +1474,7 @@ the proper value with this option. The following strings are accepted: - default Don't override the default setting - - none Disable the quirk + - disable Disable the quirk - hp_only Bind Master and Headphone controls as a single control - swap_hp Swap headphone and master controls - swap_surround Swap master and surround controls diff --git a/trunk/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl b/trunk/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl index 4963d83d1511..260334c98d95 100644 --- a/trunk/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl +++ b/trunk/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl @@ -18,8 +18,8 @@ - November 17, 2005 - 0.3.6 + October 6, 2005 + 0.3.5 @@ -403,8 +403,9 @@ static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* definition of the chip-specific record */ - struct mychip { - struct snd_card *card; + typedef struct snd_mychip mychip_t; + struct snd_mychip { + snd_card_t *card; // rest of implementation will be in the section // "PCI Resource Managements" }; @@ -412,7 +413,7 @@ /* chip-specific destructor * (see "PCI Resource Managements") */ - static int snd_mychip_free(struct mychip *chip) + static int snd_mychip_free(mychip_t *chip) { .... // will be implemented later... } @@ -420,21 +421,22 @@ /* component-destructor * (see "Management of Cards and Components") */ - static int snd_mychip_dev_free(struct snd_device *device) + static int snd_mychip_dev_free(snd_device_t *device) { - return snd_mychip_free(device->device_data); + mychip_t *chip = device->device_data; + return snd_mychip_free(chip); } /* chip-specific constructor * (see "Management of Cards and Components") */ - static int __devinit snd_mychip_create(struct snd_card *card, + static int __devinit snd_mychip_create(snd_card_t *card, struct pci_dev *pci, - struct mychip **rchip) + mychip_t **rchip) { - struct mychip *chip; + mychip_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_mychip_dev_free, }; @@ -472,8 +474,8 @@ const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct mychip *chip; + snd_card_t *card; + mychip_t *chip; int err; /* (1) */ @@ -580,7 +582,7 @@ @@ -603,7 +605,7 @@ @@ -828,7 +830,7 @@ After the card is created, you can attach the components (devices) to the card instance. On ALSA driver, a component is - represented as a struct snd_device object. + represented as a snd_device_t object. A component can be a PCM instance, a control interface, a raw MIDI interface, etc. Each of such instances has one component entry. @@ -889,11 +891,14 @@ The chip-specific information, e.g. the i/o port address, its resource pointer, or the irq number, is stored in the chip-specific record. + Usually, the chip-specific record is typedef'ed as + xxx_t like the following: @@ -913,12 +918,12 @@ - whether struct mychip is the type of the chip record. + whether mychip_t is the type of the chip record. @@ -927,7 +932,7 @@ private_data; + mychip_t *chip = (mychip_t *)card->private_data; ]]> @@ -949,8 +954,8 @@ @@ -995,7 +1000,7 @@ device_data); + mychip_t *chip = device->device_data; + return snd_mychip_free(chip); } ]]> @@ -1081,15 +1087,15 @@ PCI Resource Managements Example port = pci_resource_start(pci, 0); if (request_irq(pci->irq, snd_mychip_interrupt, - SA_INTERRUPT|SA_SHIRQ, "My Chip", chip)) { + SA_INTERRUPT|SA_SHIRQ, "My Chip", + (void *)chip)) { printk(KERN_ERR "cannot grab irq %d\n", pci->irq); snd_mychip_free(chip); return -EBUSY; @@ -1261,14 +1268,14 @@ Now assume that this PCI device has an I/O port with 8 bytes - and an interrupt. Then struct mychip will have the + and an interrupt. Then mychip_t will have the following fields: irq, snd_mychip_interrupt, - SA_INTERRUPT|SA_SHIRQ, "My Chip", chip)) { + SA_INTERRUPT|SA_SHIRQ, "My Chip", + (void *)chip)) { printk(KERN_ERR "cannot grab irq %d\n", pci->irq); snd_mychip_free(chip); return -EBUSY; @@ -1364,7 +1372,7 @@ static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct mychip *chip = dev_id; + mychip_t *chip = dev_id; .... return IRQ_HANDLED; } @@ -1479,7 +1487,7 @@ iobase_virt) @@ -1529,7 +1537,7 @@ Registration of Device Struct At some point, typically after calling snd_device_new(), - you need to register the struct device of the chip + you need to register the struct device of the chip you're handling for udev and co. ALSA provides a macro for compatibility with older kernels. Simply call like the following: @@ -1731,7 +1739,7 @@ .... /* hardware definition */ - static struct snd_pcm_hardware snd_mychip_playback_hw = { + static snd_pcm_hardware_t snd_mychip_playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1750,7 +1758,7 @@ }; /* hardware definition */ - static struct snd_pcm_hardware snd_mychip_capture_hw = { + static snd_pcm_hardware_t snd_mychip_capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1769,10 +1777,10 @@ }; /* open callback */ - static int snd_mychip_playback_open(struct snd_pcm_substream *substream) + static int snd_mychip_playback_open(snd_pcm_substream_t *substream) { - struct mychip *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + mychip_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; runtime->hw = snd_mychip_playback_hw; // more hardware-initialization will be done here @@ -1780,19 +1788,19 @@ } /* close callback */ - static int snd_mychip_playback_close(struct snd_pcm_substream *substream) + static int snd_mychip_playback_close(snd_pcm_substream_t *substream) { - struct mychip *chip = snd_pcm_substream_chip(substream); + mychip_t *chip = snd_pcm_substream_chip(substream); // the hardware-specific codes will be here return 0; } /* open callback */ - static int snd_mychip_capture_open(struct snd_pcm_substream *substream) + static int snd_mychip_capture_open(snd_pcm_substream_t *substream) { - struct mychip *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + mychip_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; runtime->hw = snd_mychip_capture_hw; // more hardware-initialization will be done here @@ -1800,33 +1808,33 @@ } /* close callback */ - static int snd_mychip_capture_close(struct snd_pcm_substream *substream) + static int snd_mychip_capture_close(snd_pcm_substream_t *substream) { - struct mychip *chip = snd_pcm_substream_chip(substream); + mychip_t *chip = snd_pcm_substream_chip(substream); // the hardware-specific codes will be here return 0; } /* hw_params callback */ - static int snd_mychip_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) + static int snd_mychip_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } /* hw_free callback */ - static int snd_mychip_pcm_hw_free(struct snd_pcm_substream *substream) + static int snd_mychip_pcm_hw_free(snd_pcm_substream_t *substream) { return snd_pcm_lib_free_pages(substream); } /* prepare callback */ - static int snd_mychip_pcm_prepare(struct snd_pcm_substream *substream) + static int snd_mychip_pcm_prepare(snd_pcm_substream_t *substream) { - struct mychip *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + mychip_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; /* set up the hardware with the current configuration * for example... @@ -1841,7 +1849,7 @@ } /* trigger callback */ - static int snd_mychip_pcm_trigger(struct snd_pcm_substream *substream, + static int snd_mychip_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { switch (cmd) { @@ -1858,9 +1866,9 @@ /* pointer callback */ static snd_pcm_uframes_t - snd_mychip_pcm_pointer(struct snd_pcm_substream *substream) + snd_mychip_pcm_pointer(snd_pcm_substream_t *substream) { - struct mychip *chip = snd_pcm_substream_chip(substream); + mychip_t *chip = snd_pcm_substream_chip(substream); unsigned int current_ptr; /* get the current hardware pointer */ @@ -1869,7 +1877,7 @@ } /* operators */ - static struct snd_pcm_ops snd_mychip_playback_ops = { + static snd_pcm_ops_t snd_mychip_playback_ops = { .open = snd_mychip_playback_open, .close = snd_mychip_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1881,7 +1889,7 @@ }; /* operators */ - static struct snd_pcm_ops snd_mychip_capture_ops = { + static snd_pcm_ops_t snd_mychip_capture_ops = { .open = snd_mychip_capture_open, .close = snd_mychip_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1897,9 +1905,9 @@ */ /* create a pcm device */ - static int __devinit snd_mychip_new_pcm(struct mychip *chip) + static int __devinit snd_mychip_new_pcm(mychip_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(chip->card, "My Chip", 0, 1, 1, @@ -1936,9 +1944,9 @@ card, "My Chip", 0, 1, 1, @@ -1981,13 +1989,13 @@ specify more numbers, but they must be handled properly in open/close, etc. callbacks. When you need to know which substream you are referring to, then it can be obtained from - struct snd_pcm_substream data passed to each callback + snd_pcm_substream_t data passed to each callback as follows: number; ]]> @@ -2016,7 +2024,7 @@ PCM Instance with a Destructor my_private_pcm_data); // do what you like else .... } - static int __devinit snd_mychip_new_pcm(struct mychip *chip) + static int __devinit snd_mychip_new_pcm(mychip_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; .... /* allocate your own data */ chip->my_private_pcm_data = kmalloc(...); @@ -2141,7 +2149,7 @@ @@ -2244,7 +2252,7 @@ struct _snd_pcm_runtime {
Hardware Description - The hardware descriptor (struct snd_pcm_hardware) + The hardware descriptor (snd_pcm_hardware_t) contains the definitions of the fundamental hardware configuration. Above all, you'll need to define this in @@ -2259,7 +2267,7 @@ struct _snd_pcm_runtime { runtime; + snd_pcm_runtime_t *runtime = substream->runtime; ... runtime->hw = snd_mychip_playback_hw; /* common definition */ if (chip->model == VERY_OLD_ONE) @@ -2274,7 +2282,7 @@ struct _snd_pcm_runtime { PAUSE bit means that the pcm supports the pause operation, while the RESUME bit means that the pcm supports - the full suspend/resume operation. - If PAUSE flag is set, - the trigger callback below - must handle the corresponding (pause push/release) commands. - The suspend/resume trigger commands can be defined even without - RESUME flag. See - Power Management section for details. + the suspend/resume operation. If these flags + are set, the trigger callback below + must handle the corresponding commands. @@ -2509,7 +2512,7 @@ struct _snd_pcm_runtime { Running Status The running status can be referred via runtime->status. - This is the pointer to struct snd_pcm_mmap_status + This is the pointer to snd_pcm_mmap_status_t record. For example, you can get the current DMA hardware pointer via runtime->status->hw_ptr. @@ -2517,7 +2520,7 @@ struct _snd_pcm_runtime { The DMA application pointer can be referred via runtime->control, which points - struct snd_pcm_mmap_control record. + snd_pcm_mmap_control_t record. However, accessing directly to this value is not recommended.
@@ -2539,9 +2542,9 @@ struct _snd_pcm_runtime { runtime->private_data = data; @@ -2583,7 +2586,7 @@ struct _snd_pcm_runtime { The callback function takes at least the argument with - snd_pcm_substream pointer. For retrieving the + snd_pcm_substream_t pointer. For retrieving the chip record from the given substream instance, you can use the following macro. @@ -2591,7 +2594,7 @@ struct _snd_pcm_runtime { @@ -2613,7 +2616,7 @@ struct _snd_pcm_runtime { @@ -2628,10 +2631,10 @@ struct _snd_pcm_runtime { runtime; + mychip_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; runtime->hw = snd_mychip_playback_hw; return 0; @@ -2664,7 +2667,7 @@ struct _snd_pcm_runtime { @@ -2679,7 +2682,7 @@ struct _snd_pcm_runtime { runtime->private_data); @@ -2706,8 +2709,8 @@ struct _snd_pcm_runtime { @@ -2782,7 +2785,7 @@ struct _snd_pcm_runtime { @@ -2817,7 +2820,7 @@ struct _snd_pcm_runtime { @@ -2866,7 +2869,7 @@ struct _snd_pcm_runtime { @@ -2908,8 +2911,8 @@ struct _snd_pcm_runtime { - When the pcm supports the suspend/resume operation, - regardless of full or partial suspend/resume support, + When the pcm supports the suspend/resume operation + (i.e. SNDRV_PCM_INFO_RESUME flag is set), SUSPEND and RESUME commands must be handled, too. These commands are issued when the power-management status is @@ -2918,8 +2921,6 @@ struct _snd_pcm_runtime { do suspend and resume of the pcm substream, and usually, they are identical with STOP and START commands, respectively. - See - Power Management section for details. @@ -2938,7 +2939,7 @@ struct _snd_pcm_runtime { @@ -3066,7 +3067,7 @@ struct _snd_pcm_runtime { static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct mychip *chip = dev_id; + mychip_t *chip = dev_id; spin_lock(&chip->lock); .... if (pcm_irq_invoked(chip)) { @@ -3110,7 +3111,7 @@ struct _snd_pcm_runtime { static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct mychip *chip = dev_id; + mychip_t *chip = dev_id; spin_lock(&chip->lock); .... if (pcm_irq_invoked(chip)) { @@ -3220,13 +3221,13 @@ struct _snd_pcm_runtime { snd_pcm_hardware stucture (or in any + specified in the snd_pcm_hardware_t stucture (or in any other constraint_list). You can build a rule like this: Example of Hardware Constraints for Channels min < 2) { @@ -3298,13 +3298,12 @@ struct _snd_pcm_runtime { Example of Hardware Constraints for Channels bits[0] == SNDRV_PCM_FMTBIT_S16_LE) { @@ -3377,13 +3376,13 @@ struct _snd_pcm_runtime { callbacks: info, get and put. Then, define a - struct snd_kcontrol_new record, such as: + snd_kcontrol_new_t record, such as: Definition of a Control The info callback is used to get the detailed information of this control. This must store the - values of the given struct snd_ctl_elem_info + values of the given snd_ctl_elem_info_t object. For example, for a boolean control with a single element will be: @@ -3608,8 +3607,8 @@ struct _snd_pcm_runtime { Example of info callback type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -3643,8 +3642,8 @@ struct _snd_pcm_runtime { Example of get callback value.integer.value[0] = get_some_value(chip); return 0; } @@ -3718,8 +3717,8 @@ struct _snd_pcm_runtime { private_value & 0xff; int shift = (kcontrol->private_value >> 16) & 0xff; @@ -3755,10 +3754,10 @@ struct _snd_pcm_runtime { Example of put callback current_value != ucontrol->value.integer.value[0]) { @@ -3815,7 +3814,7 @@ struct _snd_pcm_runtime { where my_control is the - struct snd_kcontrol_new object defined above, and chip + snd_kcontrol_new_t object defined above, and chip is the object pointer to be passed to kcontrol->private_data which can be referred in callbacks. @@ -3823,7 +3822,7 @@ struct _snd_pcm_runtime { snd_ctl_new1() allocates a new - snd_kcontrol instance (that's why the definition + snd_kcontrol_t instance (that's why the definition of my_control can be with __devinitdata prefix), and snd_ctl_add assigns the given @@ -3850,7 +3849,7 @@ struct _snd_pcm_runtime { control id pointer for the notification. The event-mask specifies the types of notification, for example, in the above example, the change of control values is notified. - The id pointer is the pointer of struct snd_ctl_elem_id + The id pointer is the pointer of snd_ctl_elem_id_t to be notified. You can find some examples in es1938.c or es1968.c for hardware volume interrupts. @@ -3883,35 +3882,35 @@ struct _snd_pcm_runtime { Example of AC97 Interface private_data; + mychip_t *chip = ac97->private_data; .... // read a register value here from the codec return the_register_value; } - static void snd_mychip_ac97_write(struct snd_ac97 *ac97, + static void snd_mychip_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct mychip *chip = ac97->private_data; + mychip_t *chip = ac97->private_data; .... // write the given register value to the codec } - static int snd_mychip_ac97(struct mychip *chip) + static int snd_mychip_ac97(mychip_t *chip) { - struct snd_ac97_bus *bus; - struct snd_ac97_template ac97; + ac97_bus_t *bus; + ac97_template_t ac97; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_mychip_ac97_write, .read = snd_mychip_ac97_read, }; @@ -3938,8 +3937,8 @@ struct _snd_pcm_runtime { - And then call snd_ac97_mixer() with an - struct snd_ac97_template + And then call snd_ac97_mixer() with an ac97_template_t record together with the bus pointer created above. private_data; + mychip_t *chip = ac97->private_data; .... return the_register_value; } @@ -4018,7 +4016,7 @@ struct _snd_pcm_runtime { @@ -4165,7 +4163,7 @@ struct _snd_pcm_runtime { Multiple Codecs When there are several codecs on the same card, you need to - call snd_ac97_mixer() multiple times with + call snd_ac97_new() multiple times with ac97.num=1 or greater. The num field specifies the codec number. @@ -4214,7 +4212,7 @@ struct _snd_pcm_runtime { @@ -4255,17 +4253,17 @@ struct _snd_pcm_runtime { Usually, the port address corresponds to the command port and port + 1 corresponds to the data port. If not, you may change the cport field of - struct snd_mpu401 manually - afterward. However, snd_mpu401 pointer is not + mpu401_t manually + afterward. However, mpu401_t pointer is not returned explicitly by snd_mpu401_uart_new(). You need to cast rmidi->private_data to - snd_mpu401 explicitly, + mpu401_t explicitly, private_data; ]]> @@ -4361,7 +4359,7 @@ struct _snd_pcm_runtime { card, "MyMIDI", 0, outs, ins, &rmidi); if (err < 0) return err; @@ -4421,7 +4419,7 @@ struct _snd_pcm_runtime { streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { - substream = list_entry(list, struct snd_rawmidi_substream, list); + substream = list_entry(list, snd_rawmidi_substream_t, list); sprintf(substream->name, "My MIDI Port %d", substream->number + 1); } /* same for SNDRV_RAWMIDI_STREAM_INPUT */ @@ -4465,12 +4463,12 @@ struct _snd_pcm_runtime { If there is more than one port, your callbacks can determine the - port index from the struct snd_rawmidi_substream data passed to each + port index from the snd_rawmidi_substream_t data passed to each callback: number; ]]> @@ -4483,7 +4481,7 @@ struct _snd_pcm_runtime { @@ -4501,7 +4499,7 @@ struct _snd_pcm_runtime { @@ -4524,7 +4522,7 @@ struct _snd_pcm_runtime { @@ -4549,7 +4547,7 @@ struct _snd_pcm_runtime { @@ -4605,7 +4603,7 @@ struct _snd_pcm_runtime { @@ -4649,7 +4647,7 @@ struct _snd_pcm_runtime { @@ -4663,7 +4661,7 @@ struct _snd_pcm_runtime { This callback is optional. If you do not set - drain in the struct snd_rawmidi_ops + drain in the snd_rawmidi_ops_t structure, ALSA will simply wait for 50 milliseconds instead. @@ -4705,7 +4703,7 @@ struct _snd_pcm_runtime { @@ -4738,7 +4736,7 @@ struct _snd_pcm_runtime { @@ -4769,7 +4767,7 @@ struct _snd_pcm_runtime { @@ -4806,7 +4804,7 @@ struct _snd_pcm_runtime { @@ -4825,7 +4823,7 @@ struct _snd_pcm_runtime { private_data = p; hw->private_free = mydata_free; ]]> @@ -4837,9 +4835,9 @@ struct _snd_pcm_runtime { private_data; + mydata_t *p = hw->private_data; kfree(p); } ]]> @@ -5063,9 +5061,9 @@ struct _snd_pcm_runtime { @@ -5146,7 +5144,7 @@ struct _snd_pcm_runtime { @@ -5213,7 +5211,7 @@ struct _snd_pcm_runtime { dma_private; + snd_pcm_sgbuf_t *sgbuf = (snd_pcm_sgbuf_t*)substream->dma_private; ]]> @@ -5268,7 +5266,7 @@ struct _snd_pcm_runtime { #include /* get the physical page pointer on the given offset */ - static struct page *mychip_page(struct snd_pcm_substream *substream, + static struct page *mychip_page(snd_pcm_substream_t *substream, unsigned long offset) { void *pageptr = substream->runtime->dma_area + offset; @@ -5303,7 +5301,7 @@ struct _snd_pcm_runtime { @@ -5347,8 +5345,8 @@ struct _snd_pcm_runtime { @@ -5363,10 +5361,10 @@ struct _snd_pcm_runtime { private_data; + chip_t *chip = entry->private_data; snd_iprintf(buffer, "This is my chip!\n"); snd_iprintf(buffer, "Port = %ld\n", chip->port); @@ -5455,7 +5453,7 @@ struct _snd_pcm_runtime { CONFIG_PM. - - If the driver supports the suspend/resume - fully, that is, the device can be - properly resumed to the status at the suspend is called, - you can set SNDRV_PCM_INFO_RESUME flag - to pcm info field. Usually, this is possible when the - registers of ths chip can be safely saved and restored to the - RAM. If this is set, the trigger callback is called with - SNDRV_PCM_TRIGGER_RESUME after resume - callback is finished. - - - - Even if the driver doesn't support PM fully but only the - partial suspend/resume is possible, it's still worthy to - implement suspend/resume callbacks. In such a case, applications - would reset the status by calling - snd_pcm_prepare() and restart the stream - appropriately. Hence, you can define suspend/resume callbacks - below but don't set SNDRV_PCM_INFO_RESUME - info flag to the PCM. - - - - Note that the trigger with SUSPEND can be always called when - snd_pcm_suspend_all is called, - regardless of SNDRV_PCM_INFO_RESUME flag. - The RESUME flag affects only the behavior - of snd_pcm_resume(). - (Thus, in theory, - SNDRV_PCM_TRIGGER_RESUME isn't needed - to be handled in the trigger callback when no - SNDRV_PCM_INFO_RESUME flag is set. But, - it's better to keep it for compatibility reason.) - - In the earlier version of ALSA drivers, a common - power-management layer was provided, but it has been removed. - The driver needs to define the suspend/resume hooks according to - the bus the device is assigned. In the case of PCI driver, the - callbacks look like below: + ALSA provides the common power-management layer. Each card driver + needs to have only low-level suspend and resume callbacks. - Retrieve the card and the chip data. - Call snd_power_change_state() with - SNDRV_CTL_POWER_D3hot to change the - power status. + Retrieve the chip data from pm_private_data field. Call snd_pcm_suspend_all() to suspend the running PCM streams. - If AC97 codecs are used, call - snd_ac97_resume() for each codec. Save the register values if necessary. Stop the hardware if necessary. - Disable the PCI device by calling - pci_disable_device(). Then, call - pci_save_state() at last. + Disable the PCI device by calling pci_disable_device(). @@ -5577,24 +5530,18 @@ struct _snd_pcm_runtime { private_data; + mychip_t *chip = card->pm_private_data; /* (2) */ - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - /* (3) */ snd_pcm_suspend_all(chip->pcm); - /* (4) */ - snd_ac97_suspend(chip->ac97); - /* (5) */ + /* (3) */ snd_mychip_save_registers(chip); - /* (6) */ + /* (4) */ snd_mychip_stop_hardware(chip); - /* (7) */ - pci_disable_device(pci); - pci_save_state(pci); + /* (5) */ + pci_disable_device(chip->pci); return 0; } ]]> @@ -5606,17 +5553,14 @@ struct _snd_pcm_runtime { The scheme of the real resume job is as following. - Retrieve the card and the chip data. - Set up PCI. First, call pci_restore_state(). - Then enable the pci device again by calling pci_enable_device(). - Call pci_set_master() if necessary, too. + Retrieve the chip data from pm_private_data field. + Enable the pci device again by calling + pci_enable_device(). Re-initialize the chip. Restore the saved registers if necessary. Resume the mixer, e.g. calling snd_ac97_resume(). Restart the hardware (if any). - Call snd_power_change_state() with - SNDRV_CTL_POWER_D0 to notify the processes. @@ -5626,15 +5570,12 @@ struct _snd_pcm_runtime { private_data; + mychip_t *chip = card->pm_private_data; /* (2) */ - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); + pci_enable_device(chip->pci); /* (3) */ snd_mychip_reinit_chip(chip); /* (4) */ @@ -5643,8 +5584,6 @@ struct _snd_pcm_runtime { snd_ac97_resume(chip->ac97); /* (6) */ snd_mychip_restart_chip(chip); - /* (7) */ - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } ]]> @@ -5653,23 +5592,8 @@ struct _snd_pcm_runtime { - As shown in the above, it's better to save registers after - suspending the PCM operations via - snd_pcm_suspend_all() or - snd_pcm_suspend(). It means that the PCM - streams are already stoppped when the register snapshot is - taken. But, remind that you don't have to restart the PCM - stream in the resume callback. It'll be restarted via - trigger call with SNDRV_PCM_TRIGGER_RESUME - when necessary. - - - - OK, we have all callbacks now. Let's set them up. In the - initialization of the card, make sure that you can get the chip - data from the card instance, typically via - private_data field, in case you - created the chip data individually. + OK, we have all callbacks now. Let's set up them now. In the + initialization of the card, add the following: @@ -5678,56 +5602,33 @@ struct _snd_pcm_runtime { const struct pci_device_id *pci_id) { .... - struct snd_card *card; - struct mychip *chip; + snd_card_t *card; + mychip_t *chip; .... - card = snd_card_new(index[dev], id[dev], THIS_MODULE, NULL); - .... - chip = kzalloc(sizeof(*chip), GFP_KERNEL); - .... - card->private_data = chip; - .... - } -]]> - - - - When you created the chip data with - snd_card_new(), it's anyway accessible - via private_data field. - - - -private_data; + snd_card_set_pm_callback(card, snd_my_suspend, snd_my_resume, chip); .... } ]]> + Here you don't have to put ifdef CONFIG_PM around, since it's already + checked in the header and expanded to empty if not needed. - If you need a space for saving the registers, allocate the - buffer for it here, too, since it would be fatal + If you need a space for saving the registers, you'll need to + allocate the buffer for it here, too, since it would be fatal if you cannot allocate a memory in the suspend phase. The allocated buffer should be released in the corresponding destructor. - And next, set suspend/resume callbacks to the pci_driver. + And next, set suspend/resume callbacks to the pci_driver, + This can be done by passing a macro SND_PCI_PM_CALLBACKS + in the pci_driver struct. This macro is expanded to the correct + (global) callbacks if CONFIG_PM is set. @@ -5737,10 +5638,7 @@ struct _snd_pcm_runtime { .id_table = snd_my_ids, .probe = snd_my_probe, .remove = __devexit_p(snd_my_remove), - #ifdef CONFIG_PM - .suspend = snd_my_suspend, - .resume = snd_my_resume, - #endif + SND_PCI_PM_CALLBACKS }; ]]> diff --git a/trunk/Documentation/sound/alsa/Procfile.txt b/trunk/Documentation/sound/alsa/Procfile.txt index 1fe48846d78f..25c5d648aef6 100644 --- a/trunk/Documentation/sound/alsa/Procfile.txt +++ b/trunk/Documentation/sound/alsa/Procfile.txt @@ -138,22 +138,6 @@ card*/codec97#0/ac97#?-?+regs # echo 02 9f1f > /proc/asound/card0/codec97#0/ac97#0-0+regs -USB Audio Streams ------------------ - -card*/stream* - Shows the assignment and the current status of each audio stream - of the given card. This information is very useful for debugging. - - -HD-Audio Codecs ---------------- - -card*/codec#* - Shows the general codec information and the attribute of each - widget node. - - Sequencer Information --------------------- diff --git a/trunk/Documentation/sound/alsa/hda_codec.txt b/trunk/Documentation/sound/alsa/hda_codec.txt index 0be57ed81302..e9d07b8f1acb 100644 --- a/trunk/Documentation/sound/alsa/hda_codec.txt +++ b/trunk/Documentation/sound/alsa/hda_codec.txt @@ -63,7 +63,7 @@ The bus instance is created via snd_hda_bus_new(). You need to pass the card instance, the template, and the pointer to store the resultant bus instance. -int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp, +int snd_hda_bus_new(snd_card_t *card, const struct hda_bus_template *temp, struct hda_bus **busp); It returns zero if successful. A negative return value means any @@ -166,14 +166,14 @@ The ops field contains the following callback functions: struct hda_pcm_ops { int (*open)(struct hda_pcm_stream *info, struct hda_codec *codec, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int (*close)(struct hda_pcm_stream *info, struct hda_codec *codec, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int (*prepare)(struct hda_pcm_stream *info, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int (*cleanup)(struct hda_pcm_stream *info, struct hda_codec *codec, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); }; All are non-NULL, so you can call them safely without NULL check. @@ -284,7 +284,7 @@ parameter, and PCI subsystem IDs. If the matching entry is found, it returns the config field value. snd_hda_add_new_ctls() can be used to create and add control entries. -Pass the zero-terminated array of struct snd_kcontrol_new. The same array +Pass the zero-terminated array of snd_kcontrol_new_t. The same array can be passed to snd_hda_resume_ctls() for resume. Note that this will call control->put callback of these entries. So, put callback should check codec->in_resume and force to restore the @@ -292,7 +292,7 @@ given value if it's non-zero even if the value is identical with the cached value. Macros HDA_CODEC_VOLUME(), HDA_CODEC_MUTE() and their variables can be -used for the entry of struct snd_kcontrol_new. +used for the entry of snd_kcontrol_new_t. The input MUX helper callbacks for such a control are provided, too: snd_hda_input_mux_info() and snd_hda_input_mux_put(). See diff --git a/trunk/Documentation/sysrq.txt b/trunk/Documentation/sysrq.txt index ad0bedf678b3..baf17b381588 100644 --- a/trunk/Documentation/sysrq.txt +++ b/trunk/Documentation/sysrq.txt @@ -202,13 +202,17 @@ you must call __handle_sysrq_nolock instead. * I have more questions, who can I ask? ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +You may feel free to send email to myrdraal@deathsdoor.com, and I will +respond as soon as possible. + -Myrdraal + And I'll answer any questions about the registration system you got, also responding as soon as possible. -Crutcher * Credits ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Written by Mydraal +Written by Mydraal Updated by Adam Sulmicki Updated by Jeremy M. Dolan 2001/01/28 10:15:59 Added to by Crutcher Dunnavant diff --git a/trunk/MAINTAINERS b/trunk/MAINTAINERS index 5daae53bf975..86ee06f43794 100644 --- a/trunk/MAINTAINERS +++ b/trunk/MAINTAINERS @@ -554,6 +554,11 @@ W: http://us1.samba.org/samba/Linux_CIFS_client.html T: git kernel.org:/pub/scm/linux/kernel/git/sfrench/cifs-2.6.git S: Supported +CONFIGFS +P: Joel Becker +M: Joel Becker +S: Supported + CIRRUS LOGIC GENERIC FBDEV DRIVER P: Jeff Garzik M: jgarzik@pobox.com @@ -650,11 +655,6 @@ L: linux-crypto@vger.kernel.org T: git kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6.git S: Maintained -CS5535 Audio ALSA driver -P: Jaya Kumar -M: jayakumar.alsa@gmail.com -S: Maintained - CYBERPRO FB DRIVER P: Russell King M: rmk@arm.linux.org.uk @@ -1230,7 +1230,7 @@ IEEE 1394 SUBSYSTEM P: Ben Collins M: bcollins@debian.org P: Jody McIntyre -M: scjody@modernduck.com +M: scjody@steamballoon.com L: linux1394-devel@lists.sourceforge.net W: http://www.linux1394.org/ T: git kernel.org:/pub/scm/linux/kernel/git/scjody/ieee1394.git @@ -1240,14 +1240,14 @@ IEEE 1394 OHCI DRIVER P: Ben Collins M: bcollins@debian.org P: Jody McIntyre -M: scjody@modernduck.com +M: scjody@steamballoon.com L: linux1394-devel@lists.sourceforge.net W: http://www.linux1394.org/ S: Maintained IEEE 1394 PCILYNX DRIVER P: Jody McIntyre -M: scjody@modernduck.com +M: scjody@steamballoon.com L: linux1394-devel@lists.sourceforge.net W: http://www.linux1394.org/ S: Maintained @@ -1470,6 +1470,7 @@ P: Several L: kernel-janitors@osdl.org W: http://www.kerneljanitors.org/ W: http://sf.net/projects/kernel-janitor/ +W: http://developer.osdl.org/rddunlap/kj-patches/ S: Maintained KERNEL NFSD @@ -1480,11 +1481,17 @@ W: http://nfs.sourceforge.net/ W: http://www.cse.unsw.edu.au/~neilb/patches/linux-devel/ S: Maintained +KERNEL EVENT LAYER (KOBJECT_UEVENT) +P: Robert Love +M: rml@novell.com +L: linux-kernel@vger.kernel.org +S: Maintained + KEXEC P: Eric Biederman P: Randy Dunlap M: ebiederm@xmission.com -M: rdunlap@xenotime.net +M: rddunlap@osdl.org W: http://www.xmission.com/~ebiederm/files/kexec/ L: linux-kernel@vger.kernel.org L: fastboot@osdl.org @@ -2585,6 +2592,7 @@ S: Maintained UDF FILESYSTEM P: Ben Fennema M: bfennema@falcon.csc.calpoly.edu +L: linux_udf@hpesjro.fc.hp.com W: http://linux-udf.sourceforge.net S: Maintained @@ -2637,12 +2645,6 @@ L: linux-usb-users@lists.sourceforge.net L: linux-usb-devel@lists.sourceforge.net S: Maintained -USB ISP116X DRIVER -P: Olav Kongas -M: ok@artecdesign.ee -L: linux-usb-devel@lists.sourceforge.net -S: Maintained - USB KAWASAKI LSI DRIVER P: Oliver Neukum M: oliver@neukum.name @@ -2654,7 +2656,7 @@ USB MASS STORAGE DRIVER P: Matthew Dharm M: mdharm-usb@one-eyed-alien.net L: linux-usb-users@lists.sourceforge.net -L: usb-storage@lists.one-eyed-alien.net +L: linux-usb-devel@lists.sourceforge.net S: Maintained W: http://www.one-eyed-alien.net/~mdharm/linux-usb/ diff --git a/trunk/Makefile b/trunk/Makefile index 599e744d3e33..497884d3d556 100644 --- a/trunk/Makefile +++ b/trunk/Makefile @@ -286,6 +286,10 @@ export quiet Q KBUILD_VERBOSE cc-option = $(shell if $(CC) $(CFLAGS) $(1) -S -o /dev/null -xc /dev/null \ > /dev/null 2>&1; then echo "$(1)"; else echo "$(2)"; fi ;) +# For backward compatibility +check_gcc = $(warning check_gcc is deprecated - use cc-option) \ + $(call cc-option, $(1),$(2)) + # cc-option-yn # Usage: flag := $(call cc-option-yn, -march=winchip-c6) cc-option-yn = $(shell if $(CC) $(CFLAGS) $(1) -S -o /dev/null -xc /dev/null \ @@ -477,20 +481,18 @@ ifeq ($(dot-config),1) # Read in dependencies to all Kconfig* files, make sure to run # oldconfig if changes are detected. --include .kconfig.d +-include .config.cmd include .config # If .config needs to be updated, it will be done via the dependency # that autoconf has on .config. # To avoid any implicit rule to kick in, define an empty command -.config .kconfig.d: ; +.config: ; # If .config is newer than include/linux/autoconf.h, someone tinkered -# with it and forgot to run make oldconfig. -# If kconfig.d is missing then we are probarly in a cleaned tree so -# we execute the config step to be sure to catch updated Kconfig files -include/linux/autoconf.h: .kconfig.d .config +# with it and forgot to run make oldconfig +include/linux/autoconf.h: .config $(Q)mkdir -p include/linux $(Q)$(MAKE) -f $(srctree)/Makefile silentoldconfig else @@ -1064,7 +1066,7 @@ help: @echo ' all - Build all targets marked with [*]' @echo '* vmlinux - Build the bare kernel' @echo '* modules - Build all modules' - @echo ' modules_install - Install all modules to INSTALL_MOD_PATH (default: /)' + @echo ' modules_install - Install all modules' @echo ' dir/ - Build all files in dir and below' @echo ' dir/file.[ois] - Build specified target only' @echo ' dir/file.ko - Build module including final link' @@ -1238,11 +1240,8 @@ cscope: FORCE quiet_cmd_TAGS = MAKE $@ define cmd_TAGS rm -f $@; \ - ETAGSF=`etags --version | grep -i exuberant >/dev/null && \ - echo "-I __initdata,__exitdata,__acquires,__releases \ - -I EXPORT_SYMBOL,EXPORT_SYMBOL_GPL \ - --extra=+f --c-kinds=+px"`; \ - $(all-sources) | xargs etags $$ETAGSF -a + ETAGSF=`etags --version | grep -i exuberant >/dev/null && echo "-I __initdata,__exitdata,EXPORT_SYMBOL,EXPORT_SYMBOL_GPL --extra=+f"`; \ + $(all-sources) | xargs etags $$ETAGSF -a endef TAGS: FORCE @@ -1252,11 +1251,8 @@ TAGS: FORCE quiet_cmd_tags = MAKE $@ define cmd_tags rm -f $@; \ - CTAGSF=`ctags --version | grep -i exuberant >/dev/null && \ - echo "-I __initdata,__exitdata,__acquires,__releases \ - -I EXPORT_SYMBOL,EXPORT_SYMBOL_GPL \ - --extra=+f --c-kinds=+px"`; \ - $(all-sources) | xargs ctags $$CTAGSF -a + CTAGSF=`ctags --version | grep -i exuberant >/dev/null && echo "-I __initdata,__exitdata,EXPORT_SYMBOL,EXPORT_SYMBOL_GPL --extra=+f"`; \ + $(all-sources) | xargs ctags $$CTAGSF -a endef tags: FORCE diff --git a/trunk/arch/arm/common/amba.c b/trunk/arch/arm/common/amba.c index c95ec9eab996..e1013112c354 100644 --- a/trunk/arch/arm/common/amba.c +++ b/trunk/arch/arm/common/amba.c @@ -45,7 +45,7 @@ static int amba_match(struct device *dev, struct device_driver *drv) } #ifdef CONFIG_HOTPLUG -static int amba_uevent(struct device *dev, char **envp, int nr_env, char *buf, int bufsz) +static int amba_hotplug(struct device *dev, char **envp, int nr_env, char *buf, int bufsz) { struct amba_device *pcdev = to_amba_device(dev); @@ -58,7 +58,7 @@ static int amba_uevent(struct device *dev, char **envp, int nr_env, char *buf, i return 0; } #else -#define amba_uevent NULL +#define amba_hotplug NULL #endif static int amba_suspend(struct device *dev, pm_message_t state) @@ -88,7 +88,7 @@ static int amba_resume(struct device *dev) static struct bus_type amba_bustype = { .name = "amba", .match = amba_match, - .uevent = amba_uevent, + .hotplug = amba_hotplug, .suspend = amba_suspend, .resume = amba_resume, }; diff --git a/trunk/arch/arm/mach-pxa/mainstone.c b/trunk/arch/arm/mach-pxa/mainstone.c index 277498ae5b6c..07892f4012d8 100644 --- a/trunk/arch/arm/mach-pxa/mainstone.c +++ b/trunk/arch/arm/mach-pxa/mainstone.c @@ -43,7 +43,6 @@ #include #include #include -#include #include "generic.h" @@ -394,25 +393,6 @@ static struct platform_device *platform_devices[] __initdata = { &mst_flash_device[1], }; -static int mainstone_ohci_init(struct device *dev) -{ - /* setup Port1 GPIO pin. */ - pxa_gpio_mode( 88 | GPIO_ALT_FN_1_IN); /* USBHPWR1 */ - pxa_gpio_mode( 89 | GPIO_ALT_FN_2_OUT); /* USBHPEN1 */ - - /* Set the Power Control Polarity Low and Power Sense - Polarity Low to active low. */ - UHCHR = (UHCHR | UHCHR_PCPL | UHCHR_PSPL) & - ~(UHCHR_SSEP1 | UHCHR_SSEP2 | UHCHR_SSEP3 | UHCHR_SSE); - - return 0; -} - -static struct pxaohci_platform_data mainstone_ohci_platform_data = { - .port_mode = PMM_PERPORT_MODE, - .init = mainstone_ohci_init, -}; - static void __init mainstone_init(void) { int SW7 = 0; /* FIXME: get from SCR (Mst doc section 3.2.1.1) */ @@ -444,7 +424,6 @@ static void __init mainstone_init(void) pxa_set_mci_info(&mainstone_mci_platform_data); pxa_set_ficp_info(&mainstone_ficp_platform_data); - pxa_set_ohci_info(&mainstone_ohci_platform_data); } diff --git a/trunk/arch/arm/mach-pxa/pxa27x.c b/trunk/arch/arm/mach-pxa/pxa27x.c index b41b1efaa2cf..c722a9a91fcc 100644 --- a/trunk/arch/arm/mach-pxa/pxa27x.c +++ b/trunk/arch/arm/mach-pxa/pxa27x.c @@ -21,7 +21,6 @@ #include #include #include -#include #include "generic.h" @@ -195,11 +194,6 @@ static struct platform_device ohci_device = { .resource = pxa27x_ohci_resources, }; -void __init pxa_set_ohci_info(struct pxaohci_platform_data *info) -{ - ohci_device.dev.platform_data = info; -} - static struct platform_device *devices[] __initdata = { &ohci_device, }; diff --git a/trunk/arch/arm26/nwfpe/fpmodule.c b/trunk/arch/arm26/nwfpe/fpmodule.c index 5258c6096fb9..528fa710aa34 100644 --- a/trunk/arch/arm26/nwfpe/fpmodule.c +++ b/trunk/arch/arm26/nwfpe/fpmodule.c @@ -46,9 +46,10 @@ typedef struct task_struct* PTASK; #ifdef MODULE void fp_send_sig(unsigned long sig, PTASK p, int priv); - +#if LINUX_VERSION_CODE > 0x20115 MODULE_AUTHOR("Scott Bambrough "); MODULE_DESCRIPTION("NWFPE floating point emulator"); +#endif #else #define fp_send_sig send_sig diff --git a/trunk/arch/i386/kernel/cpu/cpufreq/cpufreq-nforce2.c b/trunk/arch/i386/kernel/cpu/cpufreq/cpufreq-nforce2.c index 2b62dee35c6c..04a405345203 100644 --- a/trunk/arch/i386/kernel/cpu/cpufreq/cpufreq-nforce2.c +++ b/trunk/arch/i386/kernel/cpu/cpufreq/cpufreq-nforce2.c @@ -177,10 +177,9 @@ static unsigned int nforce2_fsb_read(int bootfsb) */ static int nforce2_set_fsb(unsigned int fsb) { - u32 temp = 0; + u32 pll, temp = 0; unsigned int tfsb; int diff; - int pll = 0; if ((fsb > max_fsb) || (fsb < NFORCE2_MIN_FSB)) { printk(KERN_ERR "cpufreq: FSB %d is out of range!\n", fsb); diff --git a/trunk/arch/i386/kernel/cpu/cpufreq/powernow-k8.c b/trunk/arch/i386/kernel/cpu/cpufreq/powernow-k8.c index 0fbbd4c1072e..68a1fc87f4ca 100644 --- a/trunk/arch/i386/kernel/cpu/cpufreq/powernow-k8.c +++ b/trunk/arch/i386/kernel/cpu/cpufreq/powernow-k8.c @@ -45,7 +45,7 @@ #define PFX "powernow-k8: " #define BFX PFX "BIOS error: " -#define VERSION "version 1.60.0" +#define VERSION "version 1.50.4" #include "powernow-k8.h" /* serialize freq changes */ @@ -216,10 +216,10 @@ static int write_new_vid(struct powernow_k8_data *data, u32 vid) do { wrmsr(MSR_FIDVID_CTL, lo, STOP_GRANT_5NS); - if (i++ > 100) { - printk(KERN_ERR PFX "internal error - pending bit very stuck - no further pstate changes possible\n"); - return 1; - } + if (i++ > 100) { + printk(KERN_ERR PFX "internal error - pending bit very stuck - no further pstate changes possible\n"); + return 1; + } } while (query_current_values_with_pending_wait(data)); if (savefid != data->currfid) { @@ -336,7 +336,7 @@ static int core_voltage_pre_transition(struct powernow_k8_data *data, u32 reqvid /* Phase 2 - core frequency transition */ static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid) { - u32 vcoreqfid, vcocurrfid, vcofiddiff, fid_interval, savevid = data->currvid; + u32 vcoreqfid, vcocurrfid, vcofiddiff, savevid = data->currvid; if ((reqfid < HI_FID_TABLE_BOTTOM) && (data->currfid < HI_FID_TABLE_BOTTOM)) { printk(KERN_ERR PFX "ph2: illegal lo-lo transition 0x%x 0x%x\n", @@ -359,11 +359,9 @@ static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid) : vcoreqfid - vcocurrfid; while (vcofiddiff > 2) { - (data->currfid & 1) ? (fid_interval = 1) : (fid_interval = 2); - if (reqfid > data->currfid) { if (data->currfid > LO_FID_TABLE_TOP) { - if (write_new_fid(data, data->currfid + fid_interval)) { + if (write_new_fid(data, data->currfid + 2)) { return 1; } } else { @@ -373,7 +371,7 @@ static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid) } } } else { - if (write_new_fid(data, data->currfid - fid_interval)) + if (write_new_fid(data, data->currfid - 2)) return 1; } @@ -466,7 +464,7 @@ static int check_supported_cpu(unsigned int cpu) set_cpus_allowed(current, cpumask_of_cpu(cpu)); if (smp_processor_id() != cpu) { - printk(KERN_ERR PFX "limiting to cpu %u failed\n", cpu); + printk(KERN_ERR "limiting to cpu %u failed\n", cpu); goto out; } @@ -476,7 +474,7 @@ static int check_supported_cpu(unsigned int cpu) eax = cpuid_eax(CPUID_PROCESSOR_SIGNATURE); if (((eax & CPUID_USE_XFAM_XMOD) != CPUID_USE_XFAM_XMOD) || ((eax & CPUID_XFAM) != CPUID_XFAM_K8) || - ((eax & CPUID_XMOD) > CPUID_XMOD_REV_G)) { + ((eax & CPUID_XMOD) > CPUID_XMOD_REV_F)) { printk(KERN_INFO PFX "Processor cpuid %x not supported\n", eax); goto out; } @@ -519,24 +517,22 @@ static int check_pst_table(struct powernow_k8_data *data, struct pst_s *pst, u8 printk(KERN_ERR BFX "maxvid exceeded with pstate %d\n", j); return -ENODEV; } - if (pst[j].fid > MAX_FID) { - printk(KERN_ERR BFX "maxfid exceeded with pstate %d\n", j); - return -ENODEV; - } - if (j && (pst[j].fid < HI_FID_TABLE_BOTTOM)) { + if ((pst[j].fid > MAX_FID) + || (pst[j].fid & 1) + || (j && (pst[j].fid < HI_FID_TABLE_BOTTOM))) { /* Only first fid is allowed to be in "low" range */ - printk(KERN_ERR BFX "two low fids - %d : 0x%x\n", j, pst[j].fid); + printk(KERN_ERR PFX "two low fids - %d : 0x%x\n", j, pst[j].fid); return -EINVAL; } if (pst[j].fid < lastfid) lastfid = pst[j].fid; } if (lastfid & 1) { - printk(KERN_ERR BFX "lastfid invalid\n"); + printk(KERN_ERR PFX "lastfid invalid\n"); return -EINVAL; } if (lastfid > LO_FID_TABLE_TOP) - printk(KERN_INFO BFX "first fid not from lo freq table\n"); + printk(KERN_INFO PFX "first fid not from lo freq table\n"); return 0; } @@ -635,7 +631,7 @@ static int find_psb_table(struct powernow_k8_data *data) dprintk("table vers: 0x%x\n", psb->tableversion); if (psb->tableversion != PSB_VERSION_1_4) { - printk(KERN_ERR BFX "PSB table is not v1.4\n"); + printk(KERN_INFO BFX "PSB table is not v1.4\n"); return -ENODEV; } @@ -693,7 +689,7 @@ static int find_psb_table(struct powernow_k8_data *data) * BIOS and Kernel Developer's Guide, which is available on * www.amd.com */ - printk(KERN_ERR PFX "BIOS error - no PSB or ACPI _PSS objects\n"); + printk(KERN_INFO PFX "BIOS error - no PSB or ACPI _PSS objects\n"); return -ENODEV; } @@ -916,7 +912,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi set_cpus_allowed(current, cpumask_of_cpu(pol->cpu)); if (smp_processor_id() != pol->cpu) { - printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu); + printk(KERN_ERR "limiting to cpu %u failed\n", pol->cpu); goto err_out; } @@ -986,9 +982,6 @@ static int __init powernowk8_cpu_init(struct cpufreq_policy *pol) cpumask_t oldmask = CPU_MASK_ALL; int rc, i; - if (!cpu_online(pol->cpu)) - return -ENODEV; - if (!check_supported_cpu(pol->cpu)) return -ENODEV; @@ -1028,7 +1021,7 @@ static int __init powernowk8_cpu_init(struct cpufreq_policy *pol) set_cpus_allowed(current, cpumask_of_cpu(pol->cpu)); if (smp_processor_id() != pol->cpu) { - printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu); + printk(KERN_ERR "limiting to cpu %u failed\n", pol->cpu); goto err_out; } @@ -1169,9 +1162,10 @@ static void __exit powernowk8_exit(void) cpufreq_unregister_driver(&cpufreq_amd64_driver); } -MODULE_AUTHOR("Paul Devriendt and Mark Langsdorf "); +MODULE_AUTHOR("Paul Devriendt and Mark Langsdorf = interprocessor hypertransport link speed * (only applies to MP systems obviously) */ /* fids (frequency identifiers) are arranged in 2 tables - lo and hi */ -#define LO_FID_TABLE_TOP 7 /* fid values marking the boundary */ +#define LO_FID_TABLE_TOP 6 /* fid values marking the boundary */ #define HI_FID_TABLE_BOTTOM 8 /* between the low and high tables */ #define LO_VCOFREQ_TABLE_TOP 1400 /* corresponding vco frequency values */ @@ -107,7 +106,7 @@ struct powernow_k8_data { #define MIN_FREQ 800 /* Min and max freqs, per spec */ #define MAX_FREQ 5000 -#define INVALID_FID_MASK 0xffffffc0 /* not a valid fid if these bits are set */ +#define INVALID_FID_MASK 0xffffffc1 /* not a valid fid if these bits are set */ #define INVALID_VID_MASK 0xffffffc0 /* not a valid vid if these bits are set */ #define VID_OFF 0x3f diff --git a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-ich.c b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-ich.c index b425cd3d1838..5b7d18a06afa 100644 --- a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-ich.c +++ b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-ich.c @@ -40,7 +40,6 @@ static struct pci_dev *speedstep_chipset_dev; */ static unsigned int speedstep_processor = 0; -static u32 pmbase; /* * There are only two frequency states for each processor. Values @@ -57,46 +56,33 @@ static struct cpufreq_frequency_table speedstep_freqs[] = { /** - * speedstep_find_register - read the PMBASE address + * speedstep_set_state - set the SpeedStep state + * @state: new processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH) * - * Returns: -ENODEV if no register could be found + * Tries to change the SpeedStep state. */ -static int speedstep_find_register (void) +static void speedstep_set_state (unsigned int state) { - if (!speedstep_chipset_dev) - return -ENODEV; + u32 pmbase; + u8 pm2_blk; + u8 value; + unsigned long flags; + + if (!speedstep_chipset_dev || (state > 0x1)) + return; /* get PMBASE */ pci_read_config_dword(speedstep_chipset_dev, 0x40, &pmbase); if (!(pmbase & 0x01)) { printk(KERN_ERR "speedstep-ich: could not find speedstep register\n"); - return -ENODEV; + return; } pmbase &= 0xFFFFFFFE; if (!pmbase) { printk(KERN_ERR "speedstep-ich: could not find speedstep register\n"); - return -ENODEV; - } - - dprintk("pmbase is 0x%x\n", pmbase); - return 0; -} - -/** - * speedstep_set_state - set the SpeedStep state - * @state: new processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH) - * - * Tries to change the SpeedStep state. - */ -static void speedstep_set_state (unsigned int state) -{ - u8 pm2_blk; - u8 value; - unsigned long flags; - - if (state > 0x1) return; + } /* Disable IRQs */ local_irq_save(flags); @@ -329,11 +315,10 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy) cpus_allowed = current->cpus_allowed; set_cpus_allowed(current, policy->cpus); - /* detect low and high frequency and transition latency */ + /* detect low and high frequency */ result = speedstep_get_freqs(speedstep_processor, &speedstep_freqs[SPEEDSTEP_LOW].frequency, &speedstep_freqs[SPEEDSTEP_HIGH].frequency, - &policy->cpuinfo.transition_latency, &speedstep_set_state); set_cpus_allowed(current, cpus_allowed); if (result) @@ -350,6 +335,7 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy) /* cpuinfo and default policy values */ policy->governor = CPUFREQ_DEFAULT_GOVERNOR; + policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; policy->cur = speed; result = cpufreq_frequency_table_cpuinfo(policy, speedstep_freqs); @@ -414,9 +400,6 @@ static int __init speedstep_init(void) return -EINVAL; } - if (speedstep_find_register()) - return -ENODEV; - return cpufreq_register_driver(&speedstep_driver); } diff --git a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c index 7c47005a1805..d368b3f5fce8 100644 --- a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c +++ b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.c @@ -320,13 +320,11 @@ EXPORT_SYMBOL_GPL(speedstep_detect_processor); unsigned int speedstep_get_freqs(unsigned int processor, unsigned int *low_speed, unsigned int *high_speed, - unsigned int *transition_latency, void (*set_state) (unsigned int state)) { unsigned int prev_speed; unsigned int ret = 0; unsigned long flags; - struct timeval tv1, tv2; if ((!processor) || (!low_speed) || (!high_speed) || (!set_state)) return -EINVAL; @@ -339,7 +337,7 @@ unsigned int speedstep_get_freqs(unsigned int processor, return -EIO; dprintk("previous speed is %u\n", prev_speed); - + local_irq_save(flags); /* switch to low state */ @@ -352,17 +350,8 @@ unsigned int speedstep_get_freqs(unsigned int processor, dprintk("low speed is %u\n", *low_speed); - /* start latency measurement */ - if (transition_latency) - do_gettimeofday(&tv1); - /* switch to high state */ set_state(SPEEDSTEP_HIGH); - - /* end latency measurement */ - if (transition_latency) - do_gettimeofday(&tv2); - *high_speed = speedstep_get_processor_frequency(processor); if (!*high_speed) { ret = -EIO; @@ -380,25 +369,6 @@ unsigned int speedstep_get_freqs(unsigned int processor, if (*high_speed != prev_speed) set_state(SPEEDSTEP_LOW); - if (transition_latency) { - *transition_latency = (tv2.tv_sec - tv1.tv_sec) * USEC_PER_SEC + - tv2.tv_usec - tv1.tv_usec; - dprintk("transition latency is %u uSec\n", *transition_latency); - - /* convert uSec to nSec and add 20% for safety reasons */ - *transition_latency *= 1200; - - /* check if the latency measurement is too high or too low - * and set it to a safe value (500uSec) in that case - */ - if (*transition_latency > 10000000 || *transition_latency < 50000) { - printk (KERN_WARNING "speedstep: frequency transition measured seems out of " - "range (%u nSec), falling back to a safe one of %u nSec.\n", - *transition_latency, 500000); - *transition_latency = 500000; - } - } - out: local_irq_restore(flags); return (ret); diff --git a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h index 6a727fd3a77e..261a2c9b7f6b 100644 --- a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h +++ b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-lib.h @@ -44,5 +44,4 @@ extern unsigned int speedstep_get_processor_frequency(unsigned int processor); extern unsigned int speedstep_get_freqs(unsigned int processor, unsigned int *low_speed, unsigned int *high_speed, - unsigned int *transition_latency, void (*set_state) (unsigned int state)); diff --git a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c index 28cc5d524afc..2718fb6f6aba 100644 --- a/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c +++ b/trunk/arch/i386/kernel/cpu/cpufreq/speedstep-smi.c @@ -269,7 +269,6 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy) result = speedstep_get_freqs(speedstep_processor, &speedstep_freqs[SPEEDSTEP_LOW].frequency, &speedstep_freqs[SPEEDSTEP_HIGH].frequency, - NULL, &speedstep_set_state); if (result) { diff --git a/trunk/arch/i386/kernel/cpu/proc.c b/trunk/arch/i386/kernel/cpu/proc.c index 6d91b274589c..e7921315ae9d 100644 --- a/trunk/arch/i386/kernel/cpu/proc.c +++ b/trunk/arch/i386/kernel/cpu/proc.c @@ -3,7 +3,6 @@ #include #include #include -#include /* * Get CPU information for use by the procfs. @@ -87,11 +86,8 @@ static int show_cpuinfo(struct seq_file *m, void *v) seq_printf(m, "stepping\t: unknown\n"); if ( cpu_has(c, X86_FEATURE_TSC) ) { - unsigned int freq = cpufreq_quick_get(n); - if (!freq) - freq = cpu_khz; seq_printf(m, "cpu MHz\t\t: %u.%03u\n", - freq / 1000, (freq % 1000)); + cpu_khz / 1000, (cpu_khz % 1000)); } /* Cache size */ diff --git a/trunk/arch/i386/kernel/traps.c b/trunk/arch/i386/kernel/traps.c index ab0e9430f775..f0dffa03fbba 100644 --- a/trunk/arch/i386/kernel/traps.c +++ b/trunk/arch/i386/kernel/traps.c @@ -452,7 +452,7 @@ DO_VM86_ERROR( 3, SIGTRAP, "int3", int3) #endif DO_VM86_ERROR( 4, SIGSEGV, "overflow", overflow) DO_VM86_ERROR( 5, SIGSEGV, "bounds", bounds) -DO_ERROR_INFO( 6, SIGILL, "invalid opcode", invalid_op, ILL_ILLOPN, regs->eip) +DO_ERROR_INFO( 6, SIGILL, "invalid operand", invalid_op, ILL_ILLOPN, regs->eip) DO_ERROR( 9, SIGFPE, "coprocessor segment overrun", coprocessor_segment_overrun) DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS) DO_ERROR(11, SIGBUS, "segment not present", segment_not_present) diff --git a/trunk/arch/ia64/kernel/setup.c b/trunk/arch/ia64/kernel/setup.c index c33305d8e5eb..5add0bcf87a7 100644 --- a/trunk/arch/ia64/kernel/setup.c +++ b/trunk/arch/ia64/kernel/setup.c @@ -43,7 +43,6 @@ #include #include #include -#include #include #include @@ -518,7 +517,6 @@ show_cpuinfo (struct seq_file *m, void *v) char family[32], features[128], *cp, sep; struct cpuinfo_ia64 *c = v; unsigned long mask; - unsigned long proc_freq; int i; mask = c->features; @@ -551,10 +549,6 @@ show_cpuinfo (struct seq_file *m, void *v) sprintf(cp, " 0x%lx", mask); } - proc_freq = cpufreq_quick_get(cpunum); - if (!proc_freq) - proc_freq = c->proc_freq / 1000; - seq_printf(m, "processor : %d\n" "vendor : %s\n" @@ -571,7 +565,7 @@ show_cpuinfo (struct seq_file *m, void *v) "BogoMIPS : %lu.%02lu\n", cpunum, c->vendor, family, c->model, c->revision, c->archrev, features, c->ppn, c->number, - proc_freq / 1000, proc_freq % 1000, + c->proc_freq / 1000000, c->proc_freq % 1000000, c->itc_freq / 1000000, c->itc_freq % 1000000, lpj*HZ/500000, (lpj*HZ/5000) % 100); #ifdef CONFIG_SMP diff --git a/trunk/arch/ia64/pci/pci.c b/trunk/arch/ia64/pci/pci.c index 30dbc98bf0b3..20d76fae24e8 100644 --- a/trunk/arch/ia64/pci/pci.c +++ b/trunk/arch/ia64/pci/pci.c @@ -700,7 +700,7 @@ int ia64_pci_legacy_read(struct pci_bus *bus, u16 port, u32 *val, u8 size) */ int ia64_pci_legacy_write(struct pci_dev *bus, u16 port, u32 val, u8 size) { - int ret = size; + int ret = 0; switch (size) { case 1: diff --git a/trunk/arch/ia64/sn/kernel/tiocx.c b/trunk/arch/ia64/sn/kernel/tiocx.c index 768c21deb2e5..0d8592a745a7 100644 --- a/trunk/arch/ia64/sn/kernel/tiocx.c +++ b/trunk/arch/ia64/sn/kernel/tiocx.c @@ -65,7 +65,7 @@ static int tiocx_match(struct device *dev, struct device_driver *drv) } -static int tiocx_uevent(struct device *dev, char **envp, int num_envp, +static int tiocx_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { return -ENODEV; @@ -79,7 +79,7 @@ static void tiocx_bus_release(struct device *dev) struct bus_type tiocx_bus_type = { .name = "tiocx", .match = tiocx_match, - .uevent = tiocx_uevent, + .hotplug = tiocx_hotplug, }; /** diff --git a/trunk/arch/mips/kernel/linux32.c b/trunk/arch/mips/kernel/linux32.c index 60353f5acc48..330cf84d21fe 100644 --- a/trunk/arch/mips/kernel/linux32.c +++ b/trunk/arch/mips/kernel/linux32.c @@ -420,7 +420,7 @@ asmlinkage ssize_t sys32_pread(unsigned int fd, char * buf, goto out; pos = merge_64(a4, a5); ret = rw_verify_area(READ, file, &pos, count); - if (ret < 0) + if (ret) goto out; ret = -EINVAL; if (!file->f_op || !(read = file->f_op->read)) @@ -455,7 +455,7 @@ asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char * buf, goto out; pos = merge_64(a4, a5); ret = rw_verify_area(WRITE, file, &pos, count); - if (ret < 0) + if (ret) goto out; ret = -EINVAL; if (!file->f_op || !(write = file->f_op->write)) diff --git a/trunk/arch/powerpc/kernel/vio.c b/trunk/arch/powerpc/kernel/vio.c index 13c41495fe06..71a6addf9f7f 100644 --- a/trunk/arch/powerpc/kernel/vio.c +++ b/trunk/arch/powerpc/kernel/vio.c @@ -293,6 +293,6 @@ static int vio_hotplug(struct device *dev, char **envp, int num_envp, struct bus_type vio_bus_type = { .name = "vio", - .uevent = vio_hotplug, + .hotplug = vio_hotplug, .match = vio_bus_match, }; diff --git a/trunk/arch/x86_64/boot/.gitignore b/trunk/arch/x86_64/boot/.gitignore deleted file mode 100644 index 495f20c085de..000000000000 --- a/trunk/arch/x86_64/boot/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -bootsect -bzImage -setup diff --git a/trunk/arch/x86_64/boot/tools/.gitignore b/trunk/arch/x86_64/boot/tools/.gitignore deleted file mode 100644 index 378eac25d311..000000000000 --- a/trunk/arch/x86_64/boot/tools/.gitignore +++ /dev/null @@ -1 +0,0 @@ -build diff --git a/trunk/arch/x86_64/ia32/.gitignore b/trunk/arch/x86_64/ia32/.gitignore deleted file mode 100644 index 48ab174fe5f1..000000000000 --- a/trunk/arch/x86_64/ia32/.gitignore +++ /dev/null @@ -1 +0,0 @@ -vsyscall*.so diff --git a/trunk/arch/x86_64/kernel/setup.c b/trunk/arch/x86_64/kernel/setup.c index 64c4534b930c..750e01dcbdf4 100644 --- a/trunk/arch/x86_64/kernel/setup.c +++ b/trunk/arch/x86_64/kernel/setup.c @@ -42,7 +42,6 @@ #include #include #include -#include #include #include @@ -1257,11 +1256,8 @@ static int show_cpuinfo(struct seq_file *m, void *v) seq_printf(m, "stepping\t: unknown\n"); if (cpu_has(c,X86_FEATURE_TSC)) { - unsigned int freq = cpufreq_quick_get((unsigned)(c-cpu_data)); - if (!freq) - freq = cpu_khz; seq_printf(m, "cpu MHz\t\t: %u.%03u\n", - freq / 1000, (freq % 1000)); + cpu_khz / 1000, (cpu_khz % 1000)); } /* Cache size */ diff --git a/trunk/block/genhd.c b/trunk/block/genhd.c index f1ed83f3f083..f04609d553b8 100644 --- a/trunk/block/genhd.c +++ b/trunk/block/genhd.c @@ -358,7 +358,7 @@ static struct sysfs_ops disk_sysfs_ops = { static ssize_t disk_uevent_store(struct gendisk * disk, const char *buf, size_t count) { - kobject_uevent(&disk->kobj, KOBJ_ADD); + kobject_hotplug(&disk->kobj, KOBJ_ADD); return count; } static ssize_t disk_dev_read(struct gendisk * disk, char *page) @@ -455,14 +455,14 @@ static struct kobj_type ktype_block = { extern struct kobj_type ktype_part; -static int block_uevent_filter(struct kset *kset, struct kobject *kobj) +static int block_hotplug_filter(struct kset *kset, struct kobject *kobj) { struct kobj_type *ktype = get_ktype(kobj); return ((ktype == &ktype_block) || (ktype == &ktype_part)); } -static int block_uevent(struct kset *kset, struct kobject *kobj, char **envp, +static int block_hotplug(struct kset *kset, struct kobject *kobj, char **envp, int num_envp, char *buffer, int buffer_size) { struct kobj_type *ktype = get_ktype(kobj); @@ -474,40 +474,40 @@ static int block_uevent(struct kset *kset, struct kobject *kobj, char **envp, if (ktype == &ktype_block) { disk = container_of(kobj, struct gendisk, kobj); - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, - &length, "MINOR=%u", disk->first_minor); + add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, + &length, "MINOR=%u", disk->first_minor); } else if (ktype == &ktype_part) { disk = container_of(kobj->parent, struct gendisk, kobj); part = container_of(kobj, struct hd_struct, kobj); - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, - &length, "MINOR=%u", - disk->first_minor + part->partno); + add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, + &length, "MINOR=%u", + disk->first_minor + part->partno); } else return 0; - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, - "MAJOR=%u", disk->major); + add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &length, + "MAJOR=%u", disk->major); /* add physical device, backing this device */ physdev = disk->driverfs_dev; if (physdev) { char *path = kobject_get_path(&physdev->kobj, GFP_KERNEL); - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, - &length, "PHYSDEVPATH=%s", path); + add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, + &length, "PHYSDEVPATH=%s", path); kfree(path); if (physdev->bus) - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PHYSDEVBUS=%s", - physdev->bus->name); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PHYSDEVBUS=%s", + physdev->bus->name); if (physdev->driver) - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PHYSDEVDRIVER=%s", - physdev->driver->name); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PHYSDEVDRIVER=%s", + physdev->driver->name); } /* terminate, set to next free slot, shrink available space */ @@ -520,13 +520,13 @@ static int block_uevent(struct kset *kset, struct kobject *kobj, char **envp, return 0; } -static struct kset_uevent_ops block_uevent_ops = { - .filter = block_uevent_filter, - .uevent = block_uevent, +static struct kset_hotplug_ops block_hotplug_ops = { + .filter = block_hotplug_filter, + .hotplug = block_hotplug, }; /* declare block_subsys. */ -static decl_subsys(block, &ktype_block, &block_uevent_ops); +static decl_subsys(block, &ktype_block, &block_hotplug_ops); /* diff --git a/trunk/block/ll_rw_blk.c b/trunk/block/ll_rw_blk.c index d4beb9a89ee0..99c9ca6d5992 100644 --- a/trunk/block/ll_rw_blk.c +++ b/trunk/block/ll_rw_blk.c @@ -239,7 +239,7 @@ void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn) q->backing_dev_info.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE; q->backing_dev_info.state = 0; q->backing_dev_info.capabilities = BDI_CAP_MAP_COPY; - blk_queue_max_sectors(q, SAFE_MAX_SECTORS); + blk_queue_max_sectors(q, MAX_SECTORS); blk_queue_hardsect_size(q, 512); blk_queue_dma_alignment(q, 511); blk_queue_congestion_threshold(q); @@ -555,12 +555,7 @@ void blk_queue_max_sectors(request_queue_t *q, unsigned short max_sectors) printk("%s: set to minimum %d\n", __FUNCTION__, max_sectors); } - if (BLK_DEF_MAX_SECTORS > max_sectors) - q->max_hw_sectors = q->max_sectors = max_sectors; - else { - q->max_sectors = BLK_DEF_MAX_SECTORS; - q->max_hw_sectors = max_sectors; - } + q->max_sectors = q->max_hw_sectors = max_sectors; } EXPORT_SYMBOL(blk_queue_max_sectors); @@ -662,8 +657,8 @@ EXPORT_SYMBOL(blk_queue_hardsect_size); void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b) { /* zero is "infinity" */ - t->max_sectors = min_not_zero(t->max_sectors,b->max_sectors); - t->max_hw_sectors = min_not_zero(t->max_hw_sectors,b->max_hw_sectors); + t->max_sectors = t->max_hw_sectors = + min_not_zero(t->max_sectors,b->max_sectors); t->max_phys_segments = min(t->max_phys_segments,b->max_phys_segments); t->max_hw_segments = min(t->max_hw_segments,b->max_hw_segments); @@ -1298,15 +1293,9 @@ static inline int ll_new_hw_segment(request_queue_t *q, static int ll_back_merge_fn(request_queue_t *q, struct request *req, struct bio *bio) { - unsigned short max_sectors; int len; - if (unlikely(blk_pc_request(req))) - max_sectors = q->max_hw_sectors; - else - max_sectors = q->max_sectors; - - if (req->nr_sectors + bio_sectors(bio) > max_sectors) { + if (req->nr_sectors + bio_sectors(bio) > q->max_sectors) { req->flags |= REQ_NOMERGE; if (req == q->last_merge) q->last_merge = NULL; @@ -1336,16 +1325,9 @@ static int ll_back_merge_fn(request_queue_t *q, struct request *req, static int ll_front_merge_fn(request_queue_t *q, struct request *req, struct bio *bio) { - unsigned short max_sectors; int len; - if (unlikely(blk_pc_request(req))) - max_sectors = q->max_hw_sectors; - else - max_sectors = q->max_sectors; - - - if (req->nr_sectors + bio_sectors(bio) > max_sectors) { + if (req->nr_sectors + bio_sectors(bio) > q->max_sectors) { req->flags |= REQ_NOMERGE; if (req == q->last_merge) q->last_merge = NULL; @@ -2162,7 +2144,7 @@ int blk_rq_map_user(request_queue_t *q, struct request *rq, void __user *ubuf, struct bio *bio; int reading; - if (len > (q->max_hw_sectors << 9)) + if (len > (q->max_sectors << 9)) return -EINVAL; if (!len || !ubuf) return -EINVAL; @@ -2277,7 +2259,7 @@ int blk_rq_map_kern(request_queue_t *q, struct request *rq, void *kbuf, { struct bio *bio; - if (len > (q->max_hw_sectors << 9)) + if (len > (q->max_sectors << 9)) return -EINVAL; if (!len || !kbuf) return -EINVAL; @@ -2324,8 +2306,6 @@ void blk_execute_rq_nowait(request_queue_t *q, struct gendisk *bd_disk, generic_unplug_device(q); } -EXPORT_SYMBOL_GPL(blk_execute_rq_nowait); - /** * blk_execute_rq - insert a request into queue for execution * @q: queue to insert the request in @@ -2464,7 +2444,7 @@ void disk_round_stats(struct gendisk *disk) /* * queue lock must be held */ -void __blk_put_request(request_queue_t *q, struct request *req) +static void __blk_put_request(request_queue_t *q, struct request *req) { struct request_list *rl = req->rl; @@ -2493,8 +2473,6 @@ void __blk_put_request(request_queue_t *q, struct request *req) } } -EXPORT_SYMBOL_GPL(__blk_put_request); - void blk_put_request(struct request *req) { unsigned long flags; diff --git a/trunk/block/scsi_ioctl.c b/trunk/block/scsi_ioctl.c index 1d8852f7bbff..6e7db2e79f42 100644 --- a/trunk/block/scsi_ioctl.c +++ b/trunk/block/scsi_ioctl.c @@ -233,7 +233,7 @@ static int sg_io(struct file *file, request_queue_t *q, if (verify_command(file, cmd)) return -EPERM; - if (hdr->dxfer_len > (q->max_hw_sectors << 9)) + if (hdr->dxfer_len > (q->max_sectors << 9)) return -EIO; if (hdr->dxfer_len) diff --git a/trunk/drivers/acpi/container.c b/trunk/drivers/acpi/container.c index b69a8cad82b7..27ec12c1fab0 100644 --- a/trunk/drivers/acpi/container.c +++ b/trunk/drivers/acpi/container.c @@ -172,21 +172,21 @@ static void container_notify_cb(acpi_handle handle, u32 type, void *context) if (ACPI_FAILURE(status) || !device) { result = container_device_add(&device, handle); if (!result) - kobject_uevent(&device->kobj, - KOBJ_ONLINE); + kobject_hotplug(&device->kobj, + KOBJ_ONLINE); else printk("Failed to add container\n"); } } else { if (ACPI_SUCCESS(status)) { /* device exist and this is a remove request */ - kobject_uevent(&device->kobj, KOBJ_OFFLINE); + kobject_hotplug(&device->kobj, KOBJ_OFFLINE); } } break; case ACPI_NOTIFY_EJECT_REQUEST: if (!acpi_bus_get_device(handle, &device) && device) { - kobject_uevent(&device->kobj, KOBJ_OFFLINE); + kobject_hotplug(&device->kobj, KOBJ_OFFLINE); } break; default: diff --git a/trunk/drivers/acpi/processor_core.c b/trunk/drivers/acpi/processor_core.c index 1278aca96fe3..0c561c571f29 100644 --- a/trunk/drivers/acpi/processor_core.c +++ b/trunk/drivers/acpi/processor_core.c @@ -748,7 +748,7 @@ int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device) return_VALUE(-ENODEV); if ((pr->id >= 0) && (pr->id < NR_CPUS)) { - kobject_uevent(&(*device)->kobj, KOBJ_ONLINE); + kobject_hotplug(&(*device)->kobj, KOBJ_ONLINE); } return_VALUE(0); } @@ -788,13 +788,13 @@ acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data) } if (pr->id >= 0 && (pr->id < NR_CPUS)) { - kobject_uevent(&device->kobj, KOBJ_OFFLINE); + kobject_hotplug(&device->kobj, KOBJ_OFFLINE); break; } result = acpi_processor_start(device); if ((!result) && ((pr->id >= 0) && (pr->id < NR_CPUS))) { - kobject_uevent(&device->kobj, KOBJ_ONLINE); + kobject_hotplug(&device->kobj, KOBJ_ONLINE); } else { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Device [%s] failed to start\n", @@ -818,7 +818,7 @@ acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data) } if ((pr->id < NR_CPUS) && (cpu_present(pr->id))) - kobject_uevent(&device->kobj, KOBJ_OFFLINE); + kobject_hotplug(&device->kobj, KOBJ_OFFLINE); break; default: ACPI_DEBUG_PRINT((ACPI_DB_INFO, diff --git a/trunk/drivers/acpi/scan.c b/trunk/drivers/acpi/scan.c index 0745d20afb8c..31218e1d2a18 100644 --- a/trunk/drivers/acpi/scan.c +++ b/trunk/drivers/acpi/scan.c @@ -78,7 +78,7 @@ static struct kobj_type ktype_acpi_ns = { .release = acpi_device_release, }; -static int namespace_uevent(struct kset *kset, struct kobject *kobj, +static int namespace_hotplug(struct kset *kset, struct kobject *kobj, char **envp, int num_envp, char *buffer, int buffer_size) { @@ -89,8 +89,8 @@ static int namespace_uevent(struct kset *kset, struct kobject *kobj, if (!dev->driver) return 0; - if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len, - "PHYSDEVDRIVER=%s", dev->driver->name)) + if (add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &len, + "PHYSDEVDRIVER=%s", dev->driver->name)) return -ENOMEM; envp[i] = NULL; @@ -98,8 +98,8 @@ static int namespace_uevent(struct kset *kset, struct kobject *kobj, return 0; } -static struct kset_uevent_ops namespace_uevent_ops = { - .uevent = &namespace_uevent, +static struct kset_hotplug_ops namespace_hotplug_ops = { + .hotplug = &namespace_hotplug, }; static struct kset acpi_namespace_kset = { @@ -108,7 +108,7 @@ static struct kset acpi_namespace_kset = { }, .subsys = &acpi_subsys, .ktype = &ktype_acpi_ns, - .uevent_ops = &namespace_uevent_ops, + .hotplug_ops = &namespace_hotplug_ops, }; static void acpi_device_register(struct acpi_device *device, @@ -347,7 +347,7 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device) } /* -------------------------------------------------------------------------- - ACPI sysfs device file support + ACPI hotplug sysfs device file support -------------------------------------------------------------------------- */ static ssize_t acpi_eject_store(struct acpi_device *device, const char *buf, size_t count); diff --git a/trunk/drivers/base/Kconfig b/trunk/drivers/base/Kconfig index f0eff3dac58d..934149c1512b 100644 --- a/trunk/drivers/base/Kconfig +++ b/trunk/drivers/base/Kconfig @@ -19,11 +19,11 @@ config PREVENT_FIRMWARE_BUILD If unsure say Y here. config FW_LOADER - tristate "Userspace firmware loading support" + tristate "Hotplug firmware loading support" select HOTPLUG ---help--- This option is provided for the case where no in-kernel-tree modules - require userspace firmware loading support, but a module built outside + require hotplug firmware loading support, but a module built outside the kernel tree does. config DEBUG_DRIVER diff --git a/trunk/drivers/base/bus.c b/trunk/drivers/base/bus.c index 29f6af554e71..fa601b085eba 100644 --- a/trunk/drivers/base/bus.c +++ b/trunk/drivers/base/bus.c @@ -152,11 +152,7 @@ static ssize_t driver_unbind(struct device_driver *drv, dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); if (dev && dev->driver == drv) { - if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); device_release_driver(dev); - if (dev->parent) - up(&dev->parent->sem); err = count; } put_device(dev); @@ -179,13 +175,9 @@ static ssize_t driver_bind(struct device_driver *drv, dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); if (dev && dev->driver == NULL) { - if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); down(&dev->sem); err = driver_probe_device(drv, dev); up(&dev->sem); - if (dev->parent) - up(&dev->parent->sem); } put_device(dev); put_bus(bus); @@ -428,26 +420,6 @@ static void driver_remove_attrs(struct bus_type * bus, struct device_driver * dr } } -#ifdef CONFIG_HOTPLUG -/* - * Thanks to drivers making their tables __devinit, we can't allow manual - * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled. - */ -static void add_bind_files(struct device_driver *drv) -{ - driver_create_file(drv, &driver_attr_unbind); - driver_create_file(drv, &driver_attr_bind); -} - -static void remove_bind_files(struct device_driver *drv) -{ - driver_remove_file(drv, &driver_attr_bind); - driver_remove_file(drv, &driver_attr_unbind); -} -#else -static inline void add_bind_files(struct device_driver *drv) {} -static inline void remove_bind_files(struct device_driver *drv) {} -#endif /** * bus_add_driver - Add a driver to the bus. @@ -477,7 +449,8 @@ int bus_add_driver(struct device_driver * drv) module_add_driver(drv->owner, drv); driver_add_attrs(bus, drv); - add_bind_files(drv); + driver_create_file(drv, &driver_attr_unbind); + driver_create_file(drv, &driver_attr_bind); } return error; } @@ -495,7 +468,8 @@ int bus_add_driver(struct device_driver * drv) void bus_remove_driver(struct device_driver * drv) { if (drv->bus) { - remove_bind_files(drv); + driver_remove_file(drv, &driver_attr_bind); + driver_remove_file(drv, &driver_attr_unbind); driver_remove_attrs(drv->bus, drv); klist_remove(&drv->knode_bus); pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name); @@ -510,13 +484,8 @@ void bus_remove_driver(struct device_driver * drv) /* Helper for bus_rescan_devices's iter */ static int bus_rescan_devices_helper(struct device *dev, void *data) { - if (!dev->driver) { - if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); + if (!dev->driver) device_attach(dev); - if (dev->parent) - up(&dev->parent->sem); - } return 0; } diff --git a/trunk/drivers/base/class.c b/trunk/drivers/base/class.c index df7fdabd0730..db65fd0babe9 100644 --- a/trunk/drivers/base/class.c +++ b/trunk/drivers/base/class.c @@ -178,7 +178,7 @@ static void class_device_create_release(struct class_device *class_dev) } /* needed to allow these devices to have parent class devices */ -static int class_device_create_uevent(struct class_device *class_dev, +static int class_device_create_hotplug(struct class_device *class_dev, char **envp, int num_envp, char *buffer, int buffer_size) { @@ -331,7 +331,7 @@ static struct kobj_type ktype_class_device = { .release = class_dev_release, }; -static int class_uevent_filter(struct kset *kset, struct kobject *kobj) +static int class_hotplug_filter(struct kset *kset, struct kobject *kobj) { struct kobj_type *ktype = get_ktype(kobj); @@ -343,14 +343,14 @@ static int class_uevent_filter(struct kset *kset, struct kobject *kobj) return 0; } -static const char *class_uevent_name(struct kset *kset, struct kobject *kobj) +static const char *class_hotplug_name(struct kset *kset, struct kobject *kobj) { struct class_device *class_dev = to_class_dev(kobj); return class_dev->class->name; } -static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp, +static int class_hotplug(struct kset *kset, struct kobject *kobj, char **envp, int num_envp, char *buffer, int buffer_size) { struct class_device *class_dev = to_class_dev(kobj); @@ -365,29 +365,29 @@ static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp, struct device *dev = class_dev->dev; char *path = kobject_get_path(&dev->kobj, GFP_KERNEL); - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, - &length, "PHYSDEVPATH=%s", path); + add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, + &length, "PHYSDEVPATH=%s", path); kfree(path); if (dev->bus) - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PHYSDEVBUS=%s", dev->bus->name); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PHYSDEVBUS=%s", dev->bus->name); if (dev->driver) - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PHYSDEVDRIVER=%s", dev->driver->name); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PHYSDEVDRIVER=%s", dev->driver->name); } if (MAJOR(class_dev->devt)) { - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "MAJOR=%u", MAJOR(class_dev->devt)); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "MAJOR=%u", MAJOR(class_dev->devt)); - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "MINOR=%u", MINOR(class_dev->devt)); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "MINOR=%u", MINOR(class_dev->devt)); } /* terminate, set to next free slot, shrink available space */ @@ -397,30 +397,30 @@ static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp, buffer = &buffer[length]; buffer_size -= length; - if (class_dev->uevent) { + if (class_dev->hotplug) { /* have the class device specific function add its stuff */ - retval = class_dev->uevent(class_dev, envp, num_envp, + retval = class_dev->hotplug(class_dev, envp, num_envp, buffer, buffer_size); if (retval) - pr_debug("class_dev->uevent() returned %d\n", retval); - } else if (class_dev->class->uevent) { + pr_debug("class_dev->hotplug() returned %d\n", retval); + } else if (class_dev->class->hotplug) { /* have the class specific function add its stuff */ - retval = class_dev->class->uevent(class_dev, envp, num_envp, + retval = class_dev->class->hotplug(class_dev, envp, num_envp, buffer, buffer_size); if (retval) - pr_debug("class->uevent() returned %d\n", retval); + pr_debug("class->hotplug() returned %d\n", retval); } return retval; } -static struct kset_uevent_ops class_uevent_ops = { - .filter = class_uevent_filter, - .name = class_uevent_name, - .uevent = class_uevent, +static struct kset_hotplug_ops class_hotplug_ops = { + .filter = class_hotplug_filter, + .name = class_hotplug_name, + .hotplug = class_hotplug, }; -static decl_subsys(class_obj, &ktype_class_device, &class_uevent_ops); +static decl_subsys(class_obj, &ktype_class_device, &class_hotplug_ops); static int class_device_add_attrs(struct class_device * cd) @@ -464,7 +464,7 @@ static ssize_t show_dev(struct class_device *class_dev, char *buf) static ssize_t store_uevent(struct class_device *class_dev, const char *buf, size_t count) { - kobject_uevent(&class_dev->kobj, KOBJ_ADD); + kobject_hotplug(&class_dev->kobj, KOBJ_ADD); return count; } @@ -559,7 +559,7 @@ int class_device_add(struct class_device *class_dev) class_name); } - kobject_uevent(&class_dev->kobj, KOBJ_ADD); + kobject_hotplug(&class_dev->kobj, KOBJ_ADD); /* notify any interfaces this device is now here */ if (parent_class) { @@ -632,7 +632,7 @@ struct class_device *class_device_create(struct class *cls, class_dev->class = cls; class_dev->parent = parent; class_dev->release = class_device_create_release; - class_dev->uevent = class_device_create_uevent; + class_dev->hotplug = class_device_create_hotplug; va_start(args, fmt); vsnprintf(class_dev->class_id, BUS_ID_SIZE, fmt, args); @@ -674,7 +674,7 @@ void class_device_del(struct class_device *class_dev) class_device_remove_file(class_dev, class_dev->devt_attr); class_device_remove_attrs(class_dev); - kobject_uevent(&class_dev->kobj, KOBJ_REMOVE); + kobject_hotplug(&class_dev->kobj, KOBJ_REMOVE); kobject_del(&class_dev->kobj); class_device_put(parent_device); diff --git a/trunk/drivers/base/core.c b/trunk/drivers/base/core.c index fd8059920dbf..8615b42b517a 100644 --- a/trunk/drivers/base/core.c +++ b/trunk/drivers/base/core.c @@ -90,7 +90,7 @@ static struct kobj_type ktype_device = { }; -static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) +static int dev_hotplug_filter(struct kset *kset, struct kobject *kobj) { struct kobj_type *ktype = get_ktype(kobj); @@ -102,14 +102,14 @@ static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) return 0; } -static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) +static const char *dev_hotplug_name(struct kset *kset, struct kobject *kobj) { struct device *dev = to_dev(kobj); return dev->bus->name; } -static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp, +static int dev_hotplug(struct kset *kset, struct kobject *kobj, char **envp, int num_envp, char *buffer, int buffer_size) { struct device *dev = to_dev(kobj); @@ -119,15 +119,15 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp, /* add bus name of physical device */ if (dev->bus) - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PHYSDEVBUS=%s", dev->bus->name); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PHYSDEVBUS=%s", dev->bus->name); /* add driver name of physical device */ if (dev->driver) - add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PHYSDEVDRIVER=%s", dev->driver->name); + add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PHYSDEVDRIVER=%s", dev->driver->name); /* terminate, set to next free slot, shrink available space */ envp[i] = NULL; @@ -136,11 +136,11 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp, buffer = &buffer[length]; buffer_size -= length; - if (dev->bus && dev->bus->uevent) { + if (dev->bus && dev->bus->hotplug) { /* have the bus specific function add its stuff */ - retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size); + retval = dev->bus->hotplug (dev, envp, num_envp, buffer, buffer_size); if (retval) { - pr_debug ("%s - uevent() returned %d\n", + pr_debug ("%s - hotplug() returned %d\n", __FUNCTION__, retval); } } @@ -148,16 +148,16 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp, return retval; } -static struct kset_uevent_ops device_uevent_ops = { - .filter = dev_uevent_filter, - .name = dev_uevent_name, - .uevent = dev_uevent, +static struct kset_hotplug_ops device_hotplug_ops = { + .filter = dev_hotplug_filter, + .name = dev_hotplug_name, + .hotplug = dev_hotplug, }; static ssize_t store_uevent(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { - kobject_uevent(&dev->kobj, KOBJ_ADD); + kobject_hotplug(&dev->kobj, KOBJ_ADD); return count; } @@ -165,7 +165,7 @@ static ssize_t store_uevent(struct device *dev, struct device_attribute *attr, * device_subsys - structure to be registered with kobject core. */ -decl_subsys(devices, &ktype_device, &device_uevent_ops); +decl_subsys(devices, &ktype_device, &device_hotplug_ops); /** @@ -274,7 +274,7 @@ int device_add(struct device *dev) dev->uevent_attr.store = store_uevent; device_create_file(dev, &dev->uevent_attr); - kobject_uevent(&dev->kobj, KOBJ_ADD); + kobject_hotplug(&dev->kobj, KOBJ_ADD); if ((error = device_pm_add(dev))) goto PMError; if ((error = bus_add_device(dev))) @@ -291,7 +291,7 @@ int device_add(struct device *dev) BusError: device_pm_remove(dev); PMError: - kobject_uevent(&dev->kobj, KOBJ_REMOVE); + kobject_hotplug(&dev->kobj, KOBJ_REMOVE); kobject_del(&dev->kobj); Error: if (parent) @@ -374,7 +374,7 @@ void device_del(struct device * dev) platform_notify_remove(dev); bus_remove_device(dev); device_pm_remove(dev); - kobject_uevent(&dev->kobj, KOBJ_REMOVE); + kobject_hotplug(&dev->kobj, KOBJ_REMOVE); kobject_del(&dev->kobj); if (parent) put_device(parent); diff --git a/trunk/drivers/base/cpu.c b/trunk/drivers/base/cpu.c index 281d26784d25..a95844790f7b 100644 --- a/trunk/drivers/base/cpu.c +++ b/trunk/drivers/base/cpu.c @@ -41,14 +41,14 @@ static ssize_t store_online(struct sys_device *dev, const char *buf, case '0': ret = cpu_down(cpu->sysdev.id); if (!ret) - kobject_uevent(&dev->kobj, KOBJ_OFFLINE); + kobject_hotplug(&dev->kobj, KOBJ_OFFLINE); break; case '1': ret = smp_prepare_cpu(cpu->sysdev.id); if (!ret) ret = cpu_up(cpu->sysdev.id); if (!ret) - kobject_uevent(&dev->kobj, KOBJ_ONLINE); + kobject_hotplug(&dev->kobj, KOBJ_ONLINE); break; default: ret = -EINVAL; diff --git a/trunk/drivers/base/dd.c b/trunk/drivers/base/dd.c index 2b905016664d..3b419c9a1e7e 100644 --- a/trunk/drivers/base/dd.c +++ b/trunk/drivers/base/dd.c @@ -65,8 +65,7 @@ void device_bind_driver(struct device * dev) * This function returns 1 if a match is found, an error if one * occurs (that is not -ENODEV or -ENXIO), and 0 otherwise. * - * This function must be called with @dev->sem held. When called - * for a USB interface, @dev->parent->sem must be held as well. + * This function must be called with @dev->sem held. */ int driver_probe_device(struct device_driver * drv, struct device * dev) { @@ -124,8 +123,6 @@ static int __device_attach(struct device_driver * drv, void * data) * * Returns 1 if the device was bound to a driver; * 0 if no matching device was found; error code otherwise. - * - * When called for a USB interface, @dev->parent->sem must be held. */ int device_attach(struct device * dev) { @@ -155,14 +152,10 @@ static int __driver_attach(struct device * dev, void * data) * is an error. */ - if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); down(&dev->sem); if (!dev->driver) driver_probe_device(drv, dev); up(&dev->sem); - if (dev->parent) - up(&dev->parent->sem); return 0; } @@ -188,8 +181,6 @@ void driver_attach(struct device_driver * drv) * Manually detach device from driver. * * __device_release_driver() must be called with @dev->sem held. - * When called for a USB interface, @dev->parent->sem must be held - * as well. */ static void __device_release_driver(struct device * dev) @@ -242,14 +233,10 @@ void driver_detach(struct device_driver * drv) get_device(dev); spin_unlock(&drv->klist_devices.k_lock); - if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); down(&dev->sem); if (dev->driver == drv) __device_release_driver(dev); up(&dev->sem); - if (dev->parent) - up(&dev->parent->sem); put_device(dev); } } diff --git a/trunk/drivers/base/firmware_class.c b/trunk/drivers/base/firmware_class.c index 5b3d5e9ddcb6..59dacb6552c0 100644 --- a/trunk/drivers/base/firmware_class.c +++ b/trunk/drivers/base/firmware_class.c @@ -85,17 +85,17 @@ firmware_timeout_store(struct class *class, const char *buf, size_t count) static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store); static void fw_class_dev_release(struct class_device *class_dev); -int firmware_class_uevent(struct class_device *dev, char **envp, +int firmware_class_hotplug(struct class_device *dev, char **envp, int num_envp, char *buffer, int buffer_size); static struct class firmware_class = { .name = "firmware", - .uevent = firmware_class_uevent, + .hotplug = firmware_class_hotplug, .release = fw_class_dev_release, }; int -firmware_class_uevent(struct class_device *class_dev, char **envp, +firmware_class_hotplug(struct class_device *class_dev, char **envp, int num_envp, char *buffer, int buffer_size) { struct firmware_priv *fw_priv = class_get_devdata(class_dev); @@ -104,12 +104,13 @@ firmware_class_uevent(struct class_device *class_dev, char **envp, if (!test_bit(FW_STATUS_READY, &fw_priv->status)) return -ENODEV; - if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len, - "FIRMWARE=%s", fw_priv->fw_id)) + if (add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &len, + "FIRMWARE=%s", fw_priv->fw_id)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len, - "TIMEOUT=%i", loading_timeout)) + if (add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &len, + "TIMEOUT=%i", loading_timeout)) return -ENOMEM; + envp[i] = NULL; return 0; @@ -351,7 +352,7 @@ fw_register_class_device(struct class_device **class_dev_p, static int fw_setup_class_device(struct firmware *fw, struct class_device **class_dev_p, - const char *fw_name, struct device *device, int uevent) + const char *fw_name, struct device *device, int hotplug) { struct class_device *class_dev; struct firmware_priv *fw_priv; @@ -383,7 +384,7 @@ fw_setup_class_device(struct firmware *fw, struct class_device **class_dev_p, goto error_unreg; } - if (uevent) + if (hotplug) set_bit(FW_STATUS_READY, &fw_priv->status); else set_bit(FW_STATUS_READY_NOHOTPLUG, &fw_priv->status); @@ -398,7 +399,7 @@ fw_setup_class_device(struct firmware *fw, struct class_device **class_dev_p, static int _request_firmware(const struct firmware **firmware_p, const char *name, - struct device *device, int uevent) + struct device *device, int hotplug) { struct class_device *class_dev; struct firmware_priv *fw_priv; @@ -417,19 +418,19 @@ _request_firmware(const struct firmware **firmware_p, const char *name, } retval = fw_setup_class_device(firmware, &class_dev, name, device, - uevent); + hotplug); if (retval) goto error_kfree_fw; fw_priv = class_get_devdata(class_dev); - if (uevent) { + if (hotplug) { if (loading_timeout > 0) { fw_priv->timeout.expires = jiffies + loading_timeout * HZ; add_timer(&fw_priv->timeout); } - kobject_uevent(&class_dev->kobj, KOBJ_ADD); + kobject_hotplug(&class_dev->kobj, KOBJ_ADD); wait_for_completion(&fw_priv->completion); set_bit(FW_STATUS_DONE, &fw_priv->status); del_timer_sync(&fw_priv->timeout); @@ -455,7 +456,7 @@ _request_firmware(const struct firmware **firmware_p, const char *name, } /** - * request_firmware: - send firmware request and wait for it + * request_firmware: - request firmware to hotplug and wait for it * @firmware_p: pointer to firmware image * @name: name of firmware file * @device: device for which firmware is being loaded @@ -465,7 +466,7 @@ _request_firmware(const struct firmware **firmware_p, const char *name, * * Should be called from user context where sleeping is allowed. * - * @name will be used as $FIRMWARE in the uevent environment and + * @name will be used as $FIRMWARE in the hotplug environment and * should be distinctive enough not to be confused with any other * firmware image for this or any other device. **/ @@ -473,8 +474,8 @@ int request_firmware(const struct firmware **firmware_p, const char *name, struct device *device) { - int uevent = 1; - return _request_firmware(firmware_p, name, device, uevent); + int hotplug = 1; + return _request_firmware(firmware_p, name, device, hotplug); } /** @@ -517,7 +518,7 @@ struct firmware_work { struct device *device; void *context; void (*cont)(const struct firmware *fw, void *context); - int uevent; + int hotplug; }; static int @@ -532,7 +533,7 @@ request_firmware_work_func(void *arg) } daemonize("%s/%s", "firmware", fw_work->name); ret = _request_firmware(&fw, fw_work->name, fw_work->device, - fw_work->uevent); + fw_work->hotplug); if (ret < 0) fw_work->cont(NULL, fw_work->context); else { @@ -547,7 +548,7 @@ request_firmware_work_func(void *arg) /** * request_firmware_nowait: asynchronous version of request_firmware * @module: module requesting the firmware - * @uevent: sends uevent to copy the firmware image if this flag + * @hotplug: invokes hotplug event to copy the firmware image if this flag * is non-zero else the firmware copy must be done manually. * @name: name of firmware file * @device: device for which firmware is being loaded @@ -561,7 +562,7 @@ request_firmware_work_func(void *arg) **/ int request_firmware_nowait( - struct module *module, int uevent, + struct module *module, int hotplug, const char *name, struct device *device, void *context, void (*cont)(const struct firmware *fw, void *context)) { @@ -582,7 +583,7 @@ request_firmware_nowait( .device = device, .context = context, .cont = cont, - .uevent = uevent, + .hotplug = hotplug, }; ret = kernel_thread(request_firmware_work_func, fw_work, diff --git a/trunk/drivers/base/memory.c b/trunk/drivers/base/memory.c index 7e1d077874df..bc3ca6a656b2 100644 --- a/trunk/drivers/base/memory.c +++ b/trunk/drivers/base/memory.c @@ -29,12 +29,12 @@ static struct sysdev_class memory_sysdev_class = { set_kset_name(MEMORY_CLASS_NAME), }; -static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj) +static char *memory_hotplug_name(struct kset *kset, struct kobject *kobj) { return MEMORY_CLASS_NAME; } -static int memory_uevent(struct kset *kset, struct kobject *kobj, char **envp, +static int memory_hotplug(struct kset *kset, struct kobject *kobj, char **envp, int num_envp, char *buffer, int buffer_size) { int retval = 0; @@ -42,9 +42,9 @@ static int memory_uevent(struct kset *kset, struct kobject *kobj, char **envp, return retval; } -static struct kset_uevent_ops memory_uevent_ops = { - .name = memory_uevent_name, - .uevent = memory_uevent, +static struct kset_hotplug_ops memory_hotplug_ops = { + .name = memory_hotplug_name, + .hotplug = memory_hotplug, }; static struct notifier_block *memory_chain; @@ -431,7 +431,7 @@ int __init memory_dev_init(void) unsigned int i; int ret; - memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops; + memory_sysdev_class.kset.hotplug_ops = &memory_hotplug_ops; ret = sysdev_class_register(&memory_sysdev_class); /* diff --git a/trunk/drivers/base/platform.c b/trunk/drivers/base/platform.c index 0f81731bdfa8..8827dafba945 100644 --- a/trunk/drivers/base/platform.c +++ b/trunk/drivers/base/platform.c @@ -25,7 +25,6 @@ struct device platform_bus = { .bus_id = "platform", }; -EXPORT_SYMBOL_GPL(platform_bus); /** * platform_get_resource - get a resource for a device @@ -50,7 +49,6 @@ platform_get_resource(struct platform_device *dev, unsigned int type, } return NULL; } -EXPORT_SYMBOL_GPL(platform_get_resource); /** * platform_get_irq - get an IRQ for a device @@ -63,7 +61,6 @@ int platform_get_irq(struct platform_device *dev, unsigned int num) return r ? r->start : 0; } -EXPORT_SYMBOL_GPL(platform_get_irq); /** * platform_get_resource_byname - get a resource for a device by name @@ -87,7 +84,6 @@ platform_get_resource_byname(struct platform_device *dev, unsigned int type, } return NULL; } -EXPORT_SYMBOL_GPL(platform_get_resource_byname); /** * platform_get_irq - get an IRQ for a device @@ -100,7 +96,6 @@ int platform_get_irq_byname(struct platform_device *dev, char *name) return r ? r->start : 0; } -EXPORT_SYMBOL_GPL(platform_get_irq_byname); /** * platform_add_devices - add a numbers of platform devices @@ -122,7 +117,6 @@ int platform_add_devices(struct platform_device **devs, int num) return ret; } -EXPORT_SYMBOL_GPL(platform_add_devices); struct platform_object { struct platform_device pdev; @@ -174,7 +168,7 @@ struct platform_device *platform_device_alloc(const char *name, unsigned int id) pa->pdev.dev.release = platform_device_release; } - return pa ? &pa->pdev : NULL; + return pa ? &pa->pdev : NULL; } EXPORT_SYMBOL_GPL(platform_device_alloc); @@ -263,7 +257,7 @@ int platform_device_add(struct platform_device *pdev) p = &ioport_resource; } - if (p && insert_resource(p, r)) { + if (p && request_resource(p, r)) { printk(KERN_ERR "%s: failed to claim resource %d\n", pdev->dev.bus_id, i); @@ -288,13 +282,24 @@ int platform_device_add(struct platform_device *pdev) EXPORT_SYMBOL_GPL(platform_device_add); /** - * platform_device_del - remove a platform-level device + * platform_device_register - add a platform-level device + * @pdev: platform device we're adding + * + */ +int platform_device_register(struct platform_device * pdev) +{ + device_initialize(&pdev->dev); + return platform_device_add(pdev); +} + +/** + * platform_device_unregister - remove a platform-level device * @pdev: platform device we're removing * * Note that this function will also release all memory- and port-based * resources owned by the device (@dev->resource). */ -void platform_device_del(struct platform_device *pdev) +void platform_device_unregister(struct platform_device * pdev) { int i; @@ -305,37 +310,9 @@ void platform_device_del(struct platform_device *pdev) release_resource(r); } - device_del(&pdev->dev); + device_unregister(&pdev->dev); } } -EXPORT_SYMBOL_GPL(platform_device_del); - -/** - * platform_device_register - add a platform-level device - * @pdev: platform device we're adding - * - */ -int platform_device_register(struct platform_device * pdev) -{ - device_initialize(&pdev->dev); - return platform_device_add(pdev); -} -EXPORT_SYMBOL_GPL(platform_device_register); - -/** - * platform_device_unregister - unregister a platform-level device - * @pdev: platform device we're unregistering - * - * Unregistration is done in 2 steps. Fisrt we release all resources - * and remove it from the sybsystem, then we drop reference count by - * calling platform_device_put(). - */ -void platform_device_unregister(struct platform_device * pdev) -{ - platform_device_del(pdev); - platform_device_put(pdev); -} -EXPORT_SYMBOL_GPL(platform_device_unregister); /** * platform_device_register_simple @@ -378,7 +355,6 @@ struct platform_device *platform_device_register_simple(char *name, unsigned int platform_device_put(pdev); return ERR_PTR(retval); } -EXPORT_SYMBOL_GPL(platform_device_register_simple); static int platform_drv_probe(struct device *_dev) { @@ -500,7 +476,6 @@ struct bus_type platform_bus_type = { .suspend = platform_suspend, .resume = platform_resume, }; -EXPORT_SYMBOL_GPL(platform_bus_type); int __init platform_bus_init(void) { @@ -529,3 +504,14 @@ u64 dma_get_required_mask(struct device *dev) } EXPORT_SYMBOL_GPL(dma_get_required_mask); #endif + +EXPORT_SYMBOL_GPL(platform_bus); +EXPORT_SYMBOL_GPL(platform_bus_type); +EXPORT_SYMBOL_GPL(platform_add_devices); +EXPORT_SYMBOL_GPL(platform_device_register); +EXPORT_SYMBOL_GPL(platform_device_register_simple); +EXPORT_SYMBOL_GPL(platform_device_unregister); +EXPORT_SYMBOL_GPL(platform_get_irq); +EXPORT_SYMBOL_GPL(platform_get_resource); +EXPORT_SYMBOL_GPL(platform_get_irq_byname); +EXPORT_SYMBOL_GPL(platform_get_resource_byname); diff --git a/trunk/drivers/base/power/runtime.c b/trunk/drivers/base/power/runtime.c index 96370ec1d673..adbc3148c039 100644 --- a/trunk/drivers/base/power/runtime.c +++ b/trunk/drivers/base/power/runtime.c @@ -62,10 +62,8 @@ int dpm_runtime_suspend(struct device * dev, pm_message_t state) up(&dpm_sem); return error; } -EXPORT_SYMBOL(dpm_runtime_suspend); -#if 0 /** * dpm_set_power_state - Update power_state field. * @dev: Device. @@ -82,4 +80,3 @@ void dpm_set_power_state(struct device * dev, pm_message_t state) dev->power.power_state = state; up(&dpm_sem); } -#endif /* 0 */ diff --git a/trunk/drivers/block/Kconfig b/trunk/drivers/block/Kconfig index c4b9d2adfc08..7b1cd93892be 100644 --- a/trunk/drivers/block/Kconfig +++ b/trunk/drivers/block/Kconfig @@ -358,8 +358,7 @@ config BLK_DEV_UB This driver supports certain USB attached storage devices such as flash keys. - If you enable this driver, it is recommended to avoid conflicts - with usb-storage by enabling USB_LIBUSUAL. + Warning: Enabling this cripples the usb-storage driver. If unsure, say N. diff --git a/trunk/drivers/block/ub.c b/trunk/drivers/block/ub.c index 10740a065088..bfb23d543ff7 100644 --- a/trunk/drivers/block/ub.c +++ b/trunk/drivers/block/ub.c @@ -9,6 +9,7 @@ * * TODO (sorted by decreasing priority) * -- Kill first_open (Al Viro fixed the block layer now) + * -- Do resets with usb_device_reset (needs a thread context, use khubd) * -- set readonly flag for CDs, set removable flag for CF readers * -- do inquiry and verify we got a disk and not a tape (for LUN mismatch) * -- special case some senses, e.g. 3a/0 -> no media present, reduce retries @@ -28,7 +29,6 @@ #include #include #include -#include #include #include #include @@ -106,6 +106,16 @@ * +--------+ */ +/* + * Definitions which have to be scattered once we understand the layout better. + */ + +/* Transport (despite PR in the name) */ +#define US_PR_BULK 0x50 /* bulk only */ + +/* Protocol */ +#define US_SC_SCSI 0x06 /* Transparent */ + /* * This many LUNs per USB device. * Every one of them takes a host, see UB_MAX_HOSTS. @@ -115,7 +125,7 @@ /* */ -#define UB_PARTS_PER_LUN 8 +#define UB_MINORS_PER_MAJOR 8 #define UB_MAX_CDB_SIZE 16 /* Corresponds to Bulk */ @@ -235,13 +245,6 @@ struct ub_scsi_cmd { void *back; }; -struct ub_request { - struct request *rq; - unsigned int current_try; - unsigned int nsg; /* sgv[nsg] */ - struct scatterlist sgv[UB_MAX_REQ_SG]; -}; - /* */ struct ub_capacity { @@ -337,8 +340,6 @@ struct ub_lun { int readonly; int first_open; /* Kludge. See ub_bd_open. */ - struct ub_request urq; - /* Use Ingo's mempool if or when we have more than one command. */ /* * Currently we never need more than one command for the whole device. @@ -359,7 +360,6 @@ struct ub_dev { atomic_t poison; /* The USB device is disconnected */ int openc; /* protected by ub_lock! */ /* kref is too implicit for our taste */ - int reset; /* Reset is running */ unsigned int tagcnt; char name[12]; struct usb_device *dev; @@ -387,9 +387,6 @@ struct ub_dev { struct bulk_cs_wrap work_bcs; struct usb_ctrlrequest work_cr; - struct work_struct reset_work; - wait_queue_head_t reset_wait; - int sg_stat[6]; struct ub_scsi_trace tr; }; @@ -398,14 +395,12 @@ struct ub_dev { */ static void ub_cleanup(struct ub_dev *sc); static int ub_request_fn_1(struct ub_lun *lun, struct request *rq); -static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun, - struct ub_scsi_cmd *cmd, struct ub_request *urq); -static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun, - struct ub_scsi_cmd *cmd, struct ub_request *urq); +static int ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun, + struct ub_scsi_cmd *cmd, struct request *rq); +static int ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun, + struct ub_scsi_cmd *cmd, struct request *rq); static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd); static void ub_end_rq(struct request *rq, int uptodate); -static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun, - struct ub_request *urq, struct ub_scsi_cmd *cmd); static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd); static void ub_urb_complete(struct urb *urb, struct pt_regs *pt); static void ub_scsi_action(unsigned long _dev); @@ -420,8 +415,6 @@ static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd); static int ub_submit_clear_stall(struct ub_dev *sc, struct ub_scsi_cmd *cmd, int stalled_pipe); static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd); -static void ub_reset_enter(struct ub_dev *sc); -static void ub_reset_task(void *arg); static int ub_sync_tur(struct ub_dev *sc, struct ub_lun *lun); static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun, struct ub_capacity *ret); @@ -429,18 +422,13 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum); /* */ -#ifdef CONFIG_USB_LIBUSUAL - -#define ub_usb_ids storage_usb_ids -#else - static struct usb_device_id ub_usb_ids[] = { + // { USB_DEVICE_VER(0x0781, 0x0002, 0x0009, 0x0009) }, /* SDDR-31 */ { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) }, { } }; MODULE_DEVICE_TABLE(usb, ub_usb_ids); -#endif /* CONFIG_USB_LIBUSUAL */ /* * Find me a way to identify "next free minor" for add_disk(), @@ -533,9 +521,6 @@ static ssize_t ub_diag_show(struct device *dev, struct device_attribute *attr, cnt = 0; spin_lock_irqsave(&sc->lock, flags); - cnt += sprintf(page + cnt, - "poison %d reset %d\n", - atomic_read(&sc->poison), sc->reset); cnt += sprintf(page + cnt, "qlen %d qmax %d\n", sc->cmd_queue.qlen, sc->cmd_queue.qmax); @@ -785,8 +770,7 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq) { struct ub_dev *sc = lun->udev; struct ub_scsi_cmd *cmd; - struct ub_request *urq; - int n_elem; + int rc; if (atomic_read(&sc->poison) || lun->changed) { blkdev_dequeue_request(rq); @@ -794,70 +778,65 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq) return 0; } - if (lun->urq.rq != NULL) - return -1; if ((cmd = ub_get_cmd(lun)) == NULL) return -1; memset(cmd, 0, sizeof(struct ub_scsi_cmd)); blkdev_dequeue_request(rq); - - urq = &lun->urq; - memset(urq, 0, sizeof(struct ub_request)); - urq->rq = rq; - - /* - * get scatterlist from block layer - */ - n_elem = blk_rq_map_sg(lun->disk->queue, rq, &urq->sgv[0]); - if (n_elem < 0) { - printk(KERN_INFO "%s: failed request map (%d)\n", - lun->name, n_elem); /* P3 */ - goto drop; - } - if (n_elem > UB_MAX_REQ_SG) { /* Paranoia */ - printk(KERN_WARNING "%s: request with %d segments\n", - lun->name, n_elem); - goto drop; - } - urq->nsg = n_elem; - sc->sg_stat[n_elem < 5 ? n_elem : 5]++; - if (blk_pc_request(rq)) { - ub_cmd_build_packet(sc, lun, cmd, urq); + rc = ub_cmd_build_packet(sc, lun, cmd, rq); } else { - ub_cmd_build_block(sc, lun, cmd, urq); + rc = ub_cmd_build_block(sc, lun, cmd, rq); + } + if (rc != 0) { + ub_put_cmd(lun, cmd); + ub_end_rq(rq, 0); + return 0; } cmd->state = UB_CMDST_INIT; cmd->lun = lun; cmd->done = ub_rw_cmd_done; - cmd->back = urq; + cmd->back = rq; cmd->tag = sc->tagcnt++; - if (ub_submit_scsi(sc, cmd) != 0) - goto drop; - - return 0; + if (ub_submit_scsi(sc, cmd) != 0) { + ub_put_cmd(lun, cmd); + ub_end_rq(rq, 0); + return 0; + } -drop: - ub_put_cmd(lun, cmd); - ub_end_rq(rq, 0); return 0; } -static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun, - struct ub_scsi_cmd *cmd, struct ub_request *urq) +static int ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun, + struct ub_scsi_cmd *cmd, struct request *rq) { - struct request *rq = urq->rq; + int ub_dir; + int n_elem; unsigned int block, nblks; if (rq_data_dir(rq) == WRITE) - cmd->dir = UB_DIR_WRITE; + ub_dir = UB_DIR_WRITE; else - cmd->dir = UB_DIR_READ; + ub_dir = UB_DIR_READ; + cmd->dir = ub_dir; - cmd->nsg = urq->nsg; - memcpy(cmd->sgv, urq->sgv, sizeof(struct scatterlist) * cmd->nsg); + /* + * get scatterlist from block layer + */ + n_elem = blk_rq_map_sg(lun->disk->queue, rq, &cmd->sgv[0]); + if (n_elem <= 0) { + printk(KERN_INFO "%s: failed request map (%d)\n", + sc->name, n_elem); /* P3 */ + return -1; /* request with no s/g entries? */ + } + if (n_elem > UB_MAX_REQ_SG) { /* Paranoia */ + printk(KERN_WARNING "%s: request with %d segments\n", + sc->name, n_elem); + return -1; + } + cmd->nsg = n_elem; + sc->sg_stat[n_elem < 5 ? n_elem : 5]++; /* * build the command @@ -868,7 +847,7 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun, block = rq->sector >> lun->capacity.bshift; nblks = rq->nr_sectors >> lun->capacity.bshift; - cmd->cdb[0] = (cmd->dir == UB_DIR_READ)? READ_10: WRITE_10; + cmd->cdb[0] = (ub_dir == UB_DIR_READ)? READ_10: WRITE_10; /* 10-byte uses 4 bytes of LBA: 2147483648KB, 2097152MB, 2048GB */ cmd->cdb[2] = block >> 24; cmd->cdb[3] = block >> 16; @@ -879,12 +858,14 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun, cmd->cdb_len = 10; cmd->len = rq->nr_sectors * 512; + + return 0; } -static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun, - struct ub_scsi_cmd *cmd, struct ub_request *urq) +static int ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun, + struct ub_scsi_cmd *cmd, struct request *rq) { - struct request *rq = urq->rq; + int n_elem; if (rq->data_len == 0) { cmd->dir = UB_DIR_NONE; @@ -893,26 +874,40 @@ static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun, cmd->dir = UB_DIR_WRITE; else cmd->dir = UB_DIR_READ; + } - cmd->nsg = urq->nsg; - memcpy(cmd->sgv, urq->sgv, sizeof(struct scatterlist) * cmd->nsg); + /* + * get scatterlist from block layer + */ + n_elem = blk_rq_map_sg(lun->disk->queue, rq, &cmd->sgv[0]); + if (n_elem < 0) { + printk(KERN_INFO "%s: failed request map (%d)\n", + sc->name, n_elem); /* P3 */ + return -1; + } + if (n_elem > UB_MAX_REQ_SG) { /* Paranoia */ + printk(KERN_WARNING "%s: request with %d segments\n", + sc->name, n_elem); + return -1; + } + cmd->nsg = n_elem; + sc->sg_stat[n_elem < 5 ? n_elem : 5]++; memcpy(&cmd->cdb, rq->cmd, rq->cmd_len); cmd->cdb_len = rq->cmd_len; cmd->len = rq->data_len; + + return 0; } static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd) { + struct request *rq = cmd->back; struct ub_lun *lun = cmd->lun; - struct ub_request *urq = cmd->back; - struct request *rq; int uptodate; - rq = urq->rq; - if (cmd->error == 0) { uptodate = 1; @@ -933,16 +928,9 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd) rq->errors = SAM_STAT_CHECK_CONDITION; else rq->errors = DID_ERROR << 16; - } else { - if (cmd->error == -EIO) { - if (ub_rw_cmd_retry(sc, lun, urq, cmd) == 0) - return; - } } } - urq->rq = NULL; - ub_put_cmd(lun, cmd); ub_end_rq(rq, uptodate); blk_start_queue(lun->disk->queue); @@ -950,43 +938,11 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd) static void ub_end_rq(struct request *rq, int uptodate) { - end_that_request_first(rq, uptodate, rq->hard_nr_sectors); - end_that_request_last(rq); -} - -static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun, - struct ub_request *urq, struct ub_scsi_cmd *cmd) -{ - - if (atomic_read(&sc->poison)) - return -ENXIO; - - ub_reset_enter(sc); - - if (urq->current_try >= 3) - return -EIO; - urq->current_try++; - /* P3 */ printk("%s: dir %c len/act %d/%d " - "[sense %x %02x %02x] retry %d\n", - sc->name, UB_DIR_CHAR(cmd->dir), cmd->len, cmd->act_len, - cmd->key, cmd->asc, cmd->ascq, urq->current_try); - - memset(cmd, 0, sizeof(struct ub_scsi_cmd)); - ub_cmd_build_block(sc, lun, cmd, urq); - - cmd->state = UB_CMDST_INIT; - cmd->lun = lun; - cmd->done = ub_rw_cmd_done; - cmd->back = urq; - - cmd->tag = sc->tagcnt++; + int rc; -#if 0 /* Wasteful */ - return ub_submit_scsi(sc, cmd); -#else - ub_cmdq_add(sc, cmd); - return 0; -#endif + rc = end_that_request_first(rq, uptodate, rq->hard_nr_sectors); + // assert(rc == 0); + end_that_request_last(rq); } /* @@ -1119,7 +1075,7 @@ static void ub_scsi_dispatch(struct ub_dev *sc) struct ub_scsi_cmd *cmd; int rc; - while (!sc->reset && (cmd = ub_cmdq_peek(sc)) != NULL) { + while ((cmd = ub_cmdq_peek(sc)) != NULL) { if (cmd->state == UB_CMDST_DONE) { ub_cmdq_pop(sc); (*cmd->done)(sc, cmd); @@ -1142,12 +1098,11 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) { struct urb *urb = &sc->work_urb; struct bulk_cs_wrap *bcs; - int len; int rc; if (atomic_read(&sc->poison)) { - ub_state_done(sc, cmd, -ENODEV); - return; + /* A little too simplistic, I feel... */ + goto Bad_End; } if (cmd->state == UB_CMDST_CLEAR) { @@ -1155,6 +1110,7 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) /* * STALL while clearning STALL. * The control pipe clears itself - nothing to do. + * XXX Might try to reset the device here and retry. */ printk(KERN_NOTICE "%s: stall on control pipe\n", sc->name); @@ -1173,6 +1129,11 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) } else if (cmd->state == UB_CMDST_CLR2STS) { if (urb->status == -EPIPE) { + /* + * STALL while clearning STALL. + * The control pipe clears itself - nothing to do. + * XXX Might try to reset the device here and retry. + */ printk(KERN_NOTICE "%s: stall on control pipe\n", sc->name); goto Bad_End; @@ -1190,6 +1151,11 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) } else if (cmd->state == UB_CMDST_CLRRS) { if (urb->status == -EPIPE) { + /* + * STALL while clearning STALL. + * The control pipe clears itself - nothing to do. + * XXX Might try to reset the device here and retry. + */ printk(KERN_NOTICE "%s: stall on control pipe\n", sc->name); goto Bad_End; @@ -1206,12 +1172,7 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) ub_state_stat_counted(sc, cmd); } else if (cmd->state == UB_CMDST_CMD) { - switch (urb->status) { - case 0: - break; - case -EOVERFLOW: - goto Bad_End; - case -EPIPE: + if (urb->status == -EPIPE) { rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe); if (rc != 0) { printk(KERN_NOTICE "%s: " @@ -1221,20 +1182,17 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) * This is typically ENOMEM or some other such shit. * Retrying is pointless. Just do Bad End on it... */ - ub_state_done(sc, cmd, rc); - return; + goto Bad_End; } cmd->state = UB_CMDST_CLEAR; ub_cmdtr_state(sc, cmd); return; - case -ESHUTDOWN: /* unplug */ - case -EILSEQ: /* unplug timeout on uhci */ - ub_state_done(sc, cmd, -ENODEV); - return; - default: + } + if (urb->status != 0) { goto Bad_End; } if (urb->actual_length != US_BULK_CB_WRAP_LEN) { + /* XXX Must do reset here to unconfuse the device */ goto Bad_End; } @@ -1253,8 +1211,11 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) printk(KERN_NOTICE "%s: " "unable to submit clear (%d)\n", sc->name, rc); - ub_state_done(sc, cmd, rc); - return; + /* + * This is typically ENOMEM or some other such shit. + * Retrying is pointless. Just do Bad End on it... + */ + goto Bad_End; } cmd->state = UB_CMDST_CLR2STS; ub_cmdtr_state(sc, cmd); @@ -1263,50 +1224,14 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) if (urb->status == -EOVERFLOW) { /* * A babble? Failure, but we must transfer CSW now. + * XXX This is going to end in perpetual babble. Reset. */ cmd->error = -EOVERFLOW; /* A cheap trick... */ ub_state_stat(sc, cmd); return; } - - if (cmd->dir == UB_DIR_WRITE) { - /* - * Do not continue writes in case of a failure. - * Doing so would cause sectors to be mixed up, - * which is worse than sectors lost. - * - * We must try to read the CSW, or many devices - * get confused. - */ - len = urb->actual_length; - if (urb->status != 0 || - len != cmd->sgv[cmd->current_sg].length) { - cmd->act_len += len; - ub_cmdtr_act_len(sc, cmd); - - cmd->error = -EIO; - ub_state_stat(sc, cmd); - return; - } - - } else { - /* - * If an error occurs on read, we record it, and - * continue to fetch data in order to avoid bubble. - * - * As a small shortcut, we stop if we detect that - * a CSW mixed into data. - */ - if (urb->status != 0) - cmd->error = -EIO; - - len = urb->actual_length; - if (urb->status != 0 || - len != cmd->sgv[cmd->current_sg].length) { - if ((len & 0x1FF) == US_BULK_CS_WRAP_LEN) - goto Bad_End; - } - } + if (urb->status != 0) + goto Bad_End; cmd->act_len += urb->actual_length; ub_cmdtr_act_len(sc, cmd); @@ -1324,8 +1249,11 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) printk(KERN_NOTICE "%s: " "unable to submit clear (%d)\n", sc->name, rc); - ub_state_done(sc, cmd, rc); - return; + /* + * This is typically ENOMEM or some other such shit. + * Retrying is pointless. Just do Bad End on it... + */ + goto Bad_End; } /* @@ -1338,8 +1266,14 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) ub_cmdtr_state(sc, cmd); return; } - - /* Catch everything, including -EOVERFLOW and other nasties. */ + if (urb->status == -EOVERFLOW) { + /* + * XXX We are screwed here. Retrying is pointless, + * because the pipelined data will not get in until + * we read with a big enough buffer. We must reset XXX. + */ + goto Bad_End; + } if (urb->status != 0) goto Bad_End; @@ -1385,15 +1319,15 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) return; } - len = le32_to_cpu(bcs->Residue); - if (len != cmd->len - cmd->act_len) { + rc = le32_to_cpu(bcs->Residue); + if (rc != cmd->len - cmd->act_len) { /* * It is all right to transfer less, the caller has * to check. But it's not all right if the device * counts disagree with our counts. */ /* P3 */ printk("%s: resid %d len %d act %d\n", - sc->name, len, cmd->len, cmd->act_len); + sc->name, rc, cmd->len, cmd->act_len); goto Bad_End; } @@ -1404,13 +1338,13 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) ub_state_sense(sc, cmd); return; case US_BULK_STAT_PHASE: + /* XXX We must reset the transport here */ /* P3 */ printk("%s: status PHASE\n", sc->name); goto Bad_End; default: printk(KERN_INFO "%s: unknown CSW status 0x%x\n", sc->name, bcs->Status); - ub_state_done(sc, cmd, -EINVAL); - return; + goto Bad_End; } /* Not zeroing error to preserve a babble indicator */ @@ -1430,8 +1364,7 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd) printk(KERN_WARNING "%s: " "wrong command state %d\n", sc->name, cmd->state); - ub_state_done(sc, cmd, -EINVAL); - return; + goto Bad_End; } return; @@ -1678,93 +1611,6 @@ static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd) ub_scsi_urb_compl(sc, cmd); } -/* - * Reset management - */ - -static void ub_reset_enter(struct ub_dev *sc) -{ - - if (sc->reset) { - /* This happens often on multi-LUN devices. */ - return; - } - sc->reset = 1; - -#if 0 /* Not needed because the disconnect waits for us. */ - unsigned long flags; - spin_lock_irqsave(&ub_lock, flags); - sc->openc++; - spin_unlock_irqrestore(&ub_lock, flags); -#endif - -#if 0 /* We let them stop themselves. */ - struct list_head *p; - struct ub_lun *lun; - list_for_each(p, &sc->luns) { - lun = list_entry(p, struct ub_lun, link); - blk_stop_queue(lun->disk->queue); - } -#endif - - schedule_work(&sc->reset_work); -} - -static void ub_reset_task(void *arg) -{ - struct ub_dev *sc = arg; - unsigned long flags; - struct list_head *p; - struct ub_lun *lun; - int lkr, rc; - - if (!sc->reset) { - printk(KERN_WARNING "%s: Running reset unrequested\n", - sc->name); - return; - } - - if (atomic_read(&sc->poison)) { - printk(KERN_NOTICE "%s: Not resetting disconnected device\n", - sc->name); /* P3 This floods. Remove soon. XXX */ - } else if (sc->dev->actconfig->desc.bNumInterfaces != 1) { - printk(KERN_NOTICE "%s: Not resetting multi-interface device\n", - sc->name); /* P3 This floods. Remove soon. XXX */ - } else { - if ((lkr = usb_lock_device_for_reset(sc->dev, sc->intf)) < 0) { - printk(KERN_NOTICE - "%s: usb_lock_device_for_reset failed (%d)\n", - sc->name, lkr); - } else { - rc = usb_reset_device(sc->dev); - if (rc < 0) { - printk(KERN_NOTICE "%s: " - "usb_lock_device_for_reset failed (%d)\n", - sc->name, rc); - } - - if (lkr) - usb_unlock_device(sc->dev); - } - } - - /* - * In theory, no commands can be running while reset is active, - * so nobody can ask for another reset, and so we do not need any - * queues of resets or anything. We do need a spinlock though, - * to interact with block layer. - */ - spin_lock_irqsave(&sc->lock, flags); - sc->reset = 0; - tasklet_schedule(&sc->tasklet); - list_for_each(p, &sc->luns) { - lun = list_entry(p, struct ub_lun, link); - blk_start_queue(lun->disk->queue); - } - wake_up(&sc->reset_wait); - spin_unlock_irqrestore(&sc->lock, flags); -} - /* * This is called from a process context. */ @@ -2300,7 +2146,7 @@ static int ub_get_pipes(struct ub_dev *sc, struct usb_device *dev, if (ep_in == NULL || ep_out == NULL) { printk(KERN_NOTICE "%s: failed endpoint check\n", sc->name); - return -ENODEV; + return -EIO; } /* Calculate and store the pipe values */ @@ -2326,9 +2172,6 @@ static int ub_probe(struct usb_interface *intf, int rc; int i; - if (usb_usual_check_type(dev_id, USB_US_TYPE_UB)) - return -ENXIO; - rc = -ENOMEM; if ((sc = kmalloc(sizeof(struct ub_dev), GFP_KERNEL)) == NULL) goto err_core; @@ -2338,8 +2181,6 @@ static int ub_probe(struct usb_interface *intf, usb_init_urb(&sc->work_urb); tasklet_init(&sc->tasklet, ub_scsi_action, (unsigned long)sc); atomic_set(&sc->poison, 0); - INIT_WORK(&sc->reset_work, ub_reset_task, sc); - init_waitqueue_head(&sc->reset_wait); init_timer(&sc->work_timer); sc->work_timer.data = (unsigned long) sc; @@ -2360,8 +2201,7 @@ static int ub_probe(struct usb_interface *intf, /* XXX Verify that we can handle the device (from descriptors) */ - if (ub_get_pipes(sc, sc->dev, intf) != 0) - goto err_dev_desc; + ub_get_pipes(sc, sc->dev, intf); if (device_create_file(&sc->intf->dev, &dev_attr_diag) != 0) goto err_diag; @@ -2432,7 +2272,6 @@ static int ub_probe(struct usb_interface *intf, /* device_remove_file(&sc->intf->dev, &dev_attr_diag); */ err_diag: -err_dev_desc: usb_set_intfdata(intf, NULL); // usb_put_intf(sc->intf); usb_put_dev(sc->dev); @@ -2470,14 +2309,14 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum) ub_revalidate(sc, lun); rc = -ENOMEM; - if ((disk = alloc_disk(UB_PARTS_PER_LUN)) == NULL) + if ((disk = alloc_disk(UB_MINORS_PER_MAJOR)) == NULL) goto err_diskalloc; lun->disk = disk; sprintf(disk->disk_name, DRV_NAME "%c", lun->id + 'a'); sprintf(disk->devfs_name, DEVFS_NAME "/%c", lun->id + 'a'); disk->major = UB_MAJOR; - disk->first_minor = lun->id * UB_PARTS_PER_LUN; + disk->first_minor = lun->id * UB_MINORS_PER_MAJOR; disk->fops = &ub_bd_fops; disk->private_data = lun; disk->driverfs_dev = &sc->intf->dev; @@ -2540,11 +2379,6 @@ static void ub_disconnect(struct usb_interface *intf) */ atomic_set(&sc->poison, 1); - /* - * Wait for reset to end, if any. - */ - wait_event(sc->reset_wait, !sc->reset); - /* * Blow away queued commands. * @@ -2558,7 +2392,7 @@ static void ub_disconnect(struct usb_interface *intf) { struct ub_scsi_cmd *cmd; int cnt = 0; - while ((cmd = ub_cmdq_peek(sc)) != NULL) { + while ((cmd = ub_cmdq_pop(sc)) != NULL) { cmd->error = -ENOTCONN; cmd->state = UB_CMDST_DONE; ub_cmdtr_state(sc, cmd); @@ -2627,6 +2461,7 @@ static void ub_disconnect(struct usb_interface *intf) } static struct usb_driver ub_driver = { + .owner = THIS_MODULE, .name = "ub", .probe = ub_probe, .disconnect = ub_disconnect, @@ -2644,7 +2479,6 @@ static int __init ub_init(void) if ((rc = usb_register(&ub_driver)) != 0) goto err_register; - usb_usual_set_present(USB_US_TYPE_UB); return 0; err_register: @@ -2660,7 +2494,6 @@ static void __exit ub_exit(void) devfs_remove(DEVFS_NAME); unregister_blkdev(UB_MAJOR, DRV_NAME); - usb_usual_clear_present(USB_US_TYPE_UB); } module_init(ub_init); diff --git a/trunk/drivers/bluetooth/bcm203x.c b/trunk/drivers/bluetooth/bcm203x.c index 3e7a067cc087..8e7fb3551775 100644 --- a/trunk/drivers/bluetooth/bcm203x.c +++ b/trunk/drivers/bluetooth/bcm203x.c @@ -275,6 +275,7 @@ static void bcm203x_disconnect(struct usb_interface *intf) } static struct usb_driver bcm203x_driver = { + .owner = THIS_MODULE, .name = "bcm203x", .probe = bcm203x_probe, .disconnect = bcm203x_disconnect, diff --git a/trunk/drivers/bluetooth/bfusb.c b/trunk/drivers/bluetooth/bfusb.c index 8947c8837dac..067e27893e4a 100644 --- a/trunk/drivers/bluetooth/bfusb.c +++ b/trunk/drivers/bluetooth/bfusb.c @@ -768,6 +768,7 @@ static void bfusb_disconnect(struct usb_interface *intf) } static struct usb_driver bfusb_driver = { + .owner = THIS_MODULE, .name = "bfusb", .probe = bfusb_probe, .disconnect = bfusb_disconnect, diff --git a/trunk/drivers/bluetooth/bluecard_cs.c b/trunk/drivers/bluetooth/bluecard_cs.c index 9888bc151755..f36c563d72c4 100644 --- a/trunk/drivers/bluetooth/bluecard_cs.c +++ b/trunk/drivers/bluetooth/bluecard_cs.c @@ -87,8 +87,14 @@ typedef struct bluecard_info_t { static void bluecard_config(dev_link_t *link); static void bluecard_release(dev_link_t *link); +static int bluecard_event(event_t event, int priority, event_callback_args_t *args); -static void bluecard_detach(struct pcmcia_device *p_dev); +static dev_info_t dev_info = "bluecard_cs"; + +static dev_link_t *bluecard_attach(void); +static void bluecard_detach(dev_link_t *); + +static dev_link_t *dev_list = NULL; /* Default baud rate: 57600, 115200, 230400 or 460800 */ @@ -856,15 +862,17 @@ static int bluecard_close(bluecard_info_t *info) return 0; } -static int bluecard_attach(struct pcmcia_device *p_dev) +static dev_link_t *bluecard_attach(void) { bluecard_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; /* Create new info device */ info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) - return -ENOMEM; + return NULL; link = &info->link; link->priv = info; @@ -881,24 +889,50 @@ static int bluecard_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - bluecard_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + bluecard_detach(link); + return NULL; + } - return 0; + return link; } -static void bluecard_detach(struct pcmcia_device *p_dev) +static void bluecard_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); bluecard_info_t *info = link->priv; + dev_link_t **linkp; + int ret; + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) bluecard_release(link); + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + /* Unlink device structure, free bits */ + *linkp = link->next; + kfree(info); } @@ -1011,24 +1045,39 @@ static void bluecard_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int bluecard_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - return 0; -} - -static int bluecard_resume(struct pcmcia_device *dev) +static int bluecard_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; + bluecard_info_t *info = link->priv; - link->state &= ~DEV_SUSPEND; - if (DEV_OK(link)) - pcmcia_request_configuration(link->handle, &link->conf); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + bluecard_close(info); + bluecard_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + bluecard_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (DEV_OK(link)) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } return 0; } @@ -1046,11 +1095,10 @@ static struct pcmcia_driver bluecard_driver = { .drv = { .name = "bluecard_cs", }, - .probe = bluecard_attach, - .remove = bluecard_detach, + .attach = bluecard_attach, + .event = bluecard_event, + .detach = bluecard_detach, .id_table = bluecard_ids, - .suspend = bluecard_suspend, - .resume = bluecard_resume, }; static int __init init_bluecard_cs(void) @@ -1062,6 +1110,7 @@ static int __init init_bluecard_cs(void) static void __exit exit_bluecard_cs(void) { pcmcia_unregister_driver(&bluecard_driver); + BUG_ON(dev_list != NULL); } module_init(init_bluecard_cs); diff --git a/trunk/drivers/bluetooth/bpa10x.c b/trunk/drivers/bluetooth/bpa10x.c index 9446960ac742..394796315adc 100644 --- a/trunk/drivers/bluetooth/bpa10x.c +++ b/trunk/drivers/bluetooth/bpa10x.c @@ -619,6 +619,7 @@ static void bpa10x_disconnect(struct usb_interface *intf) } static struct usb_driver bpa10x_driver = { + .owner = THIS_MODULE, .name = "bpa10x", .probe = bpa10x_probe, .disconnect = bpa10x_disconnect, diff --git a/trunk/drivers/bluetooth/bt3c_cs.c b/trunk/drivers/bluetooth/bt3c_cs.c index e522d19ad886..d2a0add19cc8 100644 --- a/trunk/drivers/bluetooth/bt3c_cs.c +++ b/trunk/drivers/bluetooth/bt3c_cs.c @@ -90,8 +90,14 @@ typedef struct bt3c_info_t { static void bt3c_config(dev_link_t *link); static void bt3c_release(dev_link_t *link); +static int bt3c_event(event_t event, int priority, event_callback_args_t *args); -static void bt3c_detach(struct pcmcia_device *p_dev); +static dev_info_t dev_info = "bt3c_cs"; + +static dev_link_t *bt3c_attach(void); +static void bt3c_detach(dev_link_t *); + +static dev_link_t *dev_list = NULL; /* Transmit states */ @@ -657,15 +663,17 @@ static int bt3c_close(bt3c_info_t *info) return 0; } -static int bt3c_attach(struct pcmcia_device *p_dev) +static dev_link_t *bt3c_attach(void) { bt3c_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; /* Create new info device */ info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) - return -ENOMEM; + return NULL; link = &info->link; link->priv = info; @@ -682,24 +690,50 @@ static int bt3c_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - bt3c_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + bt3c_detach(link); + return NULL; + } - return 0; + return link; } -static void bt3c_detach(struct pcmcia_device *p_dev) +static void bt3c_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); bt3c_info_t *info = link->priv; + dev_link_t **linkp; + int ret; + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) bt3c_release(link); + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + /* Unlink device structure, free bits */ + *linkp = link->next; + kfree(info); } @@ -857,29 +891,43 @@ static void bt3c_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int bt3c_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int bt3c_resume(struct pcmcia_device *dev) +static int bt3c_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; + bt3c_info_t *info = link->priv; - link->state &= ~DEV_SUSPEND; - if (DEV_OK(link)) - pcmcia_request_configuration(link->handle, &link->conf); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + bt3c_close(info); + bt3c_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + bt3c_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (DEV_OK(link)) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } return 0; } - static struct pcmcia_device_id bt3c_ids[] = { PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02), PCMCIA_DEVICE_NULL @@ -891,11 +939,10 @@ static struct pcmcia_driver bt3c_driver = { .drv = { .name = "bt3c_cs", }, - .probe = bt3c_attach, - .remove = bt3c_detach, + .attach = bt3c_attach, + .event = bt3c_event, + .detach = bt3c_detach, .id_table = bt3c_ids, - .suspend = bt3c_suspend, - .resume = bt3c_resume, }; static int __init init_bt3c_cs(void) @@ -907,6 +954,7 @@ static int __init init_bt3c_cs(void) static void __exit exit_bt3c_cs(void) { pcmcia_unregister_driver(&bt3c_driver); + BUG_ON(dev_list != NULL); } module_init(init_bt3c_cs); diff --git a/trunk/drivers/bluetooth/btuart_cs.c b/trunk/drivers/bluetooth/btuart_cs.c index 7b4bff4cfa2d..529a28a3209d 100644 --- a/trunk/drivers/bluetooth/btuart_cs.c +++ b/trunk/drivers/bluetooth/btuart_cs.c @@ -86,8 +86,14 @@ typedef struct btuart_info_t { static void btuart_config(dev_link_t *link); static void btuart_release(dev_link_t *link); +static int btuart_event(event_t event, int priority, event_callback_args_t *args); -static void btuart_detach(struct pcmcia_device *p_dev); +static dev_info_t dev_info = "btuart_cs"; + +static dev_link_t *btuart_attach(void); +static void btuart_detach(dev_link_t *); + +static dev_link_t *dev_list = NULL; /* Maximum baud rate */ @@ -576,15 +582,17 @@ static int btuart_close(btuart_info_t *info) return 0; } -static int btuart_attach(struct pcmcia_device *p_dev) +static dev_link_t *btuart_attach(void) { btuart_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; /* Create new info device */ info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) - return -ENOMEM; + return NULL; link = &info->link; link->priv = info; @@ -601,24 +609,50 @@ static int btuart_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - btuart_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + btuart_detach(link); + return NULL; + } - return 0; + return link; } -static void btuart_detach(struct pcmcia_device *p_dev) +static void btuart_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); btuart_info_t *info = link->priv; + dev_link_t **linkp; + int ret; + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) btuart_release(link); + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + /* Unlink device structure, free bits */ + *linkp = link->next; + kfree(info); } @@ -777,29 +811,43 @@ static void btuart_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int btuart_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int btuart_resume(struct pcmcia_device *dev) +static int btuart_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; + btuart_info_t *info = link->priv; - link->state &= ~DEV_SUSPEND; - if (DEV_OK(link)) - pcmcia_request_configuration(link->handle, &link->conf); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + btuart_close(info); + btuart_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + btuart_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (DEV_OK(link)) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } return 0; } - static struct pcmcia_device_id btuart_ids[] = { /* don't use this driver. Use serial_cs + hci_uart instead */ PCMCIA_DEVICE_NULL @@ -811,11 +859,10 @@ static struct pcmcia_driver btuart_driver = { .drv = { .name = "btuart_cs", }, - .probe = btuart_attach, - .remove = btuart_detach, + .attach = btuart_attach, + .event = btuart_event, + .detach = btuart_detach, .id_table = btuart_ids, - .suspend = btuart_suspend, - .resume = btuart_resume, }; static int __init init_btuart_cs(void) @@ -827,6 +874,7 @@ static int __init init_btuart_cs(void) static void __exit exit_btuart_cs(void) { pcmcia_unregister_driver(&btuart_driver); + BUG_ON(dev_list != NULL); } module_init(init_btuart_cs); diff --git a/trunk/drivers/bluetooth/dtl1_cs.c b/trunk/drivers/bluetooth/dtl1_cs.c index 0449bc45ae5e..dec5980a1cd6 100644 --- a/trunk/drivers/bluetooth/dtl1_cs.c +++ b/trunk/drivers/bluetooth/dtl1_cs.c @@ -89,8 +89,14 @@ typedef struct dtl1_info_t { static void dtl1_config(dev_link_t *link); static void dtl1_release(dev_link_t *link); +static int dtl1_event(event_t event, int priority, event_callback_args_t *args); -static void dtl1_detach(struct pcmcia_device *p_dev); +static dev_info_t dev_info = "dtl1_cs"; + +static dev_link_t *dtl1_attach(void); +static void dtl1_detach(dev_link_t *); + +static dev_link_t *dev_list = NULL; /* Transmit states */ @@ -555,15 +561,17 @@ static int dtl1_close(dtl1_info_t *info) return 0; } -static int dtl1_attach(struct pcmcia_device *p_dev) +static dev_link_t *dtl1_attach(void) { dtl1_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; /* Create new info device */ info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) - return -ENOMEM; + return NULL; link = &info->link; link->priv = info; @@ -580,24 +588,50 @@ static int dtl1_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - dtl1_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + dtl1_detach(link); + return NULL; + } - return 0; + return link; } -static void dtl1_detach(struct pcmcia_device *p_dev) +static void dtl1_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); dtl1_info_t *info = link->priv; + dev_link_t **linkp; + int ret; + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) dtl1_release(link); + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + /* Unlink device structure, free bits */ + *linkp = link->next; + kfree(info); } @@ -729,33 +763,46 @@ static void dtl1_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int dtl1_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int dtl1_resume(struct pcmcia_device *dev) +static int dtl1_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; + dtl1_info_t *info = link->priv; - link->state &= ~DEV_SUSPEND; - if (DEV_OK(link)) - pcmcia_request_configuration(link->handle, &link->conf); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + dtl1_close(info); + dtl1_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + dtl1_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (DEV_OK(link)) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } return 0; } - static struct pcmcia_device_id dtl1_ids[] = { PCMCIA_DEVICE_PROD_ID12("Nokia Mobile Phones", "DTL-1", 0xe1bfdd64, 0xe168480d), PCMCIA_DEVICE_PROD_ID12("Socket", "CF", 0xb38bcc2e, 0x44ebf863), - PCMCIA_DEVICE_PROD_ID12("Socket", "CF+ Personal Network Card", 0xb38bcc2e, 0xe732bae3), PCMCIA_DEVICE_NULL }; MODULE_DEVICE_TABLE(pcmcia, dtl1_ids); @@ -765,11 +812,10 @@ static struct pcmcia_driver dtl1_driver = { .drv = { .name = "dtl1_cs", }, - .probe = dtl1_attach, - .remove = dtl1_detach, + .attach = dtl1_attach, + .event = dtl1_event, + .detach = dtl1_detach, .id_table = dtl1_ids, - .suspend = dtl1_suspend, - .resume = dtl1_resume, }; static int __init init_dtl1_cs(void) @@ -781,6 +827,7 @@ static int __init init_dtl1_cs(void) static void __exit exit_dtl1_cs(void) { pcmcia_unregister_driver(&dtl1_driver); + BUG_ON(dev_list != NULL); } module_init(init_dtl1_cs); diff --git a/trunk/drivers/bluetooth/hci_usb.c b/trunk/drivers/bluetooth/hci_usb.c index 92382e823285..057cb2b6e6d1 100644 --- a/trunk/drivers/bluetooth/hci_usb.c +++ b/trunk/drivers/bluetooth/hci_usb.c @@ -1044,6 +1044,7 @@ static void hci_usb_disconnect(struct usb_interface *intf) } static struct usb_driver hci_usb_driver = { + .owner = THIS_MODULE, .name = "hci_usb", .probe = hci_usb_probe, .disconnect = hci_usb_disconnect, diff --git a/trunk/drivers/char/.gitignore b/trunk/drivers/char/.gitignore index 73dfdcebfbba..2b6b1d772ed7 100644 --- a/trunk/drivers/char/.gitignore +++ b/trunk/drivers/char/.gitignore @@ -1,3 +1,3 @@ consolemap_deftbl.c defkeymap.c -qtronixmap.c + diff --git a/trunk/drivers/char/ip2/i2pack.h b/trunk/drivers/char/ip2/i2pack.h index 00342a677c90..e9b87a78622c 100644 --- a/trunk/drivers/char/ip2/i2pack.h +++ b/trunk/drivers/char/ip2/i2pack.h @@ -358,7 +358,7 @@ typedef struct _failStat #define MB_OUT_STRIPPED 0x40 // Board has read all output from fifo #define MB_FATAL_ERROR 0x20 // Board has encountered a fatal error -#pragma pack() // Reset padding to command-line default +#pragma pack(4) // Reset padding to command-line default #endif // I2PACK_H diff --git a/trunk/drivers/char/n_hdlc.c b/trunk/drivers/char/n_hdlc.c index a133a62f3d55..c3660d8781a4 100644 --- a/trunk/drivers/char/n_hdlc.c +++ b/trunk/drivers/char/n_hdlc.c @@ -562,7 +562,7 @@ static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data, } /* end of n_hdlc_tty_receive() */ /** - * n_hdlc_tty_read - Called to retrieve one frame of data (if available) + * n_hdlc_tty_read - Called to retreive one frame of data (if available) * @tty - pointer to tty instance data * @file - pointer to open file object * @buf - pointer to returned data buffer diff --git a/trunk/drivers/char/pcmcia/cm4000_cs.c b/trunk/drivers/char/pcmcia/cm4000_cs.c index 649677b5dc36..61681c9f3f72 100644 --- a/trunk/drivers/char/pcmcia/cm4000_cs.c +++ b/trunk/drivers/char/pcmcia/cm4000_cs.c @@ -66,6 +66,7 @@ static char *version = "cm4000_cs.c v2.4.0gm5 - All bugs added by Harald Welte"; #define T_100MSEC msecs_to_jiffies(100) #define T_500MSEC msecs_to_jiffies(500) +static void cm4000_detach(dev_link_t *link); static void cm4000_release(dev_link_t *link); static int major; /* major number we get from the kernel */ @@ -155,6 +156,7 @@ struct cm4000_dev { /*sbuf*/ 512*sizeof(char) - \ /*queue*/ 4*sizeof(wait_queue_head_t)) +static dev_info_t dev_info = MODULE_NAME; static dev_link_t *dev_table[CM4000_MAX_DEV]; /* This table doesn't use spaces after the comma between fields and thus @@ -1862,36 +1864,68 @@ static void cm4000_config(dev_link_t * link, int devno) link->state &= ~DEV_CONFIG_PENDING; } -static int cm4000_suspend(struct pcmcia_device *p_dev) +static int cm4000_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - struct cm4000_dev *dev; - - dev = link->priv; - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - stop_monitor(dev); - - return 0; -} - -static int cm4000_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link; struct cm4000_dev *dev; + int devno; + link = args->client_data; dev = link->priv; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); + DEBUGP(3, dev, "-> cm4000_event\n"); + for (devno = 0; devno < CM4000_MAX_DEV; devno++) + if (dev_table[devno] == link) + break; - if (link->open) - start_monitor(dev); + if (devno == CM4000_MAX_DEV) + return CS_BAD_ADAPTER; - return 0; + switch (event) { + case CS_EVENT_CARD_INSERTION: + DEBUGP(5, dev, "CS_EVENT_CARD_INSERTION\n"); + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + cm4000_config(link, devno); + break; + case CS_EVENT_CARD_REMOVAL: + DEBUGP(5, dev, "CS_EVENT_CARD_REMOVAL\n"); + link->state &= ~DEV_PRESENT; + stop_monitor(dev); + break; + case CS_EVENT_PM_SUSPEND: + DEBUGP(5, dev, "CS_EVENT_PM_SUSPEND " + "(fall-through to CS_EVENT_RESET_PHYSICAL)\n"); + link->state |= DEV_SUSPEND; + /* fall-through */ + case CS_EVENT_RESET_PHYSICAL: + DEBUGP(5, dev, "CS_EVENT_RESET_PHYSICAL\n"); + if (link->state & DEV_CONFIG) { + DEBUGP(5, dev, "ReleaseConfiguration\n"); + pcmcia_release_configuration(link->handle); + } + stop_monitor(dev); + break; + case CS_EVENT_PM_RESUME: + DEBUGP(5, dev, "CS_EVENT_PM_RESUME " + "(fall-through to CS_EVENT_CARD_RESET)\n"); + link->state &= ~DEV_SUSPEND; + /* fall-through */ + case CS_EVENT_CARD_RESET: + DEBUGP(5, dev, "CS_EVENT_CARD_RESET\n"); + if ((link->state & DEV_CONFIG)) { + DEBUGP(5, dev, "RequestConfiguration\n"); + pcmcia_request_configuration(link->handle, &link->conf); + } + if (link->open) + start_monitor(dev); + break; + default: + DEBUGP(5, dev, "unknown event %.2x\n", event); + break; + } + DEBUGP(3, dev, "<- cm4000_event\n"); + return CS_SUCCESS; } static void cm4000_release(dev_link_t *link) @@ -1901,10 +1935,11 @@ static void cm4000_release(dev_link_t *link) pcmcia_release_io(link->handle, &link->io); } -static int cm4000_attach(struct pcmcia_device *p_dev) +static dev_link_t *cm4000_attach(void) { struct cm4000_dev *dev; dev_link_t *link; + client_reg_t client_reg; int i; for (i = 0; i < CM4000_MAX_DEV; i++) @@ -1913,55 +1948,76 @@ static int cm4000_attach(struct pcmcia_device *p_dev) if (i == CM4000_MAX_DEV) { printk(KERN_NOTICE MODULE_NAME ": all devices in use\n"); - return -ENODEV; + return NULL; } /* create a new cm4000_cs device */ dev = kzalloc(sizeof(struct cm4000_dev), GFP_KERNEL); if (dev == NULL) - return -ENOMEM; + return NULL; link = &dev->link; link->priv = dev; link->conf.IntType = INT_MEMORY_AND_IO; dev_table[i] = link; + /* register with card services */ + client_reg.dev_info = &dev_info; + client_reg.EventMask = + CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL | + CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET | + CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + + i = pcmcia_register_client(&link->handle, &client_reg); + if (i) { + cs_error(link->handle, RegisterClient, i); + cm4000_detach(link); + return NULL; + } + init_waitqueue_head(&dev->devq); init_waitqueue_head(&dev->ioq); init_waitqueue_head(&dev->atrq); init_waitqueue_head(&dev->readq); - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - cm4000_config(link, i); - - return 0; + return link; } -static void cm4000_detach(struct pcmcia_device *p_dev) +static void cm4000_detach_by_devno(int devno, dev_link_t * link) { - dev_link_t *link = dev_to_instance(p_dev); struct cm4000_dev *dev = link->priv; - int devno; - /* find device */ - for (devno = 0; devno < CM4000_MAX_DEV; devno++) - if (dev_table[devno] == link) - break; - if (devno == CM4000_MAX_DEV) - return; + DEBUGP(3, dev, "-> detach_by_devno(devno=%d)\n", devno); - link->state &= ~DEV_PRESENT; - stop_monitor(dev); + if (link->state & DEV_CONFIG) { + DEBUGP(5, dev, "device still configured (try to release it)\n"); + cm4000_release(link); + } - if (link->state & DEV_CONFIG) - cm4000_release(link); + if (link->handle) { + pcmcia_deregister_client(link->handle); + } dev_table[devno] = NULL; - kfree(dev); + kfree(dev); + return; +} + +static void cm4000_detach(dev_link_t * link) +{ + int i; + + /* find device */ + for (i = 0; i < CM4000_MAX_DEV; i++) + if (dev_table[i] == link) + break; + + if (i == CM4000_MAX_DEV) + return; + cm4000_detach_by_devno(i, link); return; } @@ -1986,10 +2042,9 @@ static struct pcmcia_driver cm4000_driver = { .drv = { .name = "cm4000_cs", }, - .probe = cm4000_attach, - .remove = cm4000_detach, - .suspend = cm4000_suspend, - .resume = cm4000_resume, + .attach = cm4000_attach, + .detach = cm4000_detach, + .event = cm4000_event, .id_table = cm4000_ids, }; @@ -2009,8 +2064,13 @@ static int __init cmm_init(void) static void __exit cmm_exit(void) { + int i; + printk(KERN_INFO MODULE_NAME ": unloading\n"); pcmcia_unregister_driver(&cm4000_driver); + for (i = 0; i < CM4000_MAX_DEV; i++) + if (dev_table[i]) + cm4000_detach_by_devno(i, dev_table[i]); unregister_chrdev(major, DEVICE_NAME); }; diff --git a/trunk/drivers/char/pcmcia/cm4040_cs.c b/trunk/drivers/char/pcmcia/cm4040_cs.c index 46eb371bf17e..4c698d908ffa 100644 --- a/trunk/drivers/char/pcmcia/cm4040_cs.c +++ b/trunk/drivers/char/pcmcia/cm4040_cs.c @@ -65,6 +65,7 @@ static char *version = #define POLL_PERIOD msecs_to_jiffies(10) static void reader_release(dev_link_t *link); +static void reader_detach(dev_link_t *link); static int major; @@ -85,6 +86,7 @@ struct reader_dev { struct timer_list poll_timer; }; +static dev_info_t dev_info = MODULE_NAME; static dev_link_t *dev_table[CM_MAX_DEV]; #ifndef PCMCIA_DEBUG @@ -627,26 +629,65 @@ static void reader_config(dev_link_t *link, int devno) link->state &= ~DEV_CONFIG_PENDING; } -static int reader_suspend(struct pcmcia_device *p_dev) +static int reader_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int reader_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link; + struct reader_dev *dev; + int devno; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); + link = args->client_data; + dev = link->priv; + DEBUGP(3, dev, "-> reader_event\n"); + for (devno = 0; devno < CM_MAX_DEV; devno++) { + if (dev_table[devno] == link) + break; + } + if (devno == CM_MAX_DEV) + return CS_BAD_ADAPTER; - return 0; + switch (event) { + case CS_EVENT_CARD_INSERTION: + DEBUGP(5, dev, "CS_EVENT_CARD_INSERTION\n"); + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + reader_config(link, devno); + break; + case CS_EVENT_CARD_REMOVAL: + DEBUGP(5, dev, "CS_EVENT_CARD_REMOVAL\n"); + link->state &= ~DEV_PRESENT; + break; + case CS_EVENT_PM_SUSPEND: + DEBUGP(5, dev, "CS_EVENT_PM_SUSPEND " + "(fall-through to CS_EVENT_RESET_PHYSICAL)\n"); + link->state |= DEV_SUSPEND; + + case CS_EVENT_RESET_PHYSICAL: + DEBUGP(5, dev, "CS_EVENT_RESET_PHYSICAL\n"); + if (link->state & DEV_CONFIG) { + DEBUGP(5, dev, "ReleaseConfiguration\n"); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + DEBUGP(5, dev, "CS_EVENT_PM_RESUME " + "(fall-through to CS_EVENT_CARD_RESET)\n"); + link->state &= ~DEV_SUSPEND; + + case CS_EVENT_CARD_RESET: + DEBUGP(5, dev, "CS_EVENT_CARD_RESET\n"); + if ((link->state & DEV_CONFIG)) { + DEBUGP(5, dev, "RequestConfiguration\n"); + pcmcia_request_configuration(link->handle, + &link->conf); + } + break; + default: + DEBUGP(5, dev, "reader_event: unknown event %.2x\n", + event); + break; + } + DEBUGP(3, dev, "<- reader_event\n"); + return CS_SUCCESS; } static void reader_release(dev_link_t *link) @@ -656,10 +697,11 @@ static void reader_release(dev_link_t *link) pcmcia_release_io(link->handle, &link->io); } -static int reader_attach(struct pcmcia_device *p_dev) +static dev_link_t *reader_attach(void) { struct reader_dev *dev; dev_link_t *link; + client_reg_t client_reg; int i; for (i = 0; i < CM_MAX_DEV; i++) { @@ -668,11 +710,11 @@ static int reader_attach(struct pcmcia_device *p_dev) } if (i == CM_MAX_DEV) - return -ENODEV; + return NULL; dev = kzalloc(sizeof(struct reader_dev), GFP_KERNEL); if (dev == NULL) - return -ENOMEM; + return NULL; dev->timeout = CCID_DRIVER_MINIMUM_TIMEOUT; dev->buffer_status = 0; @@ -683,6 +725,20 @@ static int reader_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; dev_table[i] = link; + client_reg.dev_info = &dev_info; + client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE; + client_reg.EventMask= + CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL | + CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET | + CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + i = pcmcia_register_client(&link->handle, &client_reg); + if (i) { + cs_error(link->handle, RegisterClient, i); + reader_detach(link); + return NULL; + } init_waitqueue_head(&dev->devq); init_waitqueue_head(&dev->poll_wait); init_waitqueue_head(&dev->read_wait); @@ -690,37 +746,39 @@ static int reader_attach(struct pcmcia_device *p_dev) init_timer(&dev->poll_timer); dev->poll_timer.function = &cm4040_do_poll; - link->handle = p_dev; - p_dev->instance = link; + return link; +} + +static void reader_detach_by_devno(int devno, dev_link_t *link) +{ + struct reader_dev *dev = link->priv; - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - reader_config(link, i); + if (link->state & DEV_CONFIG) { + DEBUGP(5, dev, "device still configured (try to release it)\n"); + reader_release(link); + } - return 0; + pcmcia_deregister_client(link->handle); + dev_table[devno] = NULL; + DEBUGP(5, dev, "freeing dev=%p\n", dev); + cm4040_stop_poll(dev); + kfree(dev); + return; } -static void reader_detach(struct pcmcia_device *p_dev) +static void reader_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); - struct reader_dev *dev = link->priv; - int devno; + int i; /* find device */ - for (devno = 0; devno < CM_MAX_DEV; devno++) { - if (dev_table[devno] == link) + for (i = 0; i < CM_MAX_DEV; i++) { + if (dev_table[i] == link) break; } - if (devno == CM_MAX_DEV) + if (i == CM_MAX_DEV) return; - link->state &= ~DEV_PRESENT; - - if (link->state & DEV_CONFIG) - reader_release(link); - - dev_table[devno] = NULL; - kfree(dev); - + reader_detach_by_devno(i, link); return; } @@ -746,10 +804,9 @@ static struct pcmcia_driver reader_driver = { .drv = { .name = "cm4040_cs", }, - .probe = reader_attach, - .remove = reader_detach, - .suspend = reader_suspend, - .resume = reader_resume, + .attach = reader_attach, + .detach = reader_detach, + .event = reader_event, .id_table = cm4040_ids, }; @@ -768,8 +825,14 @@ static int __init cm4040_init(void) static void __exit cm4040_exit(void) { + int i; + printk(KERN_INFO MODULE_NAME ": unloading\n"); pcmcia_unregister_driver(&reader_driver); + for (i = 0; i < CM_MAX_DEV; i++) { + if (dev_table[i]) + reader_detach_by_devno(i, dev_table[i]); + } unregister_chrdev(major, DEVICE_NAME); } diff --git a/trunk/drivers/char/pcmcia/synclink_cs.c b/trunk/drivers/char/pcmcia/synclink_cs.c index cf45b100eff1..2c326ea53421 100644 --- a/trunk/drivers/char/pcmcia/synclink_cs.c +++ b/trunk/drivers/char/pcmcia/synclink_cs.c @@ -486,7 +486,13 @@ static void mgslpc_wait_until_sent(struct tty_struct *tty, int timeout); static void mgslpc_config(dev_link_t *link); static void mgslpc_release(u_long arg); -static void mgslpc_detach(struct pcmcia_device *p_dev); +static int mgslpc_event(event_t event, int priority, + event_callback_args_t *args); +static dev_link_t *mgslpc_attach(void); +static void mgslpc_detach(dev_link_t *); + +static dev_info_t dev_info = "synclink_cs"; +static dev_link_t *dev_list = NULL; /* * 1st function defined in .text section. Calling this function in @@ -533,10 +539,12 @@ static void ldisc_receive_buf(struct tty_struct *tty, } } -static int mgslpc_attach(struct pcmcia_device *p_dev) +static dev_link_t *mgslpc_attach(void) { MGSLPC_INFO *info; dev_link_t *link; + client_reg_t client_reg; + int ret; if (debug_level >= DEBUG_LEVEL_INFO) printk("mgslpc_attach\n"); @@ -544,7 +552,7 @@ static int mgslpc_attach(struct pcmcia_device *p_dev) info = (MGSLPC_INFO *)kmalloc(sizeof(MGSLPC_INFO), GFP_KERNEL); if (!info) { printk("Error can't allocate device instance data\n"); - return -ENOMEM; + return NULL; } memset(info, 0, sizeof(MGSLPC_INFO)); @@ -579,15 +587,24 @@ static int mgslpc_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - mgslpc_config(link); + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + mgslpc_detach(link); + return NULL; + } mgslpc_add_device(info); - return 0; + return link; } /* Card has been inserted. @@ -719,50 +736,85 @@ static void mgslpc_release(u_long arg) pcmcia_release_io(link->handle, &link->io); if (link->irq.AssignedIRQ) pcmcia_release_irq(link->handle, &link->irq); + if (link->state & DEV_STALE_LINK) + mgslpc_detach(link); } -static void mgslpc_detach(struct pcmcia_device *p_dev) +static void mgslpc_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; if (debug_level >= DEBUG_LEVEL_INFO) printk("mgslpc_detach(0x%p)\n", link); + + /* find device */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) { - ((MGSLPC_INFO *)link->priv)->stop = 1; - mgslpc_release((u_long)link); + /* device is configured/active, mark it so when + * release() is called a proper detach() occurs. + */ + if (debug_level >= DEBUG_LEVEL_INFO) + printk(KERN_DEBUG "synclinkpc: detach postponed, '%s' " + "still locked\n", link->dev->dev_name); + link->state |= DEV_STALE_LINK; + return; } + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, and free it */ + *linkp = link->next; mgslpc_remove_device((MGSLPC_INFO *)link->priv); } -static int mgslpc_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - MGSLPC_INFO *info = link->priv; - - link->state |= DEV_SUSPEND; - info->stop = 1; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int mgslpc_resume(struct pcmcia_device *dev) +static int mgslpc_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); - MGSLPC_INFO *info = link->priv; - - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); - info->stop = 0; - - return 0; + dev_link_t *link = args->client_data; + MGSLPC_INFO *info = link->priv; + + if (debug_level >= DEBUG_LEVEL_INFO) + printk("mgslpc_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + ((MGSLPC_INFO *)link->priv)->stop = 1; + mgslpc_release((u_long)link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + mgslpc_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + /* Mark the device as stopped, to block IO until later */ + info->stop = 1; + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) + pcmcia_request_configuration(link->handle, &link->conf); + info->stop = 0; + break; + } + return 0; } - static inline int mgslpc_paranoia_check(MGSLPC_INFO *info, char *name, const char *routine) { @@ -3039,11 +3091,10 @@ static struct pcmcia_driver mgslpc_driver = { .drv = { .name = "synclink_cs", }, - .probe = mgslpc_attach, - .remove = mgslpc_detach, + .attach = mgslpc_attach, + .event = mgslpc_event, + .detach = mgslpc_detach, .id_table = mgslpc_ids, - .suspend = mgslpc_suspend, - .resume = mgslpc_resume, }; static struct tty_operations mgslpc_ops = { @@ -3087,6 +3138,7 @@ static void synclink_cs_cleanup(void) } pcmcia_unregister_driver(&mgslpc_driver); + BUG_ON(dev_list != NULL); } static int __init synclink_cs_init(void) diff --git a/trunk/drivers/char/random.c b/trunk/drivers/char/random.c index bdfdfd28594d..7999da25fe40 100644 --- a/trunk/drivers/char/random.c +++ b/trunk/drivers/char/random.c @@ -1554,8 +1554,10 @@ __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr, EXPORT_SYMBOL(secure_tcp_sequence_number); -/* Generate secure starting point for ephemeral IPV4 transport port search */ -u32 secure_ipv4_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport) + + +/* Generate secure starting point for ephemeral TCP port search */ +u32 secure_tcp_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport) { struct keydata *keyptr = get_keyptr(); u32 hash[4]; @@ -1573,7 +1575,7 @@ u32 secure_ipv4_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport) } #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) -u32 secure_ipv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dport) +u32 secure_tcpv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dport) { struct keydata *keyptr = get_keyptr(); u32 hash[12]; @@ -1584,7 +1586,7 @@ u32 secure_ipv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dpo return twothirdsMD4Transform(daddr, hash); } -EXPORT_SYMBOL(secure_ipv6_port_ephemeral); +EXPORT_SYMBOL(secure_tcpv6_port_ephemeral); #endif #if defined(CONFIG_IP_DCCP) || defined(CONFIG_IP_DCCP_MODULE) diff --git a/trunk/drivers/char/watchdog/ixp4xx_wdt.c b/trunk/drivers/char/watchdog/ixp4xx_wdt.c index 3800835ca8f3..b5be8b11104a 100644 --- a/trunk/drivers/char/watchdog/ixp4xx_wdt.c +++ b/trunk/drivers/char/watchdog/ixp4xx_wdt.c @@ -186,8 +186,8 @@ static int __init ixp4xx_wdt_init(void) unsigned long processor_id; asm("mrc p15, 0, %0, cr0, cr0, 0;" : "=r"(processor_id) :); - if (!(processor_id & 0xf) && !cpu_is_ixp46x()) { - printk("IXP4XXX Watchdog: Rev. A0 IXP42x CPU detected - " + if (!(processor_id & 0xf)) { + printk("IXP4XXX Watchdog: Rev. A0 CPU detected - " "watchdog disabled\n"); return -ENODEV; diff --git a/trunk/drivers/char/watchdog/pcwd_usb.c b/trunk/drivers/char/watchdog/pcwd_usb.c index 1533f56baa42..092e9b133750 100644 --- a/trunk/drivers/char/watchdog/pcwd_usb.c +++ b/trunk/drivers/char/watchdog/pcwd_usb.c @@ -151,6 +151,7 @@ static void usb_pcwd_disconnect (struct usb_interface *interface); /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver usb_pcwd_driver = { + .owner = THIS_MODULE, .name = DRIVER_NAME, .probe = usb_pcwd_probe, .disconnect = usb_pcwd_disconnect, diff --git a/trunk/drivers/cpufreq/cpufreq.c b/trunk/drivers/cpufreq/cpufreq.c index a9163d02983a..815902c2c856 100644 --- a/trunk/drivers/cpufreq/cpufreq.c +++ b/trunk/drivers/cpufreq/cpufreq.c @@ -822,30 +822,6 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigne } -/** - * cpufreq_quick_get - get the CPU frequency (in kHz) frpm policy->cur - * @cpu: CPU number - * - * This is the last known freq, without actually getting it from the driver. - * Return value will be same as what is shown in scaling_cur_freq in sysfs. - */ -unsigned int cpufreq_quick_get(unsigned int cpu) -{ - struct cpufreq_policy *policy = cpufreq_cpu_get(cpu); - unsigned int ret = 0; - - if (policy) { - down(&policy->lock); - ret = policy->cur; - up(&policy->lock); - cpufreq_cpu_put(policy); - } - - return (ret); -} -EXPORT_SYMBOL(cpufreq_quick_get); - - /** * cpufreq_get - get the current CPU frequency (in kHz) * @cpu: CPU number diff --git a/trunk/drivers/cpufreq/cpufreq_conservative.c b/trunk/drivers/cpufreq/cpufreq_conservative.c index 39543a2bed0f..2ed5c4363b53 100644 --- a/trunk/drivers/cpufreq/cpufreq_conservative.c +++ b/trunk/drivers/cpufreq/cpufreq_conservative.c @@ -93,7 +93,7 @@ static inline unsigned int get_cpu_idle_time(unsigned int cpu) { return kstat_cpu(cpu).cpustat.idle + kstat_cpu(cpu).cpustat.iowait + - ( dbs_tuners_ins.ignore_nice ? + ( !dbs_tuners_ins.ignore_nice ? kstat_cpu(cpu).cpustat.nice : 0); } @@ -127,7 +127,7 @@ show_one(sampling_rate, sampling_rate); show_one(sampling_down_factor, sampling_down_factor); show_one(up_threshold, up_threshold); show_one(down_threshold, down_threshold); -show_one(ignore_nice_load, ignore_nice); +show_one(ignore_nice, ignore_nice); show_one(freq_step, freq_step); static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, @@ -207,7 +207,7 @@ static ssize_t store_down_threshold(struct cpufreq_policy *unused, return count; } -static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, +static ssize_t store_ignore_nice(struct cpufreq_policy *policy, const char *buf, size_t count) { unsigned int input; @@ -272,7 +272,7 @@ define_one_rw(sampling_rate); define_one_rw(sampling_down_factor); define_one_rw(up_threshold); define_one_rw(down_threshold); -define_one_rw(ignore_nice_load); +define_one_rw(ignore_nice); define_one_rw(freq_step); static struct attribute * dbs_attributes[] = { @@ -282,7 +282,7 @@ static struct attribute * dbs_attributes[] = { &sampling_down_factor.attr, &up_threshold.attr, &down_threshold.attr, - &ignore_nice_load.attr, + &ignore_nice.attr, &freq_step.attr, NULL }; diff --git a/trunk/drivers/cpufreq/cpufreq_ondemand.c b/trunk/drivers/cpufreq/cpufreq_ondemand.c index e69fd8dd1f1c..17741111246b 100644 --- a/trunk/drivers/cpufreq/cpufreq_ondemand.c +++ b/trunk/drivers/cpufreq/cpufreq_ondemand.c @@ -89,7 +89,7 @@ static inline unsigned int get_cpu_idle_time(unsigned int cpu) { return kstat_cpu(cpu).cpustat.idle + kstat_cpu(cpu).cpustat.iowait + - ( dbs_tuners_ins.ignore_nice ? + ( !dbs_tuners_ins.ignore_nice ? kstat_cpu(cpu).cpustat.nice : 0); } @@ -122,7 +122,7 @@ static ssize_t show_##file_name \ show_one(sampling_rate, sampling_rate); show_one(sampling_down_factor, sampling_down_factor); show_one(up_threshold, up_threshold); -show_one(ignore_nice_load, ignore_nice); +show_one(ignore_nice, ignore_nice); static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, const char *buf, size_t count) @@ -182,7 +182,7 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused, return count; } -static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, +static ssize_t store_ignore_nice(struct cpufreq_policy *policy, const char *buf, size_t count) { unsigned int input; @@ -223,7 +223,7 @@ __ATTR(_name, 0644, show_##_name, store_##_name) define_one_rw(sampling_rate); define_one_rw(sampling_down_factor); define_one_rw(up_threshold); -define_one_rw(ignore_nice_load); +define_one_rw(ignore_nice); static struct attribute * dbs_attributes[] = { &sampling_rate_max.attr, @@ -231,7 +231,7 @@ static struct attribute * dbs_attributes[] = { &sampling_rate.attr, &sampling_down_factor.attr, &up_threshold.attr, - &ignore_nice_load.attr, + &ignore_nice.attr, NULL }; diff --git a/trunk/drivers/ide/ide-cd.c b/trunk/drivers/ide/ide-cd.c index 70aeb3a60120..b4d7a3efb90f 100644 --- a/trunk/drivers/ide/ide-cd.c +++ b/trunk/drivers/ide/ide-cd.c @@ -3509,7 +3509,6 @@ static int __init ide_cdrom_init(void) return driver_register(&ide_cdrom_driver.gen_driver); } -MODULE_ALIAS("ide:*m-cdrom*"); module_init(ide_cdrom_init); module_exit(ide_cdrom_exit); MODULE_LICENSE("GPL"); diff --git a/trunk/drivers/ide/ide-disk.c b/trunk/drivers/ide/ide-disk.c index 4e5767968d7f..449522f0540c 100644 --- a/trunk/drivers/ide/ide-disk.c +++ b/trunk/drivers/ide/ide-disk.c @@ -1271,7 +1271,6 @@ static int __init idedisk_init(void) return driver_register(&idedisk_driver.gen_driver); } -MODULE_ALIAS("ide:*m-disk*"); module_init(idedisk_init); module_exit(idedisk_exit); MODULE_LICENSE("GPL"); diff --git a/trunk/drivers/ide/ide-floppy.c b/trunk/drivers/ide/ide-floppy.c index fba3fffc2d66..9e293c8063dc 100644 --- a/trunk/drivers/ide/ide-floppy.c +++ b/trunk/drivers/ide/ide-floppy.c @@ -2197,7 +2197,6 @@ static int __init idefloppy_init(void) return driver_register(&idefloppy_driver.gen_driver); } -MODULE_ALIAS("ide:*m-floppy*"); module_init(idefloppy_init); module_exit(idefloppy_exit); MODULE_LICENSE("GPL"); diff --git a/trunk/drivers/ide/ide-tape.c b/trunk/drivers/ide/ide-tape.c index fab9b2b02504..7d7944ed4158 100644 --- a/trunk/drivers/ide/ide-tape.c +++ b/trunk/drivers/ide/ide-tape.c @@ -4947,7 +4947,6 @@ static int __init idetape_init(void) return error; } -MODULE_ALIAS("ide:*m-tape*"); module_init(idetape_init); module_exit(idetape_exit); MODULE_ALIAS_CHARDEV_MAJOR(IDETAPE_MAJOR); diff --git a/trunk/drivers/ide/ide.c b/trunk/drivers/ide/ide.c index 4b524f6b3ecd..8af179b531c3 100644 --- a/trunk/drivers/ide/ide.c +++ b/trunk/drivers/ide/ide.c @@ -1904,69 +1904,9 @@ static int ide_bus_match(struct device *dev, struct device_driver *drv) return 1; } -static char *media_string(ide_drive_t *drive) -{ - switch (drive->media) { - case ide_disk: - return "disk"; - case ide_cdrom: - return "cdrom"; - case ide_tape: - return "tape"; - case ide_floppy: - return "floppy"; - default: - return "UNKNOWN"; - } -} - -static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf) -{ - ide_drive_t *drive = to_ide_device(dev); - return sprintf(buf, "%s\n", media_string(drive)); -} - -static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf) -{ - ide_drive_t *drive = to_ide_device(dev); - return sprintf(buf, "%s\n", drive->name); -} - -static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) -{ - ide_drive_t *drive = to_ide_device(dev); - return sprintf(buf, "ide:m-%s\n", media_string(drive)); -} - -static struct device_attribute ide_dev_attrs[] = { - __ATTR_RO(media), - __ATTR_RO(drivename), - __ATTR_RO(modalias), - __ATTR_NULL -}; - -static int ide_uevent(struct device *dev, char **envp, int num_envp, - char *buffer, int buffer_size) -{ - ide_drive_t *drive = to_ide_device(dev); - int i = 0; - int length = 0; - - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, - "MEDIA=%s", media_string(drive)); - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, - "DRIVENAME=%s", drive->name); - add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length, - "MODALIAS=ide:m-%s", media_string(drive)); - envp[i] = NULL; - return 0; -} - struct bus_type ide_bus_type = { .name = "ide", .match = ide_bus_match, - .uevent = ide_uevent, - .dev_attrs = ide_dev_attrs, .suspend = generic_ide_suspend, .resume = generic_ide_resume, }; diff --git a/trunk/drivers/ide/legacy/ide-cs.c b/trunk/drivers/ide/legacy/ide-cs.c index 4c2af9020905..ef79805218e4 100644 --- a/trunk/drivers/ide/legacy/ide-cs.c +++ b/trunk/drivers/ide/legacy/ide-cs.c @@ -88,12 +88,15 @@ typedef struct ide_info_t { } ide_info_t; static void ide_release(dev_link_t *); -static void ide_config(dev_link_t *); - -static void ide_detach(struct pcmcia_device *p_dev); +static int ide_event(event_t event, int priority, + event_callback_args_t *args); +static dev_info_t dev_info = "ide-cs"; +static dev_link_t *ide_attach(void); +static void ide_detach(dev_link_t *); +static dev_link_t *dev_list = NULL; /*====================================================================== @@ -103,17 +106,18 @@ static void ide_detach(struct pcmcia_device *p_dev); ======================================================================*/ -static int ide_attach(struct pcmcia_device *p_dev) +static dev_link_t *ide_attach(void) { ide_info_t *info; dev_link_t *link; - + client_reg_t client_reg; + int ret; + DEBUG(0, "ide_attach()\n"); /* Create new ide device */ info = kzalloc(sizeof(*info), GFP_KERNEL); - if (!info) - return -ENOMEM; + if (!info) return NULL; link = &info->link; link->priv = info; link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; @@ -124,14 +128,21 @@ static int ide_attach(struct pcmcia_device *p_dev) link->conf.Attributes = CONF_ENABLE_IRQ; link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - ide_config(link); - - return 0; + + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + ide_detach(link); + return NULL; + } + + return link; } /* ide_attach */ /*====================================================================== @@ -143,16 +154,32 @@ static int ide_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void ide_detach(struct pcmcia_device *p_dev) +static void ide_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; + int ret; DEBUG(0, "ide_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) ide_release(link); - + + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + /* Unlink, free device structure */ + *linkp = link->next; kfree(link->priv); + } /* ide_detach */ static int idecs_register(unsigned long io, unsigned long ctl, unsigned long irq, struct pcmcia_device *handle) @@ -379,28 +406,6 @@ void ide_release(dev_link_t *link) } /* ide_release */ -static int ide_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int ide_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state &= ~DEV_SUSPEND; - if (DEV_OK(link)) - pcmcia_request_configuration(link->handle, &link->conf); - - return 0; -} - /*====================================================================== The card status event handler. Mostly, this schedules other @@ -410,15 +415,48 @@ static int ide_resume(struct pcmcia_device *dev) ======================================================================*/ +int ide_event(event_t event, int priority, + event_callback_args_t *args) +{ + dev_link_t *link = args->client_data; + + DEBUG(1, "ide_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + ide_release(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + ide_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (DEV_OK(link)) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } + return 0; +} /* ide_event */ + static struct pcmcia_device_id ide_ids[] = { PCMCIA_DEVICE_FUNC_ID(4), - PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */ PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704), PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401), PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000), /* Toshiba */ PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d), PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000), /* Samsung */ - PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000), /* Hitachi */ PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001), PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200), /* Lexar */ PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0), @@ -433,8 +471,6 @@ static struct pcmcia_device_id ide_ids[] = { PCMCIA_DEVICE_PROD_ID12("EXP ", "CD-ROM", 0x0a5c52fd, 0x66536591), PCMCIA_DEVICE_PROD_ID12("EXP ", "PnPIDE", 0x0a5c52fd, 0x0c694728), PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e), - PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae), - PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178), PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753), PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2 ", 0x547e66dc, 0x8671043b), PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149), @@ -458,11 +494,10 @@ static struct pcmcia_driver ide_cs_driver = { .drv = { .name = "ide-cs", }, - .probe = ide_attach, - .remove = ide_detach, + .attach = ide_attach, + .event = ide_event, + .detach = ide_detach, .id_table = ide_ids, - .suspend = ide_suspend, - .resume = ide_resume, }; static int __init init_ide_cs(void) @@ -473,6 +508,7 @@ static int __init init_ide_cs(void) static void __exit exit_ide_cs(void) { pcmcia_unregister_driver(&ide_cs_driver); + BUG_ON(dev_list != NULL); } late_initcall(init_ide_cs); diff --git a/trunk/drivers/ieee1394/.gitignore b/trunk/drivers/ieee1394/.gitignore deleted file mode 100644 index 33da10a25323..000000000000 --- a/trunk/drivers/ieee1394/.gitignore +++ /dev/null @@ -1 +0,0 @@ -oui.c diff --git a/trunk/drivers/ieee1394/Kconfig b/trunk/drivers/ieee1394/Kconfig index 39142e2f804b..25103a0ef9b3 100644 --- a/trunk/drivers/ieee1394/Kconfig +++ b/trunk/drivers/ieee1394/Kconfig @@ -169,4 +169,27 @@ config IEEE1394_RAWIO To compile this driver as a module, say M here: the module will be called raw1394. +config IEEE1394_CMP + tristate "IEC61883-1 Plug support" + depends on IEEE1394 + help + This option enables the Connection Management Procedures + (IEC61883-1) driver, which implements input and output plugs. + + To compile this driver as a module, say M here: the + module will be called cmp. + +config IEEE1394_AMDTP + tristate "IEC61883-6 (Audio transmission) support" + depends on IEEE1394 && IEEE1394_OHCI1394 && IEEE1394_CMP + help + This option enables the Audio & Music Data Transmission Protocol + (IEC61883-6) driver, which implements audio transmission over + IEEE1394. + + The userspace interface is documented in amdtp.h. + + To compile this driver as a module, say M here: the + module will be called amdtp. + endmenu diff --git a/trunk/drivers/ieee1394/Makefile b/trunk/drivers/ieee1394/Makefile index 6f53611fe255..e8b4d48d376e 100644 --- a/trunk/drivers/ieee1394/Makefile +++ b/trunk/drivers/ieee1394/Makefile @@ -14,6 +14,8 @@ obj-$(CONFIG_IEEE1394_RAWIO) += raw1394.o obj-$(CONFIG_IEEE1394_SBP2) += sbp2.o obj-$(CONFIG_IEEE1394_DV1394) += dv1394.o obj-$(CONFIG_IEEE1394_ETH1394) += eth1394.o +obj-$(CONFIG_IEEE1394_AMDTP) += amdtp.o +obj-$(CONFIG_IEEE1394_CMP) += cmp.o quiet_cmd_oui2c = OUI2C $@ cmd_oui2c = $(CONFIG_SHELL) $(srctree)/$(src)/oui2c.sh < $< > $@ diff --git a/trunk/drivers/ieee1394/csr1212.c b/trunk/drivers/ieee1394/csr1212.c index 15773544234b..61ddd5d37eff 100644 --- a/trunk/drivers/ieee1394/csr1212.c +++ b/trunk/drivers/ieee1394/csr1212.c @@ -1261,7 +1261,7 @@ static int csr1212_parse_bus_info_block(struct csr1212_csr *csr) return CSR1212_EINVAL; #endif - cr = CSR1212_MALLOC(sizeof(*cr)); + cr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region)); if (!cr) return CSR1212_ENOMEM; @@ -1393,7 +1393,8 @@ int csr1212_parse_keyval(struct csr1212_keyval *kv, case CSR1212_KV_TYPE_LEAF: if (kv->key.id != CSR1212_KV_ID_EXTENDED_ROM) { kv->value.leaf.data = CSR1212_MALLOC(quads_to_bytes(kvi_len)); - if (!kv->value.leaf.data) { + if (!kv->value.leaf.data) + { ret = CSR1212_ENOMEM; goto fail; } @@ -1461,7 +1462,7 @@ int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv) cache->next = NULL; csr->cache_tail = cache; cache->filled_head = - CSR1212_MALLOC(sizeof(*cache->filled_head)); + CSR1212_MALLOC(sizeof(struct csr1212_cache_region)); if (!cache->filled_head) { return CSR1212_ENOMEM; } @@ -1483,7 +1484,7 @@ int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv) /* Now seach read portions of the cache to see if it is there. */ for (cr = cache->filled_head; cr; cr = cr->next) { if (cache_index < cr->offset_start) { - newcr = CSR1212_MALLOC(sizeof(*newcr)); + newcr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region)); if (!newcr) return CSR1212_ENOMEM; @@ -1507,7 +1508,7 @@ int _csr1212_read_keyval(struct csr1212_csr *csr, struct csr1212_keyval *kv) if (!cr) { cr = cache->filled_tail; - newcr = CSR1212_MALLOC(sizeof(*newcr)); + newcr = CSR1212_MALLOC(sizeof(struct csr1212_cache_region)); if (!newcr) return CSR1212_ENOMEM; @@ -1610,17 +1611,15 @@ int csr1212_parse_csr(struct csr1212_csr *csr) csr->root_kv->valid = 0; csr->root_kv->next = csr->root_kv; csr->root_kv->prev = csr->root_kv; - ret = _csr1212_read_keyval(csr, csr->root_kv); - if (ret != CSR1212_SUCCESS) - return ret; + csr1212_get_keyval(csr, csr->root_kv); /* Scan through the Root directory finding all extended ROM regions * and make cache regions for them */ for (dentry = csr->root_kv->value.directory.dentries_head; dentry; dentry = dentry->next) { - if (dentry->kv->key.id == CSR1212_KV_ID_EXTENDED_ROM && - !dentry->kv->valid) { - ret = _csr1212_read_keyval(csr, dentry->kv); + if (dentry->kv->key.id == CSR1212_KV_ID_EXTENDED_ROM) { + csr1212_get_keyval(csr, dentry->kv); + if (ret != CSR1212_SUCCESS) return ret; } diff --git a/trunk/drivers/ieee1394/csr1212.h b/trunk/drivers/ieee1394/csr1212.h index cecd5871f2de..28c5f4b726e2 100644 --- a/trunk/drivers/ieee1394/csr1212.h +++ b/trunk/drivers/ieee1394/csr1212.h @@ -646,7 +646,7 @@ static inline struct csr1212_csr_rom_cache *csr1212_rom_cache_malloc(u_int32_t o { struct csr1212_csr_rom_cache *cache; - cache = CSR1212_MALLOC(sizeof(*cache) + size); + cache = CSR1212_MALLOC(sizeof(struct csr1212_csr_rom_cache) + size); if (!cache) return NULL; diff --git a/trunk/drivers/ieee1394/dma.c b/trunk/drivers/ieee1394/dma.c index 9fb2769d9abc..b79ddb43e746 100644 --- a/trunk/drivers/ieee1394/dma.c +++ b/trunk/drivers/ieee1394/dma.c @@ -23,8 +23,7 @@ void dma_prog_region_init(struct dma_prog_region *prog) prog->bus_addr = 0; } -int dma_prog_region_alloc(struct dma_prog_region *prog, unsigned long n_bytes, - struct pci_dev *dev) +int dma_prog_region_alloc(struct dma_prog_region *prog, unsigned long n_bytes, struct pci_dev *dev) { /* round up to page size */ n_bytes = PAGE_ALIGN(n_bytes); @@ -33,8 +32,7 @@ int dma_prog_region_alloc(struct dma_prog_region *prog, unsigned long n_bytes, prog->kvirt = pci_alloc_consistent(dev, n_bytes, &prog->bus_addr); if (!prog->kvirt) { - printk(KERN_ERR - "dma_prog_region_alloc: pci_alloc_consistent() failed\n"); + printk(KERN_ERR "dma_prog_region_alloc: pci_alloc_consistent() failed\n"); dma_prog_region_free(prog); return -ENOMEM; } @@ -47,8 +45,7 @@ int dma_prog_region_alloc(struct dma_prog_region *prog, unsigned long n_bytes, void dma_prog_region_free(struct dma_prog_region *prog) { if (prog->kvirt) { - pci_free_consistent(prog->dev, prog->n_pages << PAGE_SHIFT, - prog->kvirt, prog->bus_addr); + pci_free_consistent(prog->dev, prog->n_pages << PAGE_SHIFT, prog->kvirt, prog->bus_addr); } prog->kvirt = NULL; @@ -68,8 +65,7 @@ void dma_region_init(struct dma_region *dma) dma->sglist = NULL; } -int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes, - struct pci_dev *dev, int direction) +int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes, struct pci_dev *dev, int direction) { unsigned int i; @@ -99,16 +95,14 @@ int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes, /* fill scatter/gather list with pages */ for (i = 0; i < dma->n_pages; i++) { - unsigned long va = - (unsigned long)dma->kvirt + (i << PAGE_SHIFT); + unsigned long va = (unsigned long) dma->kvirt + (i << PAGE_SHIFT); dma->sglist[i].page = vmalloc_to_page((void *)va); dma->sglist[i].length = PAGE_SIZE; } /* map sglist to the IOMMU */ - dma->n_dma_pages = - pci_map_sg(dev, dma->sglist, dma->n_pages, direction); + dma->n_dma_pages = pci_map_sg(dev, dma->sglist, dma->n_pages, direction); if (dma->n_dma_pages == 0) { printk(KERN_ERR "dma_region_alloc: pci_map_sg() failed\n"); @@ -120,7 +114,7 @@ int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes, return 0; - err: +err: dma_region_free(dma); return -ENOMEM; } @@ -128,8 +122,7 @@ int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes, void dma_region_free(struct dma_region *dma) { if (dma->n_dma_pages) { - pci_unmap_sg(dma->dev, dma->sglist, dma->n_pages, - dma->direction); + pci_unmap_sg(dma->dev, dma->sglist, dma->n_pages, dma->direction); dma->n_dma_pages = 0; dma->dev = NULL; } @@ -144,8 +137,7 @@ void dma_region_free(struct dma_region *dma) /* find the scatterlist index and remaining offset corresponding to a given offset from the beginning of the buffer */ -static inline int dma_region_find(struct dma_region *dma, unsigned long offset, - unsigned long *rem) +static inline int dma_region_find(struct dma_region *dma, unsigned long offset, unsigned long *rem) { int i; unsigned long off = offset; @@ -164,18 +156,15 @@ static inline int dma_region_find(struct dma_region *dma, unsigned long offset, return i; } -dma_addr_t dma_region_offset_to_bus(struct dma_region * dma, - unsigned long offset) +dma_addr_t dma_region_offset_to_bus(struct dma_region *dma, unsigned long offset) { unsigned long rem = 0; - struct scatterlist *sg = - &dma->sglist[dma_region_find(dma, offset, &rem)]; + struct scatterlist *sg = &dma->sglist[dma_region_find(dma, offset, &rem)]; return sg_dma_address(sg) + rem; } -void dma_region_sync_for_cpu(struct dma_region *dma, unsigned long offset, - unsigned long len) +void dma_region_sync_for_cpu(struct dma_region *dma, unsigned long offset, unsigned long len) { int first, last; unsigned long rem; @@ -186,12 +175,10 @@ void dma_region_sync_for_cpu(struct dma_region *dma, unsigned long offset, first = dma_region_find(dma, offset, &rem); last = dma_region_find(dma, offset + len - 1, &rem); - pci_dma_sync_sg_for_cpu(dma->dev, &dma->sglist[first], last - first + 1, - dma->direction); + pci_dma_sync_sg_for_cpu(dma->dev, &dma->sglist[first], last - first + 1, dma->direction); } -void dma_region_sync_for_device(struct dma_region *dma, unsigned long offset, - unsigned long len) +void dma_region_sync_for_device(struct dma_region *dma, unsigned long offset, unsigned long len) { int first, last; unsigned long rem; @@ -202,47 +189,44 @@ void dma_region_sync_for_device(struct dma_region *dma, unsigned long offset, first = dma_region_find(dma, offset, &rem); last = dma_region_find(dma, offset + len - 1, &rem); - pci_dma_sync_sg_for_device(dma->dev, &dma->sglist[first], - last - first + 1, dma->direction); + pci_dma_sync_sg_for_device(dma->dev, &dma->sglist[first], last - first + 1, dma->direction); } #ifdef CONFIG_MMU /* nopage() handler for mmap access */ -static struct page *dma_region_pagefault(struct vm_area_struct *area, - unsigned long address, int *type) +static struct page* +dma_region_pagefault(struct vm_area_struct *area, unsigned long address, int *type) { unsigned long offset; unsigned long kernel_virt_addr; struct page *ret = NOPAGE_SIGBUS; - struct dma_region *dma = (struct dma_region *)area->vm_private_data; + struct dma_region *dma = (struct dma_region*) area->vm_private_data; if (!dma->kvirt) goto out; - if ((address < (unsigned long)area->vm_start) || - (address > - (unsigned long)area->vm_start + (dma->n_pages << PAGE_SHIFT))) + if ( (address < (unsigned long) area->vm_start) || + (address > (unsigned long) area->vm_start + (dma->n_pages << PAGE_SHIFT)) ) goto out; if (type) *type = VM_FAULT_MINOR; offset = address - area->vm_start; - kernel_virt_addr = (unsigned long)dma->kvirt + offset; - ret = vmalloc_to_page((void *)kernel_virt_addr); + kernel_virt_addr = (unsigned long) dma->kvirt + offset; + ret = vmalloc_to_page((void*) kernel_virt_addr); get_page(ret); - out: +out: return ret; } static struct vm_operations_struct dma_region_vm_ops = { - .nopage = dma_region_pagefault, + .nopage = dma_region_pagefault, }; -int dma_region_mmap(struct dma_region *dma, struct file *file, - struct vm_area_struct *vma) +int dma_region_mmap(struct dma_region *dma, struct file *file, struct vm_area_struct *vma) { unsigned long size; @@ -266,12 +250,11 @@ int dma_region_mmap(struct dma_region *dma, struct file *file, return 0; } -#else /* CONFIG_MMU */ +#else /* CONFIG_MMU */ -int dma_region_mmap(struct dma_region *dma, struct file *file, - struct vm_area_struct *vma) +int dma_region_mmap(struct dma_region *dma, struct file *file, struct vm_area_struct *vma) { return -EINVAL; } -#endif /* CONFIG_MMU */ +#endif /* CONFIG_MMU */ diff --git a/trunk/drivers/ieee1394/dv1394.c b/trunk/drivers/ieee1394/dv1394.c index 196db7439272..cbbbe14b8849 100644 --- a/trunk/drivers/ieee1394/dv1394.c +++ b/trunk/drivers/ieee1394/dv1394.c @@ -123,6 +123,15 @@ #include "ohci1394.h" +#ifndef virt_to_page +#define virt_to_page(x) MAP_NR(x) +#endif + +#ifndef vmalloc_32 +#define vmalloc_32(x) vmalloc(x) +#endif + + /* DEBUG LEVELS: 0 - no debugging messages 1 - some debugging messages, but none during DMA frame transmission @@ -2209,12 +2218,14 @@ static int dv1394_init(struct ti_ohci *ohci, enum pal_or_ntsc format, enum modes unsigned long flags; int i; - video = kzalloc(sizeof(*video), GFP_KERNEL); + video = kmalloc(sizeof(struct video_card), GFP_KERNEL); if (!video) { printk(KERN_ERR "dv1394: cannot allocate video_card\n"); goto err; } + memset(video, 0, sizeof(struct video_card)); + video->ohci = ohci; /* lower 2 bits of id indicate which of four "plugs" per host */ diff --git a/trunk/drivers/ieee1394/eth1394.c b/trunk/drivers/ieee1394/eth1394.c index 30fa0d43a43a..c9e92d85c893 100644 --- a/trunk/drivers/ieee1394/eth1394.c +++ b/trunk/drivers/ieee1394/eth1394.c @@ -88,6 +88,9 @@ printk(KERN_ERR "%s:%s[%d]: " fmt "\n", driver_name, __FUNCTION__, __LINE__, ## args) #define TRACE() printk(KERN_ERR "%s:%s[%d] ---- TRACE\n", driver_name, __FUNCTION__, __LINE__) +static char version[] __devinitdata = + "$Rev: 1312 $ Ben Collins "; + struct fragment_info { struct list_head list; int offset; @@ -352,12 +355,12 @@ static int eth1394_probe(struct device *dev) if (!hi) return -ENOENT; - new_node = kmalloc(sizeof(*new_node), + new_node = kmalloc(sizeof(struct eth1394_node_ref), in_interrupt() ? GFP_ATOMIC : GFP_KERNEL); if (!new_node) return -ENOMEM; - node_info = kmalloc(sizeof(*node_info), + node_info = kmalloc(sizeof(struct eth1394_node_info), in_interrupt() ? GFP_ATOMIC : GFP_KERNEL); if (!node_info) { kfree(new_node); @@ -433,12 +436,12 @@ static int eth1394_update(struct unit_directory *ud) node = eth1394_find_node(&priv->ip_node_list, ud); if (!node) { - node = kmalloc(sizeof(*node), + node = kmalloc(sizeof(struct eth1394_node_ref), in_interrupt() ? GFP_ATOMIC : GFP_KERNEL); if (!node) return -ENOMEM; - node_info = kmalloc(sizeof(*node_info), + node_info = kmalloc(sizeof(struct eth1394_node_info), in_interrupt() ? GFP_ATOMIC : GFP_KERNEL); if (!node_info) { kfree(node); @@ -563,6 +566,7 @@ static void ether1394_add_host (struct hpsb_host *host) struct eth1394_host_info *hi = NULL; struct net_device *dev = NULL; struct eth1394_priv *priv; + static int version_printed = 0; u64 fifo_addr; if (!(host->config_roms & HPSB_CONFIG_ROM_ENTRY_IP1394)) @@ -577,6 +581,9 @@ static void ether1394_add_host (struct hpsb_host *host) if (fifo_addr == ~0ULL) goto out; + if (version_printed++ == 0) + ETH1394_PRINT_G (KERN_INFO, "%s\n", version); + /* We should really have our own alloc_hpsbdev() function in * net_init.c instead of calling the one for ethernet then hijacking * it for ourselves. That way we'd be a real networking device. */ @@ -1014,7 +1021,7 @@ static inline int new_fragment(struct list_head *frag_info, int offset, int len) } } - new = kmalloc(sizeof(*new), GFP_ATOMIC); + new = kmalloc(sizeof(struct fragment_info), GFP_ATOMIC); if (!new) return -ENOMEM; @@ -1033,7 +1040,7 @@ static inline int new_partial_datagram(struct net_device *dev, { struct partial_datagram *new; - new = kmalloc(sizeof(*new), GFP_ATOMIC); + new = kmalloc(sizeof(struct partial_datagram), GFP_ATOMIC); if (!new) return -ENOMEM; @@ -1761,6 +1768,7 @@ static int ether1394_tx (struct sk_buff *skb, struct net_device *dev) static void ether1394_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) { strcpy (info->driver, driver_name); + strcpy (info->version, "$Rev: 1312 $"); /* FIXME XXX provide sane businfo */ strcpy (info->bus_info, "ieee1394"); } diff --git a/trunk/drivers/ieee1394/highlevel.c b/trunk/drivers/ieee1394/highlevel.c index 734b121a0554..997e1bf6297f 100644 --- a/trunk/drivers/ieee1394/highlevel.c +++ b/trunk/drivers/ieee1394/highlevel.c @@ -101,10 +101,12 @@ void *hpsb_create_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host, return NULL; } - hi = kzalloc(sizeof(*hi) + data_size, GFP_ATOMIC); + hi = kmalloc(sizeof(*hi) + data_size, GFP_ATOMIC); if (!hi) return NULL; + memset(hi, 0, sizeof(*hi) + data_size); + if (data_size) { data = hi->data = hi + 1; hi->size = data_size; @@ -324,9 +326,11 @@ u64 hpsb_allocate_and_register_addrspace(struct hpsb_highlevel *hl, return retval; } - as = kmalloc(sizeof(*as), GFP_KERNEL); - if (!as) + as = (struct hpsb_address_serve *) + kmalloc(sizeof(struct hpsb_address_serve), GFP_KERNEL); + if (as == NULL) { return retval; + } INIT_LIST_HEAD(&as->host_list); INIT_LIST_HEAD(&as->hl_list); @@ -379,9 +383,11 @@ int hpsb_register_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host, return 0; } - as = kmalloc(sizeof(*as), GFP_ATOMIC); - if (!as) - return 0; + as = (struct hpsb_address_serve *) + kmalloc(sizeof(struct hpsb_address_serve), GFP_ATOMIC); + if (as == NULL) { + return 0; + } INIT_LIST_HEAD(&as->host_list); INIT_LIST_HEAD(&as->hl_list); diff --git a/trunk/drivers/ieee1394/hosts.c b/trunk/drivers/ieee1394/hosts.c index ba09741fc826..aeeaeb670d03 100644 --- a/trunk/drivers/ieee1394/hosts.c +++ b/trunk/drivers/ieee1394/hosts.c @@ -61,12 +61,12 @@ static void delayed_reset_bus(void * __reset_info) static int dummy_transmit_packet(struct hpsb_host *h, struct hpsb_packet *p) { - return 0; + return 0; } static int dummy_devctl(struct hpsb_host *h, enum devctl_cmd c, int arg) { - return -1; + return -1; } static int dummy_isoctl(struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg) @@ -75,9 +75,9 @@ static int dummy_isoctl(struct hpsb_iso *iso, enum isoctl_cmd command, unsigned } static struct hpsb_host_driver dummy_driver = { - .transmit_packet = dummy_transmit_packet, - .devctl = dummy_devctl, - .isoctl = dummy_isoctl + .transmit_packet = dummy_transmit_packet, + .devctl = dummy_devctl, + .isoctl = dummy_isoctl }; static int alloc_hostnum_cb(struct hpsb_host *host, void *__data) @@ -110,13 +110,13 @@ static DECLARE_MUTEX(host_num_alloc); struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra, struct device *dev) { - struct hpsb_host *h; + struct hpsb_host *h; int i; int hostnum = 0; - h = kzalloc(sizeof(*h) + extra, SLAB_KERNEL); - if (!h) - return NULL; + h = kmalloc(sizeof(struct hpsb_host) + extra, SLAB_KERNEL); + if (!h) return NULL; + memset(h, 0, sizeof(struct hpsb_host) + extra); h->csr.rom = csr1212_create_csr(&csr_bus_ops, CSR_BUS_INFO_SIZE, h); if (!h->csr.rom) { @@ -125,7 +125,7 @@ struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra, } h->hostdata = h + 1; - h->driver = drv; + h->driver = drv; skb_queue_head_init(&h->pending_packet_queue); INIT_LIST_HEAD(&h->addr_space); @@ -145,8 +145,8 @@ struct hpsb_host *hpsb_alloc_host(struct hpsb_host_driver *drv, size_t extra, h->timeout.function = abort_timedouts; h->timeout_interval = HZ / 20; // 50ms by default - h->topology_map = h->csr.topology_map + 3; - h->speed_map = (u8 *)(h->csr.speed_map + 2); + h->topology_map = h->csr.topology_map + 3; + h->speed_map = (u8 *)(h->csr.speed_map + 2); down(&host_num_alloc); @@ -186,14 +186,14 @@ int hpsb_add_host(struct hpsb_host *host) void hpsb_remove_host(struct hpsb_host *host) { - host->is_shutdown = 1; + host->is_shutdown = 1; cancel_delayed_work(&host->delayed_reset); flush_scheduled_work(); - host->driver = &dummy_driver; + host->driver = &dummy_driver; - highlevel_remove_host(host); + highlevel_remove_host(host); hpsb_remove_extra_config_roms(host); diff --git a/trunk/drivers/ieee1394/hosts.h b/trunk/drivers/ieee1394/hosts.h index 07d188ca8495..ae9b02cc013f 100644 --- a/trunk/drivers/ieee1394/hosts.h +++ b/trunk/drivers/ieee1394/hosts.h @@ -17,47 +17,47 @@ struct hpsb_packet; struct hpsb_iso; struct hpsb_host { - struct list_head host_list; + struct list_head host_list; - void *hostdata; + void *hostdata; - atomic_t generation; + atomic_t generation; struct sk_buff_head pending_packet_queue; struct timer_list timeout; unsigned long timeout_interval; - unsigned char iso_listen_count[64]; + unsigned char iso_listen_count[64]; - int node_count; /* number of identified nodes on this bus */ - int selfid_count; /* total number of SelfIDs received */ + int node_count; /* number of identified nodes on this bus */ + int selfid_count; /* total number of SelfIDs received */ int nodes_active; /* number of nodes that are actually active */ - nodeid_t node_id; /* node ID of this host */ - nodeid_t irm_id; /* ID of this bus' isochronous resource manager */ - nodeid_t busmgr_id; /* ID of this bus' bus manager */ + nodeid_t node_id; /* node ID of this host */ + nodeid_t irm_id; /* ID of this bus' isochronous resource manager */ + nodeid_t busmgr_id; /* ID of this bus' bus manager */ - /* this nodes state */ - unsigned in_bus_reset:1; - unsigned is_shutdown:1; + /* this nodes state */ + unsigned in_bus_reset:1; + unsigned is_shutdown:1; unsigned resume_packet_sent:1; - /* this nodes' duties on the bus */ - unsigned is_root:1; - unsigned is_cycmst:1; - unsigned is_irm:1; - unsigned is_busmgr:1; + /* this nodes' duties on the bus */ + unsigned is_root:1; + unsigned is_cycmst:1; + unsigned is_irm:1; + unsigned is_busmgr:1; - int reset_retries; - quadlet_t *topology_map; - u8 *speed_map; - struct csr_control csr; + int reset_retries; + quadlet_t *topology_map; + u8 *speed_map; + struct csr_control csr; /* Per node tlabel pool allocation */ struct hpsb_tlabel_pool tpool[64]; - struct hpsb_host_driver *driver; + struct hpsb_host_driver *driver; struct pci_dev *pdev; @@ -77,34 +77,34 @@ struct hpsb_host { enum devctl_cmd { - /* Host is requested to reset its bus and cancel all outstanding async - * requests. If arg == 1, it shall also attempt to become root on the - * bus. Return void. */ - RESET_BUS, - - /* Arg is void, return value is the hardware cycle counter value. */ - GET_CYCLE_COUNTER, - - /* Set the hardware cycle counter to the value in arg, return void. - * FIXME - setting is probably not required. */ - SET_CYCLE_COUNTER, - - /* Configure hardware for new bus ID in arg, return void. */ - SET_BUS_ID, - - /* If arg true, start sending cycle start packets, stop if arg == 0. - * Return void. */ - ACT_CYCLE_MASTER, - - /* Cancel all outstanding async requests without resetting the bus. - * Return void. */ - CANCEL_REQUESTS, - - /* Start or stop receiving isochronous channel in arg. Return void. - * This acts as an optimization hint, hosts are not required not to - * listen on unrequested channels. */ - ISO_LISTEN_CHANNEL, - ISO_UNLISTEN_CHANNEL + /* Host is requested to reset its bus and cancel all outstanding async + * requests. If arg == 1, it shall also attempt to become root on the + * bus. Return void. */ + RESET_BUS, + + /* Arg is void, return value is the hardware cycle counter value. */ + GET_CYCLE_COUNTER, + + /* Set the hardware cycle counter to the value in arg, return void. + * FIXME - setting is probably not required. */ + SET_CYCLE_COUNTER, + + /* Configure hardware for new bus ID in arg, return void. */ + SET_BUS_ID, + + /* If arg true, start sending cycle start packets, stop if arg == 0. + * Return void. */ + ACT_CYCLE_MASTER, + + /* Cancel all outstanding async requests without resetting the bus. + * Return void. */ + CANCEL_REQUESTS, + + /* Start or stop receiving isochronous channel in arg. Return void. + * This acts as an optimization hint, hosts are not required not to + * listen on unrequested channels. */ + ISO_LISTEN_CHANNEL, + ISO_UNLISTEN_CHANNEL }; enum isoctl_cmd { @@ -135,13 +135,13 @@ enum isoctl_cmd { }; enum reset_types { - /* 166 microsecond reset -- only type of reset available on - non-1394a capable controllers */ - LONG_RESET, + /* 166 microsecond reset -- only type of reset available on + non-1394a capable controllers */ + LONG_RESET, - /* Short (arbitrated) reset -- only available on 1394a capable - controllers */ - SHORT_RESET, + /* Short (arbitrated) reset -- only available on 1394a capable + controllers */ + SHORT_RESET, /* Variants that set force_root before issueing the bus reset */ LONG_RESET_FORCE_ROOT, SHORT_RESET_FORCE_ROOT, @@ -159,22 +159,22 @@ struct hpsb_host_driver { * reads to the ConfigROM on its own. */ void (*set_hw_config_rom) (struct hpsb_host *host, quadlet_t *config_rom); - /* This function shall implement packet transmission based on - * packet->type. It shall CRC both parts of the packet (unless - * packet->type == raw) and do byte-swapping as necessary or instruct - * the hardware to do so. It can return immediately after the packet - * was queued for sending. After sending, hpsb_sent_packet() has to be - * called. Return 0 on success, negative errno on failure. - * NOTE: The function must be callable in interrupt context. - */ - int (*transmit_packet) (struct hpsb_host *host, - struct hpsb_packet *packet); - - /* This function requests miscellanous services from the driver, see - * above for command codes and expected actions. Return -1 for unknown - * command, though that should never happen. - */ - int (*devctl) (struct hpsb_host *host, enum devctl_cmd command, int arg); + /* This function shall implement packet transmission based on + * packet->type. It shall CRC both parts of the packet (unless + * packet->type == raw) and do byte-swapping as necessary or instruct + * the hardware to do so. It can return immediately after the packet + * was queued for sending. After sending, hpsb_sent_packet() has to be + * called. Return 0 on success, negative errno on failure. + * NOTE: The function must be callable in interrupt context. + */ + int (*transmit_packet) (struct hpsb_host *host, + struct hpsb_packet *packet); + + /* This function requests miscellanous services from the driver, see + * above for command codes and expected actions. Return -1 for unknown + * command, though that should never happen. + */ + int (*devctl) (struct hpsb_host *host, enum devctl_cmd command, int arg); /* ISO transmission/reception functions. Return 0 on success, -1 * (or -EXXX errno code) on failure. If the low-level driver does not @@ -182,15 +182,15 @@ struct hpsb_host_driver { */ int (*isoctl) (struct hpsb_iso *iso, enum isoctl_cmd command, unsigned long arg); - /* This function is mainly to redirect local CSR reads/locks to the iso - * management registers (bus manager id, bandwidth available, channels - * available) to the hardware registers in OHCI. reg is 0,1,2,3 for bus - * mgr, bwdth avail, ch avail hi, ch avail lo respectively (the same ids - * as OHCI uses). data and compare are the new data and expected data - * respectively, return value is the old value. - */ - quadlet_t (*hw_csr_reg) (struct hpsb_host *host, int reg, - quadlet_t data, quadlet_t compare); + /* This function is mainly to redirect local CSR reads/locks to the iso + * management registers (bus manager id, bandwidth available, channels + * available) to the hardware registers in OHCI. reg is 0,1,2,3 for bus + * mgr, bwdth avail, ch avail hi, ch avail lo respectively (the same ids + * as OHCI uses). data and compare are the new data and expected data + * respectively, return value is the old value. + */ + quadlet_t (*hw_csr_reg) (struct hpsb_host *host, int reg, + quadlet_t data, quadlet_t compare); }; diff --git a/trunk/drivers/ieee1394/ieee1394-ioctl.h b/trunk/drivers/ieee1394/ieee1394-ioctl.h index 156703986348..f92b566363d5 100644 --- a/trunk/drivers/ieee1394/ieee1394-ioctl.h +++ b/trunk/drivers/ieee1394/ieee1394-ioctl.h @@ -7,6 +7,14 @@ #include #include + +/* AMDTP Gets 6 */ +#define AMDTP_IOC_CHANNEL _IOW('#', 0x00, struct amdtp_ioctl) +#define AMDTP_IOC_PLUG _IOW('#', 0x01, struct amdtp_ioctl) +#define AMDTP_IOC_PING _IOW('#', 0x02, struct amdtp_ioctl) +#define AMDTP_IOC_ZAP _IO ('#', 0x03) + + /* DV1394 Gets 10 */ /* Get the driver ready to transmit video. pass a struct dv1394_init* as diff --git a/trunk/drivers/ieee1394/ieee1394.h b/trunk/drivers/ieee1394/ieee1394.h index 936d776de00a..b634a9bb365c 100644 --- a/trunk/drivers/ieee1394/ieee1394.h +++ b/trunk/drivers/ieee1394/ieee1394.h @@ -62,7 +62,6 @@ extern const char *hpsb_speedto_str[]; -/* 1394a cable PHY packets */ #define SELFID_PWRCL_NO_POWER 0x0 #define SELFID_PWRCL_PROVIDE_15W 0x1 #define SELFID_PWRCL_PROVIDE_30W 0x2 @@ -77,24 +76,8 @@ extern const char *hpsb_speedto_str[]; #define SELFID_PORT_NCONN 0x1 #define SELFID_PORT_NONE 0x0 -#define PHYPACKET_LINKON 0x40000000 -#define PHYPACKET_PHYCONFIG_R 0x00800000 -#define PHYPACKET_PHYCONFIG_T 0x00400000 -#define EXTPHYPACKET_TYPE_PING 0x00000000 -#define EXTPHYPACKET_TYPE_REMOTEACCESS_BASE 0x00040000 -#define EXTPHYPACKET_TYPE_REMOTEACCESS_PAGED 0x00140000 -#define EXTPHYPACKET_TYPE_REMOTEREPLY_BASE 0x000C0000 -#define EXTPHYPACKET_TYPE_REMOTEREPLY_PAGED 0x001C0000 -#define EXTPHYPACKET_TYPE_REMOTECOMMAND 0x00200000 -#define EXTPHYPACKET_TYPE_REMOTECONFIRMATION 0x00280000 -#define EXTPHYPACKET_TYPE_RESUME 0x003C0000 -#define EXTPHYPACKET_TYPEMASK 0xC0FC0000 - -#define PHYPACKET_PORT_SHIFT 24 -#define PHYPACKET_GAPCOUNT_SHIFT 16 - -/* 1394a PHY register map bitmasks */ +/* 1394a PHY bitmasks */ #define PHY_00_PHYSICAL_ID 0xFC #define PHY_00_R 0x02 /* Root */ #define PHY_00_PS 0x01 /* Power Status*/ diff --git a/trunk/drivers/ieee1394/ieee1394_core.c b/trunk/drivers/ieee1394/ieee1394_core.c index 64fbbb01d52a..32a1e016c85e 100644 --- a/trunk/drivers/ieee1394/ieee1394_core.c +++ b/trunk/drivers/ieee1394/ieee1394_core.c @@ -179,34 +179,34 @@ void hpsb_free_packet(struct hpsb_packet *packet) int hpsb_reset_bus(struct hpsb_host *host, int type) { - if (!host->in_bus_reset) { - host->driver->devctl(host, RESET_BUS, type); - return 0; - } else { - return 1; - } + if (!host->in_bus_reset) { + host->driver->devctl(host, RESET_BUS, type); + return 0; + } else { + return 1; + } } int hpsb_bus_reset(struct hpsb_host *host) { - if (host->in_bus_reset) { - HPSB_NOTICE("%s called while bus reset already in progress", + if (host->in_bus_reset) { + HPSB_NOTICE("%s called while bus reset already in progress", __FUNCTION__); - return 1; - } + return 1; + } - abort_requests(host); - host->in_bus_reset = 1; - host->irm_id = -1; + abort_requests(host); + host->in_bus_reset = 1; + host->irm_id = -1; host->is_irm = 0; - host->busmgr_id = -1; + host->busmgr_id = -1; host->is_busmgr = 0; host->is_cycmst = 0; - host->node_count = 0; - host->selfid_count = 0; + host->node_count = 0; + host->selfid_count = 0; - return 0; + return 0; } @@ -216,156 +216,150 @@ int hpsb_bus_reset(struct hpsb_host *host) */ static int check_selfids(struct hpsb_host *host) { - int nodeid = -1; - int rest_of_selfids = host->selfid_count; - struct selfid *sid = (struct selfid *)host->topology_map; - struct ext_selfid *esid; - int esid_seq = 23; + int nodeid = -1; + int rest_of_selfids = host->selfid_count; + struct selfid *sid = (struct selfid *)host->topology_map; + struct ext_selfid *esid; + int esid_seq = 23; host->nodes_active = 0; - while (rest_of_selfids--) { - if (!sid->extended) { - nodeid++; - esid_seq = 0; + while (rest_of_selfids--) { + if (!sid->extended) { + nodeid++; + esid_seq = 0; - if (sid->phy_id != nodeid) { - HPSB_INFO("SelfIDs failed monotony check with " - "%d", sid->phy_id); - return 0; - } + if (sid->phy_id != nodeid) { + HPSB_INFO("SelfIDs failed monotony check with " + "%d", sid->phy_id); + return 0; + } if (sid->link_active) { host->nodes_active++; if (sid->contender) host->irm_id = LOCAL_BUS | sid->phy_id; } - } else { - esid = (struct ext_selfid *)sid; - - if ((esid->phy_id != nodeid) - || (esid->seq_nr != esid_seq)) { - HPSB_INFO("SelfIDs failed monotony check with " - "%d/%d", esid->phy_id, esid->seq_nr); - return 0; - } - esid_seq++; - } - sid++; - } - - esid = (struct ext_selfid *)(sid - 1); - while (esid->extended) { - if ((esid->porta == SELFID_PORT_PARENT) || - (esid->portb == SELFID_PORT_PARENT) || - (esid->portc == SELFID_PORT_PARENT) || - (esid->portd == SELFID_PORT_PARENT) || - (esid->porte == SELFID_PORT_PARENT) || - (esid->portf == SELFID_PORT_PARENT) || - (esid->portg == SELFID_PORT_PARENT) || - (esid->porth == SELFID_PORT_PARENT)) { + } else { + esid = (struct ext_selfid *)sid; + + if ((esid->phy_id != nodeid) + || (esid->seq_nr != esid_seq)) { + HPSB_INFO("SelfIDs failed monotony check with " + "%d/%d", esid->phy_id, esid->seq_nr); + return 0; + } + esid_seq++; + } + sid++; + } + + esid = (struct ext_selfid *)(sid - 1); + while (esid->extended) { + if ((esid->porta == 0x2) || (esid->portb == 0x2) + || (esid->portc == 0x2) || (esid->portd == 0x2) + || (esid->porte == 0x2) || (esid->portf == 0x2) + || (esid->portg == 0x2) || (esid->porth == 0x2)) { HPSB_INFO("SelfIDs failed root check on " "extended SelfID"); return 0; - } - esid--; - } + } + esid--; + } - sid = (struct selfid *)esid; - if ((sid->port0 == SELFID_PORT_PARENT) || - (sid->port1 == SELFID_PORT_PARENT) || - (sid->port2 == SELFID_PORT_PARENT)) { + sid = (struct selfid *)esid; + if ((sid->port0 == 0x2) || (sid->port1 == 0x2) || (sid->port2 == 0x2)) { HPSB_INFO("SelfIDs failed root check"); return 0; - } + } host->node_count = nodeid + 1; - return 1; + return 1; } static void build_speed_map(struct hpsb_host *host, int nodecount) { u8 speedcap[nodecount]; u8 cldcnt[nodecount]; - u8 *map = host->speed_map; - struct selfid *sid; - struct ext_selfid *esid; - int i, j, n; - - for (i = 0; i < (nodecount * 64); i += 64) { - for (j = 0; j < nodecount; j++) { - map[i+j] = IEEE1394_SPEED_MAX; - } - } - - for (i = 0; i < nodecount; i++) { - cldcnt[i] = 0; - } - - /* find direct children count and speed */ - for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1], - n = nodecount - 1; - (void *)sid >= (void *)host->topology_map; sid--) { - if (sid->extended) { - esid = (struct ext_selfid *)sid; - - if (esid->porta == SELFID_PORT_CHILD) cldcnt[n]++; - if (esid->portb == SELFID_PORT_CHILD) cldcnt[n]++; - if (esid->portc == SELFID_PORT_CHILD) cldcnt[n]++; - if (esid->portd == SELFID_PORT_CHILD) cldcnt[n]++; - if (esid->porte == SELFID_PORT_CHILD) cldcnt[n]++; - if (esid->portf == SELFID_PORT_CHILD) cldcnt[n]++; - if (esid->portg == SELFID_PORT_CHILD) cldcnt[n]++; - if (esid->porth == SELFID_PORT_CHILD) cldcnt[n]++; + u8 *map = host->speed_map; + struct selfid *sid; + struct ext_selfid *esid; + int i, j, n; + + for (i = 0; i < (nodecount * 64); i += 64) { + for (j = 0; j < nodecount; j++) { + map[i+j] = IEEE1394_SPEED_MAX; + } + } + + for (i = 0; i < nodecount; i++) { + cldcnt[i] = 0; + } + + /* find direct children count and speed */ + for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1], + n = nodecount - 1; + (void *)sid >= (void *)host->topology_map; sid--) { + if (sid->extended) { + esid = (struct ext_selfid *)sid; + + if (esid->porta == 0x3) cldcnt[n]++; + if (esid->portb == 0x3) cldcnt[n]++; + if (esid->portc == 0x3) cldcnt[n]++; + if (esid->portd == 0x3) cldcnt[n]++; + if (esid->porte == 0x3) cldcnt[n]++; + if (esid->portf == 0x3) cldcnt[n]++; + if (esid->portg == 0x3) cldcnt[n]++; + if (esid->porth == 0x3) cldcnt[n]++; } else { - if (sid->port0 == SELFID_PORT_CHILD) cldcnt[n]++; - if (sid->port1 == SELFID_PORT_CHILD) cldcnt[n]++; - if (sid->port2 == SELFID_PORT_CHILD) cldcnt[n]++; - - speedcap[n] = sid->speed; - n--; - } - } - - /* set self mapping */ - for (i = 0; i < nodecount; i++) { - map[64*i + i] = speedcap[i]; - } - - /* fix up direct children count to total children count; - * also fix up speedcaps for sibling and parent communication */ - for (i = 1; i < nodecount; i++) { - for (j = cldcnt[i], n = i - 1; j > 0; j--) { - cldcnt[i] += cldcnt[n]; - speedcap[n] = min(speedcap[n], speedcap[i]); - n -= cldcnt[n] + 1; - } - } - - for (n = 0; n < nodecount; n++) { - for (i = n - cldcnt[n]; i <= n; i++) { - for (j = 0; j < (n - cldcnt[n]); j++) { - map[j*64 + i] = map[i*64 + j] = - min(map[i*64 + j], speedcap[n]); - } - for (j = n + 1; j < nodecount; j++) { - map[j*64 + i] = map[i*64 + j] = - min(map[i*64 + j], speedcap[n]); - } - } - } + if (sid->port0 == 0x3) cldcnt[n]++; + if (sid->port1 == 0x3) cldcnt[n]++; + if (sid->port2 == 0x3) cldcnt[n]++; + + speedcap[n] = sid->speed; + n--; + } + } + + /* set self mapping */ + for (i = 0; i < nodecount; i++) { + map[64*i + i] = speedcap[i]; + } + + /* fix up direct children count to total children count; + * also fix up speedcaps for sibling and parent communication */ + for (i = 1; i < nodecount; i++) { + for (j = cldcnt[i], n = i - 1; j > 0; j--) { + cldcnt[i] += cldcnt[n]; + speedcap[n] = min(speedcap[n], speedcap[i]); + n -= cldcnt[n] + 1; + } + } + + for (n = 0; n < nodecount; n++) { + for (i = n - cldcnt[n]; i <= n; i++) { + for (j = 0; j < (n - cldcnt[n]); j++) { + map[j*64 + i] = map[i*64 + j] = + min(map[i*64 + j], speedcap[n]); + } + for (j = n + 1; j < nodecount; j++) { + map[j*64 + i] = map[i*64 + j] = + min(map[i*64 + j], speedcap[n]); + } + } + } } void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid) { - if (host->in_bus_reset) { - HPSB_VERBOSE("Including SelfID 0x%x", sid); - host->topology_map[host->selfid_count++] = sid; - } else { - HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d", + if (host->in_bus_reset) { + HPSB_VERBOSE("Including SelfID 0x%x", sid); + host->topology_map[host->selfid_count++] = sid; + } else { + HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d", sid, NODEID_TO_BUS(host->node_id)); - } + } } void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot) @@ -373,50 +367,50 @@ void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot) if (!host->in_bus_reset) HPSB_NOTICE("SelfID completion called outside of bus reset!"); - host->node_id = LOCAL_BUS | phyid; - host->is_root = isroot; + host->node_id = LOCAL_BUS | phyid; + host->is_root = isroot; - if (!check_selfids(host)) { - if (host->reset_retries++ < 20) { - /* selfid stage did not complete without error */ - HPSB_NOTICE("Error in SelfID stage, resetting"); + if (!check_selfids(host)) { + if (host->reset_retries++ < 20) { + /* selfid stage did not complete without error */ + HPSB_NOTICE("Error in SelfID stage, resetting"); host->in_bus_reset = 0; /* this should work from ohci1394 now... */ - hpsb_reset_bus(host, LONG_RESET); - return; - } else { - HPSB_NOTICE("Stopping out-of-control reset loop"); - HPSB_NOTICE("Warning - topology map and speed map will not be valid"); + hpsb_reset_bus(host, LONG_RESET); + return; + } else { + HPSB_NOTICE("Stopping out-of-control reset loop"); + HPSB_NOTICE("Warning - topology map and speed map will not be valid"); host->reset_retries = 0; - } - } else { + } + } else { host->reset_retries = 0; - build_speed_map(host, host->node_count); - } + build_speed_map(host, host->node_count); + } HPSB_VERBOSE("selfid_complete called with successful SelfID stage " "... irm_id: 0x%X node_id: 0x%X",host->irm_id,host->node_id); - /* irm_id is kept up to date by check_selfids() */ - if (host->irm_id == host->node_id) { - host->is_irm = 1; - } else { - host->is_busmgr = 0; - host->is_irm = 0; - } + /* irm_id is kept up to date by check_selfids() */ + if (host->irm_id == host->node_id) { + host->is_irm = 1; + } else { + host->is_busmgr = 0; + host->is_irm = 0; + } - if (isroot) { + if (isroot) { host->driver->devctl(host, ACT_CYCLE_MASTER, 1); host->is_cycmst = 1; } atomic_inc(&host->generation); host->in_bus_reset = 0; - highlevel_host_reset(host); + highlevel_host_reset(host); } void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, - int ackcode) + int ackcode) { unsigned long flags; @@ -463,7 +457,6 @@ void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, int hpsb_send_phy_config(struct hpsb_host *host, int rootid, int gapcnt) { struct hpsb_packet *packet; - quadlet_t d = 0; int retval = 0; if (rootid >= ALL_NODES || rootid < -1 || gapcnt > 0x3f || gapcnt < -1 || @@ -473,16 +466,26 @@ int hpsb_send_phy_config(struct hpsb_host *host, int rootid, int gapcnt) return -EINVAL; } + packet = hpsb_alloc_packet(0); + if (!packet) + return -ENOMEM; + + packet->host = host; + packet->header_size = 8; + packet->data_size = 0; + packet->expect_response = 0; + packet->no_waiter = 0; + packet->type = hpsb_raw; + packet->header[0] = 0; if (rootid != -1) - d |= PHYPACKET_PHYCONFIG_R | rootid << PHYPACKET_PORT_SHIFT; + packet->header[0] |= rootid << 24 | 1 << 23; if (gapcnt != -1) - d |= PHYPACKET_PHYCONFIG_T | gapcnt << PHYPACKET_GAPCOUNT_SHIFT; + packet->header[0] |= gapcnt << 16 | 1 << 22; - packet = hpsb_make_phypacket(host, d); - if (!packet) - return -ENOMEM; + packet->header[1] = ~packet->header[0]; packet->generation = get_hpsb_generation(host); + retval = hpsb_send_packet_and_wait(packet); hpsb_free_packet(packet); @@ -507,13 +510,13 @@ int hpsb_send_packet(struct hpsb_packet *packet) { struct hpsb_host *host = packet->host; - if (host->is_shutdown) + if (host->is_shutdown) return -EINVAL; if (host->in_bus_reset || (packet->generation != get_hpsb_generation(host))) - return -EAGAIN; + return -EAGAIN; - packet->state = hpsb_queued; + packet->state = hpsb_queued; /* This just seems silly to me */ WARN_ON(packet->no_waiter && packet->expect_response); @@ -527,42 +530,42 @@ int hpsb_send_packet(struct hpsb_packet *packet) skb_queue_tail(&host->pending_packet_queue, packet->skb); } - if (packet->node_id == host->node_id) { + if (packet->node_id == host->node_id) { /* it is a local request, so handle it locally */ - quadlet_t *data; - size_t size = packet->data_size + packet->header_size; + quadlet_t *data; + size_t size = packet->data_size + packet->header_size; - data = kmalloc(size, GFP_ATOMIC); - if (!data) { - HPSB_ERR("unable to allocate memory for concatenating header and data"); - return -ENOMEM; - } + data = kmalloc(size, GFP_ATOMIC); + if (!data) { + HPSB_ERR("unable to allocate memory for concatenating header and data"); + return -ENOMEM; + } - memcpy(data, packet->header, packet->header_size); + memcpy(data, packet->header, packet->header_size); - if (packet->data_size) + if (packet->data_size) memcpy(((u8*)data) + packet->header_size, packet->data, packet->data_size); - dump_packet("send packet local", packet->header, packet->header_size, -1); + dump_packet("send packet local", packet->header, packet->header_size, -1); - hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE); - hpsb_packet_received(host, data, size, 0); + hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE); + hpsb_packet_received(host, data, size, 0); - kfree(data); + kfree(data); - return 0; - } + return 0; + } - if (packet->type == hpsb_async && packet->node_id != ALL_NODES) { - packet->speed_code = - host->speed_map[NODEID_TO_NODE(host->node_id) * 64 - + NODEID_TO_NODE(packet->node_id)]; - } + if (packet->type == hpsb_async && packet->node_id != ALL_NODES) { + packet->speed_code = + host->speed_map[NODEID_TO_NODE(host->node_id) * 64 + + NODEID_TO_NODE(packet->node_id)]; + } - dump_packet("send packet", packet->header, packet->header_size, packet->speed_code); + dump_packet("send packet", packet->header, packet->header_size, packet->speed_code); - return host->driver->transmit_packet(host, packet); + return host->driver->transmit_packet(host, packet); } /* We could just use complete() directly as the packet complete @@ -590,81 +593,81 @@ int hpsb_send_packet_and_wait(struct hpsb_packet *packet) static void send_packet_nocare(struct hpsb_packet *packet) { - if (hpsb_send_packet(packet) < 0) { - hpsb_free_packet(packet); - } + if (hpsb_send_packet(packet) < 0) { + hpsb_free_packet(packet); + } } static void handle_packet_response(struct hpsb_host *host, int tcode, quadlet_t *data, size_t size) { - struct hpsb_packet *packet = NULL; + struct hpsb_packet *packet = NULL; struct sk_buff *skb; - int tcode_match = 0; - int tlabel; - unsigned long flags; + int tcode_match = 0; + int tlabel; + unsigned long flags; - tlabel = (data[0] >> 10) & 0x3f; + tlabel = (data[0] >> 10) & 0x3f; spin_lock_irqsave(&host->pending_packet_queue.lock, flags); skb_queue_walk(&host->pending_packet_queue, skb) { packet = (struct hpsb_packet *)skb->data; - if ((packet->tlabel == tlabel) - && (packet->node_id == (data[1] >> 16))){ - break; - } + if ((packet->tlabel == tlabel) + && (packet->node_id == (data[1] >> 16))){ + break; + } packet = NULL; - } + } if (packet == NULL) { - HPSB_DEBUG("unsolicited response packet received - no tlabel match"); - dump_packet("contents", data, 16, -1); + HPSB_DEBUG("unsolicited response packet received - no tlabel match"); + dump_packet("contents", data, 16, -1); spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); - return; - } + return; + } - switch (packet->tcode) { - case TCODE_WRITEQ: - case TCODE_WRITEB: - if (tcode != TCODE_WRITE_RESPONSE) + switch (packet->tcode) { + case TCODE_WRITEQ: + case TCODE_WRITEB: + if (tcode != TCODE_WRITE_RESPONSE) break; tcode_match = 1; memcpy(packet->header, data, 12); - break; - case TCODE_READQ: - if (tcode != TCODE_READQ_RESPONSE) + break; + case TCODE_READQ: + if (tcode != TCODE_READQ_RESPONSE) break; tcode_match = 1; memcpy(packet->header, data, 16); - break; - case TCODE_READB: - if (tcode != TCODE_READB_RESPONSE) + break; + case TCODE_READB: + if (tcode != TCODE_READB_RESPONSE) break; tcode_match = 1; BUG_ON(packet->skb->len - sizeof(*packet) < size - 16); memcpy(packet->header, data, 16); memcpy(packet->data, data + 4, size - 16); - break; - case TCODE_LOCK_REQUEST: - if (tcode != TCODE_LOCK_RESPONSE) + break; + case TCODE_LOCK_REQUEST: + if (tcode != TCODE_LOCK_RESPONSE) break; tcode_match = 1; size = min((size - 16), (size_t)8); BUG_ON(packet->skb->len - sizeof(*packet) < size); memcpy(packet->header, data, 16); memcpy(packet->data, data + 4, size); - break; - } + break; + } - if (!tcode_match) { + if (!tcode_match) { spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); - HPSB_INFO("unsolicited response packet received - tcode mismatch"); - dump_packet("contents", data, 16, -1); - return; - } + HPSB_INFO("unsolicited response packet received - tcode mismatch"); + dump_packet("contents", data, 16, -1); + return; + } __skb_unlink(skb, &host->pending_packet_queue); @@ -683,27 +686,27 @@ static void handle_packet_response(struct hpsb_host *host, int tcode, static struct hpsb_packet *create_reply_packet(struct hpsb_host *host, quadlet_t *data, size_t dsize) { - struct hpsb_packet *p; + struct hpsb_packet *p; - p = hpsb_alloc_packet(dsize); - if (unlikely(p == NULL)) { - /* FIXME - send data_error response */ - return NULL; - } + p = hpsb_alloc_packet(dsize); + if (unlikely(p == NULL)) { + /* FIXME - send data_error response */ + return NULL; + } - p->type = hpsb_async; - p->state = hpsb_unused; - p->host = host; - p->node_id = data[1] >> 16; - p->tlabel = (data[0] >> 10) & 0x3f; - p->no_waiter = 1; + p->type = hpsb_async; + p->state = hpsb_unused; + p->host = host; + p->node_id = data[1] >> 16; + p->tlabel = (data[0] >> 10) & 0x3f; + p->no_waiter = 1; p->generation = get_hpsb_generation(host); if (dsize % 4) p->data[dsize / 4] = 0; - return p; + return p; } #define PREP_ASYNC_HEAD_RCODE(tc) \ @@ -714,7 +717,7 @@ static struct hpsb_packet *create_reply_packet(struct hpsb_host *host, packet->header[2] = 0 static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode, - quadlet_t data) + quadlet_t data) { PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE); packet->header[3] = data; @@ -723,7 +726,7 @@ static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode, } static void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode, - int length) + int length) { if (rcode != RCODE_COMPLETE) length = 0; @@ -743,7 +746,7 @@ static void fill_async_write_resp(struct hpsb_packet *packet, int rcode) } static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode, - int length) + int length) { if (rcode != RCODE_COMPLETE) length = 0; @@ -755,184 +758,184 @@ static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extc } #define PREP_REPLY_PACKET(length) \ - packet = create_reply_packet(host, data, length); \ - if (packet == NULL) break + packet = create_reply_packet(host, data, length); \ + if (packet == NULL) break static void handle_incoming_packet(struct hpsb_host *host, int tcode, quadlet_t *data, size_t size, int write_acked) { - struct hpsb_packet *packet; - int length, rcode, extcode; - quadlet_t buffer; - nodeid_t source = data[1] >> 16; - nodeid_t dest = data[0] >> 16; - u16 flags = (u16) data[0]; - u64 addr; - - /* big FIXME - no error checking is done for an out of bounds length */ - - switch (tcode) { - case TCODE_WRITEQ: - addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; - rcode = highlevel_write(host, source, dest, data+3, + struct hpsb_packet *packet; + int length, rcode, extcode; + quadlet_t buffer; + nodeid_t source = data[1] >> 16; + nodeid_t dest = data[0] >> 16; + u16 flags = (u16) data[0]; + u64 addr; + + /* big FIXME - no error checking is done for an out of bounds length */ + + switch (tcode) { + case TCODE_WRITEQ: + addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; + rcode = highlevel_write(host, source, dest, data+3, addr, 4, flags); - if (!write_acked - && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) - && (rcode >= 0)) { - /* not a broadcast write, reply */ - PREP_REPLY_PACKET(0); - fill_async_write_resp(packet, rcode); - send_packet_nocare(packet); - } - break; - - case TCODE_WRITEB: - addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; - rcode = highlevel_write(host, source, dest, data+4, + if (!write_acked + && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) + && (rcode >= 0)) { + /* not a broadcast write, reply */ + PREP_REPLY_PACKET(0); + fill_async_write_resp(packet, rcode); + send_packet_nocare(packet); + } + break; + + case TCODE_WRITEB: + addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; + rcode = highlevel_write(host, source, dest, data+4, addr, data[3]>>16, flags); - if (!write_acked - && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) - && (rcode >= 0)) { - /* not a broadcast write, reply */ - PREP_REPLY_PACKET(0); - fill_async_write_resp(packet, rcode); - send_packet_nocare(packet); - } - break; - - case TCODE_READQ: - addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; - rcode = highlevel_read(host, source, &buffer, addr, 4, flags); - - if (rcode >= 0) { - PREP_REPLY_PACKET(0); - fill_async_readquad_resp(packet, rcode, buffer); - send_packet_nocare(packet); - } - break; - - case TCODE_READB: - length = data[3] >> 16; - PREP_REPLY_PACKET(length); - - addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; - rcode = highlevel_read(host, source, packet->data, addr, - length, flags); - - if (rcode >= 0) { - fill_async_readblock_resp(packet, rcode, length); - send_packet_nocare(packet); - } else { - hpsb_free_packet(packet); - } - break; - - case TCODE_LOCK_REQUEST: - length = data[3] >> 16; - extcode = data[3] & 0xffff; - addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; - - PREP_REPLY_PACKET(8); - - if ((extcode == 0) || (extcode >= 7)) { - /* let switch default handle error */ - length = 0; - } - - switch (length) { - case 4: - rcode = highlevel_lock(host, source, packet->data, addr, - data[4], 0, extcode,flags); - fill_async_lock_resp(packet, rcode, extcode, 4); - break; - case 8: - if ((extcode != EXTCODE_FETCH_ADD) - && (extcode != EXTCODE_LITTLE_ADD)) { - rcode = highlevel_lock(host, source, - packet->data, addr, - data[5], data[4], - extcode, flags); - fill_async_lock_resp(packet, rcode, extcode, 4); - } else { - rcode = highlevel_lock64(host, source, - (octlet_t *)packet->data, addr, - *(octlet_t *)(data + 4), 0ULL, - extcode, flags); - fill_async_lock_resp(packet, rcode, extcode, 8); - } - break; - case 16: - rcode = highlevel_lock64(host, source, - (octlet_t *)packet->data, addr, - *(octlet_t *)(data + 6), - *(octlet_t *)(data + 4), - extcode, flags); - fill_async_lock_resp(packet, rcode, extcode, 8); - break; - default: - rcode = RCODE_TYPE_ERROR; - fill_async_lock_resp(packet, rcode, - extcode, 0); - } - - if (rcode >= 0) { - send_packet_nocare(packet); - } else { - hpsb_free_packet(packet); - } - break; - } + if (!write_acked + && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) + && (rcode >= 0)) { + /* not a broadcast write, reply */ + PREP_REPLY_PACKET(0); + fill_async_write_resp(packet, rcode); + send_packet_nocare(packet); + } + break; + + case TCODE_READQ: + addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; + rcode = highlevel_read(host, source, &buffer, addr, 4, flags); + + if (rcode >= 0) { + PREP_REPLY_PACKET(0); + fill_async_readquad_resp(packet, rcode, buffer); + send_packet_nocare(packet); + } + break; + + case TCODE_READB: + length = data[3] >> 16; + PREP_REPLY_PACKET(length); + + addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; + rcode = highlevel_read(host, source, packet->data, addr, + length, flags); + + if (rcode >= 0) { + fill_async_readblock_resp(packet, rcode, length); + send_packet_nocare(packet); + } else { + hpsb_free_packet(packet); + } + break; + + case TCODE_LOCK_REQUEST: + length = data[3] >> 16; + extcode = data[3] & 0xffff; + addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; + + PREP_REPLY_PACKET(8); + + if ((extcode == 0) || (extcode >= 7)) { + /* let switch default handle error */ + length = 0; + } + + switch (length) { + case 4: + rcode = highlevel_lock(host, source, packet->data, addr, + data[4], 0, extcode,flags); + fill_async_lock_resp(packet, rcode, extcode, 4); + break; + case 8: + if ((extcode != EXTCODE_FETCH_ADD) + && (extcode != EXTCODE_LITTLE_ADD)) { + rcode = highlevel_lock(host, source, + packet->data, addr, + data[5], data[4], + extcode, flags); + fill_async_lock_resp(packet, rcode, extcode, 4); + } else { + rcode = highlevel_lock64(host, source, + (octlet_t *)packet->data, addr, + *(octlet_t *)(data + 4), 0ULL, + extcode, flags); + fill_async_lock_resp(packet, rcode, extcode, 8); + } + break; + case 16: + rcode = highlevel_lock64(host, source, + (octlet_t *)packet->data, addr, + *(octlet_t *)(data + 6), + *(octlet_t *)(data + 4), + extcode, flags); + fill_async_lock_resp(packet, rcode, extcode, 8); + break; + default: + rcode = RCODE_TYPE_ERROR; + fill_async_lock_resp(packet, rcode, + extcode, 0); + } + + if (rcode >= 0) { + send_packet_nocare(packet); + } else { + hpsb_free_packet(packet); + } + break; + } } #undef PREP_REPLY_PACKET void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size, - int write_acked) + int write_acked) { - int tcode; - - if (host->in_bus_reset) { - HPSB_INFO("received packet during reset; ignoring"); - return; - } - - dump_packet("received packet", data, size, -1); - - tcode = (data[0] >> 4) & 0xf; - - switch (tcode) { - case TCODE_WRITE_RESPONSE: - case TCODE_READQ_RESPONSE: - case TCODE_READB_RESPONSE: - case TCODE_LOCK_RESPONSE: - handle_packet_response(host, tcode, data, size); - break; - - case TCODE_WRITEQ: - case TCODE_WRITEB: - case TCODE_READQ: - case TCODE_READB: - case TCODE_LOCK_REQUEST: - handle_incoming_packet(host, tcode, data, size, write_acked); - break; - - - case TCODE_ISO_DATA: - highlevel_iso_receive(host, data, size); - break; - - case TCODE_CYCLE_START: - /* simply ignore this packet if it is passed on */ - break; - - default: - HPSB_NOTICE("received packet with bogus transaction code %d", - tcode); - break; - } + int tcode; + + if (host->in_bus_reset) { + HPSB_INFO("received packet during reset; ignoring"); + return; + } + + dump_packet("received packet", data, size, -1); + + tcode = (data[0] >> 4) & 0xf; + + switch (tcode) { + case TCODE_WRITE_RESPONSE: + case TCODE_READQ_RESPONSE: + case TCODE_READB_RESPONSE: + case TCODE_LOCK_RESPONSE: + handle_packet_response(host, tcode, data, size); + break; + + case TCODE_WRITEQ: + case TCODE_WRITEB: + case TCODE_READQ: + case TCODE_READB: + case TCODE_LOCK_REQUEST: + handle_incoming_packet(host, tcode, data, size, write_acked); + break; + + + case TCODE_ISO_DATA: + highlevel_iso_receive(host, data, size); + break; + + case TCODE_CYCLE_START: + /* simply ignore this packet if it is passed on */ + break; + + default: + HPSB_NOTICE("received packet with bogus transaction code %d", + tcode); + break; + } } @@ -1126,7 +1129,7 @@ static int __init ieee1394_init(void) nodemgr implements functionality required of ieee1394a-2000 IRMs */ hpsb_disable_irm = 1; - + return 0; } diff --git a/trunk/drivers/ieee1394/ieee1394_core.h b/trunk/drivers/ieee1394/ieee1394_core.h index b35466023f00..0b31429d0a68 100644 --- a/trunk/drivers/ieee1394/ieee1394_core.h +++ b/trunk/drivers/ieee1394/ieee1394_core.h @@ -10,8 +10,8 @@ struct hpsb_packet { - /* This struct is basically read-only for hosts with the exception of - * the data buffer contents and xnext - see below. */ + /* This struct is basically read-only for hosts with the exception of + * the data buffer contents and xnext - see below. */ /* This can be used for host driver internal linking. * @@ -21,47 +21,47 @@ struct hpsb_packet { * driver_list when free'ing it. */ struct list_head driver_list; - nodeid_t node_id; + nodeid_t node_id; - /* Async and Iso types should be clear, raw means send-as-is, do not - * CRC! Byte swapping shall still be done in this case. */ - enum { hpsb_async, hpsb_iso, hpsb_raw } __attribute__((packed)) type; + /* Async and Iso types should be clear, raw means send-as-is, do not + * CRC! Byte swapping shall still be done in this case. */ + enum { hpsb_async, hpsb_iso, hpsb_raw } __attribute__((packed)) type; - /* Okay, this is core internal and a no care for hosts. - * queued = queued for sending - * pending = sent, waiting for response - * complete = processing completed, successful or not - */ - enum { - hpsb_unused, hpsb_queued, hpsb_pending, hpsb_complete - } __attribute__((packed)) state; + /* Okay, this is core internal and a no care for hosts. + * queued = queued for sending + * pending = sent, waiting for response + * complete = processing completed, successful or not + */ + enum { + hpsb_unused, hpsb_queued, hpsb_pending, hpsb_complete + } __attribute__((packed)) state; - /* These are core internal. */ - signed char tlabel; + /* These are core internal. */ + signed char tlabel; signed char ack_code; unsigned char tcode; - unsigned expect_response:1; - unsigned no_waiter:1; + unsigned expect_response:1; + unsigned no_waiter:1; - /* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */ - unsigned speed_code:2; + /* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */ + unsigned speed_code:2; - /* - * *header and *data are guaranteed to be 32-bit DMAable and may be - * overwritten to allow in-place byte swapping. Neither of these is - * CRCed (the sizes also don't include CRC), but contain space for at - * least one additional quadlet to allow in-place CRCing. The memory is - * also guaranteed to be DMA mappable. - */ - quadlet_t *header; - quadlet_t *data; - size_t header_size; - size_t data_size; + /* + * *header and *data are guaranteed to be 32-bit DMAable and may be + * overwritten to allow in-place byte swapping. Neither of these is + * CRCed (the sizes also don't include CRC), but contain space for at + * least one additional quadlet to allow in-place CRCing. The memory is + * also guaranteed to be DMA mappable. + */ + quadlet_t *header; + quadlet_t *data; + size_t header_size; + size_t data_size; - struct hpsb_host *host; - unsigned int generation; + struct hpsb_host *host; + unsigned int generation; atomic_t refcnt; @@ -73,10 +73,10 @@ struct hpsb_packet { /* XXX This is just a hack at the moment */ struct sk_buff *skb; - /* Store jiffies for implementing bus timeouts. */ - unsigned long sendtime; + /* Store jiffies for implementing bus timeouts. */ + unsigned long sendtime; - quadlet_t embedded_header[5]; + quadlet_t embedded_header[5]; }; /* Set a task for when a packet completes */ @@ -102,7 +102,7 @@ void hpsb_free_packet(struct hpsb_packet *packet); */ static inline unsigned int get_hpsb_generation(struct hpsb_host *host) { - return atomic_read(&host->generation); + return atomic_read(&host->generation); } /* @@ -157,7 +157,7 @@ void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot); * from within a transmit packet routine. */ void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, - int ackcode); + int ackcode); /* * Hand over received packet to the core. The contents of data are expected to @@ -171,7 +171,7 @@ void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, * packet type. */ void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size, - int write_acked); + int write_acked); /* @@ -197,20 +197,20 @@ void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size, * Block 15 (240-255) reserved for drivers under development, etc. */ -#define IEEE1394_MAJOR 171 +#define IEEE1394_MAJOR 171 -#define IEEE1394_MINOR_BLOCK_RAW1394 0 -#define IEEE1394_MINOR_BLOCK_VIDEO1394 1 -#define IEEE1394_MINOR_BLOCK_DV1394 2 -#define IEEE1394_MINOR_BLOCK_AMDTP 3 +#define IEEE1394_MINOR_BLOCK_RAW1394 0 +#define IEEE1394_MINOR_BLOCK_VIDEO1394 1 +#define IEEE1394_MINOR_BLOCK_DV1394 2 +#define IEEE1394_MINOR_BLOCK_AMDTP 3 #define IEEE1394_MINOR_BLOCK_EXPERIMENTAL 15 -#define IEEE1394_CORE_DEV MKDEV(IEEE1394_MAJOR, 0) -#define IEEE1394_RAW1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16) -#define IEEE1394_VIDEO1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_VIDEO1394 * 16) -#define IEEE1394_DV1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16) -#define IEEE1394_AMDTP_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_AMDTP * 16) -#define IEEE1394_EXPERIMENTAL_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_EXPERIMENTAL * 16) +#define IEEE1394_CORE_DEV MKDEV(IEEE1394_MAJOR, 0) +#define IEEE1394_RAW1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16) +#define IEEE1394_VIDEO1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_VIDEO1394 * 16) +#define IEEE1394_DV1394_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16) +#define IEEE1394_AMDTP_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_AMDTP * 16) +#define IEEE1394_EXPERIMENTAL_DEV MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_EXPERIMENTAL * 16) /* return the index (within a minor number block) of a file */ static inline unsigned char ieee1394_file_to_instance(struct file *file) diff --git a/trunk/drivers/ieee1394/ieee1394_transactions.c b/trunk/drivers/ieee1394/ieee1394_transactions.c index 3fe2f6c4a253..0aa876360f9b 100644 --- a/trunk/drivers/ieee1394/ieee1394_transactions.c +++ b/trunk/drivers/ieee1394/ieee1394_transactions.c @@ -22,7 +22,7 @@ #include "ieee1394_core.h" #include "highlevel.h" #include "nodemgr.h" -#include "ieee1394_transactions.h" + #define PREP_ASYNC_HEAD_ADDRESS(tc) \ packet->tcode = tc; \ @@ -31,82 +31,80 @@ packet->header[1] = (packet->host->node_id << 16) | (addr >> 32); \ packet->header[2] = addr & 0xffffffff + static void fill_async_readquad(struct hpsb_packet *packet, u64 addr) { - PREP_ASYNC_HEAD_ADDRESS(TCODE_READQ); - packet->header_size = 12; - packet->data_size = 0; - packet->expect_response = 1; + PREP_ASYNC_HEAD_ADDRESS(TCODE_READQ); + packet->header_size = 12; + packet->data_size = 0; + packet->expect_response = 1; } -static void fill_async_readblock(struct hpsb_packet *packet, u64 addr, - int length) +static void fill_async_readblock(struct hpsb_packet *packet, u64 addr, int length) { - PREP_ASYNC_HEAD_ADDRESS(TCODE_READB); - packet->header[3] = length << 16; - packet->header_size = 16; - packet->data_size = 0; - packet->expect_response = 1; + PREP_ASYNC_HEAD_ADDRESS(TCODE_READB); + packet->header[3] = length << 16; + packet->header_size = 16; + packet->data_size = 0; + packet->expect_response = 1; } -static void fill_async_writequad(struct hpsb_packet *packet, u64 addr, - quadlet_t data) +static void fill_async_writequad(struct hpsb_packet *packet, u64 addr, quadlet_t data) { - PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEQ); - packet->header[3] = data; - packet->header_size = 16; - packet->data_size = 0; - packet->expect_response = 1; + PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEQ); + packet->header[3] = data; + packet->header_size = 16; + packet->data_size = 0; + packet->expect_response = 1; } -static void fill_async_writeblock(struct hpsb_packet *packet, u64 addr, - int length) +static void fill_async_writeblock(struct hpsb_packet *packet, u64 addr, int length) { - PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEB); - packet->header[3] = length << 16; - packet->header_size = 16; - packet->expect_response = 1; - packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0); + PREP_ASYNC_HEAD_ADDRESS(TCODE_WRITEB); + packet->header[3] = length << 16; + packet->header_size = 16; + packet->expect_response = 1; + packet->data_size = length + (length % 4 ? 4 - (length % 4) : 0); } static void fill_async_lock(struct hpsb_packet *packet, u64 addr, int extcode, - int length) + int length) { - PREP_ASYNC_HEAD_ADDRESS(TCODE_LOCK_REQUEST); - packet->header[3] = (length << 16) | extcode; - packet->header_size = 16; - packet->data_size = length; - packet->expect_response = 1; + PREP_ASYNC_HEAD_ADDRESS(TCODE_LOCK_REQUEST); + packet->header[3] = (length << 16) | extcode; + packet->header_size = 16; + packet->data_size = length; + packet->expect_response = 1; } static void fill_iso_packet(struct hpsb_packet *packet, int length, int channel, - int tag, int sync) + int tag, int sync) { - packet->header[0] = (length << 16) | (tag << 14) | (channel << 8) - | (TCODE_ISO_DATA << 4) | sync; + packet->header[0] = (length << 16) | (tag << 14) | (channel << 8) + | (TCODE_ISO_DATA << 4) | sync; - packet->header_size = 4; - packet->data_size = length; - packet->type = hpsb_iso; - packet->tcode = TCODE_ISO_DATA; + packet->header_size = 4; + packet->data_size = length; + packet->type = hpsb_iso; + packet->tcode = TCODE_ISO_DATA; } static void fill_phy_packet(struct hpsb_packet *packet, quadlet_t data) { - packet->header[0] = data; - packet->header[1] = ~data; - packet->header_size = 8; - packet->data_size = 0; - packet->expect_response = 0; - packet->type = hpsb_raw; /* No CRC added */ - packet->speed_code = IEEE1394_SPEED_100; /* Force speed to be 100Mbps */ + packet->header[0] = data; + packet->header[1] = ~data; + packet->header_size = 8; + packet->data_size = 0; + packet->expect_response = 0; + packet->type = hpsb_raw; /* No CRC added */ + packet->speed_code = IEEE1394_SPEED_100; /* Force speed to be 100Mbps */ } static void fill_async_stream_packet(struct hpsb_packet *packet, int length, int channel, int tag, int sync) { packet->header[0] = (length << 16) | (tag << 14) | (channel << 8) - | (TCODE_STREAM_DATA << 4) | sync; + | (TCODE_STREAM_DATA << 4) | sync; packet->header_size = 4; packet->data_size = length; @@ -173,96 +171,99 @@ int hpsb_get_tlabel(struct hpsb_packet *packet) */ void hpsb_free_tlabel(struct hpsb_packet *packet) { - unsigned long flags; + unsigned long flags; struct hpsb_tlabel_pool *tp; tp = &packet->host->tpool[packet->node_id & NODE_MASK]; BUG_ON(packet->tlabel > 63 || packet->tlabel < 0); - spin_lock_irqsave(&tp->lock, flags); + spin_lock_irqsave(&tp->lock, flags); BUG_ON(!test_and_clear_bit(packet->tlabel, tp->pool)); - spin_unlock_irqrestore(&tp->lock, flags); + spin_unlock_irqrestore(&tp->lock, flags); up(&tp->count); } -int hpsb_packet_success(struct hpsb_packet *packet) -{ - switch (packet->ack_code) { - case ACK_PENDING: - switch ((packet->header[1] >> 12) & 0xf) { - case RCODE_COMPLETE: - return 0; - case RCODE_CONFLICT_ERROR: - return -EAGAIN; - case RCODE_DATA_ERROR: - return -EREMOTEIO; - case RCODE_TYPE_ERROR: - return -EACCES; - case RCODE_ADDRESS_ERROR: - return -EINVAL; - default: - HPSB_ERR("received reserved rcode %d from node %d", - (packet->header[1] >> 12) & 0xf, - packet->node_id); - return -EAGAIN; - } - HPSB_PANIC("reached unreachable code 1 in %s", __FUNCTION__); - - case ACK_BUSY_X: - case ACK_BUSY_A: - case ACK_BUSY_B: - return -EBUSY; - - case ACK_TYPE_ERROR: - return -EACCES; - - case ACK_COMPLETE: - if (packet->tcode == TCODE_WRITEQ - || packet->tcode == TCODE_WRITEB) { - return 0; - } else { - HPSB_ERR("impossible ack_complete from node %d " - "(tcode %d)", packet->node_id, packet->tcode); - return -EAGAIN; - } - - case ACK_DATA_ERROR: - if (packet->tcode == TCODE_WRITEB - || packet->tcode == TCODE_LOCK_REQUEST) { - return -EAGAIN; - } else { - HPSB_ERR("impossible ack_data_error from node %d " - "(tcode %d)", packet->node_id, packet->tcode); - return -EAGAIN; - } - - case ACK_ADDRESS_ERROR: - return -EINVAL; - - case ACK_TARDY: - case ACK_CONFLICT_ERROR: - case ACKX_NONE: - case ACKX_SEND_ERROR: - case ACKX_ABORTED: - case ACKX_TIMEOUT: - /* error while sending */ - return -EAGAIN; - default: - HPSB_ERR("got invalid ack %d from node %d (tcode %d)", - packet->ack_code, packet->node_id, packet->tcode); - return -EAGAIN; - } - HPSB_PANIC("reached unreachable code 2 in %s", __FUNCTION__); +int hpsb_packet_success(struct hpsb_packet *packet) +{ + switch (packet->ack_code) { + case ACK_PENDING: + switch ((packet->header[1] >> 12) & 0xf) { + case RCODE_COMPLETE: + return 0; + case RCODE_CONFLICT_ERROR: + return -EAGAIN; + case RCODE_DATA_ERROR: + return -EREMOTEIO; + case RCODE_TYPE_ERROR: + return -EACCES; + case RCODE_ADDRESS_ERROR: + return -EINVAL; + default: + HPSB_ERR("received reserved rcode %d from node %d", + (packet->header[1] >> 12) & 0xf, + packet->node_id); + return -EAGAIN; + } + HPSB_PANIC("reached unreachable code 1 in %s", __FUNCTION__); + + case ACK_BUSY_X: + case ACK_BUSY_A: + case ACK_BUSY_B: + return -EBUSY; + + case ACK_TYPE_ERROR: + return -EACCES; + + case ACK_COMPLETE: + if (packet->tcode == TCODE_WRITEQ + || packet->tcode == TCODE_WRITEB) { + return 0; + } else { + HPSB_ERR("impossible ack_complete from node %d " + "(tcode %d)", packet->node_id, packet->tcode); + return -EAGAIN; + } + + + case ACK_DATA_ERROR: + if (packet->tcode == TCODE_WRITEB + || packet->tcode == TCODE_LOCK_REQUEST) { + return -EAGAIN; + } else { + HPSB_ERR("impossible ack_data_error from node %d " + "(tcode %d)", packet->node_id, packet->tcode); + return -EAGAIN; + } + + case ACK_ADDRESS_ERROR: + return -EINVAL; + + case ACK_TARDY: + case ACK_CONFLICT_ERROR: + case ACKX_NONE: + case ACKX_SEND_ERROR: + case ACKX_ABORTED: + case ACKX_TIMEOUT: + /* error while sending */ + return -EAGAIN; + + default: + HPSB_ERR("got invalid ack %d from node %d (tcode %d)", + packet->ack_code, packet->node_id, packet->tcode); + return -EAGAIN; + } + + HPSB_PANIC("reached unreachable code 2 in %s", __FUNCTION__); } struct hpsb_packet *hpsb_make_readpacket(struct hpsb_host *host, nodeid_t node, u64 addr, size_t length) { - struct hpsb_packet *packet; + struct hpsb_packet *packet; if (length == 0) return NULL; @@ -287,9 +288,8 @@ struct hpsb_packet *hpsb_make_readpacket(struct hpsb_host *host, nodeid_t node, return packet; } -struct hpsb_packet *hpsb_make_writepacket(struct hpsb_host *host, nodeid_t node, - u64 addr, quadlet_t * buffer, - size_t length) +struct hpsb_packet *hpsb_make_writepacket (struct hpsb_host *host, nodeid_t node, + u64 addr, quadlet_t *buffer, size_t length) { struct hpsb_packet *packet; @@ -300,7 +300,7 @@ struct hpsb_packet *hpsb_make_writepacket(struct hpsb_host *host, nodeid_t node, if (!packet) return NULL; - if (length % 4) { /* zero padding bytes */ + if (length % 4) { /* zero padding bytes */ packet->data[length >> 2] = 0; } packet->host = host; @@ -322,9 +322,8 @@ struct hpsb_packet *hpsb_make_writepacket(struct hpsb_host *host, nodeid_t node, return packet; } -struct hpsb_packet *hpsb_make_streampacket(struct hpsb_host *host, u8 * buffer, - int length, int channel, int tag, - int sync) +struct hpsb_packet *hpsb_make_streampacket(struct hpsb_host *host, u8 *buffer, int length, + int channel, int tag, int sync) { struct hpsb_packet *packet; @@ -335,7 +334,7 @@ struct hpsb_packet *hpsb_make_streampacket(struct hpsb_host *host, u8 * buffer, if (!packet) return NULL; - if (length % 4) { /* zero padding bytes */ + if (length % 4) { /* zero padding bytes */ packet->data[length >> 2] = 0; } packet->host = host; @@ -353,15 +352,14 @@ struct hpsb_packet *hpsb_make_streampacket(struct hpsb_host *host, u8 * buffer, } struct hpsb_packet *hpsb_make_lockpacket(struct hpsb_host *host, nodeid_t node, - u64 addr, int extcode, - quadlet_t * data, quadlet_t arg) + u64 addr, int extcode, quadlet_t *data, + quadlet_t arg) { struct hpsb_packet *p; u32 length; p = hpsb_alloc_packet(8); - if (!p) - return NULL; + if (!p) return NULL; p->host = host; p->node_id = node; @@ -390,16 +388,15 @@ struct hpsb_packet *hpsb_make_lockpacket(struct hpsb_host *host, nodeid_t node, return p; } -struct hpsb_packet *hpsb_make_lock64packet(struct hpsb_host *host, - nodeid_t node, u64 addr, int extcode, - octlet_t * data, octlet_t arg) +struct hpsb_packet *hpsb_make_lock64packet(struct hpsb_host *host, nodeid_t node, + u64 addr, int extcode, octlet_t *data, + octlet_t arg) { struct hpsb_packet *p; u32 length; p = hpsb_alloc_packet(16); - if (!p) - return NULL; + if (!p) return NULL; p->host = host; p->node_id = node; @@ -432,18 +429,18 @@ struct hpsb_packet *hpsb_make_lock64packet(struct hpsb_host *host, return p; } -struct hpsb_packet *hpsb_make_phypacket(struct hpsb_host *host, quadlet_t data) +struct hpsb_packet *hpsb_make_phypacket(struct hpsb_host *host, + quadlet_t data) { - struct hpsb_packet *p; + struct hpsb_packet *p; - p = hpsb_alloc_packet(0); - if (!p) - return NULL; + p = hpsb_alloc_packet(0); + if (!p) return NULL; - p->host = host; - fill_phy_packet(p, data); + p->host = host; + fill_phy_packet(p, data); - return p; + return p; } struct hpsb_packet *hpsb_make_isopacket(struct hpsb_host *host, @@ -453,8 +450,7 @@ struct hpsb_packet *hpsb_make_isopacket(struct hpsb_host *host, struct hpsb_packet *p; p = hpsb_alloc_packet(length); - if (!p) - return NULL; + if (!p) return NULL; p->host = host; fill_iso_packet(p, length, channel, tag, sync); @@ -470,46 +466,47 @@ struct hpsb_packet *hpsb_make_isopacket(struct hpsb_host *host, */ int hpsb_read(struct hpsb_host *host, nodeid_t node, unsigned int generation, - u64 addr, quadlet_t * buffer, size_t length) + u64 addr, quadlet_t *buffer, size_t length) { - struct hpsb_packet *packet; - int retval = 0; + struct hpsb_packet *packet; + int retval = 0; - if (length == 0) - return -EINVAL; + if (length == 0) + return -EINVAL; - BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet + BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet packet = hpsb_make_readpacket(host, node, addr, length); - if (!packet) { - return -ENOMEM; - } + if (!packet) { + return -ENOMEM; + } packet->generation = generation; - retval = hpsb_send_packet_and_wait(packet); + retval = hpsb_send_packet_and_wait(packet); if (retval < 0) goto hpsb_read_fail; - retval = hpsb_packet_success(packet); + retval = hpsb_packet_success(packet); - if (retval == 0) { - if (length == 4) { - *buffer = packet->header[3]; - } else { - memcpy(buffer, packet->data, length); - } - } + if (retval == 0) { + if (length == 4) { + *buffer = packet->header[3]; + } else { + memcpy(buffer, packet->data, length); + } + } - hpsb_read_fail: - hpsb_free_tlabel(packet); - hpsb_free_packet(packet); +hpsb_read_fail: + hpsb_free_tlabel(packet); + hpsb_free_packet(packet); - return retval; + return retval; } + int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation, - u64 addr, quadlet_t * buffer, size_t length) + u64 addr, quadlet_t *buffer, size_t length) { struct hpsb_packet *packet; int retval; @@ -517,61 +514,62 @@ int hpsb_write(struct hpsb_host *host, nodeid_t node, unsigned int generation, if (length == 0) return -EINVAL; - BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet + BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet - packet = hpsb_make_writepacket(host, node, addr, buffer, length); + packet = hpsb_make_writepacket (host, node, addr, buffer, length); if (!packet) return -ENOMEM; packet->generation = generation; - retval = hpsb_send_packet_and_wait(packet); + retval = hpsb_send_packet_and_wait(packet); if (retval < 0) goto hpsb_write_fail; - retval = hpsb_packet_success(packet); + retval = hpsb_packet_success(packet); - hpsb_write_fail: - hpsb_free_tlabel(packet); - hpsb_free_packet(packet); +hpsb_write_fail: + hpsb_free_tlabel(packet); + hpsb_free_packet(packet); - return retval; + return retval; } #if 0 int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation, - u64 addr, int extcode, quadlet_t * data, quadlet_t arg) + u64 addr, int extcode, quadlet_t *data, quadlet_t arg) { - struct hpsb_packet *packet; - int retval = 0; + struct hpsb_packet *packet; + int retval = 0; - BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet + BUG_ON(in_interrupt()); // We can't be called in an interrupt, yet packet = hpsb_make_lockpacket(host, node, addr, extcode, data, arg); - if (!packet) - return -ENOMEM; + if (!packet) + return -ENOMEM; packet->generation = generation; - retval = hpsb_send_packet_and_wait(packet); + retval = hpsb_send_packet_and_wait(packet); if (retval < 0) goto hpsb_lock_fail; - retval = hpsb_packet_success(packet); + retval = hpsb_packet_success(packet); - if (retval == 0) { - *data = packet->data[0]; - } + if (retval == 0) { + *data = packet->data[0]; + } - hpsb_lock_fail: - hpsb_free_tlabel(packet); - hpsb_free_packet(packet); +hpsb_lock_fail: + hpsb_free_tlabel(packet); + hpsb_free_packet(packet); - return retval; + return retval; } + int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation, - quadlet_t * buffer, size_t length, u32 specifier_id, + quadlet_t *buffer, size_t length, u32 specifier_id, unsigned int version) { struct hpsb_packet *packet; @@ -588,8 +586,7 @@ int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation, return -ENOMEM; packet->data[0] = cpu_to_be32((host->node_id << 16) | specifier_id_hi); - packet->data[1] = - cpu_to_be32((specifier_id_lo << 24) | (version & 0x00ffffff)); + packet->data[1] = cpu_to_be32((specifier_id_lo << 24) | (version & 0x00ffffff)); memcpy(&(packet->data[2]), buffer, length - 8); @@ -604,4 +601,4 @@ int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation, return retval; } -#endif /* 0 */ +#endif /* 0 */ diff --git a/trunk/drivers/ieee1394/iso.c b/trunk/drivers/ieee1394/iso.c index f26680ebef7c..615541b8b90f 100644 --- a/trunk/drivers/ieee1394/iso.c +++ b/trunk/drivers/ieee1394/iso.c @@ -36,22 +36,20 @@ void hpsb_iso_shutdown(struct hpsb_iso *iso) kfree(iso); } -static struct hpsb_iso *hpsb_iso_common_init(struct hpsb_host *host, - enum hpsb_iso_type type, +static struct hpsb_iso* hpsb_iso_common_init(struct hpsb_host *host, enum hpsb_iso_type type, unsigned int data_buf_size, unsigned int buf_packets, - int channel, int dma_mode, + int channel, + int dma_mode, int irq_interval, - void (*callback) (struct hpsb_iso - *)) + void (*callback)(struct hpsb_iso*)) { struct hpsb_iso *iso; int dma_direction; /* make sure driver supports the ISO API */ if (!host->driver->isoctl) { - printk(KERN_INFO - "ieee1394: host driver '%s' does not support the rawiso API\n", + printk(KERN_INFO "ieee1394: host driver '%s' does not support the rawiso API\n", host->driver->name); return NULL; } @@ -61,13 +59,12 @@ static struct hpsb_iso *hpsb_iso_common_init(struct hpsb_host *host, if (buf_packets < 2) buf_packets = 2; - if ((dma_mode < HPSB_ISO_DMA_DEFAULT) - || (dma_mode > HPSB_ISO_DMA_PACKET_PER_BUFFER)) - dma_mode = HPSB_ISO_DMA_DEFAULT; + if ((dma_mode < HPSB_ISO_DMA_DEFAULT) || (dma_mode > HPSB_ISO_DMA_PACKET_PER_BUFFER)) + dma_mode=HPSB_ISO_DMA_DEFAULT; if ((irq_interval < 0) || (irq_interval > buf_packets / 4)) - irq_interval = buf_packets / 4; - if (irq_interval == 0) /* really interrupt for each packet */ + irq_interval = buf_packets / 4; + if (irq_interval == 0) /* really interrupt for each packet*/ irq_interval = 1; if (channel < -1 || channel >= 64) @@ -79,10 +76,7 @@ static struct hpsb_iso *hpsb_iso_common_init(struct hpsb_host *host, /* allocate and write the struct hpsb_iso */ - iso = - kmalloc(sizeof(*iso) + - buf_packets * sizeof(struct hpsb_iso_packet_info), - GFP_KERNEL); + iso = kmalloc(sizeof(*iso) + buf_packets * sizeof(struct hpsb_iso_packet_info), GFP_KERNEL); if (!iso) return NULL; @@ -117,18 +111,17 @@ static struct hpsb_iso *hpsb_iso_common_init(struct hpsb_host *host, iso->prebuffer = 0; /* allocate the packet buffer */ - if (dma_region_alloc - (&iso->data_buf, iso->buf_size, host->pdev, dma_direction)) + if (dma_region_alloc(&iso->data_buf, iso->buf_size, host->pdev, dma_direction)) goto err; return iso; - err: +err: hpsb_iso_shutdown(iso); return NULL; } -int hpsb_iso_n_ready(struct hpsb_iso *iso) +int hpsb_iso_n_ready(struct hpsb_iso* iso) { unsigned long flags; int val; @@ -140,19 +133,18 @@ int hpsb_iso_n_ready(struct hpsb_iso *iso) return val; } -struct hpsb_iso *hpsb_iso_xmit_init(struct hpsb_host *host, + +struct hpsb_iso* hpsb_iso_xmit_init(struct hpsb_host *host, unsigned int data_buf_size, unsigned int buf_packets, int channel, int speed, int irq_interval, - void (*callback) (struct hpsb_iso *)) + void (*callback)(struct hpsb_iso*)) { struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_XMIT, data_buf_size, buf_packets, - channel, - HPSB_ISO_DMA_DEFAULT, - irq_interval, callback); + channel, HPSB_ISO_DMA_DEFAULT, irq_interval, callback); if (!iso) return NULL; @@ -165,23 +157,22 @@ struct hpsb_iso *hpsb_iso_xmit_init(struct hpsb_host *host, iso->flags |= HPSB_ISO_DRIVER_INIT; return iso; - err: +err: hpsb_iso_shutdown(iso); return NULL; } -struct hpsb_iso *hpsb_iso_recv_init(struct hpsb_host *host, +struct hpsb_iso* hpsb_iso_recv_init(struct hpsb_host *host, unsigned int data_buf_size, unsigned int buf_packets, int channel, int dma_mode, int irq_interval, - void (*callback) (struct hpsb_iso *)) + void (*callback)(struct hpsb_iso*)) { struct hpsb_iso *iso = hpsb_iso_common_init(host, HPSB_ISO_RECV, data_buf_size, buf_packets, - channel, dma_mode, - irq_interval, callback); + channel, dma_mode, irq_interval, callback); if (!iso) return NULL; @@ -192,7 +183,7 @@ struct hpsb_iso *hpsb_iso_recv_init(struct hpsb_host *host, iso->flags |= HPSB_ISO_DRIVER_INIT; return iso; - err: +err: hpsb_iso_shutdown(iso); return NULL; } @@ -206,17 +197,16 @@ int hpsb_iso_recv_listen_channel(struct hpsb_iso *iso, unsigned char channel) int hpsb_iso_recv_unlisten_channel(struct hpsb_iso *iso, unsigned char channel) { - if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64) - return -EINVAL; - return iso->host->driver->isoctl(iso, RECV_UNLISTEN_CHANNEL, channel); + if (iso->type != HPSB_ISO_RECV || iso->channel != -1 || channel >= 64) + return -EINVAL; + return iso->host->driver->isoctl(iso, RECV_UNLISTEN_CHANNEL, channel); } int hpsb_iso_recv_set_channel_mask(struct hpsb_iso *iso, u64 mask) { if (iso->type != HPSB_ISO_RECV || iso->channel != -1) return -EINVAL; - return iso->host->driver->isoctl(iso, RECV_SET_CHANNEL_MASK, - (unsigned long)&mask); + return iso->host->driver->isoctl(iso, RECV_SET_CHANNEL_MASK, (unsigned long) &mask); } int hpsb_iso_recv_flush(struct hpsb_iso *iso) @@ -293,9 +283,7 @@ int hpsb_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync) isoctl_args[2] = sync; - retval = - iso->host->driver->isoctl(iso, RECV_START, - (unsigned long)&isoctl_args[0]); + retval = iso->host->driver->isoctl(iso, RECV_START, (unsigned long) &isoctl_args[0]); if (retval) return retval; @@ -308,8 +296,7 @@ int hpsb_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync) static int hpsb_iso_check_offset_len(struct hpsb_iso *iso, unsigned int offset, unsigned short len, - unsigned int *out_offset, - unsigned short *out_len) + unsigned int *out_offset, unsigned short *out_len) { if (offset >= iso->buf_size) return -EFAULT; @@ -329,8 +316,8 @@ static int hpsb_iso_check_offset_len(struct hpsb_iso *iso, return 0; } -int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len, - u8 tag, u8 sy) + +int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len, u8 tag, u8 sy) { struct hpsb_iso_packet_info *info; unsigned long flags; @@ -347,8 +334,7 @@ int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len, info = &iso->infos[iso->first_packet]; /* check for bogus offset/length */ - if (hpsb_iso_check_offset_len - (iso, offset, len, &info->offset, &info->len)) + if (hpsb_iso_check_offset_len(iso, offset, len, &info->offset, &info->len)) return -EFAULT; info->tag = tag; @@ -356,13 +342,13 @@ int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len, spin_lock_irqsave(&iso->lock, flags); - rv = iso->host->driver->isoctl(iso, XMIT_QUEUE, (unsigned long)info); + rv = iso->host->driver->isoctl(iso, XMIT_QUEUE, (unsigned long) info); if (rv) goto out; /* increment cursors */ - iso->first_packet = (iso->first_packet + 1) % iso->buf_packets; - iso->xmit_cycle = (iso->xmit_cycle + 1) % 8000; + iso->first_packet = (iso->first_packet+1) % iso->buf_packets; + iso->xmit_cycle = (iso->xmit_cycle+1) % 8000; iso->n_ready_packets--; if (iso->prebuffer != 0) { @@ -373,7 +359,7 @@ int hpsb_iso_xmit_queue_packet(struct hpsb_iso *iso, u32 offset, u16 len, } } - out: +out: spin_unlock_irqrestore(&iso->lock, flags); return rv; } @@ -383,9 +369,7 @@ int hpsb_iso_xmit_sync(struct hpsb_iso *iso) if (iso->type != HPSB_ISO_XMIT) return -EINVAL; - return wait_event_interruptible(iso->waitq, - hpsb_iso_n_ready(iso) == - iso->buf_packets); + return wait_event_interruptible(iso->waitq, hpsb_iso_n_ready(iso) == iso->buf_packets); } void hpsb_iso_packet_sent(struct hpsb_iso *iso, int cycle, int error) @@ -412,8 +396,7 @@ void hpsb_iso_packet_sent(struct hpsb_iso *iso, int cycle, int error) } void hpsb_iso_packet_received(struct hpsb_iso *iso, u32 offset, u16 len, - u16 total_len, u16 cycle, u8 channel, u8 tag, - u8 sy) + u16 total_len, u16 cycle, u8 channel, u8 tag, u8 sy) { unsigned long flags; spin_lock_irqsave(&iso->lock, flags); @@ -433,7 +416,7 @@ void hpsb_iso_packet_received(struct hpsb_iso *iso, u32 offset, u16 len, info->tag = tag; info->sy = sy; - iso->pkt_dma = (iso->pkt_dma + 1) % iso->buf_packets; + iso->pkt_dma = (iso->pkt_dma+1) % iso->buf_packets; iso->n_ready_packets++; } @@ -452,21 +435,20 @@ int hpsb_iso_recv_release_packets(struct hpsb_iso *iso, unsigned int n_packets) spin_lock_irqsave(&iso->lock, flags); for (i = 0; i < n_packets; i++) { rv = iso->host->driver->isoctl(iso, RECV_RELEASE, - (unsigned long)&iso->infos[iso-> - first_packet]); + (unsigned long) &iso->infos[iso->first_packet]); if (rv) break; - iso->first_packet = (iso->first_packet + 1) % iso->buf_packets; + iso->first_packet = (iso->first_packet+1) % iso->buf_packets; iso->n_ready_packets--; /* release memory from packets discarded when queue was full */ - if (iso->n_ready_packets == 0) { /* Release only after all prior packets handled */ + if (iso->n_ready_packets == 0) { /* Release only after all prior packets handled */ if (iso->bytes_discarded != 0) { struct hpsb_iso_packet_info inf; inf.total_len = iso->bytes_discarded; iso->host->driver->isoctl(iso, RECV_RELEASE, - (unsigned long)&inf); + (unsigned long) &inf); iso->bytes_discarded = 0; } } diff --git a/trunk/drivers/ieee1394/nodemgr.c b/trunk/drivers/ieee1394/nodemgr.c index 082c7fd239f5..0ea37b1bccb2 100644 --- a/trunk/drivers/ieee1394/nodemgr.c +++ b/trunk/drivers/ieee1394/nodemgr.c @@ -121,8 +121,8 @@ struct host_info { }; static int nodemgr_bus_match(struct device * dev, struct device_driver * drv); -static int nodemgr_uevent(struct class_device *cdev, char **envp, int num_envp, - char *buffer, int buffer_size); +static int nodemgr_hotplug(struct class_device *cdev, char **envp, int num_envp, + char *buffer, int buffer_size); static void nodemgr_resume_ne(struct node_entry *ne); static void nodemgr_remove_ne(struct node_entry *ne); static struct node_entry *find_entry_by_guid(u64 guid); @@ -162,7 +162,7 @@ static void ud_cls_release(struct class_device *class_dev) static struct class nodemgr_ud_class = { .name = "ieee1394", .release = ud_cls_release, - .uevent = nodemgr_uevent, + .hotplug = nodemgr_hotplug, }; static struct hpsb_highlevel nodemgr_highlevel; @@ -743,20 +743,21 @@ static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr unsigned int generation) { struct hpsb_host *host = hi->host; - struct node_entry *ne; + struct node_entry *ne; - ne = kzalloc(sizeof(*ne), GFP_KERNEL); - if (!ne) - return NULL; + ne = kmalloc(sizeof(struct node_entry), GFP_KERNEL); + if (!ne) return NULL; + + memset(ne, 0, sizeof(struct node_entry)); ne->tpool = &host->tpool[nodeid & NODE_MASK]; - ne->host = host; - ne->nodeid = nodeid; + ne->host = host; + ne->nodeid = nodeid; ne->generation = generation; ne->needs_probe = 1; - ne->guid = guid; + ne->guid = guid; ne->guid_vendor_id = (guid >> 40) & 0xffffff; ne->guid_vendor_oui = nodemgr_find_oui_name(ne->guid_vendor_id); ne->csr = csr; @@ -786,7 +787,7 @@ static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr (host->node_id == nodeid) ? "Host" : "Node", NODE_BUS_ARGS(host, nodeid), (unsigned long long)guid); - return ne; + return ne; } @@ -871,10 +872,12 @@ static struct unit_directory *nodemgr_process_unit_directory struct csr1212_keyval *kv; u8 last_key_id = 0; - ud = kzalloc(sizeof(*ud), GFP_KERNEL); + ud = kmalloc(sizeof(struct unit_directory), GFP_KERNEL); if (!ud) goto unit_directory_error; + memset (ud, 0, sizeof(struct unit_directory)); + ud->ne = ne; ud->ignore_driver = ignore_drivers; ud->address = ud_kv->offset + CSR1212_CONFIG_ROM_SPACE_BASE; @@ -934,10 +937,10 @@ static struct unit_directory *nodemgr_process_unit_directory /* Logical Unit Number */ if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) { if (ud->flags & UNIT_DIRECTORY_HAS_LUN) { - ud_child = kmalloc(sizeof(*ud_child), GFP_KERNEL); + ud_child = kmalloc(sizeof(struct unit_directory), GFP_KERNEL); if (!ud_child) goto unit_directory_error; - memcpy(ud_child, ud, sizeof(*ud_child)); + memcpy(ud_child, ud, sizeof(struct unit_directory)); nodemgr_register_device(ne, ud_child, &ne->device); ud_child = NULL; @@ -963,7 +966,7 @@ static struct unit_directory *nodemgr_process_unit_directory if (ud_child == NULL) break; - /* inherit unspecified values, the driver core picks it up */ + /* inherit unspecified values so hotplug picks it up */ if ((ud->flags & UNIT_DIRECTORY_MODEL_ID) && !(ud_child->flags & UNIT_DIRECTORY_MODEL_ID)) { @@ -1059,8 +1062,8 @@ static void nodemgr_process_root_directory(struct host_info *hi, struct node_ent #ifdef CONFIG_HOTPLUG -static int nodemgr_uevent(struct class_device *cdev, char **envp, int num_envp, - char *buffer, int buffer_size) +static int nodemgr_hotplug(struct class_device *cdev, char **envp, int num_envp, + char *buffer, int buffer_size) { struct unit_directory *ud; int i = 0; @@ -1109,8 +1112,8 @@ do { \ #else -static int nodemgr_uevent(struct class_device *cdev, char **envp, int num_envp, - char *buffer, int buffer_size) +static int nodemgr_hotplug(struct class_device *cdev, char **envp, int num_envp, + char *buffer, int buffer_size) { return -ENODEV; } @@ -1197,7 +1200,7 @@ static void nodemgr_node_scan_one(struct host_info *hi, struct csr1212_csr *csr; struct nodemgr_csr_info *ci; - ci = kmalloc(sizeof(*ci), GFP_KERNEL); + ci = kmalloc(sizeof(struct nodemgr_csr_info), GFP_KERNEL); if (!ci) return; @@ -1407,28 +1410,14 @@ static void nodemgr_node_probe(struct host_info *hi, int generation) struct hpsb_host *host = hi->host; struct class *class = &nodemgr_ne_class; struct class_device *cdev; - struct node_entry *ne; /* Do some processing of the nodes we've probed. This pulls them * into the sysfs layer if needed, and can result in processing of * unit-directories, or just updating the node and it's - * unit-directories. - * - * Run updates before probes. Usually, updates are time-critical - * while probes are time-consuming. (Well, those probes need some - * improvement...) */ - + * unit-directories. */ down_read(&class->subsys.rwsem); - list_for_each_entry(cdev, &class->children, node) { - ne = container_of(cdev, struct node_entry, class_dev); - if (!ne->needs_probe) - nodemgr_probe_ne(hi, ne, generation); - } - list_for_each_entry(cdev, &class->children, node) { - ne = container_of(cdev, struct node_entry, class_dev); - if (ne->needs_probe) - nodemgr_probe_ne(hi, ne, generation); - } + list_for_each_entry(cdev, &class->children, node) + nodemgr_probe_ne(hi, container_of(cdev, struct node_entry, class_dev), generation); up_read(&class->subsys.rwsem); @@ -1459,8 +1448,7 @@ static int nodemgr_send_resume_packet(struct hpsb_host *host) int ret = 1; packet = hpsb_make_phypacket(host, - EXTPHYPACKET_TYPE_RESUME | - NODEID_TO_NODE(host->node_id) << PHYPACKET_PORT_SHIFT); + 0x003c0000 | NODEID_TO_NODE(host->node_id) << 24); if (packet) { packet->no_waiter = 1; packet->generation = get_hpsb_generation(host); @@ -1630,8 +1618,8 @@ static int nodemgr_host_thread(void *__hi) /* Scan our nodes to get the bus options and create node * entries. This does not do the sysfs stuff, since that - * would trigger uevents and such, which is a bad idea at - * this point. */ + * would trigger hotplug callbacks and such, which is a + * bad idea at this point. */ nodemgr_node_scan(hi, generation); /* This actually does the full probe, with sysfs diff --git a/trunk/drivers/ieee1394/nodemgr.h b/trunk/drivers/ieee1394/nodemgr.h index 0b26616e16c3..3a2f0c02fd08 100644 --- a/trunk/drivers/ieee1394/nodemgr.h +++ b/trunk/drivers/ieee1394/nodemgr.h @@ -150,6 +150,24 @@ static inline int hpsb_node_entry_valid(struct node_entry *ne) return ne->generation == get_hpsb_generation(ne->host); } +/* + * Returns a node entry (which has its reference count incremented) or NULL if + * the GUID in question is not known. Getting a valid entry does not mean that + * the node with this GUID is currently accessible (might be powered down). + */ +struct node_entry *hpsb_guid_get_entry(u64 guid); + +/* Same as above, but use the nodeid to get an node entry. This is not + * fool-proof by itself, since the nodeid can change. */ +struct node_entry *hpsb_nodeid_get_entry(struct hpsb_host *host, nodeid_t nodeid); + +/* + * If the entry refers to a local host, this function will return the pointer + * to the hpsb_host structure. It will return NULL otherwise. Once you have + * established it is a local host, you can use that knowledge from then on (the + * GUID won't wander to an external node). */ +struct hpsb_host *hpsb_get_host_by_ne(struct node_entry *ne); + /* * This will fill in the given, pre-initialised hpsb_packet with the current * information from the node entry (host, node ID, generation number). It will diff --git a/trunk/drivers/ieee1394/ohci1394.c b/trunk/drivers/ieee1394/ohci1394.c index b6b96fa04d62..4cf9b8f3e336 100644 --- a/trunk/drivers/ieee1394/ohci1394.c +++ b/trunk/drivers/ieee1394/ohci1394.c @@ -161,6 +161,9 @@ printk(level "%s: " fmt "\n" , OHCI1394_DRIVER_NAME , ## args) #define PRINT(level, fmt, args...) \ printk(level "%s: fw-host%d: " fmt "\n" , OHCI1394_DRIVER_NAME, ohci->host->id , ## args) +static char version[] __devinitdata = + "$Rev: 1313 $ Ben Collins "; + /* Module Parameters */ static int phys_dma = 1; module_param(phys_dma, int, 0644); @@ -584,13 +587,12 @@ static void ohci_initialize(struct ti_ohci *ohci) sprintf (irq_buf, "%s", __irq_itoa(ohci->dev->irq)); #endif PRINT(KERN_INFO, "OHCI-1394 %d.%d (PCI): IRQ=[%s] " - "MMIO=[%lx-%lx] Max Packet=[%d] IR/IT contexts=[%d/%d]", + "MMIO=[%lx-%lx] Max Packet=[%d]", ((((buf) >> 16) & 0xf) + (((buf) >> 20) & 0xf) * 10), ((((buf) >> 4) & 0xf) + ((buf) & 0xf) * 10), irq_buf, pci_resource_start(ohci->dev, 0), pci_resource_start(ohci->dev, 0) + OHCI1394_REGISTER_SIZE - 1, - ohci->max_packet_size, - ohci->nb_iso_rcv_ctx, ohci->nb_iso_xmit_ctx); + ohci->max_packet_size); /* Check all of our ports to make sure that if anything is * connected, we enable that port. */ @@ -2958,23 +2960,28 @@ alloc_dma_rcv_ctx(struct ti_ohci *ohci, struct dma_rcv_ctx *d, d->ctrlClear = 0; d->cmdPtr = 0; - d->buf_cpu = kzalloc(d->num_desc * sizeof(*d->buf_cpu), GFP_ATOMIC); - d->buf_bus = kzalloc(d->num_desc * sizeof(*d->buf_bus), GFP_ATOMIC); + d->buf_cpu = kmalloc(d->num_desc * sizeof(quadlet_t*), GFP_ATOMIC); + d->buf_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_ATOMIC); if (d->buf_cpu == NULL || d->buf_bus == NULL) { PRINT(KERN_ERR, "Failed to allocate dma buffer"); free_dma_rcv_ctx(d); return -ENOMEM; } + memset(d->buf_cpu, 0, d->num_desc * sizeof(quadlet_t*)); + memset(d->buf_bus, 0, d->num_desc * sizeof(dma_addr_t)); - d->prg_cpu = kzalloc(d->num_desc * sizeof(*d->prg_cpu), GFP_ATOMIC); - d->prg_bus = kzalloc(d->num_desc * sizeof(*d->prg_bus), GFP_ATOMIC); + d->prg_cpu = kmalloc(d->num_desc * sizeof(struct dma_cmd*), + GFP_ATOMIC); + d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_ATOMIC); if (d->prg_cpu == NULL || d->prg_bus == NULL) { PRINT(KERN_ERR, "Failed to allocate dma prg"); free_dma_rcv_ctx(d); return -ENOMEM; } + memset(d->prg_cpu, 0, d->num_desc * sizeof(struct dma_cmd*)); + memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t)); d->spb = kmalloc(d->split_buf_size, GFP_ATOMIC); @@ -3086,14 +3093,17 @@ alloc_dma_trm_ctx(struct ti_ohci *ohci, struct dma_trm_ctx *d, d->ctrlClear = 0; d->cmdPtr = 0; - d->prg_cpu = kzalloc(d->num_desc * sizeof(*d->prg_cpu), GFP_KERNEL); - d->prg_bus = kzalloc(d->num_desc * sizeof(*d->prg_bus), GFP_KERNEL); + d->prg_cpu = kmalloc(d->num_desc * sizeof(struct at_dma_prg*), + GFP_KERNEL); + d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL); if (d->prg_cpu == NULL || d->prg_bus == NULL) { PRINT(KERN_ERR, "Failed to allocate at dma prg"); free_dma_trm_ctx(d); return -ENOMEM; } + memset(d->prg_cpu, 0, d->num_desc * sizeof(struct at_dma_prg*)); + memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t)); len = sprintf(pool_name, "ohci1394_trm_prg"); sprintf(pool_name+len, "%d", num_allocs); @@ -3191,6 +3201,8 @@ static struct hpsb_host_driver ohci1394_driver = { .hw_csr_reg = ohci_hw_csr_reg, }; + + /*********************************** * PCI Driver Interface functions * ***********************************/ @@ -3205,10 +3217,15 @@ do { \ static int __devinit ohci1394_pci_probe(struct pci_dev *dev, const struct pci_device_id *ent) { + static int version_printed = 0; + struct hpsb_host *host; struct ti_ohci *ohci; /* shortcut to currently handled device */ unsigned long ohci_base; + if (version_printed++ == 0) + PRINT_G(KERN_INFO, "%s", version); + if (pci_enable_device(dev)) FAIL(-ENXIO, "Failed to enable OHCI hardware"); pci_set_master(dev); @@ -3352,8 +3369,13 @@ static int __devinit ohci1394_pci_probe(struct pci_dev *dev, /* Determine the number of available IR and IT contexts. */ ohci->nb_iso_rcv_ctx = get_nb_iso_ctx(ohci, OHCI1394_IsoRecvIntMaskSet); + DBGMSG("%d iso receive contexts available", + ohci->nb_iso_rcv_ctx); + ohci->nb_iso_xmit_ctx = get_nb_iso_ctx(ohci, OHCI1394_IsoXmitIntMaskSet); + DBGMSG("%d iso transmit contexts available", + ohci->nb_iso_xmit_ctx); /* Set the usage bits for non-existent contexts so they can't * be allocated */ @@ -3584,6 +3606,8 @@ static struct pci_driver ohci1394_pci_driver = { .suspend = ohci1394_pci_suspend, }; + + /*********************************** * OHCI1394 Video Interface * ***********************************/ @@ -3690,6 +3714,7 @@ EXPORT_SYMBOL(ohci1394_init_iso_tasklet); EXPORT_SYMBOL(ohci1394_register_iso_tasklet); EXPORT_SYMBOL(ohci1394_unregister_iso_tasklet); + /*********************************** * General module initialization * ***********************************/ diff --git a/trunk/drivers/ieee1394/ohci1394.h b/trunk/drivers/ieee1394/ohci1394.h index 7df0962144e3..cc66c1cae250 100644 --- a/trunk/drivers/ieee1394/ohci1394.h +++ b/trunk/drivers/ieee1394/ohci1394.h @@ -219,8 +219,8 @@ struct ti_ohci { int self_id_errors; - /* Tasklets for iso receive and transmit, used by video1394 - * and dv1394 */ + /* Tasklets for iso receive and transmit, used by video1394, + * amdtp and dv1394 */ struct list_head iso_tasklet_list; spinlock_t iso_tasklet_list_lock; diff --git a/trunk/drivers/ieee1394/pcilynx.c b/trunk/drivers/ieee1394/pcilynx.c index e2edc41e1b6f..6b1ab875333b 100644 --- a/trunk/drivers/ieee1394/pcilynx.c +++ b/trunk/drivers/ieee1394/pcilynx.c @@ -1435,7 +1435,7 @@ static int __devinit add_card(struct pci_dev *dev, struct i2c_algo_bit_data i2c_adapter_data; error = -ENOMEM; - i2c_ad = kmalloc(sizeof(*i2c_ad), SLAB_KERNEL); + i2c_ad = kmalloc(sizeof(struct i2c_adapter), SLAB_KERNEL); if (!i2c_ad) FAIL("failed to allocate I2C adapter memory"); memcpy(i2c_ad, &bit_ops, sizeof(struct i2c_adapter)); diff --git a/trunk/drivers/ieee1394/raw1394.c b/trunk/drivers/ieee1394/raw1394.c index b05235639918..24411e666b21 100644 --- a/trunk/drivers/ieee1394/raw1394.c +++ b/trunk/drivers/ieee1394/raw1394.c @@ -102,9 +102,12 @@ static struct pending_request *__alloc_pending_request(gfp_t flags) { struct pending_request *req; - req = kzalloc(sizeof(*req), flags); - if (req) + req = (struct pending_request *)kmalloc(sizeof(struct pending_request), + flags); + if (req != NULL) { + memset(req, 0, sizeof(struct pending_request)); INIT_LIST_HEAD(&req->list); + } return req; } @@ -189,9 +192,9 @@ static void add_host(struct hpsb_host *host) struct host_info *hi; unsigned long flags; - hi = kmalloc(sizeof(*hi), GFP_KERNEL); + hi = (struct host_info *)kmalloc(sizeof(struct host_info), GFP_KERNEL); - if (hi) { + if (hi != NULL) { INIT_LIST_HEAD(&hi->list); hi->host = host; INIT_LIST_HEAD(&hi->file_info_list); @@ -312,8 +315,8 @@ static void iso_receive(struct hpsb_host *host, int channel, quadlet_t * data, break; if (!ibs) { - ibs = kmalloc(sizeof(*ibs) + length, - SLAB_ATOMIC); + ibs = kmalloc(sizeof(struct iso_block_store) + + length, SLAB_ATOMIC); if (!ibs) { kfree(req); break; @@ -373,8 +376,8 @@ static void fcp_request(struct hpsb_host *host, int nodeid, int direction, break; if (!ibs) { - ibs = kmalloc(sizeof(*ibs) + length, - SLAB_ATOMIC); + ibs = kmalloc(sizeof(struct iso_block_store) + + length, SLAB_ATOMIC); if (!ibs) { kfree(req); break; @@ -499,9 +502,10 @@ static int state_initialized(struct file_info *fi, struct pending_request *req) switch (req->req.type) { case RAW1394_REQ_LIST_CARDS: spin_lock_irqsave(&host_info_lock, flags); - khl = kmalloc(sizeof(*khl) * host_count, SLAB_ATOMIC); + khl = kmalloc(sizeof(struct raw1394_khost_list) * host_count, + SLAB_ATOMIC); - if (khl) { + if (khl != NULL) { req->req.misc = host_count; req->data = (quadlet_t *) khl; @@ -513,7 +517,7 @@ static int state_initialized(struct file_info *fi, struct pending_request *req) } spin_unlock_irqrestore(&host_info_lock, flags); - if (khl) { + if (khl != NULL) { req->req.error = RAW1394_ERROR_NONE; req->req.length = min(req->req.length, (u32) (sizeof @@ -1643,13 +1647,13 @@ static int arm_register(struct file_info *fi, struct pending_request *req) return (-EINVAL); } /* addr-list-entry for fileinfo */ - addr = kmalloc(sizeof(*addr), SLAB_KERNEL); + addr = (struct arm_addr *)kmalloc(sizeof(struct arm_addr), SLAB_KERNEL); if (!addr) { req->req.length = 0; return (-ENOMEM); } /* allocation of addr_space_buffer */ - addr->addr_space_buffer = vmalloc(req->req.length); + addr->addr_space_buffer = (u8 *) vmalloc(req->req.length); if (!(addr->addr_space_buffer)) { kfree(addr); req->req.length = 0; @@ -2118,7 +2122,8 @@ static int modify_config_rom(struct file_info *fi, struct pending_request *req) return -ENOMEM; } - cache->filled_head = kmalloc(sizeof(*cache->filled_head), GFP_KERNEL); + cache->filled_head = + kmalloc(sizeof(struct csr1212_cache_region), GFP_KERNEL); if (!cache->filled_head) { csr1212_release_keyval(fi->csr1212_dirs[dr]); fi->csr1212_dirs[dr] = NULL; @@ -2131,6 +2136,7 @@ static int modify_config_rom(struct file_info *fi, struct pending_request *req) req->req.length)) { csr1212_release_keyval(fi->csr1212_dirs[dr]); fi->csr1212_dirs[dr] = NULL; + CSR1212_FREE(cache); ret = -EFAULT; } else { cache->len = req->req.length; @@ -2166,7 +2172,7 @@ static int modify_config_rom(struct file_info *fi, struct pending_request *req) } } kfree(cache->filled_head); - CSR1212_FREE(cache); + kfree(cache); if (ret >= 0) { /* we have to free the request, because we queue no response, @@ -2482,8 +2488,8 @@ static int raw1394_iso_recv_packets(struct file_info *fi, void __user * uaddr) /* ensure user-supplied buffer is accessible and big enough */ if (!access_ok(VERIFY_WRITE, upackets.infos, - upackets.n_packets * - sizeof(struct raw1394_iso_packet_info))) + upackets.n_packets * + sizeof(struct raw1394_iso_packet_info))) return -EFAULT; /* copy the packet_infos out */ @@ -2516,8 +2522,8 @@ static int raw1394_iso_send_packets(struct file_info *fi, void __user * uaddr) /* ensure user-supplied buffer is accessible and big enough */ if (!access_ok(VERIFY_READ, upackets.infos, - upackets.n_packets * - sizeof(struct raw1394_iso_packet_info))) + upackets.n_packets * + sizeof(struct raw1394_iso_packet_info))) return -EFAULT; /* copy the infos structs in and queue the packets */ @@ -2678,10 +2684,11 @@ static int raw1394_open(struct inode *inode, struct file *file) { struct file_info *fi; - fi = kzalloc(sizeof(*fi), SLAB_KERNEL); - if (!fi) + fi = kmalloc(sizeof(struct file_info), SLAB_KERNEL); + if (fi == NULL) return -ENOMEM; + memset(fi, 0, sizeof(struct file_info)); fi->notification = (u8) RAW1394_NOTIFY_ON; /* busreset notification */ INIT_LIST_HEAD(&fi->list); @@ -2741,7 +2748,8 @@ static int raw1394_release(struct inode *inode, struct file *file) list) { entry = fi_hlp->addr_list.next; while (entry != &(fi_hlp->addr_list)) { - arm_addr = list_entry(entry, struct + arm_addr = list_entry(entry, + struct arm_addr, addr_list); if (arm_addr->start == @@ -2904,17 +2912,16 @@ static int __init init_raw1394(void) hpsb_register_highlevel(&raw1394_highlevel); - if (IS_ERR - (class_device_create - (hpsb_protocol_class, NULL, - MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16), NULL, - RAW1394_DEVICE_NAME))) { + if (IS_ERR(class_device_create(hpsb_protocol_class, NULL, MKDEV( + IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16), + NULL, RAW1394_DEVICE_NAME))) { ret = -EFAULT; goto out_unreg; } - - devfs_mk_cdev(MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16), - S_IFCHR | S_IRUSR | S_IWUSR, RAW1394_DEVICE_NAME); + + devfs_mk_cdev(MKDEV( + IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16), + S_IFCHR | S_IRUSR | S_IWUSR, RAW1394_DEVICE_NAME); cdev_init(&raw1394_cdev, &raw1394_fops); raw1394_cdev.owner = THIS_MODULE; @@ -2936,22 +2943,20 @@ static int __init init_raw1394(void) goto out; - out_dev: +out_dev: devfs_remove(RAW1394_DEVICE_NAME); class_device_destroy(hpsb_protocol_class, - MKDEV(IEEE1394_MAJOR, - IEEE1394_MINOR_BLOCK_RAW1394 * 16)); - out_unreg: + MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16)); +out_unreg: hpsb_unregister_highlevel(&raw1394_highlevel); - out: +out: return ret; } static void __exit cleanup_raw1394(void) { class_device_destroy(hpsb_protocol_class, - MKDEV(IEEE1394_MAJOR, - IEEE1394_MINOR_BLOCK_RAW1394 * 16)); + MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16)); cdev_del(&raw1394_cdev); devfs_remove(RAW1394_DEVICE_NAME); hpsb_unregister_highlevel(&raw1394_highlevel); diff --git a/trunk/drivers/ieee1394/sbp2.c b/trunk/drivers/ieee1394/sbp2.c index 18d7eda38851..f7e18ccc5c0a 100644 --- a/trunk/drivers/ieee1394/sbp2.c +++ b/trunk/drivers/ieee1394/sbp2.c @@ -80,6 +80,9 @@ #include "ieee1394_transactions.h" #include "sbp2.h" +static char version[] __devinitdata = + "$Rev: 1306 $ Ben Collins "; + /* * Module load parameter definitions */ @@ -148,15 +151,18 @@ static int force_inquiry_hack; module_param(force_inquiry_hack, int, 0444); MODULE_PARM_DESC(force_inquiry_hack, "Force SCSI inquiry hack (default = 0)"); + /* * Export information about protocols/devices supported by this driver. */ static struct ieee1394_device_id sbp2_id_table[] = { { - .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION, - .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff, - .version = SBP2_SW_VERSION_ENTRY & 0xffffff}, - {} + .match_flags =IEEE1394_MATCH_SPECIFIER_ID | + IEEE1394_MATCH_VERSION, + .specifier_id = SBP2_UNIT_SPEC_ID_ENTRY & 0xffffff, + .version = SBP2_SW_VERSION_ENTRY & 0xffffff + }, + { } }; MODULE_DEVICE_TABLE(ieee1394, sbp2_id_table); @@ -215,6 +221,7 @@ static u32 global_outstanding_dmas = 0; #define SBP2_ERR(fmt, args...) HPSB_ERR("sbp2: "fmt, ## args) + /* * Globals */ @@ -247,8 +254,8 @@ static struct hpsb_address_ops sbp2_ops = { #ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA static struct hpsb_address_ops sbp2_physdma_ops = { - .read = sbp2_handle_physdma_read, - .write = sbp2_handle_physdma_write, + .read = sbp2_handle_physdma_read, + .write = sbp2_handle_physdma_write, }; #endif @@ -280,6 +287,7 @@ static u32 sbp2_broken_inquiry_list[] = { * General utility functions **************************************/ + #ifndef __BIG_ENDIAN /* * Converts a buffer from be32 to cpu byte ordering. Length is in bytes. @@ -316,8 +324,7 @@ static __inline__ void sbp2util_cpu_to_be32_buffer(void *buffer, int length) /* * Debug packet dump routine. Length is in bytes. */ -static void sbp2util_packet_dump(void *buffer, int length, char *dump_name, - u32 dump_phys_addr) +static void sbp2util_packet_dump(void *buffer, int length, char *dump_name, u32 dump_phys_addr) { int i; unsigned char *dump = buffer; @@ -338,7 +345,7 @@ static void sbp2util_packet_dump(void *buffer, int length, char *dump_name, printk(" "); if ((i & 0xf) == 0) printk("\n "); - printk("%02x ", (int)dump[i]); + printk("%02x ", (int) dump[i]); } printk("\n"); @@ -357,9 +364,9 @@ static int sbp2util_down_timeout(atomic_t *done, int timeout) for (i = timeout; (i > 0 && atomic_read(done) == 0); i-= HZ/10) { if (msleep_interruptible(100)) /* 100ms */ - return 1; + return(1); } - return (i > 0) ? 0 : 1; + return ((i > 0) ? 0:1); } /* Free's an allocated packet */ @@ -373,22 +380,21 @@ static void sbp2_free_packet(struct hpsb_packet *packet) * subaction and returns immediately. Can be used from interrupts. */ static int sbp2util_node_write_no_wait(struct node_entry *ne, u64 addr, - quadlet_t *buffer, size_t length) + quadlet_t *buffer, size_t length) { struct hpsb_packet *packet; packet = hpsb_make_writepacket(ne->host, ne->nodeid, addr, buffer, length); - if (!packet) - return -ENOMEM; + if (!packet) + return -ENOMEM; - hpsb_set_packet_complete_task(packet, - (void (*)(void *))sbp2_free_packet, + hpsb_set_packet_complete_task(packet, (void (*)(void*))sbp2_free_packet, packet); hpsb_node_fill_packet(ne, packet); - if (hpsb_send_packet(packet) < 0) { + if (hpsb_send_packet(packet) < 0) { sbp2_free_packet(packet); return -EIO; } @@ -411,22 +417,22 @@ static int sbp2util_create_command_orb_pool(struct scsi_id_instance_data *scsi_i spin_lock_irqsave(&scsi_id->sbp2_command_orb_lock, flags); for (i = 0; i < orbs; i++) { - command = kzalloc(sizeof(*command), GFP_ATOMIC); + command = (struct sbp2_command_info *) + kmalloc(sizeof(struct sbp2_command_info), GFP_ATOMIC); if (!command) { - spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, - flags); - return -ENOMEM; + spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags); + return(-ENOMEM); } + memset(command, '\0', sizeof(struct sbp2_command_info)); command->command_orb_dma = - pci_map_single(hi->host->pdev, &command->command_orb, - sizeof(struct sbp2_command_orb), - PCI_DMA_BIDIRECTIONAL); + pci_map_single (hi->host->pdev, &command->command_orb, + sizeof(struct sbp2_command_orb), + PCI_DMA_BIDIRECTIONAL); SBP2_DMA_ALLOC("single command orb DMA"); command->sge_dma = - pci_map_single(hi->host->pdev, - &command->scatter_gather_element, - sizeof(command->scatter_gather_element), - PCI_DMA_BIDIRECTIONAL); + pci_map_single (hi->host->pdev, &command->scatter_gather_element, + sizeof(command->scatter_gather_element), + PCI_DMA_BIDIRECTIONAL); SBP2_DMA_ALLOC("scatter_gather_element"); INIT_LIST_HEAD(&command->list); list_add_tail(&command->list, &scsi_id->sbp2_command_orb_completed); @@ -482,7 +488,7 @@ static struct sbp2_command_info *sbp2util_find_command_for_orb( list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) { if (command->command_orb_dma == orb) { spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags); - return command; + return (command); } } } @@ -490,7 +496,7 @@ static struct sbp2_command_info *sbp2util_find_command_for_orb( SBP2_ORB_DEBUG("could not match command orb %x", (unsigned int)orb); - return NULL; + return(NULL); } /* @@ -507,12 +513,12 @@ static struct sbp2_command_info *sbp2util_find_command_for_SCpnt(struct scsi_id_ list_for_each_entry(command, &scsi_id->sbp2_command_orb_inuse, list) { if (command->Current_SCpnt == SCpnt) { spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags); - return command; + return (command); } } } spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags); - return NULL; + return(NULL); } /* @@ -539,7 +545,7 @@ static struct sbp2_command_info *sbp2util_allocate_command_orb( SBP2_ERR("sbp2util_allocate_command_orb - No orbs available!"); } spin_unlock_irqrestore(&scsi_id->sbp2_command_orb_lock, flags); - return command; + return (command); } /* Free our DMA's */ @@ -581,8 +587,7 @@ static void sbp2util_free_command_dma(struct sbp2_command_info *command) /* * This function moves a command to the completed orb list. */ -static void sbp2util_mark_command_completed(struct scsi_id_instance_data *scsi_id, - struct sbp2_command_info *command) +static void sbp2util_mark_command_completed(struct scsi_id_instance_data *scsi_id, struct sbp2_command_info *command) { unsigned long flags; @@ -601,6 +606,8 @@ static inline int sbp2util_node_is_available(struct scsi_id_instance_data *scsi_ return scsi_id && scsi_id->ne && !scsi_id->ne->in_limbo; } + + /********************************************* * IEEE-1394 core driver stack related section *********************************************/ @@ -620,14 +627,14 @@ static int sbp2_probe(struct device *dev) if (ud->flags & UNIT_DIRECTORY_HAS_LUN_DIRECTORY) return -ENODEV; - scsi_id = sbp2_alloc_device(ud); + scsi_id = sbp2_alloc_device(ud); - if (!scsi_id) - return -ENOMEM; + if (!scsi_id) + return -ENOMEM; - sbp2_parse_unit_directory(scsi_id, ud); + sbp2_parse_unit_directory(scsi_id, ud); - return sbp2_start_device(scsi_id); + return sbp2_start_device(scsi_id); } static int sbp2_remove(struct device *dev) @@ -712,11 +719,12 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud SBP2_DEBUG("sbp2_alloc_device"); - scsi_id = kzalloc(sizeof(*scsi_id), GFP_KERNEL); + scsi_id = kmalloc(sizeof(*scsi_id), GFP_KERNEL); if (!scsi_id) { SBP2_ERR("failed to create scsi_id"); goto failed_alloc; } + memset(scsi_id, 0, sizeof(*scsi_id)); scsi_id->ne = ud->ne; scsi_id->ud = ud; @@ -727,7 +735,7 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud INIT_LIST_HEAD(&scsi_id->sbp2_command_orb_completed); INIT_LIST_HEAD(&scsi_id->scsi_list); spin_lock_init(&scsi_id->sbp2_command_orb_lock); - scsi_id->sbp2_lun = 0; + scsi_id->sbp2_device_type_and_lun = SBP2_DEVICE_TYPE_LUN_UNINITIALIZED; ud->device.driver_data = scsi_id; @@ -761,7 +769,7 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud /* Register our host with the SCSI stack. */ scsi_host = scsi_host_alloc(&scsi_driver_template, - sizeof(unsigned long)); + sizeof (unsigned long)); if (!scsi_host) { SBP2_ERR("failed to register scsi host"); goto failed_alloc; @@ -782,6 +790,7 @@ static struct scsi_id_instance_data *sbp2_alloc_device(struct unit_directory *ud return NULL; } + static void sbp2_host_reset(struct hpsb_host *host) { struct sbp2scsi_host_info *hi; @@ -795,6 +804,7 @@ static void sbp2_host_reset(struct hpsb_host *host) } } + /* * This function is where we first pull the node unique ids, and then * allocate memory and register a SBP-2 device. @@ -808,8 +818,7 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) /* Login FIFO DMA */ scsi_id->login_response = - pci_alloc_consistent(hi->host->pdev, - sizeof(struct sbp2_login_response), + pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_login_response), &scsi_id->login_response_dma); if (!scsi_id->login_response) goto alloc_fail; @@ -817,8 +826,7 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) /* Query logins ORB DMA */ scsi_id->query_logins_orb = - pci_alloc_consistent(hi->host->pdev, - sizeof(struct sbp2_query_logins_orb), + pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_query_logins_orb), &scsi_id->query_logins_orb_dma); if (!scsi_id->query_logins_orb) goto alloc_fail; @@ -826,8 +834,7 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) /* Query logins response DMA */ scsi_id->query_logins_response = - pci_alloc_consistent(hi->host->pdev, - sizeof(struct sbp2_query_logins_response), + pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_query_logins_response), &scsi_id->query_logins_response_dma); if (!scsi_id->query_logins_response) goto alloc_fail; @@ -835,8 +842,7 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) /* Reconnect ORB DMA */ scsi_id->reconnect_orb = - pci_alloc_consistent(hi->host->pdev, - sizeof(struct sbp2_reconnect_orb), + pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_reconnect_orb), &scsi_id->reconnect_orb_dma); if (!scsi_id->reconnect_orb) goto alloc_fail; @@ -844,8 +850,7 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) /* Logout ORB DMA */ scsi_id->logout_orb = - pci_alloc_consistent(hi->host->pdev, - sizeof(struct sbp2_logout_orb), + pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_logout_orb), &scsi_id->logout_orb_dma); if (!scsi_id->logout_orb) goto alloc_fail; @@ -853,11 +858,58 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) /* Login ORB DMA */ scsi_id->login_orb = - pci_alloc_consistent(hi->host->pdev, - sizeof(struct sbp2_login_orb), + pci_alloc_consistent(hi->host->pdev, sizeof(struct sbp2_login_orb), &scsi_id->login_orb_dma); - if (!scsi_id->login_orb) - goto alloc_fail; + if (!scsi_id->login_orb) { +alloc_fail: + if (scsi_id->query_logins_response) { + pci_free_consistent(hi->host->pdev, + sizeof(struct sbp2_query_logins_response), + scsi_id->query_logins_response, + scsi_id->query_logins_response_dma); + SBP2_DMA_FREE("query logins response DMA"); + } + + if (scsi_id->query_logins_orb) { + pci_free_consistent(hi->host->pdev, + sizeof(struct sbp2_query_logins_orb), + scsi_id->query_logins_orb, + scsi_id->query_logins_orb_dma); + SBP2_DMA_FREE("query logins ORB DMA"); + } + + if (scsi_id->logout_orb) { + pci_free_consistent(hi->host->pdev, + sizeof(struct sbp2_logout_orb), + scsi_id->logout_orb, + scsi_id->logout_orb_dma); + SBP2_DMA_FREE("logout ORB DMA"); + } + + if (scsi_id->reconnect_orb) { + pci_free_consistent(hi->host->pdev, + sizeof(struct sbp2_reconnect_orb), + scsi_id->reconnect_orb, + scsi_id->reconnect_orb_dma); + SBP2_DMA_FREE("reconnect ORB DMA"); + } + + if (scsi_id->login_response) { + pci_free_consistent(hi->host->pdev, + sizeof(struct sbp2_login_response), + scsi_id->login_response, + scsi_id->login_response_dma); + SBP2_DMA_FREE("login FIFO DMA"); + } + + list_del(&scsi_id->scsi_list); + + kfree(scsi_id); + + SBP2_ERR ("Could not allocate memory for scsi_id"); + + return -ENOMEM; + } SBP2_DMA_ALLOC("consistent DMA region for login ORB"); SBP2_DEBUG("New SBP-2 device inserted, SCSI ID = %x", scsi_id->ud->id); @@ -883,7 +935,7 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) sbp2_remove_device(scsi_id); return -EINTR; } - + /* * Login to the sbp-2 device */ @@ -912,17 +964,10 @@ static int sbp2_start_device(struct scsi_id_instance_data *scsi_id) error = scsi_add_device(scsi_id->scsi_host, 0, scsi_id->ud->id, 0); if (error) { SBP2_ERR("scsi_add_device failed"); - sbp2_logout_device(scsi_id); - sbp2_remove_device(scsi_id); return error; } return 0; - -alloc_fail: - SBP2_ERR("Could not allocate memory for scsi_id"); - sbp2_remove_device(scsi_id); - return -ENOMEM; } /* @@ -1009,43 +1054,50 @@ static void sbp2_remove_device(struct scsi_id_instance_data *scsi_id) * This function deals with physical dma write requests (for adapters that do not support * physical dma in hardware). Mostly just here for debugging... */ -static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid, - int destid, quadlet_t *data, u64 addr, - size_t length, u16 flags) +static int sbp2_handle_physdma_write(struct hpsb_host *host, int nodeid, int destid, quadlet_t *data, + u64 addr, size_t length, u16 flags) { - /* - * Manually put the data in the right place. - */ - memcpy(bus_to_virt((u32) addr), data, length); - sbp2util_packet_dump(data, length, "sbp2 phys dma write by device", - (u32) addr); - return RCODE_COMPLETE; + /* + * Manually put the data in the right place. + */ + memcpy(bus_to_virt((u32)addr), data, length); + sbp2util_packet_dump(data, length, "sbp2 phys dma write by device", (u32)addr); + return(RCODE_COMPLETE); } /* * This function deals with physical dma read requests (for adapters that do not support * physical dma in hardware). Mostly just here for debugging... */ -static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid, - quadlet_t *data, u64 addr, size_t length, - u16 flags) +static int sbp2_handle_physdma_read(struct hpsb_host *host, int nodeid, quadlet_t *data, + u64 addr, size_t length, u16 flags) { - /* - * Grab data from memory and send a read response. - */ - memcpy(data, bus_to_virt((u32) addr), length); - sbp2util_packet_dump(data, length, "sbp2 phys dma read by device", - (u32) addr); - return RCODE_COMPLETE; + /* + * Grab data from memory and send a read response. + */ + memcpy(data, bus_to_virt((u32)addr), length); + sbp2util_packet_dump(data, length, "sbp2 phys dma read by device", (u32)addr); + return(RCODE_COMPLETE); } #endif + /************************************** * SBP-2 protocol related section **************************************/ +/* + * This function determines if we should convert scsi commands for a particular sbp2 device type + */ +static __inline__ int sbp2_command_conversion_device_type(u8 device_type) +{ + return (((device_type == TYPE_DISK) || + (device_type == TYPE_RBC) || + (device_type == TYPE_ROM)) ? 1:0); +} + /* * This function queries the device for the maximum concurrent logins it * supports. @@ -1068,7 +1120,11 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id) scsi_id->query_logins_orb->lun_misc = ORB_SET_FUNCTION(SBP2_QUERY_LOGINS_REQUEST); scsi_id->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1); - scsi_id->query_logins_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_lun); + if (scsi_id->sbp2_device_type_and_lun != SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) { + scsi_id->query_logins_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun); + SBP2_DEBUG("sbp2_query_logins: set lun to %d", + ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun)); + } SBP2_DEBUG("sbp2_query_logins: lun_misc initialized"); scsi_id->query_logins_orb->reserved_resp_length = @@ -1105,12 +1161,12 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id) if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 2*HZ)) { SBP2_INFO("Error querying logins to SBP-2 device - timed out"); - return -EIO; + return(-EIO); } if (scsi_id->status_block.ORB_offset_lo != scsi_id->query_logins_orb_dma) { SBP2_INFO("Error querying logins to SBP-2 device - timed out"); - return -EIO; + return(-EIO); } if (STATUS_GET_RESP(scsi_id->status_block.ORB_offset_hi_misc) || @@ -1118,7 +1174,7 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id) STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) { SBP2_INFO("Error querying logins to SBP-2 device - timed out"); - return -EIO; + return(-EIO); } sbp2util_cpu_to_be32_buffer(scsi_id->query_logins_response, sizeof(struct sbp2_query_logins_response)); @@ -1135,7 +1191,7 @@ static int sbp2_query_logins(struct scsi_id_instance_data *scsi_id) SBP2_DEBUG("Number of active logins: %d", active_logins); if (active_logins >= max_logins) { - return -EIO; + return(-EIO); } return 0; @@ -1154,13 +1210,13 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id) if (!scsi_id->login_orb) { SBP2_DEBUG("sbp2_login_device: login_orb not alloc'd!"); - return -EIO; + return(-EIO); } if (!exclusive_login) { if (sbp2_query_logins(scsi_id)) { SBP2_INFO("Device does not support any more concurrent logins"); - return -EIO; + return(-EIO); } } @@ -1177,7 +1233,12 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id) scsi_id->login_orb->lun_misc |= ORB_SET_RECONNECT(0); /* One second reconnect time */ scsi_id->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(exclusive_login); /* Exclusive access to device */ scsi_id->login_orb->lun_misc |= ORB_SET_NOTIFY(1); /* Notify us of login complete */ - scsi_id->login_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_lun); + /* Set the lun if we were able to pull it from the device's unit directory */ + if (scsi_id->sbp2_device_type_and_lun != SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) { + scsi_id->login_orb->lun_misc |= ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun); + SBP2_DEBUG("sbp2_query_logins: set lun to %d", + ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun)); + } SBP2_DEBUG("sbp2_login_device: lun_misc initialized"); scsi_id->login_orb->passwd_resp_lengths = @@ -1227,7 +1288,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id) */ if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, 20*HZ)) { SBP2_ERR("Error logging into SBP-2 device - login timed-out"); - return -EIO; + return(-EIO); } /* @@ -1235,7 +1296,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id) */ if (scsi_id->status_block.ORB_offset_lo != scsi_id->login_orb_dma) { SBP2_ERR("Error logging into SBP-2 device - login timed-out"); - return -EIO; + return(-EIO); } /* @@ -1246,7 +1307,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id) STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) { SBP2_ERR("Error logging into SBP-2 device - login failed"); - return -EIO; + return(-EIO); } /* @@ -1270,7 +1331,7 @@ static int sbp2_login_device(struct scsi_id_instance_data *scsi_id) SBP2_INFO("Logged into SBP-2 device"); - return 0; + return(0); } @@ -1324,7 +1385,8 @@ static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id) atomic_set(&scsi_id->sbp2_login_complete, 0); error = hpsb_node_write(scsi_id->ne, - scsi_id->sbp2_management_agent_addr, data, 8); + scsi_id->sbp2_management_agent_addr, + data, 8); if (error) return error; @@ -1334,7 +1396,7 @@ static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id) SBP2_INFO("Logged out of SBP-2 device"); - return 0; + return(0); } @@ -1394,7 +1456,8 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id) atomic_set(&scsi_id->sbp2_login_complete, 0); error = hpsb_node_write(scsi_id->ne, - scsi_id->sbp2_management_agent_addr, data, 8); + scsi_id->sbp2_management_agent_addr, + data, 8); if (error) return error; @@ -1403,7 +1466,7 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id) */ if (sbp2util_down_timeout(&scsi_id->sbp2_login_complete, HZ)) { SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out"); - return -EIO; + return(-EIO); } /* @@ -1411,7 +1474,7 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id) */ if (scsi_id->status_block.ORB_offset_lo != scsi_id->reconnect_orb_dma) { SBP2_ERR("Error reconnecting to SBP-2 device - reconnect timed-out"); - return -EIO; + return(-EIO); } /* @@ -1422,12 +1485,12 @@ static int sbp2_reconnect_device(struct scsi_id_instance_data *scsi_id) STATUS_GET_SBP_STATUS(scsi_id->status_block.ORB_offset_hi_misc)) { SBP2_ERR("Error reconnecting to SBP-2 device - reconnect failed"); - return -EIO; + return(-EIO); } HPSB_DEBUG("Reconnected to SBP-2 device"); - return 0; + return(0); } @@ -1450,9 +1513,10 @@ static int sbp2_set_busy_timeout(struct scsi_id_instance_data *scsi_id) SBP2_ERR("sbp2_set_busy_timeout error"); } - return 0; + return(0); } + /* * This function is called to parse sbp2 device's config rom unit * directory. Used to determine things like sbp2 management agent offset, @@ -1465,7 +1529,7 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id, struct csr1212_dentry *dentry; u64 management_agent_addr; u32 command_set_spec_id, command_set, unit_characteristics, - firmware_revision, workarounds; + firmware_revision, workarounds; int i; SBP2_DEBUG("sbp2_parse_unit_directory"); @@ -1483,14 +1547,13 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id, if (kv->key.type == CSR1212_KV_TYPE_CSR_OFFSET) { /* Save off the management agent address */ management_agent_addr = - CSR1212_REGISTER_SPACE_BASE + - (kv->value.csr_offset << 2); + CSR1212_REGISTER_SPACE_BASE + + (kv->value.csr_offset << 2); SBP2_DEBUG("sbp2_management_agent_addr = %x", - (unsigned int)management_agent_addr); + (unsigned int) management_agent_addr); } else if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) { - scsi_id->sbp2_lun = - ORB_SET_LUN(kv->value.immediate); + scsi_id->sbp2_device_type_and_lun = kv->value.immediate; } break; @@ -1498,14 +1561,14 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id, /* Command spec organization */ command_set_spec_id = kv->value.immediate; SBP2_DEBUG("sbp2_command_set_spec_id = %x", - (unsigned int)command_set_spec_id); + (unsigned int) command_set_spec_id); break; case SBP2_COMMAND_SET_KEY: /* Command set used by sbp2 device */ command_set = kv->value.immediate; SBP2_DEBUG("sbp2_command_set = %x", - (unsigned int)command_set); + (unsigned int) command_set); break; case SBP2_UNIT_CHARACTERISTICS_KEY: @@ -1515,7 +1578,7 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id, */ unit_characteristics = kv->value.immediate; SBP2_DEBUG("sbp2_unit_characteristics = %x", - (unsigned int)unit_characteristics); + (unsigned int) unit_characteristics); break; case SBP2_FIRMWARE_REVISION_KEY: @@ -1523,10 +1586,9 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id, firmware_revision = kv->value.immediate; if (force_inquiry_hack) SBP2_INFO("sbp2_firmware_revision = %x", - (unsigned int)firmware_revision); - else - SBP2_DEBUG("sbp2_firmware_revision = %x", - (unsigned int)firmware_revision); + (unsigned int) firmware_revision); + else SBP2_DEBUG("sbp2_firmware_revision = %x", + (unsigned int) firmware_revision); break; default: @@ -1584,7 +1646,7 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id, scsi_id->sbp2_firmware_revision = firmware_revision; scsi_id->workarounds = workarounds; if (ud->flags & UNIT_DIRECTORY_HAS_LUN) - scsi_id->sbp2_lun = ORB_SET_LUN(ud->lun); + scsi_id->sbp2_device_type_and_lun = ud->lun; } } @@ -1604,9 +1666,8 @@ static int sbp2_max_speed_and_size(struct scsi_id_instance_data *scsi_id) SBP2_DEBUG("sbp2_max_speed_and_size"); /* Initial setting comes from the hosts speed map */ - scsi_id->speed_code = - hi->host->speed_map[NODEID_TO_NODE(hi->host->node_id) * 64 + - NODEID_TO_NODE(scsi_id->ne->nodeid)]; + scsi_id->speed_code = hi->host->speed_map[NODEID_TO_NODE(hi->host->node_id) * 64 + + NODEID_TO_NODE(scsi_id->ne->nodeid)]; /* Bump down our speed if the user requested it */ if (scsi_id->speed_code > max_speed) { @@ -1617,16 +1678,15 @@ static int sbp2_max_speed_and_size(struct scsi_id_instance_data *scsi_id) /* Payload size is the lesser of what our speed supports and what * our host supports. */ - scsi_id->max_payload_size = - min(sbp2_speedto_max_payload[scsi_id->speed_code], - (u8) (hi->host->csr.max_rec - 1)); + scsi_id->max_payload_size = min(sbp2_speedto_max_payload[scsi_id->speed_code], + (u8)(hi->host->csr.max_rec - 1)); HPSB_DEBUG("Node " NODE_BUS_FMT ": Max speed [%s] - Max payload [%u]", NODE_BUS_ARGS(hi->host, scsi_id->ne->nodeid), hpsb_speedto_str[scsi_id->speed_code], - 1 << ((u32) scsi_id->max_payload_size + 2)); + 1 << ((u32)scsi_id->max_payload_size + 2)); - return 0; + return(0); } /* @@ -1661,187 +1721,30 @@ static int sbp2_agent_reset(struct scsi_id_instance_data *scsi_id, int wait) */ scsi_id->last_orb = NULL; - return 0; -} - -static void sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb, - struct sbp2scsi_host_info *hi, - struct sbp2_command_info *command, - unsigned int scsi_use_sg, - struct scatterlist *sgpnt, - u32 orb_direction, - enum dma_data_direction dma_dir) -{ - command->dma_dir = dma_dir; - orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id); - orb->misc |= ORB_SET_DIRECTION(orb_direction); - - /* Special case if only one element (and less than 64KB in size) */ - if ((scsi_use_sg == 1) && - (sgpnt[0].length <= SBP2_MAX_SG_ELEMENT_LENGTH)) { - - SBP2_DEBUG("Only one s/g element"); - command->dma_size = sgpnt[0].length; - command->dma_type = CMD_DMA_PAGE; - command->cmd_dma = pci_map_page(hi->host->pdev, - sgpnt[0].page, - sgpnt[0].offset, - command->dma_size, - command->dma_dir); - SBP2_DMA_ALLOC("single page scatter element"); - - orb->data_descriptor_lo = command->cmd_dma; - orb->misc |= ORB_SET_DATA_SIZE(command->dma_size); - - } else { - struct sbp2_unrestricted_page_table *sg_element = - &command->scatter_gather_element[0]; - u32 sg_count, sg_len; - dma_addr_t sg_addr; - int i, count = pci_map_sg(hi->host->pdev, sgpnt, scsi_use_sg, - dma_dir); - - SBP2_DMA_ALLOC("scatter list"); - - command->dma_size = scsi_use_sg; - command->sge_buffer = sgpnt; - - /* use page tables (s/g) */ - orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1); - orb->data_descriptor_lo = command->sge_dma; - - /* - * Loop through and fill out our sbp-2 page tables - * (and split up anything too large) - */ - for (i = 0, sg_count = 0 ; i < count; i++, sgpnt++) { - sg_len = sg_dma_len(sgpnt); - sg_addr = sg_dma_address(sgpnt); - while (sg_len) { - sg_element[sg_count].segment_base_lo = sg_addr; - if (sg_len > SBP2_MAX_SG_ELEMENT_LENGTH) { - sg_element[sg_count].length_segment_base_hi = - PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH); - sg_addr += SBP2_MAX_SG_ELEMENT_LENGTH; - sg_len -= SBP2_MAX_SG_ELEMENT_LENGTH; - } else { - sg_element[sg_count].length_segment_base_hi = - PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len); - sg_len = 0; - } - sg_count++; - } - } - - /* Number of page table (s/g) elements */ - orb->misc |= ORB_SET_DATA_SIZE(sg_count); - - sbp2util_packet_dump(sg_element, - (sizeof(struct sbp2_unrestricted_page_table)) * sg_count, - "sbp2 s/g list", command->sge_dma); - - /* Byte swap page tables if necessary */ - sbp2util_cpu_to_be32_buffer(sg_element, - (sizeof(struct sbp2_unrestricted_page_table)) * - sg_count); - } -} - -static void sbp2_prep_command_orb_no_sg(struct sbp2_command_orb *orb, - struct sbp2scsi_host_info *hi, - struct sbp2_command_info *command, - struct scatterlist *sgpnt, - u32 orb_direction, - unsigned int scsi_request_bufflen, - void *scsi_request_buffer, - enum dma_data_direction dma_dir) -{ - command->dma_dir = dma_dir; - command->dma_size = scsi_request_bufflen; - command->dma_type = CMD_DMA_SINGLE; - command->cmd_dma = pci_map_single(hi->host->pdev, scsi_request_buffer, - command->dma_size, command->dma_dir); - orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id); - orb->misc |= ORB_SET_DIRECTION(orb_direction); - - SBP2_DMA_ALLOC("single bulk"); - - /* - * Handle case where we get a command w/o s/g enabled (but - * check for transfers larger than 64K) - */ - if (scsi_request_bufflen <= SBP2_MAX_SG_ELEMENT_LENGTH) { - - orb->data_descriptor_lo = command->cmd_dma; - orb->misc |= ORB_SET_DATA_SIZE(scsi_request_bufflen); - - } else { - struct sbp2_unrestricted_page_table *sg_element = - &command->scatter_gather_element[0]; - u32 sg_count, sg_len; - dma_addr_t sg_addr; - - /* - * Need to turn this into page tables, since the - * buffer is too large. - */ - orb->data_descriptor_lo = command->sge_dma; - - /* Use page tables (s/g) */ - orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1); - - /* - * fill out our sbp-2 page tables (and split up - * the large buffer) - */ - sg_count = 0; - sg_len = scsi_request_bufflen; - sg_addr = command->cmd_dma; - while (sg_len) { - sg_element[sg_count].segment_base_lo = sg_addr; - if (sg_len > SBP2_MAX_SG_ELEMENT_LENGTH) { - sg_element[sg_count].length_segment_base_hi = - PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH); - sg_addr += SBP2_MAX_SG_ELEMENT_LENGTH; - sg_len -= SBP2_MAX_SG_ELEMENT_LENGTH; - } else { - sg_element[sg_count].length_segment_base_hi = - PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len); - sg_len = 0; - } - sg_count++; - } - - /* Number of page table (s/g) elements */ - orb->misc |= ORB_SET_DATA_SIZE(sg_count); - - sbp2util_packet_dump(sg_element, - (sizeof(struct sbp2_unrestricted_page_table)) * sg_count, - "sbp2 s/g list", command->sge_dma); - - /* Byte swap page tables if necessary */ - sbp2util_cpu_to_be32_buffer(sg_element, - (sizeof(struct sbp2_unrestricted_page_table)) * - sg_count); - } + return(0); } /* * This function is called to create the actual command orb and s/g list * out of the scsi command itself. */ -static void sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id, - struct sbp2_command_info *command, - unchar *scsi_cmd, - unsigned int scsi_use_sg, - unsigned int scsi_request_bufflen, - void *scsi_request_buffer, - enum dma_data_direction dma_dir) +static int sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id, + struct sbp2_command_info *command, + unchar *scsi_cmd, + unsigned int scsi_use_sg, + unsigned int scsi_request_bufflen, + void *scsi_request_buffer, + enum dma_data_direction dma_dir) + { struct sbp2scsi_host_info *hi = scsi_id->hi; - struct scatterlist *sgpnt = (struct scatterlist *)scsi_request_buffer; + struct scatterlist *sgpnt = (struct scatterlist *) scsi_request_buffer; struct sbp2_command_orb *command_orb = &command->command_orb; - u32 orb_direction; + struct sbp2_unrestricted_page_table *scatter_gather_element = + &command->scatter_gather_element[0]; + u32 sg_count, sg_len, orb_direction; + dma_addr_t sg_addr; + int i; /* * Set-up our command ORB.. @@ -1855,42 +1758,222 @@ static void sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id, command_orb->next_ORB_lo = 0x0; command_orb->misc = ORB_SET_MAX_PAYLOAD(scsi_id->max_payload_size); command_orb->misc |= ORB_SET_SPEED(scsi_id->speed_code); - command_orb->misc |= ORB_SET_NOTIFY(1); /* Notify us when complete */ + command_orb->misc |= ORB_SET_NOTIFY(1); /* Notify us when complete */ - if (dma_dir == DMA_NONE) - orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER; - else if (dma_dir == DMA_TO_DEVICE && scsi_request_bufflen) - orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA; - else if (dma_dir == DMA_FROM_DEVICE && scsi_request_bufflen) - orb_direction = ORB_DIRECTION_READ_FROM_MEDIA; - else { - SBP2_WARN("Falling back to DMA_NONE"); - orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER; + /* + * Get the direction of the transfer. If the direction is unknown, then use our + * goofy table as a back-up. + */ + switch (dma_dir) { + case DMA_NONE: + orb_direction = ORB_DIRECTION_NO_DATA_TRANSFER; + break; + case DMA_TO_DEVICE: + orb_direction = ORB_DIRECTION_WRITE_TO_MEDIA; + break; + case DMA_FROM_DEVICE: + orb_direction = ORB_DIRECTION_READ_FROM_MEDIA; + break; + case DMA_BIDIRECTIONAL: + default: + SBP2_ERR("SCSI data transfer direction not specified. " + "Update the SBP2 direction table in sbp2.h if " + "necessary for your application"); + __scsi_print_command(scsi_cmd); + orb_direction = sbp2scsi_direction_table[*scsi_cmd]; + break; } - /* Set-up our pagetable stuff */ + /* + * Set-up our pagetable stuff... unfortunately, this has become + * messier than I'd like. Need to clean this up a bit. ;-) + */ if (orb_direction == ORB_DIRECTION_NO_DATA_TRANSFER) { + SBP2_DEBUG("No data transfer"); + + /* + * Handle no data transfer + */ command_orb->data_descriptor_hi = 0x0; command_orb->data_descriptor_lo = 0x0; command_orb->misc |= ORB_SET_DIRECTION(1); + } else if (scsi_use_sg) { + SBP2_DEBUG("Use scatter/gather"); - sbp2_prep_command_orb_sg(command_orb, hi, command, scsi_use_sg, - sgpnt, orb_direction, dma_dir); + + /* + * Special case if only one element (and less than 64KB in size) + */ + if ((scsi_use_sg == 1) && (sgpnt[0].length <= SBP2_MAX_SG_ELEMENT_LENGTH)) { + + SBP2_DEBUG("Only one s/g element"); + command->dma_dir = dma_dir; + command->dma_size = sgpnt[0].length; + command->dma_type = CMD_DMA_PAGE; + command->cmd_dma = pci_map_page(hi->host->pdev, + sgpnt[0].page, + sgpnt[0].offset, + command->dma_size, + command->dma_dir); + SBP2_DMA_ALLOC("single page scatter element"); + + command_orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id); + command_orb->data_descriptor_lo = command->cmd_dma; + command_orb->misc |= ORB_SET_DATA_SIZE(command->dma_size); + command_orb->misc |= ORB_SET_DIRECTION(orb_direction); + + } else { + int count = pci_map_sg(hi->host->pdev, sgpnt, scsi_use_sg, dma_dir); + SBP2_DMA_ALLOC("scatter list"); + + command->dma_size = scsi_use_sg; + command->dma_dir = dma_dir; + command->sge_buffer = sgpnt; + + /* use page tables (s/g) */ + command_orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1); + command_orb->misc |= ORB_SET_DIRECTION(orb_direction); + command_orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id); + command_orb->data_descriptor_lo = command->sge_dma; + + /* + * Loop through and fill out our sbp-2 page tables + * (and split up anything too large) + */ + for (i = 0, sg_count = 0 ; i < count; i++, sgpnt++) { + sg_len = sg_dma_len(sgpnt); + sg_addr = sg_dma_address(sgpnt); + while (sg_len) { + scatter_gather_element[sg_count].segment_base_lo = sg_addr; + if (sg_len > SBP2_MAX_SG_ELEMENT_LENGTH) { + scatter_gather_element[sg_count].length_segment_base_hi = + PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH); + sg_addr += SBP2_MAX_SG_ELEMENT_LENGTH; + sg_len -= SBP2_MAX_SG_ELEMENT_LENGTH; + } else { + scatter_gather_element[sg_count].length_segment_base_hi = + PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len); + sg_len = 0; + } + sg_count++; + } + } + + /* Number of page table (s/g) elements */ + command_orb->misc |= ORB_SET_DATA_SIZE(sg_count); + + sbp2util_packet_dump(scatter_gather_element, + (sizeof(struct sbp2_unrestricted_page_table)) * sg_count, + "sbp2 s/g list", command->sge_dma); + + /* + * Byte swap page tables if necessary + */ + sbp2util_cpu_to_be32_buffer(scatter_gather_element, + (sizeof(struct sbp2_unrestricted_page_table)) * + sg_count); + + } + } else { + SBP2_DEBUG("No scatter/gather"); - sbp2_prep_command_orb_no_sg(command_orb, hi, command, sgpnt, - orb_direction, scsi_request_bufflen, - scsi_request_buffer, dma_dir); + + command->dma_dir = dma_dir; + command->dma_size = scsi_request_bufflen; + command->dma_type = CMD_DMA_SINGLE; + command->cmd_dma = pci_map_single (hi->host->pdev, scsi_request_buffer, + command->dma_size, + command->dma_dir); + SBP2_DMA_ALLOC("single bulk"); + + /* + * Handle case where we get a command w/o s/g enabled (but + * check for transfers larger than 64K) + */ + if (scsi_request_bufflen <= SBP2_MAX_SG_ELEMENT_LENGTH) { + + command_orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id); + command_orb->data_descriptor_lo = command->cmd_dma; + command_orb->misc |= ORB_SET_DATA_SIZE(scsi_request_bufflen); + command_orb->misc |= ORB_SET_DIRECTION(orb_direction); + + /* + * Sanity, in case our direction table is not + * up-to-date + */ + if (!scsi_request_bufflen) { + command_orb->data_descriptor_hi = 0x0; + command_orb->data_descriptor_lo = 0x0; + command_orb->misc |= ORB_SET_DIRECTION(1); + } + + } else { + /* + * Need to turn this into page tables, since the + * buffer is too large. + */ + command_orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id); + command_orb->data_descriptor_lo = command->sge_dma; + + /* Use page tables (s/g) */ + command_orb->misc |= ORB_SET_PAGE_TABLE_PRESENT(0x1); + command_orb->misc |= ORB_SET_DIRECTION(orb_direction); + + /* + * fill out our sbp-2 page tables (and split up + * the large buffer) + */ + sg_count = 0; + sg_len = scsi_request_bufflen; + sg_addr = command->cmd_dma; + while (sg_len) { + scatter_gather_element[sg_count].segment_base_lo = sg_addr; + if (sg_len > SBP2_MAX_SG_ELEMENT_LENGTH) { + scatter_gather_element[sg_count].length_segment_base_hi = + PAGE_TABLE_SET_SEGMENT_LENGTH(SBP2_MAX_SG_ELEMENT_LENGTH); + sg_addr += SBP2_MAX_SG_ELEMENT_LENGTH; + sg_len -= SBP2_MAX_SG_ELEMENT_LENGTH; + } else { + scatter_gather_element[sg_count].length_segment_base_hi = + PAGE_TABLE_SET_SEGMENT_LENGTH(sg_len); + sg_len = 0; + } + sg_count++; + } + + /* Number of page table (s/g) elements */ + command_orb->misc |= ORB_SET_DATA_SIZE(sg_count); + + sbp2util_packet_dump(scatter_gather_element, + (sizeof(struct sbp2_unrestricted_page_table)) * sg_count, + "sbp2 s/g list", command->sge_dma); + + /* + * Byte swap page tables if necessary + */ + sbp2util_cpu_to_be32_buffer(scatter_gather_element, + (sizeof(struct sbp2_unrestricted_page_table)) * + sg_count); + + } + } - /* Byte swap command ORB if necessary */ + /* + * Byte swap command ORB if necessary + */ sbp2util_cpu_to_be32_buffer(command_orb, sizeof(struct sbp2_command_orb)); - /* Put our scsi command in the command ORB */ + /* + * Put our scsi command in the command ORB + */ memset(command_orb->cdb, 0, 12); memcpy(command_orb->cdb, scsi_cmd, COMMAND_SIZE(*scsi_cmd)); + + return(0); } /* @@ -1906,7 +1989,7 @@ static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id, outstanding_orb_incr; SBP2_ORB_DEBUG("sending command orb %p, total orbs = %x", - command_orb, global_outstanding_command_orbs); + command_orb, global_outstanding_command_orbs); pci_dma_sync_single_for_device(hi->host->pdev, command->command_orb_dma, sizeof(struct sbp2_command_orb), @@ -1951,11 +2034,10 @@ static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id, * both by the sbp2 device and us. */ scsi_id->last_orb->next_ORB_lo = - cpu_to_be32(command->command_orb_dma); + cpu_to_be32(command->command_orb_dma); /* Tells hardware that this pointer is valid */ scsi_id->last_orb->next_ORB_hi = 0x0; - pci_dma_sync_single_for_device(hi->host->pdev, - scsi_id->last_orb_dma, + pci_dma_sync_single_for_device(hi->host->pdev, scsi_id->last_orb_dma, sizeof(struct sbp2_command_orb), PCI_DMA_BIDIRECTIONAL); @@ -1969,14 +2051,14 @@ static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id, if (sbp2util_node_write_no_wait(ne, addr, &data, 4) < 0) { SBP2_ERR("sbp2util_node_write_no_wait failed"); - return -EIO; + return(-EIO); } scsi_id->last_orb = command_orb; scsi_id->last_orb_dma = command->command_orb_dma; } - return 0; + return(0); } /* @@ -2003,7 +2085,7 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id, */ command = sbp2util_allocate_command_orb(scsi_id, SCpnt, done); if (!command) { - return -EIO; + return(-EIO); } /* @@ -2024,6 +2106,11 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id, sbp2_create_command_orb(scsi_id, command, cmd, SCpnt->use_sg, request_bufflen, SCpnt->request_buffer, SCpnt->sc_data_direction); + /* + * Update our cdb if necessary (to handle sbp2 RBC command set + * differences). This is where the command set hacks go! =) + */ + sbp2_check_sbp2_command(scsi_id, command->command_orb.cdb); sbp2util_packet_dump(&command->command_orb, sizeof(struct sbp2_command_orb), "sbp2 command orb", command->command_orb_dma); @@ -2038,7 +2125,112 @@ static int sbp2_send_command(struct scsi_id_instance_data *scsi_id, */ sbp2_link_orb_command(scsi_id, command); - return 0; + return(0); +} + + +/* + * This function deals with command set differences between Linux scsi + * command set and sbp2 RBC command set. + */ +static void sbp2_check_sbp2_command(struct scsi_id_instance_data *scsi_id, unchar *cmd) +{ + unchar new_cmd[16]; + u8 device_type = SBP2_DEVICE_TYPE (scsi_id->sbp2_device_type_and_lun); + + SBP2_DEBUG("sbp2_check_sbp2_command"); + + switch (*cmd) { + + case READ_6: + + if (sbp2_command_conversion_device_type(device_type)) { + + SBP2_DEBUG("Convert READ_6 to READ_10"); + + /* + * Need to turn read_6 into read_10 + */ + new_cmd[0] = 0x28; + new_cmd[1] = (cmd[1] & 0xe0); + new_cmd[2] = 0x0; + new_cmd[3] = (cmd[1] & 0x1f); + new_cmd[4] = cmd[2]; + new_cmd[5] = cmd[3]; + new_cmd[6] = 0x0; + new_cmd[7] = 0x0; + new_cmd[8] = cmd[4]; + new_cmd[9] = cmd[5]; + + memcpy(cmd, new_cmd, 10); + + } + + break; + + case WRITE_6: + + if (sbp2_command_conversion_device_type(device_type)) { + + SBP2_DEBUG("Convert WRITE_6 to WRITE_10"); + + /* + * Need to turn write_6 into write_10 + */ + new_cmd[0] = 0x2a; + new_cmd[1] = (cmd[1] & 0xe0); + new_cmd[2] = 0x0; + new_cmd[3] = (cmd[1] & 0x1f); + new_cmd[4] = cmd[2]; + new_cmd[5] = cmd[3]; + new_cmd[6] = 0x0; + new_cmd[7] = 0x0; + new_cmd[8] = cmd[4]; + new_cmd[9] = cmd[5]; + + memcpy(cmd, new_cmd, 10); + + } + + break; + + case MODE_SENSE: + + if (sbp2_command_conversion_device_type(device_type)) { + + SBP2_DEBUG("Convert MODE_SENSE_6 to MODE_SENSE_10"); + + /* + * Need to turn mode_sense_6 into mode_sense_10 + */ + new_cmd[0] = 0x5a; + new_cmd[1] = cmd[1]; + new_cmd[2] = cmd[2]; + new_cmd[3] = 0x0; + new_cmd[4] = 0x0; + new_cmd[5] = 0x0; + new_cmd[6] = 0x0; + new_cmd[7] = 0x0; + new_cmd[8] = cmd[4]; + new_cmd[9] = cmd[5]; + + memcpy(cmd, new_cmd, 10); + + } + + break; + + case MODE_SELECT: + + /* + * TODO. Probably need to change mode select to 10 byte version + */ + + default: + break; + } + + return; } /* @@ -2068,40 +2260,80 @@ static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status, unchar *sense sense_data[14] = sbp2_status[20]; sense_data[15] = sbp2_status[21]; - return sbp2_status[8] & 0x3f; /* return scsi status */ + return(sbp2_status[8] & 0x3f); /* return scsi status */ } /* * This function is called after a command is completed, in order to do any necessary SBP-2 * response data translations for the SCSI stack */ -static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id, +static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id, struct scsi_cmnd *SCpnt) { u8 *scsi_buf = SCpnt->request_buffer; + u8 device_type = SBP2_DEVICE_TYPE (scsi_id->sbp2_device_type_and_lun); SBP2_DEBUG("sbp2_check_sbp2_response"); switch (SCpnt->cmnd[0]) { - case INQUIRY: - /* - * Make sure data length is ok. Minimum length is 36 bytes - */ - if (scsi_buf[4] == 0) { - scsi_buf[4] = 36 - 5; - } + case INQUIRY: - /* - * Fix ansi revision and response data format - */ - scsi_buf[2] |= 2; - scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2; + /* + * If scsi_id->sbp2_device_type_and_lun is uninitialized, then fill + * this information in from the inquiry response data. Lun is set to zero. + */ + if (scsi_id->sbp2_device_type_and_lun == SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) { + SBP2_DEBUG("Creating sbp2_device_type_and_lun from scsi inquiry data"); + scsi_id->sbp2_device_type_and_lun = (scsi_buf[0] & 0x1f) << 16; + } + + /* + * Make sure data length is ok. Minimum length is 36 bytes + */ + if (scsi_buf[4] == 0) { + scsi_buf[4] = 36 - 5; + } + + /* + * Check for Simple Direct Access Device and change it to TYPE_DISK + */ + if ((scsi_buf[0] & 0x1f) == TYPE_RBC) { + SBP2_DEBUG("Changing TYPE_RBC to TYPE_DISK"); + scsi_buf[0] &= 0xe0; + } + + /* + * Fix ansi revision and response data format + */ + scsi_buf[2] |= 2; + scsi_buf[3] = (scsi_buf[3] & 0xf0) | 2; + + break; + + case MODE_SENSE: + + if (sbp2_command_conversion_device_type(device_type)) { + + SBP2_DEBUG("Modify mode sense response (10 byte version)"); + + scsi_buf[0] = scsi_buf[1]; /* Mode data length */ + scsi_buf[1] = scsi_buf[2]; /* Medium type */ + scsi_buf[2] = scsi_buf[3]; /* Device specific parameter */ + scsi_buf[3] = scsi_buf[7]; /* Block descriptor length */ + memcpy(scsi_buf + 4, scsi_buf + 8, scsi_buf[0]); + } + + break; - break; + case MODE_SELECT: - default: - break; + /* + * TODO. Probably need to change mode select to 10 byte version + */ + + default: + break; } return; } @@ -2126,14 +2358,14 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest if (!host) { SBP2_ERR("host is NULL - this is bad!"); - return RCODE_ADDRESS_ERROR; + return(RCODE_ADDRESS_ERROR); } hi = hpsb_get_hostinfo(&sbp2_highlevel, host); if (!hi) { SBP2_ERR("host info is NULL - this is bad!"); - return RCODE_ADDRESS_ERROR; + return(RCODE_ADDRESS_ERROR); } /* @@ -2150,7 +2382,7 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest if (!scsi_id) { SBP2_ERR("scsi_id is NULL - device is gone?"); - return RCODE_ADDRESS_ERROR; + return(RCODE_ADDRESS_ERROR); } /* @@ -2248,9 +2480,10 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int dest SBP2_ORB_DEBUG("command orb completed"); } - return RCODE_COMPLETE; + return(RCODE_COMPLETE); } + /************************************** * SCSI interface related section **************************************/ @@ -2307,16 +2540,6 @@ static int sbp2scsi_queuecommand(struct scsi_cmnd *SCpnt, goto done; } - /* - * Bidirectional commands are not yet implemented, - * and unknown transfer direction not handled. - */ - if (SCpnt->sc_data_direction == DMA_BIDIRECTIONAL) { - SBP2_ERR("Cannot handle DMA_BIDIRECTIONAL - rejecting command"); - result = DID_ERROR << 16; - goto done; - } - /* * Try and send our SCSI command */ @@ -2393,56 +2616,55 @@ static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id, * complete the command, just let it get retried at the end of the * bus reset. */ - if (!hpsb_node_entry_valid(scsi_id->ne) - && (scsi_status != SBP2_SCSI_STATUS_GOOD)) { + if (!hpsb_node_entry_valid(scsi_id->ne) && (scsi_status != SBP2_SCSI_STATUS_GOOD)) { SBP2_ERR("Bus reset in progress - retry command later"); return; } - + /* * Switch on scsi status */ switch (scsi_status) { - case SBP2_SCSI_STATUS_GOOD: - SCpnt->result = DID_OK; - break; + case SBP2_SCSI_STATUS_GOOD: + SCpnt->result = DID_OK; + break; - case SBP2_SCSI_STATUS_BUSY: - SBP2_ERR("SBP2_SCSI_STATUS_BUSY"); - SCpnt->result = DID_BUS_BUSY << 16; - break; + case SBP2_SCSI_STATUS_BUSY: + SBP2_ERR("SBP2_SCSI_STATUS_BUSY"); + SCpnt->result = DID_BUS_BUSY << 16; + break; - case SBP2_SCSI_STATUS_CHECK_CONDITION: - SBP2_DEBUG("SBP2_SCSI_STATUS_CHECK_CONDITION"); - SCpnt->result = CHECK_CONDITION << 1; + case SBP2_SCSI_STATUS_CHECK_CONDITION: + SBP2_DEBUG("SBP2_SCSI_STATUS_CHECK_CONDITION"); + SCpnt->result = CHECK_CONDITION << 1; - /* - * Debug stuff - */ + /* + * Debug stuff + */ #if CONFIG_IEEE1394_SBP2_DEBUG >= 1 - scsi_print_command(SCpnt); - scsi_print_sense("bh", SCpnt); + scsi_print_command(SCpnt); + scsi_print_sense("bh", SCpnt); #endif - break; + break; - case SBP2_SCSI_STATUS_SELECTION_TIMEOUT: - SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT"); - SCpnt->result = DID_NO_CONNECT << 16; - scsi_print_command(SCpnt); - break; + case SBP2_SCSI_STATUS_SELECTION_TIMEOUT: + SBP2_ERR("SBP2_SCSI_STATUS_SELECTION_TIMEOUT"); + SCpnt->result = DID_NO_CONNECT << 16; + scsi_print_command(SCpnt); + break; - case SBP2_SCSI_STATUS_CONDITION_MET: - case SBP2_SCSI_STATUS_RESERVATION_CONFLICT: - case SBP2_SCSI_STATUS_COMMAND_TERMINATED: - SBP2_ERR("Bad SCSI status = %x", scsi_status); - SCpnt->result = DID_ERROR << 16; - scsi_print_command(SCpnt); - break; + case SBP2_SCSI_STATUS_CONDITION_MET: + case SBP2_SCSI_STATUS_RESERVATION_CONFLICT: + case SBP2_SCSI_STATUS_COMMAND_TERMINATED: + SBP2_ERR("Bad SCSI status = %x", scsi_status); + SCpnt->result = DID_ERROR << 16; + scsi_print_command(SCpnt); + break; - default: - SBP2_ERR("Unsupported SCSI status = %x", scsi_status); - SCpnt->result = DID_ERROR << 16; + default: + SBP2_ERR("Unsupported SCSI status = %x", scsi_status); + SCpnt->result = DID_ERROR << 16; } /* @@ -2456,8 +2678,7 @@ static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id, * If a bus reset is in progress and there was an error, complete * the command as busy so that it will get retried. */ - if (!hpsb_node_entry_valid(scsi_id->ne) - && (scsi_status != SBP2_SCSI_STATUS_GOOD)) { + if (!hpsb_node_entry_valid(scsi_id->ne) && (scsi_status != SBP2_SCSI_STATUS_GOOD)) { SBP2_ERR("Completing command with busy (bus reset)"); SCpnt->result = DID_BUS_BUSY << 16; } @@ -2478,29 +2699,31 @@ static void sbp2scsi_complete_command(struct scsi_id_instance_data *scsi_id, /* * Tell scsi stack that we're done with this command */ - done(SCpnt); + done (SCpnt); } + static int sbp2scsi_slave_alloc(struct scsi_device *sdev) { ((struct scsi_id_instance_data *)sdev->host->hostdata[0])->sdev = sdev; return 0; } + static int sbp2scsi_slave_configure(struct scsi_device *sdev) { blk_queue_dma_alignment(sdev->request_queue, (512 - 1)); - sdev->use_10_for_rw = 1; - sdev->use_10_for_ms = 1; return 0; } + static void sbp2scsi_slave_destroy(struct scsi_device *sdev) { ((struct scsi_id_instance_data *)sdev->host->hostdata[0])->sdev = NULL; return; } + /* * Called by scsi stack when something has really gone wrong. Usually * called when a command has timed-out for some reason. @@ -2546,7 +2769,7 @@ static int sbp2scsi_abort(struct scsi_cmnd *SCpnt) sbp2scsi_complete_all_commands(scsi_id, DID_BUS_BUSY); } - return SUCCESS; + return(SUCCESS); } /* @@ -2556,20 +2779,28 @@ static int sbp2scsi_reset(struct scsi_cmnd *SCpnt) { struct scsi_id_instance_data *scsi_id = (struct scsi_id_instance_data *)SCpnt->device->host->hostdata[0]; + unsigned long flags; SBP2_ERR("reset requested"); + spin_lock_irqsave(SCpnt->device->host->host_lock, flags); + if (sbp2util_node_is_available(scsi_id)) { SBP2_ERR("Generating sbp2 fetch agent reset"); sbp2_agent_reset(scsi_id, 0); } + spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags); + return SUCCESS; } -static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev, - struct device_attribute *attr, - char *buf) +static const char *sbp2scsi_info (struct Scsi_Host *host) +{ + return "SCSI emulation for IEEE-1394 SBP-2 Devices"; +} + +static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev, struct device_attribute *attr, char *buf) { struct scsi_device *sdev; struct scsi_id_instance_data *scsi_id; @@ -2581,7 +2812,10 @@ static ssize_t sbp2_sysfs_ieee1394_id_show(struct device *dev, if (!(scsi_id = (struct scsi_id_instance_data *)sdev->host->hostdata[0])) return 0; - lun = ORB_SET_LUN(scsi_id->sbp2_lun); + if (scsi_id->sbp2_device_type_and_lun == SBP2_DEVICE_TYPE_LUN_UNINITIALIZED) + lun = 0; + else + lun = ORB_SET_LUN(scsi_id->sbp2_device_type_and_lun); return sprintf(buf, "%016Lx:%d:%d\n", (unsigned long long)scsi_id->ne->guid, scsi_id->ud->id, lun); @@ -2603,9 +2837,12 @@ static struct scsi_host_template scsi_driver_template = { .module = THIS_MODULE, .name = "SBP-2 IEEE-1394", .proc_name = SBP2_DEVICE_NAME, + .info = sbp2scsi_info, .queuecommand = sbp2scsi_queuecommand, .eh_abort_handler = sbp2scsi_abort, .eh_device_reset_handler = sbp2scsi_reset, + .eh_bus_reset_handler = sbp2scsi_reset, + .eh_host_reset_handler = sbp2scsi_reset, .slave_alloc = sbp2scsi_slave_alloc, .slave_configure = sbp2scsi_slave_configure, .slave_destroy = sbp2scsi_slave_destroy, @@ -2624,6 +2861,8 @@ static int sbp2_module_init(void) SBP2_DEBUG("sbp2_module_init"); + printk(KERN_INFO "sbp2: %s\n", version); + /* Module load debug option to force one command at a time (serializing I/O) */ if (serialize_io) { SBP2_INFO("Driver forced to serialize I/O (serialize_io=1)"); @@ -2635,6 +2874,7 @@ static int sbp2_module_init(void) /* Set max sectors (module load option). Default is 255 sectors. */ scsi_driver_template.max_sectors = max_sectors; + /* Register our high level driver with 1394 stack */ hpsb_register_highlevel(&sbp2_highlevel); diff --git a/trunk/drivers/ieee1394/sbp2.h b/trunk/drivers/ieee1394/sbp2.h index 900ea1d25e71..cd425be74841 100644 --- a/trunk/drivers/ieee1394/sbp2.h +++ b/trunk/drivers/ieee1394/sbp2.h @@ -119,8 +119,8 @@ struct sbp2_query_logins_response { struct sbp2_reconnect_orb { u32 reserved1; u32 reserved2; - u32 reserved3; - u32 reserved4; + u32 reserved3; + u32 reserved4; u32 login_ID_misc; u32 reserved5; u32 status_FIFO_hi; @@ -130,8 +130,8 @@ struct sbp2_reconnect_orb { struct sbp2_logout_orb { u32 reserved1; u32 reserved2; - u32 reserved3; - u32 reserved4; + u32 reserved3; + u32 reserved4; u32 login_ID_misc; u32 reserved5; u32 status_FIFO_hi; @@ -188,7 +188,7 @@ struct sbp2_unrestricted_page_table { struct sbp2_status_block { u32 ORB_offset_hi_misc; u32 ORB_offset_lo; - u8 command_set_dependent[24]; + u8 command_set_dependent[24]; }; /* @@ -211,7 +211,7 @@ struct sbp2_status_block { * specified for write posting, where the ohci controller will * automatically send an ack_complete when the status is written by the * sbp2 device... saving a split transaction. =) - */ + */ #define SBP2_STATUS_FIFO_ADDRESS 0xfffe00000000ULL #define SBP2_STATUS_FIFO_ADDRESS_HI 0xfffe #define SBP2_STATUS_FIFO_ADDRESS_LO 0x0 @@ -229,6 +229,9 @@ struct sbp2_status_block { #define SBP2_DEVICE_TYPE_AND_LUN_KEY 0x14 #define SBP2_FIRMWARE_REVISION_KEY 0x3c +#define SBP2_DEVICE_TYPE(q) (((q) >> 16) & 0x1f) +#define SBP2_DEVICE_LUN(q) ((q) & 0xffff) + #define SBP2_AGENT_STATE_OFFSET 0x00ULL #define SBP2_AGENT_RESET_OFFSET 0x04ULL #define SBP2_ORB_POINTER_OFFSET 0x08ULL @@ -253,6 +256,8 @@ struct sbp2_status_block { */ #define SBP2_128KB_BROKEN_FIRMWARE 0xa0b800 +#define SBP2_DEVICE_TYPE_LUN_UNINITIALIZED 0xffffffff + /* * SCSI specific stuff */ @@ -260,7 +265,45 @@ struct sbp2_status_block { #define SBP2_MAX_SG_ELEMENT_LENGTH 0xf000 #define SBP2_MAX_UDS_PER_NODE 16 /* Maximum scsi devices per node */ #define SBP2_MAX_SECTORS 255 /* Max sectors supported */ -#define SBP2_MAX_CMDS 8 /* This should be safe */ + +/* + * SCSI direction table... + * (now used as a back-up in case the direction passed down from above is "unknown") + * + * DIN = IN data direction + * DOU = OUT data direction + * DNO = No data transfer + * DUN = Unknown data direction + * + * Opcode 0xec (Teac specific "opc execute") possibly should be DNO, + * but we'll change it when somebody reports a problem with this. + */ +#define DIN ORB_DIRECTION_READ_FROM_MEDIA +#define DOU ORB_DIRECTION_WRITE_TO_MEDIA +#define DNO ORB_DIRECTION_NO_DATA_TRANSFER +#define DUN DIN + +static unchar sbp2scsi_direction_table[0x100] = { + DNO,DNO,DIN,DIN,DOU,DIN,DIN,DOU,DIN,DUN,DOU,DOU,DUN,DUN,DUN,DIN, + DNO,DIN,DIN,DOU,DIN,DOU,DNO,DNO,DOU,DNO,DIN,DNO,DIN,DOU,DNO,DUN, + DIN,DUN,DIN,DIN,DOU,DIN,DUN,DUN,DIN,DIN,DOU,DNO,DUN,DIN,DOU,DOU, + DOU,DOU,DOU,DNO,DIN,DNO,DNO,DIN,DOU,DOU,DOU,DOU,DIN,DOU,DIN,DOU, + DOU,DOU,DIN,DIN,DIN,DNO,DIN,DNO,DNO,DNO,DUN,DNO,DOU,DIN,DNO,DUN, + DUN,DIN,DIN,DNO,DNO,DOU,DUN,DUN,DNO,DIN,DIN,DNO,DIN,DOU,DUN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, + DUN,DNO,DOU,DOU,DIN,DNO,DNO,DNO,DIN,DNO,DOU,DUN,DNO,DIN,DOU,DOU, + DOU,DOU,DOU,DNO,DUN,DIN,DOU,DIN,DIN,DIN,DNO,DNO,DNO,DIN,DIN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DOU,DUN,DUN,DUN,DUN,DUN, + DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN,DUN +}; + +/* This should be safe */ +#define SBP2_MAX_CMDS 8 /* This is the two dma types we use for cmd_dma below */ enum cmd_dma_types { @@ -295,8 +338,10 @@ struct sbp2_command_info { #define SBP2_BREAKAGE_128K_MAX_TRANSFER 0x1 #define SBP2_BREAKAGE_INQUIRY_HACK 0x2 + struct sbp2scsi_host_info; + /* * Information needed on a per scsi id basis (one for each sbp2 device) */ @@ -334,7 +379,7 @@ struct scsi_id_instance_data { u32 sbp2_command_set_spec_id; u32 sbp2_command_set; u32 sbp2_unit_characteristics; - u32 sbp2_lun; + u32 sbp2_device_type_and_lun; u32 sbp2_firmware_revision; /* @@ -366,6 +411,7 @@ struct scsi_id_instance_data { u32 workarounds; }; + /* Sbp2 host data structure (one per IEEE1394 host) */ struct sbp2scsi_host_info { struct hpsb_host *host; /* IEEE1394 host */ @@ -410,12 +456,20 @@ static int sbp2_logout_device(struct scsi_id_instance_data *scsi_id); static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid, int destid, quadlet_t *data, u64 addr, size_t length, u16 flags); static int sbp2_agent_reset(struct scsi_id_instance_data *scsi_id, int wait); +static int sbp2_create_command_orb(struct scsi_id_instance_data *scsi_id, + struct sbp2_command_info *command, + unchar *scsi_cmd, + unsigned int scsi_use_sg, + unsigned int scsi_request_bufflen, + void *scsi_request_buffer, + enum dma_data_direction dma_dir); static int sbp2_link_orb_command(struct scsi_id_instance_data *scsi_id, struct sbp2_command_info *command); static int sbp2_send_command(struct scsi_id_instance_data *scsi_id, struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)); static unsigned int sbp2_status_to_sense_data(unchar *sbp2_status, unchar *sense_data); +static void sbp2_check_sbp2_command(struct scsi_id_instance_data *scsi_id, unchar *cmd); static void sbp2_check_sbp2_response(struct scsi_id_instance_data *scsi_id, struct scsi_cmnd *SCpnt); static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id, diff --git a/trunk/drivers/ieee1394/video1394.c b/trunk/drivers/ieee1394/video1394.c index 608479b2df14..23911da50154 100644 --- a/trunk/drivers/ieee1394/video1394.c +++ b/trunk/drivers/ieee1394/video1394.c @@ -19,6 +19,12 @@ * * NOTES: * + * jds -- add private data to file to keep track of iso contexts associated + * with each open -- so release won't kill all iso transfers. + * + * Damien Douxchamps: Fix failure when the number of DMA pages per frame is + * one. + * * ioctl return codes: * EFAULT is only for invalid address for the argp * EINVAL for out of range values @@ -28,6 +34,12 @@ * ENOTTY for unsupported ioctl request * */ + +/* Markus Tavenrath : + - fixed checks for valid buffer-numbers in video1394_icotl + - changed the ways the dma prg's are used, now it's possible to use + even a single dma buffer +*/ #include #include #include @@ -65,6 +77,14 @@ #define ISO_CHANNELS 64 +#ifndef virt_to_page +#define virt_to_page(x) MAP_NR(x) +#endif + +#ifndef vmalloc_32 +#define vmalloc_32(x) vmalloc(x) +#endif + struct it_dma_prg { struct dma_cmd begin; quadlet_t data[4]; @@ -186,12 +206,14 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc, struct dma_iso_ctx *d; int i; - d = kzalloc(sizeof(*d), GFP_KERNEL); - if (!d) { + d = kmalloc(sizeof(struct dma_iso_ctx), GFP_KERNEL); + if (d == NULL) { PRINT(KERN_ERR, ohci->host->id, "Failed to allocate dma_iso_ctx"); return NULL; } + memset(d, 0, sizeof *d); + d->ohci = ohci; d->type = type; d->channel = channel; @@ -229,8 +251,9 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc, } d->ctx = d->iso_tasklet.context; - d->prg_reg = kmalloc(d->num_desc * sizeof(*d->prg_reg), GFP_KERNEL); - if (!d->prg_reg) { + d->prg_reg = kmalloc(d->num_desc * sizeof(struct dma_prog_region), + GFP_KERNEL); + if (d->prg_reg == NULL) { PRINT(KERN_ERR, ohci->host->id, "Failed to allocate ir prg regs"); free_dma_iso_ctx(d); return NULL; @@ -245,14 +268,15 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc, d->cmdPtr = OHCI1394_IsoRcvCommandPtr+32*d->ctx; d->ctxMatch = OHCI1394_IsoRcvContextMatch+32*d->ctx; - d->ir_prg = kzalloc(d->num_desc * sizeof(*d->ir_prg), + d->ir_prg = kmalloc(d->num_desc * sizeof(struct dma_cmd *), GFP_KERNEL); - if (!d->ir_prg) { + if (d->ir_prg == NULL) { PRINT(KERN_ERR, ohci->host->id, "Failed to allocate dma ir prg"); free_dma_iso_ctx(d); return NULL; } + memset(d->ir_prg, 0, d->num_desc * sizeof(struct dma_cmd *)); d->nb_cmd = d->buf_size / PAGE_SIZE + 1; d->left_size = (d->frame_size % PAGE_SIZE) ? @@ -273,15 +297,16 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc, d->ctrlClear = OHCI1394_IsoXmitContextControlClear+16*d->ctx; d->cmdPtr = OHCI1394_IsoXmitCommandPtr+16*d->ctx; - d->it_prg = kzalloc(d->num_desc * sizeof(*d->it_prg), + d->it_prg = kmalloc(d->num_desc * sizeof(struct it_dma_prg *), GFP_KERNEL); - if (!d->it_prg) { + if (d->it_prg == NULL) { PRINT(KERN_ERR, ohci->host->id, "Failed to allocate dma it prg"); free_dma_iso_ctx(d); return NULL; } + memset(d->it_prg, 0, d->num_desc*sizeof(struct it_dma_prg *)); d->packet_size = packet_size; @@ -312,24 +337,47 @@ alloc_dma_iso_ctx(struct ti_ohci *ohci, int type, int num_desc, } } - d->buffer_status = - kzalloc(d->num_desc * sizeof(*d->buffer_status), GFP_KERNEL); - d->buffer_prg_assignment = - kzalloc(d->num_desc * sizeof(*d->buffer_prg_assignment), GFP_KERNEL); - d->buffer_time = - kzalloc(d->num_desc * sizeof(*d->buffer_time), GFP_KERNEL); - d->last_used_cmd = - kzalloc(d->num_desc * sizeof(*d->last_used_cmd), GFP_KERNEL); - d->next_buffer = - kzalloc(d->num_desc * sizeof(*d->next_buffer), GFP_KERNEL); - - if (!d->buffer_status || !d->buffer_prg_assignment || !d->buffer_time || - !d->last_used_cmd || !d->next_buffer) { - PRINT(KERN_ERR, ohci->host->id, - "Failed to allocate dma_iso_ctx member"); + d->buffer_status = kmalloc(d->num_desc * sizeof(unsigned int), + GFP_KERNEL); + d->buffer_prg_assignment = kmalloc(d->num_desc * sizeof(unsigned int), + GFP_KERNEL); + d->buffer_time = kmalloc(d->num_desc * sizeof(struct timeval), + GFP_KERNEL); + d->last_used_cmd = kmalloc(d->num_desc * sizeof(unsigned int), + GFP_KERNEL); + d->next_buffer = kmalloc(d->num_desc * sizeof(int), + GFP_KERNEL); + + if (d->buffer_status == NULL) { + PRINT(KERN_ERR, ohci->host->id, "Failed to allocate buffer_status"); + free_dma_iso_ctx(d); + return NULL; + } + if (d->buffer_prg_assignment == NULL) { + PRINT(KERN_ERR, ohci->host->id, "Failed to allocate buffer_prg_assignment"); + free_dma_iso_ctx(d); + return NULL; + } + if (d->buffer_time == NULL) { + PRINT(KERN_ERR, ohci->host->id, "Failed to allocate buffer_time"); + free_dma_iso_ctx(d); + return NULL; + } + if (d->last_used_cmd == NULL) { + PRINT(KERN_ERR, ohci->host->id, "Failed to allocate last_used_cmd"); + free_dma_iso_ctx(d); + return NULL; + } + if (d->next_buffer == NULL) { + PRINT(KERN_ERR, ohci->host->id, "Failed to allocate next_buffer"); free_dma_iso_ctx(d); return NULL; } + memset(d->buffer_status, 0, d->num_desc * sizeof(unsigned int)); + memset(d->buffer_prg_assignment, 0, d->num_desc * sizeof(unsigned int)); + memset(d->buffer_time, 0, d->num_desc * sizeof(struct timeval)); + memset(d->last_used_cmd, 0, d->num_desc * sizeof(unsigned int)); + memset(d->next_buffer, -1, d->num_desc * sizeof(int)); spin_lock_init(&d->lock); @@ -491,7 +539,7 @@ static void wakeup_dma_ir_ctx(unsigned long l) if (d->ir_prg[i][d->nb_cmd-1].status & cpu_to_le32(0xFFFF0000)) { reset_ir_status(d, i); d->buffer_status[d->buffer_prg_assignment[i]] = VIDEO1394_BUFFER_READY; - do_gettimeofday(&d->buffer_time[d->buffer_prg_assignment[i]]); + do_gettimeofday(&d->buffer_time[i]); } } @@ -998,6 +1046,7 @@ static int __video1394_ioctl(struct file *file, /* set time of buffer */ v.filltime = d->buffer_time[v.buffer]; +// printk("Buffer %d time %d\n", v.buffer, (d->buffer_time[v.buffer]).tv_usec); /* * Look ahead to see how many more buffers have been received @@ -1036,7 +1085,7 @@ static int __video1394_ioctl(struct file *file, } if (d->flags & VIDEO1394_VARIABLE_PACKET_SIZE) { - int buf_size = d->nb_cmd * sizeof(*psizes); + int buf_size = d->nb_cmd * sizeof(unsigned int); struct video1394_queue_variable __user *p = argp; unsigned int __user *qv; @@ -1055,7 +1104,7 @@ static int __video1394_ioctl(struct file *file, spin_lock_irqsave(&d->lock,flags); - /* last_buffer is last_prg */ + // last_buffer is last_prg next_prg = (d->last_buffer + 1) % d->num_desc; if (d->buffer_status[v.buffer]!=VIDEO1394_BUFFER_FREE) { PRINT(KERN_ERR, ohci->host->id, @@ -1202,12 +1251,13 @@ static int video1394_open(struct inode *inode, struct file *file) if (ohci == NULL) return -EIO; - ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); - if (!ctx) { + ctx = kmalloc(sizeof(struct file_ctx), GFP_KERNEL); + if (ctx == NULL) { PRINT(KERN_ERR, ohci->host->id, "Cannot malloc file_ctx"); return -ENOMEM; } + memset(ctx, 0, sizeof(struct file_ctx)); ctx->ohci = ohci; INIT_LIST_HEAD(&ctx->context_list); ctx->current_ctx = NULL; diff --git a/trunk/drivers/infiniband/core/sysfs.c b/trunk/drivers/infiniband/core/sysfs.c index 1f1743c5c9a3..08648b1a387e 100644 --- a/trunk/drivers/infiniband/core/sysfs.c +++ b/trunk/drivers/infiniband/core/sysfs.c @@ -434,24 +434,24 @@ static void ib_device_release(struct class_device *cdev) kfree(dev); } -static int ib_device_uevent(struct class_device *cdev, char **envp, - int num_envp, char *buf, int size) +static int ib_device_hotplug(struct class_device *cdev, char **envp, + int num_envp, char *buf, int size) { struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); int i = 0, len = 0; - if (add_uevent_var(envp, num_envp, &i, buf, size, &len, - "NAME=%s", dev->name)) + if (add_hotplug_env_var(envp, num_envp, &i, buf, size, &len, + "NAME=%s", dev->name)) return -ENOMEM; /* - * It might be nice to pass the node GUID with the event, but + * It might be nice to pass the node GUID to hotplug, but * right now the only way to get it is to query the device * provider, and this can crash during device removal because * we are will be running after driver removal has started. * We could add a node_guid field to struct ib_device, or we - * could just let userspace read the node GUID from sysfs when - * devices are added. + * could just let the hotplug script read the node GUID from + * sysfs when devices are added. */ envp[i] = NULL; @@ -653,7 +653,7 @@ static struct class_device_attribute *ib_class_attributes[] = { static struct class ib_class = { .name = "infiniband", .release = ib_device_release, - .uevent = ib_device_uevent, + .hotplug = ib_device_hotplug, }; int ib_device_register_sysfs(struct ib_device *device) diff --git a/trunk/drivers/infiniband/ulp/ipoib/ipoib_main.c b/trunk/drivers/infiniband/ulp/ipoib/ipoib_main.c index 780009c7eaa6..475d98fa9e26 100644 --- a/trunk/drivers/infiniband/ulp/ipoib/ipoib_main.c +++ b/trunk/drivers/infiniband/ulp/ipoib/ipoib_main.c @@ -47,8 +47,6 @@ #include #include -#include - MODULE_AUTHOR("Roland Dreier"); MODULE_DESCRIPTION("IP-over-InfiniBand net driver"); MODULE_LICENSE("Dual BSD/GPL"); diff --git a/trunk/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/trunk/drivers/infiniband/ulp/ipoib/ipoib_multicast.c index ed0c2ead8bc1..ef3ee035bbc8 100644 --- a/trunk/drivers/infiniband/ulp/ipoib/ipoib_multicast.c +++ b/trunk/drivers/infiniband/ulp/ipoib/ipoib_multicast.c @@ -43,8 +43,6 @@ #include #include -#include - #include "ipoib.h" #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG diff --git a/trunk/drivers/input/input.c b/trunk/drivers/input/input.c index ef5824c8846b..bdd2a7fc268d 100644 --- a/trunk/drivers/input/input.c +++ b/trunk/drivers/input/input.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -528,49 +529,10 @@ INPUT_DEV_STRING_ATTR_SHOW(name); INPUT_DEV_STRING_ATTR_SHOW(phys); INPUT_DEV_STRING_ATTR_SHOW(uniq); -static int print_modalias_bits(char *buf, char prefix, unsigned long *arr, - unsigned int min, unsigned int max) -{ - int len, i; - - len = sprintf(buf, "%c", prefix); - for (i = min; i < max; i++) - if (arr[LONG(i)] & BIT(i)) - len += sprintf(buf+len, "%X,", i); - return len; -} - -static ssize_t input_dev_show_modalias(struct class_device *dev, char *buf) -{ - struct input_dev *id = to_input_dev(dev); - ssize_t len = 0; - - len += sprintf(buf+len, "input:b%04Xv%04Xp%04Xe%04X-", - id->id.bustype, - id->id.vendor, - id->id.product, - id->id.version); - - len += print_modalias_bits(buf+len, 'e', id->evbit, 0, EV_MAX); - len += print_modalias_bits(buf+len, 'k', id->keybit, - KEY_MIN_INTERESTING, KEY_MAX); - len += print_modalias_bits(buf+len, 'r', id->relbit, 0, REL_MAX); - len += print_modalias_bits(buf+len, 'a', id->absbit, 0, ABS_MAX); - len += print_modalias_bits(buf+len, 'm', id->mscbit, 0, MSC_MAX); - len += print_modalias_bits(buf+len, 'l', id->ledbit, 0, LED_MAX); - len += print_modalias_bits(buf+len, 's', id->sndbit, 0, SND_MAX); - len += print_modalias_bits(buf+len, 'f', id->ffbit, 0, FF_MAX); - len += print_modalias_bits(buf+len, 'w', id->swbit, 0, SW_MAX); - len += sprintf(buf+len, "\n"); - return len; -} -static CLASS_DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL); - static struct attribute *input_dev_attrs[] = { &class_device_attr_name.attr, &class_device_attr_phys.attr, &class_device_attr_uniq.attr, - &class_device_attr_modalias.attr, NULL }; @@ -649,10 +611,10 @@ static void input_dev_release(struct class_device *class_dev) } /* - * Input uevent interface - loading event handlers based on + * Input hotplugging interface - loading event handlers based on * device bitfields. */ -static int input_add_uevent_bm_var(char **envp, int num_envp, int *cur_index, +static int input_add_hotplug_bm_var(char **envp, int num_envp, int *cur_index, char *buffer, int buffer_size, int *cur_len, const char *name, unsigned long *bitmap, int max) { @@ -677,7 +639,7 @@ static int input_add_uevent_bm_var(char **envp, int num_envp, int *cur_index, #define INPUT_ADD_HOTPLUG_VAR(fmt, val...) \ do { \ - int err = add_uevent_var(envp, num_envp, &i, \ + int err = add_hotplug_env_var(envp, num_envp, &i, \ buffer, buffer_size, &len, \ fmt, val); \ if (err) \ @@ -686,15 +648,15 @@ static int input_add_uevent_bm_var(char **envp, int num_envp, int *cur_index, #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max) \ do { \ - int err = input_add_uevent_bm_var(envp, num_envp, &i, \ + int err = input_add_hotplug_bm_var(envp, num_envp, &i, \ buffer, buffer_size, &len, \ name, bm, max); \ if (err) \ return err; \ } while (0) -static int input_dev_uevent(struct class_device *cdev, char **envp, - int num_envp, char *buffer, int buffer_size) +static int input_dev_hotplug(struct class_device *cdev, char **envp, + int num_envp, char *buffer, int buffer_size) { struct input_dev *dev = to_input_dev(cdev); int i = 0; @@ -736,7 +698,7 @@ static int input_dev_uevent(struct class_device *cdev, char **envp, struct class input_class = { .name = "input", .release = input_dev_release, - .uevent = input_dev_uevent, + .hotplug = input_dev_hotplug, }; struct input_dev *input_allocate_device(void) diff --git a/trunk/drivers/input/joystick/iforce/iforce-usb.c b/trunk/drivers/input/joystick/iforce/iforce-usb.c index bc2fce60f9f8..64b4a3080985 100644 --- a/trunk/drivers/input/joystick/iforce/iforce-usb.c +++ b/trunk/drivers/input/joystick/iforce/iforce-usb.c @@ -235,6 +235,7 @@ static struct usb_device_id iforce_usb_ids [] = { MODULE_DEVICE_TABLE (usb, iforce_usb_ids); struct usb_driver iforce_usb_driver = { + .owner = THIS_MODULE, .name = "iforce", .probe = iforce_usb_probe, .disconnect = iforce_usb_disconnect, diff --git a/trunk/drivers/input/serio/serio.c b/trunk/drivers/input/serio/serio.c index 8e530cc970e1..fbb69ef6a77b 100644 --- a/trunk/drivers/input/serio/serio.c +++ b/trunk/drivers/input/serio/serio.c @@ -800,16 +800,16 @@ static int serio_bus_match(struct device *dev, struct device_driver *drv) #ifdef CONFIG_HOTPLUG -#define SERIO_ADD_UEVENT_VAR(fmt, val...) \ +#define SERIO_ADD_HOTPLUG_VAR(fmt, val...) \ do { \ - int err = add_uevent_var(envp, num_envp, &i, \ + int err = add_hotplug_env_var(envp, num_envp, &i, \ buffer, buffer_size, &len, \ fmt, val); \ if (err) \ return err; \ } while (0) -static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) +static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { struct serio *serio; int i = 0; @@ -820,21 +820,21 @@ static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buf serio = to_serio_port(dev); - SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type); - SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto); - SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id); - SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra); - SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X", + SERIO_ADD_HOTPLUG_VAR("SERIO_TYPE=%02x", serio->id.type); + SERIO_ADD_HOTPLUG_VAR("SERIO_PROTO=%02x", serio->id.proto); + SERIO_ADD_HOTPLUG_VAR("SERIO_ID=%02x", serio->id.id); + SERIO_ADD_HOTPLUG_VAR("SERIO_EXTRA=%02x", serio->id.extra); + SERIO_ADD_HOTPLUG_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X", serio->id.type, serio->id.proto, serio->id.id, serio->id.extra); envp[i] = NULL; return 0; } -#undef SERIO_ADD_UEVENT_VAR +#undef SERIO_ADD_HOTPLUG_VAR #else -static int serio_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) +static int serio_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { return -ENODEV; } @@ -908,7 +908,7 @@ static int __init serio_init(void) serio_bus.dev_attrs = serio_device_attrs; serio_bus.drv_attrs = serio_driver_attrs; serio_bus.match = serio_bus_match; - serio_bus.uevent = serio_uevent; + serio_bus.hotplug = serio_hotplug; serio_bus.resume = serio_resume; bus_register(&serio_bus); diff --git a/trunk/drivers/isdn/hardware/avm/avm_cs.c b/trunk/drivers/isdn/hardware/avm/avm_cs.c index 2a2b03ff096b..27391c32f3eb 100644 --- a/trunk/drivers/isdn/hardware/avm/avm_cs.c +++ b/trunk/drivers/isdn/hardware/avm/avm_cs.c @@ -53,6 +53,8 @@ MODULE_LICENSE("GPL"); static void avmcs_config(dev_link_t *link); static void avmcs_release(dev_link_t *link); +static int avmcs_event(event_t event, int priority, + event_callback_args_t *args); /* The attach() and detach() entry points are used to create and destroy @@ -60,7 +62,16 @@ static void avmcs_release(dev_link_t *link); needed to manage one actual PCMCIA card. */ -static void avmcs_detach(struct pcmcia_device *p_dev); +static dev_link_t *avmcs_attach(void); +static void avmcs_detach(dev_link_t *); + +/* + The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ + +static dev_info_t dev_info = "avm_cs"; /* A linked list of "instances" of the skeleton device. Each actual @@ -72,7 +83,15 @@ static void avmcs_detach(struct pcmcia_device *p_dev); device numbers are used to derive the corresponding array index. */ +static dev_link_t *dev_list = NULL; + /* + A dev_link_t structure has fields for most things that are needed + to keep track of a socket, but there will usually be some device + specific information that also needs to be kept track of. The + 'priv' pointer in a dev_link_t structure can be used to point to + a device-specific private data structure, like this. + A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be @@ -99,11 +118,13 @@ typedef struct local_info_t { ======================================================================*/ -static int avmcs_attach(struct pcmcia_device *p_dev) +static dev_link_t *avmcs_attach(void) { + client_reg_t client_reg; dev_link_t *link; local_info_t *local; - + int ret; + /* Initialize the dev_link_t structure */ link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL); if (!link) @@ -134,19 +155,25 @@ static int avmcs_attach(struct pcmcia_device *p_dev) goto err_kfree; memset(local, 0, sizeof(local_info_t)); link->priv = local; - - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - avmcs_config(link); - - return 0; + + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + avmcs_detach(link); + goto err; + } + return link; err_kfree: kfree(link); err: - return -EINVAL; + return NULL; } /* avmcs_attach */ /*====================================================================== @@ -158,13 +185,33 @@ static int avmcs_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void avmcs_detach(struct pcmcia_device *p_dev) +static void avmcs_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; - if (link->state & DEV_CONFIG) - avmcs_release(link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + + /* + If the device is currently configured and active, we won't + actually delete it yet. Instead, it is marked so that when + the release() function is called, that will trigger a proper + detach(). + */ + if (link->state & DEV_CONFIG) { + link->state |= DEV_STALE_LINK; + return; + } + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free pieces */ + *linkp = link->next; kfree(link->priv); kfree(link); } /* avmcs_detach */ @@ -377,30 +424,12 @@ static void avmcs_release(dev_link_t *link) pcmcia_release_io(link->handle, &link->io); pcmcia_release_irq(link->handle, &link->irq); link->state &= ~DEV_CONFIG; + + if (link->state & DEV_STALE_LINK) + avmcs_detach(link); + } /* avmcs_release */ -static int avmcs_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int avmcs_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); - - return 0; -} - /*====================================================================== The card status event handler. Mostly, this schedules other @@ -415,6 +444,38 @@ static int avmcs_resume(struct pcmcia_device *dev) ======================================================================*/ +static int avmcs_event(event_t event, int priority, + event_callback_args_t *args) +{ + dev_link_t *link = args->client_data; + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + avmcs_release(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + avmcs_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } + return 0; +} /* avmcs_event */ static struct pcmcia_device_id avmcs_ids[] = { PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN-Controller B1", 0x95d42008, 0x845dc335), @@ -429,11 +490,10 @@ static struct pcmcia_driver avmcs_driver = { .drv = { .name = "avm_cs", }, - .probe = avmcs_attach, - .remove = avmcs_detach, + .attach = avmcs_attach, + .event = avmcs_event, + .detach = avmcs_detach, .id_table = avmcs_ids, - .suspend= avmcs_suspend, - .resume = avmcs_resume, }; static int __init avmcs_init(void) @@ -444,6 +504,7 @@ static int __init avmcs_init(void) static void __exit avmcs_exit(void) { pcmcia_unregister_driver(&avmcs_driver); + BUG_ON(dev_list != NULL); } module_init(avmcs_init); diff --git a/trunk/drivers/isdn/hisax/avma1_cs.c b/trunk/drivers/isdn/hisax/avma1_cs.c index 969da40c4248..5f5a5ae740d2 100644 --- a/trunk/drivers/isdn/hisax/avma1_cs.c +++ b/trunk/drivers/isdn/hisax/avma1_cs.c @@ -69,6 +69,8 @@ module_param(isdnprot, int, 0); static void avma1cs_config(dev_link_t *link); static void avma1cs_release(dev_link_t *link); +static int avma1cs_event(event_t event, int priority, + event_callback_args_t *args); /* The attach() and detach() entry points are used to create and destroy @@ -76,8 +78,16 @@ static void avma1cs_release(dev_link_t *link); needed to manage one actual PCMCIA card. */ -static void avma1cs_detach(struct pcmcia_device *p_dev); +static dev_link_t *avma1cs_attach(void); +static void avma1cs_detach(dev_link_t *); +/* + The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ + +static dev_info_t dev_info = "avma1_cs"; /* A linked list of "instances" of the skeleton device. Each actual @@ -89,7 +99,15 @@ static void avma1cs_detach(struct pcmcia_device *p_dev); device numbers are used to derive the corresponding array index. */ +static dev_link_t *dev_list = NULL; + /* + A dev_link_t structure has fields for most things that are needed + to keep track of a socket, but there will usually be some device + specific information that also needs to be kept track of. The + 'priv' pointer in a dev_link_t structure can be used to point to + a device-specific private data structure, like this. + A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be @@ -116,24 +134,26 @@ typedef struct local_info_t { ======================================================================*/ -static int avma1cs_attach(struct pcmcia_device *p_dev) +static dev_link_t *avma1cs_attach(void) { + client_reg_t client_reg; dev_link_t *link; local_info_t *local; - + int ret; + DEBUG(0, "avma1cs_attach()\n"); /* Initialize the dev_link_t structure */ link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL); if (!link) - return -ENOMEM; + return NULL; memset(link, 0, sizeof(struct dev_link_t)); /* Allocate space for private device-specific data */ local = kmalloc(sizeof(local_info_t), GFP_KERNEL); if (!local) { kfree(link); - return -ENOMEM; + return NULL; } memset(local, 0, sizeof(local_info_t)); link->priv = local; @@ -158,13 +178,20 @@ static int avma1cs_attach(struct pcmcia_device *p_dev) link->conf.ConfigIndex = 1; link->conf.Present = PRESENT_OPTION; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - avma1cs_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + avma1cs_detach(link); + return NULL; + } - return 0; + return link; } /* avma1cs_attach */ /*====================================================================== @@ -176,17 +203,42 @@ static int avma1cs_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void avma1cs_detach(struct pcmcia_device *p_dev) +static void avma1cs_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; DEBUG(0, "avma1cs_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; - if (link->state & DEV_CONFIG) - avma1cs_release(link); + /* + If the device is currently configured and active, we won't + actually delete it yet. Instead, it is marked so that when + the release() function is called, that will trigger a proper + detach(). + */ + if (link->state & DEV_CONFIG) { +#ifdef PCMCIA_DEBUG + printk(KERN_DEBUG "avma1_cs: detach postponed, '%s' " + "still locked\n", link->dev->dev_name); +#endif + link->state |= DEV_STALE_LINK; + return; + } + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free pieces */ + *linkp = link->next; kfree(link->priv); kfree(link); + } /* avma1cs_detach */ /*====================================================================== @@ -388,30 +440,58 @@ static void avma1cs_release(dev_link_t *link) pcmcia_release_io(link->handle, &link->io); pcmcia_release_irq(link->handle, &link->irq); link->state &= ~DEV_CONFIG; + + if (link->state & DEV_STALE_LINK) + avma1cs_detach(link); } /* avma1cs_release */ -static int avma1cs_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); +/*====================================================================== - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. - return 0; -} + When a CARD_REMOVAL event is received, we immediately set a flag + to block future accesses to this device. All the functions that + actually access the device should check this flag to make sure + the card is still present. + +======================================================================*/ -static int avma1cs_resume(struct pcmcia_device *dev) +static int avma1cs_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) + DEBUG(1, "avma1cs_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + if (link->state & DEV_CONFIG) + avma1cs_release(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + avma1cs_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) pcmcia_request_configuration(link->handle, &link->conf); - - return 0; -} - + break; + } + return 0; +} /* avma1cs_event */ static struct pcmcia_device_id avma1cs_ids[] = { PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN A", 0x95d42008, 0xadc9d4bb), @@ -425,11 +505,10 @@ static struct pcmcia_driver avma1cs_driver = { .drv = { .name = "avma1_cs", }, - .probe = avma1cs_attach, - .remove = avma1cs_detach, + .attach = avma1cs_attach, + .event = avma1cs_event, + .detach = avma1cs_detach, .id_table = avma1cs_ids, - .suspend = avma1cs_suspend, - .resume = avma1cs_resume, }; /*====================================================================*/ @@ -442,6 +521,7 @@ static int __init init_avma1_cs(void) static void __exit exit_avma1_cs(void) { pcmcia_unregister_driver(&avma1cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_avma1_cs); diff --git a/trunk/drivers/isdn/hisax/elsa_cs.c b/trunk/drivers/isdn/hisax/elsa_cs.c index 062fb8f0739f..6fc6868de0b0 100644 --- a/trunk/drivers/isdn/hisax/elsa_cs.c +++ b/trunk/drivers/isdn/hisax/elsa_cs.c @@ -96,6 +96,8 @@ module_param(protocol, int, 0); static void elsa_cs_config(dev_link_t *link); static void elsa_cs_release(dev_link_t *link); +static int elsa_cs_event(event_t event, int priority, + event_callback_args_t *args); /* The attach() and detach() entry points are used to create and destroy @@ -103,9 +105,39 @@ static void elsa_cs_release(dev_link_t *link); needed to manage one actual PCMCIA card. */ -static void elsa_cs_detach(struct pcmcia_device *p_dev); +static dev_link_t *elsa_cs_attach(void); +static void elsa_cs_detach(dev_link_t *); /* + The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ + +static dev_info_t dev_info = "elsa_cs"; + +/* + A linked list of "instances" of the elsa_cs device. Each actual + PCMCIA card corresponds to one device instance, and is described + by one dev_link_t structure (defined in ds.h). + + You may not want to use a linked list for this -- for example, the + memory card driver uses an array of dev_link_t pointers, where minor + device numbers are used to derive the corresponding array index. +*/ + +static dev_link_t *dev_list = NULL; + +/* + A dev_link_t structure has fields for most things that are needed + to keep track of a socket, but there will usually be some device + specific information that also needs to be kept track of. The + 'priv' pointer in a dev_link_t structure can be used to point to + a device-specific private data structure, like this. + + To simplify the data structure handling, we actually include the + dev_link_t structure in the device's private data structure. + A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be @@ -139,16 +171,18 @@ typedef struct local_info_t { ======================================================================*/ -static int elsa_cs_attach(struct pcmcia_device *p_dev) +static dev_link_t *elsa_cs_attach(void) { + client_reg_t client_reg; dev_link_t *link; local_info_t *local; + int ret; DEBUG(0, "elsa_cs_attach()\n"); /* Allocate space for private device-specific data */ local = kmalloc(sizeof(local_info_t), GFP_KERNEL); - if (!local) return -ENOMEM; + if (!local) return NULL; memset(local, 0, sizeof(local_info_t)); local->cardnr = -1; link = &local->link; link->priv = local; @@ -173,13 +207,20 @@ static int elsa_cs_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - elsa_cs_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + elsa_cs_detach(link); + return NULL; + } - return 0; + return link; } /* elsa_cs_attach */ /*====================================================================== @@ -191,18 +232,32 @@ static int elsa_cs_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void elsa_cs_detach(struct pcmcia_device *p_dev) +static void elsa_cs_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; local_info_t *info = link->priv; + int ret; DEBUG(0, "elsa_cs_detach(0x%p)\n", link); - if (link->state & DEV_CONFIG) { - info->busy = 1; - elsa_cs_release(link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + + if (link->state & DEV_CONFIG) + elsa_cs_release(link); + + /* Break the link with Card Services */ + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); } + /* Unlink device structure and free it */ + *linkp = link->next; kfree(info); } /* elsa_cs_detach */ @@ -392,31 +447,60 @@ static void elsa_cs_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } /* elsa_cs_release */ -static int elsa_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - local_info_t *dev = link->priv; +/*====================================================================== - link->state |= DEV_SUSPEND; - dev->busy = 1; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. - return 0; -} + When a CARD_REMOVAL event is received, we immediately set a flag + to block future accesses to this device. All the functions that + actually access the device should check this flag to make sure + the card is still present. + +======================================================================*/ -static int elsa_resume(struct pcmcia_device *p_dev) +static int elsa_cs_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - local_info_t *dev = link->priv; + dev_link_t *link = args->client_data; + local_info_t *dev = link->priv; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); - dev->busy = 0; + DEBUG(1, "elsa_cs_event(%d)\n", event); - return 0; -} + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + ((local_info_t*)link->priv)->busy = 1; + elsa_cs_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + elsa_cs_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + /* Mark the device as stopped, to block IO until later */ + dev->busy = 1; + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) + pcmcia_request_configuration(link->handle, &link->conf); + dev->busy = 0; + break; + } + return 0; +} /* elsa_cs_event */ static struct pcmcia_device_id elsa_ids[] = { PCMCIA_DEVICE_PROD_ID12("ELSA AG (Aachen, Germany)", "MicroLink ISDN/MC ", 0x983de2c4, 0x333ba257), @@ -430,11 +514,10 @@ static struct pcmcia_driver elsa_cs_driver = { .drv = { .name = "elsa_cs", }, - .probe = elsa_cs_attach, - .remove = elsa_cs_detach, + .attach = elsa_cs_attach, + .event = elsa_cs_event, + .detach = elsa_cs_detach, .id_table = elsa_ids, - .suspend = elsa_suspend, - .resume = elsa_resume, }; static int __init init_elsa_cs(void) @@ -445,6 +528,7 @@ static int __init init_elsa_cs(void) static void __exit exit_elsa_cs(void) { pcmcia_unregister_driver(&elsa_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_elsa_cs); diff --git a/trunk/drivers/isdn/hisax/hfc_usb.c b/trunk/drivers/isdn/hisax/hfc_usb.c index ca5b4a3b683e..f8457ef48826 100644 --- a/trunk/drivers/isdn/hisax/hfc_usb.c +++ b/trunk/drivers/isdn/hisax/hfc_usb.c @@ -1715,6 +1715,7 @@ hfc_usb_disconnect(struct usb_interface /* our driver information structure */ /************************************/ static struct usb_driver hfc_drv = { + .owner = THIS_MODULE, .name = "hfc_usb", .id_table = hfcusb_idtab, .probe = hfc_usb_probe, diff --git a/trunk/drivers/isdn/hisax/sedlbauer_cs.c b/trunk/drivers/isdn/hisax/sedlbauer_cs.c index 6f5213a18a8d..dc334aab433e 100644 --- a/trunk/drivers/isdn/hisax/sedlbauer_cs.c +++ b/trunk/drivers/isdn/hisax/sedlbauer_cs.c @@ -97,6 +97,8 @@ module_param(protocol, int, 0); static void sedlbauer_config(dev_link_t *link); static void sedlbauer_release(dev_link_t *link); +static int sedlbauer_event(event_t event, int priority, + event_callback_args_t *args); /* The attach() and detach() entry points are used to create and destroy @@ -104,7 +106,8 @@ static void sedlbauer_release(dev_link_t *link); needed to manage one actual PCMCIA card. */ -static void sedlbauer_detach(struct pcmcia_device *p_dev); +static dev_link_t *sedlbauer_attach(void); +static void sedlbauer_detach(dev_link_t *); /* You'll also need to prototype all the functions that will actually @@ -114,6 +117,35 @@ static void sedlbauer_detach(struct pcmcia_device *p_dev); */ /* + The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ + +static dev_info_t dev_info = "sedlbauer_cs"; + +/* + A linked list of "instances" of the sedlbauer device. Each actual + PCMCIA card corresponds to one device instance, and is described + by one dev_link_t structure (defined in ds.h). + + You may not want to use a linked list for this -- for example, the + memory card driver uses an array of dev_link_t pointers, where minor + device numbers are used to derive the corresponding array index. +*/ + +static dev_link_t *dev_list = NULL; + +/* + A dev_link_t structure has fields for most things that are needed + to keep track of a socket, but there will usually be some device + specific information that also needs to be kept track of. The + 'priv' pointer in a dev_link_t structure can be used to point to + a device-specific private data structure, like this. + + To simplify the data structure handling, we actually include the + dev_link_t structure in the device's private data structure. + A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be @@ -148,16 +180,18 @@ typedef struct local_info_t { ======================================================================*/ -static int sedlbauer_attach(struct pcmcia_device *p_dev) +static dev_link_t *sedlbauer_attach(void) { local_info_t *local; dev_link_t *link; + client_reg_t client_reg; + int ret; DEBUG(0, "sedlbauer_attach()\n"); /* Allocate space for private device-specific data */ local = kmalloc(sizeof(local_info_t), GFP_KERNEL); - if (!local) return -ENOMEM; + if (!local) return NULL; memset(local, 0, sizeof(local_info_t)); local->cardnr = -1; link = &local->link; link->priv = local; @@ -187,13 +221,20 @@ static int sedlbauer_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - sedlbauer_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + sedlbauer_detach(link); + return NULL; + } - return 0; + return link; } /* sedlbauer_attach */ /*====================================================================== @@ -205,17 +246,39 @@ static int sedlbauer_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void sedlbauer_detach(struct pcmcia_device *p_dev) +static void sedlbauer_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; DEBUG(0, "sedlbauer_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + /* + If the device is currently configured and active, we won't + actually delete it yet. Instead, it is marked so that when + the release() function is called, that will trigger a proper + detach(). + */ if (link->state & DEV_CONFIG) { - ((local_info_t *)link->priv)->stop = 1; - sedlbauer_release(link); +#ifdef PCMCIA_DEBUG + printk(KERN_DEBUG "sedlbauer_cs: detach postponed, '%s' " + "still locked\n", link->dev->dev_name); +#endif + link->state |= DEV_STALE_LINK; + return; } + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, and free it */ + *linkp = link->next; /* This points to the parent local_info_t struct */ kfree(link->priv); } /* sedlbauer_detach */ @@ -484,34 +547,68 @@ static void sedlbauer_release(dev_link_t *link) if (link->irq.AssignedIRQ) pcmcia_release_irq(link->handle, &link->irq); link->state &= ~DEV_CONFIG; + + if (link->state & DEV_STALE_LINK) + sedlbauer_detach(link); + } /* sedlbauer_release */ -static int sedlbauer_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - local_info_t *dev = link->priv; +/*====================================================================== - link->state |= DEV_SUSPEND; - dev->stop = 1; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. - return 0; -} + When a CARD_REMOVAL event is received, we immediately set a + private flag to block future accesses to this device. All the + functions that actually access the device should check this flag + to make sure the card is still present. + +======================================================================*/ -static int sedlbauer_resume(struct pcmcia_device *p_dev) +static int sedlbauer_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - local_info_t *dev = link->priv; - + dev_link_t *link = args->client_data; + local_info_t *dev = link->priv; + + DEBUG(1, "sedlbauer_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + ((local_info_t *)link->priv)->stop = 1; + sedlbauer_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + sedlbauer_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + /* Mark the device as stopped, to block IO until later */ + dev->stop = 1; + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); + pcmcia_request_configuration(link->handle, &link->conf); dev->stop = 0; - - return 0; -} - + /* + In a normal driver, additional code may go here to restore + the device state and restart IO. + */ + break; + } + return 0; +} /* sedlbauer_event */ static struct pcmcia_device_id sedlbauer_ids[] = { PCMCIA_DEVICE_PROD_ID123("SEDLBAUER", "speed star II", "V 3.1", 0x81fb79f5, 0xf3612e1d, 0x6b95c78a), @@ -530,11 +627,10 @@ static struct pcmcia_driver sedlbauer_driver = { .drv = { .name = "sedlbauer_cs", }, - .probe = sedlbauer_attach, - .remove = sedlbauer_detach, + .attach = sedlbauer_attach, + .event = sedlbauer_event, + .detach = sedlbauer_detach, .id_table = sedlbauer_ids, - .suspend = sedlbauer_suspend, - .resume = sedlbauer_resume, }; static int __init init_sedlbauer_cs(void) @@ -545,6 +641,7 @@ static int __init init_sedlbauer_cs(void) static void __exit exit_sedlbauer_cs(void) { pcmcia_unregister_driver(&sedlbauer_driver); + BUG_ON(dev_list != NULL); } module_init(init_sedlbauer_cs); diff --git a/trunk/drivers/isdn/hisax/st5481_init.c b/trunk/drivers/isdn/hisax/st5481_init.c index 99cb0f3d59a1..8e192a3a3490 100644 --- a/trunk/drivers/isdn/hisax/st5481_init.c +++ b/trunk/drivers/isdn/hisax/st5481_init.c @@ -180,6 +180,7 @@ static struct usb_device_id st5481_ids[] = { MODULE_DEVICE_TABLE (usb, st5481_ids); static struct usb_driver st5481_usb_driver = { + .owner = THIS_MODULE, .name = "st5481_usb", .probe = probe_st5481, .disconnect = disconnect_st5481, diff --git a/trunk/drivers/isdn/hisax/teles_cs.c b/trunk/drivers/isdn/hisax/teles_cs.c index 4e5c14c7240e..0ddef1bf778b 100644 --- a/trunk/drivers/isdn/hisax/teles_cs.c +++ b/trunk/drivers/isdn/hisax/teles_cs.c @@ -77,6 +77,8 @@ module_param(protocol, int, 0); static void teles_cs_config(dev_link_t *link); static void teles_cs_release(dev_link_t *link); +static int teles_cs_event(event_t event, int priority, + event_callback_args_t *args); /* The attach() and detach() entry points are used to create and destroy @@ -84,7 +86,16 @@ static void teles_cs_release(dev_link_t *link); needed to manage one actual PCMCIA card. */ -static void teles_detach(struct pcmcia_device *p_dev); +static dev_link_t *teles_attach(void); +static void teles_detach(dev_link_t *); + +/* + The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ + +static dev_info_t dev_info = "teles_cs"; /* A linked list of "instances" of the teles_cs device. Each actual @@ -96,7 +107,18 @@ static void teles_detach(struct pcmcia_device *p_dev); device numbers are used to derive the corresponding array index. */ +static dev_link_t *dev_list = NULL; + /* + A dev_link_t structure has fields for most things that are needed + to keep track of a socket, but there will usually be some device + specific information that also needs to be kept track of. The + 'priv' pointer in a dev_link_t structure can be used to point to + a device-specific private data structure, like this. + + To simplify the data structure handling, we actually include the + dev_link_t structure in the device's private data structure. + A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be @@ -130,16 +152,18 @@ typedef struct local_info_t { ======================================================================*/ -static int teles_attach(struct pcmcia_device *p_dev) +static dev_link_t *teles_attach(void) { + client_reg_t client_reg; dev_link_t *link; local_info_t *local; + int ret; DEBUG(0, "teles_attach()\n"); /* Allocate space for private device-specific data */ local = kmalloc(sizeof(local_info_t), GFP_KERNEL); - if (!local) return -ENOMEM; + if (!local) return NULL; memset(local, 0, sizeof(local_info_t)); local->cardnr = -1; link = &local->link; link->priv = local; @@ -164,13 +188,20 @@ static int teles_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - teles_cs_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + teles_detach(link); + return NULL; + } - return 0; + return link; } /* teles_attach */ /*====================================================================== @@ -182,18 +213,32 @@ static int teles_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void teles_detach(struct pcmcia_device *p_dev) +static void teles_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; local_info_t *info = link->priv; + int ret; DEBUG(0, "teles_detach(0x%p)\n", link); - if (link->state & DEV_CONFIG) { - info->busy = 1; - teles_cs_release(link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + + if (link->state & DEV_CONFIG) + teles_cs_release(link); + + /* Break the link with Card Services */ + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); } + /* Unlink device structure and free it */ + *linkp = link->next; kfree(info); } /* teles_detach */ @@ -383,32 +428,60 @@ static void teles_cs_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } /* teles_cs_release */ -static int teles_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - local_info_t *dev = link->priv; +/*====================================================================== - link->state |= DEV_SUSPEND; - dev->busy = 1; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. - return 0; -} + When a CARD_REMOVAL event is received, we immediately set a flag + to block future accesses to this device. All the functions that + actually access the device should check this flag to make sure + the card is still present. -static int teles_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - local_info_t *dev = link->priv; +======================================================================*/ - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); - dev->busy = 0; +static int teles_cs_event(event_t event, int priority, + event_callback_args_t *args) +{ + dev_link_t *link = args->client_data; + local_info_t *dev = link->priv; - return 0; -} + DEBUG(1, "teles_cs_event(%d)\n", event); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + ((local_info_t*)link->priv)->busy = 1; + teles_cs_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + teles_cs_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + /* Mark the device as stopped, to block IO until later */ + dev->busy = 1; + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) + pcmcia_request_configuration(link->handle, &link->conf); + dev->busy = 0; + break; + } + return 0; +} /* teles_cs_event */ static struct pcmcia_device_id teles_ids[] = { PCMCIA_DEVICE_PROD_ID12("TELES", "S0/PC", 0x67b50eae, 0xe9e70119), @@ -421,11 +494,10 @@ static struct pcmcia_driver teles_cs_driver = { .drv = { .name = "teles_cs", }, - .probe = teles_attach, - .remove = teles_detach, + .attach = teles_attach, + .event = teles_cs_event, + .detach = teles_detach, .id_table = teles_ids, - .suspend = teles_suspend, - .resume = teles_resume, }; static int __init init_teles_cs(void) @@ -436,6 +508,7 @@ static int __init init_teles_cs(void) static void __exit exit_teles_cs(void) { pcmcia_unregister_driver(&teles_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_teles_cs); diff --git a/trunk/drivers/macintosh/macio_asic.c b/trunk/drivers/macintosh/macio_asic.c index 228e1852a836..c34c96d18907 100644 --- a/trunk/drivers/macintosh/macio_asic.c +++ b/trunk/drivers/macintosh/macio_asic.c @@ -128,7 +128,7 @@ static int macio_device_resume(struct device * dev) return 0; } -static int macio_uevent(struct device *dev, char **envp, int num_envp, +static int macio_hotplug (struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { struct macio_dev * macio_dev; @@ -203,7 +203,7 @@ extern struct device_attribute macio_dev_attrs[]; struct bus_type macio_bus_type = { .name = "macio", .match = macio_bus_match, - .uevent = macio_uevent, + .hotplug = macio_hotplug, .suspend = macio_device_suspend, .resume = macio_device_resume, .dev_attrs = macio_dev_attrs, diff --git a/trunk/drivers/md/.gitignore b/trunk/drivers/md/.gitignore deleted file mode 100644 index a7afec6b19c6..000000000000 --- a/trunk/drivers/md/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -mktables -raid6altivec*.c -raid6int*.c -raid6tables.c diff --git a/trunk/drivers/md/dm-table.c b/trunk/drivers/md/dm-table.c index a6f2dc66c3db..a6d3baa46f61 100644 --- a/trunk/drivers/md/dm-table.c +++ b/trunk/drivers/md/dm-table.c @@ -638,7 +638,7 @@ int dm_split_args(int *argc, char ***argvp, char *input) static void check_for_valid_limits(struct io_restrictions *rs) { if (!rs->max_sectors) - rs->max_sectors = SAFE_MAX_SECTORS; + rs->max_sectors = MAX_SECTORS; if (!rs->max_phys_segments) rs->max_phys_segments = MAX_PHYS_SEGMENTS; if (!rs->max_hw_segments) diff --git a/trunk/drivers/media/dvb/b2c2/flexcop-usb.c b/trunk/drivers/media/dvb/b2c2/flexcop-usb.c index a6c91db40ad6..0a78ba3737a5 100644 --- a/trunk/drivers/media/dvb/b2c2/flexcop-usb.c +++ b/trunk/drivers/media/dvb/b2c2/flexcop-usb.c @@ -544,6 +544,7 @@ static struct usb_device_id flexcop_usb_table [] = { /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver flexcop_usb_driver = { + .owner = THIS_MODULE, .name = "b2c2_flexcop_usb", .probe = flexcop_usb_probe, .disconnect = flexcop_usb_disconnect, diff --git a/trunk/drivers/media/dvb/cinergyT2/cinergyT2.c b/trunk/drivers/media/dvb/cinergyT2/cinergyT2.c index b996fb59b7e4..336fc284fa52 100644 --- a/trunk/drivers/media/dvb/cinergyT2/cinergyT2.c +++ b/trunk/drivers/media/dvb/cinergyT2/cinergyT2.c @@ -986,6 +986,7 @@ static const struct usb_device_id cinergyt2_table [] __devinitdata = { MODULE_DEVICE_TABLE(usb, cinergyt2_table); static struct usb_driver cinergyt2_driver = { + .owner = THIS_MODULE, .name = "cinergyT2", .probe = cinergyt2_probe, .disconnect = cinergyt2_disconnect, diff --git a/trunk/drivers/media/dvb/dvb-usb/a800.c b/trunk/drivers/media/dvb/dvb-usb/a800.c index ce44aa6bbb83..8c7beffb045f 100644 --- a/trunk/drivers/media/dvb/dvb-usb/a800.c +++ b/trunk/drivers/media/dvb/dvb-usb/a800.c @@ -144,6 +144,7 @@ static struct dvb_usb_properties a800_properties = { }; static struct usb_driver a800_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_a800", .probe = a800_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/cxusb.c b/trunk/drivers/media/dvb/dvb-usb/cxusb.c index d05fab01cccd..3fe383f4bb4c 100644 --- a/trunk/drivers/media/dvb/dvb-usb/cxusb.c +++ b/trunk/drivers/media/dvb/dvb-usb/cxusb.c @@ -241,6 +241,7 @@ static struct dvb_usb_properties cxusb_properties = { }; static struct usb_driver cxusb_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_cxusb", .probe = cxusb_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/dibusb-mb.c b/trunk/drivers/media/dvb/dvb-usb/dibusb-mb.c index 52ac3e5adf5d..aa271a2496d5 100644 --- a/trunk/drivers/media/dvb/dvb-usb/dibusb-mb.c +++ b/trunk/drivers/media/dvb/dvb-usb/dibusb-mb.c @@ -373,6 +373,7 @@ static struct dvb_usb_properties artec_t1_usb2_properties = { }; static struct usb_driver dibusb_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_dibusb_mb", .probe = dibusb_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/dibusb-mc.c b/trunk/drivers/media/dvb/dvb-usb/dibusb-mc.c index 55802fba3c29..6a0912eab396 100644 --- a/trunk/drivers/media/dvb/dvb-usb/dibusb-mc.c +++ b/trunk/drivers/media/dvb/dvb-usb/dibusb-mc.c @@ -82,6 +82,7 @@ static struct dvb_usb_properties dibusb_mc_properties = { }; static struct usb_driver dibusb_mc_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_dibusb_mc", .probe = dibusb_mc_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/digitv.c b/trunk/drivers/media/dvb/dvb-usb/digitv.c index 450417a9e64b..f98e306a5759 100644 --- a/trunk/drivers/media/dvb/dvb-usb/digitv.c +++ b/trunk/drivers/media/dvb/dvb-usb/digitv.c @@ -233,6 +233,7 @@ static struct dvb_usb_properties digitv_properties = { }; static struct usb_driver digitv_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_digitv", .probe = digitv_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/dtt200u.c b/trunk/drivers/media/dvb/dvb-usb/dtt200u.c index 6e2bac873445..b595476332cd 100644 --- a/trunk/drivers/media/dvb/dvb-usb/dtt200u.c +++ b/trunk/drivers/media/dvb/dvb-usb/dtt200u.c @@ -198,6 +198,7 @@ static struct dvb_usb_properties wt220u_properties = { /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver dtt200u_usb_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_dtt200u", .probe = dtt200u_usb_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/nova-t-usb2.c b/trunk/drivers/media/dvb/dvb-usb/nova-t-usb2.c index fac48fc7a4ac..1841a66427bf 100644 --- a/trunk/drivers/media/dvb/dvb-usb/nova-t-usb2.c +++ b/trunk/drivers/media/dvb/dvb-usb/nova-t-usb2.c @@ -202,6 +202,7 @@ static struct dvb_usb_properties nova_t_properties = { }; static struct usb_driver nova_t_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_nova_t_usb2", .probe = nova_t_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/umt-010.c b/trunk/drivers/media/dvb/dvb-usb/umt-010.c index 14f1911c79bb..6fd67657c269 100644 --- a/trunk/drivers/media/dvb/dvb-usb/umt-010.c +++ b/trunk/drivers/media/dvb/dvb-usb/umt-010.c @@ -128,6 +128,7 @@ static struct dvb_usb_properties umt_properties = { }; static struct usb_driver umt_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_umt_010", .probe = umt_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/vp702x.c b/trunk/drivers/media/dvb/dvb-usb/vp702x.c index afa00fdb5ec0..de13c04e8e64 100644 --- a/trunk/drivers/media/dvb/dvb-usb/vp702x.c +++ b/trunk/drivers/media/dvb/dvb-usb/vp702x.c @@ -256,6 +256,7 @@ static struct dvb_usb_properties vp702x_properties = { /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver vp702x_usb_driver = { + .owner = THIS_MODULE, .name = "dvb-usb-vp702x", .probe = vp702x_usb_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/dvb/dvb-usb/vp7045.c b/trunk/drivers/media/dvb/dvb-usb/vp7045.c index 3835235b68df..75765e3a569c 100644 --- a/trunk/drivers/media/dvb/dvb-usb/vp7045.c +++ b/trunk/drivers/media/dvb/dvb-usb/vp7045.c @@ -253,6 +253,7 @@ static struct dvb_usb_properties vp7045_properties = { /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver vp7045_usb_driver = { + .owner = THIS_MODULE, .name = "dvb_usb_vp7045", .probe = vp7045_usb_probe, .disconnect = dvb_usb_device_exit, diff --git a/trunk/drivers/media/video/cpia_usb.c b/trunk/drivers/media/video/cpia_usb.c index 1439cb752874..9774e94d1e7d 100644 --- a/trunk/drivers/media/video/cpia_usb.c +++ b/trunk/drivers/media/video/cpia_usb.c @@ -582,6 +582,7 @@ MODULE_LICENSE("GPL"); static struct usb_driver cpia_driver = { + .owner = THIS_MODULE, .name = "cpia", .probe = cpia_probe, .disconnect = cpia_disconnect, diff --git a/trunk/drivers/media/video/em28xx/em28xx-video.c b/trunk/drivers/media/video/em28xx/em28xx-video.c index 3a56120397ae..06d76879bde2 100644 --- a/trunk/drivers/media/video/em28xx/em28xx-video.c +++ b/trunk/drivers/media/video/em28xx/em28xx-video.c @@ -1884,6 +1884,7 @@ static void em28xx_usb_disconnect(struct usb_interface *interface) } static struct usb_driver em28xx_usb_driver = { + .owner = THIS_MODULE, .name = "em28xx", .probe = em28xx_usb_probe, .disconnect = em28xx_usb_disconnect, diff --git a/trunk/drivers/message/fusion/mptbase.c b/trunk/drivers/message/fusion/mptbase.c index 537836068c49..4262a22adc22 100644 --- a/trunk/drivers/message/fusion/mptbase.c +++ b/trunk/drivers/message/fusion/mptbase.c @@ -313,13 +313,13 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa) u32 log_info = le32_to_cpu(mr->u.reply.IOCLogInfo); if (ioc->bus_type == FC) mpt_fc_log_info(ioc, log_info); - else if (ioc->bus_type == SPI) + else if (ioc->bus_type == SCSI) mpt_sp_log_info(ioc, log_info); else if (ioc->bus_type == SAS) mpt_sas_log_info(ioc, log_info); } if (ioc_stat & MPI_IOCSTATUS_MASK) { - if (ioc->bus_type == SPI && + if (ioc->bus_type == SCSI && cb_idx != mpt_stm_index && cb_idx != mpt_lan_index) mpt_sp_ioc_info(ioc, (u32)ioc_stat, mf); @@ -1376,7 +1376,7 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id) } else if (pdev->device == MPI_MANUFACTPAGE_DEVID_53C1030) { ioc->prod_name = "LSI53C1030"; - ioc->bus_type = SPI; + ioc->bus_type = SCSI; /* 1030 Chip Fix. Disable Split transactions * for PCIX. Set MOST bits to zero if Rev < C0( = 8). */ @@ -1389,7 +1389,7 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id) } else if (pdev->device == MPI_MANUFACTPAGE_DEVID_1030_53C1035) { ioc->prod_name = "LSI53C1035"; - ioc->bus_type = SPI; + ioc->bus_type = SCSI; } else if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1064) { ioc->prod_name = "LSISAS1064"; @@ -3042,7 +3042,7 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag) /* Clear the internal flash bad bit - autoincrementing register, * so must do two writes. */ - if (ioc->bus_type == SPI) { + if (ioc->bus_type == SCSI) { /* * 1030 and 1035 H/W errata, workaround to access * the ClearFlashBadSignatureBit @@ -3152,7 +3152,7 @@ KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag) int cnt,cntdn; dinitprintk((KERN_WARNING MYNAM ": KickStarting %s!\n", ioc->name)); - if (ioc->bus_type == SPI) { + if (ioc->bus_type == SCSI) { /* Always issue a Msg Unit Reset first. This will clear some * SCSI bus hang conditions. */ @@ -3580,7 +3580,7 @@ initChainBuffers(MPT_ADAPTER *ioc) dinitprintk((KERN_INFO MYNAM ": %s Now numSGE=%d num_sge=%d num_chain=%d\n", ioc->name, numSGE, num_sge, num_chain)); - if (ioc->bus_type == SPI) + if (ioc->bus_type == SCSI) num_chain *= MPT_SCSI_CAN_QUEUE; else num_chain *= MPT_FC_CAN_QUEUE; diff --git a/trunk/drivers/message/fusion/mptbase.h b/trunk/drivers/message/fusion/mptbase.h index 6c48d1f54ac9..bac8eb4186d2 100644 --- a/trunk/drivers/message/fusion/mptbase.h +++ b/trunk/drivers/message/fusion/mptbase.h @@ -76,8 +76,8 @@ #define COPYRIGHT "Copyright (c) 1999-2005 " MODULEAUTHOR #endif -#define MPT_LINUX_VERSION_COMMON "3.03.05" -#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-3.03.05" +#define MPT_LINUX_VERSION_COMMON "3.03.04" +#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-3.03.04" #define WHAT_MAGIC_STRING "@" "(" "#" ")" #define show_mptmod_ver(s,ver) \ @@ -321,7 +321,7 @@ typedef struct _SYSIF_REGS * Dynamic Multi-Pathing specific stuff... */ -/* VirtTarget negoFlags field */ +/* VirtDevice negoFlags field */ #define MPT_TARGET_NO_NEGO_WIDE 0x01 #define MPT_TARGET_NO_NEGO_SYNC 0x02 #define MPT_TARGET_NO_NEGO_QAS 0x04 @@ -330,7 +330,8 @@ typedef struct _SYSIF_REGS /* * VirtDevice - FC LUN device or SCSI target device */ -typedef struct _VirtTarget { +typedef struct _VirtDevice { + struct scsi_device *device; u8 tflags; u8 ioc_id; u8 target_id; @@ -341,18 +342,21 @@ typedef struct _VirtTarget { u8 negoFlags; /* bit field, see above */ u8 raidVolume; /* set, if RAID Volume */ u8 type; /* byte 0 of Inquiry data */ + u8 cflags; /* controller flags */ + u8 rsvd1raid; + u16 fc_phys_lun; + u16 fc_xlat_lun; u32 num_luns; u32 luns[8]; /* Max LUNs is 256 */ + u8 pad[4]; u8 inq_data[8]; -} VirtTarget; - -typedef struct _VirtDevice { - VirtTarget *vtarget; - u8 ioc_id; - u8 bus_id; - u8 target_id; - u8 configured_lun; - u32 lun; + /* IEEE Registered Extended Identifier + obtained via INQUIRY VPD page 0x83 */ + /* NOTE: Do not separate uniq_prepad and uniq_data + as they are treateed as a single entity in the code */ + u8 uniq_prepad[8]; + u8 uniq_data[20]; + u8 pad2[4]; } VirtDevice; /* @@ -899,7 +903,7 @@ typedef struct _MPT_LOCAL_REPLY { typedef enum { FC, - SPI, + SCSI, SAS } BUS_TYPE; @@ -908,7 +912,7 @@ typedef struct _MPT_SCSI_HOST { int port; u32 pad0; struct scsi_cmnd **ScsiLookup; - VirtTarget **Targets; + VirtDevice **Targets; MPT_LOCAL_REPLY *pLocal; /* used for internal commands */ struct timer_list timer; /* Pool of memory for holding SCpnts before doing diff --git a/trunk/drivers/message/fusion/mptctl.c b/trunk/drivers/message/fusion/mptctl.c index 959d2c5951b8..602138f8544d 100644 --- a/trunk/drivers/message/fusion/mptctl.c +++ b/trunk/drivers/message/fusion/mptctl.c @@ -1245,7 +1245,7 @@ mptctl_gettargetinfo (unsigned long arg) MPT_ADAPTER *ioc; struct Scsi_Host *sh; MPT_SCSI_HOST *hd; - VirtTarget *vdev; + VirtDevice *vdev; char *pmem; int *pdata; IOCPage2_t *pIoc2; @@ -1822,7 +1822,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_command karg, void __user *mfPtr) case MPI_FUNCTION_SCSI_IO_REQUEST: if (ioc->sh) { SCSIIORequest_t *pScsiReq = (SCSIIORequest_t *) mf; - VirtTarget *pTarget = NULL; + VirtDevice *pTarget = NULL; MPT_SCSI_HOST *hd = NULL; int qtag = MPI_SCSIIO_CONTROL_UNTAGGED; int scsidir = 0; diff --git a/trunk/drivers/message/fusion/mptfc.c b/trunk/drivers/message/fusion/mptfc.c index ba61e1828858..a628be9bbbad 100644 --- a/trunk/drivers/message/fusion/mptfc.c +++ b/trunk/drivers/message/fusion/mptfc.c @@ -84,16 +84,13 @@ static int mptfcTaskCtx = -1; static int mptfcInternalCtx = -1; /* Used only for internal commands */ static struct scsi_host_template mptfc_driver_template = { - .module = THIS_MODULE, .proc_name = "mptfc", .proc_info = mptscsih_proc_info, .name = "MPT FC Host", .info = mptscsih_info, .queuecommand = mptscsih_qcmd, - .target_alloc = mptscsih_target_alloc, .slave_alloc = mptscsih_slave_alloc, .slave_configure = mptscsih_slave_configure, - .target_destroy = mptscsih_target_destroy, .slave_destroy = mptscsih_slave_destroy, .change_queue_depth = mptscsih_change_queue_depth, .eh_abort_handler = mptscsih_abort, @@ -170,15 +167,13 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id) printk(MYIOC_s_WARN_FMT "Skipping because it's not operational!\n", ioc->name); - error = -ENODEV; - goto out_mptfc_probe; + return -ENODEV; } if (!ioc->active) { printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", ioc->name); - error = -ENODEV; - goto out_mptfc_probe; + return -ENODEV; } /* Sanity check - ensure at least 1 port is INITIATOR capable @@ -203,8 +198,7 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id) printk(MYIOC_s_WARN_FMT "Unable to register controller with SCSI subsystem\n", ioc->name); - error = -1; - goto out_mptfc_probe; + return -1; } spin_lock_irqsave(&ioc->FreeQlock, flags); @@ -272,7 +266,7 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id) mem = kmalloc(sz, GFP_ATOMIC); if (mem == NULL) { error = -ENOMEM; - goto out_mptfc_probe; + goto mptfc_probe_failed; } memset(mem, 0, sz); @@ -290,14 +284,14 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id) mem = kmalloc(sz, GFP_ATOMIC); if (mem == NULL) { error = -ENOMEM; - goto out_mptfc_probe; + goto mptfc_probe_failed; } memset(mem, 0, sz); - hd->Targets = (VirtTarget **) mem; + hd->Targets = (VirtDevice **) mem; dprintk((KERN_INFO - " vdev @ %p, sz=%d\n", hd->Targets, sz)); + " Targets @ %p, sz=%d\n", hd->Targets, sz)); /* Clear the TM flags */ @@ -336,13 +330,13 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id) if(error) { dprintk((KERN_ERR MYNAM "scsi_add_host failed\n")); - goto out_mptfc_probe; + goto mptfc_probe_failed; } scsi_scan_host(sh); return 0; -out_mptfc_probe: +mptfc_probe_failed: mptscsih_remove(pdev); return error; diff --git a/trunk/drivers/message/fusion/mptsas.c b/trunk/drivers/message/fusion/mptsas.c index 17e9757e728b..e0a8bb8ba7d8 100644 --- a/trunk/drivers/message/fusion/mptsas.c +++ b/trunk/drivers/message/fusion/mptsas.c @@ -228,35 +228,31 @@ static void mptsas_print_expander_pg1(SasExpanderPage1_t *pg1) * implement ->target_alloc. */ static int -mptsas_slave_alloc(struct scsi_device *sdev) +mptsas_slave_alloc(struct scsi_device *device) { - struct Scsi_Host *host = sdev->host; + struct Scsi_Host *host = device->host; MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; struct sas_rphy *rphy; struct mptsas_portinfo *p; - VirtTarget *vtarget; VirtDevice *vdev; - struct scsi_target *starget; + uint target = device->id; int i; + if ((vdev = hd->Targets[target]) != NULL) + goto out; + vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL); if (!vdev) { printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n", hd->ioc->name, sizeof(VirtDevice)); return -ENOMEM; } + memset(vdev, 0, sizeof(VirtDevice)); + vdev->tflags = MPT_TARGET_FLAGS_Q_YES|MPT_TARGET_FLAGS_VALID_INQUIRY; vdev->ioc_id = hd->ioc->id; - sdev->hostdata = vdev; - starget = scsi_target(sdev); - vtarget = starget->hostdata; - vdev->vtarget = vtarget; - if (vtarget->num_luns == 0) { - vtarget->tflags = MPT_TARGET_FLAGS_Q_YES|MPT_TARGET_FLAGS_VALID_INQUIRY; - hd->Targets[sdev->id] = vtarget; - } - rphy = dev_to_rphy(sdev->sdev_target->dev.parent); + rphy = dev_to_rphy(device->sdev_target->dev.parent); list_for_each_entry(p, &hd->ioc->sas_topology, list) { for (i = 0; i < p->num_phys; i++) { if (p->phy_info[i].attached.sas_address == @@ -264,7 +260,7 @@ mptsas_slave_alloc(struct scsi_device *sdev) vdev->target_id = p->phy_info[i].attached.target; vdev->bus_id = p->phy_info[i].attached.bus; - vdev->lun = sdev->lun; + hd->Targets[device->id] = vdev; goto out; } } @@ -275,24 +271,19 @@ mptsas_slave_alloc(struct scsi_device *sdev) return -ENODEV; out: - vtarget->ioc_id = vdev->ioc_id; - vtarget->target_id = vdev->target_id; - vtarget->bus_id = vdev->bus_id; - vtarget->num_luns++; + vdev->num_luns++; + device->hostdata = vdev; return 0; } static struct scsi_host_template mptsas_driver_template = { - .module = THIS_MODULE, .proc_name = "mptsas", .proc_info = mptscsih_proc_info, .name = "MPT SPI Host", .info = mptscsih_info, .queuecommand = mptscsih_qcmd, - .target_alloc = mptscsih_target_alloc, .slave_alloc = mptsas_slave_alloc, .slave_configure = mptscsih_slave_configure, - .target_destroy = mptscsih_target_destroy, .slave_destroy = mptscsih_slave_destroy, .change_queue_depth = mptscsih_change_queue_depth, .eh_abort_handler = mptscsih_abort, @@ -995,6 +986,7 @@ mptsas_probe_hba_phys(MPT_ADAPTER *ioc, int *index) goto out_free_port_info; list_add_tail(&port_info->list, &ioc->sas_topology); + for (i = 0; i < port_info->num_phys; i++) { mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i], (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER << @@ -1141,15 +1133,13 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) printk(MYIOC_s_WARN_FMT "Skipping because it's not operational!\n", ioc->name); - error = -ENODEV; - goto out_mptsas_probe; + return -ENODEV; } if (!ioc->active) { printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", ioc->name); - error = -ENODEV; - goto out_mptsas_probe; + return -ENODEV; } /* Sanity check - ensure at least 1 port is INITIATOR capable @@ -1173,8 +1163,7 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) printk(MYIOC_s_WARN_FMT "Unable to register controller with SCSI subsystem\n", ioc->name); - error = -1; - goto out_mptsas_probe; + return -1; } spin_lock_irqsave(&ioc->FreeQlock, flags); @@ -1248,7 +1237,7 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) mem = kmalloc(sz, GFP_ATOMIC); if (mem == NULL) { error = -ENOMEM; - goto out_mptsas_probe; + goto mptsas_probe_failed; } memset(mem, 0, sz); @@ -1266,14 +1255,14 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) mem = kmalloc(sz, GFP_ATOMIC); if (mem == NULL) { error = -ENOMEM; - goto out_mptsas_probe; + goto mptsas_probe_failed; } memset(mem, 0, sz); - hd->Targets = (VirtTarget **) mem; + hd->Targets = (VirtDevice **) mem; dprintk((KERN_INFO - " vtarget @ %p, sz=%d\n", hd->Targets, sz)); + " Targets @ %p, sz=%d\n", hd->Targets, sz)); /* Clear the TM flags */ @@ -1319,14 +1308,14 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) if (error) { dprintk((KERN_ERR MYNAM "scsi_add_host failed\n")); - goto out_mptsas_probe; + goto mptsas_probe_failed; } mptsas_scan_sas_topology(ioc); return 0; -out_mptsas_probe: +mptsas_probe_failed: mptscsih_remove(pdev); return error; diff --git a/trunk/drivers/message/fusion/mptscsih.c b/trunk/drivers/message/fusion/mptscsih.c index 93a16fa3c4ba..b7b9846ff3fd 100644 --- a/trunk/drivers/message/fusion/mptscsih.c +++ b/trunk/drivers/message/fusion/mptscsih.c @@ -150,29 +150,28 @@ static int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 tar int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset); int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply); -static void mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, u8 lun, char *data, int dlen); -static void mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *vtarget, char byte56); +static void mptscsih_initTarget(MPT_SCSI_HOST *hd, int bus_id, int target_id, u8 lun, char *data, int dlen); +static void mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtDevice *target, char byte56); +static void mptscsih_set_dvflags(MPT_SCSI_HOST *hd, SCSIIORequest_t *pReq); static void mptscsih_setDevicePage1Flags (u8 width, u8 factor, u8 offset, int *requestedPtr, int *configurationPtr, u8 flags); -static void mptscsih_no_negotiate(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc); +static void mptscsih_no_negotiate(MPT_SCSI_HOST *hd, int target_id); static int mptscsih_writeSDP1(MPT_SCSI_HOST *hd, int portnum, int target, int flags); static int mptscsih_writeIOCPage4(MPT_SCSI_HOST *hd, int target_id, int bus); int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r); static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd); -static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice); -static void mptscsih_negotiate_to_asyn_narrow(MPT_SCSI_HOST *hd, VirtTarget *vtarget); -static int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id); +static int mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, int portnum); static struct work_struct mptscsih_persistTask; #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION static int mptscsih_do_raid(MPT_SCSI_HOST *hd, u8 action, INTERNAL_CMD *io); static void mptscsih_domainValidation(void *hd); +static int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id); static void mptscsih_qas_check(MPT_SCSI_HOST *hd, int id); static int mptscsih_doDv(MPT_SCSI_HOST *hd, int channel, int target); static void mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage); static void mptscsih_fillbuf(char *buffer, int size, int index, int width); static void mptscsih_set_dvflags_raid(MPT_SCSI_HOST *hd, int id); -static void mptscsih_set_dvflags(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc); #endif void mptscsih_remove(struct pci_dev *); @@ -628,7 +627,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) dreplyprintk((KERN_NOTICE "Reply ha=%d id=%d lun=%d:\n" "IOCStatus=%04xh SCSIState=%02xh SCSIStatus=%02xh\n" "resid=%d bufflen=%d xfer_cnt=%d\n", - ioc->id, sc->device->id, sc->device->lun, + ioc->id, pScsiReq->TargetID, pScsiReq->LUN[1], status, scsi_state, scsi_status, sc->resid, sc->request_bufflen, xfer_cnt)); @@ -642,7 +641,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) pScsiReply->ResponseInfo) { printk(KERN_NOTICE "ha=%d id=%d lun=%d: " "FCP_ResponseInfo=%08xh\n", - ioc->id, sc->device->id, sc->device->lun, + ioc->id, pScsiReq->TargetID, pScsiReq->LUN[1], le32_to_cpu(pScsiReply->ResponseInfo)); } @@ -678,8 +677,8 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) sc->result = DID_RESET << 16; /* GEM Workaround. */ - if (ioc->bus_type == SPI) - mptscsih_no_negotiate(hd, sc); + if (ioc->bus_type == SCSI) + mptscsih_no_negotiate(hd, sc->device->id); break; case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */ @@ -893,15 +892,16 @@ mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd) * when a lun is disable by mid-layer. * Do NOT access the referenced scsi_cmnd structure or * members. Will cause either a paging or NULL ptr error. - * @hd: Pointer to a SCSI HOST structure - * @vdevice: per device private data + * @hd: Pointer to a SCSI HOST structure + * @target: target id + * @lun: lun * * Returns: None. * * Called from slave_destroy. */ static void -mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice) +mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, uint target, uint lun) { SCSIIORequest_t *mf = NULL; int ii; @@ -909,7 +909,7 @@ mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice) struct scsi_cmnd *sc; dsprintk((KERN_INFO MYNAM ": search_running target %d lun %d max %d\n", - vdevice->target_id, vdevice->lun, max)); + target, lun, max)); for (ii=0; ii < max; ii++) { if ((sc = hd->ScsiLookup[ii]) != NULL) { @@ -919,7 +919,7 @@ mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice) dsprintk(( "search_running: found (sc=%p, mf = %p) target %d, lun %d \n", hd->ScsiLookup[ii], mf, mf->TargetID, mf->LUN[1])); - if ((mf->TargetID != ((u8)vdevice->target_id)) || (mf->LUN[1] != ((u8) vdevice->lun))) + if ((mf->TargetID != ((u8)target)) || (mf->LUN[1] != ((u8) lun))) continue; /* Cleanup @@ -993,10 +993,8 @@ mptscsih_remove(struct pci_dev *pdev) MPT_ADAPTER *ioc = pci_get_drvdata(pdev); struct Scsi_Host *host = ioc->sh; MPT_SCSI_HOST *hd; -#ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION int count; unsigned long flags; -#endif int sz1; if(!host) { @@ -1077,6 +1075,11 @@ mptscsih_shutdown(struct pci_dev *pdev) hd = (MPT_SCSI_HOST *)host->hostdata; + /* Flush the cache of this adapter + */ + if(hd != NULL) + mptscsih_synchronize_cache(hd, 0); + } #ifdef CONFIG_PM @@ -1283,7 +1286,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) MPT_SCSI_HOST *hd; MPT_FRAME_HDR *mf; SCSIIORequest_t *pScsiReq; - VirtDevice *vdev = SCpnt->device->hostdata; + VirtDevice *pTarget = SCpnt->device->hostdata; int lun; u32 datalen; u32 scsictl; @@ -1338,8 +1341,8 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) /* Default to untagged. Once a target structure has been allocated, * use the Inquiry data to determine if device supports tagged. */ - if (vdev - && (vdev->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES) + if (pTarget + && (pTarget->tflags & MPT_TARGET_FLAGS_Q_YES) && (SCpnt->device->tagged_supported)) { scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ; } else { @@ -1348,8 +1351,8 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) /* Use the above information to set up the message frame */ - pScsiReq->TargetID = (u8) vdev->target_id; - pScsiReq->Bus = vdev->bus_id; + pScsiReq->TargetID = (u8) pTarget->target_id; + pScsiReq->Bus = pTarget->bus_id; pScsiReq->ChainOffset = 0; pScsiReq->Function = MPI_FUNCTION_SCSI_IO_REQUEST; pScsiReq->CDBLength = SCpnt->cmd_len; @@ -1400,8 +1403,8 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) SCpnt->host_scribble = NULL; #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION - if (hd->ioc->bus_type == SPI) { - int dvStatus = hd->ioc->spi_data.dvStatus[vdev->target_id]; + if (hd->ioc->bus_type == SCSI) { + int dvStatus = hd->ioc->spi_data.dvStatus[pTarget->target_id]; int issueCmd = 1; if (dvStatus || hd->ioc->spi_data.forceDv) { @@ -1434,7 +1437,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) /* Set the DV flags. */ if (dvStatus & MPT_SCSICFG_DV_NOT_DONE) - mptscsih_set_dvflags(hd, SCpnt); + mptscsih_set_dvflags(hd, pScsiReq); if (!issueCmd) goto fail; @@ -1738,7 +1741,6 @@ mptscsih_abort(struct scsi_cmnd * SCpnt) u32 ctx2abort; int scpnt_idx; int retval; - VirtDevice *vdev; /* If we can't locate our host adapter structure, return FAILED status. */ @@ -1788,9 +1790,8 @@ mptscsih_abort(struct scsi_cmnd * SCpnt) hd->abortSCpnt = SCpnt; - vdev = SCpnt->device->hostdata; retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK, - vdev->bus_id, vdev->target_id, vdev->lun, + SCpnt->device->channel, SCpnt->device->id, SCpnt->device->lun, ctx2abort, 2 /* 2 second timeout */); printk (KERN_WARNING MYNAM ": %s: task abort: %s (sc=%p)\n", @@ -1821,7 +1822,6 @@ mptscsih_dev_reset(struct scsi_cmnd * SCpnt) { MPT_SCSI_HOST *hd; int retval; - VirtDevice *vdev; /* If we can't locate our host adapter structure, return FAILED status. */ @@ -1839,9 +1839,8 @@ mptscsih_dev_reset(struct scsi_cmnd * SCpnt) hd->ioc->name, SCpnt); scsi_print_command(SCpnt); - vdev = SCpnt->device->hostdata; retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, - vdev->bus_id, vdev->target_id, + SCpnt->device->channel, SCpnt->device->id, 0, 0, 5 /* 5 second timeout */); printk (KERN_WARNING MYNAM ": %s: target reset: %s (sc=%p)\n", @@ -1872,7 +1871,6 @@ mptscsih_bus_reset(struct scsi_cmnd * SCpnt) { MPT_SCSI_HOST *hd; int retval; - VirtDevice *vdev; /* If we can't locate our host adapter structure, return FAILED status. */ @@ -1890,9 +1888,8 @@ mptscsih_bus_reset(struct scsi_cmnd * SCpnt) if (hd->timeouts < -1) hd->timeouts++; - vdev = SCpnt->device->hostdata; retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, - vdev->bus_id, 0, 0, 0, 5 /* 5 second timeout */); + SCpnt->device->channel, 0, 0, 0, 5 /* 5 second timeout */); printk (KERN_WARNING MYNAM ": %s: bus reset: %s (sc=%p)\n", hd->ioc->name, @@ -2151,39 +2148,26 @@ mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev, return 0; } -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ -/* - * OS entry point to allow host driver to alloc memory - * for each scsi target. Called once per device the bus scan. - * Return non-zero if allocation fails. - */ -int -mptscsih_target_alloc(struct scsi_target *starget) -{ - VirtTarget *vtarget; - - vtarget = kmalloc(sizeof(VirtTarget), GFP_KERNEL); - if (!vtarget) - return -ENOMEM; - memset(vtarget, 0, sizeof(VirtTarget)); - starget->hostdata = vtarget; - return 0; -} - /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ /* * OS entry point to allow host driver to alloc memory * for each scsi device. Called once per device the bus scan. * Return non-zero if allocation fails. + * Init memory once per id (not LUN). */ int -mptscsih_slave_alloc(struct scsi_device *sdev) +mptscsih_slave_alloc(struct scsi_device *device) { - struct Scsi_Host *host = sdev->host; + struct Scsi_Host *host = device->host; MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; - VirtTarget *vtarget; VirtDevice *vdev; - struct scsi_target *starget; + uint target = device->id; + + if (hd == NULL) + return -ENODEV; + + if ((vdev = hd->Targets[target]) != NULL) + goto out; vdev = kmalloc(sizeof(VirtDevice), GFP_KERNEL); if (!vdev) { @@ -2193,46 +2177,26 @@ mptscsih_slave_alloc(struct scsi_device *sdev) } memset(vdev, 0, sizeof(VirtDevice)); + vdev->tflags = MPT_TARGET_FLAGS_Q_YES; vdev->ioc_id = hd->ioc->id; - vdev->target_id = sdev->id; - vdev->bus_id = sdev->channel; - vdev->lun = sdev->lun; - sdev->hostdata = vdev; - - starget = scsi_target(sdev); - vtarget = starget->hostdata; - vdev->vtarget = vtarget; - - if (vtarget->num_luns == 0) { - hd->Targets[sdev->id] = vtarget; - vtarget->ioc_id = hd->ioc->id; - vtarget->tflags = MPT_TARGET_FLAGS_Q_YES; - vtarget->target_id = sdev->id; - vtarget->bus_id = sdev->channel; - if (hd->ioc->bus_type == SPI) { - if (hd->ioc->raid_data.isRaid & (1 << sdev->id)) { - vtarget->raidVolume = 1; - ddvtprintk((KERN_INFO - "RAID Volume @ id %d\n", sdev->id)); - } - } else { - vtarget->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; + vdev->target_id = device->id; + vdev->bus_id = device->channel; + vdev->raidVolume = 0; + hd->Targets[device->id] = vdev; + if (hd->ioc->bus_type == SCSI) { + if (hd->ioc->raid_data.isRaid & (1 << device->id)) { + vdev->raidVolume = 1; + ddvtprintk((KERN_INFO + "RAID Volume @ id %d\n", device->id)); } + } else { + vdev->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; } - vtarget->num_luns++; - return 0; -} -/* - * OS entry point to allow for host driver to free allocated memory - * Called if no device present or device being unloaded - */ -void -mptscsih_target_destroy(struct scsi_target *starget) -{ - if (starget->hostdata) - kfree(starget->hostdata); - starget->hostdata = NULL; + out: + vdev->num_luns++; + device->hostdata = vdev; + return 0; } /* @@ -2240,40 +2204,40 @@ mptscsih_target_destroy(struct scsi_target *starget) * Called if no device present or device being unloaded */ void -mptscsih_slave_destroy(struct scsi_device *sdev) +mptscsih_slave_destroy(struct scsi_device *device) { - struct Scsi_Host *host = sdev->host; + struct Scsi_Host *host = device->host; MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; - VirtTarget *vtarget; - VirtDevice *vdevice; - struct scsi_target *starget; - - starget = scsi_target(sdev); - vtarget = starget->hostdata; - vdevice = sdev->hostdata; - - mptscsih_search_running_cmds(hd, vdevice); - vtarget->luns[0] &= ~(1 << vdevice->lun); - vtarget->num_luns--; - if (vtarget->num_luns == 0) { - mptscsih_negotiate_to_asyn_narrow(hd, vtarget); - if (hd->ioc->bus_type == SPI) { - if (mptscsih_is_phys_disk(hd->ioc, vtarget->target_id)) { - hd->ioc->spi_data.forceDv |= MPT_SCSICFG_RELOAD_IOC_PG3; - } else { - hd->ioc->spi_data.dvStatus[vtarget->target_id] = - MPT_SCSICFG_NEGOTIATE; - if (!hd->negoNvram) { - hd->ioc->spi_data.dvStatus[vtarget->target_id] |= - MPT_SCSICFG_DV_NOT_DONE; - } + VirtDevice *vdev; + uint target = device->id; + uint lun = device->lun; + + if (hd == NULL) + return; + + mptscsih_search_running_cmds(hd, target, lun); + + vdev = hd->Targets[target]; + vdev->luns[0] &= ~(1 << lun); + if (--vdev->num_luns) + return; + + kfree(hd->Targets[target]); + hd->Targets[target] = NULL; + + if (hd->ioc->bus_type == SCSI) { + if (mptscsih_is_phys_disk(hd->ioc, target)) { + hd->ioc->spi_data.forceDv |= MPT_SCSICFG_RELOAD_IOC_PG3; + } else { + hd->ioc->spi_data.dvStatus[target] = + MPT_SCSICFG_NEGOTIATE; + + if (!hd->negoNvram) { + hd->ioc->spi_data.dvStatus[target] |= + MPT_SCSICFG_DV_NOT_DONE; } } - hd->Targets[sdev->id] = NULL; } - mptscsih_synchronize_cache(hd, vdevice); - kfree(vdevice); - sdev->hostdata = NULL; } /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ @@ -2287,21 +2251,22 @@ mptscsih_slave_destroy(struct scsi_device *sdev) int mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth) { - MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata; - VirtTarget *vtarget; - struct scsi_target *starget; - int max_depth; - int tagged; - - starget = scsi_target(sdev); - vtarget = starget->hostdata; - - if (hd->ioc->bus_type == SPI) { - if (vtarget->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY) { - if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)) + MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata; + VirtDevice *pTarget; + int max_depth; + int tagged; + + if (hd == NULL) + return 0; + if (!(pTarget = hd->Targets[sdev->id])) + return 0; + + if (hd->ioc->bus_type == SCSI) { + if (pTarget->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY) { + if (!(pTarget->tflags & MPT_TARGET_FLAGS_Q_YES)) max_depth = 1; - else if (((vtarget->inq_data[0] & 0x1f) == 0x00) && - (vtarget->minSyncFactor <= MPT_ULTRA160 )) + else if (((pTarget->inq_data[0] & 0x1f) == 0x00) && + (pTarget->minSyncFactor <= MPT_ULTRA160 )) max_depth = MPT_SCSI_CMD_PER_DEV_HIGH; else max_depth = MPT_SCSI_CMD_PER_DEV_LOW; @@ -2330,58 +2295,64 @@ mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth) * Return non-zero if fails. */ int -mptscsih_slave_configure(struct scsi_device *sdev) +mptscsih_slave_configure(struct scsi_device *device) { - struct Scsi_Host *sh = sdev->host; - VirtTarget *vtarget; - VirtDevice *vdevice; - struct scsi_target *starget; + struct Scsi_Host *sh = device->host; + VirtDevice *pTarget; MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sh->hostdata; - int indexed_lun, lun_index; - starget = scsi_target(sdev); - vtarget = starget->hostdata; - vdevice = sdev->hostdata; + if ((hd == NULL) || (hd->Targets == NULL)) { + return 0; + } dsprintk((MYIOC_s_INFO_FMT "device @ %p, id=%d, LUN=%d, channel=%d\n", - hd->ioc->name, sdev, sdev->id, sdev->lun, sdev->channel)); - if (hd->ioc->bus_type == SPI) - dsprintk((MYIOC_s_INFO_FMT - "sdtr %d wdtr %d ppr %d inq length=%d\n", - hd->ioc->name, sdev->sdtr, sdev->wdtr, - sdev->ppr, sdev->inquiry_len)); - - if (sdev->id > sh->max_id) { + hd->ioc->name, device, device->id, device->lun, device->channel)); + dsprintk((MYIOC_s_INFO_FMT + "sdtr %d wdtr %d ppr %d inq length=%d\n", + hd->ioc->name, device->sdtr, device->wdtr, + device->ppr, device->inquiry_len)); + + if (device->id > sh->max_id) { /* error case, should never happen */ - scsi_adjust_queue_depth(sdev, 0, 1); + scsi_adjust_queue_depth(device, 0, 1); + goto slave_configure_exit; + } + + pTarget = hd->Targets[device->id]; + + if (pTarget == NULL) { + /* Driver doesn't know about this device. + * Kernel may generate a "Dummy Lun 0" which + * may become a real Lun if a + * "scsi add-single-device" command is executed + * while the driver is active (hot-plug a + * device). LSI Raid controllers need + * queue_depth set to DEV_HIGH for this reason. + */ + scsi_adjust_queue_depth(device, MSG_SIMPLE_TAG, + MPT_SCSI_CMD_PER_DEV_HIGH); goto slave_configure_exit; } - vdevice->configured_lun=1; - lun_index = (vdevice->lun >> 5); /* 32 luns per lun_index */ - indexed_lun = (vdevice->lun % 32); - vtarget->luns[lun_index] |= (1 << indexed_lun); - mptscsih_initTarget(hd, vtarget, sdev->lun, sdev->inquiry, - sdev->inquiry_len ); - mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH); + mptscsih_initTarget(hd, device->channel, device->id, device->lun, + device->inquiry, device->inquiry_len ); + mptscsih_change_queue_depth(device, MPT_SCSI_CMD_PER_DEV_HIGH); dsprintk((MYIOC_s_INFO_FMT "Queue depth=%d, tflags=%x\n", - hd->ioc->name, sdev->queue_depth, vtarget->tflags)); + hd->ioc->name, device->queue_depth, pTarget->tflags)); - if (hd->ioc->bus_type == SPI) - dsprintk((MYIOC_s_INFO_FMT - "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n", - hd->ioc->name, vtarget->negoFlags, vtarget->maxOffset, - vtarget->minSyncFactor)); + dsprintk((MYIOC_s_INFO_FMT + "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n", + hd->ioc->name, pTarget->negoFlags, pTarget->maxOffset, pTarget->minSyncFactor)); slave_configure_exit: dsprintk((MYIOC_s_INFO_FMT "tagged %d, simple %d, ordered %d\n", - hd->ioc->name,sdev->tagged_supported, sdev->simple_tags, - sdev->ordered_tags)); + hd->ioc->name,device->tagged_supported, device->simple_tags, + device->ordered_tags)); return 0; } @@ -2399,14 +2370,16 @@ mptscsih_slave_configure(struct scsi_device *sdev) static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply) { - VirtDevice *vdev; + VirtDevice *target; SCSIIORequest_t *pReq; u32 sense_count = le32_to_cpu(pScsiReply->SenseCount); + int index; /* Get target structure */ pReq = (SCSIIORequest_t *) mf; - vdev = sc->device->hostdata; + index = (int) pReq->TargetID; + target = hd->Targets[index]; if (sense_count) { u8 *sense_data; @@ -2420,7 +2393,7 @@ mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR /* Log SMART data (asc = 0x5D, non-IM case only) if required. */ if ((hd->ioc->events) && (hd->ioc->eventTypes & (1 << MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE))) { - if ((sense_data[12] == 0x5D) && (vdev->vtarget->raidVolume == 0)) { + if ((sense_data[12] == 0x5D) && (target->raidVolume == 0)) { int idx; MPT_ADAPTER *ioc = hd->ioc; @@ -2430,7 +2403,7 @@ mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR ioc->events[idx].data[0] = (pReq->LUN[1] << 24) || (MPI_EVENT_SCSI_DEV_STAT_RC_SMART_DATA << 16) || - (sc->device->channel << 8) || sc->device->id; + (pReq->Bus << 8) || pReq->TargetID; ioc->events[idx].data[1] = (sense_data[13] << 8) || sense_data[12]; @@ -2530,9 +2503,9 @@ mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) /* 2. Chain Buffer initialization */ - /* 4. Renegotiate to all devices, if SPI + /* 4. Renegotiate to all devices, if SCSI */ - if (ioc->bus_type == SPI) { + if (ioc->bus_type == SCSI) { dnegoprintk(("writeSDP1: ALL_IDS USE_NVRAM\n")); mptscsih_writeSDP1(hd, 0, 0, MPT_SCSICFG_ALL_IDS | MPT_SCSICFG_USE_NVRAM); } @@ -2561,7 +2534,7 @@ mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) /* 7. Set flag to force DV and re-read IOC Page 3 */ - if (ioc->bus_type == SPI) { + if (ioc->bus_type == SCSI) { ioc->spi_data.forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3; ddvtprintk(("Set reload IOC Pg3 Flag\n")); } @@ -2603,7 +2576,7 @@ mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) break; case MPI_EVENT_IOC_BUS_RESET: /* 04 */ case MPI_EVENT_EXT_BUS_RESET: /* 05 */ - if (hd && (ioc->bus_type == SPI) && (hd->soft_resets < -1)) + if (hd && (ioc->bus_type == SCSI) && (hd->soft_resets < -1)) hd->soft_resets++; break; case MPI_EVENT_LOGOUT: /* 09 */ @@ -2624,11 +2597,11 @@ mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) case MPI_EVENT_INTEGRATED_RAID: /* 0B */ { -#ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION pMpiEventDataRaid_t pRaidEventData = (pMpiEventDataRaid_t) pEvReply->Data; +#ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION /* Domain Validation Needed */ - if (ioc->bus_type == SPI && + if (ioc->bus_type == SCSI && pRaidEventData->ReasonCode == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) mptscsih_set_dvflags_raid(hd, pRaidEventData->PhysDiskNum); @@ -2659,7 +2632,8 @@ mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) /* * mptscsih_initTarget - Target, LUN alloc/free functionality. * @hd: Pointer to MPT_SCSI_HOST structure - * @vtarget: per target private data + * @bus_id: Bus number (?) + * @target_id: SCSI target id * @lun: SCSI LUN id * @data: Pointer to data * @dlen: Number of INQUIRY bytes @@ -2672,14 +2646,15 @@ mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) * */ static void -mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, u8 lun, char *data, int dlen) +mptscsih_initTarget(MPT_SCSI_HOST *hd, int bus_id, int target_id, u8 lun, char *data, int dlen) { + int indexed_lun, lun_index; + VirtDevice *vdev; SpiCfgData *pSpi; char data_56; - int inq_len; dinitprintk((MYIOC_s_INFO_FMT "initTarget bus=%d id=%d lun=%d hd=%p\n", - hd->ioc->name, vtarget->bus_id, vtarget->target_id, lun, hd)); + hd->ioc->name, bus_id, target_id, lun, hd)); /* * If the peripheral qualifier filter is enabled then if the target reports a 0x1 @@ -2699,68 +2674,75 @@ mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, u8 lun, char *data, if (data[0] & 0xe0) return; - if (vtarget == NULL) - return; - - if (data) - vtarget->type = data[0]; - - if (hd->ioc->bus_type != SPI) + if ((vdev = hd->Targets[target_id]) == NULL) { return; + } - if ((data[0] == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) { - /* Treat all Processors as SAF-TE if - * command line option is set */ - vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; - mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id); - }else if ((data[0] == TYPE_PROCESSOR) && - !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) { - if ( dlen > 49 ) { - vtarget->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; - if ( data[44] == 'S' && - data[45] == 'A' && - data[46] == 'F' && - data[47] == '-' && - data[48] == 'T' && - data[49] == 'E' ) { - vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; - mptscsih_writeIOCPage4(hd, vtarget->target_id, vtarget->bus_id); + lun_index = (lun >> 5); /* 32 luns per lun_index */ + indexed_lun = (lun % 32); + vdev->luns[lun_index] |= (1 << indexed_lun); + + if (hd->ioc->bus_type == SCSI) { + if ((data[0] == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) { + /* Treat all Processors as SAF-TE if + * command line option is set */ + vdev->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; + mptscsih_writeIOCPage4(hd, target_id, bus_id); + }else if ((data[0] == TYPE_PROCESSOR) && + !(vdev->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) { + if ( dlen > 49 ) { + vdev->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; + if ( data[44] == 'S' && + data[45] == 'A' && + data[46] == 'F' && + data[47] == '-' && + data[48] == 'T' && + data[49] == 'E' ) { + vdev->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED; + mptscsih_writeIOCPage4(hd, target_id, bus_id); + } } } - } - if (!(vtarget->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY)) { - inq_len = dlen < 8 ? dlen : 8; - memcpy (vtarget->inq_data, data, inq_len); - /* If have not done DV, set the DV flag. - */ - pSpi = &hd->ioc->spi_data; - if ((data[0] == TYPE_TAPE) || (data[0] == TYPE_PROCESSOR)) { - if (pSpi->dvStatus[vtarget->target_id] & MPT_SCSICFG_DV_NOT_DONE) - pSpi->dvStatus[vtarget->target_id] |= MPT_SCSICFG_NEED_DV; - } - vtarget->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; + if (!(vdev->tflags & MPT_TARGET_FLAGS_VALID_INQUIRY)) { + if ( dlen > 8 ) { + memcpy (vdev->inq_data, data, 8); + } else { + memcpy (vdev->inq_data, data, dlen); + } - data_56 = 0x0F; /* Default to full capabilities if Inq data length is < 57 */ - if (dlen > 56) { - if ( (!(vtarget->tflags & MPT_TARGET_FLAGS_VALID_56))) { - /* Update the target capabilities + /* If have not done DV, set the DV flag. */ - data_56 = data[56]; - vtarget->tflags |= MPT_TARGET_FLAGS_VALID_56; + pSpi = &hd->ioc->spi_data; + if ((data[0] == TYPE_TAPE) || (data[0] == TYPE_PROCESSOR)) { + if (pSpi->dvStatus[target_id] & MPT_SCSICFG_DV_NOT_DONE) + pSpi->dvStatus[target_id] |= MPT_SCSICFG_NEED_DV; } - } - mptscsih_setTargetNegoParms(hd, vtarget, data_56); - } else { - /* Initial Inquiry may not request enough data bytes to - * obtain byte 57. DV will; if target doesn't return - * at least 57 bytes, data[56] will be zero. */ - if (dlen > 56) { - if ( (!(vtarget->tflags & MPT_TARGET_FLAGS_VALID_56))) { - /* Update the target capabilities - */ - data_56 = data[56]; - vtarget->tflags |= MPT_TARGET_FLAGS_VALID_56; - mptscsih_setTargetNegoParms(hd, vtarget, data_56); + + vdev->tflags |= MPT_TARGET_FLAGS_VALID_INQUIRY; + + + data_56 = 0x0F; /* Default to full capabilities if Inq data length is < 57 */ + if (dlen > 56) { + if ( (!(vdev->tflags & MPT_TARGET_FLAGS_VALID_56))) { + /* Update the target capabilities + */ + data_56 = data[56]; + vdev->tflags |= MPT_TARGET_FLAGS_VALID_56; + } + } + mptscsih_setTargetNegoParms(hd, vdev, data_56); + } else { + /* Initial Inquiry may not request enough data bytes to + * obtain byte 57. DV will; if target doesn't return + * at least 57 bytes, data[56] will be zero. */ + if (dlen > 56) { + if ( (!(vdev->tflags & MPT_TARGET_FLAGS_VALID_56))) { + /* Update the target capabilities + */ + data_56 = data[56]; + vdev->tflags |= MPT_TARGET_FLAGS_VALID_56; + mptscsih_setTargetNegoParms(hd, vdev, data_56); + } } } } @@ -2773,12 +2755,12 @@ mptscsih_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget, u8 lun, char *data, * */ static void -mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target, char byte56) +mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtDevice *target, char byte56) { SpiCfgData *pspi_data = &hd->ioc->spi_data; int id = (int) target->target_id; int nvram; - VirtTarget *vtarget; + VirtDevice *vdev; int ii; u8 width = MPT_NARROW; u8 factor = MPT_ASYNC; @@ -2923,9 +2905,9 @@ mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target, char byte56) ddvtprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id)); for (ii = 0; ii < id; ii++) { - if ( (vtarget = hd->Targets[ii]) ) { - vtarget->negoFlags |= MPT_TARGET_NO_NEGO_QAS; - mptscsih_writeSDP1(hd, 0, ii, vtarget->negoFlags); + if ( (vdev = hd->Targets[ii]) ) { + vdev->negoFlags |= MPT_TARGET_NO_NEGO_QAS; + mptscsih_writeSDP1(hd, 0, ii, vdev->negoFlags); } } } @@ -2943,18 +2925,106 @@ mptscsih_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target, char byte56) } } +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ +/* If DV disabled (negoNvram set to USE_NVARM) or if not LUN 0, return. + * Else set the NEED_DV flag after Read Capacity Issued (disks) + * or Mode Sense (cdroms). + * + * Tapes, initTarget will set this flag on completion of Inquiry command. + * Called only if DV_NOT_DONE flag is set + */ +static void +mptscsih_set_dvflags(MPT_SCSI_HOST *hd, SCSIIORequest_t *pReq) +{ + MPT_ADAPTER *ioc = hd->ioc; + u8 cmd; + SpiCfgData *pSpi; + + ddvtprintk((MYIOC_s_NOTE_FMT + " set_dvflags: id=%d lun=%d negoNvram=%x cmd=%x\n", + hd->ioc->name, pReq->TargetID, pReq->LUN[1], hd->negoNvram, pReq->CDB[0])); + + if ((pReq->LUN[1] != 0) || (hd->negoNvram != 0)) + return; + + cmd = pReq->CDB[0]; + + if ((cmd == READ_CAPACITY) || (cmd == MODE_SENSE)) { + pSpi = &ioc->spi_data; + if ((ioc->raid_data.isRaid & (1 << pReq->TargetID)) && ioc->raid_data.pIocPg3) { + /* Set NEED_DV for all hidden disks + */ + Ioc3PhysDisk_t *pPDisk = ioc->raid_data.pIocPg3->PhysDisk; + int numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks; + + while (numPDisk) { + pSpi->dvStatus[pPDisk->PhysDiskID] |= MPT_SCSICFG_NEED_DV; + ddvtprintk(("NEED_DV set for phys disk id %d\n", pPDisk->PhysDiskID)); + pPDisk++; + numPDisk--; + } + } + pSpi->dvStatus[pReq->TargetID] |= MPT_SCSICFG_NEED_DV; + ddvtprintk(("NEED_DV set for visible disk id %d\n", pReq->TargetID)); + } +} + +/* mptscsih_raid_set_dv_flags() + * + * New or replaced disk. Set DV flag and schedule DV. + */ +static void +mptscsih_set_dvflags_raid(MPT_SCSI_HOST *hd, int id) +{ + MPT_ADAPTER *ioc = hd->ioc; + SpiCfgData *pSpi = &ioc->spi_data; + Ioc3PhysDisk_t *pPDisk; + int numPDisk; + + if (hd->negoNvram != 0) + return; + + ddvtprintk(("DV requested for phys disk id %d\n", id)); + if (ioc->raid_data.pIocPg3) { + pPDisk = ioc->raid_data.pIocPg3->PhysDisk; + numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks; + while (numPDisk) { + if (id == pPDisk->PhysDiskNum) { + pSpi->dvStatus[pPDisk->PhysDiskID] = + (MPT_SCSICFG_NEED_DV | MPT_SCSICFG_DV_NOT_DONE); + pSpi->forceDv = MPT_SCSICFG_NEED_DV; + ddvtprintk(("NEED_DV set for phys disk id %d\n", + pPDisk->PhysDiskID)); + break; + } + pPDisk++; + numPDisk--; + } + + if (numPDisk == 0) { + /* The physical disk that needs DV was not found + * in the stored IOC Page 3. The driver must reload + * this page. DV routine will set the NEED_DV flag for + * all phys disks that have DV_NOT_DONE set. + */ + pSpi->forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3; + ddvtprintk(("phys disk %d not found. Setting reload IOC Pg3 Flag\n",id)); + } + } +} + /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ /* * If no Target, bus reset on 1st I/O. Set the flag to * prevent any future negotiations to this device. */ static void -mptscsih_no_negotiate(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc) +mptscsih_no_negotiate(MPT_SCSI_HOST *hd, int target_id) { - VirtDevice *vdev; - if ((vdev = sc->device->hostdata) != NULL) - hd->ioc->spi_data.dvStatus[vdev->target_id] |= MPT_SCSICFG_BLK_NEGO; + if ((hd->Targets) && (hd->Targets[target_id] == NULL)) + hd->ioc->spi_data.dvStatus[target_id] |= MPT_SCSICFG_BLK_NEGO; + return; } @@ -3030,7 +3100,7 @@ mptscsih_writeSDP1(MPT_SCSI_HOST *hd, int portnum, int target_id, int flags) MPT_ADAPTER *ioc = hd->ioc; Config_t *pReq; SCSIDevicePage1_t *pData; - VirtTarget *vtarget=NULL; + VirtDevice *pTarget=NULL; MPT_FRAME_HDR *mf; dma_addr_t dataDma; u16 req_idx; @@ -3110,11 +3180,11 @@ mptscsih_writeSDP1(MPT_SCSI_HOST *hd, int portnum, int target_id, int flags) /* If id is not a raid volume, get the updated * transmission settings from the target structure. */ - if (hd->Targets && (vtarget = hd->Targets[id]) && !vtarget->raidVolume) { - width = vtarget->maxWidth; - factor = vtarget->minSyncFactor; - offset = vtarget->maxOffset; - negoFlags = vtarget->negoFlags; + if (hd->Targets && (pTarget = hd->Targets[id]) && !pTarget->raidVolume) { + width = pTarget->maxWidth; + factor = pTarget->minSyncFactor; + offset = pTarget->maxOffset; + negoFlags = pTarget->negoFlags; } #ifdef MPTSCSIH_ENABLE_DOMAIN_VALIDATION @@ -3834,139 +3904,149 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io) /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ /** - * mptscsih_negotiate_to_asyn_narrow - Restore devices to default state - * @hd: Pointer to a SCSI HOST structure - * @vtarget: per device private data + * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks. + * @hd: Pointer to MPT_SCSI_HOST structure + * @portnum: IOC port number * * Uses the ISR, but with special processing. * MUST be single-threaded. * + * Return: 0 on completion */ -static void -mptscsih_negotiate_to_asyn_narrow(MPT_SCSI_HOST *hd, VirtTarget *vtarget) +static int +mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, int portnum) { MPT_ADAPTER *ioc= hd->ioc; - SCSIDevicePage1_t *pcfg1Data; + VirtDevice *pTarget; + SCSIDevicePage1_t *pcfg1Data = NULL; + INTERNAL_CMD iocmd; CONFIGPARMS cfg; - dma_addr_t cfg1_dma_addr; - ConfigPageHeader_t header; - int id; - int requested, configuration, data,i; + dma_addr_t cfg1_dma_addr = -1; + ConfigPageHeader_t header1; + int bus = 0; + int id = 0; + int lun; + int indexed_lun, lun_index; + int hostId = ioc->pfacts[portnum].PortSCSIID; + int max_id; + int requested, configuration, data; + int doConfig = 0; u8 flags, factor; - if (ioc->bus_type != SPI) - return; + max_id = ioc->sh->max_id - 1; - if (!ioc->spi_data.sdp1length) - return; + /* Following parameters will not change + * in this routine. + */ + iocmd.cmd = SYNCHRONIZE_CACHE; + iocmd.flags = 0; + iocmd.physDiskNum = -1; + iocmd.data = NULL; + iocmd.data_dma = -1; + iocmd.size = 0; + iocmd.rsvd = iocmd.rsvd2 = 0; - pcfg1Data = (SCSIDevicePage1_t *)pci_alloc_consistent(ioc->pcidev, - ioc->spi_data.sdp1length * 4, &cfg1_dma_addr); + /* No SCSI hosts + */ + if (hd->Targets == NULL) + return 0; - if (pcfg1Data == NULL) - return; + /* Skip the host + */ + if (id == hostId) + id++; - header.PageVersion = ioc->spi_data.sdp1version; - header.PageLength = ioc->spi_data.sdp1length; - header.PageNumber = 1; - header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; - cfg.cfghdr.hdr = &header; - cfg.physAddr = cfg1_dma_addr; - cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; - cfg.dir = 1; - cfg.timeout = 0; + /* Write SDP1 for all SCSI devices + * Alloc memory and set up config buffer + */ + if (ioc->bus_type == SCSI) { + if (ioc->spi_data.sdp1length > 0) { + pcfg1Data = (SCSIDevicePage1_t *)pci_alloc_consistent(ioc->pcidev, + ioc->spi_data.sdp1length * 4, &cfg1_dma_addr); + + if (pcfg1Data != NULL) { + doConfig = 1; + header1.PageVersion = ioc->spi_data.sdp1version; + header1.PageLength = ioc->spi_data.sdp1length; + header1.PageNumber = 1; + header1.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE; + cfg.cfghdr.hdr = &header1; + cfg.physAddr = cfg1_dma_addr; + cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; + cfg.dir = 1; + cfg.timeout = 0; + } + } + } - if (vtarget->raidVolume && ioc->raid_data.pIocPg3) { - for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) { - id = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID; - flags = hd->ioc->spi_data.noQas; - if (hd->ioc->spi_data.nvram && (hd->ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) { - data = hd->ioc->spi_data.nvram[id]; - if (data & MPT_NVRAM_WIDE_DISABLE) - flags |= MPT_TARGET_NO_NEGO_WIDE; - factor = (data & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT; - if ((factor == 0) || (factor == MPT_ASYNC)) - flags |= MPT_TARGET_NO_NEGO_SYNC; + /* loop through all devices on this port + */ + while (bus < MPT_MAX_BUS) { + iocmd.bus = bus; + iocmd.id = id; + pTarget = hd->Targets[(int)id]; + + if (doConfig) { + + /* Set the negotiation flags */ + if (pTarget && (pTarget = hd->Targets[id]) && !pTarget->raidVolume) { + flags = pTarget->negoFlags; + } else { + flags = hd->ioc->spi_data.noQas; + if (hd->ioc->spi_data.nvram && (hd->ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) { + data = hd->ioc->spi_data.nvram[id]; + + if (data & MPT_NVRAM_WIDE_DISABLE) + flags |= MPT_TARGET_NO_NEGO_WIDE; + + factor = (data & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT; + if ((factor == 0) || (factor == MPT_ASYNC)) + flags |= MPT_TARGET_NO_NEGO_SYNC; + } } + + /* Force to async, narrow */ mptscsih_setDevicePage1Flags(0, MPT_ASYNC, 0, &requested, - &configuration, flags); + &configuration, flags); dnegoprintk(("syncronize cache: id=%d width=0 factor=MPT_ASYNC " "offset=0 negoFlags=%x request=%x config=%x\n", id, flags, requested, configuration)); pcfg1Data->RequestedParameters = cpu_to_le32(requested); pcfg1Data->Reserved = 0; pcfg1Data->Configuration = cpu_to_le32(configuration); - cfg.pageAddr = (vtarget->bus_id<<8) | id; + cfg.pageAddr = (bus<<8) | id; mpt_config(hd->ioc, &cfg); } - } else { - flags = vtarget->negoFlags; - mptscsih_setDevicePage1Flags(0, MPT_ASYNC, 0, &requested, - &configuration, flags); - dnegoprintk(("syncronize cache: id=%d width=0 factor=MPT_ASYNC " - "offset=0 negoFlags=%x request=%x config=%x\n", - vtarget->target_id, flags, requested, configuration)); - pcfg1Data->RequestedParameters = cpu_to_le32(requested); - pcfg1Data->Reserved = 0; - pcfg1Data->Configuration = cpu_to_le32(configuration); - cfg.pageAddr = (vtarget->bus_id<<8) | vtarget->target_id; - mpt_config(hd->ioc, &cfg); - } - - if (pcfg1Data) - pci_free_consistent(ioc->pcidev, header.PageLength * 4, pcfg1Data, cfg1_dma_addr); -} -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ -/** - * mptscsih_synchronize_cache - Send SYNCHRONIZE_CACHE to all disks. - * @hd: Pointer to a SCSI HOST structure - * @vtarget: per device private data - * @lun: lun - * - * Uses the ISR, but with special processing. - * MUST be single-threaded. - * - */ -static void -mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice) -{ - INTERNAL_CMD iocmd; - - /* Following parameters will not change - * in this routine. - */ - iocmd.cmd = SYNCHRONIZE_CACHE; - iocmd.flags = 0; - iocmd.physDiskNum = -1; - iocmd.data = NULL; - iocmd.data_dma = -1; - iocmd.size = 0; - iocmd.rsvd = iocmd.rsvd2 = 0; - iocmd.bus = vdevice->bus_id; - iocmd.id = vdevice->target_id; - iocmd.lun = (u8)vdevice->lun; + /* If target Ptr NULL or if this target is NOT a disk, skip. + */ + if ((pTarget) && (pTarget->inq_data[0] == TYPE_DISK)){ + for (lun=0; lun <= MPT_LAST_LUN; lun++) { + /* If LUN present, issue the command + */ + lun_index = (lun >> 5); /* 32 luns per lun_index */ + indexed_lun = (lun % 32); + if (pTarget->luns[lun_index] & (1<vtarget->type & TYPE_DISK) && - (vdevice->configured_lun)) - mptscsih_do_cmd(hd, &iocmd); -} + /* get next relevant device */ + id++; -/* Search IOC page 3 to determine if this is hidden physical disk - */ -/* Search IOC page 3 to determine if this is hidden physical disk - */ -static int -mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id) -{ - int i; + if (id == hostId) + id++; - if (!ioc->raid_data.isRaid || !ioc->raid_data.pIocPg3) - return 0; + if (id > max_id) { + id = 0; + bus++; + } + } - for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) { - if (id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) - return 1; + if (pcfg1Data) { + pci_free_consistent(ioc->pcidev, header1.PageLength * 4, pcfg1Data, cfg1_dma_addr); } return 0; @@ -4021,8 +4101,8 @@ mptscsih_domainValidation(void *arg) msleep(250); - /* DV only to SPI adapters */ - if (ioc->bus_type != SPI) + /* DV only to SCSI adapters */ + if (ioc->bus_type != SCSI) continue; /* Make sure everything looks ok */ @@ -4125,12 +4205,32 @@ mptscsih_domainValidation(void *arg) return; } +/* Search IOC page 3 to determine if this is hidden physical disk + */ +/* Search IOC page 3 to determine if this is hidden physical disk + */ +static int +mptscsih_is_phys_disk(MPT_ADAPTER *ioc, int id) +{ + int i; + + if (!ioc->raid_data.isRaid || !ioc->raid_data.pIocPg3) + return 0; + + for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) { + if (id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) + return 1; + } + + return 0; +} + /* Write SDP1 if no QAS has been enabled */ static void mptscsih_qas_check(MPT_SCSI_HOST *hd, int id) { - VirtTarget *vtarget; + VirtDevice *pTarget; int ii; if (hd->Targets == NULL) @@ -4143,11 +4243,11 @@ mptscsih_qas_check(MPT_SCSI_HOST *hd, int id) if ((hd->ioc->spi_data.dvStatus[ii] & MPT_SCSICFG_DV_NOT_DONE) != 0) continue; - vtarget = hd->Targets[ii]; + pTarget = hd->Targets[ii]; - if ((vtarget != NULL) && (!vtarget->raidVolume)) { - if ((vtarget->negoFlags & hd->ioc->spi_data.noQas) == 0) { - vtarget->negoFlags |= hd->ioc->spi_data.noQas; + if ((pTarget != NULL) && (!pTarget->raidVolume)) { + if ((pTarget->negoFlags & hd->ioc->spi_data.noQas) == 0) { + pTarget->negoFlags |= hd->ioc->spi_data.noQas; dnegoprintk(("writeSDP1: id=%d flags=0\n", id)); mptscsih_writeSDP1(hd, 0, ii, 0); } @@ -4187,7 +4287,7 @@ static int mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) { MPT_ADAPTER *ioc = hd->ioc; - VirtTarget *vtarget; + VirtDevice *pTarget; SCSIDevicePage1_t *pcfg1Data; SCSIDevicePage0_t *pcfg0Data; u8 *pbuf1; @@ -4258,12 +4358,12 @@ mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) iocmd.physDiskNum = -1; iocmd.rsvd = iocmd.rsvd2 = 0; - vtarget = hd->Targets[id]; + pTarget = hd->Targets[id]; /* Use tagged commands if possible. */ - if (vtarget) { - if (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES) + if (pTarget) { + if (pTarget->tflags & MPT_TARGET_FLAGS_Q_YES) iocmd.flags |= MPT_ICFLAG_TAGGED_CMD; else { if (hd->ioc->facts.FWVersion.Word < 0x01000600) @@ -4479,7 +4579,7 @@ mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) /* Reset the size for disks */ inq0 = (*pbuf1) & 0x1F; - if ((inq0 == 0) && vtarget && !vtarget->raidVolume) { + if ((inq0 == 0) && pTarget && !pTarget->raidVolume) { sz = 0x40; iocmd.size = sz; } @@ -4489,7 +4589,8 @@ mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) */ if (inq0 == TYPE_PROCESSOR) { mptscsih_initTarget(hd, - vtarget, + bus, + id, lun, pbuf1, sz); @@ -4503,22 +4604,22 @@ mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) goto target_done; if (sz == 0x40) { - if ((vtarget->maxWidth == 1) && (vtarget->maxOffset) && (nfactor < 0x0A) - && (vtarget->minSyncFactor > 0x09)) { + if ((pTarget->maxWidth == 1) && (pTarget->maxOffset) && (nfactor < 0x0A) + && (pTarget->minSyncFactor > 0x09)) { if ((pbuf1[56] & 0x04) == 0) ; else if ((pbuf1[56] & 0x01) == 1) { - vtarget->minSyncFactor = + pTarget->minSyncFactor = nfactor > MPT_ULTRA320 ? nfactor : MPT_ULTRA320; } else { - vtarget->minSyncFactor = + pTarget->minSyncFactor = nfactor > MPT_ULTRA160 ? nfactor : MPT_ULTRA160; } - dv.max.factor = vtarget->minSyncFactor; + dv.max.factor = pTarget->minSyncFactor; if ((pbuf1[56] & 0x02) == 0) { - vtarget->negoFlags |= MPT_TARGET_NO_NEGO_QAS; + pTarget->negoFlags |= MPT_TARGET_NO_NEGO_QAS; hd->ioc->spi_data.noQas = MPT_TARGET_NO_NEGO_QAS; ddvprintk((MYIOC_s_NOTE_FMT "DV: Start Basic noQas on id=%d due to pbuf1[56]=%x\n", @@ -4601,7 +4702,8 @@ mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) "DV:Inquiry compared id=%d, calling initTarget\n", ioc->name, id)); hd->ioc->spi_data.dvStatus[id] &= ~MPT_SCSICFG_DV_NOT_DONE; mptscsih_initTarget(hd, - vtarget, + bus, + id, lun, pbuf1, sz); @@ -5102,7 +5204,7 @@ mptscsih_doDv(MPT_SCSI_HOST *hd, int bus_number, int id) static void mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage) { - VirtTarget *vtarget; + VirtDevice *pTarget; SCSIDevicePage0_t *pPage0; SCSIDevicePage1_t *pPage1; int val = 0, data, configuration; @@ -5122,11 +5224,11 @@ mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage) * already throttled back. */ negoFlags = hd->ioc->spi_data.noQas; - if ((hd->Targets)&&((vtarget = hd->Targets[(int)id]) != NULL) && !vtarget->raidVolume) { - width = vtarget->maxWidth; - offset = vtarget->maxOffset; - factor = vtarget->minSyncFactor; - negoFlags |= vtarget->negoFlags; + if ((hd->Targets)&&((pTarget = hd->Targets[(int)id]) != NULL) && !pTarget->raidVolume) { + width = pTarget->maxWidth; + offset = pTarget->maxOffset; + factor = pTarget->minSyncFactor; + negoFlags |= pTarget->negoFlags; } else { if (hd->ioc->spi_data.nvram && (hd->ioc->spi_data.nvram[id] != MPT_HOST_NVRAM_INVALID)) { data = hd->ioc->spi_data.nvram[id]; @@ -5328,11 +5430,11 @@ mptscsih_dv_parms(MPT_SCSI_HOST *hd, DVPARAMETERS *dv,void *pPage) * or overwrite nvram (phys disks only). */ - if ((hd->Targets)&&((vtarget = hd->Targets[(int)id]) != NULL) && !vtarget->raidVolume ) { - vtarget->maxWidth = dv->now.width; - vtarget->maxOffset = dv->now.offset; - vtarget->minSyncFactor = dv->now.factor; - vtarget->negoFlags = dv->now.flags; + if ((hd->Targets)&&((pTarget = hd->Targets[(int)id]) != NULL) && !pTarget->raidVolume ) { + pTarget->maxWidth = dv->now.width; + pTarget->maxOffset = dv->now.offset; + pTarget->minSyncFactor = dv->now.factor; + pTarget->negoFlags = dv->now.flags; } else { /* Preserv all flags, use * read-modify-write algorithm @@ -5486,94 +5588,6 @@ mptscsih_fillbuf(char *buffer, int size, int index, int width) break; } } - -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ -/* If DV disabled (negoNvram set to USE_NVARM) or if not LUN 0, return. - * Else set the NEED_DV flag after Read Capacity Issued (disks) - * or Mode Sense (cdroms). - * - * Tapes, initTarget will set this flag on completion of Inquiry command. - * Called only if DV_NOT_DONE flag is set - */ -static void -mptscsih_set_dvflags(MPT_SCSI_HOST *hd, struct scsi_cmnd *sc) -{ - MPT_ADAPTER *ioc = hd->ioc; - u8 cmd; - SpiCfgData *pSpi; - - ddvtprintk((MYIOC_s_NOTE_FMT - " set_dvflags: id=%d lun=%d negoNvram=%x cmd=%x\n", - hd->ioc->name, sc->device->id, sc->device->lun , hd->negoNvram, sc->cmnd[0])); - - if ((sc->device->lun != 0) || (hd->negoNvram != 0)) - return; - - cmd = sc->cmnd[0]; - - if ((cmd == READ_CAPACITY) || (cmd == MODE_SENSE)) { - pSpi = &ioc->spi_data; - if ((ioc->raid_data.isRaid & (1 << sc->device->id)) && ioc->raid_data.pIocPg3) { - /* Set NEED_DV for all hidden disks - */ - Ioc3PhysDisk_t *pPDisk = ioc->raid_data.pIocPg3->PhysDisk; - int numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks; - - while (numPDisk) { - pSpi->dvStatus[pPDisk->PhysDiskID] |= MPT_SCSICFG_NEED_DV; - ddvtprintk(("NEED_DV set for phys disk id %d\n", pPDisk->PhysDiskID)); - pPDisk++; - numPDisk--; - } - } - pSpi->dvStatus[sc->device->id] |= MPT_SCSICFG_NEED_DV; - ddvtprintk(("NEED_DV set for visible disk id %d\n", sc->device->id)); - } -} - -/* mptscsih_raid_set_dv_flags() - * - * New or replaced disk. Set DV flag and schedule DV. - */ -static void -mptscsih_set_dvflags_raid(MPT_SCSI_HOST *hd, int id) -{ - MPT_ADAPTER *ioc = hd->ioc; - SpiCfgData *pSpi = &ioc->spi_data; - Ioc3PhysDisk_t *pPDisk; - int numPDisk; - - if (hd->negoNvram != 0) - return; - - ddvtprintk(("DV requested for phys disk id %d\n", id)); - if (ioc->raid_data.pIocPg3) { - pPDisk = ioc->raid_data.pIocPg3->PhysDisk; - numPDisk = ioc->raid_data.pIocPg3->NumPhysDisks; - while (numPDisk) { - if (id == pPDisk->PhysDiskNum) { - pSpi->dvStatus[pPDisk->PhysDiskID] = - (MPT_SCSICFG_NEED_DV | MPT_SCSICFG_DV_NOT_DONE); - pSpi->forceDv = MPT_SCSICFG_NEED_DV; - ddvtprintk(("NEED_DV set for phys disk id %d\n", - pPDisk->PhysDiskID)); - break; - } - pPDisk++; - numPDisk--; - } - - if (numPDisk == 0) { - /* The physical disk that needs DV was not found - * in the stored IOC Page 3. The driver must reload - * this page. DV routine will set the NEED_DV flag for - * all phys disks that have DV_NOT_DONE set. - */ - pSpi->forceDv = MPT_SCSICFG_NEED_DV | MPT_SCSICFG_RELOAD_IOC_PG3; - ddvtprintk(("phys disk %d not found. Setting reload IOC Pg3 Flag\n",id)); - } - } -} #endif /* ~MPTSCSIH_ENABLE_DOMAIN_VALIDATION */ EXPORT_SYMBOL(mptscsih_remove); @@ -5585,9 +5599,7 @@ EXPORT_SYMBOL(mptscsih_resume); EXPORT_SYMBOL(mptscsih_proc_info); EXPORT_SYMBOL(mptscsih_info); EXPORT_SYMBOL(mptscsih_qcmd); -EXPORT_SYMBOL(mptscsih_target_alloc); EXPORT_SYMBOL(mptscsih_slave_alloc); -EXPORT_SYMBOL(mptscsih_target_destroy); EXPORT_SYMBOL(mptscsih_slave_destroy); EXPORT_SYMBOL(mptscsih_slave_configure); EXPORT_SYMBOL(mptscsih_abort); diff --git a/trunk/drivers/message/fusion/mptscsih.h b/trunk/drivers/message/fusion/mptscsih.h index d3cba12f4bd9..971fda4b8b57 100644 --- a/trunk/drivers/message/fusion/mptscsih.h +++ b/trunk/drivers/message/fusion/mptscsih.h @@ -91,9 +91,7 @@ extern int mptscsih_resume(struct pci_dev *pdev); extern int mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length, int func); extern const char * mptscsih_info(struct Scsi_Host *SChost); extern int mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)); -extern int mptscsih_target_alloc(struct scsi_target *starget); extern int mptscsih_slave_alloc(struct scsi_device *device); -extern void mptscsih_target_destroy(struct scsi_target *starget); extern void mptscsih_slave_destroy(struct scsi_device *device); extern int mptscsih_slave_configure(struct scsi_device *device); extern int mptscsih_abort(struct scsi_cmnd * SCpnt); diff --git a/trunk/drivers/message/fusion/mptspi.c b/trunk/drivers/message/fusion/mptspi.c index ce332a6085e5..5c0e307d1d5d 100644 --- a/trunk/drivers/message/fusion/mptspi.c +++ b/trunk/drivers/message/fusion/mptspi.c @@ -103,16 +103,13 @@ static int mptspiTaskCtx = -1; static int mptspiInternalCtx = -1; /* Used only for internal commands */ static struct scsi_host_template mptspi_driver_template = { - .module = THIS_MODULE, .proc_name = "mptspi", .proc_info = mptscsih_proc_info, .name = "MPT SPI Host", .info = mptscsih_info, .queuecommand = mptscsih_qcmd, - .target_alloc = mptscsih_target_alloc, .slave_alloc = mptscsih_slave_alloc, .slave_configure = mptscsih_slave_configure, - .target_destroy = mptscsih_target_destroy, .slave_destroy = mptscsih_slave_destroy, .change_queue_depth = mptscsih_change_queue_depth, .eh_abort_handler = mptscsih_abort, @@ -180,15 +177,13 @@ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) printk(MYIOC_s_WARN_FMT "Skipping because it's not operational!\n", ioc->name); - error = -ENODEV; - goto out_mptspi_probe; + return -ENODEV; } if (!ioc->active) { printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", ioc->name); - error = -ENODEV; - goto out_mptspi_probe; + return -ENODEV; } /* Sanity check - ensure at least 1 port is INITIATOR capable @@ -213,8 +208,7 @@ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) printk(MYIOC_s_WARN_FMT "Unable to register controller with SCSI subsystem\n", ioc->name); - error = -1; - goto out_mptspi_probe; + return -1; } spin_lock_irqsave(&ioc->FreeQlock, flags); @@ -292,7 +286,7 @@ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) mem = kmalloc(sz, GFP_ATOMIC); if (mem == NULL) { error = -ENOMEM; - goto out_mptspi_probe; + goto mptspi_probe_failed; } memset(mem, 0, sz); @@ -310,14 +304,14 @@ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) mem = kmalloc(sz, GFP_ATOMIC); if (mem == NULL) { error = -ENOMEM; - goto out_mptspi_probe; + goto mptspi_probe_failed; } memset(mem, 0, sz); - hd->Targets = (VirtTarget **) mem; + hd->Targets = (VirtDevice **) mem; dprintk((KERN_INFO - " vdev @ %p, sz=%d\n", hd->Targets, sz)); + " Targets @ %p, sz=%d\n", hd->Targets, sz)); /* Clear the TM flags */ @@ -391,13 +385,13 @@ mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id) if(error) { dprintk((KERN_ERR MYNAM "scsi_add_host failed\n")); - goto out_mptspi_probe; + goto mptspi_probe_failed; } scsi_scan_host(sh); return 0; -out_mptspi_probe: +mptspi_probe_failed: mptscsih_remove(pdev); return error; diff --git a/trunk/drivers/mmc/mmc_sysfs.c b/trunk/drivers/mmc/mmc_sysfs.c index ec701667abfc..3f4a66ca9555 100644 --- a/trunk/drivers/mmc/mmc_sysfs.c +++ b/trunk/drivers/mmc/mmc_sysfs.c @@ -80,7 +80,7 @@ static int mmc_bus_match(struct device *dev, struct device_driver *drv) } static int -mmc_bus_uevent(struct device *dev, char **envp, int num_envp, char *buf, +mmc_bus_hotplug(struct device *dev, char **envp, int num_envp, char *buf, int buf_size) { struct mmc_card *card = dev_to_mmc_card(dev); @@ -140,7 +140,7 @@ static struct bus_type mmc_bus_type = { .name = "mmc", .dev_attrs = mmc_dev_attrs, .match = mmc_bus_match, - .uevent = mmc_bus_uevent, + .hotplug = mmc_bus_hotplug, .suspend = mmc_bus_suspend, .resume = mmc_bus_resume, }; diff --git a/trunk/drivers/mtd/maps/pcmciamtd.c b/trunk/drivers/mtd/maps/pcmciamtd.c index f0f8916da7ad..af24216a0626 100644 --- a/trunk/drivers/mtd/maps/pcmciamtd.c +++ b/trunk/drivers/mtd/maps/pcmciamtd.c @@ -66,6 +66,9 @@ struct pcmciamtd_dev { }; +static dev_info_t dev_info = "pcmciamtd"; +static dev_link_t *dev_list; + /* Module parameters */ /* 2 = do 16-bit transfers, 1 = do 8-bit transfers */ @@ -688,21 +691,55 @@ static void pcmciamtd_config(dev_link_t *link) } -static int pcmciamtd_suspend(struct pcmcia_device *dev) -{ - DEBUG(2, "EVENT_PM_RESUME"); - - /* get_lock(link); */ - - return 0; -} +/* The card status event handler. Mostly, this schedules other + * stuff to run after an event is received. A CARD_REMOVAL event + * also sets some flags to discourage the driver from trying + * to talk to the card any more. + */ -static int pcmciamtd_resume(struct pcmcia_device *dev) +static int pcmciamtd_event(event_t event, int priority, + event_callback_args_t *args) { - DEBUG(2, "EVENT_PM_SUSPEND"); - - /* free_lock(link); */ - + dev_link_t *link = args->client_data; + + DEBUG(1, "event=0x%06x", event); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + DEBUG(2, "EVENT_CARD_REMOVAL"); + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + struct pcmciamtd_dev *dev = link->priv; + if(dev->mtd_info) { + del_mtd_device(dev->mtd_info); + info("mtd%d: Removed", dev->mtd_info->index); + } + pcmciamtd_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + DEBUG(2, "EVENT_CARD_INSERTION"); + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + pcmciamtd_config(link); + break; + case CS_EVENT_PM_SUSPEND: + DEBUG(2, "EVENT_PM_SUSPEND"); + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + DEBUG(2, "EVENT_RESET_PHYSICAL"); + /* get_lock(link); */ + break; + case CS_EVENT_PM_RESUME: + DEBUG(2, "EVENT_PM_RESUME"); + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + DEBUG(2, "EVENT_CARD_RESET"); + /* free_lock(link); */ + break; + default: + DEBUG(2, "Unknown event %d", event); + } return 0; } @@ -713,21 +750,23 @@ static int pcmciamtd_resume(struct pcmcia_device *dev) * when the device is released. */ -static void pcmciamtd_detach(struct pcmcia_device *p_dev) +static void pcmciamtd_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); - DEBUG(3, "link=0x%p", link); if(link->state & DEV_CONFIG) { - struct pcmciamtd_dev *dev = link->priv; - if(dev->mtd_info) { - del_mtd_device(dev->mtd_info); - info("mtd%d: Removed", dev->mtd_info->index); - } - pcmciamtd_release(link); } + + if (link->handle) { + int ret; + DEBUG(2, "Deregistering with card services"); + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + link->state |= DEV_STALE_LINK; } @@ -736,14 +775,16 @@ static void pcmciamtd_detach(struct pcmcia_device *p_dev) * with Card Services. */ -static int pcmciamtd_attach(struct pcmcia_device *p_dev) +static dev_link_t *pcmciamtd_attach(void) { struct pcmciamtd_dev *dev; dev_link_t *link; + client_reg_t client_reg; + int ret; /* Create new memory card device */ dev = kmalloc(sizeof(*dev), GFP_KERNEL); - if (!dev) return -ENOMEM; + if (!dev) return NULL; DEBUG(1, "dev=0x%p", dev); memset(dev, 0, sizeof(*dev)); @@ -753,14 +794,22 @@ static int pcmciamtd_attach(struct pcmcia_device *p_dev) link->conf.Attributes = 0; link->conf.IntType = INT_MEMORY; - link->next = NULL; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - pcmciamtd_config(link); - - return 0; + link->next = dev_list; + dev_list = link; + + /* Register with Card Services */ + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + DEBUG(2, "Calling RegisterClient"); + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + pcmciamtd_detach(link); + return NULL; + } + DEBUG(2, "link = %p", link); + return link; } static struct pcmcia_device_id pcmciamtd_ids[] = { @@ -794,12 +843,11 @@ static struct pcmcia_driver pcmciamtd_driver = { .drv = { .name = "pcmciamtd" }, - .probe = pcmciamtd_attach, - .remove = pcmciamtd_detach, + .attach = pcmciamtd_attach, + .event = pcmciamtd_event, + .detach = pcmciamtd_detach, .owner = THIS_MODULE, .id_table = pcmciamtd_ids, - .suspend = pcmciamtd_suspend, - .resume = pcmciamtd_resume, }; @@ -827,6 +875,7 @@ static void __exit exit_pcmciamtd(void) { DEBUG(1, DRIVER_DESC " unloading"); pcmcia_unregister_driver(&pcmciamtd_driver); + BUG_ON(dev_list != NULL); } module_init(init_pcmciamtd); diff --git a/trunk/drivers/net/8139too.c b/trunk/drivers/net/8139too.c index d2102a27d307..30bee11c48bd 100644 --- a/trunk/drivers/net/8139too.c +++ b/trunk/drivers/net/8139too.c @@ -586,16 +586,16 @@ struct rtl8139_private { dma_addr_t tx_bufs_dma; signed char phys[4]; /* MII device addresses. */ char twistie, twist_row, twist_col; /* Twister tune state. */ - unsigned int default_port : 4; /* Last dev->if_port value. */ - unsigned int have_thread : 1; + unsigned int default_port:4; /* Last dev->if_port value. */ spinlock_t lock; spinlock_t rx_lock; chip_t chipset; + pid_t thr_pid; + wait_queue_head_t thr_wait; + struct completion thr_exited; u32 rx_config; struct rtl_extra_stats xstats; - - struct work_struct thread; - + int time_to_die; struct mii_if_info mii; unsigned int regs_len; unsigned long fifo_copy_timeout; @@ -620,7 +620,7 @@ static int rtl8139_open (struct net_device *dev); static int mdio_read (struct net_device *dev, int phy_id, int location); static void mdio_write (struct net_device *dev, int phy_id, int location, int val); -static void rtl8139_start_thread(struct rtl8139_private *tp); +static void rtl8139_start_thread(struct net_device *dev); static void rtl8139_tx_timeout (struct net_device *dev); static void rtl8139_init_ring (struct net_device *dev); static int rtl8139_start_xmit (struct sk_buff *skb, @@ -637,7 +637,6 @@ static struct net_device_stats *rtl8139_get_stats (struct net_device *dev); static void rtl8139_set_rx_mode (struct net_device *dev); static void __set_rx_mode (struct net_device *dev); static void rtl8139_hw_start (struct net_device *dev); -static void rtl8139_thread (void *_data); static struct ethtool_ops rtl8139_ethtool_ops; /* write MMIO register, with flush */ @@ -1008,7 +1007,8 @@ static int __devinit rtl8139_init_one (struct pci_dev *pdev, (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1)); spin_lock_init (&tp->lock); spin_lock_init (&tp->rx_lock); - INIT_WORK(&tp->thread, rtl8139_thread, dev); + init_waitqueue_head (&tp->thr_wait); + init_completion (&tp->thr_exited); tp->mii.dev = dev; tp->mii.mdio_read = mdio_read; tp->mii.mdio_write = mdio_write; @@ -1345,7 +1345,7 @@ static int rtl8139_open (struct net_device *dev) dev->irq, RTL_R8 (MediaStatus), tp->mii.full_duplex ? "full" : "half"); - rtl8139_start_thread(tp); + rtl8139_start_thread(dev); return 0; } @@ -1594,43 +1594,55 @@ static inline void rtl8139_thread_iter (struct net_device *dev, RTL_R8 (Config1)); } -static void rtl8139_thread (void *_data) +static int rtl8139_thread (void *data) { - struct net_device *dev = _data; + struct net_device *dev = data; struct rtl8139_private *tp = netdev_priv(dev); - unsigned long thr_delay; + unsigned long timeout; + + daemonize("%s", dev->name); + allow_signal(SIGTERM); + + while (1) { + timeout = next_tick; + do { + timeout = interruptible_sleep_on_timeout (&tp->thr_wait, timeout); + /* make swsusp happy with our thread */ + try_to_freeze(); + } while (!signal_pending (current) && (timeout > 0)); + + if (signal_pending (current)) { + flush_signals(current); + } - if (rtnl_shlock_nowait() == 0) { + if (tp->time_to_die) + break; + + if (rtnl_lock_interruptible ()) + break; rtl8139_thread_iter (dev, tp, tp->mmio_addr); rtnl_unlock (); - - thr_delay = next_tick; - } else { - /* unlikely race. mitigate with fast poll. */ - thr_delay = HZ / 2; } - schedule_delayed_work(&tp->thread, thr_delay); + complete_and_exit (&tp->thr_exited, 0); } -static void rtl8139_start_thread(struct rtl8139_private *tp) +static void rtl8139_start_thread(struct net_device *dev) { + struct rtl8139_private *tp = netdev_priv(dev); + + tp->thr_pid = -1; tp->twistie = 0; + tp->time_to_die = 0; if (tp->chipset == CH_8139_K) tp->twistie = 1; else if (tp->drv_flags & HAS_LNK_CHNG) return; - tp->have_thread = 1; - - schedule_delayed_work(&tp->thread, next_tick); -} - -static void rtl8139_stop_thread(struct rtl8139_private *tp) -{ - if (tp->have_thread) { - cancel_rearming_delayed_work(&tp->thread); - tp->have_thread = 0; + tp->thr_pid = kernel_thread(rtl8139_thread, dev, CLONE_FS|CLONE_FILES); + if (tp->thr_pid < 0) { + printk (KERN_WARNING "%s: unable to start kernel thread\n", + dev->name); } } @@ -2212,12 +2224,22 @@ static int rtl8139_close (struct net_device *dev) { struct rtl8139_private *tp = netdev_priv(dev); void __iomem *ioaddr = tp->mmio_addr; + int ret = 0; unsigned long flags; netif_stop_queue (dev); - rtl8139_stop_thread(tp); - + if (tp->thr_pid >= 0) { + tp->time_to_die = 1; + wmb(); + ret = kill_proc (tp->thr_pid, SIGTERM, 1); + if (ret) { + printk (KERN_ERR "%s: unable to signal thread\n", dev->name); + return ret; + } + wait_for_completion (&tp->thr_exited); + } + if (netif_msg_ifdown(tp)) printk(KERN_DEBUG "%s: Shutting down ethercard, status was 0x%4.4x.\n", dev->name, RTL_R16 (IntrStatus)); diff --git a/trunk/drivers/net/Kconfig b/trunk/drivers/net/Kconfig index e2fa29b612cd..ebd7313d7fc1 100644 --- a/trunk/drivers/net/Kconfig +++ b/trunk/drivers/net/Kconfig @@ -1901,8 +1901,6 @@ config E1000_NAPI If in doubt, say N. -source "drivers/net/ixp2000/Kconfig" - config MYRI_SBUS tristate "MyriCOM Gigabit Ethernet support" depends on SBUS @@ -2010,18 +2008,7 @@ config SKGE It does not support the link failover and network management features that "portable" vendor supplied sk98lin driver does. - - -config SKY2 - tristate "SysKonnect Yukon2 support (EXPERIMENTAL)" - depends on PCI && EXPERIMENTAL - select CRC32 - ---help--- - This driver support the Marvell Yukon 2 Gigabit Ethernet adapter. - - To compile this driver as a module, choose M here: the module - will be called sky2. This is recommended. - + config SK98LIN tristate "Marvell Yukon Chipset / SysKonnect SK-98xx Support" depends on PCI @@ -2133,7 +2120,7 @@ config BNX2 config SPIDER_NET tristate "Spider Gigabit Ethernet driver" - depends on PCI && PPC_CELL + depends on PCI && PPC_BPA help This driver supports the Gigabit Ethernet chips present on the Cell Processor-Based Blades from IBM. diff --git a/trunk/drivers/net/Makefile b/trunk/drivers/net/Makefile index b74a7cb5bae6..4cffd34442aa 100644 --- a/trunk/drivers/net/Makefile +++ b/trunk/drivers/net/Makefile @@ -13,10 +13,7 @@ obj-$(CONFIG_CHELSIO_T1) += chelsio/ obj-$(CONFIG_BONDING) += bonding/ obj-$(CONFIG_GIANFAR) += gianfar_driver.o -gianfar_driver-objs := gianfar.o \ - gianfar_ethtool.o \ - gianfar_mii.o \ - gianfar_sysfs.o +gianfar_driver-objs := gianfar.o gianfar_ethtool.o gianfar_mii.o # # link order important here @@ -62,7 +59,6 @@ spidernet-y += spider_net.o spider_net_ethtool.o sungem_phy.o obj-$(CONFIG_SPIDER_NET) += spidernet.o obj-$(CONFIG_TC35815) += tc35815.o obj-$(CONFIG_SKGE) += skge.o -obj-$(CONFIG_SKY2) += sky2.o obj-$(CONFIG_SK98LIN) += sk98lin/ obj-$(CONFIG_SKFP) += skfp/ obj-$(CONFIG_VIA_RHINE) += via-rhine.o @@ -206,7 +202,6 @@ obj-$(CONFIG_NET_TULIP) += tulip/ obj-$(CONFIG_HAMRADIO) += hamradio/ obj-$(CONFIG_IRDA) += irda/ obj-$(CONFIG_ETRAX_ETHERNET) += cris/ -obj-$(CONFIG_ENP2611_MSF_NET) += ixp2000/ obj-$(CONFIG_NETCONSOLE) += netconsole.o diff --git a/trunk/drivers/net/bonding/Makefile b/trunk/drivers/net/bonding/Makefile index 5cdae2bc055a..cf50384b469e 100644 --- a/trunk/drivers/net/bonding/Makefile +++ b/trunk/drivers/net/bonding/Makefile @@ -4,5 +4,5 @@ obj-$(CONFIG_BONDING) += bonding.o -bonding-objs := bond_main.o bond_3ad.o bond_alb.o bond_sysfs.o +bonding-objs := bond_main.o bond_3ad.o bond_alb.o diff --git a/trunk/drivers/net/bonding/bond_3ad.c b/trunk/drivers/net/bonding/bond_3ad.c index f3f5825469d6..d2f34d5a8083 100644 --- a/trunk/drivers/net/bonding/bond_3ad.c +++ b/trunk/drivers/net/bonding/bond_3ad.c @@ -18,6 +18,38 @@ * The full GNU General Public License is included in this distribution in the * file called LICENSE. * + * + * Changes: + * + * 2003/05/01 - Tsippy Mendelson and + * Amir Noam + * - Added support for lacp_rate module param. + * + * 2003/05/01 - Shmulik Hen + * - Based on discussion on mailing list, changed locking scheme + * to use lock/unlock or lock_bh/unlock_bh appropriately instead + * of lock_irqsave/unlock_irqrestore. The new scheme helps exposing + * hidden bugs and solves system hangs that occurred due to the fact + * that holding lock_irqsave doesn't prevent softirqs from running. + * This also increases total throughput since interrupts are not + * blocked on each transmitted packets or monitor timeout. + * + * 2003/05/01 - Shmulik Hen + * - Renamed bond_3ad_link_status_changed() to + * bond_3ad_handle_link_change() for compatibility with TLB. + * + * 2003/05/20 - Amir Noam + * - Fix long fail over time when releasing last slave of an active + * aggregator - send LACPDU on unbind of slave to tell partner this + * port is no longer aggregatable. + * + * 2003/06/25 - Tsippy Mendelson + * - Send LACPDU as highest priority packet to further fix the above + * problem on very high Tx traffic load where packets may get dropped + * by the slave. + * + * 2003/12/01 - Shmulik Hen + * - Code cleanup and style changes */ //#define BONDING_DEBUG 1 @@ -1166,10 +1198,10 @@ static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port) // detect loopback situation if (!MAC_ADDRESS_COMPARE(&(lacpdu->actor_system), &(port->actor_system))) { // INFO_RECEIVED_LOOPBACK_FRAMES - printk(KERN_ERR DRV_NAME ": %s: An illegal loopback occurred on " - "adapter (%s). Check the configuration to verify that all " - "Adapters are connected to 802.3ad compliant switch ports\n", - port->slave->dev->master->name, port->slave->dev->name); + printk(KERN_ERR DRV_NAME ": An illegal loopback occurred on adapter (%s)\n", + port->slave->dev->name); + printk(KERN_ERR "Check the configuration to verify that all Adapters " + "are connected to 802.3ad compliant switch ports\n"); __release_rx_machine_lock(port); return; } @@ -1346,9 +1378,8 @@ static void ad_port_selection_logic(struct port *port) } } if (!curr_port) { // meaning: the port was related to an aggregator but was not on the aggregator port list - printk(KERN_WARNING DRV_NAME ": %s: Warning: Port %d (on %s) was " + printk(KERN_WARNING DRV_NAME ": Warning: Port %d (on %s) was " "related to aggregator %d but was not on its port list\n", - port->slave->dev->master->name, port->actor_port_number, port->slave->dev->name, port->aggregator->aggregator_identifier); } @@ -1419,8 +1450,7 @@ static void ad_port_selection_logic(struct port *port) dprintk("Port %d joined LAG %d(new LAG)\n", port->actor_port_number, port->aggregator->aggregator_identifier); } else { - printk(KERN_ERR DRV_NAME ": %s: Port %d (on %s) did not find a suitable aggregator\n", - port->slave->dev->master->name, + printk(KERN_ERR DRV_NAME ": Port %d (on %s) did not find a suitable aggregator\n", port->actor_port_number, port->slave->dev->name); } } @@ -1552,9 +1582,8 @@ static void ad_agg_selection_logic(struct aggregator *aggregator) // check if any partner replys if (best_aggregator->is_individual) { - printk(KERN_WARNING DRV_NAME ": %s: Warning: No 802.3ad response from " - "the link partner for any adapters in the bond\n", - best_aggregator->slave->dev->master->name); + printk(KERN_WARNING DRV_NAME ": Warning: No 802.3ad response from the link partner " + "for any adapters in the bond\n"); } // check if there are more than one aggregator @@ -1886,8 +1915,7 @@ int bond_3ad_bind_slave(struct slave *slave) struct aggregator *aggregator; if (bond == NULL) { - printk(KERN_ERR DRV_NAME ": %s: The slave %s is not attached to its bond\n", - slave->dev->master->name, slave->dev->name); + printk(KERN_ERR "The slave %s is not attached to its bond\n", slave->dev->name); return -1; } @@ -1962,9 +1990,7 @@ void bond_3ad_unbind_slave(struct slave *slave) // if slave is null, the whole port is not initialized if (!port->slave) { - printk(KERN_WARNING DRV_NAME ": Warning: %s: Trying to " - "unbind an uninitialized port on %s\n", - slave->dev->master->name, slave->dev->name); + printk(KERN_WARNING DRV_NAME ": Trying to unbind an uninitialized port on %s\n", slave->dev->name); return; } @@ -1995,8 +2021,7 @@ void bond_3ad_unbind_slave(struct slave *slave) dprintk("Some port(s) related to LAG %d - replaceing with LAG %d\n", aggregator->aggregator_identifier, new_aggregator->aggregator_identifier); if ((new_aggregator->lag_ports == port) && new_aggregator->is_active) { - printk(KERN_INFO DRV_NAME ": %s: Removing an active aggregator\n", - aggregator->slave->dev->master->name); + printk(KERN_INFO DRV_NAME ": Removing an active aggregator\n"); // select new active aggregator select_new_active_agg = 1; } @@ -2026,17 +2051,15 @@ void bond_3ad_unbind_slave(struct slave *slave) ad_agg_selection_logic(__get_first_agg(port)); } } else { - printk(KERN_WARNING DRV_NAME ": %s: Warning: unbinding aggregator, " - "and could not find a new aggregator for its ports\n", - slave->dev->master->name); + printk(KERN_WARNING DRV_NAME ": Warning: unbinding aggregator, " + "and could not find a new aggregator for its ports\n"); } } else { // in case that the only port related to this aggregator is the one we want to remove select_new_active_agg = aggregator->is_active; // clear the aggregator ad_clear_agg(aggregator); if (select_new_active_agg) { - printk(KERN_INFO DRV_NAME ": %s: Removing an active aggregator\n", - slave->dev->master->name); + printk(KERN_INFO "Removing an active aggregator\n"); // select new active aggregator ad_agg_selection_logic(__get_first_agg(port)); } @@ -2062,8 +2085,7 @@ void bond_3ad_unbind_slave(struct slave *slave) // clear the aggregator ad_clear_agg(temp_aggregator); if (select_new_active_agg) { - printk(KERN_INFO DRV_NAME ": %s: Removing an active aggregator\n", - slave->dev->master->name); + printk(KERN_INFO "Removing an active aggregator\n"); // select new active aggregator ad_agg_selection_logic(__get_first_agg(port)); } @@ -2109,8 +2131,7 @@ void bond_3ad_state_machine_handler(struct bonding *bond) // select the active aggregator for the bond if ((port = __get_first_port(bond))) { if (!port->slave) { - printk(KERN_WARNING DRV_NAME ": %s: Warning: bond's first port is " - "uninitialized\n", bond->dev->name); + printk(KERN_WARNING DRV_NAME ": Warning: bond's first port is uninitialized\n"); goto re_arm; } @@ -2122,8 +2143,7 @@ void bond_3ad_state_machine_handler(struct bonding *bond) // for each port run the state machines for (port = __get_first_port(bond); port; port = __get_next_port(port)) { if (!port->slave) { - printk(KERN_WARNING DRV_NAME ": %s: Warning: Found an uninitialized " - "port\n", bond->dev->name); + printk(KERN_WARNING DRV_NAME ": Warning: Found an uninitialized port\n"); goto re_arm; } @@ -2164,8 +2184,7 @@ static void bond_3ad_rx_indication(struct lacpdu *lacpdu, struct slave *slave, u port = &(SLAVE_AD_INFO(slave).port); if (!port->slave) { - printk(KERN_WARNING DRV_NAME ": %s: Warning: port of slave %s is " - "uninitialized\n", slave->dev->name, slave->dev->master->name); + printk(KERN_WARNING DRV_NAME ": Warning: port of slave %s is uninitialized\n", slave->dev->name); return; } @@ -2211,9 +2230,8 @@ void bond_3ad_adapter_speed_changed(struct slave *slave) // if slave is null, the whole port is not initialized if (!port->slave) { - printk(KERN_WARNING DRV_NAME ": Warning: %s: speed " - "changed for uninitialized port on %s\n", - slave->dev->master->name, slave->dev->name); + printk(KERN_WARNING DRV_NAME ": Warning: speed changed for uninitialized port on %s\n", + slave->dev->name); return; } @@ -2239,9 +2257,8 @@ void bond_3ad_adapter_duplex_changed(struct slave *slave) // if slave is null, the whole port is not initialized if (!port->slave) { - printk(KERN_WARNING DRV_NAME ": %s: Warning: duplex changed " - "for uninitialized port on %s\n", - slave->dev->master->name, slave->dev->name); + printk(KERN_WARNING DRV_NAME ": Warning: duplex changed for uninitialized port on %s\n", + slave->dev->name); return; } @@ -2268,9 +2285,8 @@ void bond_3ad_handle_link_change(struct slave *slave, char link) // if slave is null, the whole port is not initialized if (!port->slave) { - printk(KERN_WARNING DRV_NAME ": Warning: %s: link status changed for " - "uninitialized port on %s\n", - slave->dev->master->name, slave->dev->name); + printk(KERN_WARNING DRV_NAME ": Warning: link status changed for uninitialized port on %s\n", + slave->dev->name); return; } @@ -2347,8 +2363,7 @@ int bond_3ad_xmit_xor(struct sk_buff *skb, struct net_device *dev) } if (bond_3ad_get_active_agg_info(bond, &ad_info)) { - printk(KERN_DEBUG DRV_NAME ": %s: Error: " - "bond_3ad_get_active_agg_info failed\n", dev->name); + printk(KERN_DEBUG "ERROR: bond_3ad_get_active_agg_info failed\n"); goto out; } @@ -2357,9 +2372,7 @@ int bond_3ad_xmit_xor(struct sk_buff *skb, struct net_device *dev) if (slaves_in_agg == 0) { /*the aggregator is empty*/ - printk(KERN_DEBUG DRV_NAME ": %s: Error: active " - "aggregator is empty\n", - dev->name); + printk(KERN_DEBUG "ERROR: active aggregator is empty\n"); goto out; } @@ -2377,8 +2390,7 @@ int bond_3ad_xmit_xor(struct sk_buff *skb, struct net_device *dev) } if (slave_agg_no >= 0) { - printk(KERN_ERR DRV_NAME ": %s: Error: Couldn't find a slave to tx on " - "for aggregator ID %d\n", dev->name, agg_id); + printk(KERN_ERR DRV_NAME ": Error: Couldn't find a slave to tx on for aggregator ID %d\n", agg_id); goto out; } diff --git a/trunk/drivers/net/bonding/bond_3ad.h b/trunk/drivers/net/bonding/bond_3ad.h index 5ee2cef5b037..673a30af5660 100644 --- a/trunk/drivers/net/bonding/bond_3ad.h +++ b/trunk/drivers/net/bonding/bond_3ad.h @@ -18,6 +18,19 @@ * The full GNU General Public License is included in this distribution in the * file called LICENSE. * + * + * Changes: + * + * 2003/05/01 - Tsippy Mendelson and + * Amir Noam + * - Added support for lacp_rate module param. + * + * 2003/05/01 - Shmulik Hen + * - Renamed bond_3ad_link_status_changed() to + * bond_3ad_handle_link_change() for compatibility with TLB. + * + * 2003/12/01 - Shmulik Hen + * - Code cleanup and style changes */ #ifndef __BOND_3AD_H__ diff --git a/trunk/drivers/net/bonding/bond_alb.c b/trunk/drivers/net/bonding/bond_alb.c index 854ddfb90da1..f8fce3961197 100644 --- a/trunk/drivers/net/bonding/bond_alb.c +++ b/trunk/drivers/net/bonding/bond_alb.c @@ -18,6 +18,25 @@ * The full GNU General Public License is included in this distribution in the * file called LICENSE. * + * + * Changes: + * + * 2003/06/25 - Shmulik Hen + * - Fixed signed/unsigned calculation errors that caused load sharing + * to collapse to one slave under very heavy UDP Tx stress. + * + * 2003/08/06 - Amir Noam + * - Add support for setting bond's MAC address with special + * handling required for ALB/TLB. + * + * 2003/12/01 - Shmulik Hen + * - Code cleanup and style changes + * + * 2003/12/30 - Amir Noam + * - Fixed: Cannot remove and re-enslave the original active slave. + * + * 2004/01/14 - Shmulik Hen + * - Add capability to tag self generated packets in ALB/TLB modes. */ //#define BONDING_DEBUG 1 @@ -179,21 +198,20 @@ static int tlb_initialize(struct bonding *bond) { struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); int size = TLB_HASH_TABLE_SIZE * sizeof(struct tlb_client_info); - struct tlb_client_info *new_hashtbl; int i; spin_lock_init(&(bond_info->tx_hashtbl_lock)); - new_hashtbl = kmalloc(size, GFP_KERNEL); - if (!new_hashtbl) { + _lock_tx_hashtbl(bond); + + bond_info->tx_hashtbl = kmalloc(size, GFP_KERNEL); + if (!bond_info->tx_hashtbl) { printk(KERN_ERR DRV_NAME - ": %s: Error: Failed to allocate TLB hash table\n", + ": Error: %s: Failed to allocate TLB hash table\n", bond->dev->name); + _unlock_tx_hashtbl(bond); return -1; } - _lock_tx_hashtbl(bond); - - bond_info->tx_hashtbl = new_hashtbl; memset(bond_info->tx_hashtbl, 0, size); @@ -495,8 +513,7 @@ static void rlb_update_client(struct rlb_client_info *client_info) client_info->mac_dst); if (!skb) { printk(KERN_ERR DRV_NAME - ": %s: Error: failed to create an ARP packet\n", - client_info->slave->dev->master->name); + ": Error: failed to create an ARP packet\n"); continue; } @@ -506,8 +523,7 @@ static void rlb_update_client(struct rlb_client_info *client_info) skb = vlan_put_tag(skb, client_info->vlan_id); if (!skb) { printk(KERN_ERR DRV_NAME - ": %s: Error: failed to insert VLAN tag\n", - client_info->slave->dev->master->name); + ": Error: failed to insert VLAN tag\n"); continue; } } @@ -590,9 +606,8 @@ static void rlb_req_update_subnet_clients(struct bonding *bond, u32 src_ip) if (!client_info->slave) { printk(KERN_ERR DRV_NAME - ": %s: Error: found a client with no channel in " - "the client's hash table\n", - bond->dev->name); + ": Error: found a client with no channel in " + "the client's hash table\n"); continue; } /*update all clients using this src_ip, that are not assigned @@ -782,22 +797,21 @@ static int rlb_initialize(struct bonding *bond) { struct alb_bond_info *bond_info = &(BOND_ALB_INFO(bond)); struct packet_type *pk_type = &(BOND_ALB_INFO(bond).rlb_pkt_type); - struct rlb_client_info *new_hashtbl; int size = RLB_HASH_TABLE_SIZE * sizeof(struct rlb_client_info); int i; spin_lock_init(&(bond_info->rx_hashtbl_lock)); - new_hashtbl = kmalloc(size, GFP_KERNEL); - if (!new_hashtbl) { + _lock_rx_hashtbl(bond); + + bond_info->rx_hashtbl = kmalloc(size, GFP_KERNEL); + if (!bond_info->rx_hashtbl) { printk(KERN_ERR DRV_NAME - ": %s: Error: Failed to allocate RLB hash table\n", + ": Error: %s: Failed to allocate RLB hash table\n", bond->dev->name); + _unlock_rx_hashtbl(bond); return -1; } - _lock_rx_hashtbl(bond); - - bond_info->rx_hashtbl = new_hashtbl; bond_info->rx_hashtbl_head = RLB_NULL_INDEX; @@ -913,8 +927,7 @@ static void alb_send_learning_packets(struct slave *slave, u8 mac_addr[]) skb = vlan_put_tag(skb, vlan->vlan_id); if (!skb) { printk(KERN_ERR DRV_NAME - ": %s: Error: failed to insert VLAN tag\n", - bond->dev->name); + ": Error: failed to insert VLAN tag\n"); continue; } } @@ -943,11 +956,11 @@ static int alb_set_slave_mac_addr(struct slave *slave, u8 addr[], int hw) s_addr.sa_family = dev->type; if (dev_set_mac_address(dev, &s_addr)) { printk(KERN_ERR DRV_NAME - ": %s: Error: dev_set_mac_address of dev %s failed! ALB " + ": Error: dev_set_mac_address of dev %s failed! ALB " "mode requires that the base driver support setting " "the hw address also when the network device's " "interface is open\n", - dev->master->name, dev->name); + dev->name); return -EOPNOTSUPP; } return 0; @@ -1140,16 +1153,16 @@ static int alb_handle_addr_collision_on_attach(struct bonding *bond, struct slav bond->alb_info.rlb_enabled); printk(KERN_WARNING DRV_NAME - ": %s: Warning: the hw address of slave %s is in use by " + ": Warning: the hw address of slave %s is in use by " "the bond; giving it the hw address of %s\n", - bond->dev->name, slave->dev->name, free_mac_slave->dev->name); + slave->dev->name, free_mac_slave->dev->name); } else if (has_bond_addr) { printk(KERN_ERR DRV_NAME - ": %s: Error: the hw address of slave %s is in use by the " + ": Error: the hw address of slave %s is in use by the " "bond; couldn't find a slave with a free hw address to " "give it (this should not have happened)\n", - bond->dev->name, slave->dev->name); + slave->dev->name); return -EFAULT; } @@ -1237,8 +1250,6 @@ int bond_alb_initialize(struct bonding *bond, int rlb_enabled) tlb_deinitialize(bond); return res; } - } else { - bond->alb_info.rlb_enabled = 0; } return 0; @@ -1398,7 +1409,7 @@ void bond_alb_monitor(struct bonding *bond) read_lock(&bond->curr_slave_lock); bond_for_each_slave(bond, slave, i) { - alb_send_learning_packets(slave, slave->dev->dev_addr); + alb_send_learning_packets(slave,slave->dev->dev_addr); } read_unlock(&bond->curr_slave_lock); diff --git a/trunk/drivers/net/bonding/bond_alb.h b/trunk/drivers/net/bonding/bond_alb.h index 28f2a2fd1b5a..e4091cd8d654 100644 --- a/trunk/drivers/net/bonding/bond_alb.h +++ b/trunk/drivers/net/bonding/bond_alb.h @@ -18,6 +18,15 @@ * The full GNU General Public License is included in this distribution in the * file called LICENSE. * + * + * Changes: + * + * 2003/08/06 - Amir Noam + * - Add support for setting bond's MAC address with special + * handling required for ALB/TLB. + * + * 2003/12/01 - Shmulik Hen + * - Code cleanup and style changes */ #ifndef __BOND_ALB_H__ diff --git a/trunk/drivers/net/bonding/bond_main.c b/trunk/drivers/net/bonding/bond_main.c index 2582d98ef5c3..94cec3cf2a13 100644 --- a/trunk/drivers/net/bonding/bond_main.c +++ b/trunk/drivers/net/bonding/bond_main.c @@ -29,6 +29,466 @@ * b: if a hw mac address already is there, eth0's hw mac address * will then be set from bond0. * + * v0.1 - first working version. + * v0.2 - changed stats to be calculated by summing slaves stats. + * + * Changes: + * Arnaldo Carvalho de Melo + * - fix leaks on failure at bond_init + * + * 2000/09/30 - Willy Tarreau + * - added trivial code to release a slave device. + * - fixed security bug (CAP_NET_ADMIN not checked) + * - implemented MII link monitoring to disable dead links : + * All MII capable slaves are checked every milliseconds + * (100 ms seems good). This value can be changed by passing it to + * insmod. A value of zero disables the monitoring (default). + * - fixed an infinite loop in bond_xmit_roundrobin() when there's no + * good slave. + * - made the code hopefully SMP safe + * + * 2000/10/03 - Willy Tarreau + * - optimized slave lists based on relevant suggestions from Thomas Davis + * - implemented active-backup method to obtain HA with two switches: + * stay as long as possible on the same active interface, while we + * also monitor the backup one (MII link status) because we want to know + * if we are able to switch at any time. ( pass "mode=1" to insmod ) + * - lots of stress testings because we need it to be more robust than the + * wires ! :-> + * + * 2000/10/09 - Willy Tarreau + * - added up and down delays after link state change. + * - optimized the slaves chaining so that when we run forward, we never + * repass through the bond itself, but we can find it by searching + * backwards. Renders the deletion more difficult, but accelerates the + * scan. + * - smarter enslaving and releasing. + * - finer and more robust SMP locking + * + * 2000/10/17 - Willy Tarreau + * - fixed two potential SMP race conditions + * + * 2000/10/18 - Willy Tarreau + * - small fixes to the monitoring FSM in case of zero delays + * 2000/11/01 - Willy Tarreau + * - fixed first slave not automatically used in trunk mode. + * 2000/11/10 : spelling of "EtherChannel" corrected. + * 2000/11/13 : fixed a race condition in case of concurrent accesses to ioctl(). + * 2000/12/16 : fixed improper usage of rtnl_exlock_nowait(). + * + * 2001/1/3 - Chad N. Tindel + * - The bonding driver now simulates MII status monitoring, just like + * a normal network device. It will show that the link is down iff + * every slave in the bond shows that their links are down. If at least + * one slave is up, the bond's MII status will appear as up. + * + * 2001/2/7 - Chad N. Tindel + * - Applications can now query the bond from user space to get + * information which may be useful. They do this by calling + * the BOND_INFO_QUERY ioctl. Once the app knows how many slaves + * are in the bond, it can call the BOND_SLAVE_INFO_QUERY ioctl to + * get slave specific information (# link failures, etc). See + * for more details. The structs of interest + * are ifbond and ifslave. + * + * 2001/4/5 - Chad N. Tindel + * - Ported to 2.4 Kernel + * + * 2001/5/2 - Jeffrey E. Mast + * - When a device is detached from a bond, the slave device is no longer + * left thinking that is has a master. + * + * 2001/5/16 - Jeffrey E. Mast + * - memset did not appropriately initialized the bond rw_locks. Used + * rwlock_init to initialize to unlocked state to prevent deadlock when + * first attempting a lock + * - Called SET_MODULE_OWNER for bond device + * + * 2001/5/17 - Tim Anderson + * - 2 paths for releasing for slave release; 1 through ioctl + * and 2) through close. Both paths need to release the same way. + * - the free slave in bond release is changing slave status before + * the free. The netdev_set_master() is intended to change slave state + * so it should not be done as part of the release process. + * - Simple rule for slave state at release: only the active in A/B and + * only one in the trunked case. + * + * 2001/6/01 - Tim Anderson + * - Now call dev_close when releasing a slave so it doesn't screw up + * out routing table. + * + * 2001/6/01 - Chad N. Tindel + * - Added /proc support for getting bond and slave information. + * Information is in /proc/net//info. + * - Changed the locking when calling bond_close to prevent deadlock. + * + * 2001/8/05 - Janice Girouard + * - correct problem where refcnt of slave is not incremented in bond_ioctl + * so the system hangs when halting. + * - correct locking problem when unable to malloc in bond_enslave. + * - adding bond_xmit_xor logic. + * - adding multiple bond device support. + * + * 2001/8/13 - Erik Habbinga + * - correct locking problem with rtnl_exlock_nowait + * + * 2001/8/23 - Janice Girouard + * - bzero initial dev_bonds, to correct oops + * - convert SIOCDEVPRIVATE to new MII ioctl calls + * + * 2001/9/13 - Takao Indoh + * - Add the BOND_CHANGE_ACTIVE ioctl implementation + * + * 2001/9/14 - Mark Huth + * - Change MII_LINK_READY to not check for end of auto-negotiation, + * but only for an up link. + * + * 2001/9/20 - Chad N. Tindel + * - Add the device field to bonding_t. Previously the net_device + * corresponding to a bond wasn't available from the bonding_t + * structure. + * + * 2001/9/25 - Janice Girouard + * - add arp_monitor for active backup mode + * + * 2001/10/23 - Takao Indoh + * - Various memory leak fixes + * + * 2001/11/5 - Mark Huth + * - Don't take rtnl lock in bond_mii_monitor as it deadlocks under + * certain hotswap conditions. + * Note: this same change may be required in bond_arp_monitor ??? + * - Remove possibility of calling bond_sethwaddr with NULL slave_dev ptr + * - Handle hot swap ethernet interface deregistration events to remove + * kernel oops following hot swap of enslaved interface + * + * 2002/1/2 - Chad N. Tindel + * - Restore original slave flags at release time. + * + * 2002/02/18 - Erik Habbinga + * - bond_release(): calling kfree on our_slave after call to + * bond_restore_slave_flags, not before + * - bond_enslave(): saving slave flags into original_flags before + * call to netdev_set_master, so the IFF_SLAVE flag doesn't end + * up in original_flags + * + * 2002/04/05 - Mark Smith and + * Steve Mead + * - Port Gleb Natapov's multicast support patchs from 2.4.12 + * to 2.4.18 adding support for multicast. + * + * 2002/06/10 - Tony Cureington + * - corrected uninitialized pointer (ifr.ifr_data) in bond_check_dev_link; + * actually changed function to use MIIPHY, then MIIREG, and finally + * ETHTOOL to determine the link status + * - fixed bad ifr_data pointer assignments in bond_ioctl + * - corrected mode 1 being reported as active-backup in bond_get_info; + * also added text to distinguish type of load balancing (rr or xor) + * - change arp_ip_target module param from "1-12s" (array of 12 ptrs) + * to "s" (a single ptr) + * + * 2002/08/30 - Jay Vosburgh + * - Removed acquisition of xmit_lock in set_multicast_list; caused + * deadlock on SMP (lock is held by caller). + * - Revamped SIOCGMIIPHY, SIOCGMIIREG portion of bond_check_dev_link(). + * + * 2002/09/18 - Jay Vosburgh + * - Fixed up bond_check_dev_link() (and callers): removed some magic + * numbers, banished local MII_ defines, wrapped ioctl calls to + * prevent EFAULT errors + * + * 2002/9/30 - Jay Vosburgh + * - make sure the ip target matches the arp_target before saving the + * hw address. + * + * 2002/9/30 - Dan Eisner + * - make sure my_ip is set before taking down the link, since + * not all switches respond if the source ip is not set. + * + * 2002/10/8 - Janice Girouard + * - read in the local ip address when enslaving a device + * - add primary support + * - make sure 2*arp_interval has passed when a new device + * is brought on-line before taking it down. + * + * 2002/09/11 - Philippe De Muyter + * - Added bond_xmit_broadcast logic. + * - Added bond_mode() support function. + * + * 2002/10/26 - Laurent Deniel + * - allow to register multicast addresses only on active slave + * (useful in active-backup mode) + * - add multicast module parameter + * - fix deletion of multicast groups after unloading module + * + * 2002/11/06 - Kameshwara Rayaprolu + * - Changes to prevent panic from closing the device twice; if we close + * the device in bond_release, we must set the original_flags to down + * so it won't be closed again by the network layer. + * + * 2002/11/07 - Tony Cureington + * - Fix arp_target_hw_addr memory leak + * - Created activebackup_arp_monitor function to handle arp monitoring + * in active backup mode - the bond_arp_monitor had several problems... + * such as allowing slaves to tx arps sequentially without any delay + * for a response + * - Renamed bond_arp_monitor to loadbalance_arp_monitor and re-wrote + * this function to just handle arp monitoring in load-balancing mode; + * it is a lot more compact now + * - Changes to ensure one and only one slave transmits in active-backup + * mode + * - Robustesize parameters; warn users about bad combinations of + * parameters; also if miimon is specified and a network driver does + * not support MII or ETHTOOL, inform the user of this + * - Changes to support link_failure_count when in arp monitoring mode + * - Fix up/down delay reported in /proc + * - Added version; log version; make version available from "modinfo -d" + * - Fixed problem in bond_check_dev_link - if the first IOCTL (SIOCGMIIPH) + * failed, the ETHTOOL ioctl never got a chance + * + * 2002/11/16 - Laurent Deniel + * - fix multicast handling in activebackup_arp_monitor + * - remove one unnecessary and confusing curr_active_slave == slave test + * in activebackup_arp_monitor + * + * 2002/11/17 - Laurent Deniel + * - fix bond_slave_info_query when slave_id = num_slaves + * + * 2002/11/19 - Janice Girouard + * - correct ifr_data reference. Update ifr_data reference + * to mii_ioctl_data struct values to avoid confusion. + * + * 2002/11/22 - Bert Barbe + * - Add support for multiple arp_ip_target + * + * 2002/12/13 - Jay Vosburgh + * - Changed to allow text strings for mode and multicast, e.g., + * insmod bonding mode=active-backup. The numbers still work. + * One change: an invalid choice will cause module load failure, + * rather than the previous behavior of just picking one. + * - Minor cleanups; got rid of dup ctype stuff, atoi function + * + * 2003/02/07 - Jay Vosburgh + * - Added use_carrier module parameter that causes miimon to + * use netif_carrier_ok() test instead of MII/ETHTOOL ioctls. + * - Minor cleanups; consolidated ioctl calls to one function. + * + * 2003/02/07 - Tony Cureington + * - Fix bond_mii_monitor() logic error that could result in + * bonding round-robin mode ignoring links after failover/recovery + * + * 2003/03/17 - Jay Vosburgh + * - kmalloc fix (GFP_KERNEL to GFP_ATOMIC) reported by + * Shmulik dot Hen at intel.com. + * - Based on discussion on mailing list, changed use of + * update_slave_cnt(), created wrapper functions for adding/removing + * slaves, changed bond_xmit_xor() to check slave_cnt instead of + * checking slave and slave->dev (which only worked by accident). + * - Misc code cleanup: get arp_send() prototype from header file, + * add max_bonds to bonding.txt. + * + * 2003/03/18 - Tsippy Mendelson and + * Shmulik Hen + * - Make sure only bond_attach_slave() and bond_detach_slave() can + * manipulate the slave list, including slave_cnt, even when in + * bond_release_all(). + * - Fixed hang in bond_release() with traffic running: + * netdev_set_master() must not be called from within the bond lock. + * + * 2003/03/18 - Tsippy Mendelson and + * Shmulik Hen + * - Fixed hang in bond_enslave() with traffic running: + * netdev_set_master() must not be called from within the bond lock. + * + * 2003/03/18 - Amir Noam + * - Added support for getting slave's speed and duplex via ethtool. + * Needed for 802.3ad and other future modes. + * + * 2003/03/18 - Tsippy Mendelson and + * Shmulik Hen + * - Enable support of modes that need to use the unique mac address of + * each slave. + * * bond_enslave(): Moved setting the slave's mac address, and + * openning it, from the application to the driver. This breaks + * backward comaptibility with old versions of ifenslave that open + * the slave before enalsving it !!!. + * * bond_release(): The driver also takes care of closing the slave + * and restoring its original mac address. + * - Removed the code that restores all base driver's flags. + * Flags are automatically restored once all undo stages are done + * properly. + * - Block possibility of enslaving before the master is up. This + * prevents putting the system in an unstable state. + * + * 2003/03/18 - Amir Noam , + * Tsippy Mendelson and + * Shmulik Hen + * - Added support for IEEE 802.3ad Dynamic link aggregation mode. + * + * 2003/05/01 - Amir Noam + * - Added ABI version control to restore compatibility between + * new/old ifenslave and new/old bonding. + * + * 2003/05/01 - Shmulik Hen + * - Fixed bug in bond_release_all(): save old value of curr_active_slave + * before setting it to NULL. + * - Changed driver versioning scheme to include version number instead + * of release date (that is already in another field). There are 3 + * fields X.Y.Z where: + * X - Major version - big behavior changes + * Y - Minor version - addition of features + * Z - Extra version - minor changes and bug fixes + * The current version is 1.0.0 as a base line. + * + * 2003/05/01 - Tsippy Mendelson and + * Amir Noam + * - Added support for lacp_rate module param. + * - Code beautification and style changes (mainly in comments). + * new version - 1.0.1 + * + * 2003/05/01 - Shmulik Hen + * - Based on discussion on mailing list, changed locking scheme + * to use lock/unlock or lock_bh/unlock_bh appropriately instead + * of lock_irqsave/unlock_irqrestore. The new scheme helps exposing + * hidden bugs and solves system hangs that occurred due to the fact + * that holding lock_irqsave doesn't prevent softirqs from running. + * This also increases total throughput since interrupts are not + * blocked on each transmitted packets or monitor timeout. + * new version - 2.0.0 + * + * 2003/05/01 - Shmulik Hen + * - Added support for Transmit load balancing mode. + * - Concentrate all assignments of curr_active_slave to a single point + * so specific modes can take actions when the primary adapter is + * changed. + * - Take the updelay parameter into consideration during bond_enslave + * since some adapters loose their link during setting the device. + * - Renamed bond_3ad_link_status_changed() to + * bond_3ad_handle_link_change() for compatibility with TLB. + * new version - 2.1.0 + * + * 2003/05/01 - Tsippy Mendelson + * - Added support for Adaptive load balancing mode which is + * equivalent to Transmit load balancing + Receive load balancing. + * new version - 2.2.0 + * + * 2003/05/15 - Jay Vosburgh + * - Applied fix to activebackup_arp_monitor posted to bonding-devel + * by Tony Cureington . Fixes ARP + * monitor endless failover bug. Version to 2.2.10 + * + * 2003/05/20 - Amir Noam + * - Fixed bug in ABI version control - Don't commit to a specific + * ABI version if receiving unsupported ioctl commands. + * + * 2003/05/22 - Jay Vosburgh + * - Fix ifenslave -c causing bond to loose existing routes; + * added bond_set_mac_address() that doesn't require the + * bond to be down. + * - In conjunction with fix for ifenslave -c, in + * bond_change_active(), changing to the already active slave + * is no longer an error (it successfully does nothing). + * + * 2003/06/30 - Amir Noam + * - Fixed bond_change_active() for ALB/TLB modes. + * Version to 2.2.14. + * + * 2003/07/29 - Amir Noam + * - Fixed ARP monitoring bug. + * Version to 2.2.15. + * + * 2003/07/31 - Willy Tarreau + * - Fixed kernel panic when using ARP monitoring without + * setting bond's IP address. + * Version to 2.2.16. + * + * 2003/08/06 - Amir Noam + * - Back port from 2.6: use alloc_netdev(); fix /proc handling; + * made stats a part of bond struct so no need to allocate + * and free it separately; use standard list operations instead + * of pre-allocated array of bonds. + * Version to 2.3.0. + * + * 2003/08/07 - Jay Vosburgh , + * Amir Noam and + * Shmulik Hen + * - Propagating master's settings: Distinguish between modes that + * use a primary slave from those that don't, and propagate settings + * accordingly; Consolidate change_active opeartions and add + * reselect_active and find_best opeartions; Decouple promiscuous + * handling from the multicast mode setting; Add support for changing + * HW address and MTU with proper unwind; Consolidate procfs code, + * add CHANGENAME handler; Enhance netdev notification handling. + * Version to 2.4.0. + * + * 2003/09/15 - Stephen Hemminger , + * Amir Noam + * - Convert /proc to seq_file interface. + * Change /proc/net/bondX/info to /proc/net/bonding/bondX. + * Set version to 2.4.1. + * + * 2003/11/20 - Amir Noam + * - Fix /proc creation/destruction. + * + * 2003/12/01 - Shmulik Hen + * - Massive cleanup - Set version to 2.5.0 + * Code changes: + * o Consolidate format of prints and debug prints. + * o Remove bonding_t/slave_t typedefs and consolidate all casts. + * o Remove dead code and unnecessary checks. + * o Consolidate starting/stopping timers. + * o Consolidate handling of primary module param throughout the code. + * o Removed multicast module param support - all settings are done + * according to mode. + * o Slave list iteration - bond is no longer part of the list, + * added cyclic list iteration macros. + * o Consolidate error handling in all xmit functions. + * Style changes: + * o Consolidate function naming and declarations. + * o Consolidate function params and local variables names. + * o Consolidate return values. + * o Consolidate curly braces. + * o Consolidate conditionals format. + * o Change struct member names and types. + * o Chomp trailing spaces, remove empty lines, fix indentations. + * o Re-organize code according to context. + * + * 2003/12/30 - Amir Noam + * - Fixed: Cannot remove and re-enslave the original active slave. + * - Fixed: Releasing the original active slave causes mac address + * duplication. + * - Add support for slaves that use ethtool_ops. + * Set version to 2.5.3. + * + * 2004/01/05 - Amir Noam + * - Save bonding parameters per bond instead of using the global values. + * Set version to 2.5.4. + * + * 2004/01/14 - Shmulik Hen + * - Enhance VLAN support: + * * Add support for VLAN hardware acceleration capable slaves. + * * Add capability to tag self generated packets in ALB/TLB modes. + * Set version to 2.6.0. + * 2004/10/29 - Mitch Williams + * - Fixed bug when unloading module while using 802.3ad. If + * spinlock debugging is turned on, this causes a stack dump. + * Solution is to move call to dev_remove_pack outside of the + * spinlock. + * Set version to 2.6.1. + * 2005/06/05 - Jay Vosburgh + * - Support for generating gratuitous ARPs in active-backup mode. + * Includes support for VLAN tagging all bonding-generated ARPs + * as needed. Set version to 2.6.2. + * 2005/06/08 - Jason Gabler + * - alternate hashing policy support for mode 2 + * * Added kernel parameter "xmit_hash_policy" to allow the selection + * of different hashing policies for mode 2. The original mode 2 + * policy is the default, now found in xmit_hash_policy_layer2(). + * * Added xmit_hash_policy_layer34() + * - Modified by Jay Vosburgh to also support mode 4. + * Set version to 2.6.3. + * 2005/09/26 - Jay Vosburgh + * - Removed backwards compatibility for old ifenslaves. Version 2.6.4. */ //#define BONDING_DEBUG 1 @@ -97,7 +557,6 @@ static char *lacp_rate = NULL; static char *xmit_hash_policy = NULL; static int arp_interval = BOND_LINK_ARP_INTERV; static char *arp_ip_target[BOND_MAX_ARP_TARGETS] = { NULL, }; -struct bond_params bonding_defaults; module_param(max_bonds, int, 0); MODULE_PARM_DESC(max_bonds, "Max number of bonded devices"); @@ -106,24 +565,17 @@ MODULE_PARM_DESC(miimon, "Link check interval in milliseconds"); module_param(updelay, int, 0); MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds"); module_param(downdelay, int, 0); -MODULE_PARM_DESC(downdelay, "Delay before considering link down, " - "in milliseconds"); +MODULE_PARM_DESC(downdelay, "Delay before considering link down, in milliseconds"); module_param(use_carrier, int, 0); -MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; " - "0 for off, 1 for on (default)"); +MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; 0 for off, 1 for on (default)"); module_param(mode, charp, 0); -MODULE_PARM_DESC(mode, "Mode of operation : 0 for balance-rr, " - "1 for active-backup, 2 for balance-xor, " - "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, " - "6 for balance-alb"); +MODULE_PARM_DESC(mode, "Mode of operation : 0 for round robin, 1 for active-backup, 2 for xor"); module_param(primary, charp, 0); MODULE_PARM_DESC(primary, "Primary network device to use"); module_param(lacp_rate, charp, 0); -MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner " - "(slow/fast)"); +MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner (slow/fast)"); module_param(xmit_hash_policy, charp, 0); -MODULE_PARM_DESC(xmit_hash_policy, "XOR hashing method: 0 for layer 2 (default)" - ", 1 for layer 3+4"); +MODULE_PARM_DESC(xmit_hash_policy, "XOR hashing method : 0 for layer 2 (default), 1 for layer 3+4"); module_param(arp_interval, int, 0); MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds"); module_param_array(arp_ip_target, charp, NULL, 0); @@ -134,27 +586,30 @@ MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form"); static const char *version = DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n"; -LIST_HEAD(bond_dev_list); +static LIST_HEAD(bond_dev_list); #ifdef CONFIG_PROC_FS static struct proc_dir_entry *bond_proc_dir = NULL; #endif -extern struct rw_semaphore bonding_rwsem; static u32 arp_target[BOND_MAX_ARP_TARGETS] = { 0, } ; static int arp_ip_count = 0; static int bond_mode = BOND_MODE_ROUNDROBIN; static int xmit_hashtype= BOND_XMIT_POLICY_LAYER2; static int lacp_fast = 0; +struct bond_parm_tbl { + char *modename; + int mode; +}; -struct bond_parm_tbl bond_lacp_tbl[] = { +static struct bond_parm_tbl bond_lacp_tbl[] = { { "slow", AD_LACP_SLOW}, { "fast", AD_LACP_FAST}, { NULL, -1}, }; -struct bond_parm_tbl bond_mode_tbl[] = { +static struct bond_parm_tbl bond_mode_tbl[] = { { "balance-rr", BOND_MODE_ROUNDROBIN}, { "active-backup", BOND_MODE_ACTIVEBACKUP}, { "balance-xor", BOND_MODE_XOR}, @@ -165,7 +620,7 @@ struct bond_parm_tbl bond_mode_tbl[] = { { NULL, -1}, }; -struct bond_parm_tbl xmit_hashtype_tbl[] = { +static struct bond_parm_tbl xmit_hashtype_tbl[] = { { "layer2", BOND_XMIT_POLICY_LAYER2}, { "layer3+4", BOND_XMIT_POLICY_LAYER34}, { NULL, -1}, @@ -173,11 +628,12 @@ struct bond_parm_tbl xmit_hashtype_tbl[] = { /*-------------------------- Forward declarations ---------------------------*/ +static inline void bond_set_mode_ops(struct bonding *bond, int mode); static void bond_send_gratuitous_arp(struct bonding *bond); /*---------------------------- General routines -----------------------------*/ -const char *bond_mode_name(int mode) +static const char *bond_mode_name(int mode) { switch (mode) { case BOND_MODE_ROUNDROBIN : @@ -454,7 +910,7 @@ static void bond_vlan_rx_add_vid(struct net_device *bond_dev, uint16_t vid) res = bond_add_vlan(bond, vid); if (res) { printk(KERN_ERR DRV_NAME - ": %s: Error: Failed to add vlan id %d\n", + ": %s: Failed to add vlan id %d\n", bond_dev->name, vid); } } @@ -488,7 +944,7 @@ static void bond_vlan_rx_kill_vid(struct net_device *bond_dev, uint16_t vid) res = bond_del_vlan(bond, vid); if (res) { printk(KERN_ERR DRV_NAME - ": %s: Error: Failed to remove vlan id %d\n", + ": %s: Failed to remove vlan id %d\n", bond_dev->name, vid); } } @@ -993,7 +1449,7 @@ static struct slave *bond_find_best_slave(struct bonding *bond) * * Warning: Caller must hold curr_slave_lock for writing. */ -void bond_change_active_slave(struct bonding *bond, struct slave *new_active) +static void bond_change_active_slave(struct bonding *bond, struct slave *new_active) { struct slave *old_active = bond->curr_active_slave; @@ -1067,7 +1523,7 @@ void bond_change_active_slave(struct bonding *bond, struct slave *new_active) * * Warning: Caller must hold curr_slave_lock for writing. */ -void bond_select_active_slave(struct bonding *bond) +static void bond_select_active_slave(struct bonding *bond) { struct slave *best_slave; @@ -1135,7 +1591,7 @@ static void bond_detach_slave(struct bonding *bond, struct slave *slave) /*---------------------------------- IOCTL ----------------------------------*/ -int bond_sethwaddr(struct net_device *bond_dev, struct net_device *slave_dev) +static int bond_sethwaddr(struct net_device *bond_dev, struct net_device *slave_dev) { dprintk("bond_dev=%p\n", bond_dev); dprintk("slave_dev=%p\n", slave_dev); @@ -1175,7 +1631,7 @@ static int bond_compute_features(struct bonding *bond) } /* enslave device to bond device */ -int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) +static int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) { struct bonding *bond = bond_dev->priv; struct slave *new_slave = NULL; @@ -1188,8 +1644,8 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) if (!bond->params.use_carrier && slave_dev->ethtool_ops == NULL && slave_dev->do_ioctl == NULL) { printk(KERN_WARNING DRV_NAME - ": %s: Warning: no link monitoring support for %s\n", - bond_dev->name, slave_dev->name); + ": Warning : no link monitoring support for %s\n", + slave_dev->name); } /* bond must be initialized by bond_open() before enslaving */ @@ -1210,17 +1666,17 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) dprintk("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name); if (!list_empty(&bond->vlan_list)) { printk(KERN_ERR DRV_NAME - ": %s: Error: cannot enslave VLAN " + ": Error: cannot enslave VLAN " "challenged slave %s on VLAN enabled " - "bond %s\n", bond_dev->name, slave_dev->name, + "bond %s\n", slave_dev->name, bond_dev->name); return -EPERM; } else { printk(KERN_WARNING DRV_NAME - ": %s: Warning: enslaved VLAN challenged " + ": Warning: enslaved VLAN challenged " "slave %s. Adding VLANs will be blocked as " "long as %s is part of bond %s\n", - bond_dev->name, slave_dev->name, slave_dev->name, + slave_dev->name, slave_dev->name, bond_dev->name); bond_dev->features |= NETIF_F_VLAN_CHALLENGED; } @@ -1250,11 +1706,12 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) if (slave_dev->set_mac_address == NULL) { printk(KERN_ERR DRV_NAME - ": %s: Error: The slave device you specified does " - "not support setting the MAC address. " - "Your kernel likely does not support slave " - "devices.\n", bond_dev->name); - res = -EOPNOTSUPP; + ": Error: The slave device you specified does " + "not support setting the MAC address.\n"); + printk(KERN_ERR + "Your kernel likely does not support slave devices.\n"); + + res = -EOPNOTSUPP; goto err_undo_flags; } @@ -1370,21 +1827,21 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) * the messages for netif_carrier. */ printk(KERN_WARNING DRV_NAME - ": %s: Warning: MII and ETHTOOL support not " + ": Warning: MII and ETHTOOL support not " "available for interface %s, and " "arp_interval/arp_ip_target module parameters " "not specified, thus bonding will not detect " "link failures! see bonding.txt for details.\n", - bond_dev->name, slave_dev->name); + slave_dev->name); } else if (link_reporting == -1) { /* unable get link status using mii/ethtool */ printk(KERN_WARNING DRV_NAME - ": %s: Warning: can't get link status from " + ": Warning: can't get link status from " "interface %s; the network driver associated " "with this interface does not support MII or " "ETHTOOL link status reporting, thus miimon " "has no effect on this interface.\n", - bond_dev->name, slave_dev->name); + slave_dev->name); } } @@ -1411,15 +1868,15 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) if (bond_update_speed_duplex(new_slave) && (new_slave->link != BOND_LINK_DOWN)) { printk(KERN_WARNING DRV_NAME - ": %s: Warning: failed to get speed and duplex from %s, " + ": Warning: failed to get speed and duplex from %s, " "assumed to be 100Mb/sec and Full.\n", - bond_dev->name, new_slave->dev->name); + new_slave->dev->name); if (bond->params.mode == BOND_MODE_8023AD) { - printk(KERN_WARNING DRV_NAME - ": %s: Warning: Operation of 802.3ad mode requires ETHTOOL " + printk(KERN_WARNING + "Operation of 802.3ad mode requires ETHTOOL " "support in base driver for proper aggregator " - "selection.\n", bond_dev->name); + "selection.\n"); } } @@ -1501,10 +1958,6 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) write_unlock_bh(&bond->lock); - res = bond_create_slave_symlinks(bond_dev, slave_dev); - if (res) - goto err_unset_master; - printk(KERN_INFO DRV_NAME ": %s: enslaving %s as a%s interface with a%s link.\n", bond_dev->name, slave_dev->name, @@ -1546,7 +1999,7 @@ int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) * for Bonded connections: * The first up interface should be left on and all others downed. */ -int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) +static int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) { struct bonding *bond = bond_dev->priv; struct slave *slave, *oldcurrent; @@ -1557,7 +2010,7 @@ int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) if (!(slave_dev->flags & IFF_SLAVE) || (slave_dev->master != bond_dev)) { printk(KERN_ERR DRV_NAME - ": %s: Error: cannot release %s.\n", + ": Error: %s: cannot release %s.\n", bond_dev->name, slave_dev->name); return -EINVAL; } @@ -1578,12 +2031,11 @@ int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) ETH_ALEN); if (!mac_addr_differ && (bond->slave_cnt > 1)) { printk(KERN_WARNING DRV_NAME - ": %s: Warning: the permanent HWaddr of %s " + ": Warning: the permanent HWaddr of %s " "- %02X:%02X:%02X:%02X:%02X:%02X - is " "still in use by %s. Set the HWaddr of " "%s to a different address to avoid " "conflicts.\n", - bond_dev->name, slave_dev->name, slave->perm_hwaddr[0], slave->perm_hwaddr[1], @@ -1659,28 +2111,24 @@ int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) bond_dev->features |= NETIF_F_VLAN_CHALLENGED; } else { printk(KERN_WARNING DRV_NAME - ": %s: Warning: clearing HW address of %s while it " + ": Warning: clearing HW address of %s while it " "still has VLANs.\n", - bond_dev->name, bond_dev->name); - printk(KERN_WARNING DRV_NAME - ": %s: When re-adding slaves, make sure the bond's " - "HW address matches its VLANs'.\n", bond_dev->name); + printk(KERN_WARNING DRV_NAME + ": When re-adding slaves, make sure the bond's " + "HW address matches its VLANs'.\n"); } } else if ((bond_dev->features & NETIF_F_VLAN_CHALLENGED) && !bond_has_challenged_slaves(bond)) { printk(KERN_INFO DRV_NAME - ": %s: last VLAN challenged slave %s " + ": last VLAN challenged slave %s " "left bond %s. VLAN blocking is removed\n", - bond_dev->name, slave_dev->name, bond_dev->name); + slave_dev->name, bond_dev->name); bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED; } write_unlock_bh(&bond->lock); - /* must do this from outside any spinlocks */ - bond_destroy_slave_symlinks(bond_dev, slave_dev); - bond_del_vlans_from_slave(bond, slave_dev); /* If the mode USES_PRIMARY, then we should only remove its @@ -1772,7 +2220,6 @@ static int bond_release_all(struct net_device *bond_dev) */ write_unlock_bh(&bond->lock); - bond_destroy_slave_symlinks(bond_dev, slave_dev); bond_del_vlans_from_slave(bond, slave_dev); /* If the mode USES_PRIMARY, then we should only remove its @@ -1827,13 +2274,12 @@ static int bond_release_all(struct net_device *bond_dev) bond_dev->features |= NETIF_F_VLAN_CHALLENGED; } else { printk(KERN_WARNING DRV_NAME - ": %s: Warning: clearing HW address of %s while it " + ": Warning: clearing HW address of %s while it " "still has VLANs.\n", - bond_dev->name, bond_dev->name); - printk(KERN_WARNING DRV_NAME - ": %s: When re-adding slaves, make sure the bond's " - "HW address matches its VLANs'.\n", bond_dev->name); + printk(KERN_WARNING DRV_NAME + ": When re-adding slaves, make sure the bond's " + "HW address matches its VLANs'.\n"); } printk(KERN_INFO DRV_NAME @@ -1951,7 +2397,7 @@ static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *in /*-------------------------------- Monitoring -------------------------------*/ /* this function is called regularly to monitor each slave's link. */ -void bond_mii_monitor(struct net_device *bond_dev) +static void bond_mii_monitor(struct net_device *bond_dev) { struct bonding *bond = bond_dev->priv; struct slave *slave, *oldcurrent; @@ -2150,11 +2596,8 @@ void bond_mii_monitor(struct net_device *bond_dev) break; default: /* Should not happen */ - printk(KERN_ERR DRV_NAME - ": %s: Error: %s Illegal value (link=%d)\n", - bond_dev->name, - slave->dev->name, - slave->link); + printk(KERN_ERR "bonding: Error: %s Illegal value (link=%d)\n", + slave->dev->name, slave->link); goto out; } /* end of switch (slave->link) */ @@ -2278,9 +2721,7 @@ static void bond_arp_send_all(struct bonding *bond, struct slave *slave) struct flowi fl; struct rtable *rt; - for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) { - if (!targets[i]) - continue; + for (i = 0; (i < BOND_MAX_ARP_TARGETS) && targets[i]; i++) { dprintk("basa: target %x\n", targets[i]); if (list_empty(&bond->vlan_list)) { dprintk("basa: empty vlan: arp_send\n"); @@ -2384,7 +2825,7 @@ static void bond_send_gratuitous_arp(struct bonding *bond) * arp is transmitted to generate traffic. see activebackup_arp_monitor for * arp monitoring in active backup mode. */ -void bond_loadbalance_arp_mon(struct net_device *bond_dev) +static void bond_loadbalance_arp_mon(struct net_device *bond_dev) { struct bonding *bond = bond_dev->priv; struct slave *slave, *oldcurrent; @@ -2522,7 +2963,7 @@ void bond_loadbalance_arp_mon(struct net_device *bond_dev) * may have received. * see loadbalance_arp_monitor for arp monitoring in load balancing mode */ -void bond_activebackup_arp_mon(struct net_device *bond_dev) +static void bond_activebackup_arp_mon(struct net_device *bond_dev) { struct bonding *bond = bond_dev->priv; struct slave *slave; @@ -2808,8 +3249,6 @@ static void bond_info_show_master(struct seq_file *seq) { struct bonding *bond = seq->private; struct slave *curr; - int i; - u32 target; read_lock(&bond->curr_slave_lock); curr = bond->curr_active_slave; @@ -2818,17 +3257,10 @@ static void bond_info_show_master(struct seq_file *seq) seq_printf(seq, "Bonding Mode: %s\n", bond_mode_name(bond->params.mode)); - if (bond->params.mode == BOND_MODE_XOR || - bond->params.mode == BOND_MODE_8023AD) { - seq_printf(seq, "Transmit Hash Policy: %s (%d)\n", - xmit_hashtype_tbl[bond->params.xmit_policy].modename, - bond->params.xmit_policy); - } - if (USES_PRIMARY(bond->params.mode)) { seq_printf(seq, "Primary Slave: %s\n", - (bond->primary_slave) ? - bond->primary_slave->dev->name : "None"); + (bond->params.primary[0]) ? + bond->params.primary : "None"); seq_printf(seq, "Currently Active Slave: %s\n", (curr) ? curr->dev->name : "None"); @@ -2841,27 +3273,6 @@ static void bond_info_show_master(struct seq_file *seq) seq_printf(seq, "Down Delay (ms): %d\n", bond->params.downdelay * bond->params.miimon); - - /* ARP information */ - if(bond->params.arp_interval > 0) { - int printed=0; - seq_printf(seq, "ARP Polling Interval (ms): %d\n", - bond->params.arp_interval); - - seq_printf(seq, "ARP IP target/s (n.n.n.n form):"); - - for(i = 0; (i < BOND_MAX_ARP_TARGETS) ;i++) { - if (!bond->params.arp_targets[i]) - continue; - if (printed) - seq_printf(seq, ","); - target = ntohl(bond->params.arp_targets[i]); - seq_printf(seq, " %d.%d.%d.%d", HIPQUAD(target)); - printed = 1; - } - seq_printf(seq, "\n"); - } - if (bond->params.mode == BOND_MODE_8023AD) { struct ad_info ad_info; @@ -3067,10 +3478,7 @@ static int bond_event_changename(struct bonding *bond) bond_remove_proc_entry(bond); bond_create_proc_entry(bond); #endif - down_write(&(bonding_rwsem)); - bond_destroy_sysfs_entry(bond); - bond_create_sysfs_entry(bond); - up_write(&(bonding_rwsem)); + return NOTIFY_DONE; } @@ -3547,7 +3955,6 @@ static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd return -EPERM; } - down_write(&(bonding_rwsem)); slave_dev = dev_get_by_name(ifr->ifr_slave); dprintk("slave_dev=%p: \n", slave_dev); @@ -3580,7 +3987,6 @@ static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd dev_put(slave_dev); } - up_write(&(bonding_rwsem)); return res; } @@ -3665,7 +4071,6 @@ static int bond_change_mtu(struct net_device *bond_dev, int new_mtu) bond_for_each_slave(bond, slave, i) { dprintk("s %p s->p %p c_m %p\n", slave, slave->prev, slave->dev->change_mtu); - res = dev_set_mtu(slave->dev, new_mtu); if (res) { @@ -3992,9 +4397,8 @@ static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev) struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); if (!skb2) { printk(KERN_ERR DRV_NAME - ": %s: Error: bond_xmit_broadcast(): " - "skb_clone() failed\n", - bond_dev->name); + ": Error: bond_xmit_broadcast(): " + "skb_clone() failed\n"); continue; } @@ -4027,7 +4431,7 @@ static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev) /* * set bond mode specific net device operations */ -void bond_set_mode_ops(struct bonding *bond, int mode) +static inline void bond_set_mode_ops(struct bonding *bond, int mode) { struct net_device *bond_dev = bond->dev; @@ -4063,8 +4467,7 @@ void bond_set_mode_ops(struct bonding *bond, int mode) default: /* Should never happen, mode already checked */ printk(KERN_ERR DRV_NAME - ": %s: Error: Unknown bonding mode %d\n", - bond_dev->name, + ": Error: Unknown bonding mode %d\n", mode); break; } @@ -4088,7 +4491,7 @@ static struct ethtool_ops bond_ethtool_ops = { * Does not allocate but creates a /proc entry. * Allowed to fail. */ -static int bond_init(struct net_device *bond_dev, struct bond_params *params) +static int __init bond_init(struct net_device *bond_dev, struct bond_params *params) { struct bonding *bond = bond_dev->priv; @@ -4162,7 +4565,7 @@ static int bond_init(struct net_device *bond_dev, struct bond_params *params) /* De-initialize device specific data. * Caller must hold rtnl_lock. */ -void bond_deinit(struct net_device *bond_dev) +static inline void bond_deinit(struct net_device *bond_dev) { struct bonding *bond = bond_dev->priv; @@ -4198,7 +4601,7 @@ static void bond_free_all(void) * Convert string input module parms. Accept either the * number of the mode or its string name. */ -int bond_parse_parm(char *mode_arg, struct bond_parm_tbl *tbl) +static inline int bond_parse_parm(char *mode_arg, struct bond_parm_tbl *tbl) { int i; @@ -4267,7 +4670,7 @@ static int bond_check_params(struct bond_params *params) if (max_bonds < 1 || max_bonds > INT_MAX) { printk(KERN_WARNING DRV_NAME ": Warning: max_bonds (%d) not in range %d-%d, so it " - "was reset to BOND_DEFAULT_MAX_BONDS (%d)\n", + "was reset to BOND_DEFAULT_MAX_BONDS (%d)", max_bonds, 1, INT_MAX, BOND_DEFAULT_MAX_BONDS); max_bonds = BOND_DEFAULT_MAX_BONDS; } @@ -4478,96 +4881,81 @@ static int bond_check_params(struct bond_params *params) return 0; } -/* Create a new bond based on the specified name and bonding parameters. - * Caller must NOT hold rtnl_lock; we need to release it here before we - * set up our sysfs entries. - */ -int bond_create(char *name, struct bond_params *params, struct bonding **newbond) -{ - struct net_device *bond_dev; - int res; - - rtnl_lock(); - bond_dev = alloc_netdev(sizeof(struct bonding), name, ether_setup); - if (!bond_dev) { - printk(KERN_ERR DRV_NAME - ": %s: eek! can't alloc netdev!\n", - name); - res = -ENOMEM; - goto out_rtnl; - } - - /* bond_init() must be called after dev_alloc_name() (for the - * /proc files), but before register_netdevice(), because we - * need to set function pointers. - */ - - res = bond_init(bond_dev, params); - if (res < 0) { - goto out_netdev; - } - - SET_MODULE_OWNER(bond_dev); - - res = register_netdevice(bond_dev); - if (res < 0) { - goto out_bond; - } - if (newbond) - *newbond = bond_dev->priv; - - rtnl_unlock(); /* allows sysfs registration of net device */ - res = bond_create_sysfs_entry(bond_dev->priv); - goto done; -out_bond: - bond_deinit(bond_dev); -out_netdev: - free_netdev(bond_dev); -out_rtnl: - rtnl_unlock(); -done: - return res; -} - static int __init bonding_init(void) { + struct bond_params params; int i; int res; - char new_bond_name[8]; /* Enough room for 999 bonds at init. */ printk(KERN_INFO "%s", version); - res = bond_check_params(&bonding_defaults); + res = bond_check_params(¶ms); if (res) { - goto out; + return res; } + rtnl_lock(); + #ifdef CONFIG_PROC_FS bond_create_proc_dir(); #endif + for (i = 0; i < max_bonds; i++) { - sprintf(new_bond_name, "bond%d",i); - res = bond_create(new_bond_name,&bonding_defaults, NULL); - if (res) - goto err; - } + struct net_device *bond_dev; - res = bond_create_sysfs(); - if (res) - goto err; + bond_dev = alloc_netdev(sizeof(struct bonding), "", ether_setup); + if (!bond_dev) { + res = -ENOMEM; + goto out_err; + } + res = dev_alloc_name(bond_dev, "bond%d"); + if (res < 0) { + free_netdev(bond_dev); + goto out_err; + } + + /* bond_init() must be called after dev_alloc_name() (for the + * /proc files), but before register_netdevice(), because we + * need to set function pointers. + */ + res = bond_init(bond_dev, ¶ms); + if (res < 0) { + free_netdev(bond_dev); + goto out_err; + } + + SET_MODULE_OWNER(bond_dev); + + res = register_netdevice(bond_dev); + if (res < 0) { + bond_deinit(bond_dev); + free_netdev(bond_dev); + goto out_err; + } + } + + rtnl_unlock(); register_netdevice_notifier(&bond_netdev_notifier); register_inetaddr_notifier(&bond_inetaddr_notifier); - goto out; -err: + return 0; + +out_err: + /* + * rtnl_unlock() will run netdev_run_todo(), putting the + * thus-far-registered bonding devices into a state which + * unregigister_netdevice() will accept + */ + rtnl_unlock(); rtnl_lock(); + + /* free and unregister all bonds that were successfully added */ bond_free_all(); - bond_destroy_sysfs(); + rtnl_unlock(); -out: - return res; + return res; } static void __exit bonding_exit(void) @@ -4577,7 +4965,6 @@ static void __exit bonding_exit(void) rtnl_lock(); bond_free_all(); - bond_destroy_sysfs(); rtnl_unlock(); } diff --git a/trunk/drivers/net/bonding/bond_sysfs.c b/trunk/drivers/net/bonding/bond_sysfs.c deleted file mode 100644 index 32d13da43a0b..000000000000 --- a/trunk/drivers/net/bonding/bond_sysfs.c +++ /dev/null @@ -1,1358 +0,0 @@ - -/* - * Copyright(c) 2004-2005 Intel Corporation. All rights reserved. - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY - * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * The full GNU General Public License is included in this distribution in the - * file called LICENSE. - * - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/* #define BONDING_DEBUG 1 */ -#include "bonding.h" -#define to_class_dev(obj) container_of(obj,struct class_device,kobj) -#define to_net_dev(class) container_of(class, struct net_device, class_dev) -#define to_bond(cd) ((struct bonding *)(to_net_dev(cd)->priv)) - -/*---------------------------- Declarations -------------------------------*/ - - -extern struct list_head bond_dev_list; -extern struct bond_params bonding_defaults; -extern struct bond_parm_tbl bond_mode_tbl[]; -extern struct bond_parm_tbl bond_lacp_tbl[]; -extern struct bond_parm_tbl xmit_hashtype_tbl[]; - -static int expected_refcount = -1; -static struct class *netdev_class; -/*--------------------------- Data Structures -----------------------------*/ - -/* Bonding sysfs lock. Why can't we just use the subsytem lock? - * Because kobject_register tries to acquire the subsystem lock. If - * we already hold the lock (which we would if the user was creating - * a new bond through the sysfs interface), we deadlock. - * This lock is only needed when deleting a bond - we need to make sure - * that we don't collide with an ongoing ioctl. - */ - -struct rw_semaphore bonding_rwsem; - - - - -/*------------------------------ Functions --------------------------------*/ - -/* - * "show" function for the bond_masters attribute. - * The class parameter is ignored. - */ -static ssize_t bonding_show_bonds(struct class *cls, char *buffer) -{ - int res = 0; - struct bonding *bond; - - down_read(&(bonding_rwsem)); - - list_for_each_entry(bond, &bond_dev_list, bond_list) { - if (res > (PAGE_SIZE - IFNAMSIZ)) { - /* not enough space for another interface name */ - if ((PAGE_SIZE - res) > 10) - res = PAGE_SIZE - 10; - res += sprintf(buffer + res, "++more++"); - break; - } - res += sprintf(buffer + res, "%s ", - bond->dev->name); - } - res += sprintf(buffer + res, "\n"); - res++; - up_read(&(bonding_rwsem)); - return res; -} - -/* - * "store" function for the bond_masters attribute. This is what - * creates and deletes entire bonds. - * - * The class parameter is ignored. - * - */ - -static ssize_t bonding_store_bonds(struct class *cls, const char *buffer, size_t count) -{ - char command[IFNAMSIZ + 1] = {0, }; - char *ifname; - int res = count; - struct bonding *bond; - struct bonding *nxt; - - down_write(&(bonding_rwsem)); - sscanf(buffer, "%16s", command); /* IFNAMSIZ*/ - ifname = command + 1; - if ((strlen(command) <= 1) || - !dev_valid_name(ifname)) - goto err_no_cmd; - - if (command[0] == '+') { - - /* Check to see if the bond already exists. */ - list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list) - if (strnicmp(bond->dev->name, ifname, IFNAMSIZ) == 0) { - printk(KERN_ERR DRV_NAME - ": cannot add bond %s; it already exists\n", - ifname); - res = -EPERM; - goto out; - } - - printk(KERN_INFO DRV_NAME - ": %s is being created...\n", ifname); - if (bond_create(ifname, &bonding_defaults, &bond)) { - printk(KERN_INFO DRV_NAME - ": %s interface already exists. Bond creation failed.\n", - ifname); - res = -EPERM; - } - goto out; - } - - if (command[0] == '-') { - list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list) - if (strnicmp(bond->dev->name, ifname, IFNAMSIZ) == 0) { - rtnl_lock(); - /* check the ref count on the bond's kobject. - * If it's > expected, then there's a file open, - * and we have to fail. - */ - if (atomic_read(&bond->dev->class_dev.kobj.kref.refcount) - > expected_refcount){ - rtnl_unlock(); - printk(KERN_INFO DRV_NAME - ": Unable remove bond %s due to open references.\n", - ifname); - res = -EPERM; - goto out; - } - printk(KERN_INFO DRV_NAME - ": %s is being deleted...\n", - bond->dev->name); - unregister_netdevice(bond->dev); - bond_deinit(bond->dev); - bond_destroy_sysfs_entry(bond); - rtnl_unlock(); - goto out; - } - - printk(KERN_ERR DRV_NAME - ": unable to delete non-existent bond %s\n", ifname); - res = -ENODEV; - goto out; - } - -err_no_cmd: - printk(KERN_ERR DRV_NAME - ": no command found in bonding_masters. Use +ifname or -ifname.\n"); - res = -EPERM; - - /* Always return either count or an error. If you return 0, you'll - * get called forever, which is bad. - */ -out: - up_write(&(bonding_rwsem)); - return res; -} -/* class attribute for bond_masters file. This ends up in /sys/class/net */ -static CLASS_ATTR(bonding_masters, S_IWUSR | S_IRUGO, - bonding_show_bonds, bonding_store_bonds); - -int bond_create_slave_symlinks(struct net_device *master, struct net_device *slave) -{ - char linkname[IFNAMSIZ+7]; - int ret = 0; - - /* first, create a link from the slave back to the master */ - ret = sysfs_create_link(&(slave->class_dev.kobj), &(master->class_dev.kobj), - "master"); - if (ret) - return ret; - /* next, create a link from the master to the slave */ - sprintf(linkname,"slave_%s",slave->name); - ret = sysfs_create_link(&(master->class_dev.kobj), &(slave->class_dev.kobj), - linkname); - return ret; - -} - -void bond_destroy_slave_symlinks(struct net_device *master, struct net_device *slave) -{ - char linkname[IFNAMSIZ+7]; - - sysfs_remove_link(&(slave->class_dev.kobj), "master"); - sprintf(linkname,"slave_%s",slave->name); - sysfs_remove_link(&(master->class_dev.kobj), linkname); -} - - -/* - * Show the slaves in the current bond. - */ -static ssize_t bonding_show_slaves(struct class_device *cd, char *buf) -{ - struct slave *slave; - int i, res = 0; - struct bonding *bond = to_bond(cd); - - read_lock_bh(&bond->lock); - bond_for_each_slave(bond, slave, i) { - if (res > (PAGE_SIZE - IFNAMSIZ)) { - /* not enough space for another interface name */ - if ((PAGE_SIZE - res) > 10) - res = PAGE_SIZE - 10; - res += sprintf(buf + res, "++more++"); - break; - } - res += sprintf(buf + res, "%s ", slave->dev->name); - } - read_unlock_bh(&bond->lock); - res += sprintf(buf + res, "\n"); - res++; - return res; -} - -/* - * Set the slaves in the current bond. The bond interface must be - * up for this to succeed. - * This function is largely the same flow as bonding_update_bonds(). - */ -static ssize_t bonding_store_slaves(struct class_device *cd, const char *buffer, size_t count) -{ - char command[IFNAMSIZ + 1] = { 0, }; - char *ifname; - int i, res, found, ret = count; - struct slave *slave; - struct net_device *dev = 0; - struct bonding *bond = to_bond(cd); - - /* Quick sanity check -- is the bond interface up? */ - if (!(bond->dev->flags & IFF_UP)) { - printk(KERN_ERR DRV_NAME - ": %s: Unable to update slaves because interface is down.\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - /* Note: We can't hold bond->lock here, as bond_create grabs it. */ - - sscanf(buffer, "%16s", command); /* IFNAMSIZ*/ - ifname = command + 1; - if ((strlen(command) <= 1) || - !dev_valid_name(ifname)) - goto err_no_cmd; - - if (command[0] == '+') { - - /* Got a slave name in ifname. Is it already in the list? */ - found = 0; - read_lock_bh(&bond->lock); - bond_for_each_slave(bond, slave, i) - if (strnicmp(slave->dev->name, ifname, IFNAMSIZ) == 0) { - printk(KERN_ERR DRV_NAME - ": %s: Interface %s is already enslaved!\n", - bond->dev->name, ifname); - ret = -EPERM; - read_unlock_bh(&bond->lock); - goto out; - } - - read_unlock_bh(&bond->lock); - printk(KERN_INFO DRV_NAME ": %s: Adding slave %s.\n", - bond->dev->name, ifname); - dev = dev_get_by_name(ifname); - if (!dev) { - printk(KERN_INFO DRV_NAME - ": %s: Interface %s does not exist!\n", - bond->dev->name, ifname); - ret = -EPERM; - goto out; - } - else - dev_put(dev); - - if (dev->flags & IFF_UP) { - printk(KERN_ERR DRV_NAME - ": %s: Error: Unable to enslave %s " - "because it is already up.\n", - bond->dev->name, dev->name); - ret = -EPERM; - goto out; - } - /* If this is the first slave, then we need to set - the master's hardware address to be the same as the - slave's. */ - if (!(*((u32 *) & (bond->dev->dev_addr[0])))) { - memcpy(bond->dev->dev_addr, dev->dev_addr, - dev->addr_len); - } - - /* Set the slave's MTU to match the bond */ - if (dev->mtu != bond->dev->mtu) { - if (dev->change_mtu) { - res = dev->change_mtu(dev, - bond->dev->mtu); - if (res) { - ret = res; - goto out; - } - } else { - dev->mtu = bond->dev->mtu; - } - } - rtnl_lock(); - res = bond_enslave(bond->dev, dev); - rtnl_unlock(); - if (res) { - ret = res; - } - goto out; - } - - if (command[0] == '-') { - dev = NULL; - bond_for_each_slave(bond, slave, i) - if (strnicmp(slave->dev->name, ifname, IFNAMSIZ) == 0) { - dev = slave->dev; - break; - } - if (dev) { - printk(KERN_INFO DRV_NAME ": %s: Removing slave %s\n", - bond->dev->name, dev->name); - rtnl_lock(); - res = bond_release(bond->dev, dev); - rtnl_unlock(); - if (res) { - ret = res; - goto out; - } - /* set the slave MTU to the default */ - if (dev->change_mtu) { - dev->change_mtu(dev, 1500); - } else { - dev->mtu = 1500; - } - } - else { - printk(KERN_ERR DRV_NAME ": unable to remove non-existent slave %s for bond %s.\n", - ifname, bond->dev->name); - ret = -ENODEV; - } - goto out; - } - -err_no_cmd: - printk(KERN_ERR DRV_NAME ": no command found in slaves file for bond %s. Use +ifname or -ifname.\n", bond->dev->name); - ret = -EPERM; - -out: - return ret; -} - -static CLASS_DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, bonding_store_slaves); - -/* - * Show and set the bonding mode. The bond interface must be down to - * change the mode. - */ -static ssize_t bonding_show_mode(struct class_device *cd, char *buf) -{ - struct bonding *bond = to_bond(cd); - - return sprintf(buf, "%s %d\n", - bond_mode_tbl[bond->params.mode].modename, - bond->params.mode) + 1; -} - -static ssize_t bonding_store_mode(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - if (bond->dev->flags & IFF_UP) { - printk(KERN_ERR DRV_NAME - ": unable to update mode of %s because interface is up.\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - new_value = bond_parse_parm((char *)buf, bond_mode_tbl); - if (new_value < 0) { - printk(KERN_ERR DRV_NAME - ": %s: Ignoring invalid mode value %.*s.\n", - bond->dev->name, - (int)strlen(buf) - 1, buf); - ret = -EINVAL; - goto out; - } else { - bond->params.mode = new_value; - bond_set_mode_ops(bond, bond->params.mode); - printk(KERN_INFO DRV_NAME ": %s: setting mode to %s (%d).\n", - bond->dev->name, bond_mode_tbl[new_value].modename, new_value); - } -out: - return ret; -} -static CLASS_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, bonding_show_mode, bonding_store_mode); - -/* - * Show and set the bonding transmit hash method. The bond interface must be down to - * change the xmit hash policy. - */ -static ssize_t bonding_show_xmit_hash(struct class_device *cd, char *buf) -{ - int count; - struct bonding *bond = to_bond(cd); - - if ((bond->params.mode != BOND_MODE_XOR) && - (bond->params.mode != BOND_MODE_8023AD)) { - // Not Applicable - count = sprintf(buf, "NA\n") + 1; - } else { - count = sprintf(buf, "%s %d\n", - xmit_hashtype_tbl[bond->params.xmit_policy].modename, - bond->params.xmit_policy) + 1; - } - - return count; -} - -static ssize_t bonding_store_xmit_hash(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - if (bond->dev->flags & IFF_UP) { - printk(KERN_ERR DRV_NAME - "%s: Interface is up. Unable to update xmit policy.\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - if ((bond->params.mode != BOND_MODE_XOR) && - (bond->params.mode != BOND_MODE_8023AD)) { - printk(KERN_ERR DRV_NAME - "%s: Transmit hash policy is irrelevant in this mode.\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - new_value = bond_parse_parm((char *)buf, xmit_hashtype_tbl); - if (new_value < 0) { - printk(KERN_ERR DRV_NAME - ": %s: Ignoring invalid xmit hash policy value %.*s.\n", - bond->dev->name, - (int)strlen(buf) - 1, buf); - ret = -EINVAL; - goto out; - } else { - bond->params.xmit_policy = new_value; - bond_set_mode_ops(bond, bond->params.mode); - printk(KERN_INFO DRV_NAME ": %s: setting xmit hash policy to %s (%d).\n", - bond->dev->name, xmit_hashtype_tbl[new_value].modename, new_value); - } -out: - return ret; -} -static CLASS_DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, bonding_show_xmit_hash, bonding_store_xmit_hash); - -/* - * Show and set the arp timer interval. There are two tricky bits - * here. First, if ARP monitoring is activated, then we must disable - * MII monitoring. Second, if the ARP timer isn't running, we must - * start it. - */ -static ssize_t bonding_show_arp_interval(struct class_device *cd, char *buf) -{ - struct bonding *bond = to_bond(cd); - - return sprintf(buf, "%d\n", bond->params.arp_interval) + 1; -} - -static ssize_t bonding_store_arp_interval(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - if (sscanf(buf, "%d", &new_value) != 1) { - printk(KERN_ERR DRV_NAME - ": %s: no arp_interval value specified.\n", - bond->dev->name); - ret = -EINVAL; - goto out; - } - if (new_value < 0) { - printk(KERN_ERR DRV_NAME - ": %s: Invalid arp_interval value %d not in range 1-%d; rejected.\n", - bond->dev->name, new_value, INT_MAX); - ret = -EINVAL; - goto out; - } - - printk(KERN_INFO DRV_NAME - ": %s: Setting ARP monitoring interval to %d.\n", - bond->dev->name, new_value); - bond->params.arp_interval = new_value; - if (bond->params.miimon) { - printk(KERN_INFO DRV_NAME - ": %s: ARP monitoring cannot be used with MII monitoring. " - "%s Disabling MII monitoring.\n", - bond->dev->name, bond->dev->name); - bond->params.miimon = 0; - /* Kill MII timer, else it brings bond's link down */ - if (bond->arp_timer.function) { - printk(KERN_INFO DRV_NAME - ": %s: Kill MII timer, else it brings bond's link down...\n", - bond->dev->name); - del_timer_sync(&bond->mii_timer); - } - } - if (!bond->params.arp_targets[0]) { - printk(KERN_INFO DRV_NAME - ": %s: ARP monitoring has been set up, " - "but no ARP targets have been specified.\n", - bond->dev->name); - } - if (bond->dev->flags & IFF_UP) { - /* If the interface is up, we may need to fire off - * the ARP timer. If the interface is down, the - * timer will get fired off when the open function - * is called. - */ - if (bond->arp_timer.function) { - /* The timer's already set up, so fire it off */ - mod_timer(&bond->arp_timer, jiffies + 1); - } else { - /* Set up the timer. */ - init_timer(&bond->arp_timer); - bond->arp_timer.expires = jiffies + 1; - bond->arp_timer.data = - (unsigned long) bond->dev; - if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) { - bond->arp_timer.function = - (void *) - &bond_activebackup_arp_mon; - } else { - bond->arp_timer.function = - (void *) - &bond_loadbalance_arp_mon; - } - add_timer(&bond->arp_timer); - } - } - -out: - return ret; -} -static CLASS_DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR , bonding_show_arp_interval, bonding_store_arp_interval); - -/* - * Show and set the arp targets. - */ -static ssize_t bonding_show_arp_targets(struct class_device *cd, char *buf) -{ - int i, res = 0; - struct bonding *bond = to_bond(cd); - - for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) { - if (bond->params.arp_targets[i]) - res += sprintf(buf + res, "%u.%u.%u.%u ", - NIPQUAD(bond->params.arp_targets[i])); - } - if (res) - res--; /* eat the leftover space */ - res += sprintf(buf + res, "\n"); - res++; - return res; -} - -static ssize_t bonding_store_arp_targets(struct class_device *cd, const char *buf, size_t count) -{ - u32 newtarget; - int i = 0, done = 0, ret = count; - struct bonding *bond = to_bond(cd); - u32 *targets; - - targets = bond->params.arp_targets; - newtarget = in_aton(buf + 1); - /* look for adds */ - if (buf[0] == '+') { - if ((newtarget == 0) || (newtarget == INADDR_BROADCAST)) { - printk(KERN_ERR DRV_NAME - ": %s: invalid ARP target %u.%u.%u.%u specified for addition\n", - bond->dev->name, NIPQUAD(newtarget)); - ret = -EINVAL; - goto out; - } - /* look for an empty slot to put the target in, and check for dupes */ - for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) { - if (targets[i] == newtarget) { /* duplicate */ - printk(KERN_ERR DRV_NAME - ": %s: ARP target %u.%u.%u.%u is already present\n", - bond->dev->name, NIPQUAD(newtarget)); - if (done) - targets[i] = 0; - ret = -EINVAL; - goto out; - } - if (targets[i] == 0 && !done) { - printk(KERN_INFO DRV_NAME - ": %s: adding ARP target %d.%d.%d.%d.\n", - bond->dev->name, NIPQUAD(newtarget)); - done = 1; - targets[i] = newtarget; - } - } - if (!done) { - printk(KERN_ERR DRV_NAME - ": %s: ARP target table is full!\n", - bond->dev->name); - ret = -EINVAL; - goto out; - } - - } - else if (buf[0] == '-') { - if ((newtarget == 0) || (newtarget == INADDR_BROADCAST)) { - printk(KERN_ERR DRV_NAME - ": %s: invalid ARP target %d.%d.%d.%d specified for removal\n", - bond->dev->name, NIPQUAD(newtarget)); - ret = -EINVAL; - goto out; - } - - for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) { - if (targets[i] == newtarget) { - printk(KERN_INFO DRV_NAME - ": %s: removing ARP target %d.%d.%d.%d.\n", - bond->dev->name, NIPQUAD(newtarget)); - targets[i] = 0; - done = 1; - } - } - if (!done) { - printk(KERN_INFO DRV_NAME - ": %s: unable to remove nonexistent ARP target %d.%d.%d.%d.\n", - bond->dev->name, NIPQUAD(newtarget)); - ret = -EINVAL; - goto out; - } - } - else { - printk(KERN_ERR DRV_NAME ": no command found in arp_ip_targets file for bond %s. Use + or -.\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - -out: - return ret; -} -static CLASS_DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets); - -/* - * Show and set the up and down delays. These must be multiples of the - * MII monitoring value, and are stored internally as the multiplier. - * Thus, we must translate to MS for the real world. - */ -static ssize_t bonding_show_downdelay(struct class_device *cd, char *buf) -{ - struct bonding *bond = to_bond(cd); - - return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon) + 1; -} - -static ssize_t bonding_store_downdelay(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - if (!(bond->params.miimon)) { - printk(KERN_ERR DRV_NAME - ": %s: Unable to set down delay as MII monitoring is disabled\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - if (sscanf(buf, "%d", &new_value) != 1) { - printk(KERN_ERR DRV_NAME - ": %s: no down delay value specified.\n", - bond->dev->name); - ret = -EINVAL; - goto out; - } - if (new_value < 0) { - printk(KERN_ERR DRV_NAME - ": %s: Invalid down delay value %d not in range %d-%d; rejected.\n", - bond->dev->name, new_value, 1, INT_MAX); - ret = -EINVAL; - goto out; - } else { - if ((new_value % bond->params.miimon) != 0) { - printk(KERN_WARNING DRV_NAME - ": %s: Warning: down delay (%d) is not a multiple " - "of miimon (%d), delay rounded to %d ms\n", - bond->dev->name, new_value, bond->params.miimon, - (new_value / bond->params.miimon) * - bond->params.miimon); - } - bond->params.downdelay = new_value / bond->params.miimon; - printk(KERN_INFO DRV_NAME ": %s: Setting down delay to %d.\n", - bond->dev->name, bond->params.downdelay * bond->params.miimon); - - } - -out: - return ret; -} -static CLASS_DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR , bonding_show_downdelay, bonding_store_downdelay); - -static ssize_t bonding_show_updelay(struct class_device *cd, char *buf) -{ - struct bonding *bond = to_bond(cd); - - return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon) + 1; - -} - -static ssize_t bonding_store_updelay(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - if (!(bond->params.miimon)) { - printk(KERN_ERR DRV_NAME - ": %s: Unable to set up delay as MII monitoring is disabled\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - if (sscanf(buf, "%d", &new_value) != 1) { - printk(KERN_ERR DRV_NAME - ": %s: no up delay value specified.\n", - bond->dev->name); - ret = -EINVAL; - goto out; - } - if (new_value < 0) { - printk(KERN_ERR DRV_NAME - ": %s: Invalid down delay value %d not in range %d-%d; rejected.\n", - bond->dev->name, new_value, 1, INT_MAX); - ret = -EINVAL; - goto out; - } else { - if ((new_value % bond->params.miimon) != 0) { - printk(KERN_WARNING DRV_NAME - ": %s: Warning: up delay (%d) is not a multiple " - "of miimon (%d), updelay rounded to %d ms\n", - bond->dev->name, new_value, bond->params.miimon, - (new_value / bond->params.miimon) * - bond->params.miimon); - } - bond->params.updelay = new_value / bond->params.miimon; - printk(KERN_INFO DRV_NAME ": %s: Setting up delay to %d.\n", - bond->dev->name, bond->params.updelay * bond->params.miimon); - - } - -out: - return ret; -} -static CLASS_DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR , bonding_show_updelay, bonding_store_updelay); - -/* - * Show and set the LACP interval. Interface must be down, and the mode - * must be set to 802.3ad mode. - */ -static ssize_t bonding_show_lacp(struct class_device *cd, char *buf) -{ - struct bonding *bond = to_bond(cd); - - return sprintf(buf, "%s %d\n", - bond_lacp_tbl[bond->params.lacp_fast].modename, - bond->params.lacp_fast) + 1; -} - -static ssize_t bonding_store_lacp(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - if (bond->dev->flags & IFF_UP) { - printk(KERN_ERR DRV_NAME - ": %s: Unable to update LACP rate because interface is up.\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - if (bond->params.mode != BOND_MODE_8023AD) { - printk(KERN_ERR DRV_NAME - ": %s: Unable to update LACP rate because bond is not in 802.3ad mode.\n", - bond->dev->name); - ret = -EPERM; - goto out; - } - - new_value = bond_parse_parm((char *)buf, bond_lacp_tbl); - - if ((new_value == 1) || (new_value == 0)) { - bond->params.lacp_fast = new_value; - printk(KERN_INFO DRV_NAME - ": %s: Setting LACP rate to %s (%d).\n", - bond->dev->name, bond_lacp_tbl[new_value].modename, new_value); - } else { - printk(KERN_ERR DRV_NAME - ": %s: Ignoring invalid LACP rate value %.*s.\n", - bond->dev->name, (int)strlen(buf) - 1, buf); - ret = -EINVAL; - } -out: - return ret; -} -static CLASS_DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, bonding_show_lacp, bonding_store_lacp); - -/* - * Show and set the MII monitor interval. There are two tricky bits - * here. First, if MII monitoring is activated, then we must disable - * ARP monitoring. Second, if the timer isn't running, we must - * start it. - */ -static ssize_t bonding_show_miimon(struct class_device *cd, char *buf) -{ - struct bonding *bond = to_bond(cd); - - return sprintf(buf, "%d\n", bond->params.miimon) + 1; -} - -static ssize_t bonding_store_miimon(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - if (sscanf(buf, "%d", &new_value) != 1) { - printk(KERN_ERR DRV_NAME - ": %s: no miimon value specified.\n", - bond->dev->name); - ret = -EINVAL; - goto out; - } - if (new_value < 0) { - printk(KERN_ERR DRV_NAME - ": %s: Invalid miimon value %d not in range %d-%d; rejected.\n", - bond->dev->name, new_value, 1, INT_MAX); - ret = -EINVAL; - goto out; - } else { - printk(KERN_INFO DRV_NAME - ": %s: Setting MII monitoring interval to %d.\n", - bond->dev->name, new_value); - bond->params.miimon = new_value; - if(bond->params.updelay) - printk(KERN_INFO DRV_NAME - ": %s: Note: Updating updelay (to %d) " - "since it is a multiple of the miimon value.\n", - bond->dev->name, - bond->params.updelay * bond->params.miimon); - if(bond->params.downdelay) - printk(KERN_INFO DRV_NAME - ": %s: Note: Updating downdelay (to %d) " - "since it is a multiple of the miimon value.\n", - bond->dev->name, - bond->params.downdelay * bond->params.miimon); - if (bond->params.arp_interval) { - printk(KERN_INFO DRV_NAME - ": %s: MII monitoring cannot be used with " - "ARP monitoring. Disabling ARP monitoring...\n", - bond->dev->name); - bond->params.arp_interval = 0; - /* Kill ARP timer, else it brings bond's link down */ - if (bond->mii_timer.function) { - printk(KERN_INFO DRV_NAME - ": %s: Kill ARP timer, else it brings bond's link down...\n", - bond->dev->name); - del_timer_sync(&bond->arp_timer); - } - } - - if (bond->dev->flags & IFF_UP) { - /* If the interface is up, we may need to fire off - * the MII timer. If the interface is down, the - * timer will get fired off when the open function - * is called. - */ - if (bond->mii_timer.function) { - /* The timer's already set up, so fire it off */ - mod_timer(&bond->mii_timer, jiffies + 1); - } else { - /* Set up the timer. */ - init_timer(&bond->mii_timer); - bond->mii_timer.expires = jiffies + 1; - bond->mii_timer.data = - (unsigned long) bond->dev; - bond->mii_timer.function = - (void *) &bond_mii_monitor; - add_timer(&bond->mii_timer); - } - } - } -out: - return ret; -} -static CLASS_DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, bonding_show_miimon, bonding_store_miimon); - -/* - * Show and set the primary slave. The store function is much - * simpler than bonding_store_slaves function because it only needs to - * handle one interface name. - * The bond must be a mode that supports a primary for this be - * set. - */ -static ssize_t bonding_show_primary(struct class_device *cd, char *buf) -{ - int count = 0; - struct bonding *bond = to_bond(cd); - - if (bond->primary_slave) - count = sprintf(buf, "%s\n", bond->primary_slave->dev->name) + 1; - else - count = sprintf(buf, "\n") + 1; - - return count; -} - -static ssize_t bonding_store_primary(struct class_device *cd, const char *buf, size_t count) -{ - int i; - struct slave *slave; - struct bonding *bond = to_bond(cd); - - write_lock_bh(&bond->lock); - if (!USES_PRIMARY(bond->params.mode)) { - printk(KERN_INFO DRV_NAME - ": %s: Unable to set primary slave; %s is in mode %d\n", - bond->dev->name, bond->dev->name, bond->params.mode); - } else { - bond_for_each_slave(bond, slave, i) { - if (strnicmp - (slave->dev->name, buf, - strlen(slave->dev->name)) == 0) { - printk(KERN_INFO DRV_NAME - ": %s: Setting %s as primary slave.\n", - bond->dev->name, slave->dev->name); - bond->primary_slave = slave; - bond_select_active_slave(bond); - goto out; - } - } - - /* if we got here, then we didn't match the name of any slave */ - - if (strlen(buf) == 0 || buf[0] == '\n') { - printk(KERN_INFO DRV_NAME - ": %s: Setting primary slave to None.\n", - bond->dev->name); - bond->primary_slave = 0; - bond_select_active_slave(bond); - } else { - printk(KERN_INFO DRV_NAME - ": %s: Unable to set %.*s as primary slave as it is not a slave.\n", - bond->dev->name, (int)strlen(buf) - 1, buf); - } - } -out: - write_unlock_bh(&bond->lock); - return count; -} -static CLASS_DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, bonding_show_primary, bonding_store_primary); - -/* - * Show and set the use_carrier flag. - */ -static ssize_t bonding_show_carrier(struct class_device *cd, char *buf) -{ - struct bonding *bond = to_bond(cd); - - return sprintf(buf, "%d\n", bond->params.use_carrier) + 1; -} - -static ssize_t bonding_store_carrier(struct class_device *cd, const char *buf, size_t count) -{ - int new_value, ret = count; - struct bonding *bond = to_bond(cd); - - - if (sscanf(buf, "%d", &new_value) != 1) { - printk(KERN_ERR DRV_NAME - ": %s: no use_carrier value specified.\n", - bond->dev->name); - ret = -EINVAL; - goto out; - } - if ((new_value == 0) || (new_value == 1)) { - bond->params.use_carrier = new_value; - printk(KERN_INFO DRV_NAME ": %s: Setting use_carrier to %d.\n", - bond->dev->name, new_value); - } else { - printk(KERN_INFO DRV_NAME - ": %s: Ignoring invalid use_carrier value %d.\n", - bond->dev->name, new_value); - } -out: - return count; -} -static CLASS_DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, bonding_show_carrier, bonding_store_carrier); - - -/* - * Show and set currently active_slave. - */ -static ssize_t bonding_show_active_slave(struct class_device *cd, char *buf) -{ - struct slave *curr; - struct bonding *bond = to_bond(cd); - int count; - - - read_lock(&bond->curr_slave_lock); - curr = bond->curr_active_slave; - read_unlock(&bond->curr_slave_lock); - - if (USES_PRIMARY(bond->params.mode) && curr) - count = sprintf(buf, "%s\n", curr->dev->name) + 1; - else - count = sprintf(buf, "\n") + 1; - return count; -} - -static ssize_t bonding_store_active_slave(struct class_device *cd, const char *buf, size_t count) -{ - int i; - struct slave *slave; - struct slave *old_active = NULL; - struct slave *new_active = NULL; - struct bonding *bond = to_bond(cd); - - write_lock_bh(&bond->lock); - if (!USES_PRIMARY(bond->params.mode)) { - printk(KERN_INFO DRV_NAME - ": %s: Unable to change active slave; %s is in mode %d\n", - bond->dev->name, bond->dev->name, bond->params.mode); - } else { - bond_for_each_slave(bond, slave, i) { - if (strnicmp - (slave->dev->name, buf, - strlen(slave->dev->name)) == 0) { - old_active = bond->curr_active_slave; - new_active = slave; - if (new_active && (new_active == old_active)) { - /* do nothing */ - printk(KERN_INFO DRV_NAME - ": %s: %s is already the current active slave.\n", - bond->dev->name, slave->dev->name); - goto out; - } - else { - if ((new_active) && - (old_active) && - (new_active->link == BOND_LINK_UP) && - IS_UP(new_active->dev)) { - printk(KERN_INFO DRV_NAME - ": %s: Setting %s as active slave.\n", - bond->dev->name, slave->dev->name); - bond_change_active_slave(bond, new_active); - } - else { - printk(KERN_INFO DRV_NAME - ": %s: Could not set %s as active slave; " - "either %s is down or the link is down.\n", - bond->dev->name, slave->dev->name, - slave->dev->name); - } - goto out; - } - } - } - - /* if we got here, then we didn't match the name of any slave */ - - if (strlen(buf) == 0 || buf[0] == '\n') { - printk(KERN_INFO DRV_NAME - ": %s: Setting active slave to None.\n", - bond->dev->name); - bond->primary_slave = 0; - bond_select_active_slave(bond); - } else { - printk(KERN_INFO DRV_NAME - ": %s: Unable to set %.*s as active slave as it is not a slave.\n", - bond->dev->name, (int)strlen(buf) - 1, buf); - } - } -out: - write_unlock_bh(&bond->lock); - return count; - -} -static CLASS_DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, bonding_show_active_slave, bonding_store_active_slave); - - -/* - * Show link status of the bond interface. - */ -static ssize_t bonding_show_mii_status(struct class_device *cd, char *buf) -{ - struct slave *curr; - struct bonding *bond = to_bond(cd); - - read_lock(&bond->curr_slave_lock); - curr = bond->curr_active_slave; - read_unlock(&bond->curr_slave_lock); - - return sprintf(buf, "%s\n", (curr) ? "up" : "down") + 1; -} -static CLASS_DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL); - - -/* - * Show current 802.3ad aggregator ID. - */ -static ssize_t bonding_show_ad_aggregator(struct class_device *cd, char *buf) -{ - int count = 0; - struct bonding *bond = to_bond(cd); - - if (bond->params.mode == BOND_MODE_8023AD) { - struct ad_info ad_info; - count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ? 0 : ad_info.aggregator_id) + 1; - } - else - count = sprintf(buf, "\n") + 1; - - return count; -} -static CLASS_DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL); - - -/* - * Show number of active 802.3ad ports. - */ -static ssize_t bonding_show_ad_num_ports(struct class_device *cd, char *buf) -{ - int count = 0; - struct bonding *bond = to_bond(cd); - - if (bond->params.mode == BOND_MODE_8023AD) { - struct ad_info ad_info; - count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ? 0: ad_info.ports) + 1; - } - else - count = sprintf(buf, "\n") + 1; - - return count; -} -static CLASS_DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL); - - -/* - * Show current 802.3ad actor key. - */ -static ssize_t bonding_show_ad_actor_key(struct class_device *cd, char *buf) -{ - int count = 0; - struct bonding *bond = to_bond(cd); - - if (bond->params.mode == BOND_MODE_8023AD) { - struct ad_info ad_info; - count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ? 0 : ad_info.actor_key) + 1; - } - else - count = sprintf(buf, "\n") + 1; - - return count; -} -static CLASS_DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL); - - -/* - * Show current 802.3ad partner key. - */ -static ssize_t bonding_show_ad_partner_key(struct class_device *cd, char *buf) -{ - int count = 0; - struct bonding *bond = to_bond(cd); - - if (bond->params.mode == BOND_MODE_8023AD) { - struct ad_info ad_info; - count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ? 0 : ad_info.partner_key) + 1; - } - else - count = sprintf(buf, "\n") + 1; - - return count; -} -static CLASS_DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL); - - -/* - * Show current 802.3ad partner mac. - */ -static ssize_t bonding_show_ad_partner_mac(struct class_device *cd, char *buf) -{ - int count = 0; - struct bonding *bond = to_bond(cd); - - if (bond->params.mode == BOND_MODE_8023AD) { - struct ad_info ad_info; - if (!bond_3ad_get_active_agg_info(bond, &ad_info)) { - count = sprintf(buf,"%02x:%02x:%02x:%02x:%02x:%02x\n", - ad_info.partner_system[0], - ad_info.partner_system[1], - ad_info.partner_system[2], - ad_info.partner_system[3], - ad_info.partner_system[4], - ad_info.partner_system[5]) + 1; - } - } - else - count = sprintf(buf, "\n") + 1; - - return count; -} -static CLASS_DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL); - - - -static struct attribute *per_bond_attrs[] = { - &class_device_attr_slaves.attr, - &class_device_attr_mode.attr, - &class_device_attr_arp_interval.attr, - &class_device_attr_arp_ip_target.attr, - &class_device_attr_downdelay.attr, - &class_device_attr_updelay.attr, - &class_device_attr_lacp_rate.attr, - &class_device_attr_xmit_hash_policy.attr, - &class_device_attr_miimon.attr, - &class_device_attr_primary.attr, - &class_device_attr_use_carrier.attr, - &class_device_attr_active_slave.attr, - &class_device_attr_mii_status.attr, - &class_device_attr_ad_aggregator.attr, - &class_device_attr_ad_num_ports.attr, - &class_device_attr_ad_actor_key.attr, - &class_device_attr_ad_partner_key.attr, - &class_device_attr_ad_partner_mac.attr, - NULL, -}; - -static struct attribute_group bonding_group = { - .name = "bonding", - .attrs = per_bond_attrs, -}; - -/* - * Initialize sysfs. This sets up the bonding_masters file in - * /sys/class/net. - */ -int bond_create_sysfs(void) -{ - int ret = 0; - struct bonding *firstbond; - - init_rwsem(&bonding_rwsem); - - /* get the netdev class pointer */ - firstbond = container_of(bond_dev_list.next, struct bonding, bond_list); - if (!firstbond) - return -ENODEV; - - netdev_class = firstbond->dev->class_dev.class; - if (!netdev_class) - return -ENODEV; - - ret = class_create_file(netdev_class, &class_attr_bonding_masters); - - return ret; - -} - -/* - * Remove /sys/class/net/bonding_masters. - */ -void bond_destroy_sysfs(void) -{ - if (netdev_class) - class_remove_file(netdev_class, &class_attr_bonding_masters); -} - -/* - * Initialize sysfs for each bond. This sets up and registers - * the 'bondctl' directory for each individual bond under /sys/class/net. - */ -int bond_create_sysfs_entry(struct bonding *bond) -{ - struct net_device *dev = bond->dev; - int err; - - err = sysfs_create_group(&(dev->class_dev.kobj), &bonding_group); - if (err) { - printk(KERN_EMERG "eek! didn't create group!\n"); - } - - if (expected_refcount < 1) - expected_refcount = atomic_read(&bond->dev->class_dev.kobj.kref.refcount); - - return err; -} -/* - * Remove sysfs entries for each bond. - */ -void bond_destroy_sysfs_entry(struct bonding *bond) -{ - struct net_device *dev = bond->dev; - - sysfs_remove_group(&(dev->class_dev.kobj), &bonding_group); -} - diff --git a/trunk/drivers/net/bonding/bonding.h b/trunk/drivers/net/bonding/bonding.h index 015c7f1d1bc0..1433e91db0f7 100644 --- a/trunk/drivers/net/bonding/bonding.h +++ b/trunk/drivers/net/bonding/bonding.h @@ -10,6 +10,25 @@ * This software may be used and distributed according to the terms * of the GNU Public License, incorporated herein by reference. * + * + * 2003/03/18 - Amir Noam , + * Tsippy Mendelson and + * Shmulik Hen + * - Added support for IEEE 802.3ad Dynamic link aggregation mode. + * + * 2003/05/01 - Tsippy Mendelson and + * Amir Noam + * - Code beautification and style changes (mainly in comments). + * + * 2003/05/01 - Shmulik Hen + * - Added support for Transmit load balancing mode. + * + * 2003/12/01 - Shmulik Hen + * - Code cleanup and style changes + * + * 2005/05/05 - Jason Gabler + * - added "xmit_policy" kernel parameter for alternate hashing policy + * support for mode 2 */ #ifndef _LINUX_BONDING_H @@ -18,12 +37,11 @@ #include #include #include -#include #include "bond_3ad.h" #include "bond_alb.h" -#define DRV_VERSION "3.0.0" -#define DRV_RELDATE "November 8, 2005" +#define DRV_VERSION "2.6.5" +#define DRV_RELDATE "November 4, 2005" #define DRV_NAME "bonding" #define DRV_DESCRIPTION "Ethernet Channel Bonding Driver" @@ -134,11 +152,6 @@ struct bond_params { u32 arp_targets[BOND_MAX_ARP_TARGETS]; }; -struct bond_parm_tbl { - char *modename; - int mode; -}; - struct vlan_entry { struct list_head vlan_list; u32 vlan_ip; @@ -146,7 +159,7 @@ struct vlan_entry { }; struct slave { - struct net_device *dev; /* first - useful for panic debug */ + struct net_device *dev; /* first - usefull for panic debug */ struct slave *next; struct slave *prev; s16 delay; @@ -172,7 +185,7 @@ struct slave { * beforehand. */ struct bonding { - struct net_device *dev; /* first - useful for panic debug */ + struct net_device *dev; /* first - usefull for panic debug */ struct slave *first_slave; struct slave *curr_active_slave; struct slave *current_arp_slave; @@ -242,25 +255,6 @@ extern inline void bond_set_slave_active_flags(struct slave *slave) struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr); int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev); -int bond_create(char *name, struct bond_params *params, struct bonding **newbond); -void bond_deinit(struct net_device *bond_dev); -int bond_create_sysfs(void); -void bond_destroy_sysfs(void); -void bond_destroy_sysfs_entry(struct bonding *bond); -int bond_create_sysfs_entry(struct bonding *bond); -int bond_create_slave_symlinks(struct net_device *master, struct net_device *slave); -void bond_destroy_slave_symlinks(struct net_device *master, struct net_device *slave); -int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev); -int bond_release(struct net_device *bond_dev, struct net_device *slave_dev); -int bond_sethwaddr(struct net_device *bond_dev, struct net_device *slave_dev); -void bond_mii_monitor(struct net_device *bond_dev); -void bond_loadbalance_arp_mon(struct net_device *bond_dev); -void bond_activebackup_arp_mon(struct net_device *bond_dev); -void bond_set_mode_ops(struct bonding *bond, int mode); -int bond_parse_parm(char *mode_arg, struct bond_parm_tbl *tbl); -const char *bond_mode_name(int mode); -void bond_select_active_slave(struct bonding *bond); -void bond_change_active_slave(struct bonding *bond, struct slave *new_active); #endif /* _LINUX_BONDING_H */ diff --git a/trunk/drivers/net/chelsio/sge.c b/trunk/drivers/net/chelsio/sge.c index 2c5b849b7ba4..53b41d99b00b 100644 --- a/trunk/drivers/net/chelsio/sge.c +++ b/trunk/drivers/net/chelsio/sge.c @@ -1332,8 +1332,8 @@ intr_handler_t t1_select_intr_handler(adapter_t *adapter) * * This runs with softirqs disabled. */ -static int t1_sge_tx(struct sk_buff *skb, struct adapter *adapter, - unsigned int qid, struct net_device *dev) +unsigned int t1_sge_tx(struct sk_buff *skb, struct adapter *adapter, + unsigned int qid, struct net_device *dev) { struct sge *sge = adapter->sge; struct cmdQ *q = &sge->cmdQ[qid]; @@ -1352,10 +1352,9 @@ static int t1_sge_tx(struct sk_buff *skb, struct adapter *adapter, set_bit(dev->if_port, &sge->stopped_tx_queues); sge->stats.cmdQ_full[3]++; spin_unlock(&q->lock); - if (!netif_queue_stopped(dev)) - CH_ERR("%s: Tx ring full while queue awake!\n", - adapter->name); - return NETDEV_TX_BUSY; + CH_ERR("%s: Tx ring full while queue awake!\n", + adapter->name); + return 1; } if (unlikely(credits - count < q->stop_thres)) { sge->stats.cmdQ_full[3]++; @@ -1390,7 +1389,7 @@ static int t1_sge_tx(struct sk_buff *skb, struct adapter *adapter, writel(F_CMDQ0_ENABLE, adapter->regs + A_SG_DOORBELL); } } - return NETDEV_TX_OK; + return 0; } #define MK_ETH_TYPE_MSS(type, mss) (((mss) & 0x3FFF) | ((type) << 14)) @@ -1450,7 +1449,7 @@ int t1_start_xmit(struct sk_buff *skb, struct net_device *dev) if (unlikely(skb->len < ETH_HLEN || skb->len > dev->mtu + eth_hdr_len(skb->data))) { dev_kfree_skb_any(skb); - return NETDEV_TX_OK; + return NET_XMIT_SUCCESS; } /* @@ -1468,7 +1467,7 @@ int t1_start_xmit(struct sk_buff *skb, struct net_device *dev) skb = skb_realloc_headroom(skb, sizeof(*cpl)); dev_kfree_skb_any(orig_skb); if (!skb) - return NETDEV_TX_OK; + return -ENOMEM; } if (!(adapter->flags & UDP_CSUM_CAPABLE) && @@ -1476,7 +1475,7 @@ int t1_start_xmit(struct sk_buff *skb, struct net_device *dev) skb->nh.iph->protocol == IPPROTO_UDP) if (unlikely(skb_checksum_help(skb, 0))) { dev_kfree_skb_any(skb); - return NETDEV_TX_OK; + return -ENOMEM; } /* Hmmm, assuming to catch the gratious arp... and we'll use diff --git a/trunk/drivers/net/chelsio/sge.h b/trunk/drivers/net/chelsio/sge.h index 6d0d24a6364f..434b25586851 100644 --- a/trunk/drivers/net/chelsio/sge.h +++ b/trunk/drivers/net/chelsio/sge.h @@ -89,6 +89,8 @@ int t1_sge_configure(struct sge *, struct sge_params *); int t1_sge_set_coalesce_params(struct sge *, struct sge_params *); void t1_sge_destroy(struct sge *); intr_handler_t t1_select_intr_handler(adapter_t *adapter); +unsigned int t1_sge_tx(struct sk_buff *skb, struct adapter *adapter, + unsigned int qid, struct net_device *netdev); int t1_start_xmit(struct sk_buff *skb, struct net_device *dev); void t1_set_vlan_accel(struct adapter *adapter, int on_off); void t1_sge_start(struct sge *); diff --git a/trunk/drivers/net/e1000/e1000.h b/trunk/drivers/net/e1000/e1000.h index e02e9ba2e18b..3f653a93e1bc 100644 --- a/trunk/drivers/net/e1000/e1000.h +++ b/trunk/drivers/net/e1000/e1000.h @@ -188,13 +188,11 @@ struct e1000_tx_ring { /* array of buffer information structs */ struct e1000_buffer *buffer_info; + struct e1000_buffer previous_buffer_info; spinlock_t tx_lock; uint16_t tdh; uint16_t tdt; uint64_t pkt; - - boolean_t last_tx_tso; - }; struct e1000_rx_ring { diff --git a/trunk/drivers/net/e1000/e1000_ethtool.c b/trunk/drivers/net/e1000/e1000_ethtool.c index c88f1a3c1b1d..8eae8ba27e84 100644 --- a/trunk/drivers/net/e1000/e1000_ethtool.c +++ b/trunk/drivers/net/e1000/e1000_ethtool.c @@ -562,29 +562,10 @@ e1000_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo) { struct e1000_adapter *adapter = netdev_priv(netdev); - char firmware_version[32]; - uint16_t eeprom_data; strncpy(drvinfo->driver, e1000_driver_name, 32); strncpy(drvinfo->version, e1000_driver_version, 32); - - /* EEPROM image version # is reported as firware version # for - * 8257{1|2|3} controllers */ - e1000_read_eeprom(&adapter->hw, 5, 1, &eeprom_data); - switch (adapter->hw.mac_type) { - case e1000_82571: - case e1000_82572: - case e1000_82573: - sprintf(firmware_version, "%d.%d-%d", - (eeprom_data & 0xF000) >> 12, - (eeprom_data & 0x0FF0) >> 4, - eeprom_data & 0x000F); - break; - default: - sprintf(firmware_version, "n/a"); - } - - strncpy(drvinfo->fw_version, firmware_version, 32); + strncpy(drvinfo->fw_version, "N/A", 32); strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32); drvinfo->n_stats = E1000_STATS_LEN; drvinfo->testinfo_len = E1000_TEST_LEN; @@ -979,21 +960,13 @@ e1000_free_desc_rings(struct e1000_adapter *adapter) } } - if(txdr->desc) { + if(txdr->desc) pci_free_consistent(pdev, txdr->size, txdr->desc, txdr->dma); - txdr->desc = NULL; - } - if(rxdr->desc) { + if(rxdr->desc) pci_free_consistent(pdev, rxdr->size, rxdr->desc, rxdr->dma); - rxdr->desc = NULL; - } kfree(txdr->buffer_info); - txdr->buffer_info = NULL; - kfree(rxdr->buffer_info); - rxdr->buffer_info = NULL; - return; } @@ -1328,32 +1301,21 @@ static int e1000_setup_loopback_test(struct e1000_adapter *adapter) { uint32_t rctl; - struct e1000_hw *hw = &adapter->hw; - if (hw->media_type == e1000_media_type_fiber || - hw->media_type == e1000_media_type_internal_serdes) { - switch (hw->mac_type) { - case e1000_82545: - case e1000_82546: - case e1000_82545_rev_3: - case e1000_82546_rev_3: + if(adapter->hw.media_type == e1000_media_type_fiber || + adapter->hw.media_type == e1000_media_type_internal_serdes) { + if(adapter->hw.mac_type == e1000_82545 || + adapter->hw.mac_type == e1000_82546 || + adapter->hw.mac_type == e1000_82545_rev_3 || + adapter->hw.mac_type == e1000_82546_rev_3) return e1000_set_phy_loopback(adapter); - break; - case e1000_82571: - case e1000_82572: -#define E1000_SERDES_LB_ON 0x410 - e1000_set_phy_loopback(adapter); - E1000_WRITE_REG(hw, SCTL, E1000_SERDES_LB_ON); - msec_delay(10); - return 0; - break; - default: - rctl = E1000_READ_REG(hw, RCTL); + else { + rctl = E1000_READ_REG(&adapter->hw, RCTL); rctl |= E1000_RCTL_LBM_TCVR; - E1000_WRITE_REG(hw, RCTL, rctl); + E1000_WRITE_REG(&adapter->hw, RCTL, rctl); return 0; } - } else if (hw->media_type == e1000_media_type_copper) + } else if(adapter->hw.media_type == e1000_media_type_copper) return e1000_set_phy_loopback(adapter); return 7; @@ -1364,36 +1326,25 @@ e1000_loopback_cleanup(struct e1000_adapter *adapter) { uint32_t rctl; uint16_t phy_reg; - struct e1000_hw *hw = &adapter->hw; rctl = E1000_READ_REG(&adapter->hw, RCTL); rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC); E1000_WRITE_REG(&adapter->hw, RCTL, rctl); - switch (hw->mac_type) { - case e1000_82571: - case e1000_82572: - if (hw->media_type == e1000_media_type_fiber || - hw->media_type == e1000_media_type_internal_serdes){ -#define E1000_SERDES_LB_OFF 0x400 - E1000_WRITE_REG(hw, SCTL, E1000_SERDES_LB_OFF); - msec_delay(10); - break; - } - /* fall thru for Cu adapters */ - case e1000_82545: - case e1000_82546: - case e1000_82545_rev_3: - case e1000_82546_rev_3: - default: - hw->autoneg = TRUE; - e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg); - if (phy_reg & MII_CR_LOOPBACK) { + if(adapter->hw.media_type == e1000_media_type_copper || + ((adapter->hw.media_type == e1000_media_type_fiber || + adapter->hw.media_type == e1000_media_type_internal_serdes) && + (adapter->hw.mac_type == e1000_82545 || + adapter->hw.mac_type == e1000_82546 || + adapter->hw.mac_type == e1000_82545_rev_3 || + adapter->hw.mac_type == e1000_82546_rev_3))) { + adapter->hw.autoneg = TRUE; + e1000_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_reg); + if(phy_reg & MII_CR_LOOPBACK) { phy_reg &= ~MII_CR_LOOPBACK; - e1000_write_phy_reg(hw, PHY_CTRL, phy_reg); - e1000_phy_reset(hw); + e1000_write_phy_reg(&adapter->hw, PHY_CTRL, phy_reg); + e1000_phy_reset(&adapter->hw); } - break; } } @@ -1489,11 +1440,9 @@ static int e1000_loopback_test(struct e1000_adapter *adapter, uint64_t *data) { if((*data = e1000_setup_desc_rings(adapter))) goto err_loopback; - if((*data = e1000_setup_loopback_test(adapter))) - goto err_loopback_setup; + if((*data = e1000_setup_loopback_test(adapter))) goto err_loopback; *data = e1000_run_loopback_test(adapter); e1000_loopback_cleanup(adapter); -err_loopback_setup: e1000_free_desc_rings(adapter); err_loopback: return *data; @@ -1722,14 +1671,6 @@ e1000_phys_id(struct net_device *netdev, uint32_t data) msleep_interruptible(data * 1000); del_timer_sync(&adapter->blink_timer); } - else if(adapter->hw.mac_type < e1000_82573) { - E1000_WRITE_REG(&adapter->hw, LEDCTL, (E1000_LEDCTL_LED2_BLINK_RATE | - E1000_LEDCTL_LED0_BLINK | E1000_LEDCTL_LED2_BLINK | - (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED2_MODE_SHIFT) | - (E1000_LEDCTL_MODE_LINK_ACTIVITY << E1000_LEDCTL_LED0_MODE_SHIFT) | - (E1000_LEDCTL_MODE_LED_OFF << E1000_LEDCTL_LED1_MODE_SHIFT))); - msleep_interruptible(data * 1000); - } else { E1000_WRITE_REG(&adapter->hw, LEDCTL, (E1000_LEDCTL_LED2_BLINK_RATE | E1000_LEDCTL_LED1_BLINK | E1000_LEDCTL_LED2_BLINK | diff --git a/trunk/drivers/net/e1000/e1000_hw.c b/trunk/drivers/net/e1000/e1000_hw.c index 136fc031e4ad..a267c5235fc0 100644 --- a/trunk/drivers/net/e1000/e1000_hw.c +++ b/trunk/drivers/net/e1000/e1000_hw.c @@ -563,13 +563,11 @@ e1000_reset_hw(struct e1000_hw *hw) msec_delay(20); break; case e1000_82573: - if (e1000_is_onboard_nvm_eeprom(hw) == FALSE) { - udelay(10); - ctrl_ext = E1000_READ_REG(hw, CTRL_EXT); - ctrl_ext |= E1000_CTRL_EXT_EE_RST; - E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext); - E1000_WRITE_FLUSH(hw); - } + udelay(10); + ctrl_ext = E1000_READ_REG(hw, CTRL_EXT); + ctrl_ext |= E1000_CTRL_EXT_EE_RST; + E1000_WRITE_REG(hw, CTRL_EXT, ctrl_ext); + E1000_WRITE_FLUSH(hw); /* fall through */ case e1000_82571: case e1000_82572: @@ -846,27 +844,19 @@ e1000_setup_link(struct e1000_hw *hw) * control setting, then the variable hw->fc will * be initialized based on a value in the EEPROM. */ - if (hw->fc == e1000_fc_default) { - switch (hw->mac_type) { - case e1000_82573: + if(e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data)) { + DEBUGOUT("EEPROM Read Error\n"); + return -E1000_ERR_EEPROM; + } + + if(hw->fc == e1000_fc_default) { + if((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == 0) + hw->fc = e1000_fc_none; + else if((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == + EEPROM_WORD0F_ASM_DIR) + hw->fc = e1000_fc_tx_pause; + else hw->fc = e1000_fc_full; - break; - default: - ret_val = e1000_read_eeprom(hw, EEPROM_INIT_CONTROL2_REG, - 1, &eeprom_data); - if (ret_val) { - DEBUGOUT("EEPROM Read Error\n"); - return -E1000_ERR_EEPROM; - } - if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == 0) - hw->fc = e1000_fc_none; - else if ((eeprom_data & EEPROM_WORD0F_PAUSE_MASK) == - EEPROM_WORD0F_ASM_DIR) - hw->fc = e1000_fc_tx_pause; - else - hw->fc = e1000_fc_full; - break; - } } /* We want to save off the original Flow Control configuration just @@ -2972,22 +2962,13 @@ e1000_phy_hw_reset(struct e1000_hw *hw) if(hw->mac_type > e1000_82543) { /* Read the device control register and assert the E1000_CTRL_PHY_RST * bit. Then, take it out of reset. - * For pre-e1000_82571 hardware, we delay for 10ms between the assert - * and deassert. For e1000_82571 hardware and later, we instead delay - * for 10ms after the deassertion. */ ctrl = E1000_READ_REG(hw, CTRL); E1000_WRITE_REG(hw, CTRL, ctrl | E1000_CTRL_PHY_RST); E1000_WRITE_FLUSH(hw); - - if (hw->mac_type < e1000_82571) - msec_delay(10); - + msec_delay(10); E1000_WRITE_REG(hw, CTRL, ctrl); E1000_WRITE_FLUSH(hw); - - if (hw->mac_type >= e1000_82571) - msec_delay(10); } else { /* Read the Extended Device Control Register, assert the PHY_RESET_DIR * bit to put the PHY into reset. Then, take it out of reset. @@ -5297,13 +5278,9 @@ e1000_get_bus_info(struct e1000_hw *hw) hw->bus_speed = e1000_bus_speed_unknown; hw->bus_width = e1000_bus_width_unknown; break; + case e1000_82571: case e1000_82572: case e1000_82573: - hw->bus_type = e1000_bus_type_pci_express; - hw->bus_speed = e1000_bus_speed_2500; - hw->bus_width = e1000_bus_width_pciex_1; - break; - case e1000_82571: hw->bus_type = e1000_bus_type_pci_express; hw->bus_speed = e1000_bus_speed_2500; hw->bus_width = e1000_bus_width_pciex_4; @@ -6673,12 +6650,6 @@ e1000_get_auto_rd_done(struct e1000_hw *hw) break; } - /* PHY configuration from NVM just starts after EECD_AUTO_RD sets to high. - * Need to wait for PHY configuration completion before accessing NVM - * and PHY. */ - if (hw->mac_type == e1000_82573) - msec_delay(25); - return E1000_SUCCESS; } diff --git a/trunk/drivers/net/e1000/e1000_hw.h b/trunk/drivers/net/e1000/e1000_hw.h index 7caa35748cea..76ce12809a11 100644 --- a/trunk/drivers/net/e1000/e1000_hw.h +++ b/trunk/drivers/net/e1000/e1000_hw.h @@ -123,7 +123,6 @@ typedef enum { e1000_bus_width_32, e1000_bus_width_64, e1000_bus_width_pciex_1, - e1000_bus_width_pciex_2, e1000_bus_width_pciex_4, e1000_bus_width_reserved } e1000_bus_width; @@ -150,7 +149,6 @@ typedef enum { e1000_igp_cable_length_90 = 90, e1000_igp_cable_length_100 = 100, e1000_igp_cable_length_110 = 110, - e1000_igp_cable_length_115 = 115, e1000_igp_cable_length_120 = 120, e1000_igp_cable_length_130 = 130, e1000_igp_cable_length_140 = 140, @@ -1459,7 +1457,6 @@ struct e1000_hw { #define E1000_EECD_AUPDEN 0x00100000 /* Enable Autonomous FLASH update */ #define E1000_EECD_SHADV 0x00200000 /* Shadow RAM Data Valid */ #define E1000_EECD_SEC1VAL 0x00400000 /* Sector One Valid */ -#define E1000_EECD_SECVAL_SHIFT 22 #define E1000_STM_OPCODE 0xDB00 #define E1000_HICR_FW_RESET 0xC0 @@ -1954,6 +1951,7 @@ struct e1000_host_command_info { #define E1000_MDALIGN 4096 +#define E1000_GCR_BEM32 0x00400000 #define E1000_GCR_L1_ACT_WITHOUT_L0S_RX 0x08000000 /* Function Active and Power State to MNG */ #define E1000_FACTPS_FUNC0_POWER_STATE_MASK 0x00000003 diff --git a/trunk/drivers/net/e1000/e1000_main.c b/trunk/drivers/net/e1000/e1000_main.c index 438a931fd55d..e0ae248b4313 100644 --- a/trunk/drivers/net/e1000/e1000_main.c +++ b/trunk/drivers/net/e1000/e1000_main.c @@ -711,7 +711,6 @@ e1000_probe(struct pci_dev *pdev, break; case e1000_82546: case e1000_82546_rev_3: - case e1000_82571: if((E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_FUNC_1) && (adapter->hw.media_type == e1000_media_type_copper)) { e1000_read_eeprom(&adapter->hw, @@ -1159,6 +1158,7 @@ e1000_setup_tx_resources(struct e1000_adapter *adapter, return -ENOMEM; } memset(txdr->buffer_info, 0, size); + memset(&txdr->previous_buffer_info, 0, sizeof(struct e1000_buffer)); /* round up to nearest 4K */ @@ -1813,6 +1813,11 @@ e1000_clean_tx_ring(struct e1000_adapter *adapter, /* Free all the Tx ring sk_buffs */ + if (likely(tx_ring->previous_buffer_info.skb != NULL)) { + e1000_unmap_and_free_tx_resource(adapter, + &tx_ring->previous_buffer_info); + } + for(i = 0; i < tx_ring->count; i++) { buffer_info = &tx_ring->buffer_info[i]; e1000_unmap_and_free_tx_resource(adapter, buffer_info); @@ -1827,7 +1832,6 @@ e1000_clean_tx_ring(struct e1000_adapter *adapter, tx_ring->next_to_use = 0; tx_ring->next_to_clean = 0; - tx_ring->last_tx_tso = 0; writel(0, adapter->hw.hw_addr + tx_ring->tdh); writel(0, adapter->hw.hw_addr + tx_ring->tdt); @@ -2433,16 +2437,6 @@ e1000_tx_map(struct e1000_adapter *adapter, struct e1000_tx_ring *tx_ring, buffer_info = &tx_ring->buffer_info[i]; size = min(len, max_per_txd); #ifdef NETIF_F_TSO - /* Workaround for Controller erratum -- - * descriptor for non-tso packet in a linear SKB that follows a - * tso gets written back prematurely before the data is fully - * DMAd to the controller */ - if (!skb->data_len && tx_ring->last_tx_tso && - !skb_shinfo(skb)->tso_size) { - tx_ring->last_tx_tso = 0; - size -= 4; - } - /* Workaround for premature desc write-backs * in TSO mode. Append 4-byte sentinel desc */ if(unlikely(mss && !nr_frags && size == len && size > 8)) @@ -2699,14 +2693,6 @@ e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev) if(skb->ip_summed == CHECKSUM_HW) count++; #endif - -#ifdef NETIF_F_TSO - /* Controller Erratum workaround */ - if (!skb->data_len && tx_ring->last_tx_tso && - !skb_shinfo(skb)->tso_size) - count++; -#endif - count += TXD_USE_COUNT(len, max_txd_pwr); if(adapter->pcix_82544) @@ -2788,10 +2774,9 @@ e1000_xmit_frame(struct sk_buff *skb, struct net_device *netdev) return NETDEV_TX_OK; } - if (likely(tso)) { - tx_ring->last_tx_tso = 1; + if (likely(tso)) tx_flags |= E1000_TX_FLAGS_TSO; - } else if (likely(e1000_tx_csum(adapter, tx_ring, skb))) + else if (likely(e1000_tx_csum(adapter, tx_ring, skb))) tx_flags |= E1000_TX_FLAGS_CSUM; /* Old method was to assume IPv4 packet by default if TSO was enabled. @@ -3242,12 +3227,37 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter, eop_desc = E1000_TX_DESC(*tx_ring, eop); while (eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) { + /* Premature writeback of Tx descriptors clear (free buffers + * and unmap pci_mapping) previous_buffer_info */ + if (likely(tx_ring->previous_buffer_info.skb != NULL)) { + e1000_unmap_and_free_tx_resource(adapter, + &tx_ring->previous_buffer_info); + } + for(cleaned = FALSE; !cleaned; ) { tx_desc = E1000_TX_DESC(*tx_ring, i); buffer_info = &tx_ring->buffer_info[i]; cleaned = (i == eop); - e1000_unmap_and_free_tx_resource(adapter, buffer_info); +#ifdef NETIF_F_TSO + if (!(netdev->features & NETIF_F_TSO)) { +#endif + e1000_unmap_and_free_tx_resource(adapter, + buffer_info); +#ifdef NETIF_F_TSO + } else { + if (cleaned) { + memcpy(&tx_ring->previous_buffer_info, + buffer_info, + sizeof(struct e1000_buffer)); + memset(buffer_info, 0, + sizeof(struct e1000_buffer)); + } else { + e1000_unmap_and_free_tx_resource( + adapter, buffer_info); + } + } +#endif tx_desc->buffer_addr = 0; tx_desc->lower.data = 0; @@ -3308,6 +3318,12 @@ e1000_clean_tx_irq(struct e1000_adapter *adapter, netif_stop_queue(netdev); } } +#ifdef NETIF_F_TSO + if (unlikely(!(eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) && + time_after(jiffies, tx_ring->previous_buffer_info.time_stamp + HZ))) + e1000_unmap_and_free_tx_resource( + adapter, &tx_ring->previous_buffer_info); +#endif return cleaned; } diff --git a/trunk/drivers/net/gianfar.c b/trunk/drivers/net/gianfar.c index 146f9513aea5..0f030b73cbb3 100644 --- a/trunk/drivers/net/gianfar.c +++ b/trunk/drivers/net/gianfar.c @@ -2,8 +2,7 @@ * drivers/net/gianfar.c * * Gianfar Ethernet Driver - * This driver is designed for the non-CPM ethernet controllers - * on the 85xx and 83xx family of integrated processors + * Driver for FEC on MPC8540 and TSEC on MPC8540/MPC8560 * Based on 8260_io/fcc_enet.c * * Author: Andy Fleming @@ -23,6 +22,8 @@ * B-V +1.62 * * Theory of operation + * This driver is designed for the non-CPM ethernet controllers + * on the 85xx and 83xx family of integrated processors * * The driver is initialized through platform_device. Structures which * define the configuration needed by the board are defined in a @@ -109,7 +110,7 @@ #endif const char gfar_driver_name[] = "Gianfar Ethernet"; -const char gfar_driver_version[] = "1.3"; +const char gfar_driver_version[] = "1.2"; static int gfar_enet_open(struct net_device *dev); static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev); @@ -138,10 +139,6 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb, int l static void gfar_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp); static void gfar_vlan_rx_kill_vid(struct net_device *netdev, uint16_t vid); -void gfar_halt(struct net_device *dev); -void gfar_start(struct net_device *dev); -static void gfar_clear_exact_match(struct net_device *dev); -static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr); extern struct ethtool_ops gfar_ethtool_ops; @@ -149,10 +146,12 @@ MODULE_AUTHOR("Freescale Semiconductor, Inc"); MODULE_DESCRIPTION("Gianfar Ethernet Driver"); MODULE_LICENSE("GPL"); -/* Returns 1 if incoming frames use an FCB */ -static inline int gfar_uses_fcb(struct gfar_private *priv) +int gfar_uses_fcb(struct gfar_private *priv) { - return (priv->vlan_enable || priv->rx_csum_enable); + if (priv->vlan_enable || priv->rx_csum_enable) + return 1; + else + return 0; } /* Set up the ethernet device structure, private data, @@ -321,10 +320,15 @@ static int gfar_probe(struct platform_device *pdev) else priv->padding = 0; + dev->hard_header_len += priv->padding; + if (dev->features & NETIF_F_IP_CSUM) dev->hard_header_len += GMAC_FCB_LEN; priv->rx_buffer_size = DEFAULT_RX_BUFFER_SIZE; +#ifdef CONFIG_GFAR_BUFSTASH + priv->rx_stash_size = STASH_LENGTH; +#endif priv->tx_ring_size = DEFAULT_TX_RING_SIZE; priv->rx_ring_size = DEFAULT_RX_RING_SIZE; @@ -346,9 +350,6 @@ static int gfar_probe(struct platform_device *pdev) goto register_fail; } - /* Create all the sysfs files */ - gfar_init_sysfs(dev); - /* Print out the device info */ printk(KERN_INFO DEVICE_NAME, dev->name); for (idx = 0; idx < 6; idx++) @@ -356,7 +357,8 @@ static int gfar_probe(struct platform_device *pdev) printk("\n"); /* Even more device info helps when determining which kernel */ - /* provided which set of benchmarks. */ + /* provided which set of benchmarks. Since this is global for all */ + /* devices, we only print it once */ #ifdef CONFIG_GFAR_NAPI printk(KERN_INFO "%s: Running with NAPI enabled\n", dev->name); #else @@ -461,9 +463,19 @@ static void init_registers(struct net_device *dev) /* Initialize the max receive buffer length */ gfar_write(&priv->regs->mrblr, priv->rx_buffer_size); +#ifdef CONFIG_GFAR_BUFSTASH + /* If we are stashing buffers, we need to set the + * extraction length to the size of the buffer */ + gfar_write(&priv->regs->attreli, priv->rx_stash_size << 16); +#endif + /* Initialize the Minimum Frame Length Register */ gfar_write(&priv->regs->minflr, MINFLR_INIT_SETTINGS); + /* Setup Attributes so that snooping is on for rx */ + gfar_write(&priv->regs->attr, ATTR_INIT_SETTINGS); + gfar_write(&priv->regs->attreli, ATTRELI_INIT_SETTINGS); + /* Assign the TBI an address which won't conflict with the PHYs */ gfar_write(&priv->regs->tbipa, TBIPA_VALUE); } @@ -565,7 +577,8 @@ static void free_skb_resources(struct gfar_private *priv) for (i = 0; i < priv->rx_ring_size; i++) { if (priv->rx_skbuff[i]) { dma_unmap_single(NULL, rxbdp->bufPtr, - priv->rx_buffer_size, + priv->rx_buffer_size + + RXBUF_ALIGNMENT, DMA_FROM_DEVICE); dev_kfree_skb_any(priv->rx_skbuff[i]); @@ -623,7 +636,6 @@ int startup_gfar(struct net_device *dev) struct gfar *regs = priv->regs; int err = 0; u32 rctrl = 0; - u32 attrs = 0; gfar_write(®s->imask, IMASK_INIT_CLEAR); @@ -783,50 +795,18 @@ int startup_gfar(struct net_device *dev) if (priv->rx_csum_enable) rctrl |= RCTRL_CHECKSUMMING; - if (priv->extended_hash) { + if (priv->extended_hash) rctrl |= RCTRL_EXTHASH; - gfar_clear_exact_match(dev); - rctrl |= RCTRL_EMEN; - } - if (priv->vlan_enable) rctrl |= RCTRL_VLAN; - if (priv->padding) { - rctrl &= ~RCTRL_PAL_MASK; - rctrl |= RCTRL_PADDING(priv->padding); - } - /* Init rctrl based on our settings */ gfar_write(&priv->regs->rctrl, rctrl); if (dev->features & NETIF_F_IP_CSUM) gfar_write(&priv->regs->tctrl, TCTRL_INIT_CSUM); - /* Set the extraction length and index */ - attrs = ATTRELI_EL(priv->rx_stash_size) | - ATTRELI_EI(priv->rx_stash_index); - - gfar_write(&priv->regs->attreli, attrs); - - /* Start with defaults, and add stashing or locking - * depending on the approprate variables */ - attrs = ATTR_INIT_SETTINGS; - - if (priv->bd_stash_en) - attrs |= ATTR_BDSTASH; - - if (priv->rx_stash_size != 0) - attrs |= ATTR_BUFSTASH; - - gfar_write(&priv->regs->attr, attrs); - - gfar_write(&priv->regs->fifo_tx_thr, priv->fifo_threshold); - gfar_write(&priv->regs->fifo_tx_starve, priv->fifo_starve); - gfar_write(&priv->regs->fifo_tx_starve_shutoff, priv->fifo_starve_off); - - /* Start the controller */ gfar_start(dev); return 0; @@ -871,32 +851,34 @@ static int gfar_enet_open(struct net_device *dev) return err; } -static inline struct txfcb *gfar_add_fcb(struct sk_buff *skb, struct txbd8 *bdp) +static struct txfcb *gfar_add_fcb(struct sk_buff *skb, struct txbd8 *bdp) { struct txfcb *fcb = (struct txfcb *)skb_push (skb, GMAC_FCB_LEN); memset(fcb, 0, GMAC_FCB_LEN); + /* Flag the bd so the controller looks for the FCB */ + bdp->status |= TXBD_TOE; + return fcb; } static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb) { - u8 flags = 0; + int len; /* If we're here, it's a IP packet with a TCP or UDP * payload. We set it to checksum, using a pseudo-header * we provide */ - flags = TXFCB_DEFAULT; + fcb->ip = 1; + fcb->tup = 1; + fcb->ctu = 1; + fcb->nph = 1; - /* Tell the controller what the protocol is */ - /* And provide the already calculated phcs */ - if (skb->nh.iph->protocol == IPPROTO_UDP) { - flags |= TXFCB_UDP; - fcb->phcs = skb->h.uh->check; - } else - fcb->phcs = skb->h.th->check; + /* Notify the controller what the protocol is */ + if (skb->nh.iph->protocol == IPPROTO_UDP) + fcb->udp = 1; /* l3os is the distance between the start of the * frame (skb->data) and the start of the IP hdr. @@ -905,12 +887,17 @@ static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb) fcb->l3os = (u16)(skb->nh.raw - skb->data - GMAC_FCB_LEN); fcb->l4os = (u16)(skb->h.raw - skb->nh.raw); - fcb->flags = flags; + len = skb->nh.iph->tot_len - fcb->l4os; + + /* Provide the pseudoheader csum */ + fcb->phcs = ~csum_tcpudp_magic(skb->nh.iph->saddr, + skb->nh.iph->daddr, len, + skb->nh.iph->protocol, 0); } -void inline gfar_tx_vlan(struct sk_buff *skb, struct txfcb *fcb) +void gfar_tx_vlan(struct sk_buff *skb, struct txfcb *fcb) { - fcb->flags |= TXFCB_VLN; + fcb->vln = 1; fcb->vlctl = vlan_tx_tag_get(skb); } @@ -921,7 +908,6 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev) struct gfar_private *priv = netdev_priv(dev); struct txfcb *fcb = NULL; struct txbd8 *txbdp; - u16 status; /* Update transmit stats */ priv->stats.tx_bytes += skb->len; @@ -933,22 +919,19 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev) txbdp = priv->cur_tx; /* Clear all but the WRAP status flags */ - status = txbdp->status & TXBD_WRAP; + txbdp->status &= TXBD_WRAP; /* Set up checksumming */ - if (likely((dev->features & NETIF_F_IP_CSUM) - && (CHECKSUM_HW == skb->ip_summed))) { + if ((dev->features & NETIF_F_IP_CSUM) + && (CHECKSUM_HW == skb->ip_summed)) { fcb = gfar_add_fcb(skb, txbdp); - status |= TXBD_TOE; gfar_tx_checksum(skb, fcb); } if (priv->vlan_enable && unlikely(priv->vlgrp && vlan_tx_tag_present(skb))) { - if (unlikely(NULL == fcb)) { + if (NULL == fcb) fcb = gfar_add_fcb(skb, txbdp); - status |= TXBD_TOE; - } gfar_tx_vlan(skb, fcb); } @@ -966,16 +949,14 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev) (priv->skb_curtx + 1) & TX_RING_MOD_MASK(priv->tx_ring_size); /* Flag the BD as interrupt-causing */ - status |= TXBD_INTERRUPT; + txbdp->status |= TXBD_INTERRUPT; /* Flag the BD as ready to go, last in frame, and */ /* in need of CRC */ - status |= (TXBD_READY | TXBD_LAST | TXBD_CRC); + txbdp->status |= (TXBD_READY | TXBD_LAST | TXBD_CRC); dev->trans_start = jiffies; - txbdp->status = status; - /* If this was the last BD in the ring, the next one */ /* is at the beginning of the ring */ if (txbdp->status & TXBD_WRAP) @@ -1029,7 +1010,21 @@ static struct net_device_stats * gfar_get_stats(struct net_device *dev) /* Changes the mac address if the controller is not running. */ int gfar_set_mac_address(struct net_device *dev) { - gfar_set_mac_for_addr(dev, 0, dev->dev_addr); + struct gfar_private *priv = netdev_priv(dev); + int i; + char tmpbuf[MAC_ADDR_LEN]; + u32 tempval; + + /* Now copy it into the mac registers backwards, cuz */ + /* little endian is silly */ + for (i = 0; i < MAC_ADDR_LEN; i++) + tmpbuf[MAC_ADDR_LEN - 1 - i] = dev->dev_addr[i]; + + gfar_write(&priv->regs->macstnaddr1, *((u32 *) (tmpbuf))); + + tempval = *((u32 *) (tmpbuf + 4)); + + gfar_write(&priv->regs->macstnaddr2, tempval); return 0; } @@ -1115,7 +1110,7 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu) INCREMENTAL_BUFFER_SIZE; /* Only stop and start the controller if it isn't already - * stopped, and we changed something */ + * stopped */ if ((oldsize != tempsize) && (dev->flags & IFF_UP)) stop_gfar(dev); @@ -1225,7 +1220,6 @@ static irqreturn_t gfar_transmit(int irq, void *dev_id, struct pt_regs *regs) struct sk_buff * gfar_new_skb(struct net_device *dev, struct rxbd8 *bdp) { - unsigned int alignamount; struct gfar_private *priv = netdev_priv(dev); struct sk_buff *skb = NULL; unsigned int timeout = SKB_ALLOC_TIMEOUT; @@ -1237,18 +1231,18 @@ struct sk_buff * gfar_new_skb(struct net_device *dev, struct rxbd8 *bdp) if (NULL == skb) return NULL; - alignamount = RXBUF_ALIGNMENT - - (((unsigned) skb->data) & (RXBUF_ALIGNMENT - 1)); - /* We need the data buffer to be aligned properly. We will reserve * as many bytes as needed to align the data properly */ - skb_reserve(skb, alignamount); + skb_reserve(skb, + RXBUF_ALIGNMENT - + (((unsigned) skb->data) & (RXBUF_ALIGNMENT - 1))); skb->dev = dev; bdp->bufPtr = dma_map_single(NULL, skb->data, - priv->rx_buffer_size, DMA_FROM_DEVICE); + priv->rx_buffer_size + RXBUF_ALIGNMENT, + DMA_FROM_DEVICE); bdp->length = 0; @@ -1356,7 +1350,7 @@ static inline void gfar_rx_checksum(struct sk_buff *skb, struct rxfcb *fcb) /* If valid headers were found, and valid sums * were verified, then we tell the kernel that no * checksumming is necessary. Otherwise, it is */ - if ((fcb->flags & RXFCB_CSUM_MASK) == (RXFCB_CIP | RXFCB_CTU)) + if (fcb->cip && !fcb->eip && fcb->ctu && !fcb->etu) skb->ip_summed = CHECKSUM_UNNECESSARY; else skb->ip_summed = CHECKSUM_NONE; @@ -1407,7 +1401,7 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb, skb->protocol = eth_type_trans(skb, dev); /* Send the packet up the stack */ - if (unlikely(priv->vlgrp && (fcb->flags & RXFCB_VLN))) + if (unlikely(priv->vlgrp && fcb->vln)) ret = gfar_rx_vlan(skb, priv->vlgrp, fcb->vlctl); else ret = RECEIVE(skb); @@ -1626,7 +1620,6 @@ static void adjust_link(struct net_device *dev) spin_lock_irqsave(&priv->lock, flags); if (phydev->link) { u32 tempval = gfar_read(®s->maccfg2); - u32 ecntrl = gfar_read(®s->ecntrl); /* Now we make sure that we can be in full duplex mode. * If not, we operate in half-duplex mode. */ @@ -1651,13 +1644,6 @@ static void adjust_link(struct net_device *dev) case 10: tempval = ((tempval & ~(MACCFG2_IF)) | MACCFG2_MII); - - /* Reduced mode distinguishes - * between 10 and 100 */ - if (phydev->speed == SPEED_100) - ecntrl |= ECNTRL_R100; - else - ecntrl &= ~(ECNTRL_R100); break; default: if (netif_msg_link(priv)) @@ -1671,7 +1657,6 @@ static void adjust_link(struct net_device *dev) } gfar_write(®s->maccfg2, tempval); - gfar_write(®s->ecntrl, ecntrl); if (!priv->oldlink) { new_state = 1; @@ -1736,9 +1721,6 @@ static void gfar_set_multi(struct net_device *dev) gfar_write(®s->gaddr6, 0xffffffff); gfar_write(®s->gaddr7, 0xffffffff); } else { - int em_num; - int idx; - /* zero out the hash */ gfar_write(®s->igaddr0, 0x0); gfar_write(®s->igaddr1, 0x0); @@ -1757,47 +1739,18 @@ static void gfar_set_multi(struct net_device *dev) gfar_write(®s->gaddr6, 0x0); gfar_write(®s->gaddr7, 0x0); - /* If we have extended hash tables, we need to - * clear the exact match registers to prepare for - * setting them */ - if (priv->extended_hash) { - em_num = GFAR_EM_NUM + 1; - gfar_clear_exact_match(dev); - idx = 1; - } else { - idx = 0; - em_num = 0; - } - if(dev->mc_count == 0) return; /* Parse the list, and set the appropriate bits */ for(mc_ptr = dev->mc_list; mc_ptr; mc_ptr = mc_ptr->next) { - if (idx < em_num) { - gfar_set_mac_for_addr(dev, idx, - mc_ptr->dmi_addr); - idx++; - } else - gfar_set_hash_for_addr(dev, mc_ptr->dmi_addr); + gfar_set_hash_for_addr(dev, mc_ptr->dmi_addr); } } return; } - -/* Clears each of the exact match registers to zero, so they - * don't interfere with normal reception */ -static void gfar_clear_exact_match(struct net_device *dev) -{ - int idx; - u8 zero_arr[MAC_ADDR_LEN] = {0,0,0,0,0,0}; - - for(idx = 1;idx < GFAR_EM_NUM + 1;idx++) - gfar_set_mac_for_addr(dev, idx, (u8 *)zero_arr); -} - /* Set the appropriate hash bit for the given addr */ /* The algorithm works like so: * 1) Take the Destination Address (ie the multicast address), and @@ -1828,32 +1781,6 @@ static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr) return; } - -/* There are multiple MAC Address register pairs on some controllers - * This function sets the numth pair to a given address - */ -static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr) -{ - struct gfar_private *priv = netdev_priv(dev); - int idx; - char tmpbuf[MAC_ADDR_LEN]; - u32 tempval; - u32 *macptr = &priv->regs->macstnaddr1; - - macptr += num*2; - - /* Now copy it into the mac registers backwards, cuz */ - /* little endian is silly */ - for (idx = 0; idx < MAC_ADDR_LEN; idx++) - tmpbuf[MAC_ADDR_LEN - 1 - idx] = addr[idx]; - - gfar_write(macptr, *((u32 *) (tmpbuf))); - - tempval = *((u32 *) (tmpbuf + 4)); - - gfar_write(macptr+1, tempval); -} - /* GFAR error interrupt handler */ static irqreturn_t gfar_error(int irq, void *dev_id, struct pt_regs *regs) { diff --git a/trunk/drivers/net/gianfar.h b/trunk/drivers/net/gianfar.h index 94a91da84fbb..5065ba82cb76 100644 --- a/trunk/drivers/net/gianfar.h +++ b/trunk/drivers/net/gianfar.h @@ -90,26 +90,12 @@ extern const char gfar_driver_version[]; #define GFAR_RX_MAX_RING_SIZE 256 #define GFAR_TX_MAX_RING_SIZE 256 -#define GFAR_MAX_FIFO_THRESHOLD 511 -#define GFAR_MAX_FIFO_STARVE 511 -#define GFAR_MAX_FIFO_STARVE_OFF 511 - #define DEFAULT_RX_BUFFER_SIZE 1536 #define TX_RING_MOD_MASK(size) (size-1) #define RX_RING_MOD_MASK(size) (size-1) #define JUMBO_BUFFER_SIZE 9728 #define JUMBO_FRAME_SIZE 9600 -#define DEFAULT_FIFO_TX_THR 0x100 -#define DEFAULT_FIFO_TX_STARVE 0x40 -#define DEFAULT_FIFO_TX_STARVE_OFF 0x80 -#define DEFAULT_BD_STASH 1 -#define DEFAULT_STASH_LENGTH 64 -#define DEFAULT_STASH_INDEX 0 - -/* The number of Exact Match registers */ -#define GFAR_EM_NUM 15 - /* Latency of interface clock in nanoseconds */ /* Interface clock latency , in this case, means the * time described by a value of 1 in the interrupt @@ -126,11 +112,11 @@ extern const char gfar_driver_version[]; #define DEFAULT_TX_COALESCE 1 #define DEFAULT_TXCOUNT 16 -#define DEFAULT_TXTIME 4 +#define DEFAULT_TXTIME 400 #define DEFAULT_RX_COALESCE 1 #define DEFAULT_RXCOUNT 16 -#define DEFAULT_RXTIME 4 +#define DEFAULT_RXTIME 400 #define TBIPA_VALUE 0x1f #define MIIMCFG_INIT_VALUE 0x00000007 @@ -161,7 +147,6 @@ extern const char gfar_driver_version[]; #define ECNTRL_INIT_SETTINGS 0x00001000 #define ECNTRL_TBI_MODE 0x00000020 -#define ECNTRL_R100 0x00000008 #define MRBLR_INIT_SETTINGS DEFAULT_RX_BUFFER_SIZE @@ -196,12 +181,10 @@ extern const char gfar_driver_version[]; #define RCTRL_PRSDEP_MASK 0x000000c0 #define RCTRL_PRSDEP_INIT 0x000000c0 #define RCTRL_PROM 0x00000008 -#define RCTRL_EMEN 0x00000002 #define RCTRL_CHECKSUMMING (RCTRL_IPCSEN \ | RCTRL_TUCSEN | RCTRL_PRSDEP_INIT) #define RCTRL_EXTHASH (RCTRL_GHTX) #define RCTRL_VLAN (RCTRL_PRSDEP_INIT) -#define RCTRL_PADDING(x) ((x << 16) & RCTRL_PAL_MASK) #define RSTAT_CLEAR_RHALT 0x00800000 @@ -268,26 +251,28 @@ extern const char gfar_driver_version[]; IMASK_XFUN | IMASK_RXC | IMASK_BABT | IMASK_DPE \ | IMASK_PERR) -/* Fifo management */ -#define FIFO_TX_THR_MASK 0x01ff -#define FIFO_TX_STARVE_MASK 0x01ff -#define FIFO_TX_STARVE_OFF_MASK 0x01ff /* Attribute fields */ /* This enables rx snooping for buffers and descriptors */ +#ifdef CONFIG_GFAR_BDSTASH #define ATTR_BDSTASH 0x00000800 +#else +#define ATTR_BDSTASH 0x00000000 +#endif +#ifdef CONFIG_GFAR_BUFSTASH #define ATTR_BUFSTASH 0x00004000 +#define STASH_LENGTH 64 +#else +#define ATTR_BUFSTASH 0x00000000 +#endif #define ATTR_SNOOPING 0x000000c0 -#define ATTR_INIT_SETTINGS ATTR_SNOOPING +#define ATTR_INIT_SETTINGS (ATTR_SNOOPING \ + | ATTR_BDSTASH | ATTR_BUFSTASH) #define ATTRELI_INIT_SETTINGS 0x0 -#define ATTRELI_EL_MASK 0x3fff0000 -#define ATTRELI_EL(x) (x << 16) -#define ATTRELI_EI_MASK 0x00003fff -#define ATTRELI_EI(x) (x) /* TxBD status field bits */ @@ -343,7 +328,6 @@ extern const char gfar_driver_version[]; #define RXFCB_CTU 0x0400 #define RXFCB_EIP 0x0200 #define RXFCB_ETU 0x0100 -#define RXFCB_CSUM_MASK 0x0f00 #define RXFCB_PERR_MASK 0x000c #define RXFCB_PERR_BADL3 0x0008 @@ -355,7 +339,14 @@ struct txbd8 }; struct txfcb { - u8 flags; + u8 vln:1, + ip:1, + ip6:1, + tup:1, + udp:1, + cip:1, + ctu:1, + nph:1; u8 reserved; u8 l4os; /* Level 4 Header Offset */ u8 l3os; /* Level 3 Header Offset */ @@ -371,7 +362,14 @@ struct rxbd8 }; struct rxfcb { - u16 flags; + u16 vln:1, + ip:1, + ip6:1, + tup:1, + cip:1, + ctu:1, + eip:1, + etu:1; u8 rq; /* Receive Queue index */ u8 pro; /* Layer 4 Protocol */ u16 reserved; @@ -690,17 +688,12 @@ struct gfar_private { spinlock_t lock; unsigned int rx_buffer_size; unsigned int rx_stash_size; - unsigned int rx_stash_index; unsigned int tx_ring_size; unsigned int rx_ring_size; - unsigned int fifo_threshold; - unsigned int fifo_starve; - unsigned int fifo_starve_off; unsigned char vlan_enable:1, rx_csum_enable:1, - extended_hash:1, - bd_stash_en:1; + extended_hash:1; unsigned short padding; struct vlan_group *vlgrp; /* Info structure initialized by board setup code */ @@ -738,6 +731,6 @@ extern void stop_gfar(struct net_device *dev); extern void gfar_halt(struct net_device *dev); extern void gfar_phy_test(struct mii_bus *bus, struct phy_device *phydev, int enable, u32 regnum, u32 read); -void gfar_init_sysfs(struct net_device *dev); +void gfar_setup_stashing(struct net_device *dev); #endif /* __GIANFAR_H */ diff --git a/trunk/drivers/net/gianfar_ethtool.c b/trunk/drivers/net/gianfar_ethtool.c index 765e810620fe..cfa3cd7c91a0 100644 --- a/trunk/drivers/net/gianfar_ethtool.c +++ b/trunk/drivers/net/gianfar_ethtool.c @@ -125,7 +125,7 @@ static char stat_gstrings[][ETH_GSTRING_LEN] = { static void gfar_gstrings(struct net_device *dev, u32 stringset, u8 * buf) { struct gfar_private *priv = netdev_priv(dev); - + if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) memcpy(buf, stat_gstrings, GFAR_STATS_LEN * ETH_GSTRING_LEN); else diff --git a/trunk/drivers/net/gianfar_mii.h b/trunk/drivers/net/gianfar_mii.h index d527cf2f9c1d..e85eb216fb5b 100644 --- a/trunk/drivers/net/gianfar_mii.h +++ b/trunk/drivers/net/gianfar_mii.h @@ -24,7 +24,6 @@ #define MII_READ_COMMAND 0x00000001 #define GFAR_SUPPORTED (SUPPORTED_10baseT_Half \ - | SUPPORTED_10baseT_Full \ | SUPPORTED_100baseT_Half \ | SUPPORTED_100baseT_Full \ | SUPPORTED_Autoneg \ diff --git a/trunk/drivers/net/gianfar_sysfs.c b/trunk/drivers/net/gianfar_sysfs.c deleted file mode 100644 index 10d34cb19192..000000000000 --- a/trunk/drivers/net/gianfar_sysfs.c +++ /dev/null @@ -1,311 +0,0 @@ -/* - * drivers/net/gianfar_sysfs.c - * - * Gianfar Ethernet Driver - * This driver is designed for the non-CPM ethernet controllers - * on the 85xx and 83xx family of integrated processors - * Based on 8260_io/fcc_enet.c - * - * Author: Andy Fleming - * Maintainer: Kumar Gala (kumar.gala@freescale.com) - * - * Copyright (c) 2002-2005 Freescale Semiconductor, Inc. - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. - * - * Sysfs file creation and management - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "gianfar.h" - -#define GFAR_ATTR(_name) \ -static ssize_t gfar_show_##_name(struct class_device *cdev, char *buf); \ -static ssize_t gfar_set_##_name(struct class_device *cdev, \ - const char *buf, size_t count); \ -static CLASS_DEVICE_ATTR(_name, 0644, gfar_show_##_name, gfar_set_##_name) - -#define GFAR_CREATE_FILE(_dev, _name) \ - class_device_create_file(&_dev->class_dev, &class_device_attr_##_name) - -GFAR_ATTR(bd_stash); -GFAR_ATTR(rx_stash_size); -GFAR_ATTR(rx_stash_index); -GFAR_ATTR(fifo_threshold); -GFAR_ATTR(fifo_starve); -GFAR_ATTR(fifo_starve_off); - -#define to_net_dev(cd) container_of(cd, struct net_device, class_dev) - -static ssize_t gfar_show_bd_stash(struct class_device *cdev, char *buf) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - - return sprintf(buf, "%s\n", priv->bd_stash_en? "on" : "off"); -} - -static ssize_t gfar_set_bd_stash(struct class_device *cdev, - const char *buf, size_t count) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - int new_setting = 0; - u32 temp; - unsigned long flags; - - /* Find out the new setting */ - if (!strncmp("on", buf, count-1) || !strncmp("1", buf, count-1)) - new_setting = 1; - else if (!strncmp("off", buf, count-1) || !strncmp("0", buf, count-1)) - new_setting = 0; - else - return count; - - spin_lock_irqsave(&priv->lock, flags); - - /* Set the new stashing value */ - priv->bd_stash_en = new_setting; - - temp = gfar_read(&priv->regs->attr); - - if (new_setting) - temp |= ATTR_BDSTASH; - else - temp &= ~(ATTR_BDSTASH); - - gfar_write(&priv->regs->attr, temp); - - spin_unlock_irqrestore(&priv->lock, flags); - - return count; -} - -static ssize_t gfar_show_rx_stash_size(struct class_device *cdev, char *buf) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - - return sprintf(buf, "%d\n", priv->rx_stash_size); -} - -static ssize_t gfar_set_rx_stash_size(struct class_device *cdev, - const char *buf, size_t count) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - unsigned int length = simple_strtoul(buf, NULL, 0); - u32 temp; - unsigned long flags; - - spin_lock_irqsave(&priv->lock, flags); - if (length > priv->rx_buffer_size) - return count; - - if (length == priv->rx_stash_size) - return count; - - priv->rx_stash_size = length; - - temp = gfar_read(&priv->regs->attreli); - temp &= ~ATTRELI_EL_MASK; - temp |= ATTRELI_EL(length); - gfar_write(&priv->regs->attreli, temp); - - /* Turn stashing on/off as appropriate */ - temp = gfar_read(&priv->regs->attr); - - if (length) - temp |= ATTR_BUFSTASH; - else - temp &= ~(ATTR_BUFSTASH); - - gfar_write(&priv->regs->attr, temp); - - spin_unlock_irqrestore(&priv->lock, flags); - - return count; -} - - -/* Stashing will only be enabled when rx_stash_size != 0 */ -static ssize_t gfar_show_rx_stash_index(struct class_device *cdev, char *buf) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - - return sprintf(buf, "%d\n", priv->rx_stash_index); -} - -static ssize_t gfar_set_rx_stash_index(struct class_device *cdev, - const char *buf, size_t count) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - unsigned short index = simple_strtoul(buf, NULL, 0); - u32 temp; - unsigned long flags; - - spin_lock_irqsave(&priv->lock, flags); - if (index > priv->rx_stash_size) - return count; - - if (index == priv->rx_stash_index) - return count; - - priv->rx_stash_index = index; - - temp = gfar_read(&priv->regs->attreli); - temp &= ~ATTRELI_EI_MASK; - temp |= ATTRELI_EI(index); - gfar_write(&priv->regs->attreli, flags); - - spin_unlock_irqrestore(&priv->lock, flags); - - return count; -} - -static ssize_t gfar_show_fifo_threshold(struct class_device *cdev, char *buf) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - - return sprintf(buf, "%d\n", priv->fifo_threshold); -} - -static ssize_t gfar_set_fifo_threshold(struct class_device *cdev, - const char *buf, size_t count) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - unsigned int length = simple_strtoul(buf, NULL, 0); - u32 temp; - unsigned long flags; - - if (length > GFAR_MAX_FIFO_THRESHOLD) - return count; - - spin_lock_irqsave(&priv->lock, flags); - - priv->fifo_threshold = length; - - temp = gfar_read(&priv->regs->fifo_tx_thr); - temp &= ~FIFO_TX_THR_MASK; - temp |= length; - gfar_write(&priv->regs->fifo_tx_thr, temp); - - spin_unlock_irqrestore(&priv->lock, flags); - - return count; -} - -static ssize_t gfar_show_fifo_starve(struct class_device *cdev, char *buf) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - - return sprintf(buf, "%d\n", priv->fifo_starve); -} - - -static ssize_t gfar_set_fifo_starve(struct class_device *cdev, - const char *buf, size_t count) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - unsigned int num = simple_strtoul(buf, NULL, 0); - u32 temp; - unsigned long flags; - - if (num > GFAR_MAX_FIFO_STARVE) - return count; - - spin_lock_irqsave(&priv->lock, flags); - - priv->fifo_starve = num; - - temp = gfar_read(&priv->regs->fifo_tx_starve); - temp &= ~FIFO_TX_STARVE_MASK; - temp |= num; - gfar_write(&priv->regs->fifo_tx_starve, temp); - - spin_unlock_irqrestore(&priv->lock, flags); - - return count; -} - -static ssize_t gfar_show_fifo_starve_off(struct class_device *cdev, char *buf) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - - return sprintf(buf, "%d\n", priv->fifo_starve_off); -} - -static ssize_t gfar_set_fifo_starve_off(struct class_device *cdev, - const char *buf, size_t count) -{ - struct net_device *dev = to_net_dev(cdev); - struct gfar_private *priv = netdev_priv(dev); - unsigned int num = simple_strtoul(buf, NULL, 0); - u32 temp; - unsigned long flags; - - if (num > GFAR_MAX_FIFO_STARVE_OFF) - return count; - - spin_lock_irqsave(&priv->lock, flags); - - priv->fifo_starve_off = num; - - temp = gfar_read(&priv->regs->fifo_tx_starve_shutoff); - temp &= ~FIFO_TX_STARVE_OFF_MASK; - temp |= num; - gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp); - - spin_unlock_irqrestore(&priv->lock, flags); - - return count; -} - -void gfar_init_sysfs(struct net_device *dev) -{ - struct gfar_private *priv = netdev_priv(dev); - - /* Initialize the default values */ - priv->rx_stash_size = DEFAULT_STASH_LENGTH; - priv->rx_stash_index = DEFAULT_STASH_INDEX; - priv->fifo_threshold = DEFAULT_FIFO_TX_THR; - priv->fifo_starve = DEFAULT_FIFO_TX_STARVE; - priv->fifo_starve_off = DEFAULT_FIFO_TX_STARVE_OFF; - priv->bd_stash_en = DEFAULT_BD_STASH; - - /* Create our sysfs files */ - GFAR_CREATE_FILE(dev, bd_stash); - GFAR_CREATE_FILE(dev, rx_stash_size); - GFAR_CREATE_FILE(dev, rx_stash_index); - GFAR_CREATE_FILE(dev, fifo_threshold); - GFAR_CREATE_FILE(dev, fifo_starve); - GFAR_CREATE_FILE(dev, fifo_starve_off); - -} diff --git a/trunk/drivers/net/irda/irda-usb.c b/trunk/drivers/net/irda/irda-usb.c index fa176ffb4ad5..c22c0517883c 100644 --- a/trunk/drivers/net/irda/irda-usb.c +++ b/trunk/drivers/net/irda/irda-usb.c @@ -1539,6 +1539,7 @@ static void irda_usb_disconnect(struct usb_interface *intf) * USB device callbacks */ static struct usb_driver irda_driver = { + .owner = THIS_MODULE, .name = "irda-usb", .probe = irda_usb_probe, .disconnect = irda_usb_disconnect, diff --git a/trunk/drivers/net/irda/stir4200.c b/trunk/drivers/net/irda/stir4200.c index 31867e4b891b..3961a754e920 100644 --- a/trunk/drivers/net/irda/stir4200.c +++ b/trunk/drivers/net/irda/stir4200.c @@ -1152,6 +1152,7 @@ static int stir_resume(struct usb_interface *intf) * USB device callbacks */ static struct usb_driver irda_driver = { + .owner = THIS_MODULE, .name = "stir4200", .probe = stir_probe, .disconnect = stir_disconnect, diff --git a/trunk/drivers/net/ixp2000/Kconfig b/trunk/drivers/net/ixp2000/Kconfig deleted file mode 100644 index 2fec2415651f..000000000000 --- a/trunk/drivers/net/ixp2000/Kconfig +++ /dev/null @@ -1,6 +0,0 @@ -config ENP2611_MSF_NET - tristate "Radisys ENP2611 MSF network interface support" - depends on ARCH_ENP2611 - help - This is a driver for the MSF network interface unit in - the IXP2400 on the Radisys ENP2611 platform. diff --git a/trunk/drivers/net/ixp2000/Makefile b/trunk/drivers/net/ixp2000/Makefile deleted file mode 100644 index fd38351ceaa7..000000000000 --- a/trunk/drivers/net/ixp2000/Makefile +++ /dev/null @@ -1,3 +0,0 @@ -obj-$(CONFIG_ENP2611_MSF_NET) += enp2611_mod.o - -enp2611_mod-objs := caleb.o enp2611.o ixp2400-msf.o ixpdev.o pm3386.o diff --git a/trunk/drivers/net/ixp2000/caleb.c b/trunk/drivers/net/ixp2000/caleb.c deleted file mode 100644 index 3595e107df22..000000000000 --- a/trunk/drivers/net/ixp2000/caleb.c +++ /dev/null @@ -1,137 +0,0 @@ -/* - * Helper functions for the SPI-3 bridge FPGA on the Radisys ENP2611 - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#include -#include -#include -#include -#include "caleb.h" - -#define CALEB_IDLO 0x00 -#define CALEB_IDHI 0x01 -#define CALEB_RID 0x02 -#define CALEB_RESET 0x03 -#define CALEB_INTREN0 0x04 -#define CALEB_INTREN1 0x05 -#define CALEB_INTRSTAT0 0x06 -#define CALEB_INTRSTAT1 0x07 -#define CALEB_PORTEN 0x08 -#define CALEB_BURST 0x09 -#define CALEB_PORTPAUS 0x0A -#define CALEB_PORTPAUSD 0x0B -#define CALEB_PHY0RX 0x10 -#define CALEB_PHY1RX 0x11 -#define CALEB_PHY0TX 0x12 -#define CALEB_PHY1TX 0x13 -#define CALEB_IXPRX_HI_CNTR 0x15 -#define CALEB_PHY0RX_HI_CNTR 0x16 -#define CALEB_PHY1RX_HI_CNTR 0x17 -#define CALEB_IXPRX_CNTR 0x18 -#define CALEB_PHY0RX_CNTR 0x19 -#define CALEB_PHY1RX_CNTR 0x1A -#define CALEB_IXPTX_CNTR 0x1B -#define CALEB_PHY0TX_CNTR 0x1C -#define CALEB_PHY1TX_CNTR 0x1D -#define CALEB_DEBUG0 0x1E -#define CALEB_DEBUG1 0x1F - - -static u8 caleb_reg_read(int reg) -{ - u8 value; - - value = *((volatile u8 *)(ENP2611_CALEB_VIRT_BASE + reg)); - -// printk(KERN_INFO "caleb_reg_read(%d) = %.2x\n", reg, value); - - return value; -} - -static void caleb_reg_write(int reg, u8 value) -{ - u8 dummy; - -// printk(KERN_INFO "caleb_reg_write(%d, %.2x)\n", reg, value); - - *((volatile u8 *)(ENP2611_CALEB_VIRT_BASE + reg)) = value; - - dummy = *((volatile u8 *)ENP2611_CALEB_VIRT_BASE); - __asm__ __volatile__("mov %0, %0" : "+r" (dummy)); -} - - -void caleb_reset(void) -{ - /* - * Perform a chip reset. - */ - caleb_reg_write(CALEB_RESET, 0x02); - udelay(1); - - /* - * Enable all interrupt sources. This is needed to get - * meaningful results out of the status bits (register 6 - * and 7.) - */ - caleb_reg_write(CALEB_INTREN0, 0xff); - caleb_reg_write(CALEB_INTREN1, 0x07); - - /* - * Set RX and TX FIFO thresholds to 1.5kb. - */ - caleb_reg_write(CALEB_PHY0RX, 0x11); - caleb_reg_write(CALEB_PHY1RX, 0x11); - caleb_reg_write(CALEB_PHY0TX, 0x11); - caleb_reg_write(CALEB_PHY1TX, 0x11); - - /* - * Program SPI-3 burst size. - */ - caleb_reg_write(CALEB_BURST, 0); // 64-byte RBUF mpackets -// caleb_reg_write(CALEB_BURST, 1); // 128-byte RBUF mpackets -// caleb_reg_write(CALEB_BURST, 2); // 256-byte RBUF mpackets -} - -void caleb_enable_rx(int port) -{ - u8 temp; - - temp = caleb_reg_read(CALEB_PORTEN); - temp |= 1 << port; - caleb_reg_write(CALEB_PORTEN, temp); -} - -void caleb_disable_rx(int port) -{ - u8 temp; - - temp = caleb_reg_read(CALEB_PORTEN); - temp &= ~(1 << port); - caleb_reg_write(CALEB_PORTEN, temp); -} - -void caleb_enable_tx(int port) -{ - u8 temp; - - temp = caleb_reg_read(CALEB_PORTEN); - temp |= 1 << (port + 4); - caleb_reg_write(CALEB_PORTEN, temp); -} - -void caleb_disable_tx(int port) -{ - u8 temp; - - temp = caleb_reg_read(CALEB_PORTEN); - temp &= ~(1 << (port + 4)); - caleb_reg_write(CALEB_PORTEN, temp); -} diff --git a/trunk/drivers/net/ixp2000/caleb.h b/trunk/drivers/net/ixp2000/caleb.h deleted file mode 100644 index e93a1ef5b8a3..000000000000 --- a/trunk/drivers/net/ixp2000/caleb.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Helper functions for the SPI-3 bridge FPGA on the Radisys ENP2611 - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#ifndef __CALEB_H -#define __CALEB_H - -void caleb_reset(void); -void caleb_enable_rx(int port); -void caleb_disable_rx(int port); -void caleb_enable_tx(int port); -void caleb_disable_tx(int port); - - -#endif diff --git a/trunk/drivers/net/ixp2000/enp2611.c b/trunk/drivers/net/ixp2000/enp2611.c deleted file mode 100644 index d82651a97bae..000000000000 --- a/trunk/drivers/net/ixp2000/enp2611.c +++ /dev/null @@ -1,245 +0,0 @@ -/* - * IXP2400 MSF network device driver for the Radisys ENP2611 - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "ixpdev.h" -#include "caleb.h" -#include "ixp2400-msf.h" -#include "pm3386.h" - -/*********************************************************************** - * The Radisys ENP2611 is a PCI form factor board with three SFP GBIC - * slots, connected via two PMC/Sierra 3386s and an SPI-3 bridge FPGA - * to the IXP2400. - * - * +-------------+ - * SFP GBIC #0 ---+ | +---------+ - * | PM3386 #0 +-------+ | - * SFP GBIC #1 ---+ | | "Caleb" | +---------+ - * +-------------+ | | | | - * | SPI-3 +---------+ IXP2400 | - * +-------------+ | bridge | | | - * SFP GBIC #2 ---+ | | FPGA | +---------+ - * | PM3386 #1 +-------+ | - * | | +---------+ - * +-------------+ - * ^ ^ ^ - * | 1.25Gbaud | 104MHz | 104MHz - * | SERDES ea. | SPI-3 ea. | SPI-3 - * - ***********************************************************************/ -static struct ixp2400_msf_parameters enp2611_msf_parameters = -{ - .rx_mode = IXP2400_RX_MODE_UTOPIA_POS | - IXP2400_RX_MODE_1x32 | - IXP2400_RX_MODE_MPHY | - IXP2400_RX_MODE_MPHY_32 | - IXP2400_RX_MODE_MPHY_POLLED_STATUS | - IXP2400_RX_MODE_MPHY_LEVEL3 | - IXP2400_RX_MODE_RBUF_SIZE_64, - - .rxclk01_multiplier = IXP2400_PLL_MULTIPLIER_16, - - .rx_poll_ports = 3, - - .rx_channel_mode = { - IXP2400_PORT_RX_MODE_MASTER | - IXP2400_PORT_RX_MODE_POS_PHY | - IXP2400_PORT_RX_MODE_POS_PHY_L3 | - IXP2400_PORT_RX_MODE_ODD_PARITY | - IXP2400_PORT_RX_MODE_2_CYCLE_DECODE, - - IXP2400_PORT_RX_MODE_MASTER | - IXP2400_PORT_RX_MODE_POS_PHY | - IXP2400_PORT_RX_MODE_POS_PHY_L3 | - IXP2400_PORT_RX_MODE_ODD_PARITY | - IXP2400_PORT_RX_MODE_2_CYCLE_DECODE, - - IXP2400_PORT_RX_MODE_MASTER | - IXP2400_PORT_RX_MODE_POS_PHY | - IXP2400_PORT_RX_MODE_POS_PHY_L3 | - IXP2400_PORT_RX_MODE_ODD_PARITY | - IXP2400_PORT_RX_MODE_2_CYCLE_DECODE, - - IXP2400_PORT_RX_MODE_MASTER | - IXP2400_PORT_RX_MODE_POS_PHY | - IXP2400_PORT_RX_MODE_POS_PHY_L3 | - IXP2400_PORT_RX_MODE_ODD_PARITY | - IXP2400_PORT_RX_MODE_2_CYCLE_DECODE - }, - - .tx_mode = IXP2400_TX_MODE_UTOPIA_POS | - IXP2400_TX_MODE_1x32 | - IXP2400_TX_MODE_MPHY | - IXP2400_TX_MODE_MPHY_32 | - IXP2400_TX_MODE_MPHY_POLLED_STATUS | - IXP2400_TX_MODE_MPHY_LEVEL3 | - IXP2400_TX_MODE_TBUF_SIZE_64, - - .txclk01_multiplier = IXP2400_PLL_MULTIPLIER_16, - - .tx_poll_ports = 3, - - .tx_channel_mode = { - IXP2400_PORT_TX_MODE_MASTER | - IXP2400_PORT_TX_MODE_POS_PHY | - IXP2400_PORT_TX_MODE_ODD_PARITY | - IXP2400_PORT_TX_MODE_2_CYCLE_DECODE, - - IXP2400_PORT_TX_MODE_MASTER | - IXP2400_PORT_TX_MODE_POS_PHY | - IXP2400_PORT_TX_MODE_ODD_PARITY | - IXP2400_PORT_TX_MODE_2_CYCLE_DECODE, - - IXP2400_PORT_TX_MODE_MASTER | - IXP2400_PORT_TX_MODE_POS_PHY | - IXP2400_PORT_TX_MODE_ODD_PARITY | - IXP2400_PORT_TX_MODE_2_CYCLE_DECODE, - - IXP2400_PORT_TX_MODE_MASTER | - IXP2400_PORT_TX_MODE_POS_PHY | - IXP2400_PORT_TX_MODE_ODD_PARITY | - IXP2400_PORT_TX_MODE_2_CYCLE_DECODE - } -}; - -struct enp2611_ixpdev_priv -{ - struct ixpdev_priv ixpdev_priv; - struct net_device_stats stats; -}; - -static struct net_device *nds[3]; -static struct timer_list link_check_timer; - -static struct net_device_stats *enp2611_get_stats(struct net_device *dev) -{ - struct enp2611_ixpdev_priv *ip = netdev_priv(dev); - - pm3386_get_stats(ip->ixpdev_priv.channel, &(ip->stats)); - - return &(ip->stats); -} - -/* @@@ Poll the SFP moddef0 line too. */ -/* @@@ Try to use the pm3386 DOOL interrupt as well. */ -static void enp2611_check_link_status(unsigned long __dummy) -{ - int i; - - for (i = 0; i < 3; i++) { - struct net_device *dev; - int status; - - dev = nds[i]; - - status = pm3386_is_link_up(i); - if (status && !netif_carrier_ok(dev)) { - /* @@@ Should report autonegotiation status. */ - printk(KERN_INFO "%s: NIC Link is Up\n", dev->name); - - pm3386_enable_tx(i); - caleb_enable_tx(i); - netif_carrier_on(dev); - } else if (!status && netif_carrier_ok(dev)) { - printk(KERN_INFO "%s: NIC Link is Down\n", dev->name); - - netif_carrier_off(dev); - caleb_disable_tx(i); - pm3386_disable_tx(i); - } - } - - link_check_timer.expires = jiffies + HZ / 10; - add_timer(&link_check_timer); -} - -static void enp2611_set_port_admin_status(int port, int up) -{ - if (up) { - caleb_enable_rx(port); - - pm3386_set_carrier(port, 1); - pm3386_enable_rx(port); - } else { - caleb_disable_tx(port); - pm3386_disable_tx(port); - /* @@@ Flush out pending packets. */ - pm3386_set_carrier(port, 0); - - pm3386_disable_rx(port); - caleb_disable_rx(port); - } -} - -static int __init enp2611_init_module(void) -{ - int i; - - if (!machine_is_enp2611()) - return -ENODEV; - - caleb_reset(); - pm3386_reset(); - - for (i = 0; i < 3; i++) { - nds[i] = ixpdev_alloc(i, sizeof(struct enp2611_ixpdev_priv)); - if (nds[i] == NULL) { - while (--i >= 0) - free_netdev(nds[i]); - return -ENOMEM; - } - - SET_MODULE_OWNER(nds[i]); - nds[i]->get_stats = enp2611_get_stats; - pm3386_init_port(i); - pm3386_get_mac(i, nds[i]->dev_addr); - } - - ixp2400_msf_init(&enp2611_msf_parameters); - - if (ixpdev_init(3, nds, enp2611_set_port_admin_status)) { - for (i = 0; i < 3; i++) - free_netdev(nds[i]); - return -EINVAL; - } - - init_timer(&link_check_timer); - link_check_timer.function = enp2611_check_link_status; - link_check_timer.expires = jiffies; - add_timer(&link_check_timer); - - return 0; -} - -static void __exit enp2611_cleanup_module(void) -{ - int i; - - del_timer_sync(&link_check_timer); - - ixpdev_deinit(); - for (i = 0; i < 3; i++) - free_netdev(nds[i]); -} - -module_init(enp2611_init_module); -module_exit(enp2611_cleanup_module); -MODULE_LICENSE("GPL"); diff --git a/trunk/drivers/net/ixp2000/ixp2400-msf.c b/trunk/drivers/net/ixp2000/ixp2400-msf.c deleted file mode 100644 index 48a3a891d3a4..000000000000 --- a/trunk/drivers/net/ixp2000/ixp2400-msf.c +++ /dev/null @@ -1,213 +0,0 @@ -/* - * Generic library functions for the MSF (Media and Switch Fabric) unit - * found on the Intel IXP2400 network processor. - * - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation; either version 2.1 of the - * License, or (at your option) any later version. - */ - -#include -#include -#include -#include -#include -#include -#include -#include "ixp2400-msf.h" - -/* - * This is the Intel recommended PLL init procedure as described on - * page 340 of the IXP2400/IXP2800 Programmer's Reference Manual. - */ -static void ixp2400_pll_init(struct ixp2400_msf_parameters *mp) -{ - int rx_dual_clock; - int tx_dual_clock; - u32 value; - - /* - * If the RX mode is not 1x32, we have to enable both RX PLLs - * (#0 and #1.) The same thing for the TX direction. - */ - rx_dual_clock = !!(mp->rx_mode & IXP2400_RX_MODE_WIDTH_MASK); - tx_dual_clock = !!(mp->tx_mode & IXP2400_TX_MODE_WIDTH_MASK); - - /* - * Read initial value. - */ - value = ixp2000_reg_read(IXP2000_MSF_CLK_CNTRL); - - /* - * Put PLLs in powerdown and bypass mode. - */ - value |= 0x0000f0f0; - ixp2000_reg_write(IXP2000_MSF_CLK_CNTRL, value); - - /* - * Set single or dual clock mode bits. - */ - value &= ~0x03000000; - value |= (rx_dual_clock << 24) | (tx_dual_clock << 25); - - /* - * Set multipliers. - */ - value &= ~0x00ff0000; - value |= mp->rxclk01_multiplier << 16; - value |= mp->rxclk23_multiplier << 18; - value |= mp->txclk01_multiplier << 20; - value |= mp->txclk23_multiplier << 22; - - /* - * And write value. - */ - ixp2000_reg_write(IXP2000_MSF_CLK_CNTRL, value); - - /* - * Disable PLL bypass mode. - */ - value &= ~(0x00005000 | rx_dual_clock << 13 | tx_dual_clock << 15); - ixp2000_reg_write(IXP2000_MSF_CLK_CNTRL, value); - - /* - * Turn on PLLs. - */ - value &= ~(0x00000050 | rx_dual_clock << 5 | tx_dual_clock << 7); - ixp2000_reg_write(IXP2000_MSF_CLK_CNTRL, value); - - /* - * Wait for PLLs to lock. There are lock status bits, but IXP2400 - * erratum #65 says that these lock bits should not be relied upon - * as they might not accurately reflect the true state of the PLLs. - */ - udelay(100); -} - -/* - * Needed according to p480 of Programmer's Reference Manual. - */ -static void ixp2400_msf_free_rbuf_entries(struct ixp2400_msf_parameters *mp) -{ - int size_bits; - int i; - - /* - * Work around IXP2400 erratum #69 (silent RBUF-to-DRAM transfer - * corruption) in the Intel-recommended way: do not add the RBUF - * elements susceptible to corruption to the freelist. - */ - size_bits = mp->rx_mode & IXP2400_RX_MODE_RBUF_SIZE_MASK; - if (size_bits == IXP2400_RX_MODE_RBUF_SIZE_64) { - for (i = 1; i < 128; i++) { - if (i == 9 || i == 18 || i == 27) - continue; - ixp2000_reg_write(IXP2000_MSF_RBUF_ELEMENT_DONE, i); - } - } else if (size_bits == IXP2400_RX_MODE_RBUF_SIZE_128) { - for (i = 1; i < 64; i++) { - if (i == 4 || i == 9 || i == 13) - continue; - ixp2000_reg_write(IXP2000_MSF_RBUF_ELEMENT_DONE, i); - } - } else if (size_bits == IXP2400_RX_MODE_RBUF_SIZE_256) { - for (i = 1; i < 32; i++) { - if (i == 2 || i == 4 || i == 6) - continue; - ixp2000_reg_write(IXP2000_MSF_RBUF_ELEMENT_DONE, i); - } - } -} - -static u32 ixp2400_msf_valid_channels(u32 reg) -{ - u32 channels; - - channels = 0; - switch (reg & IXP2400_RX_MODE_WIDTH_MASK) { - case IXP2400_RX_MODE_1x32: - channels = 0x1; - if (reg & IXP2400_RX_MODE_MPHY && - !(reg & IXP2400_RX_MODE_MPHY_32)) - channels = 0xf; - break; - - case IXP2400_RX_MODE_2x16: - channels = 0x5; - break; - - case IXP2400_RX_MODE_4x8: - channels = 0xf; - break; - - case IXP2400_RX_MODE_1x16_2x8: - channels = 0xd; - break; - } - - return channels; -} - -static void ixp2400_msf_enable_rx(struct ixp2400_msf_parameters *mp) -{ - u32 value; - - value = ixp2000_reg_read(IXP2000_MSF_RX_CONTROL) & 0x0fffffff; - value |= ixp2400_msf_valid_channels(mp->rx_mode) << 28; - ixp2000_reg_write(IXP2000_MSF_RX_CONTROL, value); -} - -static void ixp2400_msf_enable_tx(struct ixp2400_msf_parameters *mp) -{ - u32 value; - - value = ixp2000_reg_read(IXP2000_MSF_TX_CONTROL) & 0x0fffffff; - value |= ixp2400_msf_valid_channels(mp->tx_mode) << 28; - ixp2000_reg_write(IXP2000_MSF_TX_CONTROL, value); -} - - -void ixp2400_msf_init(struct ixp2400_msf_parameters *mp) -{ - u32 value; - int i; - - /* - * Init the RX/TX PLLs based on the passed parameter block. - */ - ixp2400_pll_init(mp); - - /* - * Reset MSF. Bit 7 in IXP_RESET_0 resets the MSF. - */ - value = ixp2000_reg_read(IXP2000_RESET0); - ixp2000_reg_write(IXP2000_RESET0, value | 0x80); - ixp2000_reg_write(IXP2000_RESET0, value & ~0x80); - - /* - * Initialise the RX section. - */ - ixp2000_reg_write(IXP2000_MSF_RX_MPHY_POLL_LIMIT, mp->rx_poll_ports - 1); - ixp2000_reg_write(IXP2000_MSF_RX_CONTROL, mp->rx_mode); - for (i = 0; i < 4; i++) { - ixp2000_reg_write(IXP2000_MSF_RX_UP_CONTROL_0 + i, - mp->rx_channel_mode[i]); - } - ixp2400_msf_free_rbuf_entries(mp); - ixp2400_msf_enable_rx(mp); - - /* - * Initialise the TX section. - */ - ixp2000_reg_write(IXP2000_MSF_TX_MPHY_POLL_LIMIT, mp->tx_poll_ports - 1); - ixp2000_reg_write(IXP2000_MSF_TX_CONTROL, mp->tx_mode); - for (i = 0; i < 4; i++) { - ixp2000_reg_write(IXP2000_MSF_TX_UP_CONTROL_0 + i, - mp->tx_channel_mode[i]); - } - ixp2400_msf_enable_tx(mp); -} diff --git a/trunk/drivers/net/ixp2000/ixp2400-msf.h b/trunk/drivers/net/ixp2000/ixp2400-msf.h deleted file mode 100644 index 3ac1af2771da..000000000000 --- a/trunk/drivers/net/ixp2000/ixp2400-msf.h +++ /dev/null @@ -1,115 +0,0 @@ -/* - * Generic library functions for the MSF (Media and Switch Fabric) unit - * found on the Intel IXP2400 network processor. - * - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation; either version 2.1 of the - * License, or (at your option) any later version. - */ - -#ifndef __IXP2400_MSF_H -#define __IXP2400_MSF_H - -struct ixp2400_msf_parameters -{ - u32 rx_mode; - unsigned rxclk01_multiplier:2; - unsigned rxclk23_multiplier:2; - unsigned rx_poll_ports:6; - u32 rx_channel_mode[4]; - - u32 tx_mode; - unsigned txclk01_multiplier:2; - unsigned txclk23_multiplier:2; - unsigned tx_poll_ports:6; - u32 tx_channel_mode[4]; -}; - -void ixp2400_msf_init(struct ixp2400_msf_parameters *mp); - -#define IXP2400_PLL_MULTIPLIER_48 0x00 -#define IXP2400_PLL_MULTIPLIER_24 0x01 -#define IXP2400_PLL_MULTIPLIER_16 0x02 -#define IXP2400_PLL_MULTIPLIER_12 0x03 - -#define IXP2400_RX_MODE_CSIX 0x00400000 -#define IXP2400_RX_MODE_UTOPIA_POS 0x00000000 -#define IXP2400_RX_MODE_WIDTH_MASK 0x00300000 -#define IXP2400_RX_MODE_1x16_2x8 0x00300000 -#define IXP2400_RX_MODE_4x8 0x00200000 -#define IXP2400_RX_MODE_2x16 0x00100000 -#define IXP2400_RX_MODE_1x32 0x00000000 -#define IXP2400_RX_MODE_MPHY 0x00080000 -#define IXP2400_RX_MODE_SPHY 0x00000000 -#define IXP2400_RX_MODE_MPHY_32 0x00040000 -#define IXP2400_RX_MODE_MPHY_4 0x00000000 -#define IXP2400_RX_MODE_MPHY_POLLED_STATUS 0x00020000 -#define IXP2400_RX_MODE_MPHY_DIRECT_STATUS 0x00000000 -#define IXP2400_RX_MODE_CBUS_FULL_DUPLEX 0x00010000 -#define IXP2400_RX_MODE_CBUS_SIMPLEX 0x00000000 -#define IXP2400_RX_MODE_MPHY_LEVEL2 0x00004000 -#define IXP2400_RX_MODE_MPHY_LEVEL3 0x00000000 -#define IXP2400_RX_MODE_CBUS_8BIT 0x00002000 -#define IXP2400_RX_MODE_CBUS_4BIT 0x00000000 -#define IXP2400_RX_MODE_CSIX_SINGLE_FREELIST 0x00000200 -#define IXP2400_RX_MODE_CSIX_SPLIT_FREELISTS 0x00000000 -#define IXP2400_RX_MODE_RBUF_SIZE_MASK 0x0000000c -#define IXP2400_RX_MODE_RBUF_SIZE_256 0x00000008 -#define IXP2400_RX_MODE_RBUF_SIZE_128 0x00000004 -#define IXP2400_RX_MODE_RBUF_SIZE_64 0x00000000 - -#define IXP2400_PORT_RX_MODE_SLAVE 0x00000040 -#define IXP2400_PORT_RX_MODE_MASTER 0x00000000 -#define IXP2400_PORT_RX_MODE_POS_PHY_L3 0x00000020 -#define IXP2400_PORT_RX_MODE_POS_PHY_L2 0x00000000 -#define IXP2400_PORT_RX_MODE_POS_PHY 0x00000010 -#define IXP2400_PORT_RX_MODE_UTOPIA 0x00000000 -#define IXP2400_PORT_RX_MODE_EVEN_PARITY 0x0000000c -#define IXP2400_PORT_RX_MODE_ODD_PARITY 0x00000008 -#define IXP2400_PORT_RX_MODE_NO_PARITY 0x00000000 -#define IXP2400_PORT_RX_MODE_UTOPIA_BIG_CELLS 0x00000002 -#define IXP2400_PORT_RX_MODE_UTOPIA_NORMAL_CELLS 0x00000000 -#define IXP2400_PORT_RX_MODE_2_CYCLE_DECODE 0x00000001 -#define IXP2400_PORT_RX_MODE_1_CYCLE_DECODE 0x00000000 - -#define IXP2400_TX_MODE_CSIX 0x00400000 -#define IXP2400_TX_MODE_UTOPIA_POS 0x00000000 -#define IXP2400_TX_MODE_WIDTH_MASK 0x00300000 -#define IXP2400_TX_MODE_1x16_2x8 0x00300000 -#define IXP2400_TX_MODE_4x8 0x00200000 -#define IXP2400_TX_MODE_2x16 0x00100000 -#define IXP2400_TX_MODE_1x32 0x00000000 -#define IXP2400_TX_MODE_MPHY 0x00080000 -#define IXP2400_TX_MODE_SPHY 0x00000000 -#define IXP2400_TX_MODE_MPHY_32 0x00040000 -#define IXP2400_TX_MODE_MPHY_4 0x00000000 -#define IXP2400_TX_MODE_MPHY_POLLED_STATUS 0x00020000 -#define IXP2400_TX_MODE_MPHY_DIRECT_STATUS 0x00000000 -#define IXP2400_TX_MODE_CBUS_FULL_DUPLEX 0x00010000 -#define IXP2400_TX_MODE_CBUS_SIMPLEX 0x00000000 -#define IXP2400_TX_MODE_MPHY_LEVEL2 0x00004000 -#define IXP2400_TX_MODE_MPHY_LEVEL3 0x00000000 -#define IXP2400_TX_MODE_CBUS_8BIT 0x00002000 -#define IXP2400_TX_MODE_CBUS_4BIT 0x00000000 -#define IXP2400_TX_MODE_TBUF_SIZE_MASK 0x0000000c -#define IXP2400_TX_MODE_TBUF_SIZE_256 0x00000008 -#define IXP2400_TX_MODE_TBUF_SIZE_128 0x00000004 -#define IXP2400_TX_MODE_TBUF_SIZE_64 0x00000000 - -#define IXP2400_PORT_TX_MODE_SLAVE 0x00000040 -#define IXP2400_PORT_TX_MODE_MASTER 0x00000000 -#define IXP2400_PORT_TX_MODE_POS_PHY 0x00000010 -#define IXP2400_PORT_TX_MODE_UTOPIA 0x00000000 -#define IXP2400_PORT_TX_MODE_EVEN_PARITY 0x0000000c -#define IXP2400_PORT_TX_MODE_ODD_PARITY 0x00000008 -#define IXP2400_PORT_TX_MODE_NO_PARITY 0x00000000 -#define IXP2400_PORT_TX_MODE_UTOPIA_BIG_CELLS 0x00000002 -#define IXP2400_PORT_TX_MODE_2_CYCLE_DECODE 0x00000001 -#define IXP2400_PORT_TX_MODE_1_CYCLE_DECODE 0x00000000 - - -#endif diff --git a/trunk/drivers/net/ixp2000/ixp2400_rx.uc b/trunk/drivers/net/ixp2000/ixp2400_rx.uc deleted file mode 100644 index 42a73e357afa..000000000000 --- a/trunk/drivers/net/ixp2000/ixp2400_rx.uc +++ /dev/null @@ -1,408 +0,0 @@ -/* - * RX ucode for the Intel IXP2400 in POS-PHY mode. - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * Assumptions made in this code: - * - The IXP2400 MSF is configured for POS-PHY mode, in a mode where - * only one full element list is used. This includes, for example, - * 1x32 SPHY and 1x32 MPHY32, but not 4x8 SPHY or 1x32 MPHY4. (This - * is not an exhaustive list.) - * - The RBUF uses 64-byte mpackets. - * - RX descriptors reside in SRAM, and have the following format: - * struct rx_desc - * { - * // to uengine - * u32 buf_phys_addr; - * u32 buf_length; - * - * // from uengine - * u32 channel; - * u32 pkt_length; - * }; - * - Packet data resides in DRAM. - * - Packet buffer addresses are 8-byte aligned. - * - Scratch ring 0 is rx_pending. - * - Scratch ring 1 is rx_done, and has status condition 'full'. - * - The host triggers rx_done flush and rx_pending refill on seeing INTA. - * - This code is run on all eight threads of the microengine it runs on. - * - * Local memory is used for per-channel RX state. - */ - -#define RX_THREAD_FREELIST_0 0x0030 -#define RBUF_ELEMENT_DONE 0x0044 - -#define CHANNEL_FLAGS *l$index0[0] -#define CHANNEL_FLAG_RECEIVING 1 -#define PACKET_LENGTH *l$index0[1] -#define PACKET_CHECKSUM *l$index0[2] -#define BUFFER_HANDLE *l$index0[3] -#define BUFFER_START *l$index0[4] -#define BUFFER_LENGTH *l$index0[5] - -#define CHANNEL_STATE_SIZE 24 // in bytes -#define CHANNEL_STATE_SHIFT 5 // ceil(log2(state size)) - - - .sig volatile sig1 - .sig volatile sig2 - .sig volatile sig3 - - .sig mpacket_arrived - .reg add_to_rx_freelist - .reg read $rsw0, $rsw1 - .xfer_order $rsw0 $rsw1 - - .reg zero - - /* - * Initialise add_to_rx_freelist. - */ - .begin - .reg temp - .reg temp2 - - immed[add_to_rx_freelist, RX_THREAD_FREELIST_0] - immed_w1[add_to_rx_freelist, (&$rsw0 | (&mpacket_arrived << 12))] - - local_csr_rd[ACTIVE_CTX_STS] - immed[temp, 0] - alu[temp2, temp, and, 0x1f] - alu_shf[add_to_rx_freelist, add_to_rx_freelist, or, temp2, <<20] - alu[temp2, temp, and, 0x80] - alu_shf[add_to_rx_freelist, add_to_rx_freelist, or, temp2, <<18] - .end - - immed[zero, 0] - - /* - * Skip context 0 initialisation? - */ - .begin - br!=ctx[0, mpacket_receive_loop#] - .end - - /* - * Initialise local memory. - */ - .begin - .reg addr - .reg temp - - immed[temp, 0] - init_local_mem_loop#: - alu_shf[addr, --, b, temp, <>8] - bne[abort_rswerr#] - .end - - /* - * Point local memory pointer to this channel's state area. - */ - .begin - .reg chanaddr - - alu[chanaddr, $rsw0, and, 0x1f] - alu_shf[chanaddr, --, b, chanaddr, < abort) If everything's - * okay, update the RECEIVING flag to reflect our new state. - */ - .begin - .reg temp - .reg eop - - #if CHANNEL_FLAG_RECEIVING != 1 - #error CHANNEL_FLAG_RECEIVING is not 1 - #endif - - alu_shf[temp, 1, and, $rsw0, >>15] - alu[temp, temp, xor, CHANNEL_FLAGS] - alu[--, temp, and, CHANNEL_FLAG_RECEIVING] - beq[abort_proterr#] - - alu_shf[eop, 1, and, $rsw0, >>14] - alu[CHANNEL_FLAGS, temp, xor, eop] - .end - - /* - * Copy the mpacket into the right spot, and in case of EOP, - * write back the descriptor and pass the packet on. - */ - .begin - .reg buffer_offset - .reg _packet_length - .reg _packet_checksum - .reg _buffer_handle - .reg _buffer_start - .reg _buffer_length - - /* - * Determine buffer_offset, _packet_length and - * _packet_checksum. - */ - .begin - .reg temp - - alu[--, 1, and, $rsw0, >>15] - beq[not_sop#] - - immed[PACKET_LENGTH, 0] - immed[PACKET_CHECKSUM, 0] - - not_sop#: - alu[buffer_offset, --, b, PACKET_LENGTH] - alu_shf[temp, 0xff, and, $rsw0, >>16] - alu[_packet_length, buffer_offset, +, temp] - alu[PACKET_LENGTH, --, b, _packet_length] - - immed[temp, 0xffff] - alu[temp, $rsw1, and, temp] - alu[_packet_checksum, PACKET_CHECKSUM, +, temp] - alu[PACKET_CHECKSUM, --, b, _packet_checksum] - .end - - /* - * Allocate buffer in case of SOP. - */ - .begin - .reg temp - - alu[temp, 1, and, $rsw0, >>15] - beq[skip_buffer_alloc#] - - .begin - .sig zzz - .reg read $stemp $stemp2 - .xfer_order $stemp $stemp2 - - rx_nobufs#: - scratch[get, $stemp, zero, 0, 1], ctx_swap[zzz] - alu[_buffer_handle, --, b, $stemp] - beq[rx_nobufs#] - - sram[read, $stemp, _buffer_handle, 0, 2], - ctx_swap[zzz] - alu[_buffer_start, --, b, $stemp] - alu[_buffer_length, --, b, $stemp2] - .end - - skip_buffer_alloc#: - .end - - /* - * Resynchronise. - */ - .begin - ctx_arb[sig2] - local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig2 << 3))] - .end - - /* - * Synchronise buffer state. - */ - .begin - .reg temp - - alu[temp, 1, and, $rsw0, >>15] - beq[copy_from_local_mem#] - - alu[BUFFER_HANDLE, --, b, _buffer_handle] - alu[BUFFER_START, --, b, _buffer_start] - alu[BUFFER_LENGTH, --, b, _buffer_length] - br[sync_state_done#] - - copy_from_local_mem#: - alu[_buffer_handle, --, b, BUFFER_HANDLE] - alu[_buffer_start, --, b, BUFFER_START] - alu[_buffer_length, --, b, BUFFER_LENGTH] - - sync_state_done#: - .end - -#if 0 - /* - * Debug buffer state management. - */ - .begin - .reg temp - - alu[temp, 1, and, $rsw0, >>14] - beq[no_poison#] - immed[BUFFER_HANDLE, 0xdead] - immed[BUFFER_START, 0xdead] - immed[BUFFER_LENGTH, 0xdead] - no_poison#: - - immed[temp, 0xdead] - alu[--, _buffer_handle, -, temp] - beq[state_corrupted#] - alu[--, _buffer_start, -, temp] - beq[state_corrupted#] - alu[--, _buffer_length, -, temp] - beq[state_corrupted#] - .end -#endif - - /* - * Check buffer length. - */ - .begin - alu[--, _buffer_length, -, _packet_length] - blo[buffer_overflow#] - .end - - /* - * Copy the mpacket and give back the RBUF element. - */ - .begin - .reg element - .reg xfer_size - .reg temp - .sig copy_sig - - alu_shf[element, 0x7f, and, $rsw0, >>24] - alu_shf[xfer_size, 0xff, and, $rsw0, >>16] - - alu[xfer_size, xfer_size, -, 1] - alu_shf[xfer_size, 0x10, or, xfer_size, >>3] - alu_shf[temp, 0x10, or, xfer_size, <<21] - alu_shf[temp, temp, or, element, <<11] - alu_shf[--, temp, or, 1, <<18] - - dram[rbuf_rd, --, _buffer_start, buffer_offset, max_8], - indirect_ref, sig_done[copy_sig] - ctx_arb[copy_sig] - - alu[temp, RBUF_ELEMENT_DONE, or, element, <<16] - msf[fast_wr, --, temp, 0] - .end - - /* - * If EOP, write back the packet descriptor. - */ - .begin - .reg write $stemp $stemp2 - .xfer_order $stemp $stemp2 - .sig zzz - - alu_shf[--, 1, and, $rsw0, >>14] - beq[no_writeback#] - - alu[$stemp, $rsw0, and, 0x1f] - alu[$stemp2, --, b, _packet_length] - sram[write, $stemp, _buffer_handle, 8, 2], ctx_swap[zzz] - - no_writeback#: - .end - - /* - * Resynchronise. - */ - .begin - ctx_arb[sig3] - local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig3 << 3))] - .end - - /* - * If EOP, put the buffer back onto the scratch ring. - */ - .begin - .reg write $stemp - .sig zzz - - br_inp_state[SCR_Ring1_Status, rx_done_ring_overflow#] - - alu_shf[--, 1, and, $rsw0, >>14] - beq[mpacket_receive_loop#] - - alu[--, 1, and, $rsw0, >>10] - bne[rxerr#] - - alu[$stemp, --, b, _buffer_handle] - scratch[put, $stemp, zero, 4, 1], ctx_swap[zzz] - cap[fast_wr, 0, XSCALE_INT_A] - br[mpacket_receive_loop#] - - rxerr#: - alu[$stemp, --, b, _buffer_handle] - scratch[put, $stemp, zero, 0, 1], ctx_swap[zzz] - br[mpacket_receive_loop#] - .end - .end - - -abort_rswerr#: - halt - -abort_proterr#: - halt - -state_corrupted#: - halt - -buffer_overflow#: - halt - -rx_done_ring_overflow#: - halt - - diff --git a/trunk/drivers/net/ixp2000/ixp2400_rx.ucode b/trunk/drivers/net/ixp2000/ixp2400_rx.ucode deleted file mode 100644 index e8aee2f81aad..000000000000 --- a/trunk/drivers/net/ixp2000/ixp2400_rx.ucode +++ /dev/null @@ -1,130 +0,0 @@ -static struct ixp2000_uengine_code ixp2400_rx = -{ - .cpu_model_bitmask = 0x000003fe, - .cpu_min_revision = 0, - .cpu_max_revision = 255, - - .uengine_parameters = IXP2000_UENGINE_8_CONTEXTS | - IXP2000_UENGINE_PRN_UPDATE_EVERY | - IXP2000_UENGINE_NN_FROM_PREVIOUS | - IXP2000_UENGINE_ASSERT_EMPTY_AT_0 | - IXP2000_UENGINE_LM_ADDR1_PER_CONTEXT | - IXP2000_UENGINE_LM_ADDR0_PER_CONTEXT, - - .initial_reg_values = (struct ixp2000_reg_value []) { - { -1, -1 } - }, - - .num_insns = 109, - .insns = (u8 []) { - 0xf0, 0x00, 0x0c, 0xc0, 0x05, - 0xf4, 0x44, 0x0c, 0x00, 0x05, - 0xfc, 0x04, 0x4c, 0x00, 0x00, - 0xf0, 0x00, 0x00, 0x3b, 0x00, - 0xb4, 0x40, 0xf0, 0x3b, 0x1f, - 0x8a, 0xc0, 0x50, 0x3e, 0x05, - 0xb4, 0x40, 0xf0, 0x3b, 0x80, - 0x9a, 0xe0, 0x00, 0x3e, 0x05, - 0xf0, 0x00, 0x00, 0x07, 0x00, - 0xd8, 0x05, 0xc0, 0x00, 0x11, - 0xf0, 0x00, 0x00, 0x0f, 0x00, - 0x91, 0xb0, 0x20, 0x0e, 0x00, - 0xfc, 0x06, 0x60, 0x0b, 0x00, - 0xf0, 0x00, 0x0c, 0x03, 0x00, - 0xf0, 0x00, 0x0c, 0x03, 0x00, - 0xf0, 0x00, 0x0c, 0x03, 0x00, - 0xf0, 0x00, 0x0c, 0x02, 0x00, - 0xb0, 0xc0, 0x30, 0x0f, 0x01, - 0xa4, 0x70, 0x00, 0x0f, 0x20, - 0xd8, 0x02, 0xc0, 0x01, 0x00, - 0xfc, 0x10, 0xac, 0x23, 0x08, - 0xfc, 0x10, 0xac, 0x43, 0x10, - 0xfc, 0x10, 0xac, 0x63, 0x18, - 0xe0, 0x00, 0x00, 0x00, 0x02, - 0xfc, 0x10, 0xae, 0x23, 0x88, - 0x3d, 0x00, 0x04, 0x03, 0x20, - 0xe0, 0x00, 0x00, 0x00, 0x10, - 0x84, 0x82, 0x02, 0x01, 0x3b, - 0xd8, 0x1a, 0x00, 0x01, 0x01, - 0xb4, 0x00, 0x8c, 0x7d, 0x80, - 0x91, 0xb0, 0x80, 0x22, 0x00, - 0xfc, 0x06, 0x60, 0x23, 0x00, - 0xf0, 0x00, 0x0c, 0x03, 0x00, - 0xf0, 0x00, 0x0c, 0x03, 0x00, - 0xf0, 0x00, 0x0c, 0x03, 0x00, - 0x94, 0xf0, 0x92, 0x01, 0x21, - 0xac, 0x40, 0x60, 0x26, 0x00, - 0xa4, 0x30, 0x0c, 0x04, 0x06, - 0xd8, 0x1a, 0x40, 0x01, 0x00, - 0x94, 0xe0, 0xa2, 0x01, 0x21, - 0xac, 0x20, 0x00, 0x28, 0x06, - 0x84, 0xf2, 0x02, 0x01, 0x21, - 0xd8, 0x0b, 0x40, 0x01, 0x00, - 0xf0, 0x00, 0x0c, 0x02, 0x01, - 0xf0, 0x00, 0x0c, 0x02, 0x02, - 0xa0, 0x00, 0x08, 0x04, 0x00, - 0x95, 0x00, 0xc6, 0x01, 0xff, - 0xa0, 0x80, 0x10, 0x30, 0x00, - 0xa0, 0x60, 0x1c, 0x00, 0x01, - 0xf0, 0x0f, 0xf0, 0x33, 0xff, - 0xb4, 0x00, 0xc0, 0x31, 0x81, - 0xb0, 0x80, 0xb0, 0x32, 0x02, - 0xa0, 0x20, 0x20, 0x2c, 0x00, - 0x94, 0xf0, 0xd2, 0x01, 0x21, - 0xd8, 0x0f, 0x40, 0x01, 0x00, - 0x19, 0x40, 0x10, 0x04, 0x20, - 0xa0, 0x00, 0x26, 0x04, 0x00, - 0xd8, 0x0d, 0xc0, 0x01, 0x00, - 0x00, 0x42, 0x10, 0x80, 0x02, - 0xb0, 0x00, 0x46, 0x04, 0x00, - 0xb0, 0x00, 0x56, 0x08, 0x00, - 0xe0, 0x00, 0x00, 0x00, 0x04, - 0xfc, 0x10, 0xae, 0x43, 0x90, - 0x84, 0xf0, 0x32, 0x01, 0x21, - 0xd8, 0x11, 0x40, 0x01, 0x00, - 0xa0, 0x60, 0x3c, 0x00, 0x02, - 0xa0, 0x20, 0x40, 0x10, 0x00, - 0xa0, 0x20, 0x50, 0x14, 0x00, - 0xd8, 0x12, 0x00, 0x00, 0x18, - 0xa0, 0x00, 0x28, 0x0c, 0x00, - 0xb0, 0x00, 0x48, 0x10, 0x00, - 0xb0, 0x00, 0x58, 0x14, 0x00, - 0xaa, 0xf0, 0x00, 0x14, 0x01, - 0xd8, 0x1a, 0xc0, 0x01, 0x05, - 0x85, 0x80, 0x42, 0x01, 0xff, - 0x95, 0x00, 0x66, 0x01, 0xff, - 0xba, 0xc0, 0x60, 0x1b, 0x01, - 0x9a, 0x30, 0x60, 0x19, 0x30, - 0x9a, 0xb0, 0x70, 0x1a, 0x30, - 0x9b, 0x50, 0x78, 0x1e, 0x04, - 0x8a, 0xe2, 0x08, 0x1e, 0x21, - 0x6a, 0x4e, 0x00, 0x13, 0x00, - 0xe0, 0x00, 0x00, 0x00, 0x30, - 0x9b, 0x00, 0x7a, 0x92, 0x04, - 0x3d, 0x00, 0x04, 0x1f, 0x20, - 0x84, 0xe2, 0x02, 0x01, 0x21, - 0xd8, 0x16, 0x80, 0x01, 0x00, - 0xa4, 0x18, 0x0c, 0x7d, 0x80, - 0xa0, 0x58, 0x1c, 0x00, 0x01, - 0x01, 0x42, 0x00, 0xa0, 0x02, - 0xe0, 0x00, 0x00, 0x00, 0x08, - 0xfc, 0x10, 0xae, 0x63, 0x98, - 0xd8, 0x1b, 0x00, 0xc2, 0x14, - 0x84, 0xe2, 0x02, 0x01, 0x21, - 0xd8, 0x05, 0xc0, 0x01, 0x00, - 0x84, 0xa2, 0x02, 0x01, 0x21, - 0xd8, 0x19, 0x40, 0x01, 0x01, - 0xa0, 0x58, 0x0c, 0x00, 0x02, - 0x1a, 0x40, 0x00, 0x04, 0x24, - 0x33, 0x00, 0x01, 0x2f, 0x20, - 0xd8, 0x05, 0xc0, 0x00, 0x18, - 0xa0, 0x58, 0x0c, 0x00, 0x02, - 0x1a, 0x40, 0x00, 0x04, 0x20, - 0xd8, 0x05, 0xc0, 0x00, 0x18, - 0xe0, 0x00, 0x02, 0x00, 0x00, - 0xe0, 0x00, 0x02, 0x00, 0x00, - 0xe0, 0x00, 0x02, 0x00, 0x00, - 0xe0, 0x00, 0x02, 0x00, 0x00, - 0xe0, 0x00, 0x02, 0x00, 0x00, - } -}; diff --git a/trunk/drivers/net/ixp2000/ixp2400_tx.uc b/trunk/drivers/net/ixp2000/ixp2400_tx.uc deleted file mode 100644 index d090d1884fb7..000000000000 --- a/trunk/drivers/net/ixp2000/ixp2400_tx.uc +++ /dev/null @@ -1,272 +0,0 @@ -/* - * TX ucode for the Intel IXP2400 in POS-PHY mode. - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * Assumptions made in this code: - * - The IXP2400 MSF is configured for POS-PHY mode, in a mode where - * only one TBUF partition is used. This includes, for example, - * 1x32 SPHY and 1x32 MPHY32, but not 4x8 SPHY or 1x32 MPHY4. (This - * is not an exhaustive list.) - * - The TBUF uses 64-byte mpackets. - * - TX descriptors reside in SRAM, and have the following format: - * struct tx_desc - * { - * // to uengine - * u32 buf_phys_addr; - * u32 pkt_length; - * u32 channel; - * }; - * - Packet data resides in DRAM. - * - Packet buffer addresses are 8-byte aligned. - * - Scratch ring 2 is tx_pending. - * - Scratch ring 3 is tx_done, and has status condition 'full'. - * - This code is run on all eight threads of the microengine it runs on. - */ - -#define TX_SEQUENCE_0 0x0060 -#define TBUF_CTRL 0x1800 - -#define PARTITION_SIZE 128 -#define PARTITION_THRESH 96 - - - .sig volatile sig1 - .sig volatile sig2 - .sig volatile sig3 - - .reg @old_tx_seq_0 - .reg @mpkts_in_flight - .reg @next_tbuf_mpacket - - .reg @buffer_handle - .reg @buffer_start - .reg @packet_length - .reg @channel - .reg @packet_offset - - .reg zero - - immed[zero, 0] - - /* - * Skip context 0 initialisation? - */ - .begin - br!=ctx[0, mpacket_tx_loop#] - .end - - /* - * Wait until all pending TBUF elements have been transmitted. - */ - .begin - .reg read $tx - .sig zzz - - loop_empty#: - msf[read, $tx, zero, TX_SEQUENCE_0, 1], ctx_swap[zzz] - alu_shf[--, --, b, $tx, >>31] - beq[loop_empty#] - - alu[@old_tx_seq_0, --, b, $tx] - .end - - immed[@mpkts_in_flight, 0] - alu[@next_tbuf_mpacket, @old_tx_seq_0, and, (PARTITION_SIZE - 1)] - - immed[@buffer_handle, 0] - - /* - * Initialise signal pipeline. - */ - .begin - local_csr_wr[SAME_ME_SIGNAL, (&sig1 << 3)] - .set_sig sig1 - - local_csr_wr[SAME_ME_SIGNAL, (&sig2 << 3)] - .set_sig sig2 - - local_csr_wr[SAME_ME_SIGNAL, (&sig3 << 3)] - .set_sig sig3 - .end - -mpacket_tx_loop#: - .begin - .reg tbuf_element_index - .reg buffer_handle - .reg sop_eop - .reg packet_data - .reg channel - .reg mpacket_size - - /* - * If there is no packet currently being transmitted, - * dequeue the next TX descriptor, and fetch the buffer - * address, packet length and destination channel number. - */ - .begin - .reg read $stemp $stemp2 $stemp3 - .xfer_order $stemp $stemp2 $stemp3 - .sig zzz - - ctx_arb[sig1] - - alu[--, --, b, @buffer_handle] - bne[already_got_packet#] - - tx_nobufs#: - scratch[get, $stemp, zero, 8, 1], ctx_swap[zzz] - alu[@buffer_handle, --, b, $stemp] - beq[tx_nobufs#] - - sram[read, $stemp, $stemp, 0, 3], ctx_swap[zzz] - alu[@buffer_start, --, b, $stemp] - alu[@packet_length, --, b, $stemp2] - beq[zero_byte_packet#] - alu[@channel, --, b, $stemp3] - immed[@packet_offset, 0] - - already_got_packet#: - local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig1 << 3))] - .end - - /* - * Determine tbuf element index, SOP/EOP flags, mpacket - * offset and mpacket size and cache buffer_handle and - * channel number. - */ - .begin - alu[tbuf_element_index, --, b, @next_tbuf_mpacket] - alu[@next_tbuf_mpacket, @next_tbuf_mpacket, +, 1] - alu[@next_tbuf_mpacket, @next_tbuf_mpacket, and, - (PARTITION_SIZE - 1)] - - alu[buffer_handle, --, b, @buffer_handle] - immed[@buffer_handle, 0] - - immed[sop_eop, 1] - - alu[packet_data, --, b, @packet_offset] - bne[no_sop#] - alu[sop_eop, sop_eop, or, 2] - no_sop#: - alu[packet_data, packet_data, +, @buffer_start] - - alu[channel, --, b, @channel] - - alu[mpacket_size, @packet_length, -, @packet_offset] - alu[--, 64, -, mpacket_size] - bhs[eop#] - alu[@buffer_handle, --, b, buffer_handle] - immed[mpacket_size, 64] - alu[sop_eop, sop_eop, and, 2] - eop#: - - alu[@packet_offset, @packet_offset, +, mpacket_size] - .end - - /* - * Wait until there's enough space in the TBUF. - */ - .begin - .reg read $tx - .reg temp - .sig zzz - - ctx_arb[sig2] - - br[test_space#] - - loop_space#: - msf[read, $tx, zero, TX_SEQUENCE_0, 1], ctx_swap[zzz] - - alu[temp, $tx, -, @old_tx_seq_0] - alu[temp, temp, and, 0xff] - alu[@mpkts_in_flight, @mpkts_in_flight, -, temp] - - alu[@old_tx_seq_0, --, b, $tx] - - test_space#: - alu[--, PARTITION_THRESH, -, @mpkts_in_flight] - blo[loop_space#] - - alu[@mpkts_in_flight, @mpkts_in_flight, +, 1] - - local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig2 << 3))] - .end - - /* - * Copy the packet data to the TBUF. - */ - .begin - .reg temp - .sig copy_sig - - alu[temp, mpacket_size, -, 1] - alu_shf[temp, 0x10, or, temp, >>3] - alu_shf[temp, 0x10, or, temp, <<21] - alu_shf[temp, temp, or, tbuf_element_index, <<11] - alu_shf[--, temp, or, 1, <<18] - - dram[tbuf_wr, --, packet_data, 0, max_8], - indirect_ref, sig_done[copy_sig] - ctx_arb[copy_sig] - .end - - /* - * Mark TBUF element as ready-to-be-transmitted. - */ - .begin - .reg write $tsw $tsw2 - .xfer_order $tsw $tsw2 - .reg temp - .sig zzz - - alu_shf[temp, channel, or, mpacket_size, <<24] - alu_shf[$tsw, temp, or, sop_eop, <<8] - immed[$tsw2, 0] - - immed[temp, TBUF_CTRL] - alu_shf[temp, temp, or, tbuf_element_index, <<3] - msf[write, $tsw, temp, 0, 2], ctx_swap[zzz] - .end - - /* - * Resynchronise. - */ - .begin - ctx_arb[sig3] - local_csr_wr[SAME_ME_SIGNAL, (0x80 | (&sig3 << 3))] - .end - - /* - * If this was an EOP mpacket, recycle the TX buffer - * and signal the host. - */ - .begin - .reg write $stemp - .sig zzz - - alu[--, sop_eop, and, 1] - beq[mpacket_tx_loop#] - - tx_done_ring_full#: - br_inp_state[SCR_Ring3_Status, tx_done_ring_full#] - - alu[$stemp, --, b, buffer_handle] - scratch[put, $stemp, zero, 12, 1], ctx_swap[zzz] - cap[fast_wr, 0, XSCALE_INT_A] - br[mpacket_tx_loop#] - .end - .end - - -zero_byte_packet#: - halt - - diff --git a/trunk/drivers/net/ixp2000/ixp2400_tx.ucode b/trunk/drivers/net/ixp2000/ixp2400_tx.ucode deleted file mode 100644 index a433e24b0a51..000000000000 --- a/trunk/drivers/net/ixp2000/ixp2400_tx.ucode +++ /dev/null @@ -1,98 +0,0 @@ -static struct ixp2000_uengine_code ixp2400_tx = -{ - .cpu_model_bitmask = 0x000003fe, - .cpu_min_revision = 0, - .cpu_max_revision = 255, - - .uengine_parameters = IXP2000_UENGINE_8_CONTEXTS | - IXP2000_UENGINE_PRN_UPDATE_EVERY | - IXP2000_UENGINE_NN_FROM_PREVIOUS | - IXP2000_UENGINE_ASSERT_EMPTY_AT_0 | - IXP2000_UENGINE_LM_ADDR1_PER_CONTEXT | - IXP2000_UENGINE_LM_ADDR0_PER_CONTEXT, - - .initial_reg_values = (struct ixp2000_reg_value []) { - { -1, -1 } - }, - - .num_insns = 77, - .insns = (u8 []) { - 0xf0, 0x00, 0x00, 0x07, 0x00, - 0xd8, 0x03, 0x00, 0x00, 0x11, - 0x3c, 0x40, 0x00, 0x04, 0xe0, - 0x81, 0xf2, 0x02, 0x01, 0x00, - 0xd8, 0x00, 0x80, 0x01, 0x00, - 0xb0, 0x08, 0x06, 0x00, 0x00, - 0xf0, 0x00, 0x0c, 0x00, 0x80, - 0xb4, 0x49, 0x02, 0x03, 0x7f, - 0xf0, 0x00, 0x02, 0x83, 0x00, - 0xfc, 0x10, 0xac, 0x23, 0x08, - 0xfc, 0x10, 0xac, 0x43, 0x10, - 0xfc, 0x10, 0xac, 0x63, 0x18, - 0xe0, 0x00, 0x00, 0x00, 0x02, - 0xa0, 0x30, 0x02, 0x80, 0x00, - 0xd8, 0x06, 0x00, 0x01, 0x01, - 0x19, 0x40, 0x00, 0x04, 0x28, - 0xb0, 0x0a, 0x06, 0x00, 0x00, - 0xd8, 0x03, 0xc0, 0x01, 0x00, - 0x00, 0x44, 0x00, 0x80, 0x80, - 0xa0, 0x09, 0x06, 0x00, 0x00, - 0xb0, 0x0b, 0x06, 0x04, 0x00, - 0xd8, 0x13, 0x00, 0x01, 0x00, - 0xb0, 0x0c, 0x06, 0x08, 0x00, - 0xf0, 0x00, 0x0c, 0x00, 0xa0, - 0xfc, 0x10, 0xae, 0x23, 0x88, - 0xa0, 0x00, 0x12, 0x40, 0x00, - 0xb0, 0xc9, 0x02, 0x43, 0x01, - 0xb4, 0x49, 0x02, 0x43, 0x7f, - 0xb0, 0x00, 0x22, 0x80, 0x00, - 0xf0, 0x00, 0x02, 0x83, 0x00, - 0xf0, 0x00, 0x0c, 0x04, 0x02, - 0xb0, 0x40, 0x6c, 0x00, 0xa0, - 0xd8, 0x08, 0x80, 0x01, 0x01, - 0xaa, 0x00, 0x2c, 0x08, 0x02, - 0xa0, 0xc0, 0x30, 0x18, 0x90, - 0xa0, 0x00, 0x43, 0x00, 0x00, - 0xba, 0xc0, 0x32, 0xc0, 0xa0, - 0xaa, 0xb0, 0x00, 0x0f, 0x40, - 0xd8, 0x0a, 0x80, 0x01, 0x04, - 0xb0, 0x0a, 0x00, 0x08, 0x00, - 0xf0, 0x00, 0x00, 0x0f, 0x40, - 0xa4, 0x00, 0x2c, 0x08, 0x02, - 0xa0, 0x8a, 0x00, 0x0c, 0xa0, - 0xe0, 0x00, 0x00, 0x00, 0x04, - 0xd8, 0x0c, 0x80, 0x00, 0x18, - 0x3c, 0x40, 0x00, 0x04, 0xe0, - 0xba, 0x80, 0x42, 0x01, 0x80, - 0xb4, 0x40, 0x40, 0x13, 0xff, - 0xaa, 0x88, 0x00, 0x10, 0x80, - 0xb0, 0x08, 0x06, 0x00, 0x00, - 0xaa, 0xf0, 0x0d, 0x80, 0x80, - 0xd8, 0x0b, 0x40, 0x01, 0x05, - 0xa0, 0x88, 0x0c, 0x04, 0x80, - 0xfc, 0x10, 0xae, 0x43, 0x90, - 0xba, 0xc0, 0x50, 0x0f, 0x01, - 0x9a, 0x30, 0x50, 0x15, 0x30, - 0x9a, 0xb0, 0x50, 0x16, 0x30, - 0x9b, 0x50, 0x58, 0x16, 0x01, - 0x8a, 0xe2, 0x08, 0x16, 0x21, - 0x6b, 0x4e, 0x00, 0x83, 0x03, - 0xe0, 0x00, 0x00, 0x00, 0x30, - 0x9a, 0x80, 0x70, 0x0e, 0x04, - 0x8b, 0x88, 0x08, 0x1e, 0x02, - 0xf0, 0x00, 0x0c, 0x01, 0x81, - 0xf0, 0x01, 0x80, 0x1f, 0x00, - 0x9b, 0xd0, 0x78, 0x1e, 0x01, - 0x3d, 0x42, 0x00, 0x1c, 0x20, - 0xe0, 0x00, 0x00, 0x00, 0x08, - 0xfc, 0x10, 0xae, 0x63, 0x98, - 0xa4, 0x30, 0x0c, 0x04, 0x02, - 0xd8, 0x03, 0x00, 0x01, 0x00, - 0xd8, 0x11, 0xc1, 0x42, 0x14, - 0xa0, 0x18, 0x00, 0x08, 0x00, - 0x1a, 0x40, 0x00, 0x04, 0x2c, - 0x33, 0x00, 0x01, 0x2f, 0x20, - 0xd8, 0x03, 0x00, 0x00, 0x18, - 0xe0, 0x00, 0x02, 0x00, 0x00, - } -}; diff --git a/trunk/drivers/net/ixp2000/ixpdev.c b/trunk/drivers/net/ixp2000/ixpdev.c deleted file mode 100644 index 09f03f493bea..000000000000 --- a/trunk/drivers/net/ixp2000/ixpdev.c +++ /dev/null @@ -1,421 +0,0 @@ -/* - * IXP2000 MSF network device driver - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "ixp2400_rx.ucode" -#include "ixp2400_tx.ucode" -#include "ixpdev_priv.h" -#include "ixpdev.h" - -#define DRV_MODULE_VERSION "0.2" - -static int nds_count; -static struct net_device **nds; -static int nds_open; -static void (*set_port_admin_status)(int port, int up); - -static struct ixpdev_rx_desc * const rx_desc = - (struct ixpdev_rx_desc *)(IXP2000_SRAM0_VIRT_BASE + RX_BUF_DESC_BASE); -static struct ixpdev_tx_desc * const tx_desc = - (struct ixpdev_tx_desc *)(IXP2000_SRAM0_VIRT_BASE + TX_BUF_DESC_BASE); -static int tx_pointer; - - -static int ixpdev_xmit(struct sk_buff *skb, struct net_device *dev) -{ - struct ixpdev_priv *ip = netdev_priv(dev); - struct ixpdev_tx_desc *desc; - int entry; - - if (unlikely(skb->len > PAGE_SIZE)) { - /* @@@ Count drops. */ - dev_kfree_skb(skb); - return 0; - } - - entry = tx_pointer; - tx_pointer = (tx_pointer + 1) % TX_BUF_COUNT; - - desc = tx_desc + entry; - desc->pkt_length = skb->len; - desc->channel = ip->channel; - - skb_copy_and_csum_dev(skb, phys_to_virt(desc->buf_addr)); - dev_kfree_skb(skb); - - ixp2000_reg_write(RING_TX_PENDING, - TX_BUF_DESC_BASE + (entry * sizeof(struct ixpdev_tx_desc))); - - dev->trans_start = jiffies; - - local_irq_disable(); - ip->tx_queue_entries++; - if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN) - netif_stop_queue(dev); - local_irq_enable(); - - return 0; -} - - -static int ixpdev_rx(struct net_device *dev, int *budget) -{ - while (*budget > 0) { - struct ixpdev_rx_desc *desc; - struct sk_buff *skb; - void *buf; - u32 _desc; - - _desc = ixp2000_reg_read(RING_RX_DONE); - if (_desc == 0) - return 0; - - desc = rx_desc + - ((_desc - RX_BUF_DESC_BASE) / sizeof(struct ixpdev_rx_desc)); - buf = phys_to_virt(desc->buf_addr); - - if (desc->pkt_length < 4 || desc->pkt_length > PAGE_SIZE) { - printk(KERN_ERR "ixp2000: rx err, length %d\n", - desc->pkt_length); - goto err; - } - - if (desc->channel < 0 || desc->channel >= nds_count) { - printk(KERN_ERR "ixp2000: rx err, channel %d\n", - desc->channel); - goto err; - } - - /* @@@ Make FCS stripping configurable. */ - desc->pkt_length -= 4; - - if (unlikely(!netif_running(nds[desc->channel]))) - goto err; - - skb = dev_alloc_skb(desc->pkt_length + 2); - if (likely(skb != NULL)) { - skb->dev = nds[desc->channel]; - skb_reserve(skb, 2); - eth_copy_and_sum(skb, buf, desc->pkt_length, 0); - skb_put(skb, desc->pkt_length); - skb->protocol = eth_type_trans(skb, skb->dev); - - skb->dev->last_rx = jiffies; - - netif_receive_skb(skb); - } - -err: - ixp2000_reg_write(RING_RX_PENDING, _desc); - dev->quota--; - (*budget)--; - } - - return 1; -} - -/* dev always points to nds[0]. */ -static int ixpdev_poll(struct net_device *dev, int *budget) -{ - /* @@@ Have to stop polling when nds[0] is administratively - * downed while we are polling. */ - do { - ixp2000_reg_write(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0x00ff); - - if (ixpdev_rx(dev, budget)) - return 1; - } while (ixp2000_reg_read(IXP2000_IRQ_THD_RAW_STATUS_A_0) & 0x00ff); - - netif_rx_complete(dev); - ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0x00ff); - - return 0; -} - -static void ixpdev_tx_complete(void) -{ - int channel; - u32 wake; - - wake = 0; - while (1) { - struct ixpdev_priv *ip; - u32 desc; - int entry; - - desc = ixp2000_reg_read(RING_TX_DONE); - if (desc == 0) - break; - - /* @@@ Check whether entries come back in order. */ - entry = (desc - TX_BUF_DESC_BASE) / sizeof(struct ixpdev_tx_desc); - channel = tx_desc[entry].channel; - - if (channel < 0 || channel >= nds_count) { - printk(KERN_ERR "ixp2000: txcomp channel index " - "out of bounds (%d, %.8i, %d)\n", - channel, (unsigned int)desc, entry); - continue; - } - - ip = netdev_priv(nds[channel]); - if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN) - wake |= 1 << channel; - ip->tx_queue_entries--; - } - - for (channel = 0; wake != 0; channel++) { - if (wake & (1 << channel)) { - netif_wake_queue(nds[channel]); - wake &= ~(1 << channel); - } - } -} - -static irqreturn_t ixpdev_interrupt(int irq, void *dev_id, struct pt_regs *regs) -{ - u32 status; - - status = ixp2000_reg_read(IXP2000_IRQ_THD_STATUS_A_0); - if (status == 0) - return IRQ_NONE; - - /* - * Any of the eight receive units signaled RX? - */ - if (status & 0x00ff) { - ixp2000_reg_wrb(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0x00ff); - if (likely(__netif_rx_schedule_prep(nds[0]))) { - __netif_rx_schedule(nds[0]); - } else { - printk(KERN_CRIT "ixp2000: irq while polling!!\n"); - } - } - - /* - * Any of the eight transmit units signaled TXdone? - */ - if (status & 0xff00) { - ixp2000_reg_wrb(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0xff00); - ixpdev_tx_complete(); - } - - return IRQ_HANDLED; -} - -#ifdef CONFIG_NET_POLL_CONTROLLER -static void ixpdev_poll_controller(struct net_device *dev) -{ - disable_irq(IRQ_IXP2000_THDA0); - ixpdev_interrupt(IRQ_IXP2000_THDA0, dev, NULL); - enable_irq(IRQ_IXP2000_THDA0); -} -#endif - -static int ixpdev_open(struct net_device *dev) -{ - struct ixpdev_priv *ip = netdev_priv(dev); - int err; - - if (!nds_open++) { - err = request_irq(IRQ_IXP2000_THDA0, ixpdev_interrupt, - SA_SHIRQ, "ixp2000_eth", nds); - if (err) { - nds_open--; - return err; - } - - ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0xffff); - } - - set_port_admin_status(ip->channel, 1); - netif_start_queue(dev); - - return 0; -} - -static int ixpdev_close(struct net_device *dev) -{ - struct ixpdev_priv *ip = netdev_priv(dev); - - netif_stop_queue(dev); - set_port_admin_status(ip->channel, 0); - - if (!--nds_open) { - ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0xffff); - free_irq(IRQ_IXP2000_THDA0, nds); - } - - return 0; -} - -struct net_device *ixpdev_alloc(int channel, int sizeof_priv) -{ - struct net_device *dev; - struct ixpdev_priv *ip; - - dev = alloc_etherdev(sizeof_priv); - if (dev == NULL) - return NULL; - - dev->hard_start_xmit = ixpdev_xmit; - dev->poll = ixpdev_poll; - dev->open = ixpdev_open; - dev->stop = ixpdev_close; -#ifdef CONFIG_NET_POLL_CONTROLLER - dev->poll_controller = ixpdev_poll_controller; -#endif - - dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM; - dev->weight = 64; - - ip = netdev_priv(dev); - ip->channel = channel; - ip->tx_queue_entries = 0; - - return dev; -} - -int ixpdev_init(int __nds_count, struct net_device **__nds, - void (*__set_port_admin_status)(int port, int up)) -{ - int i; - int err; - - if (RX_BUF_COUNT > 192 || TX_BUF_COUNT > 192) { - static void __too_many_rx_or_tx_buffers(void); - __too_many_rx_or_tx_buffers(); - } - - printk(KERN_INFO "IXP2000 MSF ethernet driver %s\n", DRV_MODULE_VERSION); - - nds_count = __nds_count; - nds = __nds; - set_port_admin_status = __set_port_admin_status; - - for (i = 0; i < RX_BUF_COUNT; i++) { - void *buf; - - buf = (void *)get_zeroed_page(GFP_KERNEL); - if (buf == NULL) { - err = -ENOMEM; - while (--i >= 0) - free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr)); - goto err_out; - } - rx_desc[i].buf_addr = virt_to_phys(buf); - rx_desc[i].buf_length = PAGE_SIZE; - } - - /* @@@ Maybe we shouldn't be preallocating TX buffers. */ - for (i = 0; i < TX_BUF_COUNT; i++) { - void *buf; - - buf = (void *)get_zeroed_page(GFP_KERNEL); - if (buf == NULL) { - err = -ENOMEM; - while (--i >= 0) - free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr)); - goto err_free_rx; - } - tx_desc[i].buf_addr = virt_to_phys(buf); - } - - /* 256 entries, ring status set means 'empty', base address 0x0000. */ - ixp2000_reg_write(RING_RX_PENDING_BASE, 0x44000000); - ixp2000_reg_write(RING_RX_PENDING_HEAD, 0x00000000); - ixp2000_reg_write(RING_RX_PENDING_TAIL, 0x00000000); - - /* 256 entries, ring status set means 'full', base address 0x0400. */ - ixp2000_reg_write(RING_RX_DONE_BASE, 0x40000400); - ixp2000_reg_write(RING_RX_DONE_HEAD, 0x00000000); - ixp2000_reg_write(RING_RX_DONE_TAIL, 0x00000000); - - for (i = 0; i < RX_BUF_COUNT; i++) { - ixp2000_reg_write(RING_RX_PENDING, - RX_BUF_DESC_BASE + (i * sizeof(struct ixpdev_rx_desc))); - } - - ixp2000_uengine_load(0, &ixp2400_rx); - ixp2000_uengine_start_contexts(0, 0xff); - - /* 256 entries, ring status set means 'empty', base address 0x0800. */ - ixp2000_reg_write(RING_TX_PENDING_BASE, 0x44000800); - ixp2000_reg_write(RING_TX_PENDING_HEAD, 0x00000000); - ixp2000_reg_write(RING_TX_PENDING_TAIL, 0x00000000); - - /* 256 entries, ring status set means 'full', base address 0x0c00. */ - ixp2000_reg_write(RING_TX_DONE_BASE, 0x40000c00); - ixp2000_reg_write(RING_TX_DONE_HEAD, 0x00000000); - ixp2000_reg_write(RING_TX_DONE_TAIL, 0x00000000); - - ixp2000_uengine_load(1, &ixp2400_tx); - ixp2000_uengine_start_contexts(1, 0xff); - - for (i = 0; i < nds_count; i++) { - err = register_netdev(nds[i]); - if (err) { - while (--i >= 0) - unregister_netdev(nds[i]); - goto err_free_tx; - } - } - - for (i = 0; i < nds_count; i++) { - printk(KERN_INFO "%s: IXP2000 MSF ethernet (port %d), " - "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x.\n", nds[i]->name, i, - nds[i]->dev_addr[0], nds[i]->dev_addr[1], - nds[i]->dev_addr[2], nds[i]->dev_addr[3], - nds[i]->dev_addr[4], nds[i]->dev_addr[5]); - } - - return 0; - -err_free_tx: - for (i = 0; i < TX_BUF_COUNT; i++) - free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr)); - -err_free_rx: - for (i = 0; i < RX_BUF_COUNT; i++) - free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr)); - -err_out: - return err; -} - -void ixpdev_deinit(void) -{ - int i; - - /* @@@ Flush out pending packets. */ - - for (i = 0; i < nds_count; i++) - unregister_netdev(nds[i]); - - ixp2000_uengine_stop_contexts(1, 0xff); - ixp2000_uengine_stop_contexts(0, 0xff); - ixp2000_uengine_reset(0x3); - - for (i = 0; i < TX_BUF_COUNT; i++) - free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr)); - - for (i = 0; i < RX_BUF_COUNT; i++) - free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr)); -} diff --git a/trunk/drivers/net/ixp2000/ixpdev.h b/trunk/drivers/net/ixp2000/ixpdev.h deleted file mode 100644 index bd686cb63058..000000000000 --- a/trunk/drivers/net/ixp2000/ixpdev.h +++ /dev/null @@ -1,27 +0,0 @@ -/* - * IXP2000 MSF network device driver - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#ifndef __IXPDEV_H -#define __IXPDEV_H - -struct ixpdev_priv -{ - int channel; - int tx_queue_entries; -}; - -struct net_device *ixpdev_alloc(int channel, int sizeof_priv); -int ixpdev_init(int num_ports, struct net_device **nds, - void (*set_port_admin_status)(int port, int up)); -void ixpdev_deinit(void); - - -#endif diff --git a/trunk/drivers/net/ixp2000/ixpdev_priv.h b/trunk/drivers/net/ixp2000/ixpdev_priv.h deleted file mode 100644 index 86aa08ea0c33..000000000000 --- a/trunk/drivers/net/ixp2000/ixpdev_priv.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * IXP2000 MSF network device driver - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#ifndef __IXPDEV_PRIV_H -#define __IXPDEV_PRIV_H - -#define RX_BUF_DESC_BASE 0x00001000 -#define RX_BUF_COUNT ((3 * PAGE_SIZE) / (4 * sizeof(struct ixpdev_rx_desc))) -#define TX_BUF_DESC_BASE 0x00002000 -#define TX_BUF_COUNT ((3 * PAGE_SIZE) / (4 * sizeof(struct ixpdev_tx_desc))) -#define TX_BUF_COUNT_PER_CHAN (TX_BUF_COUNT / 4) - -#define RING_RX_PENDING ((u32 *)IXP2000_SCRATCH_RING_VIRT_BASE) -#define RING_RX_DONE ((u32 *)(IXP2000_SCRATCH_RING_VIRT_BASE + 4)) -#define RING_TX_PENDING ((u32 *)(IXP2000_SCRATCH_RING_VIRT_BASE + 8)) -#define RING_TX_DONE ((u32 *)(IXP2000_SCRATCH_RING_VIRT_BASE + 12)) - -#define SCRATCH_REG(x) ((u32 *)(IXP2000_GLOBAL_REG_VIRT_BASE | 0x0800 | (x))) -#define RING_RX_PENDING_BASE SCRATCH_REG(0x00) -#define RING_RX_PENDING_HEAD SCRATCH_REG(0x04) -#define RING_RX_PENDING_TAIL SCRATCH_REG(0x08) -#define RING_RX_DONE_BASE SCRATCH_REG(0x10) -#define RING_RX_DONE_HEAD SCRATCH_REG(0x14) -#define RING_RX_DONE_TAIL SCRATCH_REG(0x18) -#define RING_TX_PENDING_BASE SCRATCH_REG(0x20) -#define RING_TX_PENDING_HEAD SCRATCH_REG(0x24) -#define RING_TX_PENDING_TAIL SCRATCH_REG(0x28) -#define RING_TX_DONE_BASE SCRATCH_REG(0x30) -#define RING_TX_DONE_HEAD SCRATCH_REG(0x34) -#define RING_TX_DONE_TAIL SCRATCH_REG(0x38) - -struct ixpdev_rx_desc -{ - u32 buf_addr; - u32 buf_length; - u32 channel; - u32 pkt_length; -}; - -struct ixpdev_tx_desc -{ - u32 buf_addr; - u32 pkt_length; - u32 channel; - u32 unused; -}; - - -#endif diff --git a/trunk/drivers/net/ixp2000/pm3386.c b/trunk/drivers/net/ixp2000/pm3386.c deleted file mode 100644 index 5c7ab7564053..000000000000 --- a/trunk/drivers/net/ixp2000/pm3386.c +++ /dev/null @@ -1,334 +0,0 @@ -/* - * Helper functions for the PM3386s on the Radisys ENP2611 - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#include -#include -#include -#include -#include -#include "pm3386.h" - -/* - * Read from register 'reg' of PM3386 device 'pm'. - */ -static u16 pm3386_reg_read(int pm, int reg) -{ - void *_reg; - u16 value; - - _reg = (void *)ENP2611_PM3386_0_VIRT_BASE; - if (pm == 1) - _reg = (void *)ENP2611_PM3386_1_VIRT_BASE; - - value = *((volatile u16 *)(_reg + (reg << 1))); - -// printk(KERN_INFO "pm3386_reg_read(%d, %.3x) = %.8x\n", pm, reg, value); - - return value; -} - -/* - * Write to register 'reg' of PM3386 device 'pm', and perform - * a readback from the identification register. - */ -static void pm3386_reg_write(int pm, int reg, u16 value) -{ - void *_reg; - u16 dummy; - -// printk(KERN_INFO "pm3386_reg_write(%d, %.3x, %.8x)\n", pm, reg, value); - - _reg = (void *)ENP2611_PM3386_0_VIRT_BASE; - if (pm == 1) - _reg = (void *)ENP2611_PM3386_1_VIRT_BASE; - - *((volatile u16 *)(_reg + (reg << 1))) = value; - - dummy = *((volatile u16 *)_reg); - __asm__ __volatile__("mov %0, %0" : "+r" (dummy)); -} - -/* - * Read from port 'port' register 'reg', where the registers - * for the different ports are 'spacing' registers apart. - */ -static u16 pm3386_port_reg_read(int port, int _reg, int spacing) -{ - int reg; - - reg = _reg; - if (port & 1) - reg += spacing; - - return pm3386_reg_read(port >> 1, reg); -} - -/* - * Write to port 'port' register 'reg', where the registers - * for the different ports are 'spacing' registers apart. - */ -static void pm3386_port_reg_write(int port, int _reg, int spacing, u16 value) -{ - int reg; - - reg = _reg; - if (port & 1) - reg += spacing; - - pm3386_reg_write(port >> 1, reg, value); -} - - -void pm3386_reset(void) -{ - u8 mac[3][6]; - - /* Save programmed MAC addresses. */ - pm3386_get_mac(0, mac[0]); - pm3386_get_mac(1, mac[1]); - pm3386_get_mac(2, mac[2]); - - /* Assert analog and digital reset. */ - pm3386_reg_write(0, 0x002, 0x0060); - pm3386_reg_write(1, 0x002, 0x0060); - mdelay(1); - - /* Deassert analog reset. */ - pm3386_reg_write(0, 0x002, 0x0062); - pm3386_reg_write(1, 0x002, 0x0062); - mdelay(10); - - /* Deassert digital reset. */ - pm3386_reg_write(0, 0x002, 0x0063); - pm3386_reg_write(1, 0x002, 0x0063); - mdelay(10); - - /* Restore programmed MAC addresses. */ - pm3386_set_mac(0, mac[0]); - pm3386_set_mac(1, mac[1]); - pm3386_set_mac(2, mac[2]); - - /* Disable carrier on all ports. */ - pm3386_set_carrier(0, 0); - pm3386_set_carrier(1, 0); - pm3386_set_carrier(2, 0); -} - -static u16 swaph(u16 x) -{ - return ((x << 8) | (x >> 8)) & 0xffff; -} - -void pm3386_init_port(int port) -{ - int pm = port >> 1; - - /* - * Work around ENP2611 bootloader programming MAC address - * in reverse. - */ - if (pm3386_port_reg_read(port, 0x30a, 0x100) == 0x0000 && - (pm3386_port_reg_read(port, 0x309, 0x100) & 0xff00) == 0x5000) { - u16 temp[3]; - - temp[0] = pm3386_port_reg_read(port, 0x308, 0x100); - temp[1] = pm3386_port_reg_read(port, 0x309, 0x100); - temp[2] = pm3386_port_reg_read(port, 0x30a, 0x100); - pm3386_port_reg_write(port, 0x308, 0x100, swaph(temp[2])); - pm3386_port_reg_write(port, 0x309, 0x100, swaph(temp[1])); - pm3386_port_reg_write(port, 0x30a, 0x100, swaph(temp[0])); - } - - /* - * Initialise narrowbanding mode. See application note 2010486 - * for more information. (@@@ We also need to issue a reset - * when ROOL or DOOL are detected.) - */ - pm3386_port_reg_write(port, 0x708, 0x10, 0xd055); - udelay(500); - pm3386_port_reg_write(port, 0x708, 0x10, 0x5055); - - /* - * SPI-3 ingress block. Set 64 bytes SPI-3 burst size - * towards SPI-3 bridge. - */ - pm3386_port_reg_write(port, 0x122, 0x20, 0x0002); - - /* - * Enable ingress protocol checking, and soft reset the - * SPI-3 ingress block. - */ - pm3386_reg_write(pm, 0x103, 0x0003); - while (!(pm3386_reg_read(pm, 0x103) & 0x80)) - ; - - /* - * SPI-3 egress block. Gather 12288 bytes of the current - * packet in the TX fifo before initiating transmit on the - * SERDES interface. (Prevents TX underflows.) - */ - pm3386_port_reg_write(port, 0x221, 0x20, 0x0007); - - /* - * Enforce odd parity from the SPI-3 bridge, and soft reset - * the SPI-3 egress block. - */ - pm3386_reg_write(pm, 0x203, 0x000d & ~(4 << (port & 1))); - while ((pm3386_reg_read(pm, 0x203) & 0x000c) != 0x000c) - ; - - /* - * EGMAC block. Set this channels to reject long preambles, - * not send or transmit PAUSE frames, enable preamble checking, - * disable frame length checking, enable FCS appending, enable - * TX frame padding. - */ - pm3386_port_reg_write(port, 0x302, 0x100, 0x0113); - - /* - * Soft reset the EGMAC block. - */ - pm3386_port_reg_write(port, 0x301, 0x100, 0x8000); - pm3386_port_reg_write(port, 0x301, 0x100, 0x0000); - - /* - * Auto-sense autonegotiation status. - */ - pm3386_port_reg_write(port, 0x306, 0x100, 0x0100); - - /* - * Allow reception of jumbo frames. - */ - pm3386_port_reg_write(port, 0x310, 0x100, 9018); - - /* - * Allow transmission of jumbo frames. - */ - pm3386_port_reg_write(port, 0x336, 0x100, 9018); - - /* @@@ Should set 0x337/0x437 (RX forwarding threshold.) */ - - /* - * Set autonegotiation parameters to 'no PAUSE, full duplex.' - */ - pm3386_port_reg_write(port, 0x31c, 0x100, 0x0020); - - /* - * Enable and restart autonegotiation. - */ - pm3386_port_reg_write(port, 0x318, 0x100, 0x0003); - pm3386_port_reg_write(port, 0x318, 0x100, 0x0002); -} - -void pm3386_get_mac(int port, u8 *mac) -{ - u16 temp; - - temp = pm3386_port_reg_read(port, 0x308, 0x100); - mac[0] = temp & 0xff; - mac[1] = (temp >> 8) & 0xff; - - temp = pm3386_port_reg_read(port, 0x309, 0x100); - mac[2] = temp & 0xff; - mac[3] = (temp >> 8) & 0xff; - - temp = pm3386_port_reg_read(port, 0x30a, 0x100); - mac[4] = temp & 0xff; - mac[5] = (temp >> 8) & 0xff; -} - -void pm3386_set_mac(int port, u8 *mac) -{ - pm3386_port_reg_write(port, 0x308, 0x100, (mac[1] << 8) | mac[0]); - pm3386_port_reg_write(port, 0x309, 0x100, (mac[3] << 8) | mac[2]); - pm3386_port_reg_write(port, 0x30a, 0x100, (mac[5] << 8) | mac[4]); -} - -static u32 pm3386_get_stat(int port, u16 base) -{ - u32 value; - - value = pm3386_port_reg_read(port, base, 0x100); - value |= pm3386_port_reg_read(port, base + 1, 0x100) << 16; - - return value; -} - -void pm3386_get_stats(int port, struct net_device_stats *stats) -{ - /* - * Snapshot statistics counters. - */ - pm3386_port_reg_write(port, 0x500, 0x100, 0x0001); - while (pm3386_port_reg_read(port, 0x500, 0x100) & 0x0001) - ; - - memset(stats, 0, sizeof(*stats)); - - stats->rx_packets = pm3386_get_stat(port, 0x510); - stats->tx_packets = pm3386_get_stat(port, 0x590); - stats->rx_bytes = pm3386_get_stat(port, 0x514); - stats->tx_bytes = pm3386_get_stat(port, 0x594); - /* @@@ Add other stats. */ -} - -void pm3386_set_carrier(int port, int state) -{ - pm3386_port_reg_write(port, 0x703, 0x10, state ? 0x1001 : 0x0000); -} - -int pm3386_is_link_up(int port) -{ - u16 temp; - - temp = pm3386_port_reg_read(port, 0x31a, 0x100); - temp = pm3386_port_reg_read(port, 0x31a, 0x100); - - return !!(temp & 0x0002); -} - -void pm3386_enable_rx(int port) -{ - u16 temp; - - temp = pm3386_port_reg_read(port, 0x303, 0x100); - temp |= 0x1000; - pm3386_port_reg_write(port, 0x303, 0x100, temp); -} - -void pm3386_disable_rx(int port) -{ - u16 temp; - - temp = pm3386_port_reg_read(port, 0x303, 0x100); - temp &= 0xefff; - pm3386_port_reg_write(port, 0x303, 0x100, temp); -} - -void pm3386_enable_tx(int port) -{ - u16 temp; - - temp = pm3386_port_reg_read(port, 0x303, 0x100); - temp |= 0x4000; - pm3386_port_reg_write(port, 0x303, 0x100, temp); -} - -void pm3386_disable_tx(int port) -{ - u16 temp; - - temp = pm3386_port_reg_read(port, 0x303, 0x100); - temp &= 0xbfff; - pm3386_port_reg_write(port, 0x303, 0x100, temp); -} - -MODULE_LICENSE("GPL"); diff --git a/trunk/drivers/net/ixp2000/pm3386.h b/trunk/drivers/net/ixp2000/pm3386.h deleted file mode 100644 index fe92bb056ac4..000000000000 --- a/trunk/drivers/net/ixp2000/pm3386.h +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Helper functions for the PM3386s on the Radisys ENP2611 - * Copyright (C) 2004, 2005 Lennert Buytenhek - * Dedicated to Marija Kulikova. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - */ - -#ifndef __PM3386_H -#define __PM3386_H - -void pm3386_reset(void); -void pm3386_init_port(int port); -void pm3386_get_mac(int port, u8 *mac); -void pm3386_set_mac(int port, u8 *mac); -void pm3386_get_stats(int port, struct net_device_stats *stats); -void pm3386_set_carrier(int port, int state); -int pm3386_is_link_up(int port); -void pm3386_enable_rx(int port); -void pm3386_disable_rx(int port); -void pm3386_enable_tx(int port); -void pm3386_disable_tx(int port); - - -#endif diff --git a/trunk/drivers/net/ns83820.c b/trunk/drivers/net/ns83820.c index b0c3b6ab6263..f857ae94d261 100644 --- a/trunk/drivers/net/ns83820.c +++ b/trunk/drivers/net/ns83820.c @@ -115,7 +115,6 @@ #include #include #include -#include #include #include diff --git a/trunk/drivers/net/pcmcia/3c574_cs.c b/trunk/drivers/net/pcmcia/3c574_cs.c index 48774efeec71..71fd41122c91 100644 --- a/trunk/drivers/net/pcmcia/3c574_cs.c +++ b/trunk/drivers/net/pcmcia/3c574_cs.c @@ -227,6 +227,8 @@ static char mii_preamble_required = 0; static void tc574_config(dev_link_t *link); static void tc574_release(dev_link_t *link); +static int tc574_event(event_t event, int priority, + event_callback_args_t *args); static void mdio_sync(kio_addr_t ioaddr, int bits); static int mdio_read(kio_addr_t ioaddr, int phy_id, int location); @@ -248,7 +250,12 @@ static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); static struct ethtool_ops netdev_ethtool_ops; static void set_rx_mode(struct net_device *dev); -static void tc574_detach(struct pcmcia_device *p_dev); +static dev_info_t dev_info = "3c574_cs"; + +static dev_link_t *tc574_attach(void); +static void tc574_detach(dev_link_t *); + +static dev_link_t *dev_list; /* tc574_attach() creates an "instance" of the driver, allocating @@ -256,18 +263,20 @@ static void tc574_detach(struct pcmcia_device *p_dev); with Card Services. */ -static int tc574_attach(struct pcmcia_device *p_dev) +static dev_link_t *tc574_attach(void) { struct el3_private *lp; + client_reg_t client_reg; dev_link_t *link; struct net_device *dev; + int ret; DEBUG(0, "3c574_attach()\n"); /* Create the PC card device object. */ dev = alloc_etherdev(sizeof(struct el3_private)); if (!dev) - return -ENOMEM; + return NULL; lp = netdev_priv(dev); link = &lp->link; link->priv = dev; @@ -298,13 +307,20 @@ static int tc574_attach(struct pcmcia_device *p_dev) dev->watchdog_timeo = TX_TIMEOUT; #endif - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - tc574_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + tc574_detach(link); + return NULL; + } - return 0; + return link; } /* tc574_attach */ /* @@ -316,19 +332,30 @@ static int tc574_attach(struct pcmcia_device *p_dev) */ -static void tc574_detach(struct pcmcia_device *p_dev) +static void tc574_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct net_device *dev = link->priv; + dev_link_t **linkp; DEBUG(0, "3c574_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + if (link->dev) unregister_netdev(dev); if (link->state & DEV_CONFIG) tc574_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; free_netdev(dev); } /* tc574_detach */ @@ -520,37 +547,56 @@ static void tc574_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int tc574_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); - } - - return 0; -} +/* + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. +*/ -static int tc574_resume(struct pcmcia_device *p_dev) +static int tc574_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link = args->client_data; struct net_device *dev = link->priv; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - tc574_reset(dev); - netif_device_attach(dev); + DEBUG(1, "3c574_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + tc574_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + tc574_reset(dev); + netif_device_attach(dev); + } } + break; } - return 0; -} +} /* tc574_event */ static void dump_status(struct net_device *dev) { @@ -1246,11 +1292,10 @@ static struct pcmcia_driver tc574_driver = { .drv = { .name = "3c574_cs", }, - .probe = tc574_attach, - .remove = tc574_detach, + .attach = tc574_attach, + .event = tc574_event, + .detach = tc574_detach, .id_table = tc574_ids, - .suspend = tc574_suspend, - .resume = tc574_resume, }; static int __init init_tc574(void) @@ -1261,6 +1306,7 @@ static int __init init_tc574(void) static void __exit exit_tc574(void) { pcmcia_unregister_driver(&tc574_driver); + BUG_ON(dev_list != NULL); } module_init(init_tc574); diff --git a/trunk/drivers/net/pcmcia/3c589_cs.c b/trunk/drivers/net/pcmcia/3c589_cs.c index 1c3c9c666f74..d83fdd8c1943 100644 --- a/trunk/drivers/net/pcmcia/3c589_cs.c +++ b/trunk/drivers/net/pcmcia/3c589_cs.c @@ -143,6 +143,8 @@ DRV_NAME ".c " DRV_VERSION " 2001/10/13 00:08:50 (David Hinds)"; static void tc589_config(dev_link_t *link); static void tc589_release(dev_link_t *link); +static int tc589_event(event_t event, int priority, + event_callback_args_t *args); static u16 read_eeprom(kio_addr_t ioaddr, int index); static void tc589_reset(struct net_device *dev); @@ -159,7 +161,12 @@ static void el3_tx_timeout(struct net_device *dev); static void set_multicast_list(struct net_device *dev); static struct ethtool_ops netdev_ethtool_ops; -static void tc589_detach(struct pcmcia_device *p_dev); +static dev_info_t dev_info = "3c589_cs"; + +static dev_link_t *tc589_attach(void); +static void tc589_detach(dev_link_t *); + +static dev_link_t *dev_list; /*====================================================================== @@ -169,18 +176,20 @@ static void tc589_detach(struct pcmcia_device *p_dev); ======================================================================*/ -static int tc589_attach(struct pcmcia_device *p_dev) +static dev_link_t *tc589_attach(void) { struct el3_private *lp; + client_reg_t client_reg; dev_link_t *link; struct net_device *dev; + int ret; DEBUG(0, "3c589_attach()\n"); - + /* Create new ethernet device */ dev = alloc_etherdev(sizeof(struct el3_private)); if (!dev) - return -ENOMEM; + return NULL; lp = netdev_priv(dev); link = &lp->link; link->priv = dev; @@ -197,7 +206,7 @@ static int tc589_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; link->conf.ConfigIndex = 1; link->conf.Present = PRESENT_OPTION; - + /* The EL3-specific entries in the device structure. */ SET_MODULE_OWNER(dev); dev->hard_start_xmit = &el3_start_xmit; @@ -212,13 +221,20 @@ static int tc589_attach(struct pcmcia_device *p_dev) #endif SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops); - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - tc589_config(link); - - return 0; + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + tc589_detach(link); + return NULL; + } + + return link; } /* tc589_attach */ /*====================================================================== @@ -230,19 +246,30 @@ static int tc589_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void tc589_detach(struct pcmcia_device *p_dev) +static void tc589_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct net_device *dev = link->priv; - + dev_link_t **linkp; + DEBUG(0, "3c589_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; if (link->dev) unregister_netdev(dev); if (link->state & DEV_CONFIG) tc589_release(link); - + + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; free_netdev(dev); } /* tc589_detach */ @@ -394,37 +421,58 @@ static void tc589_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int tc589_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; +/*====================================================================== + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. + +======================================================================*/ + +static int tc589_event(event_t event, int priority, + event_callback_args_t *args) +{ + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + + DEBUG(1, "3c589_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + tc589_config(link); + break; + case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); } - - return 0; -} - -static int tc589_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - tc589_reset(dev); - netif_device_attach(dev); - } + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + tc589_reset(dev); + netif_device_attach(dev); + } } - - return 0; -} + break; + } + return 0; +} /* tc589_event */ /*====================================================================*/ @@ -1019,11 +1067,10 @@ static struct pcmcia_driver tc589_driver = { .drv = { .name = "3c589_cs", }, - .probe = tc589_attach, - .remove = tc589_detach, + .attach = tc589_attach, + .event = tc589_event, + .detach = tc589_detach, .id_table = tc589_ids, - .suspend = tc589_suspend, - .resume = tc589_resume, }; static int __init init_tc589(void) @@ -1034,6 +1081,7 @@ static int __init init_tc589(void) static void __exit exit_tc589(void) { pcmcia_unregister_driver(&tc589_driver); + BUG_ON(dev_list != NULL); } module_init(init_tc589); diff --git a/trunk/drivers/net/pcmcia/axnet_cs.c b/trunk/drivers/net/pcmcia/axnet_cs.c index 01ddfc8cce3f..8bb4e85689ea 100644 --- a/trunk/drivers/net/pcmcia/axnet_cs.c +++ b/trunk/drivers/net/pcmcia/axnet_cs.c @@ -87,6 +87,8 @@ static char *version = static void axnet_config(dev_link_t *link); static void axnet_release(dev_link_t *link); +static int axnet_event(event_t event, int priority, + event_callback_args_t *args); static int axnet_open(struct net_device *dev); static int axnet_close(struct net_device *dev); static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); @@ -105,7 +107,11 @@ static void block_input(struct net_device *dev, int count, static void block_output(struct net_device *dev, int count, const u_char *buf, const int start_page); -static void axnet_detach(struct pcmcia_device *p_dev); +static dev_link_t *axnet_attach(void); +static void axnet_detach(dev_link_t *); + +static dev_info_t dev_info = "axnet_cs"; +static dev_link_t *dev_list; static void axdev_setup(struct net_device *dev); static void AX88190_init(struct net_device *dev, int startp); @@ -141,11 +147,13 @@ static inline axnet_dev_t *PRIV(struct net_device *dev) ======================================================================*/ -static int axnet_attach(struct pcmcia_device *p_dev) +static dev_link_t *axnet_attach(void) { axnet_dev_t *info; dev_link_t *link; struct net_device *dev; + client_reg_t client_reg; + int ret; DEBUG(0, "axnet_attach()\n"); @@ -153,7 +161,7 @@ static int axnet_attach(struct pcmcia_device *p_dev) "eth%d", axdev_setup); if (!dev) - return -ENOMEM; + return NULL; info = PRIV(dev); link = &info->link; @@ -168,13 +176,20 @@ static int axnet_attach(struct pcmcia_device *p_dev) dev->do_ioctl = &axnet_ioctl; SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops); - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - axnet_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + axnet_detach(link); + return NULL; + } - return 0; + return link; } /* axnet_attach */ /*====================================================================== @@ -186,19 +201,30 @@ static int axnet_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void axnet_detach(struct pcmcia_device *p_dev) +static void axnet_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct net_device *dev = link->priv; + dev_link_t **linkp; DEBUG(0, "axnet_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + if (link->dev) unregister_netdev(dev); if (link->state & DEV_CONFIG) axnet_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; free_netdev(dev); } /* axnet_detach */ @@ -464,39 +490,59 @@ static void axnet_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int axnet_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; +/*====================================================================== - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); - } + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. - return 0; -} +======================================================================*/ -static int axnet_resume(struct pcmcia_device *p_dev) +static int axnet_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + DEBUG(2, "axnet_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + axnet_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - axnet_reset_8390(dev); - AX88190_init(dev, 1); - netif_device_attach(dev); - } + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + axnet_reset_8390(dev); + AX88190_init(dev, 1); + netif_device_attach(dev); + } } - - return 0; -} - + break; + } + return 0; +} /* axnet_event */ /*====================================================================== @@ -570,7 +616,7 @@ static int axnet_open(struct net_device *dev) link->open++; - request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, "axnet_cs", dev); + request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev); info->link_status = 0x00; init_timer(&info->watchdog); @@ -831,11 +877,10 @@ static struct pcmcia_driver axnet_cs_driver = { .drv = { .name = "axnet_cs", }, - .probe = axnet_attach, - .remove = axnet_detach, + .attach = axnet_attach, + .event = axnet_event, + .detach = axnet_detach, .id_table = axnet_ids, - .suspend = axnet_suspend, - .resume = axnet_resume, }; static int __init init_axnet_cs(void) @@ -846,6 +891,7 @@ static int __init init_axnet_cs(void) static void __exit exit_axnet_cs(void) { pcmcia_unregister_driver(&axnet_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_axnet_cs); diff --git a/trunk/drivers/net/pcmcia/com20020_cs.c b/trunk/drivers/net/pcmcia/com20020_cs.c index 2827a48ea37c..b9355d9498a3 100644 --- a/trunk/drivers/net/pcmcia/com20020_cs.c +++ b/trunk/drivers/net/pcmcia/com20020_cs.c @@ -120,8 +120,15 @@ MODULE_LICENSE("GPL"); static void com20020_config(dev_link_t *link); static void com20020_release(dev_link_t *link); +static int com20020_event(event_t event, int priority, + event_callback_args_t *args); -static void com20020_detach(struct pcmcia_device *p_dev); +static dev_info_t dev_info = "com20020_cs"; + +static dev_link_t *com20020_attach(void); +static void com20020_detach(dev_link_t *); + +static dev_link_t *dev_list; /*====================================================================*/ @@ -138,19 +145,21 @@ typedef struct com20020_dev_t { ======================================================================*/ -static int com20020_attach(struct pcmcia_device *p_dev) +static dev_link_t *com20020_attach(void) { + client_reg_t client_reg; dev_link_t *link; com20020_dev_t *info; struct net_device *dev; + int ret; struct arcnet_local *lp; - + DEBUG(0, "com20020_attach()\n"); /* Create new network device */ link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL); if (!link) - return -ENOMEM; + return NULL; info = kmalloc(sizeof(struct com20020_dev_t), GFP_KERNEL); if (!info) @@ -182,19 +191,30 @@ static int com20020_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; link->conf.Present = PRESENT_OPTION; + link->irq.Instance = info->dev = dev; link->priv = info; - link->state |= DEV_PRESENT; - com20020_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + com20020_detach(link); + return NULL; + } - return 0; + return link; fail_alloc_dev: kfree(info); fail_alloc_info: kfree(link); - return -ENOMEM; + return NULL; } /* com20020_attach */ /*====================================================================== @@ -206,21 +226,29 @@ static int com20020_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void com20020_detach(struct pcmcia_device *p_dev) +static void com20020_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct com20020_dev_t *info = link->priv; - struct net_device *dev = info->dev; - + dev_link_t **linkp; + struct net_device *dev; + DEBUG(1,"detach...\n"); DEBUG(0, "com20020_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + + dev = info->dev; + if (link->dev) { DEBUG(1,"unregister...\n"); unregister_netdev(dev); - + /* * this is necessary because we register our IRQ separately * from card services. @@ -232,8 +260,12 @@ static void com20020_detach(struct pcmcia_device *p_dev) if (link->state & DEV_CONFIG) com20020_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + /* Unlink device structure, free bits */ DEBUG(1,"unlinking...\n"); + *linkp = link->next; if (link->priv) { dev = info->dev; @@ -389,41 +421,61 @@ static void com20020_release(dev_link_t *link) link->state &= ~(DEV_CONFIG | DEV_RELEASE_PENDING); } -static int com20020_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - com20020_dev_t *info = link->priv; - struct net_device *dev = info->dev; +/*====================================================================== - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - if (link->open) { - netif_device_detach(dev); - } - pcmcia_release_configuration(link->handle); - } + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. - return 0; -} +======================================================================*/ -static int com20020_resume(struct pcmcia_device *p_dev) +static int com20020_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - com20020_dev_t *info = link->priv; - struct net_device *dev = info->dev; + dev_link_t *link = args->client_data; + com20020_dev_t *info = link->priv; + struct net_device *dev = info->dev; - link->state &= ~DEV_SUSPEND; + DEBUG(1, "com20020_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT; + com20020_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - int ioaddr = dev->base_addr; - struct arcnet_local *lp = dev->priv; - ARCRESET; - } + if (link->open) { + netif_device_detach(dev); + } + pcmcia_release_configuration(link->handle); } - - return 0; -} + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + int ioaddr = dev->base_addr; + struct arcnet_local *lp = dev->priv; + ARCRESET; + } + } + break; + } + return 0; +} /* com20020_event */ static struct pcmcia_device_id com20020_ids[] = { PCMCIA_DEVICE_PROD_ID12("Contemporary Control Systems, Inc.", "PCM20 Arcnet Adapter", 0x59991666, 0x95dfffaf), @@ -436,11 +488,10 @@ static struct pcmcia_driver com20020_cs_driver = { .drv = { .name = "com20020_cs", }, - .probe = com20020_attach, - .remove = com20020_detach, + .attach = com20020_attach, + .event = com20020_event, + .detach = com20020_detach, .id_table = com20020_ids, - .suspend = com20020_suspend, - .resume = com20020_resume, }; static int __init init_com20020_cs(void) @@ -451,6 +502,7 @@ static int __init init_com20020_cs(void) static void __exit exit_com20020_cs(void) { pcmcia_unregister_driver(&com20020_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_com20020_cs); diff --git a/trunk/drivers/net/pcmcia/fmvj18x_cs.c b/trunk/drivers/net/pcmcia/fmvj18x_cs.c index 28fe2fb4d6c0..356f50909222 100644 --- a/trunk/drivers/net/pcmcia/fmvj18x_cs.c +++ b/trunk/drivers/net/pcmcia/fmvj18x_cs.c @@ -88,7 +88,10 @@ static void fmvj18x_config(dev_link_t *link); static int fmvj18x_get_hwinfo(dev_link_t *link, u_char *node_id); static int fmvj18x_setup_mfc(dev_link_t *link); static void fmvj18x_release(dev_link_t *link); -static void fmvj18x_detach(struct pcmcia_device *p_dev); +static int fmvj18x_event(event_t event, int priority, + event_callback_args_t *args); +static dev_link_t *fmvj18x_attach(void); +static void fmvj18x_detach(dev_link_t *); /* LAN controller(MBH86960A) specific routines @@ -105,6 +108,9 @@ static void set_rx_mode(struct net_device *dev); static void fjn_tx_timeout(struct net_device *dev); static struct ethtool_ops netdev_ethtool_ops; +static dev_info_t dev_info = "fmvj18x_cs"; +static dev_link_t *dev_list; + /* card type */ @@ -228,18 +234,20 @@ typedef struct local_info_t { #define BANK_1U 0x24 /* bank 1 (CONFIG_1) */ #define BANK_2U 0x28 /* bank 2 (CONFIG_1) */ -static int fmvj18x_attach(struct pcmcia_device *p_dev) +static dev_link_t *fmvj18x_attach(void) { local_info_t *lp; dev_link_t *link; struct net_device *dev; - + client_reg_t client_reg; + int ret; + DEBUG(0, "fmvj18x_attach()\n"); /* Make up a FMVJ18x specific data structure */ dev = alloc_etherdev(sizeof(local_info_t)); if (!dev) - return -ENOMEM; + return NULL; lp = netdev_priv(dev); link = &lp->link; link->priv = dev; @@ -254,7 +262,7 @@ static int fmvj18x_attach(struct pcmcia_device *p_dev) link->irq.IRQInfo1 = IRQ_LEVEL_ID; link->irq.Handler = &fjn_interrupt; link->irq.Instance = dev; - + /* General socket configuration */ link->conf.Attributes = CONF_ENABLE_IRQ; link->conf.Vcc = 50; @@ -273,24 +281,37 @@ static int fmvj18x_attach(struct pcmcia_device *p_dev) dev->watchdog_timeo = TX_TIMEOUT; #endif SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops); + + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + fmvj18x_detach(link); + return NULL; + } - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - fmvj18x_config(link); - - return 0; + return link; } /* fmvj18x_attach */ /*====================================================================*/ -static void fmvj18x_detach(struct pcmcia_device *p_dev) +static void fmvj18x_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct net_device *dev = link->priv; - + dev_link_t **linkp; + DEBUG(0, "fmvj18x_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; if (link->dev) unregister_netdev(dev); @@ -298,6 +319,12 @@ static void fmvj18x_detach(struct pcmcia_device *p_dev) if (link->state & DEV_CONFIG) fmvj18x_release(link); + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free pieces */ + *linkp = link->next; free_netdev(dev); } /* fmvj18x_detach */ @@ -686,40 +713,51 @@ static void fmvj18x_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int fmvj18x_suspend(struct pcmcia_device *p_dev) +/*====================================================================*/ + +static int fmvj18x_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + DEBUG(1, "fmvj18x_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + fmvj18x_config(link); + break; + case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); } - - - return 0; -} - -static int fmvj18x_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - fjn_reset(dev); - netif_device_attach(dev); - } + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + fjn_reset(dev); + netif_device_attach(dev); + } } - - return 0; -} - -/*====================================================================*/ + break; + } + return 0; +} /* fmvj18x_event */ static struct pcmcia_device_id fmvj18x_ids[] = { PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004), @@ -751,11 +789,10 @@ static struct pcmcia_driver fmvj18x_cs_driver = { .drv = { .name = "fmvj18x_cs", }, - .probe = fmvj18x_attach, - .remove = fmvj18x_detach, + .attach = fmvj18x_attach, + .event = fmvj18x_event, + .detach = fmvj18x_detach, .id_table = fmvj18x_ids, - .suspend = fmvj18x_suspend, - .resume = fmvj18x_resume, }; static int __init init_fmvj18x_cs(void) @@ -766,6 +803,7 @@ static int __init init_fmvj18x_cs(void) static void __exit exit_fmvj18x_cs(void) { pcmcia_unregister_driver(&fmvj18x_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_fmvj18x_cs); diff --git a/trunk/drivers/net/pcmcia/ibmtr_cs.c b/trunk/drivers/net/pcmcia/ibmtr_cs.c index b9c7e39576f5..b6c140eb9799 100644 --- a/trunk/drivers/net/pcmcia/ibmtr_cs.c +++ b/trunk/drivers/net/pcmcia/ibmtr_cs.c @@ -108,7 +108,15 @@ MODULE_LICENSE("GPL"); static void ibmtr_config(dev_link_t *link); static void ibmtr_hw_setup(struct net_device *dev, u_int mmiobase); static void ibmtr_release(dev_link_t *link); -static void ibmtr_detach(struct pcmcia_device *p_dev); +static int ibmtr_event(event_t event, int priority, + event_callback_args_t *args); + +static dev_info_t dev_info = "ibmtr_cs"; + +static dev_link_t *ibmtr_attach(void); +static void ibmtr_detach(dev_link_t *); + +static dev_link_t *dev_list; /*====================================================================*/ @@ -138,23 +146,25 @@ static struct ethtool_ops netdev_ethtool_ops = { ======================================================================*/ -static int ibmtr_attach(struct pcmcia_device *p_dev) +static dev_link_t *ibmtr_attach(void) { ibmtr_dev_t *info; dev_link_t *link; struct net_device *dev; + client_reg_t client_reg; + int ret; DEBUG(0, "ibmtr_attach()\n"); /* Create new token-ring device */ info = kmalloc(sizeof(*info), GFP_KERNEL); - if (!info) return -ENOMEM; + if (!info) return NULL; memset(info,0,sizeof(*info)); dev = alloc_trdev(sizeof(struct tok_info)); - if (!dev) { - kfree(info); - return -ENOMEM; - } + if (!dev) { + kfree(info); + return NULL; + } link = &info->link; link->priv = info; @@ -175,13 +185,25 @@ static int ibmtr_attach(struct pcmcia_device *p_dev) SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops); - link->handle = p_dev; - p_dev->instance = link; + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + goto out_detach; + } - link->state |= DEV_PRESENT; - ibmtr_config(link); +out: + return link; - return 0; +out_detach: + ibmtr_detach(link); + link = NULL; + goto out; } /* ibmtr_attach */ /*====================================================================== @@ -193,14 +215,22 @@ static int ibmtr_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void ibmtr_detach(struct pcmcia_device *p_dev) +static void ibmtr_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct ibmtr_dev_t *info = link->priv; - struct net_device *dev = info->dev; + dev_link_t **linkp; + struct net_device *dev; DEBUG(0, "ibmtr_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + + dev = info->dev; + if (link->dev) unregister_netdev(dev); @@ -211,8 +241,13 @@ static void ibmtr_detach(struct pcmcia_device *p_dev) if (link->state & DEV_CONFIG) ibmtr_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; free_netdev(dev); - kfree(info); + kfree(info); } /* ibmtr_detach */ /*====================================================================== @@ -366,40 +401,63 @@ static void ibmtr_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int ibmtr_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - ibmtr_dev_t *info = link->priv; - struct net_device *dev = info->dev; +/*====================================================================== - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); - } + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. - return 0; -} +======================================================================*/ -static int ibmtr_resume(struct pcmcia_device *p_dev) +static int ibmtr_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - ibmtr_dev_t *info = link->priv; - struct net_device *dev = info->dev; + dev_link_t *link = args->client_data; + ibmtr_dev_t *info = link->priv; + struct net_device *dev = info->dev; - link->state &= ~DEV_SUSPEND; + DEBUG(1, "ibmtr_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - ibmtr_probe(dev); /* really? */ - netif_device_attach(dev); - } + /* set flag to bypass normal interrupt code */ + struct tok_info *priv = netdev_priv(dev); + priv->sram_phys |= 1; + netif_device_detach(dev); } - - return 0; -} - + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT; + ibmtr_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + ibmtr_probe(dev); /* really? */ + netif_device_attach(dev); + } + } + break; + } + return 0; +} /* ibmtr_event */ /*====================================================================*/ @@ -456,11 +514,10 @@ static struct pcmcia_driver ibmtr_cs_driver = { .drv = { .name = "ibmtr_cs", }, - .probe = ibmtr_attach, - .remove = ibmtr_detach, + .attach = ibmtr_attach, + .event = ibmtr_event, + .detach = ibmtr_detach, .id_table = ibmtr_ids, - .suspend = ibmtr_suspend, - .resume = ibmtr_resume, }; static int __init init_ibmtr_cs(void) @@ -471,6 +528,7 @@ static int __init init_ibmtr_cs(void) static void __exit exit_ibmtr_cs(void) { pcmcia_unregister_driver(&ibmtr_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_ibmtr_cs); diff --git a/trunk/drivers/net/pcmcia/nmclan_cs.c b/trunk/drivers/net/pcmcia/nmclan_cs.c index 4a232254a497..980d7e5d66cb 100644 --- a/trunk/drivers/net/pcmcia/nmclan_cs.c +++ b/trunk/drivers/net/pcmcia/nmclan_cs.c @@ -388,6 +388,9 @@ static char *version = DRV_NAME " " DRV_VERSION " (Roger C. Pao)"; #endif +static dev_info_t dev_info="nmclan_cs"; +static dev_link_t *dev_list; + static char *if_names[]={ "Auto", "10baseT", "BNC", }; @@ -419,6 +422,8 @@ Function Prototypes static void nmclan_config(dev_link_t *link); static void nmclan_release(dev_link_t *link); +static int nmclan_event(event_t event, int priority, + event_callback_args_t *args); static void nmclan_reset(struct net_device *dev); static int mace_config(struct net_device *dev, struct ifmap *map); @@ -434,7 +439,8 @@ static void set_multicast_list(struct net_device *dev); static struct ethtool_ops netdev_ethtool_ops; -static void nmclan_detach(struct pcmcia_device *p_dev); +static dev_link_t *nmclan_attach(void); +static void nmclan_detach(dev_link_t *); /* ---------------------------------------------------------------------------- nmclan_attach @@ -443,11 +449,13 @@ nmclan_attach Services. ---------------------------------------------------------------------------- */ -static int nmclan_attach(struct pcmcia_device *p_dev) +static dev_link_t *nmclan_attach(void) { mace_private *lp; dev_link_t *link; struct net_device *dev; + client_reg_t client_reg; + int ret; DEBUG(0, "nmclan_attach()\n"); DEBUG(1, "%s\n", rcsid); @@ -455,7 +463,7 @@ static int nmclan_attach(struct pcmcia_device *p_dev) /* Create new ethernet device */ dev = alloc_etherdev(sizeof(mace_private)); if (!dev) - return -ENOMEM; + return NULL; lp = netdev_priv(dev); link = &lp->link; link->priv = dev; @@ -489,13 +497,20 @@ static int nmclan_attach(struct pcmcia_device *p_dev) dev->watchdog_timeo = TX_TIMEOUT; #endif - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - nmclan_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + nmclan_detach(link); + return NULL; + } - return 0; + return link; } /* nmclan_attach */ /* ---------------------------------------------------------------------------- @@ -506,19 +521,30 @@ nmclan_detach when the device is released. ---------------------------------------------------------------------------- */ -static void nmclan_detach(struct pcmcia_device *p_dev) +static void nmclan_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct net_device *dev = link->priv; + dev_link_t **linkp; DEBUG(0, "nmclan_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + if (link->dev) unregister_netdev(dev); if (link->state & DEV_CONFIG) nmclan_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; free_netdev(dev); } /* nmclan_detach */ @@ -775,39 +801,59 @@ static void nmclan_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int nmclan_suspend(struct pcmcia_device *p_dev) +/* ---------------------------------------------------------------------------- +nmclan_event + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. +---------------------------------------------------------------------------- */ +static int nmclan_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); - } - + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; - return 0; -} + DEBUG(1, "nmclan_event(0x%06x)\n", event); -static int nmclan_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - nmclan_reset(dev); - netif_device_attach(dev); - } + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + nmclan_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + nmclan_reset(dev); + netif_device_attach(dev); } - - return 0; -} - + } + break; + case CS_EVENT_RESET_REQUEST: + return 1; + break; + } + return 0; +} /* nmclan_event */ /* ---------------------------------------------------------------------------- nmclan_reset @@ -1635,11 +1681,10 @@ static struct pcmcia_driver nmclan_cs_driver = { .drv = { .name = "nmclan_cs", }, - .probe = nmclan_attach, - .remove = nmclan_detach, + .attach = nmclan_attach, + .event = nmclan_event, + .detach = nmclan_detach, .id_table = nmclan_ids, - .suspend = nmclan_suspend, - .resume = nmclan_resume, }; static int __init init_nmclan_cs(void) @@ -1650,6 +1695,7 @@ static int __init init_nmclan_cs(void) static void __exit exit_nmclan_cs(void) { pcmcia_unregister_driver(&nmclan_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_nmclan_cs); diff --git a/trunk/drivers/net/pcmcia/pcnet_cs.c b/trunk/drivers/net/pcmcia/pcnet_cs.c index d85b758f3efa..818c185d6438 100644 --- a/trunk/drivers/net/pcmcia/pcnet_cs.c +++ b/trunk/drivers/net/pcmcia/pcnet_cs.c @@ -105,6 +105,8 @@ module_param_array(hw_addr, int, NULL, 0); static void mii_phy_probe(struct net_device *dev); static void pcnet_config(dev_link_t *link); static void pcnet_release(dev_link_t *link); +static int pcnet_event(event_t event, int priority, + event_callback_args_t *args); static int pcnet_open(struct net_device *dev); static int pcnet_close(struct net_device *dev); static int ei_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); @@ -118,9 +120,11 @@ static int setup_shmem_window(dev_link_t *link, int start_pg, static int setup_dma_config(dev_link_t *link, int start_pg, int stop_pg); -static void pcnet_detach(struct pcmcia_device *p_dev); +static dev_link_t *pcnet_attach(void); +static void pcnet_detach(dev_link_t *); static dev_info_t dev_info = "pcnet_cs"; +static dev_link_t *dev_list; /*====================================================================*/ @@ -240,17 +244,19 @@ static inline pcnet_dev_t *PRIV(struct net_device *dev) ======================================================================*/ -static int pcnet_probe(struct pcmcia_device *p_dev) +static dev_link_t *pcnet_attach(void) { pcnet_dev_t *info; dev_link_t *link; struct net_device *dev; + client_reg_t client_reg; + int ret; DEBUG(0, "pcnet_attach()\n"); /* Create new ethernet device */ dev = __alloc_ei_netdev(sizeof(pcnet_dev_t)); - if (!dev) return -ENOMEM; + if (!dev) return NULL; info = PRIV(dev); link = &info->link; link->priv = dev; @@ -265,13 +271,20 @@ static int pcnet_probe(struct pcmcia_device *p_dev) dev->stop = &pcnet_close; dev->set_config = &set_config; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - pcnet_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + pcnet_detach(link); + return NULL; + } - return 0; + return link; } /* pcnet_attach */ /*====================================================================== @@ -283,20 +296,31 @@ static int pcnet_probe(struct pcmcia_device *p_dev) ======================================================================*/ -static void pcnet_detach(struct pcmcia_device *p_dev) +static void pcnet_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; + struct net_device *dev = link->priv; + dev_link_t **linkp; - DEBUG(0, "pcnet_detach(0x%p)\n", link); + DEBUG(0, "pcnet_detach(0x%p)\n", link); - if (link->dev) - unregister_netdev(dev); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; - if (link->state & DEV_CONFIG) - pcnet_release(link); + if (link->dev) + unregister_netdev(dev); - free_netdev(dev); + if (link->state & DEV_CONFIG) + pcnet_release(link); + + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; + free_netdev(dev); } /* pcnet_detach */ /*====================================================================== @@ -756,39 +780,50 @@ static void pcnet_release(dev_link_t *link) ======================================================================*/ -static int pcnet_suspend(struct pcmcia_device *p_dev) +static int pcnet_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + DEBUG(2, "pcnet_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + pcnet_config(link); + break; + case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); } - - return 0; -} - -static int pcnet_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - pcnet_reset_8390(dev); - NS8390_init(dev, 1); - netif_device_attach(dev); - } + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + pcnet_reset_8390(dev); + NS8390_init(dev, 1); + netif_device_attach(dev); + } } - - return 0; -} - + break; + } + return 0; +} /* pcnet_event */ /*====================================================================== @@ -1809,12 +1844,11 @@ static struct pcmcia_driver pcnet_driver = { .drv = { .name = "pcnet_cs", }, - .probe = pcnet_probe, - .remove = pcnet_detach, + .attach = pcnet_attach, + .event = pcnet_event, + .detach = pcnet_detach, .owner = THIS_MODULE, .id_table = pcnet_ids, - .suspend = pcnet_suspend, - .resume = pcnet_resume, }; static int __init init_pcnet_cs(void) @@ -1826,6 +1860,7 @@ static void __exit exit_pcnet_cs(void) { DEBUG(0, "pcnet_cs: unloading\n"); pcmcia_unregister_driver(&pcnet_driver); + BUG_ON(dev_list != NULL); } module_init(init_pcnet_cs); diff --git a/trunk/drivers/net/pcmcia/smc91c92_cs.c b/trunk/drivers/net/pcmcia/smc91c92_cs.c index 0122415dfeef..c7cca842e5ee 100644 --- a/trunk/drivers/net/pcmcia/smc91c92_cs.c +++ b/trunk/drivers/net/pcmcia/smc91c92_cs.c @@ -102,6 +102,10 @@ static const char *version = currently have room for another Tx packet. */ #define MEMORY_WAIT_TIME 8 +static dev_info_t dev_info = "smc91c92_cs"; + +static dev_link_t *dev_list; + struct smc_private { dev_link_t link; spinlock_t lock; @@ -277,9 +281,12 @@ enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002, /*====================================================================*/ -static void smc91c92_detach(struct pcmcia_device *p_dev); +static dev_link_t *smc91c92_attach(void); +static void smc91c92_detach(dev_link_t *); static void smc91c92_config(dev_link_t *link); static void smc91c92_release(dev_link_t *link); +static int smc91c92_event(event_t event, int priority, + event_callback_args_t *args); static int smc_open(struct net_device *dev); static int smc_close(struct net_device *dev); @@ -308,18 +315,20 @@ static struct ethtool_ops ethtool_ops; ======================================================================*/ -static int smc91c92_attach(struct pcmcia_device *p_dev) +static dev_link_t *smc91c92_attach(void) { + client_reg_t client_reg; struct smc_private *smc; dev_link_t *link; struct net_device *dev; + int ret; DEBUG(0, "smc91c92_attach()\n"); /* Create new ethernet device */ dev = alloc_etherdev(sizeof(struct smc_private)); if (!dev) - return -ENOMEM; + return NULL; smc = netdev_priv(dev); link = &smc->link; link->priv = dev; @@ -357,13 +366,20 @@ static int smc91c92_attach(struct pcmcia_device *p_dev) smc->mii_if.phy_id_mask = 0x1f; smc->mii_if.reg_num_mask = 0x1f; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - smc91c92_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + smc91c92_detach(link); + return NULL; + } - return 0; + return link; } /* smc91c92_attach */ /*====================================================================== @@ -375,19 +391,30 @@ static int smc91c92_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void smc91c92_detach(struct pcmcia_device *p_dev) +static void smc91c92_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct net_device *dev = link->priv; + dev_link_t **linkp; DEBUG(0, "smc91c92_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + if (link->dev) unregister_netdev(dev); if (link->state & DEV_CONFIG) smc91c92_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; free_netdev(dev); } /* smc91c92_detach */ @@ -868,62 +895,6 @@ static int osi_setup(dev_link_t *link, u_short manfid, u_short cardid) return rc; } -static int smc91c92_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); - } - - return 0; -} - -static int smc91c92_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - struct smc_private *smc = netdev_priv(dev); - int i; - - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - if ((smc->manfid == MANFID_MEGAHERTZ) && - (smc->cardid == PRODID_MEGAHERTZ_EM3288)) - mhz_3288_power(link); - pcmcia_request_configuration(link->handle, &link->conf); - if (smc->manfid == MANFID_MOTOROLA) - mot_config(link); - if ((smc->manfid == MANFID_OSITECH) && - (smc->cardid != PRODID_OSITECH_SEVEN)) { - /* Power up the card and enable interrupts */ - set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR); - set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR); - } - if (((smc->manfid == MANFID_OSITECH) && - (smc->cardid == PRODID_OSITECH_SEVEN)) || - ((smc->manfid == MANFID_PSION) && - (smc->cardid == PRODID_PSION_NET100))) { - /* Download the Seven of Diamonds firmware */ - for (i = 0; i < sizeof(__Xilinx7OD); i++) { - outb(__Xilinx7OD[i], link->io.BasePort1+2); - udelay(50); - } - } - if (link->open) { - smc_reset(dev); - netif_device_attach(dev); - } - } - - return 0; -} - - /*====================================================================== This verifies that the chip is some SMC91cXX variant, and returns @@ -964,12 +935,14 @@ static int check_sig(dev_link_t *link) } if (width) { + event_callback_args_t args; printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n"); - smc91c92_suspend(link->handle); + args.client_data = link; + smc91c92_event(CS_EVENT_RESET_PHYSICAL, 0, &args); pcmcia_release_io(link->handle, &link->io); link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; pcmcia_request_io(link->handle, &link->io); - smc91c92_resume(link->handle); + smc91c92_event(CS_EVENT_CARD_RESET, 0, &args); return check_sig(link); } return -ENODEV; @@ -1197,6 +1170,82 @@ static void smc91c92_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } +/*====================================================================== + + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. + +======================================================================*/ + +static int smc91c92_event(event_t event, int priority, + event_callback_args_t *args) +{ + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + struct smc_private *smc = netdev_priv(dev); + int i; + + DEBUG(1, "smc91c92_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + smc91c92_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + if ((smc->manfid == MANFID_MEGAHERTZ) && + (smc->cardid == PRODID_MEGAHERTZ_EM3288)) + mhz_3288_power(link); + pcmcia_request_configuration(link->handle, &link->conf); + if (smc->manfid == MANFID_MOTOROLA) + mot_config(link); + if ((smc->manfid == MANFID_OSITECH) && + (smc->cardid != PRODID_OSITECH_SEVEN)) { + /* Power up the card and enable interrupts */ + set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR); + set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR); + } + if (((smc->manfid == MANFID_OSITECH) && + (smc->cardid == PRODID_OSITECH_SEVEN)) || + ((smc->manfid == MANFID_PSION) && + (smc->cardid == PRODID_PSION_NET100))) { + /* Download the Seven of Diamonds firmware */ + for (i = 0; i < sizeof(__Xilinx7OD); i++) { + outb(__Xilinx7OD[i], link->io.BasePort1+2); + udelay(50); + } + } + if (link->open) { + smc_reset(dev); + netif_device_attach(dev); + } + } + break; + } + return 0; +} /* smc91c92_event */ + /*====================================================================== MII interface support for SMC91cXX based cards @@ -2311,11 +2360,10 @@ static struct pcmcia_driver smc91c92_cs_driver = { .drv = { .name = "smc91c92_cs", }, - .probe = smc91c92_attach, - .remove = smc91c92_detach, + .attach = smc91c92_attach, + .event = smc91c92_event, + .detach = smc91c92_detach, .id_table = smc91c92_ids, - .suspend = smc91c92_suspend, - .resume = smc91c92_resume, }; static int __init init_smc91c92_cs(void) @@ -2326,6 +2374,7 @@ static int __init init_smc91c92_cs(void) static void __exit exit_smc91c92_cs(void) { pcmcia_unregister_driver(&smc91c92_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_smc91c92_cs); diff --git a/trunk/drivers/net/pcmcia/xirc2ps_cs.c b/trunk/drivers/net/pcmcia/xirc2ps_cs.c index 049c34b37067..ce143f08638a 100644 --- a/trunk/drivers/net/pcmcia/xirc2ps_cs.c +++ b/trunk/drivers/net/pcmcia/xirc2ps_cs.c @@ -292,6 +292,8 @@ static void mii_wr(kio_addr_t ioaddr, u_char phyaddr, u_char phyreg, static int has_ce2_string(dev_link_t * link); static void xirc2ps_config(dev_link_t * link); static void xirc2ps_release(dev_link_t * link); +static int xirc2ps_event(event_t event, int priority, + event_callback_args_t * args); /**************** * The attach() and detach() entry points are used to create and destroy @@ -299,7 +301,8 @@ static void xirc2ps_release(dev_link_t * link); * needed to manage one actual PCMCIA card. */ -static void xirc2ps_detach(struct pcmcia_device *p_dev); +static dev_link_t *xirc2ps_attach(void); +static void xirc2ps_detach(dev_link_t *); /**************** * You'll also need to prototype all the functions that will actually @@ -310,6 +313,14 @@ static void xirc2ps_detach(struct pcmcia_device *p_dev); static irqreturn_t xirc2ps_interrupt(int irq, void *dev_id, struct pt_regs *regs); +/* + * The dev_info variable is the "key" that is used to match up this + * device driver with appropriate cards, through the card configuration + * database. + */ + +static dev_info_t dev_info = "xirc2ps_cs"; + /**************** * A linked list of "instances" of the device. Each actual * PCMCIA card corresponds to one device instance, and is described @@ -320,7 +331,15 @@ static irqreturn_t xirc2ps_interrupt(int irq, void *dev_id, struct pt_regs *regs * device numbers are used to derive the corresponding array index. */ +static dev_link_t *dev_list; + /**************** + * A dev_link_t structure has fields for most things that are needed + * to keep track of a socket, but there will usually be some device + * specific information that also needs to be kept track of. The + * 'priv' pointer in a dev_link_t structure can be used to point to + * a device-specific private data structure, like this. + * * A driver needs to provide a dev_node_t structure for each device * on a card. In some cases, there is only one device per card (for * example, ethernet cards, modems). In other cases, there may be @@ -552,19 +571,21 @@ mii_wr(kio_addr_t ioaddr, u_char phyaddr, u_char phyreg, unsigned data, int len) * card insertion event. */ -static int -xirc2ps_attach(struct pcmcia_device *p_dev) +static dev_link_t * +xirc2ps_attach(void) { + client_reg_t client_reg; dev_link_t *link; struct net_device *dev; local_info_t *local; + int err; DEBUG(0, "attach()\n"); /* Allocate the device structure */ dev = alloc_etherdev(sizeof(local_info_t)); if (!dev) - return -ENOMEM; + return NULL; local = netdev_priv(dev); link = &local->link; link->priv = dev; @@ -593,13 +614,19 @@ xirc2ps_attach(struct pcmcia_device *p_dev) dev->watchdog_timeo = TX_TIMEOUT; #endif - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - xirc2ps_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + if ((err = pcmcia_register_client(&link->handle, &client_reg))) { + cs_error(link->handle, RegisterClient, err); + xirc2ps_detach(link); + return NULL; + } - return 0; + return link; } /* xirc2ps_attach */ /**************** @@ -610,19 +637,40 @@ xirc2ps_attach(struct pcmcia_device *p_dev) */ static void -xirc2ps_detach(struct pcmcia_device *p_dev) +xirc2ps_detach(dev_link_t * link) { - dev_link_t *link = dev_to_instance(p_dev); struct net_device *dev = link->priv; + dev_link_t **linkp; DEBUG(0, "detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + if (!*linkp) { + DEBUG(0, "detach(0x%p): dev_link lost\n", link); + return; + } + if (link->dev) unregister_netdev(dev); + /* + * If the device is currently configured and active, we won't + * actually delete it yet. Instead, it is marked so that when + * the release() function is called, that will trigger a proper + * detach(). + */ if (link->state & DEV_CONFIG) xirc2ps_release(link); + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free it */ + *linkp = link->next; free_netdev(dev); } /* xirc2ps_detach */ @@ -1109,41 +1157,67 @@ xirc2ps_release(dev_link_t *link) /*====================================================================*/ +/**************** + * The card status event handler. Mostly, this schedules other + * stuff to run after an event is received. A CARD_REMOVAL event + * also sets some flags to discourage the net drivers from trying + * to talk to the card any more. + * + * When a CARD_REMOVAL event is received, we immediately set a flag + * to block future accesses to this device. All the functions that + * actually access the device should check this flag to make sure + * the card is still present. + */ -static int xirc2ps_suspend(struct pcmcia_device *p_dev) +static int +xirc2ps_event(event_t event, int priority, + event_callback_args_t * args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + + DEBUG(0, "event(%d)\n", (int)event); + switch (event) { + case CS_EVENT_REGISTRATION_COMPLETE: + DEBUG(0, "registration complete\n"); + break; + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + netif_device_detach(dev); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + xirc2ps_config(link); + break; + case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { - if (link->open) { - netif_device_detach(dev); - do_powerdown(dev); - } - pcmcia_release_configuration(link->handle); + if (link->open) { + netif_device_detach(dev); + do_powerdown(dev); + } + pcmcia_release_configuration(link->handle); } - - return 0; -} - -static int xirc2ps_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - do_reset(dev,1); - netif_device_attach(dev); - } + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + do_reset(dev,1); + netif_device_attach(dev); + } } - - return 0; -} - + break; + } + return 0; +} /* xirc2ps_event */ /*====================================================================*/ @@ -1935,11 +2009,10 @@ static struct pcmcia_driver xirc2ps_cs_driver = { .drv = { .name = "xirc2ps_cs", }, - .probe = xirc2ps_attach, - .remove = xirc2ps_detach, + .attach = xirc2ps_attach, + .event = xirc2ps_event, + .detach = xirc2ps_detach, .id_table = xirc2ps_ids, - .suspend = xirc2ps_suspend, - .resume = xirc2ps_resume, }; static int __init @@ -1952,6 +2025,7 @@ static void __exit exit_xirc2ps_cs(void) { pcmcia_unregister_driver(&xirc2ps_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_xirc2ps_cs); diff --git a/trunk/drivers/net/pppoe.c b/trunk/drivers/net/pppoe.c index 9369f811075d..a842ecc60a34 100644 --- a/trunk/drivers/net/pppoe.c +++ b/trunk/drivers/net/pppoe.c @@ -85,7 +85,7 @@ static int pppoe_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) static int pppoe_xmit(struct ppp_channel *chan, struct sk_buff *skb); static int __pppoe_xmit(struct sock *sk, struct sk_buff *skb); -static const struct proto_ops pppoe_ops; +static struct proto_ops pppoe_ops; static DEFINE_RWLOCK(pppoe_hash_lock); static struct ppp_channel_ops pppoe_chan_ops; @@ -383,6 +383,8 @@ static int pppoe_rcv(struct sk_buff *skb, { struct pppoe_hdr *ph; struct pppox_sock *po; + struct sock *sk; + int ret; if (!pskb_may_pull(skb, sizeof(struct pppoe_hdr))) goto drop; @@ -393,8 +395,24 @@ static int pppoe_rcv(struct sk_buff *skb, ph = (struct pppoe_hdr *) skb->nh.raw; po = get_item((unsigned long) ph->sid, eth_hdr(skb)->h_source); - if (po != NULL) - return sk_receive_skb(sk_pppox(po), skb); + if (!po) + goto drop; + + sk = sk_pppox(po); + bh_lock_sock(sk); + + /* Socket state is unknown, must put skb into backlog. */ + if (sock_owned_by_user(sk) != 0) { + sk_add_backlog(sk, skb); + ret = NET_RX_SUCCESS; + } else { + ret = pppoe_rcv_core(sk, skb); + } + + bh_unlock_sock(sk); + sock_put(sk); + + return ret; drop: kfree_skb(skb); out: @@ -1063,7 +1081,9 @@ static int __init pppoe_proc_init(void) static inline int pppoe_proc_init(void) { return 0; } #endif /* CONFIG_PROC_FS */ -static const struct proto_ops pppoe_ops = { +/* ->ioctl are set at pppox_create */ + +static struct proto_ops pppoe_ops = { .family = AF_PPPOX, .owner = THIS_MODULE, .release = pppoe_release, @@ -1079,8 +1099,7 @@ static const struct proto_ops pppoe_ops = { .getsockopt = sock_no_getsockopt, .sendmsg = pppoe_sendmsg, .recvmsg = pppoe_recvmsg, - .mmap = sock_no_mmap, - .ioctl = pppox_ioctl, + .mmap = sock_no_mmap }; static struct pppox_proto pppoe_proto = { diff --git a/trunk/drivers/net/pppox.c b/trunk/drivers/net/pppox.c index 9315046b3f55..0c1e114527fb 100644 --- a/trunk/drivers/net/pppox.c +++ b/trunk/drivers/net/pppox.c @@ -68,7 +68,8 @@ EXPORT_SYMBOL(register_pppox_proto); EXPORT_SYMBOL(unregister_pppox_proto); EXPORT_SYMBOL(pppox_unbind_sock); -int pppox_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) +static int pppox_ioctl(struct socket* sock, unsigned int cmd, + unsigned long arg) { struct sock *sk = sock->sk; struct pppox_sock *po = pppox_sk(sk); @@ -104,7 +105,6 @@ int pppox_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) return rc; } -EXPORT_SYMBOL(pppox_ioctl); static int pppox_create(struct socket *sock, int protocol) { @@ -119,7 +119,11 @@ static int pppox_create(struct socket *sock, int protocol) goto out; rc = pppox_protos[protocol]->create(sock); - + if (!rc) { + /* We get to set the ioctl handler. */ + /* For everything else, pppox is just a shell. */ + sock->ops->ioctl = pppox_ioctl; + } module_put(pppox_protos[protocol]->owner); out: return rc; diff --git a/trunk/drivers/net/s2io.c b/trunk/drivers/net/s2io.c index 89c46787676c..669dd52c412a 100644 --- a/trunk/drivers/net/s2io.c +++ b/trunk/drivers/net/s2io.c @@ -66,7 +66,7 @@ #include "s2io.h" #include "s2io-regs.h" -#define DRV_VERSION "Version 2.0.9.4" +#define DRV_VERSION "Version 2.0.9.3" /* S2io Driver name & version. */ static char s2io_driver_name[] = "Neterion"; @@ -412,7 +412,7 @@ static int init_shared_mem(struct s2io_nic *nic) config->tx_cfg[i].fifo_len - 1; mac_control->fifos[i].fifo_no = i; mac_control->fifos[i].nic = nic; - mac_control->fifos[i].max_txds = MAX_SKB_FRAGS + 2; + mac_control->fifos[i].max_txds = MAX_SKB_FRAGS + 1; for (j = 0; j < page_num; j++) { int k = 0; @@ -459,10 +459,6 @@ static int init_shared_mem(struct s2io_nic *nic) } } - nic->ufo_in_band_v = kmalloc((sizeof(u64) * size), GFP_KERNEL); - if (!nic->ufo_in_band_v) - return -ENOMEM; - /* Allocation and initialization of RXDs in Rings */ size = 0; for (i = 0; i < config->rx_ring_num; i++) { @@ -735,8 +731,6 @@ static void free_shared_mem(struct s2io_nic *nic) mac_control->stats_mem, mac_control->stats_mem_phy); } - if (nic->ufo_in_band_v) - kfree(nic->ufo_in_band_v); } /** @@ -2009,49 +2003,6 @@ static int start_nic(struct s2io_nic *nic) return SUCCESS; } -/** - * s2io_txdl_getskb - Get the skb from txdl, unmap and return skb - */ -static struct sk_buff *s2io_txdl_getskb(fifo_info_t *fifo_data, TxD_t *txdlp, int get_off) -{ - nic_t *nic = fifo_data->nic; - struct sk_buff *skb; - TxD_t *txds; - u16 j, frg_cnt; - - txds = txdlp; - if (txds->Host_Control == (u64)(long)nic->ufo_in_band_v) { - pci_unmap_single(nic->pdev, (dma_addr_t) - txds->Buffer_Pointer, sizeof(u64), - PCI_DMA_TODEVICE); - txds++; - } - - skb = (struct sk_buff *) ((unsigned long) - txds->Host_Control); - if (!skb) { - memset(txdlp, 0, (sizeof(TxD_t) * fifo_data->max_txds)); - return NULL; - } - pci_unmap_single(nic->pdev, (dma_addr_t) - txds->Buffer_Pointer, - skb->len - skb->data_len, - PCI_DMA_TODEVICE); - frg_cnt = skb_shinfo(skb)->nr_frags; - if (frg_cnt) { - txds++; - for (j = 0; j < frg_cnt; j++, txds++) { - skb_frag_t *frag = &skb_shinfo(skb)->frags[j]; - if (!txds->Buffer_Pointer) - break; - pci_unmap_page(nic->pdev, (dma_addr_t) - txds->Buffer_Pointer, - frag->size, PCI_DMA_TODEVICE); - } - } - txdlp->Host_Control = 0; - return(skb); -} /** * free_tx_buffers - Free all queued Tx buffers @@ -2069,7 +2020,7 @@ static void free_tx_buffers(struct s2io_nic *nic) int i, j; mac_info_t *mac_control; struct config_param *config; - int cnt = 0; + int cnt = 0, frg_cnt; mac_control = &nic->mac_control; config = &nic->config; @@ -2078,11 +2029,38 @@ static void free_tx_buffers(struct s2io_nic *nic) for (j = 0; j < config->tx_cfg[i].fifo_len - 1; j++) { txdp = (TxD_t *) mac_control->fifos[i].list_info[j]. list_virt_addr; - skb = s2io_txdl_getskb(&mac_control->fifos[i], txdp, j); - if (skb) { - dev_kfree_skb(skb); - cnt++; + skb = + (struct sk_buff *) ((unsigned long) txdp-> + Host_Control); + if (skb == NULL) { + memset(txdp, 0, sizeof(TxD_t) * + config->max_txds); + continue; + } + frg_cnt = skb_shinfo(skb)->nr_frags; + pci_unmap_single(nic->pdev, (dma_addr_t) + txdp->Buffer_Pointer, + skb->len - skb->data_len, + PCI_DMA_TODEVICE); + if (frg_cnt) { + TxD_t *temp; + temp = txdp; + txdp++; + for (j = 0; j < frg_cnt; j++, txdp++) { + skb_frag_t *frag = + &skb_shinfo(skb)->frags[j]; + pci_unmap_page(nic->pdev, + (dma_addr_t) + txdp-> + Buffer_Pointer, + frag->size, + PCI_DMA_TODEVICE); + } + txdp = temp; } + dev_kfree_skb(skb); + memset(txdp, 0, sizeof(TxD_t) * config->max_txds); + cnt++; } DBG_PRINT(INTR_DBG, "%s:forcibly freeing %d skbs on FIFO%d\n", @@ -2683,6 +2661,7 @@ static void tx_intr_handler(fifo_info_t *fifo_data) tx_curr_get_info_t get_info, put_info; struct sk_buff *skb; TxD_t *txdlp; + u16 j, frg_cnt; get_info = fifo_data->tx_curr_get_info; put_info = fifo_data->tx_curr_put_info; @@ -2705,7 +2684,8 @@ to loss of link\n"); } } - skb = s2io_txdl_getskb(fifo_data, txdlp, get_info.offset); + skb = (struct sk_buff *) ((unsigned long) + txdlp->Host_Control); if (skb == NULL) { DBG_PRINT(ERR_DBG, "%s: Null skb ", __FUNCTION__); @@ -2713,6 +2693,34 @@ to loss of link\n"); return; } + frg_cnt = skb_shinfo(skb)->nr_frags; + nic->tx_pkt_count++; + + pci_unmap_single(nic->pdev, (dma_addr_t) + txdlp->Buffer_Pointer, + skb->len - skb->data_len, + PCI_DMA_TODEVICE); + if (frg_cnt) { + TxD_t *temp; + temp = txdlp; + txdlp++; + for (j = 0; j < frg_cnt; j++, txdlp++) { + skb_frag_t *frag = + &skb_shinfo(skb)->frags[j]; + if (!txdlp->Buffer_Pointer) + break; + pci_unmap_page(nic->pdev, + (dma_addr_t) + txdlp-> + Buffer_Pointer, + frag->size, + PCI_DMA_TODEVICE); + } + txdlp = temp; + } + memset(txdlp, 0, + (sizeof(TxD_t) * fifo_data->max_txds)); + /* Updating the statistics block */ nic->stats.tx_bytes += skb->len; dev_kfree_skb_irq(skb); @@ -3323,7 +3331,7 @@ failed\n", dev->name); s2io_msix_fifo_handle, 0, sp->desc1, sp->s2io_entries[i].arg); DBG_PRINT(ERR_DBG, "%s @ 0x%llx\n", sp->desc1, - (unsigned long long)sp->msix_info[i].addr); + sp->msix_info[i].addr); } else { sprintf(sp->desc2, "%s:MSI-X-%d-RX", dev->name, i); @@ -3331,7 +3339,7 @@ failed\n", dev->name); s2io_msix_ring_handle, 0, sp->desc2, sp->s2io_entries[i].arg); DBG_PRINT(ERR_DBG, "%s @ 0x%llx\n", sp->desc2, - (unsigned long long)sp->msix_info[i].addr); + sp->msix_info[i].addr); } if (err) { DBG_PRINT(ERR_DBG, "%s: MSI-X-%d registration \ @@ -3519,8 +3527,6 @@ static int s2io_xmit(struct sk_buff *skb, struct net_device *dev) return 0; } - txdp->Control_1 = 0; - txdp->Control_2 = 0; #ifdef NETIF_F_TSO mss = skb_shinfo(skb)->tso_size; if (mss) { @@ -3528,13 +3534,19 @@ static int s2io_xmit(struct sk_buff *skb, struct net_device *dev) txdp->Control_1 |= TXD_TCP_LSO_MSS(mss); } #endif + + frg_cnt = skb_shinfo(skb)->nr_frags; + frg_len = skb->len - skb->data_len; + + txdp->Buffer_Pointer = pci_map_single + (sp->pdev, skb->data, frg_len, PCI_DMA_TODEVICE); + txdp->Host_Control = (unsigned long) skb; if (skb->ip_summed == CHECKSUM_HW) { txdp->Control_2 |= (TXD_TX_CKO_IPV4_EN | TXD_TX_CKO_TCP_EN | TXD_TX_CKO_UDP_EN); } - txdp->Control_1 |= TXD_GATHER_CODE_FIRST; - txdp->Control_1 |= TXD_LIST_OWN_XENA; + txdp->Control_2 |= config->tx_intr_type; if (sp->vlgrp && vlan_tx_tag_present(skb)) { @@ -3542,40 +3554,10 @@ static int s2io_xmit(struct sk_buff *skb, struct net_device *dev) txdp->Control_2 |= TXD_VLAN_TAG(vlan_tag); } - frg_len = skb->len - skb->data_len; - if (skb_shinfo(skb)->ufo_size) { - int ufo_size; - - ufo_size = skb_shinfo(skb)->ufo_size; - ufo_size &= ~7; - txdp->Control_1 |= TXD_UFO_EN; - txdp->Control_1 |= TXD_UFO_MSS(ufo_size); - txdp->Control_1 |= TXD_BUFFER0_SIZE(8); -#ifdef __BIG_ENDIAN - sp->ufo_in_band_v[put_off] = - (u64)skb_shinfo(skb)->ip6_frag_id; -#else - sp->ufo_in_band_v[put_off] = - (u64)skb_shinfo(skb)->ip6_frag_id << 32; -#endif - txdp->Host_Control = (unsigned long)sp->ufo_in_band_v; - txdp->Buffer_Pointer = pci_map_single(sp->pdev, - sp->ufo_in_band_v, - sizeof(u64), PCI_DMA_TODEVICE); - txdp++; - txdp->Control_1 = 0; - txdp->Control_2 = 0; - } - - txdp->Buffer_Pointer = pci_map_single - (sp->pdev, skb->data, frg_len, PCI_DMA_TODEVICE); - txdp->Host_Control = (unsigned long) skb; - txdp->Control_1 |= TXD_BUFFER0_SIZE(frg_len); - - if (skb_shinfo(skb)->ufo_size) - txdp->Control_1 |= TXD_UFO_EN; + txdp->Control_1 |= (TXD_BUFFER0_SIZE(frg_len) | + TXD_GATHER_CODE_FIRST); + txdp->Control_1 |= TXD_LIST_OWN_XENA; - frg_cnt = skb_shinfo(skb)->nr_frags; /* For fragmented SKB. */ for (i = 0; i < frg_cnt; i++) { skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; @@ -3587,14 +3569,9 @@ static int s2io_xmit(struct sk_buff *skb, struct net_device *dev) (sp->pdev, frag->page, frag->page_offset, frag->size, PCI_DMA_TODEVICE); txdp->Control_1 |= TXD_BUFFER0_SIZE(frag->size); - if (skb_shinfo(skb)->ufo_size) - txdp->Control_1 |= TXD_UFO_EN; } txdp->Control_1 |= TXD_GATHER_CODE_LAST; - if (skb_shinfo(skb)->ufo_size) - frg_cnt++; /* as Txd0 was used for inband header */ - tx_fifo = mac_control->tx_FIFO_start[queue]; val64 = mac_control->fifos[queue].list_info[put_off].list_phy_addr; writeq(val64, &tx_fifo->TxDL_Pointer); @@ -3606,8 +3583,6 @@ static int s2io_xmit(struct sk_buff *skb, struct net_device *dev) if (mss) val64 |= TX_FIFO_SPECIAL_FUNC; #endif - if (skb_shinfo(skb)->ufo_size) - val64 |= TX_FIFO_SPECIAL_FUNC; writeq(val64, &tx_fifo->List_Control); mmiowb(); @@ -4746,10 +4721,7 @@ static int s2io_eeprom_test(nic_t * sp, uint64_t * data) fail = 1; if (ret_data != 0x012345) { - DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x4F0. " - "Data written %llx Data read %llx\n", - dev->name, (unsigned long long)0x12345, - (unsigned long long)ret_data); + DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x4F0. Data written %llx Data read %llx\n", dev->name, (u64)0x12345, ret_data); fail = 1; } @@ -4768,10 +4740,7 @@ static int s2io_eeprom_test(nic_t * sp, uint64_t * data) fail = 1; if (ret_data != 0x012345) { - DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x7F0. " - "Data written %llx Data read %llx\n", - dev->name, (unsigned long long)0x12345, - (unsigned long long)ret_data); + DBG_PRINT(ERR_DBG, "%s: eeprom test error at offset 0x7F0. Data written %llx Data read %llx\n", dev->name, (u64)0x12345, ret_data); fail = 1; } @@ -5221,8 +5190,6 @@ static struct ethtool_ops netdev_ethtool_ops = { .get_tso = ethtool_op_get_tso, .set_tso = ethtool_op_set_tso, #endif - .get_ufo = ethtool_op_get_ufo, - .set_ufo = ethtool_op_set_ufo, .self_test_count = s2io_ethtool_self_test_count, .self_test = s2io_ethtool_test, .get_strings = s2io_ethtool_get_strings, @@ -5974,8 +5941,7 @@ Defaulting to INTA\n"); break; } } - /* + 2 because one Txd for skb->data and one Txd for UFO */ - config->max_txds = MAX_SKB_FRAGS + 2; + config->max_txds = MAX_SKB_FRAGS + 1; /* Rx side parameters. */ if (rx_ring_sz[0] == 0) @@ -6069,10 +6035,6 @@ Defaulting to INTA\n"); #ifdef NETIF_F_TSO dev->features |= NETIF_F_TSO; #endif - if (sp->device_type & XFRAME_II_DEVICE) { - dev->features |= NETIF_F_UFO; - dev->features |= NETIF_F_HW_CSUM; - } dev->tx_timeout = &s2io_tx_watchdog; dev->watchdog_timeo = WATCH_DOG_TIMEOUT; diff --git a/trunk/drivers/net/s2io.h b/trunk/drivers/net/s2io.h index 852a6a899d07..419aad7f10e7 100644 --- a/trunk/drivers/net/s2io.h +++ b/trunk/drivers/net/s2io.h @@ -393,9 +393,7 @@ typedef struct _TxD { #define TXD_GATHER_CODE_LAST BIT(23) #define TXD_TCP_LSO_EN BIT(30) #define TXD_UDP_COF_EN BIT(31) -#define TXD_UFO_EN BIT(31) | BIT(30) #define TXD_TCP_LSO_MSS(val) vBIT(val,34,14) -#define TXD_UFO_MSS(val) vBIT(val,34,14) #define TXD_BUFFER0_SIZE(val) vBIT(val,48,16) u64 Control_2; @@ -791,7 +789,6 @@ struct s2io_nic { spinlock_t rx_lock; atomic_t isr_cnt; - u64 *ufo_in_band_v; }; #define RESET_ERROR 1; diff --git a/trunk/drivers/net/sis900.c b/trunk/drivers/net/sis900.c index 3d95fa20cd88..1d4d88680db1 100644 --- a/trunk/drivers/net/sis900.c +++ b/trunk/drivers/net/sis900.c @@ -1,6 +1,6 @@ /* sis900.c: A SiS 900/7016 PCI Fast Ethernet driver for Linux. Copyright 1999 Silicon Integrated System Corporation - Revision: 1.08.09 Sep. 19 2005 + Revision: 1.08.08 Jan. 22 2005 Modified from the driver which is originally written by Donald Becker. @@ -17,7 +17,6 @@ SiS 7014 Single Chip 100BASE-TX/10BASE-T Physical Layer Solution, preliminary Rev. 1.0 Jan. 18, 1998 - Rev 1.08.09 Sep. 19 2005 Daniele Venzano add Wake on LAN support Rev 1.08.08 Jan. 22 2005 Daniele Venzano use netif_msg for debugging messages Rev 1.08.07 Nov. 2 2003 Daniele Venzano add suspend/resume support Rev 1.08.06 Sep. 24 2002 Mufasa Yang bug fix for Tx timeout & add SiS963 support @@ -77,7 +76,7 @@ #include "sis900.h" #define SIS900_MODULE_NAME "sis900" -#define SIS900_DRV_VERSION "v1.08.09 Sep. 19 2005" +#define SIS900_DRV_VERSION "v1.08.08 Jan. 22 2005" static char version[] __devinitdata = KERN_INFO "sis900.c: " SIS900_DRV_VERSION "\n"; @@ -539,11 +538,6 @@ static int __devinit sis900_probe(struct pci_dev *pci_dev, printk("%2.2x:", (u8)net_dev->dev_addr[i]); printk("%2.2x.\n", net_dev->dev_addr[i]); - /* Detect Wake on Lan support */ - ret = inl(CFGPMC & PMESP); - if (netif_msg_probe(sis_priv) && (ret & PME_D3C) == 0) - printk(KERN_INFO "%s: Wake on LAN only available from suspend to RAM.", net_dev->name); - return 0; err_unmap_rx: @@ -2021,67 +2015,6 @@ static int sis900_nway_reset(struct net_device *net_dev) return mii_nway_restart(&sis_priv->mii_info); } -/** - * sis900_set_wol - Set up Wake on Lan registers - * @net_dev: the net device to probe - * @wol: container for info passed to the driver - * - * Process ethtool command "wol" to setup wake on lan features. - * SiS900 supports sending WoL events if a correct packet is received, - * but there is no simple way to filter them to only a subset (broadcast, - * multicast, unicast or arp). - */ - -static int sis900_set_wol(struct net_device *net_dev, struct ethtool_wolinfo *wol) -{ - struct sis900_private *sis_priv = net_dev->priv; - long pmctrl_addr = net_dev->base_addr + pmctrl; - u32 cfgpmcsr = 0, pmctrl_bits = 0; - - if (wol->wolopts == 0) { - pci_read_config_dword(sis_priv->pci_dev, CFGPMCSR, &cfgpmcsr); - cfgpmcsr |= ~PME_EN; - pci_write_config_dword(sis_priv->pci_dev, CFGPMCSR, cfgpmcsr); - outl(pmctrl_bits, pmctrl_addr); - if (netif_msg_wol(sis_priv)) - printk(KERN_DEBUG "%s: Wake on LAN disabled\n", net_dev->name); - return 0; - } - - if (wol->wolopts & (WAKE_MAGICSECURE | WAKE_UCAST | WAKE_MCAST - | WAKE_BCAST | WAKE_ARP)) - return -EINVAL; - - if (wol->wolopts & WAKE_MAGIC) - pmctrl_bits |= MAGICPKT; - if (wol->wolopts & WAKE_PHY) - pmctrl_bits |= LINKON; - - outl(pmctrl_bits, pmctrl_addr); - - pci_read_config_dword(sis_priv->pci_dev, CFGPMCSR, &cfgpmcsr); - cfgpmcsr |= PME_EN; - pci_write_config_dword(sis_priv->pci_dev, CFGPMCSR, cfgpmcsr); - if (netif_msg_wol(sis_priv)) - printk(KERN_DEBUG "%s: Wake on LAN enabled\n", net_dev->name); - - return 0; -} - -static void sis900_get_wol(struct net_device *net_dev, struct ethtool_wolinfo *wol) -{ - long pmctrl_addr = net_dev->base_addr + pmctrl; - u32 pmctrl_bits; - - pmctrl_bits = inl(pmctrl_addr); - if (pmctrl_bits & MAGICPKT) - wol->wolopts |= WAKE_MAGIC; - if (pmctrl_bits & LINKON) - wol->wolopts |= WAKE_PHY; - - wol->supported = (WAKE_PHY | WAKE_MAGIC); -} - static struct ethtool_ops sis900_ethtool_ops = { .get_drvinfo = sis900_get_drvinfo, .get_msglevel = sis900_get_msglevel, @@ -2090,8 +2023,6 @@ static struct ethtool_ops sis900_ethtool_ops = { .get_settings = sis900_get_settings, .set_settings = sis900_set_settings, .nway_reset = sis900_nway_reset, - .get_wol = sis900_get_wol, - .set_wol = sis900_set_wol }; /** diff --git a/trunk/drivers/net/sis900.h b/trunk/drivers/net/sis900.h index 4233ea55670f..de3c06735d15 100644 --- a/trunk/drivers/net/sis900.h +++ b/trunk/drivers/net/sis900.h @@ -33,7 +33,6 @@ enum sis900_registers { rxcfg=0x34, //Receive Configuration Register flctrl=0x38, //Flow Control Register rxlen=0x3c, //Receive Packet Length Register - cfgpmcsr=0x44, //Configuration Power Management Control/Status Register rfcr=0x48, //Receive Filter Control Register rfdr=0x4C, //Receive Filter Data Register pmctrl=0xB0, //Power Management Control Register @@ -141,50 +140,6 @@ enum sis96x_eeprom_command { EEREQ = 0x00000400, EEDONE = 0x00000200, EEGNT = 0x00000100 }; -/* PCI Registers */ -enum sis900_pci_registers { - CFGPMC = 0x40, - CFGPMCSR = 0x44 -}; - -/* Power management capabilities bits */ -enum sis900_cfgpmc_register_bits { - PMVER = 0x00070000, - DSI = 0x00100000, - PMESP = 0xf8000000 -}; - -enum sis900_pmesp_bits { - PME_D0 = 0x1, - PME_D1 = 0x2, - PME_D2 = 0x4, - PME_D3H = 0x8, - PME_D3C = 0x10 -}; - -/* Power management control/status bits */ -enum sis900_cfgpmcsr_register_bits { - PMESTS = 0x00004000, - PME_EN = 0x00000100, // Power management enable - PWR_STA = 0x00000003 // Current power state -}; - -/* Wake-on-LAN support. */ -enum sis900_power_management_control_register_bits { - LINKLOSS = 0x00000001, - LINKON = 0x00000002, - MAGICPKT = 0x00000400, - ALGORITHM = 0x00000800, - FRM1EN = 0x00100000, - FRM2EN = 0x00200000, - FRM3EN = 0x00400000, - FRM1ACS = 0x01000000, - FRM2ACS = 0x02000000, - FRM3ACS = 0x04000000, - WAKEALL = 0x40000000, - GATECLK = 0x80000000 -}; - /* Management Data I/O (mdio) frame */ #define MIIread 0x6000 #define MIIwrite 0x5002 diff --git a/trunk/drivers/net/sk98lin/Makefile b/trunk/drivers/net/sk98lin/Makefile index afd900d5d730..7653d6e33aa2 100644 --- a/trunk/drivers/net/sk98lin/Makefile +++ b/trunk/drivers/net/sk98lin/Makefile @@ -26,7 +26,8 @@ sk98lin-objs := \ skrlmt.o \ sktimer.o \ skvpd.o \ - skxmac2.o + skxmac2.o \ + skproc.o # DBGDEF = \ # -DDEBUG diff --git a/trunk/drivers/net/sk98lin/h/skdrv2nd.h b/trunk/drivers/net/sk98lin/h/skdrv2nd.h index 778d9e618ebd..2dc5728e3ef6 100644 --- a/trunk/drivers/net/sk98lin/h/skdrv2nd.h +++ b/trunk/drivers/net/sk98lin/h/skdrv2nd.h @@ -60,6 +60,7 @@ extern SK_U64 SkOsGetTime(SK_AC*); extern int SkPciReadCfgDWord(SK_AC*, int, SK_U32*); extern int SkPciReadCfgWord(SK_AC*, int, SK_U16*); extern int SkPciReadCfgByte(SK_AC*, int, SK_U8*); +extern int SkPciWriteCfgDWord(SK_AC*, int, SK_U32); extern int SkPciWriteCfgWord(SK_AC*, int, SK_U16); extern int SkPciWriteCfgByte(SK_AC*, int, SK_U8); extern int SkDrvEvent(SK_AC*, SK_IOC IoC, SK_U32, SK_EVPARA); @@ -267,6 +268,8 @@ typedef struct s_DevNet DEV_NET; struct s_DevNet { int PortNr; int NetNr; + int Mtu; + int Up; SK_AC *pAC; }; @@ -295,7 +298,6 @@ struct s_RxPort { RXD *pRxdRingTail; /* Tail of Rx rings */ RXD *pRxdRingPrev; /* descriptor given to BMU previously */ int RxdRingFree; /* # of free entrys */ - int RxCsum; /* use receive checksum hardware */ spinlock_t RxDesRingLock; /* serialize descriptor accesses */ int RxFillLimit; /* limit for buffers in ring */ SK_IOC HwAddr; /* bmu registers address */ @@ -388,10 +390,12 @@ struct s_AC { SK_IOC IoBase; /* register set of adapter */ int BoardLevel; /* level of active hw init (0-2) */ - + char DeviceStr[80]; /* adapter string from vpd */ SK_U32 AllocFlag; /* flag allocation of resources */ struct pci_dev *PciDev; /* for access to pci config space */ + SK_U32 PciDevId; /* pci device id */ struct SK_NET_DEVICE *dev[2]; /* pointer to device struct */ + char Name[30]; /* driver name */ int RxBufSize; /* length of receive buffers */ struct net_device_stats stats; /* linux 'netstat -i' statistics */ @@ -426,6 +430,7 @@ struct s_AC { DIM_INFO DynIrqModInfo; /* all data related to DIM */ /* Only for tests */ + int PortUp; int PortDown; int ChipsetType; /* Chipset family type * 0 == Genesis family support diff --git a/trunk/drivers/net/sk98lin/h/skvpd.h b/trunk/drivers/net/sk98lin/h/skvpd.h index daa9a8d154fc..bdc1a5eaaae9 100644 --- a/trunk/drivers/net/sk98lin/h/skvpd.h +++ b/trunk/drivers/net/sk98lin/h/skvpd.h @@ -130,12 +130,14 @@ typedef struct s_vpd_key { #ifndef VPD_DO_IO #define VPD_OUT8(pAC,IoC,Addr,Val) (void)SkPciWriteCfgByte(pAC,Addr,Val) #define VPD_OUT16(pAC,IoC,Addr,Val) (void)SkPciWriteCfgWord(pAC,Addr,Val) +#define VPD_OUT32(pAC,IoC,Addr,Val) (void)SkPciWriteCfgDWord(pAC,Addr,Val) #define VPD_IN8(pAC,IoC,Addr,pVal) (void)SkPciReadCfgByte(pAC,Addr,pVal) #define VPD_IN16(pAC,IoC,Addr,pVal) (void)SkPciReadCfgWord(pAC,Addr,pVal) #define VPD_IN32(pAC,IoC,Addr,pVal) (void)SkPciReadCfgDWord(pAC,Addr,pVal) #else /* VPD_DO_IO */ #define VPD_OUT8(pAC,IoC,Addr,Val) SK_OUT8(IoC,PCI_C(Addr),Val) #define VPD_OUT16(pAC,IoC,Addr,Val) SK_OUT16(IoC,PCI_C(Addr),Val) +#define VPD_OUT32(pAC,IoC,Addr,Val) SK_OUT32(IoC,PCI_C(Addr),Val) #define VPD_IN8(pAC,IoC,Addr,pVal) SK_IN8(IoC,PCI_C(Addr),pVal) #define VPD_IN16(pAC,IoC,Addr,pVal) SK_IN16(IoC,PCI_C(Addr),pVal) #define VPD_IN32(pAC,IoC,Addr,pVal) SK_IN32(IoC,PCI_C(Addr),pVal) @@ -153,6 +155,12 @@ typedef struct s_vpd_key { else \ SK_OUT16(pAC,PCI_C(Addr),Val); \ } +#define VPD_OUT32(pAC,Ioc,Addr,Val) { \ + if ((pAC)->DgT.DgUseCfgCycle) \ + SkPciWriteCfgDWord(pAC,Addr,Val); \ + else \ + SK_OUT32(pAC,PCI_C(Addr),Val); \ + } #define VPD_IN8(pAC,Ioc,Addr,pVal) { \ if ((pAC)->DgT.DgUseCfgCycle) \ SkPciReadCfgByte(pAC,Addr,pVal); \ diff --git a/trunk/drivers/net/sk98lin/skethtool.c b/trunk/drivers/net/sk98lin/skethtool.c index 4265ed91a9c4..b71769ae4603 100644 --- a/trunk/drivers/net/sk98lin/skethtool.c +++ b/trunk/drivers/net/sk98lin/skethtool.c @@ -539,48 +539,6 @@ static int setPauseParams(struct net_device *dev , struct ethtool_pauseparam *ep return ret ? -EIO : 0; } -/* Only Yukon supports checksum offload. */ -static int setScatterGather(struct net_device *dev, u32 data) -{ - DEV_NET *pNet = netdev_priv(dev); - SK_AC *pAC = pNet->pAC; - - if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) - return -EOPNOTSUPP; - return ethtool_op_set_sg(dev, data); -} - -static int setTxCsum(struct net_device *dev, u32 data) -{ - DEV_NET *pNet = netdev_priv(dev); - SK_AC *pAC = pNet->pAC; - - if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) - return -EOPNOTSUPP; - - return ethtool_op_set_tx_csum(dev, data); -} - -static u32 getRxCsum(struct net_device *dev) -{ - DEV_NET *pNet = netdev_priv(dev); - SK_AC *pAC = pNet->pAC; - - return pAC->RxPort[pNet->PortNr].RxCsum; -} - -static int setRxCsum(struct net_device *dev, u32 data) -{ - DEV_NET *pNet = netdev_priv(dev); - SK_AC *pAC = pNet->pAC; - - if (pAC->GIni.GIChipId == CHIP_ID_GENESIS) - return -EOPNOTSUPP; - - pAC->RxPort[pNet->PortNr].RxCsum = data != 0; - return 0; -} - struct ethtool_ops SkGeEthtoolOps = { .get_settings = getSettings, .set_settings = setSettings, @@ -593,10 +551,4 @@ struct ethtool_ops SkGeEthtoolOps = { .set_pauseparam = setPauseParams, .get_link = ethtool_op_get_link, .get_perm_addr = ethtool_op_get_perm_addr, - .get_sg = ethtool_op_get_sg, - .set_sg = setScatterGather, - .get_tx_csum = ethtool_op_get_tx_csum, - .set_tx_csum = setTxCsum, - .get_rx_csum = getRxCsum, - .set_rx_csum = setRxCsum, }; diff --git a/trunk/drivers/net/sk98lin/skge.c b/trunk/drivers/net/sk98lin/skge.c index 9a76ac180b11..ae7343934758 100644 --- a/trunk/drivers/net/sk98lin/skge.c +++ b/trunk/drivers/net/sk98lin/skge.c @@ -107,10 +107,10 @@ #include "h/skversion.h" -#include #include #include #include +#include #include #include @@ -206,6 +206,7 @@ static void SkGeSetRxMode(struct SK_NET_DEVICE *dev); static struct net_device_stats *SkGeStats(struct SK_NET_DEVICE *dev); static int SkGeIoctl(struct SK_NET_DEVICE *dev, struct ifreq *rq, int cmd); static void GetConfiguration(SK_AC*); +static void ProductStr(SK_AC*); static int XmitFrame(SK_AC*, TX_PORT*, struct sk_buff*); static void FreeTxDescriptors(SK_AC*pAC, TX_PORT*); static void FillRxRing(SK_AC*, RX_PORT*); @@ -234,6 +235,28 @@ static int SkDrvDeInitAdapter(SK_AC *pAC, int devNbr); * Extern Function Prototypes * ******************************************************************************/ +static const char SKRootName[] = "net/sk98lin"; +static struct proc_dir_entry *pSkRootDir; +extern struct file_operations sk_proc_fops; + +static inline void SkGeProcCreate(struct net_device *dev) +{ + struct proc_dir_entry *pe; + + if (pSkRootDir && + (pe = create_proc_entry(dev->name, S_IRUGO, pSkRootDir))) { + pe->proc_fops = &sk_proc_fops; + pe->data = dev; + pe->owner = THIS_MODULE; + } +} + +static inline void SkGeProcRemove(struct net_device *dev) +{ + if (pSkRootDir) + remove_proc_entry(dev->name, pSkRootDir); +} + extern void SkDimEnableModerationIfNeeded(SK_AC *pAC); extern void SkDimDisplayModerationSettings(SK_AC *pAC); extern void SkDimStartModerationTimer(SK_AC *pAC); @@ -254,27 +277,6 @@ extern struct ethtool_ops SkGeEthtoolOps; static uintptr_t TxQueueAddr[SK_MAX_MACS][2] = {{0x680, 0x600},{0x780, 0x700}}; static uintptr_t RxQueueAddr[SK_MAX_MACS] = {0x400, 0x480}; -/***************************************************************************** - * - * SkPciWriteCfgDWord - write a 32 bit value to pci config space - * - * Description: - * This routine writes a 32 bit value to the pci configuration - * space. - * - * Returns: - * 0 - indicate everything worked ok. - * != 0 - error indication - */ -static inline int SkPciWriteCfgDWord( -SK_AC *pAC, /* Adapter Control structure pointer */ -int PciAddr, /* PCI register address */ -SK_U32 Val) /* pointer to store the read value */ -{ - pci_write_config_dword(pAC->PciDev, PciAddr, Val); - return(0); -} /* SkPciWriteCfgDWord */ - /***************************************************************************** * * SkGeInitPCI - Init the PCI resources @@ -298,7 +300,7 @@ int SkGeInitPCI(SK_AC *pAC) dev->mem_start = pci_resource_start (pdev, 0); pci_set_master(pdev); - if (pci_request_regions(pdev, "sk98lin") != 0) { + if (pci_request_regions(pdev, pAC->Name) != 0) { retval = 2; goto out_disable; } @@ -576,10 +578,10 @@ SK_BOOL DualNet; spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); if (pAC->GIni.GIMacsFound == 2) { - Ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, "sk98lin", dev); + Ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, pAC->Name, dev); } else if (pAC->GIni.GIMacsFound == 1) { Ret = request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ, - "sk98lin", dev); + pAC->Name, dev); } else { printk(KERN_WARNING "sk98lin: Illegal number of ports: %d\n", pAC->GIni.GIMacsFound); @@ -1263,6 +1265,7 @@ struct SK_NET_DEVICE *dev) spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); pAC->MaxPorts++; + pNet->Up = 1; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY, @@ -1392,6 +1395,7 @@ struct SK_NET_DEVICE *dev) sizeof(SK_PNMI_STRUCT_DATA)); pAC->MaxPorts--; + pNet->Up = 0; return (0); } /* SkGeClose */ @@ -2171,6 +2175,7 @@ SK_U64 PhysAddr; pMsg->ip_summed = CHECKSUM_NONE; #endif + SK_DBG_MSG(NULL, SK_DBGMOD_DRV, 1,("V")); ForRlmt = SK_RLMT_RX_PROTOCOL; #if 0 @@ -2545,7 +2550,7 @@ unsigned long Flags; static int SkGeChangeMtu(struct SK_NET_DEVICE *dev, int NewMtu) { DEV_NET *pNet; -struct net_device *pOtherDev; +DEV_NET *pOtherNet; SK_AC *pAC; unsigned long Flags; int i; @@ -2575,11 +2580,11 @@ SK_EVPARA EvPara; } #endif - pOtherDev = pAC->dev[1 - pNet->NetNr]; - - if ( netif_running(pOtherDev) && (pOtherDev->mtu > 1500) - && (NewMtu <= 1500)) - return 0; + pNet->Mtu = NewMtu; + pOtherNet = netdev_priv(pAC->dev[1 - pNet->NetNr]); + if ((pOtherNet->Mtu>1500) && (NewMtu<=1500) && (pOtherNet->Up==1)) { + return(0); + } pAC->RxBufSize = NewMtu + 32; dev->mtu = NewMtu; @@ -2741,8 +2746,7 @@ SK_EVPARA EvPara; EvPara.Para32[1] = -1; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); - if (netif_running(pOtherDev)) { - DEV_NET *pOtherNet = netdev_priv(pOtherDev); + if (pOtherNet->Up) { EvPara.Para32[0] = pOtherNet->PortNr; SkEventQueue(pAC, SKGE_RLMT, SK_RLMT_START, EvPara); } @@ -2816,7 +2820,7 @@ unsigned long Flags; /* for spin lock */ pAC->stats.rx_bytes = (SK_U32) pPnmiStruct->RxOctetsDeliveredCts; pAC->stats.tx_bytes = (SK_U32) pPnmiStat->StatTxOctetsOkCts; - if (dev->mtu <= 1500) { + if (pNet->Mtu <= 1500) { pAC->stats.rx_errors = (SK_U32) pPnmiStruct->InErrorsCts & 0xFFFFFFFF; } else { pAC->stats.rx_errors = (SK_U32) ((pPnmiStruct->InErrorsCts - @@ -3767,21 +3771,25 @@ int Capabilities[3][3] = * * Returns: N/A */ -static inline int ProductStr( - SK_AC *pAC, /* pointer to adapter context */ - char *DeviceStr, /* result string */ - int StrLen /* length of the string */ +static void ProductStr( +SK_AC *pAC /* pointer to adapter context */ ) { +int StrLen = 80; /* length of the string, defined in SK_AC */ char Keyword[] = VPD_NAME; /* vpd productname identifier */ int ReturnCode; /* return code from vpd_read */ unsigned long Flags; spin_lock_irqsave(&pAC->SlowPathLock, Flags); - ReturnCode = VpdRead(pAC, pAC->IoBase, Keyword, DeviceStr, &StrLen); + ReturnCode = VpdRead(pAC, pAC->IoBase, Keyword, pAC->DeviceStr, + &StrLen); spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); - - return ReturnCode; + if (ReturnCode != 0) { + /* there was an error reading the vpd data */ + SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ERROR, + ("Error reading VPD data: %d\n", ReturnCode)); + pAC->DeviceStr[0] = '\0'; + } } /* ProductStr */ /***************************************************************************** @@ -3982,6 +3990,28 @@ SK_U8 *pVal) /* pointer to store the read value */ } /* SkPciReadCfgByte */ +/***************************************************************************** + * + * SkPciWriteCfgDWord - write a 32 bit value to pci config space + * + * Description: + * This routine writes a 32 bit value to the pci configuration + * space. + * + * Returns: + * 0 - indicate everything worked ok. + * != 0 - error indication + */ +int SkPciWriteCfgDWord( +SK_AC *pAC, /* Adapter Control structure pointer */ +int PciAddr, /* PCI register address */ +SK_U32 Val) /* pointer to store the read value */ +{ + pci_write_config_dword(pAC->PciDev, PciAddr, Val); + return(0); +} /* SkPciWriteCfgDWord */ + + /***************************************************************************** * * SkPciWriteCfgWord - write a 16 bit value to pci config space @@ -4120,7 +4150,6 @@ SK_BOOL DualNet; Flags); break; case SK_DRV_NET_UP: /* SK_U32 PortIdx */ - { struct net_device *dev = pAC->dev[Param.Para32[0]]; /* action list 5 */ FromPort = Param.Para32[0]; SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, @@ -4204,12 +4233,22 @@ SK_BOOL DualNet; printk(" irq moderation: disabled\n"); - printk(" scatter-gather: %s\n", - (dev->features & NETIF_F_SG) ? "enabled" : "disabled"); - printk(" tx-checksum: %s\n", - (dev->features & NETIF_F_IP_CSUM) ? "enabled" : "disabled"); - printk(" rx-checksum: %s\n", - pAC->RxPort[Param.Para32[0]].RxCsum ? "enabled" : "disabled"); +#ifdef SK_ZEROCOPY + if (pAC->ChipsetType) +#ifdef USE_SK_TX_CHECKSUM + printk(" scatter-gather: enabled\n"); +#else + printk(" tx-checksum: disabled\n"); +#endif + else + printk(" scatter-gather: disabled\n"); +#else + printk(" scatter-gather: disabled\n"); +#endif + +#ifndef USE_SK_RX_CHECKSUM + printk(" rx-checksum: disabled\n"); +#endif } else { DoPrintInterfaceChange = SK_TRUE; @@ -4224,9 +4263,9 @@ SK_BOOL DualNet; } /* Inform the world that link protocol is up. */ - netif_carrier_on(dev); + netif_carrier_on(pAC->dev[Param.Para32[0]]); + break; - } case SK_DRV_NET_DOWN: /* SK_U32 Reason */ /* action list 7 */ SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_EVENT, @@ -4440,7 +4479,7 @@ SK_AC *pAc) /* pointer to adapter context */ pAC->DiagModeActive = DIAG_ACTIVE; if (pAC->BoardLevel > SK_INIT_DATA) { - if (netif_running(pAC->dev[0])) { + if (pNet->Up) { pAC->WasIfUp[0] = SK_TRUE; pAC->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */ DoPrintInterfaceChange = SK_FALSE; @@ -4450,7 +4489,7 @@ SK_AC *pAc) /* pointer to adapter context */ } if (pNet != netdev_priv(pAC->dev[1])) { pNet = netdev_priv(pAC->dev[1]); - if (netif_running(pAC->dev[1])) { + if (pNet->Up) { pAC->WasIfUp[1] = SK_TRUE; pAC->DiagFlowCtrl = SK_TRUE; /* for SkGeClose */ DoPrintInterfaceChange = SK_FALSE; @@ -4776,7 +4815,6 @@ static int __devinit skge_probe_one(struct pci_dev *pdev, struct net_device *dev = NULL; static int boards_found = 0; int error = -ENODEV; - char DeviceStr[80]; if (pci_enable_device(pdev)) goto out; @@ -4804,11 +4842,14 @@ static int __devinit skge_probe_one(struct pci_dev *pdev, memset(pNet->pAC, 0, sizeof(SK_AC)); pAC = pNet->pAC; pAC->PciDev = pdev; - + pAC->PciDevId = pdev->device; pAC->dev[0] = dev; pAC->dev[1] = dev; + sprintf(pAC->Name, "SysKonnect SK-98xx"); pAC->CheckQueue = SK_FALSE; + pNet->Mtu = 1500; + pNet->Up = 0; dev->irq = pdev->irq; error = SkGeInitPCI(pAC); if (error) { @@ -4831,30 +4872,21 @@ static int __devinit skge_probe_one(struct pci_dev *pdev, SET_NETDEV_DEV(dev, &pdev->dev); SET_ETHTOOL_OPS(dev, &SkGeEthtoolOps); - /* Use only if yukon hardware */ - if (pAC->ChipsetType) { -#ifdef USE_SK_TX_CHECKSUM - dev->features |= NETIF_F_IP_CSUM; -#endif #ifdef SK_ZEROCOPY - dev->features |= NETIF_F_SG; +#ifdef USE_SK_TX_CHECKSUM + if (pAC->ChipsetType) { + /* Use only if yukon hardware */ + /* SK and ZEROCOPY - fly baby... */ + dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; + } #endif -#ifdef USE_SK_RX_CHECKSUM - pAC->RxPort[0].RxCsum = 1; #endif - } pAC->Index = boards_found++; if (SkGeBoardInit(dev, pAC)) goto out_free_netdev; - /* Read Adapter name from VPD */ - if (ProductStr(pAC, DeviceStr, sizeof(DeviceStr)) != 0) { - printk(KERN_ERR "sk98lin: Could not read VPD data.\n"); - goto out_free_resources; - } - /* Register net device */ if (register_netdev(dev)) { printk(KERN_ERR "sk98lin: Could not register device.\n"); @@ -4862,7 +4894,8 @@ static int __devinit skge_probe_one(struct pci_dev *pdev, } /* Print adapter specific string from vpd */ - printk("%s: %s\n", dev->name, DeviceStr); + ProductStr(pAC); + printk("%s: %s\n", dev->name, pAC->DeviceStr); /* Print configuration settings */ printk(" PrefPort:%c RlmtMode:%s\n", @@ -4878,6 +4911,8 @@ static int __devinit skge_probe_one(struct pci_dev *pdev, memcpy(&dev->dev_addr, &pAC->Addr.Net[0].CurrentMacAddress, 6); memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len); + SkGeProcCreate(dev); + pNet->PortNr = 0; pNet->NetNr = 0; @@ -4896,6 +4931,8 @@ static int __devinit skge_probe_one(struct pci_dev *pdev, pNet->PortNr = 1; pNet->NetNr = 1; pNet->pAC = pAC; + pNet->Mtu = 1500; + pNet->Up = 0; dev->open = &SkGeOpen; dev->stop = &SkGeClose; @@ -4908,28 +4945,26 @@ static int __devinit skge_probe_one(struct pci_dev *pdev, SET_NETDEV_DEV(dev, &pdev->dev); SET_ETHTOOL_OPS(dev, &SkGeEthtoolOps); - if (pAC->ChipsetType) { -#ifdef USE_SK_TX_CHECKSUM - dev->features |= NETIF_F_IP_CSUM; -#endif #ifdef SK_ZEROCOPY - dev->features |= NETIF_F_SG; +#ifdef USE_SK_TX_CHECKSUM + if (pAC->ChipsetType) { + /* SG and ZEROCOPY - fly baby... */ + dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; + } #endif -#ifdef USE_SK_RX_CHECKSUM - pAC->RxPort[1].RxCsum = 1; #endif - } if (register_netdev(dev)) { printk(KERN_ERR "sk98lin: Could not register device for seconf port.\n"); free_netdev(dev); pAC->dev[1] = pAC->dev[0]; } else { + SkGeProcCreate(dev); memcpy(&dev->dev_addr, &pAC->Addr.Net[1].CurrentMacAddress, 6); memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len); - printk("%s: %s\n", dev->name, DeviceStr); + printk("%s: %s\n", dev->name, pAC->DeviceStr); printk(" PrefPort:B RlmtMode:Dual Check Link State\n"); } } @@ -4965,7 +5000,10 @@ static void __devexit skge_remove_one(struct pci_dev *pdev) SK_AC *pAC = pNet->pAC; struct net_device *otherdev = pAC->dev[1]; + SkGeProcRemove(dev); unregister_netdev(dev); + if (otherdev != dev) + SkGeProcRemove(otherdev); SkGeYellowLED(pAC, pAC->IoBase, 0); @@ -5050,9 +5088,9 @@ static int skge_resume(struct pci_dev *pdev) pci_enable_device(pdev); pci_set_master(pdev); if (pAC->GIni.GIMacsFound == 2) - ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, "sk98lin", dev); + ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, pAC->Name, dev); else - ret = request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ, "sk98lin", dev); + ret = request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ, pAC->Name, dev); if (ret) { printk(KERN_WARNING "sk98lin: unable to acquire IRQ %d\n", dev->irq); pAC->AllocFlag &= ~SK_ALLOC_IRQ; @@ -5110,12 +5148,23 @@ static struct pci_driver skge_driver = { static int __init skge_init(void) { - return pci_module_init(&skge_driver); + int error; + + pSkRootDir = proc_mkdir(SKRootName, NULL); + if (pSkRootDir) + pSkRootDir->owner = THIS_MODULE; + + error = pci_register_driver(&skge_driver); + if (error) + remove_proc_entry(SKRootName, NULL); + return error; } static void __exit skge_exit(void) { pci_unregister_driver(&skge_driver); + remove_proc_entry(SKRootName, NULL); + } module_init(skge_init); diff --git a/trunk/drivers/net/sk98lin/skproc.c b/trunk/drivers/net/sk98lin/skproc.c new file mode 100644 index 000000000000..5cece25c034e --- /dev/null +++ b/trunk/drivers/net/sk98lin/skproc.c @@ -0,0 +1,265 @@ +/****************************************************************************** + * + * Name: skproc.c + * Project: GEnesis, PCI Gigabit Ethernet Adapter + * Version: $Revision: 1.11 $ + * Date: $Date: 2003/12/11 16:03:57 $ + * Purpose: Funktions to display statictic data + * + ******************************************************************************/ + +/****************************************************************************** + * + * (C)Copyright 1998-2002 SysKonnect GmbH. + * (C)Copyright 2002-2003 Marvell. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * Created 22-Nov-2000 + * Author: Mirko Lindner (mlindner@syskonnect.de) + * + * The information in this file is provided "AS IS" without warranty. + * + ******************************************************************************/ +#include +#include + +#include "h/skdrv1st.h" +#include "h/skdrv2nd.h" +#include "h/skversion.h" + +static int sk_seq_show(struct seq_file *seq, void *v); +static int sk_proc_open(struct inode *inode, struct file *file); + +struct file_operations sk_proc_fops = { + .owner = THIS_MODULE, + .open = sk_proc_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + + +/***************************************************************************** + * + * sk_seq_show - show proc information of a particular adapter + * + * Description: + * This function fills the proc entry with statistic data about + * the ethernet device. It invokes the generic sk_gen_browse() to + * print out all items one per one. + * + * Returns: 0 + * + */ +static int sk_seq_show(struct seq_file *seq, void *v) +{ + struct net_device *dev = seq->private; + DEV_NET *pNet = netdev_priv(dev); + SK_AC *pAC = pNet->pAC; + SK_PNMI_STRUCT_DATA *pPnmiStruct = &pAC->PnmiStruct; + unsigned long Flags; + unsigned int Size; + char sens_msg[50]; + int t; + int i; + + /* NetIndex in GetStruct is now required, zero is only dummy */ + for (t=pAC->GIni.GIMacsFound; t > 0; t--) { + if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 1) + t--; + + spin_lock_irqsave(&pAC->SlowPathLock, Flags); + Size = SK_PNMI_STRUCT_SIZE; +#ifdef SK_DIAG_SUPPORT + if (pAC->BoardLevel == SK_INIT_DATA) { + SK_MEMCPY(&(pAC->PnmiStruct), &(pAC->PnmiBackup), sizeof(SK_PNMI_STRUCT_DATA)); + if (pAC->DiagModeActive == DIAG_NOTACTIVE) { + pAC->Pnmi.DiagAttached = SK_DIAG_IDLE; + } + } else { + SkPnmiGetStruct(pAC, pAC->IoBase, pPnmiStruct, &Size, t-1); + } +#else + SkPnmiGetStruct(pAC, pAC->IoBase, + pPnmiStruct, &Size, t-1); +#endif + spin_unlock_irqrestore(&pAC->SlowPathLock, Flags); + + if (pAC->dev[t-1] == dev) { + SK_PNMI_STAT *pPnmiStat = &pPnmiStruct->Stat[0]; + + seq_printf(seq, "\nDetailed statistic for device %s\n", + pAC->dev[t-1]->name); + seq_printf(seq, "=======================================\n"); + + /* Board statistics */ + seq_printf(seq, "\nBoard statistics\n\n"); + seq_printf(seq, "Active Port %c\n", + 'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt. + Net[t-1].PrefPort]->PortNumber); + seq_printf(seq, "Preferred Port %c\n", + 'A' + pAC->Rlmt.Net[t-1].Port[pAC->Rlmt. + Net[t-1].PrefPort]->PortNumber); + + seq_printf(seq, "Bus speed (MHz) %d\n", + pPnmiStruct->BusSpeed); + + seq_printf(seq, "Bus width (Bit) %d\n", + pPnmiStruct->BusWidth); + seq_printf(seq, "Driver version %s\n", + VER_STRING); + seq_printf(seq, "Hardware revision v%d.%d\n", + (pAC->GIni.GIPciHwRev >> 4) & 0x0F, + pAC->GIni.GIPciHwRev & 0x0F); + + /* Print sensor informations */ + for (i=0; i < pAC->I2c.MaxSens; i ++) { + /* Check type */ + switch (pAC->I2c.SenTable[i].SenType) { + case 1: + strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc); + strcat(sens_msg, " (C)"); + seq_printf(seq, "%-25s %d.%02d\n", + sens_msg, + pAC->I2c.SenTable[i].SenValue / 10, + pAC->I2c.SenTable[i].SenValue % 10); + + strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc); + strcat(sens_msg, " (F)"); + seq_printf(seq, "%-25s %d.%02d\n", + sens_msg, + ((((pAC->I2c.SenTable[i].SenValue) + *10)*9)/5 + 3200)/100, + ((((pAC->I2c.SenTable[i].SenValue) + *10)*9)/5 + 3200) % 10); + break; + case 2: + strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc); + strcat(sens_msg, " (V)"); + seq_printf(seq, "%-25s %d.%03d\n", + sens_msg, + pAC->I2c.SenTable[i].SenValue / 1000, + pAC->I2c.SenTable[i].SenValue % 1000); + break; + case 3: + strcpy(sens_msg, pAC->I2c.SenTable[i].SenDesc); + strcat(sens_msg, " (rpm)"); + seq_printf(seq, "%-25s %d\n", + sens_msg, + pAC->I2c.SenTable[i].SenValue); + break; + default: + break; + } + } + + /*Receive statistics */ + seq_printf(seq, "\nReceive statistics\n\n"); + + seq_printf(seq, "Received bytes %Lu\n", + (unsigned long long) pPnmiStat->StatRxOctetsOkCts); + seq_printf(seq, "Received packets %Lu\n", + (unsigned long long) pPnmiStat->StatRxOkCts); +#if 0 + if (pAC->GIni.GP[0].PhyType == SK_PHY_XMAC && + pAC->HWRevision < 12) { + pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts - + pPnmiStat->StatRxShortsCts; + pPnmiStat->StatRxShortsCts = 0; + } +#endif + if (dev->mtu > 1500) + pPnmiStruct->InErrorsCts = pPnmiStruct->InErrorsCts - + pPnmiStat->StatRxTooLongCts; + + seq_printf(seq, "Receive errors %Lu\n", + (unsigned long long) pPnmiStruct->InErrorsCts); + seq_printf(seq, "Receive dropped %Lu\n", + (unsigned long long) pPnmiStruct->RxNoBufCts); + seq_printf(seq, "Received multicast %Lu\n", + (unsigned long long) pPnmiStat->StatRxMulticastOkCts); + seq_printf(seq, "Receive error types\n"); + seq_printf(seq, " length %Lu\n", + (unsigned long long) pPnmiStat->StatRxRuntCts); + seq_printf(seq, " buffer overflow %Lu\n", + (unsigned long long) pPnmiStat->StatRxFifoOverflowCts); + seq_printf(seq, " bad crc %Lu\n", + (unsigned long long) pPnmiStat->StatRxFcsCts); + seq_printf(seq, " framing %Lu\n", + (unsigned long long) pPnmiStat->StatRxFramingCts); + seq_printf(seq, " missed frames %Lu\n", + (unsigned long long) pPnmiStat->StatRxMissedCts); + + if (dev->mtu > 1500) + pPnmiStat->StatRxTooLongCts = 0; + + seq_printf(seq, " too long %Lu\n", + (unsigned long long) pPnmiStat->StatRxTooLongCts); + seq_printf(seq, " carrier extension %Lu\n", + (unsigned long long) pPnmiStat->StatRxCextCts); + seq_printf(seq, " too short %Lu\n", + (unsigned long long) pPnmiStat->StatRxShortsCts); + seq_printf(seq, " symbol %Lu\n", + (unsigned long long) pPnmiStat->StatRxSymbolCts); + seq_printf(seq, " LLC MAC size %Lu\n", + (unsigned long long) pPnmiStat->StatRxIRLengthCts); + seq_printf(seq, " carrier event %Lu\n", + (unsigned long long) pPnmiStat->StatRxCarrierCts); + seq_printf(seq, " jabber %Lu\n", + (unsigned long long) pPnmiStat->StatRxJabberCts); + + + /*Transmit statistics */ + seq_printf(seq, "\nTransmit statistics\n\n"); + + seq_printf(seq, "Transmited bytes %Lu\n", + (unsigned long long) pPnmiStat->StatTxOctetsOkCts); + seq_printf(seq, "Transmited packets %Lu\n", + (unsigned long long) pPnmiStat->StatTxOkCts); + seq_printf(seq, "Transmit errors %Lu\n", + (unsigned long long) pPnmiStat->StatTxSingleCollisionCts); + seq_printf(seq, "Transmit dropped %Lu\n", + (unsigned long long) pPnmiStruct->TxNoBufCts); + seq_printf(seq, "Transmit collisions %Lu\n", + (unsigned long long) pPnmiStat->StatTxSingleCollisionCts); + seq_printf(seq, "Transmit error types\n"); + seq_printf(seq, " excessive collision %ld\n", + pAC->stats.tx_aborted_errors); + seq_printf(seq, " carrier %Lu\n", + (unsigned long long) pPnmiStat->StatTxCarrierCts); + seq_printf(seq, " fifo underrun %Lu\n", + (unsigned long long) pPnmiStat->StatTxFifoUnderrunCts); + seq_printf(seq, " heartbeat %Lu\n", + (unsigned long long) pPnmiStat->StatTxCarrierCts); + seq_printf(seq, " window %ld\n", + pAC->stats.tx_window_errors); + + } + } + return 0; +} + +/***************************************************************************** + * + * sk_proc_open - register the show function when proc is open'ed + * + * Description: + * This function is called whenever a sk98lin proc file is queried. + * + * Returns: the return value of single_open() + * + */ +static int sk_proc_open(struct inode *inode, struct file *file) +{ + return single_open(file, sk_seq_show, PDE(inode)->data); +} + +/******************************************************************************* + * + * End of file + * + ******************************************************************************/ diff --git a/trunk/drivers/net/skge.c b/trunk/drivers/net/skge.c index b538e3038058..00d683063c01 100644 --- a/trunk/drivers/net/skge.c +++ b/trunk/drivers/net/skge.c @@ -25,7 +25,6 @@ */ #include -#include #include #include #include @@ -44,7 +43,7 @@ #include "skge.h" #define DRV_NAME "skge" -#define DRV_VERSION "1.3" +#define DRV_VERSION "1.2" #define PFX DRV_NAME " " #define DEFAULT_TX_RING_SIZE 128 @@ -89,14 +88,15 @@ MODULE_DEVICE_TABLE(pci, skge_id_table); static int skge_up(struct net_device *dev); static int skge_down(struct net_device *dev); -static void skge_phy_reset(struct skge_port *skge); static void skge_tx_clean(struct skge_port *skge); static int xm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val); static int gm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val); static void genesis_get_stats(struct skge_port *skge, u64 *data); static void yukon_get_stats(struct skge_port *skge, u64 *data); static void yukon_init(struct skge_hw *hw, int port); +static void yukon_reset(struct skge_hw *hw, int port); static void genesis_mac_init(struct skge_hw *hw, int port); +static void genesis_reset(struct skge_hw *hw, int port); static void genesis_link_up(struct skge_port *skge); /* Avoid conditionals by using array */ @@ -276,9 +276,10 @@ static int skge_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) skge->autoneg = ecmd->autoneg; skge->advertising = ecmd->advertising; - if (netif_running(dev)) - skge_phy_reset(skge); - + if (netif_running(dev)) { + skge_down(dev); + skge_up(dev); + } return (0); } @@ -398,7 +399,6 @@ static int skge_set_ring_param(struct net_device *dev, struct ethtool_ringparam *p) { struct skge_port *skge = netdev_priv(dev); - int err; if (p->rx_pending == 0 || p->rx_pending > MAX_RX_RING_SIZE || p->tx_pending == 0 || p->tx_pending > MAX_TX_RING_SIZE) @@ -409,9 +409,7 @@ static int skge_set_ring_param(struct net_device *dev, if (netif_running(dev)) { skge_down(dev); - err = skge_up(dev); - if (err) - dev_close(dev); + skge_up(dev); } return 0; @@ -432,11 +430,21 @@ static void skge_set_msglevel(struct net_device *netdev, u32 value) static int skge_nway_reset(struct net_device *dev) { struct skge_port *skge = netdev_priv(dev); + struct skge_hw *hw = skge->hw; + int port = skge->port; if (skge->autoneg != AUTONEG_ENABLE || !netif_running(dev)) return -EINVAL; - skge_phy_reset(skge); + spin_lock_bh(&hw->phy_lock); + if (hw->chip_id == CHIP_ID_GENESIS) { + genesis_reset(hw, port); + genesis_mac_init(hw, port); + } else { + yukon_reset(hw, port); + yukon_init(hw, port); + } + spin_unlock_bh(&hw->phy_lock); return 0; } @@ -508,8 +516,10 @@ static int skge_set_pauseparam(struct net_device *dev, else skge->flow_control = FLOW_MODE_NONE; - if (netif_running(dev)) - skge_phy_reset(skge); + if (netif_running(dev)) { + skge_down(dev); + skge_up(dev); + } return 0; } @@ -2009,25 +2019,6 @@ static void yukon_phy_intr(struct skge_port *skge) /* XXX restart autonegotiation? */ } -static void skge_phy_reset(struct skge_port *skge) -{ - struct skge_hw *hw = skge->hw; - int port = skge->port; - - netif_stop_queue(skge->netdev); - netif_carrier_off(skge->netdev); - - spin_lock_bh(&hw->phy_lock); - if (hw->chip_id == CHIP_ID_GENESIS) { - genesis_reset(hw, port); - genesis_mac_init(hw, port); - } else { - yukon_reset(hw, port); - yukon_init(hw, port); - } - spin_unlock_bh(&hw->phy_lock); -} - /* Basic MII support */ static int skge_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) { @@ -2196,7 +2187,6 @@ static int skge_up(struct net_device *dev) kfree(skge->rx_ring.start); free_pci_mem: pci_free_consistent(hw->pdev, skge->mem_size, skge->mem, skge->dma); - skge->mem = NULL; return err; } @@ -2207,9 +2197,6 @@ static int skge_down(struct net_device *dev) struct skge_hw *hw = skge->hw; int port = skge->port; - if (skge->mem == NULL) - return 0; - if (netif_msg_ifdown(skge)) printk(KERN_INFO PFX "%s: disabling interface\n", dev->name); @@ -2266,7 +2253,6 @@ static int skge_down(struct net_device *dev) kfree(skge->rx_ring.start); kfree(skge->tx_ring.start); pci_free_consistent(hw->pdev, skge->mem_size, skge->mem, skge->dma); - skge->mem = NULL; return 0; } @@ -2427,23 +2413,18 @@ static void skge_tx_timeout(struct net_device *dev) static int skge_change_mtu(struct net_device *dev, int new_mtu) { - int err; + int err = 0; + int running = netif_running(dev); if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU) return -EINVAL; - if (!netif_running(dev)) { - dev->mtu = new_mtu; - return 0; - } - - skge_down(dev); + if (running) + skge_down(dev); dev->mtu = new_mtu; - - err = skge_up(dev); - if (err) - dev_close(dev); + if (running) + skge_up(dev); return err; } @@ -3417,8 +3398,8 @@ static int skge_resume(struct pci_dev *pdev) struct net_device *dev = hw->dev[i]; if (dev) { netif_device_attach(dev); - if (netif_running(dev) && skge_up(dev)) - dev_close(dev); + if (netif_running(dev)) + skge_up(dev); } } return 0; diff --git a/trunk/drivers/net/skge.h b/trunk/drivers/net/skge.h index 2efdacc290e5..ee123c15f545 100644 --- a/trunk/drivers/net/skge.h +++ b/trunk/drivers/net/skge.h @@ -475,6 +475,18 @@ enum { Q_T2 = 0x40, /* 32 bit Test Register 2 */ Q_T3 = 0x44, /* 32 bit Test Register 3 */ +/* Yukon-2 */ + Q_DONE = 0x24, /* 16 bit Done Index (Yukon-2 only) */ + Q_WM = 0x40, /* 16 bit FIFO Watermark */ + Q_AL = 0x42, /* 8 bit FIFO Alignment */ + Q_RSP = 0x44, /* 16 bit FIFO Read Shadow Pointer */ + Q_RSL = 0x46, /* 8 bit FIFO Read Shadow Level */ + Q_RP = 0x48, /* 8 bit FIFO Read Pointer */ + Q_RL = 0x4a, /* 8 bit FIFO Read Level */ + Q_WP = 0x4c, /* 8 bit FIFO Write Pointer */ + Q_WSP = 0x4d, /* 8 bit FIFO Write Shadow Pointer */ + Q_WL = 0x4e, /* 8 bit FIFO Write Level */ + Q_WSL = 0x4f, /* 8 bit FIFO Write Shadow Level */ }; #define Q_ADDR(reg, offs) (B8_Q_REGS + (reg) + (offs)) @@ -663,16 +675,22 @@ enum { LED_OFF = 1<<0, /* switch LED off */ }; -/* Receive GMAC FIFO (YUKON) */ +/* Receive GMAC FIFO (YUKON and Yukon-2) */ enum { RX_GMF_EA = 0x0c40,/* 32 bit Rx GMAC FIFO End Address */ RX_GMF_AF_THR = 0x0c44,/* 32 bit Rx GMAC FIFO Almost Full Thresh. */ RX_GMF_CTRL_T = 0x0c48,/* 32 bit Rx GMAC FIFO Control/Test */ RX_GMF_FL_MSK = 0x0c4c,/* 32 bit Rx GMAC FIFO Flush Mask */ RX_GMF_FL_THR = 0x0c50,/* 32 bit Rx GMAC FIFO Flush Threshold */ + RX_GMF_TR_THR = 0x0c54,/* 32 bit Rx Truncation Threshold (Yukon-2) */ + + RX_GMF_VLAN = 0x0c5c,/* 32 bit Rx VLAN Type Register (Yukon-2) */ RX_GMF_WP = 0x0c60,/* 32 bit Rx GMAC FIFO Write Pointer */ + RX_GMF_WLEV = 0x0c68,/* 32 bit Rx GMAC FIFO Write Level */ + RX_GMF_RP = 0x0c70,/* 32 bit Rx GMAC FIFO Read Pointer */ + RX_GMF_RLEV = 0x0c78,/* 32 bit Rx GMAC FIFO Read Level */ }; @@ -837,6 +855,48 @@ enum { GMAC_TI_ST_TST = 0x0e1a,/* 8 bit Time Stamp Timer Test Reg */ }; +/* Status BMU Registers (Yukon-2 only)*/ +enum { + STAT_CTRL = 0x0e80,/* 32 bit Status BMU Control Reg */ + STAT_LAST_IDX = 0x0e84,/* 16 bit Status BMU Last Index */ + /* 0x0e85 - 0x0e86: reserved */ + STAT_LIST_ADDR_LO = 0x0e88,/* 32 bit Status List Start Addr (low) */ + STAT_LIST_ADDR_HI = 0x0e8c,/* 32 bit Status List Start Addr (high) */ + STAT_TXA1_RIDX = 0x0e90,/* 16 bit Status TxA1 Report Index Reg */ + STAT_TXS1_RIDX = 0x0e92,/* 16 bit Status TxS1 Report Index Reg */ + STAT_TXA2_RIDX = 0x0e94,/* 16 bit Status TxA2 Report Index Reg */ + STAT_TXS2_RIDX = 0x0e96,/* 16 bit Status TxS2 Report Index Reg */ + STAT_TX_IDX_TH = 0x0e98,/* 16 bit Status Tx Index Threshold Reg */ + STAT_PUT_IDX = 0x0e9c,/* 16 bit Status Put Index Reg */ + +/* FIFO Control/Status Registers (Yukon-2 only)*/ + STAT_FIFO_WP = 0x0ea0,/* 8 bit Status FIFO Write Pointer Reg */ + STAT_FIFO_RP = 0x0ea4,/* 8 bit Status FIFO Read Pointer Reg */ + STAT_FIFO_RSP = 0x0ea6,/* 8 bit Status FIFO Read Shadow Ptr */ + STAT_FIFO_LEVEL = 0x0ea8,/* 8 bit Status FIFO Level Reg */ + STAT_FIFO_SHLVL = 0x0eaa,/* 8 bit Status FIFO Shadow Level Reg */ + STAT_FIFO_WM = 0x0eac,/* 8 bit Status FIFO Watermark Reg */ + STAT_FIFO_ISR_WM = 0x0ead,/* 8 bit Status FIFO ISR Watermark Reg */ + +/* Level and ISR Timer Registers (Yukon-2 only)*/ + STAT_LEV_TIMER_INI = 0x0eb0,/* 32 bit Level Timer Init. Value Reg */ + STAT_LEV_TIMER_CNT = 0x0eb4,/* 32 bit Level Timer Counter Reg */ + STAT_LEV_TIMER_CTRL = 0x0eb8,/* 8 bit Level Timer Control Reg */ + STAT_LEV_TIMER_TEST = 0x0eb9,/* 8 bit Level Timer Test Reg */ + STAT_TX_TIMER_INI = 0x0ec0,/* 32 bit Tx Timer Init. Value Reg */ + STAT_TX_TIMER_CNT = 0x0ec4,/* 32 bit Tx Timer Counter Reg */ + STAT_TX_TIMER_CTRL = 0x0ec8,/* 8 bit Tx Timer Control Reg */ + STAT_TX_TIMER_TEST = 0x0ec9,/* 8 bit Tx Timer Test Reg */ + STAT_ISR_TIMER_INI = 0x0ed0,/* 32 bit ISR Timer Init. Value Reg */ + STAT_ISR_TIMER_CNT = 0x0ed4,/* 32 bit ISR Timer Counter Reg */ + STAT_ISR_TIMER_CTRL = 0x0ed8,/* 8 bit ISR Timer Control Reg */ + STAT_ISR_TIMER_TEST = 0x0ed9,/* 8 bit ISR Timer Test Reg */ + + ST_LAST_IDX_MASK = 0x007f,/* Last Index Mask */ + ST_TXRP_IDX_MASK = 0x0fff,/* Tx Report Index Mask */ + ST_TXTH_IDX_MASK = 0x0fff,/* Tx Threshold Index Mask */ + ST_WM_IDX_MASK = 0x3f,/* FIFO Watermark Index Mask */ +}; enum { LINKLED_OFF = 0x01, @@ -863,6 +923,8 @@ enum { WOL_MATCH_CTL = 0x0f22,/* 8 bit WOL Match Control Reg */ WOL_MATCH_RES = 0x0f23,/* 8 bit WOL Match Result Reg */ WOL_MAC_ADDR = 0x0f24,/* 32 bit WOL MAC Address */ + WOL_PATT_PME = 0x0f2a,/* 8 bit WOL PME Match Enable (Yukon-2) */ + WOL_PATT_ASFM = 0x0f2b,/* 8 bit WOL ASF Match Enable (Yukon-2) */ WOL_PATT_RPTR = 0x0f2c,/* 8 bit WOL Pattern Read Pointer */ /* WOL Pattern Length Registers (YUKON only) */ @@ -1579,6 +1641,15 @@ enum { PHY_M_FESC_SEL_CL_A = 1<<0, /* Select Class A driver (100B-TX) */ }; +/* for Yukon-2 Gigabit Ethernet PHY (88E1112 only) */ +/***** PHY_MARV_PHY_CTRL (page 2) 16 bit r/w MAC Specific Ctrl *****/ +enum { + PHY_M_MAC_MD_MSK = 7<<7, /* Bit 9.. 7: Mode Select Mask */ + PHY_M_MAC_MD_AUTO = 3,/* Auto Copper/1000Base-X */ + PHY_M_MAC_MD_COPPER = 5,/* Copper only */ + PHY_M_MAC_MD_1000BX = 7,/* 1000Base-X only */ +}; +#define PHY_M_MAC_MODE_SEL(x) (((x)<<7) & PHY_M_MAC_MD_MSK) /***** PHY_MARV_PHY_CTRL (page 3) 16 bit r/w LED Control Reg. *****/ enum { diff --git a/trunk/drivers/net/sky2.c b/trunk/drivers/net/sky2.c deleted file mode 100644 index f5d697c0c031..000000000000 --- a/trunk/drivers/net/sky2.c +++ /dev/null @@ -1,3262 +0,0 @@ -/* - * New driver for Marvell Yukon 2 chipset. - * Based on earlier sk98lin, and skge driver. - * - * This driver intentionally does not support all the features - * of the original driver such as link fail-over and link management because - * those should be done at higher levels. - * - * Copyright (C) 2005 Stephen Hemminger - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -/* - * TOTEST - * - speed setting - * - suspend/resume - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE) -#define SKY2_VLAN_TAG_USED 1 -#endif - -#include "sky2.h" - -#define DRV_NAME "sky2" -#define DRV_VERSION "0.11" -#define PFX DRV_NAME " " - -/* - * The Yukon II chipset takes 64 bit command blocks (called list elements) - * that are organized into three (receive, transmit, status) different rings - * similar to Tigon3. A transmit can require several elements; - * a receive requires one (or two if using 64 bit dma). - */ - -#define is_ec_a1(hw) \ - unlikely((hw)->chip_id == CHIP_ID_YUKON_EC && \ - (hw)->chip_rev == CHIP_REV_YU_EC_A1) - -#define RX_LE_SIZE 512 -#define RX_LE_BYTES (RX_LE_SIZE*sizeof(struct sky2_rx_le)) -#define RX_MAX_PENDING (RX_LE_SIZE/2 - 2) -#define RX_DEF_PENDING RX_MAX_PENDING - -#define TX_RING_SIZE 512 -#define TX_DEF_PENDING (TX_RING_SIZE - 1) -#define TX_MIN_PENDING 64 -#define MAX_SKB_TX_LE (4 + 2*MAX_SKB_FRAGS) - -#define STATUS_RING_SIZE 2048 /* 2 ports * (TX + 2*RX) */ -#define STATUS_LE_BYTES (STATUS_RING_SIZE*sizeof(struct sky2_status_le)) -#define ETH_JUMBO_MTU 9000 -#define TX_WATCHDOG (5 * HZ) -#define NAPI_WEIGHT 64 -#define PHY_RETRIES 1000 - -static const u32 default_msg = - NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK - | NETIF_MSG_TIMER | NETIF_MSG_TX_ERR | NETIF_MSG_RX_ERR - | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN | NETIF_MSG_INTR; - -static int debug = -1; /* defaults above */ -module_param(debug, int, 0); -MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)"); - -static int copybreak __read_mostly = 256; -module_param(copybreak, int, 0); -MODULE_PARM_DESC(copybreak, "Receive copy threshold"); - -static const struct pci_device_id sky2_id_table[] = { - { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9000) }, - { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E00) }, - { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b00) }, - { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b01) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4340) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4341) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4342) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4343) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4344) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4345) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4346) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4347) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4350) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4351) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4352) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4360) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4361) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4362) }, - { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4363) }, - { 0 } -}; - -MODULE_DEVICE_TABLE(pci, sky2_id_table); - -/* Avoid conditionals by using array */ -static const unsigned txqaddr[] = { Q_XA1, Q_XA2 }; -static const unsigned rxqaddr[] = { Q_R1, Q_R2 }; - -/* This driver supports yukon2 chipset only */ -static const char *yukon2_name[] = { - "XL", /* 0xb3 */ - "EC Ultra", /* 0xb4 */ - "UNKNOWN", /* 0xb5 */ - "EC", /* 0xb6 */ - "FE", /* 0xb7 */ -}; - -/* Access to external PHY */ -static int gm_phy_write(struct sky2_hw *hw, unsigned port, u16 reg, u16 val) -{ - int i; - - gma_write16(hw, port, GM_SMI_DATA, val); - gma_write16(hw, port, GM_SMI_CTRL, - GM_SMI_CT_PHY_AD(PHY_ADDR_MARV) | GM_SMI_CT_REG_AD(reg)); - - for (i = 0; i < PHY_RETRIES; i++) { - if (!(gma_read16(hw, port, GM_SMI_CTRL) & GM_SMI_CT_BUSY)) - return 0; - udelay(1); - } - - printk(KERN_WARNING PFX "%s: phy write timeout\n", hw->dev[port]->name); - return -ETIMEDOUT; -} - -static int __gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg, u16 *val) -{ - int i; - - gma_write16(hw, port, GM_SMI_CTRL, GM_SMI_CT_PHY_AD(PHY_ADDR_MARV) - | GM_SMI_CT_REG_AD(reg) | GM_SMI_CT_OP_RD); - - for (i = 0; i < PHY_RETRIES; i++) { - if (gma_read16(hw, port, GM_SMI_CTRL) & GM_SMI_CT_RD_VAL) { - *val = gma_read16(hw, port, GM_SMI_DATA); - return 0; - } - - udelay(1); - } - - return -ETIMEDOUT; -} - -static u16 gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg) -{ - u16 v; - - if (__gm_phy_read(hw, port, reg, &v) != 0) - printk(KERN_WARNING PFX "%s: phy read timeout\n", hw->dev[port]->name); - return v; -} - -static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state) -{ - u16 power_control; - u32 reg1; - int vaux; - int ret = 0; - - pr_debug("sky2_set_power_state %d\n", state); - sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); - - pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_PMC, &power_control); - vaux = (sky2_read8(hw, B0_CTST) & Y2_VAUX_AVAIL) && - (power_control & PCI_PM_CAP_PME_D3cold); - - pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_CTRL, &power_control); - - power_control |= PCI_PM_CTRL_PME_STATUS; - power_control &= ~(PCI_PM_CTRL_STATE_MASK); - - switch (state) { - case PCI_D0: - /* switch power to VCC (WA for VAUX problem) */ - sky2_write8(hw, B0_POWER_CTRL, - PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_OFF | PC_VCC_ON); - - /* disable Core Clock Division, */ - sky2_write32(hw, B2_Y2_CLK_CTRL, Y2_CLK_DIV_DIS); - - if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1) - /* enable bits are inverted */ - sky2_write8(hw, B2_Y2_CLK_GATE, - Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS | - Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS | - Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS); - else - sky2_write8(hw, B2_Y2_CLK_GATE, 0); - - /* Turn off phy power saving */ - pci_read_config_dword(hw->pdev, PCI_DEV_REG1, ®1); - reg1 &= ~(PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD); - - /* looks like this XL is back asswards .. */ - if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1) { - reg1 |= PCI_Y2_PHY1_COMA; - if (hw->ports > 1) - reg1 |= PCI_Y2_PHY2_COMA; - } - pci_write_config_dword(hw->pdev, PCI_DEV_REG1, reg1); - break; - - case PCI_D3hot: - case PCI_D3cold: - /* Turn on phy power saving */ - pci_read_config_dword(hw->pdev, PCI_DEV_REG1, ®1); - if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1) - reg1 &= ~(PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD); - else - reg1 |= (PCI_Y2_PHY1_POWD | PCI_Y2_PHY2_POWD); - pci_write_config_dword(hw->pdev, PCI_DEV_REG1, reg1); - - if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1) - sky2_write8(hw, B2_Y2_CLK_GATE, 0); - else - /* enable bits are inverted */ - sky2_write8(hw, B2_Y2_CLK_GATE, - Y2_PCI_CLK_LNK1_DIS | Y2_COR_CLK_LNK1_DIS | - Y2_CLK_GAT_LNK1_DIS | Y2_PCI_CLK_LNK2_DIS | - Y2_COR_CLK_LNK2_DIS | Y2_CLK_GAT_LNK2_DIS); - - /* switch power to VAUX */ - if (vaux && state != PCI_D3cold) - sky2_write8(hw, B0_POWER_CTRL, - (PC_VAUX_ENA | PC_VCC_ENA | - PC_VAUX_ON | PC_VCC_OFF)); - break; - default: - printk(KERN_ERR PFX "Unknown power state %d\n", state); - ret = -1; - } - - pci_write_config_byte(hw->pdev, hw->pm_cap + PCI_PM_CTRL, power_control); - sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); - return ret; -} - -static void sky2_phy_reset(struct sky2_hw *hw, unsigned port) -{ - u16 reg; - - /* disable all GMAC IRQ's */ - sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), 0); - /* disable PHY IRQs */ - gm_phy_write(hw, port, PHY_MARV_INT_MASK, 0); - - gma_write16(hw, port, GM_MC_ADDR_H1, 0); /* clear MC hash */ - gma_write16(hw, port, GM_MC_ADDR_H2, 0); - gma_write16(hw, port, GM_MC_ADDR_H3, 0); - gma_write16(hw, port, GM_MC_ADDR_H4, 0); - - reg = gma_read16(hw, port, GM_RX_CTRL); - reg |= GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA; - gma_write16(hw, port, GM_RX_CTRL, reg); -} - -static void sky2_phy_init(struct sky2_hw *hw, unsigned port) -{ - struct sky2_port *sky2 = netdev_priv(hw->dev[port]); - u16 ctrl, ct1000, adv, pg, ledctrl, ledover; - - if (sky2->autoneg == AUTONEG_ENABLE && hw->chip_id != CHIP_ID_YUKON_XL) { - u16 ectrl = gm_phy_read(hw, port, PHY_MARV_EXT_CTRL); - - ectrl &= ~(PHY_M_EC_M_DSC_MSK | PHY_M_EC_S_DSC_MSK | - PHY_M_EC_MAC_S_MSK); - ectrl |= PHY_M_EC_MAC_S(MAC_TX_CLK_25_MHZ); - - if (hw->chip_id == CHIP_ID_YUKON_EC) - ectrl |= PHY_M_EC_DSC_2(2) | PHY_M_EC_DOWN_S_ENA; - else - ectrl |= PHY_M_EC_M_DSC(2) | PHY_M_EC_S_DSC(3); - - gm_phy_write(hw, port, PHY_MARV_EXT_CTRL, ectrl); - } - - ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL); - if (hw->copper) { - if (hw->chip_id == CHIP_ID_YUKON_FE) { - /* enable automatic crossover */ - ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO) >> 1; - } else { - /* disable energy detect */ - ctrl &= ~PHY_M_PC_EN_DET_MSK; - - /* enable automatic crossover */ - ctrl |= PHY_M_PC_MDI_XMODE(PHY_M_PC_ENA_AUTO); - - if (sky2->autoneg == AUTONEG_ENABLE && - hw->chip_id == CHIP_ID_YUKON_XL) { - ctrl &= ~PHY_M_PC_DSC_MSK; - ctrl |= PHY_M_PC_DSC(2) | PHY_M_PC_DOWN_S_ENA; - } - } - gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl); - } else { - /* workaround for deviation #4.88 (CRC errors) */ - /* disable Automatic Crossover */ - - ctrl &= ~PHY_M_PC_MDIX_MSK; - gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl); - - if (hw->chip_id == CHIP_ID_YUKON_XL) { - /* Fiber: select 1000BASE-X only mode MAC Specific Ctrl Reg. */ - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 2); - ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL); - ctrl &= ~PHY_M_MAC_MD_MSK; - ctrl |= PHY_M_MAC_MODE_SEL(PHY_M_MAC_MD_1000BX); - gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl); - - /* select page 1 to access Fiber registers */ - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 1); - } - } - - ctrl = gm_phy_read(hw, port, PHY_MARV_CTRL); - if (sky2->autoneg == AUTONEG_DISABLE) - ctrl &= ~PHY_CT_ANE; - else - ctrl |= PHY_CT_ANE; - - ctrl |= PHY_CT_RESET; - gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl); - - ctrl = 0; - ct1000 = 0; - adv = PHY_AN_CSMA; - - if (sky2->autoneg == AUTONEG_ENABLE) { - if (hw->copper) { - if (sky2->advertising & ADVERTISED_1000baseT_Full) - ct1000 |= PHY_M_1000C_AFD; - if (sky2->advertising & ADVERTISED_1000baseT_Half) - ct1000 |= PHY_M_1000C_AHD; - if (sky2->advertising & ADVERTISED_100baseT_Full) - adv |= PHY_M_AN_100_FD; - if (sky2->advertising & ADVERTISED_100baseT_Half) - adv |= PHY_M_AN_100_HD; - if (sky2->advertising & ADVERTISED_10baseT_Full) - adv |= PHY_M_AN_10_FD; - if (sky2->advertising & ADVERTISED_10baseT_Half) - adv |= PHY_M_AN_10_HD; - } else /* special defines for FIBER (88E1011S only) */ - adv |= PHY_M_AN_1000X_AHD | PHY_M_AN_1000X_AFD; - - /* Set Flow-control capabilities */ - if (sky2->tx_pause && sky2->rx_pause) - adv |= PHY_AN_PAUSE_CAP; /* symmetric */ - else if (sky2->rx_pause && !sky2->tx_pause) - adv |= PHY_AN_PAUSE_ASYM | PHY_AN_PAUSE_CAP; - else if (!sky2->rx_pause && sky2->tx_pause) - adv |= PHY_AN_PAUSE_ASYM; /* local */ - - /* Restart Auto-negotiation */ - ctrl |= PHY_CT_ANE | PHY_CT_RE_CFG; - } else { - /* forced speed/duplex settings */ - ct1000 = PHY_M_1000C_MSE; - - if (sky2->duplex == DUPLEX_FULL) - ctrl |= PHY_CT_DUP_MD; - - switch (sky2->speed) { - case SPEED_1000: - ctrl |= PHY_CT_SP1000; - break; - case SPEED_100: - ctrl |= PHY_CT_SP100; - break; - } - - ctrl |= PHY_CT_RESET; - } - - if (hw->chip_id != CHIP_ID_YUKON_FE) - gm_phy_write(hw, port, PHY_MARV_1000T_CTRL, ct1000); - - gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, adv); - gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl); - - /* Setup Phy LED's */ - ledctrl = PHY_M_LED_PULS_DUR(PULS_170MS); - ledover = 0; - - switch (hw->chip_id) { - case CHIP_ID_YUKON_FE: - /* on 88E3082 these bits are at 11..9 (shifted left) */ - ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) << 1; - - ctrl = gm_phy_read(hw, port, PHY_MARV_FE_LED_PAR); - - /* delete ACT LED control bits */ - ctrl &= ~PHY_M_FELP_LED1_MSK; - /* change ACT LED control to blink mode */ - ctrl |= PHY_M_FELP_LED1_CTRL(LED_PAR_CTRL_ACT_BL); - gm_phy_write(hw, port, PHY_MARV_FE_LED_PAR, ctrl); - break; - - case CHIP_ID_YUKON_XL: - pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR); - - /* select page 3 to access LED control register */ - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3); - - /* set LED Function Control register */ - gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, (PHY_M_LEDC_LOS_CTRL(1) | /* LINK/ACT */ - PHY_M_LEDC_INIT_CTRL(7) | /* 10 Mbps */ - PHY_M_LEDC_STA1_CTRL(7) | /* 100 Mbps */ - PHY_M_LEDC_STA0_CTRL(7))); /* 1000 Mbps */ - - /* set Polarity Control register */ - gm_phy_write(hw, port, PHY_MARV_PHY_STAT, - (PHY_M_POLC_LS1_P_MIX(4) | - PHY_M_POLC_IS0_P_MIX(4) | - PHY_M_POLC_LOS_CTRL(2) | - PHY_M_POLC_INIT_CTRL(2) | - PHY_M_POLC_STA1_CTRL(2) | - PHY_M_POLC_STA0_CTRL(2))); - - /* restore page register */ - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg); - break; - - default: - /* set Tx LED (LED_TX) to blink mode on Rx OR Tx activity */ - ledctrl |= PHY_M_LED_BLINK_RT(BLINK_84MS) | PHY_M_LEDC_TX_CTRL; - /* turn off the Rx LED (LED_RX) */ - ledover |= PHY_M_LED_MO_RX(MO_LED_OFF); - } - - gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl); - - if (sky2->autoneg == AUTONEG_DISABLE || sky2->speed == SPEED_100) { - /* turn on 100 Mbps LED (LED_LINK100) */ - ledover |= PHY_M_LED_MO_100(MO_LED_ON); - } - - if (ledover) - gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover); - - /* Enable phy interrupt on auto-negotiation complete (or link up) */ - if (sky2->autoneg == AUTONEG_ENABLE) - gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_AN_COMPL); - else - gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK); -} - -/* Force a renegotiation */ -static void sky2_phy_reinit(struct sky2_port *sky2) -{ - down(&sky2->phy_sema); - sky2_phy_init(sky2->hw, sky2->port); - up(&sky2->phy_sema); -} - -static void sky2_mac_init(struct sky2_hw *hw, unsigned port) -{ - struct sky2_port *sky2 = netdev_priv(hw->dev[port]); - u16 reg; - int i; - const u8 *addr = hw->dev[port]->dev_addr; - - sky2_write32(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET); - sky2_write32(hw, SK_REG(port, GPHY_CTRL), GPC_RST_CLR|GPC_ENA_PAUSE); - - sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_CLR); - - if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0 && port == 1) { - /* WA DEV_472 -- looks like crossed wires on port 2 */ - /* clear GMAC 1 Control reset */ - sky2_write8(hw, SK_REG(0, GMAC_CTRL), GMC_RST_CLR); - do { - sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_SET); - sky2_write8(hw, SK_REG(1, GMAC_CTRL), GMC_RST_CLR); - } while (gm_phy_read(hw, 1, PHY_MARV_ID0) != PHY_MARV_ID0_VAL || - gm_phy_read(hw, 1, PHY_MARV_ID1) != PHY_MARV_ID1_Y2 || - gm_phy_read(hw, 1, PHY_MARV_INT_MASK) != 0); - } - - if (sky2->autoneg == AUTONEG_DISABLE) { - reg = gma_read16(hw, port, GM_GP_CTRL); - reg |= GM_GPCR_AU_ALL_DIS; - gma_write16(hw, port, GM_GP_CTRL, reg); - gma_read16(hw, port, GM_GP_CTRL); - - switch (sky2->speed) { - case SPEED_1000: - reg |= GM_GPCR_SPEED_1000; - /* fallthru */ - case SPEED_100: - reg |= GM_GPCR_SPEED_100; - } - - if (sky2->duplex == DUPLEX_FULL) - reg |= GM_GPCR_DUP_FULL; - } else - reg = GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100 | GM_GPCR_DUP_FULL; - - if (!sky2->tx_pause && !sky2->rx_pause) { - sky2_write32(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF); - reg |= - GM_GPCR_FC_TX_DIS | GM_GPCR_FC_RX_DIS | GM_GPCR_AU_FCT_DIS; - } else if (sky2->tx_pause && !sky2->rx_pause) { - /* disable Rx flow-control */ - reg |= GM_GPCR_FC_RX_DIS | GM_GPCR_AU_FCT_DIS; - } - - gma_write16(hw, port, GM_GP_CTRL, reg); - - sky2_read16(hw, SK_REG(port, GMAC_IRQ_SRC)); - - down(&sky2->phy_sema); - sky2_phy_init(hw, port); - up(&sky2->phy_sema); - - /* MIB clear */ - reg = gma_read16(hw, port, GM_PHY_ADDR); - gma_write16(hw, port, GM_PHY_ADDR, reg | GM_PAR_MIB_CLR); - - for (i = 0; i < GM_MIB_CNT_SIZE; i++) - gma_read16(hw, port, GM_MIB_CNT_BASE + 8 * i); - gma_write16(hw, port, GM_PHY_ADDR, reg); - - /* transmit control */ - gma_write16(hw, port, GM_TX_CTRL, TX_COL_THR(TX_COL_DEF)); - - /* receive control reg: unicast + multicast + no FCS */ - gma_write16(hw, port, GM_RX_CTRL, - GM_RXCR_UCF_ENA | GM_RXCR_CRC_DIS | GM_RXCR_MCF_ENA); - - /* transmit flow control */ - gma_write16(hw, port, GM_TX_FLOW_CTRL, 0xffff); - - /* transmit parameter */ - gma_write16(hw, port, GM_TX_PARAM, - TX_JAM_LEN_VAL(TX_JAM_LEN_DEF) | - TX_JAM_IPG_VAL(TX_JAM_IPG_DEF) | - TX_IPG_JAM_DATA(TX_IPG_JAM_DEF) | - TX_BACK_OFF_LIM(TX_BOF_LIM_DEF)); - - /* serial mode register */ - reg = DATA_BLIND_VAL(DATA_BLIND_DEF) | - GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF); - - if (hw->dev[port]->mtu > ETH_DATA_LEN) - reg |= GM_SMOD_JUMBO_ENA; - - gma_write16(hw, port, GM_SERIAL_MODE, reg); - - /* virtual address for data */ - gma_set_addr(hw, port, GM_SRC_ADDR_2L, addr); - - /* physical address: used for pause frames */ - gma_set_addr(hw, port, GM_SRC_ADDR_1L, addr); - - /* ignore counter overflows */ - gma_write16(hw, port, GM_TX_IRQ_MSK, 0); - gma_write16(hw, port, GM_RX_IRQ_MSK, 0); - gma_write16(hw, port, GM_TR_IRQ_MSK, 0); - - /* Configure Rx MAC FIFO */ - sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_CLR); - sky2_write16(hw, SK_REG(port, RX_GMF_CTRL_T), - GMF_RX_CTRL_DEF); - - /* Flush Rx MAC FIFO on any flow control or error */ - sky2_write16(hw, SK_REG(port, RX_GMF_FL_MSK), GMR_FS_ANY_ERR); - - /* Set threshold to 0xa (64 bytes) - * ASF disabled so no need to do WA dev #4.30 - */ - sky2_write16(hw, SK_REG(port, RX_GMF_FL_THR), RX_GMF_FL_THR_DEF); - - /* Configure Tx MAC FIFO */ - sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_CLR); - sky2_write16(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_OPER_ON); - - if (hw->chip_id == CHIP_ID_YUKON_EC_U) { - sky2_write8(hw, SK_REG(port, RX_GMF_LP_THR), 768/8); - sky2_write8(hw, SK_REG(port, RX_GMF_UP_THR), 1024/8); - if (hw->dev[port]->mtu > ETH_DATA_LEN) { - /* set Tx GMAC FIFO Almost Empty Threshold */ - sky2_write32(hw, SK_REG(port, TX_GMF_AE_THR), 0x180); - /* Disable Store & Forward mode for TX */ - sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T), TX_STFW_DIS); - } - } - -} - -static void sky2_ramset(struct sky2_hw *hw, u16 q, u32 start, size_t len) -{ - u32 end; - - start /= 8; - len /= 8; - end = start + len - 1; - - sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_RST_CLR); - sky2_write32(hw, RB_ADDR(q, RB_START), start); - sky2_write32(hw, RB_ADDR(q, RB_END), end); - sky2_write32(hw, RB_ADDR(q, RB_WP), start); - sky2_write32(hw, RB_ADDR(q, RB_RP), start); - - if (q == Q_R1 || q == Q_R2) { - u32 rxup, rxlo; - - rxlo = len/2; - rxup = rxlo + len/4; - - /* Set thresholds on receive queue's */ - sky2_write32(hw, RB_ADDR(q, RB_RX_UTPP), rxup); - sky2_write32(hw, RB_ADDR(q, RB_RX_LTPP), rxlo); - } else { - /* Enable store & forward on Tx queue's because - * Tx FIFO is only 1K on Yukon - */ - sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_STFWD); - } - - sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_OP_MD); - sky2_read8(hw, RB_ADDR(q, RB_CTRL)); -} - -/* Setup Bus Memory Interface */ -static void sky2_qset(struct sky2_hw *hw, u16 q) -{ - sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_CLR_RESET); - sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_OPER_INIT); - sky2_write32(hw, Q_ADDR(q, Q_CSR), BMU_FIFO_OP_ON); - sky2_write32(hw, Q_ADDR(q, Q_WM), BMU_WM_DEFAULT); -} - -/* Setup prefetch unit registers. This is the interface between - * hardware and driver list elements - */ -static void sky2_prefetch_init(struct sky2_hw *hw, u32 qaddr, - u64 addr, u32 last) -{ - sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_SET); - sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_RST_CLR); - sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_HI), addr >> 32); - sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_ADDR_LO), (u32) addr); - sky2_write16(hw, Y2_QADDR(qaddr, PREF_UNIT_LAST_IDX), last); - sky2_write32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL), PREF_UNIT_OP_ON); - - sky2_read32(hw, Y2_QADDR(qaddr, PREF_UNIT_CTRL)); -} - -static inline struct sky2_tx_le *get_tx_le(struct sky2_port *sky2) -{ - struct sky2_tx_le *le = sky2->tx_le + sky2->tx_prod; - - sky2->tx_prod = (sky2->tx_prod + 1) % TX_RING_SIZE; - return le; -} - -/* - * This is a workaround code taken from SysKonnect sk98lin driver - * to deal with chip bug on Yukon EC rev 0 in the wraparound case. - */ -static inline void sky2_put_idx(struct sky2_hw *hw, unsigned q, - u16 idx, u16 *last, u16 size) -{ - if (is_ec_a1(hw) && idx < *last) { - u16 hwget = sky2_read16(hw, Y2_QADDR(q, PREF_UNIT_GET_IDX)); - - if (hwget == 0) { - /* Start prefetching again */ - sky2_write8(hw, Y2_QADDR(q, PREF_UNIT_FIFO_WM), 0xe0); - goto setnew; - } - - if (hwget == size - 1) { - /* set watermark to one list element */ - sky2_write8(hw, Y2_QADDR(q, PREF_UNIT_FIFO_WM), 8); - - /* set put index to first list element */ - sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), 0); - } else /* have hardware go to end of list */ - sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), - size - 1); - } else { -setnew: - sky2_write16(hw, Y2_QADDR(q, PREF_UNIT_PUT_IDX), idx); - } - *last = idx; -} - - -static inline struct sky2_rx_le *sky2_next_rx(struct sky2_port *sky2) -{ - struct sky2_rx_le *le = sky2->rx_le + sky2->rx_put; - sky2->rx_put = (sky2->rx_put + 1) % RX_LE_SIZE; - return le; -} - -/* Return high part of DMA address (could be 32 or 64 bit) */ -static inline u32 high32(dma_addr_t a) -{ - return (a >> 16) >> 16; -} - -/* Build description to hardware about buffer */ -static inline void sky2_rx_add(struct sky2_port *sky2, dma_addr_t map) -{ - struct sky2_rx_le *le; - u32 hi = high32(map); - u16 len = sky2->rx_bufsize; - - if (sky2->rx_addr64 != hi) { - le = sky2_next_rx(sky2); - le->addr = cpu_to_le32(hi); - le->ctrl = 0; - le->opcode = OP_ADDR64 | HW_OWNER; - sky2->rx_addr64 = high32(map + len); - } - - le = sky2_next_rx(sky2); - le->addr = cpu_to_le32((u32) map); - le->length = cpu_to_le16(len); - le->ctrl = 0; - le->opcode = OP_PACKET | HW_OWNER; -} - - -/* Tell chip where to start receive checksum. - * Actually has two checksums, but set both same to avoid possible byte - * order problems. - */ -static void rx_set_checksum(struct sky2_port *sky2) -{ - struct sky2_rx_le *le; - - le = sky2_next_rx(sky2); - le->addr = (ETH_HLEN << 16) | ETH_HLEN; - le->ctrl = 0; - le->opcode = OP_TCPSTART | HW_OWNER; - - sky2_write32(sky2->hw, - Q_ADDR(rxqaddr[sky2->port], Q_CSR), - sky2->rx_csum ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM); - -} - -/* - * The RX Stop command will not work for Yukon-2 if the BMU does not - * reach the end of packet and since we can't make sure that we have - * incoming data, we must reset the BMU while it is not doing a DMA - * transfer. Since it is possible that the RX path is still active, - * the RX RAM buffer will be stopped first, so any possible incoming - * data will not trigger a DMA. After the RAM buffer is stopped, the - * BMU is polled until any DMA in progress is ended and only then it - * will be reset. - */ -static void sky2_rx_stop(struct sky2_port *sky2) -{ - struct sky2_hw *hw = sky2->hw; - unsigned rxq = rxqaddr[sky2->port]; - int i; - - /* disable the RAM Buffer receive queue */ - sky2_write8(hw, RB_ADDR(rxq, RB_CTRL), RB_DIS_OP_MD); - - for (i = 0; i < 0xffff; i++) - if (sky2_read8(hw, RB_ADDR(rxq, Q_RSL)) - == sky2_read8(hw, RB_ADDR(rxq, Q_RL))) - goto stopped; - - printk(KERN_WARNING PFX "%s: receiver stop failed\n", - sky2->netdev->name); -stopped: - sky2_write32(hw, Q_ADDR(rxq, Q_CSR), BMU_RST_SET | BMU_FIFO_RST); - - /* reset the Rx prefetch unit */ - sky2_write32(hw, Y2_QADDR(rxq, PREF_UNIT_CTRL), PREF_UNIT_RST_SET); -} - -/* Clean out receive buffer area, assumes receiver hardware stopped */ -static void sky2_rx_clean(struct sky2_port *sky2) -{ - unsigned i; - - memset(sky2->rx_le, 0, RX_LE_BYTES); - for (i = 0; i < sky2->rx_pending; i++) { - struct ring_info *re = sky2->rx_ring + i; - - if (re->skb) { - pci_unmap_single(sky2->hw->pdev, - re->mapaddr, sky2->rx_bufsize, - PCI_DMA_FROMDEVICE); - kfree_skb(re->skb); - re->skb = NULL; - } - } -} - -/* Basic MII support */ -static int sky2_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) -{ - struct mii_ioctl_data *data = if_mii(ifr); - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - int err = -EOPNOTSUPP; - - if (!netif_running(dev)) - return -ENODEV; /* Phy still in reset */ - - switch(cmd) { - case SIOCGMIIPHY: - data->phy_id = PHY_ADDR_MARV; - - /* fallthru */ - case SIOCGMIIREG: { - u16 val = 0; - - down(&sky2->phy_sema); - err = __gm_phy_read(hw, sky2->port, data->reg_num & 0x1f, &val); - up(&sky2->phy_sema); - - data->val_out = val; - break; - } - - case SIOCSMIIREG: - if (!capable(CAP_NET_ADMIN)) - return -EPERM; - - down(&sky2->phy_sema); - err = gm_phy_write(hw, sky2->port, data->reg_num & 0x1f, - data->val_in); - up(&sky2->phy_sema); - break; - } - return err; -} - -#ifdef SKY2_VLAN_TAG_USED -static void sky2_vlan_rx_register(struct net_device *dev, struct vlan_group *grp) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - u16 port = sky2->port; - - spin_lock(&sky2->tx_lock); - - sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T), RX_VLAN_STRIP_ON); - sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T), TX_VLAN_TAG_ON); - sky2->vlgrp = grp; - - spin_unlock(&sky2->tx_lock); -} - -static void sky2_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - u16 port = sky2->port; - - spin_lock(&sky2->tx_lock); - - sky2_write32(hw, SK_REG(port, RX_GMF_CTRL_T), RX_VLAN_STRIP_OFF); - sky2_write32(hw, SK_REG(port, TX_GMF_CTRL_T), TX_VLAN_TAG_OFF); - if (sky2->vlgrp) - sky2->vlgrp->vlan_devices[vid] = NULL; - - spin_unlock(&sky2->tx_lock); -} -#endif - -/* - * Allocate and setup receiver buffer pool. - * In case of 64 bit dma, there are 2X as many list elements - * available as ring entries - * and need to reserve one list element so we don't wrap around. - * - * It appears the hardware has a bug in the FIFO logic that - * cause it to hang if the FIFO gets overrun and the receive buffer - * is not aligned. This means we can't use skb_reserve to align - * the IP header. - */ -static int sky2_rx_start(struct sky2_port *sky2) -{ - struct sky2_hw *hw = sky2->hw; - unsigned rxq = rxqaddr[sky2->port]; - int i; - - sky2->rx_put = sky2->rx_next = 0; - sky2_qset(hw, rxq); - sky2_prefetch_init(hw, rxq, sky2->rx_le_map, RX_LE_SIZE - 1); - - rx_set_checksum(sky2); - for (i = 0; i < sky2->rx_pending; i++) { - struct ring_info *re = sky2->rx_ring + i; - - re->skb = dev_alloc_skb(sky2->rx_bufsize); - if (!re->skb) - goto nomem; - - re->mapaddr = pci_map_single(hw->pdev, re->skb->data, - sky2->rx_bufsize, PCI_DMA_FROMDEVICE); - sky2_rx_add(sky2, re->mapaddr); - } - - /* Tell chip about available buffers */ - sky2_write16(hw, Y2_QADDR(rxq, PREF_UNIT_PUT_IDX), sky2->rx_put); - sky2->rx_last_put = sky2_read16(hw, Y2_QADDR(rxq, PREF_UNIT_PUT_IDX)); - return 0; -nomem: - sky2_rx_clean(sky2); - return -ENOMEM; -} - -/* Bring up network interface. */ -static int sky2_up(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - u32 ramsize, rxspace; - int err = -ENOMEM; - - if (netif_msg_ifup(sky2)) - printk(KERN_INFO PFX "%s: enabling interface\n", dev->name); - - /* must be power of 2 */ - sky2->tx_le = pci_alloc_consistent(hw->pdev, - TX_RING_SIZE * - sizeof(struct sky2_tx_le), - &sky2->tx_le_map); - if (!sky2->tx_le) - goto err_out; - - sky2->tx_ring = kcalloc(TX_RING_SIZE, sizeof(struct tx_ring_info), - GFP_KERNEL); - if (!sky2->tx_ring) - goto err_out; - sky2->tx_prod = sky2->tx_cons = 0; - - sky2->rx_le = pci_alloc_consistent(hw->pdev, RX_LE_BYTES, - &sky2->rx_le_map); - if (!sky2->rx_le) - goto err_out; - memset(sky2->rx_le, 0, RX_LE_BYTES); - - sky2->rx_ring = kcalloc(sky2->rx_pending, sizeof(struct ring_info), - GFP_KERNEL); - if (!sky2->rx_ring) - goto err_out; - - sky2_mac_init(hw, port); - - /* Configure RAM buffers */ - if (hw->chip_id == CHIP_ID_YUKON_FE || - (hw->chip_id == CHIP_ID_YUKON_EC && hw->chip_rev == 2)) - ramsize = 4096; - else { - u8 e0 = sky2_read8(hw, B2_E_0); - ramsize = (e0 == 0) ? (128 * 1024) : (e0 * 4096); - } - - /* 2/3 for Rx */ - rxspace = (2 * ramsize) / 3; - sky2_ramset(hw, rxqaddr[port], 0, rxspace); - sky2_ramset(hw, txqaddr[port], rxspace, ramsize - rxspace); - - /* Make sure SyncQ is disabled */ - sky2_write8(hw, RB_ADDR(port == 0 ? Q_XS1 : Q_XS2, RB_CTRL), - RB_RST_SET); - - sky2_qset(hw, txqaddr[port]); - if (hw->chip_id == CHIP_ID_YUKON_EC_U) - sky2_write16(hw, Q_ADDR(txqaddr[port], Q_AL), 0x1a0); - - - sky2_prefetch_init(hw, txqaddr[port], sky2->tx_le_map, - TX_RING_SIZE - 1); - - err = sky2_rx_start(sky2); - if (err) - goto err_out; - - /* Enable interrupts from phy/mac for port */ - hw->intr_mask |= (port == 0) ? Y2_IS_PORT_1 : Y2_IS_PORT_2; - sky2_write32(hw, B0_IMSK, hw->intr_mask); - return 0; - -err_out: - if (sky2->rx_le) { - pci_free_consistent(hw->pdev, RX_LE_BYTES, - sky2->rx_le, sky2->rx_le_map); - sky2->rx_le = NULL; - } - if (sky2->tx_le) { - pci_free_consistent(hw->pdev, - TX_RING_SIZE * sizeof(struct sky2_tx_le), - sky2->tx_le, sky2->tx_le_map); - sky2->tx_le = NULL; - } - kfree(sky2->tx_ring); - kfree(sky2->rx_ring); - - sky2->tx_ring = NULL; - sky2->rx_ring = NULL; - return err; -} - -/* Modular subtraction in ring */ -static inline int tx_dist(unsigned tail, unsigned head) -{ - return (head - tail) % TX_RING_SIZE; -} - -/* Number of list elements available for next tx */ -static inline int tx_avail(const struct sky2_port *sky2) -{ - return sky2->tx_pending - tx_dist(sky2->tx_cons, sky2->tx_prod); -} - -/* Estimate of number of transmit list elements required */ -static inline unsigned tx_le_req(const struct sk_buff *skb) -{ - unsigned count; - - count = sizeof(dma_addr_t) / sizeof(u32); - count += skb_shinfo(skb)->nr_frags * count; - - if (skb_shinfo(skb)->tso_size) - ++count; - - if (skb->ip_summed == CHECKSUM_HW) - ++count; - - return count; -} - -/* - * Put one packet in ring for transmit. - * A single packet can generate multiple list elements, and - * the number of ring elements will probably be less than the number - * of list elements used. - * - * No BH disabling for tx_lock here (like tg3) - */ -static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - struct sky2_tx_le *le = NULL; - struct tx_ring_info *re; - unsigned i, len; - dma_addr_t mapping; - u32 addr64; - u16 mss; - u8 ctrl; - - if (!spin_trylock(&sky2->tx_lock)) - return NETDEV_TX_LOCKED; - - if (unlikely(tx_avail(sky2) < tx_le_req(skb))) { - /* There is a known but harmless race with lockless tx - * and netif_stop_queue. - */ - if (!netif_queue_stopped(dev)) { - netif_stop_queue(dev); - printk(KERN_WARNING PFX "%s: ring full when queue awake!\n", - dev->name); - } - spin_unlock(&sky2->tx_lock); - - return NETDEV_TX_BUSY; - } - - if (unlikely(netif_msg_tx_queued(sky2))) - printk(KERN_DEBUG "%s: tx queued, slot %u, len %d\n", - dev->name, sky2->tx_prod, skb->len); - - len = skb_headlen(skb); - mapping = pci_map_single(hw->pdev, skb->data, len, PCI_DMA_TODEVICE); - addr64 = high32(mapping); - - re = sky2->tx_ring + sky2->tx_prod; - - /* Send high bits if changed or crosses boundary */ - if (addr64 != sky2->tx_addr64 || high32(mapping + len) != sky2->tx_addr64) { - le = get_tx_le(sky2); - le->tx.addr = cpu_to_le32(addr64); - le->ctrl = 0; - le->opcode = OP_ADDR64 | HW_OWNER; - sky2->tx_addr64 = high32(mapping + len); - } - - /* Check for TCP Segmentation Offload */ - mss = skb_shinfo(skb)->tso_size; - if (mss != 0) { - /* just drop the packet if non-linear expansion fails */ - if (skb_header_cloned(skb) && - pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) { - dev_kfree_skb_any(skb); - goto out_unlock; - } - - mss += ((skb->h.th->doff - 5) * 4); /* TCP options */ - mss += (skb->nh.iph->ihl * 4) + sizeof(struct tcphdr); - mss += ETH_HLEN; - } - - if (mss != sky2->tx_last_mss) { - le = get_tx_le(sky2); - le->tx.tso.size = cpu_to_le16(mss); - le->tx.tso.rsvd = 0; - le->opcode = OP_LRGLEN | HW_OWNER; - le->ctrl = 0; - sky2->tx_last_mss = mss; - } - - ctrl = 0; -#ifdef SKY2_VLAN_TAG_USED - /* Add VLAN tag, can piggyback on LRGLEN or ADDR64 */ - if (sky2->vlgrp && vlan_tx_tag_present(skb)) { - if (!le) { - le = get_tx_le(sky2); - le->tx.addr = 0; - le->opcode = OP_VLAN|HW_OWNER; - le->ctrl = 0; - } else - le->opcode |= OP_VLAN; - le->length = cpu_to_be16(vlan_tx_tag_get(skb)); - ctrl |= INS_VLAN; - } -#endif - - /* Handle TCP checksum offload */ - if (skb->ip_summed == CHECKSUM_HW) { - u16 hdr = skb->h.raw - skb->data; - u16 offset = hdr + skb->csum; - - ctrl = CALSUM | WR_SUM | INIT_SUM | LOCK_SUM; - if (skb->nh.iph->protocol == IPPROTO_UDP) - ctrl |= UDPTCP; - - le = get_tx_le(sky2); - le->tx.csum.start = cpu_to_le16(hdr); - le->tx.csum.offset = cpu_to_le16(offset); - le->length = 0; /* initial checksum value */ - le->ctrl = 1; /* one packet */ - le->opcode = OP_TCPLISW | HW_OWNER; - } - - le = get_tx_le(sky2); - le->tx.addr = cpu_to_le32((u32) mapping); - le->length = cpu_to_le16(len); - le->ctrl = ctrl; - le->opcode = mss ? (OP_LARGESEND | HW_OWNER) : (OP_PACKET | HW_OWNER); - - /* Record the transmit mapping info */ - re->skb = skb; - pci_unmap_addr_set(re, mapaddr, mapping); - - for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { - skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; - struct tx_ring_info *fre; - - mapping = pci_map_page(hw->pdev, frag->page, frag->page_offset, - frag->size, PCI_DMA_TODEVICE); - addr64 = (mapping >> 16) >> 16; - if (addr64 != sky2->tx_addr64) { - le = get_tx_le(sky2); - le->tx.addr = cpu_to_le32(addr64); - le->ctrl = 0; - le->opcode = OP_ADDR64 | HW_OWNER; - sky2->tx_addr64 = addr64; - } - - le = get_tx_le(sky2); - le->tx.addr = cpu_to_le32((u32) mapping); - le->length = cpu_to_le16(frag->size); - le->ctrl = ctrl; - le->opcode = OP_BUFFER | HW_OWNER; - - fre = sky2->tx_ring - + ((re - sky2->tx_ring) + i + 1) % TX_RING_SIZE; - pci_unmap_addr_set(fre, mapaddr, mapping); - } - - re->idx = sky2->tx_prod; - le->ctrl |= EOP; - - sky2_put_idx(hw, txqaddr[sky2->port], sky2->tx_prod, - &sky2->tx_last_put, TX_RING_SIZE); - - if (tx_avail(sky2) <= MAX_SKB_TX_LE) - netif_stop_queue(dev); - -out_unlock: - mmiowb(); - spin_unlock(&sky2->tx_lock); - - dev->trans_start = jiffies; - return NETDEV_TX_OK; -} - -/* - * Free ring elements from starting at tx_cons until "done" - * - * NB: the hardware will tell us about partial completion of multi-part - * buffers; these are deferred until completion. - */ -static void sky2_tx_complete(struct sky2_port *sky2, u16 done) -{ - struct net_device *dev = sky2->netdev; - struct pci_dev *pdev = sky2->hw->pdev; - u16 nxt, put; - unsigned i; - - BUG_ON(done >= TX_RING_SIZE); - - if (unlikely(netif_msg_tx_done(sky2))) - printk(KERN_DEBUG "%s: tx done, up to %u\n", - dev->name, done); - - for (put = sky2->tx_cons; put != done; put = nxt) { - struct tx_ring_info *re = sky2->tx_ring + put; - struct sk_buff *skb = re->skb; - - nxt = re->idx; - BUG_ON(nxt >= TX_RING_SIZE); - prefetch(sky2->tx_ring + nxt); - - /* Check for partial status */ - if (tx_dist(put, done) < tx_dist(put, nxt)) - break; - - skb = re->skb; - pci_unmap_single(pdev, pci_unmap_addr(re, mapaddr), - skb_headlen(skb), PCI_DMA_TODEVICE); - - for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { - struct tx_ring_info *fre; - fre = sky2->tx_ring + (put + i + 1) % TX_RING_SIZE; - pci_unmap_page(pdev, pci_unmap_addr(fre, mapaddr), - skb_shinfo(skb)->frags[i].size, - PCI_DMA_TODEVICE); - } - - dev_kfree_skb_any(skb); - } - - spin_lock(&sky2->tx_lock); - sky2->tx_cons = put; - if (netif_queue_stopped(dev) && tx_avail(sky2) > MAX_SKB_TX_LE) - netif_wake_queue(dev); - spin_unlock(&sky2->tx_lock); -} - -/* Cleanup all untransmitted buffers, assume transmitter not running */ -static void sky2_tx_clean(struct sky2_port *sky2) -{ - sky2_tx_complete(sky2, sky2->tx_prod); -} - -/* Network shutdown */ -static int sky2_down(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - u16 ctrl; - - /* Never really got started! */ - if (!sky2->tx_le) - return 0; - - if (netif_msg_ifdown(sky2)) - printk(KERN_INFO PFX "%s: disabling interface\n", dev->name); - - /* Stop more packets from being queued */ - netif_stop_queue(dev); - - /* Disable port IRQ */ - local_irq_disable(); - hw->intr_mask &= ~((sky2->port == 0) ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2); - sky2_write32(hw, B0_IMSK, hw->intr_mask); - local_irq_enable(); - - flush_scheduled_work(); - - sky2_phy_reset(hw, port); - - /* Stop transmitter */ - sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_STOP); - sky2_read32(hw, Q_ADDR(txqaddr[port], Q_CSR)); - - sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL), - RB_RST_SET | RB_DIS_OP_MD); - - ctrl = gma_read16(hw, port, GM_GP_CTRL); - ctrl &= ~(GM_GPCR_TX_ENA | GM_GPCR_RX_ENA); - gma_write16(hw, port, GM_GP_CTRL, ctrl); - - sky2_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET); - - /* Workaround shared GMAC reset */ - if (!(hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0 - && port == 0 && hw->dev[1] && netif_running(hw->dev[1]))) - sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_SET); - - /* Disable Force Sync bit and Enable Alloc bit */ - sky2_write8(hw, SK_REG(port, TXA_CTRL), - TXA_DIS_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC); - - /* Stop Interval Timer and Limit Counter of Tx Arbiter */ - sky2_write32(hw, SK_REG(port, TXA_ITI_INI), 0L); - sky2_write32(hw, SK_REG(port, TXA_LIM_INI), 0L); - - /* Reset the PCI FIFO of the async Tx queue */ - sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), - BMU_RST_SET | BMU_FIFO_RST); - - /* Reset the Tx prefetch units */ - sky2_write32(hw, Y2_QADDR(txqaddr[port], PREF_UNIT_CTRL), - PREF_UNIT_RST_SET); - - sky2_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL), RB_RST_SET); - - sky2_rx_stop(sky2); - - sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_SET); - sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_SET); - - /* turn off LED's */ - sky2_write16(hw, B0_Y2LED, LED_STAT_OFF); - - synchronize_irq(hw->pdev->irq); - - sky2_tx_clean(sky2); - sky2_rx_clean(sky2); - - pci_free_consistent(hw->pdev, RX_LE_BYTES, - sky2->rx_le, sky2->rx_le_map); - kfree(sky2->rx_ring); - - pci_free_consistent(hw->pdev, - TX_RING_SIZE * sizeof(struct sky2_tx_le), - sky2->tx_le, sky2->tx_le_map); - kfree(sky2->tx_ring); - - sky2->tx_le = NULL; - sky2->rx_le = NULL; - - sky2->rx_ring = NULL; - sky2->tx_ring = NULL; - - return 0; -} - -static u16 sky2_phy_speed(const struct sky2_hw *hw, u16 aux) -{ - if (!hw->copper) - return SPEED_1000; - - if (hw->chip_id == CHIP_ID_YUKON_FE) - return (aux & PHY_M_PS_SPEED_100) ? SPEED_100 : SPEED_10; - - switch (aux & PHY_M_PS_SPEED_MSK) { - case PHY_M_PS_SPEED_1000: - return SPEED_1000; - case PHY_M_PS_SPEED_100: - return SPEED_100; - default: - return SPEED_10; - } -} - -static void sky2_link_up(struct sky2_port *sky2) -{ - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - u16 reg; - - /* Enable Transmit FIFO Underrun */ - sky2_write8(hw, SK_REG(port, GMAC_IRQ_MSK), GMAC_DEF_MSK); - - reg = gma_read16(hw, port, GM_GP_CTRL); - if (sky2->duplex == DUPLEX_FULL || sky2->autoneg == AUTONEG_ENABLE) - reg |= GM_GPCR_DUP_FULL; - - /* enable Rx/Tx */ - reg |= GM_GPCR_RX_ENA | GM_GPCR_TX_ENA; - gma_write16(hw, port, GM_GP_CTRL, reg); - gma_read16(hw, port, GM_GP_CTRL); - - gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_DEF_MSK); - - netif_carrier_on(sky2->netdev); - netif_wake_queue(sky2->netdev); - - /* Turn on link LED */ - sky2_write8(hw, SK_REG(port, LNK_LED_REG), - LINKLED_ON | LINKLED_BLINK_OFF | LINKLED_LINKSYNC_OFF); - - if (hw->chip_id == CHIP_ID_YUKON_XL) { - u16 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR); - - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3); - gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, PHY_M_LEDC_LOS_CTRL(1) | /* LINK/ACT */ - PHY_M_LEDC_INIT_CTRL(sky2->speed == - SPEED_10 ? 7 : 0) | - PHY_M_LEDC_STA1_CTRL(sky2->speed == - SPEED_100 ? 7 : 0) | - PHY_M_LEDC_STA0_CTRL(sky2->speed == - SPEED_1000 ? 7 : 0)); - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg); - } - - if (netif_msg_link(sky2)) - printk(KERN_INFO PFX - "%s: Link is up at %d Mbps, %s duplex, flow control %s\n", - sky2->netdev->name, sky2->speed, - sky2->duplex == DUPLEX_FULL ? "full" : "half", - (sky2->tx_pause && sky2->rx_pause) ? "both" : - sky2->tx_pause ? "tx" : sky2->rx_pause ? "rx" : "none"); -} - -static void sky2_link_down(struct sky2_port *sky2) -{ - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - u16 reg; - - gm_phy_write(hw, port, PHY_MARV_INT_MASK, 0); - - reg = gma_read16(hw, port, GM_GP_CTRL); - reg &= ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA); - gma_write16(hw, port, GM_GP_CTRL, reg); - gma_read16(hw, port, GM_GP_CTRL); /* PCI post */ - - if (sky2->rx_pause && !sky2->tx_pause) { - /* restore Asymmetric Pause bit */ - gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, - gm_phy_read(hw, port, PHY_MARV_AUNE_ADV) - | PHY_M_AN_ASP); - } - - netif_carrier_off(sky2->netdev); - netif_stop_queue(sky2->netdev); - - /* Turn on link LED */ - sky2_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_OFF); - - if (netif_msg_link(sky2)) - printk(KERN_INFO PFX "%s: Link is down.\n", sky2->netdev->name); - sky2_phy_init(hw, port); -} - -static int sky2_autoneg_done(struct sky2_port *sky2, u16 aux) -{ - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - u16 lpa; - - lpa = gm_phy_read(hw, port, PHY_MARV_AUNE_LP); - - if (lpa & PHY_M_AN_RF) { - printk(KERN_ERR PFX "%s: remote fault", sky2->netdev->name); - return -1; - } - - if (hw->chip_id != CHIP_ID_YUKON_FE && - gm_phy_read(hw, port, PHY_MARV_1000T_STAT) & PHY_B_1000S_MSF) { - printk(KERN_ERR PFX "%s: master/slave fault", - sky2->netdev->name); - return -1; - } - - if (!(aux & PHY_M_PS_SPDUP_RES)) { - printk(KERN_ERR PFX "%s: speed/duplex mismatch", - sky2->netdev->name); - return -1; - } - - sky2->duplex = (aux & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF; - - sky2->speed = sky2_phy_speed(hw, aux); - - /* Pause bits are offset (9..8) */ - if (hw->chip_id == CHIP_ID_YUKON_XL) - aux >>= 6; - - sky2->rx_pause = (aux & PHY_M_PS_RX_P_EN) != 0; - sky2->tx_pause = (aux & PHY_M_PS_TX_P_EN) != 0; - - if ((sky2->tx_pause || sky2->rx_pause) - && !(sky2->speed < SPEED_1000 && sky2->duplex == DUPLEX_HALF)) - sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON); - else - sky2_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF); - - return 0; -} - -/* - * Interrupt from PHY are handled outside of interrupt context - * because accessing phy registers requires spin wait which might - * cause excess interrupt latency. - */ -static void sky2_phy_task(void *arg) -{ - struct sky2_port *sky2 = arg; - struct sky2_hw *hw = sky2->hw; - u16 istatus, phystat; - - down(&sky2->phy_sema); - istatus = gm_phy_read(hw, sky2->port, PHY_MARV_INT_STAT); - phystat = gm_phy_read(hw, sky2->port, PHY_MARV_PHY_STAT); - - if (netif_msg_intr(sky2)) - printk(KERN_INFO PFX "%s: phy interrupt status 0x%x 0x%x\n", - sky2->netdev->name, istatus, phystat); - - if (istatus & PHY_M_IS_AN_COMPL) { - if (sky2_autoneg_done(sky2, phystat) == 0) - sky2_link_up(sky2); - goto out; - } - - if (istatus & PHY_M_IS_LSP_CHANGE) - sky2->speed = sky2_phy_speed(hw, phystat); - - if (istatus & PHY_M_IS_DUP_CHANGE) - sky2->duplex = - (phystat & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF; - - if (istatus & PHY_M_IS_LST_CHANGE) { - if (phystat & PHY_M_PS_LINK_UP) - sky2_link_up(sky2); - else - sky2_link_down(sky2); - } -out: - up(&sky2->phy_sema); - - local_irq_disable(); - hw->intr_mask |= (sky2->port == 0) ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2; - sky2_write32(hw, B0_IMSK, hw->intr_mask); - local_irq_enable(); -} - -static void sky2_tx_timeout(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - unsigned txq = txqaddr[sky2->port]; - - if (netif_msg_timer(sky2)) - printk(KERN_ERR PFX "%s: tx timeout\n", dev->name); - - netif_stop_queue(dev); - - sky2_write32(hw, Q_ADDR(txq, Q_CSR), BMU_STOP); - sky2_read32(hw, Q_ADDR(txq, Q_CSR)); - - sky2_write32(hw, Y2_QADDR(txq, PREF_UNIT_CTRL), PREF_UNIT_RST_SET); - - sky2_tx_clean(sky2); - - sky2_qset(hw, txq); - sky2_prefetch_init(hw, txq, sky2->tx_le_map, TX_RING_SIZE - 1); - - netif_wake_queue(dev); -} - - -#define roundup(x, y) ((((x)+((y)-1))/(y))*(y)) -/* Want receive buffer size to be multiple of 64 bits, and incl room for vlan */ -static inline unsigned sky2_buf_size(int mtu) -{ - return roundup(mtu + ETH_HLEN + 4, 8); -} - -static int sky2_change_mtu(struct net_device *dev, int new_mtu) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - int err; - u16 ctl, mode; - - if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU) - return -EINVAL; - - if (hw->chip_id == CHIP_ID_YUKON_EC_U && new_mtu > ETH_DATA_LEN) - return -EINVAL; - - if (!netif_running(dev)) { - dev->mtu = new_mtu; - return 0; - } - - sky2_write32(hw, B0_IMSK, 0); - - dev->trans_start = jiffies; /* prevent tx timeout */ - netif_stop_queue(dev); - netif_poll_disable(hw->dev[0]); - - ctl = gma_read16(hw, sky2->port, GM_GP_CTRL); - gma_write16(hw, sky2->port, GM_GP_CTRL, ctl & ~GM_GPCR_RX_ENA); - sky2_rx_stop(sky2); - sky2_rx_clean(sky2); - - dev->mtu = new_mtu; - sky2->rx_bufsize = sky2_buf_size(new_mtu); - mode = DATA_BLIND_VAL(DATA_BLIND_DEF) | - GM_SMOD_VLAN_ENA | IPG_DATA_VAL(IPG_DATA_DEF); - - if (dev->mtu > ETH_DATA_LEN) - mode |= GM_SMOD_JUMBO_ENA; - - gma_write16(hw, sky2->port, GM_SERIAL_MODE, mode); - - sky2_write8(hw, RB_ADDR(rxqaddr[sky2->port], RB_CTRL), RB_ENA_OP_MD); - - err = sky2_rx_start(sky2); - sky2_write32(hw, B0_IMSK, hw->intr_mask); - - if (err) - dev_close(dev); - else { - gma_write16(hw, sky2->port, GM_GP_CTRL, ctl); - - netif_poll_enable(hw->dev[0]); - netif_wake_queue(dev); - } - - return err; -} - -/* - * Receive one packet. - * For small packets or errors, just reuse existing skb. - * For larger packets, get new buffer. - */ -static struct sk_buff *sky2_receive(struct sky2_port *sky2, - u16 length, u32 status) -{ - struct ring_info *re = sky2->rx_ring + sky2->rx_next; - struct sk_buff *skb = NULL; - - if (unlikely(netif_msg_rx_status(sky2))) - printk(KERN_DEBUG PFX "%s: rx slot %u status 0x%x len %d\n", - sky2->netdev->name, sky2->rx_next, status, length); - - sky2->rx_next = (sky2->rx_next + 1) % sky2->rx_pending; - prefetch(sky2->rx_ring + sky2->rx_next); - - if (status & GMR_FS_ANY_ERR) - goto error; - - if (!(status & GMR_FS_RX_OK)) - goto resubmit; - - if ((status >> 16) != length || length > sky2->rx_bufsize) - goto oversize; - - if (length < copybreak) { - skb = alloc_skb(length + 2, GFP_ATOMIC); - if (!skb) - goto resubmit; - - skb_reserve(skb, 2); - pci_dma_sync_single_for_cpu(sky2->hw->pdev, re->mapaddr, - length, PCI_DMA_FROMDEVICE); - memcpy(skb->data, re->skb->data, length); - skb->ip_summed = re->skb->ip_summed; - skb->csum = re->skb->csum; - pci_dma_sync_single_for_device(sky2->hw->pdev, re->mapaddr, - length, PCI_DMA_FROMDEVICE); - } else { - struct sk_buff *nskb; - - nskb = dev_alloc_skb(sky2->rx_bufsize); - if (!nskb) - goto resubmit; - - skb = re->skb; - re->skb = nskb; - pci_unmap_single(sky2->hw->pdev, re->mapaddr, - sky2->rx_bufsize, PCI_DMA_FROMDEVICE); - prefetch(skb->data); - - re->mapaddr = pci_map_single(sky2->hw->pdev, nskb->data, - sky2->rx_bufsize, PCI_DMA_FROMDEVICE); - } - - skb_put(skb, length); -resubmit: - re->skb->ip_summed = CHECKSUM_NONE; - sky2_rx_add(sky2, re->mapaddr); - - /* Tell receiver about new buffers. */ - sky2_put_idx(sky2->hw, rxqaddr[sky2->port], sky2->rx_put, - &sky2->rx_last_put, RX_LE_SIZE); - - return skb; - -oversize: - ++sky2->net_stats.rx_over_errors; - goto resubmit; - -error: - ++sky2->net_stats.rx_errors; - - if (netif_msg_rx_err(sky2)) - printk(KERN_INFO PFX "%s: rx error, status 0x%x length %d\n", - sky2->netdev->name, status, length); - - if (status & (GMR_FS_LONG_ERR | GMR_FS_UN_SIZE)) - sky2->net_stats.rx_length_errors++; - if (status & GMR_FS_FRAGMENT) - sky2->net_stats.rx_frame_errors++; - if (status & GMR_FS_CRC_ERR) - sky2->net_stats.rx_crc_errors++; - if (status & GMR_FS_RX_FF_OV) - sky2->net_stats.rx_fifo_errors++; - - goto resubmit; -} - -/* - * Check for transmit complete - */ -#define TX_NO_STATUS 0xffff - -static inline void sky2_tx_check(struct sky2_hw *hw, int port, u16 last) -{ - if (last != TX_NO_STATUS) { - struct net_device *dev = hw->dev[port]; - if (dev && netif_running(dev)) { - struct sky2_port *sky2 = netdev_priv(dev); - sky2_tx_complete(sky2, last); - } - } -} - -/* - * Both ports share the same status interrupt, therefore there is only - * one poll routine. - */ -static int sky2_poll(struct net_device *dev0, int *budget) -{ - struct sky2_hw *hw = ((struct sky2_port *) netdev_priv(dev0))->hw; - unsigned int to_do = min(dev0->quota, *budget); - unsigned int work_done = 0; - u16 hwidx; - u16 tx_done[2] = { TX_NO_STATUS, TX_NO_STATUS }; - - hwidx = sky2_read16(hw, STAT_PUT_IDX); - BUG_ON(hwidx >= STATUS_RING_SIZE); - rmb(); - - while (hwidx != hw->st_idx) { - struct sky2_status_le *le = hw->st_le + hw->st_idx; - struct net_device *dev; - struct sky2_port *sky2; - struct sk_buff *skb; - u32 status; - u16 length; - u8 op; - - le = hw->st_le + hw->st_idx; - hw->st_idx = (hw->st_idx + 1) % STATUS_RING_SIZE; - prefetch(hw->st_le + hw->st_idx); - - BUG_ON(le->link >= 2); - dev = hw->dev[le->link]; - if (dev == NULL || !netif_running(dev)) - continue; - - sky2 = netdev_priv(dev); - status = le32_to_cpu(le->status); - length = le16_to_cpu(le->length); - op = le->opcode & ~HW_OWNER; - le->opcode = 0; - - switch (op) { - case OP_RXSTAT: - skb = sky2_receive(sky2, length, status); - if (!skb) - break; - - skb->dev = dev; - skb->protocol = eth_type_trans(skb, dev); - dev->last_rx = jiffies; - -#ifdef SKY2_VLAN_TAG_USED - if (sky2->vlgrp && (status & GMR_FS_VLAN)) { - vlan_hwaccel_receive_skb(skb, - sky2->vlgrp, - be16_to_cpu(sky2->rx_tag)); - } else -#endif - netif_receive_skb(skb); - - if (++work_done >= to_do) - goto exit_loop; - break; - -#ifdef SKY2_VLAN_TAG_USED - case OP_RXVLAN: - sky2->rx_tag = length; - break; - - case OP_RXCHKSVLAN: - sky2->rx_tag = length; - /* fall through */ -#endif - case OP_RXCHKS: - skb = sky2->rx_ring[sky2->rx_next].skb; - skb->ip_summed = CHECKSUM_HW; - skb->csum = le16_to_cpu(status); - break; - - case OP_TXINDEXLE: - /* TX index reports status for both ports */ - tx_done[0] = status & 0xffff; - tx_done[1] = ((status >> 24) & 0xff) - | (u16)(length & 0xf) << 8; - break; - - default: - if (net_ratelimit()) - printk(KERN_WARNING PFX - "unknown status opcode 0x%x\n", op); - break; - } - } - -exit_loop: - sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ); - mmiowb(); - - sky2_tx_check(hw, 0, tx_done[0]); - sky2_tx_check(hw, 1, tx_done[1]); - - if (sky2_read16(hw, STAT_PUT_IDX) == hw->st_idx) { - /* need to restart TX timer */ - if (is_ec_a1(hw)) { - sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP); - sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START); - } - - netif_rx_complete(dev0); - hw->intr_mask |= Y2_IS_STAT_BMU; - sky2_write32(hw, B0_IMSK, hw->intr_mask); - mmiowb(); - return 0; - } else { - *budget -= work_done; - dev0->quota -= work_done; - return 1; - } -} - -static void sky2_hw_error(struct sky2_hw *hw, unsigned port, u32 status) -{ - struct net_device *dev = hw->dev[port]; - - printk(KERN_INFO PFX "%s: hw error interrupt status 0x%x\n", - dev->name, status); - - if (status & Y2_IS_PAR_RD1) { - printk(KERN_ERR PFX "%s: ram data read parity error\n", - dev->name); - /* Clear IRQ */ - sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_RD_PERR); - } - - if (status & Y2_IS_PAR_WR1) { - printk(KERN_ERR PFX "%s: ram data write parity error\n", - dev->name); - - sky2_write16(hw, RAM_BUFFER(port, B3_RI_CTRL), RI_CLR_WR_PERR); - } - - if (status & Y2_IS_PAR_MAC1) { - printk(KERN_ERR PFX "%s: MAC parity error\n", dev->name); - sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_PE); - } - - if (status & Y2_IS_PAR_RX1) { - printk(KERN_ERR PFX "%s: RX parity error\n", dev->name); - sky2_write32(hw, Q_ADDR(rxqaddr[port], Q_CSR), BMU_CLR_IRQ_PAR); - } - - if (status & Y2_IS_TCP_TXA1) { - printk(KERN_ERR PFX "%s: TCP segmentation error\n", dev->name); - sky2_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), BMU_CLR_IRQ_TCP); - } -} - -static void sky2_hw_intr(struct sky2_hw *hw) -{ - u32 status = sky2_read32(hw, B0_HWE_ISRC); - - if (status & Y2_IS_TIST_OV) - sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ); - - if (status & (Y2_IS_MST_ERR | Y2_IS_IRQ_STAT)) { - u16 pci_err; - - pci_read_config_word(hw->pdev, PCI_STATUS, &pci_err); - printk(KERN_ERR PFX "%s: pci hw error (0x%x)\n", - pci_name(hw->pdev), pci_err); - - sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); - pci_write_config_word(hw->pdev, PCI_STATUS, - pci_err | PCI_STATUS_ERROR_BITS); - sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); - } - - if (status & Y2_IS_PCI_EXP) { - /* PCI-Express uncorrectable Error occurred */ - u32 pex_err; - - pci_read_config_dword(hw->pdev, PEX_UNC_ERR_STAT, &pex_err); - - printk(KERN_ERR PFX "%s: pci express error (0x%x)\n", - pci_name(hw->pdev), pex_err); - - /* clear the interrupt */ - sky2_write32(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); - pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT, - 0xffffffffUL); - sky2_write32(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); - - if (pex_err & PEX_FATAL_ERRORS) { - u32 hwmsk = sky2_read32(hw, B0_HWE_IMSK); - hwmsk &= ~Y2_IS_PCI_EXP; - sky2_write32(hw, B0_HWE_IMSK, hwmsk); - } - } - - if (status & Y2_HWE_L1_MASK) - sky2_hw_error(hw, 0, status); - status >>= 8; - if (status & Y2_HWE_L1_MASK) - sky2_hw_error(hw, 1, status); -} - -static void sky2_mac_intr(struct sky2_hw *hw, unsigned port) -{ - struct net_device *dev = hw->dev[port]; - struct sky2_port *sky2 = netdev_priv(dev); - u8 status = sky2_read8(hw, SK_REG(port, GMAC_IRQ_SRC)); - - if (netif_msg_intr(sky2)) - printk(KERN_INFO PFX "%s: mac interrupt status 0x%x\n", - dev->name, status); - - if (status & GM_IS_RX_FF_OR) { - ++sky2->net_stats.rx_fifo_errors; - sky2_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_CLI_RX_FO); - } - - if (status & GM_IS_TX_FF_UR) { - ++sky2->net_stats.tx_fifo_errors; - sky2_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_CLI_TX_FU); - } -} - -static void sky2_phy_intr(struct sky2_hw *hw, unsigned port) -{ - struct net_device *dev = hw->dev[port]; - struct sky2_port *sky2 = netdev_priv(dev); - - hw->intr_mask &= ~(port == 0 ? Y2_IS_IRQ_PHY1 : Y2_IS_IRQ_PHY2); - sky2_write32(hw, B0_IMSK, hw->intr_mask); - schedule_work(&sky2->phy_task); -} - -static irqreturn_t sky2_intr(int irq, void *dev_id, struct pt_regs *regs) -{ - struct sky2_hw *hw = dev_id; - struct net_device *dev0 = hw->dev[0]; - u32 status; - - status = sky2_read32(hw, B0_Y2_SP_ISRC2); - if (status == 0 || status == ~0) - return IRQ_NONE; - - if (status & Y2_IS_HW_ERR) - sky2_hw_intr(hw); - - /* Do NAPI for Rx and Tx status */ - if (status & Y2_IS_STAT_BMU) { - hw->intr_mask &= ~Y2_IS_STAT_BMU; - sky2_write32(hw, B0_IMSK, hw->intr_mask); - - if (likely(__netif_rx_schedule_prep(dev0))) { - prefetch(&hw->st_le[hw->st_idx]); - __netif_rx_schedule(dev0); - } - } - - if (status & Y2_IS_IRQ_PHY1) - sky2_phy_intr(hw, 0); - - if (status & Y2_IS_IRQ_PHY2) - sky2_phy_intr(hw, 1); - - if (status & Y2_IS_IRQ_MAC1) - sky2_mac_intr(hw, 0); - - if (status & Y2_IS_IRQ_MAC2) - sky2_mac_intr(hw, 1); - - sky2_write32(hw, B0_Y2_SP_ICR, 2); - - sky2_read32(hw, B0_IMSK); - - return IRQ_HANDLED; -} - -#ifdef CONFIG_NET_POLL_CONTROLLER -static void sky2_netpoll(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - sky2_intr(sky2->hw->pdev->irq, sky2->hw, NULL); -} -#endif - -/* Chip internal frequency for clock calculations */ -static inline u32 sky2_mhz(const struct sky2_hw *hw) -{ - switch (hw->chip_id) { - case CHIP_ID_YUKON_EC: - case CHIP_ID_YUKON_EC_U: - return 125; /* 125 Mhz */ - case CHIP_ID_YUKON_FE: - return 100; /* 100 Mhz */ - default: /* YUKON_XL */ - return 156; /* 156 Mhz */ - } -} - -static inline u32 sky2_us2clk(const struct sky2_hw *hw, u32 us) -{ - return sky2_mhz(hw) * us; -} - -static inline u32 sky2_clk2us(const struct sky2_hw *hw, u32 clk) -{ - return clk / sky2_mhz(hw); -} - - -static int sky2_reset(struct sky2_hw *hw) -{ - u32 ctst; - u16 status; - u8 t8, pmd_type; - int i; - - ctst = sky2_read32(hw, B0_CTST); - - sky2_write8(hw, B0_CTST, CS_RST_CLR); - hw->chip_id = sky2_read8(hw, B2_CHIP_ID); - if (hw->chip_id < CHIP_ID_YUKON_XL || hw->chip_id > CHIP_ID_YUKON_FE) { - printk(KERN_ERR PFX "%s: unsupported chip type 0x%x\n", - pci_name(hw->pdev), hw->chip_id); - return -EOPNOTSUPP; - } - - /* ring for status responses */ - hw->st_le = pci_alloc_consistent(hw->pdev, STATUS_LE_BYTES, - &hw->st_dma); - if (!hw->st_le) - return -ENOMEM; - - /* disable ASF */ - if (hw->chip_id <= CHIP_ID_YUKON_EC) { - sky2_write8(hw, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET); - sky2_write16(hw, B0_CTST, Y2_ASF_DISABLE); - } - - /* do a SW reset */ - sky2_write8(hw, B0_CTST, CS_RST_SET); - sky2_write8(hw, B0_CTST, CS_RST_CLR); - - /* clear PCI errors, if any */ - pci_read_config_word(hw->pdev, PCI_STATUS, &status); - sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON); - pci_write_config_word(hw->pdev, PCI_STATUS, - status | PCI_STATUS_ERROR_BITS); - - sky2_write8(hw, B0_CTST, CS_MRST_CLR); - - /* clear any PEX errors */ - if (is_pciex(hw)) { - u16 lstat; - pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT, - 0xffffffffUL); - pci_read_config_word(hw->pdev, PEX_LNK_STAT, &lstat); - } - - pmd_type = sky2_read8(hw, B2_PMD_TYP); - hw->copper = !(pmd_type == 'L' || pmd_type == 'S'); - - hw->ports = 1; - t8 = sky2_read8(hw, B2_Y2_HW_RES); - if ((t8 & CFG_DUAL_MAC_MSK) == CFG_DUAL_MAC_MSK) { - if (!(sky2_read8(hw, B2_Y2_CLK_GATE) & Y2_STATUS_LNK2_INAC)) - ++hw->ports; - } - hw->chip_rev = (sky2_read8(hw, B2_MAC_CFG) & CFG_CHIP_R_MSK) >> 4; - - sky2_set_power_state(hw, PCI_D0); - - for (i = 0; i < hw->ports; i++) { - sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_SET); - sky2_write8(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_CLR); - } - - sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF); - - /* Clear I2C IRQ noise */ - sky2_write32(hw, B2_I2C_IRQ, 1); - - /* turn off hardware timer (unused) */ - sky2_write8(hw, B2_TI_CTRL, TIM_STOP); - sky2_write8(hw, B2_TI_CTRL, TIM_CLR_IRQ); - - sky2_write8(hw, B0_Y2LED, LED_STAT_ON); - - /* Turn off descriptor polling */ - sky2_write32(hw, B28_DPT_CTRL, DPT_STOP); - - /* Turn off receive timestamp */ - sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_STOP); - sky2_write8(hw, GMAC_TI_ST_CTRL, GMT_ST_CLR_IRQ); - - /* enable the Tx Arbiters */ - for (i = 0; i < hw->ports; i++) - sky2_write8(hw, SK_REG(i, TXA_CTRL), TXA_ENA_ARB); - - /* Initialize ram interface */ - for (i = 0; i < hw->ports; i++) { - sky2_write8(hw, RAM_BUFFER(i, B3_RI_CTRL), RI_RST_CLR); - - sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R1), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA1), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS1), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R1), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA1), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS1), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_R2), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XA2), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_WTO_XS2), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_R2), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XA2), SK_RI_TO_53); - sky2_write8(hw, RAM_BUFFER(i, B3_RI_RTO_XS2), SK_RI_TO_53); - } - - sky2_write32(hw, B0_HWE_IMSK, Y2_HWE_ALL_MASK); - - for (i = 0; i < hw->ports; i++) - sky2_phy_reset(hw, i); - - memset(hw->st_le, 0, STATUS_LE_BYTES); - hw->st_idx = 0; - - sky2_write32(hw, STAT_CTRL, SC_STAT_RST_SET); - sky2_write32(hw, STAT_CTRL, SC_STAT_RST_CLR); - - sky2_write32(hw, STAT_LIST_ADDR_LO, hw->st_dma); - sky2_write32(hw, STAT_LIST_ADDR_HI, (u64) hw->st_dma >> 32); - - /* Set the list last index */ - sky2_write16(hw, STAT_LAST_IDX, STATUS_RING_SIZE - 1); - - /* These status setup values are copied from SysKonnect's driver */ - if (is_ec_a1(hw)) { - /* WA for dev. #4.3 */ - sky2_write16(hw, STAT_TX_IDX_TH, 0xfff); /* Tx Threshold */ - - /* set Status-FIFO watermark */ - sky2_write8(hw, STAT_FIFO_WM, 0x21); /* WA for dev. #4.18 */ - - /* set Status-FIFO ISR watermark */ - sky2_write8(hw, STAT_FIFO_ISR_WM, 0x07); /* WA for dev. #4.18 */ - sky2_write32(hw, STAT_TX_TIMER_INI, sky2_us2clk(hw, 10000)); - } else { - sky2_write16(hw, STAT_TX_IDX_TH, 10); - sky2_write8(hw, STAT_FIFO_WM, 16); - - /* set Status-FIFO ISR watermark */ - if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev == 0) - sky2_write8(hw, STAT_FIFO_ISR_WM, 4); - else - sky2_write8(hw, STAT_FIFO_ISR_WM, 16); - - sky2_write32(hw, STAT_TX_TIMER_INI, sky2_us2clk(hw, 1000)); - sky2_write32(hw, STAT_LEV_TIMER_INI, sky2_us2clk(hw, 100)); - sky2_write32(hw, STAT_ISR_TIMER_INI, sky2_us2clk(hw, 20)); - } - - /* enable status unit */ - sky2_write32(hw, STAT_CTRL, SC_STAT_OP_ON); - - sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START); - sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_START); - sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START); - - return 0; -} - -static inline u32 sky2_supported_modes(const struct sky2_hw *hw) -{ - u32 modes; - if (hw->copper) { - modes = SUPPORTED_10baseT_Half - | SUPPORTED_10baseT_Full - | SUPPORTED_100baseT_Half - | SUPPORTED_100baseT_Full - | SUPPORTED_Autoneg | SUPPORTED_TP; - - if (hw->chip_id != CHIP_ID_YUKON_FE) - modes |= SUPPORTED_1000baseT_Half - | SUPPORTED_1000baseT_Full; - } else - modes = SUPPORTED_1000baseT_Full | SUPPORTED_FIBRE - | SUPPORTED_Autoneg; - return modes; -} - -static int sky2_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - - ecmd->transceiver = XCVR_INTERNAL; - ecmd->supported = sky2_supported_modes(hw); - ecmd->phy_address = PHY_ADDR_MARV; - if (hw->copper) { - ecmd->supported = SUPPORTED_10baseT_Half - | SUPPORTED_10baseT_Full - | SUPPORTED_100baseT_Half - | SUPPORTED_100baseT_Full - | SUPPORTED_1000baseT_Half - | SUPPORTED_1000baseT_Full - | SUPPORTED_Autoneg | SUPPORTED_TP; - ecmd->port = PORT_TP; - } else - ecmd->port = PORT_FIBRE; - - ecmd->advertising = sky2->advertising; - ecmd->autoneg = sky2->autoneg; - ecmd->speed = sky2->speed; - ecmd->duplex = sky2->duplex; - return 0; -} - -static int sky2_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) -{ - struct sky2_port *sky2 = netdev_priv(dev); - const struct sky2_hw *hw = sky2->hw; - u32 supported = sky2_supported_modes(hw); - - if (ecmd->autoneg == AUTONEG_ENABLE) { - ecmd->advertising = supported; - sky2->duplex = -1; - sky2->speed = -1; - } else { - u32 setting; - - switch (ecmd->speed) { - case SPEED_1000: - if (ecmd->duplex == DUPLEX_FULL) - setting = SUPPORTED_1000baseT_Full; - else if (ecmd->duplex == DUPLEX_HALF) - setting = SUPPORTED_1000baseT_Half; - else - return -EINVAL; - break; - case SPEED_100: - if (ecmd->duplex == DUPLEX_FULL) - setting = SUPPORTED_100baseT_Full; - else if (ecmd->duplex == DUPLEX_HALF) - setting = SUPPORTED_100baseT_Half; - else - return -EINVAL; - break; - - case SPEED_10: - if (ecmd->duplex == DUPLEX_FULL) - setting = SUPPORTED_10baseT_Full; - else if (ecmd->duplex == DUPLEX_HALF) - setting = SUPPORTED_10baseT_Half; - else - return -EINVAL; - break; - default: - return -EINVAL; - } - - if ((setting & supported) == 0) - return -EINVAL; - - sky2->speed = ecmd->speed; - sky2->duplex = ecmd->duplex; - } - - sky2->autoneg = ecmd->autoneg; - sky2->advertising = ecmd->advertising; - - if (netif_running(dev)) - sky2_phy_reinit(sky2); - - return 0; -} - -static void sky2_get_drvinfo(struct net_device *dev, - struct ethtool_drvinfo *info) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - strcpy(info->driver, DRV_NAME); - strcpy(info->version, DRV_VERSION); - strcpy(info->fw_version, "N/A"); - strcpy(info->bus_info, pci_name(sky2->hw->pdev)); -} - -static const struct sky2_stat { - char name[ETH_GSTRING_LEN]; - u16 offset; -} sky2_stats[] = { - { "tx_bytes", GM_TXO_OK_HI }, - { "rx_bytes", GM_RXO_OK_HI }, - { "tx_broadcast", GM_TXF_BC_OK }, - { "rx_broadcast", GM_RXF_BC_OK }, - { "tx_multicast", GM_TXF_MC_OK }, - { "rx_multicast", GM_RXF_MC_OK }, - { "tx_unicast", GM_TXF_UC_OK }, - { "rx_unicast", GM_RXF_UC_OK }, - { "tx_mac_pause", GM_TXF_MPAUSE }, - { "rx_mac_pause", GM_RXF_MPAUSE }, - { "collisions", GM_TXF_SNG_COL }, - { "late_collision",GM_TXF_LAT_COL }, - { "aborted", GM_TXF_ABO_COL }, - { "multi_collisions", GM_TXF_MUL_COL }, - { "fifo_underrun", GM_TXE_FIFO_UR }, - { "fifo_overflow", GM_RXE_FIFO_OV }, - { "rx_toolong", GM_RXF_LNG_ERR }, - { "rx_jabber", GM_RXF_JAB_PKT }, - { "rx_runt", GM_RXE_FRAG }, - { "rx_too_long", GM_RXF_LNG_ERR }, - { "rx_fcs_error", GM_RXF_FCS_ERR }, -}; - -static u32 sky2_get_rx_csum(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - return sky2->rx_csum; -} - -static int sky2_set_rx_csum(struct net_device *dev, u32 data) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - sky2->rx_csum = data; - - sky2_write32(sky2->hw, Q_ADDR(rxqaddr[sky2->port], Q_CSR), - data ? BMU_ENA_RX_CHKSUM : BMU_DIS_RX_CHKSUM); - - return 0; -} - -static u32 sky2_get_msglevel(struct net_device *netdev) -{ - struct sky2_port *sky2 = netdev_priv(netdev); - return sky2->msg_enable; -} - -static int sky2_nway_reset(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - if (sky2->autoneg != AUTONEG_ENABLE) - return -EINVAL; - - sky2_phy_reinit(sky2); - - return 0; -} - -static void sky2_phy_stats(struct sky2_port *sky2, u64 * data, unsigned count) -{ - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - int i; - - data[0] = (u64) gma_read32(hw, port, GM_TXO_OK_HI) << 32 - | (u64) gma_read32(hw, port, GM_TXO_OK_LO); - data[1] = (u64) gma_read32(hw, port, GM_RXO_OK_HI) << 32 - | (u64) gma_read32(hw, port, GM_RXO_OK_LO); - - for (i = 2; i < count; i++) - data[i] = (u64) gma_read32(hw, port, sky2_stats[i].offset); -} - -static void sky2_set_msglevel(struct net_device *netdev, u32 value) -{ - struct sky2_port *sky2 = netdev_priv(netdev); - sky2->msg_enable = value; -} - -static int sky2_get_stats_count(struct net_device *dev) -{ - return ARRAY_SIZE(sky2_stats); -} - -static void sky2_get_ethtool_stats(struct net_device *dev, - struct ethtool_stats *stats, u64 * data) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - sky2_phy_stats(sky2, data, ARRAY_SIZE(sky2_stats)); -} - -static void sky2_get_strings(struct net_device *dev, u32 stringset, u8 * data) -{ - int i; - - switch (stringset) { - case ETH_SS_STATS: - for (i = 0; i < ARRAY_SIZE(sky2_stats); i++) - memcpy(data + i * ETH_GSTRING_LEN, - sky2_stats[i].name, ETH_GSTRING_LEN); - break; - } -} - -/* Use hardware MIB variables for critical path statistics and - * transmit feedback not reported at interrupt. - * Other errors are accounted for in interrupt handler. - */ -static struct net_device_stats *sky2_get_stats(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - u64 data[13]; - - sky2_phy_stats(sky2, data, ARRAY_SIZE(data)); - - sky2->net_stats.tx_bytes = data[0]; - sky2->net_stats.rx_bytes = data[1]; - sky2->net_stats.tx_packets = data[2] + data[4] + data[6]; - sky2->net_stats.rx_packets = data[3] + data[5] + data[7]; - sky2->net_stats.multicast = data[5] + data[7]; - sky2->net_stats.collisions = data[10]; - sky2->net_stats.tx_aborted_errors = data[12]; - - return &sky2->net_stats; -} - -static int sky2_set_mac_address(struct net_device *dev, void *p) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sockaddr *addr = p; - - if (!is_valid_ether_addr(addr->sa_data)) - return -EADDRNOTAVAIL; - - memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); - memcpy_toio(sky2->hw->regs + B2_MAC_1 + sky2->port * 8, - dev->dev_addr, ETH_ALEN); - memcpy_toio(sky2->hw->regs + B2_MAC_2 + sky2->port * 8, - dev->dev_addr, ETH_ALEN); - - if (netif_running(dev)) - sky2_phy_reinit(sky2); - - return 0; -} - -static void sky2_set_multicast(struct net_device *dev) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - struct dev_mc_list *list = dev->mc_list; - u16 reg; - u8 filter[8]; - - memset(filter, 0, sizeof(filter)); - - reg = gma_read16(hw, port, GM_RX_CTRL); - reg |= GM_RXCR_UCF_ENA; - - if (dev->flags & IFF_PROMISC) /* promiscuous */ - reg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA); - else if ((dev->flags & IFF_ALLMULTI) || dev->mc_count > 16) /* all multicast */ - memset(filter, 0xff, sizeof(filter)); - else if (dev->mc_count == 0) /* no multicast */ - reg &= ~GM_RXCR_MCF_ENA; - else { - int i; - reg |= GM_RXCR_MCF_ENA; - - for (i = 0; list && i < dev->mc_count; i++, list = list->next) { - u32 bit = ether_crc(ETH_ALEN, list->dmi_addr) & 0x3f; - filter[bit / 8] |= 1 << (bit % 8); - } - } - - gma_write16(hw, port, GM_MC_ADDR_H1, - (u16) filter[0] | ((u16) filter[1] << 8)); - gma_write16(hw, port, GM_MC_ADDR_H2, - (u16) filter[2] | ((u16) filter[3] << 8)); - gma_write16(hw, port, GM_MC_ADDR_H3, - (u16) filter[4] | ((u16) filter[5] << 8)); - gma_write16(hw, port, GM_MC_ADDR_H4, - (u16) filter[6] | ((u16) filter[7] << 8)); - - gma_write16(hw, port, GM_RX_CTRL, reg); -} - -/* Can have one global because blinking is controlled by - * ethtool and that is always under RTNL mutex - */ -static void sky2_led(struct sky2_hw *hw, unsigned port, int on) -{ - u16 pg; - - switch (hw->chip_id) { - case CHIP_ID_YUKON_XL: - pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR); - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3); - gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, - on ? (PHY_M_LEDC_LOS_CTRL(1) | - PHY_M_LEDC_INIT_CTRL(7) | - PHY_M_LEDC_STA1_CTRL(7) | - PHY_M_LEDC_STA0_CTRL(7)) - : 0); - - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg); - break; - - default: - gm_phy_write(hw, port, PHY_MARV_LED_CTRL, 0); - gm_phy_write(hw, port, PHY_MARV_LED_OVER, - on ? PHY_M_LED_MO_DUP(MO_LED_ON) | - PHY_M_LED_MO_10(MO_LED_ON) | - PHY_M_LED_MO_100(MO_LED_ON) | - PHY_M_LED_MO_1000(MO_LED_ON) | - PHY_M_LED_MO_RX(MO_LED_ON) - : PHY_M_LED_MO_DUP(MO_LED_OFF) | - PHY_M_LED_MO_10(MO_LED_OFF) | - PHY_M_LED_MO_100(MO_LED_OFF) | - PHY_M_LED_MO_1000(MO_LED_OFF) | - PHY_M_LED_MO_RX(MO_LED_OFF)); - - } -} - -/* blink LED's for finding board */ -static int sky2_phys_id(struct net_device *dev, u32 data) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - unsigned port = sky2->port; - u16 ledctrl, ledover = 0; - long ms; - int interrupted; - int onoff = 1; - - if (!data || data > (u32) (MAX_SCHEDULE_TIMEOUT / HZ)) - ms = jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT); - else - ms = data * 1000; - - /* save initial values */ - down(&sky2->phy_sema); - if (hw->chip_id == CHIP_ID_YUKON_XL) { - u16 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR); - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3); - ledctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL); - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg); - } else { - ledctrl = gm_phy_read(hw, port, PHY_MARV_LED_CTRL); - ledover = gm_phy_read(hw, port, PHY_MARV_LED_OVER); - } - - interrupted = 0; - while (!interrupted && ms > 0) { - sky2_led(hw, port, onoff); - onoff = !onoff; - - up(&sky2->phy_sema); - interrupted = msleep_interruptible(250); - down(&sky2->phy_sema); - - ms -= 250; - } - - /* resume regularly scheduled programming */ - if (hw->chip_id == CHIP_ID_YUKON_XL) { - u16 pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR); - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 3); - gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ledctrl); - gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg); - } else { - gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl); - gm_phy_write(hw, port, PHY_MARV_LED_OVER, ledover); - } - up(&sky2->phy_sema); - - return 0; -} - -static void sky2_get_pauseparam(struct net_device *dev, - struct ethtool_pauseparam *ecmd) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - ecmd->tx_pause = sky2->tx_pause; - ecmd->rx_pause = sky2->rx_pause; - ecmd->autoneg = sky2->autoneg; -} - -static int sky2_set_pauseparam(struct net_device *dev, - struct ethtool_pauseparam *ecmd) -{ - struct sky2_port *sky2 = netdev_priv(dev); - int err = 0; - - sky2->autoneg = ecmd->autoneg; - sky2->tx_pause = ecmd->tx_pause != 0; - sky2->rx_pause = ecmd->rx_pause != 0; - - sky2_phy_reinit(sky2); - - return err; -} - -#ifdef CONFIG_PM -static void sky2_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - wol->supported = WAKE_MAGIC; - wol->wolopts = sky2->wol ? WAKE_MAGIC : 0; -} - -static int sky2_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - - if (wol->wolopts != WAKE_MAGIC && wol->wolopts != 0) - return -EOPNOTSUPP; - - sky2->wol = wol->wolopts == WAKE_MAGIC; - - if (sky2->wol) { - memcpy_toio(hw->regs + WOL_MAC_ADDR, dev->dev_addr, ETH_ALEN); - - sky2_write16(hw, WOL_CTRL_STAT, - WOL_CTL_ENA_PME_ON_MAGIC_PKT | - WOL_CTL_ENA_MAGIC_PKT_UNIT); - } else - sky2_write16(hw, WOL_CTRL_STAT, WOL_CTL_DEFAULT); - - return 0; -} -#endif - -static int sky2_get_coalesce(struct net_device *dev, - struct ethtool_coalesce *ecmd) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - - if (sky2_read8(hw, STAT_TX_TIMER_CTRL) == TIM_STOP) - ecmd->tx_coalesce_usecs = 0; - else { - u32 clks = sky2_read32(hw, STAT_TX_TIMER_INI); - ecmd->tx_coalesce_usecs = sky2_clk2us(hw, clks); - } - ecmd->tx_max_coalesced_frames = sky2_read16(hw, STAT_TX_IDX_TH); - - if (sky2_read8(hw, STAT_LEV_TIMER_CTRL) == TIM_STOP) - ecmd->rx_coalesce_usecs = 0; - else { - u32 clks = sky2_read32(hw, STAT_LEV_TIMER_INI); - ecmd->rx_coalesce_usecs = sky2_clk2us(hw, clks); - } - ecmd->rx_max_coalesced_frames = sky2_read8(hw, STAT_FIFO_WM); - - if (sky2_read8(hw, STAT_ISR_TIMER_CTRL) == TIM_STOP) - ecmd->rx_coalesce_usecs_irq = 0; - else { - u32 clks = sky2_read32(hw, STAT_ISR_TIMER_INI); - ecmd->rx_coalesce_usecs_irq = sky2_clk2us(hw, clks); - } - - ecmd->rx_max_coalesced_frames_irq = sky2_read8(hw, STAT_FIFO_ISR_WM); - - return 0; -} - -/* Note: this affect both ports */ -static int sky2_set_coalesce(struct net_device *dev, - struct ethtool_coalesce *ecmd) -{ - struct sky2_port *sky2 = netdev_priv(dev); - struct sky2_hw *hw = sky2->hw; - const u32 tmin = sky2_clk2us(hw, 1); - const u32 tmax = 5000; - - if (ecmd->tx_coalesce_usecs != 0 && - (ecmd->tx_coalesce_usecs < tmin || ecmd->tx_coalesce_usecs > tmax)) - return -EINVAL; - - if (ecmd->rx_coalesce_usecs != 0 && - (ecmd->rx_coalesce_usecs < tmin || ecmd->rx_coalesce_usecs > tmax)) - return -EINVAL; - - if (ecmd->rx_coalesce_usecs_irq != 0 && - (ecmd->rx_coalesce_usecs_irq < tmin || ecmd->rx_coalesce_usecs_irq > tmax)) - return -EINVAL; - - if (ecmd->tx_max_coalesced_frames > 0xffff) - return -EINVAL; - if (ecmd->rx_max_coalesced_frames > 0xff) - return -EINVAL; - if (ecmd->rx_max_coalesced_frames_irq > 0xff) - return -EINVAL; - - if (ecmd->tx_coalesce_usecs == 0) - sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP); - else { - sky2_write32(hw, STAT_TX_TIMER_INI, - sky2_us2clk(hw, ecmd->tx_coalesce_usecs)); - sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START); - } - sky2_write16(hw, STAT_TX_IDX_TH, ecmd->tx_max_coalesced_frames); - - if (ecmd->rx_coalesce_usecs == 0) - sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_STOP); - else { - sky2_write32(hw, STAT_LEV_TIMER_INI, - sky2_us2clk(hw, ecmd->rx_coalesce_usecs)); - sky2_write8(hw, STAT_LEV_TIMER_CTRL, TIM_START); - } - sky2_write8(hw, STAT_FIFO_WM, ecmd->rx_max_coalesced_frames); - - if (ecmd->rx_coalesce_usecs_irq == 0) - sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_STOP); - else { - sky2_write32(hw, STAT_TX_TIMER_INI, - sky2_us2clk(hw, ecmd->rx_coalesce_usecs_irq)); - sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START); - } - sky2_write8(hw, STAT_FIFO_ISR_WM, ecmd->rx_max_coalesced_frames_irq); - return 0; -} - -static void sky2_get_ringparam(struct net_device *dev, - struct ethtool_ringparam *ering) -{ - struct sky2_port *sky2 = netdev_priv(dev); - - ering->rx_max_pending = RX_MAX_PENDING; - ering->rx_mini_max_pending = 0; - ering->rx_jumbo_max_pending = 0; - ering->tx_max_pending = TX_RING_SIZE - 1; - - ering->rx_pending = sky2->rx_pending; - ering->rx_mini_pending = 0; - ering->rx_jumbo_pending = 0; - ering->tx_pending = sky2->tx_pending; -} - -static int sky2_set_ringparam(struct net_device *dev, - struct ethtool_ringparam *ering) -{ - struct sky2_port *sky2 = netdev_priv(dev); - int err = 0; - - if (ering->rx_pending > RX_MAX_PENDING || - ering->rx_pending < 8 || - ering->tx_pending < MAX_SKB_TX_LE || - ering->tx_pending > TX_RING_SIZE - 1) - return -EINVAL; - - if (netif_running(dev)) - sky2_down(dev); - - sky2->rx_pending = ering->rx_pending; - sky2->tx_pending = ering->tx_pending; - - if (netif_running(dev)) { - err = sky2_up(dev); - if (err) - dev_close(dev); - else - sky2_set_multicast(dev); - } - - return err; -} - -static int sky2_get_regs_len(struct net_device *dev) -{ - return 0x4000; -} - -/* - * Returns copy of control register region - * Note: access to the RAM address register set will cause timeouts. - */ -static void sky2_get_regs(struct net_device *dev, struct ethtool_regs *regs, - void *p) -{ - const struct sky2_port *sky2 = netdev_priv(dev); - const void __iomem *io = sky2->hw->regs; - - BUG_ON(regs->len < B3_RI_WTO_R1); - regs->version = 1; - memset(p, 0, regs->len); - - memcpy_fromio(p, io, B3_RAM_ADDR); - - memcpy_fromio(p + B3_RI_WTO_R1, - io + B3_RI_WTO_R1, - regs->len - B3_RI_WTO_R1); -} - -static struct ethtool_ops sky2_ethtool_ops = { - .get_settings = sky2_get_settings, - .set_settings = sky2_set_settings, - .get_drvinfo = sky2_get_drvinfo, - .get_msglevel = sky2_get_msglevel, - .set_msglevel = sky2_set_msglevel, - .nway_reset = sky2_nway_reset, - .get_regs_len = sky2_get_regs_len, - .get_regs = sky2_get_regs, - .get_link = ethtool_op_get_link, - .get_sg = ethtool_op_get_sg, - .set_sg = ethtool_op_set_sg, - .get_tx_csum = ethtool_op_get_tx_csum, - .set_tx_csum = ethtool_op_set_tx_csum, - .get_tso = ethtool_op_get_tso, - .set_tso = ethtool_op_set_tso, - .get_rx_csum = sky2_get_rx_csum, - .set_rx_csum = sky2_set_rx_csum, - .get_strings = sky2_get_strings, - .get_coalesce = sky2_get_coalesce, - .set_coalesce = sky2_set_coalesce, - .get_ringparam = sky2_get_ringparam, - .set_ringparam = sky2_set_ringparam, - .get_pauseparam = sky2_get_pauseparam, - .set_pauseparam = sky2_set_pauseparam, -#ifdef CONFIG_PM - .get_wol = sky2_get_wol, - .set_wol = sky2_set_wol, -#endif - .phys_id = sky2_phys_id, - .get_stats_count = sky2_get_stats_count, - .get_ethtool_stats = sky2_get_ethtool_stats, - .get_perm_addr = ethtool_op_get_perm_addr, -}; - -/* Initialize network device */ -static __devinit struct net_device *sky2_init_netdev(struct sky2_hw *hw, - unsigned port, int highmem) -{ - struct sky2_port *sky2; - struct net_device *dev = alloc_etherdev(sizeof(*sky2)); - - if (!dev) { - printk(KERN_ERR "sky2 etherdev alloc failed"); - return NULL; - } - - SET_MODULE_OWNER(dev); - SET_NETDEV_DEV(dev, &hw->pdev->dev); - dev->irq = hw->pdev->irq; - dev->open = sky2_up; - dev->stop = sky2_down; - dev->do_ioctl = sky2_ioctl; - dev->hard_start_xmit = sky2_xmit_frame; - dev->get_stats = sky2_get_stats; - dev->set_multicast_list = sky2_set_multicast; - dev->set_mac_address = sky2_set_mac_address; - dev->change_mtu = sky2_change_mtu; - SET_ETHTOOL_OPS(dev, &sky2_ethtool_ops); - dev->tx_timeout = sky2_tx_timeout; - dev->watchdog_timeo = TX_WATCHDOG; - if (port == 0) - dev->poll = sky2_poll; - dev->weight = NAPI_WEIGHT; -#ifdef CONFIG_NET_POLL_CONTROLLER - dev->poll_controller = sky2_netpoll; -#endif - - sky2 = netdev_priv(dev); - sky2->netdev = dev; - sky2->hw = hw; - sky2->msg_enable = netif_msg_init(debug, default_msg); - - spin_lock_init(&sky2->tx_lock); - /* Auto speed and flow control */ - sky2->autoneg = AUTONEG_ENABLE; - sky2->tx_pause = 1; - sky2->rx_pause = 1; - sky2->duplex = -1; - sky2->speed = -1; - sky2->advertising = sky2_supported_modes(hw); - - /* Receive checksum disabled for Yukon XL - * because of observed problems with incorrect - * values when multiple packets are received in one interrupt - */ - sky2->rx_csum = (hw->chip_id != CHIP_ID_YUKON_XL); - - INIT_WORK(&sky2->phy_task, sky2_phy_task, sky2); - init_MUTEX(&sky2->phy_sema); - sky2->tx_pending = TX_DEF_PENDING; - sky2->rx_pending = is_ec_a1(hw) ? 8 : RX_DEF_PENDING; - sky2->rx_bufsize = sky2_buf_size(ETH_DATA_LEN); - - hw->dev[port] = dev; - - sky2->port = port; - - dev->features |= NETIF_F_LLTX; - if (hw->chip_id != CHIP_ID_YUKON_EC_U) - dev->features |= NETIF_F_TSO; - if (highmem) - dev->features |= NETIF_F_HIGHDMA; - dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG; - -#ifdef SKY2_VLAN_TAG_USED - dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; - dev->vlan_rx_register = sky2_vlan_rx_register; - dev->vlan_rx_kill_vid = sky2_vlan_rx_kill_vid; -#endif - - /* read the mac address */ - memcpy_fromio(dev->dev_addr, hw->regs + B2_MAC_1 + port * 8, ETH_ALEN); - memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len); - - /* device is off until link detection */ - netif_carrier_off(dev); - netif_stop_queue(dev); - - return dev; -} - -static inline void sky2_show_addr(struct net_device *dev) -{ - const struct sky2_port *sky2 = netdev_priv(dev); - - if (netif_msg_probe(sky2)) - printk(KERN_INFO PFX "%s: addr %02x:%02x:%02x:%02x:%02x:%02x\n", - dev->name, - dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2], - dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]); -} - -static int __devinit sky2_probe(struct pci_dev *pdev, - const struct pci_device_id *ent) -{ - struct net_device *dev, *dev1 = NULL; - struct sky2_hw *hw; - int err, pm_cap, using_dac = 0; - - err = pci_enable_device(pdev); - if (err) { - printk(KERN_ERR PFX "%s cannot enable PCI device\n", - pci_name(pdev)); - goto err_out; - } - - err = pci_request_regions(pdev, DRV_NAME); - if (err) { - printk(KERN_ERR PFX "%s cannot obtain PCI resources\n", - pci_name(pdev)); - goto err_out; - } - - pci_set_master(pdev); - - /* Find power-management capability. */ - pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM); - if (pm_cap == 0) { - printk(KERN_ERR PFX "Cannot find PowerManagement capability, " - "aborting.\n"); - err = -EIO; - goto err_out_free_regions; - } - - if (sizeof(dma_addr_t) > sizeof(u32)) { - err = pci_set_dma_mask(pdev, DMA_64BIT_MASK); - if (!err) - using_dac = 1; - } - - if (!using_dac) { - err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); - if (err) { - printk(KERN_ERR PFX "%s no usable DMA configuration\n", - pci_name(pdev)); - goto err_out_free_regions; - } - } -#ifdef __BIG_ENDIAN - /* byte swap descriptors in hardware */ - { - u32 reg; - - pci_read_config_dword(pdev, PCI_DEV_REG2, ®); - reg |= PCI_REV_DESC; - pci_write_config_dword(pdev, PCI_DEV_REG2, reg); - } -#endif - - err = -ENOMEM; - hw = kmalloc(sizeof(*hw), GFP_KERNEL); - if (!hw) { - printk(KERN_ERR PFX "%s: cannot allocate hardware struct\n", - pci_name(pdev)); - goto err_out_free_regions; - } - - memset(hw, 0, sizeof(*hw)); - hw->pdev = pdev; - - hw->regs = ioremap_nocache(pci_resource_start(pdev, 0), 0x4000); - if (!hw->regs) { - printk(KERN_ERR PFX "%s: cannot map device registers\n", - pci_name(pdev)); - goto err_out_free_hw; - } - hw->pm_cap = pm_cap; - - err = sky2_reset(hw); - if (err) - goto err_out_iounmap; - - printk(KERN_INFO PFX "v%s addr 0x%lx irq %d Yukon-%s (0x%x) rev %d\n", - DRV_VERSION, pci_resource_start(pdev, 0), pdev->irq, - yukon2_name[hw->chip_id - CHIP_ID_YUKON_XL], - hw->chip_id, hw->chip_rev); - - dev = sky2_init_netdev(hw, 0, using_dac); - if (!dev) - goto err_out_free_pci; - - err = register_netdev(dev); - if (err) { - printk(KERN_ERR PFX "%s: cannot register net device\n", - pci_name(pdev)); - goto err_out_free_netdev; - } - - sky2_show_addr(dev); - - if (hw->ports > 1 && (dev1 = sky2_init_netdev(hw, 1, using_dac))) { - if (register_netdev(dev1) == 0) - sky2_show_addr(dev1); - else { - /* Failure to register second port need not be fatal */ - printk(KERN_WARNING PFX - "register of second port failed\n"); - hw->dev[1] = NULL; - free_netdev(dev1); - } - } - - err = request_irq(pdev->irq, sky2_intr, SA_SHIRQ, DRV_NAME, hw); - if (err) { - printk(KERN_ERR PFX "%s: cannot assign irq %d\n", - pci_name(pdev), pdev->irq); - goto err_out_unregister; - } - - hw->intr_mask = Y2_IS_BASE; - sky2_write32(hw, B0_IMSK, hw->intr_mask); - - pci_set_drvdata(pdev, hw); - - return 0; - -err_out_unregister: - if (dev1) { - unregister_netdev(dev1); - free_netdev(dev1); - } - unregister_netdev(dev); -err_out_free_netdev: - free_netdev(dev); -err_out_free_pci: - sky2_write8(hw, B0_CTST, CS_RST_SET); - pci_free_consistent(hw->pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma); -err_out_iounmap: - iounmap(hw->regs); -err_out_free_hw: - kfree(hw); -err_out_free_regions: - pci_release_regions(pdev); - pci_disable_device(pdev); -err_out: - return err; -} - -static void __devexit sky2_remove(struct pci_dev *pdev) -{ - struct sky2_hw *hw = pci_get_drvdata(pdev); - struct net_device *dev0, *dev1; - - if (!hw) - return; - - dev0 = hw->dev[0]; - dev1 = hw->dev[1]; - if (dev1) - unregister_netdev(dev1); - unregister_netdev(dev0); - - sky2_write32(hw, B0_IMSK, 0); - sky2_set_power_state(hw, PCI_D3hot); - sky2_write16(hw, B0_Y2LED, LED_STAT_OFF); - sky2_write8(hw, B0_CTST, CS_RST_SET); - sky2_read8(hw, B0_CTST); - - free_irq(pdev->irq, hw); - pci_free_consistent(pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma); - pci_release_regions(pdev); - pci_disable_device(pdev); - - if (dev1) - free_netdev(dev1); - free_netdev(dev0); - iounmap(hw->regs); - kfree(hw); - - pci_set_drvdata(pdev, NULL); -} - -#ifdef CONFIG_PM -static int sky2_suspend(struct pci_dev *pdev, pm_message_t state) -{ - struct sky2_hw *hw = pci_get_drvdata(pdev); - int i; - - for (i = 0; i < 2; i++) { - struct net_device *dev = hw->dev[i]; - - if (dev) { - if (!netif_running(dev)) - continue; - - sky2_down(dev); - netif_device_detach(dev); - } - } - - return sky2_set_power_state(hw, pci_choose_state(pdev, state)); -} - -static int sky2_resume(struct pci_dev *pdev) -{ - struct sky2_hw *hw = pci_get_drvdata(pdev); - int i; - - pci_restore_state(pdev); - pci_enable_wake(pdev, PCI_D0, 0); - sky2_set_power_state(hw, PCI_D0); - - sky2_reset(hw); - - for (i = 0; i < 2; i++) { - struct net_device *dev = hw->dev[i]; - if (dev) { - if (netif_running(dev)) { - netif_device_attach(dev); - if (sky2_up(dev)) - dev_close(dev); - } - } - } - return 0; -} -#endif - -static struct pci_driver sky2_driver = { - .name = DRV_NAME, - .id_table = sky2_id_table, - .probe = sky2_probe, - .remove = __devexit_p(sky2_remove), -#ifdef CONFIG_PM - .suspend = sky2_suspend, - .resume = sky2_resume, -#endif -}; - -static int __init sky2_init_module(void) -{ - return pci_register_driver(&sky2_driver); -} - -static void __exit sky2_cleanup_module(void) -{ - pci_unregister_driver(&sky2_driver); -} - -module_init(sky2_init_module); -module_exit(sky2_cleanup_module); - -MODULE_DESCRIPTION("Marvell Yukon 2 Gigabit Ethernet driver"); -MODULE_AUTHOR("Stephen Hemminger "); -MODULE_LICENSE("GPL"); -MODULE_VERSION(DRV_VERSION); diff --git a/trunk/drivers/net/sky2.h b/trunk/drivers/net/sky2.h deleted file mode 100644 index 95518921001c..000000000000 --- a/trunk/drivers/net/sky2.h +++ /dev/null @@ -1,1922 +0,0 @@ -/* - * Definitions for the new Marvell Yukon 2 driver. - */ -#ifndef _SKY2_H -#define _SKY2_H - -/* PCI config registers */ -#define PCI_DEV_REG1 0x40 -#define PCI_DEV_REG2 0x44 -#define PCI_DEV_STATUS 0x7c -#define PCI_OS_PCI_X (1<<26) - -#define PEX_LNK_STAT 0xf2 -#define PEX_UNC_ERR_STAT 0x104 -#define PEX_DEV_CTRL 0xe8 - -/* Yukon-2 */ -enum pci_dev_reg_1 { - PCI_Y2_PIG_ENA = 1<<31, /* Enable Plug-in-Go (YUKON-2) */ - PCI_Y2_DLL_DIS = 1<<30, /* Disable PCI DLL (YUKON-2) */ - PCI_Y2_PHY2_COMA = 1<<29, /* Set PHY 2 to Coma Mode (YUKON-2) */ - PCI_Y2_PHY1_COMA = 1<<28, /* Set PHY 1 to Coma Mode (YUKON-2) */ - PCI_Y2_PHY2_POWD = 1<<27, /* Set PHY 2 to Power Down (YUKON-2) */ - PCI_Y2_PHY1_POWD = 1<<26, /* Set PHY 1 to Power Down (YUKON-2) */ -}; - -enum pci_dev_reg_2 { - PCI_VPD_WR_THR = 0xffL<<24, /* Bit 31..24: VPD Write Threshold */ - PCI_DEV_SEL = 0x7fL<<17, /* Bit 23..17: EEPROM Device Select */ - PCI_VPD_ROM_SZ = 7L<<14, /* Bit 16..14: VPD ROM Size */ - - PCI_PATCH_DIR = 0xfL<<8, /* Bit 11.. 8: Ext Patches dir 3..0 */ - PCI_EXT_PATCHS = 0xfL<<4, /* Bit 7.. 4: Extended Patches 3..0 */ - PCI_EN_DUMMY_RD = 1<<3, /* Enable Dummy Read */ - PCI_REV_DESC = 1<<2, /* Reverse Desc. Bytes */ - - PCI_USEDATA64 = 1<<0, /* Use 64Bit Data bus ext */ -}; - - -#define PCI_STATUS_ERROR_BITS (PCI_STATUS_DETECTED_PARITY | \ - PCI_STATUS_SIG_SYSTEM_ERROR | \ - PCI_STATUS_REC_MASTER_ABORT | \ - PCI_STATUS_REC_TARGET_ABORT | \ - PCI_STATUS_PARITY) - -enum pex_dev_ctrl { - PEX_DC_MAX_RRS_MSK = 7<<12, /* Bit 14..12: Max. Read Request Size */ - PEX_DC_EN_NO_SNOOP = 1<<11,/* Enable No Snoop */ - PEX_DC_EN_AUX_POW = 1<<10,/* Enable AUX Power */ - PEX_DC_EN_PHANTOM = 1<<9, /* Enable Phantom Functions */ - PEX_DC_EN_EXT_TAG = 1<<8, /* Enable Extended Tag Field */ - PEX_DC_MAX_PLS_MSK = 7<<5, /* Bit 7.. 5: Max. Payload Size Mask */ - PEX_DC_EN_REL_ORD = 1<<4, /* Enable Relaxed Ordering */ - PEX_DC_EN_UNS_RQ_RP = 1<<3, /* Enable Unsupported Request Reporting */ - PEX_DC_EN_FAT_ER_RP = 1<<2, /* Enable Fatal Error Reporting */ - PEX_DC_EN_NFA_ER_RP = 1<<1, /* Enable Non-Fatal Error Reporting */ - PEX_DC_EN_COR_ER_RP = 1<<0, /* Enable Correctable Error Reporting */ -}; -#define PEX_DC_MAX_RD_RQ_SIZE(x) (((x)<<12) & PEX_DC_MAX_RRS_MSK) - -/* PEX_UNC_ERR_STAT PEX Uncorrectable Errors Status Register (Yukon-2) */ -enum pex_err { - PEX_UNSUP_REQ = 1<<20, /* Unsupported Request Error */ - - PEX_MALFOR_TLP = 1<<18, /* Malformed TLP */ - - PEX_UNEXP_COMP = 1<<16, /* Unexpected Completion */ - - PEX_COMP_TO = 1<<14, /* Completion Timeout */ - PEX_FLOW_CTRL_P = 1<<13, /* Flow Control Protocol Error */ - PEX_POIS_TLP = 1<<12, /* Poisoned TLP */ - - PEX_DATA_LINK_P = 1<<4, /* Data Link Protocol Error */ - PEX_FATAL_ERRORS= (PEX_MALFOR_TLP | PEX_FLOW_CTRL_P | PEX_DATA_LINK_P), -}; - - -enum csr_regs { - B0_RAP = 0x0000, - B0_CTST = 0x0004, - B0_Y2LED = 0x0005, - B0_POWER_CTRL = 0x0007, - B0_ISRC = 0x0008, - B0_IMSK = 0x000c, - B0_HWE_ISRC = 0x0010, - B0_HWE_IMSK = 0x0014, - - /* Special ISR registers (Yukon-2 only) */ - B0_Y2_SP_ISRC2 = 0x001c, - B0_Y2_SP_ISRC3 = 0x0020, - B0_Y2_SP_EISR = 0x0024, - B0_Y2_SP_LISR = 0x0028, - B0_Y2_SP_ICR = 0x002c, - - B2_MAC_1 = 0x0100, - B2_MAC_2 = 0x0108, - B2_MAC_3 = 0x0110, - B2_CONN_TYP = 0x0118, - B2_PMD_TYP = 0x0119, - B2_MAC_CFG = 0x011a, - B2_CHIP_ID = 0x011b, - B2_E_0 = 0x011c, - - B2_Y2_CLK_GATE = 0x011d, - B2_Y2_HW_RES = 0x011e, - B2_E_3 = 0x011f, - B2_Y2_CLK_CTRL = 0x0120, - - B2_TI_INI = 0x0130, - B2_TI_VAL = 0x0134, - B2_TI_CTRL = 0x0138, - B2_TI_TEST = 0x0139, - - B2_TST_CTRL1 = 0x0158, - B2_TST_CTRL2 = 0x0159, - B2_GP_IO = 0x015c, - - B2_I2C_CTRL = 0x0160, - B2_I2C_DATA = 0x0164, - B2_I2C_IRQ = 0x0168, - B2_I2C_SW = 0x016c, - - B3_RAM_ADDR = 0x0180, - B3_RAM_DATA_LO = 0x0184, - B3_RAM_DATA_HI = 0x0188, - -/* RAM Interface Registers */ -/* Yukon-2: use RAM_BUFFER() to access the RAM buffer */ -/* - * The HW-Spec. calls this registers Timeout Value 0..11. But this names are - * not usable in SW. Please notice these are NOT real timeouts, these are - * the number of qWords transferred continuously. - */ -#define RAM_BUFFER(port, reg) (reg | (port <<6)) - - B3_RI_WTO_R1 = 0x0190, - B3_RI_WTO_XA1 = 0x0191, - B3_RI_WTO_XS1 = 0x0192, - B3_RI_RTO_R1 = 0x0193, - B3_RI_RTO_XA1 = 0x0194, - B3_RI_RTO_XS1 = 0x0195, - B3_RI_WTO_R2 = 0x0196, - B3_RI_WTO_XA2 = 0x0197, - B3_RI_WTO_XS2 = 0x0198, - B3_RI_RTO_R2 = 0x0199, - B3_RI_RTO_XA2 = 0x019a, - B3_RI_RTO_XS2 = 0x019b, - B3_RI_TO_VAL = 0x019c, - B3_RI_CTRL = 0x01a0, - B3_RI_TEST = 0x01a2, - B3_MA_TOINI_RX1 = 0x01b0, - B3_MA_TOINI_RX2 = 0x01b1, - B3_MA_TOINI_TX1 = 0x01b2, - B3_MA_TOINI_TX2 = 0x01b3, - B3_MA_TOVAL_RX1 = 0x01b4, - B3_MA_TOVAL_RX2 = 0x01b5, - B3_MA_TOVAL_TX1 = 0x01b6, - B3_MA_TOVAL_TX2 = 0x01b7, - B3_MA_TO_CTRL = 0x01b8, - B3_MA_TO_TEST = 0x01ba, - B3_MA_RCINI_RX1 = 0x01c0, - B3_MA_RCINI_RX2 = 0x01c1, - B3_MA_RCINI_TX1 = 0x01c2, - B3_MA_RCINI_TX2 = 0x01c3, - B3_MA_RCVAL_RX1 = 0x01c4, - B3_MA_RCVAL_RX2 = 0x01c5, - B3_MA_RCVAL_TX1 = 0x01c6, - B3_MA_RCVAL_TX2 = 0x01c7, - B3_MA_RC_CTRL = 0x01c8, - B3_MA_RC_TEST = 0x01ca, - B3_PA_TOINI_RX1 = 0x01d0, - B3_PA_TOINI_RX2 = 0x01d4, - B3_PA_TOINI_TX1 = 0x01d8, - B3_PA_TOINI_TX2 = 0x01dc, - B3_PA_TOVAL_RX1 = 0x01e0, - B3_PA_TOVAL_RX2 = 0x01e4, - B3_PA_TOVAL_TX1 = 0x01e8, - B3_PA_TOVAL_TX2 = 0x01ec, - B3_PA_CTRL = 0x01f0, - B3_PA_TEST = 0x01f2, - - Y2_CFG_SPC = 0x1c00, -}; - -/* B0_CTST 16 bit Control/Status register */ -enum { - Y2_VMAIN_AVAIL = 1<<17,/* VMAIN available (YUKON-2 only) */ - Y2_VAUX_AVAIL = 1<<16,/* VAUX available (YUKON-2 only) */ - Y2_ASF_ENABLE = 1<<13,/* ASF Unit Enable (YUKON-2 only) */ - Y2_ASF_DISABLE = 1<<12,/* ASF Unit Disable (YUKON-2 only) */ - Y2_CLK_RUN_ENA = 1<<11,/* CLK_RUN Enable (YUKON-2 only) */ - Y2_CLK_RUN_DIS = 1<<10,/* CLK_RUN Disable (YUKON-2 only) */ - Y2_LED_STAT_ON = 1<<9, /* Status LED On (YUKON-2 only) */ - Y2_LED_STAT_OFF = 1<<8, /* Status LED Off (YUKON-2 only) */ - - CS_ST_SW_IRQ = 1<<7, /* Set IRQ SW Request */ - CS_CL_SW_IRQ = 1<<6, /* Clear IRQ SW Request */ - CS_STOP_DONE = 1<<5, /* Stop Master is finished */ - CS_STOP_MAST = 1<<4, /* Command Bit to stop the master */ - CS_MRST_CLR = 1<<3, /* Clear Master reset */ - CS_MRST_SET = 1<<2, /* Set Master reset */ - CS_RST_CLR = 1<<1, /* Clear Software reset */ - CS_RST_SET = 1, /* Set Software reset */ -}; - -/* B0_LED 8 Bit LED register */ -enum { -/* Bit 7.. 2: reserved */ - LED_STAT_ON = 1<<1, /* Status LED on */ - LED_STAT_OFF = 1, /* Status LED off */ -}; - -/* B0_POWER_CTRL 8 Bit Power Control reg (YUKON only) */ -enum { - PC_VAUX_ENA = 1<<7, /* Switch VAUX Enable */ - PC_VAUX_DIS = 1<<6, /* Switch VAUX Disable */ - PC_VCC_ENA = 1<<5, /* Switch VCC Enable */ - PC_VCC_DIS = 1<<4, /* Switch VCC Disable */ - PC_VAUX_ON = 1<<3, /* Switch VAUX On */ - PC_VAUX_OFF = 1<<2, /* Switch VAUX Off */ - PC_VCC_ON = 1<<1, /* Switch VCC On */ - PC_VCC_OFF = 1<<0, /* Switch VCC Off */ -}; - -/* B2_IRQM_MSK 32 bit IRQ Moderation Mask */ - -/* B0_Y2_SP_ISRC2 32 bit Special Interrupt Source Reg 2 */ -/* B0_Y2_SP_ISRC3 32 bit Special Interrupt Source Reg 3 */ -/* B0_Y2_SP_EISR 32 bit Enter ISR Reg */ -/* B0_Y2_SP_LISR 32 bit Leave ISR Reg */ -enum { - Y2_IS_HW_ERR = 1<<31, /* Interrupt HW Error */ - Y2_IS_STAT_BMU = 1<<30, /* Status BMU Interrupt */ - Y2_IS_ASF = 1<<29, /* ASF subsystem Interrupt */ - - Y2_IS_POLL_CHK = 1<<27, /* Check IRQ from polling unit */ - Y2_IS_TWSI_RDY = 1<<26, /* IRQ on end of TWSI Tx */ - Y2_IS_IRQ_SW = 1<<25, /* SW forced IRQ */ - Y2_IS_TIMINT = 1<<24, /* IRQ from Timer */ - - Y2_IS_IRQ_PHY2 = 1<<12, /* Interrupt from PHY 2 */ - Y2_IS_IRQ_MAC2 = 1<<11, /* Interrupt from MAC 2 */ - Y2_IS_CHK_RX2 = 1<<10, /* Descriptor error Rx 2 */ - Y2_IS_CHK_TXS2 = 1<<9, /* Descriptor error TXS 2 */ - Y2_IS_CHK_TXA2 = 1<<8, /* Descriptor error TXA 2 */ - - Y2_IS_IRQ_PHY1 = 1<<4, /* Interrupt from PHY 1 */ - Y2_IS_IRQ_MAC1 = 1<<3, /* Interrupt from MAC 1 */ - Y2_IS_CHK_RX1 = 1<<2, /* Descriptor error Rx 1 */ - Y2_IS_CHK_TXS1 = 1<<1, /* Descriptor error TXS 1 */ - Y2_IS_CHK_TXA1 = 1<<0, /* Descriptor error TXA 1 */ - - Y2_IS_BASE = Y2_IS_HW_ERR | Y2_IS_STAT_BMU | - Y2_IS_POLL_CHK | Y2_IS_TWSI_RDY | - Y2_IS_IRQ_SW | Y2_IS_TIMINT, - Y2_IS_PORT_1 = Y2_IS_IRQ_PHY1 | Y2_IS_IRQ_MAC1 | - Y2_IS_CHK_RX1 | Y2_IS_CHK_TXA1 | Y2_IS_CHK_TXS1, - Y2_IS_PORT_2 = Y2_IS_IRQ_PHY2 | Y2_IS_IRQ_MAC2 | - Y2_IS_CHK_RX2 | Y2_IS_CHK_TXA2 | Y2_IS_CHK_TXS2, -}; - -/* B2_IRQM_HWE_MSK 32 bit IRQ Moderation HW Error Mask */ -enum { - IS_ERR_MSK = 0x00003fff,/* All Error bits */ - - IS_IRQ_TIST_OV = 1<<13, /* Time Stamp Timer Overflow (YUKON only) */ - IS_IRQ_SENSOR = 1<<12, /* IRQ from Sensor (YUKON only) */ - IS_IRQ_MST_ERR = 1<<11, /* IRQ master error detected */ - IS_IRQ_STAT = 1<<10, /* IRQ status exception */ - IS_NO_STAT_M1 = 1<<9, /* No Rx Status from MAC 1 */ - IS_NO_STAT_M2 = 1<<8, /* No Rx Status from MAC 2 */ - IS_NO_TIST_M1 = 1<<7, /* No Time Stamp from MAC 1 */ - IS_NO_TIST_M2 = 1<<6, /* No Time Stamp from MAC 2 */ - IS_RAM_RD_PAR = 1<<5, /* RAM Read Parity Error */ - IS_RAM_WR_PAR = 1<<4, /* RAM Write Parity Error */ - IS_M1_PAR_ERR = 1<<3, /* MAC 1 Parity Error */ - IS_M2_PAR_ERR = 1<<2, /* MAC 2 Parity Error */ - IS_R1_PAR_ERR = 1<<1, /* Queue R1 Parity Error */ - IS_R2_PAR_ERR = 1<<0, /* Queue R2 Parity Error */ -}; - -/* Hardware error interrupt mask for Yukon 2 */ -enum { - Y2_IS_TIST_OV = 1<<29,/* Time Stamp Timer overflow interrupt */ - Y2_IS_SENSOR = 1<<28, /* Sensor interrupt */ - Y2_IS_MST_ERR = 1<<27, /* Master error interrupt */ - Y2_IS_IRQ_STAT = 1<<26, /* Status exception interrupt */ - Y2_IS_PCI_EXP = 1<<25, /* PCI-Express interrupt */ - Y2_IS_PCI_NEXP = 1<<24, /* PCI-Express error similar to PCI error */ - /* Link 2 */ - Y2_IS_PAR_RD2 = 1<<13, /* Read RAM parity error interrupt */ - Y2_IS_PAR_WR2 = 1<<12, /* Write RAM parity error interrupt */ - Y2_IS_PAR_MAC2 = 1<<11, /* MAC hardware fault interrupt */ - Y2_IS_PAR_RX2 = 1<<10, /* Parity Error Rx Queue 2 */ - Y2_IS_TCP_TXS2 = 1<<9, /* TCP length mismatch sync Tx queue IRQ */ - Y2_IS_TCP_TXA2 = 1<<8, /* TCP length mismatch async Tx queue IRQ */ - /* Link 1 */ - Y2_IS_PAR_RD1 = 1<<5, /* Read RAM parity error interrupt */ - Y2_IS_PAR_WR1 = 1<<4, /* Write RAM parity error interrupt */ - Y2_IS_PAR_MAC1 = 1<<3, /* MAC hardware fault interrupt */ - Y2_IS_PAR_RX1 = 1<<2, /* Parity Error Rx Queue 1 */ - Y2_IS_TCP_TXS1 = 1<<1, /* TCP length mismatch sync Tx queue IRQ */ - Y2_IS_TCP_TXA1 = 1<<0, /* TCP length mismatch async Tx queue IRQ */ - - Y2_HWE_L1_MASK = Y2_IS_PAR_RD1 | Y2_IS_PAR_WR1 | Y2_IS_PAR_MAC1 | - Y2_IS_PAR_RX1 | Y2_IS_TCP_TXS1| Y2_IS_TCP_TXA1, - Y2_HWE_L2_MASK = Y2_IS_PAR_RD2 | Y2_IS_PAR_WR2 | Y2_IS_PAR_MAC2 | - Y2_IS_PAR_RX2 | Y2_IS_TCP_TXS2| Y2_IS_TCP_TXA2, - - Y2_HWE_ALL_MASK = Y2_IS_TIST_OV | Y2_IS_MST_ERR | Y2_IS_IRQ_STAT | - Y2_IS_PCI_EXP | - Y2_HWE_L1_MASK | Y2_HWE_L2_MASK, -}; - -/* B28_DPT_CTRL 8 bit Descriptor Poll Timer Ctrl Reg */ -enum { - DPT_START = 1<<1, - DPT_STOP = 1<<0, -}; - -/* B2_TST_CTRL1 8 bit Test Control Register 1 */ -enum { - TST_FRC_DPERR_MR = 1<<7, /* force DATAPERR on MST RD */ - TST_FRC_DPERR_MW = 1<<6, /* force DATAPERR on MST WR */ - TST_FRC_DPERR_TR = 1<<5, /* force DATAPERR on TRG RD */ - TST_FRC_DPERR_TW = 1<<4, /* force DATAPERR on TRG WR */ - TST_FRC_APERR_M = 1<<3, /* force ADDRPERR on MST */ - TST_FRC_APERR_T = 1<<2, /* force ADDRPERR on TRG */ - TST_CFG_WRITE_ON = 1<<1, /* Enable Config Reg WR */ - TST_CFG_WRITE_OFF= 1<<0, /* Disable Config Reg WR */ -}; - -/* B2_MAC_CFG 8 bit MAC Configuration / Chip Revision */ -enum { - CFG_CHIP_R_MSK = 0xf<<4, /* Bit 7.. 4: Chip Revision */ - /* Bit 3.. 2: reserved */ - CFG_DIS_M2_CLK = 1<<1, /* Disable Clock for 2nd MAC */ - CFG_SNG_MAC = 1<<0, /* MAC Config: 0=2 MACs / 1=1 MAC*/ -}; - -/* B2_CHIP_ID 8 bit Chip Identification Number */ -enum { - CHIP_ID_GENESIS = 0x0a, /* Chip ID for GENESIS */ - CHIP_ID_YUKON = 0xb0, /* Chip ID for YUKON */ - CHIP_ID_YUKON_LITE = 0xb1, /* Chip ID for YUKON-Lite (Rev. A1-A3) */ - CHIP_ID_YUKON_LP = 0xb2, /* Chip ID for YUKON-LP */ - CHIP_ID_YUKON_XL = 0xb3, /* Chip ID for YUKON-2 XL */ - CHIP_ID_YUKON_EC_U = 0xb4, /* Chip ID for YUKON-2 EC Ultra */ - CHIP_ID_YUKON_EC = 0xb6, /* Chip ID for YUKON-2 EC */ - CHIP_ID_YUKON_FE = 0xb7, /* Chip ID for YUKON-2 FE */ - - CHIP_REV_YU_EC_A1 = 0, /* Chip Rev. for Yukon-EC A1/A0 */ - CHIP_REV_YU_EC_A2 = 1, /* Chip Rev. for Yukon-EC A2 */ - CHIP_REV_YU_EC_A3 = 2, /* Chip Rev. for Yukon-EC A3 */ -}; - -/* B2_Y2_CLK_GATE 8 bit Clock Gating (Yukon-2 only) */ -enum { - Y2_STATUS_LNK2_INAC = 1<<7, /* Status Link 2 inactive (0 = active) */ - Y2_CLK_GAT_LNK2_DIS = 1<<6, /* Disable clock gating Link 2 */ - Y2_COR_CLK_LNK2_DIS = 1<<5, /* Disable Core clock Link 2 */ - Y2_PCI_CLK_LNK2_DIS = 1<<4, /* Disable PCI clock Link 2 */ - Y2_STATUS_LNK1_INAC = 1<<3, /* Status Link 1 inactive (0 = active) */ - Y2_CLK_GAT_LNK1_DIS = 1<<2, /* Disable clock gating Link 1 */ - Y2_COR_CLK_LNK1_DIS = 1<<1, /* Disable Core clock Link 1 */ - Y2_PCI_CLK_LNK1_DIS = 1<<0, /* Disable PCI clock Link 1 */ -}; - -/* B2_Y2_HW_RES 8 bit HW Resources (Yukon-2 only) */ -enum { - CFG_LED_MODE_MSK = 7<<2, /* Bit 4.. 2: LED Mode Mask */ - CFG_LINK_2_AVAIL = 1<<1, /* Link 2 available */ - CFG_LINK_1_AVAIL = 1<<0, /* Link 1 available */ -}; -#define CFG_LED_MODE(x) (((x) & CFG_LED_MODE_MSK) >> 2) -#define CFG_DUAL_MAC_MSK (CFG_LINK_2_AVAIL | CFG_LINK_1_AVAIL) - - -/* B2_Y2_CLK_CTRL 32 bit Clock Frequency Control Register (Yukon-2/EC) */ -enum { - Y2_CLK_DIV_VAL_MSK = 0xff<<16,/* Bit 23..16: Clock Divisor Value */ -#define Y2_CLK_DIV_VAL(x) (((x)<<16) & Y2_CLK_DIV_VAL_MSK) - Y2_CLK_DIV_VAL2_MSK = 7<<21, /* Bit 23..21: Clock Divisor Value */ - Y2_CLK_SELECT2_MSK = 0x1f<<16,/* Bit 20..16: Clock Select */ -#define Y2_CLK_DIV_VAL_2(x) (((x)<<21) & Y2_CLK_DIV_VAL2_MSK) -#define Y2_CLK_SEL_VAL_2(x) (((x)<<16) & Y2_CLK_SELECT2_MSK) - Y2_CLK_DIV_ENA = 1<<1, /* Enable Core Clock Division */ - Y2_CLK_DIV_DIS = 1<<0, /* Disable Core Clock Division */ -}; - -/* B2_TI_CTRL 8 bit Timer control */ -/* B2_IRQM_CTRL 8 bit IRQ Moderation Timer Control */ -enum { - TIM_START = 1<<2, /* Start Timer */ - TIM_STOP = 1<<1, /* Stop Timer */ - TIM_CLR_IRQ = 1<<0, /* Clear Timer IRQ (!IRQM) */ -}; - -/* B2_TI_TEST 8 Bit Timer Test */ -/* B2_IRQM_TEST 8 bit IRQ Moderation Timer Test */ -/* B28_DPT_TST 8 bit Descriptor Poll Timer Test Reg */ -enum { - TIM_T_ON = 1<<2, /* Test mode on */ - TIM_T_OFF = 1<<1, /* Test mode off */ - TIM_T_STEP = 1<<0, /* Test step */ -}; - -/* B3_RAM_ADDR 32 bit RAM Address, to read or write */ - /* Bit 31..19: reserved */ -#define RAM_ADR_RAN 0x0007ffffL /* Bit 18.. 0: RAM Address Range */ -/* RAM Interface Registers */ - -/* B3_RI_CTRL 16 bit RAM Interface Control Register */ -enum { - RI_CLR_RD_PERR = 1<<9, /* Clear IRQ RAM Read Parity Err */ - RI_CLR_WR_PERR = 1<<8, /* Clear IRQ RAM Write Parity Err*/ - - RI_RST_CLR = 1<<1, /* Clear RAM Interface Reset */ - RI_RST_SET = 1<<0, /* Set RAM Interface Reset */ -}; - -#define SK_RI_TO_53 36 /* RAM interface timeout */ - - -/* Port related registers FIFO, and Arbiter */ -#define SK_REG(port,reg) (((port)<<7)+(reg)) - -/* Transmit Arbiter Registers MAC 1 and 2, use SK_REG() to access */ -/* TXA_ITI_INI 32 bit Tx Arb Interval Timer Init Val */ -/* TXA_ITI_VAL 32 bit Tx Arb Interval Timer Value */ -/* TXA_LIM_INI 32 bit Tx Arb Limit Counter Init Val */ -/* TXA_LIM_VAL 32 bit Tx Arb Limit Counter Value */ - -#define TXA_MAX_VAL 0x00ffffffUL /* Bit 23.. 0: Max TXA Timer/Cnt Val */ - -/* TXA_CTRL 8 bit Tx Arbiter Control Register */ -enum { - TXA_ENA_FSYNC = 1<<7, /* Enable force of sync Tx queue */ - TXA_DIS_FSYNC = 1<<6, /* Disable force of sync Tx queue */ - TXA_ENA_ALLOC = 1<<5, /* Enable alloc of free bandwidth */ - TXA_DIS_ALLOC = 1<<4, /* Disable alloc of free bandwidth */ - TXA_START_RC = 1<<3, /* Start sync Rate Control */ - TXA_STOP_RC = 1<<2, /* Stop sync Rate Control */ - TXA_ENA_ARB = 1<<1, /* Enable Tx Arbiter */ - TXA_DIS_ARB = 1<<0, /* Disable Tx Arbiter */ -}; - -/* - * Bank 4 - 5 - */ -/* Transmit Arbiter Registers MAC 1 and 2, use SK_REG() to access */ -enum { - TXA_ITI_INI = 0x0200,/* 32 bit Tx Arb Interval Timer Init Val*/ - TXA_ITI_VAL = 0x0204,/* 32 bit Tx Arb Interval Timer Value */ - TXA_LIM_INI = 0x0208,/* 32 bit Tx Arb Limit Counter Init Val */ - TXA_LIM_VAL = 0x020c,/* 32 bit Tx Arb Limit Counter Value */ - TXA_CTRL = 0x0210,/* 8 bit Tx Arbiter Control Register */ - TXA_TEST = 0x0211,/* 8 bit Tx Arbiter Test Register */ - TXA_STAT = 0x0212,/* 8 bit Tx Arbiter Status Register */ -}; - - -enum { - B6_EXT_REG = 0x0300,/* External registers (GENESIS only) */ - B7_CFG_SPC = 0x0380,/* copy of the Configuration register */ - B8_RQ1_REGS = 0x0400,/* Receive Queue 1 */ - B8_RQ2_REGS = 0x0480,/* Receive Queue 2 */ - B8_TS1_REGS = 0x0600,/* Transmit sync queue 1 */ - B8_TA1_REGS = 0x0680,/* Transmit async queue 1 */ - B8_TS2_REGS = 0x0700,/* Transmit sync queue 2 */ - B8_TA2_REGS = 0x0780,/* Transmit sync queue 2 */ - B16_RAM_REGS = 0x0800,/* RAM Buffer Registers */ -}; - -/* Queue Register Offsets, use Q_ADDR() to access */ -enum { - B8_Q_REGS = 0x0400, /* base of Queue registers */ - Q_D = 0x00, /* 8*32 bit Current Descriptor */ - Q_DA_L = 0x20, /* 32 bit Current Descriptor Address Low dWord */ - Q_DA_H = 0x24, /* 32 bit Current Descriptor Address High dWord */ - Q_AC_L = 0x28, /* 32 bit Current Address Counter Low dWord */ - Q_AC_H = 0x2c, /* 32 bit Current Address Counter High dWord */ - Q_BC = 0x30, /* 32 bit Current Byte Counter */ - Q_CSR = 0x34, /* 32 bit BMU Control/Status Register */ - Q_F = 0x38, /* 32 bit Flag Register */ - Q_T1 = 0x3c, /* 32 bit Test Register 1 */ - Q_T1_TR = 0x3c, /* 8 bit Test Register 1 Transfer SM */ - Q_T1_WR = 0x3d, /* 8 bit Test Register 1 Write Descriptor SM */ - Q_T1_RD = 0x3e, /* 8 bit Test Register 1 Read Descriptor SM */ - Q_T1_SV = 0x3f, /* 8 bit Test Register 1 Supervisor SM */ - Q_T2 = 0x40, /* 32 bit Test Register 2 */ - Q_T3 = 0x44, /* 32 bit Test Register 3 */ - -/* Yukon-2 */ - Q_DONE = 0x24, /* 16 bit Done Index (Yukon-2 only) */ - Q_WM = 0x40, /* 16 bit FIFO Watermark */ - Q_AL = 0x42, /* 8 bit FIFO Alignment */ - Q_RSP = 0x44, /* 16 bit FIFO Read Shadow Pointer */ - Q_RSL = 0x46, /* 8 bit FIFO Read Shadow Level */ - Q_RP = 0x48, /* 8 bit FIFO Read Pointer */ - Q_RL = 0x4a, /* 8 bit FIFO Read Level */ - Q_WP = 0x4c, /* 8 bit FIFO Write Pointer */ - Q_WSP = 0x4d, /* 8 bit FIFO Write Shadow Pointer */ - Q_WL = 0x4e, /* 8 bit FIFO Write Level */ - Q_WSL = 0x4f, /* 8 bit FIFO Write Shadow Level */ -}; -#define Q_ADDR(reg, offs) (B8_Q_REGS + (reg) + (offs)) - - -/* Queue Prefetch Unit Offsets, use Y2_QADDR() to address (Yukon-2 only)*/ -enum { - Y2_B8_PREF_REGS = 0x0450, - - PREF_UNIT_CTRL = 0x00, /* 32 bit Control register */ - PREF_UNIT_LAST_IDX = 0x04, /* 16 bit Last Index */ - PREF_UNIT_ADDR_LO = 0x08, /* 32 bit List start addr, low part */ - PREF_UNIT_ADDR_HI = 0x0c, /* 32 bit List start addr, high part*/ - PREF_UNIT_GET_IDX = 0x10, /* 16 bit Get Index */ - PREF_UNIT_PUT_IDX = 0x14, /* 16 bit Put Index */ - PREF_UNIT_FIFO_WP = 0x20, /* 8 bit FIFO write pointer */ - PREF_UNIT_FIFO_RP = 0x24, /* 8 bit FIFO read pointer */ - PREF_UNIT_FIFO_WM = 0x28, /* 8 bit FIFO watermark */ - PREF_UNIT_FIFO_LEV = 0x2c, /* 8 bit FIFO level */ - - PREF_UNIT_MASK_IDX = 0x0fff, -}; -#define Y2_QADDR(q,reg) (Y2_B8_PREF_REGS + (q) + (reg)) - -/* RAM Buffer Register Offsets */ -enum { - - RB_START = 0x00,/* 32 bit RAM Buffer Start Address */ - RB_END = 0x04,/* 32 bit RAM Buffer End Address */ - RB_WP = 0x08,/* 32 bit RAM Buffer Write Pointer */ - RB_RP = 0x0c,/* 32 bit RAM Buffer Read Pointer */ - RB_RX_UTPP = 0x10,/* 32 bit Rx Upper Threshold, Pause Packet */ - RB_RX_LTPP = 0x14,/* 32 bit Rx Lower Threshold, Pause Packet */ - RB_RX_UTHP = 0x18,/* 32 bit Rx Upper Threshold, High Prio */ - RB_RX_LTHP = 0x1c,/* 32 bit Rx Lower Threshold, High Prio */ - /* 0x10 - 0x1f: reserved at Tx RAM Buffer Registers */ - RB_PC = 0x20,/* 32 bit RAM Buffer Packet Counter */ - RB_LEV = 0x24,/* 32 bit RAM Buffer Level Register */ - RB_CTRL = 0x28,/* 32 bit RAM Buffer Control Register */ - RB_TST1 = 0x29,/* 8 bit RAM Buffer Test Register 1 */ - RB_TST2 = 0x2a,/* 8 bit RAM Buffer Test Register 2 */ -}; - -/* Receive and Transmit Queues */ -enum { - Q_R1 = 0x0000, /* Receive Queue 1 */ - Q_R2 = 0x0080, /* Receive Queue 2 */ - Q_XS1 = 0x0200, /* Synchronous Transmit Queue 1 */ - Q_XA1 = 0x0280, /* Asynchronous Transmit Queue 1 */ - Q_XS2 = 0x0300, /* Synchronous Transmit Queue 2 */ - Q_XA2 = 0x0380, /* Asynchronous Transmit Queue 2 */ -}; - -/* Different PHY Types */ -enum { - PHY_ADDR_MARV = 0, -}; - -#define RB_ADDR(offs, queue) (B16_RAM_REGS + (queue) + (offs)) - - -enum { - LNK_SYNC_INI = 0x0c30,/* 32 bit Link Sync Cnt Init Value */ - LNK_SYNC_VAL = 0x0c34,/* 32 bit Link Sync Cnt Current Value */ - LNK_SYNC_CTRL = 0x0c38,/* 8 bit Link Sync Cnt Control Register */ - LNK_SYNC_TST = 0x0c39,/* 8 bit Link Sync Cnt Test Register */ - - LNK_LED_REG = 0x0c3c,/* 8 bit Link LED Register */ - -/* Receive GMAC FIFO (YUKON and Yukon-2) */ - - RX_GMF_EA = 0x0c40,/* 32 bit Rx GMAC FIFO End Address */ - RX_GMF_AF_THR = 0x0c44,/* 32 bit Rx GMAC FIFO Almost Full Thresh. */ - RX_GMF_CTRL_T = 0x0c48,/* 32 bit Rx GMAC FIFO Control/Test */ - RX_GMF_FL_MSK = 0x0c4c,/* 32 bit Rx GMAC FIFO Flush Mask */ - RX_GMF_FL_THR = 0x0c50,/* 32 bit Rx GMAC FIFO Flush Threshold */ - RX_GMF_TR_THR = 0x0c54,/* 32 bit Rx Truncation Threshold (Yukon-2) */ - RX_GMF_UP_THR = 0x0c58,/* 8 bit Rx Upper Pause Thr (Yukon-EC_U) */ - RX_GMF_LP_THR = 0x0c5a,/* 8 bit Rx Lower Pause Thr (Yukon-EC_U) */ - RX_GMF_VLAN = 0x0c5c,/* 32 bit Rx VLAN Type Register (Yukon-2) */ - RX_GMF_WP = 0x0c60,/* 32 bit Rx GMAC FIFO Write Pointer */ - - RX_GMF_WLEV = 0x0c68,/* 32 bit Rx GMAC FIFO Write Level */ - - RX_GMF_RP = 0x0c70,/* 32 bit Rx GMAC FIFO Read Pointer */ - - RX_GMF_RLEV = 0x0c78,/* 32 bit Rx GMAC FIFO Read Level */ -}; - - -/* Q_BC 32 bit Current Byte Counter */ - -/* BMU Control Status Registers */ -/* B0_R1_CSR 32 bit BMU Ctrl/Stat Rx Queue 1 */ -/* B0_R2_CSR 32 bit BMU Ctrl/Stat Rx Queue 2 */ -/* B0_XA1_CSR 32 bit BMU Ctrl/Stat Sync Tx Queue 1 */ -/* B0_XS1_CSR 32 bit BMU Ctrl/Stat Async Tx Queue 1 */ -/* B0_XA2_CSR 32 bit BMU Ctrl/Stat Sync Tx Queue 2 */ -/* B0_XS2_CSR 32 bit BMU Ctrl/Stat Async Tx Queue 2 */ -/* Q_CSR 32 bit BMU Control/Status Register */ - -/* Rx BMU Control / Status Registers (Yukon-2) */ -enum { - BMU_IDLE = 1<<31, /* BMU Idle State */ - BMU_RX_TCP_PKT = 1<<30, /* Rx TCP Packet (when RSS Hash enabled) */ - BMU_RX_IP_PKT = 1<<29, /* Rx IP Packet (when RSS Hash enabled) */ - - BMU_ENA_RX_RSS_HASH = 1<<15, /* Enable Rx RSS Hash */ - BMU_DIS_RX_RSS_HASH = 1<<14, /* Disable Rx RSS Hash */ - BMU_ENA_RX_CHKSUM = 1<<13, /* Enable Rx TCP/IP Checksum Check */ - BMU_DIS_RX_CHKSUM = 1<<12, /* Disable Rx TCP/IP Checksum Check */ - BMU_CLR_IRQ_PAR = 1<<11, /* Clear IRQ on Parity errors (Rx) */ - BMU_CLR_IRQ_TCP = 1<<11, /* Clear IRQ on TCP segment. error (Tx) */ - BMU_CLR_IRQ_CHK = 1<<10, /* Clear IRQ Check */ - BMU_STOP = 1<<9, /* Stop Rx/Tx Queue */ - BMU_START = 1<<8, /* Start Rx/Tx Queue */ - BMU_FIFO_OP_ON = 1<<7, /* FIFO Operational On */ - BMU_FIFO_OP_OFF = 1<<6, /* FIFO Operational Off */ - BMU_FIFO_ENA = 1<<5, /* Enable FIFO */ - BMU_FIFO_RST = 1<<4, /* Reset FIFO */ - BMU_OP_ON = 1<<3, /* BMU Operational On */ - BMU_OP_OFF = 1<<2, /* BMU Operational Off */ - BMU_RST_CLR = 1<<1, /* Clear BMU Reset (Enable) */ - BMU_RST_SET = 1<<0, /* Set BMU Reset */ - - BMU_CLR_RESET = BMU_FIFO_RST | BMU_OP_OFF | BMU_RST_CLR, - BMU_OPER_INIT = BMU_CLR_IRQ_PAR | BMU_CLR_IRQ_CHK | BMU_START | - BMU_FIFO_ENA | BMU_OP_ON, - - BMU_WM_DEFAULT = 0x600, -}; - -/* Tx BMU Control / Status Registers (Yukon-2) */ - /* Bit 31: same as for Rx */ -enum { - BMU_TX_IPIDINCR_ON = 1<<13, /* Enable IP ID Increment */ - BMU_TX_IPIDINCR_OFF = 1<<12, /* Disable IP ID Increment */ - BMU_TX_CLR_IRQ_TCP = 1<<11, /* Clear IRQ on TCP segment length mismatch */ -}; - -/* Queue Prefetch Unit Offsets, use Y2_QADDR() to address (Yukon-2 only)*/ -/* PREF_UNIT_CTRL 32 bit Prefetch Control register */ -enum { - PREF_UNIT_OP_ON = 1<<3, /* prefetch unit operational */ - PREF_UNIT_OP_OFF = 1<<2, /* prefetch unit not operational */ - PREF_UNIT_RST_CLR = 1<<1, /* Clear Prefetch Unit Reset */ - PREF_UNIT_RST_SET = 1<<0, /* Set Prefetch Unit Reset */ -}; - -/* RAM Buffer Register Offsets, use RB_ADDR(Queue, Offs) to access */ -/* RB_START 32 bit RAM Buffer Start Address */ -/* RB_END 32 bit RAM Buffer End Address */ -/* RB_WP 32 bit RAM Buffer Write Pointer */ -/* RB_RP 32 bit RAM Buffer Read Pointer */ -/* RB_RX_UTPP 32 bit Rx Upper Threshold, Pause Pack */ -/* RB_RX_LTPP 32 bit Rx Lower Threshold, Pause Pack */ -/* RB_RX_UTHP 32 bit Rx Upper Threshold, High Prio */ -/* RB_RX_LTHP 32 bit Rx Lower Threshold, High Prio */ -/* RB_PC 32 bit RAM Buffer Packet Counter */ -/* RB_LEV 32 bit RAM Buffer Level Register */ - -#define RB_MSK 0x0007ffff /* Bit 18.. 0: RAM Buffer Pointer Bits */ -/* RB_TST2 8 bit RAM Buffer Test Register 2 */ -/* RB_TST1 8 bit RAM Buffer Test Register 1 */ - -/* RB_CTRL 8 bit RAM Buffer Control Register */ -enum { - RB_ENA_STFWD = 1<<5, /* Enable Store & Forward */ - RB_DIS_STFWD = 1<<4, /* Disable Store & Forward */ - RB_ENA_OP_MD = 1<<3, /* Enable Operation Mode */ - RB_DIS_OP_MD = 1<<2, /* Disable Operation Mode */ - RB_RST_CLR = 1<<1, /* Clear RAM Buf STM Reset */ - RB_RST_SET = 1<<0, /* Set RAM Buf STM Reset */ -}; - - -/* Transmit GMAC FIFO (YUKON only) */ -enum { - TX_GMF_EA = 0x0d40,/* 32 bit Tx GMAC FIFO End Address */ - TX_GMF_AE_THR = 0x0d44,/* 32 bit Tx GMAC FIFO Almost Empty Thresh.*/ - TX_GMF_CTRL_T = 0x0d48,/* 32 bit Tx GMAC FIFO Control/Test */ - - TX_GMF_WP = 0x0d60,/* 32 bit Tx GMAC FIFO Write Pointer */ - TX_GMF_WSP = 0x0d64,/* 32 bit Tx GMAC FIFO Write Shadow Ptr. */ - TX_GMF_WLEV = 0x0d68,/* 32 bit Tx GMAC FIFO Write Level */ - - TX_GMF_RP = 0x0d70,/* 32 bit Tx GMAC FIFO Read Pointer */ - TX_GMF_RSTP = 0x0d74,/* 32 bit Tx GMAC FIFO Restart Pointer */ - TX_GMF_RLEV = 0x0d78,/* 32 bit Tx GMAC FIFO Read Level */ -}; - -/* Descriptor Poll Timer Registers */ -enum { - B28_DPT_INI = 0x0e00,/* 24 bit Descriptor Poll Timer Init Val */ - B28_DPT_VAL = 0x0e04,/* 24 bit Descriptor Poll Timer Curr Val */ - B28_DPT_CTRL = 0x0e08,/* 8 bit Descriptor Poll Timer Ctrl Reg */ - - B28_DPT_TST = 0x0e0a,/* 8 bit Descriptor Poll Timer Test Reg */ -}; - -/* Time Stamp Timer Registers (YUKON only) */ -enum { - GMAC_TI_ST_VAL = 0x0e14,/* 32 bit Time Stamp Timer Curr Val */ - GMAC_TI_ST_CTRL = 0x0e18,/* 8 bit Time Stamp Timer Ctrl Reg */ - GMAC_TI_ST_TST = 0x0e1a,/* 8 bit Time Stamp Timer Test Reg */ -}; - -/* Polling Unit Registers (Yukon-2 only) */ -enum { - POLL_CTRL = 0x0e20, /* 32 bit Polling Unit Control Reg */ - POLL_LAST_IDX = 0x0e24,/* 16 bit Polling Unit List Last Index */ - - POLL_LIST_ADDR_LO= 0x0e28,/* 32 bit Poll. List Start Addr (low) */ - POLL_LIST_ADDR_HI= 0x0e2c,/* 32 bit Poll. List Start Addr (high) */ -}; - -/* ASF Subsystem Registers (Yukon-2 only) */ -enum { - B28_Y2_SMB_CONFIG = 0x0e40,/* 32 bit ASF SMBus Config Register */ - B28_Y2_SMB_CSD_REG = 0x0e44,/* 32 bit ASF SMB Control/Status/Data */ - B28_Y2_ASF_IRQ_V_BASE=0x0e60,/* 32 bit ASF IRQ Vector Base */ - - B28_Y2_ASF_STAT_CMD= 0x0e68,/* 32 bit ASF Status and Command Reg */ - B28_Y2_ASF_HOST_COM= 0x0e6c,/* 32 bit ASF Host Communication Reg */ - B28_Y2_DATA_REG_1 = 0x0e70,/* 32 bit ASF/Host Data Register 1 */ - B28_Y2_DATA_REG_2 = 0x0e74,/* 32 bit ASF/Host Data Register 2 */ - B28_Y2_DATA_REG_3 = 0x0e78,/* 32 bit ASF/Host Data Register 3 */ - B28_Y2_DATA_REG_4 = 0x0e7c,/* 32 bit ASF/Host Data Register 4 */ -}; - -/* Status BMU Registers (Yukon-2 only)*/ -enum { - STAT_CTRL = 0x0e80,/* 32 bit Status BMU Control Reg */ - STAT_LAST_IDX = 0x0e84,/* 16 bit Status BMU Last Index */ - - STAT_LIST_ADDR_LO= 0x0e88,/* 32 bit Status List Start Addr (low) */ - STAT_LIST_ADDR_HI= 0x0e8c,/* 32 bit Status List Start Addr (high) */ - STAT_TXA1_RIDX = 0x0e90,/* 16 bit Status TxA1 Report Index Reg */ - STAT_TXS1_RIDX = 0x0e92,/* 16 bit Status TxS1 Report Index Reg */ - STAT_TXA2_RIDX = 0x0e94,/* 16 bit Status TxA2 Report Index Reg */ - STAT_TXS2_RIDX = 0x0e96,/* 16 bit Status TxS2 Report Index Reg */ - STAT_TX_IDX_TH = 0x0e98,/* 16 bit Status Tx Index Threshold Reg */ - STAT_PUT_IDX = 0x0e9c,/* 16 bit Status Put Index Reg */ - -/* FIFO Control/Status Registers (Yukon-2 only)*/ - STAT_FIFO_WP = 0x0ea0,/* 8 bit Status FIFO Write Pointer Reg */ - STAT_FIFO_RP = 0x0ea4,/* 8 bit Status FIFO Read Pointer Reg */ - STAT_FIFO_RSP = 0x0ea6,/* 8 bit Status FIFO Read Shadow Ptr */ - STAT_FIFO_LEVEL = 0x0ea8,/* 8 bit Status FIFO Level Reg */ - STAT_FIFO_SHLVL = 0x0eaa,/* 8 bit Status FIFO Shadow Level Reg */ - STAT_FIFO_WM = 0x0eac,/* 8 bit Status FIFO Watermark Reg */ - STAT_FIFO_ISR_WM= 0x0ead,/* 8 bit Status FIFO ISR Watermark Reg */ - -/* Level and ISR Timer Registers (Yukon-2 only)*/ - STAT_LEV_TIMER_INI= 0x0eb0,/* 32 bit Level Timer Init. Value Reg */ - STAT_LEV_TIMER_CNT= 0x0eb4,/* 32 bit Level Timer Counter Reg */ - STAT_LEV_TIMER_CTRL= 0x0eb8,/* 8 bit Level Timer Control Reg */ - STAT_LEV_TIMER_TEST= 0x0eb9,/* 8 bit Level Timer Test Reg */ - STAT_TX_TIMER_INI = 0x0ec0,/* 32 bit Tx Timer Init. Value Reg */ - STAT_TX_TIMER_CNT = 0x0ec4,/* 32 bit Tx Timer Counter Reg */ - STAT_TX_TIMER_CTRL = 0x0ec8,/* 8 bit Tx Timer Control Reg */ - STAT_TX_TIMER_TEST = 0x0ec9,/* 8 bit Tx Timer Test Reg */ - STAT_ISR_TIMER_INI = 0x0ed0,/* 32 bit ISR Timer Init. Value Reg */ - STAT_ISR_TIMER_CNT = 0x0ed4,/* 32 bit ISR Timer Counter Reg */ - STAT_ISR_TIMER_CTRL= 0x0ed8,/* 8 bit ISR Timer Control Reg */ - STAT_ISR_TIMER_TEST= 0x0ed9,/* 8 bit ISR Timer Test Reg */ -}; - -enum { - LINKLED_OFF = 0x01, - LINKLED_ON = 0x02, - LINKLED_LINKSYNC_OFF = 0x04, - LINKLED_LINKSYNC_ON = 0x08, - LINKLED_BLINK_OFF = 0x10, - LINKLED_BLINK_ON = 0x20, -}; - -/* GMAC and GPHY Control Registers (YUKON only) */ -enum { - GMAC_CTRL = 0x0f00,/* 32 bit GMAC Control Reg */ - GPHY_CTRL = 0x0f04,/* 32 bit GPHY Control Reg */ - GMAC_IRQ_SRC = 0x0f08,/* 8 bit GMAC Interrupt Source Reg */ - GMAC_IRQ_MSK = 0x0f0c,/* 8 bit GMAC Interrupt Mask Reg */ - GMAC_LINK_CTRL = 0x0f10,/* 16 bit Link Control Reg */ - -/* Wake-up Frame Pattern Match Control Registers (YUKON only) */ - - WOL_REG_OFFS = 0x20,/* HW-Bug: Address is + 0x20 against spec. */ - - WOL_CTRL_STAT = 0x0f20,/* 16 bit WOL Control/Status Reg */ - WOL_MATCH_CTL = 0x0f22,/* 8 bit WOL Match Control Reg */ - WOL_MATCH_RES = 0x0f23,/* 8 bit WOL Match Result Reg */ - WOL_MAC_ADDR = 0x0f24,/* 32 bit WOL MAC Address */ - WOL_PATT_PME = 0x0f2a,/* 8 bit WOL PME Match Enable (Yukon-2) */ - WOL_PATT_ASFM = 0x0f2b,/* 8 bit WOL ASF Match Enable (Yukon-2) */ - WOL_PATT_RPTR = 0x0f2c,/* 8 bit WOL Pattern Read Pointer */ - -/* WOL Pattern Length Registers (YUKON only) */ - - WOL_PATT_LEN_LO = 0x0f30,/* 32 bit WOL Pattern Length 3..0 */ - WOL_PATT_LEN_HI = 0x0f34,/* 24 bit WOL Pattern Length 6..4 */ - -/* WOL Pattern Counter Registers (YUKON only) */ - - - WOL_PATT_CNT_0 = 0x0f38,/* 32 bit WOL Pattern Counter 3..0 */ - WOL_PATT_CNT_4 = 0x0f3c,/* 24 bit WOL Pattern Counter 6..4 */ -}; - -enum { - WOL_PATT_RAM_1 = 0x1000,/* WOL Pattern RAM Link 1 */ - WOL_PATT_RAM_2 = 0x1400,/* WOL Pattern RAM Link 2 */ -}; - -enum { - BASE_GMAC_1 = 0x2800,/* GMAC 1 registers */ - BASE_GMAC_2 = 0x3800,/* GMAC 2 registers */ -}; - -/* - * Marvel-PHY Registers, indirect addressed over GMAC - */ -enum { - PHY_MARV_CTRL = 0x00,/* 16 bit r/w PHY Control Register */ - PHY_MARV_STAT = 0x01,/* 16 bit r/o PHY Status Register */ - PHY_MARV_ID0 = 0x02,/* 16 bit r/o PHY ID0 Register */ - PHY_MARV_ID1 = 0x03,/* 16 bit r/o PHY ID1 Register */ - PHY_MARV_AUNE_ADV = 0x04,/* 16 bit r/w Auto-Neg. Advertisement */ - PHY_MARV_AUNE_LP = 0x05,/* 16 bit r/o Link Part Ability Reg */ - PHY_MARV_AUNE_EXP = 0x06,/* 16 bit r/o Auto-Neg. Expansion Reg */ - PHY_MARV_NEPG = 0x07,/* 16 bit r/w Next Page Register */ - PHY_MARV_NEPG_LP = 0x08,/* 16 bit r/o Next Page Link Partner */ - /* Marvel-specific registers */ - PHY_MARV_1000T_CTRL = 0x09,/* 16 bit r/w 1000Base-T Control Reg */ - PHY_MARV_1000T_STAT = 0x0a,/* 16 bit r/o 1000Base-T Status Reg */ - PHY_MARV_EXT_STAT = 0x0f,/* 16 bit r/o Extended Status Reg */ - PHY_MARV_PHY_CTRL = 0x10,/* 16 bit r/w PHY Specific Ctrl Reg */ - PHY_MARV_PHY_STAT = 0x11,/* 16 bit r/o PHY Specific Stat Reg */ - PHY_MARV_INT_MASK = 0x12,/* 16 bit r/w Interrupt Mask Reg */ - PHY_MARV_INT_STAT = 0x13,/* 16 bit r/o Interrupt Status Reg */ - PHY_MARV_EXT_CTRL = 0x14,/* 16 bit r/w Ext. PHY Specific Ctrl */ - PHY_MARV_RXE_CNT = 0x15,/* 16 bit r/w Receive Error Counter */ - PHY_MARV_EXT_ADR = 0x16,/* 16 bit r/w Ext. Ad. for Cable Diag. */ - PHY_MARV_PORT_IRQ = 0x17,/* 16 bit r/o Port 0 IRQ (88E1111 only) */ - PHY_MARV_LED_CTRL = 0x18,/* 16 bit r/w LED Control Reg */ - PHY_MARV_LED_OVER = 0x19,/* 16 bit r/w Manual LED Override Reg */ - PHY_MARV_EXT_CTRL_2 = 0x1a,/* 16 bit r/w Ext. PHY Specific Ctrl 2 */ - PHY_MARV_EXT_P_STAT = 0x1b,/* 16 bit r/w Ext. PHY Spec. Stat Reg */ - PHY_MARV_CABLE_DIAG = 0x1c,/* 16 bit r/o Cable Diagnostic Reg */ - PHY_MARV_PAGE_ADDR = 0x1d,/* 16 bit r/w Extended Page Address Reg */ - PHY_MARV_PAGE_DATA = 0x1e,/* 16 bit r/w Extended Page Data Reg */ - -/* for 10/100 Fast Ethernet PHY (88E3082 only) */ - PHY_MARV_FE_LED_PAR = 0x16,/* 16 bit r/w LED Parallel Select Reg. */ - PHY_MARV_FE_LED_SER = 0x17,/* 16 bit r/w LED Stream Select S. LED */ - PHY_MARV_FE_VCT_TX = 0x1a,/* 16 bit r/w VCT Reg. for TXP/N Pins */ - PHY_MARV_FE_VCT_RX = 0x1b,/* 16 bit r/o VCT Reg. for RXP/N Pins */ - PHY_MARV_FE_SPEC_2 = 0x1c,/* 16 bit r/w Specific Control Reg. 2 */ -}; - -enum { - PHY_CT_RESET = 1<<15, /* Bit 15: (sc) clear all PHY related regs */ - PHY_CT_LOOP = 1<<14, /* Bit 14: enable Loopback over PHY */ - PHY_CT_SPS_LSB = 1<<13, /* Bit 13: Speed select, lower bit */ - PHY_CT_ANE = 1<<12, /* Bit 12: Auto-Negotiation Enabled */ - PHY_CT_PDOWN = 1<<11, /* Bit 11: Power Down Mode */ - PHY_CT_ISOL = 1<<10, /* Bit 10: Isolate Mode */ - PHY_CT_RE_CFG = 1<<9, /* Bit 9: (sc) Restart Auto-Negotiation */ - PHY_CT_DUP_MD = 1<<8, /* Bit 8: Duplex Mode */ - PHY_CT_COL_TST = 1<<7, /* Bit 7: Collision Test enabled */ - PHY_CT_SPS_MSB = 1<<6, /* Bit 6: Speed select, upper bit */ -}; - -enum { - PHY_CT_SP1000 = PHY_CT_SPS_MSB, /* enable speed of 1000 Mbps */ - PHY_CT_SP100 = PHY_CT_SPS_LSB, /* enable speed of 100 Mbps */ - PHY_CT_SP10 = 0, /* enable speed of 10 Mbps */ -}; - -enum { - PHY_ST_EXT_ST = 1<<8, /* Bit 8: Extended Status Present */ - - PHY_ST_PRE_SUP = 1<<6, /* Bit 6: Preamble Suppression */ - PHY_ST_AN_OVER = 1<<5, /* Bit 5: Auto-Negotiation Over */ - PHY_ST_REM_FLT = 1<<4, /* Bit 4: Remote Fault Condition Occured */ - PHY_ST_AN_CAP = 1<<3, /* Bit 3: Auto-Negotiation Capability */ - PHY_ST_LSYNC = 1<<2, /* Bit 2: Link Synchronized */ - PHY_ST_JAB_DET = 1<<1, /* Bit 1: Jabber Detected */ - PHY_ST_EXT_REG = 1<<0, /* Bit 0: Extended Register available */ -}; - -enum { - PHY_I1_OUI_MSK = 0x3f<<10, /* Bit 15..10: Organization Unique ID */ - PHY_I1_MOD_NUM = 0x3f<<4, /* Bit 9.. 4: Model Number */ - PHY_I1_REV_MSK = 0xf, /* Bit 3.. 0: Revision Number */ -}; - -/* different Marvell PHY Ids */ -enum { - PHY_MARV_ID0_VAL= 0x0141, /* Marvell Unique Identifier */ - - PHY_BCOM_ID1_A1 = 0x6041, - PHY_BCOM_ID1_B2 = 0x6043, - PHY_BCOM_ID1_C0 = 0x6044, - PHY_BCOM_ID1_C5 = 0x6047, - - PHY_MARV_ID1_B0 = 0x0C23, /* Yukon (PHY 88E1011) */ - PHY_MARV_ID1_B2 = 0x0C25, /* Yukon-Plus (PHY 88E1011) */ - PHY_MARV_ID1_C2 = 0x0CC2, /* Yukon-EC (PHY 88E1111) */ - PHY_MARV_ID1_Y2 = 0x0C91, /* Yukon-2 (PHY 88E1112) */ -}; - -/* Advertisement register bits */ -enum { - PHY_AN_NXT_PG = 1<<15, /* Bit 15: Request Next Page */ - PHY_AN_ACK = 1<<14, /* Bit 14: (ro) Acknowledge Received */ - PHY_AN_RF = 1<<13, /* Bit 13: Remote Fault Bits */ - - PHY_AN_PAUSE_ASYM = 1<<11,/* Bit 11: Try for asymmetric */ - PHY_AN_PAUSE_CAP = 1<<10, /* Bit 10: Try for pause */ - PHY_AN_100BASE4 = 1<<9, /* Bit 9: Try for 100mbps 4k packets */ - PHY_AN_100FULL = 1<<8, /* Bit 8: Try for 100mbps full-duplex */ - PHY_AN_100HALF = 1<<7, /* Bit 7: Try for 100mbps half-duplex */ - PHY_AN_10FULL = 1<<6, /* Bit 6: Try for 10mbps full-duplex */ - PHY_AN_10HALF = 1<<5, /* Bit 5: Try for 10mbps half-duplex */ - PHY_AN_CSMA = 1<<0, /* Bit 0: Only selector supported */ - PHY_AN_SEL = 0x1f, /* Bit 4..0: Selector Field, 00001=Ethernet*/ - PHY_AN_FULL = PHY_AN_100FULL | PHY_AN_10FULL | PHY_AN_CSMA, - PHY_AN_ALL = PHY_AN_10HALF | PHY_AN_10FULL | - PHY_AN_100HALF | PHY_AN_100FULL, -}; - -/***** PHY_BCOM_1000T_STAT 16 bit r/o 1000Base-T Status Reg *****/ -/***** PHY_MARV_1000T_STAT 16 bit r/o 1000Base-T Status Reg *****/ -enum { - PHY_B_1000S_MSF = 1<<15, /* Bit 15: Master/Slave Fault */ - PHY_B_1000S_MSR = 1<<14, /* Bit 14: Master/Slave Result */ - PHY_B_1000S_LRS = 1<<13, /* Bit 13: Local Receiver Status */ - PHY_B_1000S_RRS = 1<<12, /* Bit 12: Remote Receiver Status */ - PHY_B_1000S_LP_FD = 1<<11, /* Bit 11: Link Partner can FD */ - PHY_B_1000S_LP_HD = 1<<10, /* Bit 10: Link Partner can HD */ - /* Bit 9..8: reserved */ - PHY_B_1000S_IEC = 0xff, /* Bit 7..0: Idle Error Count */ -}; - -/** Marvell-Specific */ -enum { - PHY_M_AN_NXT_PG = 1<<15, /* Request Next Page */ - PHY_M_AN_ACK = 1<<14, /* (ro) Acknowledge Received */ - PHY_M_AN_RF = 1<<13, /* Remote Fault */ - - PHY_M_AN_ASP = 1<<11, /* Asymmetric Pause */ - PHY_M_AN_PC = 1<<10, /* MAC Pause implemented */ - PHY_M_AN_100_T4 = 1<<9, /* Not cap. 100Base-T4 (always 0) */ - PHY_M_AN_100_FD = 1<<8, /* Advertise 100Base-TX Full Duplex */ - PHY_M_AN_100_HD = 1<<7, /* Advertise 100Base-TX Half Duplex */ - PHY_M_AN_10_FD = 1<<6, /* Advertise 10Base-TX Full Duplex */ - PHY_M_AN_10_HD = 1<<5, /* Advertise 10Base-TX Half Duplex */ - PHY_M_AN_SEL_MSK =0x1f<<4, /* Bit 4.. 0: Selector Field Mask */ -}; - -/* special defines for FIBER (88E1011S only) */ -enum { - PHY_M_AN_ASP_X = 1<<8, /* Asymmetric Pause */ - PHY_M_AN_PC_X = 1<<7, /* MAC Pause implemented */ - PHY_M_AN_1000X_AHD = 1<<6, /* Advertise 10000Base-X Half Duplex */ - PHY_M_AN_1000X_AFD = 1<<5, /* Advertise 10000Base-X Full Duplex */ -}; - -/* Pause Bits (PHY_M_AN_ASP_X and PHY_M_AN_PC_X) encoding */ -enum { - PHY_M_P_NO_PAUSE_X = 0<<7,/* Bit 8.. 7: no Pause Mode */ - PHY_M_P_SYM_MD_X = 1<<7, /* Bit 8.. 7: symmetric Pause Mode */ - PHY_M_P_ASYM_MD_X = 2<<7,/* Bit 8.. 7: asymmetric Pause Mode */ - PHY_M_P_BOTH_MD_X = 3<<7,/* Bit 8.. 7: both Pause Mode */ -}; - -/***** PHY_MARV_1000T_CTRL 16 bit r/w 1000Base-T Control Reg *****/ -enum { - PHY_M_1000C_TEST = 7<<13,/* Bit 15..13: Test Modes */ - PHY_M_1000C_MSE = 1<<12, /* Manual Master/Slave Enable */ - PHY_M_1000C_MSC = 1<<11, /* M/S Configuration (1=Master) */ - PHY_M_1000C_MPD = 1<<10, /* Multi-Port Device */ - PHY_M_1000C_AFD = 1<<9, /* Advertise Full Duplex */ - PHY_M_1000C_AHD = 1<<8, /* Advertise Half Duplex */ -}; - -/***** PHY_MARV_PHY_CTRL 16 bit r/w PHY Specific Ctrl Reg *****/ -enum { - PHY_M_PC_TX_FFD_MSK = 3<<14,/* Bit 15..14: Tx FIFO Depth Mask */ - PHY_M_PC_RX_FFD_MSK = 3<<12,/* Bit 13..12: Rx FIFO Depth Mask */ - PHY_M_PC_ASS_CRS_TX = 1<<11, /* Assert CRS on Transmit */ - PHY_M_PC_FL_GOOD = 1<<10, /* Force Link Good */ - PHY_M_PC_EN_DET_MSK = 3<<8,/* Bit 9.. 8: Energy Detect Mask */ - PHY_M_PC_ENA_EXT_D = 1<<7, /* Enable Ext. Distance (10BT) */ - PHY_M_PC_MDIX_MSK = 3<<5,/* Bit 6.. 5: MDI/MDIX Config. Mask */ - PHY_M_PC_DIS_125CLK = 1<<4, /* Disable 125 CLK */ - PHY_M_PC_MAC_POW_UP = 1<<3, /* MAC Power up */ - PHY_M_PC_SQE_T_ENA = 1<<2, /* SQE Test Enabled */ - PHY_M_PC_POL_R_DIS = 1<<1, /* Polarity Reversal Disabled */ - PHY_M_PC_DIS_JABBER = 1<<0, /* Disable Jabber */ -}; - -enum { - PHY_M_PC_EN_DET = 2<<8, /* Energy Detect (Mode 1) */ - PHY_M_PC_EN_DET_PLUS = 3<<8, /* Energy Detect Plus (Mode 2) */ -}; - -#define PHY_M_PC_MDI_XMODE(x) (((x)<<5) & PHY_M_PC_MDIX_MSK) - -enum { - PHY_M_PC_MAN_MDI = 0, /* 00 = Manual MDI configuration */ - PHY_M_PC_MAN_MDIX = 1, /* 01 = Manual MDIX configuration */ - PHY_M_PC_ENA_AUTO = 3, /* 11 = Enable Automatic Crossover */ -}; - -/* for 10/100 Fast Ethernet PHY (88E3082 only) */ -enum { - PHY_M_PC_ENA_DTE_DT = 1<<15, /* Enable Data Terminal Equ. (DTE) Detect */ - PHY_M_PC_ENA_ENE_DT = 1<<14, /* Enable Energy Detect (sense & pulse) */ - PHY_M_PC_DIS_NLP_CK = 1<<13, /* Disable Normal Link Puls (NLP) Check */ - PHY_M_PC_ENA_LIP_NP = 1<<12, /* Enable Link Partner Next Page Reg. */ - PHY_M_PC_DIS_NLP_GN = 1<<11, /* Disable Normal Link Puls Generation */ - - PHY_M_PC_DIS_SCRAMB = 1<<9, /* Disable Scrambler */ - PHY_M_PC_DIS_FEFI = 1<<8, /* Disable Far End Fault Indic. (FEFI) */ - - PHY_M_PC_SH_TP_SEL = 1<<6, /* Shielded Twisted Pair Select */ - PHY_M_PC_RX_FD_MSK = 3<<2,/* Bit 3.. 2: Rx FIFO Depth Mask */ -}; - -/***** PHY_MARV_PHY_STAT 16 bit r/o PHY Specific Status Reg *****/ -enum { - PHY_M_PS_SPEED_MSK = 3<<14, /* Bit 15..14: Speed Mask */ - PHY_M_PS_SPEED_1000 = 1<<15, /* 10 = 1000 Mbps */ - PHY_M_PS_SPEED_100 = 1<<14, /* 01 = 100 Mbps */ - PHY_M_PS_SPEED_10 = 0, /* 00 = 10 Mbps */ - PHY_M_PS_FULL_DUP = 1<<13, /* Full Duplex */ - PHY_M_PS_PAGE_REC = 1<<12, /* Page Received */ - PHY_M_PS_SPDUP_RES = 1<<11, /* Speed & Duplex Resolved */ - PHY_M_PS_LINK_UP = 1<<10, /* Link Up */ - PHY_M_PS_CABLE_MSK = 7<<7, /* Bit 9.. 7: Cable Length Mask */ - PHY_M_PS_MDI_X_STAT = 1<<6, /* MDI Crossover Stat (1=MDIX) */ - PHY_M_PS_DOWNS_STAT = 1<<5, /* Downshift Status (1=downsh.) */ - PHY_M_PS_ENDET_STAT = 1<<4, /* Energy Detect Status (1=act) */ - PHY_M_PS_TX_P_EN = 1<<3, /* Tx Pause Enabled */ - PHY_M_PS_RX_P_EN = 1<<2, /* Rx Pause Enabled */ - PHY_M_PS_POL_REV = 1<<1, /* Polarity Reversed */ - PHY_M_PS_JABBER = 1<<0, /* Jabber */ -}; - -#define PHY_M_PS_PAUSE_MSK (PHY_M_PS_TX_P_EN | PHY_M_PS_RX_P_EN) - -/* for 10/100 Fast Ethernet PHY (88E3082 only) */ -enum { - PHY_M_PS_DTE_DETECT = 1<<15, /* Data Terminal Equipment (DTE) Detected */ - PHY_M_PS_RES_SPEED = 1<<14, /* Resolved Speed (1=100 Mbps, 0=10 Mbps */ -}; - -enum { - PHY_M_IS_AN_ERROR = 1<<15, /* Auto-Negotiation Error */ - PHY_M_IS_LSP_CHANGE = 1<<14, /* Link Speed Changed */ - PHY_M_IS_DUP_CHANGE = 1<<13, /* Duplex Mode Changed */ - PHY_M_IS_AN_PR = 1<<12, /* Page Received */ - PHY_M_IS_AN_COMPL = 1<<11, /* Auto-Negotiation Completed */ - PHY_M_IS_LST_CHANGE = 1<<10, /* Link Status Changed */ - PHY_M_IS_SYMB_ERROR = 1<<9, /* Symbol Error */ - PHY_M_IS_FALSE_CARR = 1<<8, /* False Carrier */ - PHY_M_IS_FIFO_ERROR = 1<<7, /* FIFO Overflow/Underrun Error */ - PHY_M_IS_MDI_CHANGE = 1<<6, /* MDI Crossover Changed */ - PHY_M_IS_DOWNSH_DET = 1<<5, /* Downshift Detected */ - PHY_M_IS_END_CHANGE = 1<<4, /* Energy Detect Changed */ - - PHY_M_IS_DTE_CHANGE = 1<<2, /* DTE Power Det. Status Changed */ - PHY_M_IS_POL_CHANGE = 1<<1, /* Polarity Changed */ - PHY_M_IS_JABBER = 1<<0, /* Jabber */ - - PHY_M_DEF_MSK = PHY_M_IS_LSP_CHANGE | PHY_M_IS_LST_CHANGE - | PHY_M_IS_FIFO_ERROR, - PHY_M_AN_MSK = PHY_M_IS_AN_ERROR | PHY_M_IS_AN_COMPL, -}; - - -/***** PHY_MARV_EXT_CTRL 16 bit r/w Ext. PHY Specific Ctrl *****/ -enum { - PHY_M_EC_ENA_BC_EXT = 1<<15, /* Enable Block Carr. Ext. (88E1111 only) */ - PHY_M_EC_ENA_LIN_LB = 1<<14, /* Enable Line Loopback (88E1111 only) */ - - PHY_M_EC_DIS_LINK_P = 1<<12, /* Disable Link Pulses (88E1111 only) */ - PHY_M_EC_M_DSC_MSK = 3<<10, /* Bit 11..10: Master Downshift Counter */ - /* (88E1011 only) */ - PHY_M_EC_S_DSC_MSK = 3<<8,/* Bit 9.. 8: Slave Downshift Counter */ - /* (88E1011 only) */ - PHY_M_EC_M_DSC_MSK2 = 7<<9,/* Bit 11.. 9: Master Downshift Counter */ - /* (88E1111 only) */ - PHY_M_EC_DOWN_S_ENA = 1<<8, /* Downshift Enable (88E1111 only) */ - /* !!! Errata in spec. (1 = disable) */ - PHY_M_EC_RX_TIM_CT = 1<<7, /* RGMII Rx Timing Control*/ - PHY_M_EC_MAC_S_MSK = 7<<4,/* Bit 6.. 4: Def. MAC interface speed */ - PHY_M_EC_FIB_AN_ENA = 1<<3, /* Fiber Auto-Neg. Enable (88E1011S only) */ - PHY_M_EC_DTE_D_ENA = 1<<2, /* DTE Detect Enable (88E1111 only) */ - PHY_M_EC_TX_TIM_CT = 1<<1, /* RGMII Tx Timing Control */ - PHY_M_EC_TRANS_DIS = 1<<0, /* Transmitter Disable (88E1111 only) */}; - -#define PHY_M_EC_M_DSC(x) ((x)<<10 & PHY_M_EC_M_DSC_MSK) - /* 00=1x; 01=2x; 10=3x; 11=4x */ -#define PHY_M_EC_S_DSC(x) ((x)<<8 & PHY_M_EC_S_DSC_MSK) - /* 00=dis; 01=1x; 10=2x; 11=3x */ -#define PHY_M_EC_DSC_2(x) ((x)<<9 & PHY_M_EC_M_DSC_MSK2) - /* 000=1x; 001=2x; 010=3x; 011=4x */ -#define PHY_M_EC_MAC_S(x) ((x)<<4 & PHY_M_EC_MAC_S_MSK) - /* 01X=0; 110=2.5; 111=25 (MHz) */ - -/* for Yukon-2 Gigabit Ethernet PHY (88E1112 only) */ -enum { - PHY_M_PC_DIS_LINK_Pa = 1<<15,/* Disable Link Pulses */ - PHY_M_PC_DSC_MSK = 7<<12,/* Bit 14..12: Downshift Counter */ - PHY_M_PC_DOWN_S_ENA = 1<<11,/* Downshift Enable */ -}; -/* !!! Errata in spec. (1 = disable) */ - -#define PHY_M_PC_DSC(x) (((x)<<12) & PHY_M_PC_DSC_MSK) - /* 100=5x; 101=6x; 110=7x; 111=8x */ -enum { - MAC_TX_CLK_0_MHZ = 2, - MAC_TX_CLK_2_5_MHZ = 6, - MAC_TX_CLK_25_MHZ = 7, -}; - -/***** PHY_MARV_LED_CTRL 16 bit r/w LED Control Reg *****/ -enum { - PHY_M_LEDC_DIS_LED = 1<<15, /* Disable LED */ - PHY_M_LEDC_PULS_MSK = 7<<12,/* Bit 14..12: Pulse Stretch Mask */ - PHY_M_LEDC_F_INT = 1<<11, /* Force Interrupt */ - PHY_M_LEDC_BL_R_MSK = 7<<8,/* Bit 10.. 8: Blink Rate Mask */ - PHY_M_LEDC_DP_C_LSB = 1<<7, /* Duplex Control (LSB, 88E1111 only) */ - PHY_M_LEDC_TX_C_LSB = 1<<6, /* Tx Control (LSB, 88E1111 only) */ - PHY_M_LEDC_LK_C_MSK = 7<<3,/* Bit 5.. 3: Link Control Mask */ - /* (88E1111 only) */ -}; - -enum { - PHY_M_LEDC_LINK_MSK = 3<<3,/* Bit 4.. 3: Link Control Mask */ - /* (88E1011 only) */ - PHY_M_LEDC_DP_CTRL = 1<<2, /* Duplex Control */ - PHY_M_LEDC_DP_C_MSB = 1<<2, /* Duplex Control (MSB, 88E1111 only) */ - PHY_M_LEDC_RX_CTRL = 1<<1, /* Rx Activity / Link */ - PHY_M_LEDC_TX_CTRL = 1<<0, /* Tx Activity / Link */ - PHY_M_LEDC_TX_C_MSB = 1<<0, /* Tx Control (MSB, 88E1111 only) */ -}; - -#define PHY_M_LED_PULS_DUR(x) (((x)<<12) & PHY_M_LEDC_PULS_MSK) - -/***** PHY_MARV_PHY_STAT (page 3)16 bit r/w Polarity Control Reg. *****/ -enum { - PHY_M_POLC_LS1M_MSK = 0xf<<12, /* Bit 15..12: LOS,STAT1 Mix % Mask */ - PHY_M_POLC_IS0M_MSK = 0xf<<8, /* Bit 11.. 8: INIT,STAT0 Mix % Mask */ - PHY_M_POLC_LOS_MSK = 0x3<<6, /* Bit 7.. 6: LOS Pol. Ctrl. Mask */ - PHY_M_POLC_INIT_MSK = 0x3<<4, /* Bit 5.. 4: INIT Pol. Ctrl. Mask */ - PHY_M_POLC_STA1_MSK = 0x3<<2, /* Bit 3.. 2: STAT1 Pol. Ctrl. Mask */ - PHY_M_POLC_STA0_MSK = 0x3, /* Bit 1.. 0: STAT0 Pol. Ctrl. Mask */ -}; - -#define PHY_M_POLC_LS1_P_MIX(x) (((x)<<12) & PHY_M_POLC_LS1M_MSK) -#define PHY_M_POLC_IS0_P_MIX(x) (((x)<<8) & PHY_M_POLC_IS0M_MSK) -#define PHY_M_POLC_LOS_CTRL(x) (((x)<<6) & PHY_M_POLC_LOS_MSK) -#define PHY_M_POLC_INIT_CTRL(x) (((x)<<4) & PHY_M_POLC_INIT_MSK) -#define PHY_M_POLC_STA1_CTRL(x) (((x)<<2) & PHY_M_POLC_STA1_MSK) -#define PHY_M_POLC_STA0_CTRL(x) (((x)<<0) & PHY_M_POLC_STA0_MSK) - -enum { - PULS_NO_STR = 0,/* no pulse stretching */ - PULS_21MS = 1,/* 21 ms to 42 ms */ - PULS_42MS = 2,/* 42 ms to 84 ms */ - PULS_84MS = 3,/* 84 ms to 170 ms */ - PULS_170MS = 4,/* 170 ms to 340 ms */ - PULS_340MS = 5,/* 340 ms to 670 ms */ - PULS_670MS = 6,/* 670 ms to 1.3 s */ - PULS_1300MS = 7,/* 1.3 s to 2.7 s */ -}; - -#define PHY_M_LED_BLINK_RT(x) (((x)<<8) & PHY_M_LEDC_BL_R_MSK) - -enum { - BLINK_42MS = 0,/* 42 ms */ - BLINK_84MS = 1,/* 84 ms */ - BLINK_170MS = 2,/* 170 ms */ - BLINK_340MS = 3,/* 340 ms */ - BLINK_670MS = 4,/* 670 ms */ -}; - -/***** PHY_MARV_LED_OVER 16 bit r/w Manual LED Override Reg *****/ -#define PHY_M_LED_MO_SGMII(x) ((x)<<14) /* Bit 15..14: SGMII AN Timer */ - /* Bit 13..12: reserved */ -#define PHY_M_LED_MO_DUP(x) ((x)<<10) /* Bit 11..10: Duplex */ -#define PHY_M_LED_MO_10(x) ((x)<<8) /* Bit 9.. 8: Link 10 */ -#define PHY_M_LED_MO_100(x) ((x)<<6) /* Bit 7.. 6: Link 100 */ -#define PHY_M_LED_MO_1000(x) ((x)<<4) /* Bit 5.. 4: Link 1000 */ -#define PHY_M_LED_MO_RX(x) ((x)<<2) /* Bit 3.. 2: Rx */ -#define PHY_M_LED_MO_TX(x) ((x)<<0) /* Bit 1.. 0: Tx */ - -enum { - MO_LED_NORM = 0, - MO_LED_BLINK = 1, - MO_LED_OFF = 2, - MO_LED_ON = 3, -}; - -/***** PHY_MARV_EXT_CTRL_2 16 bit r/w Ext. PHY Specific Ctrl 2 *****/ -enum { - PHY_M_EC2_FI_IMPED = 1<<6, /* Fiber Input Impedance */ - PHY_M_EC2_FO_IMPED = 1<<5, /* Fiber Output Impedance */ - PHY_M_EC2_FO_M_CLK = 1<<4, /* Fiber Mode Clock Enable */ - PHY_M_EC2_FO_BOOST = 1<<3, /* Fiber Output Boost */ - PHY_M_EC2_FO_AM_MSK = 7,/* Bit 2.. 0: Fiber Output Amplitude */ -}; - -/***** PHY_MARV_EXT_P_STAT 16 bit r/w Ext. PHY Specific Status *****/ -enum { - PHY_M_FC_AUTO_SEL = 1<<15, /* Fiber/Copper Auto Sel. Dis. */ - PHY_M_FC_AN_REG_ACC = 1<<14, /* Fiber/Copper AN Reg. Access */ - PHY_M_FC_RESOLUTION = 1<<13, /* Fiber/Copper Resolution */ - PHY_M_SER_IF_AN_BP = 1<<12, /* Ser. IF AN Bypass Enable */ - PHY_M_SER_IF_BP_ST = 1<<11, /* Ser. IF AN Bypass Status */ - PHY_M_IRQ_POLARITY = 1<<10, /* IRQ polarity */ - PHY_M_DIS_AUT_MED = 1<<9, /* Disable Aut. Medium Reg. Selection */ - /* (88E1111 only) */ - - PHY_M_UNDOC1 = 1<<7, /* undocumented bit !! */ - PHY_M_DTE_POW_STAT = 1<<4, /* DTE Power Status (88E1111 only) */ - PHY_M_MODE_MASK = 0xf, /* Bit 3.. 0: copy of HWCFG MODE[3:0] */ -}; - -/* for 10/100 Fast Ethernet PHY (88E3082 only) */ -/***** PHY_MARV_FE_LED_PAR 16 bit r/w LED Parallel Select Reg. *****/ - /* Bit 15..12: reserved (used internally) */ -enum { - PHY_M_FELP_LED2_MSK = 0xf<<8, /* Bit 11.. 8: LED2 Mask (LINK) */ - PHY_M_FELP_LED1_MSK = 0xf<<4, /* Bit 7.. 4: LED1 Mask (ACT) */ - PHY_M_FELP_LED0_MSK = 0xf, /* Bit 3.. 0: LED0 Mask (SPEED) */ -}; - -#define PHY_M_FELP_LED2_CTRL(x) (((x)<<8) & PHY_M_FELP_LED2_MSK) -#define PHY_M_FELP_LED1_CTRL(x) (((x)<<4) & PHY_M_FELP_LED1_MSK) -#define PHY_M_FELP_LED0_CTRL(x) (((x)<<0) & PHY_M_FELP_LED0_MSK) - -enum { - LED_PAR_CTRL_COLX = 0x00, - LED_PAR_CTRL_ERROR = 0x01, - LED_PAR_CTRL_DUPLEX = 0x02, - LED_PAR_CTRL_DP_COL = 0x03, - LED_PAR_CTRL_SPEED = 0x04, - LED_PAR_CTRL_LINK = 0x05, - LED_PAR_CTRL_TX = 0x06, - LED_PAR_CTRL_RX = 0x07, - LED_PAR_CTRL_ACT = 0x08, - LED_PAR_CTRL_LNK_RX = 0x09, - LED_PAR_CTRL_LNK_AC = 0x0a, - LED_PAR_CTRL_ACT_BL = 0x0b, - LED_PAR_CTRL_TX_BL = 0x0c, - LED_PAR_CTRL_RX_BL = 0x0d, - LED_PAR_CTRL_COL_BL = 0x0e, - LED_PAR_CTRL_INACT = 0x0f -}; - -/*****,PHY_MARV_FE_SPEC_2 16 bit r/w Specific Control Reg. 2 *****/ -enum { - PHY_M_FESC_DIS_WAIT = 1<<2, /* Disable TDR Waiting Period */ - PHY_M_FESC_ENA_MCLK = 1<<1, /* Enable MAC Rx Clock in sleep mode */ - PHY_M_FESC_SEL_CL_A = 1<<0, /* Select Class A driver (100B-TX) */ -}; - -/* for Yukon-2 Gigabit Ethernet PHY (88E1112 only) */ -/***** PHY_MARV_PHY_CTRL (page 2) 16 bit r/w MAC Specific Ctrl *****/ -enum { - PHY_M_MAC_MD_MSK = 7<<7, /* Bit 9.. 7: Mode Select Mask */ - PHY_M_MAC_MD_AUTO = 3,/* Auto Copper/1000Base-X */ - PHY_M_MAC_MD_COPPER = 5,/* Copper only */ - PHY_M_MAC_MD_1000BX = 7,/* 1000Base-X only */ -}; -#define PHY_M_MAC_MODE_SEL(x) (((x)<<7) & PHY_M_MAC_MD_MSK) - -/***** PHY_MARV_PHY_CTRL (page 3) 16 bit r/w LED Control Reg. *****/ -enum { - PHY_M_LEDC_LOS_MSK = 0xf<<12,/* Bit 15..12: LOS LED Ctrl. Mask */ - PHY_M_LEDC_INIT_MSK = 0xf<<8, /* Bit 11.. 8: INIT LED Ctrl. Mask */ - PHY_M_LEDC_STA1_MSK = 0xf<<4,/* Bit 7.. 4: STAT1 LED Ctrl. Mask */ - PHY_M_LEDC_STA0_MSK = 0xf, /* Bit 3.. 0: STAT0 LED Ctrl. Mask */ -}; - -#define PHY_M_LEDC_LOS_CTRL(x) (((x)<<12) & PHY_M_LEDC_LOS_MSK) -#define PHY_M_LEDC_INIT_CTRL(x) (((x)<<8) & PHY_M_LEDC_INIT_MSK) -#define PHY_M_LEDC_STA1_CTRL(x) (((x)<<4) & PHY_M_LEDC_STA1_MSK) -#define PHY_M_LEDC_STA0_CTRL(x) (((x)<<0) & PHY_M_LEDC_STA0_MSK) - -/* GMAC registers */ -/* Port Registers */ -enum { - GM_GP_STAT = 0x0000, /* 16 bit r/o General Purpose Status */ - GM_GP_CTRL = 0x0004, /* 16 bit r/w General Purpose Control */ - GM_TX_CTRL = 0x0008, /* 16 bit r/w Transmit Control Reg. */ - GM_RX_CTRL = 0x000c, /* 16 bit r/w Receive Control Reg. */ - GM_TX_FLOW_CTRL = 0x0010, /* 16 bit r/w Transmit Flow-Control */ - GM_TX_PARAM = 0x0014, /* 16 bit r/w Transmit Parameter Reg. */ - GM_SERIAL_MODE = 0x0018, /* 16 bit r/w Serial Mode Register */ -/* Source Address Registers */ - GM_SRC_ADDR_1L = 0x001c, /* 16 bit r/w Source Address 1 (low) */ - GM_SRC_ADDR_1M = 0x0020, /* 16 bit r/w Source Address 1 (middle) */ - GM_SRC_ADDR_1H = 0x0024, /* 16 bit r/w Source Address 1 (high) */ - GM_SRC_ADDR_2L = 0x0028, /* 16 bit r/w Source Address 2 (low) */ - GM_SRC_ADDR_2M = 0x002c, /* 16 bit r/w Source Address 2 (middle) */ - GM_SRC_ADDR_2H = 0x0030, /* 16 bit r/w Source Address 2 (high) */ - -/* Multicast Address Hash Registers */ - GM_MC_ADDR_H1 = 0x0034, /* 16 bit r/w Multicast Address Hash 1 */ - GM_MC_ADDR_H2 = 0x0038, /* 16 bit r/w Multicast Address Hash 2 */ - GM_MC_ADDR_H3 = 0x003c, /* 16 bit r/w Multicast Address Hash 3 */ - GM_MC_ADDR_H4 = 0x0040, /* 16 bit r/w Multicast Address Hash 4 */ - -/* Interrupt Source Registers */ - GM_TX_IRQ_SRC = 0x0044, /* 16 bit r/o Tx Overflow IRQ Source */ - GM_RX_IRQ_SRC = 0x0048, /* 16 bit r/o Rx Overflow IRQ Source */ - GM_TR_IRQ_SRC = 0x004c, /* 16 bit r/o Tx/Rx Over. IRQ Source */ - -/* Interrupt Mask Registers */ - GM_TX_IRQ_MSK = 0x0050, /* 16 bit r/w Tx Overflow IRQ Mask */ - GM_RX_IRQ_MSK = 0x0054, /* 16 bit r/w Rx Overflow IRQ Mask */ - GM_TR_IRQ_MSK = 0x0058, /* 16 bit r/w Tx/Rx Over. IRQ Mask */ - -/* Serial Management Interface (SMI) Registers */ - GM_SMI_CTRL = 0x0080, /* 16 bit r/w SMI Control Register */ - GM_SMI_DATA = 0x0084, /* 16 bit r/w SMI Data Register */ - GM_PHY_ADDR = 0x0088, /* 16 bit r/w GPHY Address Register */ -}; - -/* MIB Counters */ -#define GM_MIB_CNT_BASE 0x0100 /* Base Address of MIB Counters */ -#define GM_MIB_CNT_SIZE 44 /* Number of MIB Counters */ - -/* - * MIB Counters base address definitions (low word) - - * use offset 4 for access to high word (32 bit r/o) - */ -enum { - GM_RXF_UC_OK = GM_MIB_CNT_BASE + 0, /* Unicast Frames Received OK */ - GM_RXF_BC_OK = GM_MIB_CNT_BASE + 8, /* Broadcast Frames Received OK */ - GM_RXF_MPAUSE = GM_MIB_CNT_BASE + 16, /* Pause MAC Ctrl Frames Received */ - GM_RXF_MC_OK = GM_MIB_CNT_BASE + 24, /* Multicast Frames Received OK */ - GM_RXF_FCS_ERR = GM_MIB_CNT_BASE + 32, /* Rx Frame Check Seq. Error */ - /* GM_MIB_CNT_BASE + 40: reserved */ - GM_RXO_OK_LO = GM_MIB_CNT_BASE + 48, /* Octets Received OK Low */ - GM_RXO_OK_HI = GM_MIB_CNT_BASE + 56, /* Octets Received OK High */ - GM_RXO_ERR_LO = GM_MIB_CNT_BASE + 64, /* Octets Received Invalid Low */ - GM_RXO_ERR_HI = GM_MIB_CNT_BASE + 72, /* Octets Received Invalid High */ - GM_RXF_SHT = GM_MIB_CNT_BASE + 80, /* Frames <64 Byte Received OK */ - GM_RXE_FRAG = GM_MIB_CNT_BASE + 88, /* Frames <64 Byte Received with FCS Err */ - GM_RXF_64B = GM_MIB_CNT_BASE + 96, /* 64 Byte Rx Frame */ - GM_RXF_127B = GM_MIB_CNT_BASE + 104, /* 65-127 Byte Rx Frame */ - GM_RXF_255B = GM_MIB_CNT_BASE + 112, /* 128-255 Byte Rx Frame */ - GM_RXF_511B = GM_MIB_CNT_BASE + 120, /* 256-511 Byte Rx Frame */ - GM_RXF_1023B = GM_MIB_CNT_BASE + 128, /* 512-1023 Byte Rx Frame */ - GM_RXF_1518B = GM_MIB_CNT_BASE + 136, /* 1024-1518 Byte Rx Frame */ - GM_RXF_MAX_SZ = GM_MIB_CNT_BASE + 144, /* 1519-MaxSize Byte Rx Frame */ - GM_RXF_LNG_ERR = GM_MIB_CNT_BASE + 152, /* Rx Frame too Long Error */ - GM_RXF_JAB_PKT = GM_MIB_CNT_BASE + 160, /* Rx Jabber Packet Frame */ - /* GM_MIB_CNT_BASE + 168: reserved */ - GM_RXE_FIFO_OV = GM_MIB_CNT_BASE + 176, /* Rx FIFO overflow Event */ - /* GM_MIB_CNT_BASE + 184: reserved */ - GM_TXF_UC_OK = GM_MIB_CNT_BASE + 192, /* Unicast Frames Xmitted OK */ - GM_TXF_BC_OK = GM_MIB_CNT_BASE + 200, /* Broadcast Frames Xmitted OK */ - GM_TXF_MPAUSE = GM_MIB_CNT_BASE + 208, /* Pause MAC Ctrl Frames Xmitted */ - GM_TXF_MC_OK = GM_MIB_CNT_BASE + 216, /* Multicast Frames Xmitted OK */ - GM_TXO_OK_LO = GM_MIB_CNT_BASE + 224, /* Octets Transmitted OK Low */ - GM_TXO_OK_HI = GM_MIB_CNT_BASE + 232, /* Octets Transmitted OK High */ - GM_TXF_64B = GM_MIB_CNT_BASE + 240, /* 64 Byte Tx Frame */ - GM_TXF_127B = GM_MIB_CNT_BASE + 248, /* 65-127 Byte Tx Frame */ - GM_TXF_255B = GM_MIB_CNT_BASE + 256, /* 128-255 Byte Tx Frame */ - GM_TXF_511B = GM_MIB_CNT_BASE + 264, /* 256-511 Byte Tx Frame */ - GM_TXF_1023B = GM_MIB_CNT_BASE + 272, /* 512-1023 Byte Tx Frame */ - GM_TXF_1518B = GM_MIB_CNT_BASE + 280, /* 1024-1518 Byte Tx Frame */ - GM_TXF_MAX_SZ = GM_MIB_CNT_BASE + 288, /* 1519-MaxSize Byte Tx Frame */ - - GM_TXF_COL = GM_MIB_CNT_BASE + 304, /* Tx Collision */ - GM_TXF_LAT_COL = GM_MIB_CNT_BASE + 312, /* Tx Late Collision */ - GM_TXF_ABO_COL = GM_MIB_CNT_BASE + 320, /* Tx aborted due to Exces. Col. */ - GM_TXF_MUL_COL = GM_MIB_CNT_BASE + 328, /* Tx Multiple Collision */ - GM_TXF_SNG_COL = GM_MIB_CNT_BASE + 336, /* Tx Single Collision */ - GM_TXE_FIFO_UR = GM_MIB_CNT_BASE + 344, /* Tx FIFO Underrun Event */ -}; - -/* GMAC Bit Definitions */ -/* GM_GP_STAT 16 bit r/o General Purpose Status Register */ -enum { - GM_GPSR_SPEED = 1<<15, /* Bit 15: Port Speed (1 = 100 Mbps) */ - GM_GPSR_DUPLEX = 1<<14, /* Bit 14: Duplex Mode (1 = Full) */ - GM_GPSR_FC_TX_DIS = 1<<13, /* Bit 13: Tx Flow-Control Mode Disabled */ - GM_GPSR_LINK_UP = 1<<12, /* Bit 12: Link Up Status */ - GM_GPSR_PAUSE = 1<<11, /* Bit 11: Pause State */ - GM_GPSR_TX_ACTIVE = 1<<10, /* Bit 10: Tx in Progress */ - GM_GPSR_EXC_COL = 1<<9, /* Bit 9: Excessive Collisions Occured */ - GM_GPSR_LAT_COL = 1<<8, /* Bit 8: Late Collisions Occured */ - - GM_GPSR_PHY_ST_CH = 1<<5, /* Bit 5: PHY Status Change */ - GM_GPSR_GIG_SPEED = 1<<4, /* Bit 4: Gigabit Speed (1 = 1000 Mbps) */ - GM_GPSR_PART_MODE = 1<<3, /* Bit 3: Partition mode */ - GM_GPSR_FC_RX_DIS = 1<<2, /* Bit 2: Rx Flow-Control Mode Disabled */ - GM_GPSR_PROM_EN = 1<<1, /* Bit 1: Promiscuous Mode Enabled */ -}; - -/* GM_GP_CTRL 16 bit r/w General Purpose Control Register */ -enum { - GM_GPCR_PROM_ENA = 1<<14, /* Bit 14: Enable Promiscuous Mode */ - GM_GPCR_FC_TX_DIS = 1<<13, /* Bit 13: Disable Tx Flow-Control Mode */ - GM_GPCR_TX_ENA = 1<<12, /* Bit 12: Enable Transmit */ - GM_GPCR_RX_ENA = 1<<11, /* Bit 11: Enable Receive */ - GM_GPCR_BURST_ENA = 1<<10, /* Bit 10: Enable Burst Mode */ - GM_GPCR_LOOP_ENA = 1<<9, /* Bit 9: Enable MAC Loopback Mode */ - GM_GPCR_PART_ENA = 1<<8, /* Bit 8: Enable Partition Mode */ - GM_GPCR_GIGS_ENA = 1<<7, /* Bit 7: Gigabit Speed (1000 Mbps) */ - GM_GPCR_FL_PASS = 1<<6, /* Bit 6: Force Link Pass */ - GM_GPCR_DUP_FULL = 1<<5, /* Bit 5: Full Duplex Mode */ - GM_GPCR_FC_RX_DIS = 1<<4, /* Bit 4: Disable Rx Flow-Control Mode */ - GM_GPCR_SPEED_100 = 1<<3, /* Bit 3: Port Speed 100 Mbps */ - GM_GPCR_AU_DUP_DIS = 1<<2, /* Bit 2: Disable Auto-Update Duplex */ - GM_GPCR_AU_FCT_DIS = 1<<1, /* Bit 1: Disable Auto-Update Flow-C. */ - GM_GPCR_AU_SPD_DIS = 1<<0, /* Bit 0: Disable Auto-Update Speed */ -}; - -#define GM_GPCR_SPEED_1000 (GM_GPCR_GIGS_ENA | GM_GPCR_SPEED_100) -#define GM_GPCR_AU_ALL_DIS (GM_GPCR_AU_DUP_DIS | GM_GPCR_AU_FCT_DIS|GM_GPCR_AU_SPD_DIS) - -/* GM_TX_CTRL 16 bit r/w Transmit Control Register */ -enum { - GM_TXCR_FORCE_JAM = 1<<15, /* Bit 15: Force Jam / Flow-Control */ - GM_TXCR_CRC_DIS = 1<<14, /* Bit 14: Disable insertion of CRC */ - GM_TXCR_PAD_DIS = 1<<13, /* Bit 13: Disable padding of packets */ - GM_TXCR_COL_THR_MSK = 1<<10, /* Bit 12..10: Collision Threshold */ -}; - -#define TX_COL_THR(x) (((x)<<10) & GM_TXCR_COL_THR_MSK) -#define TX_COL_DEF 0x04 - -/* GM_RX_CTRL 16 bit r/w Receive Control Register */ -enum { - GM_RXCR_UCF_ENA = 1<<15, /* Bit 15: Enable Unicast filtering */ - GM_RXCR_MCF_ENA = 1<<14, /* Bit 14: Enable Multicast filtering */ - GM_RXCR_CRC_DIS = 1<<13, /* Bit 13: Remove 4-byte CRC */ - GM_RXCR_PASS_FC = 1<<12, /* Bit 12: Pass FC packets to FIFO */ -}; - -/* GM_TX_PARAM 16 bit r/w Transmit Parameter Register */ -enum { - GM_TXPA_JAMLEN_MSK = 0x03<<14, /* Bit 15..14: Jam Length */ - GM_TXPA_JAMIPG_MSK = 0x1f<<9, /* Bit 13..9: Jam IPG */ - GM_TXPA_JAMDAT_MSK = 0x1f<<4, /* Bit 8..4: IPG Jam to Data */ - GM_TXPA_BO_LIM_MSK = 0x0f, /* Bit 3.. 0: Backoff Limit Mask */ - - TX_JAM_LEN_DEF = 0x03, - TX_JAM_IPG_DEF = 0x0b, - TX_IPG_JAM_DEF = 0x1c, - TX_BOF_LIM_DEF = 0x04, -}; - -#define TX_JAM_LEN_VAL(x) (((x)<<14) & GM_TXPA_JAMLEN_MSK) -#define TX_JAM_IPG_VAL(x) (((x)<<9) & GM_TXPA_JAMIPG_MSK) -#define TX_IPG_JAM_DATA(x) (((x)<<4) & GM_TXPA_JAMDAT_MSK) -#define TX_BACK_OFF_LIM(x) ((x) & GM_TXPA_BO_LIM_MSK) - - -/* GM_SERIAL_MODE 16 bit r/w Serial Mode Register */ -enum { - GM_SMOD_DATABL_MSK = 0x1f<<11, /* Bit 15..11: Data Blinder (r/o) */ - GM_SMOD_LIMIT_4 = 1<<10, /* Bit 10: 4 consecutive Tx trials */ - GM_SMOD_VLAN_ENA = 1<<9, /* Bit 9: Enable VLAN (Max. Frame Len) */ - GM_SMOD_JUMBO_ENA = 1<<8, /* Bit 8: Enable Jumbo (Max. Frame Len) */ - GM_SMOD_IPG_MSK = 0x1f /* Bit 4..0: Inter-Packet Gap (IPG) */ -}; - -#define DATA_BLIND_VAL(x) (((x)<<11) & GM_SMOD_DATABL_MSK) -#define DATA_BLIND_DEF 0x04 - -#define IPG_DATA_VAL(x) (x & GM_SMOD_IPG_MSK) -#define IPG_DATA_DEF 0x1e - -/* GM_SMI_CTRL 16 bit r/w SMI Control Register */ -enum { - GM_SMI_CT_PHY_A_MSK = 0x1f<<11,/* Bit 15..11: PHY Device Address */ - GM_SMI_CT_REG_A_MSK = 0x1f<<6,/* Bit 10.. 6: PHY Register Address */ - GM_SMI_CT_OP_RD = 1<<5, /* Bit 5: OpCode Read (0=Write)*/ - GM_SMI_CT_RD_VAL = 1<<4, /* Bit 4: Read Valid (Read completed) */ - GM_SMI_CT_BUSY = 1<<3, /* Bit 3: Busy (Operation in progress) */ -}; - -#define GM_SMI_CT_PHY_AD(x) (((x)<<11) & GM_SMI_CT_PHY_A_MSK) -#define GM_SMI_CT_REG_AD(x) (((x)<<6) & GM_SMI_CT_REG_A_MSK) - -/* GM_PHY_ADDR 16 bit r/w GPHY Address Register */ -enum { - GM_PAR_MIB_CLR = 1<<5, /* Bit 5: Set MIB Clear Counter Mode */ - GM_PAR_MIB_TST = 1<<4, /* Bit 4: MIB Load Counter (Test Mode) */ -}; - -/* Receive Frame Status Encoding */ -enum { - GMR_FS_LEN = 0xffff<<16, /* Bit 31..16: Rx Frame Length */ - GMR_FS_VLAN = 1<<13, /* VLAN Packet */ - GMR_FS_JABBER = 1<<12, /* Jabber Packet */ - GMR_FS_UN_SIZE = 1<<11, /* Undersize Packet */ - GMR_FS_MC = 1<<10, /* Multicast Packet */ - GMR_FS_BC = 1<<9, /* Broadcast Packet */ - GMR_FS_RX_OK = 1<<8, /* Receive OK (Good Packet) */ - GMR_FS_GOOD_FC = 1<<7, /* Good Flow-Control Packet */ - GMR_FS_BAD_FC = 1<<6, /* Bad Flow-Control Packet */ - GMR_FS_MII_ERR = 1<<5, /* MII Error */ - GMR_FS_LONG_ERR = 1<<4, /* Too Long Packet */ - GMR_FS_FRAGMENT = 1<<3, /* Fragment */ - - GMR_FS_CRC_ERR = 1<<1, /* CRC Error */ - GMR_FS_RX_FF_OV = 1<<0, /* Rx FIFO Overflow */ - - GMR_FS_ANY_ERR = GMR_FS_RX_FF_OV | GMR_FS_CRC_ERR | - GMR_FS_FRAGMENT | GMR_FS_LONG_ERR | - GMR_FS_MII_ERR | GMR_FS_BAD_FC | GMR_FS_GOOD_FC | - GMR_FS_UN_SIZE | GMR_FS_JABBER, -}; - -/* RX_GMF_CTRL_T 32 bit Rx GMAC FIFO Control/Test */ -enum { - RX_TRUNC_ON = 1<<27, /* enable packet truncation */ - RX_TRUNC_OFF = 1<<26, /* disable packet truncation */ - RX_VLAN_STRIP_ON = 1<<25, /* enable VLAN stripping */ - RX_VLAN_STRIP_OFF = 1<<24, /* disable VLAN stripping */ - - GMF_WP_TST_ON = 1<<14, /* Write Pointer Test On */ - GMF_WP_TST_OFF = 1<<13, /* Write Pointer Test Off */ - GMF_WP_STEP = 1<<12, /* Write Pointer Step/Increment */ - - GMF_RP_TST_ON = 1<<10, /* Read Pointer Test On */ - GMF_RP_TST_OFF = 1<<9, /* Read Pointer Test Off */ - GMF_RP_STEP = 1<<8, /* Read Pointer Step/Increment */ - GMF_RX_F_FL_ON = 1<<7, /* Rx FIFO Flush Mode On */ - GMF_RX_F_FL_OFF = 1<<6, /* Rx FIFO Flush Mode Off */ - GMF_CLI_RX_FO = 1<<5, /* Clear IRQ Rx FIFO Overrun */ - GMF_CLI_RX_C = 1<<4, /* Clear IRQ Rx Frame Complete */ - - GMF_OPER_ON = 1<<3, /* Operational Mode On */ - GMF_OPER_OFF = 1<<2, /* Operational Mode Off */ - GMF_RST_CLR = 1<<1, /* Clear GMAC FIFO Reset */ - GMF_RST_SET = 1<<0, /* Set GMAC FIFO Reset */ - - RX_GMF_FL_THR_DEF = 0xa, /* flush threshold (default) */ - - GMF_RX_CTRL_DEF = GMF_OPER_ON | GMF_RX_F_FL_ON, -}; - - -/* TX_GMF_CTRL_T 32 bit Tx GMAC FIFO Control/Test */ -enum { - TX_STFW_DIS = 1<<31,/* Disable Store & Forward (Yukon-EC Ultra) */ - TX_STFW_ENA = 1<<30,/* Enable Store & Forward (Yukon-EC Ultra) */ - - TX_VLAN_TAG_ON = 1<<25,/* enable VLAN tagging */ - TX_VLAN_TAG_OFF = 1<<24,/* disable VLAN tagging */ - - GMF_WSP_TST_ON = 1<<18,/* Write Shadow Pointer Test On */ - GMF_WSP_TST_OFF = 1<<17,/* Write Shadow Pointer Test Off */ - GMF_WSP_STEP = 1<<16,/* Write Shadow Pointer Step/Increment */ - - GMF_CLI_TX_FU = 1<<6, /* Clear IRQ Tx FIFO Underrun */ - GMF_CLI_TX_FC = 1<<5, /* Clear IRQ Tx Frame Complete */ - GMF_CLI_TX_PE = 1<<4, /* Clear IRQ Tx Parity Error */ -}; - -/* GMAC_TI_ST_CTRL 8 bit Time Stamp Timer Ctrl Reg (YUKON only) */ -enum { - GMT_ST_START = 1<<2, /* Start Time Stamp Timer */ - GMT_ST_STOP = 1<<1, /* Stop Time Stamp Timer */ - GMT_ST_CLR_IRQ = 1<<0, /* Clear Time Stamp Timer IRQ */ -}; - -/* B28_Y2_ASF_STAT_CMD 32 bit ASF Status and Command Reg */ -enum { - Y2_ASF_OS_PRES = 1<<4, /* ASF operation system present */ - Y2_ASF_RESET = 1<<3, /* ASF system in reset state */ - Y2_ASF_RUNNING = 1<<2, /* ASF system operational */ - Y2_ASF_CLR_HSTI = 1<<1, /* Clear ASF IRQ */ - Y2_ASF_IRQ = 1<<0, /* Issue an IRQ to ASF system */ - - Y2_ASF_UC_STATE = 3<<2, /* ASF uC State */ - Y2_ASF_CLK_HALT = 0, /* ASF system clock stopped */ -}; - -/* B28_Y2_ASF_HOST_COM 32 bit ASF Host Communication Reg */ -enum { - Y2_ASF_CLR_ASFI = 1<<1, /* Clear host IRQ */ - Y2_ASF_HOST_IRQ = 1<<0, /* Issue an IRQ to HOST system */ -}; - -/* STAT_CTRL 32 bit Status BMU control register (Yukon-2 only) */ -enum { - SC_STAT_CLR_IRQ = 1<<4, /* Status Burst IRQ clear */ - SC_STAT_OP_ON = 1<<3, /* Operational Mode On */ - SC_STAT_OP_OFF = 1<<2, /* Operational Mode Off */ - SC_STAT_RST_CLR = 1<<1, /* Clear Status Unit Reset (Enable) */ - SC_STAT_RST_SET = 1<<0, /* Set Status Unit Reset */ -}; - -/* GMAC_CTRL 32 bit GMAC Control Reg (YUKON only) */ -enum { - GMC_H_BURST_ON = 1<<7, /* Half Duplex Burst Mode On */ - GMC_H_BURST_OFF = 1<<6, /* Half Duplex Burst Mode Off */ - GMC_F_LOOPB_ON = 1<<5, /* FIFO Loopback On */ - GMC_F_LOOPB_OFF = 1<<4, /* FIFO Loopback Off */ - GMC_PAUSE_ON = 1<<3, /* Pause On */ - GMC_PAUSE_OFF = 1<<2, /* Pause Off */ - GMC_RST_CLR = 1<<1, /* Clear GMAC Reset */ - GMC_RST_SET = 1<<0, /* Set GMAC Reset */ -}; - -/* GPHY_CTRL 32 bit GPHY Control Reg (YUKON only) */ -enum { - GPC_SEL_BDT = 1<<28, /* Select Bi-Dir. Transfer for MDC/MDIO */ - GPC_INT_POL_HI = 1<<27, /* IRQ Polarity is Active HIGH */ - GPC_75_OHM = 1<<26, /* Use 75 Ohm Termination instead of 50 */ - GPC_DIS_FC = 1<<25, /* Disable Automatic Fiber/Copper Detection */ - GPC_DIS_SLEEP = 1<<24, /* Disable Energy Detect */ - GPC_HWCFG_M_3 = 1<<23, /* HWCFG_MODE[3] */ - GPC_HWCFG_M_2 = 1<<22, /* HWCFG_MODE[2] */ - GPC_HWCFG_M_1 = 1<<21, /* HWCFG_MODE[1] */ - GPC_HWCFG_M_0 = 1<<20, /* HWCFG_MODE[0] */ - GPC_ANEG_0 = 1<<19, /* ANEG[0] */ - GPC_ENA_XC = 1<<18, /* Enable MDI crossover */ - GPC_DIS_125 = 1<<17, /* Disable 125 MHz clock */ - GPC_ANEG_3 = 1<<16, /* ANEG[3] */ - GPC_ANEG_2 = 1<<15, /* ANEG[2] */ - GPC_ANEG_1 = 1<<14, /* ANEG[1] */ - GPC_ENA_PAUSE = 1<<13, /* Enable Pause (SYM_OR_REM) */ - GPC_PHYADDR_4 = 1<<12, /* Bit 4 of Phy Addr */ - GPC_PHYADDR_3 = 1<<11, /* Bit 3 of Phy Addr */ - GPC_PHYADDR_2 = 1<<10, /* Bit 2 of Phy Addr */ - GPC_PHYADDR_1 = 1<<9, /* Bit 1 of Phy Addr */ - GPC_PHYADDR_0 = 1<<8, /* Bit 0 of Phy Addr */ - /* Bits 7..2: reserved */ - GPC_RST_CLR = 1<<1, /* Clear GPHY Reset */ - GPC_RST_SET = 1<<0, /* Set GPHY Reset */ -}; - -/* GMAC_IRQ_SRC 8 bit GMAC Interrupt Source Reg (YUKON only) */ -/* GMAC_IRQ_MSK 8 bit GMAC Interrupt Mask Reg (YUKON only) */ -enum { - GM_IS_TX_CO_OV = 1<<5, /* Transmit Counter Overflow IRQ */ - GM_IS_RX_CO_OV = 1<<4, /* Receive Counter Overflow IRQ */ - GM_IS_TX_FF_UR = 1<<3, /* Transmit FIFO Underrun */ - GM_IS_TX_COMPL = 1<<2, /* Frame Transmission Complete */ - GM_IS_RX_FF_OR = 1<<1, /* Receive FIFO Overrun */ - GM_IS_RX_COMPL = 1<<0, /* Frame Reception Complete */ - -#define GMAC_DEF_MSK GM_IS_TX_FF_UR - -/* GMAC_LINK_CTRL 16 bit GMAC Link Control Reg (YUKON only) */ - /* Bits 15.. 2: reserved */ - GMLC_RST_CLR = 1<<1, /* Clear GMAC Link Reset */ - GMLC_RST_SET = 1<<0, /* Set GMAC Link Reset */ - - -/* WOL_CTRL_STAT 16 bit WOL Control/Status Reg */ - WOL_CTL_LINK_CHG_OCC = 1<<15, - WOL_CTL_MAGIC_PKT_OCC = 1<<14, - WOL_CTL_PATTERN_OCC = 1<<13, - WOL_CTL_CLEAR_RESULT = 1<<12, - WOL_CTL_ENA_PME_ON_LINK_CHG = 1<<11, - WOL_CTL_DIS_PME_ON_LINK_CHG = 1<<10, - WOL_CTL_ENA_PME_ON_MAGIC_PKT = 1<<9, - WOL_CTL_DIS_PME_ON_MAGIC_PKT = 1<<8, - WOL_CTL_ENA_PME_ON_PATTERN = 1<<7, - WOL_CTL_DIS_PME_ON_PATTERN = 1<<6, - WOL_CTL_ENA_LINK_CHG_UNIT = 1<<5, - WOL_CTL_DIS_LINK_CHG_UNIT = 1<<4, - WOL_CTL_ENA_MAGIC_PKT_UNIT = 1<<3, - WOL_CTL_DIS_MAGIC_PKT_UNIT = 1<<2, - WOL_CTL_ENA_PATTERN_UNIT = 1<<1, - WOL_CTL_DIS_PATTERN_UNIT = 1<<0, -}; - -#define WOL_CTL_DEFAULT \ - (WOL_CTL_DIS_PME_ON_LINK_CHG | \ - WOL_CTL_DIS_PME_ON_PATTERN | \ - WOL_CTL_DIS_PME_ON_MAGIC_PKT | \ - WOL_CTL_DIS_LINK_CHG_UNIT | \ - WOL_CTL_DIS_PATTERN_UNIT | \ - WOL_CTL_DIS_MAGIC_PKT_UNIT) - -/* WOL_MATCH_CTL 8 bit WOL Match Control Reg */ -#define WOL_CTL_PATT_ENA(x) (1 << (x)) - - -/* Control flags */ -enum { - UDPTCP = 1<<0, - CALSUM = 1<<1, - WR_SUM = 1<<2, - INIT_SUM= 1<<3, - LOCK_SUM= 1<<4, - INS_VLAN= 1<<5, - FRC_STAT= 1<<6, - EOP = 1<<7, -}; - -enum { - HW_OWNER = 1<<7, - OP_TCPWRITE = 0x11, - OP_TCPSTART = 0x12, - OP_TCPINIT = 0x14, - OP_TCPLCK = 0x18, - OP_TCPCHKSUM = OP_TCPSTART, - OP_TCPIS = OP_TCPINIT | OP_TCPSTART, - OP_TCPLW = OP_TCPLCK | OP_TCPWRITE, - OP_TCPLSW = OP_TCPLCK | OP_TCPSTART | OP_TCPWRITE, - OP_TCPLISW = OP_TCPLCK | OP_TCPINIT | OP_TCPSTART | OP_TCPWRITE, - - OP_ADDR64 = 0x21, - OP_VLAN = 0x22, - OP_ADDR64VLAN = OP_ADDR64 | OP_VLAN, - OP_LRGLEN = 0x24, - OP_LRGLENVLAN = OP_LRGLEN | OP_VLAN, - OP_BUFFER = 0x40, - OP_PACKET = 0x41, - OP_LARGESEND = 0x43, - -/* YUKON-2 STATUS opcodes defines */ - OP_RXSTAT = 0x60, - OP_RXTIMESTAMP = 0x61, - OP_RXVLAN = 0x62, - OP_RXCHKS = 0x64, - OP_RXCHKSVLAN = OP_RXCHKS | OP_RXVLAN, - OP_RXTIMEVLAN = OP_RXTIMESTAMP | OP_RXVLAN, - OP_RSS_HASH = 0x65, - OP_TXINDEXLE = 0x68, -}; - -/* Yukon 2 hardware interface - * Not tested on big endian - */ -struct sky2_tx_le { - union { - __le32 addr; - struct { - __le16 offset; - __le16 start; - } csum __attribute((packed)); - struct { - __le16 size; - __le16 rsvd; - } tso __attribute((packed)); - } tx; - __le16 length; /* also vlan tag or checksum start */ - u8 ctrl; - u8 opcode; -} __attribute((packed)); - -struct sky2_rx_le { - __le32 addr; - __le16 length; - u8 ctrl; - u8 opcode; -} __attribute((packed));; - -struct sky2_status_le { - __le32 status; /* also checksum */ - __le16 length; /* also vlan tag */ - u8 link; - u8 opcode; -} __attribute((packed)); - -struct tx_ring_info { - struct sk_buff *skb; - DECLARE_PCI_UNMAP_ADDR(mapaddr); - u16 idx; -}; - -struct ring_info { - struct sk_buff *skb; - dma_addr_t mapaddr; -}; - -struct sky2_port { - struct sky2_hw *hw; - struct net_device *netdev; - unsigned port; - u32 msg_enable; - - spinlock_t tx_lock ____cacheline_aligned_in_smp; - struct tx_ring_info *tx_ring; - struct sky2_tx_le *tx_le; - u16 tx_cons; /* next le to check */ - u16 tx_prod; /* next le to use */ - u32 tx_addr64; - u16 tx_pending; - u16 tx_last_put; - u16 tx_last_mss; - - struct ring_info *rx_ring ____cacheline_aligned_in_smp; - struct sky2_rx_le *rx_le; - u32 rx_addr64; - u16 rx_next; /* next re to check */ - u16 rx_put; /* next le index to use */ - u16 rx_pending; - u16 rx_last_put; - u16 rx_bufsize; -#ifdef SKY2_VLAN_TAG_USED - u16 rx_tag; - struct vlan_group *vlgrp; -#endif - - dma_addr_t rx_le_map; - dma_addr_t tx_le_map; - u32 advertising; /* ADVERTISED_ bits */ - u16 speed; /* SPEED_1000, SPEED_100, ... */ - u8 autoneg; /* AUTONEG_ENABLE, AUTONEG_DISABLE */ - u8 duplex; /* DUPLEX_HALF, DUPLEX_FULL */ - u8 rx_pause; - u8 tx_pause; - u8 rx_csum; - u8 wol; - - struct net_device_stats net_stats; - - struct work_struct phy_task; - struct semaphore phy_sema; -}; - -struct sky2_hw { - void __iomem *regs; - struct pci_dev *pdev; - u32 intr_mask; - struct net_device *dev[2]; - - int pm_cap; - u8 chip_id; - u8 chip_rev; - u8 copper; - u8 ports; - - struct sky2_status_le *st_le; - u32 st_idx; - dma_addr_t st_dma; -}; - -/* Register accessor for memory mapped device */ -static inline u32 sky2_read32(const struct sky2_hw *hw, unsigned reg) -{ - return readl(hw->regs + reg); -} - -static inline u16 sky2_read16(const struct sky2_hw *hw, unsigned reg) -{ - return readw(hw->regs + reg); -} - -static inline u8 sky2_read8(const struct sky2_hw *hw, unsigned reg) -{ - return readb(hw->regs + reg); -} - -/* This should probably go away, bus based tweeks suck */ -static inline int is_pciex(const struct sky2_hw *hw) -{ - u32 status; - pci_read_config_dword(hw->pdev, PCI_DEV_STATUS, &status); - return (status & PCI_OS_PCI_X) == 0; -} - -static inline void sky2_write32(const struct sky2_hw *hw, unsigned reg, u32 val) -{ - writel(val, hw->regs + reg); -} - -static inline void sky2_write16(const struct sky2_hw *hw, unsigned reg, u16 val) -{ - writew(val, hw->regs + reg); -} - -static inline void sky2_write8(const struct sky2_hw *hw, unsigned reg, u8 val) -{ - writeb(val, hw->regs + reg); -} - -/* Yukon PHY related registers */ -#define SK_GMAC_REG(port,reg) \ - (BASE_GMAC_1 + (port) * (BASE_GMAC_2-BASE_GMAC_1) + (reg)) -#define GM_PHY_RETRIES 100 - -static inline u16 gma_read16(const struct sky2_hw *hw, unsigned port, unsigned reg) -{ - return sky2_read16(hw, SK_GMAC_REG(port,reg)); -} - -static inline u32 gma_read32(struct sky2_hw *hw, unsigned port, unsigned reg) -{ - unsigned base = SK_GMAC_REG(port, reg); - return (u32) sky2_read16(hw, base) - | (u32) sky2_read16(hw, base+4) << 16; -} - -static inline void gma_write16(const struct sky2_hw *hw, unsigned port, int r, u16 v) -{ - sky2_write16(hw, SK_GMAC_REG(port,r), v); -} - -static inline void gma_set_addr(struct sky2_hw *hw, unsigned port, unsigned reg, - const u8 *addr) -{ - gma_write16(hw, port, reg, (u16) addr[0] | ((u16) addr[1] << 8)); - gma_write16(hw, port, reg+4,(u16) addr[2] | ((u16) addr[3] << 8)); - gma_write16(hw, port, reg+8,(u16) addr[4] | ((u16) addr[5] << 8)); -} -#endif diff --git a/trunk/drivers/net/tg3.c b/trunk/drivers/net/tg3.c index eb86b059809b..2fc9893d69e1 100644 --- a/trunk/drivers/net/tg3.c +++ b/trunk/drivers/net/tg3.c @@ -24,7 +24,6 @@ #include #include #include -#include #include #include #include @@ -3651,7 +3650,7 @@ static int tg3_start_xmit(struct sk_buff *skb, struct net_device *dev) TXD_FLAG_CPU_POST_DMA); skb->nh.iph->check = 0; - skb->nh.iph->tot_len = htons(mss + ip_tcp_len + tcp_opt_len); + skb->nh.iph->tot_len = ntohs(mss + ip_tcp_len + tcp_opt_len); if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) { skb->h.th->check = 0; base_flags &= ~TXD_FLAG_TCPUDP_CSUM; diff --git a/trunk/drivers/net/tlan.c b/trunk/drivers/net/tlan.c index c2506b56a186..942fae0f2130 100644 --- a/trunk/drivers/net/tlan.c +++ b/trunk/drivers/net/tlan.c @@ -2865,11 +2865,11 @@ void TLan_PhyMonitor( struct net_device *dev ) * for this device. * phy The address of the PHY to be queried. * reg The register whose contents are to be - * retrieved. + * retreived. * val A pointer to a variable to store the * retrieved value. * - * This function uses the TLAN's MII bus to retrieve the contents + * This function uses the TLAN's MII bus to retreive the contents * of a given register on a PHY. It sends the appropriate info * and then reads the 16-bit register value from the MII bus via * the TLAN SIO register. diff --git a/trunk/drivers/net/wan/.gitignore b/trunk/drivers/net/wan/.gitignore deleted file mode 100644 index dae3ea6bb18c..000000000000 --- a/trunk/drivers/net/wan/.gitignore +++ /dev/null @@ -1 +0,0 @@ -wanxlfw.inc diff --git a/trunk/drivers/net/wan/lmc/lmc_prot.h b/trunk/drivers/net/wan/lmc/lmc_prot.h new file mode 100644 index 000000000000..f3b1df9e2cdb --- /dev/null +++ b/trunk/drivers/net/wan/lmc/lmc_prot.h @@ -0,0 +1,15 @@ +#ifndef _LMC_PROTO_H_ +#define _LMC_PROTO_H_ + +void lmc_proto_init(lmc_softc_t * const) +void lmc_proto_attach(lmc_softc_t *sc const) +void lmc_proto_detach(lmc_softc *sc const) +void lmc_proto_reopen(lmc_softc_t *sc const) +int lmc_proto_ioctl(lmc_softc_t *sc const, struct ifreq *ifr, int cmd) +void lmc_proto_open(lmc_softc_t *sc const) +void lmc_proto_close(lmc_softc_t *sc const) +unsigned short lmc_proto_type(lmc_softc_t *sc const, struct skbuff *skb) + + +#endif + diff --git a/trunk/drivers/net/wireless/Kconfig b/trunk/drivers/net/wireless/Kconfig index 24f7967aab67..00e55165b760 100644 --- a/trunk/drivers/net/wireless/Kconfig +++ b/trunk/drivers/net/wireless/Kconfig @@ -173,7 +173,7 @@ config IPW2100_MONITOR promiscuous mode via the Wireless Tool's Monitor mode. While in this mode, no packets can be sent. -config IPW2100_DEBUG +config IPW_DEBUG bool "Enable full debugging output in IPW2100 module." depends on IPW2100 ---help--- @@ -192,7 +192,7 @@ config IPW2100_DEBUG config IPW2200 tristate "Intel PRO/Wireless 2200BG and 2915ABG Network Connection" - depends on NET_RADIO && IEEE80211 && PCI + depends on IEEE80211 && PCI select FW_LOADER ---help--- A driver for the Intel PRO/Wireless 2200BG and 2915ABG Network @@ -217,7 +217,7 @@ config IPW2200 say M here and read . The module will be called ipw2200.ko. -config IPW2200_DEBUG +config IPW_DEBUG bool "Enable full debugging output in IPW2200 module." depends on IPW2200 ---help--- diff --git a/trunk/drivers/net/wireless/airo.c b/trunk/drivers/net/wireless/airo.c index ee866fd6957d..7a92b1cbd6aa 100644 --- a/trunk/drivers/net/wireless/airo.c +++ b/trunk/drivers/net/wireless/airo.c @@ -4037,7 +4037,7 @@ static int PC4500_writerid(struct airo_info *ai, u16 rid, Cmd cmd; Resp rsp; - if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid)) + if (test_bit(FLAG_ENABLED, &ai->flags)) printk(KERN_ERR "%s: MAC should be disabled (rid=%04x)\n", __FUNCTION__, rid); @@ -5093,9 +5093,9 @@ static int set_wep_key(struct airo_info *ai, u16 index, printk(KERN_INFO "Setting key %d\n", index); } - if (perm) disable_MAC(ai, lock); + disable_MAC(ai, lock); writeWepKeyRid(ai, &wkr, perm, lock); - if (perm) enable_MAC(ai, &rsp, lock); + enable_MAC(ai, &rsp, lock); return 0; } @@ -6170,8 +6170,6 @@ static int airo_set_encode(struct net_device *dev, { struct airo_info *local = dev->priv; CapabilityRid cap_rid; /* Card capability info */ - int perm = ( dwrq->flags & IW_ENCODE_TEMP ? 0 : 1 ); - u16 currentAuthType = local->config.authType; /* Is WEP supported ? */ readCapabilityRid(local, &cap_rid, 1); @@ -6214,7 +6212,7 @@ static int airo_set_encode(struct net_device *dev, /* Copy the key in the driver */ memcpy(key.key, extra, dwrq->length); /* Send the key to the card */ - set_wep_key(local, index, key.key, key.len, perm, 1); + set_wep_key(local, index, key.key, key.len, 1, 1); } /* WE specify that if a valid key is set, encryption * should be enabled (user may turn it off later) @@ -6222,12 +6220,13 @@ static int airo_set_encode(struct net_device *dev, if((index == current_index) && (key.len > 0) && (local->config.authType == AUTH_OPEN)) { local->config.authType = AUTH_ENCRYPT; + set_bit (FLAG_COMMIT, &local->flags); } } else { /* Do we want to just set the transmit key index ? */ int index = (dwrq->flags & IW_ENCODE_INDEX) - 1; if ((index >= 0) && (index < ((cap_rid.softCap & 0x80)?4:1))) { - set_wep_key(local, index, NULL, 0, perm, 1); + set_wep_key(local, index, NULL, 0, 1, 1); } else /* Don't complain if only change the mode */ if(!dwrq->flags & IW_ENCODE_MODE) { @@ -6242,7 +6241,7 @@ static int airo_set_encode(struct net_device *dev, if(dwrq->flags & IW_ENCODE_OPEN) local->config.authType = AUTH_ENCRYPT; // Only Wep /* Commit the changes to flags if needed */ - if (local->config.authType != currentAuthType) + if(dwrq->flags & IW_ENCODE_MODE) set_bit (FLAG_COMMIT, &local->flags); return -EINPROGRESS; /* Call commit handler */ } diff --git a/trunk/drivers/net/wireless/airo_cs.c b/trunk/drivers/net/wireless/airo_cs.c index a496460ce224..e328547599dc 100644 --- a/trunk/drivers/net/wireless/airo_cs.c +++ b/trunk/drivers/net/wireless/airo_cs.c @@ -82,6 +82,8 @@ MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards"); static void airo_config(dev_link_t *link); static void airo_release(dev_link_t *link); +static int airo_event(event_t event, int priority, + event_callback_args_t *args); /* The attach() and detach() entry points are used to create and destroy @@ -89,7 +91,8 @@ static void airo_release(dev_link_t *link); needed to manage one actual PCMCIA card. */ -static void airo_detach(struct pcmcia_device *p_dev); +static dev_link_t *airo_attach(void); +static void airo_detach(dev_link_t *); /* You'll also need to prototype all the functions that will actually @@ -98,6 +101,14 @@ static void airo_detach(struct pcmcia_device *p_dev); less on other parts of the kernel. */ +/* + The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ + +static dev_info_t dev_info = "airo_cs"; + /* A linked list of "instances" of the aironet device. Each actual PCMCIA card corresponds to one device instance, and is described @@ -108,7 +119,15 @@ static void airo_detach(struct pcmcia_device *p_dev); device numbers are used to derive the corresponding array index. */ +static dev_link_t *dev_list = NULL; + /* + A dev_link_t structure has fields for most things that are needed + to keep track of a socket, but there will usually be some device + specific information that also needs to be kept track of. The + 'priv' pointer in a dev_link_t structure can be used to point to + a device-specific private data structure, like this. + A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be @@ -141,18 +160,20 @@ typedef struct local_info_t { ======================================================================*/ -static int airo_attach(struct pcmcia_device *p_dev) +static dev_link_t *airo_attach(void) { + client_reg_t client_reg; dev_link_t *link; local_info_t *local; - + int ret; + DEBUG(0, "airo_attach()\n"); /* Initialize the dev_link_t structure */ link = kzalloc(sizeof(struct dev_link_t), GFP_KERNEL); if (!link) { printk(KERN_ERR "airo_cs: no memory for new device\n"); - return -ENOMEM; + return NULL; } /* Interrupt setup */ @@ -176,17 +197,24 @@ static int airo_attach(struct pcmcia_device *p_dev) if (!local) { printk(KERN_ERR "airo_cs: no memory for new device\n"); kfree (link); - return -ENOMEM; + return NULL; } link->priv = local; - - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - airo_config(link); - - return 0; + + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + airo_detach(link); + return NULL; + } + + return link; } /* airo_attach */ /*====================================================================== @@ -198,22 +226,37 @@ static int airo_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void airo_detach(struct pcmcia_device *p_dev) +static void airo_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); - + dev_link_t **linkp; + DEBUG(0, "airo_detach(0x%p)\n", link); - + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; + if (link->state & DEV_CONFIG) airo_release(link); - + if ( ((local_info_t*)link->priv)->eth_dev ) { stop_airo_card( ((local_info_t*)link->priv)->eth_dev, 0 ); } - ((local_info_t*)link->priv)->eth_dev = NULL; - + ((local_info_t*)link->priv)->eth_dev = NULL; + + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + + + /* Unlink device structure, free pieces */ + *linkp = link->next; kfree(link->priv); kfree(link); + } /* airo_detach */ /*====================================================================== @@ -449,34 +492,60 @@ static void airo_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int airo_suspend(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - local_info_t *local = link->priv; - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - netif_device_detach(local->eth_dev); - pcmcia_release_configuration(link->handle); - } +/*====================================================================== + + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. - return 0; -} + When a CARD_REMOVAL event is received, we immediately set a + private flag to block future accesses to this device. All the + functions that actually access the device should check this flag + to make sure the card is still present. + + ======================================================================*/ -static int airo_resume(struct pcmcia_device *p_dev) +static int airo_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link = args->client_data; local_info_t *local = link->priv; - - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - reset_airo_card(local->eth_dev); - netif_device_attach(local->eth_dev); + + DEBUG(1, "airo_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + netif_device_detach(local->eth_dev); + airo_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + airo_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + netif_device_detach(local->eth_dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + reset_airo_card(local->eth_dev); + netif_device_attach(local->eth_dev); + } + break; } - return 0; -} +} /* airo_event */ static struct pcmcia_device_id airo_ids[] = { PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a), @@ -492,11 +561,10 @@ static struct pcmcia_driver airo_driver = { .drv = { .name = "airo_cs", }, - .probe = airo_attach, - .remove = airo_detach, + .attach = airo_attach, + .event = airo_event, + .detach = airo_detach, .id_table = airo_ids, - .suspend = airo_suspend, - .resume = airo_resume, }; static int airo_cs_init(void) @@ -507,6 +575,7 @@ static int airo_cs_init(void) static void airo_cs_cleanup(void) { pcmcia_unregister_driver(&airo_driver); + BUG_ON(dev_list != NULL); } /* diff --git a/trunk/drivers/net/wireless/atmel.c b/trunk/drivers/net/wireless/atmel.c index e4729ddf29fd..5e53c5258a33 100644 --- a/trunk/drivers/net/wireless/atmel.c +++ b/trunk/drivers/net/wireless/atmel.c @@ -5,9 +5,9 @@ Copyright 2000-2001 ATMEL Corporation. Copyright 2003-2004 Simon Kelley. - This code was developed from version 2.1.1 of the Atmel drivers, - released by Atmel corp. under the GPL in December 2002. It also - includes code from the Linux aironet drivers (C) Benjamin Reed, + This code was developed from version 2.1.1 of the Atmel drivers, + released by Atmel corp. under the GPL in December 2002. It also + includes code from the Linux aironet drivers (C) Benjamin Reed, and the Linux PCMCIA package, (C) David Hinds and the Linux wireless extensions, (C) Jean Tourrilhes. @@ -31,7 +31,7 @@ along with Atmel wireless lan drivers; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - For all queries about this code, please contact the current author, + For all queries about this code, please contact the current author, Simon Kelley and not Atmel Corporation. Credit is due to HP UK and Cambridge Online Systems Ltd for supplying @@ -79,13 +79,13 @@ MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.") MODULE_LICENSE("GPL"); MODULE_SUPPORTED_DEVICE("Atmel at76c50x wireless cards"); -/* The name of the firmware file to be loaded +/* The name of the firmware file to be loaded over-rides any automatic selection */ static char *firmware = NULL; module_param(firmware, charp, 0); /* table of firmware file names */ -static struct { +static struct { AtmelFWType fw_type; const char *fw_file; const char *fw_file_ext; @@ -104,17 +104,17 @@ static struct { #define MAX_SSID_LENGTH 32 #define MGMT_JIFFIES (256 * HZ / 100) -#define MAX_BSS_ENTRIES 64 +#define MAX_BSS_ENTRIES 64 /* registers */ -#define GCR 0x00 // (SIR0) General Configuration Register -#define BSR 0x02 // (SIR1) Bank Switching Select Register +#define GCR 0x00 // (SIR0) General Configuration Register +#define BSR 0x02 // (SIR1) Bank Switching Select Register #define AR 0x04 #define DR 0x08 -#define MR1 0x12 // Mirror Register 1 -#define MR2 0x14 // Mirror Register 2 -#define MR3 0x16 // Mirror Register 3 -#define MR4 0x18 // Mirror Register 4 +#define MR1 0x12 // Mirror Register 1 +#define MR2 0x14 // Mirror Register 2 +#define MR3 0x16 // Mirror Register 3 +#define MR4 0x18 // Mirror Register 4 #define GPR1 0x0c #define GPR2 0x0e @@ -123,9 +123,9 @@ static struct { // Constants for the GCR register. // #define GCR_REMAP 0x0400 // Remap internal SRAM to 0 -#define GCR_SWRES 0x0080 // BIU reset (ARM and PAI are NOT reset) +#define GCR_SWRES 0x0080 // BIU reset (ARM and PAI are NOT reset) #define GCR_CORES 0x0060 // Core Reset (ARM and PAI are reset) -#define GCR_ENINT 0x0002 // Enable Interrupts +#define GCR_ENINT 0x0002 // Enable Interrupts #define GCR_ACKINT 0x0008 // Acknowledge Interrupts #define BSS_SRAM 0x0200 // AMBA module selection --> SRAM @@ -190,7 +190,7 @@ struct rx_desc { u32 Next; u16 MsduPos; u16 MsduSize; - + u8 State; u8 Status; u8 Rate; @@ -199,6 +199,7 @@ struct rx_desc { u8 PreambleType; u16 Duration; u32 RxTime; + }; #define RX_DESC_FLAG_VALID 0x80 @@ -217,15 +218,16 @@ struct rx_desc { #define RX_DESC_DURATION_OFFSET 14 #define RX_DESC_RX_TIME_OFFSET 16 + struct tx_desc { u32 NextDescriptor; u16 TxStartOfFrame; u16 TxLength; - + u8 TxState; u8 TxStatus; u8 RetryCount; - + u8 TxRate; u8 KeyIndex; @@ -236,8 +238,10 @@ struct tx_desc { u8 Reserved; u8 PacketType; u16 HostTxLength; + }; + #define TX_DESC_NEXT_OFFSET 0 #define TX_DESC_POS_OFFSET 4 #define TX_DESC_SIZE_OFFSET 6 @@ -251,6 +255,8 @@ struct tx_desc { #define TX_DESC_PACKET_TYPE_OFFSET 17 #define TX_DESC_HOST_LENGTH_OFFSET 18 + + /////////////////////////////////////////////////////// // Host-MAC interface /////////////////////////////////////////////////////// @@ -260,6 +266,7 @@ struct tx_desc { #define TX_FIRM_OWN 0x80 #define TX_DONE 0x40 + #define TX_ERROR 0x01 #define TX_PACKET_TYPE_DATA 0x01 @@ -273,7 +280,8 @@ struct tx_desc { #define ISR_COMMAND_COMPLETE 0x10 // command completed #define ISR_OUT_OF_RANGE 0x20 // command completed #define ISR_IBSS_MERGE 0x40 // (4.1.2.30): IBSS merge -#define ISR_GENERIC_IRQ 0x80 +#define ISR_GENERIC_IRQ 0x80 + #define Local_Mib_Type 0x01 #define Mac_Address_Mib_Type 0x02 @@ -309,6 +317,7 @@ struct tx_desc { #define LOCAL_MIB_PREAMBLE_TYPE 9 #define MAC_ADDR_MIB_MAC_ADDR_POS 0 + #define CMD_Set_MIB_Vars 0x01 #define CMD_Get_MIB_Vars 0x02 #define CMD_Scan 0x03 @@ -329,6 +338,7 @@ struct tx_desc { #define CMD_STATUS_HOST_ERROR 0xFF #define CMD_STATUS_BUSY 0xFE + #define CMD_BLOCK_COMMAND_OFFSET 0 #define CMD_BLOCK_STATUS_OFFSET 1 #define CMD_BLOCK_PARAMETERS_OFFSET 4 @@ -337,15 +347,15 @@ struct tx_desc { #define MGMT_FRAME_BODY_OFFSET 24 #define MAX_AUTHENTICATION_RETRIES 3 -#define MAX_ASSOCIATION_RETRIES 3 +#define MAX_ASSOCIATION_RETRIES 3 #define AUTHENTICATION_RESPONSE_TIME_OUT 1000 #define MAX_WIRELESS_BODY 2316 /* mtu is 2312, CRC is 4 */ #define LOOP_RETRY_LIMIT 500000 -#define ACTIVE_MODE 1 -#define PS_MODE 2 +#define ACTIVE_MODE 1 +#define PS_MODE 2 #define MAX_ENCRYPTION_KEYS 4 #define MAX_ENCRYPTION_KEY_SIZE 40 @@ -367,7 +377,7 @@ struct tx_desc { #define REG_DOMAIN_MKK1 0x41 //Channel 1-14 Japan(MKK1) #define REG_DOMAIN_ISRAEL 0x50 //Channel 3-9 ISRAEL -#define BSS_TYPE_AD_HOC 1 +#define BSS_TYPE_AD_HOC 1 #define BSS_TYPE_INFRASTRUCTURE 2 #define SCAN_TYPE_ACTIVE 0 @@ -379,7 +389,7 @@ struct tx_desc { #define DATA_FRAME_WS_HEADER_SIZE 30 -/* promiscuous mode control */ +/* promiscuous mode control */ #define PROM_MODE_OFF 0x0 #define PROM_MODE_UNKNOWN 0x1 #define PROM_MODE_CRC_FAILED 0x2 @@ -388,7 +398,8 @@ struct tx_desc { #define PROM_MODE_CTRL 0x10 #define PROM_MODE_BAD_PROTOCOL 0x20 -#define IFACE_INT_STATUS_OFFSET 0 + +#define IFACE_INT_STATUS_OFFSET 0 #define IFACE_INT_MASK_OFFSET 1 #define IFACE_LOCKOUT_HOST_OFFSET 2 #define IFACE_LOCKOUT_MAC_OFFSET 3 @@ -396,7 +407,7 @@ struct tx_desc { #define IFACE_MAC_STAT_OFFSET 30 #define IFACE_GENERIC_INT_TYPE_OFFSET 32 -#define CIPHER_SUITE_NONE 0 +#define CIPHER_SUITE_NONE 0 #define CIPHER_SUITE_WEP_64 1 #define CIPHER_SUITE_TKIP 2 #define CIPHER_SUITE_AES 3 @@ -408,11 +419,11 @@ struct tx_desc { // // -// FuncCtrl field: +// FuncCtrl field: // #define FUNC_CTRL_TxENABLE 0x10 #define FUNC_CTRL_RxENABLE 0x20 -#define FUNC_CTRL_INIT_COMPLETE 0x01 +#define FUNC_CTRL_INIT_COMPLETE 0x01 /* A stub firmware image which reads the MAC address from NVRAM on the card. For copyright information and source see the end of this file. */ @@ -475,10 +486,10 @@ struct atmel_private { struct net_device_stats stats; // device stats spinlock_t irqlock, timerlock; // spinlocks enum { BUS_TYPE_PCCARD, BUS_TYPE_PCI } bus_type; - enum { - CARD_TYPE_PARALLEL_FLASH, + enum { + CARD_TYPE_PARALLEL_FLASH, CARD_TYPE_SPI_FLASH, - CARD_TYPE_EEPROM + CARD_TYPE_EEPROM } card_type; int do_rx_crc; /* If we need to CRC incoming packets */ int probe_crc; /* set if we don't yet know */ @@ -486,18 +497,18 @@ struct atmel_private { u16 rx_desc_head; u16 tx_desc_free, tx_desc_head, tx_desc_tail, tx_desc_previous; u16 tx_free_mem, tx_buff_head, tx_buff_tail; - + u16 frag_seq, frag_len, frag_no; - u8 frag_source[6]; - + u8 frag_source[6]; + u8 wep_is_on, default_key, exclude_unencrypted, encryption_level; u8 group_cipher_suite, pairwise_cipher_suite; u8 wep_keys[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE]; - int wep_key_len[MAX_ENCRYPTION_KEYS]; + int wep_key_len[MAX_ENCRYPTION_KEYS]; int use_wpa, radio_on_broken; /* firmware dependent stuff. */ u16 host_info_base; - struct host_info_struct { + struct host_info_struct { /* NB this is matched to the hardware, don't change. */ u8 volatile int_status; u8 volatile int_mask; @@ -513,20 +524,20 @@ struct atmel_private { u16 rx_buff_size; u16 rx_desc_pos; u16 rx_desc_count; - + u16 build_version; - u16 command_pos; - + u16 command_pos; + u16 major_version; u16 minor_version; - + u16 func_ctrl; u16 mac_status; u16 generic_IRQ_type; u8 reserved[2]; } host_info; - enum { + enum { STATION_STATE_SCANNING, STATION_STATE_JOINNING, STATION_STATE_AUTHENTICATING, @@ -536,7 +547,7 @@ struct atmel_private { STATION_STATE_DOWN, STATION_STATE_MGMT_ERROR } station_state; - + int operating_mode, power_mode; time_t last_qual; int beacons_this_sec; @@ -549,18 +560,18 @@ struct atmel_private { int long_retry, short_retry; int preamble; int default_beacon_period, beacon_period, listen_interval; - int CurrentAuthentTransactionSeqNum, ExpectedAuthentTransactionSeqNum; + int CurrentAuthentTransactionSeqNum, ExpectedAuthentTransactionSeqNum; int AuthenticationRequestRetryCnt, AssociationRequestRetryCnt, ReAssociationRequestRetryCnt; enum { SITE_SURVEY_IDLE, SITE_SURVEY_IN_PROGRESS, - SITE_SURVEY_COMPLETED + SITE_SURVEY_COMPLETED } site_survey_state; time_t last_survey; int station_was_associated, station_is_associated; int fast_scan; - + struct bss_info { int channel; int SSIDsize; @@ -573,12 +584,13 @@ struct atmel_private { u8 SSID[MAX_SSID_LENGTH]; } BSSinfo[MAX_BSS_ENTRIES]; int BSS_list_entries, current_BSS; - int connect_to_any_BSS; + int connect_to_any_BSS; int SSID_size, new_SSID_size; u8 CurrentBSSID[6], BSSID[6]; u8 SSID[MAX_SSID_LENGTH], new_SSID[MAX_SSID_LENGTH]; u64 last_beacon_timestamp; u8 rx_buf[MAX_WIRELESS_BODY]; + }; static u8 atmel_basic_rates[4] = {0x82,0x84,0x0b,0x16}; @@ -586,49 +598,39 @@ static u8 atmel_basic_rates[4] = {0x82,0x84,0x0b,0x16}; static const struct { int reg_domain; int min, max; - char *name; + char *name; } channel_table[] = { { REG_DOMAIN_FCC, 1, 11, "USA" }, { REG_DOMAIN_DOC, 1, 11, "Canada" }, { REG_DOMAIN_ETSI, 1, 13, "Europe" }, { REG_DOMAIN_SPAIN, 10, 11, "Spain" }, - { REG_DOMAIN_FRANCE, 10, 13, "France" }, + { REG_DOMAIN_FRANCE, 10, 13, "France" }, { REG_DOMAIN_MKK, 14, 14, "MKK" }, { REG_DOMAIN_MKK1, 1, 14, "MKK1" }, { REG_DOMAIN_ISRAEL, 3, 9, "Israel"} }; static void build_wpa_mib(struct atmel_private *priv); static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); -static void atmel_copy_to_card(struct net_device *dev, u16 dest, - unsigned char *src, u16 len); -static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest, - u16 src, u16 len); +static void atmel_copy_to_card(struct net_device *dev, u16 dest, unsigned char *src, u16 len); +static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest, u16 src, u16 len); static void atmel_set_gcr(struct net_device *dev, u16 mask); static void atmel_clear_gcr(struct net_device *dev, u16 mask); static int atmel_lock_mac(struct atmel_private *priv); static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data); static void atmel_command_irq(struct atmel_private *priv); static int atmel_validate_channel(struct atmel_private *priv, int channel); -static void atmel_management_frame(struct atmel_private *priv, - struct ieee80211_hdr_4addr *header, +static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, u16 frame_len, u8 rssi); static void atmel_management_timer(u_long a); -static void atmel_send_command(struct atmel_private *priv, int command, - void *cmd, int cmd_size); -static int atmel_send_command_wait(struct atmel_private *priv, int command, - void *cmd, int cmd_size); -static void atmel_transmit_management_frame(struct atmel_private *priv, - struct ieee80211_hdr_4addr *header, +static void atmel_send_command(struct atmel_private *priv, int command, void *cmd, int cmd_size); +static int atmel_send_command_wait(struct atmel_private *priv, int command, void *cmd, int cmd_size); +static void atmel_transmit_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, u8 *body, int body_len); static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index); -static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, - u8 data); -static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, - u16 data); -static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, - u8 *data, int data_len); -static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index, - u8 *data, int data_len); +static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, u8 data); +static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, u16 data); +static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len); +static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len); static void atmel_scan(struct atmel_private *priv, int specific_ssid); static void atmel_join_bss(struct atmel_private *priv, int bss_index); static void atmel_smooth_qual(struct atmel_private *priv); @@ -648,12 +650,12 @@ static inline u16 atmel_co(struct atmel_private *priv, u16 offset) return priv->host_info.command_pos + offset; } -static inline u16 atmel_rx(struct atmel_private *priv, u16 offset, u16 desc) +static inline u16 atmel_rx(struct atmel_private *priv, u16 offset, u16 desc) { return priv->host_info.rx_desc_pos + (sizeof(struct rx_desc) * desc) + offset; } -static inline u16 atmel_tx(struct atmel_private *priv, u16 offset, u16 desc) +static inline u16 atmel_tx(struct atmel_private *priv, u16 offset, u16 desc) { return priv->host_info.tx_desc_pos + (sizeof(struct tx_desc) * desc) + offset; } @@ -680,25 +682,25 @@ static inline void atmel_write16(struct net_device *dev, u16 offset, u16 data) static inline u8 atmel_rmem8(struct atmel_private *priv, u16 pos) { - atmel_writeAR(priv->dev, pos); + atmel_writeAR(priv->dev, pos); return atmel_read8(priv->dev, DR); } static inline void atmel_wmem8(struct atmel_private *priv, u16 pos, u16 data) { - atmel_writeAR(priv->dev, pos); + atmel_writeAR(priv->dev, pos); atmel_write8(priv->dev, DR, data); } static inline u16 atmel_rmem16(struct atmel_private *priv, u16 pos) { - atmel_writeAR(priv->dev, pos); + atmel_writeAR(priv->dev, pos); return atmel_read16(priv->dev, DR); } static inline void atmel_wmem16(struct atmel_private *priv, u16 pos, u16 data) { - atmel_writeAR(priv->dev, pos); + atmel_writeAR(priv->dev, pos); atmel_write16(priv->dev, DR, data); } @@ -708,10 +710,11 @@ static void tx_done_irq(struct atmel_private *priv) { int i; - for (i = 0; + for (i = 0; atmel_rmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head)) == TX_DONE && i < priv->host_info.tx_desc_count; i++) { + u8 status = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_STATUS_OFFSET, priv->tx_desc_head)); u16 msdu_size = atmel_rmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_head)); u8 type = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_head)); @@ -725,16 +728,16 @@ static void tx_done_irq(struct atmel_private *priv) priv->tx_buff_head = 0; else priv->tx_buff_head += msdu_size; - + if (priv->tx_desc_head < (priv->host_info.tx_desc_count - 1)) - priv->tx_desc_head++ ; + priv->tx_desc_head++ ; else priv->tx_desc_head = 0; - + if (type == TX_PACKET_TYPE_DATA) { if (status == TX_STATUS_SUCCESS) priv->stats.tx_packets++; - else + else priv->stats.tx_errors++; netif_wake_queue(priv->dev); } @@ -745,22 +748,21 @@ static u16 find_tx_buff(struct atmel_private *priv, u16 len) { u16 bottom_free = priv->host_info.tx_buff_size - priv->tx_buff_tail; - if (priv->tx_desc_free == 3 || priv->tx_free_mem < len) + if (priv->tx_desc_free == 3 || priv->tx_free_mem < len) return 0; - + if (bottom_free >= len) return priv->host_info.tx_buff_pos + priv->tx_buff_tail; - + if (priv->tx_free_mem - bottom_free >= len) { priv->tx_buff_tail = 0; return priv->host_info.tx_buff_pos; } - + return 0; } -static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, - u16 len, u16 buff, u8 type) +static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, u16 len, u16 buff, u8 type) { atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, priv->tx_desc_tail), buff); atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_tail), len); @@ -773,8 +775,8 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, int cipher_type, cipher_length; if (is_bcast) { cipher_type = priv->group_cipher_suite; - if (cipher_type == CIPHER_SUITE_WEP_64 || - cipher_type == CIPHER_SUITE_WEP_128) + if (cipher_type == CIPHER_SUITE_WEP_64 || + cipher_type == CIPHER_SUITE_WEP_128 ) cipher_length = 8; else if (cipher_type == CIPHER_SUITE_TKIP) cipher_length = 12; @@ -788,8 +790,8 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, } } else { cipher_type = priv->pairwise_cipher_suite; - if (cipher_type == CIPHER_SUITE_WEP_64 || - cipher_type == CIPHER_SUITE_WEP_128) + if (cipher_type == CIPHER_SUITE_WEP_64 || + cipher_type == CIPHER_SUITE_WEP_128 ) cipher_length = 8; else if (cipher_type == CIPHER_SUITE_TKIP) cipher_length = 12; @@ -802,9 +804,9 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, cipher_length = 0; } } - + atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_TYPE_OFFSET, priv->tx_desc_tail), - cipher_type); + cipher_type); atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_LENGTH_OFFSET, priv->tx_desc_tail), cipher_length); } @@ -813,46 +815,46 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, if (priv->tx_desc_previous != priv->tx_desc_tail) atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_previous), 0); priv->tx_desc_previous = priv->tx_desc_tail; - if (priv->tx_desc_tail < (priv->host_info.tx_desc_count - 1)) + if (priv->tx_desc_tail < (priv->host_info.tx_desc_count -1 )) priv->tx_desc_tail++; else priv->tx_desc_tail = 0; priv->tx_desc_free--; priv->tx_free_mem -= len; + } -static int start_tx(struct sk_buff *skb, struct net_device *dev) +static int start_tx (struct sk_buff *skb, struct net_device *dev) { struct atmel_private *priv = netdev_priv(dev); struct ieee80211_hdr_4addr header; unsigned long flags; u16 buff, frame_ctl, len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN; u8 SNAP_RFC1024[6] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00}; - - if (priv->card && priv->present_callback && + + if (priv->card && priv->present_callback && !(*priv->present_callback)(priv->card)) { priv->stats.tx_errors++; dev_kfree_skb(skb); return 0; } - + if (priv->station_state != STATION_STATE_READY) { priv->stats.tx_errors++; dev_kfree_skb(skb); return 0; } - + /* first ensure the timer func cannot run */ - spin_lock_bh(&priv->timerlock); + spin_lock_bh(&priv->timerlock); /* then stop the hardware ISR */ - spin_lock_irqsave(&priv->irqlock, flags); + spin_lock_irqsave(&priv->irqlock, flags); /* nb doing the above in the opposite order will deadlock */ - + /* The Wireless Header is 30 bytes. In the Ethernet packet we "cut" the - 12 first bytes (containing DA/SA) and put them in the appropriate - fields of the Wireless Header. Thus the packet length is then the - initial + 18 (+30-12) */ - + 12 first bytes (containing DA/SA) and put them in the appropriate fields of + the Wireless Header. Thus the packet length is then the initial + 18 (+30-12) */ + if (!(buff = find_tx_buff(priv, len + 18))) { priv->stats.tx_dropped++; spin_unlock_irqrestore(&priv->irqlock, flags); @@ -860,7 +862,7 @@ static int start_tx(struct sk_buff *skb, struct net_device *dev) netif_stop_queue(dev); return 1; } - + frame_ctl = IEEE80211_FTYPE_DATA; header.duration_id = 0; header.seq_ctl = 0; @@ -876,7 +878,7 @@ static int start_tx(struct sk_buff *skb, struct net_device *dev) memcpy(&header.addr2, dev->dev_addr, 6); memcpy(&header.addr3, skb->data, 6); } - + if (priv->use_wpa) memcpy(&header.addr4, SNAP_RFC1024, 6); @@ -886,27 +888,27 @@ static int start_tx(struct sk_buff *skb, struct net_device *dev) /* Copy the packet sans its 802.3 header addresses which have been replaced */ atmel_copy_to_card(dev, buff + DATA_FRAME_WS_HEADER_SIZE, skb->data + 12, len - 12); priv->tx_buff_tail += len - 12 + DATA_FRAME_WS_HEADER_SIZE; - + /* low bit of first byte of destination tells us if broadcast */ tx_update_descriptor(priv, *(skb->data) & 0x01, len + 18, buff, TX_PACKET_TYPE_DATA); dev->trans_start = jiffies; priv->stats.tx_bytes += len; - + spin_unlock_irqrestore(&priv->irqlock, flags); spin_unlock_bh(&priv->timerlock); dev_kfree_skb(skb); - - return 0; + + return 0; } -static void atmel_transmit_management_frame(struct atmel_private *priv, +static void atmel_transmit_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, u8 *body, int body_len) { u16 buff; - int len = MGMT_FRAME_BODY_OFFSET + body_len; - - if (!(buff = find_tx_buff(priv, len))) + int len = MGMT_FRAME_BODY_OFFSET + body_len; + + if (!(buff = find_tx_buff(priv, len))) return; atmel_copy_to_card(priv->dev, buff, (u8 *)header, MGMT_FRAME_BODY_OFFSET); @@ -914,25 +916,24 @@ static void atmel_transmit_management_frame(struct atmel_private *priv, priv->tx_buff_tail += len; tx_update_descriptor(priv, header->addr1[0] & 0x01, len, buff, TX_PACKET_TYPE_MGMT); } - -static void fast_rx_path(struct atmel_private *priv, - struct ieee80211_hdr_4addr *header, + +static void fast_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, u16 msdu_size, u16 rx_packet_loc, u32 crc) { /* fast path: unfragmented packet copy directly into skbuf */ - u8 mac4[6]; - struct sk_buff *skb; + u8 mac4[6]; + struct sk_buff *skb; unsigned char *skbp; - + /* get the final, mac 4 header field, this tells us encapsulation */ atmel_copy_to_host(priv->dev, mac4, rx_packet_loc + 24, 6); msdu_size -= 6; - + if (priv->do_rx_crc) { crc = crc32_le(crc, mac4, 6); msdu_size -= 4; } - + if (!(skb = dev_alloc_skb(msdu_size + 14))) { priv->stats.rx_dropped++; return; @@ -941,7 +942,7 @@ static void fast_rx_path(struct atmel_private *priv, skb_reserve(skb, 2); skbp = skb_put(skb, msdu_size + 12); atmel_copy_to_host(priv->dev, skbp + 12, rx_packet_loc + 30, msdu_size); - + if (priv->do_rx_crc) { u32 netcrc; crc = crc32_le(crc, skbp + 12, msdu_size); @@ -952,25 +953,24 @@ static void fast_rx_path(struct atmel_private *priv, return; } } - + memcpy(skbp, header->addr1, 6); /* destination address */ - if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) + if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) memcpy(&skbp[6], header->addr3, 6); else memcpy(&skbp[6], header->addr2, 6); /* source address */ - - priv->dev->last_rx = jiffies; + + priv->dev->last_rx=jiffies; skb->dev = priv->dev; skb->protocol = eth_type_trans(skb, priv->dev); - skb->ip_summed = CHECKSUM_NONE; + skb->ip_summed = CHECKSUM_NONE; netif_rx(skb); priv->stats.rx_bytes += 12 + msdu_size; priv->stats.rx_packets++; } /* Test to see if the packet in card memory at packet_loc has a valid CRC - It doesn't matter that this is slow: it is only used to proble the first few - packets. */ + It doesn't matter that this is slow: it is only used to proble the first few packets. */ static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size) { int i = msdu_size - 4; @@ -980,7 +980,7 @@ static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size) return 0; atmel_copy_to_host(priv->dev, (void *)&netcrc, packet_loc + i, 4); - + atmel_writeAR(priv->dev, packet_loc); while (i--) { u8 octet = atmel_read8(priv->dev, DR); @@ -990,22 +990,20 @@ static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size) return (crc ^ 0xffffffff) == netcrc; } -static void frag_rx_path(struct atmel_private *priv, - struct ieee80211_hdr_4addr *header, - u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no, - u8 frag_no, int more_frags) +static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, + u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no, u8 frag_no, int more_frags) { - u8 mac4[6]; + u8 mac4[6]; u8 source[6]; struct sk_buff *skb; - if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) + if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) memcpy(source, header->addr3, 6); else - memcpy(source, header->addr2, 6); - + memcpy(source, header->addr2, 6); + rx_packet_loc += 24; /* skip header */ - + if (priv->do_rx_crc) msdu_size -= 4; @@ -1014,16 +1012,16 @@ static void frag_rx_path(struct atmel_private *priv, msdu_size -= 6; rx_packet_loc += 6; - if (priv->do_rx_crc) + if (priv->do_rx_crc) crc = crc32_le(crc, mac4, 6); - + priv->frag_seq = seq_no; priv->frag_no = 1; priv->frag_len = msdu_size; - memcpy(priv->frag_source, source, 6); + memcpy(priv->frag_source, source, 6); memcpy(&priv->rx_buf[6], source, 6); memcpy(priv->rx_buf, header->addr1, 6); - + atmel_copy_to_host(priv->dev, &priv->rx_buf[12], rx_packet_loc, msdu_size); if (priv->do_rx_crc) { @@ -1035,17 +1033,17 @@ static void frag_rx_path(struct atmel_private *priv, memset(priv->frag_source, 0xff, 6); } } - + } else if (priv->frag_no == frag_no && priv->frag_seq == seq_no && memcmp(priv->frag_source, source, 6) == 0) { - - atmel_copy_to_host(priv->dev, &priv->rx_buf[12 + priv->frag_len], + + atmel_copy_to_host(priv->dev, &priv->rx_buf[12 + priv->frag_len], rx_packet_loc, msdu_size); if (priv->do_rx_crc) { u32 netcrc; - crc = crc32_le(crc, - &priv->rx_buf[12 + priv->frag_len], + crc = crc32_le(crc, + &priv->rx_buf[12 + priv->frag_len], msdu_size); atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4); if ((crc ^ 0xffffffff) != netcrc) { @@ -1054,7 +1052,7 @@ static void frag_rx_path(struct atmel_private *priv, more_frags = 1; /* don't send broken assembly */ } } - + priv->frag_len += msdu_size; priv->frag_no++; @@ -1064,60 +1062,60 @@ static void frag_rx_path(struct atmel_private *priv, priv->stats.rx_dropped++; } else { skb_reserve(skb, 2); - memcpy(skb_put(skb, priv->frag_len + 12), + memcpy(skb_put(skb, priv->frag_len + 12), priv->rx_buf, priv->frag_len + 12); priv->dev->last_rx = jiffies; skb->dev = priv->dev; skb->protocol = eth_type_trans(skb, priv->dev); - skb->ip_summed = CHECKSUM_NONE; + skb->ip_summed = CHECKSUM_NONE; netif_rx(skb); priv->stats.rx_bytes += priv->frag_len + 12; priv->stats.rx_packets++; } } + } else priv->wstats.discard.fragment++; } - + static void rx_done_irq(struct atmel_private *priv) { int i; struct ieee80211_hdr_4addr header; - - for (i = 0; + + for (i = 0; atmel_rmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head)) == RX_DESC_FLAG_VALID && i < priv->host_info.rx_desc_count; i++) { - + u16 msdu_size, rx_packet_loc, frame_ctl, seq_control; u8 status = atmel_rmem8(priv, atmel_rx(priv, RX_DESC_STATUS_OFFSET, priv->rx_desc_head)); u32 crc = 0xffffffff; - + if (status != RX_STATUS_SUCCESS) { if (status == 0xc1) /* determined by experiment */ priv->wstats.discard.nwid++; else - priv->stats.rx_errors++; + priv->stats.rx_errors++; goto next; } msdu_size = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_SIZE_OFFSET, priv->rx_desc_head)); rx_packet_loc = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_POS_OFFSET, priv->rx_desc_head)); - + if (msdu_size < 30) { - priv->stats.rx_errors++; + priv->stats.rx_errors++; goto next; } - + /* Get header as far as end of seq_ctl */ atmel_copy_to_host(priv->dev, (char *)&header, rx_packet_loc, 24); frame_ctl = le16_to_cpu(header.frame_ctl); seq_control = le16_to_cpu(header.seq_ctl); - /* probe for CRC use here if needed once five packets have - arrived with the same crc status, we assume we know what's - happening and stop probing */ + /* probe for CRC use here if needed once five packets have arrived with + the same crc status, we assume we know what's happening and stop probing */ if (priv->probe_crc) { if (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED)) { priv->do_rx_crc = probe_crc(priv, rx_packet_loc, msdu_size); @@ -1132,33 +1130,34 @@ static void rx_done_irq(struct atmel_private *priv) priv->probe_crc = 0; } } - + /* don't CRC header when WEP in use */ if (priv->do_rx_crc && (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED))) { crc = crc32_le(0xffffffff, (unsigned char *)&header, 24); } msdu_size -= 24; /* header */ - if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) { + if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) { + int more_fragments = frame_ctl & IEEE80211_FCTL_MOREFRAGS; u8 packet_fragment_no = seq_control & IEEE80211_SCTL_FRAG; u16 packet_sequence_no = (seq_control & IEEE80211_SCTL_SEQ) >> 4; - - if (!more_fragments && packet_fragment_no == 0) { + + if (!more_fragments && packet_fragment_no == 0 ) { fast_rx_path(priv, &header, msdu_size, rx_packet_loc, crc); } else { frag_rx_path(priv, &header, msdu_size, rx_packet_loc, crc, packet_sequence_no, packet_fragment_no, more_fragments); } } - + if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) { /* copy rest of packet into buffer */ atmel_copy_to_host(priv->dev, (unsigned char *)&priv->rx_buf, rx_packet_loc + 24, msdu_size); - + /* we use the same buffer for frag reassembly and control packets */ memset(priv->frag_source, 0xff, 6); - + if (priv->do_rx_crc) { /* last 4 octets is crc */ msdu_size -= 4; @@ -1171,18 +1170,18 @@ static void rx_done_irq(struct atmel_private *priv) atmel_management_frame(priv, &header, msdu_size, atmel_rmem8(priv, atmel_rx(priv, RX_DESC_RSSI_OFFSET, priv->rx_desc_head))); - } + } -next: + next: /* release descriptor */ - atmel_wmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head), RX_DESC_FLAG_CONSUMED); - + atmel_wmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head), RX_DESC_FLAG_CONSUMED); + if (priv->rx_desc_head < (priv->host_info.rx_desc_count - 1)) - priv->rx_desc_head++; + priv->rx_desc_head++; else priv->rx_desc_head = 0; } -} +} static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs) { @@ -1190,7 +1189,7 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs struct atmel_private *priv = netdev_priv(dev); u8 isr; int i = -1; - static u8 irq_order[] = { + static u8 irq_order[] = { ISR_OUT_OF_RANGE, ISR_RxCOMPLETE, ISR_TxCOMPLETE, @@ -1200,19 +1199,20 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs ISR_IBSS_MERGE, ISR_GENERIC_IRQ }; + - if (priv->card && priv->present_callback && + if (priv->card && priv->present_callback && !(*priv->present_callback)(priv->card)) return IRQ_HANDLED; /* In this state upper-level code assumes it can mess with the card unhampered by interrupts which may change register state. Note that even though the card shouldn't generate interrupts - the inturrupt line may be shared. This allows card setup + the inturrupt line may be shared. This allows card setup to go on without disabling interrupts for a long time. */ if (priv->station_state == STATION_STATE_DOWN) return IRQ_NONE; - + atmel_clear_gcr(dev, GCR_ENINT); /* disable interrupts */ while (1) { @@ -1221,36 +1221,36 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name); return IRQ_HANDLED; } - + isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET)); atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0); - + if (!isr) { atmel_set_gcr(dev, GCR_ENINT); /* enable interrupts */ return i == -1 ? IRQ_NONE : IRQ_HANDLED; } - + atmel_set_gcr(dev, GCR_ACKINT); /* acknowledge interrupt */ - + for (i = 0; i < sizeof(irq_order)/sizeof(u8); i++) if (isr & irq_order[i]) break; - + if (!atmel_lock_mac(priv)) { /* failed to contact card */ printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name); return IRQ_HANDLED; } - + isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET)); isr ^= irq_order[i]; atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET), isr); atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0); - + switch (irq_order[i]) { - - case ISR_OUT_OF_RANGE: - if (priv->operating_mode == IW_MODE_INFRA && + + case ISR_OUT_OF_RANGE: + if (priv->operating_mode == IW_MODE_INFRA && priv->station_state == STATION_STATE_READY) { priv->station_is_associated = 0; atmel_scan(priv, 1); @@ -1261,24 +1261,24 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs priv->wstats.discard.misc++; /* fall through */ case ISR_RxCOMPLETE: - rx_done_irq(priv); + rx_done_irq(priv); break; - + case ISR_TxCOMPLETE: - tx_done_irq(priv); + tx_done_irq(priv); break; - + case ISR_FATAL_ERROR: printk(KERN_ALERT "%s: *** FATAL error interrupt ***\n", dev->name); atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); break; - - case ISR_COMMAND_COMPLETE: + + case ISR_COMMAND_COMPLETE: atmel_command_irq(priv); break; case ISR_IBSS_MERGE: - atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS, + atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS, priv->CurrentBSSID, 6); /* The WPA stuff cares about the current AP address */ if (priv->use_wpa) @@ -1288,23 +1288,24 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs printk(KERN_INFO "%s: Generic_irq received.\n", dev->name); break; } - } + } } -static struct net_device_stats *atmel_get_stats(struct net_device *dev) + +static struct net_device_stats *atmel_get_stats (struct net_device *dev) { struct atmel_private *priv = netdev_priv(dev); return &priv->stats; } -static struct iw_statistics *atmel_get_wireless_stats(struct net_device *dev) +static struct iw_statistics *atmel_get_wireless_stats (struct net_device *dev) { struct atmel_private *priv = netdev_priv(dev); - /* update the link quality here in case we are seeing no beacons + /* update the link quality here in case we are seeing no beacons at all to drive the process */ atmel_smooth_qual(priv); - + priv->wstats.status = priv->station_state; if (priv->operating_mode == IW_MODE_INFRA) { @@ -1327,8 +1328,8 @@ static struct iw_statistics *atmel_get_wireless_stats(struct net_device *dev) | IW_QUAL_NOISE_INVALID; priv->wstats.miss.beacon = 0; } - - return &priv->wstats; + + return (&priv->wstats); } static int atmel_change_mtu(struct net_device *dev, int new_mtu) @@ -1342,21 +1343,21 @@ static int atmel_change_mtu(struct net_device *dev, int new_mtu) static int atmel_set_mac_address(struct net_device *dev, void *p) { struct sockaddr *addr = p; - + memcpy (dev->dev_addr, addr->sa_data, dev->addr_len); return atmel_open(dev); } EXPORT_SYMBOL(atmel_open); -int atmel_open(struct net_device *dev) +int atmel_open (struct net_device *dev) { struct atmel_private *priv = netdev_priv(dev); int i, channel; /* any scheduled timer is no longer needed and might screw things up.. */ del_timer_sync(&priv->management_timer); - + /* Interrupts will not touch the card once in this state... */ priv->station_state = STATION_STATE_DOWN; @@ -1376,7 +1377,7 @@ int atmel_open(struct net_device *dev) priv->site_survey_state = SITE_SURVEY_IDLE; priv->station_is_associated = 0; - if (!reset_atmel_card(dev)) + if (!reset_atmel_card(dev)) return -EAGAIN; if (priv->config_reg_domain) { @@ -1390,26 +1391,26 @@ int atmel_open(struct net_device *dev) if (i == sizeof(channel_table)/sizeof(channel_table[0])) { priv->reg_domain = REG_DOMAIN_MKK1; printk(KERN_ALERT "%s: failed to get regulatory domain: assuming MKK1.\n", dev->name); - } + } } - + if ((channel = atmel_validate_channel(priv, priv->channel))) priv->channel = channel; - /* this moves station_state on.... */ - atmel_scan(priv, 1); + /* this moves station_state on.... */ + atmel_scan(priv, 1); atmel_set_gcr(priv->dev, GCR_ENINT); /* enable interrupts */ return 0; } -static int atmel_close(struct net_device *dev) +static int atmel_close (struct net_device *dev) { struct atmel_private *priv = netdev_priv(dev); - + atmel_enter_state(priv, STATION_STATE_DOWN); - - if (priv->bus_type == BUS_TYPE_PCCARD) + + if (priv->bus_type == BUS_TYPE_PCCARD) atmel_write16(dev, GCR, 0x0060); atmel_write16(dev, GCR, 0x0040); return 0; @@ -1437,46 +1438,43 @@ static int atmel_proc_output (char *buf, struct atmel_private *priv) int i; char *p = buf; char *s, *r, *c; - - p += sprintf(p, "Driver version:\t\t%d.%d\n", - DRIVER_MAJOR, DRIVER_MINOR); - + + p += sprintf(p, "Driver version:\t\t%d.%d\n", DRIVER_MAJOR, DRIVER_MINOR); + if (priv->station_state != STATION_STATE_DOWN) { - p += sprintf(p, "Firmware version:\t%d.%d build %d\n" - "Firmware location:\t", + p += sprintf(p, "Firmware version:\t%d.%d build %d\nFirmware location:\t", priv->host_info.major_version, priv->host_info.minor_version, priv->host_info.build_version); - - if (priv->card_type != CARD_TYPE_EEPROM) + + if (priv->card_type != CARD_TYPE_EEPROM) p += sprintf(p, "on card\n"); - else if (priv->firmware) - p += sprintf(p, "%s loaded by host\n", - priv->firmware_id); + else if (priv->firmware) + p += sprintf(p, "%s loaded by host\n", priv->firmware_id); else - p += sprintf(p, "%s loaded by hotplug\n", - priv->firmware_id); - - switch (priv->card_type) { + p += sprintf(p, "%s loaded by hotplug\n", priv->firmware_id); + + switch(priv->card_type) { case CARD_TYPE_PARALLEL_FLASH: c = "Parallel flash"; break; case CARD_TYPE_SPI_FLASH: c = "SPI flash\n"; break; case CARD_TYPE_EEPROM: c = "EEPROM"; break; default: c = ""; } + r = ""; for (i = 0; i < sizeof(channel_table)/sizeof(channel_table[0]); i++) if (priv->reg_domain == channel_table[i].reg_domain) r = channel_table[i].name; - + p += sprintf(p, "MAC memory type:\t%s\n", c); p += sprintf(p, "Regulatory domain:\t%s\n", r); - p += sprintf(p, "Host CRC checking:\t%s\n", + p += sprintf(p, "Host CRC checking:\t%s\n", priv->do_rx_crc ? "On" : "Off"); p += sprintf(p, "WPA-capable firmware:\t%s\n", priv->use_wpa ? "Yes" : "No"); } - + switch(priv->station_state) { case STATION_STATE_SCANNING: s = "Scanning"; break; case STATION_STATE_JOINNING: s = "Joining"; break; @@ -1488,9 +1486,9 @@ static int atmel_proc_output (char *buf, struct atmel_private *priv) case STATION_STATE_DOWN: s = "Down"; break; default: s = ""; } - + p += sprintf(p, "Current state:\t\t%s\n", s); - return p - buf; + return p - buf; } static int atmel_read_proc(char *page, char **start, off_t off, @@ -1506,12 +1504,9 @@ static int atmel_read_proc(char *page, char **start, off_t off, return len; } -struct net_device *init_atmel_card(unsigned short irq, unsigned long port, - const AtmelFWType fw_type, - struct device *sys_dev, - int (*card_present)(void *), void *card) +struct net_device *init_atmel_card( unsigned short irq, unsigned long port, const AtmelFWType fw_type, + struct device *sys_dev, int (*card_present)(void *), void *card) { - struct proc_dir_entry *ent; struct net_device *dev; struct atmel_private *priv; int rc; @@ -1519,11 +1514,11 @@ struct net_device *init_atmel_card(unsigned short irq, unsigned long port, /* Create the network device object. */ dev = alloc_etherdev(sizeof(*priv)); if (!dev) { - printk(KERN_ERR "atmel: Couldn't alloc_etherdev\n"); + printk(KERN_ERR "atmel: Couldn't alloc_etherdev\n"); return NULL; } if (dev_alloc_name(dev, dev->name) < 0) { - printk(KERN_ERR "atmel: Couldn't get name!\n"); + printk(KERN_ERR "atmel: Couldn't get name!\n"); goto err_out_free; } @@ -1555,7 +1550,7 @@ struct net_device *init_atmel_card(unsigned short irq, unsigned long port, memset(priv->BSSID, 0, 6); priv->CurrentBSSID[0] = 0xFF; /* Initialize to something invalid.... */ priv->station_was_associated = 0; - + priv->last_survey = jiffies; priv->preamble = LONG_PREAMBLE; priv->operating_mode = IW_MODE_INFRA; @@ -1591,7 +1586,7 @@ struct net_device *init_atmel_card(unsigned short irq, unsigned long port, spin_lock_init(&priv->timerlock); priv->management_timer.function = atmel_management_timer; priv->management_timer.data = (unsigned long) dev; - + dev->open = atmel_open; dev->stop = atmel_close; dev->change_mtu = atmel_change_mtu; @@ -1602,46 +1597,44 @@ struct net_device *init_atmel_card(unsigned short irq, unsigned long port, dev->do_ioctl = atmel_ioctl; dev->irq = irq; dev->base_addr = port; - + SET_NETDEV_DEV(dev, sys_dev); - + if ((rc = request_irq(dev->irq, service_interrupt, SA_SHIRQ, dev->name, dev))) { - printk(KERN_ERR "%s: register interrupt %d failed, rc %d\n", dev->name, irq, rc); + printk(KERN_ERR "%s: register interrupt %d failed, rc %d\n", dev->name, irq, rc ); goto err_out_free; } - if (!request_region(dev->base_addr, 32, + if (!request_region(dev->base_addr, 32, priv->bus_type == BUS_TYPE_PCCARD ? "atmel_cs" : "atmel_pci")) { goto err_out_irq; } - + if (register_netdev(dev)) goto err_out_res; - + if (!probe_atmel_card(dev)){ unregister_netdev(dev); goto err_out_res; } - + netif_carrier_off(dev); - - ent = create_proc_read_entry ("driver/atmel", 0, NULL, atmel_read_proc, priv); - if (!ent) - printk(KERN_WARNING "atmel: unable to create /proc entry.\n"); - + + create_proc_read_entry ("driver/atmel", 0, NULL, atmel_read_proc, priv); + printk(KERN_INFO "%s: Atmel at76c50x. Version %d.%d. MAC %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n", dev->name, DRIVER_MAJOR, DRIVER_MINOR, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] ); - + SET_MODULE_OWNER(dev); return dev; - -err_out_res: + + err_out_res: release_region( dev->base_addr, 32); -err_out_irq: + err_out_irq: free_irq(dev->irq, dev); -err_out_free: + err_out_free: free_netdev(dev); return NULL; } @@ -1651,12 +1644,12 @@ EXPORT_SYMBOL(init_atmel_card); void stop_atmel_card(struct net_device *dev) { struct atmel_private *priv = netdev_priv(dev); - + /* put a brick on it... */ - if (priv->bus_type == BUS_TYPE_PCCARD) + if (priv->bus_type == BUS_TYPE_PCCARD) atmel_write16(dev, GCR, 0x0060); atmel_write16(dev, GCR, 0x0040); - + del_timer_sync(&priv->management_timer); unregister_netdev(dev); remove_proc_entry("driver/atmel", NULL); @@ -1682,13 +1675,13 @@ static int atmel_set_essid(struct net_device *dev, int index = (dwrq->flags & IW_ENCODE_INDEX) - 1; priv->connect_to_any_BSS = 0; - + /* Check the size of the string */ if (dwrq->length > MAX_SSID_LENGTH + 1) - return -E2BIG; + return -E2BIG ; if (index != 0) return -EINVAL; - + memcpy(priv->new_SSID, extra, dwrq->length - 1); priv->new_SSID_size = dwrq->length - 1; } @@ -1713,7 +1706,7 @@ static int atmel_get_essid(struct net_device *dev, extra[priv->SSID_size] = '\0'; dwrq->length = priv->SSID_size + 1; } - + dwrq->flags = !priv->connect_to_any_BSS; /* active */ return 0; @@ -1775,7 +1768,7 @@ static int atmel_set_encode(struct net_device *dev, /* WE specify that if a valid key is set, encryption * should be enabled (user may turn it off later) * This is also how "iwconfig ethX key on" works */ - if (index == current_index && + if (index == current_index && priv->wep_key_len[index] > 0) { priv->wep_is_on = 1; priv->exclude_unencrypted = 1; @@ -1790,18 +1783,18 @@ static int atmel_set_encode(struct net_device *dev, } else { /* Do we want to just set the transmit key index ? */ int index = (dwrq->flags & IW_ENCODE_INDEX) - 1; - if (index >= 0 && index < 4) { + if ( index>=0 && index < 4 ) { priv->default_key = index; } else /* Don't complain if only change the mode */ - if (!dwrq->flags & IW_ENCODE_MODE) { + if(!dwrq->flags & IW_ENCODE_MODE) { return -EINVAL; } } /* Read the flags */ - if (dwrq->flags & IW_ENCODE_DISABLED) { + if(dwrq->flags & IW_ENCODE_DISABLED) { priv->wep_is_on = 0; - priv->encryption_level = 0; + priv->encryption_level = 0; priv->pairwise_cipher_suite = CIPHER_SUITE_NONE; } else { priv->wep_is_on = 1; @@ -1813,14 +1806,15 @@ static int atmel_set_encode(struct net_device *dev, priv->encryption_level = 1; } } - if (dwrq->flags & IW_ENCODE_RESTRICTED) + if(dwrq->flags & IW_ENCODE_RESTRICTED) priv->exclude_unencrypted = 1; - if(dwrq->flags & IW_ENCODE_OPEN) + if(dwrq->flags & IW_ENCODE_OPEN) priv->exclude_unencrypted = 0; - + return -EINPROGRESS; /* Call commit handler */ } + static int atmel_get_encode(struct net_device *dev, struct iw_request_info *info, struct iw_point *dwrq, @@ -1828,7 +1822,7 @@ static int atmel_get_encode(struct net_device *dev, { struct atmel_private *priv = netdev_priv(dev); int index = (dwrq->flags & IW_ENCODE_INDEX) - 1; - + if (!priv->wep_is_on) dwrq->flags = IW_ENCODE_DISABLED; else { @@ -1849,7 +1843,7 @@ static int atmel_get_encode(struct net_device *dev, memset(extra, 0, 16); memcpy(extra, priv->wep_keys[index], dwrq->length); } - + return 0; } @@ -1868,17 +1862,17 @@ static int atmel_set_rate(struct net_device *dev, char *extra) { struct atmel_private *priv = netdev_priv(dev); - + if (vwrq->fixed == 0) { priv->tx_rate = 3; priv->auto_tx_rate = 1; } else { priv->auto_tx_rate = 0; - + /* Which type of value ? */ - if ((vwrq->value < 4) && (vwrq->value >= 0)) { + if((vwrq->value < 4) && (vwrq->value >= 0)) { /* Setting by rate index */ - priv->tx_rate = vwrq->value; + priv->tx_rate = vwrq->value; } else { /* Setting by frequency value */ switch (vwrq->value) { @@ -1905,7 +1899,7 @@ static int atmel_set_mode(struct net_device *dev, return -EINVAL; priv->operating_mode = *uwrq; - return -EINPROGRESS; + return -EINPROGRESS; } static int atmel_get_mode(struct net_device *dev, @@ -1914,7 +1908,7 @@ static int atmel_get_mode(struct net_device *dev, char *extra) { struct atmel_private *priv = netdev_priv(dev); - + *uwrq = priv->operating_mode; return 0; } @@ -1968,9 +1962,9 @@ static int atmel_set_retry(struct net_device *dev, char *extra) { struct atmel_private *priv = netdev_priv(dev); - - if (!vwrq->disabled && (vwrq->flags & IW_RETRY_LIMIT)) { - if (vwrq->flags & IW_RETRY_MAX) + + if(!vwrq->disabled && (vwrq->flags & IW_RETRY_LIMIT)) { + if(vwrq->flags & IW_RETRY_MAX) priv->long_retry = vwrq->value; else if (vwrq->flags & IW_RETRY_MIN) priv->short_retry = vwrq->value; @@ -1979,9 +1973,9 @@ static int atmel_set_retry(struct net_device *dev, priv->long_retry = vwrq->value; priv->short_retry = vwrq->value; } - return -EINPROGRESS; + return -EINPROGRESS; } - + return -EINVAL; } @@ -1995,13 +1989,13 @@ static int atmel_get_retry(struct net_device *dev, vwrq->disabled = 0; /* Can't be disabled */ /* Note : by default, display the min retry number */ - if (vwrq->flags & IW_RETRY_MAX) { + if((vwrq->flags & IW_RETRY_MAX)) { vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX; vwrq->value = priv->long_retry; } else { vwrq->flags = IW_RETRY_LIMIT; vwrq->value = priv->short_retry; - if (priv->long_retry != priv->short_retry) + if(priv->long_retry != priv->short_retry) vwrq->flags |= IW_RETRY_MIN; } @@ -2016,13 +2010,13 @@ static int atmel_set_rts(struct net_device *dev, struct atmel_private *priv = netdev_priv(dev); int rthr = vwrq->value; - if (vwrq->disabled) + if(vwrq->disabled) rthr = 2347; - if ((rthr < 0) || (rthr > 2347)) { + if((rthr < 0) || (rthr > 2347)) { return -EINVAL; } priv->rts_threshold = rthr; - + return -EINPROGRESS; /* Call commit handler */ } @@ -2032,7 +2026,7 @@ static int atmel_get_rts(struct net_device *dev, char *extra) { struct atmel_private *priv = netdev_priv(dev); - + vwrq->value = priv->rts_threshold; vwrq->disabled = (vwrq->value >= 2347); vwrq->fixed = 1; @@ -2048,14 +2042,14 @@ static int atmel_set_frag(struct net_device *dev, struct atmel_private *priv = netdev_priv(dev); int fthr = vwrq->value; - if (vwrq->disabled) + if(vwrq->disabled) fthr = 2346; - if ((fthr < 256) || (fthr > 2346)) { + if((fthr < 256) || (fthr > 2346)) { return -EINVAL; } fthr &= ~0x1; /* Get an even value - is it really needed ??? */ priv->frag_threshold = fthr; - + return -EINPROGRESS; /* Call commit handler */ } @@ -2083,21 +2077,21 @@ static int atmel_set_freq(struct net_device *dev, { struct atmel_private *priv = netdev_priv(dev); int rc = -EINPROGRESS; /* Call commit handler */ - + /* If setting by frequency, convert to a channel */ - if ((fwrq->e == 1) && - (fwrq->m >= (int) 241200000) && - (fwrq->m <= (int) 248700000)) { + if((fwrq->e == 1) && + (fwrq->m >= (int) 241200000) && + (fwrq->m <= (int) 248700000)) { int f = fwrq->m / 100000; int c = 0; - while ((c < 14) && (f != frequency_list[c])) + while((c < 14) && (f != frequency_list[c])) c++; /* Hack to fall through... */ fwrq->e = 0; fwrq->m = c + 1; } /* Setting by channel number */ - if ((fwrq->m > 1000) || (fwrq->e > 0)) + if((fwrq->m > 1000) || (fwrq->e > 0)) rc = -EOPNOTSUPP; else { int channel = fwrq->m; @@ -2105,7 +2099,7 @@ static int atmel_set_freq(struct net_device *dev, priv->channel = channel; } else { rc = -EINVAL; - } + } } return rc; } @@ -2136,7 +2130,7 @@ static int atmel_set_scan(struct net_device *dev, * This is not an error, while the device perform scanning, * traffic doesn't flow, so it's a perfect DoS... * Jean II */ - + if (priv->station_state == STATION_STATE_DOWN) return -EAGAIN; @@ -2148,15 +2142,15 @@ static int atmel_set_scan(struct net_device *dev, /* Initiate a scan command */ if (priv->site_survey_state == SITE_SURVEY_IN_PROGRESS) return -EBUSY; - + del_timer_sync(&priv->management_timer); spin_lock_irqsave(&priv->irqlock, flags); - + priv->site_survey_state = SITE_SURVEY_IN_PROGRESS; priv->fast_scan = 0; atmel_scan(priv, 0); spin_unlock_irqrestore(&priv->irqlock, flags); - + return 0; } @@ -2169,11 +2163,11 @@ static int atmel_get_scan(struct net_device *dev, int i; char *current_ev = extra; struct iw_event iwe; - + if (priv->site_survey_state != SITE_SURVEY_COMPLETED) return -EAGAIN; - - for (i = 0; i < priv->BSS_list_entries; i++) { + + for(i=0; iBSS_list_entries; i++) { iwe.cmd = SIOCGIWAP; iwe.u.ap_addr.sa_family = ARPHRD_ETHER; memcpy(iwe.u.ap_addr.sa_data, priv->BSSinfo[i].BSSID, 6); @@ -2185,16 +2179,16 @@ static int atmel_get_scan(struct net_device *dev, iwe.cmd = SIOCGIWESSID; iwe.u.data.flags = 1; current_ev = iwe_stream_add_point(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, priv->BSSinfo[i].SSID); - + iwe.cmd = SIOCGIWMODE; iwe.u.mode = priv->BSSinfo[i].BSStype; current_ev = iwe_stream_add_event(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, IW_EV_UINT_LEN); - + iwe.cmd = SIOCGIWFREQ; iwe.u.freq.m = priv->BSSinfo[i].channel; iwe.u.freq.e = 0; current_ev = iwe_stream_add_event(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, IW_EV_FREQ_LEN); - + iwe.cmd = SIOCGIWENCODE; if (priv->BSSinfo[i].UsingWEP) iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; @@ -2202,12 +2196,13 @@ static int atmel_get_scan(struct net_device *dev, iwe.u.data.flags = IW_ENCODE_DISABLED; iwe.u.data.length = 0; current_ev = iwe_stream_add_point(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, NULL); + } /* Length of data */ dwrq->length = (current_ev - extra); - dwrq->flags = 0; - + dwrq->flags = 0; + return 0; } @@ -2218,7 +2213,7 @@ static int atmel_get_range(struct net_device *dev, { struct atmel_private *priv = netdev_priv(dev); struct iw_range *range = (struct iw_range *) extra; - int k, i, j; + int k,i,j; dwrq->length = sizeof(struct iw_range); memset(range, 0, sizeof(struct iw_range)); @@ -2231,14 +2226,14 @@ static int atmel_get_range(struct net_device *dev, break; } if (range->num_channels != 0) { - for (k = 0, i = channel_table[j].min; i <= channel_table[j].max; i++) { + for(k = 0, i = channel_table[j].min; i <= channel_table[j].max; i++) { range->freq[k].i = i; /* List index */ - range->freq[k].m = frequency_list[i - 1] * 100000; + range->freq[k].m = frequency_list[i-1] * 100000; range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */ } range->num_frequency = k; } - + range->max_qual.qual = 100; range->max_qual.level = 100; range->max_qual.noise = 0; @@ -2266,11 +2261,11 @@ static int atmel_get_range(struct net_device *dev, range->encoding_size[1] = 13; range->num_encoding_sizes = 2; range->max_encoding_tokens = 4; - + range->pmp_flags = IW_POWER_ON; range->pmt_flags = IW_POWER_ON; range->pm_capa = 0; - + range->we_version_source = WIRELESS_EXT; range->we_version_compiled = WIRELESS_EXT; range->retry_capa = IW_RETRY_LIMIT ; @@ -2294,7 +2289,7 @@ static int atmel_set_wap(struct net_device *dev, if (awrq->sa_family != ARPHRD_ETHER) return -EINVAL; - + if (memcmp(bcast, awrq->sa_data, 6) == 0) { del_timer_sync(&priv->management_timer); spin_lock_irqsave(&priv->irqlock, flags); @@ -2302,8 +2297,8 @@ static int atmel_set_wap(struct net_device *dev, spin_unlock_irqrestore(&priv->irqlock, flags); return 0; } - - for (i = 0; i < priv->BSS_list_entries; i++) { + + for(i=0; iBSS_list_entries; i++) { if (memcmp(priv->BSSinfo[i].BSSID, awrq->sa_data, 6) == 0) { if (!priv->wep_is_on && priv->BSSinfo[i].UsingWEP) { return -EINVAL; @@ -2318,10 +2313,10 @@ static int atmel_set_wap(struct net_device *dev, } } } - + return -EINVAL; } - + static int atmel_config_commit(struct net_device *dev, struct iw_request_info *info, /* NULL */ void *zwrq, /* NULL */ @@ -2330,18 +2325,18 @@ static int atmel_config_commit(struct net_device *dev, return atmel_open(dev); } -static const iw_handler atmel_handler[] = +static const iw_handler atmel_handler[] = { (iw_handler) atmel_config_commit, /* SIOCSIWCOMMIT */ - (iw_handler) atmel_get_name, /* SIOCGIWNAME */ + (iw_handler) atmel_get_name, /* SIOCGIWNAME */ (iw_handler) NULL, /* SIOCSIWNWID */ (iw_handler) NULL, /* SIOCGIWNWID */ (iw_handler) atmel_set_freq, /* SIOCSIWFREQ */ (iw_handler) atmel_get_freq, /* SIOCGIWFREQ */ (iw_handler) atmel_set_mode, /* SIOCSIWMODE */ (iw_handler) atmel_get_mode, /* SIOCGIWMODE */ - (iw_handler) NULL, /* SIOCSIWSENS */ - (iw_handler) NULL, /* SIOCGIWSENS */ + (iw_handler) NULL, /* SIOCSIWSENS */ + (iw_handler) NULL, /* SIOCGIWSENS */ (iw_handler) NULL, /* SIOCSIWRANGE */ (iw_handler) atmel_get_range, /* SIOCGIWRANGE */ (iw_handler) NULL, /* SIOCSIWPRIV */ @@ -2355,13 +2350,13 @@ static const iw_handler atmel_handler[] = (iw_handler) atmel_set_wap, /* SIOCSIWAP */ (iw_handler) atmel_get_wap, /* SIOCGIWAP */ (iw_handler) NULL, /* -- hole -- */ - (iw_handler) NULL, /* SIOCGIWAPLIST */ + (iw_handler) NULL, /* SIOCGIWAPLIST */ (iw_handler) atmel_set_scan, /* SIOCSIWSCAN */ (iw_handler) atmel_get_scan, /* SIOCGIWSCAN */ (iw_handler) atmel_set_essid, /* SIOCSIWESSID */ (iw_handler) atmel_get_essid, /* SIOCGIWESSID */ - (iw_handler) NULL, /* SIOCSIWNICKN */ - (iw_handler) NULL, /* SIOCGIWNICKN */ + (iw_handler) NULL, /* SIOCSIWNICKN */ + (iw_handler) NULL, /* SIOCGIWNICKN */ (iw_handler) NULL, /* -- hole -- */ (iw_handler) NULL, /* -- hole -- */ (iw_handler) atmel_set_rate, /* SIOCSIWRATE */ @@ -2370,8 +2365,8 @@ static const iw_handler atmel_handler[] = (iw_handler) atmel_get_rts, /* SIOCGIWRTS */ (iw_handler) atmel_set_frag, /* SIOCSIWFRAG */ (iw_handler) atmel_get_frag, /* SIOCGIWFRAG */ - (iw_handler) NULL, /* SIOCSIWTXPOW */ - (iw_handler) NULL, /* SIOCGIWTXPOW */ + (iw_handler) NULL, /* SIOCSIWTXPOW */ + (iw_handler) NULL, /* SIOCGIWTXPOW */ (iw_handler) atmel_set_retry, /* SIOCSIWRETRY */ (iw_handler) atmel_get_retry, /* SIOCGIWRETRY */ (iw_handler) atmel_set_encode, /* SIOCSIWENCODE */ @@ -2380,51 +2375,39 @@ static const iw_handler atmel_handler[] = (iw_handler) atmel_get_power, /* SIOCGIWPOWER */ }; -static const iw_handler atmel_private_handler[] = + +static const iw_handler atmel_private_handler[] = { NULL, /* SIOCIWFIRSTPRIV */ }; typedef struct atmel_priv_ioctl { char id[32]; - unsigned char __user *data; - unsigned short len; + unsigned char __user *data; + unsigned short len; } atmel_priv_ioctl; -#define ATMELFWL SIOCIWFIRSTPRIV -#define ATMELIDIFC ATMELFWL + 1 -#define ATMELRD ATMELFWL + 2 -#define ATMELMAGIC 0x51807 + +#define ATMELFWL SIOCIWFIRSTPRIV +#define ATMELIDIFC ATMELFWL + 1 +#define ATMELRD ATMELFWL + 2 +#define ATMELMAGIC 0x51807 #define REGDOMAINSZ 20 static const struct iw_priv_args atmel_private_args[] = { - { - .cmd = ATMELFWL, - .set_args = IW_PRIV_TYPE_BYTE - | IW_PRIV_SIZE_FIXED - | sizeof (atmel_priv_ioctl), - .get_args = IW_PRIV_TYPE_NONE, - .name = "atmelfwl" - }, { - .cmd = ATMELIDIFC, - .set_args = IW_PRIV_TYPE_NONE, - .get_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, - .name = "atmelidifc" - }, { - .cmd = ATMELRD, - .set_args = IW_PRIV_TYPE_CHAR | REGDOMAINSZ, - .get_args = IW_PRIV_TYPE_NONE, - .name = "regdomain" - }, +/*{ cmd, set_args, get_args, name } */ + { ATMELFWL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (atmel_priv_ioctl), IW_PRIV_TYPE_NONE, "atmelfwl" }, + { ATMELIDIFC, IW_PRIV_TYPE_NONE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "atmelidifc" }, + { ATMELRD, IW_PRIV_TYPE_CHAR | REGDOMAINSZ, IW_PRIV_TYPE_NONE, "regdomain" }, }; -static const struct iw_handler_def atmel_handler_def = +static const struct iw_handler_def atmel_handler_def = { .num_standard = sizeof(atmel_handler)/sizeof(iw_handler), - .num_private = sizeof(atmel_private_handler)/sizeof(iw_handler), - .num_private_args = sizeof(atmel_private_args)/sizeof(struct iw_priv_args), + .num_private = sizeof(atmel_private_handler)/sizeof(iw_handler), + .num_private_args = sizeof(atmel_private_args)/sizeof(struct iw_priv_args), .standard = (iw_handler *) atmel_handler, - .private = (iw_handler *) atmel_private_handler, + .private = (iw_handler *) atmel_private_handler, .private_args = (struct iw_priv_args *) atmel_private_args, .get_wireless_stats = atmel_get_wireless_stats }; @@ -2436,13 +2419,13 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) atmel_priv_ioctl com; struct iwreq *wrq = (struct iwreq *) rq; unsigned char *new_firmware; - char domain[REGDOMAINSZ + 1]; + char domain[REGDOMAINSZ+1]; switch (cmd) { case ATMELIDIFC: - wrq->u.param.value = ATMELMAGIC; + wrq->u.param.value = ATMELMAGIC; break; - + case ATMELFWL: if (copy_from_user(&com, rq->ifr_data, sizeof(com))) { rc = -EFAULT; @@ -2466,7 +2449,7 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) } kfree(priv->firmware); - + priv->firmware = new_firmware; priv->firmware_length = com.len; strncpy(priv->firmware_id, com.id, 31); @@ -2478,7 +2461,7 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) rc = -EFAULT; break; } - + if (!capable(CAP_NET_ADMIN)) { rc = -EPERM; break; @@ -2501,15 +2484,15 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) rc = 0; } } - + if (rc == 0 && priv->station_state != STATION_STATE_DOWN) rc = atmel_open(dev); break; - + default: rc = -EOPNOTSUPP; } - + return rc; } @@ -2520,17 +2503,17 @@ struct auth_body { u8 el_id; u8 chall_text_len; u8 chall_text[253]; -}; +}; static void atmel_enter_state(struct atmel_private *priv, int new_state) { int old_state = priv->station_state; - + if (new_state == old_state) return; - + priv->station_state = new_state; - + if (new_state == STATION_STATE_READY) { netif_start_queue(priv->dev); netif_carrier_on(priv->dev); @@ -2557,7 +2540,7 @@ static void atmel_scan(struct atmel_private *priv, int specific_ssid) u8 options; u8 SSID_size; } cmd; - + memset(cmd.BSSID, 0xff, 6); if (priv->fast_scan) { @@ -2571,17 +2554,17 @@ static void atmel_scan(struct atmel_private *priv, int specific_ssid) cmd.min_channel_time = cpu_to_le16(10); cmd.max_channel_time = cpu_to_le16(120); } - + cmd.options = 0; - + if (!specific_ssid) cmd.options |= SCAN_OPTIONS_SITE_SURVEY; - - cmd.channel = (priv->channel & 0x7f); + + cmd.channel = (priv->channel & 0x7f); cmd.scan_type = SCAN_TYPE_ACTIVE; - cmd.BSS_type = cpu_to_le16(priv->operating_mode == IW_MODE_ADHOC ? + cmd.BSS_type = cpu_to_le16(priv->operating_mode == IW_MODE_ADHOC ? BSS_TYPE_AD_HOC : BSS_TYPE_INFRASTRUCTURE); - + atmel_send_command(priv, CMD_Scan, &cmd, sizeof(cmd)); /* This must come after all hardware access to avoid being messed up @@ -2608,15 +2591,16 @@ static void join(struct atmel_private *priv, int type) cmd.BSS_type = type; cmd.timeout = cpu_to_le16(2000); - atmel_send_command(priv, CMD_Join, &cmd, sizeof(cmd)); + atmel_send_command(priv, CMD_Join, &cmd, sizeof(cmd)); } + static void start(struct atmel_private *priv, int type) { struct { u8 BSSID[6]; u8 SSID[MAX_SSID_LENGTH]; - u8 BSS_type; + u8 BSS_type; u8 channel; u8 SSID_size; u8 reserved[3]; @@ -2628,14 +2612,13 @@ static void start(struct atmel_private *priv, int type) cmd.BSS_type = type; cmd.channel = (priv->channel & 0x7f); - atmel_send_command(priv, CMD_Start, &cmd, sizeof(cmd)); + atmel_send_command(priv, CMD_Start, &cmd, sizeof(cmd)); } -static void handle_beacon_probe(struct atmel_private *priv, u16 capability, - u8 channel) +static void handle_beacon_probe(struct atmel_private *priv, u16 capability, u8 channel) { int rejoin = 0; - int new = capability & C80211_MGMT_CAPABILITY_ShortPreamble ? + int new = capability & C80211_MGMT_CAPABILITY_ShortPreamble ? SHORT_PREAMBLE : LONG_PREAMBLE; if (priv->preamble != new) { @@ -2643,48 +2626,48 @@ static void handle_beacon_probe(struct atmel_private *priv, u16 capability, rejoin = 1; atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, new); } - + if (priv->channel != channel) { priv->channel = channel; rejoin = 1; atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_CHANNEL_POS, channel); } - + if (rejoin) { priv->station_is_associated = 0; atmel_enter_state(priv, STATION_STATE_JOINNING); - + if (priv->operating_mode == IW_MODE_INFRA) join(priv, BSS_TYPE_INFRASTRUCTURE); - else + else join(priv, BSS_TYPE_AD_HOC); - } + } } -static void send_authentication_request(struct atmel_private *priv, u16 system, - u8 *challenge, int challenge_len) + +static void send_authentication_request(struct atmel_private *priv, u16 system, u8 *challenge, int challenge_len) { struct ieee80211_hdr_4addr header; struct auth_body auth; - - header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH); - header.duration_id = cpu_to_le16(0x8000); + + header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH); + header.duration_id = cpu_to_le16(0x8000); header.seq_ctl = 0; memcpy(header.addr1, priv->CurrentBSSID, 6); memcpy(header.addr2, priv->dev->dev_addr, 6); memcpy(header.addr3, priv->CurrentBSSID, 6); - - if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1) + + if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1) /* no WEP for authentication frames with TrSeqNo 1 */ header.frame_ctl |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); - - auth.alg = cpu_to_le16(system); + + auth.alg = cpu_to_le16(system); auth.status = 0; auth.trans_seq = cpu_to_le16(priv->CurrentAuthentTransactionSeqNum); - priv->ExpectedAuthentTransactionSeqNum = priv->CurrentAuthentTransactionSeqNum+1; + priv->ExpectedAuthentTransactionSeqNum = priv->CurrentAuthentTransactionSeqNum+1; priv->CurrentAuthentTransactionSeqNum += 2; - + if (challenge_len != 0) { auth.el_id = 16; /* challenge_text */ auth.chall_text_len = challenge_len; @@ -2702,7 +2685,7 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc) struct ieee80211_hdr_4addr header; struct ass_req_format { u16 capability; - u16 listen_interval; + u16 listen_interval; u8 ap[6]; /* nothing after here directly accessible */ u8 ssid_el_id; u8 ssid_len; @@ -2711,15 +2694,15 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc) u8 sup_rates_len; u8 rates[4]; } body; - - header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | + + header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | (is_reassoc ? IEEE80211_STYPE_REASSOC_REQ : IEEE80211_STYPE_ASSOC_REQ)); header.duration_id = cpu_to_le16(0x8000); header.seq_ctl = 0; - memcpy(header.addr1, priv->CurrentBSSID, 6); + memcpy(header.addr1, priv->CurrentBSSID, 6); memcpy(header.addr2, priv->dev->dev_addr, 6); - memcpy(header.addr3, priv->CurrentBSSID, 6); + memcpy(header.addr3, priv->CurrentBSSID, 6); body.capability = cpu_to_le16(C80211_MGMT_CAPABILITY_ESS); if (priv->wep_is_on) @@ -2728,18 +2711,18 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc) body.capability |= cpu_to_le16(C80211_MGMT_CAPABILITY_ShortPreamble); body.listen_interval = cpu_to_le16(priv->listen_interval * priv->beacon_period); - + /* current AP address - only in reassoc frame */ if (is_reassoc) { - memcpy(body.ap, priv->CurrentBSSID, 6); + memcpy(body.ap, priv->CurrentBSSID, 6); ssid_el_p = (u8 *)&body.ssid_el_id; bodysize = 18 + priv->SSID_size; } else { ssid_el_p = (u8 *)&body.ap[0]; bodysize = 12 + priv->SSID_size; } - - ssid_el_p[0] = C80211_MGMT_ElementID_SSID; + + ssid_el_p[0]= C80211_MGMT_ElementID_SSID; ssid_el_p[1] = priv->SSID_size; memcpy(ssid_el_p + 2, priv->SSID, priv->SSID_size); ssid_el_p[2 + priv->SSID_size] = C80211_MGMT_ElementID_SupportedRates; @@ -2749,8 +2732,7 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc) atmel_transmit_management_frame(priv, &header, (void *)&body, bodysize); } -static int is_frame_from_current_bss(struct atmel_private *priv, - struct ieee80211_hdr_4addr *header) +static int is_frame_from_current_bss(struct atmel_private *priv, struct ieee80211_hdr_4addr *header) { if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) return memcmp(header->addr3, priv->CurrentBSSID, 6) == 0; @@ -2763,29 +2745,29 @@ static int retrieve_bss(struct atmel_private *priv) int i; int max_rssi = -128; int max_index = -1; - + if (priv->BSS_list_entries == 0) return -1; - + if (priv->connect_to_any_BSS) { - /* Select a BSS with the max-RSSI but of the same type and of - the same WEP mode and that it is not marked as 'bad' (i.e. - we had previously failed to connect to this BSS with the - settings that we currently use) */ + /* Select a BSS with the max-RSSI but of the same type and of the same WEP mode + and that it is not marked as 'bad' (i.e. we had previously failed to connect to + this BSS with the settings that we currently use) */ priv->current_BSS = 0; - for (i = 0; i < priv->BSS_list_entries; i++) { + for(i=0; iBSS_list_entries; i++) { if (priv->operating_mode == priv->BSSinfo[i].BSStype && - ((!priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) || + ((!priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) || (priv->wep_is_on && priv->BSSinfo[i].UsingWEP)) && !(priv->BSSinfo[i].channel & 0x80)) { max_rssi = priv->BSSinfo[i].RSSI; priv->current_BSS = max_index = i; } + } return max_index; } - - for (i = 0; i < priv->BSS_list_entries; i++) { + + for(i=0; iBSS_list_entries; i++) { if (priv->SSID_size == priv->BSSinfo[i].SSIDsize && memcmp(priv->SSID, priv->BSSinfo[i].SSID, priv->SSID_size) == 0 && priv->operating_mode == priv->BSSinfo[i].BSStype && @@ -2799,19 +2781,19 @@ static int retrieve_bss(struct atmel_private *priv) return max_index; } -static void store_bss_info(struct atmel_private *priv, - struct ieee80211_hdr_4addr *header, u16 capability, - u16 beacon_period, u8 channel, u8 rssi, u8 ssid_len, - u8 *ssid, int is_beacon) + +static void store_bss_info(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, + u16 capability, u16 beacon_period, u8 channel, u8 rssi, + u8 ssid_len, u8 *ssid, int is_beacon) { u8 *bss = capability & C80211_MGMT_CAPABILITY_ESS ? header->addr2 : header->addr3; int i, index; - - for (index = -1, i = 0; i < priv->BSS_list_entries; i++) - if (memcmp(bss, priv->BSSinfo[i].BSSID, 6) == 0) + + for (index = -1, i = 0; i < priv->BSS_list_entries; i++) + if (memcmp(bss, priv->BSSinfo[i].BSSID, 6) == 0) index = i; - /* If we process a probe and an entry from this BSS exists + /* If we process a probe and an entry from this BSS exists we will update the BSS entry with the info from this BSS. If we process a beacon we will only update RSSI */ @@ -2838,8 +2820,8 @@ static void store_bss_info(struct atmel_private *priv, priv->BSSinfo[index].BSStype = IW_MODE_ADHOC; else if (capability & C80211_MGMT_CAPABILITY_ESS) priv->BSSinfo[index].BSStype =IW_MODE_INFRA; - - priv->BSSinfo[index].preamble = capability & C80211_MGMT_CAPABILITY_ShortPreamble ? + + priv->BSSinfo[index].preamble = capability & C80211_MGMT_CAPABILITY_ShortPreamble ? SHORT_PREAMBLE : LONG_PREAMBLE; } @@ -2849,8 +2831,8 @@ static void authenticate(struct atmel_private *priv, u16 frame_len) u16 status = le16_to_cpu(auth->status); u16 trans_seq_no = le16_to_cpu(auth->trans_seq); u16 system = le16_to_cpu(auth->alg); - - if (status == C80211_MGMT_SC_Success && !priv->wep_is_on) { + + if (status == C80211_MGMT_SC_Success && !priv->wep_is_on) { /* no WEP */ if (priv->station_was_associated) { atmel_enter_state(priv, STATION_STATE_REASSOCIATING); @@ -2860,20 +2842,20 @@ static void authenticate(struct atmel_private *priv, u16 frame_len) atmel_enter_state(priv, STATION_STATE_ASSOCIATING); send_association_request(priv, 0); return; - } + } } - - if (status == C80211_MGMT_SC_Success && priv->wep_is_on) { + + if (status == C80211_MGMT_SC_Success && priv->wep_is_on) { /* WEP */ if (trans_seq_no != priv->ExpectedAuthentTransactionSeqNum) return; - + if (trans_seq_no == 0x0002 && auth->el_id == C80211_MGMT_ElementID_ChallengeText) { send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len); return; } - + if (trans_seq_no == 0x0004) { if(priv->station_was_associated) { atmel_enter_state(priv, STATION_STATE_REASSOCIATING); @@ -2883,10 +2865,10 @@ static void authenticate(struct atmel_private *priv, u16 frame_len) atmel_enter_state(priv, STATION_STATE_ASSOCIATING); send_association_request(priv, 0); return; - } + } } - } - + } + if (status == C80211_MGMT_SC_AuthAlgNotSupported) { /* Do opensystem first, then try sharedkey */ if (system == C80211_MGMT_AAN_OPENSYSTEM) { @@ -2894,16 +2876,17 @@ static void authenticate(struct atmel_private *priv, u16 frame_len) send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0); } else if (priv->connect_to_any_BSS) { int bss_index; - + priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80; - + if ((bss_index = retrieve_bss(priv)) != -1) { atmel_join_bss(priv, bss_index); return; } } } - + + priv->AuthenticationRequestRetryCnt = 0; atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); priv->station_is_associated = 0; @@ -2919,44 +2902,38 @@ static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype) u8 length; u8 rates[4]; } *ass_resp = (struct ass_resp_format *)priv->rx_buf; - - u16 status = le16_to_cpu(ass_resp->status); + + u16 status = le16_to_cpu(ass_resp->status); u16 ass_id = le16_to_cpu(ass_resp->ass_id); - u16 rates_len = ass_resp->length > 4 ? 4 : ass_resp->length; - + u16 rates_len = ass_resp->length > 4 ? 4 : ass_resp->length; + if (frame_len < 8 + rates_len) return; - + if (status == C80211_MGMT_SC_Success) { if (subtype == C80211_SUBTYPE_MGMT_ASS_RESPONSE) priv->AssociationRequestRetryCnt = 0; else priv->ReAssociationRequestRetryCnt = 0; - - atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, - MAC_MGMT_MIB_STATION_ID_POS, ass_id & 0x3fff); - atmel_set_mib(priv, Phy_Mib_Type, - PHY_MIB_RATE_SET_POS, ass_resp->rates, rates_len); + + atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_STATION_ID_POS, ass_id & 0x3fff); + atmel_set_mib(priv, Phy_Mib_Type, PHY_MIB_RATE_SET_POS, ass_resp->rates, rates_len); if (priv->power_mode == 0) { priv->listen_interval = 1; - atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, - MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); - atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, - MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); + atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); + atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); } else { priv->listen_interval = 2; - atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, - MAC_MGMT_MIB_PS_MODE_POS, PS_MODE); - atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, - MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 2); + atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, PS_MODE); + atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 2); } - + priv->station_is_associated = 1; priv->station_was_associated = 1; atmel_enter_state(priv, STATION_STATE_READY); return; } - + if (subtype == C80211_SUBTYPE_MGMT_ASS_RESPONSE && status != C80211_MGMT_SC_AssDeniedBSSRate && status != C80211_MGMT_SC_SupportCapabilities && @@ -2966,7 +2943,7 @@ static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype) send_association_request(priv, 0); return; } - + if (subtype == C80211_SUBTYPE_MGMT_REASS_RESPONSE && status != C80211_MGMT_SC_AssDeniedBSSRate && status != C80211_MGMT_SC_SupportCapabilities && @@ -2976,16 +2953,17 @@ static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype) send_association_request(priv, 1); return; } - + atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); priv->station_is_associated = 0; - - if (priv->connect_to_any_BSS) { + + if(priv->connect_to_any_BSS) { int bss_index; priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80; - - if ((bss_index = retrieve_bss(priv)) != -1) + + if ((bss_index = retrieve_bss(priv)) != -1) atmel_join_bss(priv, bss_index); + } } @@ -2999,7 +2977,7 @@ void atmel_join_bss(struct atmel_private *priv, int bss_index) /* The WPA stuff cares about the current AP address */ if (priv->use_wpa) build_wpa_mib(priv); - + /* When switching to AdHoc turn OFF Power Save if needed */ if (bss->BSStype == IW_MODE_ADHOC && @@ -3007,28 +2985,25 @@ void atmel_join_bss(struct atmel_private *priv, int bss_index) priv->power_mode) { priv->power_mode = 0; priv->listen_interval = 1; - atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, - MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); - atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, - MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); + atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); + atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); } - + priv->operating_mode = bss->BSStype; - priv->channel = bss->channel & 0x7f; + priv->channel = bss->channel & 0x7f; priv->beacon_period = bss->beacon_period; - + if (priv->preamble != bss->preamble) { priv->preamble = bss->preamble; - atmel_set_mib8(priv, Local_Mib_Type, - LOCAL_MIB_PREAMBLE_TYPE, bss->preamble); + atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, bss->preamble); } - + if (!priv->wep_is_on && bss->UsingWEP) { atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); priv->station_is_associated = 0; return; } - + if (priv->wep_is_on && !bss->UsingWEP) { atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); priv->station_is_associated = 0; @@ -3036,28 +3011,30 @@ void atmel_join_bss(struct atmel_private *priv, int bss_index) } atmel_enter_state(priv, STATION_STATE_JOINNING); - + if (priv->operating_mode == IW_MODE_INFRA) join(priv, BSS_TYPE_INFRASTRUCTURE); - else + else join(priv, BSS_TYPE_AD_HOC); } + static void restart_search(struct atmel_private *priv) { int bss_index; - + if (!priv->connect_to_any_BSS) { atmel_scan(priv, 1); } else { priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80; - - if ((bss_index = retrieve_bss(priv)) != -1) + + if ((bss_index = retrieve_bss(priv)) != -1) atmel_join_bss(priv, bss_index); else atmel_scan(priv, 0); - } -} + + } +} static void smooth_rssi(struct atmel_private *priv, u8 rssi) { @@ -3073,21 +3050,21 @@ static void smooth_rssi(struct atmel_private *priv, u8 rssi) } rssi = rssi * 100 / max_rssi; - if ((rssi + old) % 2) - priv->wstats.qual.level = (rssi + old) / 2 + 1; + if((rssi + old) % 2) + priv->wstats.qual.level = ((rssi + old)/2) + 1; else - priv->wstats.qual.level = (rssi + old) / 2; + priv->wstats.qual.level = ((rssi + old)/2); priv->wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED; priv->wstats.qual.updated &= ~IW_QUAL_LEVEL_INVALID; } static void atmel_smooth_qual(struct atmel_private *priv) { - unsigned long time_diff = (jiffies - priv->last_qual) / HZ; + unsigned long time_diff = (jiffies - priv->last_qual)/HZ; while (time_diff--) { priv->last_qual += HZ; - priv->wstats.qual.qual = priv->wstats.qual.qual / 2; - priv->wstats.qual.qual += + priv->wstats.qual.qual = priv->wstats.qual.qual/2; + priv->wstats.qual.qual += priv->beacons_this_sec * priv->beacon_period * (priv->wstats.qual.level + 100) / 4000; priv->beacons_this_sec = 0; } @@ -3096,17 +3073,15 @@ static void atmel_smooth_qual(struct atmel_private *priv) } /* deals with incoming managment frames. */ -static void atmel_management_frame(struct atmel_private *priv, - struct ieee80211_hdr_4addr *header, - u16 frame_len, u8 rssi) +static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, + u16 frame_len, u8 rssi) { u16 subtype; - - subtype = le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_STYPE; - switch (subtype) { - case C80211_SUBTYPE_MGMT_BEACON: + + switch (subtype = le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_STYPE) { + case C80211_SUBTYPE_MGMT_BEACON : case C80211_SUBTYPE_MGMT_ProbeResponse: - + /* beacon frame has multiple variable-length fields - never let an engineer loose with a data structure design. */ { @@ -3124,7 +3099,7 @@ static void atmel_management_frame(struct atmel_private *priv, u8 ds_length; /* ds here */ } *beacon = (struct beacon_format *)priv->rx_buf; - + u8 channel, rates_length, ssid_length; u64 timestamp = le64_to_cpu(beacon->timestamp); u16 beacon_interval = le16_to_cpu(beacon->interval); @@ -3132,7 +3107,7 @@ static void atmel_management_frame(struct atmel_private *priv, u8 *beaconp = priv->rx_buf; ssid_length = beacon->ssid_length; /* this blows chunks. */ - if (frame_len < 14 || frame_len < ssid_length + 15) + if (frame_len < 14 || frame_len < ssid_length + 15) return; rates_length = beaconp[beacon->ssid_length + 15]; if (frame_len < ssid_length + rates_length + 18) @@ -3140,10 +3115,10 @@ static void atmel_management_frame(struct atmel_private *priv, if (ssid_length > MAX_SSID_LENGTH) return; channel = beaconp[ssid_length + rates_length + 18]; - + if (priv->station_state == STATION_STATE_READY) { smooth_rssi(priv, rssi); - if (is_frame_from_current_bss(priv, header)) { + if (is_frame_from_current_bss(priv, header)) { priv->beacons_this_sec++; atmel_smooth_qual(priv); if (priv->last_beacon_timestamp) { @@ -3157,43 +3132,41 @@ static void atmel_management_frame(struct atmel_private *priv, handle_beacon_probe(priv, capability, channel); } } - - if (priv->station_state == STATION_STATE_SCANNING) - store_bss_info(priv, header, capability, - beacon_interval, channel, rssi, - ssid_length, - &beacon->rates_el_id, - subtype == C80211_SUBTYPE_MGMT_BEACON); + + if (priv->station_state == STATION_STATE_SCANNING ) + store_bss_info(priv, header, capability, beacon_interval, channel, + rssi, ssid_length, &beacon->rates_el_id, + subtype == C80211_SUBTYPE_MGMT_BEACON) ; } break; - + case C80211_SUBTYPE_MGMT_Authentication: if (priv->station_state == STATION_STATE_AUTHENTICATING) authenticate(priv, frame_len); - + break; - + case C80211_SUBTYPE_MGMT_ASS_RESPONSE: case C80211_SUBTYPE_MGMT_REASS_RESPONSE: - - if (priv->station_state == STATION_STATE_ASSOCIATING || + + if (priv->station_state == STATION_STATE_ASSOCIATING || priv->station_state == STATION_STATE_REASSOCIATING) associate(priv, frame_len, subtype); - + break; case C80211_SUBTYPE_MGMT_DISASSOSIATION: - if (priv->station_is_associated && - priv->operating_mode == IW_MODE_INFRA && + if (priv->station_is_associated && + priv->operating_mode == IW_MODE_INFRA && is_frame_from_current_bss(priv, header)) { priv->station_was_associated = 0; priv->station_is_associated = 0; - + atmel_enter_state(priv, STATION_STATE_JOINNING); join(priv, BSS_TYPE_INFRASTRUCTURE); } - + break; case C80211_SUBTYPE_MGMT_Deauthentication: @@ -3204,7 +3177,7 @@ static void atmel_management_frame(struct atmel_private *priv, atmel_enter_state(priv, STATION_STATE_JOINNING); join(priv, BSS_TYPE_INFRASTRUCTURE); } - + break; } } @@ -3212,73 +3185,76 @@ static void atmel_management_frame(struct atmel_private *priv, /* run when timer expires */ static void atmel_management_timer(u_long a) { - struct net_device *dev = (struct net_device *) a; - struct atmel_private *priv = netdev_priv(dev); - unsigned long flags; - - /* Check if the card has been yanked. */ - if (priv->card && priv->present_callback && - !(*priv->present_callback)(priv->card)) - return; - - spin_lock_irqsave(&priv->irqlock, flags); - - switch (priv->station_state) { - - case STATION_STATE_AUTHENTICATING: - if (priv->AuthenticationRequestRetryCnt >= MAX_AUTHENTICATION_RETRIES) { - atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); - priv->station_is_associated = 0; - priv->AuthenticationRequestRetryCnt = 0; - restart_search(priv); - } else { - priv->AuthenticationRequestRetryCnt++; - priv->CurrentAuthentTransactionSeqNum = 0x0001; - mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); - send_authentication_request(priv, C80211_MGMT_AAN_OPENSYSTEM, NULL, 0); + struct net_device *dev = (struct net_device *) a; + struct atmel_private *priv = netdev_priv(dev); + unsigned long flags; + + /* Check if the card has been yanked. */ + if (priv->card && priv->present_callback && + !(*priv->present_callback)(priv->card)) + return; + + spin_lock_irqsave(&priv->irqlock, flags); + + switch (priv->station_state) { + + case STATION_STATE_AUTHENTICATING: + if (priv->AuthenticationRequestRetryCnt >= MAX_AUTHENTICATION_RETRIES) { + atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); + priv->station_is_associated = 0; + priv->AuthenticationRequestRetryCnt = 0; + restart_search(priv); + } else { + priv->AuthenticationRequestRetryCnt++; + priv->CurrentAuthentTransactionSeqNum = 0x0001; + mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); + send_authentication_request(priv, C80211_MGMT_AAN_OPENSYSTEM, NULL, 0); } + break; - case STATION_STATE_ASSOCIATING: - if (priv->AssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) { - atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); - priv->station_is_associated = 0; - priv->AssociationRequestRetryCnt = 0; - restart_search(priv); - } else { - priv->AssociationRequestRetryCnt++; - mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); - send_association_request(priv, 0); - } - break; - - case STATION_STATE_REASSOCIATING: - if (priv->ReAssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) { - atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); - priv->station_is_associated = 0; - priv->ReAssociationRequestRetryCnt = 0; - restart_search(priv); - } else { - priv->ReAssociationRequestRetryCnt++; - mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); - send_association_request(priv, 1); - } - break; + case STATION_STATE_ASSOCIATING: + if (priv->AssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) { + atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); + priv->station_is_associated = 0; + priv->AssociationRequestRetryCnt = 0; + restart_search(priv); + } else { + priv->AssociationRequestRetryCnt++; + mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); + send_association_request(priv, 0); + } - default: - break; - } + break; + + case STATION_STATE_REASSOCIATING: + if (priv->ReAssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) { + atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); + priv->station_is_associated = 0; + priv->ReAssociationRequestRetryCnt = 0; + restart_search(priv); + } else { + priv->ReAssociationRequestRetryCnt++; + mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); + send_association_request(priv, 1); + } - spin_unlock_irqrestore(&priv->irqlock, flags); + break; + + default: + break; + } + + spin_unlock_irqrestore(&priv->irqlock, flags); } - + static void atmel_command_irq(struct atmel_private *priv) { u8 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET)); u8 command = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET)); int fast_scan; - - if (status == CMD_STATUS_IDLE || + + if (status == CMD_STATUS_IDLE || status == CMD_STATUS_IN_PROGRESS) return; @@ -3290,20 +3266,20 @@ static void atmel_command_irq(struct atmel_private *priv) atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS, (u8 *)priv->CurrentBSSID, 6); atmel_enter_state(priv, STATION_STATE_READY); - } + } break; - + case CMD_Scan: fast_scan = priv->fast_scan; priv->fast_scan = 0; - + if (status != CMD_STATUS_COMPLETE) { atmel_scan(priv, 1); } else { int bss_index = retrieve_bss(priv); if (bss_index != -1) { atmel_join_bss(priv, bss_index); - } else if (priv->operating_mode == IW_MODE_ADHOC && + } else if (priv->operating_mode == IW_MODE_ADHOC && priv->SSID_size != 0) { start(priv, BSS_TYPE_AD_HOC); } else { @@ -3313,16 +3289,16 @@ static void atmel_command_irq(struct atmel_private *priv) priv->site_survey_state = SITE_SURVEY_COMPLETED; } break; - + case CMD_SiteSurvey: priv->fast_scan = 0; - + if (status != CMD_STATUS_COMPLETE) return; - + priv->site_survey_state = SITE_SURVEY_COMPLETED; if (priv->station_is_associated) { - atmel_enter_state(priv, STATION_STATE_READY); + atmel_enter_state(priv, STATION_STATE_READY); } else { atmel_scan(priv, 1); } @@ -3336,15 +3312,16 @@ static void atmel_command_irq(struct atmel_private *priv) } else { priv->AuthenticationRequestRetryCnt = 0; atmel_enter_state(priv, STATION_STATE_AUTHENTICATING); - + mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); priv->CurrentAuthentTransactionSeqNum = 0x0001; send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0); } return; } - + atmel_scan(priv, 1); + } } @@ -3356,20 +3333,20 @@ static int atmel_wakeup_firmware(struct atmel_private *priv) if (priv->card_type == CARD_TYPE_SPI_FLASH) atmel_set_gcr(priv->dev, GCR_REMAP); - + /* wake up on-board processor */ atmel_clear_gcr(priv->dev, 0x0040); atmel_write16(priv->dev, BSR, BSS_SRAM); - + if (priv->card_type == CARD_TYPE_SPI_FLASH) mdelay(100); /* and wait for it */ - for (i = LOOP_RETRY_LIMIT; i; i--) { + for (i = LOOP_RETRY_LIMIT; i; i--) { mr1 = atmel_read16(priv->dev, MR1); mr3 = atmel_read16(priv->dev, MR3); - - if (mr3 & MAC_BOOT_COMPLETE) + + if (mr3 & MAC_BOOT_COMPLETE) break; if (mr1 & MAC_BOOT_COMPLETE && priv->bus_type == BUS_TYPE_PCCARD) @@ -3380,36 +3357,35 @@ static int atmel_wakeup_firmware(struct atmel_private *priv) printk(KERN_ALERT "%s: MAC failed to boot.\n", priv->dev->name); return 0; } - + if ((priv->host_info_base = atmel_read16(priv->dev, MR2)) == 0xffff) { printk(KERN_ALERT "%s: card missing.\n", priv->dev->name); return 0; } - - /* now check for completion of MAC initialization through - the FunCtrl field of the IFACE, poll MR1 to detect completion of - MAC initialization, check completion status, set interrupt mask, - enables interrupts and calls Tx and Rx initialization functions */ - + + /* now check for completion of MAC initialization through + the FunCtrl field of the IFACE, poll MR1 to detect completion of + MAC initialization, check completion status, set interrupt mask, + enables interrupts and calls Tx and Rx initialization functions */ + atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), FUNC_CTRL_INIT_COMPLETE); - - for (i = LOOP_RETRY_LIMIT; i; i--) { + + for (i = LOOP_RETRY_LIMIT; i; i--) { mr1 = atmel_read16(priv->dev, MR1); mr3 = atmel_read16(priv->dev, MR3); - - if (mr3 & MAC_INIT_COMPLETE) + + if (mr3 & MAC_INIT_COMPLETE) break; if (mr1 & MAC_INIT_COMPLETE && priv->bus_type == BUS_TYPE_PCCARD) break; } - + if (i == 0) { - printk(KERN_ALERT "%s: MAC failed to initialise.\n", - priv->dev->name); + printk(KERN_ALERT "%s: MAC failed to initialise.\n", priv->dev->name); return 0; } - + /* Check for MAC_INIT_OK only on the register that the MAC_INIT_OK was set */ if ((mr3 & MAC_INIT_COMPLETE) && !(atmel_read16(priv->dev, MR3) & MAC_INIT_OK)) { @@ -3422,9 +3398,9 @@ static int atmel_wakeup_firmware(struct atmel_private *priv) return 0; } - atmel_copy_to_host(priv->dev, (unsigned char *)iface, + atmel_copy_to_host(priv->dev, (unsigned char *)iface, priv->host_info_base, sizeof(*iface)); - + iface->tx_buff_pos = le16_to_cpu(iface->tx_buff_pos); iface->tx_buff_size = le16_to_cpu(iface->tx_buff_size); iface->tx_desc_pos = le16_to_cpu(iface->tx_desc_pos); @@ -3448,16 +3424,16 @@ static int probe_atmel_card(struct net_device *dev) { int rc = 0; struct atmel_private *priv = netdev_priv(dev); - + /* reset pccard */ - if (priv->bus_type == BUS_TYPE_PCCARD) + if (priv->bus_type == BUS_TYPE_PCCARD) atmel_write16(dev, GCR, 0x0060); - + atmel_write16(dev, GCR, 0x0040); mdelay(500); - + if (atmel_read16(dev, MR2) == 0) { - /* No stored firmware so load a small stub which just + /* No stored firmware so load a small stub which just tells us the MAC address */ int i; priv->card_type = CARD_TYPE_EEPROM; @@ -3466,7 +3442,7 @@ static int probe_atmel_card(struct net_device *dev) atmel_set_gcr(dev, GCR_REMAP); atmel_clear_gcr(priv->dev, 0x0040); atmel_write16(dev, BSR, BSS_SRAM); - for (i = LOOP_RETRY_LIMIT; i; i--) + for (i = LOOP_RETRY_LIMIT; i; i--) if (atmel_read16(dev, MR3) & MAC_BOOT_COMPLETE) break; if (i == 0) { @@ -3475,7 +3451,7 @@ static int probe_atmel_card(struct net_device *dev) atmel_copy_to_host(dev, dev->dev_addr, atmel_read16(dev, MR2), 6); /* got address, now squash it again until the network interface is opened */ - if (priv->bus_type == BUS_TYPE_PCCARD) + if (priv->bus_type == BUS_TYPE_PCCARD) atmel_write16(dev, GCR, 0x0060); atmel_write16(dev, GCR, 0x0040); rc = 1; @@ -3483,7 +3459,7 @@ static int probe_atmel_card(struct net_device *dev) } else if (atmel_read16(dev, MR4) == 0) { /* Mac address easy in this case. */ priv->card_type = CARD_TYPE_PARALLEL_FLASH; - atmel_write16(dev, BSR, 1); + atmel_write16(dev, BSR, 1); atmel_copy_to_host(dev, dev->dev_addr, 0xc000, 6); atmel_write16(dev, BSR, 0x200); rc = 1; @@ -3493,16 +3469,16 @@ static int probe_atmel_card(struct net_device *dev) priv->card_type = CARD_TYPE_SPI_FLASH; if (atmel_wakeup_firmware(priv)) { atmel_get_mib(priv, Mac_Address_Mib_Type, 0, dev->dev_addr, 6); - + /* got address, now squash it again until the network interface is opened */ - if (priv->bus_type == BUS_TYPE_PCCARD) + if (priv->bus_type == BUS_TYPE_PCCARD) atmel_write16(dev, GCR, 0x0060); atmel_write16(dev, GCR, 0x0040); rc = 1; } } - + if (rc) { if (dev->dev_addr[0] == 0xFF) { u8 default_mac[] = {0x00,0x04, 0x25, 0x00, 0x00, 0x00}; @@ -3510,27 +3486,27 @@ static int probe_atmel_card(struct net_device *dev) memcpy(dev->dev_addr, default_mac, 6); } } - + return rc; } +static void build_wep_mib(struct atmel_private *priv) /* Move the encyption information on the MIB structure. This routine is for the pre-WPA firmware: later firmware has a different format MIB and a different routine. */ -static void build_wep_mib(struct atmel_private *priv) { struct { /* NB this is matched to the hardware, don't change. */ - u8 wep_is_on; + u8 wep_is_on; u8 default_key; /* 0..3 */ u8 reserved; u8 exclude_unencrypted; - + u32 WEPICV_error_count; u32 WEP_excluded_count; - + u8 wep_keys[MAX_ENCRYPTION_KEYS][13]; - u8 encryption_level; /* 0, 1, 2 */ - u8 reserved2[3]; + u8 encryption_level; /* 0, 1, 2 */ + u8 reserved2[3]; } mib; int i; @@ -3539,55 +3515,54 @@ static void build_wep_mib(struct atmel_private *priv) if (priv->wep_key_len[priv->default_key] > 5) mib.encryption_level = 2; else - mib.encryption_level = 1; + mib.encryption_level = 1; } else { mib.encryption_level = 0; } mib.default_key = priv->default_key; mib.exclude_unencrypted = priv->exclude_unencrypted; - - for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) + + for(i = 0; i < MAX_ENCRYPTION_KEYS; i++) memcpy(mib.wep_keys[i], priv->wep_keys[i], 13); - + atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib)); } static void build_wpa_mib(struct atmel_private *priv) { - /* This is for the later (WPA enabled) firmware. */ + /* This is for the later (WPA enabled) firmware. */ struct { /* NB this is matched to the hardware, don't change. */ u8 cipher_default_key_value[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE]; u8 receiver_address[6]; - u8 wep_is_on; + u8 wep_is_on; u8 default_key; /* 0..3 */ u8 group_key; u8 exclude_unencrypted; u8 encryption_type; u8 reserved; - + u32 WEPICV_error_count; u32 WEP_excluded_count; - + u8 key_RSC[4][8]; } mib; - + int i; mib.wep_is_on = priv->wep_is_on; mib.exclude_unencrypted = priv->exclude_unencrypted; memcpy(mib.receiver_address, priv->CurrentBSSID, 6); - + /* zero all the keys before adding in valid ones. */ memset(mib.cipher_default_key_value, 0, sizeof(mib.cipher_default_key_value)); - + if (priv->wep_is_on) { - /* There's a comment in the Atmel code to the effect that this - is only valid when still using WEP, it may need to be set to - something to use WPA */ + /* There's a comment in the Atmel code to the effect that this is only valid + when still using WEP, it may need to be set to something to use WPA */ memset(mib.key_RSC, 0, sizeof(mib.key_RSC)); - + mib.default_key = mib.group_key = 255; for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) { if (priv->wep_key_len[i] > 0) { @@ -3595,12 +3570,12 @@ static void build_wpa_mib(struct atmel_private *priv) if (i == priv->default_key) { mib.default_key = i; mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 7; - mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->pairwise_cipher_suite; + mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->pairwise_cipher_suite; } else { mib.group_key = i; priv->group_cipher_suite = priv->pairwise_cipher_suite; mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1; - mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite; + mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite; } } } @@ -3608,47 +3583,47 @@ static void build_wpa_mib(struct atmel_private *priv) mib.default_key = mib.group_key != 255 ? mib.group_key : 0; if (mib.group_key == 255) mib.group_key = mib.default_key; - + } - + atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib)); } - -static int reset_atmel_card(struct net_device *dev) + +static int reset_atmel_card(struct net_device *dev) { /* do everything necessary to wake up the hardware, including waiting for the lightning strike and throwing the knife switch.... - set all the Mib values which matter in the card to match + set all the Mib values which matter in the card to match their settings in the atmel_private structure. Some of these can be altered on the fly, but many (WEP, infrastucture or ad-hoc) can only be changed by tearing down the world and coming back through here. - This routine is also responsible for initialising some - hardware-specific fields in the atmel_private structure, + This routine is also responsible for initialising some + hardware-specific fields in the atmel_private structure, including a copy of the firmware's hostinfo stucture which is the route into the rest of the firmare datastructures. */ struct atmel_private *priv = netdev_priv(dev); u8 configuration; - + /* data to add to the firmware names, in priority order this implemenents firmware versioning */ - + static char *firmware_modifier[] = { "-wpa", "", NULL }; - + /* reset pccard */ - if (priv->bus_type == BUS_TYPE_PCCARD) + if (priv->bus_type == BUS_TYPE_PCCARD) atmel_write16(priv->dev, GCR, 0x0060); - + /* stop card , disable interrupts */ atmel_write16(priv->dev, GCR, 0x0040); - + if (priv->card_type == CARD_TYPE_EEPROM) { /* copy in firmware if needed */ const struct firmware *fw_entry = NULL; @@ -3661,13 +3636,13 @@ static int reset_atmel_card(struct net_device *dev) "%s: card type is unknown: assuming at76c502 firmware is OK.\n", dev->name); printk(KERN_INFO - "%s: if not, use the firmware= module parameter.\n", + "%s: if not, use the firmware= module parameter.\n", dev->name); strcpy(priv->firmware_id, "atmel_at76c502.bin"); } if (request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev) != 0) { - printk(KERN_ALERT - "%s: firmware %s is missing, cannot continue.\n", + printk(KERN_ALERT + "%s: firmware %s is missing, cannot continue.\n", dev->name, priv->firmware_id); return 0; } @@ -3679,7 +3654,7 @@ static int reset_atmel_card(struct net_device *dev) while (fw_table[fw_index].fw_type != priv->firmware_type && fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) fw_index++; - + /* construct the actual firmware file name */ if (fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) { int i; @@ -3694,24 +3669,24 @@ static int reset_atmel_card(struct net_device *dev) } } if (!success) { - printk(KERN_ALERT - "%s: firmware %s is missing, cannot start.\n", + printk(KERN_ALERT + "%s: firmware %s is missing, cannot start.\n", dev->name, priv->firmware_id); priv->firmware_id[0] = '\0'; - return 0; + return 0; } } - + fw = fw_entry->data; len = fw_entry->size; } - + if (len <= 0x6000) { atmel_write16(priv->dev, BSR, BSS_IRAM); atmel_copy_to_card(priv->dev, 0, fw, len); atmel_set_gcr(priv->dev, GCR_REMAP); } else { - /* Remap */ + /* Remap */ atmel_set_gcr(priv->dev, GCR_REMAP); atmel_write16(priv->dev, BSR, BSS_IRAM); atmel_copy_to_card(priv->dev, 0, fw, 0x6000); @@ -3733,45 +3708,45 @@ static int reset_atmel_card(struct net_device *dev) the 3com broken-ness filter. */ priv->use_wpa = (priv->host_info.major_version == 4); priv->radio_on_broken = (priv->host_info.major_version == 5); - + /* unmask all irq sources */ atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_MASK_OFFSET), 0xff); - + /* int Tx system and enable Tx */ atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, 0), 0); atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, 0), 0x80000000L); atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, 0), 0); atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, 0), 0); - priv->tx_desc_free = priv->host_info.tx_desc_count; - priv->tx_desc_head = 0; - priv->tx_desc_tail = 0; + priv->tx_desc_free = priv->host_info.tx_desc_count; + priv->tx_desc_head = 0; + priv->tx_desc_tail = 0; priv->tx_desc_previous = 0; priv->tx_free_mem = priv->host_info.tx_buff_size; - priv->tx_buff_head = 0; - priv->tx_buff_tail = 0; - - configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET)); - atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), + priv->tx_buff_head = 0; + priv->tx_buff_tail = 0; + + configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET)); + atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), configuration | FUNC_CTRL_TxENABLE); /* init Rx system and enable */ priv->rx_desc_head = 0; - - configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET)); - atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), + + configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET)); + atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), configuration | FUNC_CTRL_RxENABLE); - + if (!priv->radio_on_broken) { - if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) == + if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) == CMD_STATUS_REJECTED_RADIO_OFF) { - printk(KERN_INFO + printk(KERN_INFO "%s: cannot turn the radio on. (Hey radio, you're beautiful!)\n", dev->name); return 0; } } - + /* set up enough MIB values to run. */ atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_AUTO_TX_RATE_POS, priv->auto_tx_rate); atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_TX_PROMISCUOUS_POS, PROM_MODE_OFF); @@ -3780,7 +3755,7 @@ static int reset_atmel_card(struct net_device *dev) atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_SHORT_RETRY_POS, priv->short_retry); atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_LONG_RETRY_POS, priv->long_retry); atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, priv->preamble); - atmel_set_mib(priv, Mac_Address_Mib_Type, MAC_ADDR_MIB_MAC_ADDR_POS, + atmel_set_mib(priv, Mac_Address_Mib_Type, MAC_ADDR_MIB_MAC_ADDR_POS, priv->dev->dev_addr, 6); atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); @@ -3791,44 +3766,42 @@ static int reset_atmel_card(struct net_device *dev) build_wpa_mib(priv); else build_wep_mib(priv); - + return 1; } -static void atmel_send_command(struct atmel_private *priv, int command, - void *cmd, int cmd_size) +static void atmel_send_command(struct atmel_private *priv, int command, void *cmd, int cmd_size) { if (cmd) - atmel_copy_to_card(priv->dev, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET), + atmel_copy_to_card(priv->dev, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET), cmd, cmd_size); - + atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET), command); atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET), 0); } - -static int atmel_send_command_wait(struct atmel_private *priv, int command, - void *cmd, int cmd_size) + +static int atmel_send_command_wait(struct atmel_private *priv, int command, void *cmd, int cmd_size) { int i, status; - + atmel_send_command(priv, command, cmd, cmd_size); - + for (i = 5000; i; i--) { status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET)); - if (status != CMD_STATUS_IDLE && + if (status != CMD_STATUS_IDLE && status != CMD_STATUS_IN_PROGRESS) break; udelay(20); } - + if (i == 0) { printk(KERN_ALERT "%s: failed to contact MAC.\n", priv->dev->name); status = CMD_STATUS_HOST_ERROR; - } else { + } else { if (command != CMD_EnableRadio) status = CMD_STATUS_COMPLETE; } - + return status; } @@ -3854,8 +3827,7 @@ static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, u8 dat atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 1); } -static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, - u16 data) +static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, u16 data) { struct get_set_mib m; m.type = type; @@ -3867,8 +3839,7 @@ static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 2); } -static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, - u8 *data, int data_len) +static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len) { struct get_set_mib m; m.type = type; @@ -3877,24 +3848,23 @@ static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, if (data_len > MIB_MAX_DATA_BYTES) printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name); - + memcpy(m.data, data, data_len); atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + data_len); } -static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index, - u8 *data, int data_len) +static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len) { struct get_set_mib m; m.type = type; m.size = data_len; m.index = index; - + if (data_len > MIB_MAX_DATA_BYTES) printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name); - + atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + data_len); - atmel_copy_to_host(priv->dev, data, + atmel_copy_to_host(priv->dev, data, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE), data_len); } @@ -3903,12 +3873,11 @@ static void atmel_writeAR(struct net_device *dev, u16 data) int i; outw(data, dev->base_addr + AR); /* Address register appears to need some convincing..... */ - for (i = 0; data != inw(dev->base_addr + AR) && i < 10; i++) + for (i = 0; data != inw(dev->base_addr + AR) && i<10; i++) outw(data, dev->base_addr + AR); } -static void atmel_copy_to_card(struct net_device *dev, u16 dest, - unsigned char *src, u16 len) +static void atmel_copy_to_card(struct net_device *dev, u16 dest, unsigned char *src, u16 len) { int i; atmel_writeAR(dev, dest); @@ -3925,8 +3894,7 @@ static void atmel_copy_to_card(struct net_device *dev, u16 dest, atmel_write8(dev, DR, *src); } -static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest, - u16 src, u16 len) +static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest, u16 src, u16 len) { int i; atmel_writeAR(dev, src); @@ -3962,24 +3930,22 @@ static int atmel_lock_mac(struct atmel_private *priv) break; udelay(20); } - - if (!i) - return 0; /* timed out */ - + + if (!i) return 0; /* timed out */ + atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 1); if (atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET))) { atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0); - if (!j--) - return 0; /* timed out */ + if (!j--) return 0; /* timed out */ goto retry; } - + return 1; } static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data) { - atmel_writeAR(priv->dev, pos); + atmel_writeAR(priv->dev, pos); atmel_write16(priv->dev, DR, data); /* card is little-endian */ atmel_write16(priv->dev, DR, data >> 16); } @@ -4051,9 +4017,9 @@ static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data) serial output, since SO is normally high. But it does cause 8 clock cycles and thus 8 bits to be clocked in to the chip. See Atmel's SPI - controller (e.g. AT91M55800) timing and 4K + controller (e.g. AT91M55800) timing and 4K SPI EEPROM manuals */ - + .set NVRAM_SCRATCH, 0x02000100 /* arbitrary area for scratchpad memory */ .set NVRAM_IMAGE, 0x02000200 .set NVRAM_LENGTH, 0x0200 @@ -4066,24 +4032,24 @@ static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data) .set MR4, 0xC RESET_VECTOR: b RESET_HANDLER -UNDEF_VECTOR: +UNDEF_VECTOR: b HALT1 -SWI_VECTOR: +SWI_VECTOR: b HALT1 -IABORT_VECTOR: +IABORT_VECTOR: b HALT1 -DABORT_VECTOR: -RESERVED_VECTOR: +DABORT_VECTOR: +RESERVED_VECTOR: b HALT1 -IRQ_VECTOR: +IRQ_VECTOR: b HALT1 -FIQ_VECTOR: +FIQ_VECTOR: b HALT1 HALT1: b HALT1 RESET_HANDLER: mov r0, #CPSR_INITIAL msr CPSR_c, r0 /* This is probably unnecessary */ - + /* I'm guessing this is initializing clock generator electronics for SPI */ ldr r0, =SPI_CGEN_BASE mov r1, #0 @@ -4095,7 +4061,7 @@ HALT1: b HALT1 str r1, [r0, #28] mov r1, #1 str r1, [r0, #8] - + ldr r0, =MRBASE mov r1, #0 strh r1, [r0, #MR1] @@ -4128,7 +4094,7 @@ HALT2: b HALT2 ldmia sp!, {lr} bx lr .endfunc - + .func Get_MAC_Addr, GET_MAC_ADDR GET_MAC_ADDR: stmdb sp!, {lr} @@ -4144,13 +4110,13 @@ HALT2: b HALT2 .func Delay9, DELAY9 DELAY9: adds r0, r0, r0, LSL #3 /* r0 = r0 * 9 */ -DELAYLOOP: +DELAYLOOP: beq DELAY9_done subs r0, r0, #1 b DELAYLOOP -DELAY9_done: +DELAY9_done: bx lr -.endfunc +.endfunc .func SP_Init, SP_INIT SP_INIT: @@ -4179,26 +4145,26 @@ HALT2: b HALT2 ldr r0, [r0, #SP_RDR] bx lr .endfunc -.func NVRAM_Init, NVRAM_INIT +.func NVRAM_Init, NVRAM_INIT NVRAM_INIT: ldr r1, =SP_BASE ldr r0, [r1, #SP_RDR] mov r0, #NVRAM_CMD_RDSR str r0, [r1, #SP_TDR] -SP_loop1: +SP_loop1: ldr r0, [r1, #SP_SR] tst r0, #SP_TDRE beq SP_loop1 mov r0, #SPI_8CLOCKS - str r0, [r1, #SP_TDR] -SP_loop2: + str r0, [r1, #SP_TDR] +SP_loop2: ldr r0, [r1, #SP_SR] tst r0, #SP_TDRE beq SP_loop2 ldr r0, [r1, #SP_RDR] -SP_loop3: +SP_loop3: ldr r0, [r1, #SP_SR] tst r0, #SP_RDRF beq SP_loop3 @@ -4207,7 +4173,7 @@ HALT2: b HALT2 and r0, r0, #255 bx lr .endfunc - + .func NVRAM_Xfer, NVRAM_XFER /* r0 = dest address */ /* r1 = not used */ @@ -4219,11 +4185,11 @@ HALT2: b HALT2 mov r4, r3 /* save r3 (length) */ mov r0, r2, LSR #5 /* SPI memories put A8 in the command field */ and r0, r0, #8 - add r0, r0, #NVRAM_CMD_READ + add r0, r0, #NVRAM_CMD_READ ldr r1, =NVRAM_SCRATCH strb r0, [r1, #0] /* save command in NVRAM_SCRATCH[0] */ strb r2, [r1, #1] /* save low byte of source address in NVRAM_SCRATCH[1] */ -_local1: +_local1: bl NVRAM_INIT tst r0, #NVRAM_SR_RDY bne _local1 @@ -4245,7 +4211,7 @@ HALT2: b HALT2 cmp r0, #0 bls _local2 ldr r5, =NVRAM_SCRATCH -_local4: +_local4: ldrb r6, [r5, r3] str r6, [r4, #SP_TDR] _local3: @@ -4259,7 +4225,7 @@ HALT2: b HALT2 mov r3, #SPI_8CLOCKS str r3, [r4, #SP_TDR] ldr r0, [r4, #SP_RDR] -_local5: +_local5: ldr r0, [r4, #SP_SR] tst r0, #SP_RDRF beq _local5 @@ -4267,12 +4233,12 @@ HALT2: b HALT2 mov r0, #0 cmp r2, #0 /* r2 is # of bytes to copy in */ bls _local6 -_local7: +_local7: ldr r5, [r4, #SP_SR] tst r5, #SP_TDRE beq _local7 str r3, [r4, #SP_TDR] /* r3 has SPI_8CLOCKS */ -_local8: +_local8: ldr r5, [r4, #SP_SR] tst r5, #SP_RDRF beq _local8 diff --git a/trunk/drivers/net/wireless/atmel_cs.c b/trunk/drivers/net/wireless/atmel_cs.c index d6f4a5a3e55a..17d1fd90f832 100644 --- a/trunk/drivers/net/wireless/atmel_cs.c +++ b/trunk/drivers/net/wireless/atmel_cs.c @@ -93,6 +93,8 @@ MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards"); static void atmel_config(dev_link_t *link); static void atmel_release(dev_link_t *link); +static int atmel_event(event_t event, int priority, + event_callback_args_t *args); /* The attach() and detach() entry points are used to create and destroy @@ -100,7 +102,8 @@ static void atmel_release(dev_link_t *link); needed to manage one actual PCMCIA card. */ -static void atmel_detach(struct pcmcia_device *p_dev); +static dev_link_t *atmel_attach(void); +static void atmel_detach(dev_link_t *); /* You'll also need to prototype all the functions that will actually @@ -109,6 +112,14 @@ static void atmel_detach(struct pcmcia_device *p_dev); less on other parts of the kernel. */ +/* + The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ + +static dev_info_t dev_info = "atmel_cs"; + /* A linked list of "instances" of the atmelnet device. Each actual PCMCIA card corresponds to one device instance, and is described @@ -119,7 +130,15 @@ static void atmel_detach(struct pcmcia_device *p_dev); device numbers are used to derive the corresponding array index. */ +static dev_link_t *dev_list = NULL; + /* + A dev_link_t structure has fields for most things that are needed + to keep track of a socket, but there will usually be some device + specific information that also needs to be kept track of. The + 'priv' pointer in a dev_link_t structure can be used to point to + a device-specific private data structure, like this. + A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be @@ -152,25 +171,27 @@ typedef struct local_info_t { ======================================================================*/ -static int atmel_attach(struct pcmcia_device *p_dev) +static dev_link_t *atmel_attach(void) { + client_reg_t client_reg; dev_link_t *link; local_info_t *local; - + int ret; + DEBUG(0, "atmel_attach()\n"); /* Initialize the dev_link_t structure */ link = kzalloc(sizeof(struct dev_link_t), GFP_KERNEL); if (!link) { printk(KERN_ERR "atmel_cs: no memory for new device\n"); - return -ENOMEM; + return NULL; } - + /* Interrupt setup */ link->irq.Attributes = IRQ_TYPE_EXCLUSIVE; link->irq.IRQInfo1 = IRQ_LEVEL_ID; link->irq.Handler = NULL; - + /* General socket configuration defaults can go here. In this client, we assume very little, and rely on the CIS for almost @@ -181,23 +202,30 @@ static int atmel_attach(struct pcmcia_device *p_dev) link->conf.Attributes = 0; link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - + /* Allocate space for private device-specific data */ local = kzalloc(sizeof(local_info_t), GFP_KERNEL); if (!local) { printk(KERN_ERR "atmel_cs: no memory for new device\n"); kfree (link); - return -ENOMEM; + return NULL; } link->priv = local; - - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - atmel_config(link); - - return 0; + + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + atmel_detach(link); + return NULL; + } + + return link; } /* atmel_attach */ /*====================================================================== @@ -209,15 +237,27 @@ static int atmel_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void atmel_detach(struct pcmcia_device *p_dev) +static void atmel_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); - + dev_link_t **linkp; + DEBUG(0, "atmel_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) atmel_release(link); + + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + /* Unlink device structure, free pieces */ + *linkp = link->next; kfree(link->priv); kfree(link); } @@ -437,34 +477,60 @@ static void atmel_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int atmel_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - local_info_t *local = link->priv; - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - netif_device_detach(local->eth_dev); - pcmcia_release_configuration(link->handle); - } +/*====================================================================== + + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. - return 0; -} + When a CARD_REMOVAL event is received, we immediately set a + private flag to block future accesses to this device. All the + functions that actually access the device should check this flag + to make sure the card is still present. + + ======================================================================*/ -static int atmel_resume(struct pcmcia_device *dev) +static int atmel_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; local_info_t *local = link->priv; - - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - atmel_open(local->eth_dev); - netif_device_attach(local->eth_dev); + + DEBUG(1, "atmel_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + netif_device_detach(local->eth_dev); + atmel_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + atmel_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + netif_device_detach(local->eth_dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + atmel_open(local->eth_dev); + netif_device_attach(local->eth_dev); + } + break; } - return 0; -} +} /* atmel_event */ /*====================================================================*/ /* We use the driver_info field to store the correct firmware type for a card. */ @@ -515,11 +581,10 @@ static struct pcmcia_driver atmel_driver = { .drv = { .name = "atmel_cs", }, - .probe = atmel_attach, - .remove = atmel_detach, + .attach = atmel_attach, + .event = atmel_event, + .detach = atmel_detach, .id_table = atmel_ids, - .suspend = atmel_suspend, - .resume = atmel_resume, }; static int atmel_cs_init(void) @@ -530,6 +595,7 @@ static int atmel_cs_init(void) static void atmel_cs_cleanup(void) { pcmcia_unregister_driver(&atmel_driver); + BUG_ON(dev_list != NULL); } /* diff --git a/trunk/drivers/net/wireless/hostap/Makefile b/trunk/drivers/net/wireless/hostap/Makefile index 353ccb93134b..fc62235bfc24 100644 --- a/trunk/drivers/net/wireless/hostap/Makefile +++ b/trunk/drivers/net/wireless/hostap/Makefile @@ -1,4 +1,3 @@ -hostap-y := hostap_main.o obj-$(CONFIG_HOSTAP) += hostap.o obj-$(CONFIG_HOSTAP_CS) += hostap_cs.o diff --git a/trunk/drivers/net/wireless/hostap/hostap_main.c b/trunk/drivers/net/wireless/hostap/hostap.c similarity index 100% rename from trunk/drivers/net/wireless/hostap/hostap_main.c rename to trunk/drivers/net/wireless/hostap/hostap.c diff --git a/trunk/drivers/net/wireless/hostap/hostap_cs.c b/trunk/drivers/net/wireless/hostap/hostap_cs.c index 8bc0b528548f..2643976a6677 100644 --- a/trunk/drivers/net/wireless/hostap/hostap_cs.c +++ b/trunk/drivers/net/wireless/hostap/hostap_cs.c @@ -25,6 +25,7 @@ static char *version = PRISM2_VERSION " (Jouni Malinen )"; static dev_info_t dev_info = "hostap_cs"; +static dev_link_t *dev_list = NULL; MODULE_AUTHOR("Jouni Malinen"); MODULE_DESCRIPTION("Support for Intersil Prism2-based 802.11 wireless LAN " @@ -202,9 +203,10 @@ static int hfa384x_to_bap(struct net_device *dev, u16 bap, void *buf, int len) -static void prism2_detach(struct pcmcia_device *p_dev); +static void prism2_detach(dev_link_t *link); static void prism2_release(u_long arg); -static int prism2_config(dev_link_t *link); +static int prism2_event(event_t event, int priority, + event_callback_args_t *args); static int prism2_pccard_card_present(local_info_t *local) @@ -501,13 +503,15 @@ static struct prism2_helper_functions prism2_pccard_funcs = /* allocate local data and register with CardServices * initialize dev_link structure, but do not configure the card yet */ -static int prism2_attach(struct pcmcia_device *p_dev) +static dev_link_t *prism2_attach(void) { dev_link_t *link; + client_reg_t client_reg; + int ret; link = kmalloc(sizeof(dev_link_t), GFP_KERNEL); if (link == NULL) - return -ENOMEM; + return NULL; memset(link, 0, sizeof(dev_link_t)); @@ -515,27 +519,50 @@ static int prism2_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 33; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - if (prism2_config(link)) - PDEBUG(DEBUG_EXTRA, "prism2_config() failed\n"); - - return 0; + /* register with CardServices */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + prism2_detach(link); + return NULL; + } + return link; } -static void prism2_detach(struct pcmcia_device *p_dev) +static void prism2_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; PDEBUG(DEBUG_FLOW, "prism2_detach\n"); + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + if (*linkp == NULL) { + printk(KERN_WARNING "%s: Attempt to detach non-existing " + "PCMCIA client\n", dev_info); + return; + } + if (link->state & DEV_CONFIG) { prism2_release((u_long)link); } + if (link->handle) { + int res = pcmcia_deregister_client(link->handle); + if (res) { + printk("CardService(DeregisterClient) => %d\n", res); + cs_error(link->handle, DeregisterClient, res); + } + } + + *linkp = link->next; /* release net devices */ if (link->priv) { struct hostap_cs_priv *hw_priv; @@ -819,58 +846,84 @@ static void prism2_release(u_long arg) PDEBUG(DEBUG_FLOW, "release - done\n"); } -static int hostap_cs_suspend(struct pcmcia_device *p_dev) + +static int prism2_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link = args->client_data; struct net_device *dev = (struct net_device *) link->priv; int dev_open = 0; - PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_PM_SUSPEND\n", dev_info); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { struct hostap_interface *iface = netdev_priv(dev); if (iface && iface->local) dev_open = iface->local->num_dev_open > 0; - if (dev_open) { - netif_stop_queue(dev); - netif_device_detach(dev); - } - prism2_suspend(dev); - pcmcia_release_configuration(link->handle); } - return 0; -} - -static int hostap_cs_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = (struct net_device *) link->priv; - int dev_open = 0; - - PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_PM_RESUME\n", dev_info); + switch (event) { + case CS_EVENT_CARD_INSERTION: + PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_CARD_INSERTION\n", dev_info); + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + if (prism2_config(link)) { + PDEBUG(DEBUG_EXTRA, "prism2_config() failed\n"); + } + break; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - struct hostap_interface *iface = netdev_priv(dev); - if (iface && iface->local) - dev_open = iface->local->num_dev_open > 0; + case CS_EVENT_CARD_REMOVAL: + PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_CARD_REMOVAL\n", dev_info); + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + netif_stop_queue(dev); + netif_device_detach(dev); + prism2_release((u_long) link); + } + break; - pcmcia_request_configuration(link->handle, &link->conf); + case CS_EVENT_PM_SUSPEND: + PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_PM_SUSPEND\n", dev_info); + link->state |= DEV_SUSPEND; + /* fall through */ + + case CS_EVENT_RESET_PHYSICAL: + PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_RESET_PHYSICAL\n", dev_info); + if (link->state & DEV_CONFIG) { + if (dev_open) { + netif_stop_queue(dev); + netif_device_detach(dev); + } + prism2_suspend(dev); + pcmcia_release_configuration(link->handle); + } + break; - prism2_hw_shutdown(dev, 1); - prism2_hw_config(dev, dev_open ? 0 : 1); - if (dev_open) { - netif_device_attach(dev); - netif_start_queue(dev); + case CS_EVENT_PM_RESUME: + PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_PM_RESUME\n", dev_info); + link->state &= ~DEV_SUSPEND; + /* fall through */ + + case CS_EVENT_CARD_RESET: + PDEBUG(DEBUG_EXTRA, "%s: CS_EVENT_CARD_RESET\n", dev_info); + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, + &link->conf); + prism2_hw_shutdown(dev, 1); + prism2_hw_config(dev, dev_open ? 0 : 1); + if (dev_open) { + netif_device_attach(dev); + netif_start_queue(dev); + } } - } + break; + default: + PDEBUG(DEBUG_EXTRA, "%s: prism2_event() - unknown event %d\n", + dev_info, event); + break; + } return 0; } + static struct pcmcia_device_id hostap_cs_ids[] = { PCMCIA_DEVICE_MANF_CARD(0x000b, 0x7100), PCMCIA_DEVICE_MANF_CARD(0x000b, 0x7300), @@ -929,12 +982,11 @@ static struct pcmcia_driver hostap_driver = { .drv = { .name = "hostap_cs", }, - .probe = prism2_attach, - .remove = prism2_detach, + .attach = prism2_attach, + .detach = prism2_detach, .owner = THIS_MODULE, + .event = prism2_event, .id_table = hostap_cs_ids, - .suspend = hostap_cs_suspend, - .resume = hostap_cs_resume, }; static int __init init_prism2_pccard(void) diff --git a/trunk/drivers/net/wireless/ipw2100.c b/trunk/drivers/net/wireless/ipw2100.c index 44cd3fcd1572..77d2a21d4cd0 100644 --- a/trunk/drivers/net/wireless/ipw2100.c +++ b/trunk/drivers/net/wireless/ipw2100.c @@ -175,7 +175,7 @@ that only one external action is invoked at a time. #define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation" /* Debugging stuff */ -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG #define CONFIG_IPW2100_RX_DEBUG /* Reception debugging */ #endif @@ -208,7 +208,7 @@ MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])"); static u32 ipw2100_debug_level = IPW_DL_NONE; -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG #define IPW_DEBUG(level, message...) \ do { \ if (ipw2100_debug_level & (level)) { \ @@ -219,9 +219,9 @@ do { \ } while (0) #else #define IPW_DEBUG(level, message...) do {} while (0) -#endif /* CONFIG_IPW2100_DEBUG */ +#endif /* CONFIG_IPW_DEBUG */ -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG static const char *command_types[] = { "undefined", "unused", /* HOST_ATTENTION */ @@ -2081,7 +2081,7 @@ static void isr_scan_complete(struct ipw2100_priv *priv, u32 status) priv->status &= ~STATUS_SCANNING; } -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG #define IPW2100_HANDLER(v, f) { v, f, # v } struct ipw2100_status_indicator { int status; @@ -2094,7 +2094,7 @@ struct ipw2100_status_indicator { int status; void (*cb) (struct ipw2100_priv * priv, u32 status); }; -#endif /* CONFIG_IPW2100_DEBUG */ +#endif /* CONFIG_IPW_DEBUG */ static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status) { @@ -2149,7 +2149,7 @@ static void isr_status_change(struct ipw2100_priv *priv, int status) static void isr_rx_complete_command(struct ipw2100_priv *priv, struct ipw2100_cmd_header *cmd) { -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG if (cmd->host_command_reg < ARRAY_SIZE(command_types)) { IPW_DEBUG_HC("Command completed '%s (%d)'\n", command_types[cmd->host_command_reg], @@ -2167,7 +2167,7 @@ static void isr_rx_complete_command(struct ipw2100_priv *priv, wake_up_interruptible(&priv->wait_command_queue); } -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG static const char *frame_types[] = { "COMMAND_STATUS_VAL", "STATUS_CHANGE_VAL", @@ -2290,7 +2290,7 @@ static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH]; static inline void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i) { -#ifdef CONFIG_IPW2100_DEBUG_C3 +#ifdef CONFIG_IPW_DEBUG_C3 struct ipw2100_status *status = &priv->status_queue.drv[i]; u32 match, reg; int j; @@ -2312,7 +2312,7 @@ static inline void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i) } #endif -#ifdef CONFIG_IPW2100_DEBUG_C3 +#ifdef CONFIG_IPW_DEBUG_C3 /* Halt the fimrware so we can get a good image */ write_register(priv->net_dev, IPW_REG_RESET_REG, IPW_AUX_HOST_RESET_REG_STOP_MASTER); @@ -2716,7 +2716,7 @@ static inline int __ipw2100_tx_process(struct ipw2100_priv *priv) list_del(element); DEC_STAT(&priv->fw_pend_stat); -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG { int i = txq->oldest; IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i, @@ -2782,7 +2782,7 @@ static inline int __ipw2100_tx_process(struct ipw2100_priv *priv) "something else: ids %d=%d.\n", priv->net_dev->name, txq->oldest, packet->index); -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG if (packet->info.c_struct.cmd->host_command_reg < sizeof(command_types) / sizeof(*command_types)) IPW_DEBUG_TX("Command '%s (%d)' processed: %d.\n", @@ -2975,7 +2975,7 @@ static void ipw2100_tx_send_data(struct ipw2100_priv *priv) IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n", packet->index, tbd->host_addr, tbd->buf_length); -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG if (packet->info.d_struct.txb->nr_frags > 1) IPW_DEBUG_FRAG("fragment Tx: %d frames\n", packet->info.d_struct.txb->nr_frags); @@ -3827,7 +3827,7 @@ static ssize_t show_stats(struct device *d, struct device_attribute *attr, priv->rx_interrupts, priv->inta_other); out += sprintf(out, "firmware resets: %d\n", priv->resets); out += sprintf(out, "firmware hangs: %d\n", priv->hangs); -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG out += sprintf(out, "packet mismatch image: %s\n", priv->snapshot[0] ? "YES" : "NO"); #endif @@ -3982,7 +3982,7 @@ static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr, static DEVICE_ATTR(bssinfo, S_IRUGO, show_bssinfo, NULL); -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG static ssize_t show_debug_level(struct device_driver *d, char *buf) { return sprintf(buf, "0x%08X\n", ipw2100_debug_level); @@ -4011,7 +4011,7 @@ static ssize_t store_debug_level(struct device_driver *d, static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO, show_debug_level, store_debug_level); -#endif /* CONFIG_IPW2100_DEBUG */ +#endif /* CONFIG_IPW_DEBUG */ static ssize_t show_fatal_error(struct device *d, struct device_attribute *attr, char *buf) @@ -4937,7 +4937,7 @@ static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid, }; int err; -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG if (bssid != NULL) IPW_DEBUG_HC("MANDATORY_BSSID: %02X:%02X:%02X:%02X:%02X:%02X\n", bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], @@ -6858,7 +6858,7 @@ static int __init ipw2100_init(void) ret = pci_module_init(&ipw2100_pci_driver); -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG ipw2100_debug_level = debug; driver_create_file(&ipw2100_pci_driver.driver, &driver_attr_debug_level); @@ -6873,7 +6873,7 @@ static int __init ipw2100_init(void) static void __exit ipw2100_exit(void) { /* FIXME: IPG: check that we have no instances of the devices open */ -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG driver_remove_file(&ipw2100_pci_driver.driver, &driver_attr_debug_level); #endif @@ -8558,7 +8558,7 @@ static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev) quality = min(beacon_qual, min(tx_qual, rssi_qual)); -#ifdef CONFIG_IPW2100_DEBUG +#ifdef CONFIG_IPW_DEBUG if (beacon_qual == quality) IPW_DEBUG_WX("Quality clamped by Missed Beacons\n"); else if (tx_qual == quality) diff --git a/trunk/drivers/net/wireless/ipw2100.h b/trunk/drivers/net/wireless/ipw2100.h index f6c51441fa87..7c65b10bb164 100644 --- a/trunk/drivers/net/wireless/ipw2100.h +++ b/trunk/drivers/net/wireless/ipw2100.h @@ -73,7 +73,7 @@ struct ipw2100_rx_packet; * you simply need to add your entry to the ipw2100_debug_levels array. * * If you do not see debug_level in /proc/net/ipw2100 then you do not have - * CONFIG_IPW2100_DEBUG defined in your kernel configuration + * CONFIG_IPW_DEBUG defined in your kernel configuration * */ diff --git a/trunk/drivers/net/wireless/ipw2200.c b/trunk/drivers/net/wireless/ipw2200.c index cdfe50207757..5e7c7e944c9d 100644 --- a/trunk/drivers/net/wireless/ipw2200.c +++ b/trunk/drivers/net/wireless/ipw2200.c @@ -462,7 +462,7 @@ static inline void ipw_disable_interrupts(struct ipw_priv *priv) ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL); } -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG static char *ipw_error_desc(u32 val) { switch (val) { @@ -1235,7 +1235,7 @@ static ssize_t store_scan_age(struct device *d, struct device_attribute *attr, const char *buf, size_t count) { struct ipw_priv *priv = dev_get_drvdata(d); -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG struct net_device *dev = priv->net_dev; #endif char buffer[] = "00000000"; @@ -1754,7 +1754,7 @@ static void ipw_irq_tasklet(struct ipw_priv *priv) IPW_ERROR("Firmware error detected. Restarting.\n"); if (priv->error) { IPW_ERROR("Sysfs 'error' log already exists.\n"); -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG if (ipw_debug_level & IPW_DL_FW_ERRORS) { struct ipw_fw_error *error = ipw_alloc_error_log(priv); @@ -1770,7 +1770,7 @@ static void ipw_irq_tasklet(struct ipw_priv *priv) else IPW_ERROR("Error allocating sysfs 'error' " "log.\n"); -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG if (ipw_debug_level & IPW_DL_FW_ERRORS) ipw_dump_error_log(priv, priv->error); #endif @@ -3778,7 +3778,7 @@ static const struct ipw_status_code ipw_status_codes[] = { {0x2E, "Cipher suite is rejected per security policy"}, }; -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG static const char *ipw_get_status_code(u16 status) { int i; @@ -4250,7 +4250,7 @@ static inline void ipw_rx_notification(struct ipw_priv *priv, if (priv-> status & (STATUS_ASSOCIATED | STATUS_AUTH)) { -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG struct notif_authenticate *auth = ¬if->u.auth; IPW_DEBUG(IPW_DL_NOTIF | @@ -4944,11 +4944,12 @@ static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv) struct ipw_rx_queue *rxq; int i; - rxq = kzalloc(sizeof(*rxq), GFP_KERNEL); + rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL); if (unlikely(!rxq)) { IPW_ERROR("memory allocation failed\n"); return NULL; } + memset(rxq, 0, sizeof(*rxq)); spin_lock_init(&rxq->lock); INIT_LIST_HEAD(&rxq->rx_free); INIT_LIST_HEAD(&rxq->rx_used); @@ -5827,7 +5828,7 @@ static void ipw_bg_adhoc_check(void *data) up(&priv->sem); } -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG static void ipw_debug_config(struct ipw_priv *priv) { IPW_DEBUG_INFO("Scan completed, no valid APs matched " @@ -7455,7 +7456,8 @@ static void ipw_handle_data_packet(struct ipw_priv *priv, /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */ hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data; if (priv->ieee->iw_mode != IW_MODE_MONITOR && - (is_multicast_ether_addr(hdr->addr1) ? + ((is_multicast_ether_addr(hdr->addr1) || + is_broadcast_ether_addr(hdr->addr1)) ? !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt)) ipw_rebuild_decrypted_skb(priv, rxb->skb); @@ -7646,7 +7648,8 @@ static inline int is_network_packet(struct ipw_priv *priv, return 0; /* {broad,multi}cast packets to our BSSID go through */ - if (is_multicast_ether_addr(header->addr1)) + if (is_multicast_ether_addr(header->addr1) || + is_broadcast_ether_addr(header->addr1)) return !memcmp(header->addr3, priv->bssid, ETH_ALEN); /* packets to our adapter go through */ @@ -7659,7 +7662,8 @@ static inline int is_network_packet(struct ipw_priv *priv, return 0; /* {broad,multi}cast packets to our BSS go through */ - if (is_multicast_ether_addr(header->addr1)) + if (is_multicast_ether_addr(header->addr1) || + is_broadcast_ether_addr(header->addr1)) return !memcmp(header->addr2, priv->bssid, ETH_ALEN); /* packets to our adapter go through */ @@ -7811,7 +7815,7 @@ static void ipw_rx(struct ipw_priv *priv) while (i != r) { rxb = priv->rxq->queue[i]; -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG if (unlikely(rxb == NULL)) { printk(KERN_CRIT "Queue not allocated!\n"); break; @@ -9653,7 +9657,8 @@ static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb, switch (priv->ieee->iw_mode) { case IW_MODE_ADHOC: hdr_len = IEEE80211_3ADDR_LEN; - unicast = !is_multicast_ether_addr(hdr->addr1); + unicast = !(is_multicast_ether_addr(hdr->addr1) || + is_broadcast_ether_addr(hdr->addr1)); id = ipw_find_station(priv, hdr->addr1); if (id == IPW_INVALID_STATION) { id = ipw_add_station(priv, hdr->addr1); @@ -9668,7 +9673,8 @@ static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb, case IW_MODE_INFRA: default: - unicast = !is_multicast_ether_addr(hdr->addr3); + unicast = !(is_multicast_ether_addr(hdr->addr3) || + is_broadcast_ether_addr(hdr->addr3)); hdr_len = IEEE80211_3ADDR_LEN; id = 0; break; @@ -10950,7 +10956,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) priv->net_dev = net_dev; priv->pci_dev = pdev; -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG ipw_debug_level = debug; #endif spin_lock_init(&priv->lock); diff --git a/trunk/drivers/net/wireless/ipw2200.h b/trunk/drivers/net/wireless/ipw2200.h index e65620a4d79e..1c98db0652c9 100644 --- a/trunk/drivers/net/wireless/ipw2200.h +++ b/trunk/drivers/net/wireless/ipw2200.h @@ -1301,14 +1301,14 @@ struct ipw_priv { /* debug macros */ -#ifdef CONFIG_IPW2200_DEBUG +#ifdef CONFIG_IPW_DEBUG #define IPW_DEBUG(level, fmt, args...) \ do { if (ipw_debug_level & (level)) \ printk(KERN_DEBUG DRV_NAME": %c %s " fmt, \ in_interrupt() ? 'I' : 'U', __FUNCTION__ , ## args); } while (0) #else #define IPW_DEBUG(level, fmt, args...) do {} while (0) -#endif /* CONFIG_IPW2200_DEBUG */ +#endif /* CONFIG_IPW_DEBUG */ /* * To use the debug system; @@ -1332,7 +1332,7 @@ do { if (ipw_debug_level & (level)) \ * you simply need to add your entry to the ipw_debug_levels array. * * If you do not see debug_level in /proc/net/ipw then you do not have - * CONFIG_IPW2200_DEBUG defined in your kernel configuration + * CONFIG_IPW_DEBUG defined in your kernel configuration * */ diff --git a/trunk/drivers/net/wireless/netwave_cs.c b/trunk/drivers/net/wireless/netwave_cs.c index bf6271ee387a..92793b958e32 100644 --- a/trunk/drivers/net/wireless/netwave_cs.c +++ b/trunk/drivers/net/wireless/netwave_cs.c @@ -166,6 +166,8 @@ static char *version = #define DEBUG(n, args...) #endif +static dev_info_t dev_info = "netwave_cs"; + /*====================================================================*/ /* Parameters that can be set with 'insmod' */ @@ -193,9 +195,12 @@ module_param(mem_speed, int, 0); /* PCMCIA (Card Services) related functions */ static void netwave_release(dev_link_t *link); /* Card removal */ +static int netwave_event(event_t event, int priority, + event_callback_args_t *args); static void netwave_pcmcia_config(dev_link_t *arg); /* Runs after card insertion */ -static void netwave_detach(struct pcmcia_device *p_dev); /* Destroy instance */ +static dev_link_t *netwave_attach(void); /* Create instance */ +static void netwave_detach(dev_link_t *); /* Destroy instance */ /* Hardware configuration */ static void netwave_doreset(kio_addr_t iobase, u_char __iomem *ramBase); @@ -222,6 +227,17 @@ static struct iw_statistics* netwave_get_wireless_stats(struct net_device *dev); static void set_multicast_list(struct net_device *dev); +/* + A linked list of "instances" of the skeleton device. Each actual + PCMCIA card corresponds to one device instance, and is described + by one dev_link_t structure (defined in ds.h). + + You may not want to use a linked list for this -- for example, the + memory card driver uses an array of dev_link_t pointers, where minor + device numbers are used to derive the corresponding array index. +*/ +static dev_link_t *dev_list; + /* A dev_link_t structure has fields for most things that are needed to keep track of a socket, but there will usually be some device @@ -378,18 +394,20 @@ static struct iw_statistics *netwave_get_wireless_stats(struct net_device *dev) * configure the card at this point -- we wait until we receive a * card insertion event. */ -static int netwave_attach(struct pcmcia_device *p_dev) +static dev_link_t *netwave_attach(void) { + client_reg_t client_reg; dev_link_t *link; struct net_device *dev; netwave_private *priv; - + int ret; + DEBUG(0, "netwave_attach()\n"); - + /* Initialize the dev_link_t structure */ dev = alloc_etherdev(sizeof(netwave_private)); if (!dev) - return -ENOMEM; + return NULL; priv = netdev_priv(dev); link = &priv->link; link->priv = dev; @@ -431,14 +449,21 @@ static int netwave_attach(struct pcmcia_device *p_dev) dev->open = &netwave_open; dev->stop = &netwave_close; link->irq.Instance = dev; + + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + netwave_detach(link); + return NULL; + } - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - netwave_pcmcia_config( link); - - return 0; + return link; } /* netwave_attach */ /* @@ -449,20 +474,42 @@ static int netwave_attach(struct pcmcia_device *p_dev) * structures are freed. Otherwise, the structures will be freed * when the device is released. */ -static void netwave_detach(struct pcmcia_device *p_dev) +static void netwave_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - DEBUG(0, "netwave_detach(0x%p)\n", link); - - if (link->state & DEV_CONFIG) - netwave_release(link); - - if (link->dev) - unregister_netdev(dev); + struct net_device *dev = link->priv; + dev_link_t **linkp; - free_netdev(dev); + DEBUG(0, "netwave_detach(0x%p)\n", link); + + /* + If the device is currently configured and active, we won't + actually delete it yet. Instead, it is marked so that when + the release() function is called, that will trigger a proper + detach(). + */ + if (link->state & DEV_CONFIG) + netwave_release(link); + + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + { + DEBUG(1, "netwave_cs: detach fail, '%s' not in list\n", + link->dev->dev_name); + return; + } + + /* Unlink device structure, free pieces */ + *linkp = link->next; + if (link->dev) + unregister_netdev(dev); + free_netdev(dev); + } /* netwave_detach */ /* @@ -888,38 +935,69 @@ static void netwave_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int netwave_suspend(struct pcmcia_device *p_dev) +/* + * Function netwave_event (event, priority, args) + * + * The card status event handler. Mostly, this schedules other + * stuff to run after an event is received. A CARD_REMOVAL event + * also sets some flags to discourage the net drivers from trying + * to talk to the card any more. + * + * When a CARD_REMOVAL event is received, we immediately set a flag + * to block future accesses to this device. All the functions that + * actually access the device should check this flag to make sure + * the card is still present. + * + */ +static int netwave_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + + DEBUG(1, "netwave_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_REGISTRATION_COMPLETE: + DEBUG(0, "netwave_cs: registration complete\n"); + break; + + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + netif_device_detach(dev); + netwave_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + netwave_pcmcia_config( link); + break; + case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); } - - return 0; -} - -static int netwave_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - netwave_reset(dev); - netif_device_attach(dev); - } + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + netwave_reset(dev); + netif_device_attach(dev); + } } - - return 0; -} - + break; + } + return 0; +} /* netwave_event */ /* * Function netwave_doreset (ioBase, ramBase) @@ -1413,11 +1491,10 @@ static struct pcmcia_driver netwave_driver = { .drv = { .name = "netwave_cs", }, - .probe = netwave_attach, - .remove = netwave_detach, + .attach = netwave_attach, + .event = netwave_event, + .detach = netwave_detach, .id_table = netwave_ids, - .suspend = netwave_suspend, - .resume = netwave_resume, }; static int __init init_netwave_cs(void) @@ -1428,6 +1505,7 @@ static int __init init_netwave_cs(void) static void __exit exit_netwave_cs(void) { pcmcia_unregister_driver(&netwave_driver); + BUG_ON(dev_list != NULL); } module_init(init_netwave_cs); diff --git a/trunk/drivers/net/wireless/orinoco_cs.c b/trunk/drivers/net/wireless/orinoco_cs.c index b664708481cc..dc1128a00971 100644 --- a/trunk/drivers/net/wireless/orinoco_cs.c +++ b/trunk/drivers/net/wireless/orinoco_cs.c @@ -42,6 +42,17 @@ static int ignore_cis_vcc; /* = 0 */ module_param(ignore_cis_vcc, int, 0); MODULE_PARM_DESC(ignore_cis_vcc, "Allow voltage mismatch between card and socket"); +/********************************************************************/ +/* Magic constants */ +/********************************************************************/ + +/* + * The dev_info variable is the "key" that is used to match up this + * device driver with appropriate cards, through the card + * configuration database. + */ +static dev_info_t dev_info = DRIVER_NAME; + /********************************************************************/ /* Data structures */ /********************************************************************/ @@ -58,14 +69,19 @@ struct orinoco_pccard { unsigned long hard_reset_in_progress; }; +/* + * A linked list of "instances" of the device. Each actual PCMCIA + * card corresponds to one device instance, and is described by one + * dev_link_t structure (defined in ds.h). + */ +static dev_link_t *dev_list; /* = NULL */ /********************************************************************/ /* Function prototypes */ /********************************************************************/ -static void orinoco_cs_config(dev_link_t *link); static void orinoco_cs_release(dev_link_t *link); -static void orinoco_cs_detach(struct pcmcia_device *p_dev); +static void orinoco_cs_detach(dev_link_t *link); /********************************************************************/ /* Device methods */ @@ -103,17 +119,19 @@ orinoco_cs_hard_reset(struct orinoco_private *priv) * The dev_link structure is initialized, but we don't actually * configure the card at this point -- we wait until we receive a card * insertion event. */ -static int -orinoco_cs_attach(struct pcmcia_device *p_dev) +static dev_link_t * +orinoco_cs_attach(void) { struct net_device *dev; struct orinoco_private *priv; struct orinoco_pccard *card; dev_link_t *link; + client_reg_t client_reg; + int ret; dev = alloc_orinocodev(sizeof(*card), orinoco_cs_hard_reset); if (! dev) - return -ENOMEM; + return NULL; priv = netdev_priv(dev); card = priv->card; @@ -136,15 +154,22 @@ orinoco_cs_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; /* Register with Card Services */ - link->next = NULL; - - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - orinoco_cs_config(link); + /* FIXME: need a lock? */ + link->next = dev_list; + dev_list = link; + + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; /* FIXME: what does this mean? */ + client_reg.event_callback_args.client_data = link; + + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + orinoco_cs_detach(link); + return NULL; + } - return 0; + return link; } /* orinoco_cs_attach */ /* @@ -153,14 +178,27 @@ orinoco_cs_attach(struct pcmcia_device *p_dev) * are freed. Otherwise, the structures will be freed when the device * is released. */ -static void orinoco_cs_detach(struct pcmcia_device *p_dev) +static void orinoco_cs_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; struct net_device *dev = link->priv; + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + + BUG_ON(*linkp == NULL); + if (link->state & DEV_CONFIG) orinoco_cs_release(link); + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, and free it */ + *linkp = link->next; DEBUG(0, PFX "detach: link=%p link->dev=%p\n", link, link->dev); if (link->dev) { DEBUG(0, PFX "About to unregister net device %p\n", @@ -427,82 +465,106 @@ orinoco_cs_release(dev_link_t *link) ioport_unmap(priv->hw.iobase); } /* orinoco_cs_release */ -static int orinoco_cs_suspend(struct pcmcia_device *p_dev) +/* + * The card status event handler. Mostly, this schedules other stuff + * to run after an event is received. + */ +static int +orinoco_cs_event(event_t event, int priority, + event_callback_args_t * args) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link = args->client_data; struct net_device *dev = link->priv; struct orinoco_private *priv = netdev_priv(dev); struct orinoco_pccard *card = priv->card; int err = 0; unsigned long flags; - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - /* This is probably racy, but I can't think of - a better way, short of rewriting the PCMCIA - layer to not suck :-( */ - if (! test_bit(0, &card->hard_reset_in_progress)) { - spin_lock_irqsave(&priv->lock, flags); - - err = __orinoco_down(dev); - if (err) - printk(KERN_WARNING "%s: Error %d downing interface\n", - dev->name, err); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + unsigned long flags; + spin_lock_irqsave(&priv->lock, flags); netif_device_detach(dev); priv->hw_unavailable++; - spin_unlock_irqrestore(&priv->lock, flags); } + break; - pcmcia_release_configuration(link->handle); - } - - return 0; -} - -static int orinoco_cs_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - struct orinoco_private *priv = netdev_priv(dev); - struct orinoco_pccard *card = priv->card; - int err = 0; - unsigned long flags; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + orinoco_cs_config(link); + break; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - /* FIXME: should we double check that this is - * the same card as we had before */ - pcmcia_request_configuration(link->handle, &link->conf); - - if (! test_bit(0, &card->hard_reset_in_progress)) { - err = orinoco_reinit_firmware(dev); - if (err) { - printk(KERN_ERR "%s: Error %d re-initializing firmware\n", - dev->name, err); - return -EIO; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + /* Mark the device as stopped, to block IO until later */ + if (link->state & DEV_CONFIG) { + /* This is probably racy, but I can't think of + a better way, short of rewriting the PCMCIA + layer to not suck :-( */ + if (! test_bit(0, &card->hard_reset_in_progress)) { + spin_lock_irqsave(&priv->lock, flags); + + err = __orinoco_down(dev); + if (err) + printk(KERN_WARNING "%s: %s: Error %d downing interface\n", + dev->name, + event == CS_EVENT_PM_SUSPEND ? "SUSPEND" : "RESET_PHYSICAL", + err); + + netif_device_detach(dev); + priv->hw_unavailable++; + + spin_unlock_irqrestore(&priv->lock, flags); } - spin_lock_irqsave(&priv->lock, flags); - - netif_device_attach(dev); - priv->hw_unavailable--; + pcmcia_release_configuration(link->handle); + } + break; - if (priv->open && ! priv->hw_unavailable) { - err = __orinoco_up(dev); - if (err) - printk(KERN_ERR "%s: Error %d restarting card\n", + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + /* FIXME: should we double check that this is + * the same card as we had before */ + pcmcia_request_configuration(link->handle, &link->conf); + + if (! test_bit(0, &card->hard_reset_in_progress)) { + err = orinoco_reinit_firmware(dev); + if (err) { + printk(KERN_ERR "%s: Error %d re-initializing firmware\n", dev->name, err); + break; + } + + spin_lock_irqsave(&priv->lock, flags); + + netif_device_attach(dev); + priv->hw_unavailable--; + + if (priv->open && ! priv->hw_unavailable) { + err = __orinoco_up(dev); + if (err) + printk(KERN_ERR "%s: Error %d restarting card\n", + dev->name, err); + + } + + spin_unlock_irqrestore(&priv->lock, flags); } - - spin_unlock_irqrestore(&priv->lock, flags); } + break; } - return 0; -} - + return err; +} /* orinoco_cs_event */ /********************************************************************/ /* Module initialization */ @@ -603,11 +665,10 @@ static struct pcmcia_driver orinoco_driver = { .drv = { .name = DRIVER_NAME, }, - .probe = orinoco_cs_attach, - .remove = orinoco_cs_detach, + .attach = orinoco_cs_attach, + .detach = orinoco_cs_detach, + .event = orinoco_cs_event, .id_table = orinoco_cs_ids, - .suspend = orinoco_cs_suspend, - .resume = orinoco_cs_resume, }; static int __init @@ -622,6 +683,7 @@ static void __exit exit_orinoco_cs(void) { pcmcia_unregister_driver(&orinoco_driver); + BUG_ON(dev_list != NULL); } module_init(init_orinoco_cs); diff --git a/trunk/drivers/net/wireless/ray_cs.c b/trunk/drivers/net/wireless/ray_cs.c index 319180ca7e71..70fd6fd8feb9 100644 --- a/trunk/drivers/net/wireless/ray_cs.c +++ b/trunk/drivers/net/wireless/ray_cs.c @@ -92,7 +92,9 @@ module_param(pc_debug, int, 0); /** Prototypes based on PCMCIA skeleton driver *******************************/ static void ray_config(dev_link_t *link); static void ray_release(dev_link_t *link); -static void ray_detach(struct pcmcia_device *p_dev); +static int ray_event(event_t event, int priority, event_callback_args_t *args); +static dev_link_t *ray_attach(void); +static void ray_detach(dev_link_t *); /***** Prototypes indicated by device structure ******************************/ static int ray_dev_close(struct net_device *dev); @@ -190,6 +192,12 @@ static int bc; static char *phy_addr = NULL; +/* The dev_info variable is the "key" that is used to match up this + device driver with appropriate cards, through the card configuration + database. +*/ +static dev_info_t dev_info = "ray_cs"; + /* A linked list of "instances" of the ray device. Each actual PCMCIA card corresponds to one device instance, and is described by one dev_link_t structure (defined in ds.h). @@ -306,10 +314,12 @@ static char rcsid[] = "Raylink/WebGear wireless LAN - Corey stop = &ray_dev_close; netif_stop_queue(dev); - init_timer(&local->timer); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; - link->handle = p_dev; - p_dev->instance = link; + DEBUG(2,"ray_cs ray_attach calling pcmcia_register_client(...)\n"); - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - ray_config(link); + init_timer(&local->timer); - return 0; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + printk("ray_cs ray_attach RegisterClient unhappy - detaching\n"); + cs_error(link->handle, RegisterClient, ret); + ray_detach(link); + return NULL; + } + DEBUG(2,"ray_cs ray_attach ending\n"); + return link; fail_alloc_dev: kfree(link); - return -ENOMEM; + return NULL; } /* ray_attach */ /*============================================================================= This deletes a driver "instance". The device is de-registered @@ -397,12 +418,9 @@ static int ray_attach(struct pcmcia_device *p_dev) structures are freed. Otherwise, the structures will be freed when the device is released. =============================================================================*/ -static void ray_detach(struct pcmcia_device *p_dev) +static void ray_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); dev_link_t **linkp; - struct net_device *dev; - ray_dev_t *local; DEBUG(1, "ray_detach(0x%p)\n", link); @@ -412,18 +430,22 @@ static void ray_detach(struct pcmcia_device *p_dev) if (*linkp == NULL) return; - dev = link->priv; - - if (link->state & DEV_CONFIG) { - ray_release(link); - - local = (ray_dev_t *)dev->priv; - del_timer(&local->timer); - } + /* If the device is currently configured and active, we won't + actually delete it yet. Instead, it is marked so that when + the release() function is called, that will trigger a proper + detach(). + */ + if (link->state & DEV_CONFIG) + ray_release(link); + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + /* Unlink device structure, free pieces */ *linkp = link->next; if (link->priv) { + struct net_device *dev = link->priv; if (link->dev) unregister_netdev(dev); free_netdev(dev); } @@ -869,40 +891,65 @@ static void ray_release(dev_link_t *link) DEBUG(2,"ray_release ending\n"); } -static int ray_suspend(struct pcmcia_device *p_dev) +/*============================================================================= + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. + + When a CARD_REMOVAL event is received, we immediately set a flag + to block future accesses to this device. All the functions that + actually access the device should check this flag to make sure + the card is still present. +=============================================================================*/ +static int ray_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - link->state |= DEV_SUSPEND; + dev_link_t *link = args->client_data; + struct net_device *dev = link->priv; + ray_dev_t *local = (ray_dev_t *)dev->priv; + DEBUG(1, "ray_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + netif_device_detach(dev); if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - - pcmcia_release_configuration(link->handle); + ray_release(link); + del_timer(&local->timer); } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + ray_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + if (link->open) + netif_device_detach(dev); - - return 0; -} - -static int ray_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - link->state &= ~DEV_SUSPEND; + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - ray_reset(dev); - netif_device_attach(dev); - } + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + ray_reset(dev); + netif_device_attach(dev); + } } - - return 0; -} - + break; + } + return 0; + DEBUG(2,"ray_event ending\n"); +} /* ray_event */ /*===========================================================================*/ int ray_dev_init(struct net_device *dev) { @@ -2898,11 +2945,10 @@ static struct pcmcia_driver ray_driver = { .drv = { .name = "ray_cs", }, - .probe = ray_attach, - .remove = ray_detach, + .attach = ray_attach, + .event = ray_event, + .detach = ray_detach, .id_table = ray_ids, - .suspend = ray_suspend, - .resume = ray_resume, }; static int __init init_ray_cs(void) diff --git a/trunk/drivers/net/wireless/spectrum_cs.c b/trunk/drivers/net/wireless/spectrum_cs.c index fee4be1ce810..b1bbc8e8e91f 100644 --- a/trunk/drivers/net/wireless/spectrum_cs.c +++ b/trunk/drivers/net/wireless/spectrum_cs.c @@ -56,6 +56,17 @@ static int ignore_cis_vcc; /* = 0 */ module_param(ignore_cis_vcc, int, 0); MODULE_PARM_DESC(ignore_cis_vcc, "Allow voltage mismatch between card and socket"); +/********************************************************************/ +/* Magic constants */ +/********************************************************************/ + +/* + * The dev_info variable is the "key" that is used to match up this + * device driver with appropriate cards, through the card + * configuration database. + */ +static dev_info_t dev_info = DRIVER_NAME; + /********************************************************************/ /* Data structures */ /********************************************************************/ @@ -67,12 +78,19 @@ struct orinoco_pccard { dev_node_t node; }; +/* + * A linked list of "instances" of the device. Each actual PCMCIA + * card corresponds to one device instance, and is described by one + * dev_link_t structure (defined in ds.h). + */ +static dev_link_t *dev_list; /* = NULL */ + /********************************************************************/ /* Function prototypes */ /********************************************************************/ -static void spectrum_cs_config(dev_link_t *link); static void spectrum_cs_release(dev_link_t *link); +static void spectrum_cs_detach(dev_link_t *link); /********************************************************************/ /* Firmware downloader */ @@ -583,17 +601,19 @@ spectrum_cs_hard_reset(struct orinoco_private *priv) * The dev_link structure is initialized, but we don't actually * configure the card at this point -- we wait until we receive a card * insertion event. */ -static int -spectrum_cs_attach(struct pcmcia_device *p_dev) +static dev_link_t * +spectrum_cs_attach(void) { struct net_device *dev; struct orinoco_private *priv; struct orinoco_pccard *card; dev_link_t *link; + client_reg_t client_reg; + int ret; dev = alloc_orinocodev(sizeof(*card), spectrum_cs_hard_reset); if (! dev) - return -ENOMEM; + return NULL; priv = netdev_priv(dev); card = priv->card; @@ -615,13 +635,23 @@ spectrum_cs_attach(struct pcmcia_device *p_dev) link->conf.Attributes = 0; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; + /* Register with Card Services */ + /* FIXME: need a lock? */ + link->next = dev_list; + dev_list = link; - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - spectrum_cs_config(link); + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; /* FIXME: what does this mean? */ + client_reg.event_callback_args.client_data = link; - return 0; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + spectrum_cs_detach(link); + return NULL; + } + + return link; } /* spectrum_cs_attach */ /* @@ -630,14 +660,27 @@ spectrum_cs_attach(struct pcmcia_device *p_dev) * are freed. Otherwise, the structures will be freed when the device * is released. */ -static void spectrum_cs_detach(struct pcmcia_device *p_dev) +static void spectrum_cs_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; struct net_device *dev = link->priv; + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + + BUG_ON(*linkp == NULL); + if (link->state & DEV_CONFIG) spectrum_cs_release(link); + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, and free it */ + *linkp = link->next; DEBUG(0, PFX "detach: link=%p link->dev=%p\n", link, link->dev); if (link->dev) { DEBUG(0, PFX "About to unregister net device %p\n", @@ -905,56 +948,82 @@ spectrum_cs_release(dev_link_t *link) ioport_unmap(priv->hw.iobase); } /* spectrum_cs_release */ - +/* + * The card status event handler. Mostly, this schedules other stuff + * to run after an event is received. + */ static int -spectrum_cs_suspend(struct pcmcia_device *p_dev) +spectrum_cs_event(event_t event, int priority, + event_callback_args_t * args) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link = args->client_data; struct net_device *dev = link->priv; struct orinoco_private *priv = netdev_priv(dev); - unsigned long flags; int err = 0; + unsigned long flags; - link->state |= DEV_SUSPEND; - /* Mark the device as stopped, to block IO until later */ - if (link->state & DEV_CONFIG) { - spin_lock_irqsave(&priv->lock, flags); - - err = __orinoco_down(dev); - if (err) - printk(KERN_WARNING "%s: Error %d downing interface\n", - dev->name, err); - - netif_device_detach(dev); - priv->hw_unavailable++; - - spin_unlock_irqrestore(&priv->lock, flags); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + unsigned long flags; - pcmcia_release_configuration(link->handle); - } + spin_lock_irqsave(&priv->lock, flags); + netif_device_detach(dev); + priv->hw_unavailable++; + spin_unlock_irqrestore(&priv->lock, flags); + } + break; - return 0; -} + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + spectrum_cs_config(link); + break; -static int -spectrum_cs_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - struct orinoco_private *priv = netdev_priv(dev); + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + /* Mark the device as stopped, to block IO until later */ + if (link->state & DEV_CONFIG) { + /* This is probably racy, but I can't think of + a better way, short of rewriting the PCMCIA + layer to not suck :-( */ + spin_lock_irqsave(&priv->lock, flags); + + err = __orinoco_down(dev); + if (err) + printk(KERN_WARNING "%s: %s: Error %d downing interface\n", + dev->name, + event == CS_EVENT_PM_SUSPEND ? "SUSPEND" : "RESET_PHYSICAL", + err); + + netif_device_detach(dev); + priv->hw_unavailable++; + + spin_unlock_irqrestore(&priv->lock, flags); + + pcmcia_release_configuration(link->handle); + } + break; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - /* FIXME: should we double check that this is - * the same card as we had before */ - pcmcia_request_configuration(link->handle, &link->conf); - netif_device_attach(dev); - priv->hw_unavailable--; - schedule_work(&priv->reset_work); + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + /* FIXME: should we double check that this is + * the same card as we had before */ + pcmcia_request_configuration(link->handle, &link->conf); + netif_device_attach(dev); + priv->hw_unavailable--; + schedule_work(&priv->reset_work); + } + break; } - return 0; -} + return err; +} /* spectrum_cs_event */ /********************************************************************/ /* Module initialization */ @@ -979,10 +1048,9 @@ static struct pcmcia_driver orinoco_driver = { .drv = { .name = DRIVER_NAME, }, - .probe = spectrum_cs_attach, - .remove = spectrum_cs_detach, - .suspend = spectrum_cs_suspend, - .resume = spectrum_cs_resume, + .attach = spectrum_cs_attach, + .detach = spectrum_cs_detach, + .event = spectrum_cs_event, .id_table = spectrum_cs_ids, }; @@ -998,6 +1066,7 @@ static void __exit exit_spectrum_cs(void) { pcmcia_unregister_driver(&orinoco_driver); + BUG_ON(dev_list != NULL); } module_init(init_spectrum_cs); diff --git a/trunk/drivers/net/wireless/wavelan_cs.c b/trunk/drivers/net/wireless/wavelan_cs.c index 7e2039f52c49..c822cad3333f 100644 --- a/trunk/drivers/net/wireless/wavelan_cs.c +++ b/trunk/drivers/net/wireless/wavelan_cs.c @@ -4594,12 +4594,14 @@ wavelan_close(struct net_device * dev) * configure the card at this point -- we wait until we receive a * card insertion event. */ -static int -wavelan_attach(struct pcmcia_device *p_dev) +static dev_link_t * +wavelan_attach(void) { + client_reg_t client_reg; /* Register with cardmgr */ dev_link_t * link; /* Info for cardmgr */ struct net_device * dev; /* Interface generic data */ net_local * lp; /* Interface specific data */ + int ret; #ifdef DEBUG_CALLBACK_TRACE printk(KERN_DEBUG "-> wavelan_attach()\n"); @@ -4607,7 +4609,7 @@ wavelan_attach(struct pcmcia_device *p_dev) /* Initialize the dev_link_t structure */ link = kzalloc(sizeof(struct dev_link_t), GFP_KERNEL); - if (!link) return -ENOMEM; + if (!link) return NULL; /* The io structure describes IO port mapping */ link->io.NumPorts1 = 8; @@ -4625,13 +4627,14 @@ wavelan_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; /* Chain drivers */ - link->next = NULL; + link->next = dev_list; + dev_list = link; /* Allocate the generic data structure */ dev = alloc_etherdev(sizeof(net_local)); if (!dev) { kfree(link); - return -ENOMEM; + return NULL; } link->priv = link->irq.Instance = dev; @@ -4676,21 +4679,28 @@ wavelan_attach(struct pcmcia_device *p_dev) /* Other specific data */ dev->mtu = WAVELAN_MTU; - link->handle = p_dev; - p_dev->instance = link; + /* Register with Card Services */ + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - if(wv_pcmcia_config(link) && - wv_hw_config(dev)) - wv_init_info(dev); - else - dev->irq = 0; +#ifdef DEBUG_CONFIG_INFO + printk(KERN_DEBUG "wavelan_attach(): almost done, calling pcmcia_register_client\n"); +#endif + + ret = pcmcia_register_client(&link->handle, &client_reg); + if(ret != 0) + { + cs_error(link->handle, RegisterClient, ret); + wavelan_detach(link); + return NULL; + } #ifdef DEBUG_CALLBACK_TRACE printk(KERN_DEBUG "<- wavelan_attach()\n"); #endif - return 0; + return link; } /*------------------------------------------------------------------*/ @@ -4701,10 +4711,8 @@ wavelan_attach(struct pcmcia_device *p_dev) * is released. */ static void -wavelan_detach(struct pcmcia_device *p_dev) +wavelan_detach(dev_link_t * link) { - dev_link_t *link = dev_to_instance(p_dev); - #ifdef DEBUG_CALLBACK_TRACE printk(KERN_DEBUG "-> wavelan_detach(0x%p)\n", link); #endif @@ -4721,6 +4729,31 @@ wavelan_detach(struct pcmcia_device *p_dev) wv_pcmcia_release(link); } + /* Break the link with Card Services */ + if(link->handle) + pcmcia_deregister_client(link->handle); + + /* Remove the interface data from the linked list */ + if(dev_list == link) + dev_list = link->next; + else + { + dev_link_t * prev = dev_list; + + while((prev != (dev_link_t *) NULL) && (prev->next != link)) + prev = prev->next; + + if(prev == (dev_link_t *) NULL) + { +#ifdef DEBUG_CONFIG_ERRORS + printk(KERN_WARNING "wavelan_detach : Attempting to remove a nonexistent device.\n"); +#endif + return; + } + + prev->next = link->next; + } + /* Free pieces */ if(link->priv) { @@ -4742,11 +4775,65 @@ wavelan_detach(struct pcmcia_device *p_dev) #endif } -static int wavelan_suspend(struct pcmcia_device *p_dev) +/*------------------------------------------------------------------*/ +/* + * The card status event handler. Mostly, this schedules other stuff + * to run after an event is received. A CARD_REMOVAL event also sets + * some flags to discourage the net drivers from trying to talk to the + * card any more. + */ +static int +wavelan_event(event_t event, /* The event received */ + int priority, + event_callback_args_t * args) { - dev_link_t *link = dev_to_instance(p_dev); - struct net_device * dev = (struct net_device *) link->priv; + dev_link_t * link = (dev_link_t *) args->client_data; + struct net_device * dev = (struct net_device *) link->priv; + +#ifdef DEBUG_CALLBACK_TRACE + printk(KERN_DEBUG "->wavelan_event(): %s\n", + ((event == CS_EVENT_REGISTRATION_COMPLETE)?"registration complete" : + ((event == CS_EVENT_CARD_REMOVAL) ? "card removal" : + ((event == CS_EVENT_CARD_INSERTION) ? "card insertion" : + ((event == CS_EVENT_PM_SUSPEND) ? "pm suspend" : + ((event == CS_EVENT_RESET_PHYSICAL) ? "physical reset" : + ((event == CS_EVENT_PM_RESUME) ? "pm resume" : + ((event == CS_EVENT_CARD_RESET) ? "card reset" : + "unknown")))))))); +#endif + + switch(event) + { + case CS_EVENT_REGISTRATION_COMPLETE: +#ifdef DEBUG_CONFIG_INFO + printk(KERN_DEBUG "wavelan_cs: registration complete\n"); +#endif + break; + case CS_EVENT_CARD_REMOVAL: + /* Oups ! The card is no more there */ + link->state &= ~DEV_PRESENT; + if(link->state & DEV_CONFIG) + { + /* Accept no more transmissions */ + netif_device_detach(dev); + + /* Release the card */ + wv_pcmcia_release(link); + } + break; + + case CS_EVENT_CARD_INSERTION: + /* Reset and configure the card */ + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + if(wv_pcmcia_config(link) && + wv_hw_config(dev)) + wv_init_info(dev); + else + dev->irq = 0; + break; + + case CS_EVENT_PM_SUSPEND: /* NB: wavelan_close will be called, but too late, so we are * obliged to close nicely the wavelan here. David, could you * close the device before suspending them ? And, by the way, @@ -4761,37 +4848,38 @@ static int wavelan_suspend(struct pcmcia_device *p_dev) /* The card is now suspended */ link->state |= DEV_SUSPEND; - + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if(link->state & DEV_CONFIG) - { - if(link->open) - netif_device_detach(dev); - pcmcia_release_configuration(link->handle); - } - - return 0; -} - -static int wavelan_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device * dev = (struct net_device *) link->priv; + { + if(link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if(link->state & DEV_CONFIG) - { - pcmcia_request_configuration(link->handle, &link->conf); - if(link->open) /* If RESET -> True, If RESUME -> False ? */ - { - wv_hw_reset(dev); - netif_device_attach(dev); - } - } + { + pcmcia_request_configuration(link->handle, &link->conf); + if(link->open) /* If RESET -> True, If RESUME -> False ? */ + { + wv_hw_reset(dev); + netif_device_attach(dev); + } + } + break; + } - return 0; +#ifdef DEBUG_CALLBACK_TRACE + printk(KERN_DEBUG "<-wavelan_event()\n"); +#endif + return 0; } - static struct pcmcia_device_id wavelan_ids[] = { PCMCIA_DEVICE_PROD_ID12("AT&T","WaveLAN/PCMCIA", 0xe7c5affd, 0x1bc50975), PCMCIA_DEVICE_PROD_ID12("Digital", "RoamAbout/DS", 0x9999ab35, 0x00d05e06), @@ -4806,11 +4894,10 @@ static struct pcmcia_driver wavelan_driver = { .drv = { .name = "wavelan_cs", }, - .probe = wavelan_attach, - .remove = wavelan_detach, + .attach = wavelan_attach, + .event = wavelan_event, + .detach = wavelan_detach, .id_table = wavelan_ids, - .suspend = wavelan_suspend, - .resume = wavelan_resume, }; static int __init diff --git a/trunk/drivers/net/wireless/wavelan_cs.p.h b/trunk/drivers/net/wireless/wavelan_cs.p.h index f2d597568151..724a715089c9 100644 --- a/trunk/drivers/net/wireless/wavelan_cs.p.h +++ b/trunk/drivers/net/wireless/wavelan_cs.p.h @@ -754,11 +754,20 @@ static void static int wavelan_open(struct net_device *), /* Open the device */ wavelan_close(struct net_device *); /* Close the device */ +static dev_link_t * + wavelan_attach(void); /* Create a new device */ static void - wavelan_detach(struct pcmcia_device *p_dev); /* Destroy a removed device */ + wavelan_detach(dev_link_t *); /* Destroy a removed device */ +static int + wavelan_event(event_t, /* Manage pcmcia events */ + int, + event_callback_args_t *); /**************************** VARIABLES ****************************/ +static dev_info_t dev_info = "wavelan_cs"; +static dev_link_t *dev_list = NULL; /* Linked list of devices */ + /* * Parameters that can be set with 'insmod' * The exact syntax is 'insmod wavelan_cs.o =' diff --git a/trunk/drivers/net/wireless/wl3501_cs.c b/trunk/drivers/net/wireless/wl3501_cs.c index 48e10b0c7e74..978fdc606781 100644 --- a/trunk/drivers/net/wireless/wl3501_cs.c +++ b/trunk/drivers/net/wireless/wl3501_cs.c @@ -105,6 +105,7 @@ module_param(pc_debug, int, 0); */ static void wl3501_config(dev_link_t *link); static void wl3501_release(dev_link_t *link); +static int wl3501_event(event_t event, int pri, event_callback_args_t *args); /* * The dev_info variable is the "key" that is used to match up this @@ -1497,11 +1498,9 @@ static struct ethtool_ops ops = { * Services. If it has been released, all local data structures are freed. * Otherwise, the structures will be freed when the device is released. */ -static void wl3501_detach(struct pcmcia_device *p_dev) +static void wl3501_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); dev_link_t **linkp; - struct net_device *dev = link->priv; /* Locate device structure */ for (linkp = &wl3501_dev_list; *linkp; linkp = &(*linkp)->next) @@ -1515,13 +1514,17 @@ static void wl3501_detach(struct pcmcia_device *p_dev) * function is called, that will trigger a proper detach(). */ if (link->state & DEV_CONFIG) { - while (link->open > 0) - wl3501_close(dev); - - netif_device_detach(dev); - wl3501_release(link); +#ifdef PCMCIA_DEBUG + printk(KERN_DEBUG "wl3501_cs: detach postponed, '%s' " + "still locked\n", link->dev->dev_name); +#endif + goto out; } + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + /* Unlink device structure, free pieces */ *linkp = link->next; @@ -1953,16 +1956,18 @@ static const struct iw_handler_def wl3501_handler_def = { * The dev_link structure is initialized, but we don't actually configure the * card at this point -- we wait until we receive a card insertion event. */ -static int wl3501_attach(struct pcmcia_device *p_dev) +static dev_link_t *wl3501_attach(void) { + client_reg_t client_reg; dev_link_t *link; struct net_device *dev; struct wl3501_card *this; + int ret; /* Initialize the dev_link_t structure */ link = kzalloc(sizeof(*link), GFP_KERNEL); if (!link) - return -ENOMEM; + goto out; /* The io structure describes IO port mapping */ link->io.NumPorts1 = 16; @@ -1998,17 +2003,24 @@ static int wl3501_attach(struct pcmcia_device *p_dev) netif_stop_queue(dev); link->priv = link->irq.Instance = dev; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - wl3501_config(link); - - return 0; + /* Register with Card Services */ + link->next = wl3501_dev_list; + wl3501_dev_list = link; + client_reg.dev_info = &wl3501_dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret) { + cs_error(link->handle, RegisterClient, ret); + wl3501_detach(link); + link = NULL; + } +out: + return link; out_link: kfree(link); link = NULL; - return -ENOMEM; + goto out; } #define CS_CHECK(fn, ret) \ @@ -2161,41 +2173,67 @@ static void wl3501_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int wl3501_suspend(struct pcmcia_device *p_dev) +/** + * wl3501_event - The card status event handler + * @event - event + * @pri - priority + * @args - arguments for this event + * + * The card status event handler. Mostly, this schedules other stuff to run + * after an event is received. A CARD_REMOVAL event also sets some flags to + * discourage the net drivers from trying to talk to the card any more. + * + * When a CARD_REMOVAL event is received, we immediately set a flag to block + * future accesses to this device. All the functions that actually access the + * device should check this flag to make sure the card is still present. + */ +static int wl3501_event(event_t event, int pri, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t *link = args->client_data; struct net_device *dev = link->priv; - link->state |= DEV_SUSPEND; - - wl3501_pwr_mgmt(dev->priv, WL3501_SUSPEND); - if (link->state & DEV_CONFIG) { - if (link->open) + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + while (link->open > 0) + wl3501_close(dev); netif_device_detach(dev); - pcmcia_release_configuration(link->handle); - } - - return 0; -} - -static int wl3501_resume(struct pcmcia_device *p_dev) -{ - dev_link_t *link = dev_to_instance(p_dev); - struct net_device *dev = link->priv; - - wl3501_pwr_mgmt(dev->priv, WL3501_RESUME); - if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - if (link->open) { - wl3501_reset(dev); - netif_device_attach(dev); + wl3501_release(link); } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + wl3501_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + wl3501_pwr_mgmt(dev->priv, WL3501_SUSPEND); + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) { + if (link->open) + netif_device_detach(dev); + pcmcia_release_configuration(link->handle); + } + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + wl3501_pwr_mgmt(dev->priv, WL3501_RESUME); + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + if (link->open) { + wl3501_reset(dev); + netif_device_attach(dev); + } + } + break; } - return 0; } - static struct pcmcia_device_id wl3501_ids[] = { PCMCIA_DEVICE_MANF_CARD(0xd601, 0x0001), PCMCIA_DEVICE_NULL @@ -2207,11 +2245,10 @@ static struct pcmcia_driver wl3501_driver = { .drv = { .name = "wl3501_cs", }, - .probe = wl3501_attach, - .remove = wl3501_detach, + .attach = wl3501_attach, + .event = wl3501_event, + .detach = wl3501_detach, .id_table = wl3501_ids, - .suspend = wl3501_suspend, - .resume = wl3501_resume, }; static int __init wl3501_init_module(void) diff --git a/trunk/drivers/parport/parport_cs.c b/trunk/drivers/parport/parport_cs.c index 158d92563259..24e6aacddb74 100644 --- a/trunk/drivers/parport/parport_cs.c +++ b/trunk/drivers/parport/parport_cs.c @@ -87,9 +87,15 @@ typedef struct parport_info_t { struct parport *port; } parport_info_t; -static void parport_detach(struct pcmcia_device *p_dev); +static dev_link_t *parport_attach(void); +static void parport_detach(dev_link_t *); static void parport_config(dev_link_t *link); static void parport_cs_release(dev_link_t *); +static int parport_event(event_t event, int priority, + event_callback_args_t *args); + +static dev_info_t dev_info = "parport_cs"; +static dev_link_t *dev_list = NULL; /*====================================================================== @@ -99,16 +105,18 @@ static void parport_cs_release(dev_link_t *); ======================================================================*/ -static int parport_attach(struct pcmcia_device *p_dev) +static dev_link_t *parport_attach(void) { parport_info_t *info; dev_link_t *link; - + client_reg_t client_reg; + int ret; + DEBUG(0, "parport_attach()\n"); /* Create new parport device */ info = kmalloc(sizeof(*info), GFP_KERNEL); - if (!info) return -ENOMEM; + if (!info) return NULL; memset(info, 0, sizeof(*info)); link = &info->link; link->priv = info; @@ -119,14 +127,21 @@ static int parport_attach(struct pcmcia_device *p_dev) link->conf.Attributes = CONF_ENABLE_IRQ; link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; - - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - parport_config(link); - - return 0; + + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + parport_detach(link); + return NULL; + } + + return link; } /* parport_attach */ /*====================================================================== @@ -138,16 +153,32 @@ static int parport_attach(struct pcmcia_device *p_dev) ======================================================================*/ -static void parport_detach(struct pcmcia_device *p_dev) +static void parport_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; + int ret; DEBUG(0, "parport_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; if (link->state & DEV_CONFIG) parport_cs_release(link); - + + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + /* Unlink, free device structure */ + *linkp = link->next; kfree(link->priv); + } /* parport_detach */ /*====================================================================== @@ -294,27 +325,47 @@ void parport_cs_release(dev_link_t *link) } /* parport_cs_release */ -static int parport_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); +/*====================================================================== - return 0; -} + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. + +======================================================================*/ -static int parport_resume(struct pcmcia_device *dev) +int parport_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; + DEBUG(1, "parport_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + parport_cs_release(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + parport_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (DEV_OK(link)) - pcmcia_request_configuration(link->handle, &link->conf); - - return 0; -} + pcmcia_request_configuration(link->handle, &link->conf); + break; + } + return 0; +} /* parport_event */ static struct pcmcia_device_id parport_ids[] = { PCMCIA_DEVICE_FUNC_ID(3), @@ -328,11 +379,11 @@ static struct pcmcia_driver parport_cs_driver = { .drv = { .name = "parport_cs", }, - .probe = parport_attach, - .remove = parport_detach, + .attach = parport_attach, + .event = parport_event, + .detach = parport_detach, .id_table = parport_ids, - .suspend = parport_suspend, - .resume = parport_resume, + }; static int __init init_parport_cs(void) @@ -343,6 +394,7 @@ static int __init init_parport_cs(void) static void __exit exit_parport_cs(void) { pcmcia_unregister_driver(&parport_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_parport_cs); diff --git a/trunk/drivers/pci/hotplug.c b/trunk/drivers/pci/hotplug.c index 1c97e7dd130b..e1743be31909 100644 --- a/trunk/drivers/pci/hotplug.c +++ b/trunk/drivers/pci/hotplug.c @@ -3,8 +3,8 @@ #include #include "pci.h" -int pci_uevent(struct device *dev, char **envp, int num_envp, - char *buffer, int buffer_size) +int pci_hotplug (struct device *dev, char **envp, int num_envp, + char *buffer, int buffer_size) { struct pci_dev *pdev; int i = 0; @@ -17,34 +17,34 @@ int pci_uevent(struct device *dev, char **envp, int num_envp, if (!pdev) return -ENODEV; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PCI_CLASS=%04X", pdev->class)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PCI_CLASS=%04X", pdev->class)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PCI_ID=%04X:%04X", pdev->vendor, pdev->device)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PCI_ID=%04X:%04X", pdev->vendor, pdev->device)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor, - pdev->subsystem_device)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor, + pdev->subsystem_device)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PCI_SLOT_NAME=%s", pci_name(pdev))) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PCI_SLOT_NAME=%s", pci_name(pdev))) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x", - pdev->vendor, pdev->device, - pdev->subsystem_vendor, pdev->subsystem_device, - (u8)(pdev->class >> 16), (u8)(pdev->class >> 8), - (u8)(pdev->class))) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x", + pdev->vendor, pdev->device, + pdev->subsystem_vendor, pdev->subsystem_device, + (u8)(pdev->class >> 16), (u8)(pdev->class >> 8), + (u8)(pdev->class))) return -ENOMEM; envp[i] = NULL; diff --git a/trunk/drivers/pci/pci-driver.c b/trunk/drivers/pci/pci-driver.c index 7146b69b812c..a9046d4b8af3 100644 --- a/trunk/drivers/pci/pci-driver.c +++ b/trunk/drivers/pci/pci-driver.c @@ -502,8 +502,8 @@ void pci_dev_put(struct pci_dev *dev) } #ifndef CONFIG_HOTPLUG -int pci_uevent(struct device *dev, char **envp, int num_envp, - char *buffer, int buffer_size) +int pci_hotplug (struct device *dev, char **envp, int num_envp, + char *buffer, int buffer_size) { return -ENODEV; } @@ -512,7 +512,7 @@ int pci_uevent(struct device *dev, char **envp, int num_envp, struct bus_type pci_bus_type = { .name = "pci", .match = pci_bus_match, - .uevent = pci_uevent, + .hotplug = pci_hotplug, .suspend = pci_device_suspend, .resume = pci_device_resume, .dev_attrs = pci_dev_attrs, diff --git a/trunk/drivers/pci/pci.h b/trunk/drivers/pci/pci.h index 294849d24590..6527b36c9a61 100644 --- a/trunk/drivers/pci/pci.h +++ b/trunk/drivers/pci/pci.h @@ -1,7 +1,7 @@ /* Functions internal to the PCI core code */ -extern int pci_uevent(struct device *dev, char **envp, int num_envp, - char *buffer, int buffer_size); +extern int pci_hotplug (struct device *dev, char **envp, int num_envp, + char *buffer, int buffer_size); extern int pci_create_sysfs_dev_files(struct pci_dev *pdev); extern void pci_remove_sysfs_dev_files(struct pci_dev *pdev); extern void pci_cleanup_rom(struct pci_dev *dev); diff --git a/trunk/drivers/pci/quirks.c b/trunk/drivers/pci/quirks.c index f28ebdd3958a..3a4f49f4effb 100644 --- a/trunk/drivers/pci/quirks.c +++ b/trunk/drivers/pci/quirks.c @@ -1098,23 +1098,6 @@ static void __init quirk_alder_ioapic(struct pci_dev *pdev) DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EESSC, quirk_alder_ioapic ); #endif -enum ide_combined_type { COMBINED = 0, IDE = 1, LIBATA = 2 }; -/* Defaults to combined */ -static enum ide_combined_type combined_mode; - -static int __init combined_setup(char *str) -{ - if (!strncmp(str, "ide", 3)) - combined_mode = IDE; - else if (!strncmp(str, "libata", 6)) - combined_mode = LIBATA; - else /* "combined" or anything else defaults to old behavior */ - combined_mode = COMBINED; - - return 1; -} -__setup("combined_mode=", combined_setup); - #ifdef CONFIG_SCSI_SATA_INTEL_COMBINED static void __devinit quirk_intel_ide_combined(struct pci_dev *pdev) { @@ -1181,19 +1164,6 @@ static void __devinit quirk_intel_ide_combined(struct pci_dev *pdev) if (prog & comb) return; - /* Don't reserve any so the IDE driver can get them (but only if - * combined_mode=ide). - */ - if (combined_mode == IDE) - return; - - /* Grab them both for libata if combined_mode=libata. */ - if (combined_mode == LIBATA) { - request_region(0x1f0, 8, "libata"); /* port 0 */ - request_region(0x170, 8, "libata"); /* port 1 */ - return; - } - /* SATA port is in legacy mode. Reserve port so that * IDE driver does not attempt to use it. If request_region * fails, it will be obvious at boot time, so we don't bother diff --git a/trunk/drivers/pcmcia/Kconfig b/trunk/drivers/pcmcia/Kconfig index 1f4ad0e7836e..309eb557f9a3 100644 --- a/trunk/drivers/pcmcia/Kconfig +++ b/trunk/drivers/pcmcia/Kconfig @@ -116,31 +116,6 @@ config YENTA If unsure, say Y. -config YENTA_O2 - default y - bool "Special initialization for O2Micro bridges" if EMBEDDED - depends on YENTA - -config YENTA_RICOH - default y - bool "Special initialization for Ricoh bridges" if EMBEDDED - depends on YENTA - -config YENTA_TI - default y - bool "Special initialization for TI and EnE bridges" if EMBEDDED - depends on YENTA - -config YENTA_ENE_TUNE - default y - bool "Auto-tune EnE bridges for CB cards" if EMBEDDED - depends on YENTA_TI && CARDBUS - -config YENTA_TOSHIBA - default y - bool "Special initialization for Toshiba ToPIC bridges" if EMBEDDED - depends on YENTA - config PD6729 tristate "Cirrus PD6729 compatible bridge support" depends on PCMCIA && PCI @@ -182,7 +157,7 @@ config TCIC config PCMCIA_M8XX tristate "MPC8xx PCMCIA support" depends on PCMCIA && PPC && 8xx - select PCCARD_IODYN + select PCCARD_NONSTATIC help Say Y here to include support for PowerPC 8xx series PCMCIA controller. @@ -225,7 +200,7 @@ config PCMCIA_PXA2XX config PCMCIA_PROBE bool - default y if ISA && !ARCH_SA1100 && !ARCH_CLPS711X && !PARISC + default y if ISA && !ARCH_SA1100 && !ARCH_CLPS711X config M32R_PCC bool "M32R PCMCIA I/F" @@ -266,9 +241,6 @@ config OMAP_CF config PCCARD_NONSTATIC tristate -config PCCARD_IODYN - bool - endif # PCCARD endmenu diff --git a/trunk/drivers/pcmcia/au1000_generic.c b/trunk/drivers/pcmcia/au1000_generic.c index 971a35281649..87302c548c24 100644 --- a/trunk/drivers/pcmcia/au1000_generic.c +++ b/trunk/drivers/pcmcia/au1000_generic.c @@ -241,6 +241,23 @@ au1x00_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status) return 0; } +/* au1x00_pcmcia_get_socket() + * Implements the get_socket() operation for the in-kernel PCMCIA + * service (formerly SS_GetSocket in Card Services). Not a very + * exciting routine. + * + * Returns: 0 + */ +static int +au1x00_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state) +{ + struct au1000_pcmcia_socket *skt = to_au1000_socket(sock); + + debug("for sock %u\n", skt->nr); + *state = skt->cs_state; + return 0; +} + /* au1x00_pcmcia_set_socket() * Implements the set_socket() operation for the in-kernel PCMCIA * service (formerly SS_SetSocket in Card Services). We more or @@ -335,6 +352,7 @@ static struct pccard_operations au1x00_pcmcia_operations = { .init = au1x00_pcmcia_sock_init, .suspend = au1x00_pcmcia_suspend, .get_status = au1x00_pcmcia_get_status, + .get_socket = au1x00_pcmcia_get_socket, .set_socket = au1x00_pcmcia_set_socket, .set_io_map = au1x00_pcmcia_set_io_map, .set_mem_map = au1x00_pcmcia_set_mem_map, @@ -354,12 +372,13 @@ int au1x00_pcmcia_socket_probe(struct device *dev, struct pcmcia_low_level *ops, struct skt_dev_info *sinfo; int ret, i; - sinfo = kzalloc(sizeof(struct skt_dev_info), GFP_KERNEL); + sinfo = kmalloc(sizeof(struct skt_dev_info), GFP_KERNEL); if (!sinfo) { ret = -ENOMEM; goto out; } + memset(sinfo, 0, sizeof(struct skt_dev_info)); sinfo->nskt = nr; /* diff --git a/trunk/drivers/pcmcia/cistpl.c b/trunk/drivers/pcmcia/cistpl.c index 120fa8da6392..2dc3e611a9a3 100644 --- a/trunk/drivers/pcmcia/cistpl.c +++ b/trunk/drivers/pcmcia/cistpl.c @@ -60,9 +60,9 @@ static const u_int exponent[] = { /* Parameters that can be set with 'insmod' */ -/* 16-bit CIS? */ -static int cis_width; -module_param(cis_width, int, 0444); +#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444) + +INT_MODULE_PARM(cis_width, 0); /* 16-bit CIS? */ void release_cis_mem(struct pcmcia_socket *s) { @@ -463,7 +463,7 @@ static int follow_link(struct pcmcia_socket *s, tuple_t *tuple) /* Get indirect link from the MFC tuple */ read_cis_cache(s, LINK_SPACE(tuple->Flags), tuple->LinkOffset, 5, link); - ofs = le32_to_cpu(*(__le32 *)(link+1)); + ofs = le32_to_cpu(*(u_int *)(link+1)); SPACE(tuple->Flags) = (link[0] == CISTPL_MFC_ATTR); /* Move to the next indirect link */ tuple->LinkOffset += 5; @@ -671,8 +671,8 @@ static int parse_checksum(tuple_t *tuple, cistpl_checksum_t *csum) if (tuple->TupleDataLen < 5) return CS_BAD_TUPLE; p = (u_char *)tuple->TupleData; - csum->addr = tuple->CISOffset+(short)le16_to_cpu(*(__le16 *)p)-2; - csum->len = le16_to_cpu(*(__le16 *)(p + 2)); + csum->addr = tuple->CISOffset+(short)le16_to_cpu(*(u_short *)p)-2; + csum->len = le16_to_cpu(*(u_short *)(p + 2)); csum->sum = *(p+4); return CS_SUCCESS; } @@ -683,7 +683,7 @@ static int parse_longlink(tuple_t *tuple, cistpl_longlink_t *link) { if (tuple->TupleDataLen < 4) return CS_BAD_TUPLE; - link->addr = le32_to_cpu(*(__le32 *)tuple->TupleData); + link->addr = le32_to_cpu(*(u_int *)tuple->TupleData); return CS_SUCCESS; } @@ -702,7 +702,7 @@ static int parse_longlink_mfc(tuple_t *tuple, return CS_BAD_TUPLE; for (i = 0; i < link->nfn; i++) { link->fn[i].space = *p; p++; - link->fn[i].addr = le32_to_cpu(*(__le32 *)p); p += 4; + link->fn[i].addr = le32_to_cpu(*(u_int *)p); p += 4; } return CS_SUCCESS; } @@ -789,10 +789,10 @@ static int parse_jedec(tuple_t *tuple, cistpl_jedec_t *jedec) static int parse_manfid(tuple_t *tuple, cistpl_manfid_t *m) { - __le16 *p; + u_short *p; if (tuple->TupleDataLen < 4) return CS_BAD_TUPLE; - p = (__le16 *)tuple->TupleData; + p = (u_short *)tuple->TupleData; m->manf = le16_to_cpu(p[0]); m->card = le16_to_cpu(p[1]); return CS_SUCCESS; @@ -1093,7 +1093,7 @@ static int parse_cftable_entry(tuple_t *tuple, break; case 0x20: entry->mem.nwin = 1; - entry->mem.win[0].len = le16_to_cpu(*(__le16 *)p) << 8; + entry->mem.win[0].len = le16_to_cpu(*(u_short *)p) << 8; entry->mem.win[0].card_addr = 0; entry->mem.win[0].host_addr = 0; p += 2; @@ -1101,9 +1101,9 @@ static int parse_cftable_entry(tuple_t *tuple, break; case 0x40: entry->mem.nwin = 1; - entry->mem.win[0].len = le16_to_cpu(*(__le16 *)p) << 8; + entry->mem.win[0].len = le16_to_cpu(*(u_short *)p) << 8; entry->mem.win[0].card_addr = - le16_to_cpu(*(__le16 *)(p+2)) << 8; + le16_to_cpu(*(u_short *)(p+2)) << 8; entry->mem.win[0].host_addr = 0; p += 4; if (p > q) return CS_BAD_TUPLE; @@ -1140,7 +1140,7 @@ static int parse_bar(tuple_t *tuple, cistpl_bar_t *bar) p = (u_char *)tuple->TupleData; bar->attr = *p; p += 2; - bar->size = le32_to_cpu(*(__le32 *)p); + bar->size = le32_to_cpu(*(u_int *)p); return CS_SUCCESS; } @@ -1153,7 +1153,7 @@ static int parse_config_cb(tuple_t *tuple, cistpl_config_t *config) return CS_BAD_TUPLE; config->last_idx = *(++p); p++; - config->base = le32_to_cpu(*(__le32 *)p); + config->base = le32_to_cpu(*(u_int *)p); config->subtuples = tuple->TupleDataLen - 6; return CS_SUCCESS; } @@ -1269,7 +1269,7 @@ static int parse_vers_2(tuple_t *tuple, cistpl_vers_2_t *v2) v2->vers = p[0]; v2->comply = p[1]; - v2->dindex = le16_to_cpu(*(__le16 *)(p+2)); + v2->dindex = le16_to_cpu(*(u_short *)(p+2)); v2->vspec8 = p[6]; v2->vspec9 = p[7]; v2->nhdr = p[8]; @@ -1310,8 +1310,8 @@ static int parse_format(tuple_t *tuple, cistpl_format_t *fmt) fmt->type = p[0]; fmt->edc = p[1]; - fmt->offset = le32_to_cpu(*(__le32 *)(p+2)); - fmt->length = le32_to_cpu(*(__le32 *)(p+6)); + fmt->offset = le32_to_cpu(*(u_int *)(p+2)); + fmt->length = le32_to_cpu(*(u_int *)(p+6)); return CS_SUCCESS; } diff --git a/trunk/drivers/pcmcia/cs.c b/trunk/drivers/pcmcia/cs.c index 613f2f1fbfdd..a30aa74304a2 100644 --- a/trunk/drivers/pcmcia/cs.c +++ b/trunk/drivers/pcmcia/cs.c @@ -309,6 +309,41 @@ struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr) } EXPORT_SYMBOL(pcmcia_get_socket_by_nr); + +/** + * socket_setup() and shutdown_socket() are called by the main event + * handler when card insertion and removal events are received. + * socket_setup() turns on socket power and resets the socket, in two stages. + * shutdown_socket() unconfigures a socket and turns off socket power. + */ +static void shutdown_socket(struct pcmcia_socket *s) +{ + cs_dbg(s, 1, "shutdown_socket\n"); + + /* Blank out the socket state */ + s->socket = dead_socket; + s->ops->init(s); + s->ops->set_socket(s, &s->socket); + s->irq.AssignedIRQ = s->irq.Config = 0; + s->lock_count = 0; + destroy_cis_cache(s); +#ifdef CONFIG_CARDBUS + cb_free(s); +#endif + s->functions = 0; + kfree(s->config); + s->config = NULL; + + { + int status; + s->ops->get_status(s, &status); + if (status & SS_POWERON) { + printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s); + } + } +} /* shutdown_socket */ + + /** * The central event handler. Send_event() sends an event to the * 16-bit subsystem, which then calls the relevant device drivers. @@ -348,6 +383,17 @@ static void socket_remove_drivers(struct pcmcia_socket *skt) send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH); } +static void socket_shutdown(struct pcmcia_socket *skt) +{ + cs_dbg(skt, 4, "shutdown\n"); + + socket_remove_drivers(skt); + skt->state &= SOCKET_INUSE|SOCKET_PRESENT; + msleep(shutdown_delay * 10); + skt->state &= SOCKET_INUSE; + shutdown_socket(skt); +} + static int socket_reset(struct pcmcia_socket *skt) { int status, i; @@ -378,45 +424,6 @@ static int socket_reset(struct pcmcia_socket *skt) return CS_GENERAL_FAILURE; } -/** - * socket_setup() and socket_shutdown() are called by the main event handler - * when card insertion and removal events are received. - * socket_setup() turns on socket power and resets the socket, in two stages. - * socket_shutdown() unconfigures a socket and turns off socket power. - */ -static void socket_shutdown(struct pcmcia_socket *s) -{ - int status; - - cs_dbg(s, 4, "shutdown\n"); - - socket_remove_drivers(s); - s->state &= SOCKET_INUSE | SOCKET_PRESENT; - msleep(shutdown_delay * 10); - s->state &= SOCKET_INUSE; - - /* Blank out the socket state */ - s->socket = dead_socket; - s->ops->init(s); - s->ops->set_socket(s, &s->socket); - s->irq.AssignedIRQ = s->irq.Config = 0; - s->lock_count = 0; - destroy_cis_cache(s); -#ifdef CONFIG_CARDBUS - cb_free(s); -#endif - s->functions = 0; - kfree(s->config); - s->config = NULL; - - s->ops->get_status(s, &status); - if (status & SS_POWERON) { - printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s); - } - - cs_socket_put(s); -} - static int socket_setup(struct pcmcia_socket *skt, int initial_delay) { int status, i; @@ -522,6 +529,7 @@ static int socket_insert(struct pcmcia_socket *skt) send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); } else { socket_shutdown(skt); + cs_socket_put(skt); } return ret; @@ -585,6 +593,7 @@ static int socket_resume(struct pcmcia_socket *skt) } } else { socket_shutdown(skt); + cs_socket_put(skt); } skt->state &= ~SOCKET_SUSPEND; @@ -596,6 +605,7 @@ static void socket_remove(struct pcmcia_socket *skt) { printk(KERN_NOTICE "pccard: card ejected from slot %d\n", skt->sock); socket_shutdown(skt); + cs_socket_put(skt); } /* @@ -770,13 +780,8 @@ int pccard_reset_card(struct pcmcia_socket *skt) ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW); if (ret == 0) { send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW); - if (skt->callback) - skt->callback->suspend(skt); - if (socket_reset(skt) == CS_SUCCESS) { + if (socket_reset(skt) == CS_SUCCESS) send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW); - if (skt->callback) - skt->callback->resume(skt); - } } ret = CS_SUCCESS; @@ -807,11 +812,6 @@ int pcmcia_suspend_card(struct pcmcia_socket *skt) ret = CS_UNSUPPORTED_FUNCTION; break; } - if (skt->callback) { - ret = skt->callback->suspend(skt); - if (ret) - break; - } ret = socket_suspend(skt); } while (0); up(&skt->skt_sem); @@ -838,8 +838,6 @@ int pcmcia_resume_card(struct pcmcia_socket *skt) break; } ret = socket_resume(skt); - if (!ret && skt->callback) - skt->callback->resume(skt); } while (0); up(&skt->skt_sem); @@ -903,14 +901,14 @@ int pcmcia_insert_card(struct pcmcia_socket *skt) EXPORT_SYMBOL(pcmcia_insert_card); -static int pcmcia_socket_uevent(struct class_device *dev, char **envp, - int num_envp, char *buffer, int buffer_size) +static int pcmcia_socket_hotplug(struct class_device *dev, char **envp, + int num_envp, char *buffer, int buffer_size) { struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev); int i = 0, length = 0; - if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, - &length, "SOCKET_NO=%u", s->sock)) + if (add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, + &length, "SOCKET_NO=%u", s->sock)) return -ENOMEM; envp[i] = NULL; @@ -929,7 +927,7 @@ static void pcmcia_release_socket_class(struct class *data) struct class pcmcia_socket_class = { .name = "pcmcia_socket", - .uevent = pcmcia_socket_uevent, + .hotplug = pcmcia_socket_hotplug, .release = pcmcia_release_socket, .class_release = pcmcia_release_socket_class, }; diff --git a/trunk/drivers/pcmcia/cs_internal.h b/trunk/drivers/pcmcia/cs_internal.h index 7b37eba35bf1..55867bc7f199 100644 --- a/trunk/drivers/pcmcia/cs_internal.h +++ b/trunk/drivers/pcmcia/cs_internal.h @@ -117,7 +117,7 @@ int verify_cis_cache(struct pcmcia_socket *s); int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function, cisdata_t code, void *parse); /* In rsrc_mgr */ -int pcmcia_validate_mem(struct pcmcia_socket *s); +void pcmcia_validate_mem(struct pcmcia_socket *s); struct resource *pcmcia_find_io_region(unsigned long base, int num, unsigned long align, struct pcmcia_socket *s); int pcmcia_adjust_io_region(struct resource *res, unsigned long r_start, @@ -143,8 +143,6 @@ struct pcmcia_callback{ struct module *owner; int (*event) (struct pcmcia_socket *s, event_t event, int priority); void (*requery) (struct pcmcia_socket *s); - int (*suspend) (struct pcmcia_socket *s); - int (*resume) (struct pcmcia_socket *s); }; int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c); diff --git a/trunk/drivers/pcmcia/ds.c b/trunk/drivers/pcmcia/ds.c index 0252582b91cd..7f8219f3fd9e 100644 --- a/trunk/drivers/pcmcia/ds.c +++ b/trunk/drivers/pcmcia/ds.c @@ -57,6 +57,8 @@ module_param_named(pc_debug, ds_pc_debug, int, 0644); spinlock_t pcmcia_dev_list_lock; +static int unbind_request(struct pcmcia_socket *s); + /*====================================================================*/ /* code which was in cs.c before */ @@ -203,7 +205,7 @@ static void pcmcia_check_driver(struct pcmcia_driver *p_drv) unsigned int i; u32 hash; - if (!p_drv->probe || !p_drv->remove) + if (!p_drv->attach || !p_drv->event || !p_drv->detach) printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback " "function\n", p_drv->drv.name); @@ -264,10 +266,12 @@ static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) if (fw->size >= CISTPL_MAX_CIS_SIZE) goto release; - cis = kzalloc(sizeof(cisdump_t), GFP_KERNEL); + cis = kmalloc(sizeof(cisdump_t), GFP_KERNEL); if (!cis) goto release; + memset(cis, 0, sizeof(cisdump_t)); + cis->Length = fw->size + 1; memcpy(cis->Data, fw->data, fw->size); @@ -359,7 +363,6 @@ static int pcmcia_device_probe(struct device * dev) { struct pcmcia_device *p_dev; struct pcmcia_driver *p_drv; - struct pcmcia_socket *s; int ret = 0; dev = get_device(dev); @@ -368,38 +371,25 @@ static int pcmcia_device_probe(struct device * dev) p_dev = to_pcmcia_dev(dev); p_drv = to_pcmcia_drv(dev->driver); - s = p_dev->socket; - if ((!p_drv->probe) || (!try_module_get(p_drv->owner))) { + if (!try_module_get(p_drv->owner)) { ret = -EINVAL; goto put_dev; } - p_dev->state &= ~CLIENT_UNBOUND; - - /* set up the device configuration, if it hasn't been done before */ - if (!s->functions) { - cistpl_longlink_mfc_t mfc; - if (pccard_read_tuple(s, p_dev->func, CISTPL_LONGLINK_MFC, - &mfc) == CS_SUCCESS) - s->functions = mfc.nfn; - else - s->functions = 1; - s->config = kzalloc(sizeof(config_t) * s->functions, - GFP_KERNEL); - if (!s->config) { - ret = -ENOMEM; - goto put_module; + if (p_drv->attach) { + p_dev->instance = p_drv->attach(); + if ((!p_dev->instance) || (p_dev->state & CLIENT_UNBOUND)) { + printk(KERN_NOTICE "ds: unable to create instance " + "of '%s'!\n", p_drv->drv.name); + ret = -EINVAL; } } - ret = p_drv->probe(p_dev); - - put_module: if (ret) module_put(p_drv->owner); put_dev: - if (ret) + if ((ret) || !(p_drv->attach)) put_device(dev); return (ret); } @@ -409,66 +399,24 @@ static int pcmcia_device_remove(struct device * dev) { struct pcmcia_device *p_dev; struct pcmcia_driver *p_drv; - int i; /* detach the "instance" */ p_dev = to_pcmcia_dev(dev); p_drv = to_pcmcia_drv(dev->driver); - if (!p_drv) - return 0; - - if (p_drv->remove) - p_drv->remove(p_dev); - - /* check for proper unloading */ - if (p_dev->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED)) - printk(KERN_INFO "pcmcia: driver %s did not release config properly\n", - p_drv->drv.name); - - for (i = 0; i < MAX_WIN; i++) - if (p_dev->state & CLIENT_WIN_REQ(i)) - printk(KERN_INFO "pcmcia: driver %s did not release windows properly\n", - p_drv->drv.name); - /* references from pcmcia_probe_device */ - p_dev->state = CLIENT_UNBOUND; - pcmcia_put_dev(p_dev); - module_put(p_drv->owner); + if (p_drv) { + if ((p_drv->detach) && (p_dev->instance)) { + p_drv->detach(p_dev->instance); + /* from pcmcia_probe_device */ + put_device(&p_dev->dev); + } + module_put(p_drv->owner); + } return 0; } -/* - * Removes a PCMCIA card from the device tree and socket list. - */ -static void pcmcia_card_remove(struct pcmcia_socket *s) -{ - struct pcmcia_device *p_dev; - unsigned long flags; - - ds_dbg(2, "unbind_request(%d)\n", s->sock); - - s->device_count = 0; - - for (;;) { - /* unregister all pcmcia_devices registered with this socket*/ - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); - if (list_empty(&s->devices_list)) { - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); - return; - } - p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list); - list_del(&p_dev->socket_device_list); - p_dev->state |= CLIENT_STALE; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); - - device_unregister(&p_dev->dev); - } - - return; -} /* unbind_request */ - /* * pcmcia_device_query -- determine information about a pcmcia device @@ -569,9 +517,10 @@ struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int f if (s->device_count == 2) goto err_put; - p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL); + p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL); if (!p_dev) goto err_put; + memset(p_dev, 0, sizeof(struct pcmcia_device)); p_dev->socket = s; p_dev->device_no = (s->device_count++); @@ -634,9 +583,7 @@ static int pcmcia_card_add(struct pcmcia_socket *s) if (!(s->resource_setup_done)) return -EAGAIN; /* try again, but later... */ - if (pcmcia_validate_mem(s)) - return -EAGAIN; /* try again, but later... */ - + pcmcia_validate_mem(s); ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo); if (ret || !cisinfo.Chains) { ds_dbg(0, "invalid CIS or invalid resources\n"); @@ -832,8 +779,8 @@ static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) { #ifdef CONFIG_HOTPLUG -static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp, - char *buffer, int buffer_size) +static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp, + char *buffer, int buffer_size) { struct pcmcia_device *p_dev; int i, length = 0; @@ -853,31 +800,31 @@ static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp, i = 0; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "SOCKET_NO=%u", - p_dev->socket->sock)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "SOCKET_NO=%u", + p_dev->socket->sock)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "DEVICE_NO=%02X", - p_dev->device_no)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "DEVICE_NO=%02X", + p_dev->device_no)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" - "pa%08Xpb%08Xpc%08Xpd%08X", - p_dev->has_manf_id ? p_dev->manf_id : 0, - p_dev->has_card_id ? p_dev->card_id : 0, - p_dev->has_func_id ? p_dev->func_id : 0, - p_dev->func, - p_dev->device_no, - hash[0], - hash[1], - hash[2], - hash[3])) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" + "pa%08Xpb%08Xpc%08Xpd%08X", + p_dev->has_manf_id ? p_dev->manf_id : 0, + p_dev->has_card_id ? p_dev->card_id : 0, + p_dev->has_func_id ? p_dev->func_id : 0, + p_dev->func, + p_dev->device_no, + hash[0], + hash[1], + hash[2], + hash[3])) return -ENOMEM; envp[i] = NULL; @@ -887,7 +834,7 @@ static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp, #else -static int pcmcia_bus_uevent(struct device *dev, char **envp, int num_envp, +static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { return -ENODEV; @@ -971,84 +918,55 @@ static struct device_attribute pcmcia_dev_attrs[] = { __ATTR_NULL, }; -/* PM support, also needed for reset */ - -static int pcmcia_dev_suspend(struct device * dev, pm_message_t state) -{ - struct pcmcia_device *p_dev = to_pcmcia_dev(dev); - struct pcmcia_driver *p_drv = NULL; - - if (dev->driver) - p_drv = to_pcmcia_drv(dev->driver); - - if (p_drv && p_drv->suspend) - return p_drv->suspend(p_dev); - - return 0; -} - - -static int pcmcia_dev_resume(struct device * dev) -{ - struct pcmcia_device *p_dev = to_pcmcia_dev(dev); - struct pcmcia_driver *p_drv = NULL; - - if (dev->driver) - p_drv = to_pcmcia_drv(dev->driver); - if (p_drv && p_drv->resume) - return p_drv->resume(p_dev); +/*====================================================================== - return 0; -} + The card status event handler. + +======================================================================*/ +struct send_event_data { + struct pcmcia_socket *skt; + event_t event; + int priority; +}; -static int pcmcia_bus_suspend_callback(struct device *dev, void * _data) +static int send_event_callback(struct device *dev, void * _data) { - struct pcmcia_socket *skt = _data; struct pcmcia_device *p_dev = to_pcmcia_dev(dev); + struct pcmcia_driver *p_drv; + struct send_event_data *data = _data; - if (p_dev->socket != skt) + /* we get called for all sockets, but may only pass the event + * for drivers _on the affected socket_ */ + if (p_dev->socket != data->skt) return 0; - return dpm_runtime_suspend(dev, PMSG_SUSPEND); -} - -static int pcmcia_bus_resume_callback(struct device *dev, void * _data) -{ - struct pcmcia_socket *skt = _data; - struct pcmcia_device *p_dev = to_pcmcia_dev(dev); - - if (p_dev->socket != skt) + p_drv = to_pcmcia_drv(p_dev->dev.driver); + if (!p_drv) return 0; - dpm_runtime_resume(dev); + if (p_dev->state & (CLIENT_UNBOUND|CLIENT_STALE)) + return 0; - return 0; -} + if (p_drv->event) + return p_drv->event(data->event, data->priority, + &p_dev->event_callback_args); -static int pcmcia_bus_resume(struct pcmcia_socket *skt) -{ - bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback); return 0; } -static int pcmcia_bus_suspend(struct pcmcia_socket *skt) +static int send_event(struct pcmcia_socket *s, event_t event, int priority) { - if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt, - pcmcia_bus_suspend_callback)) { - pcmcia_bus_resume(skt); - return -EIO; - } - return 0; -} + struct send_event_data private; + private.skt = s; + private.event = event; + private.priority = priority; -/*====================================================================== + return bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback); +} /* send_event */ - The card status event handler. - -======================================================================*/ /* Normally, the event is passed to individual drivers after * informing userspace. Only for CS_EVENT_CARD_REMOVAL this @@ -1058,17 +976,20 @@ static int pcmcia_bus_suspend(struct pcmcia_socket *skt) static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) { struct pcmcia_socket *s = pcmcia_get_socket(skt); + int ret = 0; ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n", event, priority, skt); - + switch (event) { + case CS_EVENT_CARD_REMOVAL: s->pcmcia_state.present = 0; - pcmcia_card_remove(skt); + send_event(skt, event, priority); + unbind_request(skt); handle_event(skt, event); break; - + case CS_EVENT_CARD_INSERTION: s->pcmcia_state.present = 1; pcmcia_card_add(skt); @@ -1076,14 +997,12 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) break; case CS_EVENT_EJECTION_REQUEST: + ret = send_event(skt, event, priority); break; - case CS_EVENT_PM_SUSPEND: - case CS_EVENT_PM_RESUME: - case CS_EVENT_RESET_PHYSICAL: - case CS_EVENT_CARD_RESET: default: handle_event(skt, event); + send_event(skt, event, priority); break; } @@ -1093,12 +1012,152 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) } /* ds_event */ + +int pcmcia_register_client(struct pcmcia_device **handle, client_reg_t *req) +{ + struct pcmcia_socket *s = NULL; + struct pcmcia_device *p_dev = NULL; + struct pcmcia_driver *p_drv = NULL; + + /* Look for unbound client with matching dev_info */ + down_read(&pcmcia_socket_list_rwsem); + list_for_each_entry(s, &pcmcia_socket_list, socket_list) { + unsigned long flags; + + if (s->state & SOCKET_CARDBUS) + continue; + + s = pcmcia_get_socket(s); + if (!s) + continue; + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + list_for_each_entry(p_dev, &s->devices_list, socket_device_list) { + p_dev = pcmcia_get_dev(p_dev); + if (!p_dev) + continue; + if (!(p_dev->state & CLIENT_UNBOUND) || + (!p_dev->dev.driver)) { + pcmcia_put_dev(p_dev); + continue; + } + p_drv = to_pcmcia_drv(p_dev->dev.driver); + if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) { + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + goto found; + } + pcmcia_put_dev(p_dev); + } + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + pcmcia_put_socket(s); + } + found: + up_read(&pcmcia_socket_list_rwsem); + if (!p_dev) + return -ENODEV; + + pcmcia_put_socket(s); /* safe, as we already hold a reference from bind_device */ + + *handle = p_dev; + p_dev->state &= ~CLIENT_UNBOUND; + p_dev->event_callback_args = req->event_callback_args; + p_dev->event_callback_args.client_handle = p_dev; + + + if (!s->functions) { + cistpl_longlink_mfc_t mfc; + if (pccard_read_tuple(s, p_dev->func, CISTPL_LONGLINK_MFC, &mfc) + == CS_SUCCESS) + s->functions = mfc.nfn; + else + s->functions = 1; + s->config = kmalloc(sizeof(config_t) * s->functions, + GFP_KERNEL); + if (!s->config) + goto out_no_resource; + memset(s->config, 0, sizeof(config_t) * s->functions); + } + + ds_dbg(1, "register_client(): client 0x%p, dev %s\n", + p_dev, p_dev->dev.bus_id); + + if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) { + if (p_drv->event) + p_drv->event(CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW, + &p_dev->event_callback_args); + + } + + return CS_SUCCESS; + + out_no_resource: + pcmcia_put_dev(p_dev); + return CS_OUT_OF_RESOURCE; +} /* register_client */ +EXPORT_SYMBOL(pcmcia_register_client); + + +/* unbind _all_ devices attached to a given pcmcia_bus_socket. The + * drivers have been called with EVENT_CARD_REMOVAL before. + */ +static int unbind_request(struct pcmcia_socket *s) +{ + struct pcmcia_device *p_dev; + unsigned long flags; + + ds_dbg(2, "unbind_request(%d)\n", s->sock); + + s->device_count = 0; + + for (;;) { + /* unregister all pcmcia_devices registered with this socket*/ + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + if (list_empty(&s->devices_list)) { + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + return 0; + } + p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list); + list_del(&p_dev->socket_device_list); + p_dev->state |= CLIENT_STALE; + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + + device_unregister(&p_dev->dev); + } + + return 0; +} /* unbind_request */ + +int pcmcia_deregister_client(struct pcmcia_device *p_dev) +{ + struct pcmcia_socket *s; + int i; + + s = p_dev->socket; + ds_dbg(1, "deregister_client(%p)\n", p_dev); + + if (p_dev->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED)) + goto warn_out; + for (i = 0; i < MAX_WIN; i++) + if (p_dev->state & CLIENT_WIN_REQ(i)) + goto warn_out; + + if (p_dev->state & CLIENT_STALE) { + p_dev->state &= ~CLIENT_STALE; + pcmcia_put_dev(p_dev); + } else { + p_dev->state = CLIENT_UNBOUND; + } + + return CS_SUCCESS; + warn_out: + printk(KERN_WARNING "ds: deregister_client was called too early.\n"); + return CS_IN_USE; +} /* deregister_client */ +EXPORT_SYMBOL(pcmcia_deregister_client); + static struct pcmcia_callback pcmcia_bus_callback = { .owner = THIS_MODULE, .event = ds_event, .requery = pcmcia_bus_rescan, - .suspend = pcmcia_bus_suspend, - .resume = pcmcia_bus_resume, }; static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev, @@ -1164,11 +1223,9 @@ static struct class_interface pcmcia_bus_interface = { struct bus_type pcmcia_bus_type = { .name = "pcmcia", - .uevent = pcmcia_bus_uevent, + .hotplug = pcmcia_bus_hotplug, .match = pcmcia_bus_match, .dev_attrs = pcmcia_dev_attrs, - .suspend = pcmcia_dev_suspend, - .resume = pcmcia_dev_resume, }; diff --git a/trunk/drivers/pcmcia/hd64465_ss.c b/trunk/drivers/pcmcia/hd64465_ss.c index b39435bbfaeb..561706ba4499 100644 --- a/trunk/drivers/pcmcia/hd64465_ss.c +++ b/trunk/drivers/pcmcia/hd64465_ss.c @@ -417,6 +417,18 @@ static int hs_get_status(struct pcmcia_socket *s, u_int *value) /*============================================================*/ +static int hs_get_socket(struct pcmcia_socket *s, socket_state_t *state) +{ + hs_socket_t *sp = container_of(s, struct hs_socket_t, socket); + + DPRINTK("hs_get_socket(%d)\n", sock); + + *state = sp->state; + return 0; +} + +/*============================================================*/ + static int hs_set_socket(struct pcmcia_socket *s, socket_state_t *state) { hs_socket_t *sp = container_of(s, struct hs_socket_t, socket); @@ -737,6 +749,7 @@ static irqreturn_t hs_interrupt(int irq, void *dev, struct pt_regs *regs) static struct pccard_operations hs_operations = { .init = hs_init, .get_status = hs_get_status, + .get_socket = hs_get_socket, .set_socket = hs_set_socket, .set_io_map = hs_set_io_map, .set_mem_map = hs_set_mem_map, diff --git a/trunk/drivers/pcmcia/i82092.c b/trunk/drivers/pcmcia/i82092.c index 7979c85df3dc..f3fdc748659d 100644 --- a/trunk/drivers/pcmcia/i82092.c +++ b/trunk/drivers/pcmcia/i82092.c @@ -66,6 +66,7 @@ static struct pci_driver i82092aa_pci_drv = { static struct pccard_operations i82092aa_operations = { .init = i82092aa_init, .get_status = i82092aa_get_status, + .get_socket = i82092aa_get_socket, .set_socket = i82092aa_set_socket, .set_io_map = i82092aa_set_io_map, .set_mem_map = i82092aa_set_mem_map, @@ -481,6 +482,78 @@ static int i82092aa_get_status(struct pcmcia_socket *socket, u_int *value) } +static int i82092aa_get_socket(struct pcmcia_socket *socket, socket_state_t *state) +{ + unsigned int sock = container_of(socket, struct socket_info, socket)->number; + unsigned char reg,vcc,vpp; + + enter("i82092aa_get_socket"); + state->flags = 0; + state->Vcc = 0; + state->Vpp = 0; + state->io_irq = 0; + state->csc_mask = 0; + + /* First the power status of the socket */ + reg = indirect_read(sock,I365_POWER); /* PCTRL - Power Control Register */ + + if (reg & I365_PWR_AUTO) + state->flags |= SS_PWR_AUTO; /* Automatic Power Switch */ + + if (reg & I365_PWR_OUT) + state->flags |= SS_OUTPUT_ENA; /* Output signals are enabled */ + + vcc = reg & I365_VCC_MASK; vpp = reg & I365_VPP1_MASK; + + if (reg & I365_VCC_5V) { /* Can still be 3.3V, in this case the Vcc value will be overwritten later */ + state->Vcc = 50; + + if (vpp == I365_VPP1_5V) + state->Vpp = 50; + if (vpp == I365_VPP1_12V) + state->Vpp = 120; + + } + + if ((reg & I365_VCC_3V)==I365_VCC_3V) + state->Vcc = 33; + + + /* Now the IO card, RESET flags and IO interrupt */ + + reg = indirect_read(sock, I365_INTCTL); /* IGENC, Interrupt and General Control */ + + if ((reg & I365_PC_RESET)==0) + state->flags |= SS_RESET; + if (reg & I365_PC_IOCARD) + state->flags |= SS_IOCARD; /* This is an IO card */ + + /* Set the IRQ number */ + if (sockets[sock].dev!=NULL) + state->io_irq = sockets[sock].dev->irq; + + /* Card status change */ + reg = indirect_read(sock, I365_CSCINT); /* CSCICR, Card Status Change Interrupt Configuration */ + + if (reg & I365_CSC_DETECT) + state->csc_mask |= SS_DETECT; /* Card detect is enabled */ + + if (state->flags & SS_IOCARD) {/* IO Cards behave different */ + if (reg & I365_CSC_STSCHG) + state->csc_mask |= SS_STSCHG; + } else { + if (reg & I365_CSC_BVD1) + state->csc_mask |= SS_BATDEAD; + if (reg & I365_CSC_BVD2) + state->csc_mask |= SS_BATWARN; + if (reg & I365_CSC_READY) + state->csc_mask |= SS_READY; + } + + leave("i82092aa_get_socket"); + return 0; +} + static int i82092aa_set_socket(struct pcmcia_socket *socket, socket_state_t *state) { unsigned int sock = container_of(socket, struct socket_info, socket)->number; diff --git a/trunk/drivers/pcmcia/i82092aa.h b/trunk/drivers/pcmcia/i82092aa.h index 9c14599d0673..b98cac7bda9f 100644 --- a/trunk/drivers/pcmcia/i82092aa.h +++ b/trunk/drivers/pcmcia/i82092aa.h @@ -29,6 +29,7 @@ static irqreturn_t i82092aa_interrupt(int irq, void *dev, struct pt_regs *regs); static int i82092aa_get_status(struct pcmcia_socket *socket, u_int *value); +static int i82092aa_get_socket(struct pcmcia_socket *socket, socket_state_t *state); static int i82092aa_set_socket(struct pcmcia_socket *socket, socket_state_t *state); static int i82092aa_set_io_map(struct pcmcia_socket *socket, struct pccard_io_map *io); static int i82092aa_set_mem_map(struct pcmcia_socket *socket, struct pccard_mem_map *mem); diff --git a/trunk/drivers/pcmcia/i82365.c b/trunk/drivers/pcmcia/i82365.c index 35a92d1e4945..4d56bc9926d6 100644 --- a/trunk/drivers/pcmcia/i82365.c +++ b/trunk/drivers/pcmcia/i82365.c @@ -940,6 +940,78 @@ static int i365_get_status(u_short sock, u_int *value) /*====================================================================*/ +static int i365_get_socket(u_short sock, socket_state_t *state) +{ + struct i82365_socket *t = &socket[sock]; + u_char reg, vcc, vpp; + + reg = i365_get(sock, I365_POWER); + state->flags = (reg & I365_PWR_AUTO) ? SS_PWR_AUTO : 0; + state->flags |= (reg & I365_PWR_OUT) ? SS_OUTPUT_ENA : 0; + vcc = reg & I365_VCC_MASK; vpp = reg & I365_VPP1_MASK; + state->Vcc = state->Vpp = 0; + if (t->flags & IS_CIRRUS) { + if (i365_get(sock, PD67_MISC_CTL_1) & PD67_MC1_VCC_3V) { + if (reg & I365_VCC_5V) state->Vcc = 33; + if (vpp == I365_VPP1_5V) state->Vpp = 33; + } else { + if (reg & I365_VCC_5V) state->Vcc = 50; + if (vpp == I365_VPP1_5V) state->Vpp = 50; + } + if (vpp == I365_VPP1_12V) state->Vpp = 120; + } else if (t->flags & IS_VG_PWR) { + if (i365_get(sock, VG469_VSELECT) & VG469_VSEL_VCC) { + if (reg & I365_VCC_5V) state->Vcc = 33; + if (vpp == I365_VPP1_5V) state->Vpp = 33; + } else { + if (reg & I365_VCC_5V) state->Vcc = 50; + if (vpp == I365_VPP1_5V) state->Vpp = 50; + } + if (vpp == I365_VPP1_12V) state->Vpp = 120; + } else if (t->flags & IS_DF_PWR) { + if (vcc == I365_VCC_3V) state->Vcc = 33; + if (vcc == I365_VCC_5V) state->Vcc = 50; + if (vpp == I365_VPP1_5V) state->Vpp = 50; + if (vpp == I365_VPP1_12V) state->Vpp = 120; + } else { + if (reg & I365_VCC_5V) { + state->Vcc = 50; + if (vpp == I365_VPP1_5V) state->Vpp = 50; + if (vpp == I365_VPP1_12V) state->Vpp = 120; + } + } + + /* IO card, RESET flags, IO interrupt */ + reg = i365_get(sock, I365_INTCTL); + state->flags |= (reg & I365_PC_RESET) ? 0 : SS_RESET; + if (reg & I365_PC_IOCARD) state->flags |= SS_IOCARD; + state->io_irq = reg & I365_IRQ_MASK; + + /* speaker control */ + if (t->flags & IS_CIRRUS) { + if (i365_get(sock, PD67_MISC_CTL_1) & PD67_MC1_SPKR_ENA) + state->flags |= SS_SPKR_ENA; + } + + /* Card status change mask */ + reg = i365_get(sock, I365_CSCINT); + state->csc_mask = (reg & I365_CSC_DETECT) ? SS_DETECT : 0; + if (state->flags & SS_IOCARD) + state->csc_mask |= (reg & I365_CSC_STSCHG) ? SS_STSCHG : 0; + else { + state->csc_mask |= (reg & I365_CSC_BVD1) ? SS_BATDEAD : 0; + state->csc_mask |= (reg & I365_CSC_BVD2) ? SS_BATWARN : 0; + state->csc_mask |= (reg & I365_CSC_READY) ? SS_READY : 0; + } + + debug(1, "GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, " + "io_irq %d, csc_mask %#2.2x\n", sock, state->flags, + state->Vcc, state->Vpp, state->io_irq, state->csc_mask); + return 0; +} /* i365_get_socket */ + +/*====================================================================*/ + static int i365_set_socket(u_short sock, socket_state_t *state) { struct i82365_socket *t = &socket[sock]; @@ -1193,6 +1265,16 @@ static int pcic_get_status(struct pcmcia_socket *s, u_int *value) LOCKED(i365_get_status(sock, value)); } +static int pcic_get_socket(struct pcmcia_socket *s, socket_state_t *state) +{ + unsigned int sock = container_of(s, struct i82365_socket, socket)->number; + + if (socket[sock].flags & IS_ALIVE) + return -EINVAL; + + LOCKED(i365_get_socket(sock, state)); +} + static int pcic_set_socket(struct pcmcia_socket *s, socket_state_t *state) { unsigned int sock = container_of(s, struct i82365_socket, socket)->number; @@ -1242,6 +1324,7 @@ static int pcic_init(struct pcmcia_socket *s) static struct pccard_operations pcic_operations = { .init = pcic_init, .get_status = pcic_get_status, + .get_socket = pcic_get_socket, .set_socket = pcic_set_socket, .set_io_map = pcic_set_io_map, .set_mem_map = pcic_set_mem_map, diff --git a/trunk/drivers/pcmcia/m32r_cfc.c b/trunk/drivers/pcmcia/m32r_cfc.c index 071cf485e1a3..078579ae6359 100644 --- a/trunk/drivers/pcmcia/m32r_cfc.c +++ b/trunk/drivers/pcmcia/m32r_cfc.c @@ -480,6 +480,25 @@ static int _pcc_get_status(u_short sock, u_int *value) /*====================================================================*/ +static int _pcc_get_socket(u_short sock, socket_state_t *state) +{ +// pcc_socket_t *t = &socket[sock]; + + state->flags = 0; + state->csc_mask = SS_DETECT; + state->csc_mask |= SS_READY; + state->io_irq = 0; + state->Vcc = 33; /* 3.3V fixed */ + state->Vpp = 33; + + debug(3, "m32r_cfc: GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, " + "io_irq %d, csc_mask %#2.2x\n", sock, state->flags, + state->Vcc, state->Vpp, state->io_irq, state->csc_mask); + return 0; +} /* _get_socket */ + +/*====================================================================*/ + static int _pcc_set_socket(u_short sock, socket_state_t *state) { debug(3, "m32r_cfc: SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, " @@ -648,6 +667,18 @@ static int pcc_get_status(struct pcmcia_socket *s, u_int *value) LOCKED(_pcc_get_status(sock, value)); } +static int pcc_get_socket(struct pcmcia_socket *s, socket_state_t *state) +{ + unsigned int sock = container_of(s, struct pcc_socket, socket)->number; + + if (socket[sock].flags & IS_ALIVE) { + debug(3, "m32r_cfc: pcc_get_socket: sock(%d) -EINVAL\n", sock); + return -EINVAL; + } + debug(3, "m32r_cfc: pcc_get_socket: sock(%d)\n", sock); + LOCKED(_pcc_get_socket(sock, state)); +} + static int pcc_set_socket(struct pcmcia_socket *s, socket_state_t *state) { unsigned int sock = container_of(s, struct pcc_socket, socket)->number; @@ -693,6 +724,7 @@ static int pcc_init(struct pcmcia_socket *s) static struct pccard_operations pcc_operations = { .init = pcc_init, .get_status = pcc_get_status, + .get_socket = pcc_get_socket, .set_socket = pcc_set_socket, .set_io_map = pcc_set_io_map, .set_mem_map = pcc_set_mem_map, diff --git a/trunk/drivers/pcmcia/m32r_pcc.c b/trunk/drivers/pcmcia/m32r_pcc.c index 70d5f0748d55..356a6fb416a1 100644 --- a/trunk/drivers/pcmcia/m32r_pcc.c +++ b/trunk/drivers/pcmcia/m32r_pcc.c @@ -429,6 +429,16 @@ static int _pcc_get_status(u_short sock, u_int *value) /*====================================================================*/ +static int _pcc_get_socket(u_short sock, socket_state_t *state) +{ + debug(3, "m32r-pcc: GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, " + "io_irq %d, csc_mask %#2.2x\n", sock, state->flags, + state->Vcc, state->Vpp, state->io_irq, state->csc_mask); + return 0; +} /* _get_socket */ + +/*====================================================================*/ + static int _pcc_set_socket(u_short sock, socket_state_t *state) { u_long reg = 0; @@ -631,6 +641,15 @@ static int pcc_get_status(struct pcmcia_socket *s, u_int *value) LOCKED(_pcc_get_status(sock, value)); } +static int pcc_get_socket(struct pcmcia_socket *s, socket_state_t *state) +{ + unsigned int sock = container_of(s, struct pcc_socket, socket)->number; + + if (socket[sock].flags & IS_ALIVE) + return -EINVAL; + LOCKED(_pcc_get_socket(sock, state)); +} + static int pcc_set_socket(struct pcmcia_socket *s, socket_state_t *state) { unsigned int sock = container_of(s, struct pcc_socket, socket)->number; @@ -668,6 +687,7 @@ static int pcc_init(struct pcmcia_socket *s) static struct pccard_operations pcc_operations = { .init = pcc_init, .get_status = pcc_get_status, + .get_socket = pcc_get_socket, .set_socket = pcc_set_socket, .set_io_map = pcc_set_io_map, .set_mem_map = pcc_set_mem_map, diff --git a/trunk/drivers/pcmcia/m8xx_pcmcia.c b/trunk/drivers/pcmcia/m8xx_pcmcia.c index 0e07d9535116..6d9f71cfcb34 100644 --- a/trunk/drivers/pcmcia/m8xx_pcmcia.c +++ b/trunk/drivers/pcmcia/m8xx_pcmcia.c @@ -9,9 +9,6 @@ * * Further fixes, v2.6 kernel port * - * - * Some fixes, additions (C) 2005 Montavista Software, Inc. - * * * "The ExCA standard specifies that socket controllers should provide * two IO and five memory windows per socket, which can be independently @@ -100,11 +97,6 @@ MODULE_LICENSE("Dual MPL/GPL"); #endif #endif -#if defined(CONFIG_MPC885ADS) -#define CONFIG_PCMCIA_SLOT_A -#define PCMCIA_GLITCHY_CD -#endif - /* Cyclades ACS uses both slots */ #ifdef CONFIG_PRxK #define CONFIG_PCMCIA_SLOT_A @@ -382,10 +374,10 @@ static int voltage_set(int slot, int vcc, int vpp) } /* first, turn off all power */ - out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) & ~(BCSR1_PCCVCC_MASK | BCSR1_PCCVPP_MASK)); + out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) & ~(BCSR1_PCCVCC_MASK | BCSR1_PCCVPP_MASK)); /* enable new powersettings */ - out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) | reg); + out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) | reg); return 0; } @@ -394,89 +386,12 @@ static int voltage_set(int slot, int vcc, int vpp) static void hardware_enable(int slot) { - out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) & ~BCSR1_PCCEN); + out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) & ~BCSR1_PCCEN); } static void hardware_disable(int slot) { - out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) | BCSR1_PCCEN); -} - -#endif - -/* MPC885ADS Boards */ - -#if defined(CONFIG_MPC885ADS) - -#define PCMCIA_BOARD_MSG "MPC885ADS" - -static int voltage_set(int slot, int vcc, int vpp) -{ - u32 reg = 0; - unsigned *bcsr_io; - - bcsr_io = ioremap(BCSR1, sizeof(unsigned long)); - - switch(vcc) { - case 0: - break; - case 33: - reg |= BCSR1_PCCVCC0; - break; - case 50: - reg |= BCSR1_PCCVCC1; - break; - default: - return 1; - } - - switch(vpp) { - case 0: - break; - case 33: - case 50: - if(vcc == vpp) - reg |= BCSR1_PCCVPP1; - else - return 1; - break; - case 120: - if ((vcc == 33) || (vcc == 50)) - reg |= BCSR1_PCCVPP0; - else - return 1; - default: - return 1; - } - - /* first, turn off all power */ - out_be32(bcsr_io, in_be32(bcsr_io) & ~(BCSR1_PCCVCC_MASK | BCSR1_PCCVPP_MASK)); - - /* enable new powersettings */ - out_be32(bcsr_io, in_be32(bcsr_io) | reg); - - iounmap(bcsr_io); - return 0; -} - -#define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V - -static void hardware_enable(int slot) -{ - unsigned *bcsr_io; - - bcsr_io = ioremap(BCSR1, sizeof(unsigned long)); - out_be32(bcsr_io, in_be32(bcsr_io) & ~BCSR1_PCCEN); - iounmap(bcsr_io); -} - -static void hardware_disable(int slot) -{ - unsigned *bcsr_io; - - bcsr_io = ioremap(BCSR1, sizeof(unsigned long)); - out_be32(bcsr_io, in_be32(bcsr_io) | BCSR1_PCCEN); - iounmap(bcsr_io); + out_be32(&((u32 *)BCSR1), in_be32(&((u32 *)BCSR1)) | BCSR1_PCCEN); } #endif @@ -525,10 +440,10 @@ static int voltage_set(int slot, int vcc, int vpp) } /* first, turn off all power */ - out_8((u8 *)MBX_CSR2_ADDR, in_8((u8 *)MBX_CSR2_ADDR) & ~(CSR2_VCC_MASK | CSR2_VPP_MASK)); + out_8(&((u8 *)MBX_CSR2_ADDR), in_8(&((u8 *)MBX_CSR2_ADDR)) & ~(CSR2_VCC_MASK | CSR2_VPP_MASK)); /* enable new powersettings */ - out_8((u8 *)MBX_CSR2_ADDR, in_8((u8 *)MBX_CSR2_ADDR) | reg); + out_8(&((u8 *)MBX_CSR2_ADDR), in_8(&((u8 *)MBX_CSR2_ADDR)) | reg); return 0; } @@ -908,6 +823,17 @@ static int m8xx_get_status(struct pcmcia_socket *sock, unsigned int *value) return 0; } +static int m8xx_get_socket(struct pcmcia_socket *sock, socket_state_t *state) +{ + int lsock = container_of(sock, struct socket_info, socket)->slot; + *state = socket[lsock].state; /* copy the whole structure */ + + dprintk("GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, " + "io_irq %d, csc_mask %#2.2x\n", lsock, state->flags, + state->Vcc, state->Vpp, state->io_irq, state->csc_mask); + return 0; +} + static int m8xx_set_socket(struct pcmcia_socket *sock, socket_state_t *state) { int lsock = container_of(sock, struct socket_info, socket)->slot; @@ -1097,7 +1023,8 @@ static int m8xx_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io) if(io->flags & MAP_WRPROT) reg |= M8XX_PCMCIA_POR_WRPROT; - if(io->flags & (MAP_16BIT | MAP_AUTOSZ)) + /*if(io->flags & (MAP_16BIT | MAP_AUTOSZ))*/ + if(io->flags & MAP_16BIT) reg |= M8XX_PCMCIA_POR_16BIT; if(io->flags & MAP_ACTIVE) @@ -1242,6 +1169,7 @@ static struct pccard_operations m8xx_services = { .init = m8xx_sock_init, .suspend = m8xx_suspend, .get_status = m8xx_get_status, + .get_socket = m8xx_get_socket, .set_socket = m8xx_set_socket, .set_io_map = m8xx_set_io_map, .set_mem_map = m8xx_set_mem_map, @@ -1316,7 +1244,7 @@ static int __init m8xx_init(void) socket[i].socket.io_offset = 0; socket[i].socket.pci_irq = i ? 7 : 9; socket[i].socket.ops = &m8xx_services; - socket[i].socket.resource_ops = &pccard_iodyn_ops; + socket[i].socket.resource_ops = &pccard_nonstatic_ops; socket[i].socket.cb_dev = NULL; socket[i].socket.dev.dev = &m8xx_device.dev; } diff --git a/trunk/drivers/pcmcia/pd6729.c b/trunk/drivers/pcmcia/pd6729.c index f2789afb22b2..20642f0e7bfe 100644 --- a/trunk/drivers/pcmcia/pd6729.c +++ b/trunk/drivers/pcmcia/pd6729.c @@ -304,6 +304,75 @@ static int pd6729_get_status(struct pcmcia_socket *sock, u_int *value) } +static int pd6729_get_socket(struct pcmcia_socket *sock, socket_state_t *state) +{ + struct pd6729_socket *socket + = container_of(sock, struct pd6729_socket, socket); + unsigned char reg, vcc, vpp; + + state->flags = 0; + state->Vcc = 0; + state->Vpp = 0; + state->io_irq = 0; + state->csc_mask = 0; + + /* First the power status of the socket */ + reg = indirect_read(socket, I365_POWER); + + if (reg & I365_PWR_AUTO) + state->flags |= SS_PWR_AUTO; /* Automatic Power Switch */ + + if (reg & I365_PWR_OUT) + state->flags |= SS_OUTPUT_ENA; /* Output signals are enabled */ + + vcc = reg & I365_VCC_MASK; vpp = reg & I365_VPP1_MASK; + + if (reg & I365_VCC_5V) { + state->Vcc = (indirect_read(socket, PD67_MISC_CTL_1) & + PD67_MC1_VCC_3V) ? 33 : 50; + + if (vpp == I365_VPP1_5V) { + if (state->Vcc == 50) + state->Vpp = 50; + else + state->Vpp = 33; + } + if (vpp == I365_VPP1_12V) + state->Vpp = 120; + } + + /* Now the IO card, RESET flags and IO interrupt */ + reg = indirect_read(socket, I365_INTCTL); + + if ((reg & I365_PC_RESET) == 0) + state->flags |= SS_RESET; + if (reg & I365_PC_IOCARD) + state->flags |= SS_IOCARD; /* This is an IO card */ + + /* Set the IRQ number */ + state->io_irq = socket->card_irq; + + /* Card status change */ + reg = indirect_read(socket, I365_CSCINT); + + if (reg & I365_CSC_DETECT) + state->csc_mask |= SS_DETECT; /* Card detect is enabled */ + + if (state->flags & SS_IOCARD) {/* IO Cards behave different */ + if (reg & I365_CSC_STSCHG) + state->csc_mask |= SS_STSCHG; + } else { + if (reg & I365_CSC_BVD1) + state->csc_mask |= SS_BATDEAD; + if (reg & I365_CSC_BVD2) + state->csc_mask |= SS_BATWARN; + if (reg & I365_CSC_READY) + state->csc_mask |= SS_READY; + } + + return 0; +} + static int pd6729_set_socket(struct pcmcia_socket *sock, socket_state_t *state) { struct pd6729_socket *socket @@ -571,6 +640,7 @@ static int pd6729_init(struct pcmcia_socket *sock) static struct pccard_operations pd6729_operations = { .init = pd6729_init, .get_status = pd6729_get_status, + .get_socket = pd6729_get_socket, .set_socket = pd6729_set_socket, .set_io_map = pd6729_set_io_map, .set_mem_map = pd6729_set_mem_map, @@ -634,11 +704,13 @@ static int __devinit pd6729_pci_probe(struct pci_dev *dev, char configbyte; struct pd6729_socket *socket; - socket = kzalloc(sizeof(struct pd6729_socket) * MAX_SOCKETS, + socket = kmalloc(sizeof(struct pd6729_socket) * MAX_SOCKETS, GFP_KERNEL); if (!socket) return -ENOMEM; + memset(socket, 0, sizeof(struct pd6729_socket) * MAX_SOCKETS); + if ((ret = pci_enable_device(dev))) goto err_out_free_mem; diff --git a/trunk/drivers/pcmcia/pxa2xx_mainstone.c b/trunk/drivers/pcmcia/pxa2xx_mainstone.c index 5d957dfe23d9..5209d8c7764f 100644 --- a/trunk/drivers/pcmcia/pxa2xx_mainstone.c +++ b/trunk/drivers/pcmcia/pxa2xx_mainstone.c @@ -171,9 +171,10 @@ static int __init mst_pcmcia_init(void) { int ret; - mst_pcmcia_device = kzalloc(sizeof(*mst_pcmcia_device), GFP_KERNEL); + mst_pcmcia_device = kmalloc(sizeof(*mst_pcmcia_device), GFP_KERNEL); if (!mst_pcmcia_device) return -ENOMEM; + memset(mst_pcmcia_device, 0, sizeof(*mst_pcmcia_device)); mst_pcmcia_device->name = "pxa2xx-pcmcia"; mst_pcmcia_device->dev.platform_data = &mst_pcmcia_ops; diff --git a/trunk/drivers/pcmcia/pxa2xx_sharpsl.c b/trunk/drivers/pcmcia/pxa2xx_sharpsl.c index b5fdeec20b15..56c58831e80e 100644 --- a/trunk/drivers/pcmcia/pxa2xx_sharpsl.c +++ b/trunk/drivers/pcmcia/pxa2xx_sharpsl.c @@ -264,10 +264,11 @@ static int __init sharpsl_pcmcia_init(void) int ret; sharpsl_pcmcia_ops.nr=platform_scoop_config->num_devs; - sharpsl_pcmcia_device = kzalloc(sizeof(*sharpsl_pcmcia_device), GFP_KERNEL); + sharpsl_pcmcia_device = kmalloc(sizeof(*sharpsl_pcmcia_device), GFP_KERNEL); if (!sharpsl_pcmcia_device) return -ENOMEM; + memset(sharpsl_pcmcia_device, 0, sizeof(*sharpsl_pcmcia_device)); sharpsl_pcmcia_device->name = "pxa2xx-pcmcia"; sharpsl_pcmcia_device->dev.platform_data = &sharpsl_pcmcia_ops; sharpsl_pcmcia_device->dev.parent=platform_scoop_config->devs[0].dev; diff --git a/trunk/drivers/pcmcia/rsrc_mgr.c b/trunk/drivers/pcmcia/rsrc_mgr.c index 514609369836..0668384ebc8b 100644 --- a/trunk/drivers/pcmcia/rsrc_mgr.c +++ b/trunk/drivers/pcmcia/rsrc_mgr.c @@ -98,12 +98,10 @@ int pcmcia_adjust_resource_info(adjust_t *adj) } EXPORT_SYMBOL(pcmcia_adjust_resource_info); -int pcmcia_validate_mem(struct pcmcia_socket *s) +void pcmcia_validate_mem(struct pcmcia_socket *s) { if (s->resource_ops->validate_mem) - return s->resource_ops->validate_mem(s); - /* if there is no callback, we can assume that everything is OK */ - return 0; + s->resource_ops->validate_mem(s); } EXPORT_SYMBOL(pcmcia_validate_mem); @@ -166,105 +164,3 @@ struct pccard_resource_ops pccard_static_ops = { .exit = NULL, }; EXPORT_SYMBOL(pccard_static_ops); - - -#ifdef CONFIG_PCCARD_IODYN - -static struct resource * -make_resource(unsigned long b, unsigned long n, int flags, char *name) -{ - struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL); - - if (res) { - res->name = name; - res->start = b; - res->end = b + n - 1; - res->flags = flags; - } - return res; -} - -struct pcmcia_align_data { - unsigned long mask; - unsigned long offset; -}; - -static void pcmcia_align(void *align_data, struct resource *res, - unsigned long size, unsigned long align) -{ - struct pcmcia_align_data *data = align_data; - unsigned long start; - - start = (res->start & ~data->mask) + data->offset; - if (start < res->start) - start += data->mask + 1; - res->start = start; - -#ifdef CONFIG_X86 - if (res->flags & IORESOURCE_IO) { - if (start & 0x300) { - start = (start + 0x3ff) & ~0x3ff; - res->start = start; - } - } -#endif - -#ifdef CONFIG_M68K - if (res->flags & IORESOURCE_IO) { - if ((res->start + size - 1) >= 1024) - res->start = res->end; - } -#endif -} - - -static int iodyn_adjust_io_region(struct resource *res, unsigned long r_start, - unsigned long r_end, struct pcmcia_socket *s) -{ - return adjust_resource(res, r_start, r_end - r_start + 1); -} - - -static struct resource *iodyn_find_io_region(unsigned long base, int num, - unsigned long align, struct pcmcia_socket *s) -{ - struct resource *res = make_resource(0, num, IORESOURCE_IO, - s->dev.class_id); - struct pcmcia_align_data data; - unsigned long min = base; - int ret; - - if (align == 0) - align = 0x10000; - - data.mask = align - 1; - data.offset = base & data.mask; - -#ifdef CONFIG_PCI - if (s->cb_dev) { - ret = pci_bus_alloc_resource(s->cb_dev->bus, res, num, 1, - min, 0, pcmcia_align, &data); - } else -#endif - ret = allocate_resource(&ioport_resource, res, num, min, ~0UL, - 1, pcmcia_align, &data); - - if (ret != 0) { - kfree(res); - res = NULL; - } - return res; -} - -struct pccard_resource_ops pccard_iodyn_ops = { - .validate_mem = NULL, - .adjust_io_region = iodyn_adjust_io_region, - .find_io = iodyn_find_io_region, - .find_mem = NULL, - .adjust_resource = NULL, - .init = static_init, - .exit = NULL, -}; -EXPORT_SYMBOL(pccard_iodyn_ops); - -#endif /* CONFIG_PCCARD_IODYN */ diff --git a/trunk/drivers/pcmcia/rsrc_nonstatic.c b/trunk/drivers/pcmcia/rsrc_nonstatic.c index 5301ac60358f..00960a379b9c 100644 --- a/trunk/drivers/pcmcia/rsrc_nonstatic.c +++ b/trunk/drivers/pcmcia/rsrc_nonstatic.c @@ -75,9 +75,10 @@ static DECLARE_MUTEX(rsrc_sem); static struct resource * make_resource(unsigned long b, unsigned long n, int flags, char *name) { - struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL); + struct resource *res = kmalloc(sizeof(*res), GFP_KERNEL); if (res) { + memset(res, 0, sizeof(*res)); res->name = name; res->start = b; res->end = b + n - 1; @@ -199,11 +200,12 @@ static void do_io_probe(struct pcmcia_socket *s, kio_addr_t base, kio_addr_t num base, base+num-1); /* First, what does a floating port look like? */ - b = kzalloc(256, GFP_KERNEL); + b = kmalloc(256, GFP_KERNEL); if (!b) { printk(KERN_ERR "do_io_probe: unable to kmalloc 256 bytes"); return; } + memset(b, 0, 256); for (i = base, most = 0; i < base+num; i += 8) { res = claim_region(NULL, i, 8, IORESOURCE_IO, "PCMCIA IO probe"); if (!res) @@ -405,79 +407,69 @@ static int do_mem_probe(u_long base, u_long num, struct pcmcia_socket *s) static u_long inv_probe(struct resource_map *m, struct pcmcia_socket *s) { - struct socket_data *s_data = s->resource_data; - u_long ok; - if (m == &s_data->mem_db) - return 0; - ok = inv_probe(m->next, s); - if (ok) { - if (m->base >= 0x100000) - sub_interval(&s_data->mem_db, m->base, m->num); - return ok; - } - if (m->base < 0x100000) - return 0; - return do_mem_probe(m->base, m->num, s); + struct socket_data *s_data = s->resource_data; + u_long ok; + if (m == &s_data->mem_db) + return 0; + ok = inv_probe(m->next, s); + if (ok) { + if (m->base >= 0x100000) + sub_interval(&s_data->mem_db, m->base, m->num); + return ok; + } + if (m->base < 0x100000) + return 0; + return do_mem_probe(m->base, m->num, s); } -static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) +static void validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) { - struct resource_map *m, mm; - static unsigned char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 }; - unsigned long b, i, ok = 0; - struct socket_data *s_data = s->resource_data; + struct resource_map *m, mm; + static u_char order[] = { 0xd0, 0xe0, 0xc0, 0xf0 }; + u_long b, i, ok = 0; + struct socket_data *s_data = s->resource_data; - /* We do up to four passes through the list */ - if (probe_mask & MEM_PROBE_HIGH) { - if (inv_probe(s_data->mem_db.next, s) > 0) - return 0; - printk(KERN_NOTICE "cs: warning: no high memory space " - "available!\n"); - return -ENODEV; + /* We do up to four passes through the list */ + if (probe_mask & MEM_PROBE_HIGH) { + if (inv_probe(s_data->mem_db.next, s) > 0) + return; + printk(KERN_NOTICE "cs: warning: no high memory space " + "available!\n"); + } + if ((probe_mask & MEM_PROBE_LOW) == 0) + return; + for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) { + mm = *m; + /* Only probe < 1 MB */ + if (mm.base >= 0x100000) continue; + if ((mm.base | mm.num) & 0xffff) { + ok += do_mem_probe(mm.base, mm.num, s); + continue; } - - for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) { - mm = *m; - /* Only probe < 1 MB */ - if (mm.base >= 0x100000) - continue; - if ((mm.base | mm.num) & 0xffff) { - ok += do_mem_probe(mm.base, mm.num, s); - continue; - } - /* Special probe for 64K-aligned block */ - for (i = 0; i < 4; i++) { - b = order[i] << 12; - if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) { - if (ok >= mem_limit) - sub_interval(&s_data->mem_db, b, 0x10000); - else - ok += do_mem_probe(b, 0x10000, s); - } - } + /* Special probe for 64K-aligned block */ + for (i = 0; i < 4; i++) { + b = order[i] << 12; + if ((b >= mm.base) && (b+0x10000 <= mm.base+mm.num)) { + if (ok >= mem_limit) + sub_interval(&s_data->mem_db, b, 0x10000); + else + ok += do_mem_probe(b, 0x10000, s); + } } - - if (ok > 0) - return 0; - - return -ENODEV; + } } #else /* CONFIG_PCMCIA_PROBE */ -static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) +static void validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) { struct resource_map *m, mm; struct socket_data *s_data = s->resource_data; - unsigned long ok = 0; for (m = s_data->mem_db.next; m != &s_data->mem_db; m = mm.next) { mm = *m; - ok += do_mem_probe(mm.base, mm.num, s); + do_mem_probe(mm.base, mm.num, s); } - if (ok > 0) - return 0; - return -ENODEV; } #endif /* CONFIG_PCMCIA_PROBE */ @@ -486,30 +478,27 @@ static int validate_mem(struct pcmcia_socket *s, unsigned int probe_mask) /* * Locking note: Must be called with skt_sem held! */ -static int pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s) +static void pcmcia_nonstatic_validate_mem(struct pcmcia_socket *s) { struct socket_data *s_data = s->resource_data; - unsigned int probe_mask = MEM_PROBE_LOW; - int ret = 0; + if (probe_mem) { + unsigned int probe_mask; - if (!probe_mem) - return 0; - - down(&rsrc_sem); + down(&rsrc_sem); - if (s->features & SS_CAP_PAGE_REGS) - probe_mask = MEM_PROBE_HIGH; + probe_mask = MEM_PROBE_LOW; + if (s->features & SS_CAP_PAGE_REGS) + probe_mask = MEM_PROBE_HIGH; - if (probe_mask & ~s_data->rsrc_mem_probe) { - if (s->state & SOCKET_PRESENT) - ret = validate_mem(s, probe_mask); - if (!ret) + if (probe_mask & ~s_data->rsrc_mem_probe) { s_data->rsrc_mem_probe |= probe_mask; - } - up(&rsrc_sem); + if (s->state & SOCKET_PRESENT) + validate_mem(s, probe_mask); + } - return ret; + up(&rsrc_sem); + } } struct pcmcia_align_data { @@ -848,9 +837,10 @@ static int nonstatic_init(struct pcmcia_socket *s) { struct socket_data *data; - data = kzalloc(sizeof(struct socket_data), GFP_KERNEL); + data = kmalloc(sizeof(struct socket_data), GFP_KERNEL); if (!data) return -ENOMEM; + memset(data, 0, sizeof(struct socket_data)); data->mem_db.next = &data->mem_db; data->io_db.next = &data->io_db; diff --git a/trunk/drivers/pcmcia/soc_common.c b/trunk/drivers/pcmcia/soc_common.c index ea7d9ca160b2..9e7ccd8a4321 100644 --- a/trunk/drivers/pcmcia/soc_common.c +++ b/trunk/drivers/pcmcia/soc_common.c @@ -296,6 +296,25 @@ soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status) } +/* + * Implements the get_socket() operation for the in-kernel PCMCIA + * service (formerly SS_GetSocket in Card Services). Not a very + * exciting routine. + * + * Returns: 0 + */ +static int +soc_common_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state) +{ + struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock); + + debug(skt, 2, "\n"); + + *state = skt->cs_state; + + return 0; +} + /* * Implements the set_socket() operation for the in-kernel PCMCIA * service (formerly SS_SetSocket in Card Services). We more or @@ -509,6 +528,7 @@ static struct pccard_operations soc_common_pcmcia_operations = { .init = soc_common_pcmcia_sock_init, .suspend = soc_common_pcmcia_suspend, .get_status = soc_common_pcmcia_get_status, + .get_socket = soc_common_pcmcia_get_socket, .set_socket = soc_common_pcmcia_set_socket, .set_io_map = soc_common_pcmcia_set_io_map, .set_mem_map = soc_common_pcmcia_set_mem_map, @@ -645,12 +665,13 @@ int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops down(&soc_pcmcia_sockets_lock); - sinfo = kzalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL); + sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL); if (!sinfo) { ret = -ENOMEM; goto out; } + memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr)); sinfo->nskt = nr; /* diff --git a/trunk/drivers/pcmcia/socket_sysfs.c b/trunk/drivers/pcmcia/socket_sysfs.c index 7a7744662d54..4a3150a7854c 100644 --- a/trunk/drivers/pcmcia/socket_sysfs.c +++ b/trunk/drivers/pcmcia/socket_sysfs.c @@ -42,28 +42,35 @@ static ssize_t pccard_show_type(struct class_device *dev, char *buf) { + int val; struct pcmcia_socket *s = to_socket(dev); if (!(s->state & SOCKET_PRESENT)) return -ENODEV; - if (s->state & SOCKET_CARDBUS) + s->ops->get_status(s, &val); + if (val & SS_CARDBUS) return sprintf(buf, "32-bit\n"); - return sprintf(buf, "16-bit\n"); + if (val & SS_DETECT) + return sprintf(buf, "16-bit\n"); + return sprintf(buf, "invalid\n"); } -static CLASS_DEVICE_ATTR(card_type, 0444, pccard_show_type, NULL); +static CLASS_DEVICE_ATTR(card_type, 0400, pccard_show_type, NULL); static ssize_t pccard_show_voltage(struct class_device *dev, char *buf) { + int val; struct pcmcia_socket *s = to_socket(dev); if (!(s->state & SOCKET_PRESENT)) return -ENODEV; - if (s->socket.Vcc) - return sprintf(buf, "%d.%dV\n", s->socket.Vcc / 10, - s->socket.Vcc % 10); - return sprintf(buf, "X.XV\n"); + s->ops->get_status(s, &val); + if (val & SS_3VCARD) + return sprintf(buf, "3.3V\n"); + if (val & SS_XVCARD) + return sprintf(buf, "X.XV\n"); + return sprintf(buf, "5.0V\n"); } -static CLASS_DEVICE_ATTR(card_voltage, 0444, pccard_show_voltage, NULL); +static CLASS_DEVICE_ATTR(card_voltage, 0400, pccard_show_voltage, NULL); static ssize_t pccard_show_vpp(struct class_device *dev, char *buf) { @@ -72,7 +79,7 @@ static ssize_t pccard_show_vpp(struct class_device *dev, char *buf) return -ENODEV; return sprintf(buf, "%d.%dV\n", s->socket.Vpp / 10, s->socket.Vpp % 10); } -static CLASS_DEVICE_ATTR(card_vpp, 0444, pccard_show_vpp, NULL); +static CLASS_DEVICE_ATTR(card_vpp, 0400, pccard_show_vpp, NULL); static ssize_t pccard_show_vcc(struct class_device *dev, char *buf) { @@ -81,7 +88,7 @@ static ssize_t pccard_show_vcc(struct class_device *dev, char *buf) return -ENODEV; return sprintf(buf, "%d.%dV\n", s->socket.Vcc / 10, s->socket.Vcc % 10); } -static CLASS_DEVICE_ATTR(card_vcc, 0444, pccard_show_vcc, NULL); +static CLASS_DEVICE_ATTR(card_vcc, 0400, pccard_show_vcc, NULL); static ssize_t pccard_store_insert(struct class_device *dev, const char *buf, size_t count) @@ -285,9 +292,10 @@ static ssize_t pccard_store_cis(struct kobject *kobj, char *buf, loff_t off, siz if (!(s->state & SOCKET_PRESENT)) return -ENODEV; - cis = kzalloc(sizeof(cisdump_t), GFP_KERNEL); + cis = kmalloc(sizeof(cisdump_t), GFP_KERNEL); if (!cis) return -ENOMEM; + memset(cis, 0, sizeof(cisdump_t)); cis->Length = count + 1; memcpy(cis->Data, buf, count); diff --git a/trunk/drivers/pcmcia/tcic.c b/trunk/drivers/pcmcia/tcic.c index 73bad1d5cb23..e31263864377 100644 --- a/trunk/drivers/pcmcia/tcic.c +++ b/trunk/drivers/pcmcia/tcic.c @@ -181,6 +181,13 @@ static void tcic_setl(u_char reg, u_int data) outw(data >> 16, tcic_base+reg+2); } +static u_char tcic_aux_getb(u_short reg) +{ + u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg; + tcic_setb(TCIC_MODE, mode); + return tcic_getb(TCIC_AUX); +} + static void tcic_aux_setb(u_short reg, u_char data) { u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg; @@ -634,6 +641,59 @@ static int tcic_get_status(struct pcmcia_socket *sock, u_int *value) debug(1, "GetStatus(%d) = %#2.2x\n", psock, *value); return 0; } /* tcic_get_status */ + +/*====================================================================*/ + +static int tcic_get_socket(struct pcmcia_socket *sock, socket_state_t *state) +{ + u_short psock = container_of(sock, struct tcic_socket, socket)->psock; + u_char reg; + u_short scf1, scf2; + + tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT) + | TCIC_ADDR_INDREG | TCIC_SCF1(psock)); + scf1 = tcic_getw(TCIC_DATA); + state->flags = (scf1 & TCIC_SCF1_IOSTS) ? SS_IOCARD : 0; + state->flags |= (scf1 & TCIC_SCF1_DMA_MASK) ? SS_DMA_MODE : 0; + state->flags |= (scf1 & TCIC_SCF1_SPKR) ? SS_SPKR_ENA : 0; + if (tcic_getb(TCIC_SCTRL) & TCIC_SCTRL_ENA) + state->flags |= SS_OUTPUT_ENA; + state->io_irq = scf1 & TCIC_SCF1_IRQ_MASK; + if (state->io_irq == 1) state->io_irq = 11; + + reg = tcic_getb(TCIC_PWR); + state->Vcc = state->Vpp = 0; + if (reg & TCIC_PWR_VCC(psock)) { + if (reg & TCIC_PWR_VPP(psock)) + state->Vcc = 50; + else + state->Vcc = state->Vpp = 50; + } else { + if (reg & TCIC_PWR_VPP(psock)) { + state->Vcc = 50; + state->Vpp = 120; + } + } + reg = tcic_aux_getb(TCIC_AUX_ILOCK); + state->flags |= (reg & TCIC_ILOCK_CRESET) ? SS_RESET : 0; + + /* Card status change interrupt mask */ + tcic_setw(TCIC_ADDR, TCIC_SCF2(psock)); + scf2 = tcic_getw(TCIC_DATA); + state->csc_mask = (scf2 & TCIC_SCF2_MCD) ? 0 : SS_DETECT; + if (state->flags & SS_IOCARD) { + state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT1) ? 0 : SS_STSCHG; + } else { + state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT1) ? 0 : SS_BATDEAD; + state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT2) ? 0 : SS_BATWARN; + state->csc_mask |= (scf2 & TCIC_SCF2_MRDY) ? 0 : SS_READY; + } + + debug(1, "GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, " + "io_irq %d, csc_mask %#2.2x\n", psock, state->flags, + state->Vcc, state->Vpp, state->io_irq, state->csc_mask); + return 0; +} /* tcic_get_socket */ /*====================================================================*/ @@ -814,6 +874,7 @@ static int tcic_init(struct pcmcia_socket *s) static struct pccard_operations tcic_operations = { .init = tcic_init, .get_status = tcic_get_status, + .get_socket = tcic_get_socket, .set_socket = tcic_set_socket, .set_io_map = tcic_set_io_map, .set_mem_map = tcic_set_mem_map, diff --git a/trunk/drivers/pcmcia/ti113x.h b/trunk/drivers/pcmcia/ti113x.h index d5b4ff74462e..539b5cd1a598 100644 --- a/trunk/drivers/pcmcia/ti113x.h +++ b/trunk/drivers/pcmcia/ti113x.h @@ -873,7 +873,7 @@ static int ti1250_override(struct yenta_socket *socket) * Some fixup code to make everybody happy (TM). */ -#ifdef CONFIG_YENTA_ENE_TUNE +#ifdef CONFIG_CARDBUS /** * set/clear various test bits: * Defaults to clear the bit. @@ -937,7 +937,7 @@ static int ene_override(struct yenta_socket *socket) } #else # define ene_override ti1250_override -#endif /* !CONFIG_YENTA_ENE_TUNE */ +#endif #endif /* _LINUX_TI113X_H */ diff --git a/trunk/drivers/pcmcia/vrc4171_card.c b/trunk/drivers/pcmcia/vrc4171_card.c index 24c547ef512b..38a028c725d4 100644 --- a/trunk/drivers/pcmcia/vrc4171_card.c +++ b/trunk/drivers/pcmcia/vrc4171_card.c @@ -301,6 +301,75 @@ static int pccard_get_status(struct pcmcia_socket *sock, u_int *value) return 0; } +static inline u_char get_Vcc_value(uint8_t voltage) +{ + switch (voltage) { + case VCC_STATUS_3V: + return 33; + case VCC_STATUS_5V: + return 50; + default: + break; + } + + return 0; +} + +static inline u_char get_Vpp_value(uint8_t power, u_char Vcc) +{ + if ((power & 0x03) == 0x01 || (power & 0x03) == 0x02) + return Vcc; + + return 0; +} + +static int pccard_get_socket(struct pcmcia_socket *sock, socket_state_t *state) +{ + unsigned int slot; + uint8_t power, voltage, control, cscint; + + if (sock == NULL || sock->sock >= CARD_MAX_SLOTS || state == NULL) + return -EINVAL; + + slot = sock->sock; + + power = exca_read_byte(slot, I365_POWER); + voltage = exca_read_byte(slot, CARD_VOLTAGE_SELECT); + + state->Vcc = get_Vcc_value(voltage); + state->Vpp = get_Vpp_value(power, state->Vcc); + + state->flags = 0; + if (power & POWER_ENABLE) + state->flags |= SS_PWR_AUTO; + if (power & I365_PWR_OUT) + state->flags |= SS_OUTPUT_ENA; + + control = exca_read_byte(slot, I365_INTCTL); + if (control & I365_PC_IOCARD) + state->flags |= SS_IOCARD; + if (!(control & I365_PC_RESET)) + state->flags |= SS_RESET; + + cscint = exca_read_byte(slot, I365_CSCINT); + state->csc_mask = 0; + if (state->flags & SS_IOCARD) { + if (cscint & I365_CSC_STSCHG) + state->flags |= SS_STSCHG; + } else { + if (cscint & I365_CSC_BVD1) + state->csc_mask |= SS_BATDEAD; + if (cscint & I365_CSC_BVD2) + state->csc_mask |= SS_BATWARN; + } + if (cscint & I365_CSC_READY) + state->csc_mask |= SS_READY; + if (cscint & I365_CSC_DETECT) + state->csc_mask |= SS_DETECT; + + return 0; +} + static inline uint8_t set_Vcc_value(u_char Vcc) { switch (Vcc) { @@ -482,6 +551,7 @@ static int pccard_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map static struct pccard_operations vrc4171_pccard_operations = { .init = pccard_init, .get_status = pccard_get_status, + .get_socket = pccard_get_socket, .set_socket = pccard_set_socket, .set_io_map = pccard_set_io_map, .set_mem_map = pccard_set_mem_map, diff --git a/trunk/drivers/pcmcia/vrc4173_cardu.c b/trunk/drivers/pcmcia/vrc4173_cardu.c index 1b277d2c1c96..db91259dc50e 100644 --- a/trunk/drivers/pcmcia/vrc4173_cardu.c +++ b/trunk/drivers/pcmcia/vrc4173_cardu.c @@ -198,6 +198,48 @@ static int cardu_get_status(unsigned int sock, u_int *value) return 0; } +static inline u_char get_Vcc_value(uint8_t val) +{ + switch (val & VCC_MASK) { + case VCC_3V: + return 33; + case VCC_5V: + return 50; + } + + return 0; +} + +static inline u_char get_Vpp_value(uint8_t val) +{ + switch (val & VPP_MASK) { + case VPP_12V: + return 120; + case VPP_VCC: + return get_Vcc_value(val); + } + + return 0; +} + +static int cardu_get_socket(unsigned int sock, socket_state_t *state) +{ + vrc4173_socket_t *socket = &cardu_sockets[sock]; + uint8_t val; + + val = exca_readb(socket, PWR_CNT); + state->Vcc = get_Vcc_value(val); + state->Vpp = get_Vpp_value(val); + state->flags = 0; + if (val & CARD_OUT_EN) state->flags |= SS_OUTPUT_ENA; + + val = exca_readb(socket, INT_GEN_CNT); + if (!(val & CARD_REST0)) state->flags |= SS_RESET; + if (val & CARD_TYPE_IO) state->flags |= SS_IOCARD; + + return 0; +} + static inline uint8_t set_Vcc_value(u_char Vcc) { switch (Vcc) { @@ -389,6 +431,7 @@ static struct pccard_operations cardu_operations = { .register_callback = cardu_register_callback, .inquire_socket = cardu_inquire_socket, .get_status = cardu_get_status, + .get_socket = cardu_get_socket, .set_socket = cardu_set_socket, .get_io_map = cardu_get_io_map, .set_io_map = cardu_set_io_map, diff --git a/trunk/drivers/pcmcia/yenta_socket.c b/trunk/drivers/pcmcia/yenta_socket.c index 4145eb83b9b6..ec6ab65f0872 100644 --- a/trunk/drivers/pcmcia/yenta_socket.c +++ b/trunk/drivers/pcmcia/yenta_socket.c @@ -49,13 +49,7 @@ MODULE_PARM_DESC(pwr_irqs_off, "Force IRQs off during power-on of slot. Use only #define to_cycles(ns) ((ns)/120) #define to_ns(cycles) ((cycles)*120) -/** - * yenta PCI irq probing. - * currently only used in the TI/EnE initialization code - */ -#ifdef CONFIG_YENTA_TI static int yenta_probe_cb_irq(struct yenta_socket *socket); -#endif static unsigned int override_bios; @@ -230,6 +224,95 @@ static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value) return 0; } +static void yenta_get_power(struct yenta_socket *socket, socket_state_t *state) +{ + if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) && + (socket->flags & YENTA_16BIT_POWER_EXCA)) { + u8 reg, vcc, vpp; + + reg = exca_readb(socket, I365_POWER); + vcc = reg & I365_VCC_MASK; + vpp = reg & I365_VPP1_MASK; + state->Vcc = state->Vpp = 0; + + if (socket->flags & YENTA_16BIT_POWER_DF) { + if (vcc == I365_VCC_3V) + state->Vcc = 33; + if (vcc == I365_VCC_5V) + state->Vcc = 50; + if (vpp == I365_VPP1_5V) + state->Vpp = state->Vcc; + if (vpp == I365_VPP1_12V) + state->Vpp = 120; + } else { + if (reg & I365_VCC_5V) { + state->Vcc = 50; + if (vpp == I365_VPP1_5V) + state->Vpp = 50; + if (vpp == I365_VPP1_12V) + state->Vpp = 120; + } + } + } else { + u32 control; + + control = cb_readl(socket, CB_SOCKET_CONTROL); + + switch (control & CB_SC_VCC_MASK) { + case CB_SC_VCC_5V: state->Vcc = 50; break; + case CB_SC_VCC_3V: state->Vcc = 33; break; + default: state->Vcc = 0; + } + + switch (control & CB_SC_VPP_MASK) { + case CB_SC_VPP_12V: state->Vpp = 120; break; + case CB_SC_VPP_5V: state->Vpp = 50; break; + case CB_SC_VPP_3V: state->Vpp = 33; break; + default: state->Vpp = 0; + } + } +} + +static int yenta_get_socket(struct pcmcia_socket *sock, socket_state_t *state) +{ + struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); + u8 reg; + u32 control; + + control = cb_readl(socket, CB_SOCKET_CONTROL); + + yenta_get_power(socket, state); + state->io_irq = socket->io_irq; + + if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) { + u16 bridge = config_readw(socket, CB_BRIDGE_CONTROL); + if (bridge & CB_BRIDGE_CRST) + state->flags |= SS_RESET; + return 0; + } + + /* 16-bit card state.. */ + reg = exca_readb(socket, I365_POWER); + state->flags = (reg & I365_PWR_AUTO) ? SS_PWR_AUTO : 0; + state->flags |= (reg & I365_PWR_OUT) ? SS_OUTPUT_ENA : 0; + + reg = exca_readb(socket, I365_INTCTL); + state->flags |= (reg & I365_PC_RESET) ? 0 : SS_RESET; + state->flags |= (reg & I365_PC_IOCARD) ? SS_IOCARD : 0; + + reg = exca_readb(socket, I365_CSCINT); + state->csc_mask = (reg & I365_CSC_DETECT) ? SS_DETECT : 0; + if (state->flags & SS_IOCARD) { + state->csc_mask |= (reg & I365_CSC_STSCHG) ? SS_STSCHG : 0; + } else { + state->csc_mask |= (reg & I365_CSC_BVD1) ? SS_BATDEAD : 0; + state->csc_mask |= (reg & I365_CSC_BVD2) ? SS_BATWARN : 0; + state->csc_mask |= (reg & I365_CSC_READY) ? SS_READY : 0; + } + + return 0; +} + static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state) { /* some birdges require to use the ExCA registers to power 16bit cards */ @@ -448,9 +531,6 @@ static irqreturn_t yenta_interrupt(int irq, void *dev_id, struct pt_regs *regs) csc = exca_readb(socket, I365_CSC); - if (!(cb_event || csc)) - return IRQ_NONE; - events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ; events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0; if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { @@ -464,7 +544,10 @@ static irqreturn_t yenta_interrupt(int irq, void *dev_id, struct pt_regs *regs) if (events) pcmcia_parse_events(&socket->socket, events); - return IRQ_HANDLED; + if (cb_event || csc) + return IRQ_HANDLED; + + return IRQ_NONE; } static void yenta_interrupt_wrapper(unsigned long data) @@ -745,24 +828,17 @@ static struct pccard_operations yenta_socket_operations = { .init = yenta_sock_init, .suspend = yenta_sock_suspend, .get_status = yenta_get_status, + .get_socket = yenta_get_socket, .set_socket = yenta_set_socket, .set_io_map = yenta_set_io_map, .set_mem_map = yenta_set_mem_map, }; -#ifdef CONFIG_YENTA_TI #include "ti113x.h" -#endif -#ifdef CONFIG_YENTA_RICOH #include "ricoh.h" -#endif -#ifdef CONFIG_YENTA_TOSHIBA #include "topic.h" -#endif -#ifdef CONFIG_YENTA_O2 #include "o2micro.h" -#endif enum { CARDBUS_TYPE_DEFAULT = -1, @@ -782,7 +858,6 @@ enum { * initialization sequences etc details. List them here.. */ static struct cardbus_type cardbus_type[] = { -#ifdef CONFIG_YENTA_TI [CARDBUS_TYPE_TI] = { .override = ti_override, .save_state = ti_save_state, @@ -807,36 +882,27 @@ static struct cardbus_type cardbus_type[] = { .restore_state = ti_restore_state, .sock_init = ti_init, }, -#endif -#ifdef CONFIG_YENTA_RICOH [CARDBUS_TYPE_RICOH] = { .override = ricoh_override, .save_state = ricoh_save_state, .restore_state = ricoh_restore_state, }, -#endif -#ifdef CONFIG_YENTA_TOSHIBA [CARDBUS_TYPE_TOPIC95] = { .override = topic95_override, }, [CARDBUS_TYPE_TOPIC97] = { .override = topic97_override, }, -#endif -#ifdef CONFIG_YENTA_O2 [CARDBUS_TYPE_O2MICRO] = { .override = o2micro_override, .restore_state = o2micro_restore_state, }, -#endif -#ifdef CONFIG_YENTA_TI [CARDBUS_TYPE_ENE] = { .override = ene_override, .save_state = ti_save_state, .restore_state = ti_restore_state, .sock_init = ti_init, }, -#endif }; @@ -882,12 +948,6 @@ static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mas } -/** - * yenta PCI irq probing. - * currently only used in the TI/EnE initialization code - */ -#ifdef CONFIG_YENTA_TI - /* interrupt handler, only used during probing */ static irqreturn_t yenta_probe_handler(int irq, void *dev_id, struct pt_regs *regs) { @@ -940,7 +1000,6 @@ static int yenta_probe_cb_irq(struct yenta_socket *socket) return (int) socket->probe_status; } -#endif /* CONFIG_YENTA_TI */ /* @@ -1019,9 +1078,10 @@ static int __devinit yenta_probe (struct pci_dev *dev, const struct pci_device_i return -ENODEV; } - socket = kzalloc(sizeof(struct yenta_socket), GFP_KERNEL); + socket = kmalloc(sizeof(struct yenta_socket), GFP_KERNEL); if (!socket) return -ENOMEM; + memset(socket, 0, sizeof(*socket)); /* prepare pcmcia_socket */ socket->socket.ops = ¥ta_socket_operations; @@ -1203,7 +1263,6 @@ static struct pci_device_id yenta_table [] = { * advanced overrides instead. (I can't get the * data sheets for these devices. --rmk) */ -#ifdef CONFIG_YENTA_TI CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI), CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X), @@ -1246,25 +1305,18 @@ static struct pci_device_id yenta_table [] = { CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, ENE), CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, ENE), CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, ENE), -#endif /* CONFIG_YENTA_TI */ -#ifdef CONFIG_YENTA_RICOH CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH), CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH), CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH), CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH), CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH), -#endif -#ifdef CONFIG_YENTA_TOSHIBA CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95), CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97), CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97), -#endif -#ifdef CONFIG_YENTA_O2 CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO), -#endif /* match any cardbus bridge */ CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT), diff --git a/trunk/drivers/pnp/card.c b/trunk/drivers/pnp/card.c index 0ecbe4edbec1..bd7c966ea2d7 100644 --- a/trunk/drivers/pnp/card.c +++ b/trunk/drivers/pnp/card.c @@ -69,7 +69,6 @@ static int card_probe(struct pnp_card * card, struct pnp_card_driver * drv) return 0; clink->card = card; clink->driver = drv; - clink->pm_state = PMSG_ON; if (drv->probe) { if (drv->probe(clink, id)>=0) return 1; @@ -334,28 +333,6 @@ void pnp_release_card_device(struct pnp_dev * dev) up_write(&dev->dev.bus->subsys.rwsem); } -/* - * suspend/resume callbacks - */ -static int card_suspend(struct pnp_dev *dev, pm_message_t state) -{ - struct pnp_card_link *link = dev->card_link; - if (link->pm_state.event == state.event) - return 0; - link->pm_state = state; - return link->driver->suspend(link, state); -} - -static int card_resume(struct pnp_dev *dev) -{ - struct pnp_card_link *link = dev->card_link; - if (link->pm_state.event == PM_EVENT_ON) - return 0; - link->pm_state = PMSG_ON; - link->driver->resume(link); - return 0; -} - /** * pnp_register_card_driver - registers a PnP card driver with the PnP Layer * @drv: pointer to the driver to register @@ -371,8 +348,6 @@ int pnp_register_card_driver(struct pnp_card_driver * drv) drv->link.flags = drv->flags; drv->link.probe = NULL; drv->link.remove = &card_remove_first; - drv->link.suspend = drv->suspend ? card_suspend : NULL; - drv->link.resume = drv->resume ? card_resume : NULL; spin_lock(&pnp_lock); list_add_tail(&drv->global_list, &pnp_card_drivers); diff --git a/trunk/drivers/pnp/driver.c b/trunk/drivers/pnp/driver.c index 15fb758a9e52..d3ccce706ab4 100644 --- a/trunk/drivers/pnp/driver.c +++ b/trunk/drivers/pnp/driver.c @@ -146,57 +146,10 @@ static int pnp_bus_match(struct device *dev, struct device_driver *drv) return 1; } -static int pnp_bus_suspend(struct device *dev, pm_message_t state) -{ - struct pnp_dev * pnp_dev = to_pnp_dev(dev); - struct pnp_driver * pnp_drv = pnp_dev->driver; - int error; - - if (!pnp_drv) - return 0; - - if (pnp_drv->suspend) { - error = pnp_drv->suspend(pnp_dev, state); - if (error) - return error; - } - - if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE) && - pnp_can_disable(pnp_dev)) { - error = pnp_stop_dev(pnp_dev); - if (error) - return error; - } - - return 0; -} - -static int pnp_bus_resume(struct device *dev) -{ - struct pnp_dev * pnp_dev = to_pnp_dev(dev); - struct pnp_driver * pnp_drv = pnp_dev->driver; - int error; - - if (!pnp_drv) - return 0; - - if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE)) { - error = pnp_start_dev(pnp_dev); - if (error) - return error; - } - - if (pnp_drv->resume) - return pnp_drv->resume(pnp_dev); - - return 0; -} struct bus_type pnp_bus_type = { .name = "pnp", .match = pnp_bus_match, - .suspend = pnp_bus_suspend, - .resume = pnp_bus_resume, }; diff --git a/trunk/drivers/pnp/manager.c b/trunk/drivers/pnp/manager.c index c4256aa32bcb..261668618b2d 100644 --- a/trunk/drivers/pnp/manager.c +++ b/trunk/drivers/pnp/manager.c @@ -469,53 +469,6 @@ int pnp_auto_config_dev(struct pnp_dev *dev) return -EBUSY; } -/** - * pnp_start_dev - low-level start of the PnP device - * @dev: pointer to the desired device - * - * assumes that resources have alread been allocated - */ - -int pnp_start_dev(struct pnp_dev *dev) -{ - if (!pnp_can_write(dev)) { - pnp_info("Device %s does not supported activation.", dev->dev.bus_id); - return -EINVAL; - } - - if (dev->protocol->set(dev, &dev->res)<0) { - pnp_err("Failed to activate device %s.", dev->dev.bus_id); - return -EIO; - } - - pnp_info("Device %s activated.", dev->dev.bus_id); - - return 0; -} - -/** - * pnp_stop_dev - low-level disable of the PnP device - * @dev: pointer to the desired device - * - * does not free resources - */ - -int pnp_stop_dev(struct pnp_dev *dev) -{ - if (!pnp_can_disable(dev)) { - pnp_info("Device %s does not supported disabling.", dev->dev.bus_id); - return -EINVAL; - } - if (dev->protocol->disable(dev)<0) { - pnp_err("Failed to disable device %s.", dev->dev.bus_id); - return -EIO; - } - - pnp_info("Device %s disabled.", dev->dev.bus_id); - - return 0; -} - /** * pnp_activate_dev - activates a PnP device for use * @dev: pointer to the desired device @@ -524,8 +477,6 @@ int pnp_stop_dev(struct pnp_dev *dev) */ int pnp_activate_dev(struct pnp_dev *dev) { - int error; - if (!dev) return -EINVAL; if (dev->active) { @@ -536,11 +487,18 @@ int pnp_activate_dev(struct pnp_dev *dev) if (pnp_auto_config_dev(dev)) return -EBUSY; - error = pnp_start_dev(dev); - if (error) - return error; + if (!pnp_can_write(dev)) { + pnp_info("Device %s does not supported activation.", dev->dev.bus_id); + return -EINVAL; + } + + if (dev->protocol->set(dev, &dev->res)<0) { + pnp_err("Failed to activate device %s.", dev->dev.bus_id); + return -EIO; + } dev->active = 1; + pnp_info("Device %s activated.", dev->dev.bus_id); return 1; } @@ -553,19 +511,23 @@ int pnp_activate_dev(struct pnp_dev *dev) */ int pnp_disable_dev(struct pnp_dev *dev) { - int error; - if (!dev) return -EINVAL; if (!dev->active) { return 0; /* the device is already disabled */ } - error = pnp_stop_dev(dev); - if (error) - return error; + if (!pnp_can_disable(dev)) { + pnp_info("Device %s does not supported disabling.", dev->dev.bus_id); + return -EINVAL; + } + if (dev->protocol->disable(dev)<0) { + pnp_err("Failed to disable device %s.", dev->dev.bus_id); + return -EIO; + } dev->active = 0; + pnp_info("Device %s disabled.", dev->dev.bus_id); /* release the resources so that other devices can use them */ down(&pnp_res_mutex); @@ -596,8 +558,6 @@ EXPORT_SYMBOL(pnp_manual_config_dev); #if 0 EXPORT_SYMBOL(pnp_auto_config_dev); #endif -EXPORT_SYMBOL(pnp_start_dev); -EXPORT_SYMBOL(pnp_stop_dev); EXPORT_SYMBOL(pnp_activate_dev); EXPORT_SYMBOL(pnp_disable_dev); EXPORT_SYMBOL(pnp_resource_change); diff --git a/trunk/drivers/pnp/pnpbios/core.c b/trunk/drivers/pnp/pnpbios/core.c index b154b3f52cbe..f49674f07949 100644 --- a/trunk/drivers/pnp/pnpbios/core.c +++ b/trunk/drivers/pnp/pnpbios/core.c @@ -56,6 +56,7 @@ #include #include #include +#include #include #include #include @@ -105,6 +106,8 @@ static int pnp_dock_event(int dock, struct pnp_docking_station_info *info) char *argv [3], **envp, *buf, *scratch; int i = 0, value; + if (!hotplug_path [0]) + return -ENOENT; if (!current->fs->root) { return -EAGAIN; } @@ -116,9 +119,8 @@ static int pnp_dock_event(int dock, struct pnp_docking_station_info *info) return -ENOMEM; } - /* FIXME: if there are actual users of this, it should be integrated into - * the driver core and use the usual infrastructure like sysfs and uevents */ - argv [0] = "/sbin/pnpbios"; + /* only one standardized param to hotplug command: type */ + argv [0] = hotplug_path; argv [1] = "dock"; argv [2] = NULL; diff --git a/trunk/drivers/s390/cio/ccwgroup.c b/trunk/drivers/s390/cio/ccwgroup.c index be9d2d65c22f..e7bd7f37f080 100644 --- a/trunk/drivers/s390/cio/ccwgroup.c +++ b/trunk/drivers/s390/cio/ccwgroup.c @@ -45,7 +45,7 @@ ccwgroup_bus_match (struct device * dev, struct device_driver * drv) return 0; } static int -ccwgroup_uevent (struct device *dev, char **envp, int num_envp, char *buffer, +ccwgroup_hotplug (struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { /* TODO */ @@ -55,7 +55,7 @@ ccwgroup_uevent (struct device *dev, char **envp, int num_envp, char *buffer, static struct bus_type ccwgroup_bus_type = { .name = "ccwgroup", .match = ccwgroup_bus_match, - .uevent = ccwgroup_uevent, + .hotplug = ccwgroup_hotplug, }; static inline void diff --git a/trunk/drivers/s390/cio/device.c b/trunk/drivers/s390/cio/device.c index 85908cacc3b8..811c9d150637 100644 --- a/trunk/drivers/s390/cio/device.c +++ b/trunk/drivers/s390/cio/device.c @@ -59,7 +59,7 @@ ccw_bus_match (struct device * dev, struct device_driver * drv) * Heavily modeled on pci and usb hotplug. */ static int -ccw_uevent (struct device *dev, char **envp, int num_envp, +ccw_hotplug (struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { struct ccw_device *cdev = to_ccwdev(dev); @@ -110,7 +110,7 @@ ccw_uevent (struct device *dev, char **envp, int num_envp, struct bus_type ccw_bus_type = { .name = "ccw", .match = &ccw_bus_match, - .uevent = &ccw_uevent, + .hotplug = &ccw_hotplug, }; static int io_subchannel_probe (struct device *); diff --git a/trunk/drivers/s390/crypto/z90main.c b/trunk/drivers/s390/crypto/z90main.c index 790fcbb74b43..4010f2bb85af 100644 --- a/trunk/drivers/s390/crypto/z90main.c +++ b/trunk/drivers/s390/crypto/z90main.c @@ -34,6 +34,7 @@ #include #include #include +#include #include #include #include "z90crypt.h" diff --git a/trunk/drivers/scsi/.gitignore b/trunk/drivers/scsi/.gitignore deleted file mode 100644 index b385af314356..000000000000 --- a/trunk/drivers/scsi/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -53c700_d.h -53c7xx_d.h -53c7xx_u.h diff --git a/trunk/drivers/scsi/53c700.c b/trunk/drivers/scsi/53c700.c index 4ce7438608ec..e7ad269041a4 100644 --- a/trunk/drivers/scsi/53c700.c +++ b/trunk/drivers/scsi/53c700.c @@ -857,7 +857,7 @@ process_extended_message(struct Scsi_Host *host, printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ", host->host_no, pun, lun, NCR_700_phase[(dsps & 0xf00) >> 8]); - spi_print_msg(hostdata->msgin); + scsi_print_msg(hostdata->msgin); printk("\n"); /* just reject it */ hostdata->msgout[0] = A_REJECT_MSG; @@ -887,7 +887,7 @@ process_message(struct Scsi_Host *host, struct NCR_700_Host_Parameters *hostdata #ifdef NCR_700_DEBUG printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun, NCR_700_phase[(dsps & 0xf00) >> 8]); - spi_print_msg(hostdata->msgin); + scsi_print_msg(hostdata->msgin); printk("\n"); #endif @@ -939,7 +939,7 @@ process_message(struct Scsi_Host *host, struct NCR_700_Host_Parameters *hostdata host->host_no, pun, lun, NCR_700_phase[(dsps & 0xf00) >> 8]); - spi_print_msg(hostdata->msgin); + scsi_print_msg(hostdata->msgin); printk("\n"); /* just reject it */ hostdata->msgout[0] = A_REJECT_MSG; diff --git a/trunk/drivers/scsi/53c700.h b/trunk/drivers/scsi/53c700.h index a8c83bb03630..362d78483d09 100644 --- a/trunk/drivers/scsi/53c700.h +++ b/trunk/drivers/scsi/53c700.h @@ -238,23 +238,21 @@ struct NCR_700_Host_Parameters { #ifdef CONFIG_53C700_LE_ON_BE #define bE (hostdata->force_le_on_be ? 0 : 3) #define bSWAP (hostdata->force_le_on_be) -#define bEBus (!hostdata->force_le_on_be) +/* This is terrible, but there's no raw version of ioread32. That means + * that on a be board we swap twice (once in ioread32 and once again to + * get the value correct) */ +#define bS_to_io(x) ((hostdata->force_le_on_be) ? (x) : cpu_to_le32(x)) #elif defined(__BIG_ENDIAN) #define bE 3 #define bSWAP 0 +#define bS_to_io(x) (x) #elif defined(__LITTLE_ENDIAN) #define bE 0 #define bSWAP 0 +#define bS_to_io(x) (x) #else #error "__BIG_ENDIAN or __LITTLE_ENDIAN must be defined, did you include byteorder.h?" #endif -#ifndef bEBus -#ifdef CONFIG_53C700_BE_BUS -#define bEBus 1 -#else -#define bEBus 0 -#endif -#endif #define bS_to_cpu(x) (bSWAP ? le32_to_cpu(x) : (x)) #define bS_to_host(x) (bSWAP ? cpu_to_le32(x) : (x)) @@ -468,15 +466,14 @@ NCR_700_readl(struct Scsi_Host *host, __u32 reg) { const struct NCR_700_Host_Parameters *hostdata = (struct NCR_700_Host_Parameters *)host->hostdata[0]; - __u32 value = bEBus ? ioread32be(hostdata->base + reg) : - ioread32(hostdata->base + reg); + __u32 value = ioread32(hostdata->base + reg); #if 1 /* sanity check the register */ if((reg & 0x3) != 0) BUG(); #endif - return value; + return bS_to_io(value); } static inline void @@ -500,8 +497,7 @@ NCR_700_writel(__u32 value, struct Scsi_Host *host, __u32 reg) BUG(); #endif - bEBus ? iowrite32be(value, hostdata->base + reg): - iowrite32(value, hostdata->base + reg); + iowrite32(bS_to_io(value), hostdata->base + reg); } #endif diff --git a/trunk/drivers/scsi/53c7xx.c b/trunk/drivers/scsi/53c7xx.c index 7894b8ea84bd..9cb5dd48383f 100644 --- a/trunk/drivers/scsi/53c7xx.c +++ b/trunk/drivers/scsi/53c7xx.c @@ -282,7 +282,6 @@ #include "scsi.h" #include #include -#include #include "53c7xx.h" #include #include @@ -1725,7 +1724,7 @@ NCR53c7xx_run_tests (struct Scsi_Host *host) { printk ("scsi%d : status ", host->host_no); scsi_print_status (status); printk ("\nscsi%d : message ", host->host_no); - spi_print_msg(&msg); + scsi_print_msg (&msg); printk ("\n"); } else if (hostdata->test_completed == 3) { printk("scsi%d : test 2 no connection with target %d\n", @@ -2314,7 +2313,7 @@ NCR53c7x0_dstat_sir_intr (struct Scsi_Host *host, struct printk ("scsi%d : received message", host->host_no); if (c) printk (" from target %d lun %d ", c->device->id, c->device->lun); - spi_print_msg((unsigned char *) hostdata->msg_buf); + scsi_print_msg ((unsigned char *) hostdata->msg_buf); printk("\n"); } @@ -5541,7 +5540,7 @@ print_dsa (struct Scsi_Host *host, u32 *dsa, const char *prefix) { i > 0 && !check_address ((unsigned long) ptr, 1); ptr += len, i -= len) { printk(" "); - len = spi_print_msg(ptr); + len = scsi_print_msg (ptr); printk("\n"); if (!len) break; diff --git a/trunk/drivers/scsi/Kconfig b/trunk/drivers/scsi/Kconfig index 4c42065dea88..20dd85a77813 100644 --- a/trunk/drivers/scsi/Kconfig +++ b/trunk/drivers/scsi/Kconfig @@ -336,7 +336,6 @@ config SCSI_ACARD config SCSI_AHA152X tristate "Adaptec AHA152X/2825 support" depends on ISA && SCSI && !64BIT - select SCSI_SPI_ATTRS ---help--- This is a driver for the AHA-1510, AHA-1520, AHA-1522, and AHA-2825 SCSI host adapters. It also works for the AVA-1505, but the IRQ etc. @@ -624,7 +623,6 @@ config SCSI_OMIT_FLASHPOINT config SCSI_DMX3191D tristate "DMX3191D SCSI support" depends on PCI && SCSI - select SCSI_SPI_ATTRS help This is support for Domex DMX3191D SCSI Host Adapters. @@ -634,7 +632,6 @@ config SCSI_DMX3191D config SCSI_DTC3280 tristate "DTC3180/3280 SCSI support" depends on ISA && SCSI - select SCSI_SPI_ATTRS help This is support for DTC 3180/3280 SCSI Host Adapters. Please read the SCSI-HOWTO, available from @@ -755,7 +752,6 @@ config SCSI_GDTH config SCSI_GENERIC_NCR5380 tristate "Generic NCR5380/53c400 SCSI PIO support" depends on ISA && SCSI - select SCSI_SPI_ATTRS ---help--- This is a driver for the old NCR 53c80 series of SCSI controllers on boards using PIO. Most boards such as the Trantor T130 fit this @@ -775,7 +771,6 @@ config SCSI_GENERIC_NCR5380 config SCSI_GENERIC_NCR5380_MMIO tristate "Generic NCR5380/53c400 SCSI MMIO support" depends on ISA && SCSI - select SCSI_SPI_ATTRS ---help--- This is a driver for the old NCR 53c80 series of SCSI controllers on boards using memory mapped I/O. @@ -1259,7 +1254,6 @@ config SCSI_MCA_53C9X config SCSI_PAS16 tristate "PAS16 SCSI support" depends on ISA && SCSI - select SCSI_SPI_ATTRS ---help--- This is support for a SCSI host adapter. It is explained in section 3.10 of the SCSI-HOWTO, available from @@ -1429,7 +1423,6 @@ config SCSI_DC390T config SCSI_T128 tristate "Trantor T128/T128F/T228 SCSI support" depends on ISA && SCSI - select SCSI_SPI_ATTRS ---help--- This is support for a SCSI host adapter. It is explained in section 3.11 of the SCSI-HOWTO, available from @@ -1688,7 +1681,6 @@ config OKTAGON_SCSI config ATARI_SCSI tristate "Atari native SCSI support" depends on ATARI && SCSI && BROKEN - select SCSI_SPI_ATTRS ---help--- If you have an Atari with built-in NCR5380 SCSI controller (TT, Falcon, ...) say Y to get it supported. Of course also, if you have @@ -1730,7 +1722,6 @@ config TT_DMA_EMUL config MAC_SCSI bool "Macintosh NCR5380 SCSI" depends on MAC && SCSI=y - select SCSI_SPI_ATTRS help This is the NCR 5380 SCSI controller included on most of the 68030 based Macintoshes. If you have one of these say Y and read the @@ -1752,7 +1743,6 @@ config SCSI_MAC_ESP config MVME147_SCSI bool "WD33C93 SCSI driver for MVME147" depends on MVME147 && SCSI=y - select SCSI_SPI_ATTRS help Support for the on-board SCSI controller on the Motorola MVME147 single-board computer. @@ -1760,7 +1750,6 @@ config MVME147_SCSI config MVME16x_SCSI bool "NCR53C710 SCSI driver for MVME16x" depends on MVME16x && SCSI && BROKEN - select SCSI_SPI_ATTRS help The Motorola MVME162, 166, 167, 172 and 177 boards use the NCR53C710 SCSI controller chip. Almost everyone using one of these boards @@ -1769,7 +1758,6 @@ config MVME16x_SCSI config BVME6000_SCSI bool "NCR53C710 SCSI driver for BVME6000" depends on BVME6000 && SCSI && BROKEN - select SCSI_SPI_ATTRS help The BVME4000 and BVME6000 boards from BVM Ltd use the NCR53C710 SCSI controller chip. Almost everyone using one of these boards @@ -1786,7 +1774,6 @@ config SCSI_NCR53C7xx_FAST config SUN3_SCSI tristate "Sun3 NCR5380 SCSI" depends on SUN3 && SCSI && BROKEN - select SCSI_SPI_ATTRS help This option will enable support for the OBIO (onboard io) NCR5380 SCSI controller found in the Sun 3/50 and 3/60, as well as for diff --git a/trunk/drivers/scsi/NCR5380.c b/trunk/drivers/scsi/NCR5380.c index 9f0ddbe6dc76..cba9655d0f14 100644 --- a/trunk/drivers/scsi/NCR5380.c +++ b/trunk/drivers/scsi/NCR5380.c @@ -87,7 +87,6 @@ * the high level code. */ #include -#include #ifndef NDEBUG #define NDEBUG 0 @@ -2378,7 +2377,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) { * 3..length+1 arguments * * Start the extended message buffer with the EXTENDED_MESSAGE - * byte, since spi_print_msg() wants the whole thing. + * byte, since scsi_print_msg() wants the whole thing. */ extended_msg[0] = EXTENDED_MESSAGE; /* Accept first byte by clearing ACK */ @@ -2425,7 +2424,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) { default: if (!tmp) { printk("scsi%d: rejecting message ", instance->host_no); - spi_print_msg(extended_msg); + scsi_print_msg(extended_msg); printk("\n"); } else if (tmp != EXTENDED_MESSAGE) scmd_printk(KERN_INFO, cmd, @@ -2561,7 +2560,7 @@ static void NCR5380_reselect(struct Scsi_Host *instance) { if (!(msg[0] & 0x80)) { printk(KERN_ERR "scsi%d : expecting IDENTIFY message, got ", instance->host_no); - spi_print_msg(msg); + scsi_print_msg(msg); abort = 1; } else { /* Accept message by clearing ACK */ diff --git a/trunk/drivers/scsi/aha152x.c b/trunk/drivers/scsi/aha152x.c index cb2ee25f213f..9df23b654cec 100644 --- a/trunk/drivers/scsi/aha152x.c +++ b/trunk/drivers/scsi/aha152x.c @@ -259,7 +259,6 @@ #include "scsi.h" #include #include -#include #include "aha152x.h" @@ -1846,7 +1845,7 @@ static void msgi_run(struct Scsi_Host *shpnt) #if defined(AHA152X_DEBUG) if (HOSTDATA(shpnt)->debug & debug_msgi) { printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0)); - spi_print_msg(&MSGI(0)); + scsi_print_msg(&MSGI(0)); printk("\n"); } #endif @@ -1934,7 +1933,7 @@ static void msgi_run(struct Scsi_Host *shpnt) break; printk(INFO_LEAD, CMDINFO(CURRENT_SC)); - spi_print_msg(&MSGI(0)); + scsi_print_msg(&MSGI(0)); printk("\n"); ticks = (MSGI(3) * 4 + 49) / 50; @@ -2032,7 +2031,7 @@ static void msgo_init(struct Scsi_Host *shpnt) int i; printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC)); - for (i=0; iscsidone = scsi_finish_command; - qc->err_mask |= AC_ERR_OTHER; - ata_qc_complete(qc); + ata_qc_complete(qc, AC_ERR_OTHER); } spin_unlock_irqrestore(&host_set->lock, flags); @@ -665,8 +664,7 @@ static inline int ahci_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc) ci = readl(port_mmio + PORT_CMD_ISSUE); if (likely((ci & 0x1) == 0)) { if (qc) { - assert(qc->err_mask == 0); - ata_qc_complete(qc); + ata_qc_complete(qc, 0); qc = NULL; } } @@ -683,10 +681,8 @@ static inline int ahci_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc) /* command processing has stopped due to error; restart */ ahci_restart_port(ap, status); - if (qc) { - qc->err_mask |= AC_ERR_OTHER; - ata_qc_complete(qc); - } + if (qc) + ata_qc_complete(qc, err_mask); } return 1; diff --git a/trunk/drivers/scsi/aic7xxx/.gitignore b/trunk/drivers/scsi/aic7xxx/.gitignore deleted file mode 100644 index b8ee24d5748a..000000000000 --- a/trunk/drivers/scsi/aic7xxx/.gitignore +++ /dev/null @@ -1,6 +0,0 @@ -aic79xx_reg.h -aic79xx_reg_print.c -aic79xx_seq.h -aic7xxx_reg.h -aic7xxx_reg_print.c -aic7xxx_seq.h diff --git a/trunk/drivers/scsi/aic7xxx/aic79xx_osm.c b/trunk/drivers/scsi/aic7xxx/aic79xx_osm.c index 1c8f872e2dd4..6aab9dacdeea 100644 --- a/trunk/drivers/scsi/aic7xxx/aic79xx_osm.c +++ b/trunk/drivers/scsi/aic7xxx/aic79xx_osm.c @@ -1064,7 +1064,6 @@ ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *templa struct Scsi_Host *host; char *new_name; u_long s; - int retval; template->name = ahd->description; host = scsi_host_alloc(template, sizeof(struct ahd_softc *)); @@ -1097,15 +1096,9 @@ ahd_linux_register_host(struct ahd_softc *ahd, struct scsi_host_template *templa host->transportt = ahd_linux_transport_template; - retval = scsi_add_host(host, &ahd->dev_softc->dev); - if (retval) { - printk(KERN_WARNING "aic79xx: scsi_add_host failed\n"); - scsi_host_put(host); - return retval; - } - + scsi_add_host(host, &ahd->dev_softc->dev); /* XXX handle failure */ scsi_scan_host(host); - return 0; + return (0); } uint64_t diff --git a/trunk/drivers/scsi/aic7xxx/aic7xxx_osm.c b/trunk/drivers/scsi/aic7xxx/aic7xxx_osm.c index fd389e9f9460..d866213f42b8 100644 --- a/trunk/drivers/scsi/aic7xxx/aic7xxx_osm.c +++ b/trunk/drivers/scsi/aic7xxx/aic7xxx_osm.c @@ -1061,11 +1061,10 @@ uint32_t aic7xxx_verbose; int ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *template) { - char buf[80]; - struct Scsi_Host *host; + char buf[80]; + struct Scsi_Host *host; char *new_name; - u_long s; - int retval; + u_long s; template->name = ahc->description; host = scsi_host_alloc(template, sizeof(struct ahc_softc *)); @@ -1098,16 +1097,9 @@ ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *templa host->transportt = ahc_linux_transport_template; - retval = scsi_add_host(host, - (ahc->dev_softc ? &ahc->dev_softc->dev : NULL)); - if (retval) { - printk(KERN_WARNING "aic7xxx: scsi_add_host failed\n"); - scsi_host_put(host); - return retval; - } - + scsi_add_host(host, (ahc->dev_softc ? &ahc->dev_softc->dev : NULL)); /* XXX handle failure */ scsi_scan_host(host); - return 0; + return (0); } /* diff --git a/trunk/drivers/scsi/arm/Kconfig b/trunk/drivers/scsi/arm/Kconfig index 06d7601cdf56..13f23043c8a3 100644 --- a/trunk/drivers/scsi/arm/Kconfig +++ b/trunk/drivers/scsi/arm/Kconfig @@ -4,7 +4,6 @@ config SCSI_ACORNSCSI_3 tristate "Acorn SCSI card (aka30) support" depends on ARCH_ACORN && SCSI && BROKEN - select SCSI_SPI_ATTRS help This enables support for the Acorn SCSI card (aka30). If you have an Acorn system with one of these, say Y. If unsure, say N. diff --git a/trunk/drivers/scsi/arm/acornscsi.c b/trunk/drivers/scsi/arm/acornscsi.c index 09ed05727bcb..b7b20c689c24 100644 --- a/trunk/drivers/scsi/arm/acornscsi.c +++ b/trunk/drivers/scsi/arm/acornscsi.c @@ -152,7 +152,6 @@ #include "../scsi.h" #include #include -#include #include "acornscsi.h" #include "msgqueue.h" #include "scsi.h" @@ -1371,7 +1370,7 @@ void acornscsi_sendmessage(AS_Host *host) host->scsi.last_message = msg->msg[0]; #if (DEBUG & DEBUG_MESSAGES) - spi_print_msg(msg->msg); + scsi_print_msg(msg->msg); #endif break; @@ -1393,7 +1392,7 @@ void acornscsi_sendmessage(AS_Host *host) while ((msg = msgqueue_getmsg(&host->scsi.msgs, msgnr++)) != NULL) { unsigned int i; #if (DEBUG & DEBUG_MESSAGES) - spi_print_msg(msg); + scsi_print_msg(msg); #endif i = 0; if (acornscsi_write_pio(host, msg->msg, &i, msg->length, 1000000)) @@ -1489,7 +1488,7 @@ void acornscsi_message(AS_Host *host) #if (DEBUG & DEBUG_MESSAGES) printk("scsi%d.%c: message in: ", host->host->host_no, acornscsi_target(host)); - spi_print_msg(message); + scsi_print_msg(message); printk("\n"); #endif diff --git a/trunk/drivers/scsi/ata_piix.c b/trunk/drivers/scsi/ata_piix.c index 0ea27873b9ff..333d69dd84ef 100644 --- a/trunk/drivers/scsi/ata_piix.c +++ b/trunk/drivers/scsi/ata_piix.c @@ -37,49 +37,6 @@ * * Hardware documentation available at http://developer.intel.com/ * - * Documentation - * Publically available from Intel web site. Errata documentation - * is also publically available. As an aide to anyone hacking on this - * driver the list of errata that are relevant is below.going back to - * PIIX4. Older device documentation is now a bit tricky to find. - * - * The chipsets all follow very much the same design. The orginal Triton - * series chipsets do _not_ support independant device timings, but this - * is fixed in Triton II. With the odd mobile exception the chips then - * change little except in gaining more modes until SATA arrives. This - * driver supports only the chips with independant timing (that is those - * with SITRE and the 0x44 timing register). See pata_oldpiix and pata_mpiix - * for the early chip drivers. - * - * Errata of note: - * - * Unfixable - * PIIX4 errata #9 - Only on ultra obscure hw - * ICH3 errata #13 - Not observed to affect real hw - * by Intel - * - * Things we must deal with - * PIIX4 errata #10 - BM IDE hang with non UDMA - * (must stop/start dma to recover) - * 440MX errata #15 - As PIIX4 errata #10 - * PIIX4 errata #15 - Must not read control registers - * during a PIO transfer - * 440MX errata #13 - As PIIX4 errata #15 - * ICH2 errata #21 - DMA mode 0 doesn't work right - * ICH0/1 errata #55 - As ICH2 errata #21 - * ICH2 spec c #9 - Extra operations needed to handle - * drive hotswap [NOT YET SUPPORTED] - * ICH2 spec c #20 - IDE PRD must not cross a 64K boundary - * and must be dword aligned - * ICH2 spec c #24 - UDMA mode 4,5 t85/86 should be 6ns not 3.3 - * - * Should have been BIOS fixed: - * 450NX: errata #19 - DMA hangs on old 450NX - * 450NX: errata #20 - DMA hangs on old 450NX - * 450NX: errata #25 - Corruption with DMA on old 450NX - * ICH3 errata #15 - IDE deadlock under high load - * (BIOS must set dev 31 fn 0 bit 23) - * ICH3 errata #18 - Don't use native mode */ #include @@ -121,7 +78,9 @@ enum { ich5_sata = 1, piix4_pata = 2, ich6_sata = 3, - ich6_sata_ahci = 4, + ich6_sata_rm = 4, + ich7_sata = 5, + esb2_sata = 6, PIIX_AHCI_DEVICE = 6, }; @@ -152,11 +111,11 @@ static const struct pci_device_id piix_pci_tbl[] = { { 0x8086, 0x25a3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_sata }, { 0x8086, 0x25b0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_sata }, { 0x8086, 0x2651, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata }, - { 0x8086, 0x2652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_ahci }, - { 0x8086, 0x2653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_ahci }, - { 0x8086, 0x27c0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_ahci }, - { 0x8086, 0x27c4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_ahci }, - { 0x8086, 0x2680, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_ahci }, + { 0x8086, 0x2652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_rm }, + { 0x8086, 0x2653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_sata_rm }, + { 0x8086, 0x27c0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich7_sata }, + { 0x8086, 0x27c4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich7_sata }, + { 0x8086, 0x2680, PCI_ANY_ID, PCI_ANY_ID, 0, 0, esb2_sata }, { } /* terminate list */ }; @@ -299,7 +258,31 @@ static struct ata_port_info piix_port_info[] = { .port_ops = &piix_sata_ops, }, - /* ich6_sata_ahci */ + /* ich6_sata_rm */ + { + .sht = &piix_sht, + .host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST | + PIIX_FLAG_COMBINED | PIIX_FLAG_CHECKINTR | + ATA_FLAG_SLAVE_POSS | PIIX_FLAG_AHCI, + .pio_mask = 0x1f, /* pio0-4 */ + .mwdma_mask = 0x07, /* mwdma0-2 */ + .udma_mask = 0x7f, /* udma0-6 */ + .port_ops = &piix_sata_ops, + }, + + /* ich7_sata */ + { + .sht = &piix_sht, + .host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST | + PIIX_FLAG_COMBINED | PIIX_FLAG_CHECKINTR | + ATA_FLAG_SLAVE_POSS | PIIX_FLAG_AHCI, + .pio_mask = 0x1f, /* pio0-4 */ + .mwdma_mask = 0x07, /* mwdma0-2 */ + .udma_mask = 0x7f, /* udma0-6 */ + .port_ops = &piix_sata_ops, + }, + + /* esb2_sata */ { .sht = &piix_sht, .host_flags = ATA_FLAG_SATA | ATA_FLAG_SRST | @@ -619,40 +602,6 @@ static int piix_disable_ahci(struct pci_dev *pdev) return rc; } -/** - * piix_check_450nx_errata - Check for problem 450NX setup - * - * Check for the present of 450NX errata #19 and errata #25. If - * they are found return an error code so we can turn off DMA - */ - -static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev) -{ - struct pci_dev *pdev = NULL; - u16 cfg; - u8 rev; - int no_piix_dma = 0; - - while((pdev = pci_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454NX, pdev)) != NULL) - { - /* Look for 450NX PXB. Check for problem configurations - A PCI quirk checks bit 6 already */ - pci_read_config_byte(pdev, PCI_REVISION_ID, &rev); - pci_read_config_word(pdev, 0x41, &cfg); - /* Only on the original revision: IDE DMA can hang */ - if(rev == 0x00) - no_piix_dma = 1; - /* On all revisions below 5 PXB bus lock must be disabled for IDE */ - else if(cfg & (1<<14) && rev < 5) - no_piix_dma = 2; - } - if(no_piix_dma) - dev_printk(KERN_WARNING, &ata_dev->dev, "450NX errata present, disabling IDE DMA.\n"); - if(no_piix_dma == 2) - dev_printk(KERN_WARNING, &ata_dev->dev, "A BIOS update may resolve this.\n"); - return no_piix_dma; -} - /** * piix_init_one - Register PIIX ATA PCI device with kernel services * @pdev: PCI device to register @@ -727,15 +676,7 @@ static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent) "combined mode detected (p=%u, s=%u)\n", pata_chan, sata_chan); } - if (piix_check_450nx_errata(pdev)) { - /* This writes into the master table but it does not - really matter for this errata as we will apply it to - all the PIIX devices on the board */ - port_info[0]->mwdma_mask = 0; - port_info[0]->udma_mask = 0; - port_info[1]->mwdma_mask = 0; - port_info[1]->udma_mask = 0; - } + return ata_pci_init_one(pdev, port_info, 2); } diff --git a/trunk/drivers/scsi/atari_NCR5380.c b/trunk/drivers/scsi/atari_NCR5380.c index 57295bcea3e7..2ae31ceb32a8 100644 --- a/trunk/drivers/scsi/atari_NCR5380.c +++ b/trunk/drivers/scsi/atari_NCR5380.c @@ -74,7 +74,6 @@ * the high level code. */ #include -#include #if (NDEBUG & NDEBUG_LISTS) #define LIST(x,y) \ @@ -2356,7 +2355,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance) * 3..length+1 arguments * * Start the extended message buffer with the EXTENDED_MESSAGE - * byte, since spi_print_msg() wants the whole thing. + * byte, since scsi_print_msg() wants the whole thing. */ extended_msg[0] = EXTENDED_MESSAGE; /* Accept first byte by clearing ACK */ @@ -2409,7 +2408,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance) default: if (!tmp) { printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO); - spi_print_msg(extended_msg); + scsi_print_msg (extended_msg); printk("\n"); } else if (tmp != EXTENDED_MESSAGE) printk(KERN_DEBUG "scsi%d: rejecting unknown " @@ -2542,7 +2541,7 @@ static void NCR5380_reselect (struct Scsi_Host *instance) if (!(msg[0] & 0x80)) { printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO); - spi_print_msg(msg); + scsi_print_msg(msg); do_abort(instance); return; } diff --git a/trunk/drivers/scsi/ch.c b/trunk/drivers/scsi/ch.c index 0920220f3313..ccbbae2bf478 100644 --- a/trunk/drivers/scsi/ch.c +++ b/trunk/drivers/scsi/ch.c @@ -75,7 +75,7 @@ static int vendor_counts[CH_TYPES-4]; module_param_array(vendor_firsts, int, NULL, 0444); module_param_array(vendor_counts, int, NULL, 0444); -static const char * vendor_labels[CH_TYPES-4] = { +static char *vendor_labels[CH_TYPES-4] = { "v0", "v1", "v2", "v3" }; // module_param_string_array(vendor_labels, NULL, 0444); @@ -140,7 +140,7 @@ static struct file_operations changer_fops = #endif }; -static const struct { +static struct { unsigned char sense; unsigned char asc; unsigned char ascq; diff --git a/trunk/drivers/scsi/constants.c b/trunk/drivers/scsi/constants.c index 30a335349cee..09bc81557b6e 100644 --- a/trunk/drivers/scsi/constants.c +++ b/trunk/drivers/scsi/constants.c @@ -1065,7 +1065,7 @@ struct error_info2 { const char * fmt; }; -static const struct error_info2 additional2[] = +static struct error_info2 additional2[] = { {0x40,0x00,0x7f,"Ram failure (%x)"}, {0x40,0x80,0xff,"Diagnostic failure on component (%x)"}, @@ -1077,7 +1077,7 @@ static const struct error_info2 additional2[] = }; /* description of the sense key values */ -static const char * const snstext[] = { +static const char *snstext[] = { "No Sense", /* 0: There is no sense information */ "Recovered Error", /* 1: The last command completed successfully but used error correction */ @@ -1278,6 +1278,114 @@ void scsi_print_req_sense(const char *devclass, struct scsi_request *sreq) } EXPORT_SYMBOL(scsi_print_req_sense); +#ifdef CONFIG_SCSI_CONSTANTS +static const char *one_byte_msgs[] = { +/* 0x00 */ "Command Complete", NULL, "Save Pointers", +/* 0x03 */ "Restore Pointers", "Disconnect", "Initiator Error", +/* 0x06 */ "Abort", "Message Reject", "Nop", "Message Parity Error", +/* 0x0a */ "Linked Command Complete", "Linked Command Complete w/flag", +/* 0x0c */ "Bus device reset", "Abort Tag", "Clear Queue", +/* 0x0f */ "Initiate Recovery", "Release Recovery" +}; +#define NO_ONE_BYTE_MSGS (sizeof(one_byte_msgs) / sizeof (const char *)) + +static const char *two_byte_msgs[] = { +/* 0x20 */ "Simple Queue Tag", "Head of Queue Tag", "Ordered Queue Tag" +/* 0x23 */ "Ignore Wide Residue" +}; +#define NO_TWO_BYTE_MSGS (sizeof(two_byte_msgs) / sizeof (const char *)) + +static const char *extended_msgs[] = { +/* 0x00 */ "Modify Data Pointer", "Synchronous Data Transfer Request", +/* 0x02 */ "SCSI-I Extended Identify", "Wide Data Transfer Request" +}; +#define NO_EXTENDED_MSGS (sizeof(two_byte_msgs) / sizeof (const char *)) + + +int scsi_print_msg (const unsigned char *msg) +{ + int len = 0, i; + if (msg[0] == EXTENDED_MESSAGE) { + len = 3 + msg[1]; + if (msg[2] < NO_EXTENDED_MSGS) + printk ("%s ", extended_msgs[msg[2]]); + else + printk ("Extended Message, reserved code (0x%02x) ", + (int) msg[2]); + switch (msg[2]) { + case EXTENDED_MODIFY_DATA_POINTER: + printk("pointer = %d", (int) (msg[3] << 24) | + (msg[4] << 16) | (msg[5] << 8) | msg[6]); + break; + case EXTENDED_SDTR: + printk("period = %d ns, offset = %d", + (int) msg[3] * 4, (int) msg[4]); + break; + case EXTENDED_WDTR: + printk("width = 2^%d bytes", msg[3]); + break; + default: + for (i = 2; i < len; ++i) + printk("%02x ", msg[i]); + } + /* Identify */ + } else if (msg[0] & 0x80) { + printk("Identify disconnect %sallowed %s %d ", + (msg[0] & 0x40) ? "" : "not ", + (msg[0] & 0x20) ? "target routine" : "lun", + msg[0] & 0x7); + len = 1; + /* Normal One byte */ + } else if (msg[0] < 0x1f) { + if (msg[0] < NO_ONE_BYTE_MSGS) + printk(one_byte_msgs[msg[0]]); + else + printk("reserved (%02x) ", msg[0]); + len = 1; + /* Two byte */ + } else if (msg[0] <= 0x2f) { + if ((msg[0] - 0x20) < NO_TWO_BYTE_MSGS) + printk("%s %02x ", two_byte_msgs[msg[0] - 0x20], + msg[1]); + else + printk("reserved two byte (%02x %02x) ", + msg[0], msg[1]); + len = 2; + } else + printk("reserved"); + return len; +} +EXPORT_SYMBOL(scsi_print_msg); + +#else /* ifndef CONFIG_SCSI_CONSTANTS */ + +int scsi_print_msg (const unsigned char *msg) +{ + int len = 0, i; + + if (msg[0] == EXTENDED_MESSAGE) { + len = 3 + msg[1]; + for (i = 0; i < len; ++i) + printk("%02x ", msg[i]); + /* Identify */ + } else if (msg[0] & 0x80) { + printk("%02x ", msg[0]); + len = 1; + /* Normal One byte */ + } else if (msg[0] < 0x1f) { + printk("%02x ", msg[0]); + len = 1; + /* Two byte */ + } else if (msg[0] <= 0x2f) { + printk("%02x %02x", msg[0], msg[1]); + len = 2; + } else + printk("%02x ", msg[0]); + return len; +} +EXPORT_SYMBOL(scsi_print_msg); +#endif /* ! CONFIG_SCSI_CONSTANTS */ + void scsi_print_command(struct scsi_cmnd *cmd) { /* Assume appended output (i.e. not at start of line) */ @@ -1289,7 +1397,7 @@ EXPORT_SYMBOL(scsi_print_command); #ifdef CONFIG_SCSI_CONSTANTS -static const char * const hostbyte_table[]={ +static const char * hostbyte_table[]={ "DID_OK", "DID_NO_CONNECT", "DID_BUS_BUSY", "DID_TIME_OUT", "DID_BAD_TARGET", "DID_ABORT", "DID_PARITY", "DID_ERROR", "DID_RESET", "DID_BAD_INTR", "DID_PASSTHROUGH", "DID_SOFT_ERROR", "DID_IMM_RETRY"}; @@ -1314,12 +1422,12 @@ void scsi_print_hostbyte(int scsiresult) #ifdef CONFIG_SCSI_CONSTANTS -static const char * const driverbyte_table[]={ +static const char * driverbyte_table[]={ "DRIVER_OK", "DRIVER_BUSY", "DRIVER_SOFT", "DRIVER_MEDIA", "DRIVER_ERROR", "DRIVER_INVALID", "DRIVER_TIMEOUT", "DRIVER_HARD", "DRIVER_SENSE"}; #define NUM_DRIVERBYTE_STRS (sizeof(driverbyte_table) / sizeof(const char *)) -static const char * const driversuggest_table[]={"SUGGEST_OK", +static const char * driversuggest_table[]={"SUGGEST_OK", "SUGGEST_RETRY", "SUGGEST_ABORT", "SUGGEST_REMAP", "SUGGEST_DIE", "SUGGEST_5", "SUGGEST_6", "SUGGEST_7", "SUGGEST_SENSE"}; #define NUM_SUGGEST_STRS (sizeof(driversuggest_table) / sizeof(const char *)) diff --git a/trunk/drivers/scsi/ipr.c b/trunk/drivers/scsi/ipr.c index 27acf78cf8d8..fa2cb3582cfa 100644 --- a/trunk/drivers/scsi/ipr.c +++ b/trunk/drivers/scsi/ipr.c @@ -2132,7 +2132,7 @@ static void ipr_worker_thread(void *data) } spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); - kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE); + kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE, NULL); LEAVE; } @@ -5887,12 +5887,7 @@ static int __devinit ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg) ENTER; spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags); dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg); - if (ioa_cfg->needs_hard_reset) { - ioa_cfg->needs_hard_reset = 0; - ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); - } else - _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa, - IPR_SHUTDOWN_NONE); + _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa, IPR_SHUTDOWN_NONE); spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags); wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); @@ -6269,7 +6264,6 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev, unsigned long ipr_regs_pci; void __iomem *ipr_regs; u32 rc = PCIBIOS_SUCCESSFUL; - volatile u32 mask, uproc; ENTER; @@ -6362,15 +6356,6 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev, goto cleanup_nomem; } - /* - * If HRRQ updated interrupt is not masked, or reset alert is set, - * the card is in an unknown state and needs a hard reset - */ - mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg); - uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg); - if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT)) - ioa_cfg->needs_hard_reset = 1; - ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER); rc = request_irq(pdev->irq, ipr_isr, SA_SHIRQ, IPR_NAME, ioa_cfg); diff --git a/trunk/drivers/scsi/ipr.h b/trunk/drivers/scsi/ipr.h index b639332131f1..6bec673c925c 100644 --- a/trunk/drivers/scsi/ipr.h +++ b/trunk/drivers/scsi/ipr.h @@ -36,8 +36,8 @@ /* * Literals */ -#define IPR_DRIVER_VERSION "2.1.1" -#define IPR_DRIVER_DATE "(November 15, 2005)" +#define IPR_DRIVER_VERSION "2.1.0" +#define IPR_DRIVER_DATE "(October 31, 2005)" /* * IPR_MAX_CMD_PER_LUN: This defines the maximum number of outstanding @@ -922,7 +922,6 @@ struct ipr_ioa_cfg { u8 dump_taken:1; u8 allow_cmds:1; u8 allow_ml_add_del:1; - u8 needs_hard_reset:1; enum ipr_cache_state cache_state; u16 type; /* CCIN of the card */ diff --git a/trunk/drivers/scsi/iscsi_tcp.c b/trunk/drivers/scsi/iscsi_tcp.c index 10bcf42cb65c..3d8009f55342 100644 --- a/trunk/drivers/scsi/iscsi_tcp.c +++ b/trunk/drivers/scsi/iscsi_tcp.c @@ -49,7 +49,7 @@ MODULE_AUTHOR("Dmitry Yusupov , " "Alex Aizman "); MODULE_DESCRIPTION("iSCSI/TCP data-path"); MODULE_LICENSE("GPL"); -MODULE_VERSION("0:4.445"); +MODULE_VERSION("0:4.409"); /* #define DEBUG_TCP */ /* #define DEBUG_SCSI */ #define DEBUG_ASSERT @@ -581,16 +581,10 @@ iscsi_hdr_recv(struct iscsi_conn *conn) crypto_digest_digest(conn->rx_tfm, &sg, 1, (u8 *)&cdgst); rdgst = *(uint32_t*)((char*)hdr + sizeof(struct iscsi_hdr) + conn->in.ahslen); - if (cdgst != rdgst) { - printk(KERN_ERR "iscsi_tcp: itt %x: hdrdgst error " - "recv 0x%x calc 0x%x\n", conn->in.itt, rdgst, - cdgst); - return ISCSI_ERR_HDR_DGST; - } } /* save opcode for later */ - conn->in.opcode = hdr->opcode & ISCSI_OPCODE_MASK; + conn->in.opcode = hdr->opcode; /* verify itt (itt encoding: age+cid+itt) */ if (hdr->itt != cpu_to_be32(ISCSI_RESERVED_TAG)) { @@ -616,6 +610,13 @@ iscsi_hdr_recv(struct iscsi_conn *conn) conn->in.ahslen, conn->in.datalen); if (conn->in.itt < session->cmds_max) { + if (conn->hdrdgst_en && cdgst != rdgst) { + printk(KERN_ERR "iscsi_tcp: itt %x: hdrdgst error " + "recv 0x%x calc 0x%x\n", conn->in.itt, rdgst, + cdgst); + return ISCSI_ERR_HDR_DGST; + } + ctask = (struct iscsi_cmd_task *)session->cmds[conn->in.itt]; if (!ctask->sc) { @@ -641,7 +642,9 @@ iscsi_hdr_recv(struct iscsi_conn *conn) switch(conn->in.opcode) { case ISCSI_OP_SCSI_CMD_RSP: BUG_ON((void*)ctask != ctask->sc->SCp.ptr); - if (!conn->in.datalen) + if (ctask->hdr.flags & ISCSI_FLAG_CMD_WRITE) + rc = iscsi_cmd_rsp(conn, ctask); + else if (!conn->in.datalen) rc = iscsi_cmd_rsp(conn, ctask); else /* @@ -663,7 +666,8 @@ iscsi_hdr_recv(struct iscsi_conn *conn) break; case ISCSI_OP_R2T: BUG_ON((void*)ctask != ctask->sc->SCp.ptr); - if (ctask->sc->sc_data_direction == DMA_TO_DEVICE) + if (ctask->hdr.flags & ISCSI_FLAG_CMD_WRITE && + ctask->sc->sc_data_direction == DMA_TO_DEVICE) rc = iscsi_r2t_rsp(conn, ctask); else rc = ISCSI_ERR_PROTO; @@ -902,20 +906,11 @@ partial_sg_digest_update(struct iscsi_conn *conn, struct scatterlist *sg, crypto_digest_update(conn->data_rx_tfm, &temp, 1); } -static void -iscsi_recv_digest_update(struct iscsi_conn *conn, char* buf, int len) -{ - struct scatterlist tmp; - - sg_init_one(&tmp, buf, len); - crypto_digest_update(conn->data_rx_tfm, &tmp, 1); -} - static int iscsi_scsi_data_in(struct iscsi_conn *conn) { struct iscsi_cmd_task *ctask = conn->in.ctask; struct scsi_cmnd *sc = ctask->sc; - struct scatterlist *sg; + struct scatterlist tmp, *sg; int i, offset, rc = 0; BUG_ON((void*)ctask != sc->SCp.ptr); @@ -929,8 +924,10 @@ static int iscsi_scsi_data_in(struct iscsi_conn *conn) sc->request_bufflen, ctask->data_offset); if (rc == -EAGAIN) return rc; - if (conn->datadgst_en) - iscsi_recv_digest_update(conn, sc->request_buffer, i); + if (conn->datadgst_en) { + sg_init_one(&tmp, sc->request_buffer, i); + crypto_digest_update(conn->data_rx_tfm, &tmp, 1); + } rc = 0; goto done; } @@ -1024,9 +1021,6 @@ iscsi_data_recv(struct iscsi_conn *conn) conn->in.hdr = &conn->hdr; conn->senselen = (conn->data[0] << 8) | conn->data[1]; rc = iscsi_cmd_rsp(conn, conn->in.ctask); - if (!rc && conn->datadgst_en) - iscsi_recv_digest_update(conn, conn->data, - conn->in.datalen); } break; case ISCSI_OP_TEXT_RSP: @@ -1051,11 +1045,6 @@ iscsi_data_recv(struct iscsi_conn *conn) rc = iscsi_recv_pdu(iscsi_handle(conn), conn->in.hdr, conn->data, conn->in.datalen); - if (!rc && conn->datadgst_en && - conn->in.opcode != ISCSI_OP_LOGIN_RSP) - iscsi_recv_digest_update(conn, conn->data, - conn->in.datalen); - if (mtask && conn->login_mtask != mtask) { spin_lock(&session->lock); __kfifo_put(session->mgmtpool.queue, (void*)&mtask, @@ -1064,8 +1053,6 @@ iscsi_data_recv(struct iscsi_conn *conn) } } break; - case ISCSI_OP_ASYNC_EVENT: - case ISCSI_OP_REJECT: default: BUG_ON(1); } @@ -1127,7 +1114,8 @@ iscsi_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, */ rc = iscsi_hdr_recv(conn); if (!rc && conn->in.datalen) { - if (conn->datadgst_en) { + if (conn->datadgst_en && + conn->in.opcode == ISCSI_OP_SCSI_DATA_IN) { BUG_ON(!conn->data_rx_tfm); crypto_digest_init(conn->data_rx_tfm); } @@ -1139,24 +1127,26 @@ iscsi_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, } if (conn->in_progress == IN_PROGRESS_DDIGEST_RECV) { - uint32_t recv_digest; debug_tcp("extra data_recv offset %d copy %d\n", conn->in.offset, conn->in.copy); - skb_copy_bits(conn->in.skb, conn->in.offset, - &recv_digest, 4); - conn->in.offset += 4; - conn->in.copy -= 4; - if (recv_digest != conn->in.datadgst) { - debug_tcp("iscsi_tcp: data digest error!" - "0x%x != 0x%x\n", recv_digest, - conn->in.datadgst); - iscsi_conn_failure(conn, ISCSI_ERR_DATA_DGST); - return 0; - } else { - debug_tcp("iscsi_tcp: data digest match!" - "0x%x == 0x%x\n", recv_digest, - conn->in.datadgst); - conn->in_progress = IN_PROGRESS_WAIT_HEADER; + if (conn->in.opcode == ISCSI_OP_SCSI_DATA_IN) { + uint32_t recv_digest; + skb_copy_bits(conn->in.skb, conn->in.offset, + &recv_digest, 4); + conn->in.offset += 4; + conn->in.copy -= 4; + if (recv_digest != conn->in.datadgst) { + debug_tcp("iscsi_tcp: data digest error!" + "0x%x != 0x%x\n", recv_digest, + conn->in.datadgst); + iscsi_conn_failure(conn, ISCSI_ERR_DATA_DGST); + return 0; + } else { + debug_tcp("iscsi_tcp: data digest match!" + "0x%x == 0x%x\n", recv_digest, + conn->in.datadgst); + conn->in_progress = IN_PROGRESS_WAIT_HEADER; + } } } @@ -1177,7 +1167,8 @@ iscsi_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, } conn->in.copy -= conn->in.padding; conn->in.offset += conn->in.padding; - if (conn->datadgst_en) { + if (conn->datadgst_en && + conn->in.opcode == ISCSI_OP_SCSI_DATA_IN) { if (conn->in.padding) { debug_tcp("padding -> %d\n", conn->in.padding); memset(pad, 0, conn->in.padding); @@ -1246,9 +1237,8 @@ iscsi_tcp_state_change(struct sock *sk) conn = (struct iscsi_conn*)sk->sk_user_data; session = conn->session; - if ((sk->sk_state == TCP_CLOSE_WAIT || - sk->sk_state == TCP_CLOSE) && - !atomic_read(&sk->sk_rmem_alloc)) { + if (sk->sk_state == TCP_CLOSE_WAIT || + sk->sk_state == TCP_CLOSE) { debug_tcp("iscsi_tcp_state_change: TCP_CLOSE|TCP_CLOSE_WAIT\n"); iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); } @@ -2398,15 +2388,6 @@ iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) return 0; } -static int -iscsi_change_queue_depth(struct scsi_device *sdev, int depth) -{ - if (depth > ISCSI_MAX_CMD_PER_LUN) - depth = ISCSI_MAX_CMD_PER_LUN; - scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); - return sdev->queue_depth; -} - static int iscsi_pool_init(struct iscsi_queue *q, int max, void ***items, int item_size) { @@ -2872,11 +2853,8 @@ iscsi_conn_stop(iscsi_connh_t connh, int flag) * in hdr_extract() and will be re-negotiated at * set_param() time. */ - if (flag == STOP_CONN_RECOVER) { + if (flag == STOP_CONN_RECOVER) conn->hdr_size = sizeof(struct iscsi_hdr); - conn->hdrdgst_en = 0; - conn->datadgst_en = 0; - } } up(&conn->xmitsema); } @@ -3269,14 +3247,13 @@ iscsi_r2tpool_free(struct iscsi_session *session) static struct scsi_host_template iscsi_sht = { .name = "iSCSI Initiator over TCP/IP, v." ISCSI_VERSION_STR, - .queuecommand = iscsi_queuecommand, - .change_queue_depth = iscsi_change_queue_depth, + .queuecommand = iscsi_queuecommand, .can_queue = ISCSI_XMIT_CMDS_MAX - 1, .sg_tablesize = ISCSI_SG_TABLESIZE, - .cmd_per_lun = ISCSI_DEF_CMD_PER_LUN, - .eh_abort_handler = iscsi_eh_abort, - .eh_host_reset_handler = iscsi_eh_host_reset, - .use_clustering = DISABLE_CLUSTERING, + .cmd_per_lun = ISCSI_CMD_PER_LUN, + .eh_abort_handler = iscsi_eh_abort, + .eh_host_reset_handler = iscsi_eh_host_reset, + .use_clustering = DISABLE_CLUSTERING, .proc_name = "iscsi_tcp", .this_id = -1, }; diff --git a/trunk/drivers/scsi/iscsi_tcp.h b/trunk/drivers/scsi/iscsi_tcp.h index 855f2dfd18af..d23ae68fae0d 100644 --- a/trunk/drivers/scsi/iscsi_tcp.h +++ b/trunk/drivers/scsi/iscsi_tcp.h @@ -71,8 +71,7 @@ #define ISCSI_MGMT_CMDS_MAX 32 /* must be power of 2 */ #define ISCSI_MGMT_ITT_OFFSET 0xa00 #define ISCSI_SG_TABLESIZE SG_ALL -#define ISCSI_DEF_CMD_PER_LUN 32 -#define ISCSI_MAX_CMD_PER_LUN 128 +#define ISCSI_CMD_PER_LUN 128 #define ISCSI_TCP_MAX_CMD_LEN 16 #define ITT_MASK (0xfff) diff --git a/trunk/drivers/scsi/libata-core.c b/trunk/drivers/scsi/libata-core.c index 9ea102587914..d0a0fdbd0fc4 100644 --- a/trunk/drivers/scsi/libata-core.c +++ b/trunk/drivers/scsi/libata-core.c @@ -605,7 +605,7 @@ void ata_rwcmd_protocol(struct ata_queued_cmd *qc) tf->command = ata_rw_cmds[index + lba48 + write]; } -static const char * const xfer_mode_str[] = { +static const char * xfer_mode_str[] = { "UDMA/16", "UDMA/25", "UDMA/33", @@ -1046,103 +1046,28 @@ static unsigned int ata_pio_modes(const struct ata_device *adev) return modes; } -struct ata_exec_internal_arg { - unsigned int err_mask; - struct ata_taskfile *tf; - struct completion *waiting; -}; - -int ata_qc_complete_internal(struct ata_queued_cmd *qc) +static int ata_qc_wait_err(struct ata_queued_cmd *qc, + struct completion *wait) { - struct ata_exec_internal_arg *arg = qc->private_data; - struct completion *waiting = arg->waiting; - - if (!(qc->err_mask & ~AC_ERR_DEV)) - qc->ap->ops->tf_read(qc->ap, arg->tf); - arg->err_mask = qc->err_mask; - arg->waiting = NULL; - complete(waiting); - - return 0; -} - -/** - * ata_exec_internal - execute libata internal command - * @ap: Port to which the command is sent - * @dev: Device to which the command is sent - * @tf: Taskfile registers for the command and the result - * @dma_dir: Data tranfer direction of the command - * @buf: Data buffer of the command - * @buflen: Length of data buffer - * - * Executes libata internal command with timeout. @tf contains - * command on entry and result on return. Timeout and error - * conditions are reported via return value. No recovery action - * is taken after a command times out. It's caller's duty to - * clean up after timeout. - * - * LOCKING: - * None. Should be called with kernel context, might sleep. - */ - -static unsigned -ata_exec_internal(struct ata_port *ap, struct ata_device *dev, - struct ata_taskfile *tf, - int dma_dir, void *buf, unsigned int buflen) -{ - u8 command = tf->command; - struct ata_queued_cmd *qc; - DECLARE_COMPLETION(wait); - unsigned long flags; - struct ata_exec_internal_arg arg; - - spin_lock_irqsave(&ap->host_set->lock, flags); + int rc = 0; - qc = ata_qc_new_init(ap, dev); - BUG_ON(qc == NULL); - - qc->tf = *tf; - qc->dma_dir = dma_dir; - if (dma_dir != DMA_NONE) { - ata_sg_init_one(qc, buf, buflen); - qc->nsect = buflen / ATA_SECT_SIZE; - } - - arg.waiting = &wait; - arg.tf = tf; - qc->private_data = &arg; - qc->complete_fn = ata_qc_complete_internal; - - if (ata_qc_issue(qc)) - goto issue_fail; - - spin_unlock_irqrestore(&ap->host_set->lock, flags); + if (wait_for_completion_timeout(wait, 30 * HZ) < 1) { + /* timeout handling */ + unsigned int err_mask = ac_err_mask(ata_chk_status(qc->ap)); - if (!wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL)) { - spin_lock_irqsave(&ap->host_set->lock, flags); - - /* We're racing with irq here. If we lose, the - * following test prevents us from completing the qc - * again. If completion irq occurs after here but - * before the caller cleans up, it will result in a - * spurious interrupt. We can live with that. - */ - if (arg.waiting) { - qc->err_mask = AC_ERR_OTHER; - ata_qc_complete(qc); - printk(KERN_WARNING "ata%u: qc timeout (cmd 0x%x)\n", - ap->id, command); + if (!err_mask) { + printk(KERN_WARNING "ata%u: slow completion (cmd %x)\n", + qc->ap->id, qc->tf.command); + } else { + printk(KERN_WARNING "ata%u: qc timeout (cmd %x)\n", + qc->ap->id, qc->tf.command); + rc = -EIO; } - spin_unlock_irqrestore(&ap->host_set->lock, flags); + ata_qc_complete(qc, err_mask); } - return arg.err_mask; - - issue_fail: - ata_qc_free(qc); - spin_unlock_irqrestore(&ap->host_set->lock, flags); - return AC_ERR_OTHER; + return rc; } /** @@ -1174,8 +1099,9 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device) u16 tmp; unsigned long xfer_modes; unsigned int using_edd; - struct ata_taskfile tf; - unsigned int err_mask; + DECLARE_COMPLETION(wait); + struct ata_queued_cmd *qc; + unsigned long flags; int rc; if (!ata_dev_present(dev)) { @@ -1196,26 +1122,40 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device) ata_dev_select(ap, device, 1, 1); /* select device 0/1 */ -retry: - ata_tf_init(ap, &tf, device); + qc = ata_qc_new_init(ap, dev); + BUG_ON(qc == NULL); + ata_sg_init_one(qc, dev->id, sizeof(dev->id)); + qc->dma_dir = DMA_FROM_DEVICE; + qc->tf.protocol = ATA_PROT_PIO; + qc->nsect = 1; + +retry: if (dev->class == ATA_DEV_ATA) { - tf.command = ATA_CMD_ID_ATA; + qc->tf.command = ATA_CMD_ID_ATA; DPRINTK("do ATA identify\n"); } else { - tf.command = ATA_CMD_ID_ATAPI; + qc->tf.command = ATA_CMD_ID_ATAPI; DPRINTK("do ATAPI identify\n"); } - tf.protocol = ATA_PROT_PIO; + qc->waiting = &wait; + qc->complete_fn = ata_qc_complete_noop; - err_mask = ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE, - dev->id, sizeof(dev->id)); + spin_lock_irqsave(&ap->host_set->lock, flags); + rc = ata_qc_issue(qc); + spin_unlock_irqrestore(&ap->host_set->lock, flags); - if (err_mask) { - if (err_mask & ~AC_ERR_DEV) - goto err_out; + if (rc) + goto err_out; + else + ata_qc_wait_err(qc, &wait); + spin_lock_irqsave(&ap->host_set->lock, flags); + ap->ops->tf_read(ap, &qc->tf); + spin_unlock_irqrestore(&ap->host_set->lock, flags); + + if (qc->tf.command & ATA_ERR) { /* * arg! EDD works for all test cases, but seems to return * the ATA signature for some ATAPI devices. Until the @@ -1228,9 +1168,13 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device) * to have this problem. */ if ((using_edd) && (dev->class == ATA_DEV_ATA)) { - u8 err = tf.feature; + u8 err = qc->tf.feature; if (err & ATA_ABORTED) { dev->class = ATA_DEV_ATAPI; + qc->cursg = 0; + qc->cursg_ofs = 0; + qc->cursect = 0; + qc->nsect = 1; goto retry; } } @@ -1500,23 +1444,11 @@ void __sata_phy_reset(struct ata_port *ap) } while (time_before(jiffies, timeout)); /* TODO: phy layer with polling, timeouts, etc. */ - sstatus = scr_read(ap, SCR_STATUS); - if (sata_dev_present(ap)) { - const char *speed; - u32 tmp; - - tmp = (sstatus >> 4) & 0xf; - if (tmp & (1 << 0)) - speed = "1.5"; - else if (tmp & (1 << 1)) - speed = "3.0"; - else - speed = ""; - printk(KERN_INFO "ata%u: SATA link up %s Gbps (SStatus %X)\n", - ap->id, speed, sstatus); + if (sata_dev_present(ap)) ata_port_probe(ap); - } else { - printk(KERN_INFO "ata%u: SATA link down (SStatus %X)\n", + else { + sstatus = scr_read(ap, SCR_STATUS); + printk(KERN_INFO "ata%u: no device found (phy stat %08x)\n", ap->id, sstatus); ata_port_disable(ap); } @@ -2139,7 +2071,7 @@ static void ata_pr_blacklisted(const struct ata_port *ap, ap->id, dev->devno); } -static const char * const ata_dma_blacklist [] = { +static const char * ata_dma_blacklist [] = { "WDC AC11000H", "WDC AC22100H", "WDC AC32500H", @@ -2334,23 +2266,34 @@ static int ata_choose_xfer_mode(const struct ata_port *ap, static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev) { - struct ata_taskfile tf; + DECLARE_COMPLETION(wait); + struct ata_queued_cmd *qc; + int rc; + unsigned long flags; /* set up set-features taskfile */ DPRINTK("set features - xfer mode\n"); - ata_tf_init(ap, &tf, dev->devno); - tf.command = ATA_CMD_SET_FEATURES; - tf.feature = SETFEATURES_XFER; - tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; - tf.protocol = ATA_PROT_NODATA; - tf.nsect = dev->xfer_mode; + qc = ata_qc_new_init(ap, dev); + BUG_ON(qc == NULL); - if (ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0)) { - printk(KERN_ERR "ata%u: failed to set xfermode, disabled\n", - ap->id); + qc->tf.command = ATA_CMD_SET_FEATURES; + qc->tf.feature = SETFEATURES_XFER; + qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; + qc->tf.protocol = ATA_PROT_NODATA; + qc->tf.nsect = dev->xfer_mode; + + qc->waiting = &wait; + qc->complete_fn = ata_qc_complete_noop; + + spin_lock_irqsave(&ap->host_set->lock, flags); + rc = ata_qc_issue(qc); + spin_unlock_irqrestore(&ap->host_set->lock, flags); + + if (rc) ata_port_disable(ap); - } + else + ata_qc_wait_err(qc, &wait); DPRINTK("EXIT\n"); } @@ -2365,25 +2308,41 @@ static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev) static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev) { - struct ata_taskfile tf; + DECLARE_COMPLETION(wait); + struct ata_queued_cmd *qc; + unsigned long flags; + int rc; + + qc = ata_qc_new_init(ap, dev); + BUG_ON(qc == NULL); - ata_tf_init(ap, &tf, dev->devno); + ata_sg_init_one(qc, dev->id, sizeof(dev->id)); + qc->dma_dir = DMA_FROM_DEVICE; if (dev->class == ATA_DEV_ATA) { - tf.command = ATA_CMD_ID_ATA; + qc->tf.command = ATA_CMD_ID_ATA; DPRINTK("do ATA identify\n"); } else { - tf.command = ATA_CMD_ID_ATAPI; + qc->tf.command = ATA_CMD_ID_ATAPI; DPRINTK("do ATAPI identify\n"); } - tf.flags |= ATA_TFLAG_DEVICE; - tf.protocol = ATA_PROT_PIO; + qc->tf.flags |= ATA_TFLAG_DEVICE; + qc->tf.protocol = ATA_PROT_PIO; + qc->nsect = 1; + + qc->waiting = &wait; + qc->complete_fn = ata_qc_complete_noop; + + spin_lock_irqsave(&ap->host_set->lock, flags); + rc = ata_qc_issue(qc); + spin_unlock_irqrestore(&ap->host_set->lock, flags); - if (ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE, - dev->id, sizeof(dev->id))) + if (rc) goto err_out; + ata_qc_wait_err(qc, &wait); + swap_buf_le16(dev->id, ATA_ID_WORDS); ata_dump_id(dev); @@ -2392,7 +2351,6 @@ static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev) return; err_out: - printk(KERN_ERR "ata%u: failed to reread ID, disabled\n", ap->id); ata_port_disable(ap); } @@ -2406,7 +2364,10 @@ static void ata_dev_reread_id(struct ata_port *ap, struct ata_device *dev) static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev) { - struct ata_taskfile tf; + DECLARE_COMPLETION(wait); + struct ata_queued_cmd *qc; + int rc; + unsigned long flags; u16 sectors = dev->id[6]; u16 heads = dev->id[3]; @@ -2417,18 +2378,26 @@ static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev) /* set up init dev params taskfile */ DPRINTK("init dev params \n"); - ata_tf_init(ap, &tf, dev->devno); - tf.command = ATA_CMD_INIT_DEV_PARAMS; - tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; - tf.protocol = ATA_PROT_NODATA; - tf.nsect = sectors; - tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */ + qc = ata_qc_new_init(ap, dev); + BUG_ON(qc == NULL); - if (ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0)) { - printk(KERN_ERR "ata%u: failed to init parameters, disabled\n", - ap->id); + qc->tf.command = ATA_CMD_INIT_DEV_PARAMS; + qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE; + qc->tf.protocol = ATA_PROT_NODATA; + qc->tf.nsect = sectors; + qc->tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */ + + qc->waiting = &wait; + qc->complete_fn = ata_qc_complete_noop; + + spin_lock_irqsave(&ap->host_set->lock, flags); + rc = ata_qc_issue(qc); + spin_unlock_irqrestore(&ap->host_set->lock, flags); + + if (rc) ata_port_disable(ap); - } + else + ata_qc_wait_err(qc, &wait); DPRINTK("EXIT\n"); } @@ -2796,7 +2765,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc) * None. (grabs host lock) */ -void ata_poll_qc_complete(struct ata_queued_cmd *qc) +void ata_poll_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask) { struct ata_port *ap = qc->ap; unsigned long flags; @@ -2804,7 +2773,7 @@ void ata_poll_qc_complete(struct ata_queued_cmd *qc) spin_lock_irqsave(&ap->host_set->lock, flags); ap->flags &= ~ATA_FLAG_NOINTR; ata_irq_on(ap); - ata_qc_complete(qc); + ata_qc_complete(qc, err_mask); spin_unlock_irqrestore(&ap->host_set->lock, flags); } @@ -2821,14 +2790,10 @@ void ata_poll_qc_complete(struct ata_queued_cmd *qc) static unsigned long ata_pio_poll(struct ata_port *ap) { - struct ata_queued_cmd *qc; u8 status; unsigned int poll_state = HSM_ST_UNKNOWN; unsigned int reg_state = HSM_ST_UNKNOWN; - qc = ata_qc_from_tag(ap, ap->active_tag); - assert(qc != NULL); - switch (ap->hsm_task_state) { case HSM_ST: case HSM_ST_POLL: @@ -2848,7 +2813,6 @@ static unsigned long ata_pio_poll(struct ata_port *ap) status = ata_chk_status(ap); if (status & ATA_BUSY) { if (time_after(jiffies, ap->pio_task_timeout)) { - qc->err_mask |= AC_ERR_ATA_BUS; ap->hsm_task_state = HSM_ST_TMOUT; return 0; } @@ -2883,31 +2847,29 @@ static int ata_pio_complete (struct ata_port *ap) * msecs, then chk-status again. If still busy, fall back to * HSM_ST_POLL state. */ - drv_stat = ata_busy_wait(ap, ATA_BUSY, 10); - if (drv_stat & ATA_BUSY) { + drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10); + if (drv_stat & (ATA_BUSY | ATA_DRQ)) { msleep(2); - drv_stat = ata_busy_wait(ap, ATA_BUSY, 10); - if (drv_stat & ATA_BUSY) { + drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10); + if (drv_stat & (ATA_BUSY | ATA_DRQ)) { ap->hsm_task_state = HSM_ST_LAST_POLL; ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO; return 0; } } - qc = ata_qc_from_tag(ap, ap->active_tag); - assert(qc != NULL); - drv_stat = ata_wait_idle(ap); if (!ata_ok(drv_stat)) { - qc->err_mask |= __ac_err_mask(drv_stat); ap->hsm_task_state = HSM_ST_ERR; return 0; } + qc = ata_qc_from_tag(ap, ap->active_tag); + assert(qc != NULL); + ap->hsm_task_state = HSM_ST_IDLE; - assert(qc->err_mask == 0); - ata_poll_qc_complete(qc); + ata_poll_qc_complete(qc, 0); /* another command may start at this point */ @@ -3215,7 +3177,6 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc) err_out: printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n", ap->id, dev->devno); - qc->err_mask |= AC_ERR_ATA_BUS; ap->hsm_task_state = HSM_ST_ERR; } @@ -3254,16 +3215,8 @@ static void ata_pio_block(struct ata_port *ap) qc = ata_qc_from_tag(ap, ap->active_tag); assert(qc != NULL); - /* check error */ - if (status & (ATA_ERR | ATA_DF)) { - qc->err_mask |= AC_ERR_DEV; - ap->hsm_task_state = HSM_ST_ERR; - return; - } - - /* transfer data if any */ if (is_atapi_taskfile(&qc->tf)) { - /* DRQ=0 means no more data to transfer */ + /* no more data to transfer or unsupported ATAPI command */ if ((status & ATA_DRQ) == 0) { ap->hsm_task_state = HSM_ST_LAST; return; @@ -3273,7 +3226,6 @@ static void ata_pio_block(struct ata_port *ap) } else { /* handle BSY=0, DRQ=0 as error */ if ((status & ATA_DRQ) == 0) { - qc->err_mask |= AC_ERR_ATA_BUS; ap->hsm_task_state = HSM_ST_ERR; return; } @@ -3291,14 +3243,9 @@ static void ata_pio_error(struct ata_port *ap) qc = ata_qc_from_tag(ap, ap->active_tag); assert(qc != NULL); - /* make sure qc->err_mask is available to - * know what's wrong and recover - */ - assert(qc->err_mask); - ap->hsm_task_state = HSM_ST_IDLE; - ata_poll_qc_complete(qc); + ata_poll_qc_complete(qc, AC_ERR_ATA_BUS); } static void ata_pio_task(void *_data) @@ -3400,8 +3347,7 @@ static void ata_qc_timeout(struct ata_queued_cmd *qc) ap->id, qc->tf.command, drv_stat, host_stat); /* complete taskfile transaction */ - qc->err_mask |= ac_err_mask(drv_stat); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(drv_stat)); break; } @@ -3500,10 +3446,15 @@ struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap, return qc; } +int ata_qc_complete_noop(struct ata_queued_cmd *qc, unsigned int err_mask) +{ + return 0; +} + static void __ata_qc_complete(struct ata_queued_cmd *qc) { struct ata_port *ap = qc->ap; - unsigned int tag; + unsigned int tag, do_clear = 0; qc->flags = 0; tag = qc->tag; @@ -3511,8 +3462,17 @@ static void __ata_qc_complete(struct ata_queued_cmd *qc) if (tag == ap->active_tag) ap->active_tag = ATA_TAG_POISON; qc->tag = ATA_TAG_POISON; - clear_bit(tag, &ap->qactive); + do_clear = 1; } + + if (qc->waiting) { + struct completion *waiting = qc->waiting; + qc->waiting = NULL; + complete(waiting); + } + + if (likely(do_clear)) + clear_bit(tag, &ap->qactive); } /** @@ -3528,6 +3488,7 @@ static void __ata_qc_complete(struct ata_queued_cmd *qc) void ata_qc_free(struct ata_queued_cmd *qc) { assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */ + assert(qc->waiting == NULL); /* nothing should be waiting */ __ata_qc_complete(qc); } @@ -3544,7 +3505,7 @@ void ata_qc_free(struct ata_queued_cmd *qc) * spin_lock_irqsave(host_set lock) */ -void ata_qc_complete(struct ata_queued_cmd *qc) +void ata_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask) { int rc; @@ -3561,7 +3522,7 @@ void ata_qc_complete(struct ata_queued_cmd *qc) qc->flags &= ~ATA_QCFLAG_ACTIVE; /* call completion callback */ - rc = qc->complete_fn(qc); + rc = qc->complete_fn(qc, err_mask); /* if callback indicates not to complete command (non-zero), * return immediately @@ -3999,8 +3960,7 @@ inline unsigned int ata_host_intr (struct ata_port *ap, ap->ops->irq_clear(ap); /* complete taskfile transaction */ - qc->err_mask |= ac_err_mask(status); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(status)); break; default: @@ -4094,17 +4054,13 @@ static void atapi_packet_task(void *_data) /* sleep-wait for BSY to clear */ DPRINTK("busy wait\n"); - if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB)) { - qc->err_mask |= AC_ERR_ATA_BUS; - goto err_out; - } + if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB)) + goto err_out_status; /* make sure DRQ is set */ status = ata_chk_status(ap); - if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) { - qc->err_mask |= AC_ERR_ATA_BUS; + if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) goto err_out; - } /* send SCSI cdb */ DPRINTK("send cdb\n"); @@ -4136,8 +4092,10 @@ static void atapi_packet_task(void *_data) return; +err_out_status: + status = ata_chk_status(ap); err_out: - ata_poll_qc_complete(qc); + ata_poll_qc_complete(qc, __ac_err_mask(status)); } diff --git a/trunk/drivers/scsi/libata-scsi.c b/trunk/drivers/scsi/libata-scsi.c index e0439be4b573..2282c04fee46 100644 --- a/trunk/drivers/scsi/libata-scsi.c +++ b/trunk/drivers/scsi/libata-scsi.c @@ -418,7 +418,7 @@ void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc, int i; /* Based on the 3ware driver translation table */ - static const unsigned char sense_table[][4] = { + static unsigned char sense_table[][4] = { /* BBD|ECC|ID|MAR */ {0xd1, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command /* BBD|ECC|ID */ @@ -449,7 +449,7 @@ void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc, {0x80, MEDIUM_ERROR, 0x11, 0x04}, // Block marked bad Medium error, unrecovered read error {0xFF, 0xFF, 0xFF, 0xFF}, // END mark }; - static const unsigned char stat_table[][4] = { + static unsigned char stat_table[][4] = { /* Must be first because BUSY means no other bits valid */ {0x80, ABORTED_COMMAND, 0x47, 0x00}, // Busy, fake parity for now {0x20, HARDWARE_ERROR, 0x00, 0x00}, // Device fault @@ -1203,11 +1203,12 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm return 1; } -static int ata_scsi_qc_complete(struct ata_queued_cmd *qc) +static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, + unsigned int err_mask) { struct scsi_cmnd *cmd = qc->scsicmd; u8 *cdb = cmd->cmnd; - int need_sense = (qc->err_mask != 0); + int need_sense = (err_mask != 0); /* For ATA pass thru (SAT) commands, generate a sense block if * user mandated it or if there's an error. Note that if we @@ -1531,7 +1532,7 @@ unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf, return 0; } -static const char * const inq_83_str = "Linux ATA-SCSI simulator"; +static const char *inq_83_str = "Linux ATA-SCSI simulator"; /** * ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity @@ -1954,9 +1955,9 @@ void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 done(cmd); } -static int atapi_sense_complete(struct ata_queued_cmd *qc) +static int atapi_sense_complete(struct ata_queued_cmd *qc,unsigned int err_mask) { - if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) + if (err_mask && ((err_mask & AC_ERR_DEV) == 0)) /* FIXME: not quite right; we don't want the * translation of taskfile registers into * a sense descriptors, since that's only @@ -2014,18 +2015,15 @@ static void atapi_request_sense(struct ata_queued_cmd *qc) qc->complete_fn = atapi_sense_complete; - if (ata_qc_issue(qc)) { - qc->err_mask |= AC_ERR_OTHER; - ata_qc_complete(qc); - } + if (ata_qc_issue(qc)) + ata_qc_complete(qc, AC_ERR_OTHER); DPRINTK("EXIT\n"); } -static int atapi_qc_complete(struct ata_queued_cmd *qc) +static int atapi_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask) { struct scsi_cmnd *cmd = qc->scsicmd; - unsigned int err_mask = qc->err_mask; VPRINTK("ENTER, err_mask 0x%X\n", err_mask); diff --git a/trunk/drivers/scsi/libata.h b/trunk/drivers/scsi/libata.h index 251e53bdc6e0..8ebaa694d18e 100644 --- a/trunk/drivers/scsi/libata.h +++ b/trunk/drivers/scsi/libata.h @@ -39,6 +39,7 @@ struct ata_scsi_args { /* libata-core.c */ extern int atapi_enabled; +extern int ata_qc_complete_noop(struct ata_queued_cmd *qc, unsigned int err_mask); extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap, struct ata_device *dev); extern void ata_rwcmd_protocol(struct ata_queued_cmd *qc); diff --git a/trunk/drivers/scsi/lpfc/lpfc.h b/trunk/drivers/scsi/lpfc/lpfc.h index 38ffa8d6e629..3062b39fbdb9 100644 --- a/trunk/drivers/scsi/lpfc/lpfc.h +++ b/trunk/drivers/scsi/lpfc/lpfc.h @@ -29,10 +29,9 @@ struct lpfc_sli2_slim; #define LPFC_LC_HBA_Q_DEPTH 1024 /* max cmds per low cost hba */ #define LPFC_LP101_HBA_Q_DEPTH 128 /* max cmds per low cost hba */ -#define LPFC_CMD_PER_LUN 3 /* max outstanding cmds per lun */ +#define LPFC_CMD_PER_LUN 30 /* max outstanding cmds per lun */ #define LPFC_SG_SEG_CNT 64 /* sg element count per scsi cmnd */ #define LPFC_IOCB_LIST_CNT 2250 /* list of IOCBs for fast-path usage. */ -#define LPFC_Q_RAMP_UP_INTERVAL 120 /* lun q_depth ramp up interval */ /* Define macros for 64 bit support */ #define putPaddrLow(addr) ((uint32_t) (0xffffffff & (u64)(addr))) @@ -46,11 +45,6 @@ struct lpfc_sli2_slim; #define MAX_HBAEVT 32 -enum lpfc_polling_flags { - ENABLE_FCP_RING_POLLING = 0x1, - DISABLE_FCP_RING_INT = 0x2 -}; - /* Provide DMA memory definitions the driver uses per port instance. */ struct lpfc_dmabuf { struct list_head list; @@ -173,7 +167,6 @@ struct lpfc_hba { dma_addr_t slim2p_mapping; uint16_t pci_cfg_value; - struct semaphore hba_can_block; uint32_t hba_state; #define LPFC_INIT_START 1 /* Initial state after board reset */ @@ -293,8 +286,6 @@ struct lpfc_hba { uint32_t cfg_fcp_bind_method; uint32_t cfg_discovery_threads; uint32_t cfg_max_luns; - uint32_t cfg_poll; - uint32_t cfg_poll_tmo; uint32_t cfg_sg_seg_cnt; uint32_t cfg_sg_dma_buf_size; @@ -346,9 +337,7 @@ struct lpfc_hba { #define VPD_PORT 0x8 /* valid vpd port data */ #define VPD_MASK 0xf /* mask for any vpd data */ - struct timer_list fcp_poll_timer; struct timer_list els_tmofunc; - /* * stat counters */ @@ -359,7 +348,6 @@ struct lpfc_hba { struct lpfc_sysfs_mbox sysfs_mbox; /* fastpath list. */ - spinlock_t scsi_buf_list_lock; struct list_head lpfc_scsi_buf_list; uint32_t total_scsi_bufs; struct list_head lpfc_iocb_list; diff --git a/trunk/drivers/scsi/lpfc/lpfc_attr.c b/trunk/drivers/scsi/lpfc/lpfc_attr.c index 5625a8c2a8fd..89e8222bc7cc 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_attr.c +++ b/trunk/drivers/scsi/lpfc/lpfc_attr.c @@ -278,71 +278,6 @@ lpfc_board_online_store(struct class_device *cdev, const char *buf, return -EIO; } -static ssize_t -lpfc_poll_show(struct class_device *cdev, char *buf) -{ - struct Scsi_Host *host = class_to_shost(cdev); - struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0]; - - return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll); -} - -static ssize_t -lpfc_poll_store(struct class_device *cdev, const char *buf, - size_t count) -{ - struct Scsi_Host *host = class_to_shost(cdev); - struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata[0]; - uint32_t creg_val; - uint32_t old_val; - int val=0; - - if (!isdigit(buf[0])) - return -EINVAL; - - if (sscanf(buf, "%i", &val) != 1) - return -EINVAL; - - if ((val & 0x3) != val) - return -EINVAL; - - spin_lock_irq(phba->host->host_lock); - - old_val = phba->cfg_poll; - - if (val & ENABLE_FCP_RING_POLLING) { - if ((val & DISABLE_FCP_RING_INT) && - !(old_val & DISABLE_FCP_RING_INT)) { - creg_val = readl(phba->HCregaddr); - creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING); - writel(creg_val, phba->HCregaddr); - readl(phba->HCregaddr); /* flush */ - - lpfc_poll_start_timer(phba); - } - } else if (val != 0x0) { - spin_unlock_irq(phba->host->host_lock); - return -EINVAL; - } - - if (!(val & DISABLE_FCP_RING_INT) && - (old_val & DISABLE_FCP_RING_INT)) - { - spin_unlock_irq(phba->host->host_lock); - del_timer(&phba->fcp_poll_timer); - spin_lock_irq(phba->host->host_lock); - creg_val = readl(phba->HCregaddr); - creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING); - writel(creg_val, phba->HCregaddr); - readl(phba->HCregaddr); /* flush */ - } - - phba->cfg_poll = val; - - spin_unlock_irq(phba->host->host_lock); - - return strlen(buf); -} #define lpfc_param_show(attr) \ static ssize_t \ @@ -481,15 +416,6 @@ static CLASS_DEVICE_ATTR(management_version, S_IRUGO, management_version_show, static CLASS_DEVICE_ATTR(board_online, S_IRUGO | S_IWUSR, lpfc_board_online_show, lpfc_board_online_store); -static int lpfc_poll = 0; -module_param(lpfc_poll, int, 0); -MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:" - " 0 - none," - " 1 - poll with interrupts enabled" - " 3 - poll and disable FCP ring interrupts"); - -static CLASS_DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR, - lpfc_poll_show, lpfc_poll_store); /* # lpfc_log_verbose: Only turn this flag on if you are willing to risk being @@ -597,10 +523,10 @@ LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support"); # is 0. Default value of cr_count is 1. The cr_count feature is disabled if # cr_delay is set to 0. */ -LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an" +LPFC_ATTR(cr_delay, 0, 0, 63, "A count of milliseconds after which an" "interrupt response is generated"); -LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an" +LPFC_ATTR(cr_count, 1, 1, 255, "A count of I/O completions after which an" "interrupt response is generated"); /* @@ -627,13 +553,6 @@ LPFC_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands" LPFC_ATTR_R(max_luns, 256, 1, 32768, "Maximum number of LUNs per target driver will support"); -/* -# lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring. -# Value range is [1,255], default value is 10. -*/ -LPFC_ATTR_RW(poll_tmo, 10, 1, 255, - "Milliseconds driver will wait between polling FCP ring"); - struct class_device_attribute *lpfc_host_attrs[] = { &class_device_attr_info, &class_device_attr_serialnum, @@ -656,15 +575,11 @@ struct class_device_attribute *lpfc_host_attrs[] = { &class_device_attr_lpfc_topology, &class_device_attr_lpfc_scan_down, &class_device_attr_lpfc_link_speed, - &class_device_attr_lpfc_cr_delay, - &class_device_attr_lpfc_cr_count, &class_device_attr_lpfc_fdmi_on, &class_device_attr_lpfc_max_luns, &class_device_attr_nport_evt_cnt, &class_device_attr_management_version, &class_device_attr_board_online, - &class_device_attr_lpfc_poll, - &class_device_attr_lpfc_poll_tmo, NULL, }; @@ -1377,9 +1292,6 @@ lpfc_get_cfgparam(struct lpfc_hba *phba) lpfc_fdmi_on_init(phba, lpfc_fdmi_on); lpfc_discovery_threads_init(phba, lpfc_discovery_threads); lpfc_max_luns_init(phba, lpfc_max_luns); - lpfc_poll_tmo_init(phba, lpfc_poll_tmo); - - phba->cfg_poll = lpfc_poll; /* * The total number of segments is the configuration value plus 2 diff --git a/trunk/drivers/scsi/lpfc/lpfc_crtn.h b/trunk/drivers/scsi/lpfc/lpfc_crtn.h index f1e708946e66..d527d05a607f 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_crtn.h +++ b/trunk/drivers/scsi/lpfc/lpfc_crtn.h @@ -143,9 +143,6 @@ LPFC_MBOXQ_t *lpfc_mbox_get(struct lpfc_hba *); int lpfc_mem_alloc(struct lpfc_hba *); void lpfc_mem_free(struct lpfc_hba *); -void lpfc_poll_timeout(unsigned long ptr); -void lpfc_poll_start_timer(struct lpfc_hba * phba); -void lpfc_sli_poll_fcp_ring(struct lpfc_hba * hba); struct lpfc_iocbq * lpfc_sli_get_iocbq(struct lpfc_hba *); void lpfc_sli_release_iocbq(struct lpfc_hba * phba, struct lpfc_iocbq * iocb); uint16_t lpfc_sli_next_iotag(struct lpfc_hba * phba, struct lpfc_iocbq * iocb); diff --git a/trunk/drivers/scsi/lpfc/lpfc_disc.h b/trunk/drivers/scsi/lpfc/lpfc_disc.h index ed6c81660e03..084e7628ce17 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_disc.h +++ b/trunk/drivers/scsi/lpfc/lpfc_disc.h @@ -73,8 +73,6 @@ struct lpfc_nodelist { struct lpfc_hba *nlp_phba; struct lpfc_work_evt nodev_timeout_evt; struct lpfc_work_evt els_retry_evt; - unsigned long last_ramp_up_time; /* jiffy of last ramp up */ - unsigned long last_q_full_time; /* jiffy of last queue full */ }; /* Defines for nlp_flag (uint32) */ diff --git a/trunk/drivers/scsi/lpfc/lpfc_els.c b/trunk/drivers/scsi/lpfc/lpfc_els.c index 20f1a0713db2..bcc29ec126dc 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_els.c +++ b/trunk/drivers/scsi/lpfc/lpfc_els.c @@ -720,7 +720,6 @@ lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || - (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); } @@ -870,7 +869,6 @@ lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || - (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { goto out; } @@ -1056,7 +1054,6 @@ lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || - (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); } @@ -1208,7 +1205,6 @@ lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || - (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { goto out; } diff --git a/trunk/drivers/scsi/lpfc/lpfc_hbadisc.c b/trunk/drivers/scsi/lpfc/lpfc_hbadisc.c index a1f751e79405..259eeb161b82 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_hbadisc.c +++ b/trunk/drivers/scsi/lpfc/lpfc_hbadisc.c @@ -1017,7 +1017,12 @@ lpfc_register_remote_port(struct lpfc_hba * phba, rport_ids.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn); rport_ids.port_id = ndlp->nlp_DID; rport_ids.roles = FC_RPORT_ROLE_UNKNOWN; + if (ndlp->nlp_type & NLP_FCP_TARGET) + rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET; + if (ndlp->nlp_type & NLP_FCP_INITIATOR) + rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR; + scsi_block_requests(phba->host); ndlp->rport = rport = fc_remote_port_add(phba->host, 0, &rport_ids); if (!rport) { dev_printk(KERN_WARNING, &phba->pcidev->dev, @@ -1034,16 +1039,7 @@ lpfc_register_remote_port(struct lpfc_hba * phba, } rdata = rport->dd_data; rdata->pnode = ndlp; - - if (ndlp->nlp_type & NLP_FCP_TARGET) - rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET; - if (ndlp->nlp_type & NLP_FCP_INITIATOR) - rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR; - - - if (rport_ids.roles != FC_RPORT_ROLE_UNKNOWN) - fc_remote_port_rolechg(rport, rport_ids.roles); - + scsi_unblock_requests(phba->host); return; } @@ -1057,7 +1053,9 @@ lpfc_unregister_remote_port(struct lpfc_hba * phba, ndlp->rport = NULL; rdata->pnode = NULL; + scsi_block_requests(phba->host); fc_remote_port_delete(rport); + scsi_unblock_requests(phba->host); return; } diff --git a/trunk/drivers/scsi/lpfc/lpfc_hw.h b/trunk/drivers/scsi/lpfc/lpfc_hw.h index 1ea565e0561f..86c41981188b 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_hw.h +++ b/trunk/drivers/scsi/lpfc/lpfc_hw.h @@ -266,11 +266,9 @@ struct lpfc_name { struct { #ifdef __BIG_ENDIAN_BITFIELD uint8_t nameType:4; /* FC Word 0, bit 28:31 */ - uint8_t IEEEextMsn:4; /* FC Word 0, bit 24:27, bit - 8:11 of IEEE ext */ + uint8_t IEEEextMsn:4; /* FC Word 0, bit 24:27, bit 8:11 of IEEE ext */ #else /* __LITTLE_ENDIAN_BITFIELD */ - uint8_t IEEEextMsn:4; /* FC Word 0, bit 24:27, bit - 8:11 of IEEE ext */ + uint8_t IEEEextMsn:4; /* FC Word 0, bit 24:27, bit 8:11 of IEEE ext */ uint8_t nameType:4; /* FC Word 0, bit 28:31 */ #endif @@ -280,8 +278,7 @@ struct lpfc_name { #define NAME_IP_TYPE 0x4 /* IP address */ #define NAME_CCITT_TYPE 0xC #define NAME_CCITT_GR_TYPE 0xE - uint8_t IEEEextLsb; /* FC Word 0, bit 16:23, IEEE - extended Lsb */ + uint8_t IEEEextLsb; /* FC Word 0, bit 16:23, IEEE extended Lsb */ uint8_t IEEE[6]; /* FC IEEE address */ } s; uint8_t wwn[8]; @@ -1027,38 +1024,23 @@ typedef struct { /* Start FireFly Register definitions */ #define PCI_VENDOR_ID_EMULEX 0x10df #define PCI_DEVICE_ID_FIREFLY 0x1ae5 +#define PCI_DEVICE_ID_SUPERFLY 0xf700 +#define PCI_DEVICE_ID_DRAGONFLY 0xf800 #define PCI_DEVICE_ID_RFLY 0xf095 #define PCI_DEVICE_ID_PFLY 0xf098 -#define PCI_DEVICE_ID_LP101 0xf0a1 #define PCI_DEVICE_ID_TFLY 0xf0a5 -#define PCI_DEVICE_ID_BSMB 0xf0d1 -#define PCI_DEVICE_ID_BMID 0xf0d5 -#define PCI_DEVICE_ID_ZSMB 0xf0e1 -#define PCI_DEVICE_ID_ZMID 0xf0e5 -#define PCI_DEVICE_ID_NEPTUNE 0xf0f5 -#define PCI_DEVICE_ID_NEPTUNE_SCSP 0xf0f6 -#define PCI_DEVICE_ID_NEPTUNE_DCSP 0xf0f7 -#define PCI_DEVICE_ID_SUPERFLY 0xf700 -#define PCI_DEVICE_ID_DRAGONFLY 0xf800 #define PCI_DEVICE_ID_CENTAUR 0xf900 #define PCI_DEVICE_ID_PEGASUS 0xf980 #define PCI_DEVICE_ID_THOR 0xfa00 #define PCI_DEVICE_ID_VIPER 0xfb00 -#define PCI_DEVICE_ID_LP10000S 0xfc00 -#define PCI_DEVICE_ID_LP11000S 0xfc10 -#define PCI_DEVICE_ID_LPE11000S 0xfc20 #define PCI_DEVICE_ID_HELIOS 0xfd00 -#define PCI_DEVICE_ID_HELIOS_SCSP 0xfd11 -#define PCI_DEVICE_ID_HELIOS_DCSP 0xfd12 +#define PCI_DEVICE_ID_BMID 0xf0d5 +#define PCI_DEVICE_ID_BSMB 0xf0d1 #define PCI_DEVICE_ID_ZEPHYR 0xfe00 -#define PCI_DEVICE_ID_ZEPHYR_SCSP 0xfe11 -#define PCI_DEVICE_ID_ZEPHYR_DCSP 0xfe12 - -#define PCI_SUBSYSTEM_ID_LP11000S 0xfc11 -#define PCI_SUBSYSTEM_ID_LP11002S 0xfc12 -#define PCI_SUBSYSTEM_ID_LPE11000S 0xfc21 -#define PCI_SUBSYSTEM_ID_LPE11002S 0xfc22 -#define PCI_SUBSYSTEM_ID_LPE11010S 0xfc2A +#define PCI_DEVICE_ID_ZMID 0xf0e5 +#define PCI_DEVICE_ID_ZSMB 0xf0e1 +#define PCI_DEVICE_ID_LP101 0xf0a1 +#define PCI_DEVICE_ID_LP10000S 0xfc00 #define JEDEC_ID_ADDRESS 0x0080001c #define FIREFLY_JEDEC_ID 0x1ACC diff --git a/trunk/drivers/scsi/lpfc/lpfc_init.c b/trunk/drivers/scsi/lpfc/lpfc_init.c index b7a603a45328..07498118359d 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_init.c +++ b/trunk/drivers/scsi/lpfc/lpfc_init.c @@ -126,26 +126,34 @@ lpfc_config_port_prep(struct lpfc_hba * phba) return -ERESTART; } - /* - * The value of rr must be 1 since the driver set the cv field to 1. - * This setting requires the FW to set all revision fields. + /* The HBA's current state is provided by the ProgType and rr fields. + * Read and check the value of these fields before continuing to config + * this port. */ - if (mb->un.varRdRev.rr == 0) { + if (mb->un.varRdRev.rr == 0 || mb->un.varRdRev.un.b.ProgType != 2) { + /* Old firmware */ vp->rev.rBit = 0; - lpfc_printf_log(phba, KERN_ERR, LOG_INIT, - "%d:0440 Adapter failed to init, READ_REV has " - "missing revision information.\n", - phba->brd_no); + lpfc_printf_log(phba, + KERN_ERR, + LOG_INIT, + "%d:0440 Adapter failed to init, mbxCmd x%x " + "READ_REV detected outdated firmware" + "Data: x%x\n", + phba->brd_no, + mb->mbxCommand, 0); mempool_free(pmb, phba->mbox_mem_pool); return -ERESTART; + } else { + vp->rev.rBit = 1; + vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev; + memcpy(vp->rev.sli1FwName, + (char*)mb->un.varRdRev.sli1FwName, 16); + vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev; + memcpy(vp->rev.sli2FwName, + (char *)mb->un.varRdRev.sli2FwName, 16); } /* Save information as VPD data */ - vp->rev.rBit = 1; - vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev; - memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16); - vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev; - memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16); vp->rev.biuRev = mb->un.varRdRev.biuRev; vp->rev.smRev = mb->un.varRdRev.smRev; vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev; @@ -370,10 +378,6 @@ lpfc_config_port_post(struct lpfc_hba * phba) if (psli->num_rings > 3) status |= HC_R3INT_ENA; - if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) && - (phba->cfg_poll & DISABLE_FCP_RING_INT)) - status &= ~(HC_R0INT_ENA << LPFC_FCP_RING); - writel(status, phba->HCregaddr); readl(phba->HCregaddr); /* flush */ spin_unlock_irq(phba->host->host_lock); @@ -567,8 +571,6 @@ lpfc_handle_latt(struct lpfc_hba * phba) rc = -EIO; - /* Cleanup any outstanding ELS commands */ - lpfc_els_flush_cmd(phba); psli->slistat.link_event++; lpfc_read_la(phba, pmb, mp); @@ -763,139 +765,96 @@ static void lpfc_get_hba_model_desc(struct lpfc_hba * phba, uint8_t * mdp, uint8_t * descp) { lpfc_vpd_t *vp; - uint16_t dev_id = phba->pcidev->device; - uint16_t dev_subid = phba->pcidev->subsystem_device; - uint8_t hdrtype = phba->pcidev->hdr_type; - char *model_str = ""; + uint32_t id; + uint8_t hdrtype; + char str[16]; vp = &phba->vpd; + pci_read_config_dword(phba->pcidev, PCI_VENDOR_ID, &id); + pci_read_config_byte(phba->pcidev, PCI_HEADER_TYPE, &hdrtype); - switch (dev_id) { + switch ((id >> 16) & 0xffff) { case PCI_DEVICE_ID_FIREFLY: - model_str = "LP6000 1Gb PCI"; + strcpy(str, "LP6000 1"); break; case PCI_DEVICE_ID_SUPERFLY: if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3) - model_str = "LP7000 1Gb PCI"; + strcpy(str, "LP7000 1"); else - model_str = "LP7000E 1Gb PCI"; + strcpy(str, "LP7000E 1"); break; case PCI_DEVICE_ID_DRAGONFLY: - model_str = "LP8000 1Gb PCI"; + strcpy(str, "LP8000 1"); break; case PCI_DEVICE_ID_CENTAUR: if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID) - model_str = "LP9002 2Gb PCI"; + strcpy(str, "LP9002 2"); else - model_str = "LP9000 1Gb PCI"; + strcpy(str, "LP9000 1"); break; case PCI_DEVICE_ID_RFLY: - model_str = "LP952 2Gb PCI"; + strcpy(str, "LP952 2"); break; case PCI_DEVICE_ID_PEGASUS: - model_str = "LP9802 2Gb PCI-X"; + strcpy(str, "LP9802 2"); break; case PCI_DEVICE_ID_THOR: if (hdrtype == 0x80) - model_str = "LP10000DC 2Gb 2-port PCI-X"; + strcpy(str, "LP10000DC 2"); else - model_str = "LP10000 2Gb PCI-X"; + strcpy(str, "LP10000 2"); break; case PCI_DEVICE_ID_VIPER: - model_str = "LPX1000 10Gb PCI-X"; + strcpy(str, "LPX1000 10"); break; case PCI_DEVICE_ID_PFLY: - model_str = "LP982 2Gb PCI-X"; + strcpy(str, "LP982 2"); break; case PCI_DEVICE_ID_TFLY: if (hdrtype == 0x80) - model_str = "LP1050DC 2Gb 2-port PCI-X"; + strcpy(str, "LP1050DC 2"); else - model_str = "LP1050 2Gb PCI-X"; + strcpy(str, "LP1050 2"); break; case PCI_DEVICE_ID_HELIOS: if (hdrtype == 0x80) - model_str = "LP11002 4Gb 2-port PCI-X2"; - else - model_str = "LP11000 4Gb PCI-X2"; - break; - case PCI_DEVICE_ID_HELIOS_SCSP: - model_str = "LP11000-SP 4Gb PCI-X2"; - break; - case PCI_DEVICE_ID_HELIOS_DCSP: - model_str = "LP11002-SP 4Gb 2-port PCI-X2"; - break; - case PCI_DEVICE_ID_NEPTUNE: - if (hdrtype == 0x80) - model_str = "LPe1002 4Gb 2-port"; + strcpy(str, "LP11002 4"); else - model_str = "LPe1000 4Gb PCIe"; - break; - case PCI_DEVICE_ID_NEPTUNE_SCSP: - model_str = "LPe1000-SP 4Gb PCIe"; - break; - case PCI_DEVICE_ID_NEPTUNE_DCSP: - model_str = "LPe1002-SP 4Gb 2-port PCIe"; + strcpy(str, "LP11000 4"); break; case PCI_DEVICE_ID_BMID: - model_str = "LP1150 4Gb PCI-X2"; + strcpy(str, "LP1150 4"); break; case PCI_DEVICE_ID_BSMB: - model_str = "LP111 4Gb PCI-X2"; + strcpy(str, "LP111 4"); break; case PCI_DEVICE_ID_ZEPHYR: if (hdrtype == 0x80) - model_str = "LPe11002 4Gb 2-port PCIe"; + strcpy(str, "LPe11002 4"); else - model_str = "LPe11000 4Gb PCIe"; - break; - case PCI_DEVICE_ID_ZEPHYR_SCSP: - model_str = "LPe11000-SP 4Gb PCIe"; - break; - case PCI_DEVICE_ID_ZEPHYR_DCSP: - model_str = "LPe11002-SP 4Gb 2-port PCIe"; + strcpy(str, "LPe11000 4"); break; case PCI_DEVICE_ID_ZMID: - model_str = "LPe1150 4Gb PCIe"; + strcpy(str, "LPe1150 4"); break; case PCI_DEVICE_ID_ZSMB: - model_str = "LPe111 4Gb PCIe"; + strcpy(str, "LPe111 4"); break; case PCI_DEVICE_ID_LP101: - model_str = "LP101 2Gb PCI-X"; + strcpy(str, "LP101 2"); break; case PCI_DEVICE_ID_LP10000S: - model_str = "LP10000-S 2Gb PCI"; - break; - case PCI_DEVICE_ID_LP11000S: - case PCI_DEVICE_ID_LPE11000S: - switch (dev_subid) { - case PCI_SUBSYSTEM_ID_LP11000S: - model_str = "LP11002-S 4Gb PCI-X2"; - break; - case PCI_SUBSYSTEM_ID_LP11002S: - model_str = "LP11000-S 4Gb 2-port PCI-X2"; - break; - case PCI_SUBSYSTEM_ID_LPE11000S: - model_str = "LPe11002-S 4Gb PCIe"; - break; - case PCI_SUBSYSTEM_ID_LPE11002S: - model_str = "LPe11002-S 4Gb 2-port PCIe"; - break; - case PCI_SUBSYSTEM_ID_LPE11010S: - model_str = "LPe11010-S 4Gb 10-port PCIe"; - break; - default: - break; - } + strcpy(str, "LP10000-S 2"); break; default: + memset(str, 0, 16); break; } if (mdp) - sscanf(model_str, "%s", mdp); + sscanf(str, "%s", mdp); if (descp) - sprintf(descp, "Emulex %s Fibre Channel Adapter", model_str); + sprintf(descp, "Emulex LightPulse %s Gigabit PCI Fibre " + "Channel Adapter", str); } /**************************************************/ @@ -1237,7 +1196,6 @@ lpfc_stop_timer(struct lpfc_hba * phba) } } - del_timer_sync(&phba->fcp_poll_timer); del_timer_sync(&phba->fc_estabtmo); del_timer_sync(&phba->fc_disctmo); del_timer_sync(&phba->fc_fdmitmo); @@ -1393,7 +1351,7 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid) goto out_put_host; host->unique_id = phba->brd_no; - init_MUTEX(&phba->hba_can_block); + INIT_LIST_HEAD(&phba->ctrspbuflist); INIT_LIST_HEAD(&phba->rnidrspbuflist); INIT_LIST_HEAD(&phba->freebufList); @@ -1417,10 +1375,6 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid) psli->mbox_tmo.function = lpfc_mbox_timeout; psli->mbox_tmo.data = (unsigned long)phba; - init_timer(&phba->fcp_poll_timer); - phba->fcp_poll_timer.function = lpfc_poll_timeout; - phba->fcp_poll_timer.data = (unsigned long)phba; - /* * Get all the module params for configuring this host and then * establish the host parameters. @@ -1535,7 +1489,6 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid) host->max_cmd_len = 16; /* Initialize the list of scsi buffers used by driver for scsi IO. */ - spin_lock_init(&phba->scsi_buf_list_lock); INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list); host->transportt = lpfc_transport_template; @@ -1567,12 +1520,6 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid) if (error) goto out_free_irq; - if (phba->cfg_poll & DISABLE_FCP_RING_INT) { - spin_lock_irq(phba->host->host_lock); - lpfc_poll_start_timer(phba); - spin_unlock_irq(phba->host->host_lock); - } - /* * set fixed host attributes * Must done after lpfc_sli_hba_setup() @@ -1732,28 +1679,14 @@ static struct pci_device_id lpfc_id_table[] = { PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PFLY, PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE, - PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_SCSP, - PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_DCSP, - PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS, PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_SCSP, - PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_DCSP, - PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BMID, PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BSMB, PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR, PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_SCSP, - PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_DCSP, - PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZMID, PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZSMB, @@ -1764,10 +1697,6 @@ static struct pci_device_id lpfc_id_table[] = { PCI_ANY_ID, PCI_ANY_ID, }, {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP10000S, PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP11000S, - PCI_ANY_ID, PCI_ANY_ID, }, - {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S, - PCI_ANY_ID, PCI_ANY_ID, }, { 0 } }; diff --git a/trunk/drivers/scsi/lpfc/lpfc_nportdisc.c b/trunk/drivers/scsi/lpfc/lpfc_nportdisc.c index fbead786031f..507a6af56f42 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_nportdisc.c +++ b/trunk/drivers/scsi/lpfc/lpfc_nportdisc.c @@ -55,76 +55,55 @@ lpfc_check_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, return (1); } + int lpfc_check_sparm(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, struct serv_parm * sp, uint32_t class) { volatile struct serv_parm *hsp = &phba->fc_sparam; - uint16_t hsp_value, ssp_value = 0; - - /* - * The receive data field size and buffer-to-buffer receive data field - * size entries are 16 bits but are represented as two 8-bit fields in - * the driver data structure to account for rsvd bits and other control - * bits. Reconstruct and compare the fields as a 16-bit values before - * correcting the byte values. - */ + /* First check for supported version */ + + /* Next check for class validity */ if (sp->cls1.classValid) { - hsp_value = (hsp->cls1.rcvDataSizeMsb << 8) | - hsp->cls1.rcvDataSizeLsb; - ssp_value = (sp->cls1.rcvDataSizeMsb << 8) | - sp->cls1.rcvDataSizeLsb; - if (ssp_value > hsp_value) { - sp->cls1.rcvDataSizeLsb = hsp->cls1.rcvDataSizeLsb; + + if (sp->cls1.rcvDataSizeMsb > hsp->cls1.rcvDataSizeMsb) sp->cls1.rcvDataSizeMsb = hsp->cls1.rcvDataSizeMsb; - } + if (sp->cls1.rcvDataSizeLsb > hsp->cls1.rcvDataSizeLsb) + sp->cls1.rcvDataSizeLsb = hsp->cls1.rcvDataSizeLsb; } else if (class == CLASS1) { - return 0; + return (0); } if (sp->cls2.classValid) { - hsp_value = (hsp->cls2.rcvDataSizeMsb << 8) | - hsp->cls2.rcvDataSizeLsb; - ssp_value = (sp->cls2.rcvDataSizeMsb << 8) | - sp->cls2.rcvDataSizeLsb; - if (ssp_value > hsp_value) { - sp->cls2.rcvDataSizeLsb = hsp->cls2.rcvDataSizeLsb; + + if (sp->cls2.rcvDataSizeMsb > hsp->cls2.rcvDataSizeMsb) sp->cls2.rcvDataSizeMsb = hsp->cls2.rcvDataSizeMsb; - } + if (sp->cls2.rcvDataSizeLsb > hsp->cls2.rcvDataSizeLsb) + sp->cls2.rcvDataSizeLsb = hsp->cls2.rcvDataSizeLsb; } else if (class == CLASS2) { - return 0; + return (0); } if (sp->cls3.classValid) { - hsp_value = (hsp->cls3.rcvDataSizeMsb << 8) | - hsp->cls3.rcvDataSizeLsb; - ssp_value = (sp->cls3.rcvDataSizeMsb << 8) | - sp->cls3.rcvDataSizeLsb; - if (ssp_value > hsp_value) { - sp->cls3.rcvDataSizeLsb = hsp->cls3.rcvDataSizeLsb; + + if (sp->cls3.rcvDataSizeMsb > hsp->cls3.rcvDataSizeMsb) sp->cls3.rcvDataSizeMsb = hsp->cls3.rcvDataSizeMsb; - } + if (sp->cls3.rcvDataSizeLsb > hsp->cls3.rcvDataSizeLsb) + sp->cls3.rcvDataSizeLsb = hsp->cls3.rcvDataSizeLsb; } else if (class == CLASS3) { - return 0; + return (0); } - /* - * Preserve the upper four bits of the MSB from the PLOGI response. - * These bits contain the Buffer-to-Buffer State Change Number - * from the target and need to be passed to the FW. - */ - hsp_value = (hsp->cmn.bbRcvSizeMsb << 8) | hsp->cmn.bbRcvSizeLsb; - ssp_value = (sp->cmn.bbRcvSizeMsb << 8) | sp->cmn.bbRcvSizeLsb; - if (ssp_value > hsp_value) { + if (sp->cmn.bbRcvSizeMsb > hsp->cmn.bbRcvSizeMsb) + sp->cmn.bbRcvSizeMsb = hsp->cmn.bbRcvSizeMsb; + if (sp->cmn.bbRcvSizeLsb > hsp->cmn.bbRcvSizeLsb) sp->cmn.bbRcvSizeLsb = hsp->cmn.bbRcvSizeLsb; - sp->cmn.bbRcvSizeMsb = (sp->cmn.bbRcvSizeMsb & 0xF0) | - (hsp->cmn.bbRcvSizeMsb & 0x0F); - } + /* If check is good, copy wwpn wwnn into ndlp */ memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name)); memcpy(&ndlp->nlp_portname, &sp->portName, sizeof (struct lpfc_name)); - return 1; + return (1); } static void * diff --git a/trunk/drivers/scsi/lpfc/lpfc_scsi.c b/trunk/drivers/scsi/lpfc/lpfc_scsi.c index 9ee8218404c0..c63275e66e2e 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_scsi.c +++ b/trunk/drivers/scsi/lpfc/lpfc_scsi.c @@ -41,20 +41,6 @@ #define LPFC_ABORT_WAIT 2 -static inline void -lpfc_block_requests(struct lpfc_hba * phba) -{ - down(&phba->hba_can_block); - scsi_block_requests(phba->host); -} - -static inline void -lpfc_unblock_requests(struct lpfc_hba * phba) -{ - scsi_unblock_requests(phba->host); - up(&phba->hba_can_block); -} - /* * This routine allocates a scsi buffer, which contains all the necessary * information needed to initiate a SCSI I/O. The non-DMAable buffer region @@ -151,22 +137,18 @@ lpfc_new_scsi_buf(struct lpfc_hba * phba) } struct lpfc_scsi_buf* -lpfc_get_scsi_buf(struct lpfc_hba * phba) +lpfc_sli_get_scsi_buf(struct lpfc_hba * phba) { struct lpfc_scsi_buf * lpfc_cmd = NULL; struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list; - unsigned long iflag = 0; - spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag); list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list); - spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag); return lpfc_cmd; } static void lpfc_release_scsi_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * psb) { - unsigned long iflag = 0; /* * There are only two special cases to consider. (1) the scsi command * requested scatter-gather usage or (2) the scsi command allocated @@ -184,10 +166,8 @@ lpfc_release_scsi_buf(struct lpfc_hba * phba, struct lpfc_scsi_buf * psb) } } - spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag); psb->pCmd = NULL; list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list); - spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag); } static int @@ -409,9 +389,7 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn, struct lpfc_rport_data *rdata = lpfc_cmd->rdata; struct lpfc_nodelist *pnode = rdata->pnode; struct scsi_cmnd *cmd = lpfc_cmd->pCmd; - int result; - struct scsi_device *sdev, *tmp_sdev; - int depth = 0; + unsigned long iflag; lpfc_cmd->result = pIocbOut->iocb.un.ulpWord[4]; lpfc_cmd->status = pIocbOut->iocb.ulpStatus; @@ -463,64 +441,11 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn, *lp, *(lp + 3), cmd->retries, cmd->resid); } - result = cmd->result; - sdev = cmd->device; cmd->scsi_done(cmd); - if (!result && - ((jiffies - pnode->last_ramp_up_time) > - LPFC_Q_RAMP_UP_INTERVAL * HZ) && - ((jiffies - pnode->last_q_full_time) > - LPFC_Q_RAMP_UP_INTERVAL * HZ) && - (phba->cfg_lun_queue_depth > sdev->queue_depth)) { - shost_for_each_device(tmp_sdev, sdev->host) { - if (phba->cfg_lun_queue_depth > tmp_sdev->queue_depth) { - if (tmp_sdev->id != sdev->id) - continue; - if (tmp_sdev->ordered_tags) - scsi_adjust_queue_depth(tmp_sdev, - MSG_ORDERED_TAG, - tmp_sdev->queue_depth+1); - else - scsi_adjust_queue_depth(tmp_sdev, - MSG_SIMPLE_TAG, - tmp_sdev->queue_depth+1); - - pnode->last_ramp_up_time = jiffies; - } - } - } - - /* - * Check for queue full. If the lun is reporting queue full, then - * back off the lun queue depth to prevent target overloads. - */ - if (result == SAM_STAT_TASK_SET_FULL) { - pnode->last_q_full_time = jiffies; - - shost_for_each_device(tmp_sdev, sdev->host) { - if (tmp_sdev->id != sdev->id) - continue; - depth = scsi_track_queue_full(tmp_sdev, - tmp_sdev->queue_depth - 1); - } - /* - * The queue depth cannot be lowered any more. - * Modify the returned error code to store - * the final depth value set by - * scsi_track_queue_full. - */ - if (depth == -1) - depth = sdev->host->cmd_per_lun; - - if (depth) { - lpfc_printf_log(phba, KERN_WARNING, LOG_FCP, - "%d:0711 detected queue full - lun queue depth " - " adjusted to %d.\n", phba->brd_no, depth); - } - } - + spin_lock_irqsave(phba->host->host_lock, iflag); lpfc_release_scsi_buf(phba, lpfc_cmd); + spin_unlock_irqrestore(phba->host->host_lock, iflag); } static void @@ -768,37 +693,6 @@ lpfc_info(struct Scsi_Host *host) return lpfcinfobuf; } -static __inline__ void lpfc_poll_rearm_timer(struct lpfc_hba * phba) -{ - unsigned long poll_tmo_expires = - (jiffies + msecs_to_jiffies(phba->cfg_poll_tmo)); - - if (phba->sli.ring[LPFC_FCP_RING].txcmplq_cnt) - mod_timer(&phba->fcp_poll_timer, - poll_tmo_expires); -} - -void lpfc_poll_start_timer(struct lpfc_hba * phba) -{ - lpfc_poll_rearm_timer(phba); -} - -void lpfc_poll_timeout(unsigned long ptr) -{ - struct lpfc_hba *phba = (struct lpfc_hba *)ptr; - unsigned long iflag; - - spin_lock_irqsave(phba->host->host_lock, iflag); - - if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { - lpfc_sli_poll_fcp_ring (phba); - if (phba->cfg_poll & DISABLE_FCP_RING_INT) - lpfc_poll_rearm_timer(phba); - } - - spin_unlock_irqrestore(phba->host->host_lock, iflag); -} - static int lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *)) { @@ -825,11 +719,10 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *)) cmnd->result = ScsiResult(DID_BUS_BUSY, 0); goto out_fail_command; } - lpfc_cmd = lpfc_get_scsi_buf (phba); + lpfc_cmd = lpfc_sli_get_scsi_buf (phba); if (lpfc_cmd == NULL) { - lpfc_printf_log(phba, KERN_INFO, LOG_FCP, - "%d:0707 driver's buffer pool is empty, " - "IO busied\n", phba->brd_no); + printk(KERN_WARNING "%s: No buffer available - list empty, " + "total count %d\n", __FUNCTION__, phba->total_scsi_bufs); goto out_host_busy; } @@ -853,17 +746,11 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *)) &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB); if (err) goto out_host_busy_free_buf; - - if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { - lpfc_sli_poll_fcp_ring(phba); - if (phba->cfg_poll & DISABLE_FCP_RING_INT) - lpfc_poll_rearm_timer(phba); - } - return 0; out_host_busy_free_buf: lpfc_release_scsi_buf(phba, lpfc_cmd); + cmnd->host_scribble = NULL; out_host_busy: return SCSI_MLQUEUE_HOST_BUSY; @@ -872,12 +759,11 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *)) return 0; } - static int -lpfc_abort_handler(struct scsi_cmnd *cmnd) +__lpfc_abort_handler(struct scsi_cmnd *cmnd) { - struct Scsi_Host *shost = cmnd->device->host; - struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata[0]; + struct lpfc_hba *phba = + (struct lpfc_hba *)cmnd->device->host->hostdata[0]; struct lpfc_sli_ring *pring = &phba->sli.ring[phba->sli.fcp_ring]; struct lpfc_iocbq *iocb; struct lpfc_iocbq *abtsiocb; @@ -886,8 +772,6 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd) unsigned int loop_count = 0; int ret = SUCCESS; - lpfc_block_requests(phba); - spin_lock_irq(shost->host_lock); lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble; BUG_ON(!lpfc_cmd); @@ -937,15 +821,9 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd) goto out; } - if (phba->cfg_poll & DISABLE_FCP_RING_INT) - lpfc_sli_poll_fcp_ring (phba); - /* Wait for abort to complete */ while (lpfc_cmd->pCmd == cmnd) { - if (phba->cfg_poll & DISABLE_FCP_RING_INT) - lpfc_sli_poll_fcp_ring (phba); - spin_unlock_irq(phba->host->host_lock); schedule_timeout_uninterruptible(LPFC_ABORT_WAIT*HZ); spin_lock_irq(phba->host->host_lock); @@ -966,19 +844,26 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd) out: lpfc_printf_log(phba, KERN_WARNING, LOG_FCP, - "%d:0749 SCSI Layer I/O Abort Request " - "Status x%x ID %d LUN %d snum %#lx\n", + "%d:0749 SCSI layer issued abort device: ret %#x, " + "ID %d, LUN %d, snum %#lx\n", phba->brd_no, ret, cmnd->device->id, cmnd->device->lun, cmnd->serial_number); - spin_unlock_irq(shost->host_lock); - lpfc_unblock_requests(phba); - return ret; } static int -lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) +lpfc_abort_handler(struct scsi_cmnd *cmnd) +{ + int rc; + spin_lock_irq(cmnd->device->host->host_lock); + rc = __lpfc_abort_handler(cmnd); + spin_unlock_irq(cmnd->device->host->host_lock); + return rc; +} + +static int +__lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) { struct Scsi_Host *shost = cmnd->device->host; struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata[0]; @@ -986,12 +871,9 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) struct lpfc_iocbq *iocbq, *iocbqrsp; struct lpfc_rport_data *rdata = cmnd->device->hostdata; struct lpfc_nodelist *pnode = rdata->pnode; - uint32_t cmd_result = 0, cmd_status = 0; int ret = FAILED; int cnt, loopcnt; - lpfc_block_requests(phba); - spin_lock_irq(shost->host_lock); /* * If target is not in a MAPPED state, delay the reset until * target is rediscovered or nodev timeout expires. @@ -1009,7 +891,7 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) break; } - lpfc_cmd = lpfc_get_scsi_buf (phba); + lpfc_cmd = lpfc_sli_get_scsi_buf (phba); if (lpfc_cmd == NULL) goto out; @@ -1034,28 +916,26 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) if (ret == IOCB_SUCCESS) ret = SUCCESS; - - cmd_result = iocbqrsp->iocb.un.ulpWord[4]; - cmd_status = iocbqrsp->iocb.ulpStatus; - - lpfc_sli_release_iocbq(phba, iocbqrsp); - lpfc_release_scsi_buf(phba, lpfc_cmd); + lpfc_cmd->result = iocbqrsp->iocb.un.ulpWord[4]; + lpfc_cmd->status = iocbqrsp->iocb.ulpStatus; + if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT) + if (lpfc_cmd->result & IOERR_DRVR_MASK) + lpfc_cmd->status = IOSTAT_DRIVER_REJECT; /* - * All outstanding txcmplq I/Os should have been aborted by the device. + * All outstanding txcmplq I/Os should have been aborted by the target. * Unfortunately, some targets do not abide by this forcing the driver * to double check. */ - cnt = lpfc_sli_sum_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring], - cmnd->device->id, cmnd->device->lun, - LPFC_CTX_LUN); - if (cnt) - lpfc_sli_abort_iocb(phba, - &phba->sli.ring[phba->sli.fcp_ring], - cmnd->device->id, cmnd->device->lun, - 0, LPFC_CTX_LUN); + lpfc_sli_abort_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring], + cmnd->device->id, cmnd->device->lun, 0, + LPFC_CTX_LUN); + loopcnt = 0; - while(cnt) { + while((cnt = lpfc_sli_sum_iocb(phba, + &phba->sli.ring[phba->sli.fcp_ring], + cmnd->device->id, cmnd->device->lun, + LPFC_CTX_LUN))) { spin_unlock_irq(phba->host->host_lock); schedule_timeout_uninterruptible(LPFC_RESET_WAIT*HZ); spin_lock_irq(phba->host->host_lock); @@ -1063,11 +943,6 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) if (++loopcnt > (2 * phba->cfg_nodev_tmo)/LPFC_RESET_WAIT) break; - - cnt = lpfc_sli_sum_iocb(phba, - &phba->sli.ring[phba->sli.fcp_ring], - cmnd->device->id, cmnd->device->lun, - LPFC_CTX_LUN); } if (cnt) { @@ -1077,21 +952,35 @@ lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) ret = FAILED; } + lpfc_sli_release_iocbq(phba, iocbqrsp); + out_free_scsi_buf: lpfc_printf_log(phba, KERN_ERR, LOG_FCP, "%d:0713 SCSI layer issued LUN reset (%d, %d) " "Data: x%x x%x x%x\n", - phba->brd_no, cmnd->device->id,cmnd->device->lun, - ret, cmd_status, cmd_result); - + phba->brd_no, lpfc_cmd->pCmd->device->id, + lpfc_cmd->pCmd->device->lun, ret, lpfc_cmd->status, + lpfc_cmd->result); + lpfc_release_scsi_buf(phba, lpfc_cmd); out: - spin_unlock_irq(shost->host_lock); - lpfc_unblock_requests(phba); return ret; } static int -lpfc_reset_bus_handler(struct scsi_cmnd *cmnd) +lpfc_reset_lun_handler(struct scsi_cmnd *cmnd) +{ + int rc; + spin_lock_irq(cmnd->device->host->host_lock); + rc = __lpfc_reset_lun_handler(cmnd); + spin_unlock_irq(cmnd->device->host->host_lock); + return rc; +} + +/* + * Note: midlayer calls this function with the host_lock held + */ +static int +__lpfc_reset_bus_handler(struct scsi_cmnd *cmnd) { struct Scsi_Host *shost = cmnd->device->host; struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata[0]; @@ -1102,10 +991,7 @@ lpfc_reset_bus_handler(struct scsi_cmnd *cmnd) unsigned int midlayer_id = 0; struct lpfc_scsi_buf * lpfc_cmd; - lpfc_block_requests(phba); - spin_lock_irq(shost->host_lock); - - lpfc_cmd = lpfc_get_scsi_buf(phba); + lpfc_cmd = lpfc_sli_get_scsi_buf (phba); if (lpfc_cmd == NULL) goto out; @@ -1136,31 +1022,18 @@ lpfc_reset_bus_handler(struct scsi_cmnd *cmnd) lpfc_cmd->pCmd->device->hostdata = ndlp->rport->dd_data; ret = lpfc_scsi_tgt_reset(lpfc_cmd, phba); if (ret != SUCCESS) { - lpfc_printf_log(phba, KERN_ERR, LOG_FCP, + lpfc_printf_log(phba, KERN_INFO, LOG_FCP, "%d:0713 Bus Reset on target %d failed\n", phba->brd_no, i); err_count++; } } - if (err_count == 0) - ret = SUCCESS; - - lpfc_release_scsi_buf(phba, lpfc_cmd); - - /* - * All outstanding txcmplq I/Os should have been aborted by - * the targets. Unfortunately, some targets do not abide by - * this forcing the driver to double check. - */ cmnd->device->id = midlayer_id; - cnt = lpfc_sli_sum_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring], - 0, 0, LPFC_CTX_HOST); - if (cnt) - lpfc_sli_abort_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring], - 0, 0, 0, LPFC_CTX_HOST); loopcnt = 0; - while(cnt) { + while((cnt = lpfc_sli_sum_iocb(phba, + &phba->sli.ring[phba->sli.fcp_ring], + 0, 0, LPFC_CTX_HOST))) { spin_unlock_irq(phba->host->host_lock); schedule_timeout_uninterruptible(LPFC_RESET_WAIT*HZ); spin_lock_irq(phba->host->host_lock); @@ -1168,30 +1041,44 @@ lpfc_reset_bus_handler(struct scsi_cmnd *cmnd) if (++loopcnt > (2 * phba->cfg_nodev_tmo)/LPFC_RESET_WAIT) break; - - cnt = lpfc_sli_sum_iocb(phba, - &phba->sli.ring[phba->sli.fcp_ring], - 0, 0, LPFC_CTX_HOST); } if (cnt) { - lpfc_printf_log(phba, KERN_ERR, LOG_FCP, + /* flush all outstanding commands on the host */ + i = lpfc_sli_abort_iocb(phba, + &phba->sli.ring[phba->sli.fcp_ring], 0, 0, 0, + LPFC_CTX_HOST); + + lpfc_printf_log(phba, KERN_INFO, LOG_FCP, "%d:0715 Bus Reset I/O flush failure: cnt x%x left x%x\n", phba->brd_no, cnt, i); - ret = FAILED; } + if (cnt == 0) + ret = SUCCESS; + else + ret = FAILED; + + lpfc_release_scsi_buf(phba, lpfc_cmd); lpfc_printf_log(phba, KERN_ERR, LOG_FCP, "%d:0714 SCSI layer issued Bus Reset Data: x%x\n", phba->brd_no, ret); out: - spin_unlock_irq(shost->host_lock); - lpfc_unblock_requests(phba); return ret; } +static int +lpfc_reset_bus_handler(struct scsi_cmnd *cmnd) +{ + int rc; + spin_lock_irq(cmnd->device->host->host_lock); + rc = __lpfc_reset_bus_handler(cmnd); + spin_unlock_irq(cmnd->device->host->host_lock); + return rc; +} + static int lpfc_slave_alloc(struct scsi_device *sdev) { @@ -1240,10 +1127,10 @@ lpfc_slave_alloc(struct scsi_device *sdev) break; } - spin_lock_irqsave(&phba->scsi_buf_list_lock, flags); + spin_lock_irqsave(phba->host->host_lock, flags); phba->total_scsi_bufs++; list_add_tail(&scsi_buf->list, &phba->lpfc_scsi_buf_list); - spin_unlock_irqrestore(&phba->scsi_buf_list_lock, flags); + spin_unlock_irqrestore(phba->host->host_lock, flags); } return 0; } @@ -1267,12 +1154,6 @@ lpfc_slave_configure(struct scsi_device *sdev) */ rport->dev_loss_tmo = phba->cfg_nodev_tmo + 5; - if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) { - lpfc_sli_poll_fcp_ring(phba); - if (phba->cfg_poll & DISABLE_FCP_RING_INT) - lpfc_poll_rearm_timer(phba); - } - return 0; } diff --git a/trunk/drivers/scsi/lpfc/lpfc_sli.c b/trunk/drivers/scsi/lpfc/lpfc_sli.c index 7b785ade8b07..e2c08c5d83fb 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_sli.c +++ b/trunk/drivers/scsi/lpfc/lpfc_sli.c @@ -886,182 +886,6 @@ lpfc_sli_process_sol_iocb(struct lpfc_hba * phba, struct lpfc_sli_ring * pring, return rc; } -static void lpfc_sli_rsp_pointers_error(struct lpfc_hba * phba, - struct lpfc_sli_ring * pring) -{ - struct lpfc_pgp *pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno]; - /* - * Ring handler: portRspPut is bigger then - * rsp ring - */ - lpfc_printf_log(phba, KERN_ERR, LOG_SLI, - "%d:0312 Ring %d handler: portRspPut %d " - "is bigger then rsp ring %d\n", - phba->brd_no, pring->ringno, - le32_to_cpu(pgp->rspPutInx), - pring->numRiocb); - - phba->hba_state = LPFC_HBA_ERROR; - - /* - * All error attention handlers are posted to - * worker thread - */ - phba->work_ha |= HA_ERATT; - phba->work_hs = HS_FFER3; - if (phba->work_wait) - wake_up(phba->work_wait); - - return; -} - -void lpfc_sli_poll_fcp_ring(struct lpfc_hba * phba) -{ - struct lpfc_sli * psli = &phba->sli; - struct lpfc_sli_ring * pring = &psli->ring[LPFC_FCP_RING]; - IOCB_t *irsp = NULL; - IOCB_t *entry = NULL; - struct lpfc_iocbq *cmdiocbq = NULL; - struct lpfc_iocbq rspiocbq; - struct lpfc_pgp *pgp; - uint32_t status; - uint32_t portRspPut, portRspMax; - int type; - uint32_t rsp_cmpl = 0; - void __iomem *to_slim; - uint32_t ha_copy; - - pring->stats.iocb_event++; - - /* The driver assumes SLI-2 mode */ - pgp = &phba->slim2p->mbx.us.s2.port[pring->ringno]; - - /* - * The next available response entry should never exceed the maximum - * entries. If it does, treat it as an adapter hardware error. - */ - portRspMax = pring->numRiocb; - portRspPut = le32_to_cpu(pgp->rspPutInx); - if (unlikely(portRspPut >= portRspMax)) { - lpfc_sli_rsp_pointers_error(phba, pring); - return; - } - - rmb(); - while (pring->rspidx != portRspPut) { - - entry = IOCB_ENTRY(pring->rspringaddr, pring->rspidx); - - if (++pring->rspidx >= portRspMax) - pring->rspidx = 0; - - lpfc_sli_pcimem_bcopy((uint32_t *) entry, - (uint32_t *) &rspiocbq.iocb, - sizeof (IOCB_t)); - irsp = &rspiocbq.iocb; - type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK); - pring->stats.iocb_rsp++; - rsp_cmpl++; - - if (unlikely(irsp->ulpStatus)) { - /* Rsp ring error: IOCB */ - lpfc_printf_log(phba, KERN_WARNING, LOG_SLI, - "%d:0326 Rsp Ring %d error: IOCB Data: " - "x%x x%x x%x x%x x%x x%x x%x x%x\n", - phba->brd_no, pring->ringno, - irsp->un.ulpWord[0], - irsp->un.ulpWord[1], - irsp->un.ulpWord[2], - irsp->un.ulpWord[3], - irsp->un.ulpWord[4], - irsp->un.ulpWord[5], - *(((uint32_t *) irsp) + 6), - *(((uint32_t *) irsp) + 7)); - } - - switch (type) { - case LPFC_ABORT_IOCB: - case LPFC_SOL_IOCB: - /* - * Idle exchange closed via ABTS from port. No iocb - * resources need to be recovered. - */ - if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) { - printk(KERN_INFO "%s: IOCB cmd 0x%x processed." - " Skipping completion\n", __FUNCTION__, - irsp->ulpCommand); - break; - } - - cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring, - &rspiocbq); - if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) { - (cmdiocbq->iocb_cmpl)(phba, cmdiocbq, - &rspiocbq); - } - break; - default: - if (irsp->ulpCommand == CMD_ADAPTER_MSG) { - char adaptermsg[LPFC_MAX_ADPTMSG]; - memset(adaptermsg, 0, LPFC_MAX_ADPTMSG); - memcpy(&adaptermsg[0], (uint8_t *) irsp, - MAX_MSG_DATA); - dev_warn(&((phba->pcidev)->dev), "lpfc%d: %s", - phba->brd_no, adaptermsg); - } else { - /* Unknown IOCB command */ - lpfc_printf_log(phba, KERN_ERR, LOG_SLI, - "%d:0321 Unknown IOCB command " - "Data: x%x, x%x x%x x%x x%x\n", - phba->brd_no, type, - irsp->ulpCommand, - irsp->ulpStatus, - irsp->ulpIoTag, - irsp->ulpContext); - } - break; - } - - /* - * The response IOCB has been processed. Update the ring - * pointer in SLIM. If the port response put pointer has not - * been updated, sync the pgp->rspPutInx and fetch the new port - * response put pointer. - */ - to_slim = phba->MBslimaddr + - (SLIMOFF + (pring->ringno * 2) + 1) * 4; - writeb(pring->rspidx, to_slim); - - if (pring->rspidx == portRspPut) - portRspPut = le32_to_cpu(pgp->rspPutInx); - } - - ha_copy = readl(phba->HAregaddr); - ha_copy >>= (LPFC_FCP_RING * 4); - - if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) { - pring->stats.iocb_rsp_full++; - status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4)); - writel(status, phba->CAregaddr); - readl(phba->CAregaddr); - } - if ((ha_copy & HA_R0CE_RSP) && - (pring->flag & LPFC_CALL_RING_AVAILABLE)) { - pring->flag &= ~LPFC_CALL_RING_AVAILABLE; - pring->stats.iocb_cmd_empty++; - - /* Force update of the local copy of cmdGetInx */ - pring->local_getidx = le32_to_cpu(pgp->cmdGetInx); - lpfc_sli_resume_iocb(phba, pring); - - if ((pring->lpfc_sli_cmd_available)) - (pring->lpfc_sli_cmd_available) (phba, pring); - - } - - return; -} - /* * This routine presumes LPFC_FCP_RING handling and doesn't bother * to check it explicitly. @@ -1093,7 +917,24 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba, portRspMax = pring->numRiocb; portRspPut = le32_to_cpu(pgp->rspPutInx); if (unlikely(portRspPut >= portRspMax)) { - lpfc_sli_rsp_pointers_error(phba, pring); + /* + * Ring handler: portRspPut is bigger then + * rsp ring + */ + lpfc_printf_log(phba, KERN_ERR, LOG_SLI, + "%d:0312 Ring %d handler: portRspPut %d " + "is bigger then rsp ring %d\n", + phba->brd_no, pring->ringno, portRspPut, + portRspMax); + + phba->hba_state = LPFC_HBA_ERROR; + + /* All error attention handlers are posted to worker thread */ + phba->work_ha |= HA_ERATT; + phba->work_hs = HS_FFER3; + if (phba->work_wait) + wake_up(phba->work_wait); + spin_unlock_irqrestore(phba->host->host_lock, iflag); return 1; } @@ -1106,10 +947,6 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba, * network byte order and pci byte orders are different. */ entry = IOCB_ENTRY(pring->rspringaddr, pring->rspidx); - - if (++pring->rspidx >= portRspMax) - pring->rspidx = 0; - lpfc_sli_pcimem_bcopy((uint32_t *) entry, (uint32_t *) &rspiocbq.iocb, sizeof (IOCB_t)); @@ -1183,6 +1020,9 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba * phba, * been updated, sync the pgp->rspPutInx and fetch the new port * response put pointer. */ + if (++pring->rspidx >= portRspMax) + pring->rspidx = 0; + to_slim = phba->MBslimaddr + (SLIMOFF + (pring->ringno * 2) + 1) * 4; writel(pring->rspidx, to_slim); @@ -2775,7 +2615,6 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba, DECLARE_WAIT_QUEUE_HEAD(done_q); long timeleft, timeout_req = 0; int retval = IOCB_SUCCESS; - uint32_t creg_val; /* * If the caller has provided a response iocbq buffer, then context2 @@ -2791,13 +2630,6 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba, piocb->context_un.wait_queue = &done_q; piocb->iocb_flag &= ~LPFC_IO_WAKE; - if (phba->cfg_poll & DISABLE_FCP_RING_INT) { - creg_val = readl(phba->HCregaddr); - creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING); - writel(creg_val, phba->HCregaddr); - readl(phba->HCregaddr); /* flush */ - } - retval = lpfc_sli_issue_iocb(phba, pring, piocb, 0); if (retval == IOCB_SUCCESS) { timeout_req = timeout * HZ; @@ -2831,13 +2663,6 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba * phba, retval = IOCB_ERROR; } - if (phba->cfg_poll & DISABLE_FCP_RING_INT) { - creg_val = readl(phba->HCregaddr); - creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING); - writel(creg_val, phba->HCregaddr); - readl(phba->HCregaddr); /* flush */ - } - if (prspiocbq) piocb->context2 = NULL; diff --git a/trunk/drivers/scsi/lpfc/lpfc_version.h b/trunk/drivers/scsi/lpfc/lpfc_version.h index fa681a934ffe..4f0466fbd5f2 100644 --- a/trunk/drivers/scsi/lpfc/lpfc_version.h +++ b/trunk/drivers/scsi/lpfc/lpfc_version.h @@ -18,7 +18,7 @@ * included with this package. * *******************************************************************/ -#define LPFC_DRIVER_VERSION "8.1.1" +#define LPFC_DRIVER_VERSION "8.1.0" #define LPFC_DRIVER_NAME "lpfc" diff --git a/trunk/drivers/scsi/megaraid.c b/trunk/drivers/scsi/megaraid.c index 4a6feb1e5e3d..578143e93a6f 100644 --- a/trunk/drivers/scsi/megaraid.c +++ b/trunk/drivers/scsi/megaraid.c @@ -2,7 +2,7 @@ * * Linux MegaRAID device driver * - * Copyright (c) 2002 LSI Logic Corporation. + * Copyright © 2002 LSI Logic Corporation. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -17,8 +17,7 @@ * Copyright (c) 2003 Christoph Hellwig * - new-style, hotplug-aware pci probing and scsi registration * - * Version : v2.00.4 Mon Nov 14 14:02:43 EST 2005 - Seokmann Ju - * + * Version : v2.00.3 (Feb 19, 2003) - Atul Mukker * * Description: Linux device driver for LSI Logic MegaRAID controller * @@ -52,10 +51,10 @@ #include "megaraid.h" -#define MEGARAID_MODULE_VERSION "2.00.4" +#define MEGARAID_MODULE_VERSION "2.00.3" -MODULE_AUTHOR ("sju@lsil.com"); -MODULE_DESCRIPTION ("LSI Logic MegaRAID legacy driver"); +MODULE_AUTHOR ("LSI Logic Corporation"); +MODULE_DESCRIPTION ("LSI Logic MegaRAID driver"); MODULE_LICENSE ("GPL"); MODULE_VERSION(MEGARAID_MODULE_VERSION); @@ -4554,7 +4553,7 @@ mega_internal_done(Scsi_Cmnd *scmd) static struct scsi_host_template megaraid_template = { .module = THIS_MODULE, .name = "MegaRAID", - .proc_name = "megaraid_legacy", + .proc_name = "megaraid", .info = megaraid_info, .queuecommand = megaraid_queue, .bios_param = megaraid_biosparam, @@ -5038,12 +5037,22 @@ megaraid_shutdown(struct pci_dev *pdev) } static struct pci_device_id megaraid_pci_tbl[] = { + {PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DISCOVERY, + PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, + {PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_PERC4_DI, + PCI_ANY_ID, PCI_ANY_ID, 0, 0, BOARD_64BIT}, + {PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_PERC4_QC_VERDE, + PCI_ANY_ID, PCI_ANY_ID, 0, 0, BOARD_64BIT}, {PCI_VENDOR_ID_AMI, PCI_DEVICE_ID_AMI_MEGARAID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {PCI_VENDOR_ID_AMI, PCI_DEVICE_ID_AMI_MEGARAID2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, + {PCI_VENDOR_ID_AMI, PCI_DEVICE_ID_AMI_MEGARAID3, + PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_AMI_MEGARAID3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, + {PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_AMI_MEGARAID3, + PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {0,} }; MODULE_DEVICE_TABLE(pci, megaraid_pci_tbl); @@ -5086,7 +5095,7 @@ static int __init megaraid_init(void) * First argument (major) to register_chrdev implies a dynamic * major number allocation. */ - major = register_chrdev(0, "megadev_legacy", &megadev_fops); + major = register_chrdev(0, "megadev", &megadev_fops); if (!major) { printk(KERN_WARNING "megaraid: failed to register char device\n"); @@ -5100,7 +5109,7 @@ static void __exit megaraid_exit(void) /* * Unregister the character device interface to the driver. */ - unregister_chrdev(major, "megadev_legacy"); + unregister_chrdev(major, "megadev"); pci_unregister_driver(&megaraid_pci_driver); diff --git a/trunk/drivers/scsi/megaraid/Kconfig.megaraid b/trunk/drivers/scsi/megaraid/Kconfig.megaraid index 17419e30ffc8..7363e12663ac 100644 --- a/trunk/drivers/scsi/megaraid/Kconfig.megaraid +++ b/trunk/drivers/scsi/megaraid/Kconfig.megaraid @@ -64,6 +64,7 @@ config MEGARAID_MAILBOX To compile this driver as a module, choose M here: the module will be called megaraid_mbox +if MEGARAID_NEWGEN=n config MEGARAID_LEGACY tristate "LSI Logic Legacy MegaRAID Driver" depends on PCI && SCSI @@ -74,6 +75,7 @@ config MEGARAID_LEGACY To compile this driver as a module, choose M here: the module will be called megaraid +endif config MEGARAID_SAS tristate "LSI Logic MegaRAID SAS RAID Module" diff --git a/trunk/drivers/scsi/megaraid/megaraid_mbox.c b/trunk/drivers/scsi/megaraid/megaraid_mbox.c index d18a4bc2498c..4b5d420d2f4d 100644 --- a/trunk/drivers/scsi/megaraid/megaraid_mbox.c +++ b/trunk/drivers/scsi/megaraid/megaraid_mbox.c @@ -10,13 +10,12 @@ * 2 of the License, or (at your option) any later version. * * FILE : megaraid_mbox.c - * Version : v2.20.4.7 (Nov 14 2005) + * Version : v2.20.4.6 (Mar 07 2005) * * Authors: * Atul Mukker * Sreenivas Bagalkote * Manoj Jose - * Seokmann Ju * * List of supported controllers * @@ -137,7 +136,7 @@ static int wait_till_fw_empty(adapter_t *); -MODULE_AUTHOR("sju@lsil.com"); +MODULE_AUTHOR("LSI Logic Corporation"); MODULE_DESCRIPTION("LSI Logic MegaRAID Mailbox Driver"); MODULE_LICENSE("GPL"); MODULE_VERSION(MEGARAID_VERSION); @@ -279,14 +278,68 @@ static struct pci_device_id pci_id_table_g[] = { { PCI_VENDOR_ID_AMI, PCI_DEVICE_ID_AMI_MEGARAID3, - PCI_ANY_ID, - PCI_ANY_ID, + PCI_VENDOR_ID_DELL, + PCI_SUBSYS_ID_PERC3_QC, }, { - PCI_VENDOR_ID_LSI_LOGIC, + PCI_VENDOR_ID_AMI, PCI_DEVICE_ID_AMI_MEGARAID3, - PCI_ANY_ID, - PCI_ANY_ID, + PCI_VENDOR_ID_DELL, + PCI_SUBSYS_ID_PERC3_DC, + }, + { + PCI_VENDOR_ID_AMI, + PCI_DEVICE_ID_AMI_MEGARAID3, + PCI_VENDOR_ID_DELL, + PCI_SUBSYS_ID_PERC3_SC, + }, + { + PCI_VENDOR_ID_AMI, + PCI_DEVICE_ID_AMI_MEGARAID3, + PCI_VENDOR_ID_AMI, + PCI_SUBSYS_ID_PERC3_SC, + }, + { + PCI_VENDOR_ID_AMI, + PCI_DEVICE_ID_AMI_MEGARAID3, + PCI_VENDOR_ID_AMI, + PCI_SUBSYS_ID_PERC3_DC, + }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_MEGARAID_SCSI_320_0, + PCI_VENDOR_ID_LSI_LOGIC, + PCI_SUBSYS_ID_MEGARAID_SCSI_320_0, + }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_MEGARAID_SCSI_320_1, + PCI_VENDOR_ID_LSI_LOGIC, + PCI_SUBSYS_ID_MEGARAID_SCSI_320_1, + }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_MEGARAID_SCSI_320_2, + PCI_VENDOR_ID_LSI_LOGIC, + PCI_SUBSYS_ID_MEGARAID_SCSI_320_2, + }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_MEGARAID_I4_133_RAID, + PCI_VENDOR_ID_LSI_LOGIC, + PCI_SUBSYS_ID_MEGARAID_I4_133_RAID, + }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_MEGARAID_SATA_150_4, + PCI_VENDOR_ID_LSI_LOGIC, + PCI_SUBSYS_ID_MEGARAID_SATA_150_4, + }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_MEGARAID_SATA_150_6, + PCI_VENDOR_ID_LSI_LOGIC, + PCI_SUBSYS_ID_MEGARAID_SATA_150_6, }, { PCI_VENDOR_ID_LSI_LOGIC, @@ -294,6 +347,18 @@ static struct pci_device_id pci_id_table_g[] = { PCI_ANY_ID, PCI_ANY_ID, }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_INTEL_RAID_SRCS16, + PCI_VENDOR_ID_INTEL, + PCI_SUBSYS_ID_INTEL_RAID_SRCS16, + }, + { + PCI_VENDOR_ID_LSI_LOGIC, + PCI_DEVICE_ID_INTEL_RAID_SRCU41L_LAKE_SHETEK, + PCI_VENDOR_ID_INTEL, + PCI_SUBSYS_ID_INTEL_RAID_SRCU41L_LAKE_SHETEK, + }, {0} /* Terminating entry */ }; MODULE_DEVICE_TABLE(pci, pci_id_table_g); @@ -2920,7 +2985,6 @@ mbox_post_sync_cmd_fast(adapter_t *adapter, uint8_t raw_mbox[]) for (i = 0; i < 0xFFFFF; i++) { if (mbox->numstatus != 0xFF) break; - rmb(); } if (i == 0xFFFFF) { diff --git a/trunk/drivers/scsi/megaraid/megaraid_mbox.h b/trunk/drivers/scsi/megaraid/megaraid_mbox.h index 882fb1a0b575..644b91bdb028 100644 --- a/trunk/drivers/scsi/megaraid/megaraid_mbox.h +++ b/trunk/drivers/scsi/megaraid/megaraid_mbox.h @@ -21,8 +21,8 @@ #include "megaraid_ioctl.h" -#define MEGARAID_VERSION "2.20.4.7" -#define MEGARAID_EXT_VERSION "(Release Date: Mon Nov 14 12:27:22 EST 2005)" +#define MEGARAID_VERSION "2.20.4.6" +#define MEGARAID_EXT_VERSION "(Release Date: Mon Mar 07 12:27:22 EST 2005)" /* diff --git a/trunk/drivers/scsi/ncr53c8xx.c b/trunk/drivers/scsi/ncr53c8xx.c index 32350707b940..243470936fab 100644 --- a/trunk/drivers/scsi/ncr53c8xx.c +++ b/trunk/drivers/scsi/ncr53c8xx.c @@ -131,739 +131,7 @@ #define NAME53C "ncr53c" #define NAME53C8XX "ncr53c8xx" - -/*========================================================== -** -** Debugging tags -** -**========================================================== -*/ - -#define DEBUG_ALLOC (0x0001) -#define DEBUG_PHASE (0x0002) -#define DEBUG_QUEUE (0x0008) -#define DEBUG_RESULT (0x0010) -#define DEBUG_POINTER (0x0020) -#define DEBUG_SCRIPT (0x0040) -#define DEBUG_TINY (0x0080) -#define DEBUG_TIMING (0x0100) -#define DEBUG_NEGO (0x0200) -#define DEBUG_TAGS (0x0400) -#define DEBUG_SCATTER (0x0800) -#define DEBUG_IC (0x1000) - -/* -** Enable/Disable debug messages. -** Can be changed at runtime too. -*/ - -#ifdef SCSI_NCR_DEBUG_INFO_SUPPORT -static int ncr_debug = SCSI_NCR_DEBUG_FLAGS; - #define DEBUG_FLAGS ncr_debug -#else - #define DEBUG_FLAGS SCSI_NCR_DEBUG_FLAGS -#endif - -static inline struct list_head *ncr_list_pop(struct list_head *head) -{ - if (!list_empty(head)) { - struct list_head *elem = head->next; - - list_del(elem); - return elem; - } - - return NULL; -} - -/*========================================================== -** -** Simple power of two buddy-like allocator. -** -** This simple code is not intended to be fast, but to -** provide power of 2 aligned memory allocations. -** Since the SCRIPTS processor only supplies 8 bit -** arithmetic, this allocator allows simple and fast -** address calculations from the SCRIPTS code. -** In addition, cache line alignment is guaranteed for -** power of 2 cache line size. -** Enhanced in linux-2.3.44 to provide a memory pool -** per pcidev to support dynamic dma mapping. (I would -** have preferred a real bus astraction, btw). -** -**========================================================== -*/ - -#define MEMO_SHIFT 4 /* 16 bytes minimum memory chunk */ -#if PAGE_SIZE >= 8192 -#define MEMO_PAGE_ORDER 0 /* 1 PAGE maximum */ -#else -#define MEMO_PAGE_ORDER 1 /* 2 PAGES maximum */ -#endif -#define MEMO_FREE_UNUSED /* Free unused pages immediately */ -#define MEMO_WARN 1 -#define MEMO_GFP_FLAGS GFP_ATOMIC -#define MEMO_CLUSTER_SHIFT (PAGE_SHIFT+MEMO_PAGE_ORDER) -#define MEMO_CLUSTER_SIZE (1UL << MEMO_CLUSTER_SHIFT) -#define MEMO_CLUSTER_MASK (MEMO_CLUSTER_SIZE-1) - -typedef u_long m_addr_t; /* Enough bits to bit-hack addresses */ -typedef struct device *m_bush_t; /* Something that addresses DMAable */ - -typedef struct m_link { /* Link between free memory chunks */ - struct m_link *next; -} m_link_s; - -typedef struct m_vtob { /* Virtual to Bus address translation */ - struct m_vtob *next; - m_addr_t vaddr; - m_addr_t baddr; -} m_vtob_s; -#define VTOB_HASH_SHIFT 5 -#define VTOB_HASH_SIZE (1UL << VTOB_HASH_SHIFT) -#define VTOB_HASH_MASK (VTOB_HASH_SIZE-1) -#define VTOB_HASH_CODE(m) \ - ((((m_addr_t) (m)) >> MEMO_CLUSTER_SHIFT) & VTOB_HASH_MASK) - -typedef struct m_pool { /* Memory pool of a given kind */ - m_bush_t bush; - m_addr_t (*getp)(struct m_pool *); - void (*freep)(struct m_pool *, m_addr_t); - int nump; - m_vtob_s *(vtob[VTOB_HASH_SIZE]); - struct m_pool *next; - struct m_link h[PAGE_SHIFT-MEMO_SHIFT+MEMO_PAGE_ORDER+1]; -} m_pool_s; - -static void *___m_alloc(m_pool_s *mp, int size) -{ - int i = 0; - int s = (1 << MEMO_SHIFT); - int j; - m_addr_t a; - m_link_s *h = mp->h; - - if (size > (PAGE_SIZE << MEMO_PAGE_ORDER)) - return NULL; - - while (size > s) { - s <<= 1; - ++i; - } - - j = i; - while (!h[j].next) { - if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) { - h[j].next = (m_link_s *)mp->getp(mp); - if (h[j].next) - h[j].next->next = NULL; - break; - } - ++j; - s <<= 1; - } - a = (m_addr_t) h[j].next; - if (a) { - h[j].next = h[j].next->next; - while (j > i) { - j -= 1; - s >>= 1; - h[j].next = (m_link_s *) (a+s); - h[j].next->next = NULL; - } - } -#ifdef DEBUG - printk("___m_alloc(%d) = %p\n", size, (void *) a); -#endif - return (void *) a; -} - -static void ___m_free(m_pool_s *mp, void *ptr, int size) -{ - int i = 0; - int s = (1 << MEMO_SHIFT); - m_link_s *q; - m_addr_t a, b; - m_link_s *h = mp->h; - -#ifdef DEBUG - printk("___m_free(%p, %d)\n", ptr, size); -#endif - - if (size > (PAGE_SIZE << MEMO_PAGE_ORDER)) - return; - - while (size > s) { - s <<= 1; - ++i; - } - - a = (m_addr_t) ptr; - - while (1) { -#ifdef MEMO_FREE_UNUSED - if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) { - mp->freep(mp, a); - break; - } -#endif - b = a ^ s; - q = &h[i]; - while (q->next && q->next != (m_link_s *) b) { - q = q->next; - } - if (!q->next) { - ((m_link_s *) a)->next = h[i].next; - h[i].next = (m_link_s *) a; - break; - } - q->next = q->next->next; - a = a & b; - s <<= 1; - ++i; - } -} - -static DEFINE_SPINLOCK(ncr53c8xx_lock); - -static void *__m_calloc2(m_pool_s *mp, int size, char *name, int uflags) -{ - void *p; - - p = ___m_alloc(mp, size); - - if (DEBUG_FLAGS & DEBUG_ALLOC) - printk ("new %-10s[%4d] @%p.\n", name, size, p); - - if (p) - memset(p, 0, size); - else if (uflags & MEMO_WARN) - printk (NAME53C8XX ": failed to allocate %s[%d]\n", name, size); - - return p; -} - -#define __m_calloc(mp, s, n) __m_calloc2(mp, s, n, MEMO_WARN) - -static void __m_free(m_pool_s *mp, void *ptr, int size, char *name) -{ - if (DEBUG_FLAGS & DEBUG_ALLOC) - printk ("freeing %-10s[%4d] @%p.\n", name, size, ptr); - - ___m_free(mp, ptr, size); - -} - -/* - * With pci bus iommu support, we use a default pool of unmapped memory - * for memory we donnot need to DMA from/to and one pool per pcidev for - * memory accessed by the PCI chip. `mp0' is the default not DMAable pool. - */ - -static m_addr_t ___mp0_getp(m_pool_s *mp) -{ - m_addr_t m = __get_free_pages(MEMO_GFP_FLAGS, MEMO_PAGE_ORDER); - if (m) - ++mp->nump; - return m; -} - -static void ___mp0_freep(m_pool_s *mp, m_addr_t m) -{ - free_pages(m, MEMO_PAGE_ORDER); - --mp->nump; -} - -static m_pool_s mp0 = {NULL, ___mp0_getp, ___mp0_freep}; - -/* - * DMAable pools. - */ - -/* - * With pci bus iommu support, we maintain one pool per pcidev and a - * hashed reverse table for virtual to bus physical address translations. - */ -static m_addr_t ___dma_getp(m_pool_s *mp) -{ - m_addr_t vp; - m_vtob_s *vbp; - - vbp = __m_calloc(&mp0, sizeof(*vbp), "VTOB"); - if (vbp) { - dma_addr_t daddr; - vp = (m_addr_t) dma_alloc_coherent(mp->bush, - PAGE_SIZE<vaddr = vp; - vbp->baddr = daddr; - vbp->next = mp->vtob[hc]; - mp->vtob[hc] = vbp; - ++mp->nump; - return vp; - } - } - if (vbp) - __m_free(&mp0, vbp, sizeof(*vbp), "VTOB"); - return 0; -} - -static void ___dma_freep(m_pool_s *mp, m_addr_t m) -{ - m_vtob_s **vbpp, *vbp; - int hc = VTOB_HASH_CODE(m); - - vbpp = &mp->vtob[hc]; - while (*vbpp && (*vbpp)->vaddr != m) - vbpp = &(*vbpp)->next; - if (*vbpp) { - vbp = *vbpp; - *vbpp = (*vbpp)->next; - dma_free_coherent(mp->bush, PAGE_SIZE<vaddr, (dma_addr_t)vbp->baddr); - __m_free(&mp0, vbp, sizeof(*vbp), "VTOB"); - --mp->nump; - } -} - -static inline m_pool_s *___get_dma_pool(m_bush_t bush) -{ - m_pool_s *mp; - for (mp = mp0.next; mp && mp->bush != bush; mp = mp->next); - return mp; -} - -static m_pool_s *___cre_dma_pool(m_bush_t bush) -{ - m_pool_s *mp; - mp = __m_calloc(&mp0, sizeof(*mp), "MPOOL"); - if (mp) { - memset(mp, 0, sizeof(*mp)); - mp->bush = bush; - mp->getp = ___dma_getp; - mp->freep = ___dma_freep; - mp->next = mp0.next; - mp0.next = mp; - } - return mp; -} - -static void ___del_dma_pool(m_pool_s *p) -{ - struct m_pool **pp = &mp0.next; - - while (*pp && *pp != p) - pp = &(*pp)->next; - if (*pp) { - *pp = (*pp)->next; - __m_free(&mp0, p, sizeof(*p), "MPOOL"); - } -} - -static void *__m_calloc_dma(m_bush_t bush, int size, char *name) -{ - u_long flags; - struct m_pool *mp; - void *m = NULL; - - spin_lock_irqsave(&ncr53c8xx_lock, flags); - mp = ___get_dma_pool(bush); - if (!mp) - mp = ___cre_dma_pool(bush); - if (mp) - m = __m_calloc(mp, size, name); - if (mp && !mp->nump) - ___del_dma_pool(mp); - spin_unlock_irqrestore(&ncr53c8xx_lock, flags); - - return m; -} - -static void __m_free_dma(m_bush_t bush, void *m, int size, char *name) -{ - u_long flags; - struct m_pool *mp; - - spin_lock_irqsave(&ncr53c8xx_lock, flags); - mp = ___get_dma_pool(bush); - if (mp) - __m_free(mp, m, size, name); - if (mp && !mp->nump) - ___del_dma_pool(mp); - spin_unlock_irqrestore(&ncr53c8xx_lock, flags); -} - -static m_addr_t __vtobus(m_bush_t bush, void *m) -{ - u_long flags; - m_pool_s *mp; - int hc = VTOB_HASH_CODE(m); - m_vtob_s *vp = NULL; - m_addr_t a = ((m_addr_t) m) & ~MEMO_CLUSTER_MASK; - - spin_lock_irqsave(&ncr53c8xx_lock, flags); - mp = ___get_dma_pool(bush); - if (mp) { - vp = mp->vtob[hc]; - while (vp && (m_addr_t) vp->vaddr != a) - vp = vp->next; - } - spin_unlock_irqrestore(&ncr53c8xx_lock, flags); - return vp ? vp->baddr + (((m_addr_t) m) - a) : 0; -} - -#define _m_calloc_dma(np, s, n) __m_calloc_dma(np->dev, s, n) -#define _m_free_dma(np, p, s, n) __m_free_dma(np->dev, p, s, n) -#define m_calloc_dma(s, n) _m_calloc_dma(np, s, n) -#define m_free_dma(p, s, n) _m_free_dma(np, p, s, n) -#define _vtobus(np, p) __vtobus(np->dev, p) -#define vtobus(p) _vtobus(np, p) - -/* - * Deal with DMA mapping/unmapping. - */ - -/* To keep track of the dma mapping (sg/single) that has been set */ -#define __data_mapped SCp.phase -#define __data_mapping SCp.have_data_in - -static void __unmap_scsi_data(struct device *dev, struct scsi_cmnd *cmd) -{ - switch(cmd->__data_mapped) { - case 2: - dma_unmap_sg(dev, cmd->buffer, cmd->use_sg, - cmd->sc_data_direction); - break; - case 1: - dma_unmap_single(dev, cmd->__data_mapping, - cmd->request_bufflen, - cmd->sc_data_direction); - break; - } - cmd->__data_mapped = 0; -} - -static u_long __map_scsi_single_data(struct device *dev, struct scsi_cmnd *cmd) -{ - dma_addr_t mapping; - - if (cmd->request_bufflen == 0) - return 0; - - mapping = dma_map_single(dev, cmd->request_buffer, - cmd->request_bufflen, - cmd->sc_data_direction); - cmd->__data_mapped = 1; - cmd->__data_mapping = mapping; - - return mapping; -} - -static int __map_scsi_sg_data(struct device *dev, struct scsi_cmnd *cmd) -{ - int use_sg; - - if (cmd->use_sg == 0) - return 0; - - use_sg = dma_map_sg(dev, cmd->buffer, cmd->use_sg, - cmd->sc_data_direction); - cmd->__data_mapped = 2; - cmd->__data_mapping = use_sg; - - return use_sg; -} - -#define unmap_scsi_data(np, cmd) __unmap_scsi_data(np->dev, cmd) -#define map_scsi_single_data(np, cmd) __map_scsi_single_data(np->dev, cmd) -#define map_scsi_sg_data(np, cmd) __map_scsi_sg_data(np->dev, cmd) - -/*========================================================== -** -** Driver setup. -** -** This structure is initialized from linux config -** options. It can be overridden at boot-up by the boot -** command line. -** -**========================================================== -*/ -static struct ncr_driver_setup - driver_setup = SCSI_NCR_DRIVER_SETUP; - -#ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT -static struct ncr_driver_setup - driver_safe_setup __initdata = SCSI_NCR_DRIVER_SAFE_SETUP; -#endif - -#define initverbose (driver_setup.verbose) -#define bootverbose (np->verbose) - - -/*=================================================================== -** -** Driver setup from the boot command line -** -**=================================================================== -*/ - -#ifdef MODULE -#define ARG_SEP ' ' -#else -#define ARG_SEP ',' -#endif - -#define OPT_TAGS 1 -#define OPT_MASTER_PARITY 2 -#define OPT_SCSI_PARITY 3 -#define OPT_DISCONNECTION 4 -#define OPT_SPECIAL_FEATURES 5 -#define OPT_UNUSED_1 6 -#define OPT_FORCE_SYNC_NEGO 7 -#define OPT_REVERSE_PROBE 8 -#define OPT_DEFAULT_SYNC 9 -#define OPT_VERBOSE 10 -#define OPT_DEBUG 11 -#define OPT_BURST_MAX 12 -#define OPT_LED_PIN 13 -#define OPT_MAX_WIDE 14 -#define OPT_SETTLE_DELAY 15 -#define OPT_DIFF_SUPPORT 16 -#define OPT_IRQM 17 -#define OPT_PCI_FIX_UP 18 -#define OPT_BUS_CHECK 19 -#define OPT_OPTIMIZE 20 -#define OPT_RECOVERY 21 -#define OPT_SAFE_SETUP 22 -#define OPT_USE_NVRAM 23 -#define OPT_EXCLUDE 24 -#define OPT_HOST_ID 25 - -#ifdef SCSI_NCR_IARB_SUPPORT -#define OPT_IARB 26 -#endif - -static char setup_token[] __initdata = - "tags:" "mpar:" - "spar:" "disc:" - "specf:" "ultra:" - "fsn:" "revprob:" - "sync:" "verb:" - "debug:" "burst:" - "led:" "wide:" - "settle:" "diff:" - "irqm:" "pcifix:" - "buschk:" "optim:" - "recovery:" - "safe:" "nvram:" - "excl:" "hostid:" -#ifdef SCSI_NCR_IARB_SUPPORT - "iarb:" -#endif - ; /* DONNOT REMOVE THIS ';' */ - -#ifdef MODULE -#define ARG_SEP ' ' -#else -#define ARG_SEP ',' -#endif - -static int __init get_setup_token(char *p) -{ - char *cur = setup_token; - char *pc; - int i = 0; - - while (cur != NULL && (pc = strchr(cur, ':')) != NULL) { - ++pc; - ++i; - if (!strncmp(p, cur, pc - cur)) - return i; - cur = pc; - } - return 0; -} - - -static int __init sym53c8xx__setup(char *str) -{ -#ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT - char *cur = str; - char *pc, *pv; - int i, val, c; - int xi = 0; - - while (cur != NULL && (pc = strchr(cur, ':')) != NULL) { - char *pe; - - val = 0; - pv = pc; - c = *++pv; - - if (c == 'n') - val = 0; - else if (c == 'y') - val = 1; - else - val = (int) simple_strtoul(pv, &pe, 0); - - switch (get_setup_token(cur)) { - case OPT_TAGS: - driver_setup.default_tags = val; - if (pe && *pe == '/') { - i = 0; - while (*pe && *pe != ARG_SEP && - i < sizeof(driver_setup.tag_ctrl)-1) { - driver_setup.tag_ctrl[i++] = *pe++; - } - driver_setup.tag_ctrl[i] = '\0'; - } - break; - case OPT_MASTER_PARITY: - driver_setup.master_parity = val; - break; - case OPT_SCSI_PARITY: - driver_setup.scsi_parity = val; - break; - case OPT_DISCONNECTION: - driver_setup.disconnection = val; - break; - case OPT_SPECIAL_FEATURES: - driver_setup.special_features = val; - break; - case OPT_FORCE_SYNC_NEGO: - driver_setup.force_sync_nego = val; - break; - case OPT_REVERSE_PROBE: - driver_setup.reverse_probe = val; - break; - case OPT_DEFAULT_SYNC: - driver_setup.default_sync = val; - break; - case OPT_VERBOSE: - driver_setup.verbose = val; - break; - case OPT_DEBUG: - driver_setup.debug = val; - break; - case OPT_BURST_MAX: - driver_setup.burst_max = val; - break; - case OPT_LED_PIN: - driver_setup.led_pin = val; - break; - case OPT_MAX_WIDE: - driver_setup.max_wide = val? 1:0; - break; - case OPT_SETTLE_DELAY: - driver_setup.settle_delay = val; - break; - case OPT_DIFF_SUPPORT: - driver_setup.diff_support = val; - break; - case OPT_IRQM: - driver_setup.irqm = val; - break; - case OPT_PCI_FIX_UP: - driver_setup.pci_fix_up = val; - break; - case OPT_BUS_CHECK: - driver_setup.bus_check = val; - break; - case OPT_OPTIMIZE: - driver_setup.optimize = val; - break; - case OPT_RECOVERY: - driver_setup.recovery = val; - break; - case OPT_USE_NVRAM: - driver_setup.use_nvram = val; - break; - case OPT_SAFE_SETUP: - memcpy(&driver_setup, &driver_safe_setup, - sizeof(driver_setup)); - break; - case OPT_EXCLUDE: - if (xi < SCSI_NCR_MAX_EXCLUDES) - driver_setup.excludes[xi++] = val; - break; - case OPT_HOST_ID: - driver_setup.host_id = val; - break; -#ifdef SCSI_NCR_IARB_SUPPORT - case OPT_IARB: - driver_setup.iarb = val; - break; -#endif - default: - printk("sym53c8xx_setup: unexpected boot option '%.*s' ignored\n", (int)(pc-cur+1), cur); - break; - } - - if ((cur = strchr(cur, ARG_SEP)) != NULL) - ++cur; - } -#endif /* SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT */ - return 1; -} - -/*=================================================================== -** -** Get device queue depth from boot command line. -** -**=================================================================== -*/ -#define DEF_DEPTH (driver_setup.default_tags) -#define ALL_TARGETS -2 -#define NO_TARGET -1 -#define ALL_LUNS -2 -#define NO_LUN -1 - -static int device_queue_depth(int unit, int target, int lun) -{ - int c, h, t, u, v; - char *p = driver_setup.tag_ctrl; - char *ep; - - h = -1; - t = NO_TARGET; - u = NO_LUN; - while ((c = *p++) != 0) { - v = simple_strtoul(p, &ep, 0); - switch(c) { - case '/': - ++h; - t = ALL_TARGETS; - u = ALL_LUNS; - break; - case 't': - if (t != target) - t = (target == v) ? v : NO_TARGET; - u = ALL_LUNS; - break; - case 'u': - if (u != lun) - u = (lun == v) ? v : NO_LUN; - break; - case 'q': - if (h == unit && - (t == ALL_TARGETS || t == target) && - (u == ALL_LUNS || u == lun)) - return v; - break; - case '-': - t = ALL_TARGETS; - u = ALL_LUNS; - break; - default: - break; - } - p = ep; - } - return DEF_DEPTH; -} +#include "sym53c8xx_comm.h" /*========================================================== @@ -3703,10 +2971,21 @@ struct host_data { static void ncr_print_msg(struct ccb *cp, char *label, u_char *msg) { + int i; PRINT_ADDR(cp->cmd, "%s: ", label); - spi_print_msg(msg); - printk("\n"); + printk ("%x",*msg); + if (*msg == M_EXTENDED) { + for (i = 1; i < 8; i++) { + if (i - 1 > msg[1]) + break; + printk ("-%x",msg[i]); + } + } else if ((*msg & 0xf0) == 0x20) { + printk ("-%x",msg[1]); + } + + printk(".\n"); } /*========================================================== diff --git a/trunk/drivers/scsi/ncr53c8xx.h b/trunk/drivers/scsi/ncr53c8xx.h index 6a7bef2e6118..05c7b83cef09 100644 --- a/trunk/drivers/scsi/ncr53c8xx.h +++ b/trunk/drivers/scsi/ncr53c8xx.h @@ -2,7 +2,6 @@ ** Device driver for the PCI-SCSI NCR538XX controller family. ** ** Copyright (C) 1994 Wolfgang Stanglmeier -** Copyright (C) 1998-2001 Gerard Roudier ** ** This program is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by @@ -37,1275 +36,15 @@ ** And has been ported to NetBSD by ** Charles M. Hannum ** -** NVRAM detection and reading. -** Copyright (C) 1997 Richard Waltham -** -** Added support for MIPS big endian systems. -** Carsten Langgaard, carstenl@mips.com -** Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. -** -** Added support for HP PARISC big endian systems. -** Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. -** ******************************************************************************* */ #ifndef NCR53C8XX_H #define NCR53C8XX_H -#include #include -/* -** If you want a driver as small as possible, do not define the -** following options. -*/ -#define SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT -#define SCSI_NCR_DEBUG_INFO_SUPPORT - -/* -** To disable integrity checking, do not define the -** following option. -*/ -#ifdef CONFIG_SCSI_NCR53C8XX_INTEGRITY_CHECK -# define SCSI_NCR_ENABLE_INTEGRITY_CHECK -#endif - -/* --------------------------------------------------------------------- -** Take into account kernel configured parameters. -** Most of these options can be overridden at startup by a command line. -** --------------------------------------------------------------------- -*/ - -/* - * For Ultra2 and Ultra3 SCSI support option, use special features. - * - * Value (default) means: - * bit 0 : all features enabled, except: - * bit 1 : PCI Write And Invalidate. - * bit 2 : Data Phase Mismatch handling from SCRIPTS. - * - * Use boot options ncr53c8xx=specf:1 if you want all chip features to be - * enabled by the driver. - */ -#define SCSI_NCR_SETUP_SPECIAL_FEATURES (3) - -#define SCSI_NCR_MAX_SYNC (80) - -/* - * Allow tags from 2 to 256, default 8 - */ -#ifdef CONFIG_SCSI_NCR53C8XX_MAX_TAGS -#if CONFIG_SCSI_NCR53C8XX_MAX_TAGS < 2 -#define SCSI_NCR_MAX_TAGS (2) -#elif CONFIG_SCSI_NCR53C8XX_MAX_TAGS > 256 -#define SCSI_NCR_MAX_TAGS (256) -#else -#define SCSI_NCR_MAX_TAGS CONFIG_SCSI_NCR53C8XX_MAX_TAGS -#endif -#else -#define SCSI_NCR_MAX_TAGS (8) -#endif - -/* - * Allow tagged command queuing support if configured with default number - * of tags set to max (see above). - */ -#ifdef CONFIG_SCSI_NCR53C8XX_DEFAULT_TAGS -#define SCSI_NCR_SETUP_DEFAULT_TAGS CONFIG_SCSI_NCR53C8XX_DEFAULT_TAGS -#elif defined CONFIG_SCSI_NCR53C8XX_TAGGED_QUEUE -#define SCSI_NCR_SETUP_DEFAULT_TAGS SCSI_NCR_MAX_TAGS -#else -#define SCSI_NCR_SETUP_DEFAULT_TAGS (0) -#endif - -/* - * Immediate arbitration - */ -#if defined(CONFIG_SCSI_NCR53C8XX_IARB) -#define SCSI_NCR_IARB_SUPPORT -#endif - -/* - * Sync transfer frequency at startup. - * Allow from 5Mhz to 80Mhz default 20 Mhz. - */ -#ifndef CONFIG_SCSI_NCR53C8XX_SYNC -#define CONFIG_SCSI_NCR53C8XX_SYNC (20) -#elif CONFIG_SCSI_NCR53C8XX_SYNC > SCSI_NCR_MAX_SYNC -#undef CONFIG_SCSI_NCR53C8XX_SYNC -#define CONFIG_SCSI_NCR53C8XX_SYNC SCSI_NCR_MAX_SYNC -#endif - -#if CONFIG_SCSI_NCR53C8XX_SYNC == 0 -#define SCSI_NCR_SETUP_DEFAULT_SYNC (255) -#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 5 -#define SCSI_NCR_SETUP_DEFAULT_SYNC (50) -#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 20 -#define SCSI_NCR_SETUP_DEFAULT_SYNC (250/(CONFIG_SCSI_NCR53C8XX_SYNC)) -#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 33 -#define SCSI_NCR_SETUP_DEFAULT_SYNC (11) -#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 40 -#define SCSI_NCR_SETUP_DEFAULT_SYNC (10) -#else -#define SCSI_NCR_SETUP_DEFAULT_SYNC (9) -#endif - -/* - * Disallow disconnections at boot-up - */ -#ifdef CONFIG_SCSI_NCR53C8XX_NO_DISCONNECT -#define SCSI_NCR_SETUP_DISCONNECTION (0) -#else -#define SCSI_NCR_SETUP_DISCONNECTION (1) -#endif - -/* - * Force synchronous negotiation for all targets - */ -#ifdef CONFIG_SCSI_NCR53C8XX_FORCE_SYNC_NEGO -#define SCSI_NCR_SETUP_FORCE_SYNC_NEGO (1) -#else -#define SCSI_NCR_SETUP_FORCE_SYNC_NEGO (0) -#endif - -/* - * Disable master parity checking (flawed hardwares need that) - */ -#ifdef CONFIG_SCSI_NCR53C8XX_DISABLE_MPARITY_CHECK -#define SCSI_NCR_SETUP_MASTER_PARITY (0) -#else -#define SCSI_NCR_SETUP_MASTER_PARITY (1) -#endif - -/* - * Disable scsi parity checking (flawed devices may need that) - */ -#ifdef CONFIG_SCSI_NCR53C8XX_DISABLE_PARITY_CHECK -#define SCSI_NCR_SETUP_SCSI_PARITY (0) -#else -#define SCSI_NCR_SETUP_SCSI_PARITY (1) -#endif - -/* - * Settle time after reset at boot-up - */ -#define SCSI_NCR_SETUP_SETTLE_TIME (2) - -/* -** Bridge quirks work-around option defaulted to 1. -*/ -#ifndef SCSI_NCR_PCIQ_WORK_AROUND_OPT -#define SCSI_NCR_PCIQ_WORK_AROUND_OPT 1 -#endif - -/* -** Work-around common bridge misbehaviour. -** -** - Do not flush posted writes in the opposite -** direction on read. -** - May reorder DMA writes to memory. -** -** This option should not affect performances -** significantly, so it is the default. -*/ -#if SCSI_NCR_PCIQ_WORK_AROUND_OPT == 1 -#define SCSI_NCR_PCIQ_MAY_NOT_FLUSH_PW_UPSTREAM -#define SCSI_NCR_PCIQ_MAY_REORDER_WRITES -#define SCSI_NCR_PCIQ_MAY_MISS_COMPLETIONS - -/* -** Same as option 1, but also deal with -** misconfigured interrupts. -** -** - Edge triggerred instead of level sensitive. -** - No interrupt line connected. -** - IRQ number misconfigured. -** -** If no interrupt is delivered, the driver will -** catch the interrupt conditions 10 times per -** second. No need to say that this option is -** not recommended. -*/ -#elif SCSI_NCR_PCIQ_WORK_AROUND_OPT == 2 -#define SCSI_NCR_PCIQ_MAY_NOT_FLUSH_PW_UPSTREAM -#define SCSI_NCR_PCIQ_MAY_REORDER_WRITES -#define SCSI_NCR_PCIQ_MAY_MISS_COMPLETIONS -#define SCSI_NCR_PCIQ_BROKEN_INTR - -/* -** Some bridge designers decided to flush -** everything prior to deliver the interrupt. -** This option tries to deal with such a -** behaviour. -*/ -#elif SCSI_NCR_PCIQ_WORK_AROUND_OPT == 3 -#define SCSI_NCR_PCIQ_SYNC_ON_INTR -#endif - -/* -** Other parameters not configurable with "make config" -** Avoid to change these constants, unless you know what you are doing. -*/ - -#define SCSI_NCR_ALWAYS_SIMPLE_TAG -#define SCSI_NCR_MAX_SCATTER (127) -#define SCSI_NCR_MAX_TARGET (16) - -/* -** Compute some desirable value for CAN_QUEUE -** and CMD_PER_LUN. -** The driver will use lower values if these -** ones appear to be too large. -*/ -#define SCSI_NCR_CAN_QUEUE (8*SCSI_NCR_MAX_TAGS + 2*SCSI_NCR_MAX_TARGET) -#define SCSI_NCR_CMD_PER_LUN (SCSI_NCR_MAX_TAGS) - -#define SCSI_NCR_SG_TABLESIZE (SCSI_NCR_MAX_SCATTER) -#define SCSI_NCR_TIMER_INTERVAL (HZ) - -#if 1 /* defined CONFIG_SCSI_MULTI_LUN */ -#define SCSI_NCR_MAX_LUN (16) -#else -#define SCSI_NCR_MAX_LUN (1) -#endif - -/* - * IO functions definition for big/little endian CPU support. - * For now, the NCR is only supported in little endian addressing mode, - */ - -#ifdef __BIG_ENDIAN - -#define inw_l2b inw -#define inl_l2b inl -#define outw_b2l outw -#define outl_b2l outl - -#define readb_raw readb -#define writeb_raw writeb - -#if defined(SCSI_NCR_BIG_ENDIAN) -#define readw_l2b __raw_readw -#define readl_l2b __raw_readl -#define writew_b2l __raw_writew -#define writel_b2l __raw_writel -#define readw_raw __raw_readw -#define readl_raw __raw_readl -#define writew_raw __raw_writew -#define writel_raw __raw_writel -#else /* Other big-endian */ -#define readw_l2b readw -#define readl_l2b readl -#define writew_b2l writew -#define writel_b2l writel -#define readw_raw readw -#define readl_raw readl -#define writew_raw writew -#define writel_raw writel -#endif - -#else /* little endian */ - -#define inw_raw inw -#define inl_raw inl -#define outw_raw outw -#define outl_raw outl - -#define readb_raw readb -#define readw_raw readw -#define readl_raw readl -#define writeb_raw writeb -#define writew_raw writew -#define writel_raw writel - -#endif - -#if !defined(__hppa__) && !defined(__mips__) -#ifdef SCSI_NCR_BIG_ENDIAN -#error "The NCR in BIG ENDIAN addressing mode is not (yet) supported" -#endif -#endif - -#define MEMORY_BARRIER() mb() - - -/* - * If the NCR uses big endian addressing mode over the - * PCI, actual io register addresses for byte and word - * accesses must be changed according to lane routing. - * Btw, ncr_offb() and ncr_offw() macros only apply to - * constants and so donnot generate bloated code. - */ - -#if defined(SCSI_NCR_BIG_ENDIAN) - -#define ncr_offb(o) (((o)&~3)+((~((o)&3))&3)) -#define ncr_offw(o) (((o)&~3)+((~((o)&3))&2)) - -#else - -#define ncr_offb(o) (o) -#define ncr_offw(o) (o) - -#endif - -/* - * If the CPU and the NCR use same endian-ness addressing, - * no byte reordering is needed for script patching. - * Macro cpu_to_scr() is to be used for script patching. - * Macro scr_to_cpu() is to be used for getting a DWORD - * from the script. - */ - -#if defined(__BIG_ENDIAN) && !defined(SCSI_NCR_BIG_ENDIAN) - -#define cpu_to_scr(dw) cpu_to_le32(dw) -#define scr_to_cpu(dw) le32_to_cpu(dw) - -#elif defined(__LITTLE_ENDIAN) && defined(SCSI_NCR_BIG_ENDIAN) - -#define cpu_to_scr(dw) cpu_to_be32(dw) -#define scr_to_cpu(dw) be32_to_cpu(dw) - -#else - -#define cpu_to_scr(dw) (dw) -#define scr_to_cpu(dw) (dw) - -#endif - -/* - * Access to the controller chip. - * - * If the CPU and the NCR use same endian-ness addressing, - * no byte reordering is needed for accessing chip io - * registers. Functions suffixed by '_raw' are assumed - * to access the chip over the PCI without doing byte - * reordering. Functions suffixed by '_l2b' are - * assumed to perform little-endian to big-endian byte - * reordering, those suffixed by '_b2l' blah, blah, - * blah, ... - */ - -/* - * MEMORY mapped IO input / output - */ - -#define INB_OFF(o) readb_raw((char __iomem *)np->reg + ncr_offb(o)) -#define OUTB_OFF(o, val) writeb_raw((val), (char __iomem *)np->reg + ncr_offb(o)) - -#if defined(__BIG_ENDIAN) && !defined(SCSI_NCR_BIG_ENDIAN) - -#define INW_OFF(o) readw_l2b((char __iomem *)np->reg + ncr_offw(o)) -#define INL_OFF(o) readl_l2b((char __iomem *)np->reg + (o)) - -#define OUTW_OFF(o, val) writew_b2l((val), (char __iomem *)np->reg + ncr_offw(o)) -#define OUTL_OFF(o, val) writel_b2l((val), (char __iomem *)np->reg + (o)) - -#elif defined(__LITTLE_ENDIAN) && defined(SCSI_NCR_BIG_ENDIAN) - -#define INW_OFF(o) readw_b2l((char __iomem *)np->reg + ncr_offw(o)) -#define INL_OFF(o) readl_b2l((char __iomem *)np->reg + (o)) - -#define OUTW_OFF(o, val) writew_l2b((val), (char __iomem *)np->reg + ncr_offw(o)) -#define OUTL_OFF(o, val) writel_l2b((val), (char __iomem *)np->reg + (o)) - -#else - -#ifdef CONFIG_SCSI_NCR53C8XX_NO_WORD_TRANSFERS -/* Only 8 or 32 bit transfers allowed */ -#define INW_OFF(o) (readb((char __iomem *)np->reg + ncr_offw(o)) << 8 | readb((char __iomem *)np->reg + ncr_offw(o) + 1)) -#else -#define INW_OFF(o) readw_raw((char __iomem *)np->reg + ncr_offw(o)) -#endif -#define INL_OFF(o) readl_raw((char __iomem *)np->reg + (o)) - -#ifdef CONFIG_SCSI_NCR53C8XX_NO_WORD_TRANSFERS -/* Only 8 or 32 bit transfers allowed */ -#define OUTW_OFF(o, val) do { writeb((char)((val) >> 8), (char __iomem *)np->reg + ncr_offw(o)); writeb((char)(val), (char __iomem *)np->reg + ncr_offw(o) + 1); } while (0) -#else -#define OUTW_OFF(o, val) writew_raw((val), (char __iomem *)np->reg + ncr_offw(o)) -#endif -#define OUTL_OFF(o, val) writel_raw((val), (char __iomem *)np->reg + (o)) - -#endif - -#define INB(r) INB_OFF (offsetof(struct ncr_reg,r)) -#define INW(r) INW_OFF (offsetof(struct ncr_reg,r)) -#define INL(r) INL_OFF (offsetof(struct ncr_reg,r)) - -#define OUTB(r, val) OUTB_OFF (offsetof(struct ncr_reg,r), (val)) -#define OUTW(r, val) OUTW_OFF (offsetof(struct ncr_reg,r), (val)) -#define OUTL(r, val) OUTL_OFF (offsetof(struct ncr_reg,r), (val)) - -/* - * Set bit field ON, OFF - */ - -#define OUTONB(r, m) OUTB(r, INB(r) | (m)) -#define OUTOFFB(r, m) OUTB(r, INB(r) & ~(m)) -#define OUTONW(r, m) OUTW(r, INW(r) | (m)) -#define OUTOFFW(r, m) OUTW(r, INW(r) & ~(m)) -#define OUTONL(r, m) OUTL(r, INL(r) | (m)) -#define OUTOFFL(r, m) OUTL(r, INL(r) & ~(m)) - -/* - * We normally want the chip to have a consistent view - * of driver internal data structures when we restart it. - * Thus these macros. - */ -#define OUTL_DSP(v) \ - do { \ - MEMORY_BARRIER(); \ - OUTL (nc_dsp, (v)); \ - } while (0) - -#define OUTONB_STD() \ - do { \ - MEMORY_BARRIER(); \ - OUTONB (nc_dcntl, (STD|NOCOM)); \ - } while (0) - - -/* -** NCR53C8XX devices features table. -*/ -struct ncr_chip { - unsigned short revision_id; - unsigned char burst_max; /* log-base-2 of max burst */ - unsigned char offset_max; - unsigned char nr_divisor; - unsigned int features; -#define FE_LED0 (1<<0) -#define FE_WIDE (1<<1) /* Wide data transfers */ -#define FE_ULTRA (1<<2) /* Ultra speed 20Mtrans/sec */ -#define FE_DBLR (1<<4) /* Clock doubler present */ -#define FE_QUAD (1<<5) /* Clock quadrupler present */ -#define FE_ERL (1<<6) /* Enable read line */ -#define FE_CLSE (1<<7) /* Cache line size enable */ -#define FE_WRIE (1<<8) /* Write & Invalidate enable */ -#define FE_ERMP (1<<9) /* Enable read multiple */ -#define FE_BOF (1<<10) /* Burst opcode fetch */ -#define FE_DFS (1<<11) /* DMA fifo size */ -#define FE_PFEN (1<<12) /* Prefetch enable */ -#define FE_LDSTR (1<<13) /* Load/Store supported */ -#define FE_RAM (1<<14) /* On chip RAM present */ -#define FE_VARCLK (1<<15) /* SCSI clock may vary */ -#define FE_RAM8K (1<<16) /* On chip RAM sized 8Kb */ -#define FE_64BIT (1<<17) /* Have a 64-bit PCI interface */ -#define FE_IO256 (1<<18) /* Requires full 256 bytes in PCI space */ -#define FE_NOPM (1<<19) /* Scripts handles phase mismatch */ -#define FE_LEDC (1<<20) /* Hardware control of LED */ -#define FE_DIFF (1<<21) /* Support Differential SCSI */ -#define FE_66MHZ (1<<23) /* 66MHz PCI Support */ -#define FE_DAC (1<<24) /* Support DAC cycles (64 bit addressing) */ -#define FE_ISTAT1 (1<<25) /* Have ISTAT1, MBOX0, MBOX1 registers */ -#define FE_DAC_IN_USE (1<<26) /* Platform does DAC cycles */ -#define FE_EHP (1<<27) /* 720: Even host parity */ -#define FE_MUX (1<<28) /* 720: Multiplexed bus */ -#define FE_EA (1<<29) /* 720: Enable Ack */ - -#define FE_CACHE_SET (FE_ERL|FE_CLSE|FE_WRIE|FE_ERMP) -#define FE_SCSI_SET (FE_WIDE|FE_ULTRA|FE_DBLR|FE_QUAD|F_CLK80) -#define FE_SPECIAL_SET (FE_CACHE_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM) -}; - - -/* -** Driver setup structure. -** -** This structure is initialized from linux config options. -** It can be overridden at boot-up by the boot command line. -*/ -#define SCSI_NCR_MAX_EXCLUDES 8 -struct ncr_driver_setup { - u8 master_parity; - u8 scsi_parity; - u8 disconnection; - u8 special_features; - u8 force_sync_nego; - u8 reverse_probe; - u8 pci_fix_up; - u8 use_nvram; - u8 verbose; - u8 default_tags; - u16 default_sync; - u16 debug; - u8 burst_max; - u8 led_pin; - u8 max_wide; - u8 settle_delay; - u8 diff_support; - u8 irqm; - u8 bus_check; - u8 optimize; - u8 recovery; - u8 host_id; - u16 iarb; - u32 excludes[SCSI_NCR_MAX_EXCLUDES]; - char tag_ctrl[100]; -}; - -/* -** Initial setup. -** Can be overriden at startup by a command line. -*/ -#define SCSI_NCR_DRIVER_SETUP \ -{ \ - SCSI_NCR_SETUP_MASTER_PARITY, \ - SCSI_NCR_SETUP_SCSI_PARITY, \ - SCSI_NCR_SETUP_DISCONNECTION, \ - SCSI_NCR_SETUP_SPECIAL_FEATURES, \ - SCSI_NCR_SETUP_FORCE_SYNC_NEGO, \ - 0, \ - 0, \ - 1, \ - 0, \ - SCSI_NCR_SETUP_DEFAULT_TAGS, \ - SCSI_NCR_SETUP_DEFAULT_SYNC, \ - 0x00, \ - 7, \ - 0, \ - 1, \ - SCSI_NCR_SETUP_SETTLE_TIME, \ - 0, \ - 0, \ - 1, \ - 0, \ - 0, \ - 255, \ - 0x00 \ -} - -/* -** Boot fail safe setup. -** Override initial setup from boot command line: -** ncr53c8xx=safe:y -*/ -#define SCSI_NCR_DRIVER_SAFE_SETUP \ -{ \ - 0, \ - 1, \ - 0, \ - 0, \ - 0, \ - 0, \ - 0, \ - 1, \ - 2, \ - 0, \ - 255, \ - 0x00, \ - 255, \ - 0, \ - 0, \ - 10, \ - 1, \ - 1, \ - 1, \ - 0, \ - 0, \ - 255 \ -} - -/**************** ORIGINAL CONTENT of ncrreg.h from FreeBSD ******************/ - -/*----------------------------------------------------------------- -** -** The ncr 53c810 register structure. -** -**----------------------------------------------------------------- -*/ - -struct ncr_reg { -/*00*/ u8 nc_scntl0; /* full arb., ena parity, par->ATN */ - -/*01*/ u8 nc_scntl1; /* no reset */ - #define ISCON 0x10 /* connected to scsi */ - #define CRST 0x08 /* force reset */ - #define IARB 0x02 /* immediate arbitration */ - -/*02*/ u8 nc_scntl2; /* no disconnect expected */ - #define SDU 0x80 /* cmd: disconnect will raise error */ - #define CHM 0x40 /* sta: chained mode */ - #define WSS 0x08 /* sta: wide scsi send [W]*/ - #define WSR 0x01 /* sta: wide scsi received [W]*/ - -/*03*/ u8 nc_scntl3; /* cnf system clock dependent */ - #define EWS 0x08 /* cmd: enable wide scsi [W]*/ - #define ULTRA 0x80 /* cmd: ULTRA enable */ - /* bits 0-2, 7 rsvd for C1010 */ - -/*04*/ u8 nc_scid; /* cnf host adapter scsi address */ - #define RRE 0x40 /* r/w:e enable response to resel. */ - #define SRE 0x20 /* r/w:e enable response to select */ - -/*05*/ u8 nc_sxfer; /* ### Sync speed and count */ - /* bits 6-7 rsvd for C1010 */ - -/*06*/ u8 nc_sdid; /* ### Destination-ID */ - -/*07*/ u8 nc_gpreg; /* ??? IO-Pins */ - -/*08*/ u8 nc_sfbr; /* ### First byte in phase */ - -/*09*/ u8 nc_socl; - #define CREQ 0x80 /* r/w: SCSI-REQ */ - #define CACK 0x40 /* r/w: SCSI-ACK */ - #define CBSY 0x20 /* r/w: SCSI-BSY */ - #define CSEL 0x10 /* r/w: SCSI-SEL */ - #define CATN 0x08 /* r/w: SCSI-ATN */ - #define CMSG 0x04 /* r/w: SCSI-MSG */ - #define CC_D 0x02 /* r/w: SCSI-C_D */ - #define CI_O 0x01 /* r/w: SCSI-I_O */ - -/*0a*/ u8 nc_ssid; - -/*0b*/ u8 nc_sbcl; - -/*0c*/ u8 nc_dstat; - #define DFE 0x80 /* sta: dma fifo empty */ - #define MDPE 0x40 /* int: master data parity error */ - #define BF 0x20 /* int: script: bus fault */ - #define ABRT 0x10 /* int: script: command aborted */ - #define SSI 0x08 /* int: script: single step */ - #define SIR 0x04 /* int: script: interrupt instruct. */ - #define IID 0x01 /* int: script: illegal instruct. */ - -/*0d*/ u8 nc_sstat0; - #define ILF 0x80 /* sta: data in SIDL register lsb */ - #define ORF 0x40 /* sta: data in SODR register lsb */ - #define OLF 0x20 /* sta: data in SODL register lsb */ - #define AIP 0x10 /* sta: arbitration in progress */ - #define LOA 0x08 /* sta: arbitration lost */ - #define WOA 0x04 /* sta: arbitration won */ - #define IRST 0x02 /* sta: scsi reset signal */ - #define SDP 0x01 /* sta: scsi parity signal */ - -/*0e*/ u8 nc_sstat1; - #define FF3210 0xf0 /* sta: bytes in the scsi fifo */ - -/*0f*/ u8 nc_sstat2; - #define ILF1 0x80 /* sta: data in SIDL register msb[W]*/ - #define ORF1 0x40 /* sta: data in SODR register msb[W]*/ - #define OLF1 0x20 /* sta: data in SODL register msb[W]*/ - #define DM 0x04 /* sta: DIFFSENS mismatch (895/6 only) */ - #define LDSC 0x02 /* sta: disconnect & reconnect */ - -/*10*/ u8 nc_dsa; /* --> Base page */ -/*11*/ u8 nc_dsa1; -/*12*/ u8 nc_dsa2; -/*13*/ u8 nc_dsa3; - -/*14*/ u8 nc_istat; /* --> Main Command and status */ - #define CABRT 0x80 /* cmd: abort current operation */ - #define SRST 0x40 /* mod: reset chip */ - #define SIGP 0x20 /* r/w: message from host to ncr */ - #define SEM 0x10 /* r/w: message between host + ncr */ - #define CON 0x08 /* sta: connected to scsi */ - #define INTF 0x04 /* sta: int on the fly (reset by wr)*/ - #define SIP 0x02 /* sta: scsi-interrupt */ - #define DIP 0x01 /* sta: host/script interrupt */ - -/*15*/ u8 nc_istat1; /* 896 and later cores only */ - #define FLSH 0x04 /* sta: chip is flushing */ - #define SRUN 0x02 /* sta: scripts are running */ - #define SIRQD 0x01 /* r/w: disable INT pin */ - -/*16*/ u8 nc_mbox0; /* 896 and later cores only */ -/*17*/ u8 nc_mbox1; /* 896 and later cores only */ - -/*18*/ u8 nc_ctest0; - #define EHP 0x04 /* 720 even host parity */ -/*19*/ u8 nc_ctest1; - -/*1a*/ u8 nc_ctest2; - #define CSIGP 0x40 - /* bits 0-2,7 rsvd for C1010 */ - -/*1b*/ u8 nc_ctest3; - #define FLF 0x08 /* cmd: flush dma fifo */ - #define CLF 0x04 /* cmd: clear dma fifo */ - #define FM 0x02 /* mod: fetch pin mode */ - #define WRIE 0x01 /* mod: write and invalidate enable */ - /* bits 4-7 rsvd for C1010 */ - -/*1c*/ u32 nc_temp; /* ### Temporary stack */ - -/*20*/ u8 nc_dfifo; -/*21*/ u8 nc_ctest4; - #define MUX 0x80 /* 720 host bus multiplex mode */ - #define BDIS 0x80 /* mod: burst disable */ - #define MPEE 0x08 /* mod: master parity error enable */ - -/*22*/ u8 nc_ctest5; - #define DFS 0x20 /* mod: dma fifo size */ - /* bits 0-1, 3-7 rsvd for C1010 */ -/*23*/ u8 nc_ctest6; - -/*24*/ u32 nc_dbc; /* ### Byte count and command */ -/*28*/ u32 nc_dnad; /* ### Next command register */ -/*2c*/ u32 nc_dsp; /* --> Script Pointer */ -/*30*/ u32 nc_dsps; /* --> Script pointer save/opcode#2 */ - -/*34*/ u8 nc_scratcha; /* Temporary register a */ -/*35*/ u8 nc_scratcha1; -/*36*/ u8 nc_scratcha2; -/*37*/ u8 nc_scratcha3; - -/*38*/ u8 nc_dmode; - #define BL_2 0x80 /* mod: burst length shift value +2 */ - #define BL_1 0x40 /* mod: burst length shift value +1 */ - #define ERL 0x08 /* mod: enable read line */ - #define ERMP 0x04 /* mod: enable read multiple */ - #define BOF 0x02 /* mod: burst op code fetch */ - -/*39*/ u8 nc_dien; -/*3a*/ u8 nc_sbr; - -/*3b*/ u8 nc_dcntl; /* --> Script execution control */ - #define CLSE 0x80 /* mod: cache line size enable */ - #define PFF 0x40 /* cmd: pre-fetch flush */ - #define PFEN 0x20 /* mod: pre-fetch enable */ - #define EA 0x20 /* mod: 720 enable-ack */ - #define SSM 0x10 /* mod: single step mode */ - #define IRQM 0x08 /* mod: irq mode (1 = totem pole !) */ - #define STD 0x04 /* cmd: start dma mode */ - #define IRQD 0x02 /* mod: irq disable */ - #define NOCOM 0x01 /* cmd: protect sfbr while reselect */ - /* bits 0-1 rsvd for C1010 */ - -/*3c*/ u32 nc_adder; - -/*40*/ u16 nc_sien; /* -->: interrupt enable */ -/*42*/ u16 nc_sist; /* <--: interrupt status */ - #define SBMC 0x1000/* sta: SCSI Bus Mode Change (895/6 only) */ - #define STO 0x0400/* sta: timeout (select) */ - #define GEN 0x0200/* sta: timeout (general) */ - #define HTH 0x0100/* sta: timeout (handshake) */ - #define MA 0x80 /* sta: phase mismatch */ - #define CMP 0x40 /* sta: arbitration complete */ - #define SEL 0x20 /* sta: selected by another device */ - #define RSL 0x10 /* sta: reselected by another device*/ - #define SGE 0x08 /* sta: gross error (over/underflow)*/ - #define UDC 0x04 /* sta: unexpected disconnect */ - #define RST 0x02 /* sta: scsi bus reset detected */ - #define PAR 0x01 /* sta: scsi parity error */ - -/*44*/ u8 nc_slpar; -/*45*/ u8 nc_swide; -/*46*/ u8 nc_macntl; -/*47*/ u8 nc_gpcntl; -/*48*/ u8 nc_stime0; /* cmd: timeout for select&handshake*/ -/*49*/ u8 nc_stime1; /* cmd: timeout user defined */ -/*4a*/ u16 nc_respid; /* sta: Reselect-IDs */ - -/*4c*/ u8 nc_stest0; - -/*4d*/ u8 nc_stest1; - #define SCLK 0x80 /* Use the PCI clock as SCSI clock */ - #define DBLEN 0x08 /* clock doubler running */ - #define DBLSEL 0x04 /* clock doubler selected */ - - -/*4e*/ u8 nc_stest2; - #define ROF 0x40 /* reset scsi offset (after gross error!) */ - #define DIF 0x20 /* 720 SCSI differential mode */ - #define EXT 0x02 /* extended filtering */ - -/*4f*/ u8 nc_stest3; - #define TE 0x80 /* c: tolerAnt enable */ - #define HSC 0x20 /* c: Halt SCSI Clock */ - #define CSF 0x02 /* c: clear scsi fifo */ - -/*50*/ u16 nc_sidl; /* Lowlevel: latched from scsi data */ -/*52*/ u8 nc_stest4; - #define SMODE 0xc0 /* SCSI bus mode (895/6 only) */ - #define SMODE_HVD 0x40 /* High Voltage Differential */ - #define SMODE_SE 0x80 /* Single Ended */ - #define SMODE_LVD 0xc0 /* Low Voltage Differential */ - #define LCKFRQ 0x20 /* Frequency Lock (895/6 only) */ - /* bits 0-5 rsvd for C1010 */ - -/*53*/ u8 nc_53_; -/*54*/ u16 nc_sodl; /* Lowlevel: data out to scsi data */ -/*56*/ u8 nc_ccntl0; /* Chip Control 0 (896) */ - #define ENPMJ 0x80 /* Enable Phase Mismatch Jump */ - #define PMJCTL 0x40 /* Phase Mismatch Jump Control */ - #define ENNDJ 0x20 /* Enable Non Data PM Jump */ - #define DISFC 0x10 /* Disable Auto FIFO Clear */ - #define DILS 0x02 /* Disable Internal Load/Store */ - #define DPR 0x01 /* Disable Pipe Req */ - -/*57*/ u8 nc_ccntl1; /* Chip Control 1 (896) */ - #define ZMOD 0x80 /* High Impedance Mode */ - #define DIC 0x10 /* Disable Internal Cycles */ - #define DDAC 0x08 /* Disable Dual Address Cycle */ - #define XTIMOD 0x04 /* 64-bit Table Ind. Indexing Mode */ - #define EXTIBMV 0x02 /* Enable 64-bit Table Ind. BMOV */ - #define EXDBMV 0x01 /* Enable 64-bit Direct BMOV */ - -/*58*/ u16 nc_sbdl; /* Lowlevel: data from scsi data */ -/*5a*/ u16 nc_5a_; - -/*5c*/ u8 nc_scr0; /* Working register B */ -/*5d*/ u8 nc_scr1; /* */ -/*5e*/ u8 nc_scr2; /* */ -/*5f*/ u8 nc_scr3; /* */ - -/*60*/ u8 nc_scrx[64]; /* Working register C-R */ -/*a0*/ u32 nc_mmrs; /* Memory Move Read Selector */ -/*a4*/ u32 nc_mmws; /* Memory Move Write Selector */ -/*a8*/ u32 nc_sfs; /* Script Fetch Selector */ -/*ac*/ u32 nc_drs; /* DSA Relative Selector */ -/*b0*/ u32 nc_sbms; /* Static Block Move Selector */ -/*b4*/ u32 nc_dbms; /* Dynamic Block Move Selector */ -/*b8*/ u32 nc_dnad64; /* DMA Next Address 64 */ -/*bc*/ u16 nc_scntl4; /* C1010 only */ - #define U3EN 0x80 /* Enable Ultra 3 */ - #define AIPEN 0x40 /* Allow check upper byte lanes */ - #define XCLKH_DT 0x08 /* Extra clock of data hold on DT - transfer edge */ - #define XCLKH_ST 0x04 /* Extra clock of data hold on ST - transfer edge */ - -/*be*/ u8 nc_aipcntl0; /* Epat Control 1 C1010 only */ -/*bf*/ u8 nc_aipcntl1; /* AIP Control C1010_66 Only */ - -/*c0*/ u32 nc_pmjad1; /* Phase Mismatch Jump Address 1 */ -/*c4*/ u32 nc_pmjad2; /* Phase Mismatch Jump Address 2 */ -/*c8*/ u8 nc_rbc; /* Remaining Byte Count */ -/*c9*/ u8 nc_rbc1; /* */ -/*ca*/ u8 nc_rbc2; /* */ -/*cb*/ u8 nc_rbc3; /* */ - -/*cc*/ u8 nc_ua; /* Updated Address */ -/*cd*/ u8 nc_ua1; /* */ -/*ce*/ u8 nc_ua2; /* */ -/*cf*/ u8 nc_ua3; /* */ -/*d0*/ u32 nc_esa; /* Entry Storage Address */ -/*d4*/ u8 nc_ia; /* Instruction Address */ -/*d5*/ u8 nc_ia1; -/*d6*/ u8 nc_ia2; -/*d7*/ u8 nc_ia3; -/*d8*/ u32 nc_sbc; /* SCSI Byte Count (3 bytes only) */ -/*dc*/ u32 nc_csbc; /* Cumulative SCSI Byte Count */ - - /* Following for C1010 only */ -/*e0*/ u16 nc_crcpad; /* CRC Value */ -/*e2*/ u8 nc_crccntl0; /* CRC control register */ - #define SNDCRC 0x10 /* Send CRC Request */ -/*e3*/ u8 nc_crccntl1; /* CRC control register */ -/*e4*/ u32 nc_crcdata; /* CRC data register */ -/*e8*/ u32 nc_e8_; /* rsvd */ -/*ec*/ u32 nc_ec_; /* rsvd */ -/*f0*/ u16 nc_dfbc; /* DMA FIFO byte count */ - -}; - -/*----------------------------------------------------------- -** -** Utility macros for the script. -** -**----------------------------------------------------------- -*/ - -#define REGJ(p,r) (offsetof(struct ncr_reg, p ## r)) -#define REG(r) REGJ (nc_, r) - -typedef u32 ncrcmd; - -/*----------------------------------------------------------- -** -** SCSI phases -** -** DT phases illegal for ncr driver. -** -**----------------------------------------------------------- -*/ - -#define SCR_DATA_OUT 0x00000000 -#define SCR_DATA_IN 0x01000000 -#define SCR_COMMAND 0x02000000 -#define SCR_STATUS 0x03000000 -#define SCR_DT_DATA_OUT 0x04000000 -#define SCR_DT_DATA_IN 0x05000000 -#define SCR_MSG_OUT 0x06000000 -#define SCR_MSG_IN 0x07000000 - -#define SCR_ILG_OUT 0x04000000 -#define SCR_ILG_IN 0x05000000 - -/*----------------------------------------------------------- -** -** Data transfer via SCSI. -** -**----------------------------------------------------------- -** -** MOVE_ABS (LEN) -** <> -** -** MOVE_IND (LEN) -** <> -** -** MOVE_TBL -** <> -** -**----------------------------------------------------------- -*/ - -#define OPC_MOVE 0x08000000 - -#define SCR_MOVE_ABS(l) ((0x00000000 | OPC_MOVE) | (l)) -#define SCR_MOVE_IND(l) ((0x20000000 | OPC_MOVE) | (l)) -#define SCR_MOVE_TBL (0x10000000 | OPC_MOVE) - -#define SCR_CHMOV_ABS(l) ((0x00000000) | (l)) -#define SCR_CHMOV_IND(l) ((0x20000000) | (l)) -#define SCR_CHMOV_TBL (0x10000000) - -struct scr_tblmove { - u32 size; - u32 addr; -}; - -/*----------------------------------------------------------- -** -** Selection -** -**----------------------------------------------------------- -** -** SEL_ABS | SCR_ID (0..15) [ | REL_JMP] -** <> -** -** SEL_TBL | << dnad_offset>> [ | REL_JMP] -** <> -** -**----------------------------------------------------------- -*/ - -#define SCR_SEL_ABS 0x40000000 -#define SCR_SEL_ABS_ATN 0x41000000 -#define SCR_SEL_TBL 0x42000000 -#define SCR_SEL_TBL_ATN 0x43000000 - - -#ifdef SCSI_NCR_BIG_ENDIAN -struct scr_tblsel { - u8 sel_scntl3; - u8 sel_id; - u8 sel_sxfer; - u8 sel_scntl4; -}; -#else -struct scr_tblsel { - u8 sel_scntl4; - u8 sel_sxfer; - u8 sel_id; - u8 sel_scntl3; -}; -#endif - -#define SCR_JMP_REL 0x04000000 -#define SCR_ID(id) (((u32)(id)) << 16) - -/*----------------------------------------------------------- -** -** Waiting for Disconnect or Reselect -** -**----------------------------------------------------------- -** -** WAIT_DISC -** dummy: <> -** -** WAIT_RESEL -** <> -** -**----------------------------------------------------------- -*/ - -#define SCR_WAIT_DISC 0x48000000 -#define SCR_WAIT_RESEL 0x50000000 - -/*----------------------------------------------------------- -** -** Bit Set / Reset -** -**----------------------------------------------------------- -** -** SET (flags {|.. }) -** -** CLR (flags {|.. }) -** -**----------------------------------------------------------- -*/ - -#define SCR_SET(f) (0x58000000 | (f)) -#define SCR_CLR(f) (0x60000000 | (f)) - -#define SCR_CARRY 0x00000400 -#define SCR_TRG 0x00000200 -#define SCR_ACK 0x00000040 -#define SCR_ATN 0x00000008 - - - - -/*----------------------------------------------------------- -** -** Memory to memory move -** -**----------------------------------------------------------- -** -** COPY (bytecount) -** << source_address >> -** << destination_address >> -** -** SCR_COPY sets the NO FLUSH option by default. -** SCR_COPY_F does not set this option. -** -** For chips which do not support this option, -** ncr_copy_and_bind() will remove this bit. -**----------------------------------------------------------- -*/ - -#define SCR_NO_FLUSH 0x01000000 - -#define SCR_COPY(n) (0xc0000000 | SCR_NO_FLUSH | (n)) -#define SCR_COPY_F(n) (0xc0000000 | (n)) - -/*----------------------------------------------------------- -** -** Register move and binary operations -** -**----------------------------------------------------------- -** -** SFBR_REG (reg, op, data) reg = SFBR op data -** << 0 >> -** -** REG_SFBR (reg, op, data) SFBR = reg op data -** << 0 >> -** -** REG_REG (reg, op, data) reg = reg op data -** << 0 >> -** -**----------------------------------------------------------- -** On 810A, 860, 825A, 875, 895 and 896 chips the content -** of SFBR register can be used as data (SCR_SFBR_DATA). -** The 896 has additionnal IO registers starting at -** offset 0x80. Bit 7 of register offset is stored in -** bit 7 of the SCRIPTS instruction first DWORD. -**----------------------------------------------------------- -*/ - -#define SCR_REG_OFS(ofs) ((((ofs) & 0x7f) << 16ul) + ((ofs) & 0x80)) - -#define SCR_SFBR_REG(reg,op,data) \ - (0x68000000 | (SCR_REG_OFS(REG(reg))) | (op) | (((data)&0xff)<<8ul)) - -#define SCR_REG_SFBR(reg,op,data) \ - (0x70000000 | (SCR_REG_OFS(REG(reg))) | (op) | (((data)&0xff)<<8ul)) - -#define SCR_REG_REG(reg,op,data) \ - (0x78000000 | (SCR_REG_OFS(REG(reg))) | (op) | (((data)&0xff)<<8ul)) - - -#define SCR_LOAD 0x00000000 -#define SCR_SHL 0x01000000 -#define SCR_OR 0x02000000 -#define SCR_XOR 0x03000000 -#define SCR_AND 0x04000000 -#define SCR_SHR 0x05000000 -#define SCR_ADD 0x06000000 -#define SCR_ADDC 0x07000000 - -#define SCR_SFBR_DATA (0x00800000>>8ul) /* Use SFBR as data */ - -/*----------------------------------------------------------- -** -** FROM_REG (reg) SFBR = reg -** << 0 >> -** -** TO_REG (reg) reg = SFBR -** << 0 >> -** -** LOAD_REG (reg, data) reg = -** << 0 >> -** -** LOAD_SFBR(data) SFBR = -** << 0 >> -** -**----------------------------------------------------------- -*/ - -#define SCR_FROM_REG(reg) \ - SCR_REG_SFBR(reg,SCR_OR,0) - -#define SCR_TO_REG(reg) \ - SCR_SFBR_REG(reg,SCR_OR,0) - -#define SCR_LOAD_REG(reg,data) \ - SCR_REG_REG(reg,SCR_LOAD,data) - -#define SCR_LOAD_SFBR(data) \ - (SCR_REG_SFBR (gpreg, SCR_LOAD, data)) - -/*----------------------------------------------------------- -** -** LOAD from memory to register. -** STORE from register to memory. -** -** Only supported by 810A, 860, 825A, 875, 895 and 896. -** -**----------------------------------------------------------- -** -** LOAD_ABS (LEN) -** <> -** -** LOAD_REL (LEN) (DSA relative) -** <> -** -**----------------------------------------------------------- -*/ - -#define SCR_REG_OFS2(ofs) (((ofs) & 0xff) << 16ul) -#define SCR_NO_FLUSH2 0x02000000 -#define SCR_DSA_REL2 0x10000000 - -#define SCR_LOAD_R(reg, how, n) \ - (0xe1000000 | how | (SCR_REG_OFS2(REG(reg))) | (n)) - -#define SCR_STORE_R(reg, how, n) \ - (0xe0000000 | how | (SCR_REG_OFS2(REG(reg))) | (n)) - -#define SCR_LOAD_ABS(reg, n) SCR_LOAD_R(reg, SCR_NO_FLUSH2, n) -#define SCR_LOAD_REL(reg, n) SCR_LOAD_R(reg, SCR_NO_FLUSH2|SCR_DSA_REL2, n) -#define SCR_LOAD_ABS_F(reg, n) SCR_LOAD_R(reg, 0, n) -#define SCR_LOAD_REL_F(reg, n) SCR_LOAD_R(reg, SCR_DSA_REL2, n) - -#define SCR_STORE_ABS(reg, n) SCR_STORE_R(reg, SCR_NO_FLUSH2, n) -#define SCR_STORE_REL(reg, n) SCR_STORE_R(reg, SCR_NO_FLUSH2|SCR_DSA_REL2,n) -#define SCR_STORE_ABS_F(reg, n) SCR_STORE_R(reg, 0, n) -#define SCR_STORE_REL_F(reg, n) SCR_STORE_R(reg, SCR_DSA_REL2, n) - - -/*----------------------------------------------------------- -** -** Waiting for Disconnect or Reselect -** -**----------------------------------------------------------- -** -** JUMP [ | IFTRUE/IFFALSE ( ... ) ] -** <
> -** -** JUMPR [ | IFTRUE/IFFALSE ( ... ) ] -** <> -** -** CALL [ | IFTRUE/IFFALSE ( ... ) ] -** <
> -** -** CALLR [ | IFTRUE/IFFALSE ( ... ) ] -** <> -** -** RETURN [ | IFTRUE/IFFALSE ( ... ) ] -** <> -** -** INT [ | IFTRUE/IFFALSE ( ... ) ] -** <> -** -** INT_FLY [ | IFTRUE/IFFALSE ( ... ) ] -** <> -** -** Conditions: -** WHEN (phase) -** IF (phase) -** CARRYSET -** DATA (data, mask) -** -**----------------------------------------------------------- -*/ - -#define SCR_NO_OP 0x80000000 -#define SCR_JUMP 0x80080000 -#define SCR_JUMP64 0x80480000 -#define SCR_JUMPR 0x80880000 -#define SCR_CALL 0x88080000 -#define SCR_CALLR 0x88880000 -#define SCR_RETURN 0x90080000 -#define SCR_INT 0x98080000 -#define SCR_INT_FLY 0x98180000 - -#define IFFALSE(arg) (0x00080000 | (arg)) -#define IFTRUE(arg) (0x00000000 | (arg)) - -#define WHEN(phase) (0x00030000 | (phase)) -#define IF(phase) (0x00020000 | (phase)) - -#define DATA(D) (0x00040000 | ((D) & 0xff)) -#define MASK(D,M) (0x00040000 | (((M ^ 0xff) & 0xff) << 8ul)|((D) & 0xff)) - -#define CARRYSET (0x00200000) - -/*----------------------------------------------------------- -** -** SCSI constants. -** -**----------------------------------------------------------- -*/ - -/* -** Messages -*/ - -#define M_COMPLETE COMMAND_COMPLETE -#define M_EXTENDED EXTENDED_MESSAGE -#define M_SAVE_DP SAVE_POINTERS -#define M_RESTORE_DP RESTORE_POINTERS -#define M_DISCONNECT DISCONNECT -#define M_ID_ERROR INITIATOR_ERROR -#define M_ABORT ABORT_TASK_SET -#define M_REJECT MESSAGE_REJECT -#define M_NOOP NOP -#define M_PARITY MSG_PARITY_ERROR -#define M_LCOMPLETE LINKED_CMD_COMPLETE -#define M_FCOMPLETE LINKED_FLG_CMD_COMPLETE -#define M_RESET TARGET_RESET -#define M_ABORT_TAG ABORT_TASK -#define M_CLEAR_QUEUE CLEAR_TASK_SET -#define M_INIT_REC INITIATE_RECOVERY -#define M_REL_REC RELEASE_RECOVERY -#define M_TERMINATE (0x11) -#define M_SIMPLE_TAG SIMPLE_QUEUE_TAG -#define M_HEAD_TAG HEAD_OF_QUEUE_TAG -#define M_ORDERED_TAG ORDERED_QUEUE_TAG -#define M_IGN_RESIDUE IGNORE_WIDE_RESIDUE -#define M_IDENTIFY (0x80) - -#define M_X_MODIFY_DP EXTENDED_MODIFY_DATA_POINTER -#define M_X_SYNC_REQ EXTENDED_SDTR -#define M_X_WIDE_REQ EXTENDED_WDTR -#define M_X_PPR_REQ EXTENDED_PPR - -/* -** Status -*/ - -#define S_GOOD (0x00) -#define S_CHECK_COND (0x02) -#define S_COND_MET (0x04) -#define S_BUSY (0x08) -#define S_INT (0x10) -#define S_INT_COND_MET (0x14) -#define S_CONFLICT (0x18) -#define S_TERMINATED (0x20) -#define S_QUEUE_FULL (0x28) -#define S_ILLEGAL (0xff) -#define S_SENSE (0x80) - -/* - * End of ncrreg from FreeBSD - */ +#include "sym53c8xx_defs.h" /* Build a scatter/gather entry. diff --git a/trunk/drivers/scsi/pcmcia/aha152x_stub.c b/trunk/drivers/scsi/pcmcia/aha152x_stub.c index 0c9edb7051f4..7c5306499832 100644 --- a/trunk/drivers/scsi/pcmcia/aha152x_stub.c +++ b/trunk/drivers/scsi/pcmcia/aha152x_stub.c @@ -95,21 +95,27 @@ typedef struct scsi_info_t { } scsi_info_t; static void aha152x_release_cs(dev_link_t *link); -static void aha152x_detach(struct pcmcia_device *p_dev); -static void aha152x_config_cs(dev_link_t *link); +static int aha152x_event(event_t event, int priority, + event_callback_args_t *args); + +static dev_link_t *aha152x_attach(void); +static void aha152x_detach(dev_link_t *); static dev_link_t *dev_list; +static dev_info_t dev_info = "aha152x_cs"; -static int aha152x_attach(struct pcmcia_device *p_dev) +static dev_link_t *aha152x_attach(void) { scsi_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; DEBUG(0, "aha152x_attach()\n"); /* Create new SCSI device */ info = kmalloc(sizeof(*info), GFP_KERNEL); - if (!info) return -ENOMEM; + if (!info) return NULL; memset(info, 0, sizeof(*info)); link = &info->link; link->priv = info; @@ -123,20 +129,26 @@ static int aha152x_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; link->conf.Present = PRESENT_OPTION; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - aha152x_config_cs(link); - - return 0; + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + aha152x_detach(link); + return NULL; + } + + return link; } /* aha152x_attach */ /*====================================================================*/ -static void aha152x_detach(struct pcmcia_device *p_dev) +static void aha152x_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); dev_link_t **linkp; DEBUG(0, "aha152x_detach(0x%p)\n", link); @@ -150,6 +162,9 @@ static void aha152x_detach(struct pcmcia_device *p_dev) if (link->state & DEV_CONFIG) aha152x_release_cs(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + /* Unlink device structure, free bits */ *linkp = link->next; kfree(link->priv); @@ -257,31 +272,44 @@ static void aha152x_release_cs(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int aha152x_suspend(struct pcmcia_device *dev) +static int aha152x_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); - + dev_link_t *link = args->client_data; + scsi_info_t *info = link->priv; + + DEBUG(0, "aha152x_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + aha152x_release_cs(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + aha152x_config_cs(link); + break; + case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int aha152x_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - scsi_info_t *info = link->priv; - + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - Scsi_Cmnd tmp; - pcmcia_request_configuration(link->handle, &link->conf); - tmp.device->host = info->host; - aha152x_host_reset(&tmp); + Scsi_Cmnd tmp; + pcmcia_request_configuration(link->handle, &link->conf); + tmp.device->host = info->host; + aha152x_host_reset(&tmp); } - - return 0; + break; + } + return 0; } static struct pcmcia_device_id aha152x_ids[] = { @@ -299,11 +327,10 @@ static struct pcmcia_driver aha152x_cs_driver = { .drv = { .name = "aha152x_cs", }, - .probe = aha152x_attach, - .remove = aha152x_detach, + .attach = aha152x_attach, + .event = aha152x_event, + .detach = aha152x_detach, .id_table = aha152x_ids, - .suspend = aha152x_suspend, - .resume = aha152x_resume, }; static int __init init_aha152x_cs(void) diff --git a/trunk/drivers/scsi/pcmcia/fdomain_stub.c b/trunk/drivers/scsi/pcmcia/fdomain_stub.c index 788c58d805f3..db8f5cd85ffe 100644 --- a/trunk/drivers/scsi/pcmcia/fdomain_stub.c +++ b/trunk/drivers/scsi/pcmcia/fdomain_stub.c @@ -80,19 +80,29 @@ typedef struct scsi_info_t { static void fdomain_release(dev_link_t *link); -static void fdomain_detach(struct pcmcia_device *p_dev); -static void fdomain_config(dev_link_t *link); +static int fdomain_event(event_t event, int priority, + event_callback_args_t *args); -static int fdomain_attach(struct pcmcia_device *p_dev) +static dev_link_t *fdomain_attach(void); +static void fdomain_detach(dev_link_t *); + + +static dev_link_t *dev_list = NULL; + +static dev_info_t dev_info = "fdomain_cs"; + +static dev_link_t *fdomain_attach(void) { scsi_info_t *info; + client_reg_t client_reg; dev_link_t *link; - + int ret; + DEBUG(0, "fdomain_attach()\n"); /* Create new SCSI device */ info = kmalloc(sizeof(*info), GFP_KERNEL); - if (!info) return -ENOMEM; + if (!info) return NULL; memset(info, 0, sizeof(*info)); link = &info->link; link->priv = info; link->io.NumPorts1 = 0x10; @@ -105,27 +115,46 @@ static int fdomain_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; link->conf.Present = PRESENT_OPTION; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - fdomain_config(link); - - return 0; + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + fdomain_detach(link); + return NULL; + } + + return link; } /* fdomain_attach */ /*====================================================================*/ -static void fdomain_detach(struct pcmcia_device *p_dev) +static void fdomain_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; - DEBUG(0, "fdomain_detach(0x%p)\n", link); + DEBUG(0, "fdomain_detach(0x%p)\n", link); + + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) break; + if (*linkp == NULL) + return; - if (link->state & DEV_CONFIG) - fdomain_release(link); + if (link->state & DEV_CONFIG) + fdomain_release(link); - kfree(link->priv); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; + kfree(link->priv); + } /* fdomain_detach */ /*====================================================================*/ @@ -227,29 +256,43 @@ static void fdomain_release(dev_link_t *link) /*====================================================================*/ -static int fdomain_suspend(struct pcmcia_device *dev) +static int fdomain_event(event_t event, int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; + DEBUG(1, "fdomain_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + fdomain_release(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + fdomain_config(link); + break; + case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int fdomain_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - fdomain_16x0_bus_reset(NULL); + pcmcia_request_configuration(link->handle, &link->conf); + fdomain_16x0_bus_reset(NULL); } + break; + } + return 0; +} /* fdomain_event */ - return 0; -} static struct pcmcia_device_id fdomain_ids[] = { PCMCIA_DEVICE_PROD_ID12("IBM Corp.", "SCSI PCMCIA Card", 0xe3736c88, 0x859cad20), @@ -264,11 +307,10 @@ static struct pcmcia_driver fdomain_cs_driver = { .drv = { .name = "fdomain_cs", }, - .probe = fdomain_attach, - .remove = fdomain_detach, + .attach = fdomain_attach, + .event = fdomain_event, + .detach = fdomain_detach, .id_table = fdomain_ids, - .suspend = fdomain_suspend, - .resume = fdomain_resume, }; static int __init init_fdomain_cs(void) @@ -279,6 +321,7 @@ static int __init init_fdomain_cs(void) static void __exit exit_fdomain_cs(void) { pcmcia_unregister_driver(&fdomain_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_fdomain_cs); diff --git a/trunk/drivers/scsi/pcmcia/nsp_cs.c b/trunk/drivers/scsi/pcmcia/nsp_cs.c index 9e3ab3fd5355..050ea13ff80b 100644 --- a/trunk/drivers/scsi/pcmcia/nsp_cs.c +++ b/trunk/drivers/scsi/pcmcia/nsp_cs.c @@ -104,6 +104,9 @@ static struct scsi_host_template nsp_driver_template = { #endif }; +static dev_link_t *dev_list = NULL; +static dev_info_t dev_info = {"nsp_cs"}; + static nsp_hw_data nsp_data_base; /* attach <-> detect glue */ @@ -1593,17 +1596,19 @@ static int nsp_eh_host_reset(Scsi_Cmnd *SCpnt) configure the card at this point -- we wait until we receive a card insertion event. ======================================================================*/ -static int nsp_cs_attach(struct pcmcia_device *p_dev) +static dev_link_t *nsp_cs_attach(void) { scsi_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; nsp_hw_data *data = &nsp_data_base; nsp_dbg(NSP_DEBUG_INIT, "in"); /* Create new SCSI device */ info = kmalloc(sizeof(*info), GFP_KERNEL); - if (info == NULL) { return -ENOMEM; } + if (info == NULL) { return NULL; } memset(info, 0, sizeof(*info)); link = &info->link; link->priv = info; @@ -1631,14 +1636,23 @@ static int nsp_cs_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; link->conf.Present = PRESENT_OPTION; - link->handle = p_dev; - p_dev->instance = link; - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - nsp_cs_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + nsp_cs_detach(link); + return NULL; + } + nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link); - return 0; + return link; } /* nsp_cs_attach */ @@ -1648,19 +1662,35 @@ static int nsp_cs_attach(struct pcmcia_device *p_dev) structures are freed. Otherwise, the structures will be freed when the device is released. ======================================================================*/ -static void nsp_cs_detach(struct pcmcia_device *p_dev) +static void nsp_cs_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; nsp_dbg(NSP_DEBUG_INIT, "in, link=0x%p", link); - if (link->state & DEV_CONFIG) { - ((scsi_info_t *)link->priv)->stop = 1; + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) { + if (*linkp == link) { + break; + } + } + if (*linkp == NULL) { + return; + } + + if (link->state & DEV_CONFIG) nsp_cs_release(link); + + /* Break the link with Card Services */ + if (link->handle) { + pcmcia_deregister_client(link->handle); } + /* Unlink device structure, free bits */ + *linkp = link->next; kfree(link->priv); link->priv = NULL; + } /* nsp_cs_detach */ @@ -1991,58 +2021,99 @@ static void nsp_cs_release(dev_link_t *link) #endif } /* nsp_cs_release */ -static int nsp_cs_suspend(struct pcmcia_device *dev) +/*====================================================================== + + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the net drivers from trying + to talk to the card any more. + + When a CARD_REMOVAL event is received, we immediately set a flag + to block future accesses to this device. All the functions that + actually access the device should check this flag to make sure + the card is still present. + +======================================================================*/ +static int nsp_cs_event(event_t event, + int priority, + event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; scsi_info_t *info = link->priv; nsp_hw_data *data; - link->state |= DEV_SUSPEND; + nsp_dbg(NSP_DEBUG_INIT, "in, event=0x%08x", event); - nsp_dbg(NSP_DEBUG_INIT, "event: suspend"); - - if (info->host != NULL) { - nsp_msg(KERN_INFO, "clear SDTR status"); - - data = (nsp_hw_data *)info->host->hostdata; + switch (event) { + case CS_EVENT_CARD_REMOVAL: + nsp_dbg(NSP_DEBUG_INIT, "event: remove"); + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + ((scsi_info_t *)link->priv)->stop = 1; + nsp_cs_release(link); + } + break; - nsphw_init_sync(data); - } + case CS_EVENT_CARD_INSERTION: + nsp_dbg(NSP_DEBUG_INIT, "event: insert"); + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,68)) + info->bus = args->bus; +#endif + nsp_cs_config(link); + break; - info->stop = 1; + case CS_EVENT_PM_SUSPEND: + nsp_dbg(NSP_DEBUG_INIT, "event: suspend"); + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + /* Mark the device as stopped, to block IO until later */ + nsp_dbg(NSP_DEBUG_INIT, "event: reset physical"); - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); + if (info->host != NULL) { + nsp_msg(KERN_INFO, "clear SDTR status"); - return 0; -} + data = (nsp_hw_data *)info->host->hostdata; -static int nsp_cs_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - scsi_info_t *info = link->priv; - nsp_hw_data *data; + nsphw_init_sync(data); + } - nsp_dbg(NSP_DEBUG_INIT, "event: resume"); + info->stop = 1; + if (link->state & DEV_CONFIG) { + pcmcia_release_configuration(link->handle); + } + break; - link->state &= ~DEV_SUSPEND; + case CS_EVENT_PM_RESUME: + nsp_dbg(NSP_DEBUG_INIT, "event: resume"); + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + nsp_dbg(NSP_DEBUG_INIT, "event: reset"); + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + } + info->stop = 0; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); + if (info->host != NULL) { + nsp_msg(KERN_INFO, "reset host and bus"); - info->stop = 0; + data = (nsp_hw_data *)info->host->hostdata; - if (info->host != NULL) { - nsp_msg(KERN_INFO, "reset host and bus"); + nsphw_init (data); + nsp_bus_reset(data); + } - data = (nsp_hw_data *)info->host->hostdata; + break; - nsphw_init (data); - nsp_bus_reset(data); + default: + nsp_dbg(NSP_DEBUG_INIT, "event: unknown"); + break; } - + nsp_dbg(NSP_DEBUG_INIT, "end"); return 0; -} +} /* nsp_cs_event */ /*======================================================================* * module entry point @@ -2065,11 +2136,10 @@ static struct pcmcia_driver nsp_driver = { .drv = { .name = "nsp_cs", }, - .probe = nsp_cs_attach, - .remove = nsp_cs_detach, + .attach = nsp_cs_attach, + .event = nsp_cs_event, + .detach = nsp_cs_detach, .id_table = nsp_cs_ids, - .suspend = nsp_cs_suspend, - .resume = nsp_cs_resume, }; #endif @@ -2101,6 +2171,7 @@ static void __exit nsp_cs_exit(void) #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,68)) pcmcia_unregister_driver(&nsp_driver); + BUG_ON(dev_list != NULL); #else unregister_pcmcia_driver(&dev_info); /* XXX: this really needs to move into generic code.. */ diff --git a/trunk/drivers/scsi/pcmcia/nsp_cs.h b/trunk/drivers/scsi/pcmcia/nsp_cs.h index b66b140a745e..f8b943082717 100644 --- a/trunk/drivers/scsi/pcmcia/nsp_cs.h +++ b/trunk/drivers/scsi/pcmcia/nsp_cs.h @@ -296,9 +296,11 @@ typedef struct _nsp_hw_data { */ /* Card service functions */ -static void nsp_cs_detach (struct pcmcia_device *p_dev); +static dev_link_t *nsp_cs_attach (void); +static void nsp_cs_detach (dev_link_t *link); static void nsp_cs_release(dev_link_t *link); static void nsp_cs_config (dev_link_t *link); +static int nsp_cs_event (event_t event, int priority, event_callback_args_t *args); /* Linux SCSI subsystem specific functions */ static struct Scsi_Host *nsp_detect (struct scsi_host_template *sht); diff --git a/trunk/drivers/scsi/pcmcia/qlogic_stub.c b/trunk/drivers/scsi/pcmcia/qlogic_stub.c index dce7e687fd4a..bb091a45a880 100644 --- a/trunk/drivers/scsi/pcmcia/qlogic_stub.c +++ b/trunk/drivers/scsi/pcmcia/qlogic_stub.c @@ -98,8 +98,15 @@ typedef struct scsi_info_t { } scsi_info_t; static void qlogic_release(dev_link_t *link); -static void qlogic_detach(struct pcmcia_device *p_dev); -static void qlogic_config(dev_link_t * link); +static int qlogic_event(event_t event, int priority, event_callback_args_t * args); + +static dev_link_t *qlogic_attach(void); +static void qlogic_detach(dev_link_t *); + + +static dev_link_t *dev_list = NULL; + +static dev_info_t dev_info = "qlogic_cs"; static struct Scsi_Host *qlogic_detect(struct scsi_host_template *host, dev_link_t *link, int qbase, int qlirq) @@ -156,17 +163,19 @@ static struct Scsi_Host *qlogic_detect(struct scsi_host_template *host, err: return NULL; } -static int qlogic_attach(struct pcmcia_device *p_dev) +static dev_link_t *qlogic_attach(void) { scsi_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; DEBUG(0, "qlogic_attach()\n"); /* Create new SCSI device */ info = kmalloc(sizeof(*info), GFP_KERNEL); if (!info) - return -ENOMEM; + return NULL; memset(info, 0, sizeof(*info)); link = &info->link; link->priv = info; @@ -180,26 +189,45 @@ static int qlogic_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; link->conf.Present = PRESENT_OPTION; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - qlogic_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + qlogic_detach(link); + return NULL; + } - return 0; + return link; } /* qlogic_attach */ /*====================================================================*/ -static void qlogic_detach(struct pcmcia_device *p_dev) +static void qlogic_detach(dev_link_t * link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; DEBUG(0, "qlogic_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + if (*linkp == NULL) + return; + if (link->state & DEV_CONFIG) qlogic_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits */ + *linkp = link->next; kfree(link->priv); } /* qlogic_detach */ @@ -321,39 +349,48 @@ static void qlogic_release(dev_link_t *link) /*====================================================================*/ -static int qlogic_suspend(struct pcmcia_device *dev) +static int qlogic_event(event_t event, int priority, event_callback_args_t * args) { - dev_link_t *link = dev_to_instance(dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int qlogic_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - scsi_info_t *info = link->priv; - - pcmcia_request_configuration(link->handle, &link->conf); - if ((info->manf_id == MANFID_MACNICA) || - (info->manf_id == MANFID_PIONEER) || - (info->manf_id == 0x0098)) { - outb(0x80, link->io.BasePort1 + 0xd); - outb(0x24, link->io.BasePort1 + 0x9); - outb(0x04, link->io.BasePort1 + 0xd); + dev_link_t *link = args->client_data; + + DEBUG(1, "qlogic_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + qlogic_release(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + qlogic_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + scsi_info_t *info = link->priv; + pcmcia_request_configuration(link->handle, &link->conf); + if ((info->manf_id == MANFID_MACNICA) || (info->manf_id == MANFID_PIONEER) || (info->manf_id == 0x0098)) { + outb(0x80, link->io.BasePort1 + 0xd); + outb(0x24, link->io.BasePort1 + 0x9); + outb(0x04, link->io.BasePort1 + 0xd); + } + /* Ugggglllyyyy!!! */ + qlogicfas408_bus_reset(NULL); } - /* Ugggglllyyyy!!! */ - qlogicfas408_bus_reset(NULL); + break; } - return 0; -} +} /* qlogic_event */ static struct pcmcia_device_id qlogic_ids[] = { PCMCIA_DEVICE_PROD_ID12("EIger Labs", "PCMCIA-to-SCSI Adapter", 0x88395fa7, 0x33b7a5e6), @@ -382,11 +419,10 @@ static struct pcmcia_driver qlogic_cs_driver = { .drv = { .name = "qlogic_cs", }, - .probe = qlogic_attach, - .remove = qlogic_detach, + .attach = qlogic_attach, + .event = qlogic_event, + .detach = qlogic_detach, .id_table = qlogic_ids, - .suspend = qlogic_suspend, - .resume = qlogic_resume, }; static int __init init_qlogic_cs(void) @@ -397,6 +433,7 @@ static int __init init_qlogic_cs(void) static void __exit exit_qlogic_cs(void) { pcmcia_unregister_driver(&qlogic_cs_driver); + BUG_ON(dev_list != NULL); } MODULE_AUTHOR("Tom Zerucha, Michael Griffith"); diff --git a/trunk/drivers/scsi/pcmcia/sym53c500_cs.c b/trunk/drivers/scsi/pcmcia/sym53c500_cs.c index 3a4dd6f5b81f..98b64b2aa8ee 100644 --- a/trunk/drivers/scsi/pcmcia/sym53c500_cs.c +++ b/trunk/drivers/scsi/pcmcia/sym53c500_cs.c @@ -228,6 +228,15 @@ enum Phase { /* ================================================================== */ +/* +* Global (within this module) variables other than +* sym53c500_driver_template (the scsi_host_template). +*/ +static dev_link_t *dev_list; +static dev_info_t dev_info = "sym53c500_cs"; + +/* ================================================================== */ + static void chip_init(int io_port) { @@ -863,70 +872,96 @@ SYM53C500_config(dev_link_t *link) return; } /* SYM53C500_config */ -static int sym53c500_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int sym53c500_resume(struct pcmcia_device *dev) +static int +SYM53C500_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; struct scsi_info_t *info = link->priv; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) { - pcmcia_request_configuration(link->handle, &link->conf); - - /* See earlier comment about manufacturer IDs. */ - if ((info->manf_id == MANFID_MACNICA) || - (info->manf_id == MANFID_PIONEER) || - (info->manf_id == 0x0098)) { - outb(0x80, link->io.BasePort1 + 0xd); - outb(0x24, link->io.BasePort1 + 0x9); - outb(0x04, link->io.BasePort1 + 0xd); + DEBUG(1, "SYM53C500_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + SYM53C500_release(link); + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + SYM53C500_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) { + pcmcia_request_configuration(link->handle, &link->conf); + /* See earlier comment about manufacturer IDs. */ + if ((info->manf_id == MANFID_MACNICA) || + (info->manf_id == MANFID_PIONEER) || + (info->manf_id == 0x0098)) { + outb(0x80, link->io.BasePort1 + 0xd); + outb(0x24, link->io.BasePort1 + 0x9); + outb(0x04, link->io.BasePort1 + 0xd); + } + /* + * If things don't work after a "resume", + * this is a good place to start looking. + */ + SYM53C500_int_host_reset(link->io.BasePort1); } - /* - * If things don't work after a "resume", - * this is a good place to start looking. - */ - SYM53C500_int_host_reset(link->io.BasePort1); + break; } - return 0; -} +} /* SYM53C500_event */ static void -SYM53C500_detach(struct pcmcia_device *p_dev) +SYM53C500_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; DEBUG(0, "SYM53C500_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + if (*linkp == NULL) + return; + if (link->state & DEV_CONFIG) SYM53C500_release(link); + if (link->handle) + pcmcia_deregister_client(link->handle); + + /* Unlink device structure, free bits. */ + *linkp = link->next; kfree(link->priv); link->priv = NULL; } /* SYM53C500_detach */ -static int -SYM53C500_attach(struct pcmcia_device *p_dev) +static dev_link_t * +SYM53C500_attach(void) { struct scsi_info_t *info; + client_reg_t client_reg; dev_link_t *link; + int ret; DEBUG(0, "SYM53C500_attach()\n"); /* Create new SCSI device */ info = kmalloc(sizeof(*info), GFP_KERNEL); if (!info) - return -ENOMEM; + return NULL; memset(info, 0, sizeof(*info)); link = &info->link; link->priv = info; @@ -940,13 +975,20 @@ SYM53C500_attach(struct pcmcia_device *p_dev) link->conf.IntType = INT_MEMORY_AND_IO; link->conf.Present = PRESENT_OPTION; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - SYM53C500_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != 0) { + cs_error(link->handle, RegisterClient, ret); + SYM53C500_detach(link); + return NULL; + } - return 0; + return link; } /* SYM53C500_attach */ MODULE_AUTHOR("Bob Tracy "); @@ -966,11 +1008,10 @@ static struct pcmcia_driver sym53c500_cs_driver = { .drv = { .name = "sym53c500_cs", }, - .probe = SYM53C500_attach, - .remove = SYM53C500_detach, + .attach = SYM53C500_attach, + .event = SYM53C500_event, + .detach = SYM53C500_detach, .id_table = sym53c500_ids, - .suspend = sym53c500_suspend, - .resume = sym53c500_resume, }; static int __init diff --git a/trunk/drivers/scsi/pdc_adma.c b/trunk/drivers/scsi/pdc_adma.c index e8df0c9ec1e6..f557f17ca00c 100644 --- a/trunk/drivers/scsi/pdc_adma.c +++ b/trunk/drivers/scsi/pdc_adma.c @@ -464,12 +464,14 @@ static inline unsigned int adma_intr_pkt(struct ata_host_set *host_set) continue; qc = ata_qc_from_tag(ap, ap->active_tag); if (qc && (!(qc->tf.ctl & ATA_NIEN))) { + unsigned int err_mask = 0; + if ((status & (aPERR | aPSD | aUIRQ))) - qc->err_mask |= AC_ERR_OTHER; + err_mask = AC_ERR_OTHER; else if (pp->pkt[0] != cDONE) - qc->err_mask |= AC_ERR_OTHER; + err_mask = AC_ERR_OTHER; - ata_qc_complete(qc); + ata_qc_complete(qc, err_mask); } } return handled; @@ -499,8 +501,7 @@ static inline unsigned int adma_intr_mmio(struct ata_host_set *host_set) /* complete taskfile transaction */ pp->state = adma_state_idle; - qc->err_mask |= ac_err_mask(status); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(status)); handled = 1; } } diff --git a/trunk/drivers/scsi/qla2xxx/Kconfig b/trunk/drivers/scsi/qla2xxx/Kconfig index 5205c4e7d6ff..c1c1c687bcbd 100644 --- a/trunk/drivers/scsi/qla2xxx/Kconfig +++ b/trunk/drivers/scsi/qla2xxx/Kconfig @@ -1,70 +1,55 @@ config SCSI_QLA2XXX - tristate "QLogic QLA2XXX Fibre Channel Support" - depends on PCI && SCSI - select SCSI_FC_ATTRS - select FW_LOADER - ---help--- - This qla2xxx driver supports all QLogic Fibre Channel - PCI and PCIe host adapters. - - By default, firmware for the ISP parts will be loaded - via the Firmware Loader interface. - - ISP Firmware Filename - ---------- ----------------- - 21xx ql2100_fw.bin - 22xx ql2200_fw.bin - 2300, 2312 ql2300_fw.bin - 2322 ql2322_fw.bin - 6312, 6322 ql6312_fw.bin - 24xx ql2400_fw.bin - - Upon request, the driver caches the firmware image until - the driver is unloaded. - - NOTE: The original method of building firmware-loader - modules has been deprecated as the firmware-images will - be removed from the kernel sources. - -config SCSI_QLA2XXX_EMBEDDED_FIRMWARE - bool " Use firmware-loader modules (DEPRECATED)" - depends on SCSI_QLA2XXX + tristate + default (SCSI && PCI) + depends on SCSI && PCI config SCSI_QLA21XX - tristate " Build QLogic ISP2100 firmware-module" - depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE + tristate "QLogic ISP2100 host adapter family support" + depends on SCSI_QLA2XXX + select SCSI_FC_ATTRS + select FW_LOADER ---help--- This driver supports the QLogic 21xx (ISP2100) host adapter family. config SCSI_QLA22XX - tristate " Build QLogic ISP2200 firmware-module" - depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE + tristate "QLogic ISP2200 host adapter family support" + depends on SCSI_QLA2XXX + select SCSI_FC_ATTRS + select FW_LOADER ---help--- This driver supports the QLogic 22xx (ISP2200) host adapter family. config SCSI_QLA2300 - tristate " Build QLogic ISP2300 firmware-module" - depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE + tristate "QLogic ISP2300 host adapter family support" + depends on SCSI_QLA2XXX + select SCSI_FC_ATTRS + select FW_LOADER ---help--- This driver supports the QLogic 2300 (ISP2300 and ISP2312) host adapter family. config SCSI_QLA2322 - tristate " Build QLogic ISP2322 firmware-module" - depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE + tristate "QLogic ISP2322 host adapter family support" + depends on SCSI_QLA2XXX + select SCSI_FC_ATTRS + select FW_LOADER ---help--- This driver supports the QLogic 2322 (ISP2322) host adapter family. config SCSI_QLA6312 - tristate " Build QLogic ISP63xx firmware-module" - depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE + tristate "QLogic ISP63xx host adapter family support" + depends on SCSI_QLA2XXX + select SCSI_FC_ATTRS + select FW_LOADER ---help--- This driver supports the QLogic 63xx (ISP6312 and ISP6322) host adapter family. config SCSI_QLA24XX - tristate " Build QLogic ISP24xx firmware-module" - depends on SCSI_QLA2XXX_EMBEDDED_FIRMWARE + tristate "QLogic ISP24xx host adapter family support" + depends on SCSI_QLA2XXX + select SCSI_FC_ATTRS + select FW_LOADER ---help--- This driver supports the QLogic 24xx (ISP2422 and ISP2432) host adapter family. diff --git a/trunk/drivers/scsi/qla2xxx/Makefile b/trunk/drivers/scsi/qla2xxx/Makefile index 40c0de125889..b169687d08ff 100644 --- a/trunk/drivers/scsi/qla2xxx/Makefile +++ b/trunk/drivers/scsi/qla2xxx/Makefile @@ -3,18 +3,15 @@ EXTRA_CFLAGS += -DUNIQUE_FW_NAME qla2xxx-y := qla_os.o qla_init.o qla_mbx.o qla_iocb.o qla_isr.o qla_gs.o \ qla_dbg.o qla_sup.o qla_rscn.o qla_attr.o -obj-$(CONFIG_SCSI_QLA2XXX) += qla2xxx.o - qla2100-y := ql2100.o ql2100_fw.o qla2200-y := ql2200.o ql2200_fw.o qla2300-y := ql2300.o ql2300_fw.o qla2322-y := ql2322.o ql2322_fw.o qla6312-y := ql6312.o ql6312_fw.o -qla2400-y := ql2400.o ql2400_fw.o obj-$(CONFIG_SCSI_QLA21XX) += qla2xxx.o qla2100.o obj-$(CONFIG_SCSI_QLA22XX) += qla2xxx.o qla2200.o obj-$(CONFIG_SCSI_QLA2300) += qla2xxx.o qla2300.o obj-$(CONFIG_SCSI_QLA2322) += qla2xxx.o qla2322.o obj-$(CONFIG_SCSI_QLA6312) += qla2xxx.o qla6312.o -obj-$(CONFIG_SCSI_QLA24XX) += qla2xxx.o qla2400.o +obj-$(CONFIG_SCSI_QLA24XX) += qla2xxx.o diff --git a/trunk/drivers/scsi/qla2xxx/ql2400.c b/trunk/drivers/scsi/qla2xxx/ql2400.c deleted file mode 100644 index 6c7165f47e29..000000000000 --- a/trunk/drivers/scsi/qla2xxx/ql2400.c +++ /dev/null @@ -1,111 +0,0 @@ -/* - * QLogic Fibre Channel HBA Driver - * Copyright (c) 2003-2005 QLogic Corporation - * - * See LICENSE.qla2xxx for copyright and licensing details. - */ -#include -#include -#include - -#include "qla_def.h" - -static char qla_driver_name[] = "qla2400"; - -extern uint32_t fw2400_version_str[]; -extern uint32_t fw2400_addr01; -extern uint32_t fw2400_code01[]; -extern uint32_t fw2400_length01; -extern uint32_t fw2400_addr02; -extern uint32_t fw2400_code02[]; -extern uint32_t fw2400_length02; - -static struct qla_fw_info qla_fw_tbl[] = { - { - .addressing = FW_INFO_ADDR_EXTENDED, - .fwcode = (unsigned short *)&fw2400_code01[0], - .fwlen = (unsigned short *)&fw2400_length01, - .lfwstart = (unsigned long *)&fw2400_addr01, - }, - { - .addressing = FW_INFO_ADDR_EXTENDED, - .fwcode = (unsigned short *)&fw2400_code02[0], - .fwlen = (unsigned short *)&fw2400_length02, - .lfwstart = (unsigned long *)&fw2400_addr02, - }, - { FW_INFO_ADDR_NOMORE, }, -}; - -static struct qla_board_info qla_board_tbl[] = { - { - .drv_name = qla_driver_name, - .isp_name = "ISP2422", - .fw_info = qla_fw_tbl, - .fw_fname = "ql2400_fw.bin", - }, - { - .drv_name = qla_driver_name, - .isp_name = "ISP2432", - .fw_info = qla_fw_tbl, - .fw_fname = "ql2400_fw.bin", - }, -}; - -static struct pci_device_id qla24xx_pci_tbl[] = { - { - .vendor = PCI_VENDOR_ID_QLOGIC, - .device = PCI_DEVICE_ID_QLOGIC_ISP2422, - .subvendor = PCI_ANY_ID, - .subdevice = PCI_ANY_ID, - .driver_data = (unsigned long)&qla_board_tbl[0], - }, - { - .vendor = PCI_VENDOR_ID_QLOGIC, - .device = PCI_DEVICE_ID_QLOGIC_ISP2432, - .subvendor = PCI_ANY_ID, - .subdevice = PCI_ANY_ID, - .driver_data = (unsigned long)&qla_board_tbl[1], - }, - {0, 0}, -}; -MODULE_DEVICE_TABLE(pci, qla24xx_pci_tbl); - -static int __devinit -qla24xx_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) -{ - return qla2x00_probe_one(pdev, - (struct qla_board_info *)id->driver_data); -} - -static void __devexit -qla24xx_remove_one(struct pci_dev *pdev) -{ - qla2x00_remove_one(pdev); -} - -static struct pci_driver qla24xx_pci_driver = { - .name = "qla2400", - .id_table = qla24xx_pci_tbl, - .probe = qla24xx_probe_one, - .remove = __devexit_p(qla24xx_remove_one), -}; - -static int __init -qla24xx_init(void) -{ - return pci_module_init(&qla24xx_pci_driver); -} - -static void __exit -qla24xx_exit(void) -{ - pci_unregister_driver(&qla24xx_pci_driver); -} - -module_init(qla24xx_init); -module_exit(qla24xx_exit); - -MODULE_AUTHOR("QLogic Corporation"); -MODULE_DESCRIPTION("QLogic ISP24xx FC-SCSI Host Bus Adapter driver"); -MODULE_LICENSE("GPL"); -MODULE_VERSION(QLA2XXX_VERSION); diff --git a/trunk/drivers/scsi/qla2xxx/ql2400_fw.c b/trunk/drivers/scsi/qla2xxx/ql2400_fw.c deleted file mode 100644 index 5977795854f8..000000000000 --- a/trunk/drivers/scsi/qla2xxx/ql2400_fw.c +++ /dev/null @@ -1,12376 +0,0 @@ -/* - * QLogic Fibre Channel HBA Driver - * Copyright (c) 2003-2005 QLogic Corporation - * - * See LICENSE.qla2xxx for copyright and licensing details. - */ -#include - -/* - * Firmware Version 4.00.16 (08:09 Oct 26, 2005) - */ - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_version = 4*1024+0; -#else -uint32_t risc_code_version = 4*1024+0; -#endif - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_version_str[] = {4, 0,16}; -#else -uint32_t firmware_version[] = {4, 0,16}; -#endif - -#ifdef UNIQUE_FW_NAME -#define fw2400_VERSION_STRING "4.00.16" -#else -#define FW_VERSION_STRING "4.00.16" -#endif - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_addr01 = 0x00100000 ; -#else -uint32_t risc_code_addr01 = 0x00100000 ; -#endif - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_code01[] = { -#else -uint32_t risc_code01[] = { -#endif - 0x0401f17c, 0x0010e000, 0x00100000, 0x0000ab4a, - 0x00000004, 0x00000000, 0x00000010, 0x00000002, - 0x00000003, 0x00000000, 0x20434f50, 0x59524947, - 0x48542032, 0x30303520, 0x514c4f47, 0x49432043, - 0x4f52504f, 0x52415449, 0x4f4e2020, 0x20495350, - 0x32347878, 0x20466972, 0x6d776172, 0x65202020, - 0x56657273, 0x696f6e20, 0x342e302e, 0x31362020, - 0x20202024, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x42001800, 0x0010014f, 0x42002000, 0x0010b8fe, - 0x500c0800, 0x800c1800, 0x500c1000, 0x800c1800, - 0x54042000, 0x80102000, 0x80040800, 0x80081040, - 0x040207fc, 0x500c0800, 0x800409c0, 0x040207f6, - 0x44002000, 0x80102000, 0x40100000, 0x44040000, - 0x80000000, 0x44080000, 0x80000000, 0x440c0000, - 0x80000000, 0x44100000, 0x80000000, 0x44140000, - 0x80000000, 0x44180000, 0x80000000, 0x441c0000, - 0x80000000, 0x44200000, 0x80000000, 0x44240000, - 0x80000000, 0x44280000, 0x80000000, 0x442c0000, - 0x80000000, 0x44300000, 0x80000000, 0x44340000, - 0x80000000, 0x44380000, 0x80000000, 0x443c0000, - 0x80000000, 0x44400000, 0x80000000, 0x44440000, - 0x80000000, 0x44480000, 0x80000000, 0x444c0000, - 0x80000000, 0x44500000, 0x80000000, 0x44540000, - 0x80000000, 0x44580000, 0x80000000, 0x445c0000, - 0x80000000, 0x44600000, 0x80000000, 0x44640000, - 0x80000000, 0x44680000, 0x80000000, 0x446c0000, - 0x80000000, 0x44700000, 0x80000000, 0x44740000, - 0x80000000, 0x44780000, 0x80000000, 0x447c0000, - 0x80000000, 0x44800000, 0x80000000, 0x44840000, - 0x80000000, 0x44880000, 0x80000000, 0x448c0000, - 0x80000000, 0x44900000, 0x80000000, 0x44940000, - 0x80000000, 0x44980000, 0x80000000, 0x449c0000, - 0x80000000, 0x44a00000, 0x80000000, 0x44a40000, - 0x80000000, 0x44a80000, 0x80000000, 0x44ac0000, - 0x80000000, 0x44b00000, 0x80000000, 0x44b40000, - 0x80000000, 0x44b80000, 0x80000000, 0x44bc0000, - 0x80000000, 0x44c00000, 0x80000000, 0x44c40000, - 0x80000000, 0x44c80000, 0x80000000, 0x44cc0000, - 0x80000000, 0x44d00000, 0x80000000, 0x44d80000, - 0x80000000, 0x44d40000, 0x80000000, 0x44dc0000, - 0x80000000, 0x44e00000, 0x80000000, 0x44e40000, - 0x80000000, 0x44e80000, 0x80000000, 0x44ec0000, - 0x80000000, 0x44f00000, 0x80000000, 0x44f40000, - 0x80000000, 0x44f80000, 0x80000000, 0x44fc0000, - 0x80000000, 0x45000000, 0x80000000, 0x45040000, - 0x80000000, 0x45080000, 0x80000000, 0x450c0000, - 0x80000000, 0x45100000, 0x80000000, 0x45140000, - 0x80000000, 0x45180000, 0x80000000, 0x451c0000, - 0x80000000, 0x45200000, 0x80000000, 0x45240000, - 0x80000000, 0x45280000, 0x80000000, 0x452c0000, - 0x80000000, 0x45300000, 0x80000000, 0x45340000, - 0x80000000, 0x45380000, 0x80000000, 0x453c0000, - 0x80000000, 0x45400000, 0x80000000, 0x45440000, - 0x80000000, 0x45480000, 0x80000000, 0x454c0000, - 0x80000000, 0x45500000, 0x80000000, 0x45540000, - 0x80000000, 0x45580000, 0x80000000, 0x455c0000, - 0x80000000, 0x45600000, 0x80000000, 0x45640000, - 0x80000000, 0x45680000, 0x80000000, 0x456c0000, - 0x80000000, 0x45700000, 0x80000000, 0x45740000, - 0x80000000, 0x45780000, 0x80000000, 0x457c0000, - 0x80000000, 0x45800000, 0x80000000, 0x45840000, - 0x80000000, 0x45880000, 0x80000000, 0x458c0000, - 0x80000000, 0x45900000, 0x80000000, 0x45940000, - 0x80000000, 0x45980000, 0x80000000, 0x459c0000, - 0x80000000, 0x45a00000, 0x80000000, 0x45a40000, - 0x80000000, 0x45a80000, 0x80000000, 0x45ac0000, - 0x80000000, 0x45b00000, 0x80000000, 0x45b40000, - 0x80000000, 0x45b80000, 0x80000000, 0x45bc0000, - 0x80000000, 0x45c00000, 0x80000000, 0x45c40000, - 0x80000000, 0x45c80000, 0x80000000, 0x45cc0000, - 0x80000000, 0x45d00000, 0x80000000, 0x45d40000, - 0x80000000, 0x45d80000, 0x80000000, 0x45dc0000, - 0x80000000, 0x45e00000, 0x80000000, 0x45e40000, - 0x80000000, 0x45e80000, 0x80000000, 0x45ec0000, - 0x80000000, 0x45f00000, 0x80000000, 0x45f40000, - 0x80000000, 0x45f80000, 0x80000000, 0x45fc0000, - 0x4a03c020, 0x00004000, 0x4a03c011, 0x40000010, - 0x04006000, 0x4203e000, 0x40000000, 0x59e00017, - 0x8c000508, 0x04000003, 0x4a03c017, 0x00000000, - 0x4203e000, 0x30000001, 0x0401f000, 0x0000bf00, - 0x00000080, 0x0000bfe0, 0x00000020, 0x0000ff00, - 0x00000080, 0x0000ffd0, 0x00000030, 0x00007100, - 0x00000010, 0x00007200, 0x00000008, 0x00007209, - 0x00000007, 0x00007300, 0x00000008, 0x00007309, - 0x00000007, 0x00007400, 0x00000008, 0x00007409, - 0x00000007, 0x00007600, 0x000000b0, 0x00007700, - 0x00000040, 0x00003000, 0x00000070, 0x00004000, - 0x000000c0, 0x00006000, 0x00000050, 0x00006100, - 0x00000010, 0x00006130, 0x00000010, 0x00006150, - 0x00000010, 0x00006170, 0x00000010, 0x00006190, - 0x00000010, 0x000061b0, 0x00000010, 0x00000000, - 0x42000000, 0x00000100, 0x4202f000, 0x00000000, - 0x42000800, 0x00021f00, 0x45780800, 0x80040800, - 0x80000040, 0x040207fd, 0x4203f000, 0x00021fff, - 0x40000000, 0x4203e000, 0x90000100, 0x40000000, - 0x0201f800, 0x001006fd, 0x42000000, 0x00001000, - 0x50000000, 0x82000480, 0x24320002, 0x04020015, - 0x42000800, 0x00000064, 0x80040840, 0x04000007, - 0x4a030000, 0x00000001, 0x40000000, 0x59800000, - 0x8c000500, 0x040007f9, 0x04000008, 0x42000800, - 0x00007a17, 0x50040000, 0x8c00050e, 0x04020003, - 0x8400054e, 0x44000800, 0x4a030000, 0x00000000, - 0x4a03c020, 0x00000004, 0x4203e000, 0x6000000f, - 0x59e00023, 0x8c000500, 0x04020039, 0x42000000, - 0x00100001, 0x50000800, 0x82040c00, 0x00000004, - 0x58042003, 0x42001000, 0xffffffff, 0x0201f800, - 0x001006f4, 0x0402004e, 0x58042003, 0x42001000, - 0xffffffff, 0x0201f800, 0x001006f4, 0x04020048, - 0x58042003, 0x42001000, 0x00ffffff, 0x0201f800, - 0x001006f4, 0x04020042, 0x58042003, 0x42001000, - 0x00ffffff, 0x0201f800, 0x001006f4, 0x0402003c, - 0x42000000, 0x00100001, 0x5000a000, 0x8250a400, - 0x00000004, 0x4200a800, 0x00020000, 0x5850b003, - 0x0201f800, 0x0010ab17, 0x8250a400, 0x00000005, - 0x4a0370e8, 0x00000003, 0x4200a800, 0x0000c000, - 0x5850b003, 0x0201f800, 0x0010ab17, 0x4a0378e8, - 0x00000003, 0x4200a800, 0x00008000, 0x5850b003, - 0x0201f800, 0x0010ab17, 0x0401f02b, 0x42000800, - 0x00020000, 0x58042003, 0x42001000, 0xffffffff, - 0x0201f800, 0x001006f4, 0x04020019, 0x4a0370e8, - 0x00000003, 0x42000800, 0x0000c000, 0x58042003, - 0x82102500, 0x00ffffff, 0x42001000, 0x00ffffff, - 0x0201f800, 0x001006f4, 0x0402000d, 0x4a0378e8, - 0x00000003, 0x42000800, 0x00008000, 0x58042003, - 0x82102500, 0x00ffffff, 0x42001000, 0x00ffffff, - 0x0201f800, 0x001006f4, 0x0400000b, 0x4a03c020, - 0x00004010, 0x4a03c011, 0x40100011, 0x04006000, - 0x4203e000, 0x40000000, 0x4203e000, 0x30000001, - 0x0401f000, 0x0201f800, 0x00100791, 0x42001000, - 0x0010ab4a, 0x40080000, 0x80140480, 0x82001d00, - 0xffffff00, 0x04020003, 0x40001800, 0x0401f003, - 0x42001800, 0x000000ff, 0x480bc840, 0x480fc842, - 0x04011000, 0x400c0000, 0x80081400, 0x40140000, - 0x80080580, 0x040207f0, 0x4817500d, 0x45782800, - 0x59c40000, 0x82000500, 0xffff0000, 0x80000120, - 0x82000580, 0x00002422, 0x04020005, 0x59a80005, - 0x8400054e, 0x48035005, 0x0401f008, 0x59e00003, - 0x82000500, 0x00030000, 0x04000004, 0x59a80005, - 0x84000554, 0x48035005, 0x42000800, 0x00000040, - 0x59a80005, 0x8c000514, 0x0402000e, 0x42000800, - 0x00001000, 0x82141480, 0x0017ffff, 0x04021009, - 0x80040902, 0x82141480, 0x0013ffff, 0x04021005, - 0x80040902, 0x82141480, 0x0011ffff, 0x04001b8d, - 0x4807500e, 0x42001000, 0x00000024, 0x0201f800, - 0x00106681, 0x82040c00, 0x0010d1c0, 0x4807500b, - 0x4a03c810, 0x00100000, 0x4a03c811, 0x0010ab4a, - 0x4a03c829, 0x00000004, 0x59e40001, 0x82000540, - 0x0003001d, 0x4803c801, 0x4a03c014, 0x001c001c, - 0x42001000, 0x0000001c, 0x0201f800, 0x001006e2, - 0x4202c000, 0x0010d1c0, 0x59aab00b, 0x59aaa00b, - 0x59aaa80b, 0x59aac80e, 0x49675069, 0x59a8000b, - 0x4803500c, 0x0401fbf5, 0x0201f800, 0x00107903, - 0x0201f800, 0x001007be, 0x0201f800, 0x00100807, - 0x0201f800, 0x00101a05, 0x0201f800, 0x00101354, - 0x0201f800, 0x00100969, 0x0201f800, 0x00101354, - 0x0201f800, 0x00100f4c, 0x0201f800, 0x001066c1, - 0x0401fb1a, 0x0201f800, 0x0010220e, 0x0201f800, - 0x001053bb, 0x0201f800, 0x00104c90, 0x0201f800, - 0x00106194, 0x0201f800, 0x00105f28, 0x0201f800, - 0x001013ed, 0x0201f800, 0x0010126f, 0x4203e000, - 0xf0000001, 0x42000000, 0x00001000, 0x50000000, - 0x82000480, 0x24220001, 0x04000016, 0x59e00002, - 0x8c00051e, 0x42000000, 0x7ffe00fe, 0x04020003, - 0x42000000, 0x7ffe01fe, 0x50000800, 0x48075058, - 0x80040920, 0x82040580, 0x0000013a, 0x04000004, - 0x82040580, 0x0000013b, 0x04020006, 0x59a80005, - 0x84000552, 0x48035005, 0x4a0378e4, 0x000c0000, - 0x4a03c018, 0x0000000f, 0x4203e000, 0x20000511, - 0x4203e000, 0x50010000, 0x4a03c020, 0x00000000, - 0x04027013, 0x59e00020, 0x82000580, 0x00000002, - 0x0402000f, 0x4a03c020, 0x00004000, 0x4a03c011, - 0x40000010, 0x04006000, 0x4203e000, 0x40000000, - 0x59e00017, 0x8c000508, 0x04000003, 0x4a03c017, - 0x00000000, 0x4203e000, 0x30000001, 0x4202d800, - 0x00000000, 0x4203e000, 0xb0600000, 0x59a80005, - 0x42000800, 0x00000002, 0x8c000512, 0x04020007, - 0x42000800, 0x0000000f, 0x8c000514, 0x04020003, - 0x42000800, 0x00000001, 0x4007f800, 0x59a80005, - 0x8c000514, 0x02020000, 0x00020004, 0x59e00003, - 0x82000500, 0x00030000, 0x82000580, 0x00000000, - 0x04020af8, 0x0201f000, 0x00020004, 0x4df00000, - 0x4203e000, 0x50000000, 0x416c0000, 0x82000c80, - 0x00000008, 0x04021aef, 0x0c01f804, 0x5c03e000, - 0x0201f000, 0x00020008, 0x001002f7, 0x0010030a, - 0x001003d7, 0x001002f6, 0x00100452, 0x001002f6, - 0x001002f6, 0x00100593, 0x0401fae2, 0x42000800, - 0x0010b4a4, 0x5804001d, 0x4803c857, 0x8c000500, - 0x0400000d, 0x84000500, 0x4800081d, 0x4202d800, - 0x00000004, 0x0401fbd3, 0x49f3c857, 0x5c000800, - 0x5c000000, 0x82000540, 0x00003e00, 0x4c000000, - 0x4c040000, 0x1c01f000, 0x0401fbbd, 0x0201f800, - 0x0010513b, 0x04000009, 0x0201f800, 0x00105151, - 0x0402002e, 0x59c40006, 0x82000540, 0x000000c0, - 0x48038806, 0x0401f029, 0x0201f800, 0x001050a2, - 0x836c0580, 0x00000001, 0x040200bc, 0x59a80017, - 0x82000580, 0x00000009, 0x040200b8, 0x497b5010, - 0x4a038893, 0x00000001, 0x42001000, 0x000000f0, - 0x0201f800, 0x0010193d, 0x0201f800, 0x00105149, - 0x59c41006, 0x04020006, 0x82081540, 0x000000f1, - 0x82081500, 0xbbffffff, 0x0401f003, 0x82081540, - 0x440000f1, 0x480b8806, 0x0201f800, 0x0010609e, - 0x4a0378e4, 0x00002000, 0x42000000, 0x0010b83a, - 0x0201f800, 0x0010aa47, 0x42001000, 0x00008030, - 0x497b5013, 0x0401f035, 0x0201f800, 0x00103b38, - 0x59c400a4, 0x82000500, 0x0000000f, 0x82000480, - 0x00000007, 0x04021091, 0x0201f800, 0x0010609e, - 0x59c400a3, 0x82000500, 0xffefffff, 0x480388a3, - 0x59a8004b, 0x800001c0, 0x04020004, 0x0201f800, - 0x00104139, 0x0401f085, 0x59a80015, 0x84000546, - 0x48035015, 0x0201f800, 0x00105141, 0x59c41006, - 0x04020006, 0x82081540, 0x44000001, 0x82081500, - 0xffffff0f, 0x0401f003, 0x82081540, 0x440000f1, - 0x480b8806, 0x497b9005, 0x4a038802, 0x0000ffff, - 0x4a0378e4, 0x00003000, 0x42000000, 0x0010b80c, - 0x0201f800, 0x0010aa47, 0x59a81010, 0x42000800, - 0x00000003, 0x0201f800, 0x00106c78, 0x42001000, - 0x00008010, 0x59a8180a, 0x0201f800, 0x00103a3e, - 0x0201f800, 0x00101815, 0x59a80805, 0x82040d00, - 0xffffffdf, 0x48075005, 0x0201f800, 0x0010483d, - 0x0201f800, 0x0010513b, 0x0400000a, 0x0201f800, - 0x0010413e, 0x04000007, 0x4a035013, 0x00000001, - 0x497b5021, 0x0201f800, 0x00103c80, 0x0401f04f, - 0x0201f800, 0x001048ec, 0x04000005, 0x59c41002, - 0x8408150c, 0x480b8802, 0x0401f012, 0x0201f800, - 0x0010513b, 0x04020006, 0x59a8001d, 0x80000540, - 0x02000800, 0x0010930f, 0x0401f00a, 0x0201f800, - 0x0010930f, 0x59a80026, 0x8c000506, 0x04020005, - 0x59a8001d, 0x80000540, 0x02020800, 0x00104245, - 0x497b5028, 0x497b5027, 0x497b5018, 0x0201f800, - 0x0010513b, 0x59a81026, 0x0402000a, 0x0201f800, - 0x0010162a, 0x80001580, 0x59a8002a, 0x82000500, - 0xffff0000, 0x80040d40, 0x4807502a, 0x0401f005, - 0x59a8002a, 0x82000500, 0xffff0000, 0x4803502a, - 0x599c0017, 0x8c00050a, 0x04000002, 0x84081544, - 0x480b5026, 0x0201f800, 0x0010513b, 0x04000004, - 0x0201f800, 0x0010162a, 0x48078880, 0x42001000, - 0x00000005, 0x0201f800, 0x001070b0, 0x497b5028, - 0x497b501b, 0x4a03501c, 0x0000ffff, 0x4a0378e4, - 0x000000c0, 0x4202d800, 0x00000002, 0x0201f800, - 0x0010513b, 0x04000007, 0x59a80026, 0x82000500, - 0x0000000c, 0x82000580, 0x00000004, 0x04000003, - 0x0201f800, 0x00101e45, 0x1c01f000, 0x59a8001c, - 0x82000580, 0x0000ffff, 0x04000004, 0x0201f800, - 0x00101e45, 0x0401f074, 0x59a80026, 0x8c00050a, - 0x04020003, 0x8c000506, 0x0400001c, 0x8c000500, - 0x0400001a, 0x4a038802, 0x0000ffbf, 0x8c000502, - 0x04000016, 0x599c0018, 0x8c000516, 0x04020010, - 0x59a80027, 0x82000580, 0x0000ffff, 0x0400000c, - 0x0201f800, 0x00101f9a, 0x59a80026, 0x8c000504, - 0x0402005d, 0x42001000, 0x00000003, 0x417a5800, - 0x0201f800, 0x00101fbf, 0x0401f057, 0x59a80028, - 0x80000540, 0x04020054, 0x59a80026, 0x8c000508, - 0x04020005, 0x59a8001b, 0x80000540, 0x0402004e, - 0x0401f003, 0x8c000516, 0x0400004b, 0x0201f800, - 0x001048ec, 0x04020048, 0x599c0018, 0x8c000516, - 0x04020004, 0x0201f800, 0x00104c51, 0x04020042, - 0x599c0017, 0x8c00050a, 0x0400000d, 0x4200b000, - 0x000007f0, 0x417a8800, 0x0201f800, 0x00020245, - 0x04020004, 0x59340200, 0x8c00051a, 0x04020036, - 0x81468800, 0x8058b040, 0x040207f8, 0x4a038802, - 0x0000ffff, 0x42001800, 0x0010b4eb, 0x0401fb8c, - 0x42001800, 0x0010b4f8, 0x0401fb89, 0x59a80005, - 0x84000502, 0x48035005, 0x4a0378e4, 0x00000080, - 0x4202d800, 0x00000003, 0x4a03501c, 0x0000ffff, - 0x0401fa7f, 0x80000580, 0x0201f800, 0x00101590, - 0x599c0018, 0x8c000516, 0x04000004, 0x0201f800, - 0x00103b10, 0x0401f009, 0x42001800, 0x0000ffff, - 0x42002000, 0x00000006, 0x42003000, 0x00000000, - 0x0201f800, 0x00103aae, 0x0201f800, 0x00105151, - 0x0400000b, 0x59c40006, 0x0201f800, 0x0010513b, - 0x04000004, 0x82000500, 0xffffff0f, 0x0401f003, - 0x82000500, 0xfbffffff, 0x48038806, 0x0201f800, - 0x00106f36, 0x1c01f000, 0x4c040000, 0x4c080000, - 0x4c100000, 0x59a8003e, 0x82000c80, 0x00000004, - 0x04021980, 0x0c01f805, 0x5c002000, 0x5c001000, - 0x5c000800, 0x1c01f000, 0x00100462, 0x001004ea, - 0x00100516, 0x00100577, 0x42000000, 0x00000001, - 0x0201f800, 0x00101590, 0x0201f800, 0x0010609e, - 0x59c408a3, 0x82040d00, 0xfffffff7, 0x480788a3, - 0x0201f800, 0x00105141, 0x0400000e, 0x0201f800, - 0x00105151, 0x0400000b, 0x0201f800, 0x00105149, - 0x04020964, 0x59c400a3, 0x84000532, 0x84000570, - 0x480388a3, 0x4a038808, 0x00000008, 0x0401f010, - 0x59c400a3, 0x84000530, 0x82000500, 0xbf7fffff, - 0x480388a3, 0x42000800, 0x000000f8, 0x0201f800, - 0x00104200, 0x59c400a3, 0x82000540, 0x00018000, - 0x8400051c, 0x480388a3, 0x497b8808, 0x59c40006, - 0x82000500, 0xfbffff0e, 0x48038806, 0x497b2822, - 0x497b2823, 0x42000800, 0x000001f4, 0x42001000, - 0x00100591, 0x0201f800, 0x00105f83, 0x59c40805, - 0x42001000, 0x00000001, 0x0201f800, 0x0010193d, - 0x0201f800, 0x0010163b, 0x0402000a, 0x42000000, - 0x00000001, 0x0201f800, 0x0010188c, 0x42000000, - 0x00000001, 0x0201f800, 0x00101821, 0x0401f022, - 0x0201f800, 0x00101642, 0x04020008, 0x41780000, - 0x0201f800, 0x0010188c, 0x41780000, 0x0201f800, - 0x00101821, 0x0401f018, 0x0201f800, 0x00101649, - 0x0402000a, 0x42000000, 0x00000002, 0x0201f800, - 0x0010188c, 0x42000000, 0x00000002, 0x0201f800, - 0x00101821, 0x0401f00c, 0x0201f800, 0x00101650, - 0x04020918, 0x59a80049, 0x800001c0, 0x04000006, - 0x0201f800, 0x00101656, 0x4a03503e, 0x00000001, - 0x0401f021, 0x0201f800, 0x00101927, 0x4a03503e, - 0x00000001, 0x0201f800, 0x00105141, 0x0400000c, - 0x0201f800, 0x00105151, 0x04000009, 0x0201f800, - 0x00105149, 0x04020903, 0x4a035033, 0x00000001, - 0x0201f800, 0x001050a2, 0x0401f00f, 0x59c400a4, - 0x82000500, 0x0000000f, 0x82000580, 0x00000008, - 0x04000003, 0x4a038805, 0x04000000, 0x59c400a3, - 0x82000540, 0x0001c000, 0x480388a3, 0x84000520, - 0x480388a3, 0x1c01f000, 0x0401f8a3, 0x04020004, - 0x4a03503e, 0x00000003, 0x0401f027, 0x0201f800, - 0x00101650, 0x04020011, 0x59a80049, 0x800001c0, - 0x0400000e, 0x0201f800, 0x00101656, 0x59a80048, - 0x8c00051e, 0x0400001c, 0x0201f800, 0x00105149, - 0x04020009, 0x4a035033, 0x00000001, 0x0201f800, - 0x001050a2, 0x0401f004, 0x0201f800, 0x001018d3, - 0x04020011, 0x0201f800, 0x00101815, 0x4a03503e, - 0x00000002, 0x497b5049, 0x59c400a3, 0x84000520, - 0x480388a3, 0x497b2822, 0x497b2823, 0x42000800, - 0x0000002d, 0x42001000, 0x00100591, 0x0201f800, - 0x00105f83, 0x1c01f000, 0x0401f877, 0x04020004, - 0x4a03503e, 0x00000003, 0x0401f05b, 0x4a038805, - 0x000000f0, 0x0201f800, 0x001018d3, 0x04020050, - 0x0201f800, 0x00105149, 0x04000044, 0x59c400a4, - 0x82000500, 0x0000000f, 0x82000580, 0x00000008, - 0x04000020, 0x59c40005, 0x8c000534, 0x0402001d, - 0x59940022, 0x82000580, 0x00000001, 0x04020046, - 0x0201f800, 0x00105151, 0x04020043, 0x4a038805, - 0x000000f0, 0x0201f800, 0x00105196, 0x4a035032, - 0x0000aaaa, 0x4a035033, 0x00000000, 0x59c408a3, - 0x82040d40, 0x00000008, 0x480788a3, 0x4202d800, - 0x00000001, 0x4a03503e, 0x00000000, 0x4a038805, - 0x00000001, 0x497b2822, 0x497b2823, 0x0401f01f, - 0x0201f800, 0x00105151, 0x04020007, 0x59a80032, - 0x82000580, 0x0000aaaa, 0x04020003, 0x4a035010, - 0x00ffffff, 0x497b5032, 0x59c40006, 0x82000540, - 0x04000001, 0x48038806, 0x59a80805, 0x8c040d06, - 0x04020005, 0x59c408a3, 0x82040d40, 0x00000008, - 0x480788a3, 0x4202d800, 0x00000001, 0x4a03503e, - 0x00000000, 0x4a038805, 0x00000001, 0x497b2822, - 0x497b2823, 0x0401f010, 0x59c40005, 0x82000500, - 0x000000c0, 0x0400000c, 0x59c40006, 0x82000540, - 0x000000f1, 0x48038806, 0x0401f7ef, 0x0201f800, - 0x00101650, 0x04020004, 0x59a80049, 0x800001c0, - 0x040207a4, 0x497b8885, 0x1c01f000, 0x4803c856, - 0x42000000, 0x00000001, 0x0201f800, 0x00101590, - 0x4a03503e, 0x00000000, 0x0201f800, 0x00101650, - 0x0402000b, 0x59a80052, 0x800001c0, 0x04000004, - 0x80000040, 0x48035052, 0x04020005, 0x4a035052, - 0x0000000a, 0x4a035049, 0x00000001, 0x497b8885, - 0x0401f0ed, 0x59940022, 0x59940823, 0x80040540, - 0x1c01f000, 0x497b2823, 0x1c01f000, 0x4c080000, - 0x42001000, 0x000000f0, 0x0201f800, 0x0010193d, - 0x5c001000, 0x1c01f000, 0x4a03505c, 0x00000004, - 0x4a03505d, 0x00000000, 0x4a03505e, 0x00000010, - 0x4a03505f, 0x00000002, 0x4a035010, 0x00ffffff, - 0x0201f800, 0x0010930f, 0x4a03502a, 0x20200000, - 0x4a03502b, 0x88000200, 0x4a03502c, 0x00ff001f, - 0x4a03502d, 0x000007d0, 0x4a03502e, 0x80000000, - 0x4a03502f, 0x00000200, 0x4a035030, 0x00ff0000, - 0x4a035031, 0x00010000, 0x4a03503a, 0x514c4f47, - 0x4a03503b, 0x49432020, 0x1c01f000, 0x4d440000, - 0x417a8800, 0x41780800, 0x0201f800, 0x00020245, - 0x04020005, 0x0201f800, 0x001049e7, 0x04020002, - 0x80040800, 0x81468800, 0x83440580, 0x000007f0, - 0x040207f6, 0x5c028800, 0x1c01f000, 0x4803c857, - 0x5c000000, 0x4c000000, 0x4803c857, 0x0401f809, - 0x485fc857, 0x4203e000, 0x50000000, 0x5c000000, - 0x4d780000, 0x4200b800, 0x00008002, 0x0401f006, - 0x485fc857, 0x4203e000, 0x50000000, 0x4200b800, - 0x00008002, 0x04006000, 0x4c000000, 0x4c040000, - 0x59bc00ea, 0x82000500, 0x00000007, 0x82000580, - 0x00000001, 0x04020005, 0x42000800, 0x00000000, - 0x0201f800, 0x00106c6c, 0x5c000800, 0x4807c025, - 0x80040920, 0x4807c026, 0x5c000000, 0x4803c023, - 0x80000120, 0x4803c024, 0x5c000000, 0x4803c857, - 0x4803c021, 0x80000120, 0x4803c022, 0x41f80000, - 0x4803c027, 0x80000120, 0x4803c028, 0x42000000, - 0x00001000, 0x50000000, 0x82000480, 0x24320001, - 0x4803c857, 0x0400104f, 0x42000800, 0x00000064, - 0x80040840, 0x04000007, 0x4a030000, 0x00000001, - 0x40000000, 0x59800000, 0x8c000500, 0x040007f9, - 0x04000042, 0x42000800, 0x0010c1a3, 0x46000800, - 0xfaceface, 0x80040800, 0x42001000, 0x00007a00, - 0x58080013, 0x44000800, 0x80040800, 0x58080019, - 0x44000800, 0x80040800, 0x5808001a, 0x44000800, - 0x80040800, 0x5808001b, 0x44000800, 0x80040800, - 0x5808001c, 0x44000800, 0x80040800, 0x5808001f, - 0x44000800, 0x80040800, 0x42001000, 0x00007a40, - 0x42001800, 0x0000000b, 0x50080000, 0x44000800, - 0x80081000, 0x80040800, 0x800c1840, 0x040207fb, - 0x42001800, 0x00000003, 0x42001000, 0x00007b00, - 0x480c1003, 0x58080005, 0x44000800, 0x80040800, - 0x800c1840, 0x040217fb, 0x42001000, 0x00007c00, - 0x58080002, 0x44000800, 0x80040800, 0x58080003, - 0x44000800, 0x80040800, 0x58080020, 0x44000800, - 0x80040800, 0x58080021, 0x44000800, 0x80040800, - 0x58080022, 0x44000800, 0x80040800, 0x58080023, - 0x44000800, 0x80040800, 0x4a030000, 0x00000000, - 0x485fc020, 0x905cb9c0, 0x825cbd40, 0x00000012, - 0x485fc011, 0x4203e000, 0x40000000, 0x4202d800, - 0x00000005, 0x59e00017, 0x8c000508, 0x04000003, - 0x4a03c017, 0x00000002, 0x4203e000, 0x30000001, - 0x0401f81a, 0x0401f7ff, 0x4a03c850, 0x0010c1bf, - 0x4a03c851, 0x0010d1be, 0x4a03c853, 0x00000800, - 0x4a03c855, 0x0001eb5a, 0x59e40001, 0x82000540, - 0x00003f00, 0x4803c801, 0x4a03b104, 0x70000002, - 0x4a03a804, 0x70000002, 0x4a03b004, 0x70000002, - 0x42000000, 0x0010b8ec, 0x49780001, 0x49780002, - 0x1c01f000, 0x1c01f000, 0x59a8006b, 0x8c000530, - 0x040207fe, 0x4c080000, 0x42001000, 0x00000004, - 0x0401f862, 0x5c001000, 0x4201d000, 0x00028b0a, - 0x0201f800, 0x0010608e, 0x4c080000, 0x42001000, - 0x00000008, 0x0401f859, 0x5c001000, 0x4201d000, - 0x00028b0a, 0x0201f800, 0x0010608e, 0x4c080000, - 0x42001000, 0x00000010, 0x0401f850, 0x5c001000, - 0x4201d000, 0x00028b0a, 0x0201f800, 0x0010608e, - 0x0401f7e2, 0x8c00050c, 0x59a8086b, 0x04020003, - 0x84040d30, 0x0401f006, 0x84040d70, 0x4807506b, - 0x42001000, 0x00000000, 0x0401f040, 0x4807506b, - 0x836c0500, 0x00000007, 0x0c01f001, 0x001006e1, - 0x001006c7, 0x001006c7, 0x001006af, 0x001006d4, - 0x001006c7, 0x001006c7, 0x001006d4, 0x59a80005, - 0x8c000514, 0x04020013, 0x59c40801, 0x82040d00, - 0x00018000, 0x82040580, 0x00010000, 0x0400000a, - 0x82040580, 0x00008000, 0x04000004, 0x42001000, - 0x42004000, 0x0401f006, 0x42001000, 0x22002000, - 0x0401f003, 0x42001000, 0x12001000, 0x0401f025, - 0x42001000, 0x00001004, 0x0401f022, 0x59a80005, - 0x8c000514, 0x04020008, 0x59a8006b, 0x8c000534, - 0x04020004, 0x42001000, 0x74057005, 0x0401f819, - 0x1c01f000, 0x42001000, 0x00002008, 0x0401f7fc, - 0x59a8006b, 0x8c000534, 0x0402000a, 0x59a80005, - 0x8c000514, 0x04000004, 0x42001000, 0x24052005, - 0x0401f00c, 0x42001000, 0x74057005, 0x0401f009, - 0x1c01f000, 0x1c01f000, 0x82081500, 0x0000001c, - 0x82081540, 0x001c0000, 0x480bc013, 0x1c01f000, - 0x59a8006b, 0x8c000530, 0x04000002, 0x84081570, - 0x480b506b, 0x8c000530, 0x04020005, 0x82081500, - 0x00007000, 0x80081114, 0x0401fff0, 0x1c01f000, - 0x41780000, 0x50041800, 0x800c0400, 0x80040800, - 0x80102040, 0x040207fc, 0x80080500, 0x80000540, - 0x1c01f000, 0x4202f000, 0x00000000, 0x41780000, - 0x41780800, 0x41781000, 0x41781800, 0x41782000, - 0x41782800, 0x41783000, 0x41783800, 0x41784000, - 0x41784800, 0x41785000, 0x41785800, 0x41786000, - 0x41786800, 0x41787000, 0x41787800, 0x41788000, - 0x41788800, 0x41789000, 0x41789800, 0x4178a000, - 0x4178a800, 0x4178b000, 0x4178b800, 0x4178c000, - 0x4178c800, 0x4178d000, 0x4178d800, 0x4178e000, - 0x4178e800, 0x4178f000, 0x4178f800, 0x41790000, - 0x41790800, 0x41791000, 0x41791800, 0x41792000, - 0x41792800, 0x41793000, 0x41793800, 0x41794000, - 0x41794800, 0x41795000, 0x41795800, 0x41796000, - 0x41796800, 0x41797000, 0x41797800, 0x41798000, - 0x41798800, 0x42019000, 0x0010b537, 0x42019800, - 0x0010b50e, 0x4179a000, 0x4179b000, 0x4179a800, - 0x4179b800, 0x4179c800, 0x4179c000, 0x4179d000, - 0x4179d800, 0x4179e000, 0x4179e800, 0x4179f000, - 0x4179f800, 0x417a0000, 0x417a0800, 0x417a1000, - 0x417a1800, 0x417a2000, 0x42022800, 0x00006100, - 0x417a3000, 0x417a3800, 0x417a4000, 0x417a4800, - 0x417a5000, 0x417a5800, 0x417a6000, 0x417a6800, - 0x417a7000, 0x417a7800, 0x417a8000, 0x417a8800, - 0x417a9000, 0x417a9800, 0x417ae800, 0x417af800, - 0x42030000, 0x00007c00, 0x42031000, 0x0010b806, - 0x42031800, 0x0000bf1d, 0x42032000, 0x0000bf32, - 0x42032800, 0x0010b7ce, 0x42033000, 0x0010b46e, - 0x42034000, 0x0010b4a4, 0x42033800, 0x0010b4c3, - 0x42034800, 0x0010b544, 0x42035000, 0x0010b400, - 0x42035800, 0x0010ac00, 0x42030800, 0x0010b505, - 0x417b6000, 0x42036800, 0x00006f00, 0x4203c800, - 0x00003000, 0x42037000, 0x0000ff00, 0x42037800, - 0x0000bf00, 0x42038000, 0x00007700, 0x42038800, - 0x00004000, 0x42039000, 0x00006000, 0x42039800, - 0x0010bedb, 0x4203a000, 0x00007600, 0x4203a800, - 0x00007400, 0x4203b000, 0x00007200, 0x4203b800, - 0x00007100, 0x4203c000, 0x00007000, 0x4203d000, - 0x00000000, 0x4203e800, 0x00101b95, 0x417bd800, - 0x1c01f000, 0x42000800, 0x00100000, 0x50040000, - 0x4c000000, 0x42000000, 0x0000aaaa, 0x44000800, - 0x42001800, 0x00005555, 0x41782000, 0x82102400, - 0x00010000, 0x40100000, 0x80042c00, 0x440c2800, - 0x42003000, 0x0000000a, 0x80183040, 0x040207ff, - 0x50140000, 0x800c0580, 0x04020004, 0x50040000, - 0x800c0580, 0x040207f2, 0x5c000000, 0x44000800, - 0x80142840, 0x4817c861, 0x1c01f000, 0x59a8081f, - 0x800409c0, 0x04020009, 0x49781c0c, 0x4a001a0c, - 0x00000200, 0x4a001804, 0x07000000, 0x59a80010, - 0x9c0001c0, 0x48001805, 0x0401fe01, 0x9c0409c0, - 0x48041806, 0x1c01f000, 0x59a8080c, 0x4006d000, - 0x4202b800, 0x00000001, 0x59a8180d, 0x480fc857, - 0x82041400, 0x00000014, 0x82082400, 0x00000014, - 0x40100000, 0x800c0480, 0x04001006, 0x44080800, - 0x40080800, 0x40101000, 0x815eb800, 0x0401f7f7, - 0x45780800, 0x495f5020, 0x1c01f000, 0x835c0480, - 0x00000020, 0x04001009, 0x496bc857, 0x815eb840, - 0x416a5800, 0x592ed000, 0x497a5800, 0x497a5801, - 0x812e59c0, 0x1c01f000, 0x42000000, 0x0010b853, - 0x0201f800, 0x0010aa47, 0x417a5800, 0x0401f7f9, - 0x815eb840, 0x04001008, 0x416a5800, 0x492fc857, - 0x592ed000, 0x497a5800, 0x497a5801, 0x812e59c0, - 0x1c01f000, 0x42000000, 0x0010b853, 0x0201f800, - 0x0010aa47, 0x417ab800, 0x417a5800, 0x0401f7f8, - 0x492fc857, 0x496a5800, 0x412ed000, 0x815eb800, - 0x59c80000, 0x82000540, 0x00001200, 0x48039000, - 0x1c01f000, 0x492fc857, 0x812e59c0, 0x04000007, - 0x592c0001, 0x497a5801, 0x4c000000, 0x0401fff1, - 0x5c025800, 0x0401f7f9, 0x1c01f000, 0x4807c856, - 0x42007000, 0x0010b7f8, 0x4a007001, 0x00000000, - 0x59e00003, 0x82000540, 0x00008080, 0x4803c003, - 0x4a03b805, 0x90000001, 0x59dc0006, 0x4a03b805, - 0x70000000, 0x59dc0006, 0x4a03b805, 0x30000000, - 0x4200b000, 0x00000020, 0x497bb807, 0x8058b040, - 0x040207fe, 0x4a03b805, 0x30000000, 0x59dc0006, - 0x4a03b805, 0x60000001, 0x59dc0006, 0x4a03b805, - 0x70000001, 0x59dc0006, 0x4a03b805, 0x30000002, - 0x4200b000, 0x00000020, 0x497bb807, 0x8058b040, - 0x040207fe, 0x4a03b805, 0x30000000, 0x59dc0006, - 0x4a03b805, 0x60000001, 0x0401ffa1, 0x04000da5, - 0x42001000, 0x0010b7f6, 0x452c1000, 0x4a025801, - 0x00000001, 0x4a025802, 0x00000100, 0x4a025809, - 0x00107149, 0x497a580a, 0x497a580b, 0x497a580c, - 0x0401ff93, 0x04000d97, 0x42001000, 0x0010b7f7, - 0x452c1000, 0x4a025801, 0x00000000, 0x4a025802, - 0x00000100, 0x4a025809, 0x001011bc, 0x497a5803, - 0x497a5807, 0x497a5808, 0x497a580a, 0x59a80005, - 0x8c00050e, 0x04000006, 0x4a03b805, 0xe0000001, - 0x59dc0006, 0x8c000522, 0x040007fc, 0x1c01f000, - 0x4df00000, 0x4203e000, 0x50000000, 0x4c380000, - 0x40087000, 0x480bc857, 0x4a007002, 0x00000000, - 0x42007000, 0x0010b7f8, 0x82080400, 0x00000000, - 0x45780000, 0x58380005, 0x48087005, 0x80000540, - 0x04000005, 0x82000400, 0x00000000, 0x44080000, - 0x0401f003, 0x480bc857, 0x48087006, 0x58380001, - 0x80000540, 0x0400080c, 0x5c007000, 0x5c03e000, - 0x1c01f000, 0x4c380000, 0x42007000, 0x0010b7f8, - 0x58380001, 0x80000540, 0x04000803, 0x5c007000, - 0x1c01f000, 0x42007000, 0x0010b7f8, 0x58380001, - 0x82000580, 0x00000000, 0x04020012, 0x58380000, - 0x0c01f001, 0x0010088e, 0x0010088d, 0x0010088d, - 0x0010088d, 0x0010088d, 0x0010088d, 0x0010088d, - 0x0010088d, 0x0401fd4b, 0x58380808, 0x800409c0, - 0x04020024, 0x58380006, 0x80000540, 0x04020002, - 0x1c01f000, 0x4803c857, 0x48007002, 0x40006800, - 0x58340000, 0x80000540, 0x04020002, 0x48007005, - 0x48007006, 0x4a03b805, 0x20000000, 0x59dc0006, - 0x4a03b805, 0x30000000, 0x58340007, 0x4803b800, - 0x58340008, 0x4803b801, 0x58340004, 0x48007003, - 0x58340003, 0x48007004, 0x4803b803, 0x58340001, - 0x8c000500, 0x04000004, 0x4a007001, 0x00000001, - 0x0401f028, 0x4a007001, 0x00000002, 0x0401f03d, - 0x0201f800, 0x001093ea, 0x0201f800, 0x0010a69d, - 0x04000017, 0x4a03b805, 0x20000000, 0x59dc0006, - 0x4a03b805, 0x30000000, 0x4807b800, 0x480bb801, - 0x4a007003, 0x00000010, 0x480c7009, 0x42001000, - 0x00100875, 0x0201f800, 0x00105f9a, 0x58380008, - 0x82000400, 0x00000004, 0x48007004, 0x4803b803, - 0x4a007001, 0x00000007, 0x0401f022, 0x0201f800, - 0x00109402, 0x42000800, 0x00000001, 0x42001000, - 0x00100875, 0x0201f800, 0x00105f76, 0x0401f7ba, - 0x4c040000, 0x4c080000, 0x58380803, 0x42001000, - 0x00003fff, 0x82040480, 0x00003fff, 0x04021003, - 0x40041000, 0x80000580, 0x48007003, 0x800800c4, - 0x4803b802, 0x4a03b805, 0x30000002, 0x59dc0006, - 0x4a03b805, 0x70000001, 0x59dc0006, 0x4a03b805, - 0x10000000, 0x5c001000, 0x5c000800, 0x1c01f000, - 0x483bc857, 0x4c040000, 0x4c080000, 0x58380803, - 0x42001000, 0x00003fff, 0x82040480, 0x00003fff, - 0x04021003, 0x40041000, 0x80000580, 0x48007003, - 0x800800c4, 0x4803b802, 0x4a03b805, 0x10000002, - 0x5c001000, 0x5c000800, 0x1c01f000, 0x4c040000, - 0x4c380000, 0x42007000, 0x0010b7f8, 0x59dc0806, - 0x4807c857, 0x4a03b805, 0x20000000, 0x8c040d3e, - 0x04000007, 0x8c040d08, 0x04020cca, 0x58380001, - 0x82000500, 0x00000007, 0x0c01f804, 0x5c007000, - 0x5c000800, 0x1c01f000, 0x0010087d, 0x0010091e, - 0x0010092e, 0x001005d8, 0x001005d8, 0x001005d8, - 0x001005d8, 0x001011ea, 0x4807c856, 0x82040d00, - 0x43000f80, 0x04020009, 0x58380003, 0x80000540, - 0x0400001c, 0x59dc0000, 0x4803b800, 0x59dc0001, - 0x4803b801, 0x0401f7af, 0x58380802, 0x4a000802, - 0x00000200, 0x0401f01e, 0x4807c856, 0x82040d00, - 0x43000f80, 0x04020009, 0x58380003, 0x80000540, - 0x0400000c, 0x59dc0000, 0x4803b800, 0x59dc0001, - 0x4803b801, 0x0401f7b7, 0x58380002, 0x82000400, - 0x00000002, 0x46000000, 0x00000200, 0x0401f00c, - 0x4c340000, 0x58386802, 0x59dc0000, 0x4803c857, - 0x48006807, 0x59dc0001, 0x4803c857, 0x48006808, - 0x4a006802, 0x00000100, 0x5c006800, 0x4a007001, - 0x00000000, 0x4c300000, 0x58386002, 0x0401f80c, - 0x04000009, 0x58300009, 0x82000c80, 0x0010ab4a, - 0x04021c84, 0x82000c80, 0x00020000, 0x04001c81, - 0x0801f800, 0x5c006000, 0x0401f723, 0x4833c857, - 0x803061c0, 0x04000009, 0x59a8000c, 0x80300480, - 0x04001007, 0x59a8000d, 0x80300480, 0x04021004, - 0x82000540, 0x00000001, 0x1c01f000, 0x80000580, - 0x1c01f000, 0x4803c856, 0x4dc00000, 0x42007000, - 0x0010b803, 0x4a007400, 0x00000000, 0x49787001, - 0x42038000, 0x00007720, 0x4a038006, 0x60000001, - 0x4a038009, 0xf4f60000, 0x42038000, 0x00007700, - 0x4a038006, 0x60000001, 0x4a038009, 0xf4f60000, - 0x4a03c822, 0x00000010, 0x4a0370e8, 0x00000000, - 0x0401f809, 0x4a0370e9, 0x00003a0f, 0x4a0370e8, - 0x00000000, 0x4a0370e8, 0x00000001, 0x5c038000, - 0x1c01f000, 0x4c5c0000, 0x4178b800, 0x0401f80a, - 0x5c00b800, 0x1c01f000, 0x4803c856, 0x4c5c0000, - 0x825cbd40, 0x00000001, 0x0401f803, 0x5c00b800, - 0x1c01f000, 0x4803c856, 0x4dc00000, 0x4c500000, - 0x4c580000, 0x4c540000, 0x4a0370e8, 0x00000000, - 0x805cb9c0, 0x04000009, 0x4a038807, 0x00000004, - 0x59b800ea, 0x8c000510, 0x04000004, 0x59b800e0, - 0x0401f87b, 0x0401f7fb, 0x42038000, 0x00007720, - 0x0201f800, 0x00100ec1, 0x59c00007, 0x4a038006, - 0x20000000, 0x59c00007, 0x4a038006, 0x8000000a, - 0x59c00007, 0x4a038006, 0x8000000b, 0x59c00007, - 0x4a038006, 0x40000001, 0x83c00580, 0x00007700, - 0x04000004, 0x42038000, 0x00007700, 0x0401f7ed, - 0x42038000, 0x00007720, 0x42000800, 0x00000800, - 0x59c00007, 0x8c00051e, 0x04000006, 0x4a038006, - 0x90000001, 0x80040840, 0x040207fa, 0x0401fc11, - 0x83c00580, 0x00007700, 0x04000004, 0x42038000, - 0x00007700, 0x0401f7f1, 0x805cb9c0, 0x0402001d, - 0x4200b000, 0x00000020, 0x83b8ac00, 0x00000020, - 0x0201f800, 0x0010ab20, 0x4a0370fb, 0x00000001, - 0x4a037020, 0x001010bd, 0x59a80039, 0x82000500, - 0x0000ffff, 0x48037021, 0x4a037035, 0x0010bddb, - 0x4a037030, 0x0010b410, 0x4a037031, 0x0010ac00, - 0x4a037032, 0x0010b519, 0x4a037036, 0x0010b524, - 0x59840002, 0x48037034, 0x4a037038, 0x001010b4, - 0x4a0370fb, 0x00000001, 0x4178a000, 0x4200b000, - 0x00000020, 0x83b8ac00, 0x00000000, 0x0201f800, - 0x0010ab20, 0x4200b000, 0x00000040, 0x83b8ac00, - 0x00000040, 0x0201f800, 0x0010ab20, 0x805cb9c0, - 0x04020004, 0x4a0370e4, 0xaaaaaaaa, 0x0401f003, - 0x4a0370e4, 0xa2aaaa82, 0x4a0370e5, 0xaaaaaaaa, - 0x4a0370e6, 0xaaaaaaaa, 0x4a0370fb, 0x00000000, - 0x4a0370e6, 0xaaaaaaaa, 0x42038000, 0x00007720, - 0x4a038006, 0x90000000, 0x59c00007, 0x8c00051e, - 0x02020800, 0x001005d8, 0x42038000, 0x00007700, - 0x4a038006, 0x90000000, 0x59c00007, 0x8c00051e, - 0x02020800, 0x001005d8, 0x5c00a800, 0x5c00b000, - 0x5c00a000, 0x5c038000, 0x1c01f000, 0x4d300000, - 0x4d380000, 0x40026000, 0x82000500, 0x7f000000, - 0x82000580, 0x00000003, 0x0402000f, 0x83326500, - 0x00ffffff, 0x59300203, 0x82000580, 0x00000004, - 0x04020009, 0x59300c06, 0x82040580, 0x00000009, - 0x04020005, 0x42027000, 0x00000047, 0x0201f800, - 0x000207a1, 0x5c027000, 0x5c026000, 0x1c01f000, - 0x4d300000, 0x4d2c0000, 0x4d340000, 0x4d400000, - 0x4cfc0000, 0x4d380000, 0x4d3c0000, 0x4d440000, - 0x4d4c0000, 0x4d480000, 0x4c5c0000, 0x4c600000, - 0x4c640000, 0x4cc80000, 0x4ccc0000, 0x4cf00000, - 0x4cf40000, 0x4cf80000, 0x4cfc0000, 0x4d000000, - 0x4d040000, 0x0201f800, 0x00020015, 0x5c020800, - 0x5c020000, 0x5c01f800, 0x5c01f000, 0x5c01e800, - 0x5c01e000, 0x5c019800, 0x5c019000, 0x5c00c800, - 0x5c00c000, 0x5c00b800, 0x5c029000, 0x5c029800, - 0x5c028800, 0x5c027800, 0x5c027000, 0x5c01f800, - 0x5c028000, 0x5c026800, 0x5c025800, 0x5c026000, - 0x1c01f000, 0x493bc857, 0x0201f000, 0x00020044, - 0x83300500, 0x1f000000, 0x04000008, 0x81326580, - 0x80000130, 0x82000c80, 0x00000014, 0x02021800, - 0x001005d8, 0x0c01f013, 0x83300500, 0x000000ff, - 0x82000c80, 0x00000007, 0x02021800, 0x001005d8, - 0x0c01f025, 0x1c01f000, 0x82000d00, 0xc0000038, - 0x02020800, 0x001005d0, 0x0201f800, 0x001005d8, - 0x00000000, 0x00000048, 0x00000054, 0x00000053, - 0x00100a9b, 0x00100abf, 0x00100aba, 0x00100adf, - 0x00100aa6, 0x00100ab2, 0x00100a9b, 0x00100ada, - 0x00100b1a, 0x00100a9b, 0x00100a9b, 0x00100a9b, - 0x00100a9b, 0x00100b1d, 0x00100b23, 0x00100b34, - 0x00100b45, 0x00100a9b, 0x00100b4e, 0x00100b5a, - 0x00100a9b, 0x00100a9b, 0x00100a9b, 0x0201f800, - 0x001005d8, 0x00100aa4, 0x00100bff, 0x00100aec, - 0x00100b0f, 0x00100aa4, 0x00100aa4, 0x00100aa4, - 0x0201f800, 0x001005d8, 0x4803c856, 0x59300004, - 0x8c00053e, 0x04020005, 0x42027000, 0x00000055, - 0x0201f000, 0x000207a1, 0x0201f800, 0x00106f60, - 0x040007fa, 0x1c01f000, 0x4803c856, 0x0401f8a9, - 0x40002800, 0x41782000, 0x42027000, 0x00000056, - 0x0201f000, 0x000207a1, 0x4803c856, 0x42027000, - 0x00000057, 0x0201f000, 0x000207a1, 0x4803c856, - 0x59300007, 0x8c00051a, 0x04020010, 0x59325808, - 0x812e59c0, 0x04000014, 0x592c0408, 0x8c00051c, - 0x04020003, 0x4a026011, 0xffffffff, 0x59300004, - 0x8c00053e, 0x04020009, 0x42027000, 0x00000048, - 0x0201f000, 0x000207a1, 0x59325808, 0x4a025a06, - 0x00000007, 0x0401f7f4, 0x0201f800, 0x00106f60, - 0x040007f6, 0x1c01f000, 0x4803c856, 0x83300500, - 0x00ffffff, 0x0201f000, 0x001064d7, 0x1c01f000, - 0x4c040000, 0x59b808ea, 0x82040d00, 0x00000007, - 0x82040580, 0x00000003, 0x04000004, 0x42000000, - 0x60000000, 0x0401f8ab, 0x5c000800, 0x1c01f000, - 0x0401f8f9, 0x59325808, 0x812e59c0, 0x04000018, - 0x592c0204, 0x82000500, 0x000000ff, 0x82000d80, - 0x00000029, 0x04020012, 0x59300203, 0x82000580, - 0x00000003, 0x0400000b, 0x59300807, 0x84040d26, - 0x48066007, 0x0201f800, 0x00020086, 0x4a03900d, - 0x00000040, 0x4a0370e5, 0x00000008, 0x1c01f000, - 0x0201f800, 0x00106f60, 0x040007f4, 0x59880052, - 0x80000000, 0x48031052, 0x4a03900d, 0x00000040, - 0x42000000, 0xc0000000, 0x0401f05a, 0x42007800, - 0x0010bde2, 0x42002000, 0x00003000, 0x42003000, - 0x00000105, 0x0201f800, 0x00105e04, 0x4a0370e4, - 0x02000000, 0x1c01f000, 0x4933c857, 0x0201f000, - 0x0002077d, 0x41300800, 0x800409c0, 0x02020800, - 0x001005d8, 0x0201f800, 0x001005d0, 0x4933c857, - 0x813261c0, 0x02000800, 0x001005d8, 0x0401f835, - 0x40002800, 0x0201f800, 0x0010a99c, 0x0401f8ae, - 0x04000007, 0x59326809, 0x59340200, 0x8c00050e, - 0x59300414, 0x02020800, 0x001092ce, 0x1c01f000, - 0x4933c857, 0x813261c0, 0x02000800, 0x001005d8, - 0x0401f8a1, 0x0400000b, 0x59325808, 0x0201f800, - 0x00109037, 0x04000007, 0x592c0208, 0x8400054e, - 0x48025a08, 0x417a7800, 0x0201f800, 0x00108be3, - 0x1c01f000, 0x485fc857, 0x5c000000, 0x4d780000, - 0x4203e000, 0x50000000, 0x4200b800, 0x00008005, - 0x0201f000, 0x001005dd, 0x4933c857, 0x83300480, - 0x00000020, 0x02021800, 0x001005d8, 0x83300c00, - 0x0010b8cc, 0x50040000, 0x80000000, 0x04001002, - 0x44000800, 0x1c01f000, 0x4933c857, 0x0401f7f4, - 0x4807c856, 0x59b800ea, 0x8c000510, 0x040007fd, - 0x59b800e0, 0x4803c857, 0x1c01f000, 0x4803c856, - 0x42000000, 0x10000000, 0x41300800, 0x0401f02d, - 0x82000500, 0xf0000000, 0x82040d00, 0x0fffffff, - 0x80040d40, 0x4807c857, 0x59b800ea, 0x8c000516, - 0x04020003, 0x480770e1, 0x1c01f000, 0x8c000510, - 0x040007fa, 0x4c040000, 0x0401f809, 0x5c000800, - 0x82100480, 0x00000008, 0x040017f4, 0x4c040000, - 0x0401febc, 0x5c000800, 0x0401f7f0, 0x59b800e2, - 0x59b820e2, 0x80100580, 0x040207fd, 0x80102114, - 0x0401f006, 0x59b800e2, 0x59b820e2, 0x80100580, - 0x040207fd, 0x0401f001, 0x40101800, 0x800c190a, - 0x82100500, 0x0000001f, 0x820c1d00, 0x0000001f, - 0x800c2480, 0x82102500, 0x0000001f, 0x1c01f000, - 0x82000500, 0xf0000000, 0x82040d00, 0x0fffffff, - 0x80040d40, 0x4807c857, 0x42001000, 0x0010b804, - 0x50080000, 0x80000540, 0x04020005, 0x4a0370e5, - 0x00000003, 0x4a0370e4, 0x00000300, 0x80000000, - 0x44001000, 0x42001000, 0x00000400, 0x59b800ea, - 0x8c000510, 0x0400000c, 0x0401ffd5, 0x82100480, - 0x00000008, 0x04001007, 0x4c040000, 0x4c080000, - 0x0401fe88, 0x5c001000, 0x5c000800, 0x0401f020, - 0x59b800ea, 0x8c000516, 0x0402001d, 0x4a0370e4, - 0x00300000, 0x480770e1, 0x42001000, 0x0000ff00, - 0x80081040, 0x04000012, 0x59b808e4, 0x8c040d28, - 0x040207fc, 0x42001000, 0x0010b804, 0x50080000, - 0x80000040, 0x04020005, 0x4a0370e5, 0x00000002, - 0x4a0370e4, 0x00000200, 0x02001800, 0x001005d8, - 0x44001000, 0x8c040d2c, 0x1c01f000, 0x41f80000, - 0x50000000, 0x0201f800, 0x001005d8, 0x80081040, - 0x040207d3, 0x41f80000, 0x50000000, 0x0201f800, - 0x001005d8, 0x4d380000, 0x59300c06, 0x82040580, - 0x00000009, 0x04020006, 0x42027000, 0x00000047, - 0x0201f800, 0x000207a1, 0x80000580, 0x5c027000, - 0x1c01f000, 0x4c500000, 0x4a03900d, 0x00000001, - 0x59c8a020, 0x4a03900d, 0x00000002, 0x59c80820, - 0x8c50a52e, 0x04000002, 0x900409c0, 0x82040d00, - 0x0000ffff, 0x0201f800, 0x00105dd7, 0x02000800, - 0x001005d8, 0x4933c857, 0x8250a500, 0xff000000, - 0x82500580, 0x05000000, 0x04000003, 0x82000540, - 0x00000001, 0x5c00a000, 0x1c01f000, 0x0401ffe6, - 0x4933c857, 0x59300406, 0x82000580, 0x00000000, - 0x04000040, 0x59c82021, 0x4a03900d, 0x00000001, - 0x59c82821, 0x82142d00, 0x0000ffff, 0x59325808, - 0x812e59c0, 0x04000037, 0x59326809, 0x0201f800, - 0x001048d9, 0x02020800, 0x001092b6, 0x599c0019, - 0x8c00050c, 0x04020018, 0x0201f800, 0x001048d9, - 0x04020015, 0x59300811, 0x4807c857, 0x592c0408, - 0x8c00051c, 0x0402000e, 0x8400055c, 0x48025c08, - 0x592c0a04, 0x82040d00, 0x000000ff, 0x82040580, - 0x00000048, 0x04000004, 0x82040580, 0x00000018, - 0x04020003, 0x59300811, 0x48065803, 0x4a026011, - 0x7fffffff, 0x48166013, 0x0201f800, 0x001010dd, - 0x04020014, 0x0401f9fd, 0x40280000, 0x4802600d, - 0x04000005, 0x4832600b, 0x50200000, 0x4802600a, - 0x4822600c, 0x59300414, 0x8c00051c, 0x04020004, - 0x599c0019, 0x8c00050c, 0x0402086e, 0x4a03900d, - 0x00000040, 0x4a0370e5, 0x00000008, 0x1c01f000, - 0x59880052, 0x80000000, 0x48031052, 0x4a03900d, - 0x00000040, 0x42000000, 0xc0000000, 0x0401f71d, - 0x4cf80000, 0x58f40000, 0x8001f540, 0x0401f820, - 0x41781800, 0x0401f8e4, 0x04020014, 0x44140800, - 0x0401f82a, 0x04000011, 0x40043800, 0x42001800, - 0x00000001, 0x40142000, 0x0401f8db, 0x0402000b, - 0x801c3800, 0x501c0000, 0x44000800, 0x0401f810, - 0x801c0580, 0x04000004, 0x44103800, 0x801c3840, - 0x44143800, 0x0401f819, 0x5c01f000, 0x1c01f000, - 0x80f9f1c0, 0x04020003, 0x58f41202, 0x0401f003, - 0x42001000, 0x00000007, 0x1c01f000, 0x80f9f1c0, - 0x04020006, 0x58f40401, 0x82000480, 0x00000002, - 0x80f40400, 0x0401f005, 0x58f80401, 0x82000480, - 0x00000002, 0x80f80400, 0x50002800, 0x80000000, - 0x50002000, 0x1c01f000, 0x80f9f1c0, 0x04020008, - 0x58f40401, 0x82000480, 0x00000002, 0x02001800, - 0x001005d8, 0x4801ec01, 0x0401f00b, 0x58f80401, - 0x82000480, 0x00000002, 0x02001800, 0x001005d8, - 0x4801f401, 0x82000580, 0x00000002, 0x04020002, - 0x0401f809, 0x58f40202, 0x80000040, 0x4801ea02, - 0x02000800, 0x001005d8, 0x82000580, 0x00000001, - 0x1c01f000, 0x4d2c0000, 0x40fa5800, 0x0201f800, - 0x001007f4, 0x4979e800, 0x4179f000, 0x5c025800, - 0x1c01f000, 0x80f5e9c0, 0x04000009, 0x80f9f1c0, - 0x04020ff5, 0x4d2c0000, 0x40f65800, 0x0201f800, - 0x001007f4, 0x4179e800, 0x5c025800, 0x1c01f000, - 0x4cf40000, 0x59300807, 0x82040500, 0x00003100, - 0x04020032, 0x8c040d22, 0x04000032, 0x5930001f, - 0x8001ed40, 0x02000800, 0x001005d8, 0x82000580, - 0xffffffff, 0x04000029, 0x58f40201, 0x82000580, - 0x0000dcb3, 0x02020800, 0x001005d8, 0x58f40a02, - 0x82040500, 0x0000fffe, 0x04000003, 0x0401ff89, - 0x58f40a02, 0x82040480, 0x0000000f, 0x04021059, - 0x80040800, 0x4805ea02, 0x82040580, 0x00000008, - 0x0400005d, 0x82040480, 0x00000008, 0x0400100a, - 0x58f40000, 0x8001ed40, 0x02000800, 0x001005d8, - 0x58f40201, 0x82000580, 0x0000ddb9, 0x02020800, - 0x001005d8, 0x58f40401, 0x82000c00, 0x00000002, - 0x4805ec01, 0x80f40400, 0x59300812, 0x44040000, - 0x80000000, 0x45780000, 0x5c01e800, 0x1c01f000, - 0x42001000, 0x00000400, 0x59b800e4, 0x8c000524, - 0x04020023, 0x4a0370e4, 0x00030000, 0x40000000, - 0x59b800e4, 0x8c000524, 0x0402001b, 0x59300807, - 0x84040d62, 0x48066007, 0x4a0370e4, 0x00020000, - 0x4d2c0000, 0x0201f800, 0x001007d3, 0x04000025, - 0x492e601f, 0x4a025a01, 0x0000dcb3, 0x59300008, - 0x80001d40, 0x02000800, 0x001005d8, 0x580c080f, - 0x48065803, 0x59301811, 0x40040000, 0x800c0580, - 0x0402000d, 0x497a5a02, 0x4a025c01, 0x00000004, - 0x0401f011, 0x4a0370e4, 0x00020000, 0x40000000, - 0x40000000, 0x80081040, 0x02000800, 0x001005d8, - 0x0401f7d6, 0x4a025a02, 0x00000001, 0x4a025c01, - 0x00000006, 0x497a5804, 0x400c0000, 0x80040480, - 0x48025805, 0x412de800, 0x5c025800, 0x0401f7a9, - 0x5c025800, 0x4a02601f, 0xffffffff, 0x0401f7c3, - 0x4d2c0000, 0x58f65800, 0x0201f800, 0x001007f4, - 0x40f65800, 0x0201f800, 0x001007f4, 0x5c025800, - 0x0401f7f5, 0x4d2c0000, 0x0201f800, 0x001007d3, - 0x040007f8, 0x4a025a01, 0x0000ddb9, 0x4a025c01, - 0x00000002, 0x492de800, 0x412de800, 0x5c025800, - 0x0401f7a5, 0x0401ff33, 0x82f40400, 0x00000004, - 0x800c0400, 0x40000800, 0x50040000, 0x80100580, - 0x04000016, 0x82040c00, 0x00000002, 0x80081040, - 0x040207fa, 0x80f9f1c0, 0x04000011, 0x58f41202, - 0x82081480, 0x00000007, 0x82f80400, 0x00000002, - 0x800c0400, 0x40000800, 0x50040000, 0x80100580, - 0x04000006, 0x82040c00, 0x00000002, 0x80081040, - 0x040207fa, 0x0401f002, 0x1c01f000, 0x82000540, - 0x00000001, 0x0401f7fd, 0x4cf40000, 0x4cf80000, - 0x4001e800, 0x592c0a06, 0x800409c0, 0x0402001d, - 0x82f40580, 0xffffffff, 0x04000017, 0x58f40201, - 0x82000580, 0x0000dcb3, 0x02020800, 0x001005d8, - 0x58f40000, 0x8001f540, 0x04000006, 0x58f80201, - 0x82000580, 0x0000ddb9, 0x02020800, 0x001005d8, - 0x41783800, 0x0401f839, 0x04020006, 0x0401ff32, - 0x497a601f, 0x5c01f000, 0x5c01e800, 0x1c01f000, - 0x0401ff2d, 0x4a025a06, 0x00000011, 0x0401f7f9, - 0x82f40580, 0xffffffff, 0x04020f27, 0x0401f7f5, - 0x4cf40000, 0x4cf80000, 0x4001e800, 0x82040580, - 0x00000001, 0x0402001f, 0x82f40580, 0xffffffff, - 0x04000019, 0x58f40201, 0x82000580, 0x0000dcb3, - 0x02020800, 0x001005d8, 0x58f40000, 0x8001f540, - 0x04000006, 0x58f80201, 0x82000580, 0x0000ddb9, - 0x02020800, 0x001005d8, 0x41783800, 0x0401f813, - 0x04020008, 0x0401ff0c, 0x42000800, 0x00000001, - 0x497a601f, 0x5c01f000, 0x5c01e800, 0x1c01f000, - 0x0401ff05, 0x42000800, 0x00000011, 0x0401f7f9, - 0x4c040000, 0x82f40580, 0xffffffff, 0x04020efe, - 0x5c000800, 0x0401f7f3, 0x4803c856, 0x401c2000, - 0x41781800, 0x0401ff8c, 0x0402002c, 0x58f42003, - 0x42001800, 0x00000001, 0x0401ff87, 0x04020027, - 0x0401feb8, 0x40082800, 0x82f40400, 0x00000004, - 0x40003000, 0x50182000, 0x40100000, 0x801c0580, - 0x04000005, 0x42001800, 0x00000001, 0x0401ff7a, - 0x0402001a, 0x82183400, 0x00000002, 0x80142840, - 0x040207f5, 0x80f9f1c0, 0x04000013, 0x58f42a02, - 0x82142c80, 0x00000007, 0x82f80400, 0x00000003, - 0x40003000, 0x50182000, 0x40100000, 0x801c0580, - 0x04000005, 0x42001800, 0x00000001, 0x0401ff66, - 0x04020006, 0x82183400, 0x00000002, 0x80142840, - 0x040207f5, 0x1c01f000, 0x82000540, 0x00000001, - 0x0401f7fd, 0x0201f800, 0x001005d8, 0x58380207, - 0x8c000502, 0x040007fc, 0x50200000, 0x80387c00, - 0x583c2800, 0x583c2001, 0x58380404, 0x80001540, - 0x04020002, 0x58381407, 0x58c83401, 0x58380c08, - 0x59303807, 0x497a6012, 0x497a6013, 0x0201f000, - 0x000200be, 0x592c0408, 0x8c000502, 0x040007ea, - 0x592c0409, 0x80000540, 0x040007e7, 0x82000c80, - 0x00000002, 0x04001011, 0x58380001, 0x80007540, - 0x02000800, 0x001005d8, 0x58380204, 0x82000500, - 0x0000000f, 0x82000400, 0x001010bd, 0x50004000, - 0x40040000, 0x800409c0, 0x04000005, 0x82040c80, - 0x00000005, 0x040217f1, 0x80204400, 0x50200000, - 0x80387c00, 0x583c2800, 0x583c2001, 0x583c1002, - 0x592c0a07, 0x592c4c08, 0x592c300d, 0x59303807, - 0x497a6012, 0x497a6013, 0x4816600e, 0x4812600f, - 0x480a6010, 0x481a6011, 0x80040840, 0x4806600d, - 0x02000000, 0x000200c6, 0x80204000, 0x50201800, - 0x800c19c0, 0x0402000c, 0x58380001, 0x80007540, - 0x02000800, 0x001005d8, 0x58380204, 0x82000500, - 0x0000000f, 0x82000400, 0x001010bd, 0x50004000, - 0x50201800, 0x483a600b, 0x480e600a, 0x4822600c, - 0x0201f000, 0x000200c6, 0x4803c856, 0x592c0208, - 0x8c00051e, 0x04020017, 0x50200000, 0x80306c00, - 0x40240000, 0x0c01f001, 0x00100e46, 0x00100e46, - 0x00100e4f, 0x00100e46, 0x00100e46, 0x00100e46, - 0x00100e46, 0x00100e46, 0x00100e4f, 0x00100e46, - 0x00100e4f, 0x00100e46, 0x00100e46, 0x00100e4f, - 0x00100e46, 0x00100e46, 0x0201f800, 0x001005d8, - 0x8400051e, 0x48025a08, 0x50200000, 0x80306c00, - 0x58343801, 0x481e600f, 0x0401f007, 0x58341802, - 0x58342800, 0x58343801, 0x480e6010, 0x4816600e, - 0x481e600f, 0x0401f246, 0x4933c857, 0x5931f808, - 0x59300a06, 0x800409c0, 0x04000005, 0x80040906, - 0x04020002, 0x80040800, 0x4805fc06, 0x4a026206, - 0x00000002, 0x592c0409, 0x82000500, 0x00000008, - 0x0400000b, 0x0401f834, 0x59300203, 0x82000580, - 0x00000004, 0x04020005, 0x42027000, 0x00000048, - 0x0201f800, 0x000207a1, 0x1c01f000, 0x4cfc0000, - 0x58fc0204, 0x82000500, 0x000000ff, 0x82000580, - 0x00000048, 0x0402000c, 0x58fc000b, 0x800001c0, - 0x04000009, 0x58fc0407, 0x800001c0, 0x04000006, - 0x58fc080b, 0x8c040d16, 0x04000017, 0x58fc0007, - 0x0401f00a, 0x58fc0408, 0x8c000512, 0x04020014, - 0x58fc0c09, 0x8c040d16, 0x04020003, 0x5c01f800, - 0x1c01f000, 0x58fc000a, 0x59300811, 0x80040580, - 0x04020009, 0x59300007, 0x84000500, 0x48026007, - 0x42027000, 0x00000048, 0x5c01f800, 0x0201f000, - 0x000207a1, 0x5c01f800, 0x1c01f000, 0x58fdf809, - 0x0401f7ec, 0x4933c857, 0x59b808ea, 0x82040d00, - 0x00000007, 0x82040580, 0x00000000, 0x0400001e, - 0x82040580, 0x00000003, 0x0400001b, 0x59300406, - 0x4c000000, 0x4a026406, 0x00000000, 0x42003000, - 0x00000041, 0x42000000, 0x50000000, 0x41300800, - 0x4c180000, 0x0401fce7, 0x5c003000, 0x0400000b, - 0x42000000, 0x0000001e, 0x80000040, 0x040207ff, - 0x80183040, 0x040207f4, 0x42000000, 0x40000000, - 0x41300800, 0x0401fcdb, 0x5c000000, 0x48026406, - 0x1c01f000, 0x59300007, 0x84000500, 0x48026007, - 0x0401f7fc, 0x59c00007, 0x4a038006, 0x30000000, - 0x40000000, 0x59c00007, 0x8c00050a, 0x040207fe, - 0x1c01f000, 0x5c000000, 0x4c000000, 0x4803c857, - 0x4dc00000, 0x4a0370e8, 0x00000000, 0x42038000, - 0x00007720, 0x0401fff0, 0x42038000, 0x00007700, - 0x0401ffed, 0x0201f800, 0x0010513b, 0x04020013, - 0x4a038891, 0x0000ffff, 0x497b8880, 0x497b8892, - 0x42001000, 0x00000190, 0x40000000, 0x40000000, - 0x80081040, 0x040207fd, 0x42000000, 0x0010b8a6, - 0x0201f800, 0x0010aa47, 0x0401f80e, 0x5c038000, - 0x0201f000, 0x00105258, 0x0401f82d, 0x42000000, - 0x0010b8a7, 0x0201f800, 0x0010aa47, 0x0401f805, - 0x48178892, 0x480b8880, 0x5c038000, 0x1c01f000, - 0x496fc857, 0x836c0580, 0x00000003, 0x0402000b, - 0x4c080000, 0x4c0c0000, 0x42001000, 0x00008048, - 0x42001800, 0x0000ffff, 0x0201f800, 0x00103a3e, - 0x5c001800, 0x5c001000, 0x42000800, 0x0000003c, - 0x0201f800, 0x00101345, 0x59a8006c, 0x80000540, - 0x04000006, 0x59a8106d, 0x800811c0, 0x04000003, - 0x0201f800, 0x00101aaf, 0x4a038891, 0x0000ffff, - 0x4a03900d, 0x00000040, 0x0201f800, 0x0010098e, - 0x4a0370e8, 0x00000001, 0x1c01f000, 0x5c000000, - 0x4c000000, 0x4803c857, 0x59c41080, 0x497b8880, - 0x59c42892, 0x497b8892, 0x0201f800, 0x0010513b, - 0x04020002, 0x1c01f000, 0x42002000, 0x00000260, - 0x59c418a4, 0x820c1d00, 0x0000000f, 0x820c0580, - 0x00000000, 0x04000010, 0x59c41805, 0x820c1d00, - 0x00000001, 0x0402000e, 0x59c418a4, 0x820c1d00, - 0x0000000f, 0x820c0480, 0x00000007, 0x04001004, - 0x820c0480, 0x0000000c, 0x04001003, 0x80102040, - 0x040207ec, 0x497b8891, 0x1c01f000, 0x4c100000, - 0x42002000, 0x00000019, 0x46000000, 0x00000001, - 0x0201f800, 0x00101937, 0x50001800, 0x820c1d00, - 0x00000001, 0x04000005, 0x80102040, 0x040207f7, - 0x5c002000, 0x0401f7f0, 0x5c002000, 0x0401f7ec, - 0x4803c856, 0x1c01f000, 0x4d2c0000, 0x59325808, - 0x592c0a04, 0x4807c857, 0x82040d00, 0x000000ff, - 0x82040500, 0x0000000f, 0x0c01f001, 0x00100f67, - 0x00100f67, 0x00100f67, 0x00100f7f, 0x00100f67, - 0x00100f67, 0x00100f67, 0x00100f67, 0x00100f67, - 0x00100f7f, 0x00100f67, 0x00100f69, 0x00100f67, - 0x00100f67, 0x00100f67, 0x00100f67, 0x0201f800, - 0x001005d8, 0x82040580, 0x0000003b, 0x02020800, - 0x001005d8, 0x592c020a, 0x8c000500, 0x0400005f, - 0x592c1a07, 0x82040500, 0x0000000f, 0x82000400, - 0x001010bd, 0x50001000, 0x50080000, 0x59302013, - 0x4802600a, 0x492e600b, 0x480a600c, 0x480e600d, - 0x48126012, 0x5c025800, 0x1c01f000, 0x82040500, - 0x0000000f, 0x82000400, 0x001010bd, 0x50001000, - 0x50080000, 0x592c1a07, 0x4802600a, 0x492e600b, - 0x480a600c, 0x480e600d, 0x497a6012, 0x0401f7f2, - 0x8c040d00, 0x04020041, 0x82040d00, 0x00000080, - 0x0400003e, 0x0201f000, 0x000200cf, 0x59300013, - 0x59301012, 0x80080580, 0x0402000c, 0x42007800, - 0x80000005, 0x592c1208, 0x82080500, 0xffff7fff, - 0x48025a08, 0x8c08151e, 0x0402002d, 0x823c7d40, - 0x00000020, 0x0401f02a, 0x480bc857, 0x42000000, - 0x0010b851, 0x0201f800, 0x0010aa47, 0x59300414, - 0x4803c857, 0x8c000514, 0x04020007, 0x599c1819, - 0x8c0c1d12, 0x04020004, 0x820c1d40, 0x00000001, - 0x0401f01d, 0x59302013, 0x0401f92b, 0x0402001a, - 0x42007800, 0x80000005, 0x5930500d, 0x592c0208, - 0x4803c857, 0x8c00051e, 0x04020005, 0x823c7d40, - 0x00000020, 0x5930400c, 0x0401f004, 0x8400051e, - 0x48025a08, 0x0401f8da, 0x50201800, 0x480e600a, - 0x4832600b, 0x4822600c, 0x482a600d, 0x480fc857, - 0x4833c857, 0x4823c857, 0x482bc857, 0x80000580, - 0x483e6004, 0x1c01f000, 0x0201f800, 0x001005d8, - 0x4933c857, 0x4d2c0000, 0x59900004, 0x81300580, - 0x02020800, 0x001005d8, 0x0201f800, 0x00109037, - 0x02000800, 0x001005d8, 0x59325808, 0x4d3c0000, - 0x4d400000, 0x59300004, 0x4803c857, 0x4c000000, - 0x0201f800, 0x00106dc3, 0x0201f800, 0x00106b8a, - 0x5c000000, 0x8c000516, 0x04000010, 0x592c000f, - 0x4803c857, 0x48025807, 0x41780800, 0x42028000, - 0x00000002, 0x0201f800, 0x00104e70, 0x4a025c06, - 0x0000ffff, 0x0201f800, 0x000202da, 0x0201f800, - 0x00107911, 0x0401f015, 0x4a026203, 0x00000002, - 0x592c0208, 0x8400054e, 0x48025a08, 0x59300406, - 0x82000580, 0x00000006, 0x04020009, 0x811800ca, - 0x81c80c00, 0x58040939, 0x592c000d, 0x80040480, - 0x592c080f, 0x80040480, 0x4802580b, 0x417a7800, - 0x0201f800, 0x00108be3, 0x5c028000, 0x5c027800, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x4d2c0000, - 0x59900004, 0x81300580, 0x02020800, 0x001005d8, - 0x0201f800, 0x00109037, 0x02000800, 0x001005d8, - 0x59325808, 0x592c0208, 0x84000540, 0x48025a08, - 0x0401f7bf, 0x491bc857, 0x49d3c857, 0x4dd00000, - 0x41780800, 0x8007a0ca, 0x83d3a400, 0x00007600, - 0x4a03a005, 0x80000002, 0x42000000, 0x00001000, - 0x50000000, 0x82000480, 0x24220001, 0x04020029, - 0x59d01006, 0x82080500, 0x00006000, 0x82000580, - 0x00006000, 0x0400002f, 0x82080500, 0x40008000, - 0x040007f8, 0x800409c0, 0x0402002a, 0x811a31c0, - 0x04000028, 0x42000000, 0x00001002, 0x50001000, - 0x46000000, 0x00000512, 0x42001800, 0x0000000a, - 0x59e00000, 0x8c00051a, 0x040207fc, 0x800c1840, - 0x040207fc, 0x42000000, 0x00001002, 0x46000000, - 0x00000514, 0x42001800, 0x0000000a, 0x59e00000, - 0x8c00053a, 0x040207fc, 0x800c1840, 0x040207fc, - 0x42000000, 0x00001002, 0x44080000, 0x0401f00d, - 0x59d01006, 0x82080500, 0x00006000, 0x82000580, - 0x00006000, 0x04000007, 0x8c08151e, 0x040007f9, - 0x59d01006, 0x82080500, 0x00006000, 0x040207f5, - 0x83d3a400, 0x00000020, 0x80040800, 0x82040480, - 0x00000005, 0x040017bf, 0x5c03a000, 0x1c01f000, - 0x491bc857, 0x49d3c857, 0x4dd00000, 0x41780800, - 0x8007a0ca, 0x83d3a400, 0x00007600, 0x4a03a005, - 0x80000001, 0x59d00006, 0x83d3a400, 0x00000020, - 0x80040800, 0x82040480, 0x00000005, 0x040017f8, - 0x5c03a000, 0x1c01f000, 0x59d00006, 0x8c00053e, - 0x0400001e, 0x59902804, 0x4817c857, 0x801429c0, - 0x04000013, 0x5990000a, 0x5990080b, 0x5990100c, - 0x5990180d, 0x4800280a, 0x4804280b, 0x4808280c, - 0x480c280d, 0x59d00000, 0x59d00801, 0x59d01002, - 0x59d01803, 0x59d02004, 0x4800280e, 0x4804280f, - 0x48082810, 0x480c2811, 0x48102812, 0x59900006, - 0x82000500, 0xffff0000, 0x48032006, 0x4a03a005, - 0x30000000, 0x59d00006, 0x1c01f000, 0x4803c856, - 0x80204000, 0x50200000, 0x80000540, 0x04000003, - 0x80285040, 0x1c01f000, 0x58300001, 0x80000540, - 0x0400000e, 0x4802600b, 0x40006000, 0x58300204, - 0x82000500, 0x0000000f, 0x82000400, 0x001010bd, - 0x50004000, 0x802041c0, 0x02000800, 0x001005d8, - 0x80285040, 0x1c01f000, 0x40005000, 0x1c01f000, - 0x00000005, 0x00000008, 0x0000000b, 0x0000000e, - 0x00000011, 0x00000000, 0x00000000, 0x0000000b, - 0x00000000, 0x00000000, 0x00000000, 0x001010b8, - 0x001010b7, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x001010b8, 0x001010b7, 0x001010b4, - 0x001010b8, 0x001010b7, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x001010b8, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x001010b8, 0x001010b8, 0x001010b8, - 0x00000000, 0x001010b8, 0x00000000, 0x00000000, - 0x00000000, 0x4813c857, 0x492fc857, 0x4933c857, - 0x48126012, 0x592c5207, 0x802851c0, 0x0400004a, - 0x412c6000, 0x0401f84b, 0x04000009, 0x82240580, - 0x00000002, 0x04020003, 0x5830000d, 0x80102480, - 0x50200000, 0x80004540, 0x0400003f, 0x50200000, - 0x80000540, 0x0400000b, 0x80301400, 0x58080002, - 0x80102480, 0x0400101e, 0x801021c0, 0x04000009, - 0x80285040, 0x04000034, 0x80204000, 0x0401f7f4, - 0x58300001, 0x80006540, 0x0400002f, 0x0401f7e6, - 0x80285040, 0x0400002c, 0x80204000, 0x50200000, - 0x80000540, 0x0402000a, 0x58300001, 0x80006540, - 0x04000025, 0x58300204, 0x82004d00, 0x0000000f, - 0x82244400, 0x001010bd, 0x50204000, 0x592c0208, - 0x8400051e, 0x48025a08, 0x0401f013, 0x80102080, - 0x80102000, 0x48126010, 0x4813c857, 0x58080802, - 0x40100000, 0x80042480, 0x02001800, 0x001005d8, - 0x58080000, 0x58081801, 0x80102400, 0x4812600e, - 0x480e600f, 0x4813c857, 0x592c0208, 0x8400055e, - 0x48025a08, 0x4833c857, 0x4823c857, 0x482bc857, - 0x4832600b, 0x4822600c, 0x482a600d, 0x80000580, - 0x0401f003, 0x82000540, 0x00000001, 0x1c01f000, - 0x58300204, 0x82004d00, 0x0000000f, 0x82244400, - 0x001010bd, 0x82000500, 0x000000ff, 0x82000580, - 0x00000029, 0x0402001b, 0x50204000, 0x592c0409, - 0x80000540, 0x02000800, 0x001005d8, 0x82000c80, - 0x00000002, 0x04001011, 0x58300001, 0x80006540, - 0x02000800, 0x001005d8, 0x58300204, 0x82000500, - 0x0000000f, 0x82000400, 0x001010bd, 0x50004000, - 0x40040000, 0x800409c0, 0x04000006, 0x82040c80, - 0x00000005, 0x040217f1, 0x80204400, 0x80000580, - 0x1c01f000, 0x59e00004, 0x8c00050e, 0x02020000, - 0x00100903, 0x1c01f000, 0x4c5c0000, 0x59e4b800, - 0x485fc857, 0x825c0500, 0x0000001f, 0x04000004, - 0x59e40862, 0x0201f800, 0x001005d8, 0x825c0500, - 0x000000e0, 0x02000800, 0x001005d8, 0x8c5cbd0e, - 0x04020807, 0x8c5cbd0c, 0x04020809, 0x8c5cbd0a, - 0x04020878, 0x5c00b800, 0x1c01f000, 0x4803c856, - 0x4a03c800, 0x00000080, 0x1c01f000, 0x4d2c0000, - 0x42007800, 0x0010b8ec, 0x583c0001, 0x583c0802, - 0x80040540, 0x0400003f, 0x42000800, 0x0010b7f7, - 0x50065800, 0x592c0002, 0x82000580, 0x00000000, - 0x0400000e, 0x59e40850, 0x59e41853, 0x400c0000, - 0x80040400, 0x59e40852, 0x4807c857, 0x80041480, - 0x04021008, 0x40001000, 0x480bc857, 0x4a007800, - 0x00000001, 0x0401f006, 0x4803c857, 0x0401f029, - 0x59e41050, 0x480bc857, 0x49787800, 0x480bc857, - 0x480fc857, 0x592c0003, 0x80000540, 0x04000006, - 0x80080580, 0x04020004, 0x592c0003, 0x4803c857, - 0x480bc857, 0x480a5803, 0x592c0007, 0x800001c0, - 0x04000007, 0x592c1007, 0x480bc857, 0x583c0003, - 0x4803c857, 0x80080480, 0x04001003, 0x583c1001, - 0x480bc857, 0x583c0802, 0x480bc857, 0x4807c857, - 0x4a025801, 0x00000000, 0x4a025809, 0x001011bc, - 0x480a5807, 0x48065808, 0x59e40053, 0x48025804, - 0x412c1000, 0x492fc857, 0x0201f800, 0x00100858, - 0x5c025800, 0x4a03c800, 0x00000040, 0x1c01f000, - 0x42007800, 0x0010b7f7, 0x503c7800, 0x4a007802, - 0x00000100, 0x42007800, 0x0010b8ec, 0x583c0000, - 0x4803c857, 0x82000d80, 0x00000001, 0x04000004, - 0x80000000, 0x48007800, 0x0401f019, 0x49787800, - 0x583c1806, 0x583c0005, 0x800c1800, 0x480c7806, - 0x800c0580, 0x04020002, 0x49787806, 0x583c0807, - 0x800409c0, 0x0400000e, 0x583c0008, 0x80000000, - 0x48007808, 0x80040580, 0x04020009, 0x49787808, - 0x583c2006, 0x42001800, 0x00000001, 0x42001000, - 0x00008028, 0x0201f800, 0x00103a3e, 0x1c01f000, - 0x4a03c800, 0x00000020, 0x0201f800, 0x0010aa40, - 0x59e40000, 0x1c01f000, 0x4d2c0000, 0x4a007001, - 0x00000000, 0x82040d00, 0x43000f80, 0x02020800, - 0x001005d8, 0x58380009, 0x4803c00f, 0x0201f800, - 0x00109402, 0x583a5808, 0x592c0000, 0x48007008, - 0x800001c0, 0x04020002, 0x49787007, 0x0201f800, - 0x001007f4, 0x5c025800, 0x0201f000, 0x0010087d, - 0x4803c856, 0x4c3c0000, 0x4d2c0000, 0x4d300000, - 0x5830000a, 0x80025d40, 0x02000800, 0x001005d8, - 0x592e6008, 0x4c300000, 0x0201f800, 0x0010941a, - 0x5c006000, 0x02000800, 0x001005d8, 0x58300002, - 0x82000580, 0x00000100, 0x04020010, 0x5930780b, - 0x583c0001, 0x80000540, 0x0400000e, 0x4802600b, - 0x40007800, 0x82000400, 0x00000002, 0x48006003, - 0x583c0000, 0x48006004, 0x40301000, 0x0201f800, - 0x00100858, 0x0401f00c, 0x4a025a06, 0x00000002, - 0x4c300000, 0x0201f800, 0x000202da, 0x5c006000, - 0x40325800, 0x0201f800, 0x001007f4, 0x0201f800, - 0x0002077d, 0x5c026000, 0x5c025800, 0x5c007800, - 0x1c01f000, 0x4803c856, 0x4d2c0000, 0x4d300000, - 0x42007000, 0x0010b7f8, 0x58380801, 0x82040580, - 0x00000002, 0x04020011, 0x58386002, 0x5830000a, - 0x812c0580, 0x0402000d, 0x59e00004, 0x8c00050e, - 0x040007fe, 0x59dc0006, 0x4803c857, 0x4a03b805, - 0x20000000, 0x8c00053e, 0x040007f8, 0x4a007001, - 0x00000000, 0x0401f019, 0x58386006, 0x40305000, - 0x803061c0, 0x02000800, 0x001005d8, 0x5830000a, - 0x812c0580, 0x04000004, 0x40305000, 0x58306000, - 0x0401f7f8, 0x40280000, 0x80300580, 0x58300000, - 0x04000006, 0x48005000, 0x800001c0, 0x04020007, - 0x48287005, 0x0401f005, 0x800001c0, 0x04020002, - 0x48007005, 0x48007006, 0x40325800, 0x0201f800, - 0x001007f4, 0x42007000, 0x0010b7f8, 0x58380001, - 0x82000580, 0x00000000, 0x02000800, 0x0010087d, - 0x5c026000, 0x5c025800, 0x1c01f000, 0x4803c856, - 0x42000800, 0x0000003c, 0x48079000, 0x59c80000, - 0x80040500, 0x040207fe, 0x497b9005, 0x4a039035, - 0x00880200, 0x59a8000e, 0x800000e0, 0x4803900e, - 0x4a039011, 0x00000024, 0x4a03900f, 0x0010d1c0, - 0x4a039010, 0x0010d1c0, 0x4a039015, 0x0000007f, - 0x4a03900d, 0x00000040, 0x4a039000, 0x00001600, - 0x1c01f000, 0x59c80007, 0x8c000508, 0x040208b7, - 0x59c80800, 0x8c040d16, 0x04020004, 0x82000500, - 0x00000006, 0x0c01f005, 0x4807c857, 0x82000500, - 0x0000000e, 0x0c01f001, 0x001012a8, 0x001012a6, - 0x00105999, 0x001012a6, 0x001012aa, 0x001012a6, - 0x001012aa, 0x001012aa, 0x001012a6, 0x001012a6, - 0x001012a6, 0x001012a6, 0x001012aa, 0x001012a6, - 0x001012aa, 0x001012a6, 0x0201f800, 0x001005d8, - 0x4803c857, 0x1c01f000, 0x59c8080c, 0x4807c857, - 0x82040500, 0x00006000, 0x04000004, 0x0201f800, - 0x0010aa03, 0x0401f006, 0x82040500, 0x007f0000, - 0x04000006, 0x0201f800, 0x0010a9d5, 0x0201f800, - 0x00106eb3, 0x0401f02b, 0x82040500, 0x00000014, - 0x04000014, 0x0201f800, 0x0010aa32, 0x836c0580, - 0x00000003, 0x0400000d, 0x0201f800, 0x0010513b, - 0x04000004, 0x0201f800, 0x0010411d, 0x0401f007, - 0x4a035033, 0x00000001, 0x4202d800, 0x00000001, - 0x0201f800, 0x001050a2, 0x0401f817, 0x0401f015, - 0x82040500, 0x00001c00, 0x04000005, 0x0201f800, - 0x0010aa11, 0x0401f810, 0x0401f00e, 0x82040500, - 0x00000140, 0x04000005, 0x0201f800, 0x0010aa24, - 0x0401f809, 0x0401f007, 0x82040500, 0x00008000, - 0x04000004, 0x0201f800, 0x0010a9fc, 0x0401f802, - 0x1c01f000, 0x4c0c0000, 0x4c100000, 0x4c140000, - 0x0201f800, 0x00100ec9, 0x5c002800, 0x5c002000, - 0x5c001800, 0x1c01f000, 0x4803c856, 0x59a80804, - 0x59a8002b, 0x82000500, 0xfffff000, 0x80040540, - 0x4803502b, 0x59a8002f, 0x82000500, 0xfffff000, - 0x80040540, 0x4803502f, 0x48078882, 0x82041c00, - 0x0000000f, 0x800c1908, 0x820c1c00, 0x00000004, - 0x400c2000, 0x901029c0, 0x82040480, 0x000001e4, - 0x04021005, 0x42001000, 0x00000008, 0x801020c6, - 0x0401f031, 0x82040480, 0x00000230, 0x04021009, - 0x42001000, 0x00000007, 0x801000c2, 0x800000c2, - 0x80100400, 0x80100400, 0x80102400, 0x0401f026, - 0x82040480, 0x00000298, 0x04021008, 0x42001000, - 0x00000006, 0x801000c2, 0x800000c2, 0x80100400, - 0x80102400, 0x0401f01c, 0x82040480, 0x00000328, - 0x04021007, 0x42001000, 0x00000005, 0x801000c2, - 0x800000c2, 0x80102400, 0x0401f013, 0x82040480, - 0x00000404, 0x04021005, 0x42001000, 0x00000004, - 0x801020c4, 0x0401f00c, 0x82040480, 0x0000056c, - 0x04021006, 0x42001000, 0x00000003, 0x801000c2, - 0x80102400, 0x0401f004, 0x42001000, 0x00000002, - 0x801020c2, 0x82100480, 0x00000110, 0x80000080, - 0x80002000, 0x800800d0, 0x80140540, 0x80100540, - 0x48039035, 0x1c01f000, 0x59c80815, 0x0201f800, - 0x001005d0, 0x82040d00, 0x0000007c, 0x48079000, - 0x59c80000, 0x80040500, 0x040207fe, 0x8c040d04, - 0x04000003, 0x59c80035, 0x48039035, 0x59c80000, - 0x82000540, 0x00001200, 0x48039000, 0x1c01f000, - 0x4803c856, 0x497b88a9, 0x4a038807, 0x00000001, - 0x497b8807, 0x59c40005, 0x48038805, 0x0201f800, - 0x00101815, 0x4201d000, 0x000001f4, 0x0201f800, - 0x0010608e, 0x497b880e, 0x4200b000, 0x000001f4, - 0x42000000, 0x00000001, 0x42000800, 0x00000014, - 0x0201f800, 0x00101944, 0x42000800, 0x00000014, - 0x0201f800, 0x0010193f, 0x8c040d00, 0x04000005, - 0x8058b040, 0x040207f3, 0x0201f800, 0x001005d8, - 0x4200b000, 0x00000032, 0x42000000, 0x00000001, - 0x42000800, 0x000000b4, 0x0201f800, 0x00101944, - 0x42000800, 0x000000b4, 0x0201f800, 0x0010193f, - 0x8c040d00, 0x04000005, 0x8058b040, 0x040207f3, - 0x0201f800, 0x001005d8, 0x59c40005, 0x48038805, - 0x42000000, 0x00000089, 0x800008d0, 0x48075054, - 0x48075055, 0x48075056, 0x42000800, 0x000000e0, - 0x0201f800, 0x00101944, 0x42000800, 0x000000f4, - 0x0201f800, 0x0010193f, 0x82040500, 0xffffffd1, - 0x82000540, 0x00000002, 0x42000800, 0x000000f4, - 0x0201f800, 0x00101944, 0x42000800, 0x000000a0, - 0x0201f800, 0x0010193f, 0x82040540, 0x00000001, - 0x42000800, 0x000000a0, 0x0201f800, 0x00101944, - 0x42000800, 0x00000000, 0x0201f800, 0x0010193f, - 0x82040540, 0x00000001, 0x42000800, 0x00000000, - 0x0201f800, 0x00101944, 0x4201d000, 0x0001d4c0, - 0x0201f800, 0x0010608e, 0x0401fa2b, 0x4a0388a7, - 0x0000f7f7, 0x4a0388a3, 0x8000403c, 0x4a0388ae, - 0x000061a8, 0x4a038801, 0x00032063, 0x4a038810, - 0x00410108, 0x4a038811, 0x00520608, 0x4a038812, - 0x00450320, 0x4a038813, 0x00440405, 0x4a03881c, - 0x004132e1, 0x4a038850, 0x80000108, 0x4a038860, - 0x00000008, 0x4a038870, 0x00000008, 0x4a038851, - 0x80000508, 0x4a038861, 0x00800000, 0x4a038871, - 0x00800000, 0x4a038852, 0x80000708, 0x4a038862, - 0x00800000, 0x4a038872, 0x00800000, 0x4a038853, - 0x80000608, 0x497b8863, 0x4a038873, 0x00800000, - 0x4a038882, 0x00000840, 0x4a0388a5, 0x0000001e, - 0x4a0388a6, 0x0000001e, 0x4a0388b0, 0x00007530, - 0x4a038802, 0x0000ffff, 0x4a038806, 0xc0e00800, - 0x1c01f000, 0x497b5022, 0x4a035021, 0x00000001, - 0x42000800, 0x00000040, 0x0201f800, 0x0010193f, - 0x82040500, 0xffffffaf, 0x82000540, 0x00000000, - 0x42000800, 0x00000040, 0x0201f800, 0x00101944, - 0x42000800, 0x000000f4, 0x0201f800, 0x0010193f, - 0x4c040000, 0x40040000, 0x84000548, 0x42000800, - 0x000000f4, 0x0201f800, 0x00101944, 0x42000800, - 0x00000000, 0x0201f800, 0x0010193f, 0x82040500, - 0xffffffc1, 0x82000540, 0x00000038, 0x42000800, - 0x00000000, 0x0201f800, 0x00101944, 0x5c000000, - 0x42000800, 0x000000f4, 0x0201f000, 0x00101944, - 0x59c40805, 0x4807c857, 0x59c40006, 0x80040d00, - 0x02000800, 0x001005d8, 0x82040500, 0x00e00800, - 0x04020004, 0x8c040d3e, 0x040208c4, 0x0401f007, - 0x82040500, 0x00800800, 0x02020800, 0x001005d0, - 0x0201f800, 0x001005d8, 0x4c5c0000, 0x4c600000, - 0x59c4b805, 0x485fc857, 0x59c40006, 0x8c000500, - 0x04000003, 0x8c5cbd00, 0x04020079, 0x0201f800, - 0x0010513b, 0x04000014, 0x59c40005, 0x82000500, - 0x000000c0, 0x04000036, 0x0201f800, 0x00105151, - 0x04020033, 0x4a038805, 0x04000000, 0x59c400a3, - 0x82000500, 0xbf203fff, 0x480388a3, 0x497b5049, - 0x4a038805, 0x000000c0, 0x0201f800, 0x00105065, - 0x0401f063, 0x8c5cbd34, 0x04020025, 0x59c40005, - 0x8c00050c, 0x04020012, 0x8c00050e, 0x04020013, - 0x8c00050a, 0x04020014, 0x8c000508, 0x0400000b, - 0x59a80017, 0x82000580, 0x00000009, 0x04020007, - 0x42000000, 0x0010b844, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x00105318, 0x0401f04b, 0x4a035033, - 0x00000000, 0x0401f00b, 0x4a035033, 0x00000002, - 0x0401f008, 0x42000000, 0x0010b846, 0x0201f800, - 0x0010aa47, 0x0201f800, 0x001052c2, 0x0401f03e, - 0x0201f800, 0x00105378, 0x0401f03b, 0x8c5cbd34, - 0x04000037, 0x59c40005, 0x8c00053a, 0x04020005, - 0x42000000, 0x0010b818, 0x0201f800, 0x0010aa47, - 0x4a038805, 0x02000000, 0x0201f800, 0x0010513b, - 0x04020010, 0x4a038805, 0x04000000, 0x0201f800, - 0x00105149, 0x04020008, 0x4a035033, 0x00000001, - 0x4202d800, 0x00000001, 0x0201f800, 0x001050a2, - 0x0401f05b, 0x41780000, 0x0201f800, 0x00105113, - 0x0201f800, 0x001019fe, 0x4000c000, 0x0201f800, - 0x00101963, 0x836c1580, 0x00000004, 0x0402000d, - 0x8c5cbd00, 0x04020012, 0x59a81005, 0x8c081506, - 0x04020005, 0x59c410a3, 0x82081540, 0x00000008, - 0x480b88a3, 0x59c41006, 0x84081540, 0x480b8806, - 0x4a038805, 0x04000000, 0x4202d800, 0x00000001, - 0x497b5014, 0x0201f800, 0x00103b38, 0x8c5cbd3c, - 0x04020858, 0x8c5cbd00, 0x04000036, 0x42000000, - 0x0010b8ca, 0x0201f800, 0x0010aa47, 0x4a038805, - 0x00000001, 0x4200b000, 0x000003e8, 0x4201d000, - 0x00000064, 0x4c580000, 0x0201f800, 0x0010608e, - 0x0201f800, 0x001018d3, 0x5c00b000, 0x04000004, - 0x8058b040, 0x040207f6, 0x0401f004, 0x4a038805, - 0x00000001, 0x0401f01f, 0x59c40006, 0x84000500, - 0x48038806, 0x0201f800, 0x00106ede, 0x497b8880, - 0x0201f800, 0x0010a9c0, 0x59c4000d, 0x8c000500, - 0x02020800, 0x0010a9ce, 0x59c400a3, 0x82000500, - 0xfcf8ffff, 0x480388a3, 0x4a03504c, 0x00000002, - 0x4202d800, 0x00000004, 0x4a038805, 0x00000001, - 0x0201f800, 0x001006d4, 0x0401fb3b, 0x497b5052, - 0x4a035049, 0x00000001, 0x0201f800, 0x00100452, - 0x825cbd00, 0xbbfffffe, 0x485f8805, 0x5c00c000, - 0x5c00b800, 0x1c01f000, 0x59c41004, 0x480bc857, - 0x8c081500, 0x04000006, 0x4803c856, 0x497b2807, - 0x0201f800, 0x00106fa4, 0x0401f00a, 0x82080500, - 0x000001f0, 0x04000007, 0x4803c856, 0x417a3000, - 0x0201f800, 0x00106062, 0x0201f800, 0x00106fc6, - 0x4a038805, 0x80000000, 0x1c01f000, 0x59c408a3, - 0x4807c857, 0x84040d40, 0x480788a3, 0x1c01f000, - 0x4d900000, 0x4dd00000, 0x4da40000, 0x4d140000, - 0x4a038805, 0x40000000, 0x42000000, 0x0010b8c6, - 0x0201f800, 0x0010aa47, 0x0201f800, 0x00106c55, - 0x59c41004, 0x8c081500, 0x04000054, 0x598e600d, - 0x497b2807, 0x813261c0, 0x04000032, 0x59300403, - 0x82000580, 0x00000032, 0x0402002e, 0x5930001c, - 0x48038833, 0x4a038807, 0x00018000, 0x4201d000, - 0x00000002, 0x0201f800, 0x0010608e, 0x497b8807, - 0x4201d000, 0x00000002, 0x0201f800, 0x0010608e, - 0x0201f800, 0x00106e21, 0x4201d000, 0x00007530, - 0x0201f800, 0x0010608e, 0x59c408a4, 0x82040d00, - 0x0000000f, 0x82040d80, 0x00000000, 0x04000005, - 0x42000000, 0x00200000, 0x0201f800, 0x00101949, - 0x0201f800, 0x00106bbf, 0x59300008, 0x80000540, - 0x02000800, 0x001005d8, 0x40025800, 0x4a025a04, - 0x00000103, 0x5931d821, 0x58ef400b, 0x58ec0009, - 0x0801f800, 0x0201f800, 0x0002077d, 0x0401f047, - 0x598c000f, 0x82001c80, 0x000000c8, 0x0402100f, - 0x80000000, 0x4803180f, 0x59c400a4, 0x82000500, - 0x0000000f, 0x82000580, 0x00000002, 0x04020004, - 0x42000000, 0x00200000, 0x0401fbf7, 0x0201f800, - 0x0010604d, 0x0401f035, 0x4933c857, 0x0201f800, - 0x00106e21, 0x813261c0, 0x04000030, 0x4a026203, - 0x00000001, 0x42027000, 0x00000027, 0x0201f800, - 0x000207a1, 0x0401f029, 0x8c081508, 0x04000027, - 0x417a3000, 0x0201f800, 0x001070d8, 0x42032000, - 0x0000bf32, 0x0201f800, 0x00106062, 0x59926004, - 0x813261c0, 0x04000012, 0x42001800, 0x000000c8, - 0x0201f800, 0x001070a4, 0x0402000d, 0x59c400a4, - 0x82000500, 0x0000000f, 0x82000580, 0x00000002, - 0x04020004, 0x42000000, 0x00200000, 0x0401fbce, - 0x0201f800, 0x00106052, 0x0401f00c, 0x4933c857, - 0x0201f800, 0x00106dc3, 0x813261c0, 0x04000007, - 0x42027000, 0x0000004f, 0x4a026203, 0x00000003, - 0x0201f800, 0x000207a1, 0x5c022800, 0x5c034800, - 0x5c03a000, 0x5c032000, 0x0201f000, 0x00106c4b, - 0x4803c857, 0x59a80821, 0x48035021, 0x80041580, - 0x04000045, 0x800409c0, 0x04000023, 0x497b504c, - 0x42000000, 0x0010b80d, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x0010aaf9, 0x42001000, 0x00008011, - 0x59c40001, 0x82000500, 0x00018000, 0x82001d80, - 0x00000000, 0x04000009, 0x82001d80, 0x00008000, - 0x04000009, 0x82001d80, 0x00010000, 0x04000009, - 0x0201f800, 0x001005d8, 0x42001800, 0x00000000, - 0x0401f006, 0x42001800, 0x00000001, 0x0401f003, - 0x42001800, 0x00000003, 0x0201f800, 0x00103a3e, - 0x0401f021, 0x59a8084c, 0x800409c0, 0x04020007, - 0x59c4000d, 0x8c000520, 0x04000004, 0x42001800, - 0x00000003, 0x0401f002, 0x40041800, 0x0201f800, - 0x0010aadd, 0x42001000, 0x00008012, 0x0201f800, - 0x00103a3e, 0x0201f800, 0x001006d4, 0x0201f800, - 0x0010ab33, 0x0402000c, 0x0401f853, 0x4d400000, - 0x4d3c0000, 0x42028000, 0x00000028, 0x42027800, - 0x00000408, 0x0201f800, 0x00101fe5, 0x5c027800, - 0x5c028000, 0x1c01f000, 0x4803c857, 0x82000400, - 0x0010210e, 0x50000800, 0x82040d00, 0x000000ff, - 0x1c01f000, 0x4803c856, 0x4c580000, 0x4200b000, - 0x00000010, 0x497b88ac, 0x497b88ad, 0x8058b040, - 0x040207fe, 0x5c00b000, 0x1c01f000, 0x4807c857, - 0x48075010, 0x80041108, 0x4200b000, 0x00000010, - 0x497b88ac, 0x80000580, 0x800811c0, 0x04020006, - 0x82040500, 0x0000000f, 0x82000400, 0x0010ab38, - 0x50000000, 0x480388ad, 0x80081040, 0x8058b040, - 0x040207f5, 0x1c01f000, 0x59a80005, 0x04000003, - 0x84000546, 0x0401f002, 0x84000506, 0x48035005, - 0x4803c857, 0x1c01f000, 0x4803c857, 0x4c080000, - 0x4c040000, 0x4c000000, 0x59c40892, 0x4807c857, - 0x80041580, 0x04000010, 0x80041480, 0x04021007, - 0x80081080, 0x80081000, 0x4008b000, 0x42000000, - 0x00000201, 0x0401f004, 0x4008b000, 0x42000000, - 0x00000210, 0x48038886, 0x8058b040, 0x040207fe, - 0x497b8886, 0x5c000000, 0x5c000800, 0x5c001000, - 0x1c01f000, 0x4803c856, 0x0201f800, 0x00103b25, - 0x04000005, 0x42028000, 0x0000002e, 0x0201f000, - 0x0010a449, 0x1c01f000, 0x42000800, 0x00000002, - 0x59a80005, 0x8c000514, 0x0402000b, 0x59c80835, - 0x82040d00, 0x00001f00, 0x80040910, 0x80040800, - 0x59a8006c, 0x80000540, 0x04000003, 0x42000800, - 0x0000025a, 0x4807c857, 0x1c01f000, 0x4c000000, - 0x59a80053, 0x4803c857, 0x82000580, 0x00000000, - 0x5c000000, 0x1c01f000, 0x4c000000, 0x59a80053, - 0x4803c857, 0x82000580, 0x00000001, 0x5c000000, - 0x1c01f000, 0x4c000000, 0x59a80053, 0x4803c857, - 0x82000580, 0x00000003, 0x5c000000, 0x1c01f000, - 0x4c000000, 0x59a80053, 0x82000580, 0x00000002, - 0x5c000000, 0x1c01f000, 0x4c000000, 0x4c040000, - 0x4c080000, 0x4c380000, 0x59a80040, 0x82000c80, - 0x00000007, 0x02021800, 0x001005d8, 0x0c01f806, - 0x5c007000, 0x5c001000, 0x5c000800, 0x5c000000, - 0x1c01f000, 0x0010166c, 0x0010167f, 0x00101693, - 0x00101695, 0x001016bc, 0x001016be, 0x001016c0, - 0x4803c856, 0x4a035042, 0x00000000, 0x42000000, - 0x00000002, 0x0401fa1b, 0x42000000, 0x00000002, - 0x0401f9ad, 0x0401fab2, 0x4803c856, 0x4a035040, - 0x00000006, 0x42000800, 0x0000001e, 0x42001000, - 0x001016c1, 0x0201f000, 0x0010606e, 0x497b5045, - 0x4a035050, 0x00000036, 0x4a03504f, 0x0000002a, - 0x4803c856, 0x4a035042, 0x00000001, 0x42000000, - 0x00000002, 0x0401f998, 0x4803c856, 0x4a035040, - 0x00000006, 0x42000800, 0x0000001e, 0x42001000, - 0x001016c1, 0x0201f000, 0x0010606e, 0x0201f800, - 0x001005d8, 0x4a035050, 0x00000036, 0x4803c856, - 0x4a035042, 0x00000003, 0x42000800, 0x00000000, - 0x0401faa3, 0x82040d00, 0x00000090, 0x82040580, - 0x00000090, 0x04000009, 0x82040580, 0x00000010, - 0x04000009, 0x82040580, 0x00000000, 0x04000008, - 0x0201f800, 0x001005d8, 0x42000000, 0x00000001, - 0x0401f005, 0x41780000, 0x0401f003, 0x42000000, - 0x00000002, 0x0401f970, 0x497b5046, 0x4803c856, - 0x4a035040, 0x00000006, 0x42000800, 0x0000001e, - 0x42001000, 0x001016c1, 0x0201f000, 0x0010606e, - 0x0201f800, 0x001005d8, 0x0201f800, 0x001005d8, - 0x1c01f000, 0x4c000000, 0x4c040000, 0x4c080000, - 0x4c380000, 0x59a80042, 0x82000c80, 0x00000007, - 0x02021800, 0x001005d8, 0x0c01f806, 0x5c007000, - 0x5c001000, 0x5c000800, 0x5c000000, 0x1c01f000, - 0x001016d7, 0x001016f6, 0x0010174a, 0x00101761, - 0x00101778, 0x00101781, 0x00101783, 0x0401f9fc, - 0x0402001b, 0x59a81048, 0x42000800, 0x00000000, - 0x0401fa63, 0x82040d00, 0x00000090, 0x82040580, - 0x00000090, 0x04000009, 0x82040580, 0x00000010, - 0x04000008, 0x82040580, 0x00000000, 0x04000007, - 0x0201f800, 0x001005d8, 0x84081540, 0x0401f004, - 0x84081542, 0x0401f002, 0x84081544, 0x480b5048, - 0x4a035040, 0x00000001, 0x0401f003, 0x0401f8cb, - 0x0401ff82, 0x1c01f000, 0x0401f88f, 0x04000052, - 0x0401f9db, 0x0402002a, 0x42000800, 0x00000000, - 0x0401fa43, 0x82040d00, 0x00000090, 0x82040580, - 0x00000000, 0x04000044, 0x82040580, 0x00000010, - 0x04000006, 0x82040580, 0x00000090, 0x04000009, - 0x0201f800, 0x001005d8, 0x59c40801, 0x82040d00, - 0x00018000, 0x82040580, 0x00000000, 0x04000036, - 0x42000800, 0x00000000, 0x0401fa2d, 0x82040d00, - 0x00000090, 0x82040580, 0x00000010, 0x04000006, - 0x82040580, 0x00000090, 0x04000006, 0x02020800, - 0x001005d8, 0x59a80048, 0x84000542, 0x0401f003, - 0x59a80048, 0x84000540, 0x48035048, 0x59a80045, - 0x80000000, 0x48035045, 0x82000580, 0x00000005, - 0x04000003, 0x0401f861, 0x0401f01e, 0x497b5045, - 0x59c40801, 0x82040d00, 0x00018000, 0x82040580, - 0x00000000, 0x04000009, 0x82040580, 0x00008000, - 0x04000009, 0x82040580, 0x00010000, 0x04000008, - 0x0201f800, 0x001005d8, 0x42000000, 0x00000001, - 0x0401f005, 0x41780000, 0x0401f003, 0x42000000, - 0x00000002, 0x0401f94b, 0x4a035042, 0x00000002, - 0x0401f004, 0x4a035040, 0x00000003, 0x0401f002, - 0x0401ff42, 0x1c01f000, 0x0401f83b, 0x04000015, - 0x59a8004f, 0x80000040, 0x4803504f, 0x0401f984, - 0x04020005, 0x4a035040, 0x00000003, 0x497b5041, - 0x0401f00c, 0x59a8004f, 0x80000540, 0x04020003, - 0x0401f89e, 0x0401f002, 0x0401f84b, 0x0401f82f, - 0x497b5045, 0x4a035042, 0x00000001, 0x0401ff2b, - 0x1c01f000, 0x0401f824, 0x04000015, 0x0401f970, - 0x0402000f, 0x59a80046, 0x80000000, 0x48035046, - 0x82000580, 0x00000007, 0x0402000c, 0x4a035052, - 0x0000000a, 0x497b5049, 0x59a80048, 0x8400055e, - 0x48035048, 0x4803c857, 0x0401f005, 0x0401f817, - 0x4a035042, 0x00000004, 0x0401ff3d, 0x1c01f000, - 0x0401f80d, 0x04000007, 0x0401f959, 0x04020003, - 0x0401ff1b, 0x0401f003, 0x0401f80c, 0x0401ff34, - 0x1c01f000, 0x0201f800, 0x001005d8, 0x0201f800, - 0x001005d8, 0x59a80050, 0x80000040, 0x48035050, - 0x0400088d, 0x1c01f000, 0x4c040000, 0x42000800, - 0x00000000, 0x0401f9b2, 0x82040d00, 0x00000090, - 0x82040580, 0x00000090, 0x04000009, 0x82040580, - 0x00000010, 0x04000009, 0x82040580, 0x00000000, - 0x04000009, 0x0201f800, 0x001005d8, 0x42000000, - 0x00000002, 0x0401f005, 0x42000000, 0x00000001, - 0x0401f002, 0x41780000, 0x0401f8ea, 0x5c000800, - 0x1c01f000, 0x4c040000, 0x59c40801, 0x82040d00, - 0x00018000, 0x82040580, 0x00000000, 0x04000009, - 0x82040580, 0x00008000, 0x04000009, 0x82040580, - 0x00010000, 0x04000009, 0x0201f800, 0x001005d8, - 0x42000000, 0x00000002, 0x0401f005, 0x42000000, - 0x00000001, 0x0401f002, 0x41780000, 0x0401f866, - 0x5c000800, 0x1c01f000, 0x4c040000, 0x59a80045, - 0x80000000, 0x48035045, 0x82000580, 0x00000005, - 0x04020018, 0x497b5045, 0x59c40801, 0x82040d00, - 0x00018000, 0x82040580, 0x00000000, 0x04000009, - 0x82040580, 0x00008000, 0x04000009, 0x82040580, - 0x00010000, 0x04000009, 0x0201f800, 0x001005d8, - 0x42000000, 0x00000002, 0x0401f005, 0x42000000, - 0x00000001, 0x0401f002, 0x41780000, 0x0401f846, - 0x42000800, 0x00000000, 0x0401f961, 0x82040d00, - 0x00000090, 0x82040580, 0x00000090, 0x04000009, - 0x82040580, 0x00000010, 0x04000009, 0x82040580, - 0x00000000, 0x04000009, 0x0201f800, 0x001005d8, - 0x42000000, 0x00000002, 0x0401f005, 0x42000000, - 0x00000001, 0x0401f002, 0x41780000, 0x0401f899, - 0x5c000800, 0x1c01f000, 0x4c200000, 0x59a80048, - 0x82000500, 0x00007fff, 0x02000800, 0x001005d8, - 0x59a84047, 0x80204102, 0x02001800, 0x001005d8, - 0x48235047, 0x80204500, 0x040007fa, 0x8c000504, - 0x04020007, 0x8c000502, 0x04020008, 0x8c000500, - 0x04020008, 0x0201f800, 0x001005d8, 0x42000000, - 0x00000002, 0x0401f005, 0x41780000, 0x0401f003, - 0x42000000, 0x00000001, 0x0401f80f, 0x5c004000, - 0x1c01f000, 0x04011000, 0x4a03c840, 0x0010b440, - 0x4a03c842, 0x00000009, 0x40000000, 0x040117ff, - 0x4a035047, 0x00000004, 0x4a03503e, 0x00000000, - 0x1c01f000, 0x59a80858, 0x82040d80, 0x01391077, - 0x04020008, 0x59e00813, 0x8c040d00, 0x04000005, - 0x82000d80, 0x00000002, 0x04020002, 0x41780000, - 0x4c000000, 0x0401f9b1, 0x5c000000, 0x800001c0, - 0x04000040, 0x82000d80, 0x00000001, 0x0402001d, - 0x42000800, 0x000000a0, 0x0401f909, 0x82040540, - 0x00000004, 0x42000800, 0x000000a0, 0x0401f909, - 0x42000800, 0x000000c0, 0x0401f901, 0x82040540, - 0x00000020, 0x42000800, 0x000000c0, 0x0401f901, - 0x59c40001, 0x82000500, 0xfffe7fff, 0x82000540, - 0x00000000, 0x48038801, 0x59a80054, 0x80000110, - 0x42000800, 0x000000e0, 0x0401f8f6, 0x0401f03c, - 0x82000d80, 0x00000002, 0x02020800, 0x001005d8, - 0x42000800, 0x000000a0, 0x0401f8e9, 0x82040500, - 0xfffffffb, 0x42000800, 0x000000a0, 0x0401f8e9, - 0x42000800, 0x000000c0, 0x0401f8e1, 0x82040500, - 0xffffffdf, 0x42000800, 0x000000c0, 0x0401f8e1, - 0x59c40001, 0x82000500, 0xfffe7fff, 0x82000540, - 0x00010000, 0x48038801, 0x59a80056, 0x80000110, - 0x42000800, 0x000000e0, 0x0401f8d6, 0x0401f01c, - 0x42000800, 0x000000a0, 0x0401f8cd, 0x82040540, - 0x00000004, 0x42000800, 0x000000a0, 0x0401f8cd, - 0x42000800, 0x000000c0, 0x0401f8c5, 0x82040500, - 0xffffffdf, 0x42000800, 0x000000c0, 0x0401f8c5, - 0x59c40001, 0x82000500, 0xfffe7fff, 0x82000540, - 0x00008000, 0x48038801, 0x59a80055, 0x80000110, - 0x42000800, 0x000000e0, 0x0401f8ba, 0x0401f163, - 0x4803c857, 0x59a80858, 0x82040d80, 0x01391077, - 0x04020008, 0x59e00813, 0x8c040d00, 0x04000005, - 0x82000d80, 0x00000002, 0x04020002, 0x41780000, - 0x4c000000, 0x0401f94d, 0x5c000000, 0x800001c0, - 0x04000026, 0x82000d80, 0x00000001, 0x04020010, - 0x59a8006c, 0x80000540, 0x04000004, 0x42001000, - 0x00000000, 0x0401fa0a, 0x42000800, 0x00000000, - 0x0401f897, 0x82040540, 0x00000090, 0x42000800, - 0x00000000, 0x0401f897, 0x0401f024, 0x82000d80, - 0x00000002, 0x02020800, 0x001005d8, 0x59a8006c, - 0x80000540, 0x04000004, 0x42001000, 0x00010000, - 0x0401f9f7, 0x42000800, 0x00000000, 0x0401f884, - 0x82040500, 0xffffff6f, 0x42000800, 0x00000000, - 0x0401f884, 0x0401f011, 0x59a8006c, 0x80000540, - 0x04000004, 0x42001000, 0x00008000, 0x0401f9e8, - 0x42000800, 0x00000000, 0x0401f875, 0x82040500, - 0xffffff6f, 0x82000540, 0x00000010, 0x42000800, - 0x00000000, 0x0401f873, 0x0401f124, 0x4c580000, - 0x4200b000, 0x00000014, 0x8058b040, 0x04000043, - 0x59c4000d, 0x8c000520, 0x040207fc, 0x0401f85c, - 0x59c4000d, 0x8c000520, 0x040207f8, 0x59c40808, - 0x84040d50, 0x48078808, 0x4200b000, 0x000000c8, - 0x8058b040, 0x040207ff, 0x4200b000, 0x00000014, - 0x8058b040, 0x04000031, 0x59c4000d, 0x8c000520, - 0x0402002e, 0x42000800, 0x00001000, 0x50040800, - 0x82040c80, 0x24220001, 0x04020003, 0x8c000504, - 0x040007f4, 0x0401f842, 0x59c4000d, 0x8c000520, - 0x04020022, 0x42000800, 0x00001000, 0x50040800, - 0x82040c80, 0x24220001, 0x04020003, 0x8c000504, - 0x040007e8, 0x4200b000, 0x0000000a, 0x8058b040, - 0x04000003, 0x0401f832, 0x0401f7fd, 0x4200b000, - 0x00000064, 0x59c4000d, 0x8c00051e, 0x0400000f, - 0x8058b040, 0x040207fc, 0x42000000, 0x00001000, - 0x50000000, 0x82000480, 0x24220001, 0x04020004, - 0x59c40808, 0x84040d10, 0x48078808, 0x80000580, - 0x4803c857, 0x0401f00c, 0x42000000, 0x00001000, - 0x50000000, 0x82000480, 0x24220001, 0x04020004, - 0x59c40808, 0x84040d10, 0x48078808, 0x82000540, - 0x00000001, 0x5c00b000, 0x1c01f000, 0x42000800, - 0x000000a0, 0x0401f816, 0x82040500, 0xfffffffe, - 0x42000800, 0x000000a0, 0x0401f816, 0x42000800, - 0x00000000, 0x0401f80e, 0x82040500, 0xfffffffe, - 0x42000800, 0x00000000, 0x0401f00e, 0x40000000, - 0x40000000, 0x40000000, 0x40000000, 0x40000000, - 0x1c01f000, 0x480b8805, 0x1c01f000, 0x4807880e, - 0x59c4080f, 0x82040d00, 0x000000ff, 0x1c01f000, - 0x900001c0, 0x80040d40, 0x84040d40, 0x4807880e, - 0x1c01f000, 0x82000d80, 0x00200000, 0x04000009, - 0x82000d80, 0x02000000, 0x04000006, 0x82000d80, - 0x01000000, 0x04000006, 0x59c408a3, 0x0401f006, - 0x59c408a3, 0x84040d30, 0x0401f003, 0x59c408a3, - 0x84040d32, 0x80040540, 0x480388a3, 0x480788a3, - 0x1c01f000, 0x59c400a3, 0x84000556, 0x480388a3, - 0x84000516, 0x480388a3, 0x1c01f000, 0x485fc857, - 0x4863c857, 0x4c640000, 0x4d3c0000, 0x4d400000, - 0x0201f800, 0x00106ede, 0x4863500a, 0x0201f800, - 0x0010ab33, 0x0402006c, 0x82600d00, 0x0000ff00, - 0x800409c0, 0x0400000c, 0x4200c800, 0x00000001, - 0x59a80010, 0x82000500, 0x000000ff, 0x80041110, - 0x80081580, 0x04000021, 0x82041580, 0x0000ff00, - 0x0400000a, 0x59c410a3, 0x82081500, 0x00008000, - 0x04000009, 0x59c410a7, 0x82081500, 0x0000ff00, - 0x82081580, 0x0000ff00, 0x4200c800, 0x00000000, - 0x04000012, 0x59a80005, 0x8c000502, 0x04020008, - 0x8c000500, 0x0402000d, 0x599c1017, 0x8c08151a, - 0x0400003e, 0x84000542, 0x48035005, 0x4200c800, - 0x00000002, 0x42028000, 0x00000004, 0x42027800, - 0x00000008, 0x0401f008, 0x59a80805, 0x84040d40, - 0x48075005, 0x42028000, 0x00000004, 0x42027800, - 0x00000400, 0x59a80006, 0x8c000502, 0x04020006, - 0x59a80805, 0x8c040d0a, 0x04020033, 0x84040d4a, - 0x48075005, 0x42000000, 0x0010b812, 0x0201f800, - 0x0010aa47, 0x59a8180a, 0x42001000, 0x00008013, - 0x0201f800, 0x00103a3e, 0x0201f800, 0x00103b25, - 0x04000015, 0x4d400000, 0x82600500, 0x000000ff, - 0x42028800, 0x0000ffff, 0x40643000, 0x42028000, - 0x0000000e, 0x0201f800, 0x0010a446, 0x42000800, - 0x00000001, 0x42001000, 0x00000100, 0x0201f800, - 0x0010618b, 0x5c028000, 0x599c0817, 0x8c040d0a, - 0x04020011, 0x493fc857, 0x4943c857, 0x0201f800, - 0x00101fe5, 0x0401f00c, 0x0201f800, 0x00103b25, - 0x04000009, 0x42028000, 0x0000000f, 0x42028800, - 0x0000ffff, 0x42003000, 0x00000000, 0x0201f800, - 0x0010a449, 0x497b8880, 0x5c028000, 0x5c027800, - 0x5c00c800, 0x1c01f000, 0x42000800, 0x000000a0, - 0x0401ff5f, 0x82040540, 0x00000002, 0x42000800, - 0x000000a0, 0x0401f75f, 0x42000800, 0x00000000, - 0x0401ff57, 0x82040540, 0x00000002, 0x42000800, - 0x00000000, 0x0401f757, 0x42000800, 0x000000a0, - 0x0401ff4f, 0x82040500, 0xfffffffd, 0x42000800, - 0x000000a0, 0x0401f74f, 0x42000800, 0x00000000, - 0x0401ff47, 0x82040500, 0xfffffffd, 0x42000800, - 0x00000000, 0x0401f747, 0x59c408a8, 0x0401ff38, - 0x0401ff37, 0x59c400a8, 0x80040d80, 0x040207fb, - 0x1c01f000, 0x4803c856, 0x4a038807, 0x00000001, - 0x497b8807, 0x59c40005, 0x48038805, 0x497b506c, - 0x497b506d, 0x41785800, 0x42006000, 0x00000001, - 0x42006800, 0x00000003, 0x0401f824, 0x0401f82f, - 0x40400000, 0x4803c857, 0x82408580, 0x00000000, - 0x0402001d, 0x41785800, 0x42006000, 0x0000001e, - 0x42006800, 0x00000014, 0x0401f818, 0x0401f823, - 0x40400000, 0x4803c857, 0x82408580, 0x00000800, - 0x04020011, 0x42005800, 0x00000001, 0x42006000, - 0x0000001e, 0x42006800, 0x00000014, 0x0401f80b, - 0x0401f816, 0x40400000, 0x4803c857, 0x82408580, - 0x0000ffff, 0x04020004, 0x4a03506c, 0x00000001, - 0x4803c856, 0x1c01f000, 0x41785000, 0x0401f812, - 0x0401f838, 0x40347000, 0x40340800, 0x0401f03d, - 0x42005000, 0x00000001, 0x0401f80b, 0x0401f831, - 0x40340800, 0x0401f037, 0x42005000, 0x00000002, - 0x0401f805, 0x0401f81d, 0x0401f835, 0x40048000, - 0x1c01f000, 0x0401f808, 0x0401f814, 0x40280800, - 0x0401f826, 0x402c0800, 0x0401f827, 0x40300800, - 0x0401f025, 0x42000800, 0x0000ffff, 0x42001000, - 0x00000001, 0x0401f829, 0x42001000, 0x00000010, - 0x0401f826, 0x42000800, 0x0000ffff, 0x42001000, - 0x00000010, 0x0401f021, 0x41780800, 0x42001000, - 0x00000002, 0x0401f01d, 0x0401f92e, 0x4a03d000, - 0x00050004, 0x0401f92b, 0x4a03d000, 0x00050005, - 0x0401f928, 0x4a03d000, 0x00050004, 0x42000800, - 0x00000001, 0x42001000, 0x00000001, 0x0401f00f, - 0x42000800, 0x00000002, 0x42001000, 0x00000002, - 0x0401f00a, 0x42001000, 0x00000005, 0x0401f007, - 0x42001000, 0x00000010, 0x0401f004, 0x42001000, - 0x00000010, 0x0401f01b, 0x0401f912, 0x82082c00, - 0x0010ab38, 0x50142800, 0x82081500, 0xffffffff, - 0x04000013, 0x0401f90b, 0x80081040, 0x80142902, - 0x40040000, 0x80140500, 0x04000007, 0x4a03d000, - 0x00070006, 0x0401f903, 0x4a03d000, 0x00070007, - 0x0401f006, 0x4a03d000, 0x00070004, 0x0401f8fd, - 0x4a03d000, 0x00070005, 0x0401f7ec, 0x1c01f000, - 0x41780800, 0x82082c00, 0x0010ab38, 0x50142800, - 0x82081500, 0xffffffff, 0x04000010, 0x0401f8f1, - 0x4a03d000, 0x00050001, 0x0401f8ee, 0x59e81800, - 0x80081040, 0x80142902, 0x8c0c1d06, 0x04000004, - 0x40140000, 0x80040d40, 0x0401f8e6, 0x4a03d000, - 0x00070000, 0x0401f7ef, 0x1c01f000, 0x480bc857, - 0x480b506d, 0x59c40001, 0x82000500, 0xffffefff, - 0x48038801, 0x41781800, 0x0401f8c4, 0x41785800, - 0x42006000, 0x0000001e, 0x42006800, 0x00000004, - 0x0401ff7a, 0x42006800, 0x0000003c, 0x0401ff7d, - 0x41785800, 0x42006000, 0x0000001e, 0x42006800, - 0x00000004, 0x0401ff71, 0x41786800, 0x0401ff75, - 0x41785800, 0x42006000, 0x0000001e, 0x41786800, - 0x0401ff6a, 0x42006800, 0x00000002, 0x0401ff6d, - 0x42006800, 0x00000001, 0x0401ff64, 0x42006800, - 0x000000f5, 0x0401ff67, 0x41785800, 0x42006000, - 0x0000001e, 0x42006800, 0x00000004, 0x0401ff5b, - 0x42006800, 0x00000020, 0x0401ff5e, 0x59a8106d, - 0x0401f865, 0x42001800, 0x000200f5, 0x0401f897, - 0x59a8106d, 0x0401f879, 0x41785800, 0x42006000, - 0x0000001e, 0x42006800, 0x00000004, 0x0401ff4b, - 0x41786800, 0x0401ff4f, 0x59c40001, 0x82000540, - 0x00001000, 0x48038801, 0x41785800, 0x42006000, - 0x0000001e, 0x42006800, 0x00000015, 0x0401ff3f, - 0x0401ff4a, 0x40400000, 0x82000540, 0x00000002, - 0x4c000000, 0x41785800, 0x42006000, 0x0000001e, - 0x42006800, 0x00000015, 0x0401ff34, 0x5c000000, - 0x40006800, 0x0401ff37, 0x41785800, 0x42006000, - 0x0000001e, 0x42006800, 0x00000015, 0x0401ff2b, - 0x0401ff36, 0x40400000, 0x82000500, 0x0000fffd, - 0x4c000000, 0x41785800, 0x42006000, 0x0000001e, - 0x42006800, 0x00000015, 0x0401ff20, 0x5c000000, - 0x40006800, 0x0401ff23, 0x41785800, 0x42006000, - 0x0000001e, 0x42006800, 0x00000014, 0x0401ff17, - 0x0401ff22, 0x40400000, 0x82000540, 0x00000040, - 0x4c000000, 0x41785800, 0x42006000, 0x0000001e, - 0x42006800, 0x00000014, 0x0401ff0c, 0x5c000000, - 0x40006800, 0x0401ff0f, 0x41785800, 0x42006000, - 0x0000001e, 0x42006800, 0x00000014, 0x0401ff03, - 0x0401ff0e, 0x40400000, 0x82000500, 0x0000ffbf, - 0x4c000000, 0x41785800, 0x42006000, 0x0000001e, - 0x42006800, 0x00000014, 0x0401fef8, 0x5c000000, - 0x40006800, 0x0401fefb, 0x4a038886, 0x00002020, - 0x0401f04c, 0x480bc857, 0x82080580, 0x00010000, - 0x04020007, 0x82040d40, 0x00010000, 0x42001800, - 0x00000001, 0x0401f82d, 0x0401f00f, 0x82080580, - 0x00008000, 0x04000007, 0x82040d40, 0x00000000, - 0x42001800, 0x00900001, 0x0401f824, 0x0401f006, - 0x82040d40, 0x00008000, 0x42001800, 0x00100001, - 0x0401f81e, 0x1c01f000, 0x480bc857, 0x82080580, - 0x00010000, 0x04020008, 0x42001800, 0x000000a1, - 0x0401f816, 0x42001800, 0x000000c1, 0x0401f813, - 0x0401f011, 0x82080580, 0x00008000, 0x04000008, - 0x42001800, 0x000400a1, 0x0401f80c, 0x42001800, - 0x002000c1, 0x0401f809, 0x0401f007, 0x42001800, - 0x000400a1, 0x0401f805, 0x42001800, 0x000000c1, - 0x0401f802, 0x1c01f000, 0x480fc857, 0x41785800, - 0x42006000, 0x0000001e, 0x41786800, 0x0401feb7, - 0x400c6800, 0x80346960, 0x0401feba, 0x42006800, - 0x00000001, 0x0401feb1, 0x400c6800, 0x0401feb5, - 0x42006800, 0x00000003, 0x0401feac, 0x0401feb7, - 0x40400000, 0x8c000504, 0x040207fc, 0x1c01f000, - 0x42000000, 0x00000064, 0x80000040, 0x040207ff, - 0x1c01f000, 0x00020103, 0x00101bd5, 0x00101bdb, - 0x00101be1, 0x00101be9, 0x00101bef, 0x00101bf7, - 0x00101bff, 0x00101c09, 0x00101c0f, 0x00101c17, - 0x00101c1f, 0x00101c29, 0x00101c31, 0x00101c3b, - 0x00101c45, 0x000200f8, 0x00101c51, 0x00101c59, - 0x00101c61, 0x00101c6b, 0x00101c73, 0x00101c7d, - 0x00101c87, 0x00101c93, 0x00101c9b, 0x00101ca5, - 0x00101caf, 0x00101cbb, 0x00101cc5, 0x00101cd1, - 0x00101cdd, 0x000200fd, 0x00101ceb, 0x00101cf3, - 0x00101cfb, 0x00101d05, 0x00101d0d, 0x00101d17, - 0x00101d21, 0x00101d2d, 0x00101d35, 0x00101d3f, - 0x00101d49, 0x00101d55, 0x00101d5f, 0x00101d6b, - 0x00101d77, 0x00101d85, 0x00101d8d, 0x00101d97, - 0x00101da1, 0x00101dad, 0x00101db7, 0x00101dc3, - 0x00101dcf, 0x00101ddd, 0x00101de7, 0x00101df3, - 0x00101dff, 0x00101e0d, 0x00101e19, 0x00101e27, - 0x00101e35, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00101418, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101289, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101289, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00101289, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00101289, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00101289, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00101418, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00101418, 0x0201f800, - 0x00101289, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020729, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00020729, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00020729, 0x0201f800, - 0x00101289, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00020729, 0x0201f800, - 0x00101289, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020729, 0x0201f800, - 0x00101289, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00101289, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00020729, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020729, 0x0201f800, - 0x00101289, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00101289, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00020015, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020015, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020015, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020015, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020015, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020015, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101418, 0x0201f800, 0x00101155, 0x0201f800, - 0x00020015, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101289, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f800, - 0x00101155, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101289, 0x0201f800, 0x00101155, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f800, - 0x00101155, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020015, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101155, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101155, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101155, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101289, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101289, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101289, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f800, - 0x00020104, 0x0201f000, 0x00020101, 0x4c000000, - 0x4df00000, 0x0201f800, 0x00101155, 0x0201f800, - 0x00101418, 0x0201f800, 0x00020729, 0x0201f800, - 0x00020015, 0x0201f800, 0x00101289, 0x0201f000, - 0x00020101, 0x4c000000, 0x4df00000, 0x0201f800, - 0x00101155, 0x0201f800, 0x00101418, 0x0201f800, - 0x00020729, 0x0201f800, 0x00020015, 0x0201f800, - 0x00101289, 0x0201f800, 0x00020104, 0x0201f000, - 0x00020101, 0x4c5c0000, 0x4c600000, 0x4178b800, - 0x0201f800, 0x001048ec, 0x040200fd, 0x59a8c026, - 0x0201f800, 0x0010513b, 0x04000003, 0x8c60c506, - 0x0400000e, 0x8c60c500, 0x04020004, 0x8c60c50e, - 0x040008f6, 0x0401f0f2, 0x0401fab4, 0x040200f0, - 0x0201f800, 0x0010513b, 0x04020004, 0x4a03501c, - 0x0000ffff, 0x0401f0ea, 0x8c60c504, 0x04000004, - 0x4a03501c, 0x0000ffff, 0x0401f0e5, 0x59a8c010, - 0x8260c500, 0x000000ff, 0x59a81013, 0x8c081500, - 0x0400005d, 0x8c081502, 0x0402005b, 0x59a8b81c, - 0x825c0d80, 0x0000ffff, 0x04020003, 0x4200b800, - 0x00000001, 0x805c1104, 0x82086400, 0x0010be21, - 0x50300800, 0x825c0500, 0x00000003, 0x0c01f001, - 0x00101e81, 0x00101e7c, 0x00101e80, 0x00101e7e, - 0x80040910, 0x0401f004, 0x80040930, 0x0401f002, - 0x80040920, 0x82040500, 0x000000ff, 0x82000d80, - 0x000000ff, 0x0400000f, 0x4c000000, 0x82000400, - 0x0010210e, 0x50000800, 0x80040910, 0x82040580, - 0x00000080, 0x5c000000, 0x04000030, 0x80600d80, - 0x0400002e, 0x80000540, 0x0400002c, 0x0401f00b, - 0x59a81005, 0x82081500, 0x00000003, 0x0402002b, - 0x59a81013, 0x84081542, 0x480b5013, 0x4a03501c, - 0x0000ffff, 0x0401f028, 0x4c000000, 0x59a80005, - 0x8c000514, 0x42001000, 0x00000010, 0x02020800, - 0x00104c6d, 0x5c000000, 0x0402001c, 0x417a8800, - 0x0201f800, 0x00105c9a, 0x04020016, 0x0201f800, - 0x001045e5, 0x04000006, 0x0201f800, 0x00104c62, - 0x0401f8b1, 0x0400000f, 0x0401f00c, 0x599c0019, - 0x8c00050e, 0x04020009, 0x0201f800, 0x001045a6, - 0x04020008, 0x0201f800, 0x00104c62, 0x0401f9e1, - 0x0401f8be, 0x04000003, 0x805cb800, 0x0401f7b2, - 0x485f501c, 0x0401f086, 0x4a03501c, 0x0000ffff, - 0x0401f083, 0x42003000, 0x0000007e, 0x59a8001c, - 0x82001580, 0x0000ffff, 0x04020005, 0x80000d80, - 0x4018b000, 0x4803c856, 0x0401f009, 0x8018b480, - 0x04001004, 0x40000800, 0x4803c856, 0x0401f004, - 0x4a03501c, 0x0000ffff, 0x0401f071, 0x4c040000, - 0x4c580000, 0x82040400, 0x0010210e, 0x50000000, - 0x82000500, 0x000000ff, 0x80604580, 0x0400005c, - 0x0201f800, 0x00105c9b, 0x04020061, 0x59a80005, - 0x8c000514, 0x42001000, 0x00000010, 0x02020800, - 0x00104c6d, 0x5c00b000, 0x5c000800, 0x040207d7, - 0x4c040000, 0x4c580000, 0x845cbd00, 0x0201f800, - 0x00020245, 0x04000008, 0x599c0019, 0x8c00050e, - 0x04020047, 0x0201f800, 0x001045ab, 0x0402004c, - 0x0401f002, 0x845cbd40, 0x0201f800, 0x00104c62, - 0x0201f800, 0x001049e7, 0x04020007, 0x59a80005, - 0x8c000502, 0x04000033, 0x59340200, 0x8c00050e, - 0x04020030, 0x59a81013, 0x8c081502, 0x04000025, - 0x0201f800, 0x00104a09, 0x04000031, 0x8c5cbd00, - 0x04020004, 0x0201f800, 0x001045ff, 0x0401f02c, - 0x0401f9cd, 0x0400002a, 0x42026000, 0x0010bde9, - 0x49366009, 0x497a6008, 0x417a7800, 0x0401f925, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x00103b25, 0x0400001d, 0x41782800, - 0x42003000, 0x00000008, 0x4d400000, 0x4d440000, - 0x59368c03, 0x42028000, 0x00000029, 0x0201f800, - 0x0010a446, 0x5c028800, 0x5c028000, 0x0401f010, - 0x4937c857, 0x599c0019, 0x8c00050e, 0x0402000c, - 0x0401f96c, 0x0401f849, 0x04000011, 0x0401f008, - 0x59a80013, 0x8c000500, 0x04000003, 0x0401f9a6, - 0x04000003, 0x0401f828, 0x04000009, 0x5c00b000, - 0x5c000800, 0x80040800, 0x8058b040, 0x04020798, - 0x4a03501c, 0x0000ffff, 0x0401f005, 0x4937c857, - 0x5c00b000, 0x5c000800, 0x4807501c, 0x5c00c000, - 0x5c00b800, 0x1c01f000, 0x4803c856, 0x4a03501c, - 0x00000001, 0x42028800, 0x000007fe, 0x42003000, - 0x00fffffe, 0x0201f800, 0x001045a6, 0x0402000c, - 0x0401f948, 0x0401f825, 0x04000009, 0x59a80026, - 0x8400054e, 0x48035026, 0x0201f800, 0x0010930f, - 0x82000540, 0x00000001, 0x1c01f000, 0x80000580, - 0x0401f7fe, 0x4937c857, 0x0201f800, 0x00107942, - 0x04000015, 0x49366009, 0x4a026406, 0x00000001, - 0x417a7800, 0x0201f800, 0x00104567, 0x59a8001b, - 0x80000000, 0x4803501b, 0x42027000, 0x00000004, - 0x599c0019, 0x8c00050e, 0x04000003, 0x42027000, - 0x00000000, 0x0201f800, 0x000207a1, 0x82000540, - 0x00000001, 0x1c01f000, 0x4937c857, 0x0201f800, - 0x00107942, 0x0400001c, 0x49366009, 0x59340403, - 0x82000580, 0x000007fe, 0x04000005, 0x4d3c0000, - 0x417a7800, 0x0401f8b7, 0x5c027800, 0x4a026406, - 0x00000001, 0x417a7800, 0x0201f800, 0x00104567, - 0x42000800, 0x00000003, 0x0201f800, 0x00104571, - 0x59a8001b, 0x80000000, 0x4803501b, 0x42027000, - 0x00000002, 0x0201f800, 0x000207a1, 0x82000540, - 0x00000001, 0x1c01f000, 0x4803c856, 0x42028800, - 0x000007fc, 0x42003000, 0x00fffffc, 0x0201f800, - 0x001045a6, 0x04020005, 0x0401f805, 0x04000003, - 0x4a035027, 0x0000ffff, 0x1c01f000, 0x4937c857, - 0x0201f800, 0x00107942, 0x04000014, 0x49366009, - 0x4a026406, 0x00000001, 0x417a7800, 0x0201f800, - 0x00104567, 0x42000800, 0x00000003, 0x0201f800, - 0x00104571, 0x59a80028, 0x80000000, 0x48035028, - 0x42027000, 0x00000002, 0x0201f800, 0x000207a1, - 0x82000540, 0x00000001, 0x1c01f000, 0x480bc857, - 0x492fc857, 0x4c5c0000, 0x4008b800, 0x42028800, - 0x000007fd, 0x42003000, 0x00fffffd, 0x0201f800, - 0x001045a6, 0x0402001a, 0x0201f800, 0x0002075a, - 0x04000017, 0x49366009, 0x5934000a, 0x84000544, - 0x4802680a, 0x812e59c0, 0x04000005, 0x592c0404, - 0x8c00051e, 0x04000002, 0x48ee6021, 0x492e6008, - 0x4a026406, 0x00000001, 0x485e601c, 0x42027000, - 0x00000022, 0x0201f800, 0x000207a1, 0x82000540, - 0x00000001, 0x5c00b800, 0x1c01f000, 0x80000580, - 0x0401f7fd, 0x5c000000, 0x4c000000, 0x4803c857, - 0x4943c857, 0x493fc857, 0x4d340000, 0x4d440000, - 0x4c580000, 0x4d2c0000, 0x4c5c0000, 0x0201f800, - 0x00106c55, 0x4df00000, 0x0201f800, 0x001069f1, - 0x0201f800, 0x00106aac, 0x0201f800, 0x00106737, - 0x0201f800, 0x0010848a, 0x5c03e000, 0x02000800, - 0x00106c4b, 0x4200b000, 0x000007f0, 0x417a8800, - 0x0201f800, 0x00020245, 0x0402001f, 0x8d3e7d14, - 0x04000005, 0x59340212, 0x82000500, 0x0000ff00, - 0x04000019, 0x8d3e7d06, 0x04000004, 0x59340200, - 0x8c00050e, 0x04020014, 0x8d3e7d18, 0x0400000f, - 0x5934b80f, 0x805cb9c0, 0x04000009, 0x49425a06, - 0x592cb800, 0x0201f800, 0x000202ce, 0x805cb9c0, - 0x040207fb, 0x497a680f, 0x497a6810, 0x4a026c00, - 0x00000707, 0x0401f004, 0x4937c857, 0x0201f800, - 0x001042b4, 0x81468800, 0x8058b040, 0x040207dd, - 0x8d3e7d02, 0x04000011, 0x497b501d, 0x42028800, - 0x000007f0, 0x4200b000, 0x00000010, 0x0201f800, - 0x00020245, 0x04020006, 0x4937c857, 0x4a026c00, - 0x00000707, 0x0201f800, 0x001042b4, 0x81468800, - 0x8058b040, 0x040207f6, 0x5c00b800, 0x5c025800, - 0x5c00b000, 0x5c028800, 0x5c026800, 0x1c01f000, - 0x5c000000, 0x4c000000, 0x4803c857, 0x4933c857, - 0x493fc857, 0x4d340000, 0x4d400000, 0x4d440000, - 0x4d2c0000, 0x4c5c0000, 0x0201f800, 0x00106c55, - 0x4df00000, 0x59326809, 0x813669c0, 0x04000020, - 0x59368c03, 0x42028000, 0x00000029, 0x0201f800, - 0x00106a50, 0x0201f800, 0x00106ab4, 0x0201f800, - 0x001067fd, 0x0201f800, 0x0010a2ff, 0x4937c857, - 0x8d3e7d18, 0x04000010, 0x5934b80f, 0x805cb9c0, - 0x0400000a, 0x405e5800, 0x49425a06, 0x592cb800, - 0x0201f800, 0x000202ce, 0x805cb9c0, 0x040207fa, - 0x497a680f, 0x497a6810, 0x4a026c00, 0x00000707, - 0x0401f003, 0x0201f800, 0x001042b4, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x5c00b800, 0x5c025800, - 0x5c028800, 0x5c028000, 0x5c026800, 0x1c01f000, - 0x4933c857, 0x59a80026, 0x8c000508, 0x04020012, - 0x59305009, 0x482bc857, 0x836c0580, 0x00000002, - 0x0402000d, 0x0401f813, 0x0402000b, 0x58280403, - 0x82000580, 0x000007fc, 0x04000008, 0x59a8001b, - 0x80000040, 0x4803c857, 0x02001800, 0x001005d8, - 0x4803501b, 0x1c01f000, 0x59a80028, 0x80000040, - 0x4803c857, 0x040017fc, 0x48035028, 0x1c01f000, - 0x59300008, 0x800001c0, 0x04020009, 0x59300403, - 0x82000580, 0x00000001, 0x04020004, 0x82000540, - 0x00000001, 0x0401f002, 0x80000580, 0x1c01f000, - 0x4937c857, 0x59340200, 0x84000502, 0x48026a00, - 0x1c01f000, 0x4933c857, 0x493fc857, 0x4947c857, - 0x4d3c0000, 0x4d400000, 0x4d340000, 0x4d440000, - 0x4c580000, 0x0201f800, 0x00106c55, 0x4df00000, - 0x813e79c0, 0x04020004, 0x4200b000, 0x00000001, - 0x0401f004, 0x4200b000, 0x000007f0, 0x417a8800, - 0x41440000, 0x81ac0400, 0x50000000, 0x80026d40, - 0x04000019, 0x42027800, 0x00000001, 0x0201f800, - 0x001048f6, 0x42028000, 0x00000029, 0x417a7800, - 0x0201f800, 0x00106a50, 0x0201f800, 0x00106ab4, - 0x0201f800, 0x001067fd, 0x0201f800, 0x001049e7, - 0x04020005, 0x4937c857, 0x4a026c00, 0x00000404, - 0x0401f003, 0x0201f800, 0x00104a14, 0x0201f800, - 0x0010a2ff, 0x81468800, 0x8058b040, 0x040207e1, - 0x5c03e000, 0x02000800, 0x00106c4b, 0x5c00b000, - 0x5c028800, 0x5c026800, 0x5c028000, 0x5c027800, - 0x1c01f000, 0x4937c857, 0x4947c857, 0x4c5c0000, - 0x4c600000, 0x4c640000, 0x59a80013, 0x8c000500, - 0x0400001f, 0x599c0017, 0x8c00050a, 0x0402001c, - 0x5934ba02, 0x825cbd00, 0x000000ff, 0x485fc857, - 0x4178c000, 0x4178c800, 0x82600400, 0x0010be21, - 0x50002000, 0x8060c1c0, 0x04000008, 0x82100500, - 0x000000ff, 0x82002d80, 0x000000ff, 0x0400000c, - 0x805c0580, 0x0400000d, 0x80102110, 0x8064c800, - 0x82640580, 0x00000004, 0x040207f5, 0x8060c000, - 0x82600580, 0x00000020, 0x040207eb, 0x4813c857, - 0x82000540, 0x00000001, 0x5c00c800, 0x5c00c000, - 0x5c00b800, 0x1c01f000, 0x59a80026, 0x4803c857, - 0x8c000512, 0x1c01f000, 0x00007eef, 0x00007de8, - 0x00007ce4, 0x000080e2, 0x00007be1, 0x000080e0, - 0x000080dc, 0x000080da, 0x00007ad9, 0x000080d6, - 0x000080d5, 0x000080d4, 0x000080d3, 0x000080d2, - 0x000080d1, 0x000079ce, 0x000078cd, 0x000080cc, - 0x000080cb, 0x000080ca, 0x000080c9, 0x000080c7, - 0x000080c6, 0x000077c5, 0x000076c3, 0x000080bc, - 0x000080ba, 0x000075b9, 0x000080b6, 0x000074b5, - 0x000073b4, 0x000072b3, 0x000080b2, 0x000080b1, - 0x000080ae, 0x000071ad, 0x000080ac, 0x000070ab, - 0x00006faa, 0x00006ea9, 0x000080a7, 0x00006da6, - 0x00006ca5, 0x00006ba3, 0x00006a9f, 0x0000699e, - 0x0000689d, 0x0000809b, 0x00008098, 0x00006797, - 0x00006690, 0x0000658f, 0x00006488, 0x00006384, - 0x00006282, 0x00008081, 0x00008080, 0x0000617c, - 0x0000607a, 0x00008079, 0x00005f76, 0x00008075, - 0x00008074, 0x00008073, 0x00008072, 0x00008071, - 0x0000806e, 0x00005e6d, 0x0000806c, 0x00005d6b, - 0x00005c6a, 0x00005b69, 0x00008067, 0x00005a66, - 0x00005965, 0x00005863, 0x0000575c, 0x0000565a, - 0x00005559, 0x00008056, 0x00008055, 0x00005454, - 0x00005353, 0x00005252, 0x00005151, 0x0000504e, - 0x00004f4d, 0x0000804c, 0x0000804b, 0x00004e4a, - 0x00004d49, 0x00008047, 0x00004c46, 0x00008045, - 0x00008043, 0x0000803c, 0x0000803a, 0x00008039, - 0x00008036, 0x00004b35, 0x00008034, 0x00004a33, - 0x00004932, 0x00004831, 0x0000802e, 0x0000472d, - 0x0000462c, 0x0000452b, 0x0000442a, 0x00004329, - 0x00004227, 0x00008026, 0x00008025, 0x00004123, - 0x0000401f, 0x00003f1e, 0x00003e1d, 0x00003d1b, - 0x00003c18, 0x00008017, 0x00008010, 0x00003b0f, - 0x00003a08, 0x00008004, 0x00003902, 0x00008001, - 0x00008000, 0x00008000, 0x00003800, 0x00003700, - 0x00003600, 0x00008000, 0x00003500, 0x00008000, - 0x00008000, 0x00008000, 0x00003400, 0x00008000, - 0x00008000, 0x00008000, 0x00008000, 0x00008000, - 0x00008000, 0x00003300, 0x00003200, 0x00008000, - 0x00008000, 0x00008000, 0x00008000, 0x00008000, - 0x00008000, 0x00003100, 0x00003000, 0x00008000, - 0x00008000, 0x00002f00, 0x00008000, 0x00002e00, - 0x00002d00, 0x00002c00, 0x00008000, 0x00008000, - 0x00008000, 0x00002b00, 0x00008000, 0x00002a00, - 0x00002900, 0x00002800, 0x00008000, 0x00002700, - 0x00002600, 0x00002500, 0x00002400, 0x00002300, - 0x00002200, 0x00008000, 0x00008000, 0x00002100, - 0x00002000, 0x00001f00, 0x00001e00, 0x00001d00, - 0x00001c00, 0x00008000, 0x00008000, 0x00001b00, - 0x00001a00, 0x00008000, 0x00001900, 0x00008000, - 0x00008000, 0x00008000, 0x00008000, 0x00008000, - 0x00008000, 0x00001800, 0x00008000, 0x00001700, - 0x00001600, 0x00001500, 0x00008000, 0x00001400, - 0x00001300, 0x00001200, 0x00001100, 0x00001000, - 0x00000f00, 0x00008000, 0x00008000, 0x00000e00, - 0x00000d00, 0x00000c00, 0x00000b00, 0x00000a00, - 0x00000900, 0x00008000, 0x00008000, 0x00000800, - 0x00000700, 0x00008000, 0x00000600, 0x00008000, - 0x00008000, 0x00008000, 0x00000500, 0x00000400, - 0x00000300, 0x00008000, 0x00000200, 0x00008000, - 0x00008000, 0x00008000, 0x00000100, 0x00008000, - 0x00008000, 0x00008000, 0x00008000, 0x00008000, - 0x00008000, 0x00000000, 0x00008000, 0x00008000, - 0x00008000, 0x00008000, 0x00008000, 0x00008000, - 0x00008000, 0x00008000, 0x00008000, 0x00008000, - 0x00008000, 0x00008000, 0x00008000, 0x00008000, - 0x00008000, 0x00008000, 0x0201f800, 0x001007d3, - 0x02000800, 0x001005d8, 0x492f4016, 0x1c01f000, - 0x83a0ac00, 0x00000006, 0x83a00580, 0x0010b4a4, - 0x0400000c, 0x492fc857, 0x812e59c0, 0x02000800, - 0x001005d8, 0x832ca400, 0x00000006, 0x4200b000, - 0x0000000d, 0x0201f800, 0x0010ab17, 0x0401f00f, - 0x4200b000, 0x00000010, 0x83e0a400, 0x00000020, - 0x50500000, 0x8050a000, 0x50500800, 0x900409c0, - 0x80040540, 0x4400a800, 0x8050a000, 0x8054a800, - 0x8058b040, 0x040207f7, 0x1c01f000, 0x59a00206, - 0x4803c857, 0x82000c80, 0x0000007f, 0x040210c9, - 0x59a80821, 0x0c01f001, 0x001022c0, 0x00102300, - 0x00102300, 0x0010234b, 0x0010236d, 0x00102300, - 0x001022c0, 0x0010238f, 0x001023a0, 0x00102300, - 0x00102300, 0x001023ad, 0x001023c5, 0x001023dd, - 0x00102300, 0x001023e7, 0x001023f4, 0x00102300, - 0x0010241d, 0x00102300, 0x0010247a, 0x00102300, - 0x00102300, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102300, 0x00102491, 0x00102300, - 0x001024e3, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x001024e8, 0x00102560, 0x00102300, - 0x00102567, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102300, 0x00102569, 0x001025ea, - 0x00102727, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102300, 0x00102736, 0x00102300, - 0x00102300, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102300, 0x00102753, 0x001027a6, - 0x00102802, 0x00102816, 0x00102835, 0x00102a70, - 0x00102dff, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102300, 0x00102300, 0x00102300, - 0x00102300, 0x00102fb4, 0x00103028, 0x00102300, - 0x00102300, 0x00103094, 0x00102300, 0x00103126, - 0x001031d8, 0x00102300, 0x00102300, 0x0010320f, - 0x0010326b, 0x00102300, 0x001032bd, 0x00103419, - 0x00102300, 0x0010342d, 0x001034b8, 0x00102300, - 0x00102300, 0x00102300, 0x00102300, 0x00103522, - 0x00103526, 0x00103545, 0x00102300, 0x001035e7, - 0x00102300, 0x00102300, 0x00103615, 0x00102300, - 0x00103643, 0x00102300, 0x00102300, 0x001036aa, - 0x001037b7, 0x00103814, 0x00102300, 0x0010387a, - 0x00102300, 0x00102300, 0x001038d3, 0x00103936, - 0x00102300, 0x48efc857, 0x4031d800, 0x58ef400b, - 0x58ec0002, 0x82000580, 0x00000200, 0x04000045, - 0x48efc857, 0x4a034206, 0x00004000, 0x0201f800, - 0x00103a15, 0x83a00580, 0x0010b4a4, 0x0400000d, - 0x58ee580a, 0x4d2c0000, 0x0401f856, 0x41a25800, - 0x0201f800, 0x001007f4, 0x40ee5800, 0x0201f800, - 0x001007f4, 0x5c025800, 0x0201f000, 0x000202da, - 0x04026007, 0x59a0001d, 0x84000542, 0x4803401d, - 0x4a01d809, 0x001022d4, 0x1c01f000, 0x59a00206, - 0x82000d80, 0x00004000, 0x04000006, 0x900001c0, - 0x82000540, 0x00000011, 0x4803c011, 0x0401f005, - 0x900001c0, 0x82000540, 0x00000010, 0x4803c011, - 0x0401f845, 0x59e00017, 0x8c000508, 0x0402000c, - 0x4203e000, 0x30000001, 0x4203e000, 0x40000000, - 0x40ee5800, 0x0201f800, 0x001007f4, 0x59a0001d, - 0x84000504, 0x4803401d, 0x1c01f000, 0x4a03c017, - 0x00000000, 0x59a00206, 0x82000d80, 0x00004000, - 0x040007f0, 0x4a03c017, 0x00000001, 0x0401f7ed, - 0x4803c856, 0x4a034206, 0x00004001, 0x0401f7c0, - 0x4803c856, 0x4a034206, 0x00004002, 0x0401f7bc, - 0x4803c856, 0x4a034206, 0x00004003, 0x0401f7b8, - 0x4803c856, 0x4a034206, 0x00004005, 0x0401f7b4, - 0x4803c856, 0x4a034206, 0x00004006, 0x0401f7b0, - 0x4803c856, 0x4a034206, 0x0000400b, 0x0401f7ac, - 0x4803c856, 0x4a034206, 0x0000400c, 0x0401f7a8, - 0x4803c856, 0x4a034206, 0x0000400c, 0x0401f7a4, - 0x48efc857, 0x58eca80a, 0x8054a9c0, 0x02000800, - 0x001005d8, 0x83a0a400, 0x00000006, 0x8254ac00, - 0x00000006, 0x4200b000, 0x0000000d, 0x0201f000, - 0x0010ab17, 0x59a00206, 0x4803c857, 0x59a00406, - 0x4803c857, 0x59a00207, 0x4803c857, 0x59a00407, - 0x4803c857, 0x59a00208, 0x4803c857, 0x59a00408, - 0x4803c857, 0x59a00209, 0x4803c857, 0x83e0ac00, - 0x00000020, 0x83a0a400, 0x00000006, 0x4200b000, - 0x00000010, 0x50500000, 0x4400a800, 0x8054a800, - 0x900001c0, 0x4400a800, 0x8054a800, 0x8050a000, - 0x8058b040, 0x040207f8, 0x1c01f000, 0x59a00406, - 0x800000c2, 0x59a00a07, 0x900409c0, 0x80040540, - 0x84000540, 0x59a00c07, 0x8c040d00, 0x04000018, - 0x59a80805, 0x8c040d0e, 0x040207ba, 0x42000800, - 0x00000064, 0x80040840, 0x04000007, 0x4a030000, - 0x00000001, 0x40000000, 0x59801000, 0x8c081500, - 0x040007f9, 0x04000005, 0x48030004, 0x4a030000, - 0x00000000, 0x0401f75b, 0x4a030000, 0x00000000, - 0x4a034406, 0x00000004, 0x040007a2, 0x4803880e, - 0x0401f754, 0x59a00406, 0x800000c2, 0x59a00c07, - 0x8c040d00, 0x0400001a, 0x59a80805, 0x8c040d0e, - 0x0402079c, 0x42000800, 0x00000064, 0x80040840, - 0x04000007, 0x4a030000, 0x00000001, 0x40000000, - 0x59801000, 0x8c081500, 0x040007f9, 0x04000007, - 0x48030004, 0x59800805, 0x48074406, 0x4a030000, - 0x00000000, 0x0401f73b, 0x4a030000, 0x00000000, - 0x4a034406, 0x00000004, 0x04000782, 0x4803880e, - 0x59c4080f, 0x48074406, 0x0401f732, 0x59a01c06, - 0x59a00207, 0x900c19c0, 0x800c1d40, 0x580c0803, - 0x80000580, 0x500c1000, 0x80080400, 0x800c1800, - 0x80040840, 0x040207fc, 0x48034406, 0x900001c0, - 0x48034207, 0x800001c0, 0x04000722, 0x0401f769, - 0x4a034406, 0x00000004, 0x4a034207, 0x00000000, - 0x4a034407, 0x00000010, 0x59a8000d, 0x48034208, - 0x900001c0, 0x48034408, 0x4a034209, 0x00000002, - 0x0401f714, 0x59a00407, 0x59a01207, 0x900811c0, - 0x80081540, 0x59a00409, 0x59a01a09, 0x900c19c0, - 0x800c1d40, 0x59a00a08, 0x59a00408, 0x900409c0, - 0x80040d40, 0x59a0020a, 0x82002480, 0x00000010, - 0x04001754, 0x59a02406, 0x900001c0, 0x80100540, - 0x59a8280d, 0x80142480, 0x0400174e, 0x0201f000, - 0x00103a25, 0x59a00407, 0x59a01207, 0x900811c0, - 0x80081540, 0x59a00409, 0x59a01a09, 0x900c19c0, - 0x800c1d40, 0x59a00a08, 0x59a00408, 0x900409c0, - 0x80040d40, 0x59a0020a, 0x82002480, 0x00000010, - 0x0400173c, 0x59a02406, 0x900001c0, 0x80100540, - 0x59a8280d, 0x80142480, 0x04001736, 0x0201f000, - 0x00103a28, 0x59a00a0a, 0x59a00406, 0x900409c0, - 0x80040d40, 0x59a01407, 0x59a00207, 0x900811c0, - 0x80081540, 0x44080800, 0x0401f6da, 0x59a00a0a, - 0x59a00406, 0x900409c0, 0x80040d40, 0x50040000, - 0x82000d00, 0x0000ffff, 0x48074207, 0x82000d00, - 0xffff0000, 0x900409c0, 0x48074407, 0x0401f6cd, - 0x59a00406, 0x8c000500, 0x04000020, 0x59a01207, - 0x59a01c07, 0x59a02208, 0x480b5054, 0x480f5055, - 0x48135056, 0x59c40801, 0x82040d00, 0x00018000, - 0x82040580, 0x00000000, 0x04000009, 0x82040580, - 0x00008000, 0x04000008, 0x82040580, 0x00010000, - 0x04000007, 0x0201f800, 0x001005d8, 0x40080000, - 0x0401f004, 0x400c0000, 0x0401f002, 0x40100000, - 0x80000110, 0x42000800, 0x000000e0, 0x0201f800, - 0x00101944, 0x0401f007, 0x59a81054, 0x59a81855, - 0x59a82056, 0x480b4207, 0x480f4407, 0x48134208, - 0x0401f6a4, 0x4d2c0000, 0x4d340000, 0x4d300000, - 0x4d440000, 0x59a28c06, 0x0201f800, 0x00020245, - 0x04000006, 0x5c028800, 0x5c026000, 0x5c026800, - 0x5c025800, 0x0401f6e7, 0x59a04407, 0x59a00207, - 0x900001c0, 0x80204540, 0x0401f81e, 0x04000009, - 0x4a034208, 0x00000001, 0x4a034406, 0x0000ffff, - 0x4a034207, 0x0000ffff, 0x497b4407, 0x0401f00b, - 0x0401f822, 0x0400000e, 0x4a034208, 0x00000002, - 0x59300402, 0x48034406, 0x59300202, 0x48034207, - 0x59300206, 0x48034407, 0x5c028800, 0x5c026000, - 0x5c026800, 0x5c025800, 0x0401f67a, 0x5c028800, - 0x5c026000, 0x5c026800, 0x5c025800, 0x0401f6c1, - 0x4937c856, 0x4823c856, 0x4d2c0000, 0x5934000f, - 0x80025d40, 0x04000007, 0x592c0005, 0x80200580, - 0x592c0000, 0x040207fb, 0x82000540, 0x00000001, - 0x5c025800, 0x1c01f000, 0x4823c857, 0x4d2c0000, - 0x4d300000, 0x42026000, 0x0010d1c0, 0x59300406, - 0x82000d80, 0x00000003, 0x04000004, 0x82000d80, - 0x00000006, 0x04020007, 0x59325808, 0x812e59c0, - 0x04000004, 0x592c0005, 0x80200580, 0x0400000a, - 0x83326400, 0x00000024, 0x41580000, 0x81300480, - 0x040017ef, 0x80000580, 0x5c026000, 0x5c025800, - 0x1c01f000, 0x82000540, 0x00000001, 0x5c026000, - 0x5c025800, 0x1c01f000, 0x83a00580, 0x0010b4a4, - 0x04020684, 0x59a80005, 0x8c00050e, 0x04020003, - 0x4a030000, 0x00000000, 0x4a034206, 0x00004000, - 0x4a03c011, 0x40000010, 0x0401fea7, 0x59e00017, - 0x8c000508, 0x04000003, 0x4a03c017, 0x00000000, - 0x4203e000, 0x30000001, 0x4203e000, 0x40000000, - 0x0401f000, 0x800409c0, 0x04000004, 0x4a034406, - 0x00000001, 0x0401f677, 0x836c0580, 0x00000003, - 0x04020010, 0x59a80010, 0x497b4406, 0x0201f800, - 0x0010513b, 0x0400000f, 0x82000d00, 0x00ffff00, - 0x0402000c, 0x82000c00, 0x0010210e, 0x50040800, - 0x80040910, 0x82041580, 0x00000080, 0x04020004, - 0x4a034406, 0x00000007, 0x0401f662, 0x48074406, - 0x82000d00, 0x0000ffff, 0x48074207, 0x80000120, - 0x48034407, 0x59a80026, 0x82001500, 0x00000100, - 0x480b4409, 0x8c000502, 0x0400001f, 0x8c000506, - 0x04000009, 0x82000d00, 0x0000000a, 0x82040d80, - 0x0000000a, 0x04020004, 0x4a034209, 0x00000001, - 0x0401f022, 0x8c00050a, 0x04000009, 0x82000d00, - 0x00000022, 0x82040d80, 0x00000022, 0x04020004, - 0x4a034209, 0x00000003, 0x0401f018, 0x8c000508, - 0x04000009, 0x82000d00, 0x00000012, 0x82040d80, - 0x00000012, 0x04020004, 0x4a034209, 0x00000002, - 0x0401f00e, 0x0201f800, 0x0010513b, 0x04020004, - 0x4a034209, 0x00000004, 0x0401f5e6, 0x8c000506, - 0x04000004, 0x4a034406, 0x00000005, 0x0401f62d, - 0x4a034209, 0x00000000, 0x0401f5de, 0x59a80037, - 0x48034407, 0x59a80038, 0x48034209, 0x0401f5d9, - 0x42007800, 0x0010b8ec, 0x59a00406, 0x4803c857, - 0x82000c80, 0x00000006, 0x04021622, 0x0c01f001, - 0x001024f6, 0x001024f7, 0x00102505, 0x00102518, - 0x00102539, 0x001024f6, 0x0401f61a, 0x836c0580, - 0x00000000, 0x04000613, 0x59a00a07, 0x59a00407, - 0x900001c0, 0x80040d40, 0x4807c857, 0x59a00a08, - 0x59a00408, 0x900001c0, 0x80040d40, 0x4807c857, - 0x0401f056, 0x836c0580, 0x00000000, 0x04000605, - 0x59a00407, 0x59a01207, 0x900001c0, 0x80081540, - 0x59a00408, 0x59a01a08, 0x900001c0, 0x800c1d40, - 0x42000000, 0x0010c1bf, 0x480fc857, 0x480bc857, - 0x42000800, 0x00001000, 0x0201f000, 0x00103a28, - 0x59a00a07, 0x59a00407, 0x900001c0, 0x80041d40, - 0x820c0c80, 0x0010ab4a, 0x040215f2, 0x820c0c80, - 0x00100000, 0x040015ef, 0x480fc857, 0x823c7c00, - 0x00000009, 0x503c0800, 0x800409c0, 0x04000006, - 0x823c0580, 0x0000000d, 0x040005e6, 0x803c7800, - 0x0401f7f9, 0x59e41001, 0x82080d00, 0xfffeffcf, - 0x4807c801, 0x440c7800, 0x46001800, 0x0201f800, - 0x800c1800, 0x46001800, 0x001005cb, 0x480bc801, - 0x0401f022, 0x59a01a07, 0x59a00407, 0x900001c0, - 0x800c1d40, 0x480c7801, 0x59a02208, 0x59a00408, - 0x900001c0, 0x80102540, 0x48107802, 0x59a00209, - 0x80000040, 0x040015cb, 0x48007806, 0x80000000, - 0x48007805, 0x42000800, 0x00004000, 0x40001000, - 0x0201f800, 0x00106681, 0x80000540, 0x04000003, - 0x49787801, 0x0401f5bf, 0x40040000, 0x800c1c00, - 0x040015bc, 0x480c7803, 0x48107804, 0x49787808, - 0x59a00409, 0x48007807, 0x59e40001, 0x4803c857, - 0x82000540, 0x00040000, 0x4803c801, 0x0401f561, - 0x59a80006, 0x48034406, 0x59a80007, 0x48034207, - 0x59a80008, 0x48034407, 0x0401f55a, 0x0201f800, - 0x001005d8, 0x4803c856, 0x4a03c013, 0x03800300, - 0x4a03c014, 0x03800380, 0x59a00c06, 0x82040580, - 0x000000a0, 0x04000004, 0x82040580, 0x000000a2, - 0x0402002b, 0x59a0140a, 0x82080480, 0x00000100, - 0x04021027, 0x59a0020b, 0x8c000500, 0x0402002e, - 0x59a00a0a, 0x800409c0, 0x04000021, 0x82040480, - 0x00000041, 0x0402101e, 0x82040c00, 0x00000003, - 0x82040d00, 0x000000fc, 0x80040904, 0x59a00407, - 0x59a01207, 0x900811c0, 0x80081540, 0x59a00409, - 0x59a01a09, 0x900c19c0, 0x800c1d40, 0x0201f800, - 0x00103a00, 0x04020006, 0x4a034406, 0x00000002, - 0x4a03c014, 0x03800000, 0x0401f576, 0x832e5c00, - 0x00000004, 0x412c0000, 0x0201f800, 0x00103a25, - 0x4a01d809, 0x001025a2, 0x1c01f000, 0x4a03c014, - 0x03800000, 0x0401f56f, 0x4031d800, 0x58ef400b, - 0x58ee580d, 0x58ec0002, 0x82000580, 0x00000200, - 0x0400055c, 0x59a00c06, 0x59a0140a, 0x59a0020b, - 0x8c000500, 0x04020031, 0x832e5c00, 0x00000004, - 0x41783800, 0x59a04a0a, 0x401c0000, 0x812c0400, - 0x50004000, 0x82201d00, 0x000000ff, 0x4c040000, - 0x0401f8ac, 0x5c000800, 0x0400002d, 0x80244840, - 0x04000028, 0x80081000, 0x82201d00, 0x0000ff00, - 0x800c1910, 0x4c040000, 0x0401f8a2, 0x5c000800, - 0x04000023, 0x80244840, 0x0400001e, 0x80081000, - 0x82201d00, 0x00ff0000, 0x800c1920, 0x4c040000, - 0x0401f898, 0x5c000800, 0x04000019, 0x80244840, - 0x04000014, 0x80081000, 0x82201d00, 0xff000000, - 0x800c1930, 0x4c040000, 0x0401f88e, 0x5c000800, - 0x0400000f, 0x80244840, 0x0400000a, 0x80081000, - 0x801c3800, 0x0401f7d5, 0x59a0020a, 0x82000500, - 0x000000ff, 0x40001800, 0x0401f882, 0x04000004, - 0x4a03c014, 0x03800000, 0x0401f4da, 0x4a03c014, - 0x03800000, 0x0401f523, 0x4803c856, 0x4a03c013, - 0x03800300, 0x4a03c014, 0x03800380, 0x59a00c06, - 0x82040580, 0x000000a0, 0x04000004, 0x82040580, - 0x000000a2, 0x0402006c, 0x59a0140a, 0x82080480, - 0x00000100, 0x04021068, 0x59a0020b, 0x8c000500, - 0x0402005c, 0x59a01a0a, 0x800c19c0, 0x04000062, - 0x820c0480, 0x00000041, 0x0402105f, 0x0201f800, - 0x00103a00, 0x04020006, 0x4a034406, 0x00000002, - 0x4a03c014, 0x03800000, 0x0401f502, 0x832e5c00, - 0x00000004, 0x41783800, 0x59a04a0a, 0x401c0000, - 0x812c0400, 0x40004000, 0x4c040000, 0x4c080000, - 0x0401f874, 0x5c001000, 0x5c000800, 0x04000047, - 0x44144000, 0x80244840, 0x0400002b, 0x80081000, - 0x4c040000, 0x4c080000, 0x0401f86a, 0x5c001000, - 0x5c000800, 0x0400003d, 0x50200000, 0x801428d0, - 0x80140540, 0x44004000, 0x80244840, 0x0400001e, - 0x80081000, 0x4c040000, 0x4c080000, 0x0401f85d, - 0x5c001000, 0x5c000800, 0x04000030, 0x50200000, - 0x801428e0, 0x80140540, 0x44004000, 0x80244840, - 0x04000011, 0x80081000, 0x4c040000, 0x4c080000, - 0x0401f850, 0x5c001000, 0x5c000800, 0x04000023, - 0x50200000, 0x801428f0, 0x80140540, 0x44004000, - 0x80244840, 0x04000004, 0x80081000, 0x801c3800, - 0x0401f7cb, 0x59a00a0a, 0x82040c00, 0x00000003, - 0x82040d00, 0x000000fc, 0x80040904, 0x59a00407, - 0x59a01207, 0x900811c0, 0x80081540, 0x59a00409, - 0x59a01a09, 0x900c19c0, 0x800c1d40, 0x4a03c014, - 0x03800000, 0x412c0000, 0x0201f000, 0x00103a28, - 0x0401f830, 0x04000005, 0x48174406, 0x4a03c014, - 0x03800000, 0x0401f463, 0x4a03c014, 0x03800000, - 0x0401f4ac, 0x4a03c014, 0x03800000, 0x0401f4ad, - 0x0401f836, 0x04000010, 0x0401f862, 0x0402000f, - 0x40080800, 0x0401f85f, 0x0402000c, 0x400c0800, - 0x0401f85c, 0x04020009, 0x0401f84b, 0x42000000, - 0x00030d40, 0x80000040, 0x040207ff, 0x82000540, - 0x00000001, 0x1c01f000, 0x0401f843, 0x80000580, - 0x0401f7fd, 0x0401f821, 0x0400000a, 0x82040d40, - 0x00000001, 0x0401f84b, 0x04020007, 0x0401f87e, - 0x0401f898, 0x0401f838, 0x82000540, 0x00000001, - 0x1c01f000, 0x0401f834, 0x80000580, 0x0401f7fd, - 0x40041800, 0x0401f811, 0x0400000c, 0x0401f83d, - 0x0402000b, 0x40080800, 0x0401f83a, 0x04020008, - 0x400c0800, 0x0401ffe8, 0x04000004, 0x0401f826, - 0x82000540, 0x00000001, 0x1c01f000, 0x0401f822, - 0x80000580, 0x0401f7fd, 0x4c040000, 0x42000800, - 0x00000064, 0x4a03c013, 0x03800300, 0x80040840, - 0x04000016, 0x59e00013, 0x82000500, 0x00000300, - 0x82000580, 0x00000300, 0x040207f7, 0x42000000, - 0x00000064, 0x80000040, 0x040207ff, 0x4a03c013, - 0x01000000, 0x42000000, 0x00000064, 0x80000040, - 0x040207ff, 0x4a03c013, 0x02000000, 0x82000540, - 0x00000001, 0x0401f002, 0x80000580, 0x5c000800, - 0x1c01f000, 0x4a03c013, 0x01000000, 0x42000000, - 0x00000064, 0x80000040, 0x040207ff, 0x4a03c013, - 0x02000200, 0x42000000, 0x00000064, 0x80000040, - 0x040207ff, 0x4a03c013, 0x01000100, 0x1c01f000, - 0x42002000, 0x00000008, 0x82040500, 0x00000080, - 0x800000c2, 0x82000540, 0x01000000, 0x4803c013, - 0x42000000, 0x00000064, 0x80000040, 0x040207ff, - 0x4a03c013, 0x02000200, 0x42000000, 0x00000064, - 0x80000040, 0x040207ff, 0x4a03c013, 0x02000000, - 0x800408c2, 0x80102040, 0x040207ec, 0x4a03c013, - 0x01000100, 0x42000000, 0x00000064, 0x80000040, - 0x040207ff, 0x4a03c013, 0x02000200, 0x42000000, - 0x00000064, 0x80000040, 0x040207ff, 0x59e00013, - 0x82000500, 0x00000100, 0x4a03c013, 0x02000000, - 0x4c040000, 0x42000800, 0x00000064, 0x59e00013, - 0x82000500, 0x00000100, 0x80040840, 0x04000003, - 0x80000540, 0x040207fa, 0x80000540, 0x5c000800, - 0x1c01f000, 0x4a03c013, 0x01000100, 0x42001000, - 0x00000008, 0x80000d80, 0x42000000, 0x00000064, - 0x80000040, 0x040207ff, 0x4a03c013, 0x02000200, - 0x42000000, 0x00000064, 0x80000040, 0x040207ff, - 0x59e00013, 0x82000500, 0x00000100, 0x80000110, - 0x800408c2, 0x80040d40, 0x4a03c013, 0x02000000, - 0x80081040, 0x040207ed, 0x40042800, 0x1c01f000, - 0x4a03c013, 0x01000100, 0x42000000, 0x00000064, - 0x80000040, 0x040207ff, 0x4a03c013, 0x02000200, - 0x42000000, 0x00000064, 0x80000040, 0x040207ff, - 0x4a03c013, 0x02000000, 0x1c01f000, 0x59a00407, - 0x59a80837, 0x48035037, 0x48074407, 0x59a00a09, - 0x82040480, 0x00000014, 0x04021003, 0x42000800, - 0x000007d0, 0x59a80038, 0x48075038, 0x48034209, - 0x0201f000, 0x001022c0, 0x836c0580, 0x00000000, - 0x0400000e, 0x59a80006, 0x59a00c06, 0x80041580, - 0x82081500, 0x00000040, 0x02000000, 0x001022c0, - 0x80080580, 0x48035006, 0x0201f800, 0x00100699, - 0x0201f000, 0x001022c0, 0x59a00406, 0x59a80806, - 0x48035006, 0x80040d80, 0x8c040d0c, 0x02020800, - 0x00100699, 0x59a00207, 0x48035007, 0x59a00407, - 0x48035008, 0x0201f000, 0x001022c0, 0x800409c0, - 0x04000005, 0x4a034406, 0x00000001, 0x0201f000, - 0x0010230c, 0x0201f800, 0x0010513b, 0x04020005, - 0x4a034406, 0x00000016, 0x0201f000, 0x0010230c, - 0x836c0580, 0x00000003, 0x04000005, 0x4a034406, - 0x00000007, 0x0201f000, 0x0010230c, 0x59a00c06, - 0x82040500, 0xffffff00, 0x02020000, 0x00102310, - 0x82041580, 0x000000ff, 0x04020007, 0x59a80010, - 0x82000500, 0x000000ff, 0x82001540, 0x0000ff00, - 0x0401f011, 0x82040400, 0x0010210e, 0x50000000, - 0x80000110, 0x82000580, 0x00000080, 0x02000000, - 0x00102310, 0x59a80010, 0x82000500, 0x000000ff, - 0x80041580, 0x02000000, 0x00102310, 0x840409c0, - 0x80041540, 0x0201f800, 0x0002075a, 0x04020005, - 0x4a034406, 0x00000003, 0x0201f000, 0x0010230c, - 0x48ee6021, 0x480a621c, 0x4a02641c, 0x0000bc09, - 0x4a026406, 0x00000001, 0x0201f800, 0x00103a00, - 0x04020007, 0x0201f800, 0x0002077d, 0x4a034406, - 0x00000002, 0x0201f000, 0x0010230c, 0x497a5a04, - 0x497a5805, 0x4a025c04, 0x00008000, 0x4a01d809, - 0x001027f9, 0x492e6008, 0x42027000, 0x00000032, - 0x0201f000, 0x000207a1, 0x800409c0, 0x04000005, - 0x4a034406, 0x00000001, 0x0201f000, 0x0010230c, - 0x0201f800, 0x0010513b, 0x04020005, 0x4a034406, - 0x00000016, 0x0201f000, 0x0010230c, 0x836c0580, - 0x00000003, 0x04000005, 0x4a034406, 0x00000007, - 0x0201f000, 0x0010230c, 0x59a00c06, 0x82040500, - 0xffffff00, 0x02020000, 0x00102310, 0x82041580, - 0x000000ff, 0x04020007, 0x59a80010, 0x82000500, - 0x000000ff, 0x82001540, 0x0000ff00, 0x0401f011, - 0x82040400, 0x0010210e, 0x50000000, 0x80000110, - 0x82000580, 0x00000080, 0x02000000, 0x00102310, - 0x59a80010, 0x82000500, 0x000000ff, 0x80041580, - 0x02000000, 0x00102310, 0x840409c0, 0x80041540, - 0x0201f800, 0x0002075a, 0x04020005, 0x4a034406, - 0x00000003, 0x0201f000, 0x0010230c, 0x48ee6021, - 0x480a621c, 0x4a02641c, 0x0000bc05, 0x4a026406, - 0x00000001, 0x0201f800, 0x00103a00, 0x04020007, - 0x0201f800, 0x0002077d, 0x4a034406, 0x00000002, - 0x0201f000, 0x0010230c, 0x497a5a04, 0x497a5805, - 0x4a025c04, 0x00008000, 0x4a01d809, 0x001027f9, - 0x492e6008, 0x42027000, 0x00000032, 0x0201f000, - 0x000207a1, 0x592c0005, 0x82000580, 0x01000000, - 0x02020000, 0x001022c0, 0x4a034406, 0x00000004, - 0x0201f000, 0x0010230c, 0x497b4406, 0x497b4207, - 0x0201f800, 0x00103b25, 0x04000008, 0x59a80066, - 0x59a8086a, 0x80040480, 0x59a80867, 0x48074406, - 0x80041480, 0x480b4207, 0x49674407, 0x59a8000e, - 0x48034209, 0x495f4409, 0x59a80020, 0x4803420b, - 0x0201f000, 0x001022c0, 0x800409c0, 0x04000005, - 0x4a034406, 0x00000001, 0x0201f000, 0x0010230c, - 0x59a00406, 0x8c000500, 0x0402000f, 0x59a80069, - 0x81640480, 0x04001008, 0x59a8000b, 0x81500580, - 0x04000009, 0x59a8006a, 0x59a81066, 0x80080580, - 0x04000005, 0x4a034406, 0x00000018, 0x0201f000, - 0x0010230c, 0x82000540, 0x00000001, 0x0201f800, - 0x001015fe, 0x0201f800, 0x00103c80, 0x0201f000, - 0x001022c0, 0x4803c856, 0x800409c0, 0x02020000, - 0x00102314, 0x59a00406, 0x8c00051e, 0x04000008, - 0x4803c856, 0x59a0020b, 0x82000480, 0x00000800, - 0x04001015, 0x0201f000, 0x00102310, 0x4803c856, - 0x59a0020b, 0x599c0a01, 0x80040480, 0x04021003, - 0x0201f000, 0x00102310, 0x59a8000e, 0x81640580, - 0x04000009, 0x4a034406, 0x00000018, 0x0201f000, - 0x0010230c, 0x4a034406, 0x00000005, 0x0201f000, - 0x0010230c, 0x59a80026, 0x8c00050a, 0x040007fa, - 0x59a00406, 0x8c00051e, 0x04000036, 0x0201f800, - 0x0002075a, 0x040007f4, 0x0201f800, 0x00103a00, - 0x040007f1, 0x497a5a04, 0x59a00406, 0x4802620a, - 0x59a00209, 0x4802640a, 0x59a00409, 0x4802620b, - 0x59a0020d, 0x4802620c, 0x59a0040d, 0x4802640c, - 0x59a0020e, 0x4802620d, 0x59a0040e, 0x4802640d, - 0x59a00210, 0x4802620e, 0x59a00410, 0x4802640e, - 0x59a0020b, 0x82000500, 0x0000fffc, 0x80000104, - 0x4802640b, 0x0401f9d9, 0x040007d7, 0x48ee6021, - 0x58ee580d, 0x5930020e, 0x59301c0e, 0x900c19c0, - 0x800c1d40, 0x5930020c, 0x5930140c, 0x900811c0, - 0x80081540, 0x592c0a05, 0x832c0400, 0x00000006, - 0x0201f800, 0x00103a25, 0x4a01d809, 0x001029e5, - 0x4a034000, 0x00000001, 0x49334001, 0x1c01f000, - 0x0201f800, 0x00106c55, 0x0201f800, 0x00100ae0, - 0x0401f86d, 0x497b5057, 0x4201d000, 0x00002710, - 0x0201f800, 0x001060c6, 0x59c40880, 0x4c040000, - 0x59c408a3, 0x4c040000, 0x497b4002, 0x0401f876, - 0x0401f893, 0x4a03a005, 0x10000000, 0x0401f8b4, - 0x0401f901, 0x04000048, 0x59c80001, 0x800001c0, - 0x040007fc, 0x59c80018, 0x82000500, 0xf0000000, - 0x59c00808, 0x82040d00, 0x0fffffff, 0x80040540, - 0x48038008, 0x0201f800, 0x00100ec1, 0x59c00006, - 0x4a038006, 0x10000000, 0x59c00009, 0x82000d00, - 0x00e00000, 0x04020024, 0x4a03900d, 0x00000000, - 0x59c80020, 0x82000500, 0xff000000, 0x82000580, - 0x32000000, 0x0402001c, 0x4a03900d, 0x00000001, - 0x59c80020, 0x82000500, 0xff000000, 0x82000580, - 0xe1000000, 0x04020014, 0x4a03900d, 0x00000000, - 0x59c80020, 0x82000500, 0x00ffffff, 0x4a03900d, - 0x00000000, 0x59c80821, 0x82040d00, 0x00ffffff, - 0x80040580, 0x04020008, 0x59a80010, 0x80040580, - 0x04020005, 0x59c40005, 0x82000500, 0x000000f0, - 0x04000006, 0x4803c856, 0x0401f8d7, 0x4a035057, - 0x00000001, 0x0401f002, 0x0401f8e1, 0x42000000, - 0x00000064, 0x80000040, 0x02000800, 0x001005d8, - 0x59c00807, 0x82040d00, 0x0000000c, 0x040007fa, - 0x0401f003, 0x4a035057, 0x00000001, 0x0401f8da, - 0x0201f800, 0x00106f36, 0x0401f818, 0x4201d000, - 0x000186a0, 0x0201f800, 0x001060c6, 0x5c000800, - 0x480788a3, 0x5c000800, 0x48078880, 0x59a80057, - 0x800001c0, 0x02000000, 0x001022c0, 0x0201f000, - 0x00102318, 0x599c0201, 0x48035059, 0x41780800, - 0x42001000, 0x00003b10, 0x0201f800, 0x001066a0, - 0x480b505a, 0x1c01f000, 0x0201f800, 0x00106c4b, - 0x59b800ea, 0x82000500, 0x00000007, 0x82000580, - 0x00000003, 0x04020003, 0x4a0370e8, 0x00000001, - 0x1c01f000, 0x42038000, 0x00007700, 0x4a038006, - 0x30000000, 0x59c00007, 0x8c00050a, 0x040207fe, - 0x59c00006, 0x59a00209, 0x59a00c09, 0x900409c0, - 0x80040d40, 0x48078001, 0x59a0020e, 0x59a00c0e, - 0x900409c0, 0x80040d40, 0x48078000, 0x59a0020b, - 0x82000500, 0x0000fffc, 0x48038002, 0x48038003, - 0x48038005, 0x497b9009, 0x59e00003, 0x82000540, - 0x00008060, 0x4803c003, 0x1c01f000, 0x41780800, - 0x8007a0ca, 0x83d3a400, 0x00007600, 0x42000800, - 0x00000040, 0x0201f800, 0x00101345, 0x4a03a00a, - 0x00000001, 0x4a03a005, 0x20000000, 0x59d00006, - 0x4a03a005, 0x30000000, 0x59d00006, 0x8c00050a, - 0x040207fe, 0x59d00005, 0x59a00210, 0x59a00c10, - 0x900409c0, 0x80040d40, 0x4807a001, 0x59a0020d, - 0x59a00c0d, 0x900409c0, 0x80040d40, 0x4807a000, - 0x59a0020b, 0x82000500, 0x0000fffc, 0x4803a003, - 0x4803a002, 0x4803a008, 0x1c01f000, 0x59a00002, - 0x4803c857, 0x800001c0, 0x0402004a, 0x59a8005a, - 0x48038880, 0x59c400a3, 0x82000540, 0x00002008, - 0x8400053a, 0x480388a3, 0x59c40008, 0x8400054e, - 0x82000500, 0xffffffe1, 0x48038808, 0x59c80040, - 0x84000534, 0x48039040, 0x0401f902, 0x04020013, - 0x59a80010, 0x800000d0, 0x82000540, 0x00000011, - 0x48039120, 0x59a80010, 0x82000500, 0x00ffffff, - 0x82000540, 0x32000000, 0x48039121, 0x4a039123, - 0xe1290008, 0x59a80010, 0x82000500, 0x00ffffff, - 0x48039122, 0x0401f016, 0x59a80010, 0x82000500, - 0x000000ff, 0x900009c0, 0x840001c0, 0x80040540, - 0x82000540, 0x00000000, 0x48039120, 0x59a80010, - 0x82000500, 0x000000ff, 0x82000540, 0x01000000, - 0x48039121, 0x4a039123, 0x08210008, 0x59a80010, - 0x82000500, 0x000000ff, 0x48039122, 0x497b9124, - 0x59a80c5b, 0x80040800, 0x4807545b, 0x900409c0, - 0x82040540, 0x0000aaaa, 0x48039125, 0x497b9126, - 0x497b9127, 0x0401f8cf, 0x04020004, 0x4a039100, - 0x0000e980, 0x0401f003, 0x4a039100, 0x0000e9a0, - 0x1c01f000, 0x82000540, 0x00000001, 0x0402500d, - 0x4203e000, 0x80000000, 0x40e81000, 0x41780800, - 0x42000000, 0x00000064, 0x0201f800, 0x001066a0, - 0x59940024, 0x80080400, 0x48032824, 0x80000580, - 0x1c01f000, 0x4d900000, 0x4dd00000, 0x4da40000, - 0x4d140000, 0x417a3000, 0x0201f800, 0x001070d8, - 0x0201f800, 0x00106dc3, 0x5c022800, 0x5c034800, - 0x5c03a000, 0x5c032000, 0x1c01f000, 0x59c80007, - 0x8c000500, 0x04000003, 0x4a03900d, 0x00000030, - 0x1c01f000, 0x4a038805, 0x00020000, 0x42000800, - 0x0000003c, 0x0201f800, 0x00101345, 0x4a038891, - 0x0000ffff, 0x59c80035, 0x48039035, 0x4a03900d, - 0x00000040, 0x42038000, 0x00007700, 0x0201f800, - 0x00100ec1, 0x42038000, 0x00007720, 0x0201f800, - 0x00100ec1, 0x4a03a005, 0x20000000, 0x4a03a005, - 0x30000000, 0x59d00806, 0x8c040d0a, 0x040207fe, - 0x1c01f000, 0x4d300000, 0x4031d800, 0x58ef400b, - 0x58ee580d, 0x58ec0002, 0x82000580, 0x00000200, - 0x5c026000, 0x02000000, 0x00102304, 0x4d300000, - 0x59a26001, 0x59a00000, 0x4000b000, 0x80000000, - 0x48034000, 0x592c0001, 0x80000540, 0x0400001e, - 0x40025800, 0x8058b040, 0x040207fb, 0x58ec1007, - 0x58ec1808, 0x592c0a05, 0x4d2c0000, 0x58ec000d, - 0x40025800, 0x592c0204, 0x5c025800, 0x82000580, - 0x00000103, 0x04000008, 0x832c0400, 0x00000006, - 0x0201f800, 0x00103a25, 0x4a01d809, 0x001029e5, - 0x0401f007, 0x832c0400, 0x00000006, 0x0201f800, - 0x00103a28, 0x4a01d809, 0x001029e5, 0x5c026000, - 0x1c01f000, 0x58ec000d, 0x40025800, 0x592c0204, - 0x82000580, 0x00000103, 0x04020006, 0x0201f800, - 0x0002077d, 0x5c026000, 0x0201f000, 0x001022c0, - 0x58ec000d, 0x40025800, 0x592c0404, 0x8400055e, - 0x48025c04, 0x42028800, 0x000007fd, 0x42003000, - 0x00fffffd, 0x0201f800, 0x001045a6, 0x04000003, - 0x80000580, 0x0401f004, 0x59a26001, 0x0201f800, - 0x0010937d, 0x5c026000, 0x02000000, 0x0010230c, - 0x4d300000, 0x4a01d809, 0x00102a38, 0x0401f7dc, - 0x592c0005, 0x82000580, 0x01000000, 0x02000000, - 0x00102318, 0x4d300000, 0x59a26001, 0x5930020b, - 0x59301c0a, 0x900001c0, 0x800c1d40, 0x5930040d, - 0x5930120d, 0x900001c0, 0x80081540, 0x592c0a05, - 0x832c0400, 0x00000006, 0x0201f800, 0x00103a28, - 0x4a01d809, 0x001029e5, 0x4a034000, 0x00000001, - 0x5c026000, 0x1c01f000, 0x4933c857, 0x4c300000, - 0x5930040b, 0x82000c80, 0x0000000e, 0x04001004, - 0x4a025a05, 0x0000000e, 0x0401f003, 0x48025a05, - 0x0401f00c, 0x800409c0, 0x0400000a, 0x4c040000, - 0x0201f800, 0x00103a00, 0x5c000800, 0x04000003, - 0x40040000, 0x0401f7f0, 0x80000580, 0x0401f003, - 0x82000540, 0x00000001, 0x5c006000, 0x1c01f000, - 0x59a00206, 0x82000580, 0x00000044, 0x1c01f000, - 0x4807c857, 0x800409c0, 0x0400000c, 0x0201f800, - 0x00101650, 0x04020009, 0x42000000, 0x00000002, - 0x0201f800, 0x0010188c, 0x42000000, 0x00000002, - 0x0201f800, 0x00101821, 0x59a00406, 0x82000500, - 0x00000007, 0x0c01f001, 0x00102a8c, 0x00102aa1, - 0x00102ab7, 0x00102a8a, 0x00102a8a, 0x00102a8a, - 0x00102a8a, 0x00102a8a, 0x0201f000, 0x00102310, - 0x42000800, 0x000000c0, 0x0201f800, 0x0010193f, - 0x82040540, 0x00000002, 0x42000800, 0x000000c0, - 0x0201f800, 0x00101944, 0x42000800, 0x00000000, - 0x0201f800, 0x0010193f, 0x82040540, 0x00000008, - 0x42000800, 0x00000000, 0x0201f800, 0x00101944, - 0x0401f00b, 0x42000800, 0x000000c0, 0x0201f800, - 0x0010193f, 0x82040540, 0x00000001, 0x42000800, - 0x000000c0, 0x0201f800, 0x00101944, 0x59c80040, - 0x4c000000, 0x59a80010, 0x4c000000, 0x59c400a3, - 0x4c000000, 0x59c40008, 0x4c000000, 0x0401f911, - 0x04000021, 0x0201f800, 0x001005d8, 0x59a80821, - 0x800409c0, 0x02020000, 0x00102314, 0x0201f800, - 0x0010513b, 0x04020005, 0x4a034406, 0x00000016, - 0x0201f000, 0x0010230c, 0x836c0580, 0x00000003, - 0x02020000, 0x00102314, 0x59c408a4, 0x82040d00, - 0x0000000f, 0x82040580, 0x00000000, 0x02020000, - 0x00102314, 0x59c80040, 0x4c000000, 0x59a80010, - 0x4c000000, 0x59c400a3, 0x4c000000, 0x59c40008, - 0x4c000000, 0x59c40080, 0x4c000000, 0x59a0020f, - 0x59a0bc0f, 0x905cb9c0, 0x805cbd40, 0x41784800, - 0x41785000, 0x41785800, 0x41789000, 0x41789800, - 0x0401fe21, 0x0201f800, 0x00106c55, 0x0201f800, - 0x00100ae0, 0x4178c000, 0x497b4002, 0x0401f95c, - 0x0401f9aa, 0x59a0020c, 0x59a00c0c, 0x80040d40, - 0x04000002, 0x0401f9fb, 0x0401f9fa, 0x0401fe68, - 0x8060c1c0, 0x04020014, 0x0401fa98, 0x0401feb2, - 0x0402000e, 0x0201f800, 0x001018d3, 0x04020008, - 0x4a034406, 0x00000017, 0x0201f800, 0x0010230c, - 0x4203e000, 0x50000000, 0x0401f000, 0x42005800, - 0x0000aaaa, 0x0401f058, 0x59c80001, 0x800001c0, - 0x040007ee, 0x59c80801, 0x800409c0, 0x04000006, - 0x0401fa70, 0x40240000, 0x80280540, 0x802c0540, - 0x0402004d, 0x59a00002, 0x82000580, 0xfeedbeef, - 0x04000004, 0x42008800, 0x10000000, 0x0401f003, - 0x42008800, 0x10000004, 0x0401fa19, 0x4a034002, - 0xfeedbeef, 0x0401fa71, 0x0401fa97, 0x0401fea8, - 0x59c40005, 0x8c000534, 0x04000004, 0x42005800, - 0x0000bbbb, 0x0401f038, 0x0401fe83, 0x04020007, - 0x42005800, 0x0000cccc, 0x485f420f, 0x905cb9c0, - 0x485f440f, 0x0401f030, 0x59a0040c, 0x800001c0, - 0x0400000e, 0x59a26000, 0x5930000d, 0x800001c0, - 0x040207be, 0x59a26001, 0x5930080d, 0x800409c0, - 0x040207ba, 0x804891c0, 0x040207b8, 0x804c99c0, - 0x040207b6, 0x0401f87a, 0x805cb840, 0x04000005, - 0x40240000, 0x80280540, 0x802c0540, 0x0402001a, - 0x42000000, 0x00030d40, 0x80000040, 0x04020012, - 0x59c00007, 0x82000500, 0x000501c0, 0x0402000b, - 0x0201f800, 0x001018d3, 0x04020008, 0x4a034406, - 0x00000017, 0x0201f800, 0x0010230c, 0x4203e000, - 0x50000000, 0x0401f000, 0x42005800, 0x0000dddd, - 0x0401f005, 0x59c00807, 0x82040d00, 0x0000000c, - 0x040007ea, 0x0401fe5c, 0x59a0040c, 0x800001c0, - 0x04000002, 0x0401f856, 0x0401fe6b, 0x40240000, - 0x80280540, 0x802c0540, 0x04020003, 0x805cb9c0, - 0x04020781, 0x0201f800, 0x00106f36, 0x0401fda3, - 0x4201d000, 0x000186a0, 0x0201f800, 0x001060c6, - 0x5c000800, 0x48078880, 0x5c000800, 0x48078808, - 0x5c000800, 0x480788a3, 0x5c000800, 0x48075010, - 0x5c000800, 0x48079040, 0x0201f800, 0x00100969, - 0x59a00406, 0x82000500, 0x00000003, 0x82000580, - 0x00000002, 0x0400002c, 0x42000800, 0x000000c0, - 0x0201f800, 0x0010193f, 0x82040500, 0xfffffffc, - 0x42000800, 0x000000c0, 0x0201f800, 0x00101944, - 0x42000800, 0x00000000, 0x0201f800, 0x0010193f, - 0x82040500, 0xfffffff7, 0x42000800, 0x00000000, - 0x0201f800, 0x00101944, 0x42000800, 0x00000000, - 0x0201f800, 0x0010193f, 0x82040500, 0xfffffffb, - 0x42000800, 0x00000000, 0x0201f800, 0x00101944, - 0x4a0388a7, 0x0000f7f7, 0x42006000, 0xbeffffff, - 0x42006800, 0x80018000, 0x0201f800, 0x0010427d, - 0x42006000, 0xfffeffff, 0x41786800, 0x0201f800, - 0x0010427d, 0x402c0000, 0x80280540, 0x80240540, - 0x02000000, 0x001022c0, 0x48274406, 0x482b4207, - 0x482f4407, 0x0201f000, 0x0010231c, 0x59a26000, - 0x813261c0, 0x0400000e, 0x59325808, 0x812e59c0, - 0x0400000b, 0x0201f800, 0x0002077d, 0x0201f800, - 0x001007fd, 0x59a26001, 0x59325808, 0x0201f800, - 0x0002077d, 0x0201f800, 0x001007fd, 0x1c01f000, - 0x42000800, 0x000000ef, 0x0201f800, 0x001015eb, - 0x59c400a3, 0x8400055a, 0x8400053a, 0x480388a3, - 0x0201f800, 0x0010163b, 0x0402000a, 0x42000000, - 0x00000001, 0x0201f800, 0x0010188c, 0x42000000, - 0x00000001, 0x0201f800, 0x00101821, 0x0401f013, - 0x0201f800, 0x00101642, 0x04020008, 0x41780000, - 0x0201f800, 0x0010188c, 0x41780000, 0x0201f800, - 0x00101821, 0x0401f009, 0x42000000, 0x00000002, - 0x0201f800, 0x0010188c, 0x42000000, 0x00000002, - 0x0201f800, 0x00101821, 0x42000800, 0x00000000, - 0x0201f800, 0x0010193f, 0x82040540, 0x00000004, - 0x42000800, 0x00000000, 0x0201f800, 0x00101944, - 0x4201d000, 0x00000014, 0x0201f800, 0x0010608e, - 0x59c40008, 0x8400054e, 0x82000500, 0xffffffe1, - 0x48038808, 0x4a0388a7, 0x0000f7f7, 0x42001000, - 0x04000001, 0x0201f800, 0x0010193d, 0x42006000, - 0xbe20bfff, 0x42006800, 0x80018000, 0x0201f800, - 0x0010427d, 0x42006000, 0xfffeffff, 0x41786800, - 0x0201f800, 0x0010427d, 0x4200b000, 0x00001388, - 0x4201d000, 0x00000014, 0x4c580000, 0x0201f800, - 0x0010608e, 0x0201f800, 0x001018d3, 0x5c00b000, - 0x04000004, 0x8058b040, 0x040207f6, 0x0401f025, - 0x59c40005, 0x8c000534, 0x04020007, 0x59c400a4, - 0x82000500, 0x0000000f, 0x82000580, 0x00000008, - 0x0402001c, 0x42006000, 0x00020000, 0x0201f800, - 0x00104282, 0x4201d000, 0x00000064, 0x0201f800, - 0x0010608e, 0x42006000, 0xfeffffff, 0x42006800, - 0x02000000, 0x0201f800, 0x0010427d, 0x42006000, - 0xfdffffff, 0x41786800, 0x0201f800, 0x0010427d, - 0x4a038805, 0x04000001, 0x59c400a4, 0x82000500, - 0x0000000f, 0x82000580, 0x00000000, 0x04000003, - 0x82000540, 0x00000001, 0x1c01f000, 0x4803c856, - 0x42038000, 0x00007700, 0x0201f800, 0x00100ec1, - 0x59c00006, 0x59a0040c, 0x800001c0, 0x0400003f, - 0x59a03c0c, 0x59a00209, 0x59a01c09, 0x900c19c0, - 0x800c1d40, 0x59a0020e, 0x59a0240e, 0x901021c0, - 0x80102540, 0x59a0020b, 0x82000500, 0x0000fffc, - 0x59a0140b, 0x900811c0, 0x80081540, 0x480b8003, - 0x0201f800, 0x0002075a, 0x02000800, 0x001005d8, - 0x49334000, 0x0201f800, 0x001007e4, 0x4a025a04, - 0x00000018, 0x4a025805, 0x00abcdef, 0x492e6008, - 0x492e600b, 0x481e600d, 0x4a02600c, 0x00000004, - 0x832c0400, 0x00000011, 0x4802600a, 0x42001000, - 0x0000000c, 0x821c0d80, 0x00000001, 0x04000004, - 0x801c3840, 0x0401f963, 0x0401f004, 0x41783800, - 0x0401f960, 0x0401f011, 0x821c0c80, 0x00000005, - 0x04001005, 0x40043800, 0x42001000, 0x0000003c, - 0x0401f006, 0x80001580, 0x82081400, 0x0000000c, - 0x801c3840, 0x040207fd, 0x832c0400, 0x00000005, - 0x0401f950, 0x040207f1, 0x497b9009, 0x59e00003, - 0x82000540, 0x00008060, 0x4803c003, 0x4a038009, - 0x00e00000, 0x1c01f000, 0x4803c856, 0x41780800, - 0x8007a0ca, 0x83d3a400, 0x00007600, 0x42000800, - 0x00000040, 0x0201f800, 0x00101345, 0x4a03a00a, - 0x00000001, 0x4a03a005, 0x20000000, 0x59d00006, - 0x4a03a005, 0x30000000, 0x59d00006, 0x8c00050a, - 0x040207fe, 0x59d00005, 0x59a0020c, 0x800001c0, - 0x0400003f, 0x59a03a0c, 0x59a00210, 0x59a01c10, - 0x900c19c0, 0x800c1d40, 0x59a0020d, 0x59a0240d, - 0x901021c0, 0x80102540, 0x59a0120b, 0x82081500, - 0x0000fffc, 0x59a0040b, 0x900001c0, 0x80081540, - 0x480ba003, 0x0201f800, 0x0002075a, 0x02000800, - 0x001005d8, 0x49334001, 0x0201f800, 0x001007e4, - 0x4a025a04, 0x00000018, 0x4a025805, 0x00abcdef, - 0x492e6008, 0x492e600b, 0x481e600d, 0x4a02600c, - 0x00000004, 0x832c0400, 0x00000011, 0x4802600a, - 0x42001000, 0x0000000c, 0x821c0d80, 0x00000001, - 0x04000004, 0x801c3840, 0x0401f906, 0x0401f004, - 0x41783800, 0x0401f903, 0x0401f011, 0x821c0c80, - 0x00000005, 0x04001005, 0x40043800, 0x42001000, - 0x0000003c, 0x0401f006, 0x80001580, 0x82081400, - 0x0000000c, 0x801c3840, 0x040207fd, 0x832c0400, - 0x00000005, 0x0401f8f3, 0x040207f1, 0x1c01f000, - 0x4803c856, 0x59a0020c, 0x800001c0, 0x04000024, - 0x824c0580, 0x00000002, 0x04000040, 0x59a26001, - 0x5930380d, 0x801c39c0, 0x0400003c, 0x801c3840, - 0x481e600d, 0x5932580b, 0x5930080a, 0x50042000, - 0x58041801, 0x58041002, 0x82081500, 0xfffffffc, - 0x5930000c, 0x80000000, 0x82000d80, 0x00000005, - 0x04020009, 0x497a600c, 0x592e5801, 0x812e59c0, - 0x0400001a, 0x492e600b, 0x832c0c00, 0x00000005, - 0x0401f005, 0x4802600c, 0x5930080a, 0x82040c00, - 0x00000003, 0x4806600a, 0x0401f010, 0x59a0120b, - 0x82081500, 0x0000fffc, 0x59a0040b, 0x900001c0, - 0x80081540, 0x480ba003, 0x59a0020d, 0x59a0240d, - 0x901021c0, 0x80102540, 0x59a00210, 0x59a01c10, - 0x900c19c0, 0x800c1d40, 0x4201d000, 0x00003a98, - 0x0201f800, 0x001060c6, 0x480ba002, 0x59a80059, - 0x4803a008, 0x4813a000, 0x480fa001, 0x4a03a005, - 0x10000000, 0x02005800, 0x001005d8, 0x804c9800, - 0x82000540, 0x00000001, 0x1c01f000, 0x4847c857, - 0x59a0040c, 0x800001c0, 0x04000024, 0x82480580, - 0x00000002, 0x04000042, 0x59a26000, 0x5930380d, - 0x801c39c0, 0x0400003e, 0x801c3840, 0x481e600d, - 0x5932580b, 0x5930080a, 0x50042000, 0x58041801, - 0x58041002, 0x82081500, 0xfffffffc, 0x5930000c, - 0x80000000, 0x82000d80, 0x00000005, 0x04020009, - 0x497a600c, 0x592e5801, 0x812e59c0, 0x0400001d, - 0x492e600b, 0x832c0c00, 0x00000005, 0x0401f005, - 0x4802600c, 0x5930080a, 0x82040c00, 0x00000003, - 0x4806600a, 0x0401f013, 0x82440580, 0x10000000, - 0x0402001f, 0x59a0020e, 0x59a0240e, 0x901021c0, - 0x80102540, 0x59a00209, 0x59a01c09, 0x900c19c0, - 0x800c1d40, 0x59a0020b, 0x82000500, 0x0000fffc, - 0x59a0140b, 0x900811c0, 0x80081540, 0x480b8003, - 0x48138000, 0x480f8001, 0x480b8002, 0x59c80018, - 0x82000500, 0xf0000000, 0x59c02008, 0x82102500, - 0x0fffffff, 0x80100540, 0x48038008, 0x48478006, - 0x80489000, 0x8260c540, 0x00000001, 0x1c01f000, - 0x59c00009, 0x4803c857, 0x82000d00, 0x00e00000, - 0x0400000d, 0x485f420f, 0x905cb9c0, 0x485f440f, - 0x8c00052e, 0x04000002, 0x80285000, 0x8c00052c, - 0x04000002, 0x80244800, 0x8c00052a, 0x04000002, - 0x802c5800, 0x1c01f000, 0x59a0020c, 0x800001c0, - 0x04000024, 0x59d00806, 0x4807c857, 0x8c040d3e, - 0x04000020, 0x4a03a005, 0x20000000, 0x4a03a005, - 0x30000000, 0x59d00806, 0x8c040d0a, 0x040207fe, - 0x824c0480, 0x00000003, 0x02021800, 0x001005d8, - 0x404c0000, 0x0c01f001, 0x00102da1, 0x00102da3, - 0x00102da9, 0x0201f800, 0x001005d8, 0x80000040, - 0x40009800, 0x0401ff43, 0x0400000a, 0x0401ff41, - 0x0401f008, 0x80000040, 0x40009800, 0x59d00806, - 0x4807c857, 0x8c040d3e, 0x040207e3, 0x0401ff39, - 0x1c01f000, 0x59a0040c, 0x800001c0, 0x04000024, - 0x59c00807, 0x4807c857, 0x8c040d3e, 0x04000020, - 0x59c00807, 0x4a038006, 0x20000000, 0x82480480, - 0x00000003, 0x02021800, 0x001005d8, 0x40480000, - 0x0c01f001, 0x00102dc4, 0x00102dc6, 0x00102dce, - 0x0201f800, 0x001005d8, 0x80000040, 0x40009000, - 0x42008800, 0x10000004, 0x0401ff65, 0x0400000c, - 0x0401ff63, 0x0401f00a, 0x80000040, 0x40009000, - 0x59c00807, 0x4807c857, 0x8c040d3e, 0x040207e5, - 0x42008800, 0x10000004, 0x0401ff59, 0x1c01f000, - 0x492fc857, 0x4000a800, 0x4a03b805, 0x20000000, - 0x59dc0006, 0x4a03b805, 0x30000000, 0x4813b800, - 0x480fb801, 0x480bb802, 0x4857b803, 0x4a03b805, - 0x30000002, 0x59dc0006, 0x4a03b805, 0x70000001, - 0x59dc0006, 0x4a03b805, 0x10000000, 0x59dc0006, - 0x8c00053e, 0x040007fe, 0x4a03b805, 0x20000000, - 0x59dc0006, 0x59dc2000, 0x59dc1801, 0x801c39c0, - 0x0400000a, 0x4d2c0000, 0x0201f800, 0x001007e4, - 0x5c000800, 0x02000800, 0x001005d8, 0x4a025a04, - 0x0000000a, 0x492c0801, 0x1c01f000, 0x42006000, - 0x00102fb2, 0x0201f800, 0x00101345, 0x4a03902c, - 0x00200000, 0x4200b000, 0x000001f4, 0x59c8002c, - 0x8c00052c, 0x04000007, 0x8058b040, 0x040207fc, - 0x42000000, 0x00004003, 0x41781000, 0x0401f196, - 0x50301000, 0x41784800, 0x4a03902d, 0x00008000, - 0x4200b000, 0x000001f4, 0x59c8002c, 0x8c000534, - 0x04000007, 0x8058b040, 0x040207fc, 0x42000000, - 0x00004003, 0x41781000, 0x0401f187, 0x0401f8f8, - 0x80244800, 0x40240000, 0x82000580, 0x000003b1, - 0x040207fb, 0x0401f988, 0x41784800, 0x0401f920, - 0x80244800, 0x40240000, 0x82000580, 0x000003b1, - 0x040207fb, 0x80306000, 0x82300580, 0x00102fb4, - 0x040207e0, 0x59a80863, 0x800409c0, 0x04000007, - 0x42000000, 0x00004004, 0x42001000, 0x00000002, - 0x59a81862, 0x0401f16c, 0x42006000, 0x00102fb2, - 0x4a035064, 0x00000004, 0x50301000, 0x41784800, - 0x4a03902d, 0x00004000, 0x4200b000, 0x000001f4, - 0x59c8002c, 0x8c000532, 0x04000007, 0x8058b040, - 0x040207fc, 0x42000000, 0x00004003, 0x41781000, - 0x0401f159, 0x0401f8ca, 0x80244800, 0x40240000, - 0x82000580, 0x00000154, 0x040207fb, 0x0401f95a, - 0x41784800, 0x0401f8f2, 0x80244800, 0x40240000, - 0x82000580, 0x00000154, 0x040207fb, 0x80306000, - 0x82300580, 0x00102fb4, 0x040207e0, 0x59a80863, - 0x800409c0, 0x04000007, 0x42000000, 0x00004004, - 0x42001000, 0x00000004, 0x59a81862, 0x0401f13e, - 0x42006000, 0x00102fb2, 0x497b5064, 0x50301000, - 0x41784800, 0x4a03902d, 0x00001000, 0x4200b000, - 0x000001f4, 0x59c8002c, 0x8c00052e, 0x04000007, - 0x8058b040, 0x040207fc, 0x42000000, 0x00004003, - 0x41781000, 0x0401f12c, 0x0401f89d, 0x80244800, - 0x40240000, 0x82000580, 0x00000088, 0x040207fb, - 0x0401f92d, 0x41784800, 0x0401f8c5, 0x80244800, - 0x40240000, 0x82000580, 0x00000088, 0x040207fb, - 0x80306000, 0x82300580, 0x00102fb4, 0x040207e0, - 0x59a80863, 0x800409c0, 0x04000007, 0x42000000, - 0x00004004, 0x42001000, 0x00000001, 0x59a81862, - 0x0401f111, 0x42006000, 0x00102fb2, 0x50301000, - 0x41784800, 0x4a03902d, 0x00000800, 0x0401f87c, - 0x80244800, 0x40240000, 0x82000580, 0x00000018, - 0x040207fb, 0x0401f90c, 0x41784800, 0x0401f8a4, - 0x80244800, 0x40240000, 0x82000580, 0x00000018, - 0x040207fb, 0x80306000, 0x82300580, 0x00102fb4, - 0x040207eb, 0x59a80863, 0x800409c0, 0x04000007, - 0x42000000, 0x00004004, 0x42001000, 0x00000010, - 0x59a81862, 0x0401f0f0, 0x42006000, 0x00102fb2, - 0x50301000, 0x41784800, 0x4a03902d, 0x00000400, - 0x0401f85b, 0x80244800, 0x40240000, 0x82000580, - 0x00000088, 0x040207fb, 0x0401f8eb, 0x41784800, - 0x0401f883, 0x80244800, 0x40240000, 0x82000580, - 0x00000088, 0x040207fb, 0x80306000, 0x82300580, - 0x00102fb4, 0x040207eb, 0x59a80863, 0x800409c0, - 0x04000007, 0x42000000, 0x00004004, 0x42001000, - 0x00000008, 0x59a81862, 0x0401f0cf, 0x42006000, - 0x00102fb2, 0x50301000, 0x41784800, 0x4a03902d, - 0x00002000, 0x4200b000, 0x000001f4, 0x59c8002c, - 0x8c000530, 0x04000007, 0x8058b040, 0x040207fc, - 0x42000000, 0x00004003, 0x41781000, 0x0401f0be, - 0x59c8002c, 0x82000500, 0xffe0ffff, 0x82080d00, - 0x001f0000, 0x80040540, 0x4803902c, 0x0401f828, - 0x80244800, 0x40240000, 0x82000580, 0x00000110, - 0x040207fb, 0x0401f8b8, 0x41784800, 0x0401f850, - 0x59c80034, 0x82080d00, 0x001f0000, 0x82000500, - 0x001f0000, 0x80040580, 0x04000006, 0x59a80063, - 0x80000000, 0x48035063, 0x40240000, 0x48035062, - 0x80244800, 0x40240000, 0x82000580, 0x00000110, - 0x040207ef, 0x80306000, 0x82300580, 0x00102fb4, - 0x040207cd, 0x59a80863, 0x800409c0, 0x04000006, - 0x42000000, 0x00004004, 0x42001000, 0x00000020, - 0x59a81862, 0x0201f000, 0x001022c0, 0x59c8002c, - 0x82000500, 0xffff0000, 0x82080d00, 0x0000ffff, - 0x80040540, 0x4803902c, 0x40080000, 0x48039028, - 0x48039029, 0x59a80064, 0x82000580, 0x00000004, - 0x04000004, 0x40080000, 0x4803902a, 0x4803902b, - 0x59c8082d, 0x82040d00, 0xfffffc00, 0x40240000, - 0x80040d40, 0x4807902d, 0x4200b000, 0x000001f4, - 0x59c8002c, 0x82000500, 0x18000000, 0x04000007, - 0x8058b040, 0x040207fb, 0x42000000, 0x00004003, - 0x41781000, 0x0401f06c, 0x4a03902e, 0x00000001, - 0x4200b000, 0x000001f4, 0x59c8002e, 0x8c000500, - 0x04000006, 0x8058b040, 0x040207fc, 0x42000000, - 0x00004003, 0x0401f060, 0x1c01f000, 0x41783800, - 0x59c8082d, 0x82040d00, 0xfffffc00, 0x40240000, - 0x80040d40, 0x4807902d, 0x4200b000, 0x000001f4, - 0x59c8002c, 0x82000500, 0x18000000, 0x04000007, - 0x8058b040, 0x040207fb, 0x42000000, 0x00004003, - 0x41781000, 0x0401f04c, 0x59c80030, 0x59c80830, - 0x80040580, 0x040207fd, 0x40041800, 0x59c80031, - 0x59c80831, 0x80040580, 0x040207fd, 0x40042000, - 0x59c80032, 0x59c80832, 0x80040580, 0x040207fd, - 0x40042800, 0x59c80033, 0x59c80833, 0x80040580, - 0x040207fd, 0x40043000, 0x400c0000, 0x80080580, - 0x04000002, 0x801c3800, 0x40100000, 0x80080580, - 0x04000002, 0x801c3800, 0x59a80064, 0x82000580, - 0x00000004, 0x04000009, 0x40140000, 0x80080580, - 0x04000002, 0x801c3800, 0x40180000, 0x80080580, - 0x04000002, 0x801c3800, 0x59a80064, 0x82000580, - 0x00000004, 0x0400000d, 0x59c80034, 0x59c80834, - 0x80040580, 0x040207fd, 0x82040500, 0x0000ffff, - 0x82080d00, 0x0000ffff, 0x80040580, 0x0400000e, - 0x801c3800, 0x0401f00c, 0x59c80034, 0x59c80834, - 0x80040580, 0x040207fd, 0x82040500, 0x000000ff, - 0x82080d00, 0x000000ff, 0x80040580, 0x04000002, - 0x801c3800, 0x801c39c0, 0x04000006, 0x59a80063, - 0x801c0400, 0x48035063, 0x40240000, 0x48035062, - 0x1c01f000, 0x48034206, 0x48074406, 0x480b4207, - 0x480f4407, 0x48134208, 0x48174408, 0x0201f000, - 0x001022c3, 0x42000000, 0x00600000, 0x80000040, - 0x040207ff, 0x1c01f000, 0x5a5a5a5a, 0xa5a5a5a5, - 0x59a00c0a, 0x800409c0, 0x02000000, 0x00102310, - 0x82040480, 0x00000021, 0x02021000, 0x00102310, - 0x82040480, 0x00000011, 0x04001003, 0x42000800, - 0x00000010, 0x59a00208, 0x59a01407, 0x900811c0, - 0x80081540, 0x59a00207, 0x59a01c06, 0x900c19c0, - 0x800c1d40, 0x0201f800, 0x00103a00, 0x04000006, - 0x0201f800, 0x00103a25, 0x4a01d809, 0x00102fd5, - 0x1c01f000, 0x4a034406, 0x00000002, 0x0201f000, - 0x0010230c, 0x4031d800, 0x58ef400b, 0x58ec0002, - 0x82000580, 0x00000200, 0x02000000, 0x00102304, - 0x59a00c0a, 0x82040480, 0x00000011, 0x04001003, - 0x42000800, 0x00000010, 0x59a0040b, 0x59a0120b, - 0x900811c0, 0x80081540, 0x59a00209, 0x59a01c08, - 0x900c19c0, 0x800c1d40, 0x58ec0003, 0x0201f800, - 0x00103a28, 0x4a01d809, 0x00102ff0, 0x1c01f000, - 0x4031d800, 0x58ef400b, 0x58ec0002, 0x82000580, - 0x00000200, 0x02000000, 0x00102304, 0x59a00c0a, - 0x82040480, 0x00000011, 0x02001000, 0x001022c0, - 0x82040c80, 0x00000010, 0x59a00208, 0x59a01407, - 0x900811c0, 0x80081540, 0x59a00207, 0x59a01c06, - 0x900c19c0, 0x800c1d40, 0x82081400, 0x00000040, - 0x58ec0003, 0x0201f800, 0x00103a25, 0x4a01d809, - 0x0010300e, 0x1c01f000, 0x4031d800, 0x58ef400b, - 0x58ec0002, 0x82000580, 0x00000200, 0x02000000, - 0x00102304, 0x59a0040a, 0x82000c80, 0x00000010, - 0x59a0040b, 0x59a0120b, 0x900811c0, 0x80081540, - 0x59a00209, 0x59a01c08, 0x900c19c0, 0x800c1d40, - 0x82081400, 0x00000040, 0x58ec0003, 0x0201f800, - 0x00103a28, 0x4a01d809, 0x001022b9, 0x1c01f000, - 0x48efc857, 0x59a00207, 0x59a01407, 0x900001c0, - 0x80081540, 0x59a00209, 0x59a01c09, 0x900001c0, - 0x800c1d40, 0x59a00406, 0x48034000, 0x480b4001, - 0x480f4002, 0x0201f800, 0x00103a00, 0x04020005, - 0x4a034406, 0x00000002, 0x0201f000, 0x0010230c, - 0x42000800, 0x00000010, 0x0201f800, 0x00103a25, - 0x4a01d809, 0x00103043, 0x1c01f000, 0x4031d800, - 0x58ef400b, 0x58ee580d, 0x58ec0002, 0x82000580, - 0x00000200, 0x02000000, 0x00102304, 0x48efc857, - 0x49a3c857, 0x492fc857, 0x592c0a04, 0x80040910, - 0x04020005, 0x4a034406, 0x00000019, 0x0201f000, - 0x0010230c, 0x4805d80c, 0x0401f00a, 0x4031d800, - 0x58ef400b, 0x58ec0002, 0x82000580, 0x00000200, - 0x02000000, 0x00102304, 0x48efc857, 0x49a3c857, - 0x48efc857, 0x49a3c857, 0x58ec000c, 0x80000040, - 0x04000012, 0x4801d80c, 0x0201f800, 0x00103a00, - 0x04020005, 0x4a034406, 0x00000002, 0x0201f000, - 0x0010230c, 0x42000800, 0x00000010, 0x58ec1007, - 0x58ec1808, 0x0201f800, 0x00103a25, 0x4a01d809, - 0x00103057, 0x1c01f000, 0x58ee580d, 0x48efc857, - 0x49a3c857, 0x492fc857, 0x492f3006, 0x592c0404, - 0x8400055e, 0x48025c04, 0x4a01d809, 0x00103081, - 0x1c01f000, 0x58ee580d, 0x48efc857, 0x49a3c857, - 0x492fc857, 0x592c0404, 0x8400051e, 0x48025c04, - 0x59a00000, 0x59a01001, 0x59a01802, 0x80081400, - 0x820c1c40, 0x00000000, 0x832c0400, 0x00000004, - 0x42000800, 0x00000010, 0x0201f000, 0x00103a28, - 0x800409c0, 0x04000005, 0x4a034406, 0x00000001, - 0x0201f000, 0x0010230c, 0x836c0580, 0x00000003, - 0x04000005, 0x4a034406, 0x00000007, 0x0201f000, - 0x0010230c, 0x59a0320b, 0x82183500, 0x000000ff, - 0x59a28c06, 0x0201f800, 0x00020245, 0x02020000, - 0x00102310, 0x83440580, 0x000007fd, 0x04000008, - 0x0201f800, 0x001049e7, 0x04000005, 0x4a034406, - 0x00000009, 0x0201f000, 0x0010230c, 0x0201f800, - 0x00103a00, 0x04020005, 0x4a034406, 0x00000002, - 0x0201f000, 0x0010230c, 0x801831c0, 0x0400000a, - 0x412c0800, 0x0201f800, 0x00103a00, 0x04020005, - 0x4a034406, 0x00000002, 0x0201f000, 0x0010230c, - 0x40065800, 0x4a025c04, 0x00008000, 0x497a5a04, - 0x0201f800, 0x00109100, 0x04020005, 0x4a034406, - 0x00000003, 0x0201f000, 0x0010230c, 0x4a01d809, - 0x001030d2, 0x1c01f000, 0x592c0005, 0x82000580, - 0x01000000, 0x04020005, 0x4a034406, 0x00000004, - 0x0201f000, 0x0010230c, 0x592c0406, 0x82002d00, - 0x0000ff00, 0x82000500, 0x000000ff, 0x80000904, - 0x80040800, 0x82040480, 0x00000006, 0x04001003, - 0x42000800, 0x00000005, 0x832ca400, 0x00000006, - 0x4050a800, 0x4004b000, 0x0201f800, 0x0010ab28, - 0x59a00407, 0x59a01207, 0x900811c0, 0x80081540, - 0x59a00409, 0x59a01a09, 0x900c19c0, 0x800c1d40, - 0x832c0400, 0x00000006, 0x4c140000, 0x0201f800, - 0x00103a28, 0x5c002800, 0x801429c0, 0x04000003, - 0x4a01d809, 0x001030ff, 0x1c01f000, 0x4031d800, - 0x58ef400b, 0x58ee580d, 0x58ec0002, 0x82000580, - 0x00000200, 0x02000000, 0x00102304, 0x812e59c0, - 0x02000800, 0x001005d8, 0x592c0006, 0x82000500, - 0xff000000, 0x80000904, 0x800409c0, 0x02000000, - 0x00102304, 0x82040480, 0x0000000e, 0x04001003, - 0x42000800, 0x0000000d, 0x592e5801, 0x812e59c0, - 0x02000800, 0x001005d8, 0x832ca400, 0x00000005, - 0x4050a800, 0x4004b000, 0x0201f800, 0x0010ab28, - 0x58ec1007, 0x58ec1808, 0x832c0400, 0x00000005, - 0x0201f000, 0x00103a28, 0x0201f800, 0x00103a00, - 0x04020005, 0x4a034406, 0x00000002, 0x0201f000, - 0x0010230c, 0x59a00c06, 0x82040500, 0x0000ff00, - 0x840001c0, 0x82001480, 0x00000007, 0x02021000, - 0x00102310, 0x0c01f001, 0x0010313d, 0x00103144, - 0x0010314b, 0x0010314b, 0x0010314b, 0x0010314d, - 0x00103152, 0x42000800, 0x0000000d, 0x42003800, - 0x00103166, 0x4a034000, 0x0010b4eb, 0x0401f013, - 0x42000800, 0x0000000d, 0x42003800, 0x00103166, - 0x4a034000, 0x0010b4f8, 0x0401f00c, 0x0201f000, - 0x00102310, 0x42000800, 0x00000008, 0x42003800, - 0x00103179, 0x0401f005, 0x42000800, 0x00000004, - 0x42003800, 0x001031c3, 0x59a00207, 0x59a01407, - 0x900001c0, 0x80081540, 0x59a00209, 0x59a01c09, - 0x900001c0, 0x800c1d40, 0x832c0400, 0x00000005, - 0x4c1c0000, 0x0201f800, 0x00103a25, 0x5c003800, - 0x481dd809, 0x1c01f000, 0x4031d800, 0x58ef400b, - 0x58ee580d, 0x58ec0002, 0x82000580, 0x00000200, - 0x02000000, 0x00102304, 0x4a03501f, 0x00000001, - 0x4200b000, 0x0000000d, 0x59a0a800, 0x832ca400, - 0x00000005, 0x0201f800, 0x0010ab17, 0x0201f000, - 0x001022c0, 0x4031d800, 0x58ef400b, 0x58ee580d, - 0x58ec0002, 0x82000580, 0x00000200, 0x02000000, - 0x00102304, 0x832ca400, 0x00000005, 0x50500000, - 0x82001500, 0x000c0016, 0x02020000, 0x00102310, - 0x82500c00, 0x00000003, 0x50040000, 0x82001500, - 0x00000001, 0x02020000, 0x00102310, 0x50500000, - 0x82001500, 0x00000028, 0x0400001d, 0x82081580, - 0x00000028, 0x02020000, 0x00102310, 0x80500800, - 0x50040000, 0x82001500, 0x00000013, 0x82081580, - 0x00000013, 0x02020000, 0x00102310, 0x80040800, - 0x50040000, 0x82001500, 0x00010000, 0x82081580, - 0x00010000, 0x02020000, 0x00102310, 0x836c0580, - 0x00000000, 0x04000012, 0x599c0019, 0x8c00050e, - 0x0402000f, 0x0201f000, 0x00102310, 0x80500800, - 0x50040000, 0x82001500, 0x00000013, 0x02020000, - 0x00102310, 0x80040800, 0x50040000, 0x82001500, - 0x00010000, 0x02020000, 0x00102310, 0x4200b000, - 0x00000008, 0x4200a800, 0x0010b4e3, 0x0201f800, - 0x0010ab17, 0x0201f000, 0x001022c0, 0x4031d800, - 0x58ef400b, 0x58ee580d, 0x58ec0002, 0x82000580, - 0x00000200, 0x02000000, 0x00102304, 0x4200b000, - 0x00000004, 0x4200a800, 0x0010b8fa, 0x832ca400, - 0x00000005, 0x0201f800, 0x0010ab17, 0x59a80005, - 0x84000550, 0x48035005, 0x0201f000, 0x001022c0, - 0x0201f800, 0x00103a00, 0x04020005, 0x4a034406, - 0x00000002, 0x0201f000, 0x0010230c, 0x59a00c06, - 0x82040500, 0x0000ff00, 0x840001c0, 0x82001480, - 0x00000006, 0x02021000, 0x00102310, 0x0c01f001, - 0x001031ee, 0x001031f3, 0x001031f8, 0x001031f8, - 0x001031f8, 0x001031fa, 0x42000800, 0x0000000d, - 0x4200a000, 0x0010b4eb, 0x0401f00c, 0x42000800, - 0x0000000d, 0x4200a000, 0x0010b4f8, 0x0401f007, - 0x0201f000, 0x00102310, 0x42000800, 0x00000008, - 0x4200a000, 0x0010b4e3, 0x4004b000, 0x832cac00, - 0x00000005, 0x0201f800, 0x0010ab17, 0x59a00207, - 0x59a01407, 0x900001c0, 0x80081540, 0x59a00209, - 0x59a01c09, 0x900001c0, 0x800c1d40, 0x832c0400, - 0x00000005, 0x0201f000, 0x00103a28, 0x836c0580, - 0x00000000, 0x04020005, 0x4a034406, 0x00000007, - 0x0201f000, 0x0010230c, 0x59a00406, 0x800001c0, - 0x0400001a, 0x59a80005, 0x8c000514, 0x04000005, - 0x42000000, 0x00000001, 0x40000800, 0x0401f003, - 0x59a00207, 0x59a80853, 0x48035053, 0x0201f800, - 0x0010163b, 0x04000022, 0x0201f800, 0x00101642, - 0x0400001f, 0x0201f800, 0x00101649, 0x0400001c, - 0x0201f800, 0x00101650, 0x04000019, 0x48075053, - 0x0201f000, 0x00102310, 0x59c40801, 0x82040d00, - 0x00018000, 0x82040580, 0x00000000, 0x04020004, - 0x4a034406, 0x00000000, 0x0401f00d, 0x82040580, - 0x00008000, 0x04020004, 0x4a034406, 0x00000001, - 0x0401f007, 0x82040580, 0x00010000, 0x02020800, - 0x001005d8, 0x4a034406, 0x00000003, 0x59a00406, - 0x82000580, 0x00000002, 0x0402001f, 0x59c40006, - 0x84000500, 0x48038806, 0x0201f800, 0x00106ede, - 0x497b8880, 0x0201f800, 0x0010a9c0, 0x0201f800, - 0x0010a9ce, 0x42000000, 0x0010b8ca, 0x0201f800, - 0x0010aa47, 0x82000540, 0x00000001, 0x0201f800, - 0x0010518c, 0x4a038808, 0x00000000, 0x4202d800, - 0x00000004, 0x42001000, 0x00000001, 0x0201f800, - 0x0010193d, 0x4a035049, 0x00000001, 0x0201f800, - 0x001006d4, 0x0201f000, 0x001022c0, 0x800409c0, - 0x04000005, 0x4a034406, 0x00000001, 0x0201f000, - 0x0010230c, 0x836c0580, 0x00000003, 0x04000005, - 0x4a034406, 0x00000007, 0x0201f000, 0x0010230c, - 0x59a28c06, 0x59a0320b, 0x82183500, 0x000000ff, - 0x0201f800, 0x00020245, 0x02020000, 0x00102310, - 0x83440580, 0x000007fd, 0x04000008, 0x0201f800, - 0x001049e7, 0x04000005, 0x42000800, 0x00000009, - 0x0201f000, 0x0010230c, 0x0201f800, 0x00103a00, - 0x04020005, 0x4a034406, 0x00000002, 0x0201f000, - 0x0010230c, 0x497a5a04, 0x4a025c04, 0x00008000, - 0x0201f800, 0x00109115, 0x04020005, 0x4a034406, - 0x00000003, 0x0201f000, 0x0010230c, 0x4a01d809, - 0x0010329e, 0x1c01f000, 0x592c0005, 0x82000d00, - 0x0000ffff, 0x82000500, 0xffff0000, 0x82000580, - 0x01000000, 0x04020005, 0x4a034406, 0x00000004, - 0x0201f000, 0x0010230c, 0x80040904, 0x832ca400, - 0x00000005, 0x4050a800, 0x4004b000, 0x0201f800, - 0x0010ab28, 0x59a00207, 0x59a01407, 0x900001c0, - 0x80081540, 0x59a00209, 0x59a01c09, 0x900001c0, - 0x800c1d40, 0x832c0400, 0x00000005, 0x0201f000, - 0x00103a28, 0x496fc857, 0x836c0580, 0x00000000, - 0x04000005, 0x4a034406, 0x0000001a, 0x0201f000, - 0x0010230c, 0x0201f800, 0x0010513b, 0x02020800, - 0x00104142, 0x42000800, 0x00000020, 0x59a00407, - 0x59a01207, 0x900811c0, 0x80081540, 0x59a00409, - 0x59a01a09, 0x900c19c0, 0x800c1d40, 0x419c0000, - 0x49a3c857, 0x0201f800, 0x00103a25, 0x4a01d809, - 0x001032da, 0x1c01f000, 0x4833c857, 0x4031d800, - 0x58ef400b, 0x58ec0002, 0x82000580, 0x00000200, - 0x02000000, 0x00102304, 0x599c0200, 0x800001c0, - 0x02000000, 0x00102310, 0x59a80005, 0x8c000512, - 0x04000004, 0x599c0019, 0x8400050c, 0x48033819, - 0x0201f800, 0x001097d7, 0x59a80005, 0x8c000514, - 0x04000004, 0x599c0017, 0x84000508, 0x48033817, - 0x0201f800, 0x00103b25, 0x04020004, 0x8c00050a, - 0x02020000, 0x00102310, 0x4803c857, 0x8c000504, - 0x04020004, 0x59c408a3, 0x84040d7a, 0x480788a3, - 0x8c000502, 0x04020004, 0x59c408a3, 0x84040d08, - 0x480788a3, 0x599c0c02, 0x8c000500, 0x04020004, - 0x8c000516, 0x04000012, 0x0401f001, 0x82041480, - 0x0000007f, 0x02021000, 0x00102310, 0x82041400, - 0x0010210e, 0x50081000, 0x82081500, 0x000000ff, - 0x8c000500, 0x04020006, 0x480b5010, 0x42000800, - 0x00000003, 0x0201f800, 0x00106c78, 0x599c0019, - 0x8c00050e, 0x0402000b, 0x59a80806, 0x8c040d14, - 0x04000008, 0x42000800, 0x0010b4e3, 0x50040800, - 0x82040d00, 0x00000028, 0x02020000, 0x00102310, - 0x82000500, 0x00000030, 0x04000003, 0x80000108, - 0x0401f003, 0x42000000, 0x00000002, 0x48039040, - 0x42000800, 0x00000002, 0x82000400, 0x00103415, - 0x50001000, 0x0201f800, 0x00106c78, 0x599c0201, - 0x82000c80, 0x00000100, 0x02001000, 0x00102310, - 0x82000c80, 0x00000841, 0x02021000, 0x00102310, - 0x82000500, 0x00000007, 0x02020000, 0x00102310, - 0x599c0401, 0x80000540, 0x02000000, 0x00102310, - 0x599c0409, 0x599c0c07, 0x80040c80, 0x02021000, - 0x00102310, 0x80000040, 0x02000000, 0x00102310, - 0x599c0209, 0x599c0a07, 0x80040c80, 0x02021000, - 0x00102310, 0x80000040, 0x02000000, 0x00102310, - 0x0201f800, 0x001053cd, 0x0201f800, 0x00104cb6, - 0x599c0201, 0x48035004, 0x0201f800, 0x001012ee, - 0x599c020a, 0x800001c0, 0x04000003, 0x4803504d, - 0x0401f003, 0x4a03504d, 0x000000c8, 0x0201f800, - 0x00103b25, 0x04000004, 0x0201f800, 0x001060df, - 0x417a5000, 0x836c0580, 0x00000000, 0x04020098, - 0x599c0003, 0x599c0804, 0x9c0001c0, 0x9c0409c0, - 0x48035002, 0x48075003, 0x599c1017, 0x8c08151c, - 0x04000006, 0x599c0005, 0x599c0806, 0x9c0001c0, - 0x9c0409c0, 0x0401f003, 0x82000500, 0xf0ffffff, - 0x48035000, 0x48075001, 0x42001000, 0x0010b4eb, - 0x48001000, 0x48041001, 0x42001000, 0x0010b4f8, - 0x48001000, 0x48041001, 0x59a80005, 0x8c000514, - 0x04020015, 0x599c1019, 0x82081500, 0x0000e000, - 0x82080580, 0x00000000, 0x0402000c, 0x4a035053, - 0x00000000, 0x42000000, 0x00000001, 0x0201f800, - 0x0010188c, 0x42000000, 0x00000001, 0x0201f800, - 0x00101821, 0x0401f02b, 0x82080580, 0x00002000, - 0x0402000a, 0x4a035053, 0x00000001, 0x41780000, - 0x0201f800, 0x0010188c, 0x41780000, 0x0201f800, - 0x00101821, 0x0401f01f, 0x82080580, 0x00004000, - 0x04020006, 0x4a035053, 0x00000002, 0x4a035049, - 0x00000001, 0x0401f017, 0x82080580, 0x00006000, - 0x02020000, 0x00102310, 0x59a80858, 0x82040d80, - 0x01391077, 0x04020005, 0x59e00813, 0x8c040d00, - 0x02020000, 0x00102310, 0x4a035053, 0x00000003, - 0x42000000, 0x00000002, 0x0201f800, 0x0010188c, - 0x42000000, 0x00000002, 0x0201f800, 0x00101821, - 0x599c0019, 0x8c000520, 0x0400000d, 0x42000000, - 0x00000004, 0x42000800, 0x00000040, 0x0201f800, - 0x00101944, 0x42000000, 0x00000010, 0x42000800, - 0x000000c0, 0x0201f800, 0x00101944, 0x4a035032, - 0x0000aaaa, 0x599c1018, 0x82081500, 0x00000030, - 0x59a8006c, 0x80000540, 0x0400000c, 0x82080580, - 0x00000000, 0x02000000, 0x00102310, 0x599c1018, - 0x82081500, 0xffffffcf, 0x82081540, 0x00000010, - 0x480b3818, 0x0401f010, 0x82080d80, 0x00000000, - 0x04000007, 0x82080d80, 0x00000010, 0x0400000a, - 0x82080d80, 0x00000020, 0x04020002, 0x48075032, - 0x0201f800, 0x00103aba, 0x04000008, 0x0201f800, - 0x001015fe, 0x0201f800, 0x0010162a, 0x59a8002a, - 0x80040540, 0x4803502a, 0x49f3c857, 0x42001000, - 0x00105065, 0x0201f800, 0x00105f90, 0x42001000, - 0x00105058, 0x0201f800, 0x00106084, 0x4a038805, - 0xffffffff, 0x4a03c014, 0x00400040, 0x4a03c013, - 0x00400000, 0x0201f800, 0x001048c7, 0x59a0001d, - 0x84000540, 0x4803401d, 0x49f3c857, 0x0201f000, - 0x001022c0, 0x00000018, 0x0000000c, 0x00000018, - 0x00000020, 0x836c0580, 0x00000000, 0x04020005, - 0x42000800, 0x00000007, 0x0201f000, 0x0010230c, - 0x42000800, 0x00000020, 0x59a00407, 0x59a01207, - 0x900811c0, 0x80081540, 0x59a00409, 0x59a01a09, - 0x900c19c0, 0x800c1d40, 0x419c0000, 0x0201f000, - 0x00103a28, 0x800409c0, 0x04000005, 0x4a034406, - 0x00000001, 0x0201f000, 0x0010230c, 0x0201f800, - 0x0010513b, 0x04020005, 0x4a034406, 0x00000016, - 0x0201f000, 0x0010230c, 0x59a80013, 0x8c000500, - 0x04000011, 0x4a034406, 0x00000000, 0x42000800, - 0x00000020, 0x59a00407, 0x59a01207, 0x900811c0, - 0x80081540, 0x59a00409, 0x59a01a09, 0x900c19c0, - 0x800c1d40, 0x42000000, 0x0010be21, 0x0201f000, - 0x00103a28, 0x4a034406, 0x00000001, 0x4200b000, - 0x00000020, 0x4200a800, 0x0010be21, 0x4200a000, - 0xffffffff, 0x4450a800, 0x8054a800, 0x8058b040, - 0x040207fd, 0x4d440000, 0x4d340000, 0x42028800, - 0xffffffff, 0x42002000, 0xffffffff, 0x42003000, - 0x00000001, 0x42003800, 0x00000001, 0x42001800, - 0x0010be21, 0x59a81010, 0x82081500, 0x000000ff, - 0x40180000, 0x0c01f001, 0x0010346e, 0x00103471, - 0x00103475, 0x00103479, 0x82102500, 0xffffff00, - 0x0401f014, 0x82102500, 0xffff00ff, 0x840811c0, - 0x0401f010, 0x82102500, 0xff00ffff, 0x900811c0, - 0x0401f00c, 0x82102500, 0x00ffffff, 0x9c0801c0, - 0x80102540, 0x44101800, 0x42003000, 0xffffffff, - 0x42002000, 0xffffffff, 0x800c1800, 0x0401f003, - 0x40080000, 0x80102540, 0x81468800, 0x83442c80, - 0x0000007f, 0x04021014, 0x4c080000, 0x4c0c0000, - 0x4c180000, 0x4c1c0000, 0x0201f800, 0x00020245, - 0x5c003800, 0x5c003000, 0x5c001800, 0x5c001000, - 0x040207f2, 0x0201f800, 0x001049f3, 0x040207ef, - 0x80183000, 0x801c3800, 0x59341202, 0x40180000, - 0x0c01f7ce, 0x82100580, 0xffffffff, 0x04000002, - 0x44101800, 0x42001800, 0x0010be21, 0x500c0000, - 0x82000500, 0xffffff00, 0x801c0540, 0x44001800, - 0x5c026800, 0x5c028800, 0x42000800, 0x00000020, - 0x59a00407, 0x59a01207, 0x900811c0, 0x80081540, - 0x59a00409, 0x59a01a09, 0x900c19c0, 0x800c1d40, - 0x42000000, 0x0010be21, 0x0201f000, 0x00103a28, - 0x59a28c06, 0x59a0020b, 0x8c000500, 0x0400000e, - 0x59a01208, 0x59a00408, 0x82000500, 0x000000ff, - 0x900001c0, 0x80081540, 0x41784000, 0x0201f800, - 0x00104919, 0x04000008, 0x48034406, 0x0201f000, - 0x00102310, 0x0201f800, 0x00020245, 0x02020000, - 0x00102310, 0x0201f800, 0x00103a00, 0x04020005, - 0x4a034406, 0x00000002, 0x0201f000, 0x0010230c, - 0x59a0020b, 0x8c000500, 0x04000005, 0x0201f800, - 0x001049f3, 0x02020000, 0x00103ac4, 0x59a0020b, - 0x8c000502, 0x04000019, 0x83440480, 0x000007f0, - 0x04021016, 0x0201f800, 0x001049fc, 0x04020013, - 0x497a5a04, 0x4a025c04, 0x00008000, 0x0201f800, - 0x001090e6, 0x04020005, 0x4a034406, 0x00000003, - 0x0201f000, 0x0010230c, 0x4a01d809, 0x001034f1, - 0x1c01f000, 0x59a28c06, 0x0201f800, 0x00020245, - 0x02020000, 0x00102310, 0x4200b000, 0x0000000a, - 0x4134a000, 0x832e5c00, 0x00000002, 0x412ca800, - 0x0201f800, 0x0010ab17, 0x832cac00, 0x00000006, - 0x4054a000, 0x4200b000, 0x00000004, 0x0201f800, - 0x0010ab28, 0x592c0802, 0x82040500, 0x00ff00ff, - 0x900001c0, 0x82041500, 0xff00ff00, 0x80080540, - 0x48025802, 0x592c0801, 0x82040500, 0x00ff00ff, - 0x900001c0, 0x82041500, 0xff00ff00, 0x80080540, - 0x48025801, 0x42000800, 0x0000000a, 0x59a00407, - 0x59a01207, 0x900811c0, 0x80081540, 0x59a00409, - 0x59a01a09, 0x900c19c0, 0x800c1d40, 0x412c0000, - 0x0201f000, 0x00103a28, 0x496fc857, 0x496f4406, - 0x0201f000, 0x001022c0, 0x59a28c06, 0x0201f800, - 0x00020245, 0x02020000, 0x00102310, 0x836c0580, - 0x00000003, 0x04000005, 0x4a034406, 0x00000007, - 0x0201f000, 0x0010230c, 0x83340c00, 0x00000006, - 0x59a0020b, 0x8c000500, 0x04000003, 0x83340c00, - 0x00000008, 0x58040001, 0x48034409, 0x900001c0, - 0x48034209, 0x50040000, 0x48034407, 0x900001c0, - 0x48034207, 0x59340200, 0x48034406, 0x0201f000, - 0x001022c0, 0x800409c0, 0x04000005, 0x4a034406, - 0x00000001, 0x0201f000, 0x0010230c, 0x59a0220b, - 0x8c102500, 0x0402002e, 0x8c102506, 0x04020006, - 0x59a03208, 0x82180480, 0x00000003, 0x02021000, - 0x00102310, 0x59a28c06, 0x0201f800, 0x00020245, - 0x02020000, 0x00102310, 0x0201f800, 0x001049e7, - 0x04000005, 0x4a034406, 0x00000009, 0x0201f000, - 0x0010230c, 0x0201f800, 0x00103a00, 0x04020005, - 0x4a034406, 0x00000002, 0x0201f000, 0x0010230c, - 0x59a0220b, 0x8c102506, 0x04000004, 0x59343002, - 0x82183500, 0x00ffffff, 0x497a5a04, 0x4a025c04, - 0x00008000, 0x0201f800, 0x001090a8, 0x04020005, - 0x4a034406, 0x00000003, 0x0201f000, 0x0010230c, - 0x4a01d809, 0x001035d1, 0x1c01f000, 0x59a28c06, - 0x0201f800, 0x00020245, 0x02020000, 0x00102310, - 0x0201f800, 0x001049e7, 0x04000005, 0x4a034406, - 0x00000009, 0x0201f000, 0x0010230c, 0x0201f800, - 0x00103a00, 0x04020005, 0x4a034406, 0x00000002, - 0x0201f000, 0x0010230c, 0x497a5a04, 0x4a025c04, - 0x00008000, 0x0201f800, 0x00103a00, 0x04020005, - 0x4a034406, 0x00000002, 0x0201f000, 0x0010230c, - 0x592e5800, 0x0201f800, 0x001090bd, 0x04020005, - 0x4a034406, 0x00000003, 0x0201f000, 0x0010230c, - 0x4a01d809, 0x001035a3, 0x1c01f000, 0x592c2805, - 0x82140d80, 0x01000000, 0x04020005, 0x4a034406, - 0x00000004, 0x0201f000, 0x0010230c, 0x42000800, - 0x00000008, 0x59a00207, 0x59a01407, 0x900001c0, - 0x80081540, 0x59a00209, 0x59a01c09, 0x900001c0, - 0x800c1d40, 0x832c0400, 0x00000005, 0x0201f800, - 0x00103a28, 0x8c142d00, 0x04000003, 0x4a01d809, - 0x001035be, 0x1c01f000, 0x4031d800, 0x58ef400b, - 0x58ee580e, 0x58ec0002, 0x82000580, 0x00000200, - 0x02000000, 0x00102304, 0x812e59c0, 0x02000800, - 0x001005d8, 0x42000800, 0x00000008, 0x832c0400, - 0x00000005, 0x58ec1007, 0x58ec1808, 0x0201f000, - 0x00103a28, 0x592c0005, 0x82000580, 0x01000000, - 0x04020005, 0x4a034406, 0x00000004, 0x0201f000, - 0x0010230c, 0x59a00207, 0x59a01407, 0x900001c0, - 0x80081540, 0x59a00209, 0x59a01c09, 0x900001c0, - 0x800c1d40, 0x42000800, 0x00000006, 0x832c0400, - 0x00000006, 0x0201f000, 0x00103a28, 0x59a00a0a, - 0x800409c0, 0x02000000, 0x00102310, 0x82040480, - 0x000000e7, 0x04001003, 0x42000800, 0x000000e6, - 0x59a00207, 0x59a01407, 0x900001c0, 0x80081540, - 0x59a00209, 0x59a01c09, 0x900001c0, 0x800c1d40, - 0x83880400, 0x00000000, 0x0201f800, 0x00103a28, - 0x4a01d809, 0x001035ff, 0x1c01f000, 0x4031d800, - 0x58ef400b, 0x58ec0002, 0x82000580, 0x00000200, - 0x02000000, 0x00102304, 0x58ef400b, 0x59a0020b, - 0x8c000500, 0x04000008, 0x83880400, 0x00000000, - 0x4803c840, 0x4a03c842, 0x00000006, 0x04011000, - 0x497b8885, 0x4a034207, 0x000000e6, 0x0201f000, - 0x001022c0, 0x800409c0, 0x04000005, 0x4a034406, - 0x00000001, 0x0201f000, 0x0010230c, 0x0401fbe5, - 0x04020005, 0x4a034406, 0x00000002, 0x0201f000, - 0x0010230c, 0x497a5a04, 0x4a025c04, 0x00008000, - 0x59a00406, 0x800001c0, 0x02000000, 0x00102310, - 0x82001580, 0x000000ff, 0x04000005, 0x82001480, - 0x00000004, 0x02021000, 0x00102310, 0x40001000, - 0x0201f800, 0x00101fbf, 0x04020005, 0x4a034406, - 0x00000003, 0x0201f000, 0x0010230c, 0x4a01d809, - 0x0010363a, 0x1c01f000, 0x592c0005, 0x82000580, - 0x01000000, 0x02020000, 0x001022c0, 0x4a034406, - 0x00000004, 0x0201f000, 0x0010230c, 0x59a01406, - 0x8c081508, 0x04020007, 0x800409c0, 0x04000005, - 0x4a034406, 0x00000001, 0x0201f000, 0x0010230c, - 0x59a01c07, 0x820c0480, 0x00001000, 0x02021000, - 0x00102310, 0x497b2804, 0x497b2805, 0x497b281c, - 0x497b281d, 0x497b281f, 0x497b2820, 0x497b2822, - 0x497b2823, 0x80000580, 0x0201f800, 0x001015fe, - 0x59a80805, 0x8c081500, 0x04000004, 0x82040d40, - 0x00000011, 0x0401f004, 0x8c081506, 0x04000002, - 0x84040d42, 0x84040d0a, 0x48075005, 0x4202d800, - 0x00000001, 0x82081500, 0x000000e0, 0x8008010a, - 0x0c020036, 0x0201f800, 0x0010513b, 0x04020009, - 0x4a035033, 0x00000001, 0x0201f800, 0x001050a2, - 0x0401f01f, 0x4a035033, 0x00000000, 0x0401f7fb, - 0x497b5032, 0x0201f800, 0x00104142, 0x0201f800, - 0x00106c55, 0x0201f800, 0x00106ede, 0x0201f800, - 0x00106c4b, 0x59a00a07, 0x480788a7, 0x59c400a3, - 0x82000500, 0xfeffffff, 0x82000540, 0x80018000, - 0x40000800, 0x84040d20, 0x480388a3, 0x480788a3, - 0x497b504e, 0x42000800, 0x0000002d, 0x42001000, - 0x001041bc, 0x0201f800, 0x00105f69, 0x59a00407, - 0x800000c2, 0x800008c4, 0x8005d400, 0x42000000, - 0x0000ffff, 0x0201f800, 0x0010513b, 0x04000003, - 0x59a00207, 0x80000110, 0x0201f800, 0x00103afc, - 0x0201f000, 0x001022c0, 0x0010366d, 0x00103670, - 0x00103678, 0x00102310, 0x00103675, 0x00102310, - 0x00102310, 0x00102310, 0x836c0580, 0x00000003, - 0x04000005, 0x4a034406, 0x00000007, 0x0201f000, - 0x0010230c, 0x59a03c06, 0x59a00407, 0x59a04a07, - 0x902449c0, 0x80244d40, 0x59a00409, 0x59a05209, - 0x902851c0, 0x80285540, 0x0401fb46, 0x04020005, - 0x4a034406, 0x00000002, 0x0201f000, 0x0010230c, - 0x417a8800, 0x41783000, 0x497b4001, 0x497b4004, - 0x832c4400, 0x00000005, 0x48234002, 0x8c1c3d04, - 0x04020078, 0x0201f800, 0x00020245, 0x0402002a, - 0x0201f800, 0x001049e7, 0x04000004, 0x0201f800, - 0x001048e3, 0x04020024, 0x8c1c3d00, 0x04000008, - 0x59340009, 0x44004000, 0x59340008, 0x80204000, - 0x44004000, 0x80204000, 0x0401f007, 0x59340007, - 0x44004000, 0x59340006, 0x80204000, 0x44004000, - 0x80204000, 0x83440580, 0x000007fe, 0x0400000d, - 0x83440580, 0x000007fc, 0x0400000a, 0x0201f800, - 0x001049f3, 0x04000003, 0x85468d5e, 0x0401f005, - 0x0201f800, 0x00104838, 0x04020002, 0x85468d5e, - 0x45444000, 0x85468d1e, 0x80204000, 0x82183400, - 0x00000003, 0x81468800, 0x83440480, 0x000007f0, - 0x0400100e, 0x8c1c3d06, 0x04000010, 0x83440580, - 0x000007f0, 0x04020004, 0x42028800, 0x000007fe, - 0x0401f006, 0x83440580, 0x000007ff, 0x04020007, - 0x42028800, 0x000007fc, 0x82180580, 0x0000000f, - 0x0400000b, 0x0401f7c0, 0x801831c0, 0x04020006, - 0x59a00801, 0x800408c4, 0x48074406, 0x0201f000, - 0x001022c0, 0x4a034004, 0x00000001, 0x49474000, - 0x59a00001, 0x80180400, 0x48034001, 0x481f4003, - 0x4a01d801, 0x00000000, 0x4819d804, 0x59a00002, - 0x4801d803, 0x4825d807, 0x4829d808, 0x4000a800, - 0x4000a000, 0x4018b000, 0x0201f800, 0x0010ab17, - 0x40ec1000, 0x0201f800, 0x00100858, 0x4a01d809, - 0x0010372a, 0x1c01f000, 0x4031d800, 0x58ef400b, - 0x58ec0002, 0x82000580, 0x00000200, 0x02000000, - 0x00102304, 0x59a00004, 0x80000540, 0x04020008, - 0x59a28800, 0x59a04002, 0x59a03803, 0x41783000, - 0x58ec4807, 0x58ec5008, 0x0401f78f, 0x59a00801, - 0x800408c4, 0x48074406, 0x0201f000, 0x001022c0, - 0x0201f800, 0x00020245, 0x0402002f, 0x0201f800, - 0x001049e7, 0x04000004, 0x0201f800, 0x001048e3, - 0x04020029, 0x83440580, 0x000007fe, 0x04000011, - 0x83440580, 0x000007fc, 0x0400000e, 0x0201f800, - 0x001049f3, 0x04000005, 0x59340403, 0x8400055e, - 0x48026c03, 0x0401f007, 0x0201f800, 0x00104838, - 0x04020004, 0x59340403, 0x8400055e, 0x48026c03, - 0x4134a000, 0x4020a800, 0x4200b000, 0x00000006, - 0x0201f800, 0x0010ab17, 0x59340007, 0x4400a800, - 0x59340006, 0x4800a801, 0x59340009, 0x4800a802, - 0x59340008, 0x4800a803, 0x59340403, 0x8400051e, - 0x48026c03, 0x82204400, 0x0000000a, 0x82183400, - 0x0000000a, 0x81468800, 0x83440480, 0x000007f0, - 0x0400100e, 0x8c1c3d06, 0x04000010, 0x83440580, - 0x000007f0, 0x04020004, 0x42028800, 0x000007fe, - 0x0401f006, 0x83440580, 0x000007ff, 0x04020007, - 0x42028800, 0x000007fc, 0x82180580, 0x0000000a, - 0x0400000b, 0x0401f7bb, 0x801831c0, 0x04020006, - 0x59a00801, 0x800408c4, 0x48074406, 0x0201f000, - 0x001022c0, 0x4a034004, 0x00000001, 0x49474000, - 0x59a00001, 0x80180400, 0x48034001, 0x481f4003, - 0x4a01d801, 0x00000000, 0x4819d804, 0x59a00002, - 0x4801d803, 0x4825d807, 0x4829d808, 0x40ec1000, - 0x0201f800, 0x00100858, 0x4a01d809, 0x001037a1, - 0x1c01f000, 0x4031d800, 0x58ef400b, 0x58ec0002, - 0x82000580, 0x00000200, 0x02000000, 0x00102304, - 0x59a00004, 0x80000540, 0x04020008, 0x59a28800, - 0x59a04002, 0x59a03803, 0x41783000, 0x58ec4807, - 0x58ec5008, 0x0401f78f, 0x59a00801, 0x800408c4, - 0x48074406, 0x0201f000, 0x001022c0, 0x42002800, - 0x0000007e, 0x59a00c06, 0x59a01207, 0x59a01c07, - 0x59a02209, 0x82040500, 0x0000ff00, 0x840001c0, - 0x82003480, 0x00000020, 0x02001000, 0x00102310, - 0x80140480, 0x02001000, 0x00102310, 0x82040500, - 0x000000ff, 0x82003480, 0x00000020, 0x02001000, - 0x00102310, 0x80140480, 0x02001000, 0x00102310, - 0x82080500, 0x0000ff00, 0x840001c0, 0x82003480, - 0x00000020, 0x02001000, 0x00102310, 0x80140480, - 0x02001000, 0x00102310, 0x82080500, 0x000000ff, - 0x82003480, 0x00000020, 0x02001000, 0x00102310, - 0x80140480, 0x02001000, 0x00102310, 0x820c0500, - 0x0000ff00, 0x840001c0, 0x82003480, 0x00000020, - 0x02001000, 0x00102310, 0x80140480, 0x02001000, - 0x00102310, 0x820c0500, 0x000000ff, 0x82003480, - 0x00000020, 0x02001000, 0x00102310, 0x80140480, - 0x02001000, 0x00102310, 0x82100500, 0x0000ff00, - 0x840001c0, 0x82003480, 0x00000020, 0x02001000, - 0x00102310, 0x80140480, 0x02001000, 0x00102310, - 0x82100500, 0x000000ff, 0x82003480, 0x00000020, - 0x02001000, 0x00102310, 0x80140480, 0x02001000, - 0x00102310, 0x900401c0, 0x80080d40, 0x900c01c0, - 0x80101d40, 0x83a83400, 0x0000003a, 0x44043000, - 0x80183000, 0x440c3000, 0x0201f000, 0x001022c0, - 0x0401f9ec, 0x04020005, 0x4a034406, 0x00000002, - 0x0201f000, 0x0010230c, 0x42000800, 0x0000000c, - 0x0401f853, 0x4a01d809, 0x00103820, 0x1c01f000, - 0x4031d800, 0x58ee580d, 0x58ef400b, 0x58ec0002, - 0x82000580, 0x00000200, 0x02000000, 0x00102304, - 0x832ca400, 0x00000004, 0x4200b000, 0x0000000c, - 0x40c8a800, 0x0201f800, 0x0010ab17, 0x58c80200, - 0x80000540, 0x04000034, 0x58c80400, 0x82000500, - 0xfffffffb, 0x04020030, 0x58c80401, 0x80000540, - 0x0400002d, 0x82000480, 0x0000ff01, 0x0402102a, - 0x58c80202, 0x82000480, 0x0000005c, 0x04001026, - 0x0201f800, 0x001063a3, 0x58c80c08, 0x58c80204, - 0x80040480, 0x04001020, 0x58c80204, 0x82000480, - 0x00000005, 0x0402101c, 0x58c80205, 0x58c80c08, - 0x80040902, 0x80040480, 0x04001017, 0x58c80c08, - 0x0201f800, 0x001062f1, 0x0400001b, 0x0201f800, - 0x001061b9, 0x04020012, 0x4979940b, 0x59c408a3, - 0x82040d40, 0x00000002, 0x480788a3, 0x4a038830, - 0x00000001, 0x4a038832, 0x01ffffff, 0x58c80202, - 0x48030804, 0x0201f800, 0x0010619b, 0x0201f000, - 0x001022c0, 0x0201f000, 0x00102310, 0x0201f800, - 0x001063f5, 0x0201f800, 0x00106402, 0x0201f800, - 0x001062e4, 0x0201f000, 0x0010230c, 0x4c000000, - 0x59a01207, 0x59a00407, 0x900811c0, 0x80081540, - 0x59a01a09, 0x59a00409, 0x900c19c0, 0x800c1d40, - 0x5c000000, 0x0401f1ac, 0x59840000, 0x82000580, - 0x00000000, 0x04000054, 0x59840002, 0x8c000504, - 0x04000051, 0x84000546, 0x48030802, 0x0201f800, - 0x001062e4, 0x59c408a3, 0x82040d00, 0xfffffffd, - 0x480788a3, 0x4c5c0000, 0x4200b800, 0x0010ac00, - 0x505e6800, 0x813669c0, 0x04000008, 0x5936600e, - 0x813261c0, 0x04000005, 0x0201f800, 0x001062d5, - 0x02000800, 0x001064ad, 0x805cb800, 0x825c0580, - 0x0010b3f0, 0x040207f3, 0x59866003, 0x813261c0, - 0x0400000b, 0x59300406, 0x82000580, 0x00000009, - 0x02020800, 0x001005d8, 0x5930b800, 0x0201f800, - 0x001062c1, 0x405e6000, 0x0401f7f5, 0x497b0803, - 0x4200b800, 0x0010b51b, 0x505e6000, 0x813261c0, - 0x04000011, 0x59300406, 0x82000580, 0x00000009, - 0x0402000d, 0x59300203, 0x82000580, 0x00000004, - 0x04020009, 0x59326809, 0x813669c0, 0x02020800, - 0x001005d8, 0x0201f800, 0x00100e99, 0x0201f800, - 0x001062c1, 0x4578b800, 0x805cb800, 0x825c0580, - 0x0010b523, 0x040207e9, 0x42000800, 0x0010b519, - 0x49780801, 0x49780800, 0x59a80069, 0x82000400, - 0x00000007, 0x48035069, 0x0201f800, 0x001063f5, - 0x0201f800, 0x00106402, 0x5c00b800, 0x0201f800, - 0x001061b4, 0x0201f000, 0x001022c0, 0x836c0580, - 0x00000003, 0x04000005, 0x4a034406, 0x00000007, - 0x0201f000, 0x0010230c, 0x59a00407, 0x59a02207, - 0x901021c0, 0x80102540, 0x59a00409, 0x59a02a09, - 0x901429c0, 0x80142d40, 0x0401f91e, 0x04020005, - 0x4a034406, 0x00000002, 0x0201f000, 0x0010230c, - 0x417a8800, 0x41781800, 0x497b4001, 0x497b4003, - 0x832c3400, 0x00000004, 0x481b4002, 0x41440000, - 0x81ac0400, 0x50026800, 0x813669c0, 0x0400000b, - 0x0201f800, 0x001049e7, 0x04020008, 0x59340002, - 0x48003000, 0x49443001, 0x82183400, 0x00000002, - 0x820c1c00, 0x00000002, 0x81468800, 0x83440480, - 0x00000800, 0x04000005, 0x820c0480, 0x00000010, - 0x0402100b, 0x0401f7ea, 0x800c19c0, 0x04020006, - 0x59a00801, 0x80040902, 0x48074406, 0x0201f000, - 0x001022c0, 0x4a034003, 0x00000001, 0x49474000, - 0x59a00001, 0x800c0400, 0x48034001, 0x40ec1000, - 0x4a001001, 0x00000000, 0x480c1004, 0x59a00002, - 0x48001003, 0x48101007, 0x48141008, 0x0201f800, - 0x00100858, 0x4a01d809, 0x00103920, 0x1c01f000, - 0x4031d800, 0x58ef400b, 0x58ec0002, 0x82000580, - 0x00000200, 0x02000000, 0x00102304, 0x59a00003, - 0x80000540, 0x04020008, 0x59a28800, 0x59a03002, - 0x41781800, 0x40ec1000, 0x58082007, 0x58082808, - 0x0401f7bf, 0x59a00801, 0x80040902, 0x48074406, - 0x0201f000, 0x001022c0, 0x800409c0, 0x04000005, - 0x4a034406, 0x00000001, 0x0201f000, 0x0010230c, - 0x59a80026, 0x8c00050a, 0x04020007, 0x8c000506, - 0x04020005, 0x4a034406, 0x00000016, 0x0201f000, - 0x0010230c, 0x0401f8bb, 0x04020005, 0x4a034406, - 0x00000002, 0x0201f000, 0x0010230c, 0x59a00c06, - 0x80040902, 0x59a00407, 0x59a01207, 0x900811c0, - 0x80081540, 0x59a00409, 0x59a01a09, 0x900c19c0, - 0x800c1d40, 0x832c0400, 0x00000005, 0x0401f8ce, - 0x4a01d809, 0x0010395b, 0x1c01f000, 0x4031d800, - 0x58ef400b, 0x58ee580d, 0x58ec0002, 0x82000580, - 0x00000200, 0x02000000, 0x00102304, 0x592c0009, - 0x0201f800, 0x00105c9a, 0x02000800, 0x001045a6, - 0x02020000, 0x00102310, 0x49474001, 0x481a6802, - 0x592c000a, 0x82001d80, 0x70000000, 0x04020007, - 0x0401f890, 0x04020011, 0x4a034406, 0x00000002, - 0x0201f000, 0x0010230c, 0x82001d80, 0x72000000, - 0x02020000, 0x00102310, 0x0401f886, 0x04020885, - 0x04020884, 0x04020005, 0x4a034406, 0x00000002, - 0x0201f000, 0x0010230c, 0x58ee580d, 0x4a025c04, - 0x00008000, 0x497a5a04, 0x592c3208, 0x80183102, - 0x592c1801, 0x4a001805, 0x01000000, 0x0201f800, - 0x001090d1, 0x04020005, 0x4a034406, 0x00000003, - 0x0201f000, 0x0010230c, 0x4a01d809, 0x00103995, - 0x1c01f000, 0x592c4000, 0x592c0005, 0x82000580, - 0x01000000, 0x04020005, 0x4a034406, 0x00000004, - 0x0201f000, 0x0010230c, 0x832c3c00, 0x00000005, - 0x401ca000, 0x401ca800, 0x5820280a, 0x4200b000, - 0x00000002, 0x82143580, 0x70000000, 0x04000003, - 0x4200b000, 0x0000000f, 0x0201f800, 0x0010ab28, - 0x401c0000, 0x58201006, 0x58201807, 0x58202205, - 0x80102102, 0x82143580, 0x70000000, 0x04020008, - 0x82103480, 0x00000002, 0x02001000, 0x00102310, - 0x42000800, 0x00000002, 0x0401f06e, 0x82143580, - 0x72000000, 0x02020000, 0x00102310, 0x82103480, - 0x0000002a, 0x02001000, 0x00102310, 0x42000800, - 0x0000000f, 0x0401f863, 0x4a01d809, 0x001039c9, - 0x1c01f000, 0x4031d800, 0x58ef400b, 0x58ee580e, - 0x58ec0002, 0x82000580, 0x00000200, 0x02000000, - 0x00102304, 0x592e5800, 0x832c0c00, 0x00000005, - 0x4004a000, 0x4004a800, 0x4200b000, 0x0000000f, - 0x0201f800, 0x0010ab28, 0x40ec1000, 0x4a001001, - 0x00000000, 0x4a001004, 0x0000000f, 0x48041003, - 0x0201f800, 0x00100858, 0x4a01d809, 0x001039e5, - 0x1c01f000, 0x4031d800, 0x58ef400b, 0x58ee580e, - 0x58ec0002, 0x82000580, 0x00000200, 0x02000000, - 0x00102304, 0x832c0c00, 0x00000005, 0x4004a000, - 0x4004a800, 0x4200b000, 0x0000000c, 0x0201f800, - 0x0010ab28, 0x40ec1000, 0x4a001001, 0x00000000, - 0x4a001004, 0x0000000c, 0x48041003, 0x0201f800, - 0x00100858, 0x4a01d809, 0x001022b9, 0x1c01f000, - 0x0201f800, 0x001007e4, 0x04000010, 0x497a5800, - 0x58ec000d, 0x80000540, 0x04020004, 0x492dd80d, - 0x492dd80e, 0x0401f007, 0x58ec000e, 0x48025800, - 0x82000400, 0x00000001, 0x452c0000, 0x492dd80e, - 0x832c0400, 0x00000004, 0x492fc857, 0x4803c857, - 0x1c01f000, 0x4d2c0000, 0x48efc857, 0x58ec400d, - 0x4823c857, 0x802041c0, 0x04000007, 0x40225800, - 0x592c4001, 0x497a5801, 0x0201f800, 0x001007f4, - 0x0401f7f8, 0x4979d80d, 0x4979d80e, 0x5c025800, - 0x1c01f000, 0x42003000, 0x00000001, 0x0401f003, - 0x42003000, 0x00000000, 0x4803c857, 0x4807c857, - 0x480bc857, 0x480fc857, 0x481bc857, 0x48efc857, - 0x4819d801, 0x800409c0, 0x02000800, 0x001005d8, - 0x4805d804, 0x4801d803, 0x4809d807, 0x480dd808, - 0x40ec1000, 0x0201f800, 0x00100858, 0x4a01d809, - 0x001022b9, 0x1c01f000, 0x80002d80, 0x480bc857, - 0x480fc857, 0x4813c857, 0x4817c857, 0x4d2c0000, - 0x4da00000, 0x42034000, 0x0010b4a4, 0x59a00017, - 0x800001c0, 0x04020013, 0x04006012, 0x480bc020, - 0x480fc021, 0x4813c022, 0x4817c023, 0x900811c0, - 0x82081540, 0x00000012, 0x480bc011, 0x59e00017, - 0x8c000508, 0x04020004, 0x4203e000, 0x30000001, - 0x0401f053, 0x4a03c017, 0x00000002, 0x0401f7fb, - 0x4c040000, 0x4c1c0000, 0x80000800, 0x48074017, - 0x59a0381a, 0x481fc857, 0x801c39c0, 0x04020027, - 0x82000480, 0x0000000a, 0x04021010, 0x59a00018, - 0x80000000, 0x48034018, 0x59a00219, 0x82000400, - 0x00000002, 0x82000c80, 0x00000013, 0x48034219, - 0x04001003, 0x497b4219, 0x41780000, 0x59a03816, - 0x801c3c00, 0x0401f030, 0x4803c856, 0x0201f800, - 0x001007e4, 0x04000007, 0x492f401a, 0x492f401b, - 0x412c3800, 0x497b421c, 0x497a5813, 0x0401f026, - 0x59880051, 0x80000000, 0x48031051, 0x59a00017, - 0x80000040, 0x48034017, 0x59a00219, 0x59a03816, - 0x801c3c00, 0x0401f01c, 0x59a0021c, 0x82000400, - 0x00000002, 0x82000c80, 0x00000012, 0x04021004, - 0x4803421c, 0x801c3c00, 0x0401f013, 0x0201f800, - 0x001007e4, 0x0402000b, 0x59880051, 0x80000000, - 0x48031051, 0x59a00017, 0x80000040, 0x48034017, - 0x4803c856, 0x59a0021c, 0x801c3c00, 0x0401f006, - 0x492f401a, 0x492c3813, 0x412c3800, 0x497b421c, - 0x497a5813, 0x48083c00, 0x480c3a00, 0x48103c01, - 0x48143a01, 0x5c003800, 0x5c000800, 0x5c034000, - 0x5c025800, 0x1c01f000, 0x480fc857, 0x4813c857, - 0x481bc857, 0x42000000, 0x0010b813, 0x0201f800, - 0x0010aa47, 0x801800d0, 0x40002800, 0x42001000, - 0x00008014, 0x0401f786, 0x4c000000, 0x599c0017, - 0x8c000512, 0x5c000000, 0x1c01f000, 0x4c000000, - 0x599c0018, 0x8c00050e, 0x5c000000, 0x1c01f000, - 0x59a80821, 0x800409c0, 0x04000005, 0x4a034406, - 0x00000001, 0x0201f000, 0x0010230c, 0x836c0580, - 0x00000003, 0x04000005, 0x4a034406, 0x00000007, - 0x0201f000, 0x0010230c, 0x599c0017, 0x8c00050a, - 0x04000005, 0x4a034406, 0x00000008, 0x0201f000, - 0x0010230c, 0x59340405, 0x8c000508, 0x04020004, - 0x8c00050a, 0x02020000, 0x001034db, 0x497a5a04, - 0x497a5805, 0x4a025c04, 0x00008000, 0x0201f800, - 0x00109176, 0x04020005, 0x4a034406, 0x00000003, - 0x0201f000, 0x0010230c, 0x4a01d809, 0x00103aed, - 0x1c01f000, 0x592c0005, 0x82000580, 0x01000000, - 0x04020005, 0x4a034406, 0x00000004, 0x0201f000, - 0x0010230c, 0x59a28c06, 0x0201f800, 0x00020245, - 0x02020000, 0x00102310, 0x0201f000, 0x001034db, - 0x82001580, 0x0000ffff, 0x04000009, 0x0201f800, - 0x00105c9a, 0x02000800, 0x00020245, 0x0402000c, - 0x0201f800, 0x00105fae, 0x0401f009, 0x42028800, - 0x000007ef, 0x0201f800, 0x00020245, 0x02000800, - 0x00105fae, 0x81468840, 0x040217fb, 0x1c01f000, - 0x4803c856, 0x4c0c0000, 0x4d340000, 0x4d440000, - 0x42028800, 0x000007fe, 0x0201f800, 0x00020245, - 0x04020009, 0x5934180a, 0x820c1d00, 0x00000001, - 0x820c1d80, 0x00000001, 0x42001000, 0x0000801b, - 0x0401ff1e, 0x5c028800, 0x5c026800, 0x5c001800, - 0x1c01f000, 0x599c0017, 0x8c000508, 0x1c01f000, - 0x48efc857, 0x04011000, 0x48efc840, 0x4a03c842, - 0x00000011, 0x40000000, 0x040117ff, 0x4a01d80f, - 0xbeefbeef, 0x1c01f000, 0x497b4000, 0x497b4001, - 0x497b4002, 0x497b4003, 0x497b4004, 0x1c01f000, - 0x59c400a4, 0x4c580000, 0x4c500000, 0x4c540000, - 0x82000500, 0x0000000f, 0x82000480, 0x00000007, - 0x0400100a, 0x82006c80, 0x00000006, 0x02021800, - 0x001005d8, 0x0c01f807, 0x5c00a800, 0x5c00a000, - 0x5c00b000, 0x1c01f000, 0x0401f906, 0x0401f7fb, - 0x00103b51, 0x00103b57, 0x00103b7c, 0x00103b9e, - 0x00103c59, 0x59c40806, 0x8c040d00, 0x04020003, - 0x84040d40, 0x48078806, 0x1c01f000, 0x59c40005, - 0x8c000534, 0x02020000, 0x0010429e, 0x4a038805, - 0xffffffff, 0x42006000, 0x00020000, 0x0201f800, - 0x00104282, 0x59a80015, 0x82000500, 0xfffffffa, - 0x84000542, 0x48035015, 0x497b5026, 0x42000800, - 0x0010be21, 0x45780800, 0x497b5013, 0x42006000, - 0xffefffff, 0x42006800, 0x40000000, 0x0201f800, - 0x0010427d, 0x59c40006, 0x82000500, 0xffffff0f, - 0x48038806, 0x42000800, 0x00000010, 0x42001000, - 0x001041f3, 0x0201f800, 0x00105f83, 0x0401f001, - 0x42006000, 0xffffffff, 0x42006800, 0x00800000, - 0x0201f800, 0x0010427d, 0x4200b000, 0x000000c8, - 0x59c400a4, 0x82000500, 0x0000000f, 0x82000580, - 0x0000000a, 0x0400000f, 0x8058b040, 0x040207f9, - 0x497b5014, 0x42006000, 0xbf7fffff, 0x42006800, - 0x00018000, 0x0201f800, 0x0010427d, 0x42006000, - 0xfffeffff, 0x41786800, 0x0201f000, 0x0010427d, - 0x497b5014, 0x4a035012, 0x00000000, 0x80000580, - 0x0201f000, 0x00104289, 0x4a038805, 0xffffffff, - 0x59a80012, 0x82000c80, 0x00000004, 0x02021800, - 0x001005d8, 0x0c01f001, 0x00103ba9, 0x00103bd6, - 0x00103c4f, 0x4803c856, 0x59c400a3, 0x8400051e, - 0x480388a3, 0x4a035012, 0x00000001, 0x59c40008, - 0x8400054e, 0x48038808, 0x0201f800, 0x00104263, - 0x42007800, 0x0010b54c, 0x4a007806, 0x11010000, - 0x4200a000, 0x0010b402, 0x4200a800, 0x0010b553, - 0x4200b000, 0x00000002, 0x0201f800, 0x0010ab17, - 0x497b8802, 0x42000800, 0x00000003, 0x497b504a, - 0x0201f800, 0x0010416e, 0x4a03504a, 0x00000001, - 0x497b5016, 0x0201f800, 0x00104290, 0x42006000, - 0xffffffff, 0x42006800, 0x00080000, 0x0201f800, - 0x0010427d, 0x42006000, 0xfff7ffff, 0x41786800, - 0x0201f000, 0x0010427d, 0x59a80016, 0x497b5016, - 0x80002540, 0x04000066, 0x59c40004, 0x82000500, - 0x00000003, 0x04020071, 0x59a80815, 0x8c040d02, - 0x0400004b, 0x82100580, 0x0000000c, 0x0402004f, - 0x82100400, 0x00000018, 0x8000b104, 0x41cc1000, - 0x42001800, 0x0010b54c, 0x50080800, 0x500c0000, - 0x80040580, 0x0402001a, 0x80081000, 0x800c1800, - 0x8058b040, 0x040207f9, 0x0201f800, 0x00104290, - 0x42006000, 0xffffffff, 0x42006800, 0x00500000, - 0x0201f800, 0x0010427d, 0x4a035012, 0x00000002, - 0x4a035014, 0x00000002, 0x42000800, 0x000007d0, - 0x42001000, 0x00104148, 0x0201f800, 0x0010606e, - 0x0201f800, 0x00104263, 0x0401f048, 0x59cc0806, - 0x82040d80, 0x11010000, 0x04020028, 0x59cc0800, - 0x82040500, 0x00ffffff, 0x0400001a, 0x82000580, - 0x000000ef, 0x04020017, 0x59cc0801, 0x82040500, - 0x00ffffff, 0x82000580, 0x000000ef, 0x04020011, - 0x83cca400, 0x00000007, 0x4200a800, 0x0010b402, - 0x4200b000, 0x00000002, 0x50500800, 0x50540000, - 0x80040480, 0x04001007, 0x04020010, 0x8050a000, - 0x8054a800, 0x8058b040, 0x040207f8, 0x0401f00b, - 0x59a80015, 0x84000502, 0x48035015, 0x41cca000, - 0x4200a800, 0x0010b54c, 0x4200b000, 0x00000009, - 0x0201f800, 0x0010ab17, 0x0201f800, 0x00104290, - 0x42006000, 0xffffffff, 0x42006800, 0x00080000, - 0x0201f800, 0x0010427d, 0x42006000, 0xfff7ffff, - 0x41786800, 0x0201f800, 0x0010427d, 0x42006000, - 0xffffffff, 0x42006800, 0x00004000, 0x0201f800, - 0x0010427d, 0x59c40004, 0x82000500, 0x00000003, - 0x04020006, 0x497b5016, 0x42000800, 0x00000003, - 0x0201f000, 0x0010416e, 0x1c01f000, 0x1c01f000, - 0x59a80014, 0x82006d80, 0x0000000f, 0x04000005, - 0x82000580, 0x0000001b, 0x02020800, 0x00104139, - 0x1c01f000, 0x59a80015, 0x84000506, 0x48035015, - 0x497b504a, 0x59a80014, 0x82000c80, 0x0000001e, - 0x02021800, 0x001005d8, 0x0c01f001, 0x00103c97, - 0x00103cac, 0x00103cd5, 0x00103cf0, 0x00103d14, - 0x00103d45, 0x00103d68, 0x00103d9b, 0x00103dbe, - 0x00103de4, 0x00103e21, 0x00103e48, 0x00103e5f, - 0x00103e71, 0x00103e8a, 0x00103ea0, 0x00103ea5, - 0x00103ecd, 0x00103ef0, 0x00103f16, 0x00103f39, - 0x00103f6c, 0x00103fae, 0x00103fd8, 0x00103ff0, - 0x00104030, 0x00104049, 0x0010405c, 0x0010405d, - 0x4803c856, 0x4202d800, 0x00000007, 0x0201f800, - 0x0010513b, 0x04000007, 0x42006000, 0xffffffd7, - 0x41786800, 0x0201f800, 0x0010427d, 0x0401f00b, - 0x59c40006, 0x82000500, 0xffffff0f, 0x48038806, - 0x42001000, 0x000000f0, 0x0201f800, 0x0010193d, - 0x0201f800, 0x00105098, 0x1c01f000, 0x4803c856, - 0x42006000, 0xbf7fffff, 0x42006800, 0x00400000, - 0x0201f800, 0x0010427d, 0x4a035014, 0x00000001, - 0x42001000, 0x001041f3, 0x0201f800, 0x00105fa4, - 0x0201f800, 0x001041f8, 0x42000800, 0x000007d0, - 0x42001000, 0x00104148, 0x0201f000, 0x0010606e, - 0x59a80016, 0x82000580, 0x00000014, 0x04020025, - 0x4803c857, 0x42006000, 0xffbfffff, 0x41786800, - 0x0201f800, 0x0010427d, 0x59c40004, 0x82000500, - 0x00000003, 0x0402001b, 0x59cc1006, 0x82081580, - 0x11020000, 0x04020016, 0x59cc1007, 0x8c08153e, - 0x0400000b, 0x59a80015, 0x8c000504, 0x04020008, - 0x42000000, 0x0010b83f, 0x0201f800, 0x0010aa47, - 0x59a80015, 0x84000544, 0x48035015, 0x42001000, - 0x00104148, 0x0201f800, 0x00105f90, 0x4a035014, - 0x00000010, 0x0401f9d4, 0x0401f002, 0x497b5016, - 0x1c01f000, 0x4803c856, 0x4a035014, 0x00000003, - 0x42006000, 0xbf3fffff, 0x42006800, 0x00100000, - 0x0201f800, 0x0010427d, 0x42001000, 0x001041f3, - 0x0201f800, 0x00105fa4, 0x0201f800, 0x001041f8, - 0x42001000, 0x00104148, 0x0201f800, 0x00105f90, - 0x42007800, 0x0010b552, 0x46007800, 0x11020000, - 0x42000800, 0x00000005, 0x0201f000, 0x0010416e, - 0x59a80016, 0x80000540, 0x04000021, 0x4803c857, - 0x42001000, 0x00104148, 0x0201f800, 0x00105f90, - 0x59a80016, 0x82000580, 0x00000014, 0x04020016, - 0x59cc1006, 0x82081580, 0x11020000, 0x04020012, - 0x59cc1007, 0x8c08153e, 0x0400000b, 0x59a80015, - 0x8c000504, 0x04020008, 0x42000000, 0x0010b83f, - 0x0201f800, 0x0010aa47, 0x59a80015, 0x84000544, - 0x48035015, 0x4a035014, 0x00000004, 0x0401f805, - 0x0401f003, 0x0201f800, 0x00104139, 0x1c01f000, - 0x4803c856, 0x4a035014, 0x00000005, 0x83cca400, - 0x00000006, 0x4200a800, 0x0010b552, 0x4200b000, - 0x00000005, 0x0201f800, 0x0010ab17, 0x42007800, - 0x0010b552, 0x46007800, 0x11030000, 0x0201f800, - 0x0010413e, 0x04020014, 0x59a80015, 0x8c000500, - 0x04020011, 0x59a80810, 0x82040580, 0x00ffffff, - 0x0400000d, 0x82040d00, 0x000000ff, 0x82040400, - 0x0010210e, 0x50000800, 0x80040910, 0x42001000, - 0x00000004, 0x0401fb9b, 0x0400000b, 0x0201f800, - 0x0010420d, 0x4200b000, 0x00000004, 0x83cca400, - 0x00000007, 0x4200a800, 0x0010b553, 0x0201f800, - 0x0010ab17, 0x42000800, 0x00000005, 0x0201f000, - 0x0010416e, 0x59a80016, 0x80000540, 0x04000020, - 0x4803c857, 0x42001000, 0x00104148, 0x0201f800, - 0x00105f90, 0x59a80016, 0x82000580, 0x00000014, - 0x04020016, 0x59cc1006, 0x82081580, 0x11030000, - 0x04020012, 0x59cc1007, 0x8c08153e, 0x0400000b, - 0x59a80015, 0x8c000504, 0x04020008, 0x42000000, - 0x0010b83f, 0x0201f800, 0x0010aa47, 0x59a80015, - 0x84000544, 0x48035015, 0x4a035014, 0x00000006, - 0x0401f804, 0x0401f002, 0x0401fbd3, 0x1c01f000, - 0x4803c856, 0x4a035014, 0x00000007, 0x83cca400, - 0x00000006, 0x4200a800, 0x0010b552, 0x4200b000, - 0x00000005, 0x0201f800, 0x0010ab17, 0x42007800, - 0x0010b552, 0x46007800, 0x11040000, 0x0401fbc7, - 0x04020020, 0x59a80015, 0x8c000500, 0x0402001d, - 0x599c0017, 0x8c000500, 0x0400001a, 0x599c1402, - 0x82080480, 0x0000007f, 0x02021800, 0x001005d8, - 0x4c080000, 0x82081400, 0x0010210e, 0x50081000, - 0x82081500, 0x000000ff, 0x480b5010, 0x42000800, - 0x00000003, 0x0201f800, 0x00106c78, 0x5c000800, - 0x42001000, 0x00000004, 0x0401fb3e, 0x04000005, - 0x0401fd2b, 0x04000003, 0x0201f800, 0x001015fe, - 0x42000800, 0x00000005, 0x0401f3d4, 0x59a80016, - 0x80000540, 0x04000020, 0x4803c857, 0x42001000, - 0x00104148, 0x0201f800, 0x00105f90, 0x59a80016, - 0x82000580, 0x00000014, 0x04020016, 0x59cc1006, - 0x82081580, 0x11040000, 0x04020012, 0x59cc1007, - 0x8c08153e, 0x0400000b, 0x59a80015, 0x8c000504, - 0x04020008, 0x42000000, 0x0010b83f, 0x0201f800, - 0x0010aa47, 0x59a80015, 0x84000544, 0x48035015, - 0x4a035014, 0x00000008, 0x0401f804, 0x0401f002, - 0x0401fb7d, 0x1c01f000, 0x4803c856, 0x4a035014, - 0x00000009, 0x83cca400, 0x00000006, 0x4200a800, - 0x0010b552, 0x4200b000, 0x00000005, 0x0201f800, - 0x0010ab17, 0x42007800, 0x0010b552, 0x46007800, - 0x11050100, 0x0401fb71, 0x0402000a, 0x59a80015, - 0x8c000500, 0x04020007, 0x0401fa8c, 0x04020005, - 0x82000540, 0x00000001, 0x0201f800, 0x001015fe, - 0x42000800, 0x00000005, 0x0401fb94, 0x0401fb63, - 0x04020ea4, 0x4d3c0000, 0x42027800, 0x00000001, - 0x0201f800, 0x00109874, 0x5c027800, 0x1c01f000, - 0x59a80016, 0x80000540, 0x0400003a, 0x4803c857, - 0x42001000, 0x00104148, 0x0201f800, 0x00105f90, - 0x59a80016, 0x82000580, 0x00000014, 0x04020030, - 0x59cc1006, 0x82080500, 0x11050000, 0x82000580, - 0x11050000, 0x0402002a, 0x8c081510, 0x04000014, - 0x59cc1007, 0x8c08153e, 0x0400000b, 0x59a80015, - 0x8c000504, 0x04020008, 0x42000000, 0x0010b83f, - 0x0201f800, 0x0010aa47, 0x59a80015, 0x84000544, - 0x48035015, 0x4a035013, 0x00000001, 0x4a035014, - 0x0000000a, 0x0401f818, 0x0401f016, 0x80000540, - 0x04020013, 0x59cc1007, 0x8c08153e, 0x0400000b, - 0x59a80015, 0x8c000504, 0x04020008, 0x42000000, - 0x0010b83f, 0x0201f800, 0x0010aa47, 0x59a80015, - 0x84000544, 0x48035015, 0x497b5013, 0x4a035014, - 0x0000000e, 0x0401f86d, 0x0401f002, 0x0401fb1a, - 0x1c01f000, 0x4803c856, 0x4a035014, 0x0000000b, - 0x42001000, 0x0010b553, 0x4008a800, 0x4200b000, - 0x00000020, 0x4600a800, 0xffffffff, 0x8054a800, - 0x8058b040, 0x040207fc, 0x42007800, 0x0010b552, - 0x46007800, 0x11060000, 0x42001000, 0x0010b553, - 0x0401fb0a, 0x04000005, 0x50080000, 0x46001000, - 0x00ffffff, 0x0401f00c, 0x50080800, 0x82040d00, - 0x0000ffff, 0x59a80010, 0x82000500, 0x000000ff, - 0x82000540, 0x00000100, 0x800000e0, 0x80040d40, - 0x44041000, 0x42000800, 0x00000021, 0x0401f327, - 0x59a80016, 0x80000540, 0x04000014, 0x4803c857, - 0x59a80016, 0x42001000, 0x00104148, 0x0201f800, - 0x00105f90, 0x59a80016, 0x82000580, 0x00000084, - 0x04020009, 0x59cc1006, 0x82081580, 0x11060000, - 0x04020005, 0x4a035014, 0x0000000c, 0x0401f804, - 0x0401f002, 0x0401fadc, 0x1c01f000, 0x4803c856, - 0x4a035014, 0x0000000d, 0x83cca400, 0x00000006, - 0x4200a800, 0x0010b552, 0x4200b000, 0x00000021, - 0x0201f800, 0x0010ab17, 0x42007800, 0x0010b552, - 0x46007800, 0x11070000, 0x42000800, 0x00000021, - 0x0401f2fe, 0x59a80016, 0x80000540, 0x04000016, - 0x4803c857, 0x59a80016, 0x42001000, 0x00104148, - 0x0201f800, 0x00105f90, 0x82000580, 0x00000084, - 0x0402000c, 0x59cc1006, 0x82081580, 0x11070000, - 0x04020008, 0x4a035013, 0x00000001, 0x0401fa91, - 0x4a035014, 0x0000000e, 0x0401f804, 0x0401f002, - 0x0401fab1, 0x1c01f000, 0x4803c856, 0x82040d40, - 0x00000001, 0x0401fbfc, 0x4a035014, 0x0000000f, - 0x497b5016, 0x42006000, 0xffffffff, 0x42006800, - 0x00300000, 0x0401fbe8, 0x42006000, 0xffdfffff, - 0x41786800, 0x0401fbe4, 0x42000800, 0x000007d0, - 0x42001000, 0x00104148, 0x0201f000, 0x00105f69, - 0x4803c856, 0x59a80016, 0x80000540, 0x04020296, - 0x1c01f000, 0x4803c856, 0x4a035014, 0x00000011, - 0x83cca400, 0x00000006, 0x4200a800, 0x0010b552, - 0x4200b000, 0x00000005, 0x0201f800, 0x0010ab17, - 0x4200a800, 0x0010b552, 0x4600a800, 0x11020000, - 0x0401fa8a, 0x04020015, 0x59a80010, 0x82000d00, - 0xffff0000, 0x04000011, 0x82000500, 0x000000ff, - 0x0400000e, 0x82000c00, 0x0010210e, 0x50040800, - 0x80040910, 0x82040580, 0x0000007e, 0x04000007, - 0x82040580, 0x00000080, 0x04000004, 0x42001000, - 0x00000004, 0x0401fa07, 0x42000800, 0x00000005, - 0x0401f2a2, 0x59a80016, 0x80000540, 0x04000020, - 0x4803c857, 0x42001000, 0x00104148, 0x0201f800, - 0x00105f90, 0x59a80016, 0x82000580, 0x00000014, - 0x04020016, 0x59cc1006, 0x82081580, 0x11030000, - 0x04020012, 0x59cc1007, 0x8c08153e, 0x0400000b, - 0x59a80015, 0x8c000504, 0x04020008, 0x42000000, - 0x0010b83f, 0x0201f800, 0x0010aa47, 0x59a80015, - 0x84000544, 0x48035015, 0x4a035014, 0x00000012, - 0x0401f804, 0x0401f002, 0x0401fa4b, 0x1c01f000, - 0x4803c856, 0x4a035014, 0x00000013, 0x83cca400, - 0x00000006, 0x4200a800, 0x0010b552, 0x4200b000, - 0x00000005, 0x0201f800, 0x0010ab17, 0x4200a800, - 0x0010b552, 0x4600a800, 0x11030000, 0x0401fa3f, - 0x04020013, 0x59a80015, 0x8c000500, 0x04020010, - 0x59a80810, 0x82040580, 0x00ffffff, 0x0400000c, - 0x82040d00, 0x000000ff, 0x82040400, 0x0010210e, - 0x50000800, 0x80040910, 0x42001000, 0x00000004, - 0x0401f9c0, 0x04000002, 0x0401fafb, 0x42000800, - 0x00000005, 0x0401f259, 0x59a80016, 0x80000540, - 0x04000020, 0x4803c857, 0x42001000, 0x00104148, - 0x0201f800, 0x00105f90, 0x59a80016, 0x82000580, - 0x00000014, 0x04020016, 0x59cc1006, 0x82081580, - 0x11040000, 0x04020012, 0x59cc1007, 0x8c08153e, - 0x0400000b, 0x59a80015, 0x8c000504, 0x04020008, - 0x42000000, 0x0010b83f, 0x0201f800, 0x0010aa47, - 0x59a80015, 0x84000544, 0x48035015, 0x4a035014, - 0x00000014, 0x0401f804, 0x0401f002, 0x0401fa02, - 0x1c01f000, 0x4803c856, 0x4a035014, 0x00000015, - 0x83cca400, 0x00000006, 0x4200a800, 0x0010b552, - 0x4200b000, 0x00000005, 0x0201f800, 0x0010ab17, - 0x4200a800, 0x0010b552, 0x4600a800, 0x11040000, - 0x0401f9f6, 0x04020020, 0x59a80015, 0x8c000500, - 0x0402001d, 0x599c0017, 0x8c000500, 0x0400001a, - 0x599c1402, 0x82080480, 0x0000007f, 0x02021800, - 0x001005d8, 0x4c080000, 0x82081400, 0x0010210e, - 0x50081000, 0x82081500, 0x000000ff, 0x480b5010, - 0x42000800, 0x00000003, 0x0201f800, 0x00106c78, - 0x5c000800, 0x42001000, 0x00000004, 0x0401f96d, - 0x04000005, 0x0201f800, 0x00103abf, 0x02020800, - 0x001015fe, 0x42000800, 0x00000005, 0x0401f203, - 0x59a80016, 0x80000540, 0x0400003f, 0x4803c857, - 0x42001000, 0x00104148, 0x0201f800, 0x00105f90, - 0x59a80016, 0x82000580, 0x00000014, 0x04020035, - 0x59cc1006, 0x82080500, 0x11050000, 0x82000580, - 0x11050000, 0x0402002f, 0x8c081510, 0x04000010, - 0x0401fb09, 0x59cc1007, 0x8c08153e, 0x0400000b, - 0x59a80015, 0x8c000504, 0x04020008, 0x42000000, - 0x0010b83f, 0x0201f800, 0x0010aa47, 0x59a80015, - 0x84000544, 0x48035015, 0x0401f013, 0x59cc1007, - 0x8c08153e, 0x0400000b, 0x59a80015, 0x8c000504, - 0x04020008, 0x42000000, 0x0010b83f, 0x0201f800, - 0x0010aa47, 0x59a80015, 0x84000544, 0x48035015, - 0x82000540, 0x00000001, 0x0401faeb, 0x497b5013, - 0x0401f003, 0x4a035013, 0x00000001, 0x59cc1007, - 0x8c08153c, 0x04000003, 0x4a035026, 0x00000008, - 0x4a035014, 0x00000016, 0x0401f804, 0x0401f002, - 0x0401f98d, 0x1c01f000, 0x4803c856, 0x83cca400, - 0x00000006, 0x4200a800, 0x0010b552, 0x4200b000, - 0x00000005, 0x0201f800, 0x0010ab17, 0x4a035014, - 0x00000017, 0x59a80013, 0x8c000500, 0x04000006, - 0x42001000, 0x0010b552, 0x46001000, 0x11050100, - 0x0401f003, 0x4a035014, 0x0000001b, 0x0401f97b, - 0x0402000a, 0x59a80015, 0x8c000500, 0x04020007, - 0x0401f896, 0x04020005, 0x82000540, 0x00000001, - 0x0201f800, 0x001015fe, 0x42000800, 0x00000005, - 0x0401f99e, 0x4d3c0000, 0x42027800, 0x00000001, - 0x0201f800, 0x00109874, 0x5c027800, 0x1c01f000, - 0x59a80016, 0x80000540, 0x04000015, 0x4803c857, - 0x42001000, 0x00104148, 0x0201f800, 0x00105f90, - 0x59a80016, 0x82000580, 0x00000084, 0x0402000b, - 0x59cc1006, 0x82081580, 0x11060000, 0x04020007, - 0x80000580, 0x0401faa0, 0x4a035014, 0x00000018, - 0x0401f804, 0x0401f002, 0x0401f94b, 0x1c01f000, - 0x4803c856, 0x4a035014, 0x00000019, 0x83cca400, - 0x00000006, 0x4200a800, 0x0010b552, 0x4200b000, - 0x00000021, 0x0201f800, 0x0010ab17, 0x42003800, - 0x0010b553, 0x0401f941, 0x04020018, 0x401c2800, - 0x50141000, 0x80080130, 0x80000000, 0x40001800, - 0x82081500, 0x00ffffff, 0x800000f0, 0x80080540, - 0x44002800, 0x59a80810, 0x82040d00, 0x000000ff, - 0x400c1000, 0x80081104, 0x82082400, 0x0010b553, - 0x50101000, 0x820c0500, 0x00000003, 0x0c01f806, - 0x80081540, 0x44082000, 0x42000800, 0x00000021, - 0x0401f156, 0x0010401d, 0x00104022, 0x00104027, - 0x0010402c, 0x800408f0, 0x40040000, 0x82081500, - 0x00ffffff, 0x1c01f000, 0x800408e0, 0x40040000, - 0x82081500, 0xff00ffff, 0x1c01f000, 0x800408d0, - 0x40040000, 0x82081500, 0xffff00ff, 0x1c01f000, - 0x40040000, 0x82081500, 0xffffff00, 0x1c01f000, - 0x59a80016, 0x80000540, 0x04000016, 0x4803c857, - 0x42001000, 0x00104148, 0x0201f800, 0x00105f90, - 0x59a80016, 0x82000580, 0x00000084, 0x0402000c, - 0x59cc1006, 0x82081580, 0x11070000, 0x04020008, - 0x4a035013, 0x00000001, 0x0401f8d2, 0x4a035014, - 0x0000001a, 0x0401f804, 0x0401f002, 0x0401f8f2, - 0x1c01f000, 0x82000540, 0x00000001, 0x0401fa3e, - 0x4a035014, 0x0000001b, 0x83cca400, 0x00000006, - 0x4200a800, 0x0010b552, 0x59a82016, 0x40100000, - 0x8000b104, 0x40580800, 0x5450a800, 0x8050a000, - 0x8054a800, 0x8058b040, 0x040207fc, 0x0401f113, - 0x1c01f000, 0x1c01f000, 0x4803c856, 0x42003000, - 0x00000004, 0x42004000, 0x0010b553, 0x599c2817, - 0x8c142d14, 0x0402001f, 0x42001000, 0x00000003, - 0x40200000, 0x80080400, 0x50000800, 0x82042580, - 0xffffffff, 0x04020005, 0x80081040, 0x80183040, - 0x040207f8, 0x0401f05e, 0x800811c0, 0x04020006, - 0x82042580, 0x3fffffff, 0x04000058, 0x82040d40, - 0xc0000000, 0x4200b000, 0x00000020, 0x42001800, - 0x00000001, 0x40042000, 0x80102102, 0x04021021, - 0x800c18c2, 0x8058b040, 0x040207fc, 0x0401f04b, - 0x41781000, 0x40200000, 0x80080400, 0x50000800, - 0x82042580, 0xffffffff, 0x04020005, 0x80081000, - 0x80183040, 0x040207f8, 0x0401f040, 0x800811c0, - 0x04020003, 0x82040d40, 0xc0000000, 0x4200b000, - 0x00000001, 0x42001800, 0x80000000, 0x40042000, - 0x801020c2, 0x04021007, 0x800c1902, 0x8058b000, - 0x82580480, 0x00000021, 0x040017fa, 0x0401f02f, - 0x40200000, 0x80082400, 0x50100000, 0x800c0540, - 0x44002000, 0x59a80015, 0x84000540, 0x48035015, - 0x40580000, 0x42002800, 0x00000020, 0x80142c80, - 0x40080000, 0x42003800, 0x00000003, 0x801c0480, - 0x800000ca, 0x80142d40, 0x82144c00, 0x0010210e, - 0x50242800, 0x82142d00, 0x000000ff, 0x48175010, - 0x4c040000, 0x40140800, 0x0201f800, 0x001015eb, - 0x5c000800, 0x40001800, 0x500c0000, 0x80100540, - 0x44001800, 0x59a80015, 0x84000540, 0x48035015, - 0x4200a800, 0x0010b553, 0x4020a000, 0x4200b000, - 0x00000004, 0x0201f800, 0x0010ab17, 0x82000540, - 0x00000001, 0x0401f002, 0x80000580, 0x1c01f000, - 0x4807c857, 0x480bc857, 0x4008b000, 0x83cca400, - 0x00000007, 0x4200a800, 0x0010b553, 0x40541000, - 0x0201f800, 0x0010ab17, 0x40041800, 0x41782000, - 0x42000000, 0x00000003, 0x820c1c80, 0x00000020, - 0x04001004, 0x80102000, 0x80000040, 0x0401f7fb, - 0x40041800, 0x801021c0, 0x04000005, 0x820c1c80, - 0x00000020, 0x80102040, 0x040207fd, 0x42002000, - 0x00000001, 0x800c19c0, 0x04000004, 0x801020c2, - 0x800c1840, 0x040207fe, 0x80083c00, 0x83cc2c00, - 0x00000007, 0x80142c00, 0x50140000, 0x80102d00, - 0x04020012, 0x80100540, 0x44003800, 0x82042400, - 0x0010210e, 0x50102800, 0x82142d00, 0x000000ff, - 0x48175010, 0x4c040000, 0x40140800, 0x0201f800, - 0x001015eb, 0x5c000800, 0x59a80015, 0x84000540, - 0x48035015, 0x80000580, 0x1c01f000, 0x4807c856, - 0x42001000, 0x00008017, 0x59a8184e, 0x0201f800, - 0x0010aa4f, 0x0201f800, 0x00103a3e, 0x1c01f000, - 0x4807c856, 0x4200b000, 0x00000020, 0x83cca400, - 0x00000007, 0x4200a800, 0x0010be21, 0x0201f000, - 0x0010ab28, 0x4807c856, 0x0201f800, 0x00106ede, - 0x42000800, 0x000000f7, 0x0401f8de, 0x497b2804, - 0x497b2805, 0x497b281c, 0x497b281d, 0x4202d800, - 0x00000001, 0x42006000, 0xbf7fffff, 0x42006800, - 0x00018000, 0x0401f950, 0x42006000, 0xfffeffff, - 0x41786800, 0x0401f94c, 0x497b504e, 0x42000800, - 0x0000002d, 0x42001000, 0x001041bc, 0x0201f000, - 0x00105f69, 0x4807c856, 0x0401ffe3, 0x497b5014, - 0x497b5016, 0x1c01f000, 0x4807c856, 0x59a80005, - 0x8c000506, 0x1c01f000, 0x4807c856, 0x42006000, - 0xffffffff, 0x42006800, 0x00000028, 0x0401f136, - 0x4807c856, 0x0401ffc2, 0x0201f800, 0x00106c55, - 0x4df00000, 0x0201f800, 0x00106e21, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x59c400a4, 0x82000500, - 0x0000000f, 0x82000580, 0x00000002, 0x0402000a, - 0x42006000, 0xffffffff, 0x42006800, 0x00200000, - 0x0401f921, 0x42006000, 0xffdfffff, 0x41786800, - 0x0401f91d, 0x497b5014, 0x42000800, 0x000000f7, - 0x0401f89c, 0x59c400a3, 0x82000500, 0xbf20bfff, - 0x82000540, 0x0001c000, 0x480388a3, 0x84000520, - 0x480388a3, 0x1c01f000, 0x497b5016, 0x59b400f5, - 0x8c000500, 0x04020004, 0x82000540, 0x00000001, - 0x480368f5, 0x800400c4, 0x82000400, 0x00002000, - 0x4803910a, 0x59b400f6, 0x82000500, 0x00000018, - 0x040207fd, 0x4a0368f0, 0x0010b54b, 0x42000000, - 0x0010b552, 0x480368f1, 0x82040400, 0x0000dc00, - 0x480368f3, 0x59c400a4, 0x82000500, 0x0000000f, - 0x82000580, 0x00000008, 0x04020017, 0x4c5c0000, - 0x4c600000, 0x59c4b805, 0x8c5cbd3a, 0x04020005, - 0x42000000, 0x0010b818, 0x0201f800, 0x0010aa47, - 0x4a038805, 0x02000000, 0x0201f800, 0x001019fe, - 0x4000c000, 0x0201f800, 0x00101963, 0x4202d800, - 0x00000001, 0x497b5014, 0x5c00c000, 0x5c00b800, - 0x1c01f000, 0x59c8010b, 0x8c000502, 0x040007e2, - 0x59c408a4, 0x82040d00, 0x0000000f, 0x82040d80, - 0x0000000b, 0x04020005, 0x59a80814, 0x82040d40, - 0x00002000, 0x0401f004, 0x59a80812, 0x82040d40, - 0x00001000, 0x4807504e, 0x59a8084a, 0x800409c0, - 0x04020007, 0x42000800, 0x000007d0, 0x42001000, - 0x00104148, 0x0201f800, 0x0010606e, 0x1c01f000, - 0x4807c856, 0x0401ff4e, 0x0201f800, 0x00106c55, - 0x4df00000, 0x0201f800, 0x00106e21, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x59c400a4, 0x82000500, - 0x0000000f, 0x82000580, 0x00000002, 0x0402000a, - 0x42006000, 0xffffffff, 0x42006800, 0x00200000, - 0x0401f8ad, 0x42006000, 0xffdfffff, 0x41786800, - 0x0401f8a9, 0x0201f800, 0x00105141, 0x04000014, - 0x0201f800, 0x00105151, 0x04020011, 0x4a035032, - 0x0000aaaa, 0x4c040000, 0x0201f800, 0x0010162a, - 0x59a8002a, 0x82000500, 0xffff0000, 0x80040540, - 0x4803502a, 0x5c000800, 0x4a035033, 0x00000000, - 0x0201f800, 0x001050a2, 0x0401f008, 0x4a03504c, - 0x00000005, 0x42000000, 0x00000001, 0x0201f800, - 0x00101590, 0x0401ff2c, 0x1c01f000, 0x0401f805, - 0x42006000, 0xbf7f7fff, 0x41786800, 0x0401f086, - 0x0201f800, 0x00105151, 0x04020005, 0x59c40006, - 0x82000540, 0x000000f0, 0x48038806, 0x1c01f000, - 0x800408d0, 0x59a80015, 0x8c000506, 0x04000006, - 0x59a80010, 0x82000500, 0x000000ff, 0x80040540, - 0x0401f003, 0x82040540, 0x000000f7, 0x480388a7, - 0x1c01f000, 0x4807c856, 0x42000000, 0x0010b83b, - 0x0201f800, 0x0010aa47, 0x42003000, 0x00000005, - 0x4d3c0000, 0x4c180000, 0x42003000, 0x0000000d, - 0x42027800, 0x00000002, 0x0401f038, 0x4807c856, - 0x42000000, 0x0010b86b, 0x0201f800, 0x0010aa47, - 0x42003000, 0x00000000, 0x4d3c0000, 0x4c180000, - 0x42003000, 0x0000000f, 0x42027800, 0x00000002, - 0x0401f02a, 0x4807c856, 0x42000000, 0x0010b86a, - 0x0201f800, 0x0010aa47, 0x42003000, 0x00000003, - 0x4d3c0000, 0x4c180000, 0x42003000, 0x0000000e, - 0x42027800, 0x00000202, 0x0401f01c, 0x4807c856, - 0x42000000, 0x0010b869, 0x0201f800, 0x0010aa47, - 0x42003000, 0x00000004, 0x4d3c0000, 0x4c180000, - 0x42003000, 0x00000010, 0x42027800, 0x00000202, - 0x0401f00e, 0x4807c856, 0x42000000, 0x0010b83e, - 0x0201f800, 0x0010aa47, 0x42003000, 0x00000001, - 0x4d3c0000, 0x4c180000, 0x42003000, 0x0000000c, - 0x42027800, 0x00000202, 0x42001800, 0x0000ffff, - 0x42002000, 0x00000007, 0x0201f800, 0x00103aae, - 0x5c003000, 0x4d400000, 0x0201f800, 0x0010a95d, - 0x42028000, 0x0000002a, 0x0201f800, 0x00101fe5, - 0x5c028000, 0x5c027800, 0x1c01f000, 0x4807c856, - 0x04011000, 0x4a03c840, 0x0010b54b, 0x4a03c842, - 0x00000040, 0x40000000, 0x040117ff, 0x42007800, - 0x0010b54b, 0x46007800, 0x00000011, 0x803c7800, - 0x4a007800, 0x220000ef, 0x4a007801, 0x000000ef, - 0x4a007802, 0x01380000, 0x4a007803, 0x00000000, - 0x4a007804, 0xffffffff, 0x4a007805, 0x00000000, - 0x1c01f000, 0x59c400a3, 0x80300500, 0x80340540, - 0x480388a3, 0x1c01f000, 0x4833c857, 0x59c400a3, - 0x80300540, 0x480388a3, 0x80300580, 0x480388a3, - 0x1c01f000, 0x4803c856, 0x04000004, 0x4a03504b, - 0x00000001, 0x0401f002, 0x497b504b, 0x1c01f000, - 0x4803c856, 0x59c80002, 0x80000540, 0x0400000a, - 0x80000040, 0x04000008, 0x4a039005, 0x00000140, - 0x42000000, 0x00000006, 0x80000040, 0x040207ff, - 0x0401f7f4, 0x1c01f000, 0x4c5c0000, 0x4c600000, - 0x59c4b805, 0x485fc856, 0x8c5cbd3a, 0x04020005, - 0x42000000, 0x0010b818, 0x0201f800, 0x0010aa47, - 0x4a038805, 0x02000000, 0x0201f800, 0x001019fe, - 0x4000c000, 0x0201f800, 0x00101963, 0x4a038805, - 0x04000000, 0x5c00c000, 0x5c00b800, 0x1c01f000, - 0x497a6a00, 0x4937c857, 0x4a026c00, 0x00000707, - 0x497a6801, 0x497a6808, 0x497a6809, 0x497a6806, - 0x497a6807, 0x497a6c0b, 0x497a680c, 0x0201f800, - 0x00103b25, 0x04020006, 0x5934080f, 0x59340010, - 0x80040540, 0x02020800, 0x001005d8, 0x4a026a04, - 0x00000100, 0x497a6a03, 0x59340402, 0x82000500, - 0x000000ff, 0x48026c02, 0x497a6c04, 0x497a6a05, - 0x497a6c05, 0x497a6811, 0x4d2c0000, 0x5934000d, - 0x49466c03, 0x80025d40, 0x04000004, 0x0201f800, - 0x001007fd, 0x497a680d, 0x5c025800, 0x599c0401, - 0x48026a0b, 0x599c0208, 0x48026c12, 0x497a680a, - 0x0201f000, 0x00104c62, 0x42000000, 0x00000005, - 0x80000d80, 0x0401f02d, 0x0201f800, 0x00104a09, - 0x04020017, 0x59a80026, 0x8c00050a, 0x04020010, - 0x59340212, 0x82000500, 0x0000ff00, 0x4803c857, - 0x0400000b, 0x59340a00, 0x8c040d1e, 0x02000000, - 0x000201c4, 0x42000000, 0x00000029, 0x42000800, - 0x00001000, 0x492fc857, 0x0401f018, 0x492fc857, - 0x42000000, 0x00000028, 0x0401f012, 0x59a80805, - 0x8c040d02, 0x04020003, 0x8c040d00, 0x04000004, - 0x42000000, 0x00000004, 0x0401f00a, 0x42000000, - 0x00000029, 0x59340a00, 0x8c040d1e, 0x04000005, - 0x492fc857, 0x42000800, 0x00001000, 0x0401f003, - 0x492fc857, 0x80000d80, 0x4803c857, 0x80028540, - 0x1c01f000, 0x4803c857, 0x59a80005, 0x8c000500, - 0x040207ec, 0x0201f800, 0x001049e7, 0x040207e4, - 0x59340200, 0x8c00050e, 0x040007e1, 0x0201f000, - 0x000201c4, 0x0201f800, 0x001047eb, 0x040007bf, - 0x0201f000, 0x000201c8, 0x592c0206, 0x492fc857, - 0x82000d80, 0x000007ff, 0x04020006, 0x4a025c0a, - 0x00000030, 0x42026800, 0x0010b524, 0x0401f021, - 0x82000c80, 0x000007f0, 0x04021046, 0x81ac0400, - 0x50000000, 0x80026d40, 0x04000038, 0x0201f800, - 0x001048e3, 0x04020038, 0x592c040a, 0x8c00050a, - 0x04020014, 0x592e6009, 0x83300480, 0x0010d1c0, - 0x0400103b, 0x41580000, 0x81300480, 0x04021038, - 0x59300c06, 0x82040580, 0x00000009, 0x04020037, - 0x4a025a06, 0x00000000, 0x497a5800, 0x59300008, - 0x80000540, 0x04020018, 0x492e6008, 0x0401f010, - 0x0201f800, 0x0002075a, 0x04000019, 0x592c0206, - 0x49366009, 0x492e6008, 0x4a026406, 0x00000009, - 0x497a6015, 0x49325809, 0x82000d80, 0x000007ff, - 0x04020003, 0x4a026015, 0x00008000, 0x42027000, - 0x00000043, 0x0201f800, 0x000207a1, 0x80000580, - 0x0401f020, 0x40000800, 0x58040000, 0x80000d40, - 0x040207fd, 0x492c0800, 0x0401f01a, 0x42000000, - 0x0000002c, 0x0401f016, 0x42000000, 0x00000028, - 0x0401f013, 0x59a80805, 0x82040500, 0x00000003, - 0x04000004, 0x42000000, 0x00000004, 0x0401f00c, - 0x42000000, 0x00000029, 0x0401f009, 0x42000000, - 0x00000008, 0x0401f006, 0x82040580, 0x00000007, - 0x040207fb, 0x42000000, 0x00000005, 0x80000540, - 0x1c01f000, 0x492fc857, 0x592e8c06, 0x83440d80, - 0x000007fc, 0x04000004, 0x83440480, 0x000007f0, - 0x04021014, 0x0201f800, 0x00020245, 0x04020011, - 0x0201f800, 0x001049f3, 0x04020011, 0x0201f800, - 0x0002075a, 0x0400001c, 0x49366009, 0x492e6008, - 0x4a026406, 0x0000000a, 0x42027000, 0x00000040, - 0x0201f800, 0x000207a1, 0x80000580, 0x0401f011, - 0x42000000, 0x00000028, 0x0401f00d, 0x0201f800, - 0x00104a09, 0x040007fb, 0x59a80805, 0x82040d00, - 0x00000003, 0x04000004, 0x42000000, 0x00000004, - 0x0401f003, 0x42000000, 0x00000029, 0x80000540, - 0x1c01f000, 0x42000000, 0x0000002c, 0x0401f7fc, - 0x492fc857, 0x592e8c06, 0x4947c857, 0x83440c80, - 0x00000800, 0x42000000, 0x0000000a, 0x04021176, - 0x592c4207, 0x4823c857, 0x82200500, 0x0000000f, - 0x0c01f001, 0x001043d5, 0x0010445d, 0x001044a9, - 0x001044b4, 0x001044bf, 0x001043d1, 0x001043d1, - 0x001043d1, 0x001044cf, 0x00104513, 0x00104530, - 0x001043d1, 0x001043d1, 0x001043d1, 0x001043d1, - 0x001043d1, 0x4803c857, 0x42000000, 0x0000000c, - 0x0401f15d, 0x592c1008, 0x82081500, 0x00ffffff, - 0x59a80010, 0x80084d80, 0x42000000, 0x00000010, - 0x04000155, 0x0201f800, 0x00104919, 0x04000036, - 0x4803c857, 0x82004d80, 0x0000001d, 0x0402001a, - 0x0201f800, 0x00105755, 0x59340405, 0x4c000000, - 0x0201f800, 0x001049e7, 0x5c000000, 0x04000004, - 0x8c20450a, 0x04000028, 0x80000580, 0x44002800, - 0x59340008, 0x48002802, 0x59340009, 0x48002801, - 0x59340006, 0x48002804, 0x59340007, 0x48002803, - 0x4200b000, 0x00000005, 0x0201f800, 0x0010955f, - 0x0401f166, 0x4803c857, 0x82004d80, 0x0000001a, - 0x04020003, 0x40101000, 0x0401f136, 0x4803c857, - 0x82004d80, 0x0000001b, 0x04020003, 0x40181000, - 0x0401f130, 0x4803c857, 0x82004d80, 0x0000001c, - 0x04000131, 0x82004d80, 0x00000019, 0x42000000, - 0x0000000a, 0x04000120, 0x42000000, 0x0000000a, - 0x04020137, 0x59a80005, 0x8c000514, 0x0400001b, - 0x0201f800, 0x001049e7, 0x04000018, 0x59340212, - 0x82000500, 0x0000ff00, 0x42001000, 0x00000010, - 0x0402000c, 0x42001000, 0x00000008, 0x59a80026, - 0x8c000506, 0x04020009, 0x59340002, 0x82000500, - 0x00ff0000, 0x82000580, 0x00ff0000, 0x04000007, - 0x0201f800, 0x00104c6d, 0x42000000, 0x0000001c, - 0x40181000, 0x04020107, 0x0201f800, 0x0002075a, - 0x04000111, 0x49366009, 0x492e6008, 0x4a026406, - 0x00000001, 0x8c20450a, 0x04000004, 0x592c0404, - 0x8400055c, 0x48025c04, 0x4c200000, 0x4d3c0000, - 0x42027800, 0x00001000, 0x0201f800, 0x0010203c, - 0x5c027800, 0x5c004000, 0x8c204512, 0x0400000b, - 0x599c0018, 0x8c000518, 0x04000008, 0x592c0009, - 0x82000500, 0x00000380, 0x5934080a, 0x80040d40, - 0x84040d54, 0x4806680a, 0x417a7800, 0x0401f914, - 0x42000800, 0x00000003, 0x0401f91b, 0x42027000, - 0x00000002, 0x0201f800, 0x000207a1, 0x80000580, - 0x0401f10a, 0x0201f800, 0x00020245, 0x040200ec, - 0x0201f800, 0x001049ed, 0x04000008, 0x0201f800, - 0x001049e7, 0x040200ec, 0x417a7800, 0x417a6000, - 0x0201f800, 0x001020a1, 0x59a80005, 0x8c000514, - 0x0400001b, 0x0201f800, 0x001049e7, 0x04000018, - 0x59340212, 0x82000500, 0x0000ff00, 0x42001000, - 0x00000010, 0x0402000c, 0x42001000, 0x00000008, - 0x59a80026, 0x8c000506, 0x04020009, 0x59340002, - 0x82000500, 0x00ff0000, 0x82000580, 0x00ff0000, - 0x04000007, 0x0201f800, 0x00104c6d, 0x42000000, - 0x0000001c, 0x40181000, 0x040200b2, 0x0201f800, - 0x0002075a, 0x040000bc, 0x5934080a, 0x8c204512, - 0x0400000c, 0x599c0018, 0x8c000518, 0x04000009, - 0x592c0009, 0x82000500, 0x00000380, 0x82041500, - 0xfffffc7f, 0x80080d40, 0x84040d54, 0x0401f002, - 0x84040d14, 0x4806680a, 0x49366009, 0x492e6008, - 0x4a026406, 0x00000001, 0x417a7800, 0x0401f8c8, - 0x42000800, 0x00000005, 0x0401f8cf, 0x42027000, - 0x00000003, 0x0201f800, 0x000207a1, 0x80000580, - 0x0401f0be, 0x0201f800, 0x00020245, 0x040200a0, - 0x0201f800, 0x001049fc, 0x040200a3, 0x0201f800, - 0x00109517, 0x04000094, 0x80000580, 0x0401f0b3, - 0x0201f800, 0x00020245, 0x04020095, 0x0201f800, - 0x001049fc, 0x04020098, 0x0201f800, 0x001090e6, - 0x04000089, 0x80000580, 0x0401f0a8, 0x0201f800, - 0x00020245, 0x0402008a, 0x83444d80, 0x000007fe, - 0x42000000, 0x0000000a, 0x0402006b, 0x0201f800, - 0x001049e7, 0x04020088, 0x0201f800, 0x0010952f, - 0x04000079, 0x80000580, 0x0401f098, 0x82200500, - 0x00000070, 0x04020005, 0x8c20450e, 0x42000000, - 0x0000000c, 0x0402005c, 0x8c20450a, 0x0400000d, - 0x4d3c0000, 0x42027800, 0x00001000, 0x8c20450e, - 0x04020002, 0x853e7d56, 0x82200500, 0x000000a0, - 0x0201f800, 0x001049d3, 0x5c027800, 0x0401f07f, - 0x0201f800, 0x00020245, 0x04020065, 0x8c204508, - 0x04000010, 0x4d3c0000, 0x42027800, 0x00001000, - 0x8c20450e, 0x04020002, 0x853e7d56, 0x82200500, - 0x00000090, 0x0201f800, 0x001049bb, 0x5c027800, - 0x42000000, 0x0000000a, 0x0402003b, 0x0401f06b, - 0x836c0580, 0x00000003, 0x42000800, 0x00000007, - 0x0402000f, 0x0201f800, 0x001049f3, 0x04000007, - 0x4c000000, 0x0201f800, 0x00104a1f, 0x5c000000, - 0x0400004d, 0x0401f05d, 0x0201f800, 0x001094c5, - 0x04000007, 0x80000580, 0x0401f05c, 0x0201f800, - 0x00104a1f, 0x04000051, 0x0401f054, 0x0201f800, - 0x00104a1f, 0x04000034, 0x0401f050, 0x0201f800, - 0x00020245, 0x04020036, 0x836c0580, 0x00000003, - 0x04020040, 0x8c204508, 0x04000006, 0x417a7800, - 0x417a6000, 0x0201f800, 0x001020a1, 0x0401f043, - 0x0201f800, 0x001049ed, 0x04000008, 0x0201f800, - 0x001049e7, 0x0402002c, 0x417a7800, 0x417a6000, - 0x0201f800, 0x001020a1, 0x480bc856, 0x0201f800, - 0x00109332, 0x04000018, 0x80000580, 0x0401f037, - 0x0401f7e3, 0x480bc857, 0x42000800, 0x00000019, - 0x40001000, 0x4200b000, 0x00000002, 0x0401f00a, - 0x480bc857, 0x40000800, 0x4200b000, 0x00000002, - 0x0401f005, 0x480bc857, 0x40000800, 0x4200b000, - 0x00000001, 0x480bc857, 0x42028000, 0x00000031, - 0x0401f020, 0x480bc857, 0x42000800, 0x00000003, - 0x4200b000, 0x00000001, 0x0401f7f7, 0x480bc857, - 0x42000800, 0x0000000a, 0x4200b000, 0x00000001, - 0x0401f7f1, 0x480bc857, 0x42000800, 0x00000009, - 0x40001000, 0x4200b000, 0x00000002, 0x0401f7ea, - 0x480bc857, 0x42000800, 0x00000007, 0x4200b000, - 0x00000001, 0x0401f7e4, 0x480bc857, 0x4200b000, - 0x00000001, 0x0401f7e0, 0x80028580, 0x4178b000, - 0x82000540, 0x00000001, 0x1c01f000, 0x4937c857, - 0x59326809, 0x59341200, 0x813e79c0, 0x04000003, - 0x84081540, 0x0401f002, 0x84081500, 0x480a6a00, - 0x1c01f000, 0x59326809, 0x5c000000, 0x4c000000, - 0x4803c857, 0x4937c857, 0x82040580, 0x00000006, - 0x04020004, 0x42000000, 0x00000606, 0x0401f021, - 0x82040580, 0x00000004, 0x04020004, 0x42000000, - 0x00000404, 0x0401f01b, 0x82040580, 0x00000007, - 0x42000000, 0x00000707, 0x04000016, 0x82040580, - 0x00000003, 0x42000000, 0x00000703, 0x04000011, - 0x82040580, 0x00000005, 0x42000000, 0x00000405, - 0x0400000c, 0x82040580, 0x00000009, 0x42000000, - 0x00000409, 0x04000007, 0x82040580, 0x0000000b, - 0x42000000, 0x0000070b, 0x02020800, 0x001005d8, - 0x4803c857, 0x48026c00, 0x82040d80, 0x00000006, - 0x04020005, 0x59341404, 0x800811c0, 0x02000800, - 0x001005d8, 0x1c01f000, 0x5c000000, 0x4c000000, - 0x4803c857, 0x4947c857, 0x481bc857, 0x83440480, - 0x00000800, 0x04021034, 0x83441400, 0x0010ac00, - 0x50080000, 0x80026d40, 0x04020011, 0x4c180000, - 0x4d2c0000, 0x0201f800, 0x001007d3, 0x412e6800, - 0x5c025800, 0x5c003000, 0x04000027, 0x45341000, - 0x497a680d, 0x497a6810, 0x497a680f, 0x497a680e, - 0x4c180000, 0x0401fcf3, 0x5c003000, 0x59340a12, - 0x4c040000, 0x0201f800, 0x0010513b, 0x5c000800, - 0x04000009, 0x82180500, 0x00ffff00, 0x04000008, - 0x59a81010, 0x82081500, 0x00ffff00, 0x80080580, - 0x04000003, 0x80000580, 0x0401f004, 0x82180500, - 0x000000ff, 0x800000d0, 0x80040d80, 0x04000003, - 0x4803c857, 0x48026a12, 0x59340002, 0x80180580, - 0x04000003, 0x481bc857, 0x481a6802, 0x80000580, - 0x1c01f000, 0x4803c856, 0x82000540, 0x00000001, - 0x0401f7fc, 0x4947c857, 0x83440480, 0x00000800, - 0x04021011, 0x83441400, 0x0010ac00, 0x50080000, - 0x80026d40, 0x0400000b, 0x0401fbf9, 0x0402000a, - 0x59a80005, 0x8c000502, 0x04000004, 0x59340200, - 0x8c00050e, 0x04000004, 0x82000540, 0x00000001, - 0x1c01f000, 0x80000580, 0x0401f7fe, 0x5c000000, - 0x4c000000, 0x4803c857, 0x4947c857, 0x4d2c0000, - 0x4d300000, 0x83440480, 0x00000800, 0x04021024, - 0x83441400, 0x0010ac00, 0x50080000, 0x80026d40, - 0x0400001b, 0x45781000, 0x5934000d, 0x80025d40, - 0x02020800, 0x001007fd, 0x59366011, 0x813261c0, - 0x0400000e, 0x4c640000, 0x5930c800, 0x59325808, - 0x0201f800, 0x00109037, 0x02020800, 0x001007fd, - 0x0201f800, 0x0002077d, 0x82666540, 0x00000000, - 0x040207f6, 0x5c00c800, 0x0201f800, 0x00104c62, - 0x41365800, 0x0201f800, 0x001007f5, 0x80000580, - 0x5c026000, 0x5c025800, 0x1c01f000, 0x82000540, - 0x00000001, 0x0401f7fb, 0x4937c857, 0x4c580000, - 0x59cc0001, 0x82000500, 0x00ffffff, 0x48026802, - 0x497a6c01, 0x497a6a01, 0x59340200, 0x84000502, - 0x48026a00, 0x0201f800, 0x0010513b, 0x04020017, - 0x59340403, 0x82000580, 0x000007fe, 0x04000005, - 0x59a80026, 0x8c00050a, 0x04020010, 0x0401f008, - 0x59cc0408, 0x8c000518, 0x0400000c, 0x59cc0009, - 0x48035035, 0x59cc000a, 0x48035036, 0x59cc0207, - 0x80000540, 0x04020003, 0x42000000, 0x00000001, - 0x48038893, 0x4803501e, 0x59cc0a09, 0x82040d00, - 0x00000010, 0x59cc0408, 0x82000500, 0x00000020, - 0x04000002, 0x84040d40, 0x5934000a, 0x82000500, - 0xffffffee, 0x80040540, 0x4802680a, 0x83cca400, - 0x0000000b, 0x8334ac00, 0x00000006, 0x4200b000, - 0x00000002, 0x0201f800, 0x0010ab17, 0x83cca400, - 0x0000000d, 0x8334ac00, 0x00000008, 0x4200b000, - 0x00000002, 0x0201f800, 0x0010ab17, 0x59cc0a18, - 0x82040480, 0x00000800, 0x0402100c, 0x82040480, - 0x00000400, 0x04001004, 0x42000800, 0x00000400, - 0x0401f006, 0x82040480, 0x00000200, 0x04001003, - 0x42000800, 0x00000200, 0x48066a04, 0x59340403, - 0x82000580, 0x000007fe, 0x04020003, 0x59cc0a08, - 0x48066a04, 0x42000800, 0x00000004, 0x59cc1207, - 0x800811c0, 0x04000005, 0x82080480, 0x00000004, - 0x04021002, 0x40080800, 0x48066c04, 0x5c00b000, - 0x1c01f000, 0x4937c857, 0x59a80026, 0x8c000508, - 0x04000004, 0x84000556, 0x4803c857, 0x48035026, - 0x59cc0207, 0x4803c857, 0x48026a05, 0x59cc020a, - 0x4803c857, 0x48026c05, 0x59341200, 0x599c0818, - 0x5934180a, 0x4807c857, 0x480bc857, 0x480fc857, - 0x59cc2006, 0x82102500, 0xff000000, 0x82102580, - 0x02000000, 0x04000007, 0x8c00050e, 0x04000009, - 0x8c0c1d14, 0x04000003, 0x8c0c1d0e, 0x04000005, - 0x8c040d18, 0x04000003, 0x8408154a, 0x0401f002, - 0x8408150a, 0x8c000510, 0x04000009, 0x8c0c1d14, - 0x04000003, 0x8c0c1d10, 0x04000005, 0x8c040d18, - 0x04000003, 0x8408154e, 0x0401f002, 0x8408150e, - 0x8c000512, 0x04000009, 0x8c0c1d14, 0x04000003, - 0x8c0c1d12, 0x04000005, 0x8c040d18, 0x04000003, - 0x8408155c, 0x0401f002, 0x8408151c, 0x480a6a00, - 0x1c01f000, 0x4803c856, 0x4c5c0000, 0x4d2c0000, - 0x4c580000, 0x5934000d, 0x80025d40, 0x04000029, - 0x592c0003, 0x82000480, 0x00000008, 0x0400100b, - 0x412cb800, 0x592c0001, 0x80025d40, 0x040207f9, - 0x0201f800, 0x001007e4, 0x04000037, 0x492fc857, - 0x492cb801, 0x0401f020, 0x832c0c00, 0x00000004, - 0x4200b000, 0x00000008, 0x50040000, 0x82000580, - 0xffffffff, 0x04020006, 0x80041000, 0x50080000, - 0x82000580, 0xffffffff, 0x04000007, 0x82040c00, - 0x00000002, 0x8058b040, 0x040207f4, 0x0201f800, - 0x001005d8, 0x45480800, 0x454c1000, 0x592c1803, - 0x800c1800, 0x480e5803, 0x480fc857, 0x0401f014, - 0x0201f800, 0x001007e4, 0x04000017, 0x492fc857, - 0x492e680d, 0x497a5802, 0x4a025803, 0x00000001, - 0x494a5804, 0x494e5805, 0x832c0c00, 0x00000006, - 0x4200b000, 0x0000000e, 0x46000800, 0xffffffff, - 0x80040800, 0x8058b040, 0x040207fc, 0x82000540, - 0x00000001, 0x5c00b000, 0x5c025800, 0x5c00b800, - 0x1c01f000, 0x80000580, 0x0401f7fb, 0x4803c856, - 0x4d3c0000, 0x4d2c0000, 0x5934000d, 0x80025d40, - 0x0400001f, 0x592c0002, 0x80000540, 0x0402001f, - 0x412e7800, 0x0401f8ce, 0x0402001c, 0x46000800, - 0xffffffff, 0x46001000, 0xffffffff, 0x4813c857, - 0x480fc857, 0x580c0003, 0x82000c80, 0x00000002, - 0x04021014, 0x480fc857, 0x400c0000, 0x812c0580, - 0x04020004, 0x580c0001, 0x4802680d, 0x0401f003, - 0x580c0001, 0x48002001, 0x400e5800, 0x0201f800, - 0x001007f4, 0x82000540, 0x00000001, 0x5c025800, - 0x5c027800, 0x1c01f000, 0x80000580, 0x0401f7fc, - 0x80000040, 0x48001803, 0x4803c857, 0x0401f7f6, - 0x0201f800, 0x00020086, 0x59300007, 0x8400054e, - 0x48026007, 0x592c1a04, 0x820c1d00, 0x000000ff, - 0x820c0580, 0x00000048, 0x04000013, 0x0201f000, - 0x0002028e, 0x8c000500, 0x02020800, 0x000200e5, - 0x4a026203, 0x00000002, 0x592c1a04, 0x820c1d00, - 0x000000ff, 0x820c0580, 0x00000018, 0x02000000, - 0x0002028e, 0x820c0580, 0x00000048, 0x02020000, - 0x0002028e, 0x42000800, 0x80000804, 0x0201f800, - 0x00106721, 0x0201f000, 0x00020297, 0x4a025a06, - 0x00000008, 0x0201f000, 0x000202da, 0x4a025a06, - 0x00000029, 0x0201f000, 0x000202da, 0x4a025a06, - 0x0000002a, 0x0201f000, 0x000202da, 0x4a025a06, - 0x00000028, 0x0201f000, 0x000202da, 0x4943c857, - 0x4d440000, 0x4d340000, 0x4d2c0000, 0x4c580000, - 0x4200b000, 0x000007f0, 0x417a8800, 0x0201f800, - 0x00020245, 0x0402000d, 0x8d3e7d14, 0x04000005, - 0x59340212, 0x82000500, 0x0000ff00, 0x04000007, - 0x8d3e7d06, 0x04000004, 0x59340200, 0x8c00050e, - 0x04020002, 0x0401f813, 0x81468800, 0x8058b040, - 0x040207ef, 0x83440480, 0x00000800, 0x04021008, - 0x8d3e7d02, 0x04000006, 0x42028800, 0x000007f0, - 0x4200b000, 0x00000010, 0x0401f7e5, 0x5c00b000, - 0x5c025800, 0x5c026800, 0x5c028800, 0x1c01f000, - 0x4d2c0000, 0x41783000, 0x5936580f, 0x812e59c0, - 0x04000029, 0x592c0204, 0x82000500, 0x000000ff, - 0x82000580, 0x00000012, 0x04000020, 0x8d3e7d00, - 0x04000003, 0x0401f83c, 0x0402001c, 0x592c2000, - 0x497a5800, 0x801831c0, 0x04020009, 0x59340010, - 0x812c0580, 0x04020004, 0x497a680f, 0x497a6810, - 0x0401f008, 0x4812680f, 0x0401f006, 0x48103000, - 0x59340010, 0x812c0580, 0x04020002, 0x481a6810, - 0x4a025a04, 0x00000103, 0x49425a06, 0x497a5c09, - 0x0201f800, 0x001091c6, 0x0201f800, 0x000202da, - 0x40125800, 0x0401f7da, 0x412c3000, 0x592e5800, - 0x0401f7d7, 0x5c025800, 0x1c01f000, 0x4803c856, - 0x41781800, 0x5934000f, 0x80025d40, 0x04000010, - 0x592c0005, 0x80200580, 0x592c0000, 0x04000003, - 0x412c1800, 0x0401f7f9, 0x497a5800, 0x800c19c0, - 0x04000008, 0x48001800, 0x80000540, 0x04020004, - 0x480e6810, 0x82000540, 0x00000001, 0x1c01f000, - 0x4802680f, 0x80000540, 0x040207fd, 0x497a6810, - 0x0401f7f9, 0x592c0008, 0x81480580, 0x04020003, - 0x592c0009, 0x814c0580, 0x1c01f000, 0x4803c856, - 0x4c580000, 0x413c1800, 0x400c2000, 0x593c0002, - 0x80000540, 0x04020018, 0x4200b000, 0x00000008, - 0x820c0c00, 0x00000004, 0x50040000, 0x81480580, - 0x04020005, 0x80041000, 0x50080000, 0x814c0580, - 0x0400000d, 0x82040c00, 0x00000002, 0x8058b040, - 0x040207f6, 0x400c2000, 0x580c0001, 0x80001d40, - 0x040207ee, 0x82000540, 0x00000001, 0x5c00b000, - 0x1c01f000, 0x80000580, 0x0401f7fd, 0x4937c857, - 0x4c580000, 0x4d2c0000, 0x5934000d, 0x80025d40, - 0x04020016, 0x0201f800, 0x001007e4, 0x04000010, - 0x492e680d, 0x4a025802, 0x00000001, 0x497a5803, - 0x832c0c00, 0x00000004, 0x4200b000, 0x00000010, - 0x46000800, 0xffffffff, 0x80040800, 0x8058b040, - 0x040207fc, 0x82000540, 0x00000001, 0x5c025800, - 0x5c00b000, 0x1c01f000, 0x4d2c0000, 0x592e5801, - 0x0201f800, 0x001007fd, 0x5c025800, 0x0401f7ea, - 0x4d2c0000, 0x5936580d, 0x812e59c0, 0x04000007, - 0x4937c857, 0x497a680d, 0x0201f800, 0x001007fd, - 0x82000540, 0x00000001, 0x5c025800, 0x1c01f000, - 0x59340405, 0x4937c857, 0x4803c857, 0x8c000508, - 0x1c01f000, 0x4803c856, 0x0201f800, 0x0010513b, - 0x04000011, 0x59a80815, 0x8c040d04, 0x0402000e, - 0x59a80826, 0x8c040d06, 0x0400000b, 0x83ac0400, - 0x000007fe, 0x50000000, 0x80026d40, 0x04000006, - 0x0401f9a7, 0x04020004, 0x59340200, 0x8400055a, - 0x48026a00, 0x599c0017, 0x8c000508, 0x04000015, - 0x4200b000, 0x000007f0, 0x417a8800, 0x0201f800, - 0x00020245, 0x0402000c, 0x0401f999, 0x0402000a, - 0x59a80010, 0x59340802, 0x80040580, 0x82000500, - 0x00ffff00, 0x04020004, 0x59340200, 0x8400055a, - 0x48026a00, 0x81468800, 0x8058b040, 0x040207f0, - 0x0401f884, 0x04000003, 0x59a80836, 0x0401f006, - 0x599c0017, 0x8c000508, 0x04000007, 0x42000800, - 0x000007d0, 0x42001000, 0x00104876, 0x0201f800, - 0x0010606e, 0x1c01f000, 0x4803c856, 0x4d340000, - 0x4d440000, 0x4d3c0000, 0x4c580000, 0x42001000, - 0x00104876, 0x0201f800, 0x00105f90, 0x59a80826, - 0x8c040d06, 0x04000015, 0x0401f86a, 0x04000013, - 0x83ae6c00, 0x000007fe, 0x51366800, 0x59340200, - 0x8400051a, 0x48026a00, 0x599c0017, 0x8c000508, - 0x04000007, 0x42000800, 0x000007d0, 0x42001000, - 0x00104876, 0x0201f800, 0x0010606e, 0x0201f800, - 0x00101e45, 0x0401f027, 0x4200b000, 0x000007f0, - 0x80028d80, 0x0201f800, 0x00020245, 0x0402001e, - 0x59340200, 0x8c00051a, 0x0400001b, 0x59368c03, - 0x417a7800, 0x42028000, 0x00000029, 0x41783000, - 0x0201f800, 0x0010a446, 0x59340200, 0x84000558, - 0x8400051a, 0x48026a00, 0x4937c857, 0x4a026c00, - 0x00000707, 0x42028000, 0x00000029, 0x0201f800, - 0x00106ab4, 0x417a7800, 0x0201f800, 0x001067fd, - 0x80000d80, 0x0201f800, 0x0010a2ff, 0x0201f800, - 0x00106c4b, 0x81468800, 0x8058b040, 0x040207de, - 0x5c00b000, 0x5c027800, 0x5c028800, 0x5c026800, - 0x1c01f000, 0x4933c857, 0x59303809, 0x581c0200, - 0x8400051a, 0x48003a00, 0x1c01f000, 0x4803c856, - 0x42026800, 0x0010b524, 0x497a680e, 0x42028800, - 0x000007ff, 0x0201f800, 0x001042b4, 0x4937c857, - 0x4a026c00, 0x00000606, 0x4a026802, 0x00ffffff, - 0x4a026a04, 0x00000200, 0x4a026c04, 0x00000002, - 0x1c01f000, 0x59300009, 0x50000000, 0x4933c857, - 0x4803c857, 0x8c00050e, 0x1c01f000, 0x59300009, - 0x50000000, 0x8c00050a, 0x1c01f000, 0x4933c856, - 0x0401f90f, 0x04000006, 0x59340400, 0x82000d00, - 0x000000ff, 0x82041580, 0x00000005, 0x1c01f000, - 0x4d340000, 0x83ac0400, 0x000007fe, 0x50000000, - 0x80026d40, 0x04000003, 0x59340200, 0x8c00051a, - 0x5c026800, 0x1c01f000, 0x4937c857, 0x493fc857, - 0x59340403, 0x81ac0400, 0x50000000, 0x81340580, - 0x02020800, 0x001005d8, 0x59341200, 0x813e79c0, - 0x04000003, 0x8408155e, 0x0401f002, 0x8408151e, - 0x480a6a00, 0x1c01f000, 0x4937c857, 0x0201f800, - 0x0010210a, 0x04000006, 0x59a80835, 0x42001000, - 0x00104910, 0x0201f800, 0x0010606e, 0x1c01f000, - 0x4937c857, 0x42001000, 0x00104910, 0x0201f800, - 0x00105f90, 0x59a81026, 0x84081512, 0x480b5026, - 0x1c01f000, 0x4c380000, 0x4c340000, 0x4c240000, - 0x4c600000, 0x4008c000, 0x83440480, 0x00000800, - 0x04021045, 0x80002d80, 0x41442000, 0x83447400, - 0x0010ac00, 0x4200b000, 0x000007f0, 0x83444c80, - 0x000007f0, 0x04001003, 0x4200b000, 0x00000010, - 0x50380000, 0x80000540, 0x0402001e, 0x41440000, - 0x80100580, 0x04020043, 0x40102800, 0x82104c80, - 0x000007f0, 0x04001015, 0x82104d80, 0x000007fc, - 0x04020005, 0x82604d80, 0x00fffffc, 0x0402002a, - 0x0401f00e, 0x82104d80, 0x000007fd, 0x04020005, - 0x82604d80, 0x00fffffd, 0x04020023, 0x0401f007, - 0x82104d80, 0x000007ff, 0x0402001f, 0x82604d80, - 0x00ffffff, 0x0402001c, 0x84142d5e, 0x0401f029, - 0x40006800, 0x58343002, 0x82183500, 0x00ffffff, - 0x40180000, 0x80600580, 0x04020019, 0x40100000, - 0x81440580, 0x0402000a, 0x40366800, 0x8c204508, - 0x04000053, 0x0401ff8a, 0x04020051, 0x4947c857, - 0x42000000, 0x0000001d, 0x0401f04e, 0x4947c857, - 0x480bc857, 0x4823c857, 0x42000000, 0x0000001a, - 0x0401f048, 0x4947c857, 0x4863c857, 0x4813c857, - 0x42000000, 0x00000019, 0x0401f042, 0x40100000, - 0x81440580, 0x04020007, 0x58343002, 0x4947c857, - 0x481bc857, 0x42000000, 0x0000001b, 0x0401f039, - 0x80102000, 0x80387000, 0x83444c80, 0x000007f0, - 0x04001009, 0x82104d80, 0x00000800, 0x0402000c, - 0x42002000, 0x000007f0, 0x42007000, 0x0010b3f0, - 0x0401f007, 0x82104d80, 0x000007f0, 0x04020004, - 0x41782000, 0x42007000, 0x0010ac00, 0x8058b040, - 0x040207a4, 0x801429c0, 0x04020007, 0x0201f800, - 0x001005d8, 0x4947c857, 0x42000000, 0x0000000a, - 0x0401f01c, 0x4d2c0000, 0x4c180000, 0x40603000, - 0x0401fc12, 0x4947c857, 0x4937c857, 0x5c003000, - 0x5c025800, 0x040207f4, 0x497a6a12, 0x59a80026, - 0x8c00050a, 0x0402000d, 0x82600500, 0x00ffff00, - 0x04000006, 0x59a84810, 0x82244d00, 0x00ffff00, - 0x80240580, 0x04020005, 0x82600500, 0x000000ff, - 0x800000d0, 0x48026a12, 0x48626802, 0x80000580, - 0x80000540, 0x5c00c000, 0x5c004800, 0x5c006800, - 0x5c007000, 0x1c01f000, 0x5934000f, 0x5934140b, - 0x80081040, 0x04001002, 0x480a6c0b, 0x80000540, - 0x02020800, 0x00020253, 0x1c01f000, 0x4803c857, - 0x4947c857, 0x4c300000, 0x82006500, 0x00000030, - 0x04000006, 0x4c000000, 0x0201f800, 0x0010942a, - 0x5c000000, 0x0402000b, 0x8c00050e, 0x04000006, - 0x0201f800, 0x00020245, 0x04020006, 0x4937c857, - 0x0401fc2f, 0x80000580, 0x5c006000, 0x1c01f000, - 0x82000540, 0x00000001, 0x0401f7fc, 0x4803c857, - 0x4c580000, 0x4d440000, 0x40001000, 0x80000d80, - 0x4200b000, 0x000007f0, 0x4c040000, 0x40068800, - 0x4c080000, 0x40080000, 0x0401ffdd, 0x5c001000, - 0x5c000800, 0x80040800, 0x8058b040, 0x040207f7, - 0x5c028800, 0x5c00b000, 0x1c01f000, 0x4c5c0000, - 0x59340400, 0x8200bd80, 0x00000606, 0x5c00b800, - 0x1c01f000, 0x4c5c0000, 0x59340400, 0x8200bd80, - 0x00000404, 0x5c00b800, 0x1c01f000, 0x4c5c0000, - 0x59340400, 0x8200bd80, 0x00000404, 0x04000003, - 0x8200bd80, 0x00000606, 0x5c00b800, 0x1c01f000, - 0x4c5c0000, 0x4c600000, 0x59340400, 0x8200bd00, - 0x0000ff00, 0x825cc580, 0x00000400, 0x04000003, - 0x825cc580, 0x00000600, 0x5c00c000, 0x5c00b800, - 0x1c01f000, 0x4c5c0000, 0x59340400, 0x82000500, - 0x000000ff, 0x8200bd80, 0x00000003, 0x04000003, - 0x8200bd80, 0x00000005, 0x5c00b800, 0x1c01f000, - 0x4c5c0000, 0x59340400, 0x82000500, 0x0000ff00, - 0x8400b9c0, 0x805c0580, 0x4937c857, 0x4803c857, - 0x48026c00, 0x5c00b800, 0x1c01f000, 0x4c040000, - 0x4c080000, 0x592c0207, 0x8c00050c, 0x0400000f, - 0x592e8c06, 0x82000500, 0x00000080, 0x84000548, - 0x4d3c0000, 0x42027800, 0x00001000, 0x0401ff90, - 0x5c027800, 0x82000540, 0x00000001, 0x5c001000, - 0x5c000800, 0x1c01f000, 0x80000580, 0x0401f7fc, - 0x592c040b, 0x82000500, 0x0000e000, 0x82000580, - 0x00006000, 0x04000019, 0x836c0580, 0x00000003, - 0x04000016, 0x836c0580, 0x00000002, 0x040200ff, - 0x59a80026, 0x82000d00, 0x00000038, 0x04020005, - 0x59a80832, 0x800409c0, 0x0400000c, 0x0401f0f7, - 0x82000d00, 0x00000003, 0x82040d80, 0x00000003, - 0x040200f2, 0x82000d00, 0x00000028, 0x04020003, - 0x8c00050c, 0x040000ed, 0x592c100a, 0x82080500, - 0xff000000, 0x040200ce, 0x59a80010, 0x80080580, - 0x040000c8, 0x592c0c0b, 0x82040d00, 0x0000e000, - 0x82040480, 0x00008000, 0x040210c8, 0x592e8c06, - 0x83440480, 0x00000800, 0x04001007, 0x83440580, - 0x0000ffff, 0x040200af, 0x800409c0, 0x040200f7, - 0x0401f0ac, 0x800409c0, 0x040200f4, 0x41784000, - 0x0401fead, 0x040200db, 0x42027000, 0x00000053, - 0x592c2409, 0x82100500, 0xffffff00, 0x040200aa, - 0x4813c857, 0x592c000c, 0x800001c0, 0x04000083, - 0x82100580, 0x00000004, 0x040000a0, 0x82100580, - 0x00000051, 0x0400009d, 0x82100580, 0x00000003, - 0x04000016, 0x82100580, 0x00000020, 0x0400004b, - 0x82100580, 0x00000024, 0x04000042, 0x82100580, - 0x00000021, 0x04000042, 0x82100580, 0x00000050, - 0x04000037, 0x82100580, 0x00000052, 0x04000031, - 0x82100580, 0x00000005, 0x0402006b, 0x42027000, - 0x00000001, 0x0401f01b, 0x42027000, 0x00000002, - 0x59a80005, 0x8c000514, 0x04000016, 0x0401ff4c, - 0x04000014, 0x59340212, 0x82000500, 0x0000ff00, - 0x42001000, 0x00000010, 0x0402000c, 0x59a80026, - 0x8c000506, 0x0402006f, 0x42001000, 0x00000008, - 0x59340002, 0x82000500, 0x00ff0000, 0x82000580, - 0x00ff0000, 0x04000003, 0x0401f9bf, 0x04020065, - 0x0201f800, 0x0002075a, 0x0400007e, 0x4a026406, - 0x00000010, 0x49366009, 0x42000800, 0x00000003, - 0x83380580, 0x00000002, 0x04000003, 0x42000800, - 0x0000000b, 0x0201f800, 0x00104571, 0x0401f044, - 0x42027000, 0x00000000, 0x0401f003, 0x42027000, - 0x00000004, 0x0401ff37, 0x04020071, 0x0401f036, - 0x42027000, 0x00000033, 0x0401f006, 0x42027000, - 0x00000005, 0x0401f003, 0x42027000, 0x00000003, - 0x0401ff23, 0x04020066, 0x59a80005, 0x8c000514, - 0x04000016, 0x0401ff12, 0x04000014, 0x59340212, - 0x82000500, 0x0000ff00, 0x42001000, 0x00000010, - 0x0402000c, 0x59a80026, 0x8c000506, 0x04020035, - 0x42001000, 0x00000008, 0x59340002, 0x82000500, - 0x00ff0000, 0x82000580, 0x00ff0000, 0x04000003, - 0x0401f985, 0x0402002b, 0x0201f800, 0x0002075a, - 0x04000044, 0x4a026406, 0x00000010, 0x49366009, - 0x42000800, 0x00000005, 0x83380580, 0x00000003, - 0x04000003, 0x42000800, 0x00000009, 0x0201f800, - 0x00104571, 0x0401f00a, 0x82102580, 0x00000011, - 0x0402002d, 0x0201f800, 0x0002075a, 0x04000031, - 0x4a026406, 0x00000010, 0x49366009, 0x492e6008, - 0x49325808, 0x813669c0, 0x04000007, 0x592c0c0b, - 0x8c040d18, 0x04000004, 0x59340200, 0x84000514, - 0x48026a00, 0x0201f800, 0x000207a1, 0x80000580, - 0x1c01f000, 0x82000540, 0x00000001, 0x0401f7fd, - 0x42001000, 0x0000000a, 0x0401f015, 0x42001000, - 0x00000010, 0x0401f012, 0x42001000, 0x00000016, - 0x0401f00f, 0x42001000, 0x00000017, 0x0401f00c, - 0x42001000, 0x00000018, 0x0401f009, 0x42001000, - 0x0000001b, 0x0401f006, 0x42001000, 0x0000001e, - 0x0401f003, 0x42001000, 0x00000020, 0x42000800, - 0x00000019, 0x42028000, 0x00000031, 0x0401f7e2, - 0x42000800, 0x00000003, 0x0401f003, 0x42000800, - 0x0000000a, 0x41781000, 0x0401f7f7, 0x42000800, - 0x00000009, 0x59341400, 0x0401f7f3, 0x42028000, - 0x00000008, 0x0401f005, 0x42000800, 0x00000007, - 0x416c1000, 0x0401f7ec, 0x41780800, 0x41781000, - 0x0401f7cd, 0x42028000, 0x00000000, 0x0401f7fb, - 0x82004d80, 0x0000001d, 0x02000800, 0x001005d8, - 0x82004d80, 0x0000001a, 0x04020004, 0x40101000, - 0x40000800, 0x0401f7dc, 0x82004d80, 0x0000001b, - 0x04020003, 0x40181000, 0x0401f7fa, 0x82004d80, - 0x0000001c, 0x040007f7, 0x82004d80, 0x00000019, - 0x040007b8, 0x0401f7d6, 0x592e6008, 0x0201f800, - 0x0010941a, 0x040007b6, 0x59300c06, 0x82040580, - 0x00000011, 0x040207d6, 0x83440580, 0x0000ffff, - 0x04020005, 0x59326809, 0x813669c0, 0x0400000e, - 0x0401f7cf, 0x592c100a, 0x82081500, 0x00ffffff, - 0x41784000, 0x0401fda8, 0x040207d6, 0x59300009, - 0x800001c0, 0x04000003, 0x81340580, 0x040207c4, - 0x49366009, 0x592c0c0b, 0x82041500, 0x0000e000, - 0x82080580, 0x00006000, 0x04000009, 0x59300a03, - 0x82040580, 0x00000007, 0x040207b9, 0x492e6008, - 0x42027000, 0x00000054, 0x0401f77f, 0x0201f800, - 0x0010a8d4, 0x040007bc, 0x0401f7b1, 0x492fc857, - 0x59a80021, 0x800001c0, 0x04020073, 0x592e6008, - 0x4933c857, 0x0201f800, 0x0010941a, 0x04000041, - 0x59301406, 0x82080580, 0x00000005, 0x0402005b, - 0x59301203, 0x82080580, 0x00000007, 0x04020057, - 0x592e8c06, 0x83440480, 0x00000800, 0x04021032, - 0x41784000, 0x592c1009, 0x82081500, 0x00ffffff, - 0x0401fd75, 0x0402005f, 0x59300009, 0x800001c0, - 0x04000003, 0x81340580, 0x04020048, 0x4d300000, - 0x592e6013, 0x4933c857, 0x83300580, 0xffffffff, - 0x0400000d, 0x0201f800, 0x0010941a, 0x5c026000, - 0x04000029, 0x591c1406, 0x82080580, 0x00000006, - 0x04000046, 0x82080580, 0x00000011, 0x04000043, - 0x0401f002, 0x5c026000, 0x59a80010, 0x592c100a, - 0x82081500, 0x00ffffff, 0x80081580, 0x04020017, - 0x592c1009, 0x82081500, 0x00ffffff, 0x80081580, - 0x0400000f, 0x49366009, 0x492e6008, 0x42027000, - 0x00000092, 0x0201f800, 0x000207a1, 0x80000580, - 0x1c01f000, 0x42001000, 0x0000000a, 0x0401f00c, - 0x42001000, 0x00000010, 0x0401f009, 0x42001000, - 0x00000014, 0x0401f006, 0x42001000, 0x00000018, - 0x0401f003, 0x42001000, 0x0000003c, 0x492fc857, - 0x480bc857, 0x42000800, 0x00000019, 0x42028000, - 0x00000031, 0x82000540, 0x00000001, 0x0401f7e9, - 0x492fc857, 0x4803c857, 0x480bc857, 0x40000800, - 0x0401f7f7, 0x492fc857, 0x42000800, 0x0000000a, - 0x41781000, 0x0401f7f2, 0x4933c857, 0x59300406, - 0x4803c857, 0x59300203, 0x4803c857, 0x59300009, - 0x4803c857, 0x42028000, 0x00000008, 0x41780800, - 0x41781000, 0x0401f7e8, 0x42000800, 0x0000001e, - 0x0401f7f0, 0x42000800, 0x00000001, 0x0401f7ed, - 0x82004d80, 0x0000001d, 0x02000800, 0x001005d8, - 0x82004d80, 0x0000001a, 0x04020003, 0x40101000, - 0x0401f7dc, 0x82004d80, 0x0000001b, 0x04020003, - 0x40181000, 0x0401f7d7, 0x82004d80, 0x0000001c, - 0x040007d4, 0x82004d80, 0x00000019, 0x040007d1, - 0x0401f7d5, 0x59302009, 0x801021c0, 0x04000035, - 0x58101400, 0x82081d00, 0x000000ff, 0x59300c03, - 0x82040580, 0x00000008, 0x04000022, 0x82040580, - 0x0000000a, 0x04000017, 0x82040580, 0x0000000c, - 0x04000010, 0x82040580, 0x00000002, 0x04000019, - 0x82040580, 0x00000001, 0x04000012, 0x82040580, - 0x00000003, 0x0400000b, 0x82040580, 0x00000005, - 0x04000004, 0x82040580, 0x00000033, 0x04020019, - 0x820c0580, 0x00000009, 0x0400000d, 0x0401f015, - 0x820c0580, 0x00000005, 0x04000009, 0x0401f011, - 0x820c0580, 0x0000000b, 0x04000005, 0x0401f00d, - 0x820c0580, 0x00000003, 0x0402000a, 0x82081d00, - 0xffffff00, 0x840c01c0, 0x800c0540, 0x4813c857, - 0x480bc857, 0x4807c857, 0x4803c857, 0x48002400, - 0x1c01f000, 0x599c0017, 0x8c00050a, 0x04000003, - 0x80000580, 0x1c01f000, 0x59a80026, 0x82000500, - 0x00000028, 0x04000008, 0x42028800, 0x000007fd, - 0x0201f800, 0x00020245, 0x04020003, 0x5934000a, - 0x8c000504, 0x1c01f000, 0x4d300000, 0x5934000e, - 0x80026540, 0x04000006, 0x0201f800, 0x001062d5, - 0x02000800, 0x001064ad, 0x497a680e, 0x5c026000, - 0x1c01f000, 0x4d440000, 0x4d340000, 0x80000580, - 0x40001800, 0x40028800, 0x82080580, 0x00000008, - 0x04020003, 0x42001800, 0x00000001, 0x0201f800, - 0x00020245, 0x0402000a, 0x0401fd6d, 0x04020008, - 0x800c19c0, 0x04000004, 0x59340405, 0x8c000508, - 0x04000003, 0x80081040, 0x04000009, 0x81468800, - 0x83440480, 0x00000800, 0x040017f1, 0x80000580, - 0x5c026800, 0x5c028800, 0x1c01f000, 0x82000540, - 0x00000001, 0x5c026800, 0x5c028800, 0x1c01f000, - 0x4a033020, 0x00000000, 0x497b3026, 0x497b3027, - 0x497b3028, 0x497b3029, 0x497b302b, 0x497b3021, - 0x4a03b104, 0x60000001, 0x1c01f000, 0x4803c856, - 0x599c0018, 0x497b3024, 0x497b3025, 0x82000500, - 0x0000000f, 0x82000d80, 0x00000005, 0x04000006, - 0x82000580, 0x00000006, 0x0400000d, 0x497b3022, - 0x1c01f000, 0x4a033022, 0x00000005, 0x599c0216, - 0x82000500, 0x0000ffff, 0x04020003, 0x42000000, - 0x00000002, 0x48033023, 0x1c01f000, 0x4a033022, - 0x00000006, 0x0401f7f6, 0x0401ffe5, 0x4a03c826, - 0x00000004, 0x599c0209, 0x80000540, 0x0400001f, - 0x599c0207, 0x80000540, 0x04000007, 0x800000cc, - 0x599c080d, 0x80040400, 0x4803b100, 0x497bb102, - 0x59d80101, 0x599c000d, 0x4803b100, 0x599c000e, - 0x4803b101, 0x599c0207, 0x80000540, 0x04020002, - 0x497bb102, 0x599c0a09, 0x82040540, 0x00400000, - 0x59980822, 0x4803b103, 0x4a03b109, 0x00000004, - 0x4a03b104, 0x10000001, 0x800409c0, 0x04020004, - 0x4a033020, 0x00000001, 0x1c01f000, 0x4a033020, - 0x00000002, 0x0401f7fd, 0x59980022, 0x4803c856, - 0x80000540, 0x02000000, 0x000202de, 0x0401f017, - 0x42034000, 0x0010b4a4, 0x59a1d81e, 0x80edd9c0, - 0x02000800, 0x001005d8, 0x58ec0009, 0x48efc857, - 0x49a3c857, 0x492fc857, 0x4803c857, 0x800001c0, - 0x08020000, 0x0201f800, 0x001005d8, 0x5931d821, - 0x58ef400b, 0x58ec0009, 0x800001c0, 0x08020000, - 0x0201f800, 0x001005d8, 0x497a5800, 0x59980026, - 0x80000540, 0x0402008c, 0x59d80105, 0x82000d00, - 0x00018780, 0x040201da, 0x80000106, 0x82000500, - 0x00000003, 0x0c01f001, 0x00104d0a, 0x00104d89, - 0x00104d22, 0x00104d50, 0x592c0001, 0x492fc857, - 0x492fb107, 0x80000d40, 0x04020007, 0x59940019, - 0x80000540, 0x04022003, 0x59980023, 0x48032819, - 0x1c01f000, 0x497a5801, 0x40065800, 0x592c0001, - 0x496a5800, 0x815eb800, 0x412ed000, 0x80000d40, - 0x040207f9, 0x59c80000, 0x82000540, 0x00001200, - 0x48039000, 0x0401f7ee, 0x492fc857, 0x492fb107, - 0x592c0001, 0x80000d40, 0x04020012, 0x59da5908, - 0x835c0480, 0x00000020, 0x0400101c, 0x0402b01a, - 0x492fb007, 0x0400e7fa, 0x59d80105, 0x82000500, - 0x00018780, 0x040201aa, 0x59940019, 0x80000540, - 0x04022003, 0x59980023, 0x48032819, 0x1c01f000, - 0x497a5801, 0x40065800, 0x592c0001, 0x496a5800, - 0x815eb800, 0x412ed000, 0x80000d40, 0x040207f9, - 0x59c80000, 0x82000540, 0x00001200, 0x48039000, - 0x0401f7e3, 0x0400f009, 0x496a5800, 0x412ed000, - 0x815eb800, 0x59c80000, 0x82000540, 0x00001200, - 0x48039000, 0x0401f7e0, 0x492fa807, 0x0401f7de, - 0x492fc857, 0x59d81108, 0x45681000, 0x400ad000, - 0x815eb800, 0x0400e7fc, 0x59c80000, 0x82000540, - 0x00001200, 0x48039000, 0x0402d00c, 0x592c0001, - 0x492fc857, 0x492fb107, 0x80000d40, 0x0402001d, - 0x59940019, 0x80000540, 0x04022003, 0x59980023, - 0x48032819, 0x1c01f000, 0x59d80105, 0x82000500, - 0x00018780, 0x04020172, 0x42000000, 0x0010b855, - 0x0201f800, 0x0010aa47, 0x59980026, 0x59980828, - 0x80000000, 0x48033026, 0x492fc857, 0x800409c0, - 0x492f3028, 0x04000003, 0x492c0800, 0x0401f002, - 0x492f3029, 0x592c0001, 0x80000d40, 0x040007e5, - 0x497a5801, 0x40065800, 0x592c0001, 0x496a5800, - 0x815eb800, 0x412ed000, 0x80000d40, 0x040207f9, - 0x59c80000, 0x82000540, 0x00001200, 0x48039000, - 0x0401f7d8, 0x59980026, 0x59980828, 0x80000000, - 0x48033026, 0x492fc857, 0x800409c0, 0x492f3028, - 0x04000003, 0x492c0800, 0x0401f002, 0x492f3029, - 0x592c0001, 0x80000d40, 0x04020027, 0x0402d00e, - 0x59980029, 0x80025d40, 0x0400000f, 0x59980026, - 0x80000040, 0x48033026, 0x04020002, 0x48033028, - 0x592c0000, 0x48033029, 0x492fc857, 0x492fb107, - 0x0400d7f4, 0x42000000, 0x0010b855, 0x0201f800, - 0x0010aa47, 0x0402e00a, 0x59da5908, 0x496a5800, - 0x412ed000, 0x815eb800, 0x0400e7fc, 0x59c80000, - 0x82000540, 0x00001200, 0x48039000, 0x59d80105, - 0x82000500, 0x00018780, 0x04020125, 0x59940019, - 0x80000540, 0x04022003, 0x59980023, 0x48032819, - 0x1c01f000, 0x497a5801, 0x40065800, 0x592c0001, - 0x496a5800, 0x815eb800, 0x412ed000, 0x80000d40, - 0x040207f9, 0x59c80000, 0x82000540, 0x00001200, - 0x48039000, 0x0401f7ce, 0x592c0204, 0x4803c856, - 0x04000008, 0x42034000, 0x0010b4a4, 0x59a1d81e, - 0x80edd9c0, 0x02000800, 0x001005d8, 0x0401f003, - 0x5931d821, 0x58ef400b, 0x58ec0009, 0x800001c0, - 0x08020000, 0x0201f800, 0x001005d8, 0x497a5801, - 0x40065800, 0x592c0001, 0x496a5800, 0x412ed000, - 0x815eb800, 0x80000d40, 0x040207f9, 0x59c80000, - 0x82000540, 0x00001200, 0x48039000, 0x1c01f000, - 0x497a5801, 0x40065800, 0x592c0001, 0x496a5800, - 0x412ed000, 0x815eb800, 0x80000d40, 0x040207f9, - 0x59c80000, 0x82000540, 0x00001200, 0x48039000, - 0x0200e000, 0x000202fb, 0x0201f000, 0x00020302, - 0x5998002b, 0x84000540, 0x4803302b, 0x0201f000, - 0x0002035e, 0x42000000, 0x0010b855, 0x0201f800, - 0x0010aa47, 0x492fc857, 0x59980026, 0x59980828, - 0x80000000, 0x48033026, 0x800409c0, 0x492f3028, - 0x04000003, 0x492c0800, 0x0401f002, 0x492f3029, - 0x592c0001, 0x80000d40, 0x04020002, 0x1c01f000, - 0x497a5801, 0x40065800, 0x592c0001, 0x496a5800, - 0x412ed000, 0x815eb800, 0x80000d40, 0x040207f9, - 0x59c80000, 0x82000540, 0x00001200, 0x48039000, - 0x1c01f000, 0x59980026, 0x59980828, 0x80000000, - 0x48033026, 0x492fc857, 0x800409c0, 0x492f3028, - 0x04000003, 0x492c0800, 0x0401f002, 0x492f3029, - 0x592c0001, 0x80000d40, 0x04020039, 0x0402d00e, - 0x59980029, 0x80025d40, 0x0400000f, 0x59980026, - 0x80000040, 0x48033026, 0x04020002, 0x48033028, - 0x592c0000, 0x48033029, 0x492fc857, 0x492fb107, - 0x0400d7f4, 0x42000000, 0x0010b855, 0x0201f800, - 0x0010aa47, 0x0402e01d, 0x59da5908, 0x496a5800, - 0x412ed000, 0x815eb800, 0x0400e7fc, 0x59c80000, - 0x82000540, 0x00001200, 0x48039000, 0x04006018, - 0x59d8010a, 0x59d8090a, 0x80040d80, 0x040207fd, - 0x900001c0, 0x82000540, 0x00000013, 0x4803c011, - 0x5998002b, 0x84000500, 0x4803302b, 0x59e00017, - 0x8c000508, 0x04000003, 0x4a03c017, 0x00000003, - 0x4203e000, 0x30000001, 0x59d80105, 0x82000500, - 0x00018780, 0x0402007e, 0x1c01f000, 0x5998002b, - 0x84000540, 0x4803302b, 0x0401f7f8, 0x497a5801, - 0x40065800, 0x592c0001, 0x496a5800, 0x412ed000, - 0x815eb800, 0x80000d40, 0x040207f9, 0x59c80000, - 0x82000540, 0x00001200, 0x48039000, 0x0401f7bc, - 0x5c000000, 0x4c000000, 0x4803c857, 0x492fc857, - 0x4943c857, 0x4807c857, 0x4a025a04, 0x00000103, - 0x49425a06, 0x48065a08, 0x4a025c06, 0x0000ffff, - 0x813261c0, 0x04000003, 0x59300402, 0x48025c06, - 0x832c0400, 0x00000009, 0x04011000, 0x4803c840, - 0x4a03c842, 0x0000000b, 0x04011000, 0x1c01f000, - 0x4df00000, 0x4203e000, 0x50000000, 0x599cb817, - 0x59940019, 0x80000540, 0x04002023, 0x0400000e, - 0x59980022, 0x82000580, 0x00000005, 0x0400001e, - 0x59a80069, 0x81640580, 0x0402001b, 0x8c5cbd08, - 0x04000005, 0x59a8006a, 0x59a80866, 0x80040580, - 0x04020015, 0x8c5cbd08, 0x04020030, 0x59d8090b, - 0x59d8010a, 0x80040580, 0x0400000d, 0x0400600e, - 0x4a03c011, 0x80400012, 0x4a03c020, 0x00008040, - 0x59e00017, 0x8c000508, 0x04000003, 0x4a03c017, - 0x00000002, 0x4203e000, 0x30000001, 0x4a032819, - 0xffff0000, 0x04026835, 0x04006003, 0x8c5cbd08, - 0x04020860, 0x59980029, 0x80025d40, 0x04000010, - 0x59d80105, 0x82000500, 0x00018780, 0x04020020, - 0x0402d00d, 0x59980026, 0x492fc857, 0x80000040, - 0x48033026, 0x592c0000, 0x492fb107, 0x48033029, - 0x04020003, 0x4803c856, 0x48033028, 0x5c03e000, - 0x1c01f000, 0x42000000, 0x0010b855, 0x0201f800, - 0x0010aa47, 0x0401f7fa, 0x59e0000f, 0x59e0080f, - 0x80040580, 0x040207fd, 0x59e00010, 0x59e01010, - 0x80081580, 0x040207fd, 0x40065000, 0x80041580, - 0x040007c7, 0x040067dc, 0x0401f7ca, 0x4803c857, - 0x485fc857, 0x8c00050e, 0x02020800, 0x001005d0, - 0x4203e000, 0x50000000, 0x4200b800, 0x00008004, - 0x0201f000, 0x001005dd, 0x5998002b, 0x8c000500, - 0x04000013, 0x84000500, 0x4803302b, 0x59d8010a, - 0x59d8090a, 0x80040580, 0x040207fd, 0x800408e0, - 0x82040d40, 0x00000013, 0x4807c011, 0x59e00017, - 0x8c000508, 0x04000003, 0x4a03c017, 0x00000003, - 0x4203e000, 0x30000001, 0x1c01f000, 0x0402e014, - 0x59da5908, 0x496a5800, 0x412ed000, 0x815eb800, - 0x0400e7fc, 0x59c80000, 0x82000540, 0x00001200, - 0x48039000, 0x59d8090b, 0x59980024, 0x48073024, - 0x80040480, 0x04020004, 0x59940019, 0x80000540, - 0x04022003, 0x59980823, 0x48072819, 0x59d80105, - 0x82000500, 0x00018780, 0x040207c9, 0x1c01f000, - 0x59981025, 0x59e00010, 0x59e00810, 0x80041d80, - 0x040207fd, 0x80080580, 0x04000013, 0x48073025, - 0x59e0000f, 0x59e0100f, 0x80081d80, 0x040207fd, - 0x81280580, 0x04000008, 0x400a5000, 0x40080000, - 0x80040580, 0x04000003, 0x59980823, 0x48072819, - 0x1c01f000, 0x59940019, 0x80000540, 0x040227f8, - 0x0401f7fc, 0x59e0000f, 0x59e0100f, 0x80081d80, - 0x040207fd, 0x81280580, 0x040007f6, 0x400a5000, - 0x59940019, 0x80000540, 0x040027ed, 0x0401f7f1, - 0x59a80017, 0x82000c80, 0x0000000a, 0x02021800, - 0x001005d8, 0x0c01f809, 0x4a038805, 0x000000f0, - 0x59c400a3, 0x82000500, 0x02870000, 0x02020800, - 0x001005d8, 0x1c01f000, 0x00104fc5, 0x00104f51, - 0x00104f6c, 0x00104f95, 0x00104fb8, 0x00104ff2, - 0x00105004, 0x00104f6c, 0x00104fd6, 0x00104f50, - 0x1c01f000, 0x4a038808, 0x00000004, 0x0401f8f9, - 0x0201f800, 0x001053ab, 0x59c40805, 0x8c040d0e, - 0x04020013, 0x8c040d0a, 0x0402000b, 0x8c040d0c, - 0x04020006, 0x8c040d08, 0x0400000d, 0x4a035017, - 0x00000003, 0x0401f00a, 0x4a035017, 0x00000000, - 0x0401f007, 0x42000000, 0x0010b844, 0x0201f800, - 0x0010aa47, 0x4a035017, 0x00000002, 0x1c01f000, - 0x4a038808, 0x00000002, 0x0401f8de, 0x59c40805, - 0x8c040d08, 0x04020021, 0x8c040d0c, 0x0402001c, - 0x8c040d0e, 0x04020017, 0x82040500, 0x000000f0, - 0x0402001c, 0x0201f800, 0x001053ab, 0x4a038808, - 0x00000080, 0x59c40002, 0x8400050c, 0x48038802, - 0x0401f9d9, 0x4d3c0000, 0x42027800, 0x00000001, - 0x0201f800, 0x00109874, 0x5c027800, 0x4a038808, - 0x00000080, 0x4a035017, 0x00000009, 0x0401f009, - 0x4a035017, 0x00000001, 0x0401f006, 0x4a035017, - 0x00000000, 0x0401f003, 0x4a035017, 0x00000003, - 0x1c01f000, 0x0401f8b7, 0x4a038808, 0x00000080, - 0x59c40805, 0x8c040d0a, 0x0402001b, 0x8c040d0c, - 0x04020016, 0x8c040d0e, 0x04020011, 0x82040500, - 0x000000f0, 0x04020016, 0x59c40002, 0x8400050c, - 0x48038802, 0x0401f9b4, 0x4d3c0000, 0x42027800, - 0x00000001, 0x0201f800, 0x00109874, 0x5c027800, - 0x4a035017, 0x00000009, 0x0401f009, 0x4a035017, - 0x00000001, 0x0401f006, 0x4a035017, 0x00000000, - 0x0401f003, 0x4a035017, 0x00000002, 0x1c01f000, - 0x4a038808, 0x00000008, 0x59c40805, 0x8c040d0c, - 0x04020006, 0x8c040d0e, 0x04000006, 0x4a035017, - 0x00000001, 0x0401f003, 0x4a035017, 0x00000000, - 0x1c01f000, 0x0401f8d3, 0x59c40805, 0x8c040d0c, - 0x0402000d, 0x4c040000, 0x0401f882, 0x5c000800, - 0x8c040d0a, 0x04020006, 0x8c040d0e, 0x04000006, - 0x4a035017, 0x00000001, 0x0401f003, 0x4a035017, - 0x00000002, 0x1c01f000, 0x4a038808, 0x00000008, - 0x42001000, 0x00105058, 0x0201f800, 0x00106084, - 0x59c40805, 0x8c040d0a, 0x0402000d, 0x8c040d08, - 0x0402000b, 0x8c040d0c, 0x04020006, 0x8c040d0e, - 0x0400000d, 0x4a035017, 0x00000001, 0x0401f00a, - 0x4a035017, 0x00000000, 0x0401f007, 0x42000000, - 0x0010b844, 0x0201f800, 0x0010aa47, 0x4a035017, - 0x00000004, 0x1c01f000, 0x0401f8a6, 0x0401f859, - 0x59c40805, 0x8c040d0a, 0x0402000b, 0x8c040d0c, - 0x04020006, 0x8c040d0e, 0x04000009, 0x4a035017, - 0x00000001, 0x0401f006, 0x4a035017, 0x00000000, - 0x0401f003, 0x4a035017, 0x00000002, 0x1c01f000, - 0x4a038808, 0x00000004, 0x0401f846, 0x59c40805, - 0x8c040d0a, 0x04020010, 0x8c040d08, 0x0402000b, - 0x8c040d0c, 0x04020006, 0x8c040d0e, 0x0400000c, - 0x4a035017, 0x00000001, 0x0401f009, 0x4a035017, - 0x00000000, 0x0401f006, 0x4a035017, 0x00000003, - 0x0401f003, 0x4a035017, 0x00000002, 0x1c01f000, - 0x0401f91f, 0x02020800, 0x001005d8, 0x59a80805, - 0x8c040d0c, 0x04000015, 0x84040d0c, 0x48075005, - 0x4a038805, 0x00000010, 0x0201f800, 0x00101937, - 0x59c40005, 0x8c000508, 0x04000008, 0x4a038808, - 0x00000008, 0x4a035033, 0x00000001, 0x4202d800, - 0x00000001, 0x0401f01a, 0x59c40006, 0x84000548, - 0x48038806, 0x0401f016, 0x59a80017, 0x82000580, - 0x00000001, 0x0400000c, 0x59a80017, 0x82000580, - 0x00000005, 0x0402000c, 0x42000000, 0x0010b844, - 0x0201f800, 0x0010aa47, 0x4a035017, 0x00000008, - 0x0401f007, 0x42000000, 0x0010b844, 0x0201f800, - 0x0010aa47, 0x4a035017, 0x00000004, 0x1c01f000, - 0x4803c856, 0x4c040000, 0x4c080000, 0x42000800, - 0x00000064, 0x42001000, 0x00105058, 0x0201f800, - 0x00106079, 0x5c001000, 0x5c000800, 0x1c01f000, - 0x4803c856, 0x4c040000, 0x0201f800, 0x00106c55, - 0x4df00000, 0x0201f800, 0x00106e21, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x0401ffba, 0x5c000800, - 0x1c01f000, 0x4803c856, 0x4c040000, 0x4c080000, - 0x0201f800, 0x00106c55, 0x4df00000, 0x0201f800, - 0x00106e21, 0x5c03e000, 0x02000800, 0x00106c4b, - 0x59c40006, 0x84000500, 0x48038806, 0x0201f800, - 0x00106ede, 0x497b8880, 0x0201f800, 0x0010a9c0, - 0x0201f800, 0x0010a9ce, 0x0201f800, 0x00101815, - 0x4a03504c, 0x00000004, 0x4202d800, 0x00000004, - 0x4a038805, 0x00000001, 0x42001000, 0x00105058, - 0x0201f800, 0x00106084, 0x0201f800, 0x001006d4, - 0x0401f8c1, 0x04000006, 0x42006000, 0xfeffffff, - 0x41786800, 0x0201f800, 0x0010427d, 0x0201f800, - 0x00100452, 0x42000000, 0x00000001, 0x0201f800, - 0x00101590, 0x5c001000, 0x5c000800, 0x1c01f000, - 0x59c40008, 0x8c000508, 0x04020007, 0x4a038808, - 0x00000010, 0x4201d000, 0x00001388, 0x0201f800, - 0x0010608e, 0x1c01f000, 0x4c040000, 0x59a80833, - 0x82040580, 0x00000000, 0x0400000b, 0x82040580, - 0x00000001, 0x0400000b, 0x82040580, 0x00000002, - 0x0400000b, 0x82040580, 0x00000003, 0x0400000b, - 0x0401f057, 0x4a035017, 0x00000000, 0x0401f009, - 0x4a035017, 0x00000004, 0x0401f006, 0x4a035017, - 0x00000001, 0x0401f003, 0x4a035017, 0x00000007, - 0x497b8880, 0x4a038893, 0x00000001, 0x41780000, - 0x0201f800, 0x00101606, 0x0201f800, 0x00106ede, - 0x836c0d80, 0x00000004, 0x04000008, 0x59c40006, - 0x82000500, 0xffffff0f, 0x82000540, 0x04000001, - 0x48038806, 0x0401f007, 0x59c40006, 0x82000500, - 0xffffff0f, 0x82000540, 0x04000000, 0x48038806, - 0x0401f875, 0x04020005, 0x59c40806, 0x82040d00, - 0xfbffff0f, 0x48078806, 0x4200b000, 0x00000005, - 0x59c40005, 0x8c000534, 0x04020033, 0x42006000, - 0xfc18ffff, 0x42006800, 0x01000000, 0x0201f800, - 0x0010427d, 0x0201f800, 0x00101937, 0x59c408a4, - 0x82040d00, 0x0000000f, 0x82040d80, 0x0000000c, - 0x0400000a, 0x42006000, 0xfeffffff, 0x42006800, - 0x02000000, 0x0201f800, 0x0010427d, 0x8058b040, - 0x040207e8, 0x0401f8a1, 0x0401f853, 0x04000006, - 0x42006000, 0xfeffffff, 0x41786800, 0x0201f800, - 0x0010427d, 0x836c0d80, 0x00000004, 0x04000006, - 0x59a8084d, 0x42001000, 0x00105065, 0x0201f800, - 0x0010606e, 0x4a035033, 0x00000004, 0x0401fe31, - 0x0401f841, 0x04020008, 0x59c408a4, 0x82040d00, - 0x0000000f, 0x82040580, 0x0000000c, 0x02020800, - 0x001005d8, 0x5c000800, 0x1c01f000, 0x4803c856, - 0x4c000000, 0x0201f800, 0x0010609e, 0x4a035010, - 0x00ffffff, 0x497b5032, 0x59a8002a, 0x82000500, - 0xffff0000, 0x4803502a, 0x497b8880, 0x497b8893, - 0x41780000, 0x0201f800, 0x00101606, 0x59c40001, - 0x82000500, 0xfffffcff, 0x48038801, 0x42006000, - 0xfc18ffff, 0x41786800, 0x0201f800, 0x0010427d, - 0x4a038808, 0x00000000, 0x5c000000, 0x800001c0, - 0x02020800, 0x0010411d, 0x4a038805, 0x040000f0, - 0x59c40006, 0x82000500, 0xffffffcf, 0x82000540, - 0x440000c1, 0x48038806, 0x1c01f000, 0x4c5c0000, - 0x59a8b832, 0x825cbd80, 0x0000aaaa, 0x5c00b800, - 0x1c01f000, 0x4c5c0000, 0x599cb818, 0x825cbd00, - 0x00000030, 0x825cbd80, 0x00000000, 0x5c00b800, - 0x1c01f000, 0x4c5c0000, 0x599cb818, 0x825cbd00, - 0x00000030, 0x825cbd80, 0x00000010, 0x5c00b800, - 0x1c01f000, 0x4c5c0000, 0x599cb818, 0x825cbd00, - 0x00000030, 0x825cbd80, 0x00000020, 0x5c00b800, - 0x1c01f000, 0x59a80005, 0x4803c857, 0x82000d00, - 0x00000013, 0x04000025, 0x599c1017, 0x4d3c0000, - 0x82000500, 0x00000011, 0x04000007, 0x42027800, - 0x00000400, 0x0201f800, 0x00103b25, 0x0402000a, - 0x0401f012, 0x42027800, 0x00000408, 0x0201f800, - 0x00103b25, 0x0400000d, 0x42003000, 0x00000003, - 0x0401f003, 0x42003000, 0x00000004, 0x42028000, - 0x0000000e, 0x0201f800, 0x0010a449, 0x599c1017, - 0x8c08150a, 0x04020007, 0x42028000, 0x00000004, - 0x0201f800, 0x00101fe5, 0x80000580, 0x0401f80d, - 0x5c027800, 0x0401f00a, 0x0201f800, 0x00103b25, - 0x04000007, 0x42028000, 0x0000000f, 0x42003000, - 0x00000001, 0x0201f800, 0x0010a449, 0x1c01f000, - 0x59a80005, 0x04000004, 0x82000540, 0x00000010, - 0x0401f003, 0x82000500, 0xffffffef, 0x48035005, - 0x4803c857, 0x1c01f000, 0x4803c856, 0x4c580000, - 0x42000000, 0x0010b8cb, 0x0201f800, 0x0010aa47, - 0x42000800, 0x0010c0f1, 0x59c40003, 0x44000800, - 0x59c40004, 0x48000801, 0x59c4000b, 0x48000802, - 0x59c4008e, 0x48000803, 0x59c4008f, 0x48000804, - 0x59c40090, 0x48000805, 0x59c40091, 0x48000806, - 0x59c40092, 0x48000807, 0x59c40093, 0x48000808, - 0x59c40099, 0x48000809, 0x59c4009e, 0x4800080a, - 0x59c400aa, 0x4800080b, 0x59c400af, 0x4800080c, - 0x59c400b2, 0x4800080d, 0x59c400b1, 0x4800080e, - 0x82040c00, 0x0000000f, 0x41c41800, 0x4200b000, - 0x00000030, 0x580c0050, 0x44000800, 0x80040800, - 0x800c1800, 0x8058b040, 0x040207fb, 0x41c41800, - 0x4200b000, 0x00000020, 0x580c0010, 0x44000800, - 0x80040800, 0x800c1800, 0x8058b040, 0x040207fb, - 0x497b8830, 0x4200b000, 0x00000040, 0x59c40031, - 0x44000800, 0x80040800, 0x8058b040, 0x040207fc, - 0x497b88ac, 0x4200b000, 0x00000010, 0x59c400ad, - 0x44000800, 0x80040800, 0x8058b040, 0x040207fc, - 0x59c41001, 0x4c080000, 0x8408150c, 0x480b8801, - 0x4a0370e4, 0x00000300, 0x4a0370e5, 0xb0000000, - 0x42000800, 0x00000800, 0x80040840, 0x02000800, - 0x001005d8, 0x59b800e5, 0x8c000538, 0x040207fb, - 0x4a0370e4, 0x00000200, 0x42006000, 0xffffffff, - 0x42006800, 0x80000000, 0x0201f800, 0x0010427d, - 0x4a038807, 0x00000001, 0x497b8807, 0x4a038808, - 0x00000010, 0x42006000, 0xfcf8ffff, 0x42006800, - 0x01000000, 0x0201f800, 0x0010427d, 0x5c001000, - 0x480b8801, 0x42000800, 0x0010c0f1, 0x50040000, - 0x48038803, 0x58040001, 0x48038804, 0x58040002, - 0x4803880b, 0x58040003, 0x4803888e, 0x58040004, - 0x4803888f, 0x58040005, 0x48038890, 0x58040006, - 0x48038891, 0x58040007, 0x48038892, 0x58040008, - 0x48038893, 0x58040009, 0x48038899, 0x5804000a, - 0x4803889e, 0x5804000b, 0x480388aa, 0x5804000c, - 0x480388af, 0x5804000d, 0x480388b2, 0x5804000e, - 0x480388b1, 0x82040c00, 0x0000000f, 0x41c41800, - 0x4200b000, 0x00000030, 0x50040000, 0x48001850, - 0x80040800, 0x800c1800, 0x8058b040, 0x040207fb, - 0x41c41800, 0x4200b000, 0x00000020, 0x50040000, - 0x48001810, 0x80040800, 0x800c1800, 0x8058b040, - 0x040207fb, 0x497b8830, 0x4200b000, 0x00000040, - 0x50040000, 0x48038831, 0x80040800, 0x8058b040, - 0x040207fc, 0x497b88ac, 0x4200b000, 0x00000010, - 0x50040000, 0x480388ad, 0x80040800, 0x8058b040, - 0x040207fc, 0x497b8880, 0x41780000, 0x0201f800, - 0x00101606, 0x59c408a4, 0x82040d00, 0x0000000f, - 0x82040580, 0x0000000c, 0x02020800, 0x001005d8, - 0x4a038805, 0x04000000, 0x5c00b000, 0x1c01f000, - 0x4803c856, 0x4c580000, 0x4ce80000, 0x42000000, - 0x0010b845, 0x0201f800, 0x0010aa47, 0x59c41008, - 0x4c080000, 0x82080500, 0xffffff7f, 0x48038808, - 0x59c40004, 0x82000500, 0x00003e02, 0x04000005, - 0x4201d000, 0x00000014, 0x0201f800, 0x0010608e, - 0x59c40006, 0x82000500, 0xffffff0f, 0x48038806, - 0x4a038805, 0x00000010, 0x4a038808, 0x00000004, - 0x4200b000, 0x00000065, 0x59c40005, 0x8c000508, - 0x04020012, 0x4201d000, 0x000003e8, 0x0201f800, - 0x0010608e, 0x8058b040, 0x040207f8, 0x0201f800, - 0x00106ede, 0x4a038808, 0x00000008, 0x4a035033, - 0x00000001, 0x4202d800, 0x00000001, 0x82000540, - 0x00000001, 0x0401f030, 0x0201f800, 0x00100ae0, - 0x42000000, 0x0010b8a8, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x00100ef4, 0x497b8880, 0x59a8002a, - 0x82000500, 0x0000ffff, 0x4c000000, 0x0201f800, - 0x00101606, 0x5c000000, 0x48038880, 0x4a038808, - 0x00000000, 0x4200b000, 0x00000065, 0x4a038805, - 0x000000f0, 0x0201f800, 0x00101937, 0x42000800, - 0x000000f0, 0x59c40005, 0x80040d00, 0x04000008, - 0x4201d000, 0x000003e8, 0x0201f800, 0x0010608e, - 0x8058b040, 0x040207f2, 0x0401f7d1, 0x59c40006, - 0x82000540, 0x000000f0, 0x48038806, 0x59a8001e, - 0x80000540, 0x04020002, 0x80000000, 0x48038893, - 0x80000580, 0x5c001000, 0x4df00000, 0x0201f800, - 0x0010195d, 0x5c03e000, 0x480b8808, 0x5c01d000, - 0x5c00b000, 0x1c01f000, 0x4803c856, 0x4c580000, - 0x4ce80000, 0x59c41008, 0x82080500, 0xffffff7f, - 0x48038808, 0x4c080000, 0x59c40004, 0x82000500, - 0x00003e02, 0x04000005, 0x4201d000, 0x00000014, - 0x0201f800, 0x0010608e, 0x0201f800, 0x00100ae0, - 0x42000000, 0x0010b8a9, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x00100ef4, 0x4a038808, 0x00000002, - 0x80000580, 0x48038880, 0x48038893, 0x0201f800, - 0x00101606, 0x4200b000, 0x00000384, 0x4a038805, - 0x000000f0, 0x0201f800, 0x00101937, 0x42000800, - 0x000000f0, 0x59c40005, 0x80040d00, 0x04000015, - 0x82000500, 0x000000d0, 0x04020012, 0x4201d000, - 0x00000067, 0x0201f800, 0x0010608e, 0x8058b040, - 0x040207ef, 0x0201f800, 0x00106ede, 0x4a038808, - 0x00000008, 0x4a035033, 0x00000001, 0x4202d800, - 0x00000001, 0x82000540, 0x00000001, 0x0401f010, - 0x497b8880, 0x59a8001e, 0x80000540, 0x04020002, - 0x80000000, 0x48038893, 0x59a8002a, 0x82000500, - 0x0000ffff, 0x4c000000, 0x0201f800, 0x00101606, - 0x5c000000, 0x48038880, 0x80000580, 0x5c001000, - 0x4df00000, 0x0201f800, 0x0010195d, 0x5c03e000, - 0x480b8808, 0x5c01d000, 0x5c00b000, 0x1c01f000, - 0x4803c856, 0x59c40004, 0x82000500, 0x00003e02, - 0x0400000a, 0x0201f800, 0x00106ede, 0x4a038808, - 0x00000008, 0x4a035033, 0x00000001, 0x4202d800, - 0x00000001, 0x0401f052, 0x0201f800, 0x00100ae0, - 0x42000000, 0x0010b8aa, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x00100ef4, 0x59c40006, 0x84000508, - 0x48038806, 0x4a038805, 0x00000010, 0x59a80805, - 0x84040d4c, 0x48075005, 0x42000800, 0x00000064, - 0x42001000, 0x00105058, 0x0201f800, 0x0010606e, - 0x4a038808, 0x00000000, 0x497b8880, 0x4a038805, - 0x000000f0, 0x0201f800, 0x00101937, 0x42000800, - 0x000000f0, 0x59c40005, 0x80040d00, 0x0400000e, - 0x82000500, 0x000000e0, 0x0402000b, 0x4201d000, - 0x000003e8, 0x0201f800, 0x0010608e, 0x0201f800, - 0x00105f48, 0x59940004, 0x80000540, 0x040207ec, - 0x0401f023, 0x4c080000, 0x42001000, 0x00105065, - 0x0201f800, 0x00105f90, 0x42001000, 0x00105058, - 0x0201f800, 0x00106084, 0x5c001000, 0x497b8880, - 0x59a8001e, 0x80000540, 0x04020002, 0x80000000, - 0x48038893, 0x59a8002a, 0x82000500, 0x0000ffff, - 0x4c000000, 0x0201f800, 0x00101606, 0x5c000000, - 0x48038880, 0x59a80805, 0x84040d0c, 0x48075005, - 0x59c40006, 0x84000548, 0x48038806, 0x0201f800, - 0x0010195d, 0x4a038808, 0x00000080, 0x1c01f000, - 0x4803c856, 0x4d400000, 0x4d3c0000, 0x0201f800, - 0x00106ede, 0x0201f800, 0x0010ab33, 0x04020025, - 0x599c1017, 0x59a80805, 0x8c040d00, 0x0402000c, - 0x8c08151a, 0x0400001f, 0x84040d42, 0x48075005, - 0x42028000, 0x00000004, 0x42027800, 0x0000000c, - 0x8c081508, 0x04020008, 0x0401f012, 0x42028000, - 0x00000004, 0x42027800, 0x00000004, 0x8c081508, - 0x0400000c, 0x4d400000, 0x42028000, 0x0000000e, - 0x42028800, 0x0000ffff, 0x0201f800, 0x0010a446, - 0x5c028000, 0x599c0817, 0x8c040d0a, 0x04020005, - 0x4943c857, 0x493fc857, 0x0201f800, 0x00101fe5, - 0x497b8880, 0x4202d800, 0x00000001, 0x0401fcfb, - 0x5c027800, 0x5c028000, 0x1c01f000, 0x0201f800, - 0x00100ae0, 0x42000000, 0x0010b8ab, 0x0201f800, - 0x0010aa47, 0x0201f800, 0x00100ef4, 0x42000000, - 0x00000001, 0x0201f800, 0x00101606, 0x4a038880, - 0x00000001, 0x0201f000, 0x0010195d, 0x4202e000, - 0x00000000, 0x4a033015, 0x00000001, 0x497b301d, - 0x497b3006, 0x4a03b004, 0x60000001, 0x59d80005, - 0x4a03b004, 0x90000001, 0x4a03a804, 0x60000001, - 0x59d40005, 0x4a03a804, 0x90000001, 0x0201f000, - 0x00105983, 0x4a03c825, 0x00000004, 0x4a03c827, - 0x00000004, 0x599c0409, 0x80000d40, 0x04000020, - 0x599c0407, 0x80000540, 0x04000007, 0x800000cc, - 0x599c100b, 0x80080400, 0x4803b000, 0x497bb002, - 0x59d80001, 0x599c000b, 0x4803b000, 0x599c000c, - 0x4803b001, 0x599c0407, 0x80000540, 0x04020002, - 0x497bb002, 0x599c0c09, 0x82040540, 0x00400000, - 0x4803b003, 0x4a03b009, 0x00000004, 0x4a03b004, - 0x10000001, 0x59e00803, 0x82040d00, 0xfffffeff, - 0x82040d40, 0x00008000, 0x4807c003, 0x599c040a, - 0x80000540, 0x04000020, 0x599c0408, 0x80000540, - 0x04000007, 0x800000cc, 0x599c100f, 0x80080400, - 0x4803a800, 0x497ba802, 0x59d40001, 0x599c000f, - 0x4803a800, 0x599c0010, 0x4803a801, 0x599c0408, - 0x80000540, 0x04020002, 0x497ba802, 0x599c0c0a, - 0x82040540, 0x00400000, 0x4803a803, 0x4a03a809, - 0x00000004, 0x4a03a804, 0x10000001, 0x59e00803, - 0x82040d00, 0xfffffbff, 0x82040d40, 0x00008000, - 0x4807c003, 0x800409c0, 0x04000007, 0x4202e000, - 0x00000001, 0x0200b800, 0x00020551, 0x0200f000, - 0x00020566, 0x1c01f000, 0x0201f800, 0x001005d8, - 0x1c01f000, 0x4df00000, 0x4203e000, 0x50000000, - 0x59981005, 0x800811c0, 0x0400001e, 0x58080005, - 0x82000d00, 0x43018780, 0x02020000, 0x00105846, - 0x8c000508, 0x04000015, 0x580a5808, 0x592c0204, - 0x497a5800, 0x497a5801, 0x82000500, 0x000000ff, - 0x82000c80, 0x0000004b, 0x0402100b, 0x0c01f80f, - 0x5c03e000, 0x83700580, 0x00000003, 0x040007e6, - 0x0200f800, 0x00020566, 0x0200b000, 0x00020551, - 0x1c01f000, 0x0401f850, 0x5c03e000, 0x0401f7f9, - 0x0401f8de, 0x0401f7fd, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x001054a1, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105519, 0x00105491, 0x00105491, 0x001054a1, - 0x001054a1, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x492fc857, 0x42000000, 0x0010b85e, - 0x0201f800, 0x0010aa47, 0x42000000, 0x00000400, - 0x0401f019, 0x492fc857, 0x42000000, 0x0010b85d, - 0x0201f800, 0x0010aa47, 0x42000000, 0x00001000, - 0x0401f011, 0x492fc857, 0x42000000, 0x0010b85c, - 0x0201f800, 0x0010aa47, 0x42000000, 0x00002000, - 0x0401f009, 0x492fc857, 0x42000000, 0x0010b85f, - 0x0201f800, 0x0010aa47, 0x42000000, 0x00000800, - 0x0401f001, 0x4803c857, 0x4202e000, 0x00000001, - 0x592c0c04, 0x82040d00, 0xffff80ff, 0x80040540, - 0x48025c04, 0x0201f000, 0x000202da, 0x592c0204, - 0x492fc857, 0x80000110, 0x040007db, 0x80000040, - 0x04000025, 0x48033002, 0x492f3003, 0x492f3004, - 0x4a033008, 0x001054e5, 0x4202e000, 0x00000003, - 0x1c01f000, 0x592c0204, 0x492fc857, 0x80000110, - 0x040007cd, 0x80000040, 0x04000033, 0x48033002, - 0x492f3003, 0x492f3004, 0x4a033008, 0x00105501, - 0x4202e000, 0x00000003, 0x1c01f000, 0x0201f800, - 0x0010ab33, 0x02020000, 0x000204d9, 0x42028000, - 0x00000028, 0x41780800, 0x417a6000, 0x0201f800, - 0x00104e70, 0x0201f800, 0x001091c6, 0x0201f000, - 0x000202da, 0x592c0a0a, 0x8c040d02, 0x04020016, - 0x59a80021, 0x492fc857, 0x80000540, 0x0402000f, - 0x592c0207, 0x80000540, 0x04000005, 0x0201f800, - 0x00104326, 0x04020004, 0x1c01f000, 0x42000000, - 0x00000000, 0x592c0a06, 0x48065c06, 0x48025a06, - 0x0201f000, 0x000202da, 0x42000000, 0x00000028, - 0x0401f7f9, 0x42000800, 0x00000009, 0x0201f000, - 0x0010665b, 0x592c0208, 0x492fc857, 0x82000c80, - 0x0000199a, 0x040217a4, 0x592c0408, 0x80000540, - 0x040207a1, 0x59a80821, 0x800409c0, 0x04020009, - 0x592c0207, 0x80000540, 0x0400079b, 0x497a5a06, - 0x0201f800, 0x00104385, 0x04020004, 0x1c01f000, - 0x42000000, 0x00000028, 0x48025a06, 0x0201f000, - 0x000202da, 0x59980804, 0x59980002, 0x48065800, - 0x492c0801, 0x492f3004, 0x80000040, 0x48033002, - 0x04000002, 0x1c01f000, 0x599a5803, 0x59980008, - 0x4202e000, 0x00000001, 0x0801f000, 0x592e8a06, - 0x592c0406, 0x4803c856, 0x82000500, 0x000000ff, - 0x4200b800, 0x00000001, 0x82000d80, 0x00000001, - 0x04000015, 0x417a8800, 0x4200b800, 0x000007f0, - 0x82000d80, 0x00000002, 0x0400000f, 0x80000540, - 0x02020000, 0x000202da, 0x592e8a06, 0x0201f800, - 0x00020245, 0x02020000, 0x000202da, 0x592e9008, - 0x592e9809, 0x0201f800, 0x00104713, 0x0201f000, - 0x000202da, 0x59a80805, 0x84040d00, 0x48075005, - 0x0201f800, 0x00020245, 0x02000800, 0x0010482c, - 0x81468800, 0x805cb840, 0x040207fa, 0x0201f000, - 0x000202da, 0x592c0a08, 0x4807c857, 0x82040580, - 0x0000000e, 0x04000045, 0x82040580, 0x00000046, - 0x04000046, 0x82040580, 0x00000045, 0x04000020, - 0x82040580, 0x00000029, 0x04000010, 0x82040580, - 0x0000002a, 0x04000009, 0x82040580, 0x0000000f, - 0x040001fc, 0x82040580, 0x0000002e, 0x040001f9, - 0x4807c856, 0x0401f1f2, 0x59a80805, 0x84040d04, - 0x48075005, 0x0401f1f3, 0x592e8a06, 0x0201f800, - 0x00020245, 0x040201ef, 0x59340200, 0x84000518, - 0x48026a00, 0x592e6009, 0x4933c857, 0x83300580, - 0xffffffff, 0x0402002a, 0x0401f1e6, 0x592c1407, - 0x480bc857, 0x0201f800, 0x00109410, 0x411e6000, - 0x04020003, 0x4803c856, 0x0401f1d9, 0x592e3809, - 0x591c1414, 0x84081516, 0x84081554, 0x480a3c14, - 0x4a026403, 0x0000003a, 0x592c040b, 0x80000540, - 0x04000007, 0x4a026403, 0x0000003b, 0x592c020c, - 0x4802641a, 0x592c040c, 0x4802621a, 0x4a026203, - 0x00000001, 0x42000800, 0x80000040, 0x0201f800, - 0x00020721, 0x0401f1c7, 0x59a80068, 0x84000510, - 0x48035068, 0x0401f1c3, 0x592c1207, 0x8c081500, - 0x040201c0, 0x592e8a06, 0x592e6009, 0x0201f800, - 0x0010941a, 0x04020003, 0x4803c856, 0x0401f1b4, - 0x59300c06, 0x82040580, 0x00000004, 0x04000003, - 0x4803c856, 0x0401f1ae, 0x59300a03, 0x82040580, - 0x00000007, 0x04000003, 0x4803c856, 0x0401f1a8, - 0x59300c03, 0x82040580, 0x00000001, 0x04000021, - 0x82040580, 0x00000003, 0x04000016, 0x82040580, - 0x00000006, 0x04000020, 0x82040580, 0x00000008, - 0x04000015, 0x82040580, 0x0000000a, 0x0400000a, - 0x82040580, 0x0000000c, 0x04000004, 0x82040580, - 0x0000002e, 0x04020018, 0x42000800, 0x00000009, - 0x0401f013, 0x42000800, 0x00000005, 0x0401f010, - 0x417a7800, 0x0201f800, 0x0010203c, 0x4a026406, - 0x00000001, 0x42000800, 0x00000003, 0x0401f008, - 0x417a7800, 0x0201f800, 0x0010203c, 0x4a026406, - 0x00000001, 0x42000800, 0x0000000b, 0x0201f800, - 0x00104571, 0x4a026203, 0x00000001, 0x0201f800, - 0x0010672b, 0x0401f17b, 0x40000800, 0x58040000, - 0x80000540, 0x040207fd, 0x492c0800, 0x1c01f000, - 0x492fc857, 0x59300c06, 0x82040580, 0x00000006, - 0x04020094, 0x0201f800, 0x001049e7, 0x04020005, - 0x59340200, 0x8c00051a, 0x02000000, 0x00020533, - 0x59340200, 0x8c00050e, 0x0400008a, 0x59300203, - 0x42027800, 0x00000001, 0x82000580, 0x00000007, - 0x02020000, 0x00020533, 0x4a026203, 0x00000002, - 0x0201f000, 0x00020533, 0x42028000, 0x00000002, - 0x4a026206, 0x00000014, 0x4d2c0000, 0x0201f800, - 0x0010a1d1, 0x5c025800, 0x59300c06, 0x4807c857, - 0x82040580, 0x00000007, 0x04020063, 0x492fc857, - 0x4a025a06, 0x00000001, 0x0201f000, 0x000202da, - 0x592c240a, 0x492fc857, 0x4813c857, 0x8c10251c, - 0x04020016, 0x8c10251a, 0x04000003, 0x8c10250a, - 0x04000069, 0x59340a00, 0x8c040d0e, 0x04000003, - 0x8c10251e, 0x04000064, 0x0201f800, 0x0002075a, - 0x0400006b, 0x592c240a, 0x49366009, 0x49325809, - 0x4a026406, 0x00000006, 0x4a026203, 0x00000007, - 0x0201f000, 0x0002052f, 0x592c0a0c, 0x5934000f, - 0x41784000, 0x80001540, 0x0400006d, 0x58080204, - 0x82000500, 0x000000ff, 0x82000580, 0x00000012, - 0x04020004, 0x5808020c, 0x80040580, 0x04000004, - 0x58080000, 0x40084000, 0x0401f7f3, 0x58080000, - 0x49781000, 0x802041c0, 0x04000006, 0x48004000, - 0x80000540, 0x04020007, 0x48226810, 0x0401f005, - 0x4802680f, 0x80000540, 0x04020002, 0x497a6810, - 0x4d2c0000, 0x400a5800, 0x4a025a06, 0x00000002, - 0x0201f800, 0x000202da, 0x5c025800, 0x0401f7bc, - 0x592c040a, 0x8c00051c, 0x04000016, 0x592c0206, - 0x82000580, 0x0000ffff, 0x04020012, 0x592e6009, - 0x83300580, 0xffffffff, 0x040007b1, 0x83300480, - 0x0010d1c0, 0x04001010, 0x59a8000b, 0x81300480, - 0x0402100d, 0x59300008, 0x800001c0, 0x04020005, - 0x59300203, 0x82000580, 0x00000007, 0x04000797, - 0x492fc857, 0x4a025a06, 0x00000029, 0x0201f000, - 0x000202da, 0x492fc857, 0x4a025a06, 0x00000008, - 0x0201f000, 0x000202da, 0x492fc857, 0x4a025a06, - 0x00000045, 0x0201f000, 0x000202da, 0x492fc857, - 0x4a025a06, 0x0000002a, 0x0201f000, 0x000202da, - 0x492fc857, 0x4a025a06, 0x00000028, 0x0201f000, - 0x000202da, 0x492fc857, 0x4a025a06, 0x00000006, - 0x0201f000, 0x000202da, 0x492fc857, 0x4a025a06, - 0x0000000e, 0x0201f000, 0x000202da, 0x59340010, - 0x492e6810, 0x492fc857, 0x80000d40, 0x04000003, - 0x492c0800, 0x1c01f000, 0x5934040b, 0x492e680f, - 0x492fc857, 0x4803c857, 0x80000540, 0x04020003, - 0x4a026a03, 0x00000001, 0x1c01f000, 0x59a8000e, - 0x81640480, 0x0402176e, 0x42026000, 0x0010d1c0, - 0x59300009, 0x81340580, 0x04020004, 0x59300202, - 0x80040580, 0x04000759, 0x83326400, 0x00000024, - 0x41580000, 0x81300480, 0x040017f6, 0x0401f760, - 0x492fc857, 0x592c0407, 0x82000c80, 0x0000199a, - 0x040215f1, 0x592c0204, 0x80000112, 0x040205de, - 0x592e8a06, 0x0201f800, 0x00020245, 0x04020059, - 0x0201f800, 0x001049e7, 0x04020059, 0x592e780a, - 0x493fc857, 0x8d3e7d3e, 0x04020007, 0x59a80021, - 0x80000540, 0x0402004f, 0x0201f800, 0x00104838, - 0x040005dd, 0x833c1d00, 0x0000001f, 0x040005da, - 0x592c0207, 0x82000c80, 0x00001000, 0x040215d6, - 0x800000c2, 0x800008c4, 0x8005d400, 0x592e9008, - 0x592e9809, 0x5934080d, 0x800409c0, 0x0402002e, - 0x833c1d00, 0x0000001f, 0x81780040, 0x80000000, - 0x800c1902, 0x040217fe, 0x040205c7, 0x0c01f001, - 0x001056e9, 0x001056ec, 0x001056f9, 0x001056fc, - 0x001056ff, 0x0201f800, 0x0010903e, 0x0401f01a, - 0x0201f800, 0x0010480b, 0x04000027, 0x80e9d1c0, - 0x02020800, 0x00105fae, 0x42028000, 0x00000005, - 0x417a9000, 0x417a9800, 0x0201f800, 0x0010904e, - 0x0401f00d, 0x42027000, 0x0000004d, 0x0401f006, - 0x42027000, 0x0000004e, 0x0401f003, 0x42027000, - 0x00000052, 0x0201f800, 0x001046c9, 0x02020800, - 0x0010907e, 0x04000010, 0x8d3e7d3e, 0x04020017, - 0x1c01f000, 0x58040002, 0x80000540, 0x04020007, - 0x4d3c0000, 0x40067800, 0x0201f800, 0x001047eb, - 0x5c027800, 0x040207cb, 0x4a025a06, 0x00000030, - 0x0401f00d, 0x4a025a06, 0x0000002c, 0x0401f00a, - 0x4a025a06, 0x00000028, 0x0401f007, 0x4a025a06, - 0x00000029, 0x0401f004, 0x497a5c09, 0x4a025a06, - 0x00000000, 0x4a025a04, 0x00000103, 0x0201f000, - 0x000202da, 0x492fc857, 0x592c0204, 0x80000110, - 0x80000040, 0x04000002, 0x0401f56f, 0x592c0207, - 0x82000500, 0x000003ff, 0x48025a07, 0x8c000506, - 0x04000004, 0x82000500, 0x00000070, 0x04020004, - 0x59a80821, 0x800409c0, 0x04020018, 0x4a025a06, - 0x0000dead, 0x592c0408, 0x82000500, 0x0000f0ff, - 0x48025c08, 0x0201f800, 0x001043b4, 0x04020002, - 0x1c01f000, 0x49425a06, 0x8058b1c0, 0x04000009, - 0x0201f800, 0x0010955f, 0x0401f80f, 0x44042800, - 0x82580580, 0x00000002, 0x04020002, 0x48082801, - 0x0201f000, 0x000202da, 0x42028000, 0x00000031, - 0x42000800, 0x00000001, 0x4200b000, 0x00000001, - 0x0401f7ed, 0x592c0408, 0x80000118, 0x832c2c00, - 0x00000009, 0x80142c00, 0x1c01f000, 0x492fc857, - 0x4a025a08, 0x00000006, 0x0201f000, 0x000202da, - 0x492fc857, 0x4a025a08, 0x00000001, 0x0201f000, - 0x000202da, 0x492fc857, 0x592c040a, 0x82000500, - 0x00000003, 0x04000020, 0x0201f800, 0x0002075a, - 0x04000021, 0x592c0204, 0x492e6008, 0x82000500, - 0x000000ff, 0x82000580, 0x00000045, 0x0400000e, - 0x592c000b, 0x0201f800, 0x00105c9a, 0x02000800, - 0x00020245, 0x04020018, 0x42027000, 0x00000041, - 0x49366009, 0x4a026406, 0x00000001, 0x0201f000, - 0x000207a1, 0x59300015, 0x8400055e, 0x48026015, - 0x42026800, 0x0010b524, 0x42027000, 0x00000040, - 0x0401f7f4, 0x4a025a06, 0x00000101, 0x0201f000, - 0x000202da, 0x4a025a06, 0x0000002c, 0x0201f000, - 0x000202da, 0x4a025a06, 0x00000028, 0x0201f800, - 0x000202da, 0x0201f000, 0x0002077d, 0x492fc857, - 0x0201f800, 0x001062e1, 0x0400000b, 0x592c0204, - 0x80000110, 0x80000040, 0x040204fb, 0x592c0c06, - 0x800409c0, 0x04000009, 0x42000000, 0x00000102, - 0x0401f003, 0x42000000, 0x00000104, 0x48025a06, - 0x0201f000, 0x000202da, 0x592c0c07, 0x800409c0, - 0x04000024, 0x82040480, 0x00000005, 0x04021021, - 0x4c040000, 0x80040800, 0x0201f800, 0x00106306, - 0x5c001000, 0x04020018, 0x832c0400, 0x00000008, - 0x4000a000, 0x0201f800, 0x0010632f, 0x04020012, - 0x592c1207, 0x82cc0580, 0x0010b50e, 0x04020009, - 0x58c80c0b, 0x84040d00, 0x84040d02, 0x8c081500, - 0x04000002, 0x84040d5e, 0x4805940b, 0x0401f001, - 0x42000000, 0x00000000, 0x48025a06, 0x0201f000, - 0x000202da, 0x42000000, 0x00000103, 0x0401f7fb, - 0x42000000, 0x00000102, 0x0401f7f8, 0x492fc857, - 0x592e7c06, 0x833c0500, 0xfffffffe, 0x04020043, - 0x592c4007, 0x42026000, 0x0010d1c0, 0x41581800, - 0x400c0000, 0x81300480, 0x04021023, 0x59300203, - 0x82000580, 0x00000000, 0x04000007, 0x59300008, - 0x80000d40, 0x04000004, 0x58040005, 0x80200580, - 0x04000004, 0x83326400, 0x00000024, 0x0401f7f1, - 0x58040204, 0x82000500, 0x000000ff, 0x82000d80, - 0x00000053, 0x04000007, 0x82000d80, 0x00000048, - 0x04000004, 0x82000580, 0x00000018, 0x04020023, - 0x4d2c0000, 0x0201f800, 0x00108be3, 0x5c025800, - 0x0400001e, 0x4a025a06, 0x00000000, 0x0201f000, - 0x000202da, 0x592e8a06, 0x83440480, 0x000007f0, - 0x04021016, 0x83440400, 0x0010ac00, 0x50000000, - 0x80026d40, 0x04000011, 0x4d2c0000, 0x0201f800, - 0x001047cb, 0x0400000c, 0x42028000, 0x00000005, - 0x592c0a08, 0x0201f800, 0x00104e70, 0x0201f800, - 0x001091cc, 0x0201f800, 0x000202da, 0x5c025800, - 0x0401f7e5, 0x5c025800, 0x4a025a06, 0x00000031, - 0x0201f000, 0x000202da, 0x492fc857, 0x4d2c0000, - 0x0201f800, 0x001007e4, 0x04000016, 0x492fc857, - 0x412f4000, 0x0201f800, 0x001007e4, 0x0400000e, - 0x492fc857, 0x412dd800, 0x0201f800, 0x00103b28, - 0x0201f800, 0x00103b32, 0x49a1d80b, 0x5c025800, - 0x492dd80a, 0x0201f800, 0x00102214, 0x0201f000, - 0x00102233, 0x41a25800, 0x0201f800, 0x001007f4, - 0x5c025800, 0x4a025a06, 0x00004005, 0x4a025c06, - 0x00000002, 0x0201f000, 0x000202da, 0x4807c857, - 0x485fc857, 0x4200b800, 0x00000001, 0x5c000800, - 0x4c5c0000, 0x0401f005, 0x4807c857, 0x485fc857, - 0x5c000800, 0x4d780000, 0x4803c857, 0x492fc857, - 0x8c00050e, 0x02020800, 0x001005d0, 0x4203e000, - 0x50000000, 0x4200b800, 0x00008003, 0x0201f000, - 0x001005dd, 0x592c0204, 0x80000110, 0x80000040, - 0x04020441, 0x0201f800, 0x00104a34, 0x04020002, - 0x1c01f000, 0x49425a06, 0x4806580d, 0x480a580e, - 0x4943c857, 0x4807c857, 0x480bc857, 0x0201f000, - 0x000202da, 0x592c0204, 0x80000110, 0x80000040, - 0x04020431, 0x0201f800, 0x00104b8b, 0x04020002, - 0x1c01f000, 0x49425a06, 0x48065811, 0x480a5812, - 0x0201f000, 0x000202da, 0x592c0204, 0x80000110, - 0x04000425, 0x80000040, 0x0402000c, 0x4202e000, - 0x00000001, 0x592c020a, 0x8c000504, 0x02000000, - 0x000204d0, 0x592c0207, 0x82000c80, 0x00001001, - 0x04021429, 0x0401f009, 0x4202e000, 0x00000003, - 0x48033002, 0x492f3003, 0x492f3004, 0x4a033008, - 0x000204d0, 0x1c01f000, 0x4202e000, 0x00000002, - 0x42000000, 0x0010beda, 0x50007000, 0x492c700b, - 0x4978700e, 0x4978700c, 0x592c0011, 0x592c0812, - 0x48007007, 0x48047008, 0x592c1013, 0x82080500, - 0xffff0000, 0x04000003, 0x0201f800, 0x001005d8, - 0x4978700d, 0x82080480, 0x00000180, 0x4803c857, - 0x04001007, 0x4800700f, 0x4a007005, 0x00000180, - 0x4a007004, 0x00000060, 0x0401f005, 0x4978700f, - 0x48087005, 0x80081104, 0x48087004, 0x5838000a, - 0x48007003, 0x40381000, 0x0201f000, 0x00100858, - 0x0201f800, 0x001007d3, 0x04000003, 0x59980007, - 0x0801f000, 0x1c01f000, 0x40307000, 0x5838000b, - 0x80025d40, 0x0400001b, 0x58380002, 0x82000580, - 0x00000100, 0x0400001d, 0x4c380000, 0x592c0204, - 0x82000500, 0x000000ff, 0x82000580, 0x00000012, - 0x0400000b, 0x592c0208, 0x8400054e, 0x48025a08, - 0x4a025a06, 0x00000002, 0x4a025a04, 0x00000103, - 0x0201f800, 0x000202c1, 0x0401f005, 0x4a025a06, - 0x00000010, 0x0201f800, 0x000202da, 0x5c007000, - 0x4202e000, 0x00000001, 0x4a007002, 0x00000100, - 0x49787010, 0x1c01f000, 0x58380004, 0x82000480, - 0x00000003, 0x04000087, 0x58380010, 0x8c000500, - 0x04020019, 0x4200b000, 0x00000003, 0x832cac00, - 0x00000011, 0x5838000a, 0x5838100d, 0x8008a400, - 0x4c380000, 0x0201f800, 0x0010ab17, 0x5c007000, - 0x5838000d, 0x82000400, 0x00000003, 0x4800700d, - 0x4a007010, 0x00000001, 0x58380004, 0x82000480, - 0x00000003, 0x48007004, 0x82000580, 0x00000003, - 0x0400006c, 0x5838000e, 0x80001d40, 0x04020020, - 0x4c380000, 0x0201f800, 0x001007d3, 0x5c007000, - 0x04000010, 0x4a025a04, 0x0000010a, 0x42001800, - 0x00000005, 0x480c700e, 0x5838000c, 0x80000540, - 0x04020002, 0x5838000b, 0x40000800, 0x492c0801, - 0x492c700c, 0x42000800, 0x0000000f, 0x0401f011, - 0x4202e000, 0x00000008, 0x4a033007, 0x00105915, - 0x1c01f000, 0x4202e000, 0x00000002, 0x42000000, - 0x0010beda, 0x50007000, 0x0401f7e7, 0x583a580c, - 0x400c0000, 0x42000800, 0x00000014, 0x80040c80, - 0x58381004, 0x5838000f, 0x41783000, 0x80000540, - 0x04020005, 0x84183540, 0x82081480, 0x00000003, - 0x0400003c, 0x40080000, 0x80040480, 0x04001002, - 0x40080800, 0x4004b000, 0x412c0000, 0x800c0400, - 0x4000a800, 0x5838000a, 0x5838100d, 0x8008a400, - 0x4c080000, 0x4c040000, 0x4c0c0000, 0x4c380000, - 0x0201f800, 0x0010ab17, 0x5c007000, 0x5c001800, - 0x5c000800, 0x40040000, 0x58381004, 0x80080480, - 0x48007004, 0x82000580, 0x00000003, 0x04000002, - 0x84183500, 0x5c000000, 0x80041400, 0x82080480, - 0x00000060, 0x04020003, 0x84183542, 0x41781000, - 0x400c0000, 0x80041c00, 0x820c0480, 0x00000014, - 0x04020003, 0x84183544, 0x40001800, 0x40080800, - 0x4804700d, 0x480c700e, 0x40180000, 0x0c01f001, - 0x00105960, 0x00105964, 0x00105962, 0x00105960, - 0x001058fc, 0x00105964, 0x00105962, 0x00105960, - 0x0201f800, 0x001005d8, 0x5838100f, 0x0401f739, - 0x5838080d, 0x82040400, 0x00000002, 0x5838100a, - 0x80080400, 0x50001000, 0x800811c0, 0x0402000f, - 0x4202e000, 0x00000001, 0x583a580b, 0x4978700b, - 0x49787010, 0x592c0204, 0x82000500, 0x000000ff, - 0x82000580, 0x00000012, 0x02000000, 0x00020507, - 0x0201f000, 0x000204d0, 0x5838000a, 0x80040c00, - 0x82381c00, 0x00000007, 0x54041800, 0x80040800, - 0x800c1800, 0x54041800, 0x0401f71a, 0x0201f800, - 0x001007d3, 0x02000800, 0x001005d8, 0x4a02580a, - 0x0010be79, 0x42000800, 0x0010beda, 0x452c0800, - 0x497a580b, 0x497a580c, 0x497a580d, 0x497a580e, - 0x497a580f, 0x4a025809, 0x001058b6, 0x497a5810, - 0x4a025802, 0x00000100, 0x4a025801, 0x00000001, - 0x1c01f000, 0x59c80007, 0x8c000502, 0x04000070, - 0x835c2c80, 0x00000005, 0x02001000, 0x00105f23, - 0x59c82817, 0x497b9005, 0x82140500, 0x00e00000, - 0x0402004f, 0x82140500, 0x000003ff, 0x82001c00, - 0x00000006, 0x41cc2000, 0x42003000, 0x00006080, - 0x820c0480, 0x00000040, 0x04001006, 0x42001000, - 0x00000040, 0x820c1c80, 0x00000040, 0x0401f003, - 0x400c1000, 0x41781800, 0x54182000, 0x80102000, - 0x80183000, 0x80081040, 0x040207fc, 0x800c19c0, - 0x04000005, 0x59c80005, 0x80000000, 0x48039005, - 0x0401f7ea, 0x82140500, 0x01f60000, 0x04020029, - 0x82140500, 0x0000f000, 0x0400000b, 0x82000c80, - 0x00002000, 0x0402100f, 0x82140500, 0x0e000000, - 0x80000132, 0x0c01f840, 0x4a039005, 0x00000140, - 0x1c01f000, 0x59cc0400, 0x82000500, 0x0000ff00, - 0x82000580, 0x00008100, 0x040007f4, 0x0401f01c, - 0x4817c857, 0x82140500, 0x000003ff, 0x04020007, - 0x59cc0400, 0x82000500, 0x0000ff00, 0x82000580, - 0x00008100, 0x04020012, 0x42000000, 0x0010b8bd, - 0x0201f800, 0x0010aa47, 0x0201f800, 0x00105dfa, - 0x4803c856, 0x4a039005, 0x00000140, 0x0401f020, - 0x4817c857, 0x82140500, 0x00f60000, 0x04020004, - 0x0201f800, 0x00105e35, 0x040207d2, 0x0201f800, - 0x0010513b, 0x04000010, 0x59c400a4, 0x4803c857, - 0x82000500, 0x0000000f, 0x82000580, 0x0000000a, - 0x04020009, 0x497b5016, 0x59c400a3, 0x82000540, - 0x00080000, 0x480388a3, 0x82000500, 0xfff7ffff, - 0x480388a3, 0x4817c856, 0x0201f800, 0x0010a978, - 0x4a039005, 0x00000140, 0x0401f842, 0x4803c856, - 0x1c01f000, 0x00105a1d, 0x00105cf4, 0x00105a15, - 0x00105a15, 0x00105a15, 0x00105a15, 0x00105a15, - 0x00105a15, 0x4803c857, 0x42000000, 0x0010b85a, - 0x0201f800, 0x0010aa47, 0x4a039005, 0x00000140, - 0x1c01f000, 0x4817c857, 0x59cc0400, 0x4803c857, - 0x82000d00, 0x0000ff00, 0x82041500, 0x0000f000, - 0x840409c0, 0x82140500, 0x000003ff, 0x800018c4, - 0x8c142d14, 0x04000005, 0x59cc0002, 0x82000500, - 0x00000003, 0x800c1c80, 0x480f5016, 0x82080580, - 0x00002000, 0x04020011, 0x836c0580, 0x00000001, - 0x0402000c, 0x59cc0006, 0x82000500, 0xff000000, - 0x82000580, 0x11000000, 0x04020011, 0x0201f800, - 0x00103b38, 0x0201f800, 0x00105f48, 0x0401f00c, - 0x0401f81f, 0x0401f00a, 0x82080580, 0x00003000, - 0x04020003, 0x0401fa06, 0x0401f005, 0x82080580, - 0x00008000, 0x04020002, 0x0401fafc, 0x1c01f000, - 0x4817c857, 0x42000000, 0x0010b859, 0x0201f800, - 0x0010aa47, 0x836c0580, 0x00000003, 0x0402000b, - 0x4c080000, 0x4c0c0000, 0x42001000, 0x00008048, - 0x40141800, 0x80142120, 0x0201f800, 0x00103a3e, - 0x5c001800, 0x5c001000, 0x1c01f000, 0x4807c857, - 0x59cc0002, 0x82000500, 0xff000000, 0x82001580, - 0x01000000, 0x04000004, 0x82001580, 0x23000000, - 0x04020192, 0x82040580, 0x00000023, 0x0402003f, - 0x0401fb6a, 0x0400018d, 0x59300c06, 0x82040580, - 0x00000010, 0x04000013, 0x82040580, 0x00000011, - 0x04000010, 0x82040580, 0x00000001, 0x0400000d, - 0x82040580, 0x00000004, 0x0400000a, 0x82040580, - 0x00000008, 0x04000007, 0x82040580, 0x0000000a, - 0x04000004, 0x4933c857, 0x4807c857, 0x0401f177, - 0x59300004, 0x82000500, 0x80010000, 0x04000004, - 0x0201f800, 0x00106f60, 0x04020170, 0x59cc0a04, - 0x48066202, 0x59cc0006, 0x82000500, 0xffff0000, - 0x82000d80, 0x02000000, 0x04020005, 0x42027000, - 0x00000015, 0x0201f000, 0x000207a1, 0x82000d80, - 0x02140000, 0x040007fa, 0x82000d80, 0x02100000, - 0x040007f7, 0x82000d80, 0x02100000, 0x040007f4, - 0x82000d80, 0x01000000, 0x04020158, 0x59cc0006, - 0x82000500, 0x0000ffff, 0x04020154, 0x42027000, - 0x00000016, 0x0401f7ec, 0x82040580, 0x00000022, - 0x0402014e, 0x59a80806, 0x8c040d14, 0x04000011, - 0x0401f967, 0x0402000f, 0x0401f97d, 0x0400000d, - 0x42027000, 0x0000004c, 0x59cc0001, 0x82000500, - 0x00ffffff, 0x0201f800, 0x00105eec, 0x0400012a, - 0x42028800, 0x0000ffff, 0x417a6800, 0x0401f126, - 0x59cc0006, 0x82000500, 0xffff0000, 0x82000d80, - 0x03000000, 0x04020021, 0x59a80026, 0x8c000508, - 0x04000017, 0x8400054c, 0x48035026, 0x59cc0800, - 0x82040d00, 0x00ffffff, 0x48075010, 0x497b8830, - 0x84040d70, 0x48078832, 0x59c40802, 0x84040d4c, - 0x48078802, 0x59cc0007, 0x82000500, 0x0000ffff, - 0x48038893, 0x4803501e, 0x42000800, 0x00000003, - 0x59a81010, 0x0201f800, 0x00106c78, 0x59cc0006, - 0x82000500, 0x0000ffff, 0x04020118, 0x42027000, - 0x00000017, 0x0401f0d9, 0x82000d80, 0x04000000, - 0x04020011, 0x59cc0006, 0x82000500, 0x0000ffff, - 0x0402010e, 0x0201f800, 0x0010513b, 0x04000004, - 0x42027000, 0x0000001d, 0x0401f0cc, 0x59a80026, - 0x84000548, 0x48035026, 0x42027000, 0x00000030, - 0x0401f0c6, 0x82000d80, 0x05000000, 0x04020008, - 0x59cc0006, 0x82000500, 0x0000ffff, 0x040200fb, - 0x42027000, 0x00000018, 0x0401f0bc, 0x82000d80, - 0x20100000, 0x04020004, 0x42027000, 0x00000019, - 0x0401f0b6, 0x82000d80, 0x21100000, 0x04020004, - 0x42027000, 0x0000001a, 0x0401f0b0, 0x82000d80, - 0x52000000, 0x04020008, 0x59cc0006, 0x82000500, - 0x0000ffff, 0x040200e5, 0x42027000, 0x0000001b, - 0x0401f0a6, 0x82000d80, 0x50000000, 0x04020008, - 0x59cc0006, 0x82000500, 0x0000ffff, 0x040200db, - 0x42027000, 0x0000001c, 0x0401f09c, 0x82000d80, - 0x13000000, 0x04020004, 0x42027000, 0x00000034, - 0x0401f096, 0x82000d80, 0x12000000, 0x04020008, - 0x59cc0006, 0x82000500, 0x0000ffff, 0x040200cb, - 0x42027000, 0x00000024, 0x0401f08c, 0x82000d00, - 0xff000000, 0x82040d80, 0x24000000, 0x04020004, - 0x42027000, 0x0000002d, 0x0401f084, 0x82000d00, - 0xff000000, 0x82040d80, 0x53000000, 0x04020004, - 0x42027000, 0x0000002a, 0x0401f07c, 0x82000d80, - 0x0f000000, 0x04020004, 0x42027000, 0x00000020, - 0x0401f076, 0x82000d80, 0x61040000, 0x04020036, - 0x83cc1400, 0x00000006, 0x80080800, 0x50080000, - 0x82000500, 0x0000ffff, 0x82000480, 0x00000004, - 0x4c580000, 0x8000b104, 0x8058b1c0, 0x04000026, - 0x4c100000, 0x50041800, 0x820c1500, 0x03000000, - 0x80081130, 0x42000000, 0x0010b817, 0x82082580, - 0x00000000, 0x04020004, 0x42000000, 0x0010b814, - 0x0401f00c, 0x82082580, 0x00000001, 0x04020004, - 0x42000000, 0x0010b815, 0x0401f006, 0x82082580, - 0x00000002, 0x04020003, 0x42000000, 0x0010b816, - 0x0201f800, 0x0010aa47, 0x42001000, 0x00008015, - 0x820c2500, 0x0000ffff, 0x800c1920, 0x0201f800, - 0x00103a3e, 0x5c002000, 0x80040800, 0x8058b040, - 0x040207da, 0x5c00b000, 0x42027000, 0x00000023, - 0x0401f03e, 0x82000d80, 0x60000000, 0x04020004, - 0x42027000, 0x0000003f, 0x0401f038, 0x82000d80, - 0x54000000, 0x04020006, 0x0401fb12, 0x0402006f, - 0x42027000, 0x00000046, 0x0401f030, 0x82000d80, - 0x55000000, 0x04020009, 0x0401fb32, 0x04020004, - 0x42027000, 0x00000041, 0x0401f028, 0x42027000, - 0x00000042, 0x0401f025, 0x82000d80, 0x78000000, - 0x04020004, 0x42027000, 0x00000045, 0x0401f01f, - 0x82000d80, 0x10000000, 0x04020004, 0x42027000, - 0x0000004e, 0x0401f019, 0x82000d80, 0x63000000, - 0x04020004, 0x42027000, 0x0000004a, 0x0401f013, - 0x82000d00, 0xff000000, 0x82040d80, 0x56000000, - 0x04020004, 0x42027000, 0x0000004f, 0x0401f00b, - 0x82000d00, 0xff000000, 0x82040d80, 0x57000000, - 0x04020004, 0x42027000, 0x00000050, 0x0401f003, - 0x42027000, 0x0000001d, 0x59cc3800, 0x821c3d00, - 0x00ffffff, 0x821c0580, 0x00fffffe, 0x59cc0001, - 0x04020005, 0x40003000, 0x42028800, 0x000007fe, - 0x0401f003, 0x0401f8d1, 0x04020030, 0x0201f800, - 0x001045a6, 0x0402002d, 0x83380580, 0x00000046, - 0x04020004, 0x59a80010, 0x80180580, 0x04000027, - 0x59340200, 0x8c000514, 0x0400000f, 0x83380580, - 0x00000030, 0x0400000c, 0x83380580, 0x0000003f, - 0x04000009, 0x83380580, 0x00000034, 0x04000006, - 0x83380580, 0x00000024, 0x04000003, 0x42027000, - 0x0000004c, 0x0201f800, 0x0002075a, 0x04000018, - 0x49366009, 0x4a026406, 0x00000004, 0x59cc0c04, - 0x48066202, 0x83380580, 0x0000004c, 0x04020009, - 0x4a026406, 0x00000011, 0x813669c0, 0x04020005, - 0x59cc0001, 0x82000500, 0x00ffffff, 0x4802601e, - 0x0201f000, 0x000207a1, 0x59880052, 0x4803c857, - 0x80000000, 0x48031052, 0x1c01f000, 0x42001000, - 0x00008049, 0x59cc1806, 0x800c1930, 0x0201f800, - 0x00103a3e, 0x0201f800, 0x00107942, 0x040007f3, - 0x49366009, 0x4a026406, 0x00000004, 0x59cc0c04, - 0x48066202, 0x4a026403, 0x00000009, 0x4a02641a, - 0x00000009, 0x4a02621a, 0x00002900, 0x4a026203, - 0x00000001, 0x0201f000, 0x0010672b, 0x59a80026, - 0x4803c857, 0x8c000508, 0x04000010, 0x59cc0006, - 0x82000500, 0xff000000, 0x82000d80, 0x03000000, - 0x0400000c, 0x82000d80, 0x20000000, 0x04000009, - 0x82000d80, 0x05000000, 0x04000006, 0x82000d80, - 0x21000000, 0x04000003, 0x80000580, 0x1c01f000, - 0x82000540, 0x00000001, 0x0401f7fd, 0x59cc2006, - 0x82102500, 0xff000000, 0x9c1021c0, 0x0401f807, - 0x820c1c00, 0x0010b4e3, 0x500c1800, 0x800c0500, - 0x4803c857, 0x1c01f000, 0x40100800, 0x41781800, - 0x82040480, 0x00000020, 0x04001004, 0x800c1800, - 0x40000800, 0x0401f7fb, 0x82040500, 0x0000000f, - 0x82000400, 0x0010ab38, 0x50000000, 0x8c040d08, - 0x04000002, 0x900001c0, 0x1c01f000, 0x4803c856, - 0x0401fac3, 0x0402000a, 0x0201f800, 0x0010210a, - 0x04020007, 0x59cc0002, 0x82000500, 0xff000000, - 0x82000d80, 0x08000000, 0x04000802, 0x1c01f000, - 0x4803c856, 0x59cc0400, 0x82000d00, 0x0000ff00, - 0x840409c0, 0x82040580, 0x00000033, 0x0402001f, - 0x0401f976, 0x04000038, 0x59cc0a04, 0x48066202, - 0x59cc0006, 0x4803c857, 0x82000500, 0xffff0000, - 0x82000d80, 0x02000000, 0x04020009, 0x59cc0006, - 0x82000500, 0x0000ffff, 0x0402002b, 0x42027000, - 0x00000015, 0x0201f000, 0x000207a1, 0x82000d80, - 0x01000000, 0x04020024, 0x59cc0006, 0x82000500, - 0x0000ffff, 0x04020020, 0x42027000, 0x00000016, - 0x0201f000, 0x000207a1, 0x82040580, 0x00000032, - 0x04020019, 0x59cc0006, 0x82000500, 0xffff0000, - 0x82000d80, 0x14000000, 0x04020013, 0x42027000, - 0x00000038, 0x59cc0001, 0x0401f810, 0x0402000e, - 0x0201f800, 0x001045a6, 0x0402000b, 0x0201f800, - 0x0002075a, 0x04000008, 0x49366009, 0x4a026406, - 0x00000004, 0x59cc0c04, 0x48066202, 0x0201f000, - 0x000207a1, 0x1c01f000, 0x4803c857, 0x4c580000, - 0x4c100000, 0x4c380000, 0x4c340000, 0x82003500, - 0x00ffffff, 0x82181500, 0x00ff0000, 0x82081580, - 0x00ff0000, 0x04020016, 0x82181480, 0x00fffffc, - 0x04001013, 0x82181580, 0x00fffffd, 0x04020004, - 0x42028800, 0x000007fd, 0x0401f040, 0x82181580, - 0x00fffffe, 0x04020004, 0x42028800, 0x000007fe, - 0x0401f03a, 0x82181580, 0x00fffffc, 0x04020004, - 0x42028800, 0x000007fc, 0x0401f034, 0x41781000, - 0x42002000, 0x00000000, 0x4200b000, 0x000007f0, - 0x41ac7000, 0x50380000, 0x80006d40, 0x04020005, - 0x800811c0, 0x0402001e, 0x8410155e, 0x0401f01c, - 0x58340212, 0x82000500, 0x0000ff00, 0x04000011, - 0x59a84010, 0x82204500, 0x00ffff00, 0x82180500, - 0x00ffff00, 0x04000002, 0x80200580, 0x58340002, - 0x0402000f, 0x82000500, 0x000000ff, 0x82184500, - 0x000000ff, 0x80204580, 0x04020009, 0x0401f006, - 0x58340002, 0x82000500, 0x00ffffff, 0x80184580, - 0x04020003, 0x40128800, 0x0401f00c, 0x80102000, - 0x80387000, 0x8058b040, 0x040207db, 0x800811c0, - 0x04020005, 0x481bc857, 0x82000540, 0x00000001, - 0x0401f003, 0x840a8d1e, 0x80000580, 0x5c006800, - 0x5c007000, 0x5c002000, 0x5c00b000, 0x1c01f000, - 0x59a80026, 0x8c00050e, 0x04000003, 0x8c000502, - 0x04000006, 0x59cc0c00, 0x80040910, 0x82040500, - 0x0000000f, 0x0c01f002, 0x1c01f000, 0x00105d0f, - 0x00105d0f, 0x00105d0f, 0x00105de5, 0x00105d0f, - 0x00105d11, 0x00105d29, 0x00105d2c, 0x00105d0f, - 0x00105d0f, 0x00105d0f, 0x00105d0f, 0x00105d0f, - 0x00105d0f, 0x00105d0f, 0x00105d0f, 0x4803c856, - 0x1c01f000, 0x0401f8c5, 0x04000014, 0x82140500, - 0x000003ff, 0x800000c4, 0x82000480, 0x00000008, - 0x0400100e, 0x59cc0001, 0x59326809, 0x59340802, - 0x80040580, 0x82000500, 0x00ffffff, 0x04020007, - 0x59cc0a04, 0x48066202, 0x42027000, 0x00000046, - 0x0201f000, 0x000207a1, 0x59cc0004, 0x4803c857, - 0x1c01f000, 0x59cc0004, 0x4803c857, 0x1c01f000, - 0x0401f8aa, 0x04000016, 0x82140500, 0x000003ff, - 0x800000c4, 0x82000480, 0x0000000c, 0x04001010, - 0x59cc0001, 0x82000500, 0x00ffffff, 0x59326809, - 0x59340802, 0x82040d00, 0x00ffffff, 0x80040580, - 0x04020007, 0x59cc0a04, 0x48066202, 0x42027000, - 0x00000045, 0x0201f000, 0x000207a1, 0x59cc0004, - 0x4803c857, 0x1c01f000, 0x4817c857, 0x0401f9c8, - 0x04020011, 0x0201f800, 0x0010210a, 0x0402000e, - 0x59cc0002, 0x82000500, 0xff000000, 0x82000580, - 0x00000000, 0x04020008, 0x82040500, 0x0000000f, - 0x82000c80, 0x00000006, 0x04021003, 0x4803c857, - 0x0c01f002, 0x1c01f000, 0x00105d60, 0x00105d64, - 0x00105d60, 0x00105d60, 0x00105db2, 0x00105dc3, - 0x4803c857, 0x59cc0004, 0x4803c857, 0x1c01f000, - 0x59cc0004, 0x4803c857, 0x59a80016, 0x800001c0, - 0x040207f8, 0x59cc0802, 0x8c040d2e, 0x0402001d, - 0x0201f800, 0x00107942, 0x02000800, 0x001005d8, - 0x59cc0001, 0x4803c857, 0x0401ff28, 0x0402000d, - 0x0201f800, 0x00020245, 0x0402000a, 0x4a026406, - 0x00000005, 0x49366009, 0x59cc0c04, 0x48066202, - 0x42027000, 0x00000088, 0x0201f000, 0x000207a1, - 0x42028800, 0x0000ffff, 0x417a6800, 0x59cc0001, - 0x82000500, 0x00ffffff, 0x4802601e, 0x0401f7f0, - 0x59cc0001, 0x4803c857, 0x0401ff10, 0x040207d5, - 0x0201f800, 0x001045a6, 0x040207d2, 0x59cc0005, - 0x8c000500, 0x04020004, 0x59340200, 0x8c00050e, - 0x040207cc, 0x0201f800, 0x001049f3, 0x0402000f, - 0x0401f83e, 0x040007c7, 0x0201f800, 0x0002075a, - 0x040007c4, 0x49366009, 0x4a026406, 0x00000002, - 0x59cc0c04, 0x48066202, 0x42027000, 0x00000088, - 0x0201f000, 0x000207a1, 0x0201f800, 0x0002075a, - 0x040007b8, 0x49366009, 0x4a026406, 0x00000004, - 0x59cc0c04, 0x48066202, 0x42027000, 0x00000001, - 0x0201f000, 0x000207a1, 0x59cc0004, 0x4803c857, - 0x59cc0802, 0x8c040d2e, 0x0400000b, 0x0401f81f, - 0x04000009, 0x0401f960, 0x04020007, 0x59cc0a04, - 0x48066202, 0x42027000, 0x00000089, 0x0201f000, - 0x000207a1, 0x4933c857, 0x1c01f000, 0x59cc0004, - 0x4803c857, 0x59cc0802, 0x8c040d2e, 0x0400000b, - 0x0401f80e, 0x04000009, 0x0401f94f, 0x04020007, - 0x59cc0a04, 0x48066202, 0x42027000, 0x0000008a, - 0x0201f000, 0x000207a1, 0x4933c857, 0x1c01f000, - 0x59cc0a04, 0x0401f002, 0x59cc0c04, 0x59a8000e, - 0x59a81067, 0x80080400, 0x80040480, 0x04021008, - 0x40040000, 0x800000c4, 0x800408ca, 0x80040c00, - 0x82066400, 0x0010d1c0, 0x1c01f000, 0x80000580, - 0x0401f7fe, 0x59cc0802, 0x8c040d2e, 0x04020010, - 0x0401ffec, 0x0400000e, 0x59cc0001, 0x82000500, - 0x00ffffff, 0x59326809, 0x59340802, 0x82040d00, - 0x00ffffff, 0x80040580, 0x04020005, 0x42027000, - 0x00000051, 0x0201f000, 0x000207a1, 0x59cc0004, - 0x4803c857, 0x1c01f000, 0x4803c856, 0x42003000, - 0x00000105, 0x0401f001, 0x4803c856, 0x4c3c0000, - 0x41cc7800, 0x0401f803, 0x5c007800, 0x1c01f000, - 0x4803c856, 0x4c580000, 0x583c0400, 0x82000500, - 0x0000f000, 0x82000580, 0x0000c000, 0x04000024, - 0x0201f800, 0x0002075a, 0x04000021, 0x4c180000, - 0x583c0001, 0x0401fe89, 0x0402001f, 0x0201f800, - 0x001045a6, 0x0402001c, 0x49366009, 0x0201f800, - 0x001007e4, 0x04000018, 0x492e6017, 0x497a5800, - 0x497a5a04, 0x48125c04, 0x832cac00, 0x00000005, - 0x4200b000, 0x00000007, 0x403ca000, 0x0201f800, - 0x0010ab17, 0x5c003000, 0x481a641a, 0x4a026403, - 0x0000003e, 0x4a026406, 0x00000001, 0x4a026203, - 0x00000001, 0x0201f800, 0x0010672b, 0x5c00b000, - 0x1c01f000, 0x0201f800, 0x0002077d, 0x5c003000, - 0x0401f7fb, 0x4803c856, 0x59cc0400, 0x82000d00, - 0x0000ff00, 0x82040500, 0x0000f000, 0x840409c0, - 0x82000580, 0x00002000, 0x04020049, 0x82040580, - 0x00000022, 0x0402003a, 0x59c400a4, 0x82000500, - 0x0000000f, 0x82000c80, 0x00000007, 0x04001004, - 0x82000480, 0x0000000c, 0x0400103f, 0x59cc0006, - 0x82000500, 0xffff0000, 0x82000d80, 0x04000000, - 0x04000039, 0x82000d80, 0x60000000, 0x04000036, - 0x82000d80, 0x54000000, 0x04000033, 0x82000d80, - 0x03000000, 0x04020015, 0x59a80826, 0x8c040d02, - 0x0402002d, 0x8c040d08, 0x0402002b, 0x0201f800, - 0x001048ec, 0x0400002b, 0x59a8001d, 0x800000d0, - 0x59a80810, 0x82040d00, 0x000000ff, 0x80040540, - 0x59cc0800, 0x82040d00, 0x00ffffff, 0x80040580, - 0x0402001b, 0x0401f01c, 0x59c40802, 0x8c040d0c, - 0x04020017, 0x82000d80, 0x52000000, 0x040007ec, - 0x82000d80, 0x05000000, 0x040007e9, 0x82000d80, - 0x50000000, 0x040007e6, 0x0401f00d, 0x82040580, - 0x00000023, 0x0402000a, 0x0401ff58, 0x04000008, - 0x59300c03, 0x82040580, 0x00000002, 0x04000006, - 0x82040580, 0x00000051, 0x04000003, 0x80000580, - 0x0401f003, 0x82000540, 0x00000001, 0x1c01f000, - 0x59cc0006, 0x82000500, 0xffff0000, 0x82000d80, - 0x03000000, 0x04000004, 0x82000d80, 0x52000000, - 0x040207f3, 0x59a80026, 0x82000500, 0x00000009, - 0x82000580, 0x00000008, 0x040007ef, 0x0401f7ec, - 0x4803c856, 0x4c5c0000, 0x4c580000, 0x59a80016, - 0x82000580, 0x0000004c, 0x0402001f, 0x59ccb807, - 0x9c5cb9c0, 0x825cbd00, 0x00000007, 0x8c5cbd00, - 0x0400000a, 0x4200b000, 0x00000002, 0x83a81c00, - 0x00000002, 0x83cc1400, 0x0000000d, 0x0201f800, - 0x0010855a, 0x04020010, 0x8c5cbd02, 0x0400000a, - 0x4200b000, 0x00000002, 0x83a81c00, 0x00000000, - 0x83cc1400, 0x0000000f, 0x0201f800, 0x0010855a, - 0x04020005, 0x8c5cbd04, 0x04000003, 0x82000540, - 0x00000001, 0x5c00b000, 0x5c00b800, 0x1c01f000, - 0x4803c856, 0x4c5c0000, 0x4c580000, 0x59a80016, - 0x82000580, 0x0000004c, 0x0402001f, 0x59ccb807, - 0x9c5cb9c0, 0x825cbd00, 0x00000007, 0x8c5cbd00, - 0x0400000a, 0x4200b000, 0x00000002, 0x83a81c00, - 0x00000002, 0x83cc1400, 0x00000009, 0x0201f800, - 0x0010855a, 0x04020010, 0x8c5cbd02, 0x0400000a, - 0x4200b000, 0x00000002, 0x83a81c00, 0x00000000, - 0x83cc1400, 0x0000000b, 0x0201f800, 0x0010855a, - 0x04020005, 0x8c5cbd04, 0x04000003, 0x82000540, - 0x00000001, 0x5c00b000, 0x5c00b800, 0x1c01f000, - 0x4803c857, 0x4c580000, 0x40003000, 0x42002000, - 0x000007f0, 0x4200b000, 0x00000010, 0x83ac7400, - 0x000007f0, 0x50380000, 0x80026d40, 0x04000006, - 0x59340002, 0x82000500, 0x00ffffff, 0x80180580, - 0x04000010, 0x80102000, 0x80387000, 0x8058b040, - 0x040207f5, 0x82100480, 0x00000800, 0x42002000, - 0x00000000, 0x4200b000, 0x000007f0, 0x41ac7000, - 0x040217ed, 0x82000540, 0x00000001, 0x0401f002, - 0x40128800, 0x5c00b000, 0x1c01f000, 0x59a80026, - 0x8c00050e, 0x04000004, 0x8c000502, 0x04000003, - 0x80000580, 0x1c01f000, 0x82000540, 0x00000001, - 0x0401f7fd, 0x59300c06, 0x82040580, 0x00000002, - 0x04000006, 0x82040580, 0x00000005, 0x04000003, - 0x82000540, 0x00000001, 0x1c01f000, 0x59c80000, - 0x84000558, 0x84000512, 0x48039000, 0x1c01f000, - 0x4a03281a, 0x000003e8, 0x4a032802, 0x0010d1c0, - 0x4a032800, 0x00000000, 0x4a032808, 0x00107049, - 0x42000000, 0x00000005, 0x83947c00, 0x00000009, - 0x49787801, 0x4a007802, 0x00106fff, 0x823c7c00, - 0x00000003, 0x80000040, 0x040207fa, 0x4a032819, - 0xffff0000, 0x4201d000, 0x00000064, 0x0401f96e, - 0x4201d000, 0x000186a0, 0x0401f184, 0x00000000, - 0x00000003, 0x00000006, 0x00000009, 0x0000000c, - 0x4d300000, 0x4d2c0000, 0x4d340000, 0x4d400000, - 0x4cfc0000, 0x4d380000, 0x4d3c0000, 0x4d440000, - 0x4d4c0000, 0x4d480000, 0x4c5c0000, 0x4c600000, - 0x4c640000, 0x4cc80000, 0x4ccc0000, 0x0201f800, - 0x0002057b, 0x5c019800, 0x5c019000, 0x5c00c800, - 0x5c00c000, 0x5c00b800, 0x5c029000, 0x5c029800, - 0x5c028800, 0x5c027800, 0x5c027000, 0x5c01f800, - 0x5c028000, 0x5c026800, 0x5c025800, 0x5c026000, - 0x1c01f000, 0x59940004, 0x80000540, 0x0402000a, - 0x59940025, 0x80040400, 0x02001800, 0x001005d8, - 0x48032804, 0x480b2805, 0x4a032803, 0x0000000a, - 0x80000580, 0x1c01f000, 0x5994001f, 0x80000540, - 0x0402000a, 0x59940025, 0x80040400, 0x02001800, - 0x001005d8, 0x4803281f, 0x480b2820, 0x4a03281e, - 0x00000001, 0x80000580, 0x1c01f000, 0x59940022, - 0x80000540, 0x0402000a, 0x59940025, 0x80040400, - 0x02001800, 0x001005d8, 0x48032822, 0x480b2823, - 0x4a032821, 0x0000000a, 0x80000580, 0x1c01f000, - 0x4c000000, 0x59940005, 0x4803c857, 0x480bc857, - 0x80080580, 0x04020003, 0x497b2804, 0x497b2805, - 0x5c000000, 0x1c01f000, 0x4c000000, 0x59940020, - 0x4803c857, 0x480bc857, 0x80080580, 0x04020003, - 0x497b281f, 0x497b2820, 0x5c000000, 0x1c01f000, - 0x4c000000, 0x59940023, 0x4803c857, 0x480bc857, - 0x80080580, 0x04020003, 0x497b2822, 0x497b2823, - 0x5c000000, 0x1c01f000, 0x4937c857, 0x48ebc857, - 0x59340203, 0x80e80480, 0x04001002, 0x48ea6a03, - 0x1c01f000, 0x5c03e000, 0x1c01f000, 0x4d440000, - 0x42007800, 0x00000010, 0x59968801, 0x0201f800, - 0x00020245, 0x04020012, 0x59341a03, 0x800c1840, - 0x0400100f, 0x59940027, 0x800c0480, 0x04000003, - 0x48026a03, 0x0402100a, 0x5934000f, 0x497a6a03, - 0x80000540, 0x04000006, 0x4c3c0000, 0x5934140b, - 0x0201f800, 0x00020253, 0x5c007800, 0x81468800, - 0x83440480, 0x00000800, 0x04021007, 0x803c7840, - 0x040207e7, 0x49472801, 0x5c028800, 0x5c03e000, - 0x1c01f000, 0x4a032800, 0x00000002, 0x497b2801, - 0x0401f7fa, 0x42007800, 0x00000010, 0x59966002, - 0x59300205, 0x80000d40, 0x04000006, 0x59940027, - 0x80040480, 0x48026205, 0x0400102d, 0x0400002c, - 0x59300206, 0x80000d40, 0x04000014, 0x59b800e4, - 0x8c000524, 0x04020011, 0x4a0370e4, 0x00030000, - 0x40000000, 0x59b800e4, 0x8c000524, 0x04000004, - 0x4a0370e4, 0x00020000, 0x0401f008, 0x59940027, - 0x80040480, 0x48026206, 0x4a0370e4, 0x00020000, - 0x0400101c, 0x0400001b, 0x83326400, 0x00000024, - 0x49332802, 0x41540000, 0x81300480, 0x04021005, - 0x803c7840, 0x040207db, 0x5c03e000, 0x1c01f000, - 0x59940026, 0x48032827, 0x4a032802, 0x0010d1c0, - 0x497b2826, 0x80000540, 0x0400000f, 0x4a032800, - 0x00000001, 0x5c03e000, 0x1c01f000, 0x4c3c0000, - 0x0201f800, 0x001091db, 0x5c007800, 0x0401f7d1, - 0x4c3c0000, 0x0201f800, 0x00108d5d, 0x5c007800, - 0x0401f7e2, 0x4a032800, 0x00000000, 0x5c03e000, - 0x1c01f000, 0x59a8086b, 0x8c040d30, 0x04020029, - 0x8c040d32, 0x0400000f, 0x59a80069, 0x81640480, - 0x04001019, 0x59a8000b, 0x81500580, 0x04000005, - 0x59a8006a, 0x59a81066, 0x80080580, 0x04020012, - 0x900411c0, 0x82081500, 0x00007000, 0x0401f012, - 0x82040500, 0x0000001f, 0x04000016, 0x80040840, - 0x82040500, 0x0000001f, 0x04000003, 0x4807506b, - 0x0401f010, 0x900401c0, 0x82000500, 0x0000001f, - 0x80040d40, 0x900401c0, 0x80040580, 0x82001500, - 0x00007000, 0x82040500, 0xffff8fff, 0x80080540, - 0x4803506b, 0x80081114, 0x0201f800, 0x001006e2, - 0x1c01f000, 0x4a032807, 0x000007d0, 0x4a032806, - 0x0000000a, 0x1c01f000, 0x42000800, 0x000007d0, - 0x83180480, 0x00000005, 0x02021800, 0x001005d8, - 0x83947c00, 0x00000009, 0x83180400, 0x00105f43, - 0x50000000, 0x803c7c00, 0x48047801, 0x4a007800, - 0x0000000a, 0x1c01f000, 0x83180480, 0x00000005, - 0x02021800, 0x001005d8, 0x83947c00, 0x00000009, - 0x83180400, 0x00105f43, 0x50000000, 0x803c7c00, - 0x49787801, 0x1c01f000, 0x4807c857, 0x480bc857, - 0x59940025, 0x80040400, 0x02001800, 0x001005d8, - 0x48032804, 0x480b2805, 0x4a032803, 0x0000000a, - 0x1c01f000, 0x4807c857, 0x480bc857, 0x59940025, - 0x80040400, 0x02001800, 0x001005d8, 0x4803281c, - 0x480b281d, 0x4a03281b, 0x0000000a, 0x1c01f000, - 0x4c000000, 0x5994001d, 0x4803c857, 0x480bc857, - 0x80080580, 0x04020003, 0x4803281c, 0x4803281d, - 0x5c000000, 0x1c01f000, 0x80e9d1c0, 0x0400000e, - 0x0401f836, 0x04025000, 0x4203e000, 0x80000000, - 0x40e81000, 0x41780800, 0x42000000, 0x00000064, - 0x0201f800, 0x001066a0, 0x59940024, 0x80080400, - 0x48032824, 0x1c01f000, 0x42001000, 0x00105065, - 0x0401fef0, 0x42001000, 0x00105058, 0x0401ffe1, - 0x42001000, 0x00104148, 0x0401feea, 0x42001000, - 0x001041bc, 0x0401fee7, 0x42001000, 0x001041f3, - 0x0401f6f8, 0x4203e000, 0x70000000, 0x4203e000, - 0xb0300000, 0x41fc0000, 0x40ebf800, 0x80e80480, - 0x04001011, 0x04000004, 0x82000480, 0x00000003, - 0x0402100d, 0x42000000, 0x0000000f, 0x04004004, - 0x80000040, 0x040207fe, 0x0401f007, 0x4203e000, - 0x70000000, 0x42000000, 0x0010b87e, 0x0201f800, - 0x0010aa47, 0x1c01f000, 0x4203e000, 0x80000000, - 0x4203e000, 0xb0400000, 0x41fc0000, 0x40ebf800, - 0x80e80480, 0x04001011, 0x04000004, 0x82000480, - 0x00000003, 0x0402100d, 0x42000000, 0x0000000f, - 0x04005004, 0x80000040, 0x040207fe, 0x0401f007, - 0x4203e000, 0x80000000, 0x42000000, 0x0010b87f, - 0x0201f800, 0x0010aa47, 0x1c01f000, 0x59a8000e, - 0x82000480, 0x00000100, 0x599c0a02, 0x800409c0, - 0x04020002, 0x80040800, 0x80041480, 0x04001002, - 0x40000800, 0x48075067, 0x59a8100e, 0x40040000, - 0x800acc80, 0x4967500e, 0x49675069, 0x59aaa80b, - 0x41640800, 0x42001000, 0x00000024, 0x0201f800, - 0x00106681, 0x8206a400, 0x0010d1c0, 0x49535065, - 0x4152b000, 0x42006000, 0x0010be65, 0x4a006004, - 0x0000012c, 0x4a006005, 0xda10da10, 0x4a006008, - 0x00000011, 0x4a006009, 0x0010be65, 0x4a00600a, - 0x001010b8, 0x599c0014, 0x48006011, 0x599c0015, - 0x48006012, 0x42006000, 0x0010be41, 0x4a006203, - 0x00000008, 0x4a006406, 0x00000006, 0x4a006002, - 0xffff0000, 0x4a006008, 0x0010be65, 0x4a006014, - 0x0010be65, 0x599c0014, 0x48006015, 0x599c0015, - 0x48006016, 0x599c0413, 0x48006017, 0x49506018, - 0x49546019, 0x59a80067, 0x4800601a, 0x4a00601b, - 0x0010b465, 0x4a00601c, 0x0010b466, 0x4a00601d, - 0x0010b46a, 0x42000000, 0xb0000000, 0x42000800, - 0x0010be41, 0x0201f800, 0x00100b68, 0x1c01f000, - 0x82000d00, 0x000000c0, 0x04000004, 0x82040d80, - 0x000000c0, 0x04020055, 0x82000d00, 0x00002020, - 0x59300414, 0x84000512, 0x82040d80, 0x00002020, - 0x0400000b, 0x8c000514, 0x0402000f, 0x48026414, - 0x813e79c0, 0x02020000, 0x000206d0, 0x42027000, - 0x00000043, 0x0201f000, 0x000207a1, 0x59326809, - 0x59340a00, 0x8c040d0a, 0x040007f3, 0x84000552, - 0x0401f7f1, 0x84000514, 0x592c080d, 0x48066015, - 0x0401f7ef, 0x59326809, 0x59340a00, 0x8c040d0a, - 0x02000000, 0x000206e3, 0x59300c14, 0x84040d52, - 0x48066414, 0x0201f000, 0x000206e3, 0x0201f800, - 0x00020086, 0x813e79c0, 0x02020000, 0x000206d0, - 0x0201f000, 0x000206f1, 0x8c00051e, 0x02000000, - 0x000206fd, 0x82000d00, 0x00002020, 0x82040d80, - 0x00002020, 0x04000014, 0x82000500, 0x000000c0, - 0x82000d80, 0x00000080, 0x04000008, 0x813e79c0, - 0x02020000, 0x000206d0, 0x42027000, 0x00000041, - 0x0201f000, 0x000207a1, 0x813e79c0, 0x02020000, - 0x000206d0, 0x42027000, 0x00000043, 0x0201f000, - 0x000207a1, 0x59326809, 0x59340a00, 0x8c040d0a, - 0x040007ea, 0x59300c14, 0x84040d52, 0x48066414, - 0x0401f7e6, 0x492fc857, 0x42000800, 0x00000006, - 0x0201f000, 0x000206f8, 0x492fc857, 0x42000800, - 0x00000004, 0x0201f000, 0x000206f8, 0x4807c856, - 0x59a80068, 0x800409c0, 0x04000003, 0x80080540, - 0x0401f002, 0x80080500, 0x48035068, 0x1c01f000, - 0x4a030800, 0x00000000, 0x4a030802, 0x00000001, - 0x497b0803, 0x497b0804, 0x1c01f000, 0x59840002, - 0x8c000500, 0x04000004, 0x84000500, 0x4a030800, - 0x00000001, 0x84000544, 0x84000506, 0x48030802, - 0x82000d00, 0x0fffffff, 0x42000000, 0x90000000, - 0x0201f800, 0x00100b94, 0x59a80069, 0x82000480, - 0x00000007, 0x48035069, 0x80000580, 0x42000800, - 0x0010b519, 0x48000800, 0x48000801, 0x1c01f000, - 0x59a80069, 0x82000480, 0x00000007, 0x48035069, - 0x1c01f000, 0x83640480, 0x00000008, 0x0400101b, - 0x58c80a03, 0x80000580, 0x82000400, 0x00000008, - 0x80040840, 0x040207fd, 0x815c0480, 0x04001013, - 0x4200b000, 0x00000007, 0x0201f800, 0x0002075a, - 0x4a026203, 0x00000004, 0x4a026406, 0x00000009, - 0x4a026203, 0x00000004, 0x4a026007, 0x00000101, - 0x0401f809, 0x0401f880, 0x8058b040, 0x040207f3, - 0x80000580, 0x1c01f000, 0x82000540, 0x00000001, - 0x0401f7fd, 0x0201f800, 0x001007e4, 0x492e6008, - 0x58c80a03, 0x4a025a04, 0x0000002c, 0x497a5800, - 0x497a5801, 0x497a5c04, 0x497a5c06, 0x497a5805, - 0x4a025a08, 0x00000005, 0x4a025a07, 0x00000002, - 0x58c80201, 0x48025c04, 0x58c80202, 0x48025c07, - 0x58c80204, 0x48025c08, 0x4a02580d, 0x0000ffff, - 0x80040840, 0x0400000c, 0x412c2000, 0x0201f800, - 0x001007e4, 0x4a025a04, 0x0000000a, 0x497a5c04, - 0x48125800, 0x492c2001, 0x412c2000, 0x80040840, - 0x040207f7, 0x1c01f000, 0x4d7c0000, 0x4202f800, - 0x00000010, 0x4df00000, 0x4203e000, 0x50000000, - 0x59847803, 0x803c79c0, 0x0400001e, 0x4c5c0000, - 0x583cb808, 0x585c3408, 0x801831c0, 0x0400000b, - 0x0401f84a, 0x04000016, 0x42001000, 0x0010b519, - 0x0401f87f, 0x04000012, 0x0201f800, 0x001007d3, - 0x0400000f, 0x492cb805, 0x585c0005, 0x80000540, - 0x02000800, 0x001005d8, 0x0401f830, 0x585c5408, - 0x0401f80b, 0x5c00b800, 0x5c03e000, 0x817ef840, - 0x040207e1, 0x5c02f800, 0x1c01f000, 0x5c00b800, - 0x5c03e000, 0x5c02f800, 0x1c01f000, 0x4803c856, - 0x405c6000, 0x802851c0, 0x04000018, 0x585c0204, - 0x82000d00, 0x0000000f, 0x82040c00, 0x001010bd, - 0x50044000, 0x4cf00000, 0x4d000000, 0x4d040000, - 0x4021e000, 0x40320800, 0x59860004, 0x4c280000, - 0x0401f934, 0x5c005000, 0x40f04000, 0x41046000, - 0x0201f800, 0x0010109b, 0x040207f6, 0x5c020800, - 0x5c020000, 0x5c01e000, 0x58c80204, 0x4800bc08, - 0x0201f800, 0x00020086, 0x4a026007, 0x00000101, - 0x497a6009, 0x0401f055, 0x4803c856, 0x59840003, - 0x80026540, 0x04000003, 0x59300000, 0x48030803, - 0x1c01f000, 0x4803c856, 0x59840003, 0x48026000, - 0x49330803, 0x1c01f000, 0x58cc0805, 0x40180000, - 0x80040480, 0x0400100d, 0x82cc0580, 0x0010b50e, - 0x02020800, 0x001005d8, 0x58c80205, 0x80040480, - 0x0400101d, 0x82000540, 0x00000001, 0x1c01f000, - 0x80003580, 0x0401f7fe, 0x82cc0580, 0x0010b50e, - 0x02020800, 0x001005d8, 0x58c80400, 0x8c000504, - 0x040007f8, 0x58c8040b, 0x8c00051e, 0x040007f5, - 0x8c000500, 0x040207f3, 0x84000540, 0x4801940b, - 0x42000000, 0x0010b839, 0x0201f800, 0x0010aa47, - 0x42001000, 0x00008026, 0x0201f800, 0x00103a3e, - 0x0401f7e8, 0x58c8040b, 0x8c00051e, 0x040007e2, - 0x8c000502, 0x040207e0, 0x84000542, 0x4801940b, - 0x42000000, 0x0010b838, 0x0201f800, 0x0010aa47, - 0x42001000, 0x00008025, 0x42001800, 0x00000000, - 0x0201f800, 0x00103a3e, 0x0401f7d3, 0x4803c856, - 0x58080000, 0x42001800, 0x00000007, 0x58080801, - 0x80040480, 0x04020004, 0x400c0000, 0x80000540, - 0x0401f005, 0x04001003, 0x800c0480, 0x0401f002, - 0x80000080, 0x1c01f000, 0x4803c856, 0x59300008, - 0x80000d40, 0x02000800, 0x001005d8, 0x58040005, - 0x80000540, 0x02000800, 0x001005d8, 0x59300007, - 0x82000500, 0x00000101, 0x82000580, 0x00000101, - 0x02020800, 0x001005d8, 0x42001000, 0x0010b519, - 0x58080801, 0x82040400, 0x0010b51b, 0x497a6414, - 0x4a026015, 0x0000ffff, 0x45300000, 0x80040800, - 0x82040480, 0x00000008, 0x04001002, 0x80000d80, - 0x48041001, 0x82040400, 0x0010b51b, 0x45780000, - 0x1c01f000, 0x4933c857, 0x59300808, 0x800409c0, - 0x02000800, 0x001005d8, 0x4d2c0000, 0x58065805, - 0x812e59c0, 0x02020800, 0x001007f4, 0x49780805, - 0x40065800, 0x0201f800, 0x001007fd, 0x5c025800, - 0x4d300000, 0x0201f800, 0x0002077d, 0x5c026000, - 0x1c01f000, 0x59300406, 0x82000580, 0x00000009, - 0x04020006, 0x59300007, 0x8c000510, 0x04000003, - 0x80000580, 0x1c01f000, 0x82000540, 0x00000001, - 0x1c01f000, 0x59840802, 0x8c040d04, 0x1c01f000, - 0x4803c856, 0x59840802, 0x84040d04, 0x84040d40, - 0x4a030800, 0x00000000, 0x48070802, 0x82040d00, - 0x0fffffff, 0x42000000, 0x90000000, 0x0201f000, - 0x00100b94, 0x4807c857, 0x4805980a, 0x49799801, - 0x49799803, 0x49799806, 0x49799807, 0x49799808, - 0x49799805, 0x49799809, 0x0401f8c9, 0x0400000a, - 0x0401f8eb, 0x04000008, 0x48359800, 0x48359802, - 0x48359806, 0x4a019804, 0x00000001, 0x4a019807, - 0x00000005, 0x1c01f000, 0x4807c857, 0x58cc1007, - 0x40040000, 0x80080480, 0x04021020, 0x4c040000, - 0x4c080000, 0x0401f8da, 0x5c001000, 0x5c000800, - 0x0400001c, 0x58cc0006, 0x80006540, 0x0402000b, - 0x48359800, 0x48359802, 0x48359806, 0x49799801, - 0x49799803, 0x49786801, 0x49786800, 0x49799804, - 0x49799807, 0x0401f005, 0x48306801, 0x48346000, - 0x48359806, 0x49786800, 0x58cc0004, 0x58cc1007, - 0x80000000, 0x82081400, 0x00000005, 0x48019804, - 0x48099807, 0x0401f7df, 0x80000580, 0x1c01f000, - 0x82000540, 0x00000001, 0x1c01f000, 0x480bc857, - 0x4c500000, 0x4c540000, 0x4c580000, 0x40083000, - 0x58cc0801, 0x82040480, 0x00000005, 0x02021800, - 0x001005d8, 0x82040400, 0x00106418, 0x50000000, - 0x58cca800, 0x8054ac00, 0x42001800, 0x00000005, - 0x40040000, 0x800c0480, 0x80082480, 0x04021002, - 0x40080000, 0x8000b0c2, 0x8058b400, 0x5450a800, - 0x8050a000, 0x8054a800, 0x8058b040, 0x040207fc, - 0x40001000, 0x58cc2805, 0x58cc0807, 0x58cc2001, - 0x80142c00, 0x80040c80, 0x80102400, 0x48159805, - 0x48059807, 0x48119801, 0x82100580, 0x00000005, - 0x0400000c, 0x48119801, 0x40080000, 0x80181480, - 0x40083000, 0x04000003, 0x040217d6, 0x80000580, - 0x5c00b000, 0x5c00a800, 0x5c00a000, 0x1c01f000, - 0x58cc0800, 0x800409c0, 0x02000800, 0x001005d8, - 0x58040800, 0x48059800, 0x41782000, 0x0401f7ee, - 0x0401f813, 0x50f00000, 0x81040400, 0x40001800, - 0x585c0204, 0x4803c857, 0x82000580, 0x0000002c, - 0x02020800, 0x001005d8, 0x58040202, 0x800000e0, - 0x81000540, 0x48001802, 0x58040000, 0x48001800, - 0x58040001, 0x48001801, 0x1c01f000, 0x4807c856, - 0x58cc0005, 0x80000040, 0x02001800, 0x001005d8, - 0x48019805, 0x58cc1003, 0x82080480, 0x00000005, - 0x02021800, 0x001005d8, 0x82080400, 0x00106418, - 0x50000000, 0x58cc0802, 0x80040c00, 0x80081000, - 0x82080480, 0x00000005, 0x0402000f, 0x58cc2002, - 0x58100000, 0x80006d40, 0x04000009, 0x4c340000, - 0x0401f858, 0x5c006800, 0x49786801, 0x48359802, - 0x58cc0004, 0x80000040, 0x48019804, 0x49799803, - 0x0401f002, 0x48099803, 0x1c01f000, 0x4807c856, - 0x41781800, 0x58c80201, 0x80000540, 0x04000002, - 0x800c1800, 0x58c80c01, 0x80040c80, 0x0400100a, - 0x04000009, 0x800c1800, 0x58c80202, 0x80041480, - 0x04001005, 0x04000004, 0x800c1800, 0x40080800, - 0x0401f7fb, 0x480d9204, 0x400c0000, 0x42002000, - 0x00000001, 0x80000040, 0x04000007, 0x04001006, - 0x80102000, 0x82000480, 0x00000005, 0x04000002, - 0x040217fc, 0x48119203, 0x1c01f000, 0x4807c856, - 0x4d2c0000, 0x58cc000a, 0x80000540, 0x02000800, - 0x001005d8, 0x82002400, 0x00000005, 0x0201f800, - 0x001007d3, 0x04000012, 0x492d9809, 0x497a5800, - 0x497a5801, 0x0201f800, 0x001007d3, 0x0400000c, - 0x58cc0009, 0x48025800, 0x497a5801, 0x492d9809, - 0x82102480, 0x00000005, 0x040217f7, 0x82000540, - 0x00000001, 0x5c025800, 0x1c01f000, 0x58cc0009, - 0x80025d40, 0x040007fc, 0x592c2000, 0x0201f800, - 0x001007f4, 0x40100000, 0x0401f7fa, 0x58cc0009, - 0x48cfc857, 0x80006d40, 0x04000005, 0x50340000, - 0x48019809, 0x49786800, 0x49786801, 0x1c01f000, - 0x4813c857, 0x58cc0009, 0x48002000, 0x48119809, - 0x1c01f000, 0x4807c856, 0x4d2c0000, 0x58cc0009, - 0x80025d40, 0x04000007, 0x592c0000, 0x4c000000, - 0x0201f800, 0x001007f4, 0x5c000000, 0x0401f7f9, - 0x5c025800, 0x1c01f000, 0x4807c856, 0x4d2c0000, - 0x58cc0002, 0x80025d40, 0x04000007, 0x592c0000, - 0x4c000000, 0x0201f800, 0x001007f4, 0x5c000000, - 0x0401f7f9, 0x49799800, 0x49799802, 0x49799801, - 0x49799803, 0x49799806, 0x49799807, 0x49799808, - 0x49799809, 0x4979980a, 0x5c025800, 0x1c01f000, - 0x00000003, 0x00000006, 0x00000009, 0x0000000c, - 0x0000000f, 0x00000012, 0x4803c856, 0x0401f857, - 0x4a00c204, 0x0000003c, 0x59301009, 0x82080580, - 0x0010b524, 0x04000013, 0x58080802, 0x82040d00, - 0x00ffffff, 0x58080403, 0x4804c005, 0x4800c406, - 0x4a00c207, 0x00000003, 0x59300811, 0x585c0404, - 0x4978c206, 0x4804c407, 0x80000540, 0x0400000d, - 0x58600206, 0x84000540, 0x4800c206, 0x0401f009, - 0x585c080a, 0x82040d00, 0x00ffffff, 0x4804c005, - 0x4a00c406, 0x000007ff, 0x4978c207, 0x0401f7ef, - 0x82603c00, 0x00000008, 0x58605404, 0x40282000, - 0x405c6000, 0x585c0a04, 0x82040d00, 0x0000000f, - 0x82040c00, 0x001010bd, 0x50044000, 0x80004d80, - 0x50200000, 0x80307400, 0x58380402, 0x8c244d00, - 0x04020003, 0x48003a00, 0x0401f003, 0x48003c00, - 0x801c3800, 0x80244800, 0x80102040, 0x04000006, - 0x0201f800, 0x0010109b, 0x02000800, 0x001005d8, - 0x0401f7f0, 0x1c01f000, 0x4803c856, 0x4d340000, - 0x59300009, 0x80026d40, 0x02000800, 0x001005d8, - 0x59340401, 0x80000540, 0x0400000e, 0x59840000, - 0x80000540, 0x0400000b, 0x836c0580, 0x00000003, - 0x04020008, 0x59341c03, 0x42002000, 0x00000004, - 0x42003000, 0x00000004, 0x0201f800, 0x00103aae, - 0x5c026800, 0x1c01f000, 0x4803c856, 0x80001580, - 0x58c80c01, 0x59300011, 0x80040c80, 0x48066011, - 0x58c80201, 0x80000540, 0x04000005, 0x80081000, - 0x80040c80, 0x04001007, 0x04000006, 0x58c80202, - 0x80081000, 0x80040c80, 0x04001002, 0x040207fd, - 0x4808bc08, 0x4808c404, 0x1c01f000, 0x4803c856, - 0x4a0370e5, 0x00020000, 0x59b800e5, 0x8c000524, - 0x040207fc, 0x4a0370e5, 0x00030000, 0x40000000, - 0x40000000, 0x59b800e5, 0x8c000524, 0x040207f5, - 0x5934000e, 0x80006d40, 0x04000010, 0x81300580, - 0x04020004, 0x58340000, 0x4802680e, 0x0401f00a, - 0x40347800, 0x58340000, 0x80006d40, 0x02000800, - 0x001005d8, 0x81300580, 0x040207fa, 0x58340000, - 0x48007800, 0x497a6000, 0x4a0370e5, 0x00020000, - 0x1c01f000, 0x4803c856, 0x4d300000, 0x4d2c0000, - 0x42000800, 0x000003ff, 0x4a0370e5, 0x00020000, - 0x59b800e5, 0x8c000524, 0x04000005, 0x80040840, - 0x040207fa, 0x0201f800, 0x001005d8, 0x4a0370e5, - 0x00030000, 0x40000000, 0x40000000, 0x59b800e5, - 0x8c000524, 0x040207f1, 0x5934000e, 0x80026540, - 0x0400000e, 0x4933c857, 0x59300000, 0x4802680e, - 0x4a026203, 0x00000004, 0x497a6206, 0x497a6009, - 0x4a026007, 0x00000101, 0x59325808, 0x497a5c08, - 0x0401fd81, 0x0401f7f1, 0x4a0370e5, 0x00020000, - 0x5c025800, 0x5c026000, 0x1c01f000, 0x4803c856, - 0x4c000000, 0x0201f800, 0x00105c9a, 0x04020011, - 0x0201f800, 0x001045a6, 0x02020800, 0x001005d8, - 0x5c000000, 0x48026802, 0x0201f800, 0x0002075a, - 0x04000009, 0x49366009, 0x4a026406, 0x00000001, - 0x42027000, 0x00000001, 0x0201f000, 0x000207a1, - 0x5c000000, 0x1c01f000, 0x59300203, 0x82000c80, - 0x0000000e, 0x02021800, 0x001005d8, 0x4803c857, - 0x0c01f001, 0x00106503, 0x00106503, 0x00106503, - 0x00106505, 0x00106565, 0x00106503, 0x00106503, - 0x001065b7, 0x001065b8, 0x00106503, 0x00106503, - 0x00106503, 0x00106503, 0x00106503, 0x0201f800, - 0x001005d8, 0x493bc857, 0x83380480, 0x00000050, - 0x02021800, 0x001005d8, 0x83380480, 0x00000049, - 0x02001800, 0x001005d8, 0x0c01f001, 0x00106518, - 0x0010653a, 0x00106516, 0x00106516, 0x00106516, - 0x00106516, 0x00106549, 0x0201f800, 0x001005d8, - 0x4d2c0000, 0x59325808, 0x592c0206, 0x48025c06, - 0x4a025a06, 0x00000000, 0x4c5c0000, 0x592cbc0a, - 0x592c0000, 0x48026008, 0x0201f800, 0x00104cde, - 0x59300008, 0x80000540, 0x04000008, 0x4a026203, - 0x00000007, 0x42027000, 0x00000043, 0x5c00b800, - 0x5c025800, 0x0401f08a, 0x8c5cbd08, 0x04020006, - 0x4a026203, 0x00000007, 0x497a6206, 0x497a6008, - 0x0401f003, 0x0201f800, 0x0002077d, 0x5c00b800, - 0x5c025800, 0x1c01f000, 0x0201f800, 0x00106b8a, - 0x4d2c0000, 0x59325808, 0x0201f800, 0x00109037, - 0x04000006, 0x4d400000, 0x42028000, 0x00000001, - 0x0401f8f8, 0x5c028000, 0x5c025800, 0x0201f000, - 0x0002077d, 0x0201f800, 0x00106b8a, 0x4d3c0000, - 0x417a7800, 0x0201f800, 0x0010203c, 0x5c027800, - 0x42003000, 0x00000014, 0x0201f800, 0x0010a942, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x4d2c0000, 0x59325808, 0x0201f800, 0x00109037, - 0x04000006, 0x4d400000, 0x42028000, 0x00000029, - 0x0401f8dc, 0x5c028000, 0x5c025800, 0x0201f000, - 0x0002077d, 0x493bc857, 0x497a6206, 0x83380480, - 0x00000054, 0x02021800, 0x001005d8, 0x83380480, - 0x00000047, 0x02001800, 0x001005d8, 0x0c01f001, - 0x001065b6, 0x0010657f, 0x0010657d, 0x0010657d, - 0x0010657d, 0x0010657d, 0x0010657d, 0x0010657d, - 0x0010657d, 0x0010657d, 0x0010657d, 0x0010657d, - 0x00106583, 0x0201f800, 0x001005d8, 0x59300011, - 0x82000500, 0xffff0000, 0x04020034, 0x59840802, - 0x8c040d04, 0x04000025, 0x59300009, 0x80026d40, - 0x0400001f, 0x4c5c0000, 0x4c600000, 0x497a6206, - 0x5930b808, 0x585c0005, 0x8000c540, 0x02000800, - 0x001005d8, 0x0401fe8d, 0x40625800, 0x0201f800, - 0x00104cde, 0x4978b805, 0x0401fef5, 0x497a6009, - 0x585c3408, 0x0401fcbd, 0x0400000e, 0x42001000, - 0x0010b519, 0x0401fcf2, 0x0400000a, 0x0201f800, - 0x001007e4, 0x04000007, 0x492cb805, 0x585c5408, - 0x0401fc83, 0x5c00c000, 0x5c00b800, 0x1c01f000, - 0x0401fca9, 0x0401f7fc, 0x8c040d06, 0x040207fc, - 0x59300009, 0x80026d40, 0x04000006, 0x5934000e, - 0x80000540, 0x02020800, 0x001005d8, 0x497a6009, - 0x0401fd0d, 0x0401f7f2, 0x0401f06f, 0x4803c856, - 0x4803c856, 0x83380580, 0x00000043, 0x02020800, - 0x001005d8, 0x4a026203, 0x00000003, 0x493a6403, - 0x59325808, 0x592c000f, 0x48026011, 0x497a6013, - 0x592c0406, 0x800000c2, 0x800010c4, 0x80081400, - 0x480a6206, 0x0201f800, 0x00100f4e, 0x42000800, - 0x80000060, 0x0401f154, 0x42000000, 0x0010b875, - 0x0201f800, 0x0010aa47, 0x59300203, 0x82000c80, - 0x0000000e, 0x02021800, 0x001005d8, 0x4803c857, - 0x82000d80, 0x00000003, 0x04000006, 0x82000d80, - 0x00000004, 0x04000045, 0x0201f800, 0x001005d8, - 0x0201f800, 0x00106c55, 0x59300004, 0x8c00053e, - 0x04020007, 0x0201f800, 0x00106b6c, 0x02020800, - 0x001005d8, 0x0201f000, 0x00106c4b, 0x0401f9c3, - 0x0201f800, 0x00106c4b, 0x59325808, 0x42028000, - 0x00000006, 0x0401f84b, 0x0201f000, 0x0002077d, - 0x4803c856, 0x59300203, 0x82000c80, 0x0000000e, - 0x02021800, 0x001005d8, 0x82000d80, 0x00000003, - 0x04000006, 0x82000d80, 0x00000004, 0x04000023, - 0x0201f800, 0x001005d8, 0x4803c856, 0x0201f800, - 0x00106c55, 0x4df00000, 0x59300004, 0x8c00053e, - 0x04020006, 0x0201f800, 0x00106f60, 0x02020800, - 0x001005d8, 0x0401f010, 0x0201f800, 0x00108cd6, - 0x04020004, 0x0201f800, 0x00106e62, 0x0402000a, - 0x0401f99a, 0x02020800, 0x001005d8, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x82000540, 0x00000001, - 0x1c01f000, 0x5c03e000, 0x02000800, 0x00106c4b, - 0x80000580, 0x1c01f000, 0x4933c857, 0x0201f800, - 0x00100e99, 0x4933c857, 0x4c5c0000, 0x4d340000, - 0x497a6206, 0x5930b808, 0x59300009, 0x80026d40, - 0x04020e5f, 0x42001000, 0x0010b519, 0x0401fc60, - 0x04000009, 0x58c80204, 0x4800bc08, 0x41785000, - 0x0201f800, 0x00106227, 0x5c026800, 0x5c00b800, - 0x1c01f000, 0x4978bc08, 0x0401fc17, 0x0401f7fb, - 0x4803c856, 0x0201f800, 0x00109037, 0x0400000f, - 0x592c0000, 0x80000d40, 0x04000009, 0x497a5800, - 0x49425a06, 0x4c040000, 0x0201f800, 0x000202da, - 0x5c000800, 0x40065800, 0x0401f7f6, 0x49425a06, - 0x0201f800, 0x000202da, 0x1c01f000, 0x4933c857, - 0x59300c06, 0x82040580, 0x0000000e, 0x04000004, - 0x82040580, 0x00000009, 0x04020004, 0x0401ffe5, - 0x497a6008, 0x80000580, 0x1c01f000, 0x592e6009, - 0x83300480, 0x0010d1c0, 0x04001016, 0x41580000, - 0x81300480, 0x04021013, 0x40040000, 0x59300c06, - 0x80040580, 0x04020012, 0x59300a03, 0x82040580, - 0x00000007, 0x02020800, 0x001005d8, 0x59300008, - 0x80000540, 0x02020800, 0x001005d8, 0x0201f800, - 0x0002077d, 0x42000000, 0x00000000, 0x0401f009, - 0x42000000, 0x00000008, 0x0401f006, 0x82040580, - 0x00000007, 0x040207fb, 0x42000000, 0x00000005, - 0x592c0a06, 0x48065c06, 0x48025a06, 0x0201f000, - 0x000202da, 0x4c0c0000, 0x4c100000, 0x4c140000, - 0x4c180000, 0x80001d80, 0x80002580, 0x42003000, - 0x00000020, 0x82040500, 0x00000001, 0x04000003, - 0x40080000, 0x800c1c00, 0x400c2800, 0x800c1902, - 0x80102102, 0x82140500, 0x00000001, 0x04000003, - 0x82102540, 0x80000000, 0x80040902, 0x80183040, - 0x040207f1, 0x40100800, 0x400c0000, 0x5c003000, - 0x5c002800, 0x5c002000, 0x5c001800, 0x1c01f000, - 0x4c580000, 0x4200b000, 0x00000020, 0x80000540, - 0x04000018, 0x80041c80, 0x04021016, 0x800810c2, - 0x80040982, 0x04001006, 0x80041c80, 0x04021005, - 0x8058b040, 0x040207fa, 0x0401f006, 0x80041c80, - 0x400c0800, 0x80081000, 0x8058b040, 0x040207f4, - 0x4c000000, 0x41f00000, 0x82000500, 0xf7ffffff, - 0x4003e000, 0x5c000000, 0x5c00b000, 0x1c01f000, - 0x4c000000, 0x41f00000, 0x82000540, 0x08000000, - 0x0401f7f8, 0x4a0378e8, 0x00000000, 0x4a03c821, - 0x00000010, 0x4a03c823, 0x00000004, 0x0401f82c, - 0x4a0378e9, 0x00003a0d, 0x4a0378e8, 0x00000001, - 0x42000000, 0x00001000, 0x50000000, 0x82000480, - 0x24220001, 0x04000004, 0x59e00002, 0x84000548, - 0x4803c002, 0x42000800, 0x00000005, 0x4203a000, - 0x00007600, 0x42000000, 0x00001000, 0x50000000, - 0x82000480, 0x24320001, 0x04021003, 0x4a03a005, - 0xd0000001, 0x59d00006, 0x4a03a005, 0x90000001, - 0x83d3a400, 0x00000020, 0x80040840, 0x040207fa, - 0x59e00003, 0x82000500, 0xffffffe0, 0x82000540, - 0x00008000, 0x4803c003, 0x59c40006, 0x82000500, - 0xfffcffff, 0x48038806, 0x1c01f000, 0x4d900000, - 0x4d180000, 0x4a0378e7, 0xaaaaaaaa, 0x4a0378e6, - 0xaaaaaaaa, 0x4a0378e5, 0xaaaaaaaa, 0x4a0378e4, - 0xaaaaaaaa, 0x42000800, 0x0000bf00, 0x4a00081a, - 0x0010b7d4, 0x4a00081b, 0x001010bd, 0x4a00081c, - 0x001010cd, 0x4a031800, 0x00000000, 0x4a031801, - 0x0010b544, 0x4a031802, 0x0010b54b, 0x42000800, - 0x0010b7d7, 0x417a3000, 0x811b20c8, 0x83932400, - 0x0000bf32, 0x48072000, 0x4a032001, 0x00000000, - 0x83180400, 0x001070ea, 0x50000000, 0x48032002, - 0x82040c00, 0x00000003, 0x811a3000, 0x83180480, - 0x00000005, 0x040017f1, 0x5c023000, 0x5c032000, - 0x1c01f000, 0x48066004, 0x497a6000, 0x497a6001, - 0x59bc00ea, 0x8c000516, 0x040207fe, 0x83300400, - 0xa0000000, 0x480378e1, 0x1c01f000, 0x4933c857, - 0x42000800, 0x80000040, 0x48066004, 0x497a6000, - 0x59bc00ea, 0x8c000516, 0x040207fe, 0x83300400, - 0x60000000, 0x480378e1, 0x1c01f000, 0x0201f800, - 0x00106c55, 0x4df00000, 0x4d300000, 0x4d340000, - 0x4d2c0000, 0x4d180000, 0x4c5c0000, 0x4c600000, - 0x4d900000, 0x4dd00000, 0x4da40000, 0x4d140000, - 0x42003000, 0x0000bf2e, 0x581a6001, 0x813261c0, - 0x0400002c, 0x41302800, 0x4178c000, 0x59300000, - 0x4c000000, 0x59326809, 0x5930b801, 0x59300406, - 0x82000d80, 0x00000006, 0x04020003, 0x8d3e7d18, - 0x04000010, 0x8d3e7d06, 0x04000007, 0x82000580, - 0x00000003, 0x04020004, 0x59340200, 0x8c00050e, - 0x04020008, 0x0401f92f, 0x4c0c0000, 0x4c140000, - 0x0401fb5f, 0x5c002800, 0x5c001800, 0x0401f005, - 0x41301800, 0x8060c1c0, 0x04020002, 0x400cc000, - 0x805cb9c0, 0x04000003, 0x405e6000, 0x0401f7e3, - 0x5c026000, 0x813261c0, 0x04000006, 0x8060c1c0, - 0x04000002, 0x40602800, 0x4178c000, 0x0401f7d8, - 0x417a3000, 0x0201f800, 0x001070d8, 0x59926004, - 0x813261c0, 0x04000023, 0x59326809, 0x4130c000, - 0x59300001, 0x8000bd40, 0x04000016, 0x40026000, - 0x40602800, 0x5930b801, 0x59300406, 0x82000d80, - 0x00000006, 0x0400000e, 0x8d3e7d06, 0x04000007, - 0x82000580, 0x00000003, 0x04020004, 0x59340200, - 0x8c00050e, 0x04020006, 0x0401f8dc, 0x4c140000, - 0x0401fb2f, 0x5c002800, 0x0401f002, 0x41302800, - 0x405e6000, 0x813261c0, 0x040207eb, 0x8060c1c0, - 0x04000004, 0x40626000, 0x4178c000, 0x0401f7e7, - 0x811a3000, 0x83180480, 0x00000005, 0x040017d6, - 0x5c022800, 0x5c034800, 0x5c03a000, 0x5c032000, - 0x5c00c000, 0x5c00b800, 0x5c023000, 0x5c025800, - 0x5c026800, 0x5c026000, 0x5c03e000, 0x02000800, - 0x00106c4b, 0x1c01f000, 0x4933c857, 0x0201f800, - 0x00106c55, 0x4df00000, 0x4d340000, 0x4d180000, - 0x4d900000, 0x42003000, 0x0000bf2e, 0x59326809, - 0x58182001, 0x40102800, 0x801021c0, 0x04000016, - 0x41300000, 0x80100580, 0x04000011, 0x58100009, - 0x81340580, 0x0402000b, 0x40101800, 0x58102001, - 0x41300000, 0x801021c0, 0x0400000b, 0x80100d80, - 0x04000007, 0x40101800, 0x58102001, 0x0401f7fa, - 0x40102800, 0x58102000, 0x0401f7ec, 0x0401f8bd, - 0x0401f01a, 0x42032000, 0x0000bf32, 0x417a3000, - 0x59902004, 0x40102800, 0x801021c0, 0x0400000b, - 0x58100009, 0x81340580, 0x04020008, 0x41300000, - 0x80100580, 0x0400000c, 0x40102800, 0x58102001, - 0x801021c0, 0x040207fa, 0x811a3000, 0x83180480, - 0x00000005, 0x0402100d, 0x83932400, 0x00000010, - 0x0401f7ec, 0x0401f881, 0x5c032000, 0x5c023000, - 0x5c026800, 0x5c03e000, 0x02000800, 0x00106c4b, - 0x80000580, 0x1c01f000, 0x0401fb6f, 0x040007f7, - 0x5c032000, 0x5c023000, 0x5c026800, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x82000540, 0x00000001, - 0x1c01f000, 0x0201f800, 0x00106c55, 0x4df00000, - 0x4d300000, 0x4d340000, 0x4d180000, 0x4d2c0000, - 0x4c5c0000, 0x4c600000, 0x4d900000, 0x4dd00000, - 0x4da40000, 0x4d140000, 0x42003000, 0x0000bf2e, - 0x581a6001, 0x813261c0, 0x04000023, 0x41302800, - 0x5930b800, 0x59326809, 0x59340403, 0x81440580, - 0x04000006, 0x805cb9c0, 0x0400001b, 0x41302800, - 0x405e6000, 0x0401f7f7, 0x5930b801, 0x8d3e7d00, - 0x04000003, 0x0401fb67, 0x0402000e, 0x59300406, - 0x82000580, 0x00000006, 0x04020003, 0x8d3e7d18, - 0x04000008, 0x0401f867, 0x4c0c0000, 0x4c140000, - 0x0401fa97, 0x5c002800, 0x5c001800, 0x0401f002, - 0x41301800, 0x405e6000, 0x813261c0, 0x040207eb, - 0x0401f02d, 0x417a3000, 0x0201f800, 0x001070d8, - 0x59926004, 0x813261c0, 0x04000005, 0x59326809, - 0x59340403, 0x81440580, 0x04000006, 0x811a3000, - 0x83180480, 0x00000005, 0x040017f4, 0x0401f01e, - 0x4130c000, 0x59300001, 0x8000bd40, 0x04000012, - 0x40026000, 0x40602800, 0x5930b801, 0x8d3e7d00, - 0x04000003, 0x0401fb3b, 0x0402000a, 0x59300406, - 0x82000580, 0x00000006, 0x04000006, 0x0401f81b, - 0x4c140000, 0x0401fa6e, 0x5c002800, 0x0401f002, - 0x41302800, 0x405e6000, 0x813261c0, 0x040207ef, - 0x8060c1c0, 0x04000004, 0x40626000, 0x4178c000, - 0x0401f7eb, 0x5c022800, 0x5c034800, 0x5c03a000, - 0x5c032000, 0x5c00c000, 0x5c00b800, 0x5c025800, - 0x5c023000, 0x5c026800, 0x5c026000, 0x5c03e000, - 0x04000be3, 0x1c01f000, 0x0401fbc8, 0x59900004, - 0x81300580, 0x04020018, 0x4c140000, 0x0201f800, - 0x00106dc3, 0x0401fbb8, 0x5c002800, 0x59300001, - 0x800001c0, 0x04020003, 0x497a680c, 0x1c01f000, - 0x42003000, 0x0000bf2e, 0x497a6001, 0x58180801, - 0x800409c0, 0x04020004, 0x48003000, 0x48003001, - 0x1c01f000, 0x58180800, 0x48000800, 0x48003000, - 0x1c01f000, 0x59300001, 0x48002801, 0x800001c0, - 0x04020002, 0x4816680c, 0x497a6001, 0x1c01f000, - 0x0401fba6, 0x42003000, 0x0000bf2e, 0x58180001, - 0x81300580, 0x0402001c, 0x59300801, 0x800409c0, - 0x0400000e, 0x59300000, 0x800001c0, 0x04020005, - 0x48043001, 0x48043000, 0x497a6001, 0x1c01f000, - 0x59300000, 0x48000800, 0x48043001, 0x497a6000, - 0x497a6001, 0x1c01f000, 0x59300800, 0x800409c0, - 0x04020005, 0x49783001, 0x49783000, 0x497a680c, - 0x1c01f000, 0x48043001, 0x497a6000, 0x497a680c, - 0x1c01f000, 0x58180000, 0x81300580, 0x0402000c, - 0x59300001, 0x800001c0, 0x04020005, 0x48143000, - 0x49782800, 0x497a680c, 0x1c01f000, 0x48003000, - 0x48002800, 0x497a6001, 0x1c01f000, 0x59300000, - 0x800001c0, 0x04020008, 0x59300001, 0x48001801, - 0x800001c0, 0x04020002, 0x480e680c, 0x497a6001, - 0x1c01f000, 0x59300801, 0x800409c0, 0x04020006, - 0x59300800, 0x48042800, 0x497a6000, 0x497a680c, - 0x1c01f000, 0x59300000, 0x48000800, 0x48042800, - 0x497a6000, 0x497a6001, 0x1c01f000, 0x0401fb82, - 0x4df00000, 0x0401f839, 0x040208c4, 0x04020945, - 0x04020a89, 0x04020005, 0x5c03e000, 0x04000b70, - 0x80000580, 0x1c01f000, 0x5c03e000, 0x04000b6c, - 0x82000540, 0x00000001, 0x1c01f000, 0x4d2c0000, - 0x4d340000, 0x4d300000, 0x41783000, 0x598e6009, - 0x813261c0, 0x04000021, 0x59300406, 0x82000580, - 0x00000006, 0x04020004, 0x8d3e7d18, 0x0402000a, - 0x0401f017, 0x82040580, 0x00000005, 0x04020006, - 0x8d3e7d16, 0x04000004, 0x59300420, 0x8c000500, - 0x0402000f, 0x0401fa4e, 0x59300000, 0x4c000000, - 0x8d3e7d06, 0x04000004, 0x0201f800, 0x001092d7, - 0x04000005, 0x0401f867, 0x4c180000, 0x0401f9bc, - 0x5c003000, 0x5c026000, 0x0401f7e2, 0x41303000, - 0x59326000, 0x0401f7df, 0x5c026000, 0x5c026800, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x4c5c0000, - 0x813261c0, 0x02000800, 0x001005d8, 0x41300000, - 0x598cb809, 0x41783000, 0x805cb9c0, 0x04000013, - 0x805c0d80, 0x04000004, 0x405c3000, 0x5818b800, - 0x0401f7fa, 0x0401f84b, 0x598c000d, 0x81300580, - 0x02000800, 0x001070b9, 0x59300403, 0x82000580, - 0x00000042, 0x04020002, 0x497a6007, 0x80000580, - 0x5c00b800, 0x1c01f000, 0x82000540, 0x00000001, - 0x5c00b800, 0x1c01f000, 0x0401fb27, 0x4df00000, - 0x4d2c0000, 0x4d340000, 0x4d300000, 0x41783000, - 0x598e6009, 0x813261c0, 0x0400002c, 0x59300c06, - 0x82040580, 0x00000006, 0x04020004, 0x8d3e7d18, - 0x0402000a, 0x0401f022, 0x82040580, 0x00000005, - 0x04020006, 0x8d3e7d18, 0x04000004, 0x59300420, - 0x8c000500, 0x0402001a, 0x59326809, 0x59340403, - 0x81440580, 0x04020016, 0x8d3e7d00, 0x04000006, - 0x82040580, 0x00000003, 0x04020011, 0x0401fa35, - 0x0402000f, 0x0401f9f6, 0x59300000, 0x4c000000, - 0x8d3e7d06, 0x04000004, 0x0201f800, 0x001092d7, - 0x04000005, 0x0401f80f, 0x4c180000, 0x0401f964, - 0x5c003000, 0x5c026000, 0x0401f7d7, 0x41303000, - 0x59326000, 0x0401f7d4, 0x5c026000, 0x5c026800, - 0x5c025800, 0x5c03e000, 0x04000ae5, 0x1c01f000, - 0x59300800, 0x497a6000, 0x0401fac8, 0x801831c0, - 0x04020009, 0x598c0008, 0x81300580, 0x04020004, - 0x48031808, 0x48031809, 0x0401f008, 0x48071809, - 0x0401f006, 0x48043000, 0x598c0008, 0x81300580, - 0x04020002, 0x481b1808, 0x0401f2ca, 0x4d2c0000, - 0x4d300000, 0x4d340000, 0x41783000, 0x598e600b, - 0x813261c0, 0x04000013, 0x8d3e7d06, 0x04000005, - 0x59326809, 0x59340200, 0x8c00050e, 0x0402000a, - 0x0401f9bf, 0x59300000, 0x4c000000, 0x0401f853, - 0x4c180000, 0x0401f932, 0x5c003000, 0x5c026000, - 0x0401f7f0, 0x41303000, 0x59326000, 0x0401f7ed, - 0x0201f800, 0x00104773, 0x5c026800, 0x5c026000, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x4c5c0000, - 0x813261c0, 0x02000800, 0x001005d8, 0x41300000, - 0x598cb80b, 0x41783000, 0x805cb9c0, 0x0400000f, - 0x805c0d80, 0x04000004, 0x405c3000, 0x5818b800, - 0x0401f7fa, 0x0401f835, 0x598c000d, 0x81300580, - 0x02000800, 0x001070b9, 0x497a6007, 0x80000580, - 0x5c00b800, 0x1c01f000, 0x82000540, 0x00000001, - 0x5c00b800, 0x1c01f000, 0x0401fa9f, 0x4df00000, - 0x4d340000, 0x4d300000, 0x4d2c0000, 0x0201f800, - 0x00020245, 0x02020800, 0x001005d8, 0x41783000, - 0x598e600b, 0x813261c0, 0x04000014, 0x59300009, - 0x81340580, 0x0402000e, 0x8d3e7d00, 0x04000003, - 0x0401f9bc, 0x0402000a, 0x0401f97d, 0x59300000, - 0x4c000000, 0x0401f811, 0x4c180000, 0x0401f8f0, - 0x5c003000, 0x5c026000, 0x0401f7ef, 0x41303000, - 0x59326000, 0x0401f7ec, 0x0201f800, 0x0010479c, - 0x5c025800, 0x5c026000, 0x5c026800, 0x5c03e000, - 0x04000a6f, 0x1c01f000, 0x59300800, 0x497a6000, - 0x0401fa52, 0x801831c0, 0x04020009, 0x598c000a, - 0x81300580, 0x04020004, 0x4803180a, 0x4803180b, - 0x0401f008, 0x4807180b, 0x0401f006, 0x48043000, - 0x598c000a, 0x81300580, 0x04020002, 0x481b180a, - 0x0401f254, 0x0401fa64, 0x4df00000, 0x4d300000, - 0x598e6005, 0x813261c0, 0x04000020, 0x59300000, - 0x4c000000, 0x59300c06, 0x82040580, 0x00000011, - 0x04020007, 0x833c0500, 0x00001800, 0x04000015, - 0x8d3e7d16, 0x04020013, 0x0401f009, 0x82040580, - 0x00000004, 0x04020006, 0x8d3e7d16, 0x04000004, - 0x59300420, 0x8c000500, 0x0402000a, 0x0201f800, - 0x0010914e, 0x02000800, 0x0010801c, 0x0201f800, - 0x00109326, 0x0201f800, 0x0002077d, 0x0401fa31, - 0x5c026000, 0x0401f7e0, 0x497b1805, 0x497b1804, - 0x5c026000, 0x5c03e000, 0x04000a31, 0x1c01f000, - 0x4933c857, 0x4c5c0000, 0x4c600000, 0x813261c0, - 0x02000800, 0x001005d8, 0x41300000, 0x598cb805, - 0x405cc000, 0x805cb9c0, 0x04000025, 0x805c0d80, - 0x04000004, 0x405cc000, 0x5860b800, 0x0401f7fa, - 0x598c000d, 0x81300580, 0x02000800, 0x001070b9, - 0x0401fa02, 0x598c0005, 0x805c0580, 0x04020009, - 0x585c0000, 0x48031805, 0x4978b800, 0x598c0004, - 0x805c0580, 0x0402000d, 0x497b1804, 0x0401f00b, - 0x598c0004, 0x805c0580, 0x04020005, 0x48631804, - 0x4978b800, 0x4978c000, 0x0401f004, 0x585c0000, - 0x4800c000, 0x4978b800, 0x0401f9fe, 0x80000580, - 0x5c00c000, 0x5c00b800, 0x1c01f000, 0x82000540, - 0x00000001, 0x5c00c000, 0x5c00b800, 0x1c01f000, - 0x4933c857, 0x0401fa04, 0x4df00000, 0x4d2c0000, - 0x4d340000, 0x4d300000, 0x4c5c0000, 0x4178b800, - 0x8d3e7d18, 0x0400000d, 0x8d3e7d16, 0x0402000b, - 0x0201f800, 0x00109037, 0x04000008, 0x0201f800, - 0x00109597, 0x04020005, 0x592c0207, 0x492fc857, - 0x8200bd00, 0x0000000f, 0x41783000, 0x598e6005, - 0x813261c0, 0x04000029, 0x59326809, 0x813669c0, - 0x04000023, 0x59340403, 0x81440580, 0x04020020, - 0x59300c06, 0x82040580, 0x00000011, 0x0400001a, - 0x82040580, 0x00000004, 0x04020004, 0x59300420, - 0x8c000500, 0x04020016, 0x0201f800, 0x00109037, - 0x04000008, 0x0201f800, 0x00109597, 0x04020005, - 0x59300403, 0x82000580, 0x00000043, 0x0400000c, - 0x0401f8c3, 0x59300000, 0x4c000000, 0x0401f812, - 0x4c180000, 0x0401f836, 0x5c003000, 0x5c026000, - 0x0401f7dc, 0x805cb9c0, 0x040207ec, 0x41303000, - 0x59326000, 0x0401f7d7, 0x5c00b800, 0x5c026000, - 0x5c026800, 0x5c025800, 0x5c03e000, 0x040009b4, - 0x1c01f000, 0x59300800, 0x497a6000, 0x0401f997, - 0x801831c0, 0x04020009, 0x598c0004, 0x81300580, - 0x04020004, 0x48031804, 0x48031805, 0x0401f008, - 0x48071805, 0x0401f006, 0x48043000, 0x598c0004, - 0x81300580, 0x04020002, 0x481b1804, 0x0401f199, - 0x4943c857, 0x0401f9a8, 0x4df00000, 0x0401fe34, - 0x0401fecb, 0x5c03e000, 0x04000999, 0x1c01f000, - 0x4947c857, 0x0401f9a0, 0x4df00000, 0x4d3c0000, - 0x853e7d00, 0x0401fe75, 0x0401fefc, 0x5c027800, - 0x5c03e000, 0x0400098e, 0x1c01f000, 0x5c000000, - 0x4c000000, 0x4803c857, 0x4d340000, 0x4d2c0000, - 0x59326809, 0x59325808, 0x59300406, 0x82000c80, - 0x00000012, 0x02021800, 0x001005d8, 0x4933c857, - 0x4943c857, 0x493fc857, 0x4803c857, 0x0c01f804, - 0x5c025800, 0x5c026800, 0x1c01f000, 0x00106ae5, - 0x00106ae7, 0x00106af1, 0x00106b0b, 0x00106ae7, - 0x00106afb, 0x00106b23, 0x00106ae5, 0x00106ae5, - 0x00106b36, 0x00106b2d, 0x00106ae5, 0x00106ae5, - 0x00106ae5, 0x00106ae5, 0x00106ae5, 0x00106b3c, - 0x00106b3c, 0x0201f800, 0x001005d8, 0x0201f800, - 0x00109134, 0x02000800, 0x00102074, 0x0201f800, - 0x00109326, 0x0201f800, 0x0010801c, 0x0201f000, - 0x00107911, 0x812e59c0, 0x02020800, 0x001005d8, - 0x5930021d, 0x82000580, 0x00000003, 0x02000800, - 0x0010912a, 0x0201f000, 0x00107911, 0x0201f800, - 0x00109037, 0x02000000, 0x00107911, 0x592c1204, - 0x82081500, 0x000000ff, 0x82080580, 0x00000055, - 0x02020800, 0x001005d8, 0x49425a06, 0x0201f800, - 0x000202da, 0x0201f000, 0x00107911, 0x59300004, - 0x8400055c, 0x48026004, 0x59300007, 0x8c000500, - 0x02020800, 0x00100e99, 0x0201f800, 0x00109037, - 0x0400000d, 0x4a025a04, 0x00000103, 0x49425a06, - 0x497a5c09, 0x0201f800, 0x001091c6, 0x0201f800, - 0x0010a693, 0x0201f800, 0x000202da, 0x0201f800, - 0x0010912a, 0x0201f000, 0x00107911, 0x59300007, - 0x8c000500, 0x02020800, 0x00100e99, 0x0201f800, - 0x00109037, 0x02020800, 0x0010a3ef, 0x0201f000, - 0x00107911, 0x0201f800, 0x00109037, 0x04000005, - 0x49425a06, 0x497a5c09, 0x0201f800, 0x000202da, - 0x0201f000, 0x00107911, 0x0201f800, 0x00109037, - 0x02020800, 0x0010664f, 0x0201f000, 0x00107911, - 0x0201f800, 0x00109037, 0x04000004, 0x49425a06, - 0x0201f800, 0x000202da, 0x59325817, 0x0201f800, - 0x001007fd, 0x0201f000, 0x00107911, 0x598c000d, - 0x81300580, 0x04000003, 0x497a6007, 0x1c01f000, - 0x59c40004, 0x82000500, 0x0000000c, 0x04000005, - 0x4a038804, 0x0000000c, 0x497b2807, 0x0401f00a, - 0x0401facd, 0x59300403, 0x82000d80, 0x00000040, - 0x04000004, 0x82000580, 0x00000042, 0x04020002, - 0x497a6007, 0x0201f800, 0x001070b9, 0x80000580, - 0x1c01f000, 0x59300804, 0x8c040d3e, 0x04020004, - 0x82000540, 0x00000001, 0x0401f005, 0x4933c857, - 0x84040d3e, 0x48066004, 0x80000580, 0x1c01f000, - 0x59300804, 0x8c040d20, 0x04020004, 0x82000540, - 0x00000001, 0x1c01f000, 0x4933c857, 0x4d380000, - 0x59300804, 0x84040d20, 0x48066004, 0x42027000, - 0x00000049, 0x59300203, 0x82000580, 0x00000003, - 0x04000003, 0x42027000, 0x00000013, 0x0201f800, - 0x000207a1, 0x80000580, 0x5c027000, 0x1c01f000, - 0x59300017, 0x81480580, 0x04020003, 0x59300018, - 0x814c0580, 0x1c01f000, 0x4d2c0000, 0x4d300000, - 0x0401f8c9, 0x4df00000, 0x0201f800, 0x00106062, - 0x59900001, 0x82000500, 0x00000003, 0x0c01f001, - 0x00106bba, 0x00106b9a, 0x00106b98, 0x00106b98, - 0x0201f800, 0x001005d8, 0x59926004, 0x0401f88e, - 0x813261c0, 0x0400001d, 0x59300004, 0x8c000516, - 0x04000004, 0x59325808, 0x497a5808, 0x497a5809, - 0x0401f88e, 0x59300001, 0x800001c0, 0x0400000e, - 0x497a6001, 0x42003000, 0x0000bf2e, 0x58180801, - 0x800409c0, 0x04020004, 0x48003001, 0x48003000, - 0x0401f00a, 0x58180800, 0x48000800, 0x48003000, - 0x0401f006, 0x59300809, 0x800409c0, 0x02000800, - 0x001005d8, 0x4978080c, 0x5c03e000, 0x04000890, - 0x5c026000, 0x5c025800, 0x1c01f000, 0x4d300000, - 0x497b2807, 0x0401f894, 0x4df00000, 0x598c0000, - 0x82000500, 0x00000007, 0x4803c857, 0x0c01f001, - 0x00106bef, 0x00106bd2, 0x00106bdb, 0x00106bdf, - 0x00106bea, 0x00106bef, 0x00106bd0, 0x00106bd0, - 0x0201f800, 0x001005d8, 0x598c000d, 0x80026540, - 0x04000004, 0x0401f81e, 0x02020800, 0x001005d8, - 0x0201f800, 0x001070b9, 0x0401f015, 0x0401f827, - 0x0201f800, 0x001070b9, 0x0401f011, 0x598c000d, - 0x80026540, 0x0400000e, 0x0401f838, 0x04000004, - 0x0401f80f, 0x04000002, 0x0401f81c, 0x0201f800, - 0x001070b9, 0x0401f006, 0x0401f830, 0x02020800, - 0x001005d8, 0x0201f800, 0x001070b9, 0x5c03e000, - 0x0400085b, 0x5c026000, 0x1c01f000, 0x598c0009, - 0x81300580, 0x0402000c, 0x0401f84e, 0x0401f83b, - 0x59300000, 0x800001c0, 0x04000004, 0x48031809, - 0x497a6000, 0x0401f003, 0x497b1809, 0x497b1808, - 0x80000580, 0x1c01f000, 0x4d2c0000, 0x59300406, - 0x82000580, 0x00000003, 0x04020012, 0x598c000b, - 0x81300580, 0x0402000f, 0x0401f83a, 0x59325808, - 0x497a5808, 0x497a5809, 0x0401f824, 0x59300000, - 0x800001c0, 0x04000004, 0x4803180b, 0x497a6000, - 0x0401f003, 0x497b180a, 0x497b180b, 0x80000580, - 0x5c025800, 0x1c01f000, 0x598c0005, 0x81300580, - 0x0402000c, 0x0401f827, 0x0401f814, 0x59300000, - 0x800001c0, 0x04000004, 0x48031805, 0x497a6000, - 0x0401f003, 0x497b1805, 0x497b1804, 0x80000580, - 0x1c01f000, 0x4a032001, 0x00000000, 0x497b2004, - 0x497b2005, 0x59900006, 0x82000500, 0x0000ffff, - 0x48032006, 0x1c01f000, 0x4c040000, 0x59300004, - 0x82000500, 0x7ffeffff, 0x48026004, 0x59bc00e4, - 0x8c000514, 0x04000009, 0x42000800, 0x0000bf00, - 0x58040012, 0x81300580, 0x04020004, 0x49780812, - 0x4a0378e4, 0x00000800, 0x5c000800, 0x1c01f000, - 0x4803c856, 0x598c000c, 0x80000540, 0x04000003, - 0x80000040, 0x4803180c, 0x1c01f000, 0x59bc00ea, - 0x82000500, 0x00000007, 0x82000580, 0x00000003, - 0x04020004, 0x4803c856, 0x4a0378e8, 0x00000001, - 0x1c01f000, 0x59bc00ea, 0x82000500, 0x00000007, - 0x82000580, 0x00000001, 0x04020011, 0x4803c856, - 0x42000800, 0x00000000, 0x0401f80e, 0x42000800, - 0x00001000, 0x59bc00ea, 0x82000500, 0x00000007, - 0x82000580, 0x00000003, 0x04000005, 0x80040840, - 0x040207f9, 0x0201f800, 0x001005d8, 0x1c01f000, - 0x59bc00ea, 0x82000500, 0x00000007, 0x82000580, - 0x00000001, 0x02020800, 0x001005d8, 0x59bc00ea, - 0x8c000516, 0x040207fe, 0x480778e1, 0x1c01f000, - 0x59bc00ea, 0x8c000516, 0x040207fe, 0x480778e1, - 0x59bc00ea, 0x8c000516, 0x040207fe, 0x480b78e1, - 0x1c01f000, 0x82000d00, 0x80000018, 0x02020800, - 0x001005d0, 0x0201f800, 0x001005d8, 0x00106c97, - 0x00106d3b, 0x00106d55, 0x00106c97, 0x00106c99, - 0x00106cba, 0x00106cd9, 0x00106d0d, 0x00106c97, - 0x00106d39, 0x00106c97, 0x00106c97, 0x00106c97, - 0x00106c97, 0x00106c97, 0x00106c97, 0x0201f800, - 0x001005d8, 0x4d300000, 0x4d900000, 0x4dd00000, - 0x4da40000, 0x4d140000, 0x0201f800, 0x001070d8, - 0x59bc00ea, 0x8c000510, 0x040007fe, 0x59be60e0, - 0x59300004, 0x8c000520, 0x04000011, 0x82000500, - 0xfffefeff, 0x48026004, 0x4a026203, 0x00000003, - 0x0401ffa9, 0x0201f800, 0x00100fd0, 0x5c022800, - 0x5c034800, 0x5c03a000, 0x5c032000, 0x5c026000, - 0x4a0378e4, 0x00000008, 0x0401f795, 0x84000510, - 0x48026004, 0x0401f7f6, 0x4d300000, 0x4d900000, - 0x4dd00000, 0x4da40000, 0x4d140000, 0x0201f800, - 0x001070d8, 0x59bc00ea, 0x8c000510, 0x040007fe, - 0x59be60e0, 0x59300004, 0x8c000520, 0x0400000f, - 0x82000500, 0xfffefeff, 0x48026004, 0x0401ff8a, - 0x0201f800, 0x0010100e, 0x5c022800, 0x5c034800, - 0x5c03a000, 0x5c032000, 0x5c026000, 0x4a0378e4, - 0x00000008, 0x0401f776, 0x84000510, 0x48026004, - 0x0401f7f6, 0x4d300000, 0x4d2c0000, 0x4d340000, - 0x4da40000, 0x4cd00000, 0x59bc00ea, 0x8c000510, - 0x040007fe, 0x59be60e0, 0x813261c0, 0x02000800, - 0x001005d8, 0x59300004, 0x8c000520, 0x0400001d, - 0x82000500, 0xfffefeff, 0x48026004, 0x59326809, - 0x42034800, 0x0010b544, 0x04011000, 0x4a03c840, - 0x0010b54b, 0x4a03c842, 0x00000012, 0x04011000, - 0x4a03c840, 0x0010b55d, 0x4a03c842, 0x000000ff, - 0x04011000, 0x4a03c840, 0x0010b65c, 0x4a03c842, - 0x000000ff, 0x0401fbf2, 0x5c01a000, 0x5c034800, - 0x5c026800, 0x5c025800, 0x5c026000, 0x1c01f000, - 0x84000510, 0x48026004, 0x5c01a000, 0x5c034800, - 0x5c026800, 0x5c025800, 0x5c026000, 0x1c01f000, - 0x1c01f000, 0x4d300000, 0x4d2c0000, 0x4d340000, - 0x4cd00000, 0x4d900000, 0x4dd00000, 0x4da40000, - 0x4d140000, 0x0401fbc3, 0x59bc00ea, 0x8c000510, - 0x040007fe, 0x59be60e0, 0x813261c0, 0x02000800, - 0x001005d8, 0x59300004, 0x8c000520, 0x0400000f, - 0x82000500, 0xfffefeff, 0x48026004, 0x0201f800, - 0x0010783a, 0x5c022800, 0x5c034800, 0x5c03a000, - 0x5c032000, 0x5c01a000, 0x5c026800, 0x5c025800, - 0x5c026000, 0x1c01f000, 0x84000510, 0x48026004, - 0x5c022800, 0x5c034800, 0x5c03a000, 0x5c032000, - 0x5c01a000, 0x5c026800, 0x5c025800, 0x5c026000, - 0x1c01f000, 0x0201f800, 0x001005d8, 0x4d300000, - 0x4d380000, 0x42000000, 0x0010b8c4, 0x0201f800, - 0x0010aa47, 0x0401ff14, 0x598e600d, 0x59c40004, - 0x8c000506, 0x04000004, 0x0401f8db, 0x4a038804, - 0x00000008, 0x813261c0, 0x04000006, 0x0401fb87, - 0x42027000, 0x00000014, 0x0201f800, 0x000207a1, - 0x4a0378e4, 0x00000002, 0x5c027000, 0x5c026000, - 0x0401f6f7, 0x4d180000, 0x4d300000, 0x4d380000, - 0x4d900000, 0x4dd00000, 0x4da40000, 0x4d140000, - 0x0401fef9, 0x417a3000, 0x59c40804, 0x83180400, - 0x0010709f, 0x50000000, 0x80040500, 0x0400001b, - 0x42000000, 0x0010b8c5, 0x0201f800, 0x0010aa47, - 0x0401fb70, 0x59926004, 0x0401f859, 0x83180400, - 0x0010709f, 0x50000000, 0x48038804, 0x813261c0, - 0x0400000a, 0x59300004, 0x8c00050c, 0x04020003, - 0x4a026203, 0x00000003, 0x42027000, 0x0000004a, - 0x0201f800, 0x000207a1, 0x59c40004, 0x82000500, - 0x00f80000, 0x04000005, 0x811a3000, 0x83180480, - 0x00000005, 0x040017dd, 0x4a0378e4, 0x00000008, - 0x5c022800, 0x5c034800, 0x5c03a000, 0x5c032000, - 0x5c027000, 0x5c026000, 0x5c023000, 0x0401f6c0, - 0x4d2c0000, 0x4d340000, 0x59326809, 0x598c0800, - 0x82040580, 0x00000004, 0x04020004, 0x838c1400, - 0x00000005, 0x0401f00c, 0x82040580, 0x00000001, - 0x04020004, 0x838c1400, 0x00000009, 0x0401f006, - 0x82040580, 0x00000002, 0x04020022, 0x838c1400, - 0x0000000b, 0x41306800, 0x58340000, 0x80007d40, - 0x0400001c, 0x583c0009, 0x81340580, 0x04020006, - 0x403c6800, 0x583c0000, 0x80007d40, 0x040207fa, - 0x0401f014, 0x4933c857, 0x483fc857, 0x583c0000, - 0x48006800, 0x49307800, 0x443c1000, 0x80000580, - 0x4803180d, 0x4803180f, 0x598c0000, 0x82000580, - 0x00000003, 0x04000003, 0x4a031800, 0x00000000, - 0x80000580, 0x5c026800, 0x5c025800, 0x1c01f000, - 0x82000540, 0x00000001, 0x0401f7fb, 0x491bc857, - 0x59c80840, 0x82040540, 0x00000010, 0x48039040, - 0x59c41008, 0x82080500, 0xffffff7f, 0x48038808, - 0x4c040000, 0x4c080000, 0x0401fabb, 0x04020007, - 0x0401fabf, 0x04000022, 0x48038804, 0x0201f800, - 0x0010107a, 0x0401f042, 0x4a038803, 0x00000008, - 0x59c40003, 0x82000500, 0x00000003, 0x040007fd, - 0x8c000502, 0x04020007, 0x0401fab1, 0x04000014, - 0x48038804, 0x0201f800, 0x0010107a, 0x0401f034, - 0x59c80040, 0x8400056a, 0x48039040, 0x59c80040, - 0x8c00052a, 0x040207fe, 0x59c40005, 0x82000500, - 0xc0000000, 0x04000006, 0x59c400a3, 0x84000540, - 0x480388a3, 0x4a038805, 0xc0000000, 0x0201f800, - 0x0010101d, 0x4a03a005, 0x30000000, 0x59d00006, - 0x4a03a005, 0x30000000, 0x59900006, 0x82000500, - 0xffff0000, 0x48032006, 0x59d00005, 0x8c000504, - 0x040207fe, 0x42000800, 0x00007600, 0x83180540, - 0x60000000, 0x480008a1, 0x811800dc, 0x59c80840, - 0x80040540, 0x48039040, 0x82000540, 0x00003000, - 0x48039040, 0x59c80040, 0x82000500, 0x00003000, - 0x040207fd, 0x0201f800, 0x00101068, 0x83180400, - 0x0010709f, 0x50000000, 0x48038804, 0x80000580, - 0x4df00000, 0x0201f800, 0x00106062, 0x5c03e000, - 0x5c001000, 0x5c000800, 0x480b8808, 0x48079040, - 0x1c01f000, 0x4803c856, 0x59c80840, 0x82040540, - 0x00000010, 0x48039040, 0x59c41008, 0x82080500, - 0xffffff7f, 0x48038808, 0x4c040000, 0x4c080000, - 0x59c40004, 0x82000500, 0x00000003, 0x04020010, - 0x59c40004, 0x82000500, 0x0000000c, 0x04000005, - 0x4a038804, 0x0000000c, 0x8c000504, 0x0401f025, - 0x59c80040, 0x8400056e, 0x48039040, 0x59c80040, - 0x8c00052e, 0x040207fe, 0x0401f01e, 0x4a038803, - 0x00000008, 0x59c40003, 0x82000500, 0x00000003, - 0x040007fd, 0x8c000502, 0x04020006, 0x59c40004, - 0x4a038804, 0x0000000c, 0x8c000504, 0x0401f011, - 0x59c80040, 0x8400056a, 0x48039040, 0x59c80040, - 0x8c00052a, 0x040207fe, 0x59c40005, 0x82000500, - 0xc0000000, 0x04000007, 0x59c400a3, 0x84000540, - 0x480388a3, 0x4a038805, 0xc0000000, 0x80000580, - 0x497b2807, 0x5c001000, 0x5c000800, 0x480b8808, - 0x48079040, 0x1c01f000, 0x4933c857, 0x4d900000, - 0x4dd00000, 0x4da40000, 0x4d140000, 0x0401fdee, - 0x4df00000, 0x0401fa6f, 0x59900004, 0x800001c0, - 0x04000011, 0x81300580, 0x0402000f, 0x59300004, - 0x84000520, 0x48026004, 0x0401ff51, 0x04020009, - 0x5c03e000, 0x04000dd6, 0x80000580, 0x5c022800, - 0x5c034800, 0x5c03a000, 0x5c032000, 0x1c01f000, - 0x0401fd0e, 0x42027000, 0x00000049, 0x59300004, - 0x84000520, 0x48026004, 0x8c00050c, 0x02020800, - 0x000207a1, 0x5c03e000, 0x04000dc5, 0x82000540, - 0x00000001, 0x5c022800, 0x5c034800, 0x5c03a000, - 0x5c032000, 0x1c01f000, 0x4933c857, 0x0401fdc6, - 0x4df00000, 0x598c000d, 0x80026540, 0x04000012, - 0x59300004, 0x84000520, 0x48026004, 0x0401ff8a, - 0x04000017, 0x0401fd26, 0x42027000, 0x00000013, - 0x59300004, 0x8c00050c, 0x02020800, 0x000207a1, - 0x5c03e000, 0x04000daa, 0x82000540, 0x00000001, - 0x1c01f000, 0x836c1580, 0x00000001, 0x040007f9, - 0x836c1580, 0x00000004, 0x040007f6, 0x42001000, - 0x00104148, 0x0201f800, 0x00105f90, 0x5c03e000, - 0x04000d9b, 0x80000580, 0x1c01f000, 0x4d300000, - 0x4d180000, 0x4d3c0000, 0x0401fd9f, 0x4df00000, - 0x4a0378e4, 0x0000000f, 0x0401f9ff, 0x417a3000, - 0x59926004, 0x813261c0, 0x04000010, 0x417a7800, - 0x0201f800, 0x001048d9, 0x0400000a, 0x59300c06, - 0x82040580, 0x00000003, 0x04000004, 0x82040580, - 0x00000006, 0x04020003, 0x42027800, 0x00000002, - 0x0201f800, 0x00108be3, 0x811a3000, 0x83180480, - 0x00000005, 0x040017eb, 0x42000800, 0x00000040, - 0x0201f800, 0x00101345, 0x4a0378e4, 0x0000000a, - 0x5c03e000, 0x04000d72, 0x5c027800, 0x5c023000, - 0x5c026000, 0x1c01f000, 0x4803c856, 0x4d300000, - 0x0401fd75, 0x4df00000, 0x59c80840, 0x82040540, - 0x00000010, 0x48039040, 0x59c41008, 0x82080500, - 0xffffff7f, 0x48038808, 0x4c040000, 0x4c080000, - 0x42001000, 0x00000003, 0x0401f9c2, 0x598e600d, - 0x813261c0, 0x04020f9d, 0x040009c7, 0x497b2807, - 0x0401f80a, 0x5c001000, 0x5c000800, 0x480b8808, - 0x84040d74, 0x48079040, 0x5c03e000, 0x04000d50, - 0x5c026000, 0x1c01f000, 0x4d380000, 0x4d180000, - 0x4d300000, 0x4d900000, 0x4dd00000, 0x4da40000, - 0x4d140000, 0x59c41004, 0x480bc857, 0x82080500, - 0x00003ff0, 0x04000025, 0x417a3000, 0x4c080000, - 0x0201f800, 0x00106062, 0x5c001000, 0x82080500, - 0x00000210, 0x04020004, 0x811a3000, 0x80081102, - 0x0401f7f7, 0x0401f9c3, 0x59926004, 0x4933c857, - 0x813261c0, 0x04020005, 0x59c400a3, 0x8c00051a, - 0x02000800, 0x001005d8, 0x0401fea5, 0x04000009, - 0x0401fc6a, 0x42027000, 0x00000049, 0x59300004, - 0x8c00050c, 0x02020800, 0x000207a1, 0x0401f007, - 0x42027000, 0x0000004a, 0x4a026203, 0x00000003, - 0x0201f800, 0x000207a1, 0x5c022800, 0x5c034800, - 0x5c03a000, 0x5c032000, 0x5c026000, 0x5c023000, - 0x5c027000, 0x1c01f000, 0x4d300000, 0x4d180000, - 0x4d900000, 0x0401fd1c, 0x42001000, 0x00000000, - 0x598c0000, 0x82000580, 0x00000005, 0x04000971, - 0x417a3000, 0x811b20c8, 0x83932400, 0x0000bf32, - 0x59900001, 0x82000580, 0x00000001, 0x0402000d, - 0x42000800, 0x000007d0, 0x59926004, 0x59300011, - 0x82000500, 0xfff00000, 0x80000540, 0x04000003, - 0x42000800, 0x00001b58, 0x0201f800, 0x00106054, - 0x811a3000, 0x83180480, 0x00000005, 0x040017ea, - 0x59c81040, 0x84081534, 0x480b9040, 0x0401fcf0, - 0x5c032000, 0x5c023000, 0x5c026000, 0x1c01f000, - 0x4933c857, 0x4d900000, 0x4dd00000, 0x4da40000, - 0x4d140000, 0x4d380000, 0x0401fcef, 0x4df00000, - 0x59300004, 0x8c00053e, 0x04020007, 0x8c000520, - 0x04000025, 0x0201f800, 0x00106b6c, 0x04000022, - 0x0401f02a, 0x598c000d, 0x81300580, 0x04000011, - 0x0201f800, 0x00108cd6, 0x04020024, 0x0401f918, - 0x04000022, 0x48038804, 0x0401f95e, 0x0201f800, - 0x0010107a, 0x0401fc0d, 0x42027000, 0x00000049, - 0x59300004, 0x8c00050c, 0x0402000d, 0x0401f00e, - 0x59c40004, 0x8c000504, 0x04000014, 0x4a038804, - 0x00000004, 0x0401fc36, 0x42027000, 0x00000013, - 0x59300004, 0x8c00050c, 0x04000003, 0x0201f800, - 0x000207a1, 0x5c03e000, 0x04000cb9, 0x5c027000, - 0x5c022800, 0x5c034800, 0x5c03a000, 0x5c032000, - 0x80000580, 0x1c01f000, 0x5c03e000, 0x04000cb0, - 0x5c027000, 0x5c022800, 0x5c034800, 0x5c03a000, - 0x5c032000, 0x82000540, 0x00000001, 0x1c01f000, - 0x497b2807, 0x0401fcb0, 0x59c400af, 0x800001c0, - 0x04020004, 0x0401fca2, 0x0201f000, 0x001014fb, - 0x598c000f, 0x82001480, 0x00000002, 0x04021007, - 0x80000000, 0x4803180f, 0x80000580, 0x0201f800, - 0x0010604d, 0x0400000e, 0x0401fed8, 0x0402000c, - 0x0401fdd4, 0x0400000a, 0x0201f800, 0x0010a9c7, - 0x0401f916, 0x4d380000, 0x42027000, 0x00000014, - 0x0201f800, 0x000207a1, 0x5c027000, 0x0401fc88, - 0x0201f000, 0x001014fb, 0x4d900000, 0x4dd00000, - 0x4da40000, 0x4d140000, 0x4d300000, 0x0201f800, - 0x00106062, 0x0401fc88, 0x59c400af, 0x800001c0, - 0x04000027, 0x0401f907, 0x59926004, 0x4933c857, - 0x59300004, 0x8c000516, 0x0400000b, 0x0401fe8b, - 0x0402001f, 0x0201f800, 0x00106b8a, 0x0401fc70, - 0x42000800, 0x80000804, 0x0201f800, 0x00106721, - 0x0401f017, 0x42001800, 0x00007530, 0x0401f8c1, - 0x04020004, 0x0201f800, 0x00106052, 0x0401f010, - 0x0401fe7a, 0x0402000e, 0x0201f800, 0x0010a9c7, - 0x59300004, 0x8c00050c, 0x04020003, 0x4a026203, - 0x00000003, 0x4d380000, 0x42027000, 0x0000004a, - 0x0201f800, 0x000207a1, 0x5c027000, 0x0401fc54, - 0x5c026000, 0x5c022800, 0x5c034800, 0x5c03a000, - 0x5c032000, 0x0201f000, 0x001014fb, 0x4d900000, - 0x4dd00000, 0x4da40000, 0x4d140000, 0x4d300000, - 0x4d2c0000, 0x0401fc50, 0x0401f8d2, 0x59926004, - 0x4933c857, 0x0401f880, 0x04000016, 0x0201f800, - 0x00106062, 0x813261c0, 0x04000034, 0x59325808, - 0x812e59c0, 0x02000800, 0x001005d8, 0x0201f800, - 0x0010513b, 0x0402001d, 0x592c0208, 0x84000550, - 0x48025a08, 0x0201f800, 0x00105258, 0x04020027, - 0x592c0208, 0x84000510, 0x48025a08, 0x0401f023, - 0x0201f800, 0x00106052, 0x0401f020, 0x0201f800, - 0x0010a9c7, 0x0401fd9e, 0x592c0208, 0x84000550, - 0x48025a08, 0x4d380000, 0x42027000, 0x0000004a, - 0x4a026203, 0x00000003, 0x0201f800, 0x000207a1, - 0x5c027000, 0x0401f011, 0x59900006, 0x82000500, - 0xffff0000, 0x040207ee, 0x59c408af, 0x82040480, - 0x000003e8, 0x040217ea, 0x59900006, 0x82000400, - 0x00010000, 0x48032006, 0x0201f800, 0x00106052, - 0x0201f800, 0x0010411d, 0x5c025800, 0x5c026000, - 0x5c022800, 0x5c034800, 0x5c03a000, 0x5c032000, - 0x0401f403, 0x4d300000, 0x4d2c0000, 0x0401fc0a, - 0x598e600d, 0x4933c857, 0x59c41004, 0x8c081500, - 0x04000007, 0x0201f800, 0x0010513b, 0x04020007, - 0x0201f800, 0x00105258, 0x0402002f, 0x0201f800, - 0x0010604d, 0x0401f02c, 0x598c000f, 0x80000540, - 0x04020011, 0x59c408af, 0x82040480, 0x000003e8, - 0x0402100d, 0x598c080f, 0x80040800, 0x4807180f, - 0x0201f800, 0x0010604d, 0x42000000, 0x0010b852, - 0x0201f800, 0x0010aa47, 0x0201f800, 0x0010411d, - 0x0401f019, 0x0401fdb4, 0x813261c0, 0x04020003, - 0x0401f849, 0x0401f014, 0x0201f800, 0x0010a9c7, - 0x59300406, 0x82000580, 0x00000003, 0x04020007, - 0x59325808, 0x812e59c0, 0x04000004, 0x592c0208, - 0x84000550, 0x48025a08, 0x0401f854, 0x4d380000, - 0x42027000, 0x00000014, 0x0201f800, 0x000207a1, - 0x5c027000, 0x5c025800, 0x5c026000, 0x0201f000, - 0x00106c4b, 0x59c40804, 0x83180400, 0x00107095, - 0x50000000, 0x80040500, 0x1c01f000, 0x59c40804, - 0x83180400, 0x0010709a, 0x50000000, 0x80040500, - 0x1c01f000, 0x00000210, 0x00000420, 0x00000840, - 0x00001080, 0x00002100, 0x00004000, 0x00008000, - 0x00010000, 0x00020000, 0x00040000, 0x00080000, - 0x00100000, 0x00200000, 0x00400000, 0x00800000, - 0x59900806, 0x80040120, 0x800c0480, 0x04021004, - 0x82000540, 0x00000001, 0x0401f005, 0x82040c00, - 0x00010000, 0x48072006, 0x80000580, 0x1c01f000, - 0x480bc857, 0x0201f800, 0x00106c55, 0x4df00000, - 0x480b1800, 0x5c03e000, 0x02000800, 0x00106c4b, - 0x1c01f000, 0x4803c856, 0x0201f800, 0x00106c55, - 0x4df00000, 0x497b180d, 0x497b1803, 0x497b180e, - 0x497b180f, 0x497b1810, 0x598c0000, 0x82000580, - 0x00000003, 0x04000009, 0x836c0580, 0x00000002, - 0x04020004, 0x4a031800, 0x00000005, 0x0401f003, - 0x4a031800, 0x00000000, 0x5c03e000, 0x02000800, - 0x00106c4b, 0x1c01f000, 0x59300004, 0x8c00050c, - 0x04020003, 0x4a026203, 0x00000001, 0x1c01f000, - 0x83180480, 0x00000005, 0x02021800, 0x001005d8, - 0x491bc857, 0x811b20c8, 0x83932400, 0x0000bf32, - 0x811ba0ca, 0x83d3a400, 0x00007600, 0x83180400, - 0x001070ea, 0x50034800, 0x811a28c2, 0x83162c00, - 0x00006100, 0x1c01f000, 0x0010b75b, 0x0010b772, - 0x0010b789, 0x0010b7a0, 0x0010b7b7, 0x4933c857, - 0x59300406, 0x82000c80, 0x00000012, 0x04021016, - 0x4803c857, 0x04011000, 0x0c01f001, 0x00107109, - 0x00107198, 0x001074d1, 0x00107556, 0x00107198, - 0x001074d1, 0x00107556, 0x00107109, 0x00107198, - 0x00107109, 0x00107109, 0x00107109, 0x00107109, - 0x00107109, 0x00107109, 0x00107109, 0x0010710f, - 0x0010710f, 0x0201f800, 0x00106c55, 0x0201f800, - 0x00106bbf, 0x0201f000, 0x00106c4b, 0x42001000, - 0x0010b7f6, 0x50081000, 0x4930100c, 0x58080002, - 0x82000580, 0x00000100, 0x04020032, 0x59325808, - 0x812e59c0, 0x02000800, 0x001005d8, 0x59326809, - 0x813669c0, 0x04000019, 0x592c040b, 0x82000500, - 0x0000e000, 0x04000003, 0x0401fba8, 0x0401f002, - 0x0401fb98, 0x42001000, 0x0010b7f6, 0x50081000, - 0x4930100b, 0x492c100a, 0x82d00400, 0x00000006, - 0x48001003, 0x592c000d, 0x80000104, 0x48001004, - 0x592c000e, 0x48001007, 0x592c000f, 0x48001008, - 0x0201f000, 0x00100858, 0x42026800, 0x0010be0d, - 0x592c080a, 0x48066802, 0x82040500, 0x00ffff00, - 0x04000007, 0x497a6a12, 0x59a81010, 0x82081500, - 0x00ffff00, 0x80080580, 0x040207dc, 0x82040d00, - 0x000000ff, 0x800408d0, 0x48066a12, 0x0401f7d7, - 0x1c01f000, 0x4d2c0000, 0x4d300000, 0x4c580000, - 0x4c540000, 0x4c500000, 0x5832580a, 0x812e59c0, - 0x02000800, 0x001005d8, 0x58300002, 0x4a006002, - 0x00000100, 0x82000580, 0x00000100, 0x0402001c, - 0x5830000b, 0x5832600c, 0x81300580, 0x04020010, - 0x0401f828, 0x04020010, 0x592c080d, 0x80040904, - 0x4004b000, 0x4200a000, 0x0010b54b, 0x4050a800, - 0x0201f800, 0x0010ab28, 0x42001000, 0x0000dc00, - 0x0201f800, 0x001078bc, 0x0401f003, 0x0401f819, - 0x04000fa3, 0x5c00a000, 0x5c00a800, 0x5c00b000, - 0x5c026000, 0x5c025800, 0x1c01f000, 0x5830000b, - 0x5832600c, 0x81300580, 0x040207f5, 0x0401f80d, - 0x040207f5, 0x0201f800, 0x001068d3, 0x02020800, - 0x001005d8, 0x4a025a06, 0x00000002, 0x0201f800, - 0x000202da, 0x0201f800, 0x00107911, 0x0401f7ea, - 0x0201f800, 0x00106c55, 0x4df00000, 0x598c000d, - 0x81300580, 0x04020009, 0x598c0005, 0x81300580, - 0x04020006, 0x5c03e000, 0x02000800, 0x00106c4b, - 0x80000580, 0x1c01f000, 0x5c03e000, 0x02000800, - 0x00106c4b, 0x82000540, 0x00000001, 0x1c01f000, - 0x59300403, 0x82000c80, 0x00000056, 0x02021800, - 0x001005d8, 0x4803c857, 0x0c01f001, 0x00107302, - 0x0010731d, 0x0010732e, 0x00107431, 0x001073f1, - 0x001073f5, 0x00107406, 0x0010741a, 0x0010740f, - 0x0010741a, 0x00107455, 0x0010741a, 0x00107497, - 0x0010741a, 0x001074a5, 0x0010741a, 0x0010740f, - 0x0010741a, 0x001074a9, 0x001071f5, 0x001071f5, - 0x001071f5, 0x001071f5, 0x001071f5, 0x001071f5, - 0x001071f5, 0x001071f5, 0x001071f5, 0x001071f5, - 0x001071f5, 0x00107574, 0x00107593, 0x0010759d, - 0x001071f5, 0x001075b3, 0x00107406, 0x001071f5, - 0x00107406, 0x0010741a, 0x001071f5, 0x0010732e, - 0x00107431, 0x001071f5, 0x00107603, 0x0010741a, - 0x001071f5, 0x00107613, 0x0010741a, 0x001071f5, - 0x0010740f, 0x001072f3, 0x001071f7, 0x001071f5, - 0x0010762a, 0x0010765d, 0x001076d7, 0x001071f5, - 0x001076e7, 0x00107404, 0x001076da, 0x001071f5, - 0x001075bf, 0x00107700, 0x001071f5, 0x00107735, - 0x00107788, 0x001071f5, 0x0010720c, 0x00107265, - 0x00107272, 0x001071f5, 0x00107406, 0x001071f5, - 0x001072b9, 0x001072c4, 0x001071f5, 0x001071f5, - 0x00107220, 0x00107245, 0x001077c7, 0x00107808, - 0x0010782e, 0x001071f5, 0x001071f5, 0x001071f5, - 0x001077fc, 0x0201f800, 0x001005d8, 0x0401fac5, - 0x59325808, 0x592c0009, 0x4801a006, 0x592c000a, - 0x4801a007, 0x592c000b, 0x4801a008, 0x592c000c, - 0x4801a009, 0x592c000d, 0x4801a00a, 0x4979a00b, - 0x592c0809, 0x82040d00, 0x00000fff, 0x80040904, - 0x42001000, 0x0000dc00, 0x0201f000, 0x001078bc, - 0x4a026202, 0x0000ffff, 0x0401faae, 0x4d2c0000, - 0x4a01a006, 0x05000000, 0x59325808, 0x592c0009, - 0x4801a007, 0x592c000a, 0x4801a008, 0x592c000b, - 0x4801a009, 0x42000800, 0x00000004, 0x42001000, - 0x0000dc00, 0x5c025800, 0x0201f000, 0x001078bc, - 0x4c580000, 0x4c500000, 0x4c540000, 0x4d2c0000, - 0x0401fa98, 0x59325808, 0x5930040b, 0x800000c2, - 0x4200a800, 0x0010b54b, 0x592cb205, 0x832ca400, - 0x00000006, 0x0201f800, 0x0010ab17, 0x40580000, - 0x8054ac00, 0x592c0001, 0x80000540, 0x04000003, - 0x40025800, 0x0401f7f5, 0x4200a000, 0x0010b54b, - 0x4050a800, 0x5930b40b, 0x0201f800, 0x0010ab28, - 0x59300c0b, 0x42001000, 0x0000dc00, 0x5c025800, - 0x5c00a800, 0x5c00b000, 0x5c00a000, 0x0201f000, - 0x001078bc, 0x4c580000, 0x4c500000, 0x4c540000, - 0x4d2c0000, 0x42034800, 0x0010b544, 0x0401fa7f, - 0x59325808, 0x4a025805, 0x02000000, 0x592c0802, - 0x82d0ac00, 0x00000006, 0x592cb011, 0x832ca400, - 0x00000005, 0x0201f800, 0x0010ab17, 0x40580000, - 0x8054ac00, 0x592e5801, 0x41780000, 0x812e5d40, - 0x040207f6, 0x42001000, 0x0000dc00, 0x5c025800, - 0x5c00a800, 0x5c00b000, 0x5c00a000, 0x0201f000, - 0x001078bc, 0x0401fa57, 0x4a01a006, 0x78000000, - 0x5930001c, 0x840001c0, 0x4801a407, 0x4979a207, - 0x42000800, 0x00000002, 0x42001000, 0x0000dc00, - 0x0201f000, 0x001078bc, 0x4c580000, 0x4c540000, - 0x4c500000, 0x0401fa55, 0x4a01a006, 0x02000000, - 0x59a80002, 0x4801a008, 0x59a80003, 0x4801a009, - 0x59a80000, 0x4801a00a, 0x59a80001, 0x4801a00b, - 0x5930001c, 0x82000d80, 0x0000e000, 0x04000016, - 0x82000d80, 0x0000df00, 0x04000006, 0x4a01a407, - 0x00000010, 0x42000800, 0x00000006, 0x0401f027, - 0x4a03c840, 0x0010b4eb, 0x4a03c842, 0x0000000d, - 0x42001800, 0x0010b4eb, 0x0201f800, 0x001007af, - 0x42000000, 0x0000df00, 0x4200a000, 0x0010b4eb, - 0x0401f00d, 0x4a03c840, 0x0010b4f8, 0x4a03c842, - 0x0000000d, 0x42001800, 0x0010b4f8, 0x0201f800, - 0x001007af, 0x42000000, 0x0000e000, 0x4200a000, - 0x0010b4f8, 0x82000540, 0x00000010, 0x4801a407, - 0x4a01a207, 0x00000034, 0x4200b000, 0x0000000d, - 0x82d0ac00, 0x0000000c, 0x0201f800, 0x0010ab17, - 0x42000800, 0x00000013, 0x42001000, 0x0000dc00, - 0x5c00a000, 0x5c00a800, 0x5c00b000, 0x0201f000, - 0x001078bc, 0x0401fa03, 0x4a01a006, 0x63000028, - 0x5930001c, 0x4801a007, 0x42000800, 0x00000002, - 0x42001000, 0x0000dc00, 0x0201f000, 0x001078bc, - 0x0401fa06, 0x41780000, 0x41780800, 0x42002000, - 0x00080000, 0x0c01f81b, 0x80000000, 0x80040800, - 0x42001000, 0x0000000c, 0x59841802, 0x8c0c1d00, - 0x04020008, 0x42002000, 0x00050000, 0x0c01f811, - 0x80000000, 0x80040800, 0x82081400, 0x00000004, - 0x82080540, 0x02000000, 0x4801a006, 0x800408e0, - 0x5930001c, 0x80040540, 0x4801a007, 0x80080904, - 0x42001000, 0x0000dc00, 0x0201f000, 0x001078bc, - 0x001072e9, 0x001072eb, 0x001072ed, 0x001072ef, - 0x001072f1, 0x4811a008, 0x1c01f000, 0x4811a009, - 0x1c01f000, 0x4811a00a, 0x1c01f000, 0x4811a00b, - 0x1c01f000, 0x4811a00c, 0x1c01f000, 0x4a026009, - 0x0010be0d, 0x59a80010, 0x82000500, 0x000000ff, - 0x800000d0, 0x42026800, 0x0010be0d, 0x48026a12, - 0x0401fa3b, 0x41780800, 0x42001000, 0x00005c00, - 0x0201f000, 0x001078bc, 0x0401f9ba, 0x4a01a006, - 0x52000000, 0x4979a007, 0x599c0017, 0x8c000500, - 0x04000005, 0x599c0402, 0x0201f800, 0x001015da, - 0x4805a007, 0x59a80002, 0x4801a008, 0x59a80003, - 0x4801a009, 0x59a80000, 0x4801a00a, 0x59a80001, - 0x4801a00b, 0x59a80010, 0x4801a00c, 0x42000800, - 0x00000007, 0x42001000, 0x0000dc00, 0x0201f000, - 0x001078bc, 0x4a026202, 0x0000ffff, 0x0401f99d, - 0x4a01a006, 0x05000000, 0x59a80010, 0x4801a007, - 0x59a80002, 0x59a80803, 0x4801a008, 0x4805a009, - 0x42000800, 0x00000004, 0x42001000, 0x0000dc00, - 0x0201f000, 0x001078bc, 0x4a026202, 0x0000ffff, - 0x0401f98c, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x001048f6, 0x5c027800, 0x4a01a006, 0x03000000, - 0x59340403, 0x82000580, 0x000007fe, 0x0402006e, - 0x4a01a006, 0x04000000, 0x81a40800, 0x4a000800, - 0x22fffffe, 0x5934000a, 0x84000500, 0x4802680a, - 0x59c41002, 0x8408150c, 0x480b8802, 0x59a80026, - 0x8c000508, 0x04000010, 0x59a8002a, 0x4801a007, - 0x59a8002b, 0x82000500, 0xffff2000, 0x599c0818, - 0x8c040d16, 0x04000002, 0x8400056a, 0x4801a008, - 0x4a01a009, 0x00002710, 0x59a8002d, 0x4801a00a, - 0x0401f039, 0x59a8002a, 0x4801a007, 0x0201f800, - 0x0010513b, 0x04020009, 0x497b8880, 0x82000500, - 0x0000ffff, 0x4c000000, 0x0201f800, 0x00101606, - 0x5c000000, 0x48038880, 0x59a8002b, 0x0201f800, - 0x0010513b, 0x04020004, 0x82000500, 0x37ffffff, - 0x0401f003, 0x82000500, 0x3fffffff, 0x599c0818, - 0x8c040d16, 0x04000002, 0x8400056a, 0x59a80805, - 0x8c040d10, 0x04000019, 0x59300c03, 0x82041580, - 0x00000051, 0x04000015, 0x82041580, 0x00000031, - 0x04000012, 0x4c580000, 0x4c500000, 0x4c540000, - 0x4200b000, 0x00000004, 0x4200a000, 0x0010b8fa, - 0x82d0ac00, 0x0000001f, 0x4c000000, 0x0201f800, - 0x0010ab17, 0x5c000000, 0x5c00a800, 0x5c00a000, - 0x5c00b000, 0x8400057a, 0x4801a008, 0x4979a009, - 0x4979a00a, 0x59a80002, 0x59a80803, 0x4801a00b, - 0x4805a00c, 0x59a80000, 0x59a80801, 0x4801a00d, - 0x4805a00e, 0x4979a00f, 0x4979a010, 0x4979a011, - 0x4979a012, 0x4979a013, 0x4979a014, 0x4979a015, - 0x4979a016, 0x59a8002e, 0x84000576, 0x4801a017, - 0x59a8002f, 0x4801a018, 0x4979a019, 0x4979a01a, - 0x0401f043, 0x59a80026, 0x8c000508, 0x0400000d, - 0x59a8002a, 0x82000500, 0x0000ffff, 0x59c40880, - 0x80040d80, 0x04000007, 0x497b8880, 0x4c000000, - 0x0201f800, 0x00101606, 0x5c000000, 0x48038880, - 0x59a8002a, 0x4801a007, 0x4c640000, 0x4d2c0000, - 0x59a8c82b, 0x0201f800, 0x00109037, 0x0400000d, - 0x0201f800, 0x00109597, 0x0402000a, 0x592c0207, - 0x8c00050e, 0x04000007, 0x8264cd00, 0x0000ffff, - 0x592c0009, 0x82000500, 0xffff0000, 0x8064cd40, - 0x4865a008, 0x5c025800, 0x5c00c800, 0x59a8002c, - 0x4801a009, 0x59a8002d, 0x4801a00a, 0x59a80002, - 0x59a80803, 0x4801a00b, 0x4805a00c, 0x59a80000, - 0x59a80801, 0x4801a00d, 0x4805a00e, 0x4979a00f, - 0x4979a010, 0x4979a011, 0x4979a012, 0x4979a013, - 0x4979a014, 0x4979a015, 0x4979a016, 0x59a8002e, - 0x4801a017, 0x59a8002f, 0x4801a018, 0x59a80030, - 0x4801a019, 0x59a80031, 0x4801a01a, 0x42000800, - 0x0000001d, 0x42001000, 0x0000dc00, 0x0201f000, - 0x001078bc, 0x0401f8cb, 0x4a01a006, 0x50000000, - 0x0401f7b5, 0x0401f8c7, 0x4a01a406, 0x21000010, - 0x4a01a206, 0x00000014, 0x4979a007, 0x4979a008, - 0x4979a009, 0x4979a00a, 0x42000800, 0x00000005, - 0x42001000, 0x0000dc00, 0x0201f000, 0x001078bc, - 0x0401f8bf, 0x0401f002, 0x0401f8c4, 0x4a01a006, - 0x02000000, 0x42000800, 0x00000001, 0x42001000, - 0x0000dc00, 0x0201f000, 0x001078bc, 0x0401f8bb, - 0x4a01a006, 0x02000000, 0x59300403, 0x82000580, - 0x00000031, 0x04020794, 0x81a40800, 0x4a000801, - 0x00fffffe, 0x0401f72b, 0x0401f8b0, 0x4a01a006, - 0x01000000, 0x5930041a, 0x80000540, 0x04000003, - 0x4801a407, 0x0401f003, 0x4a01a407, 0x00000003, - 0x5930021a, 0x80000540, 0x04000003, 0x4801a207, - 0x0401f003, 0x4a01a207, 0x00002a00, 0x42000800, - 0x00000002, 0x42001000, 0x0000dc00, 0x0201f000, - 0x001078bc, 0x4a026202, 0x0000ffff, 0x0401f889, - 0x4a01a406, 0x00002010, 0x4a01a206, 0x00000014, - 0x4a01a407, 0x00000800, 0x4a01a207, 0x00002000, - 0x80000580, 0x599c0817, 0x8c040d0a, 0x04020003, - 0x82000540, 0x00000020, 0x8c040d08, 0x04000003, - 0x82000540, 0x00000010, 0x82000540, 0x00000002, - 0x5934080a, 0x8c040d14, 0x04000005, 0x82040d00, - 0x00000380, 0x80040540, 0x0401f006, 0x599c0818, - 0x8c040d18, 0x04000003, 0x82000540, 0x00000380, - 0x0401f03c, 0x0401f875, 0x4a01a406, 0x00000210, - 0x4a01a206, 0x00000014, 0x4a01a407, 0x00000800, - 0x5934000a, 0x8c000516, 0x04000014, 0x59340c05, - 0x82040500, 0x00000030, 0x04000013, 0x59340a05, - 0x82040500, 0x0000c000, 0x04020009, 0x8c040d1a, - 0x04000004, 0x4a01a207, 0x00002100, 0x0401f00c, - 0x4a01a207, 0x00000100, 0x0401f009, 0x4a01a207, - 0x00000400, 0x0401f006, 0x4a01a207, 0x00000700, - 0x0401f003, 0x4a01a207, 0x00000800, 0x80000580, - 0x599c0817, 0x8c040d0a, 0x04020003, 0x82000540, - 0x00000020, 0x8c040d08, 0x04000003, 0x82000540, - 0x00000010, 0x82000540, 0x00000002, 0x59340a00, - 0x8c040d0e, 0x0400000b, 0x84000550, 0x599c1017, - 0x8c08150a, 0x04020004, 0x8c040d0a, 0x04000002, - 0x8400054e, 0x8c040d1c, 0x04000002, 0x84000552, - 0x4801a20a, 0x42000800, 0x00000005, 0x42001000, - 0x0000dc00, 0x0201f000, 0x001078bc, 0x0401f833, - 0x4a01a006, 0x02100014, 0x4a01a007, 0x01000000, - 0x4979a008, 0x4979a009, 0x4979a00a, 0x42000800, - 0x00000005, 0x42001000, 0x0000dc00, 0x0201f000, - 0x001078bc, 0x0401f825, 0x4a01a006, 0x02000000, - 0x0401f65d, 0x4933c857, 0x0401f820, 0x4a01a006, - 0x01000000, 0x4a01a407, 0x0000000b, 0x42000800, - 0x00000002, 0x42001000, 0x0000dc00, 0x0201f000, - 0x001078bc, 0x42005000, 0x32000000, 0x42006000, - 0x08290000, 0x41786800, 0x41787800, 0x0401f3df, - 0x42005000, 0x22000000, 0x42006000, 0x01290000, - 0x41786800, 0x41787800, 0x0401f3d8, 0x42005000, - 0x33000000, 0x42006000, 0x08980000, 0x41786800, - 0x41787800, 0x0401f3d1, 0x42005000, 0x23000000, - 0x42006000, 0x01980000, 0x41786800, 0x41787800, - 0x0401f3ca, 0x59300403, 0x82000c80, 0x00000085, - 0x02001800, 0x001005d8, 0x82000c80, 0x00000093, - 0x02021800, 0x001005d8, 0x82000480, 0x00000085, - 0x0c01f001, 0x001074eb, 0x001074ed, 0x001074fb, - 0x001074eb, 0x001074eb, 0x001074eb, 0x001074eb, - 0x001074eb, 0x001074eb, 0x001074eb, 0x001074eb, - 0x001074eb, 0x001074eb, 0x00107506, 0x0201f800, - 0x001005d8, 0x4933c857, 0x0401f850, 0x59300402, - 0x4801a407, 0x5930001c, 0x4801a207, 0x4979a408, - 0x4a01a208, 0x0000ffff, 0x42000800, 0x00000003, - 0x42001000, 0x0000dc00, 0x0401f3c2, 0x4933c857, - 0x0401f84e, 0x4a01a406, 0x00000003, 0x4a01a206, - 0x00000300, 0x42000800, 0x00000001, 0x42001000, - 0x0000dc00, 0x0401f3b7, 0x4d2c0000, 0x59325808, - 0x4933c857, 0x492fc857, 0x812e59c0, 0x02000800, - 0x001005d8, 0x59340a12, 0x82040d00, 0x0000ff00, - 0x592c000a, 0x82000500, 0x000000ff, 0x900001c0, - 0x80040540, 0x82000540, 0x00000011, 0x44034800, - 0x81a5a000, 0x42001000, 0x00000009, 0x42000800, - 0x00000003, 0x592c0009, 0x82000500, 0xff000000, - 0x82001d80, 0x84000000, 0x04000009, 0x82001d80, - 0x85000000, 0x02020800, 0x001005d8, 0x42001000, - 0x00000007, 0x42000800, 0x00000001, 0x832c1c00, - 0x00000009, 0x500c0000, 0x4401a000, 0x800c1800, - 0x80d1a000, 0x80081040, 0x040207fb, 0x42001000, - 0x0000dc00, 0x5c025800, 0x0401f386, 0x42005000, - 0x81000000, 0x42006000, 0x00090000, 0x41786800, - 0x41787800, 0x0401f35d, 0x42005000, 0x84000000, - 0x42006000, 0x00990000, 0x59300406, 0x82000580, - 0x00000005, 0x04000002, 0x8430652e, 0x41786800, - 0x41787800, 0x0401f351, 0x42005000, 0x85000000, - 0x42006000, 0x00990000, 0x59300406, 0x82000580, - 0x00000005, 0x04000002, 0x8430652e, 0x41786800, - 0x41787800, 0x0401f345, 0x59300403, 0x82000c80, - 0x00000053, 0x02021800, 0x001005d8, 0x82000480, - 0x0000004b, 0x02001800, 0x001005d8, 0x59326809, - 0x59368c03, 0x4803c857, 0x0c01f001, 0x001075da, - 0x001075e2, 0x001075ea, 0x001075f2, 0x0010756b, - 0x0010756b, 0x0010756b, 0x001075d2, 0x0201f800, - 0x001005d8, 0x42005000, 0x06000000, 0x42006000, - 0x08290000, 0x41786800, 0x41787800, 0x0401f327, - 0x4933c857, 0x0401ff47, 0x4a01a006, 0x12000000, - 0x59300406, 0x82000580, 0x00000004, 0x04020003, - 0x59340002, 0x0401f002, 0x59a80010, 0x82000500, - 0x00ffffff, 0x4801a007, 0x59300419, 0x4801a408, - 0x59300219, 0x4801a208, 0x4979a009, 0x4979a00a, - 0x4979a00b, 0x4979a00c, 0x4979a00d, 0x4979a00e, - 0x4979a00f, 0x4979a010, 0x42000800, 0x0000000b, - 0x42001000, 0x0000dc00, 0x0401f32a, 0x0401ff29, - 0x4a01a006, 0x0f000000, 0x5930001c, 0x4801a007, - 0x42000800, 0x00000002, 0x42001000, 0x0000dc00, - 0x0401f320, 0x0401ff2d, 0x4a01a006, 0x02000000, - 0x59c40085, 0x48031004, 0x59880000, 0x4801a007, - 0x59880001, 0x4801a008, 0x59880002, 0x4801a009, - 0x59880003, 0x4801a00a, 0x59880004, 0x4801a00b, - 0x59880005, 0x4801a00c, 0x42000800, 0x00000007, - 0x42001000, 0x0000dc00, 0x0401f30a, 0x4a026202, - 0x0000ffff, 0x0401ff07, 0x4a01a006, 0x62000000, - 0x5930001c, 0x4801a007, 0x42000800, 0x00000002, - 0x42001000, 0x0000dc00, 0x0401f2fe, 0x0401fefd, - 0x59300808, 0x4c500000, 0x4c540000, 0x4c580000, - 0x8204a400, 0x0000000a, 0x5930b01c, 0x82d0ac00, - 0x00000006, 0x0201f800, 0x0010ab17, 0x5930081c, - 0x42001000, 0x0000dc00, 0x5c00b000, 0x5c00a800, - 0x5c00a000, 0x0401f2eb, 0x0401ff9b, 0x59300017, - 0x4801a006, 0x59300018, 0x4801a007, 0x4a01a008, - 0x00001000, 0x0401f020, 0x0401ff93, 0x59300017, - 0x4801a006, 0x59300018, 0x4801a007, 0x4a01a008, - 0x00004000, 0x0401f018, 0x0401ff8b, 0x59300017, - 0x4801a006, 0x59300018, 0x4801a007, 0x4a01a008, - 0x00002000, 0x0401f010, 0x0401ff83, 0x59300017, - 0x4801a006, 0x59300018, 0x4801a007, 0x4a01a008, - 0x00000400, 0x0401f008, 0x0401ff7b, 0x59300017, - 0x4801a006, 0x59300018, 0x4801a007, 0x4a01a008, - 0x00000200, 0x4979a009, 0x4979a00a, 0x4979a00b, - 0x4979a00c, 0x4979a00d, 0x42000800, 0x00000008, - 0x42001000, 0x0000dc00, 0x0401f2ba, 0x0401fec7, - 0x4a01a006, 0x02000014, 0x4979a407, 0x4979a207, - 0x59a8003a, 0x4801a008, 0x59a8003b, 0x4801a009, - 0x4a01a00a, 0x00047878, 0x42000800, 0x00000005, - 0x42001000, 0x0000dc00, 0x0401f2aa, 0x0401feb7, - 0x4a01a006, 0x02140018, 0x4a01a407, 0x00000800, - 0x5930001c, 0x82000d00, 0xff000000, 0x900409c0, - 0x4805a207, 0x82000500, 0x00ffffff, 0x4801a00a, - 0x4979a408, 0x4979a208, 0x4979a409, 0x4979a209, - 0x4979a00b, 0x42000800, 0x00000006, 0x42001000, - 0x0000dc00, 0x0401f293, 0x4803c856, 0x4d380000, - 0x4d1c0000, 0x42027000, 0x00000035, 0x0201f800, - 0x001093ba, 0x0402001e, 0x0401fe8a, 0x4a01a006, - 0x13000000, 0x5932381e, 0x591c0019, 0x4801a005, - 0x591c0406, 0x82000580, 0x00000003, 0x04000007, - 0x59300809, 0x58040002, 0x82000500, 0x00ffffff, - 0x4801a007, 0x0401f003, 0x59a80010, 0x4801a007, - 0x59300419, 0x4801a408, 0x59300219, 0x4801a208, - 0x42000800, 0x00000003, 0x42001000, 0x0000dc00, - 0x5c023800, 0x5c027000, 0x0401f26e, 0x0201f800, - 0x00106c55, 0x598c000d, 0x81300580, 0x02020800, - 0x001005d8, 0x0201f800, 0x00106bbf, 0x0201f800, - 0x0002077d, 0x5c023800, 0x5c027000, 0x0201f000, - 0x00106c4b, 0x4803c856, 0x4d2c0000, 0x4d1c0000, - 0x5932381e, 0x811e39c0, 0x02000800, 0x001005d8, - 0x591c0c06, 0x82040580, 0x00000006, 0x0400000d, - 0x82040580, 0x00000003, 0x04000036, 0x4a026403, - 0x00000037, 0x4a02641a, 0x00000003, 0x4a02621a, - 0x00001700, 0x5c023800, 0x5c025800, 0x0401f064, - 0x0401f84b, 0x42001000, 0x40000000, 0x591c0203, - 0x591c0804, 0x8c040d3e, 0x04020023, 0x82000c80, - 0x0000000e, 0x0c001003, 0x0201f800, 0x001005d8, - 0x00107691, 0x0010769d, 0x00107693, 0x0010769d, - 0x00107699, 0x00107691, 0x00107691, 0x0010769d, - 0x0010769d, 0x00107691, 0x00107691, 0x00107691, - 0x00107691, 0x00107691, 0x0010769d, 0x00107691, - 0x0010769d, 0x0201f800, 0x001005d8, 0x591c0414, - 0x4803c857, 0x8c000518, 0x04000003, 0x8c000512, - 0x04000003, 0x80001580, 0x0401f003, 0x42001000, - 0x20000000, 0x591c0015, 0x4801a00a, 0x0401f018, - 0x0401f81f, 0x591e5808, 0x812e59c0, 0x02000800, - 0x001005d8, 0x592c100f, 0x591c0011, 0x80080480, - 0x4801a00a, 0x591c0203, 0x591c0804, 0x8c040d3e, - 0x04020007, 0x82000d80, 0x00000002, 0x04000007, - 0x82000d80, 0x00000004, 0x04000004, 0x42001000, - 0x40000000, 0x0401f002, 0x80001580, 0x4809a00b, - 0x42000800, 0x00000006, 0x42001000, 0x0000dc00, - 0x5c023800, 0x5c025800, 0x0401f1fe, 0x4803c856, - 0x0401fe0a, 0x4a01a006, 0x02000000, 0x59300c19, - 0x4805a407, 0x59300a19, 0x4805a207, 0x59a81010, - 0x59300809, 0x58041802, 0x820c1d00, 0x00ffffff, - 0x5930081e, 0x58040406, 0x82000580, 0x00000003, - 0x04020004, 0x4809a008, 0x480da009, 0x0401f003, - 0x480da008, 0x4809a009, 0x1c01f000, 0x4803c856, - 0x0401fdf2, 0x0401f003, 0x4803c856, 0x0401fde8, - 0x4a01a006, 0x01000000, 0x5930041a, 0x4801a407, - 0x5930021a, 0x4801a207, 0x42000800, 0x00000002, - 0x42001000, 0x0000dc00, 0x0401f1d6, 0x4803c856, - 0x4d1c0000, 0x0401fdcc, 0x4a01a006, 0x14000000, - 0x5932381e, 0x591c0019, 0x4801a005, 0x59300419, - 0x4801a407, 0x59300219, 0x4801a207, 0x59300015, - 0x4801a008, 0x59300216, 0x82000500, 0x000000ff, - 0x840001c0, 0x4801a409, 0x42000800, 0x00000004, - 0x42001000, 0x0000dc00, 0x5c023800, 0x0401f1bd, - 0x4803c856, 0x0401f80b, 0x5930041a, 0x900001c0, - 0x4801a005, 0x0401f9ec, 0x41780800, 0x42001000, - 0x00005c00, 0x0401f9b3, 0x0201f000, 0x0010604d, - 0x4803c856, 0x59300817, 0x82041c00, 0x00000005, - 0x46034800, 0x00000021, 0x58040404, 0x82000500, - 0x0000f000, 0x82000580, 0x00003000, 0x04000003, - 0x46034800, 0x00000041, 0x81a5a000, 0x580c0001, - 0x82000d00, 0x00ffffff, 0x82040d40, 0xc2000000, - 0x4805a000, 0x580c0800, 0x82041500, 0x00ffffff, - 0x82000500, 0xff000000, 0x80080540, 0x4801a001, - 0x580c0002, 0x82000580, 0x00c00000, 0x82000500, - 0x00fd0300, 0x4801a002, 0x580c0003, 0x4801a003, - 0x580c0404, 0x4801a404, 0x580c0204, 0x4801a204, - 0x1c01f000, 0x4803c856, 0x59a80026, 0x82000500, - 0x00000028, 0x04020009, 0x59a80026, 0x82000500, - 0x00000028, 0x04000003, 0x497a6a12, 0x0401f003, - 0x4a026a12, 0x0000ff00, 0x42005000, 0x22000000, - 0x42006000, 0x01380000, 0x41786800, 0x41787800, - 0x0401f952, 0x59301008, 0x4a01a006, 0x54000000, - 0x59a80010, 0x82000500, 0x00ffffff, 0x58080c0a, - 0x800408f0, 0x80040540, 0x4801a007, 0x5808000a, - 0x82000500, 0xff000000, 0x4801a008, 0x59a80002, - 0x4801a009, 0x59a80003, 0x4801a00a, 0x59a80000, - 0x4801a00b, 0x59a80001, 0x4801a00c, 0x5808000c, - 0x9c0001c0, 0x4801a00d, 0x5808000d, 0x9c0001c0, - 0x4801a00e, 0x5808000e, 0x9c0001c0, 0x4801a00f, - 0x5808000f, 0x9c0001c0, 0x4801a010, 0x58080010, - 0x9c0001c0, 0x4801a011, 0x58080011, 0x9c0001c0, - 0x4801a012, 0x58080012, 0x9c0001c0, 0x4801a013, - 0x58080013, 0x9c0001c0, 0x4801a014, 0x58080010, - 0x9c0001c0, 0x4801a015, 0x58080011, 0x9c0001c0, - 0x4801a016, 0x58080012, 0x9c0001c0, 0x4801a017, - 0x58080013, 0x9c0001c0, 0x4801a018, 0x42000800, - 0x00000013, 0x42001000, 0x0000dc00, 0x0401f135, - 0x4803c856, 0x42005000, 0x22000000, 0x42006000, - 0x01290000, 0x41786800, 0x41787800, 0x0401f90b, - 0x59301008, 0x4a01a006, 0x55000000, 0x5808000b, - 0x82000500, 0x00ffffff, 0x58080c0a, 0x800408f0, - 0x80040540, 0x4801a007, 0x5808080a, 0x82040d00, - 0xff000000, 0x59a80010, 0x82000500, 0x00ffffff, - 0x80040540, 0x4801a008, 0x5808000c, 0x9c0001c0, - 0x4801a009, 0x5808000d, 0x9c0001c0, 0x4801a00a, - 0x5808000e, 0x9c0001c0, 0x4801a00b, 0x5808000f, - 0x9c0001c0, 0x4801a00c, 0x59a80002, 0x4801a00d, - 0x59a80003, 0x4801a00e, 0x59a80000, 0x4801a00f, - 0x59a80001, 0x4801a010, 0x58080010, 0x4801a011, - 0x58080011, 0x4801a012, 0x58080012, 0x4801a013, - 0x58080013, 0x4801a014, 0x4979a015, 0x4979a016, - 0x4979a017, 0x4979a018, 0x42000800, 0x00000013, - 0x42001000, 0x0000dc00, 0x0401f0f6, 0x0401fd03, - 0x5930001c, 0x800001c0, 0x04000008, 0x4a01a006, - 0x01000000, 0x4a01a407, 0x00000003, 0x42000800, - 0x00000002, 0x0401f028, 0x4a01a006, 0x02000000, - 0x41780800, 0x836c0580, 0x00000004, 0x04020003, - 0x84040d42, 0x0401f00d, 0x0201f800, 0x0010513b, - 0x04020003, 0x84040d4a, 0x0401f002, 0x84040d48, - 0x59a80026, 0x8c000506, 0x04020003, 0x8c00050a, - 0x04000002, 0x84040d46, 0x4805a207, 0x59c40085, - 0x48031004, 0x4c580000, 0x4c500000, 0x4c540000, - 0x4200b000, 0x00000006, 0x8388a400, 0x00000000, - 0x82d0ac00, 0x00000008, 0x0201f800, 0x0010ab17, - 0x5c00a800, 0x5c00a000, 0x5c00b000, 0x42000800, - 0x00000008, 0x42001000, 0x0000dc00, 0x0401f0c1, - 0x0401fcc0, 0x4a01a006, 0x56000000, 0x59340006, - 0x4801a007, 0x59340007, 0x4801a008, 0x42000800, - 0x00000003, 0x42001000, 0x0000dc00, 0x0401f0b5, - 0x4803c856, 0x0401fcc1, 0x5930081c, 0x800409c0, - 0x0400000e, 0x82040580, 0x0000ffff, 0x04000004, - 0x82040480, 0x00000007, 0x04021008, 0x4a01a006, - 0x01000000, 0x4a01a407, 0x00000003, 0x42000800, - 0x00000002, 0x0401f012, 0x4a01a006, 0x0200001c, - 0x4a01a007, 0x00000001, 0x42001000, 0x0010b4f0, - 0x50080000, 0x9c0001c0, 0x4801a009, 0x59a80010, - 0x4801a00a, 0x59a80002, 0x59a80803, 0x4801a00b, - 0x4805a00c, 0x42000800, 0x00000007, 0x42001000, - 0x0000dc00, 0x0401f08f, 0x4d2c0000, 0x0401fc8d, - 0x59325808, 0x592c0008, 0x82000500, 0x00ffffff, - 0x4801a001, 0x4a01a006, 0x51000000, 0x5c025800, - 0x0201f000, 0x00107344, 0x4803c856, 0x59a80810, - 0x82040d00, 0x000000ff, 0x59325808, 0x59326809, - 0x59a83026, 0x8c18350a, 0x04020008, 0x8c00050e, - 0x04020006, 0x80001d80, 0x59a82010, 0x82102500, - 0x000000ff, 0x0401f001, 0x59300406, 0x4803c857, - 0x82000d80, 0x00000009, 0x04000006, 0x82000d80, - 0x0000000a, 0x0400002e, 0x0201f800, 0x001005d8, - 0x59300015, 0x8c00051e, 0x04020020, 0x42005000, - 0x04000000, 0x42006000, 0x05000000, 0x592c040a, - 0x82000500, 0x00000030, 0x800000e0, 0x80306540, - 0x5934000a, 0x8c000508, 0x04000002, 0x84306546, - 0x41786800, 0x41787800, 0x0401f831, 0x59300c14, - 0x80040000, 0x48026414, 0x40040000, 0x800000d0, - 0x82000540, 0x00000020, 0x4801a403, 0x83180d40, - 0x00000038, 0x42001000, 0x0000c920, 0x0401f860, - 0x0201f000, 0x00106052, 0x59a80026, 0x82000500, - 0x00000028, 0x04000003, 0x497a6a12, 0x0401f7dc, - 0x4a026a12, 0x0000ff00, 0x0401f7d9, 0x42005000, - 0x02000000, 0x42006000, 0x20290000, 0x41786800, - 0x41787800, 0x0401f812, 0x83180d40, 0x00000038, - 0x42001000, 0x0000c9a0, 0x0401f849, 0x42000800, - 0x000007d0, 0x59300011, 0x82000500, 0xfff00000, - 0x80000540, 0x04000003, 0x42000800, 0x00001b58, - 0x41781000, 0x0201f000, 0x00106054, 0x4201a000, - 0x00000000, 0x0401f003, 0x4201a000, 0x00000011, - 0x59340a12, 0x82040d00, 0x0000ff00, 0x59a80010, - 0x82000500, 0x000000ff, 0x900001c0, 0x80040540, - 0x80d00540, 0x44034800, 0x81a5a000, 0x59340002, - 0x82000500, 0x00ffffff, 0x80280540, 0x4801a000, - 0x59a80010, 0x4801a001, 0x4831a002, 0x82340540, - 0x00000000, 0x4801a003, 0x59300402, 0x4801a404, - 0x59300a02, 0x4805a204, 0x8c30652e, 0x04000003, - 0x4805a404, 0x4801a204, 0x483da005, 0x1c01f000, - 0x4803c856, 0x4c040000, 0x0401f822, 0x5c000800, - 0x40040000, 0x80081540, 0x800000c4, 0x82000540, - 0x00002000, 0x4803910a, 0x59b400f6, 0x82000500, - 0x00000018, 0x040207fd, 0x4a0368f0, 0x0010b544, - 0x4a0368f1, 0x0010b54b, 0x480b68f3, 0x4a0378e4, - 0x00008000, 0x0201f000, 0x0010604d, 0x4807c857, - 0x480a2800, 0x4c040000, 0x0401f80a, 0x5c000800, - 0x59b400f6, 0x8c00050a, 0x040207fe, 0x49a768f2, - 0x480768f4, 0x4a0378e4, 0x00008000, 0x1c01f000, - 0x4a0378e4, 0x0000c000, 0x59bc00e4, 0x8c000520, - 0x0400000c, 0x4a0378e4, 0x00008000, 0x42007000, - 0x000003e8, 0x59bc00e4, 0x8c000520, 0x040007f5, - 0x80387040, 0x02000800, 0x001005d8, 0x0401f7fa, - 0x1c01f000, 0x82000500, 0xffff0000, 0x82000580, - 0x01050000, 0x0402000d, 0x599c0818, 0x8c040d10, - 0x0400000a, 0x59a80807, 0x8c040d0a, 0x04000007, - 0x42001000, 0x0000804f, 0x41781800, 0x41782000, - 0x0201f800, 0x00103a3e, 0x1c01f000, 0x41781000, - 0x42026000, 0x0010d1c0, 0x59a8180e, 0x480a6402, - 0x4a026202, 0x0000ffff, 0x80081000, 0x800c1840, - 0x04000004, 0x83326400, 0x00000024, 0x0401f7f8, - 0x1c01f000, 0x4933c857, 0x59300203, 0x82000580, - 0x00000000, 0x0400002c, 0x59300406, 0x4803c857, - 0x82000d80, 0x00000004, 0x04000011, 0x82000d80, - 0x00000001, 0x0400000e, 0x82000d80, 0x00000003, - 0x04000006, 0x82000d80, 0x00000006, 0x04020011, - 0x0201f800, 0x0010a5df, 0x5930001c, 0x800001c0, - 0x02020800, 0x0010984e, 0x0401f00a, 0x5930081e, - 0x4807c857, 0x800409c0, 0x04000006, 0x5804001c, - 0x4803c857, 0x81300580, 0x04020002, 0x4978081c, - 0x497a6008, 0x4a026004, 0x00004000, 0x59a80037, - 0x82000c80, 0x00000051, 0x04001002, 0x80000102, - 0x48026206, 0x497a6205, 0x497a6009, 0x4a026406, - 0x00000007, 0x1c01f000, 0x8166c9c0, 0x0400001c, - 0x41626000, 0x41580000, 0x59300a03, 0x82040d80, - 0x00000000, 0x04000008, 0x83326400, 0x00000024, - 0x81300c80, 0x040017f9, 0x42026000, 0x0010d1c0, - 0x0401f7f6, 0x4933c857, 0x8166c840, 0x83300c00, - 0x00000024, 0x80040480, 0x04021006, 0x4006c000, - 0x4a026203, 0x00000008, 0x813261c0, 0x1c01f000, - 0x4202c000, 0x0010d1c0, 0x0401f7fa, 0x42000000, - 0x0010b854, 0x0201f800, 0x0010aa47, 0x4933c856, - 0x417a6000, 0x0401f7f5, 0x4933c857, 0x83380580, - 0x00000013, 0x0402000b, 0x59300004, 0x8c00053e, - 0x04000007, 0x0201f800, 0x00106c55, 0x0201f800, - 0x00106bbf, 0x0201f800, 0x00106c4b, 0x1c01f000, - 0x4933c857, 0x59880052, 0x80000000, 0x48031052, - 0x1c01f000, 0x4933c857, 0x59300203, 0x82003480, - 0x0000000e, 0x02021800, 0x001005d8, 0x4d2c0000, - 0x0c01f803, 0x5c025800, 0x1c01f000, 0x00107991, - 0x00107efd, 0x0010804a, 0x00107991, 0x001080b0, - 0x00107af5, 0x00107991, 0x00107991, 0x00107e93, - 0x00107991, 0x00107991, 0x00107991, 0x00107991, - 0x00107991, 0x0201f800, 0x001005d8, 0x4933c857, - 0x59300203, 0x82003480, 0x0000000e, 0x02021800, - 0x001005d8, 0x0c01f001, 0x001079a8, 0x00108a3d, - 0x001079a8, 0x001079a8, 0x001079a8, 0x001079a8, - 0x001079a8, 0x001079a8, 0x001089e5, 0x00108a58, - 0x00108ac6, 0x00108a58, 0x00108ac6, 0x001079a8, - 0x0201f800, 0x001005d8, 0x0201f800, 0x001005d8, - 0x4933c857, 0x4d2c0000, 0x59325808, 0x59300203, - 0x82003480, 0x0000000e, 0x02021800, 0x001005d8, - 0x0c01f803, 0x5c025800, 0x1c01f000, 0x001079c5, - 0x001079c5, 0x001079c5, 0x001079e1, 0x00107a2d, - 0x001079c5, 0x001079c5, 0x001079c5, 0x001079c7, - 0x001079c5, 0x001079c5, 0x001079c5, 0x001079c5, - 0x001079c5, 0x0201f800, 0x001005d8, 0x4933c857, - 0x83380580, 0x00000040, 0x02020800, 0x001005d8, - 0x4a026007, 0x00082000, 0x4a026203, 0x00000003, - 0x493a6403, 0x4a025c08, 0x00000001, 0x592c000d, - 0x48026011, 0x497a6013, 0x592c0208, 0x800000c2, - 0x800010c4, 0x80081400, 0x480a6206, 0x0201f800, - 0x00100f4e, 0x42000800, 0x80000060, 0x0201f000, - 0x00106721, 0x4933c857, 0x83380480, 0x00000050, - 0x02021800, 0x001005d8, 0x83380480, 0x00000049, - 0x02001800, 0x001005d8, 0x0c01f001, 0x001079f4, - 0x001079ff, 0x001079f2, 0x001079f2, 0x001079f2, - 0x001079f2, 0x00107a0a, 0x0201f800, 0x001005d8, - 0x4a026203, 0x00000004, 0x4a025c08, 0x00000002, - 0x592c0207, 0x48025c09, 0x592c0209, 0x48025a07, - 0x592c000c, 0x4802580d, 0x1c01f000, 0x0201f800, - 0x00106b8a, 0x0201f800, 0x00109037, 0x04000005, - 0x4a025a06, 0x00000006, 0x0201f800, 0x000202da, - 0x0201f000, 0x0002077d, 0x0201f800, 0x00106b8a, - 0x4d3c0000, 0x417a7800, 0x0201f800, 0x0010203c, - 0x5c027800, 0x42003000, 0x00000014, 0x41782800, - 0x42002000, 0x00000002, 0x4d400000, 0x4d440000, - 0x59368c03, 0x42028000, 0x00000029, 0x0201f800, - 0x0010985e, 0x5c028800, 0x5c028000, 0x42000000, - 0x0010b864, 0x0201f800, 0x0010aa47, 0x0201f800, - 0x00109037, 0x02000000, 0x0002077d, 0x4a025a06, - 0x00000029, 0x0201f800, 0x000202da, 0x0201f000, - 0x0002077d, 0x4933c857, 0x83380580, 0x00000048, - 0x04000005, 0x83380580, 0x00000053, 0x02020800, - 0x001005d8, 0x592c0206, 0x82000580, 0x00000007, - 0x04000009, 0x59300011, 0x80000540, 0x04000006, - 0x592c080c, 0x80040480, 0x4802580c, 0x4a025a06, - 0x00000015, 0x592c0206, 0x80000540, 0x04020003, - 0x4a025a06, 0x00000000, 0x0201f800, 0x000202da, - 0x0201f000, 0x0002077d, 0x4933c857, 0x4d2c0000, - 0x4c500000, 0x4c540000, 0x4c580000, 0x0201f800, - 0x001007e4, 0x02000800, 0x001005d8, 0x497a5a06, - 0x59c80017, 0x82000500, 0x0000f000, 0x48025c07, - 0x59a80816, 0x82040c00, 0x00000018, 0x48065a07, - 0x412c7800, 0x4d2c0000, 0x41cca000, 0x42002800, - 0x00000001, 0x42001000, 0x0000002c, 0x82040480, - 0x0000002d, 0x04021006, 0x832cac00, 0x00000009, - 0x0201f800, 0x00108b96, 0x0401f02e, 0x40043000, - 0x42000800, 0x0000002c, 0x832cac00, 0x00000009, - 0x0201f800, 0x00108b96, 0x82183480, 0x0000002c, - 0x0201f800, 0x001007e4, 0x0400001a, 0x80142800, - 0x4a025804, 0x00000110, 0x492c7801, 0x82180c80, - 0x0000003d, 0x04021007, 0x40180800, 0x832cac00, - 0x00000005, 0x0201f800, 0x00108b96, 0x0401f015, - 0x82081400, 0x0000003c, 0x82183480, 0x0000003c, - 0x42000800, 0x0000003c, 0x412c7800, 0x832cac00, - 0x00000005, 0x0201f800, 0x00108b96, 0x0401f7e5, - 0x5c025800, 0x592c0206, 0x8400055e, 0x48025a06, - 0x592c0407, 0x80080540, 0x48025c07, 0x0401f002, - 0x5c025800, 0x813669c0, 0x04000003, 0x59343403, - 0x0401f003, 0x42003000, 0x0000ffff, 0x49325808, - 0x481a5c06, 0x82100580, 0x00000054, 0x04020002, - 0x491e5813, 0x841401c0, 0x80100540, 0x48025804, - 0x592c0001, 0x497a5801, 0x4c000000, 0x0201f800, - 0x000202da, 0x5c025800, 0x812e59c0, 0x040207f9, - 0x5c00b000, 0x5c00a800, 0x5c00a000, 0x5c025800, - 0x1c01f000, 0x4803c856, 0x4c5c0000, 0x4d2c0000, - 0x4c500000, 0x4c540000, 0x4c580000, 0x412cb800, - 0x592c040b, 0x8c000516, 0x04000003, 0x41cca000, - 0x0401f003, 0x83cca400, 0x00000006, 0x4008b000, - 0x41781000, 0x82580480, 0x00000012, 0x04001004, - 0x4200b000, 0x00000012, 0x40001000, 0x4c080000, - 0x4d2c0000, 0x0201f800, 0x001007e4, 0x04000023, - 0x5c001800, 0x492c1801, 0x485a5800, 0x832cac00, - 0x00000002, 0x0201f800, 0x0010ab28, 0x585c040b, - 0x8c000500, 0x0400000e, 0x832c1400, 0x00000002, - 0x8c000516, 0x04000003, 0x82081400, 0x00000006, - 0x46001000, 0x00000001, 0x80081000, 0x46001000, - 0x00000900, 0x84000500, 0x4800bc0b, 0x5c001000, - 0x800811c0, 0x040207da, 0x82000540, 0x00000001, - 0x5c00b000, 0x5c00a800, 0x5c00a000, 0x5c025800, - 0x5c00b800, 0x1c01f000, 0x5c025800, 0x5c001000, - 0x0401f7f8, 0x4933c857, 0x83380d80, 0x00000015, - 0x04020003, 0x0201f000, 0x0002077d, 0x83380d80, - 0x00000016, 0x02020800, 0x001005d8, 0x0201f000, - 0x0002077d, 0x4933c857, 0x4d2c0000, 0x4c500000, - 0x4c540000, 0x4c580000, 0x59325808, 0x83cca400, - 0x00000006, 0x59cc1806, 0x820c0580, 0x01000000, - 0x04020004, 0x4200b000, 0x00000002, 0x0401f00f, - 0x4200b000, 0x00000008, 0x832cac00, 0x00000005, - 0x0201f800, 0x0010ab17, 0x8c0c1d00, 0x0400000b, - 0x4200b000, 0x00000008, 0x592e5801, 0x812e59c0, - 0x02000800, 0x001005d8, 0x832cac00, 0x00000005, - 0x0201f800, 0x0010ab17, 0x0401f816, 0x5c00b000, - 0x5c00a800, 0x5c00a000, 0x5c025800, 0x1c01f000, - 0x4933c857, 0x4c500000, 0x4c540000, 0x4c580000, - 0x83cca400, 0x00000006, 0x5930a808, 0x8254ac00, - 0x00000005, 0x4200b000, 0x00000007, 0x0201f800, - 0x0010ab17, 0x5c00b000, 0x5c00a800, 0x5c00a000, - 0x4933c857, 0x0201f800, 0x00109037, 0x02000000, - 0x0002077d, 0x4d2c0000, 0x0201f800, 0x00109597, - 0x0402000b, 0x41780800, 0x4d400000, 0x42028000, - 0x00000000, 0x0201f800, 0x0010943b, 0x5c028000, - 0x5c025800, 0x0201f000, 0x0002077d, 0x5931d821, - 0x58ef400b, 0x58ee580d, 0x4a025a04, 0x00000103, - 0x58ec0009, 0x0801f800, 0x5c025800, 0x0201f000, - 0x0002077d, 0x4933c857, 0x59cc1806, 0x820c0580, - 0x02000000, 0x04020014, 0x4a026802, 0x00fffffd, - 0x5934000a, 0x84000504, 0x4802680a, 0x59300808, - 0x800409c0, 0x02000000, 0x0002077d, 0x4a000a04, - 0x00000103, 0x480c0805, 0x5931d821, 0x58ef400b, - 0x58ee580d, 0x58ec0009, 0x0801f800, 0x0201f000, - 0x0002077d, 0x42000000, 0x0010b86c, 0x0201f800, - 0x0010aa47, 0x4c0c0000, 0x0401f804, 0x5c001800, - 0x040207eb, 0x1c01f000, 0x4933c857, 0x4d2c0000, - 0x59325808, 0x812e59c0, 0x04020009, 0x497a6206, - 0x497a6205, 0x4d380000, 0x42027000, 0x00000022, - 0x0401fb77, 0x5c027000, 0x80000580, 0x5c025800, - 0x1c01f000, 0x4933c857, 0x4d2c0000, 0x4c500000, - 0x4c540000, 0x4c580000, 0x59325808, 0x592e5801, - 0x832cac00, 0x00000005, 0x83cca400, 0x00000006, - 0x59c80817, 0x82040d00, 0x000003ff, 0x82041480, - 0x0000000f, 0x0400101b, 0x4200b000, 0x0000000f, - 0x0201f800, 0x0010ab17, 0x592e5801, 0x832cac00, - 0x00000005, 0x82080c80, 0x0000000f, 0x0400100d, - 0x4200b000, 0x0000000f, 0x0201f800, 0x0010ab17, - 0x592e5801, 0x832cac00, 0x00000005, 0x82041480, - 0x0000000f, 0x04001007, 0x42001000, 0x0000000f, - 0x4008b000, 0x0201f800, 0x0010ab17, 0x0401f004, - 0x4004b000, 0x0201f800, 0x0010ab17, 0x5931d821, - 0x58ef400b, 0x58ee580d, 0x4a025a04, 0x00000103, - 0x592e5801, 0x58ec0009, 0x0801f800, 0x0201f800, - 0x0002077d, 0x5c00b000, 0x5c00a800, 0x5c00a000, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x4d2c0000, - 0x4c500000, 0x4c540000, 0x4c580000, 0x59cc0006, - 0x82000d80, 0x01000000, 0x0400002c, 0x59cc0007, - 0x9000b1c0, 0x8258b500, 0x000000ff, 0x8058b104, - 0x8258b400, 0x00000002, 0x82580c80, 0x00000007, - 0x04001003, 0x4200b000, 0x00000006, 0x83cca400, - 0x00000006, 0x59301008, 0x800811c0, 0x02000800, - 0x001005d8, 0x8208ac00, 0x00000005, 0x0201f800, - 0x0010ab17, 0x82000d00, 0xff000000, 0x800409c0, - 0x04000019, 0x8200b500, 0x000000ff, 0x8058b104, - 0x82580c80, 0x0000000e, 0x04001003, 0x4200b000, - 0x0000000d, 0x58081001, 0x800811c0, 0x02000800, - 0x001005d8, 0x8208ac00, 0x00000005, 0x0201f800, - 0x0010ab17, 0x0401f008, 0x59301008, 0x800811c0, - 0x02000800, 0x001005d8, 0x48001005, 0x59cc0007, - 0x48001006, 0x0401ff3b, 0x5c00b000, 0x5c00a800, - 0x5c00a000, 0x5c025800, 0x1c01f000, 0x4933c857, - 0x42000800, 0x00000000, 0x59cc0006, 0x82000580, - 0x02000000, 0x04000003, 0x42000800, 0x00000001, - 0x4d2c0000, 0x59325808, 0x812e59c0, 0x02000800, - 0x001005d8, 0x48065a06, 0x0201f800, 0x000202da, - 0x5c025800, 0x0201f000, 0x0002077d, 0x4933c857, - 0x4d2c0000, 0x4c500000, 0x4c540000, 0x4c580000, - 0x4200b000, 0x00000002, 0x59cc0806, 0x82040580, - 0x01000000, 0x04000004, 0x8204b500, 0x0000ffff, - 0x8058b104, 0x83cca400, 0x00000006, 0x59300008, - 0x8200ac00, 0x00000005, 0x0201f800, 0x0010ab17, - 0x0401ff0c, 0x5c00b000, 0x5c00a800, 0x5c00a000, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x4803c857, - 0x4807c857, 0x480bc857, 0x480fc857, 0x4813c857, - 0x481bc857, 0x492fc857, 0x4d2c0000, 0x4c000000, - 0x0201f800, 0x001007d3, 0x5c000000, 0x0400000f, - 0x48025803, 0x5c000000, 0x4802580a, 0x4c000000, - 0x481a5801, 0x48125809, 0x48065804, 0x480a5807, - 0x480e5808, 0x412c1000, 0x0201f800, 0x00100858, - 0x82000540, 0x00000001, 0x5c025800, 0x1c01f000, - 0x4933c857, 0x4d1c0000, 0x59cc0001, 0x82000500, - 0x00ffffff, 0x59341002, 0x82081500, 0x00ffffff, - 0x80080580, 0x0402001f, 0x497a6205, 0x4d380000, - 0x42027000, 0x00000035, 0x0201f800, 0x001093ba, - 0x5c027000, 0x04020012, 0x591c001c, 0x800001c0, - 0x0400000f, 0x497a381c, 0x591c0414, 0x8c000502, - 0x02000800, 0x001005d8, 0x84000502, 0x48023c14, - 0x591c1406, 0x82080580, 0x00000003, 0x04000006, - 0x82080580, 0x00000006, 0x04000005, 0x0401fc9e, - 0x0401f004, 0x0401f805, 0x0401f002, 0x0401f8c0, - 0x5c023800, 0x1c01f000, 0x4d2c0000, 0x591e5808, - 0x4933c857, 0x491fc857, 0x493bc857, 0x492fc857, - 0x83380580, 0x00000015, 0x040000b3, 0x83380580, - 0x00000016, 0x040200ae, 0x4d300000, 0x411e6000, - 0x59cc0207, 0x4803c857, 0x82000d00, 0x0000ff00, - 0x82040580, 0x00001700, 0x04000004, 0x82040580, - 0x00000300, 0x0402005b, 0x591c0203, 0x4803c857, - 0x82000580, 0x0000000d, 0x0400003f, 0x812e59c0, - 0x0400009a, 0x591c0202, 0x4803c857, 0x82000580, - 0x0000ffff, 0x0402007e, 0x592c020a, 0x4803c857, - 0x82000500, 0x00000003, 0x82000580, 0x00000002, - 0x04020007, 0x592c080f, 0x591c0011, 0x4803c857, - 0x4807c857, 0x80040580, 0x04020071, 0x591c0414, - 0x4803c857, 0x8c000500, 0x0402006d, 0x41780800, - 0x591c1206, 0x42000000, 0x0000000a, 0x0201f800, - 0x001066a0, 0x592c0406, 0x4803c857, 0x800001c0, - 0x0400000c, 0x80080c80, 0x04001004, 0x02020800, - 0x001005d8, 0x80001040, 0x480a5c06, 0x800811c0, - 0x04020004, 0x0201f800, 0x00108d88, 0x0401f06b, - 0x0201f800, 0x0010912a, 0x591c0817, 0x591c0018, - 0x48065808, 0x48025809, 0x59300007, 0x8c000500, - 0x02020800, 0x00100e99, 0x497a3808, 0x0201f800, - 0x000201ba, 0x0402004a, 0x411e6000, 0x0401fc3e, - 0x0401f05a, 0x0401fc6d, 0x04000013, 0x49366009, - 0x4a026406, 0x00000003, 0x492e6008, 0x591c0817, - 0x591c1018, 0x48066017, 0x480a6018, 0x4d380000, - 0x591e7403, 0x4d300000, 0x411e6000, 0x0401fc2e, - 0x5c026000, 0x0201f800, 0x000207a1, 0x5c027000, - 0x0401f046, 0x59a80039, 0x48023a05, 0x0401f043, - 0x59cc0407, 0x82000580, 0x0000000b, 0x04020025, - 0x59340a00, 0x84040d0e, 0x48066a00, 0x592c0a04, - 0x82040d00, 0x000000ff, 0x82040d80, 0x00000014, - 0x04000003, 0x4a02621d, 0x00000003, 0x59300007, - 0x8c000500, 0x02020800, 0x00100e99, 0x4d400000, - 0x42028000, 0x00000003, 0x592c0a08, 0x0201f800, - 0x00104e70, 0x0201f800, 0x000202da, 0x5c028000, - 0x497a6008, 0x4a026403, 0x00000085, 0x4a026203, - 0x00000009, 0x4a026406, 0x00000002, 0x42000800, - 0x8000404b, 0x0201f800, 0x00020721, 0x0401f01b, - 0x59cc0207, 0x82000580, 0x00002a00, 0x04020004, - 0x59a80039, 0x48023a05, 0x0401f014, 0x812e59c0, - 0x02000800, 0x001005d8, 0x4a025a04, 0x00000103, - 0x591c0007, 0x8c000500, 0x02020800, 0x00100e99, - 0x591c0402, 0x48025c06, 0x4a025a06, 0x00000003, - 0x0201f800, 0x000202c1, 0x0201f800, 0x00107911, - 0x0201f800, 0x001049b2, 0x5c026000, 0x0201f800, - 0x0002077d, 0x0401f002, 0x5c026000, 0x5c025800, - 0x1c01f000, 0x0401f819, 0x0401f7fd, 0x4933c857, - 0x83380580, 0x00000015, 0x04020004, 0x59a80039, - 0x48023a05, 0x0401f00d, 0x83380580, 0x00000016, - 0x0402000d, 0x4d300000, 0x411e6000, 0x0201f800, - 0x0010a5df, 0x0201f800, 0x000206fd, 0x0201f800, - 0x0002077d, 0x5c026000, 0x497a381c, 0x0201f800, - 0x0002077d, 0x1c01f000, 0x591c0414, 0x84000540, - 0x48023c14, 0x59cc100b, 0x4933c857, 0x491fc857, - 0x492fc857, 0x4803c857, 0x480bc857, 0x8c08153c, - 0x04000006, 0x59a80039, 0x48023a05, 0x497a381c, - 0x0201f000, 0x0002077d, 0x4d300000, 0x411e6000, - 0x0201f800, 0x00108bd7, 0x5c026000, 0x591c0406, - 0x82000580, 0x00000000, 0x02000000, 0x0002077d, - 0x591c0403, 0x82000580, 0x00000050, 0x0402000d, - 0x4d300000, 0x411e6000, 0x4a026203, 0x00000001, - 0x42000800, 0x80000043, 0x0201f800, 0x00020721, - 0x5c026000, 0x497a381c, 0x0201f000, 0x0002077d, - 0x591c0203, 0x82000580, 0x0000000d, 0x04000014, - 0x812e59c0, 0x02000800, 0x001005d8, 0x591c0203, - 0x82000580, 0x00000004, 0x04020011, 0x592c020a, - 0x8c000502, 0x0400000e, 0x4a023812, 0x0fffffff, - 0x592c0208, 0x8400051e, 0x48025a08, 0x42000000, - 0x00000001, 0x48023a14, 0x0401f021, 0x42000000, - 0x00000007, 0x48023a14, 0x0401f01d, 0x592c020a, - 0x4803c857, 0x8c000500, 0x0402000b, 0x8c000502, - 0x040007f7, 0x591c0414, 0x8c00051c, 0x040207eb, - 0x591c0011, 0x4803c857, 0x800001c0, 0x040007f0, - 0x0401f7e6, 0x8c08153a, 0x040207ed, 0x59cc000a, - 0x592c180f, 0x4803c857, 0x480fc857, 0x800c0580, - 0x040007e7, 0x59cc000a, 0x4803c857, 0x48023816, - 0x42000000, 0x00000005, 0x48023a14, 0x0201f000, - 0x00109259, 0x4933c857, 0x4d1c0000, 0x59cc0001, - 0x59341002, 0x80080580, 0x82000500, 0x00ffffff, - 0x04020041, 0x59301419, 0x0201f800, 0x00109410, - 0x02000800, 0x001005d8, 0x591c1406, 0x82080580, - 0x00000007, 0x04000038, 0x82080580, 0x00000002, - 0x04000035, 0x82080580, 0x00000000, 0x04000032, - 0x591c0202, 0x82000d80, 0x0000ffff, 0x04000004, - 0x59301a19, 0x800c0580, 0x0402002b, 0x83380580, - 0x00000015, 0x04000026, 0x4d300000, 0x4d2c0000, - 0x411e6000, 0x59325808, 0x0201f800, 0x00109037, - 0x02000800, 0x001005d8, 0x592c0204, 0x82000500, - 0x000000ff, 0x82000580, 0x00000014, 0x04000003, - 0x4a02621d, 0x00000003, 0x42028000, 0x00000003, - 0x592c0a08, 0x0201f800, 0x00104e70, 0x0201f800, - 0x000202da, 0x5c025800, 0x497a6008, 0x4a026403, - 0x00000085, 0x4a026203, 0x00000009, 0x4a026406, - 0x00000002, 0x42000800, 0x8000404b, 0x0201f800, - 0x00020721, 0x5c026000, 0x0401f003, 0x59a80039, - 0x48023a05, 0x497a381c, 0x0201f800, 0x0002077d, - 0x5c023800, 0x1c01f000, 0x4933c857, 0x4c580000, - 0x4d2c0000, 0x59325808, 0x83383580, 0x00000015, - 0x04000010, 0x59342200, 0x84102502, 0x48126a00, - 0x0201f800, 0x00109037, 0x04000066, 0x0201f800, - 0x00109597, 0x04020005, 0x4200b000, 0x00000002, - 0x0201f800, 0x0010957d, 0x0401fa0a, 0x0401f079, - 0x83cc1400, 0x00000008, 0x4200b000, 0x00000002, - 0x83341c00, 0x00000006, 0x0201f800, 0x0010855a, - 0x04020015, 0x83cc1400, 0x0000000a, 0x4200b000, - 0x00000002, 0x83341c00, 0x00000008, 0x0201f800, - 0x0010855a, 0x0402000c, 0x0201f800, 0x00102074, - 0x59342200, 0x59cc1007, 0x800811c0, 0x04000003, - 0x480a6801, 0x84102542, 0x8410251a, 0x48126a00, - 0x0401f05f, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x0010203c, 0x5c027800, 0x42000000, 0x0010b864, - 0x0201f800, 0x0010aa47, 0x59340200, 0x84000558, - 0x48026a00, 0x4d300000, 0x0201f800, 0x0002075a, - 0x02000800, 0x001005d8, 0x49366009, 0x497a6008, - 0x4a026406, 0x00000001, 0x4a026403, 0x00000001, - 0x42003000, 0x00000003, 0x0201f800, 0x0010a942, - 0x0201f800, 0x00103b25, 0x04000011, 0x41782800, - 0x42003000, 0x00000001, 0x4d400000, 0x42028000, - 0x00000029, 0x0201f800, 0x0010a43e, 0x5c028000, - 0x4a026406, 0x00000004, 0x4a026203, 0x00000007, - 0x4a026420, 0x00000001, 0x0401f009, 0x4a026203, - 0x00000001, 0x42000800, 0x0000000b, 0x0201f800, - 0x00104571, 0x0201f800, 0x0010672b, 0x5c026000, - 0x0201f800, 0x00109037, 0x04000022, 0x0201f800, - 0x00109597, 0x04020022, 0x0401f9ae, 0x0401f01d, - 0x4d3c0000, 0x417a7800, 0x0201f800, 0x0010203c, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x59340200, 0x84000558, 0x48026a00, 0x42003000, - 0x00000003, 0x41782800, 0x42002000, 0x00000005, - 0x4d400000, 0x4d440000, 0x59368c03, 0x42028000, - 0x00000029, 0x0201f800, 0x0010985e, 0x5c028800, - 0x5c028000, 0x5c027800, 0x0201f800, 0x00102074, - 0x0201f800, 0x0002077d, 0x0401f002, 0x0401fca9, - 0x5c025800, 0x5c00b000, 0x1c01f000, 0x4933c857, - 0x41380000, 0x83383480, 0x00000056, 0x02021800, - 0x001005d8, 0x0c01f001, 0x00107ef7, 0x00107ef2, - 0x00107ef7, 0x00107ef7, 0x00107ef7, 0x00107ef7, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef7, 0x00107ef0, 0x00107ef7, - 0x00107ef7, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef7, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef7, 0x00107ef7, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef7, - 0x00107ef0, 0x00107ef0, 0x00107ef7, 0x00107ef7, - 0x00107ef0, 0x00107ef7, 0x00107ef7, 0x00107ef0, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef7, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef7, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef7, - 0x00107ef0, 0x00107ef0, 0x00107ef0, 0x00107ef7, - 0x0201f800, 0x001005d8, 0x4a026203, 0x00000001, - 0x493a6403, 0x0201f000, 0x0010672b, 0x4933c857, - 0x4a026203, 0x00000001, 0x493a6403, 0x0201f000, - 0x0010672b, 0x4933c857, 0x59300403, 0x82003480, - 0x00000056, 0x02021800, 0x001005d8, 0x83383580, - 0x00000013, 0x04000093, 0x83383580, 0x00000027, - 0x0402004b, 0x0201f800, 0x00106bbf, 0x0201f800, - 0x00109134, 0x0400000b, 0x0201f800, 0x0010914e, - 0x04000041, 0x59300403, 0x82000d80, 0x00000022, - 0x04020038, 0x0401fc61, 0x0400003a, 0x0401f03a, - 0x0201f800, 0x00102074, 0x42000800, 0x00000007, - 0x0201f800, 0x00104571, 0x0401f8fe, 0x4d440000, - 0x59368c03, 0x83440580, 0x000007fe, 0x04020008, - 0x59a81026, 0x84081540, 0x0201f800, 0x0010513b, - 0x04020002, 0x8408154a, 0x480b5026, 0x42028000, - 0x00000029, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x0010203c, 0x5c027800, 0x836c0580, 0x00000003, - 0x0400000c, 0x59326809, 0x59340008, 0x800001c0, - 0x04020008, 0x59368c03, 0x4933c857, 0x4937c857, - 0x4947c857, 0x0201f800, 0x001045fb, 0x0401f00c, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x42003000, 0x00000015, 0x41782800, 0x42002000, - 0x00000003, 0x0201f800, 0x0010985e, 0x5c028800, - 0x0201f800, 0x00109326, 0x0201f000, 0x0002077d, - 0x1c01f000, 0x0401f8cb, 0x0401f7fa, 0x83380580, - 0x00000014, 0x0400000b, 0x0201f800, 0x00106f60, - 0x02020000, 0x00107974, 0x59300203, 0x82000580, - 0x00000002, 0x040000ed, 0x0201f800, 0x001005d8, - 0x0201f800, 0x00106bbf, 0x4d3c0000, 0x417a7800, - 0x0201f800, 0x0010203c, 0x5c027800, 0x42003000, - 0x00000016, 0x41782800, 0x4d400000, 0x4d440000, - 0x59368c03, 0x42002000, 0x00000009, 0x42028000, - 0x00000029, 0x0201f800, 0x0010985e, 0x5c028800, - 0x5c028000, 0x42000000, 0x0010b864, 0x0201f800, - 0x0010aa47, 0x0201f800, 0x00109134, 0x0402000c, - 0x0201f800, 0x00102074, 0x0401f89e, 0x59340c03, - 0x82040580, 0x000007fe, 0x040207ca, 0x59a80826, - 0x84040d40, 0x48075026, 0x0401f7c6, 0x0201f800, - 0x0010914e, 0x04020003, 0x0401f892, 0x0401f7c1, - 0x59300403, 0x82000d80, 0x00000032, 0x04020004, - 0x0201f800, 0x0010230c, 0x0401f7ba, 0x59300403, - 0x82000d80, 0x00000022, 0x04000886, 0x0401f7b5, - 0x4803c857, 0x0c01f001, 0x00108016, 0x00108016, - 0x00108016, 0x00108016, 0x00108016, 0x00108016, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff9, 0x00108016, 0x00107ff0, 0x00108016, - 0x00108016, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00108016, 0x00108016, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00107ff0, - 0x00108007, 0x00108016, 0x00107ff0, 0x00108000, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00108000, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00108016, - 0x00108003, 0x00107ff0, 0x00107ff2, 0x00108016, - 0x00107ff0, 0x00108016, 0x00108016, 0x00107ff0, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00108016, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00108016, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00108016, - 0x00107ff0, 0x00107ff0, 0x00107ff0, 0x00108016, - 0x0201f800, 0x001005d8, 0x4d2c0000, 0x59325808, - 0x0201f800, 0x000202da, 0x5c025800, 0x0201f000, - 0x0002077d, 0x4a026203, 0x00000005, 0x59a80039, - 0x48026205, 0x59a80037, 0x48026206, 0x1c01f000, - 0x5930081e, 0x49780a05, 0x0401f014, 0x0201f800, - 0x00109326, 0x0201f000, 0x0002077d, 0x0201f800, - 0x0010230c, 0x0201f800, 0x00106c55, 0x04000005, - 0x0201f800, 0x00106bbf, 0x0201f000, 0x0002077d, - 0x0201f800, 0x00106bbf, 0x0201f800, 0x0002077d, - 0x0201f000, 0x00106c4b, 0x4933c857, 0x4a026203, - 0x00000002, 0x59a80037, 0x48026206, 0x1c01f000, - 0x4933c857, 0x0201f800, 0x00109037, 0x0400002a, - 0x4d2c0000, 0x0201f800, 0x00109597, 0x0402000a, - 0x4d400000, 0x42028000, 0x00000031, 0x42000800, - 0x00000004, 0x0201f800, 0x0010943b, 0x5c028000, - 0x0401f01c, 0x59300c06, 0x82040580, 0x00000010, - 0x04000004, 0x82040580, 0x00000011, 0x0402000a, - 0x4a025a06, 0x00000031, 0x4a02580d, 0x00000004, - 0x4a02580e, 0x000000ff, 0x0201f800, 0x000202da, - 0x0401f00c, 0x592c0404, 0x8c00051e, 0x04000009, - 0x4a025a04, 0x00000103, 0x4a025805, 0x01000000, - 0x5931d821, 0x58ef400b, 0x58ec0009, 0x0801f800, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x59340400, - 0x82000500, 0x000000ff, 0x82003480, 0x0000000c, - 0x02021800, 0x001005d8, 0x59303403, 0x82180d80, - 0x0000004d, 0x02000000, 0x0010938b, 0x82180d80, - 0x00000033, 0x02000000, 0x00109349, 0x82180d80, - 0x00000028, 0x02000000, 0x0010918f, 0x82180d80, - 0x00000029, 0x02000000, 0x001091a3, 0x82180d80, - 0x0000001f, 0x02000000, 0x00107b28, 0x82180d80, - 0x00000055, 0x02000000, 0x00107b01, 0x82180d80, - 0x00000000, 0x04000591, 0x82180d80, 0x00000022, - 0x02000000, 0x00107b55, 0x82180d80, 0x00000035, - 0x02000000, 0x00107c50, 0x82180d80, 0x00000039, - 0x04000539, 0x82180d80, 0x0000003d, 0x02000000, - 0x00107b85, 0x82180d80, 0x00000044, 0x02000000, - 0x00107bc2, 0x82180d80, 0x00000049, 0x02000000, - 0x00107c17, 0x82180d80, 0x00000041, 0x02000000, - 0x00107c03, 0x82180d80, 0x00000043, 0x02000000, - 0x001094dc, 0x82180d80, 0x00000051, 0x02000000, - 0x00109542, 0x82180d80, 0x00000004, 0x04020003, - 0x42000000, 0x00000001, 0x83380d80, 0x00000015, - 0x04000006, 0x83380d80, 0x00000016, 0x02020000, - 0x00107974, 0x0401f20f, 0x4d2c0000, 0x4d3c0000, - 0x0c01f804, 0x5c027800, 0x5c025800, 0x1c01f000, - 0x001080b8, 0x001080bc, 0x001080b8, 0x00108131, - 0x001080b8, 0x00108226, 0x001082bf, 0x001080b8, - 0x001080b8, 0x00108288, 0x001080b8, 0x0010829a, - 0x4933c857, 0x497a6007, 0x59300808, 0x58040000, - 0x4a000a04, 0x00000103, 0x0201f000, 0x0002077d, - 0x4933c857, 0x40000000, 0x40000000, 0x1c01f000, - 0x4933c857, 0x59a80016, 0x82000580, 0x00000074, - 0x0402005c, 0x0201f800, 0x0010a2c8, 0x04020016, - 0x0401f85c, 0x0201f800, 0x00109037, 0x0400000c, - 0x0201f800, 0x00109597, 0x04020009, 0x41780800, - 0x4d400000, 0x42028000, 0x00000000, 0x0201f800, - 0x0010943b, 0x5c028000, 0x0401f003, 0x0201f800, - 0x00102074, 0x0201f800, 0x001048c1, 0x0201f000, - 0x0002077d, 0x0201f800, 0x00109037, 0x04000007, - 0x0201f800, 0x00109597, 0x04020004, 0x0401ff3d, - 0x0201f000, 0x0002077d, 0x417a7800, 0x0201f800, - 0x0010203c, 0x42000000, 0x0010b864, 0x0201f800, - 0x0010aa47, 0x59340200, 0x84000558, 0x48026a00, - 0x42003000, 0x00000003, 0x0201f800, 0x0010a942, - 0x4d300000, 0x0201f800, 0x0002075a, 0x02000800, - 0x001005d8, 0x49366009, 0x497a6008, 0x4a026406, - 0x00000001, 0x4a026403, 0x00000001, 0x0201f800, - 0x00103b25, 0x04000011, 0x4a026406, 0x00000004, - 0x4a026203, 0x00000007, 0x4a026420, 0x00000001, - 0x42003000, 0x00000001, 0x4d400000, 0x42028000, - 0x00000029, 0x41782800, 0x0201f800, 0x0010a43e, - 0x5c028000, 0x0401f009, 0x42000800, 0x0000000b, - 0x0201f800, 0x00104571, 0x4a026203, 0x00000001, - 0x0201f800, 0x0010672b, 0x5c026000, 0x0401ff05, - 0x0201f800, 0x00102074, 0x0201f000, 0x0002077d, - 0x0401ff00, 0x42000000, 0x00000001, 0x0401f0c7, - 0x4933c857, 0x59340200, 0x8c000500, 0x0400000d, - 0x4d3c0000, 0x417a7800, 0x0201f800, 0x00104567, - 0x5c027800, 0x0201f800, 0x00103b25, 0x04000005, - 0x42000800, 0x00000006, 0x0201f800, 0x00104571, - 0x1c01f000, 0x4933c857, 0x59a80816, 0x82040580, - 0x00000074, 0x0400000e, 0x4807c857, 0x82040580, - 0x00000100, 0x040200a0, 0x59cc0408, 0x4803c857, - 0x8c000500, 0x0400009c, 0x59341403, 0x82080580, - 0x000007fe, 0x04000006, 0x0401f097, 0x59341403, - 0x82080580, 0x000007fe, 0x04020003, 0x0401fa9c, - 0x0401f04c, 0x0201f800, 0x0010462a, 0x59341403, - 0x82080580, 0x000007fc, 0x0402001f, 0x4a026802, - 0x00fffffc, 0x0201f800, 0x00109037, 0x04000012, - 0x0201f800, 0x00109597, 0x0402000f, 0x0401f8a9, - 0x41780800, 0x4d400000, 0x42028000, 0x00000000, - 0x0201f800, 0x0010943b, 0x5c028000, 0x42000800, - 0x00000004, 0x0201f800, 0x00104571, 0x0201f000, - 0x0002077d, 0x42000800, 0x00000004, 0x0201f800, - 0x00104571, 0x0201f800, 0x00102074, 0x0201f000, - 0x0002077d, 0x59a80005, 0x8c000514, 0x04000011, - 0x0201f800, 0x0010513b, 0x42001000, 0x00000010, - 0x04020009, 0x59340002, 0x82000500, 0x00ff0000, - 0x82000580, 0x00ff0000, 0x04000006, 0x42001000, - 0x00000008, 0x0201f800, 0x00104c6d, 0x0402005a, - 0x0201f800, 0x00109037, 0x0400005b, 0x0201f800, - 0x00109597, 0x04020005, 0x592c0404, 0x8c00051c, - 0x040207c9, 0x0401f877, 0x42000800, 0x00000005, - 0x0201f800, 0x00104571, 0x4a026203, 0x00000001, - 0x4a026403, 0x00000003, 0x0201f000, 0x0010672b, - 0x59cc0408, 0x8c000518, 0x04000010, 0x0201f800, - 0x001092e5, 0x0201f800, 0x0010513b, 0x04000004, - 0x59cc0408, 0x8c000516, 0x040207b3, 0x59a80026, - 0x8400054a, 0x48035026, 0x59a80010, 0x84000570, - 0x48038832, 0x0401f7ac, 0x42001000, 0x000000ef, - 0x480b5010, 0x497b8830, 0x84081570, 0x480b8832, - 0x59c40802, 0x84040d4c, 0x48078802, 0x0201f800, - 0x0010930f, 0x59a80026, 0x84000548, 0x48035026, - 0x0201f800, 0x0010a3da, 0x0402079b, 0x59a80026, - 0x8400054c, 0x48035026, 0x42000800, 0x00000006, - 0x0201f800, 0x00104571, 0x417a7800, 0x0201f800, - 0x00104567, 0x42000000, 0x000000e8, 0x0201f800, - 0x00105c9a, 0x02000800, 0x001045a6, 0x02020800, - 0x001005d8, 0x49366009, 0x59340200, 0x8400051a, - 0x48026a00, 0x42000800, 0x00000003, 0x0201f800, - 0x00104571, 0x4a026406, 0x00000001, 0x4a026203, - 0x00000001, 0x4a026403, 0x00000002, 0x0201f000, - 0x0010672b, 0x0401fe43, 0x42000000, 0x00000001, - 0x0401f00a, 0x599c0017, 0x8c00050a, 0x040007ab, - 0x42000800, 0x00000004, 0x0201f800, 0x00104571, - 0x0201f000, 0x0002077d, 0x4933c857, 0x80003540, - 0x04000005, 0x42000800, 0x00000007, 0x0201f800, - 0x00104571, 0x801831c0, 0x0402000e, 0x59302008, - 0x801021c0, 0x04000004, 0x58100404, 0x8c00051e, - 0x04020008, 0x59341c03, 0x42002000, 0x00000004, - 0x42003000, 0x00000012, 0x0201f800, 0x00103aae, - 0x0201f800, 0x00102074, 0x0201f000, 0x0002077d, - 0x4c5c0000, 0x4d2c0000, 0x59325808, 0x0201f800, - 0x00105755, 0x5c025800, 0x59cc0008, 0x48002805, - 0x59cc0009, 0x48002806, 0x49782807, 0x49782808, - 0x49782809, 0x4978280a, 0x59cc0013, 0x8c00053e, - 0x04000009, 0x59cc0414, 0x900001c0, 0x59ccbc15, - 0x805c0540, 0x48002807, 0x59cc0416, 0x900001c0, - 0x48002808, 0x59cc0017, 0x8c00053e, 0x04000009, - 0x59cc0418, 0x900001c0, 0x59ccbc19, 0x805c0540, - 0x48002809, 0x59cc041a, 0x900001c0, 0x4800280a, - 0x5c00b800, 0x1c01f000, 0x4933c857, 0x59a80016, - 0x82000580, 0x00000014, 0x04020048, 0x59a80005, - 0x8c000514, 0x04000015, 0x0201f800, 0x0010513b, - 0x42001000, 0x00000010, 0x04020009, 0x59340002, - 0x82000500, 0x00ff0000, 0x82000580, 0x00ff0000, - 0x0400000a, 0x42001000, 0x00000008, 0x0201f800, - 0x00104c6d, 0x04000005, 0x59a80005, 0x84000556, - 0x48035005, 0x0401f031, 0x836c0580, 0x00000003, - 0x0402000b, 0x59300008, 0x80000540, 0x04020008, - 0x59341c03, 0x42002000, 0x00000006, 0x42003000, - 0x00000013, 0x0201f800, 0x00103aae, 0x0201f800, - 0x0010468d, 0x0401fecf, 0x0401fa1d, 0x0402001f, - 0x59340404, 0x80000540, 0x0400001c, 0x42000800, - 0x00000006, 0x0201f800, 0x00104571, 0x0201f800, - 0x00109037, 0x04000011, 0x0201f800, 0x00109597, - 0x0402000a, 0x41780800, 0x4d400000, 0x42028000, - 0x00000000, 0x0201f800, 0x0010943b, 0x5c028000, - 0x0201f000, 0x0002077d, 0x4a025a04, 0x00000103, - 0x4a025805, 0x02000000, 0x0201f800, 0x00102074, - 0x0201f000, 0x0002077d, 0x0201f800, 0x00104c19, - 0x0201f800, 0x00109037, 0x04000007, 0x0201f800, - 0x00109597, 0x04020004, 0x0401fda2, 0x0201f000, - 0x0002077d, 0x0401fd9f, 0x80000580, 0x59a80005, - 0x8c000516, 0x04000005, 0x84000516, 0x48035005, - 0x82000540, 0x00000001, 0x0401ff60, 0x1c01f000, - 0x4933c857, 0x59a80016, 0x82000580, 0x00000014, - 0x0402000b, 0x42000800, 0x0000000b, 0x0201f800, - 0x00104571, 0x4a026203, 0x00000001, 0x4a026403, - 0x00000001, 0x0201f000, 0x0010672b, 0x42000000, - 0x00000001, 0x0401f74d, 0x4933c857, 0x40003000, - 0x59a80016, 0x82000580, 0x00000004, 0x0402000a, - 0x82183580, 0x0000000b, 0x04020005, 0x42000800, - 0x00000007, 0x0201f800, 0x00104571, 0x0201f000, - 0x0002077d, 0x42000000, 0x00000001, 0x0401f73b, - 0x4803c857, 0x4d2c0000, 0x4d3c0000, 0x0c01f804, - 0x5c027800, 0x5c025800, 0x1c01f000, 0x001080b8, - 0x001082ce, 0x001080b8, 0x00108323, 0x001080b8, - 0x00108391, 0x001082bf, 0x001080b8, 0x001080b8, - 0x001083b1, 0x001080b8, 0x001083c1, 0x4933c857, - 0x4d1c0000, 0x59301403, 0x82080580, 0x00000003, - 0x04000008, 0x82081580, 0x0000001e, 0x04020003, - 0x0201f800, 0x0002077d, 0x5c023800, 0x1c01f000, - 0x0401ff5a, 0x0401f7fd, 0x4933c857, 0x0201f800, - 0x00109037, 0x0400000b, 0x0201f800, 0x00109597, - 0x04020008, 0x4200b000, 0x00000002, 0x0201f800, - 0x0010957d, 0x0401fd43, 0x0201f000, 0x0002077d, - 0x0401f8f5, 0x04020030, 0x417a7800, 0x0201f800, - 0x00104567, 0x417a7800, 0x0201f800, 0x0010203c, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x59340200, 0x84000558, 0x48026a00, 0x4a026403, - 0x00000002, 0x42003000, 0x00000003, 0x0201f800, - 0x0010a942, 0x0201f800, 0x00103b25, 0x04000011, - 0x4d400000, 0x41782800, 0x42003000, 0x00000005, - 0x42028000, 0x00000029, 0x0201f800, 0x0010a43e, - 0x5c028000, 0x4a026203, 0x00000007, 0x4a026406, - 0x00000004, 0x4a026420, 0x00000001, 0x1c01f000, - 0x42000800, 0x00000003, 0x0201f800, 0x00104571, - 0x4a026203, 0x00000001, 0x0201f800, 0x0010672b, - 0x0401f7f7, 0x59cc0407, 0x82000580, 0x00000009, - 0x0402000a, 0x59340412, 0x82000500, 0x000000ff, - 0x0400000c, 0x80000040, 0x48026c12, 0x4a026206, - 0x0000000a, 0x0401f7ea, 0x59cc0207, 0x82000500, - 0x0000ff00, 0x82000580, 0x00001900, 0x040007c2, - 0x0401fcfc, 0x80000580, 0x0401f6c4, 0x4933c857, - 0x59a80032, 0x80000540, 0x04000015, 0x59340403, - 0x82000580, 0x000007fe, 0x04020011, 0x59a80010, - 0x80000000, 0x48035010, 0x417a7800, 0x0201f800, - 0x00104567, 0x42000800, 0x00000003, 0x0201f800, - 0x00104571, 0x4a026203, 0x00000001, 0x4a026403, - 0x00000002, 0x0201f000, 0x0010672b, 0x0201f800, - 0x00109037, 0x04000011, 0x0201f800, 0x00109597, - 0x0402000e, 0x4c580000, 0x4200b000, 0x00000002, - 0x0201f800, 0x0010957d, 0x5c00b000, 0x0401fcd5, - 0x42000800, 0x00000007, 0x0201f800, 0x00104571, - 0x0201f000, 0x0002077d, 0x0401fcce, 0x59cc3407, - 0x82183500, 0x000000ff, 0x82180580, 0x00000005, - 0x0400001c, 0x82180580, 0x0000000b, 0x04000016, - 0x59cc0207, 0x82000500, 0x0000ff00, 0x04020004, - 0x82180580, 0x00000009, 0x04000012, 0x82000580, - 0x00001900, 0x0402000c, 0x82180580, 0x00000009, - 0x0400000c, 0x42000800, 0x00000004, 0x0201f800, - 0x00104571, 0x0201f800, 0x00102074, 0x0201f000, - 0x0002077d, 0x42000000, 0x00000001, 0x0401f677, - 0x0201f800, 0x00109037, 0x59325808, 0x04000008, - 0x592c0204, 0x82000580, 0x00000139, 0x040007f6, - 0x592c0404, 0x8c00051e, 0x040207f3, 0x59340403, - 0x82000580, 0x000007fe, 0x04020007, 0x59a80026, - 0x84000540, 0x48035026, 0x0201f800, 0x00104229, - 0x0401f7e9, 0x417a7800, 0x0201f800, 0x0010203c, - 0x42003000, 0x00000005, 0x0201f800, 0x0010a942, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x0401f7dd, 0x4933c857, 0x0401f84d, 0x0402000b, - 0x42000800, 0x00000005, 0x0201f800, 0x00104571, - 0x4a026203, 0x00000001, 0x4a026403, 0x00000003, - 0x0201f000, 0x0010672b, 0x42000800, 0x00000004, - 0x0201f800, 0x00104571, 0x0201f800, 0x00109597, - 0x0402000a, 0x4c580000, 0x4200b000, 0x00000002, - 0x0201f800, 0x0010957d, 0x5c00b000, 0x0401fc71, - 0x0201f000, 0x0002077d, 0x0401fc6e, 0x80000580, - 0x0401f636, 0x4933c857, 0x0401f82d, 0x0402000b, - 0x42000800, 0x00000009, 0x0201f800, 0x00104571, - 0x4a026203, 0x00000001, 0x4a026403, 0x00000005, - 0x0201f000, 0x0010672b, 0x42000000, 0x00000001, - 0x0401f626, 0x4933c857, 0x0401f81d, 0x0402000b, - 0x42000800, 0x0000000b, 0x0201f800, 0x00104571, - 0x4a026203, 0x00000001, 0x4a026403, 0x00000001, - 0x0201f000, 0x0010672b, 0x42000000, 0x00000001, - 0x0401f616, 0x4933c857, 0x59cc0407, 0x82000580, - 0x00000003, 0x04020009, 0x59cc0207, 0x82000500, - 0x0000ff00, 0x82000d80, 0x00002a00, 0x04000003, - 0x82000d80, 0x00001e00, 0x1c01f000, 0x4933c857, - 0x82000540, 0x00000001, 0x1c01f000, 0x4933c857, - 0x4d400000, 0x4c580000, 0x59a80026, 0x82000540, - 0x00000003, 0x48035026, 0x0401f85c, 0x04000038, - 0x4d340000, 0x4d440000, 0x59a80026, 0x84000552, - 0x48035026, 0x0201f800, 0x00103b25, 0x0400000c, - 0x42028000, 0x0000002a, 0x42028800, 0x0000ffff, - 0x42003000, 0x00000002, 0x0201f800, 0x0010a446, - 0x59a80805, 0x84040d44, 0x48075005, 0x42028000, - 0x0000002a, 0x4d3c0000, 0x42027800, 0x00000204, - 0x0201f800, 0x00101fe5, 0x5c027800, 0x42000000, - 0x0010b864, 0x0201f800, 0x0010aa47, 0x0201f800, - 0x00101e45, 0x4200b000, 0x00000010, 0x42028800, - 0x000007f0, 0x4d2c0000, 0x83440580, 0x000007fe, - 0x04000003, 0x0201f800, 0x001045fb, 0x81468800, - 0x8058b040, 0x040207f9, 0x5c025800, 0x59cc0408, - 0x8c00051e, 0x04000004, 0x59a80026, 0x84000512, - 0x48035026, 0x5c028800, 0x5c026800, 0x0201f800, - 0x0010462a, 0x4a026802, 0x00fffffe, 0x59a80826, - 0x84040d50, 0x59cc0013, 0x8c00053e, 0x04000003, - 0x8c000536, 0x04000004, 0x59cc0017, 0x8c000536, - 0x04020002, 0x84040d10, 0x48075026, 0x59cc0800, - 0x82040d00, 0x00ffffff, 0x48075010, 0x80040110, - 0x4803501d, 0x48038881, 0x0201f800, 0x0010513b, - 0x04000007, 0x59cc0009, 0x48035035, 0x59cc000a, - 0x48035036, 0x0201f800, 0x001092e5, 0x5c00b000, - 0x5c028000, 0x1c01f000, 0x4933c857, 0x4c580000, - 0x59a80010, 0x82000500, 0x00ffff00, 0x04000022, - 0x59cc1000, 0x82081500, 0x00ffff00, 0x80080580, - 0x04000004, 0x42000000, 0x0010b83b, 0x0401f016, - 0x83cc1400, 0x0000000b, 0x4200b000, 0x00000002, - 0x83341c00, 0x00000006, 0x0401f900, 0x04000004, - 0x42000000, 0x0010b83c, 0x0401f00b, 0x83cc1400, - 0x0000000d, 0x4200b000, 0x00000002, 0x83341c00, - 0x00000008, 0x0401f8f5, 0x04000007, 0x42000000, - 0x0010b83d, 0x0201f800, 0x0010aa47, 0x82000540, - 0x00000001, 0x5c00b000, 0x1c01f000, 0x4933c857, - 0x59cc0206, 0x82000580, 0x00000014, 0x04020016, - 0x59cc0407, 0x82000580, 0x00000800, 0x04020012, - 0x59cc0207, 0x8c00051a, 0x0400000d, 0x82000500, - 0x00000f00, 0x82000580, 0x00000100, 0x04020008, - 0x59cc020a, 0x8c000508, 0x04020003, 0x8c00050a, - 0x04000003, 0x80000580, 0x1c01f000, 0x82000540, - 0x00000001, 0x1c01f000, 0x4933c857, 0x4943c857, - 0x493fc857, 0x4c5c0000, 0x4d300000, 0x4d340000, - 0x4d2c0000, 0x4d380000, 0x4130b800, 0x42026000, - 0x0010d1c0, 0x59a8000e, 0x81640480, 0x040210bd, - 0x8d3e7d12, 0x04000004, 0x405c0000, 0x81300580, - 0x040000b3, 0x59300406, 0x82000c80, 0x00000012, - 0x04021015, 0x59326809, 0x0c01f001, 0x0010854f, - 0x001084bc, 0x001084d3, 0x001084de, 0x001084b7, - 0x001084ce, 0x00108507, 0x0010854f, 0x001084b5, - 0x0010851b, 0x0010852a, 0x001084b5, 0x001084b5, - 0x001084b5, 0x001084b5, 0x0010854f, 0x00108540, - 0x00108538, 0x0201f800, 0x001005d8, 0x8d3e7d18, - 0x04000004, 0x59300420, 0x8c000500, 0x04020094, - 0x59300403, 0x82000580, 0x00000043, 0x04000090, - 0x0201f800, 0x00109134, 0x02000800, 0x00102074, - 0x0201f800, 0x0010914e, 0x02000800, 0x0010801c, - 0x8d3e7d06, 0x04000084, 0x0201f800, 0x001092d7, - 0x04000083, 0x0401f080, 0x8d3e7d16, 0x04000004, - 0x59300420, 0x8c000500, 0x0402007d, 0x59325808, - 0x0201f800, 0x00109037, 0x04000077, 0x49425a06, - 0x497a5c09, 0x0201f800, 0x000202da, 0x0201f800, - 0x0010912a, 0x0401f070, 0x813669c0, 0x02000800, - 0x001005d8, 0x8d3e7d06, 0x04000004, 0x59340200, - 0x8c00050e, 0x0402006a, 0x59300004, 0x8400055c, - 0x48026004, 0x59300203, 0x82000580, 0x00000004, - 0x02000800, 0x00100e99, 0x59325808, 0x0201f800, - 0x00109037, 0x0400005c, 0x4a025a04, 0x00000103, - 0x59300402, 0x48025c06, 0x592c0408, 0x8c000512, - 0x04000006, 0x4d2c0000, 0x592e5809, 0x0201f800, - 0x001007fd, 0x5c025800, 0x49425a06, 0x497a5c09, - 0x0201f800, 0x0010959c, 0x0201f800, 0x000202da, - 0x0201f800, 0x0010912a, 0x0401f047, 0x8c000518, - 0x04000047, 0x59300203, 0x82000580, 0x00000004, - 0x02000800, 0x00100e99, 0x59325808, 0x0201f800, - 0x00109037, 0x0400003c, 0x49425a06, 0x497a5c09, - 0x0201f800, 0x0010a693, 0x0201f800, 0x0010959c, - 0x0201f800, 0x000202da, 0x0401f033, 0x0201f800, - 0x001062d5, 0x04000032, 0x59300203, 0x82000580, - 0x00000004, 0x04020004, 0x0201f800, 0x00100e99, - 0x0401f02b, 0x42027000, 0x00000047, 0x0201f800, - 0x000207a1, 0x0401f026, 0x59300203, 0x82000580, - 0x00000004, 0x02000800, 0x00100e99, 0x59325808, - 0x0201f800, 0x00109037, 0x0400001b, 0x49425a06, - 0x497a5c09, 0x0201f800, 0x000202da, 0x0401f016, - 0x833c0500, 0x00001800, 0x04000015, 0x8d3e7d16, - 0x04020013, 0x59325817, 0x0201f800, 0x001007fd, - 0x59300203, 0x82000580, 0x00000004, 0x02000800, - 0x00100e99, 0x59325808, 0x0201f800, 0x00109037, - 0x04000005, 0x49425a06, 0x497a5c09, 0x0201f800, - 0x000202da, 0x0201f800, 0x00107911, 0x83326400, - 0x00000024, 0x41580000, 0x81300480, 0x04001742, - 0x5c027000, 0x5c025800, 0x5c026800, 0x5c026000, - 0x5c00b800, 0x1c01f000, 0x5c000000, 0x4c000000, - 0x4803c857, 0x480bc857, 0x480fc857, 0x485bc857, - 0x50080800, 0x500c0000, 0x80042580, 0x04020007, - 0x80081000, 0x800c1800, 0x8058b040, 0x040207f9, - 0x80000580, 0x1c01f000, 0x4803c857, 0x4807c857, - 0x480bc857, 0x480fc857, 0x80040480, 0x04001006, - 0x42000000, 0x00000001, 0x82040d40, 0x00000001, - 0x1c01f000, 0x41780000, 0x0401f7fc, 0x83380480, - 0x00000053, 0x02021800, 0x001005d8, 0x83380480, - 0x0000004b, 0x02001800, 0x001005d8, 0x0c01f001, - 0x0010858a, 0x0010858a, 0x0010858a, 0x0010858a, - 0x00108588, 0x00108588, 0x00108588, 0x0010858a, - 0x0201f800, 0x001005d8, 0x493bc857, 0x4a026203, - 0x0000000d, 0x493a6403, 0x42000800, 0x80000000, - 0x0201f000, 0x00020721, 0x83380580, 0x00000013, - 0x04020008, 0x59300403, 0x82000580, 0x00000050, - 0x02020800, 0x001005d8, 0x0201f000, 0x0002077d, - 0x4933c857, 0x83380580, 0x00000027, 0x04020030, - 0x4933c857, 0x0201f800, 0x00106bbf, 0x4d3c0000, - 0x417a7800, 0x0201f800, 0x0010203c, 0x5c027800, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x4d2c0000, 0x59325808, 0x0201f800, 0x00109037, - 0x492fc857, 0x0400000d, 0x4a025a04, 0x00000103, - 0x59300c02, 0x48065c06, 0x4a025a06, 0x00000029, - 0x497a5c09, 0x592c0c08, 0x84040d50, 0x48065c08, - 0x0201f800, 0x000202da, 0x5c025800, 0x42003000, - 0x00000015, 0x41782800, 0x42002000, 0x00000003, - 0x4d400000, 0x4d440000, 0x59368c03, 0x42028000, - 0x00000029, 0x0201f800, 0x0010985e, 0x5c028800, - 0x5c028000, 0x0201f000, 0x0002077d, 0x83380580, - 0x00000014, 0x0402000c, 0x59300403, 0x82000c80, - 0x00000053, 0x02021800, 0x001005d8, 0x82000480, - 0x00000040, 0x02001800, 0x001005d8, 0x4803c857, - 0x0c01f00e, 0x83380580, 0x00000053, 0x0400000a, - 0x83380580, 0x00000048, 0x02020800, 0x001005d8, - 0x59300403, 0x82000580, 0x00000050, 0x02020800, - 0x001005d8, 0x1c01f000, 0x001085ff, 0x001085fd, - 0x001085fd, 0x001085fd, 0x001085fd, 0x001085fd, - 0x001085fd, 0x001085fd, 0x001085fd, 0x001085fd, - 0x001085fd, 0x00108616, 0x00108616, 0x00108616, - 0x00108616, 0x001085fd, 0x00108616, 0x001085fd, - 0x00108616, 0x0201f800, 0x001005d8, 0x4933c857, - 0x0201f800, 0x00106bbf, 0x0201f800, 0x00109037, - 0x02000000, 0x0002077d, 0x4d2c0000, 0x59325808, - 0x4a025a04, 0x00000103, 0x59300402, 0x48025c06, - 0x4a025a06, 0x00000006, 0x497a5c09, 0x0201f800, - 0x000202da, 0x5c025800, 0x0201f800, 0x0010912a, - 0x0201f000, 0x0002077d, 0x4933c857, 0x0201f800, - 0x00106bbf, 0x0201f000, 0x0002077d, 0x0201f800, - 0x001005d8, 0x5930001c, 0x800001c0, 0x02020800, - 0x0010984e, 0x59300004, 0x8c00053e, 0x04020029, - 0x59325808, 0x592c0c08, 0x59cc2a08, 0x82141d00, - 0x00000c00, 0x04000002, 0x59cc1809, 0x84040d58, - 0x48065c08, 0x82143500, 0x00000fff, 0x04020027, - 0x59340200, 0x8c00050e, 0x04020080, 0x0201f800, - 0x0002082b, 0x04020006, 0x4a025a06, 0x00000000, - 0x59300811, 0x800409c0, 0x0402094b, 0x4a025a04, - 0x00000103, 0x48065807, 0x480e580a, 0x48165c09, - 0x59300c02, 0x48065c06, 0x0201f800, 0x000202c1, - 0x0201f800, 0x001049b2, 0x59cc0208, 0x8c000518, - 0x02020000, 0x001091d1, 0x0201f000, 0x0002077d, - 0x0201f800, 0x00106f60, 0x040007d6, 0x4d3c0000, - 0x42027800, 0x00000002, 0x0201f800, 0x00108be3, - 0x5c027800, 0x0401f7cf, 0x4817c857, 0x480fc857, - 0x82180500, 0x000000ff, 0x0400000e, 0x592c0204, - 0x82000500, 0x000000ff, 0x82000580, 0x00000048, - 0x04020008, 0x592c0407, 0x800001c0, 0x04000005, - 0x0201f800, 0x0010973f, 0x0201f000, 0x00109787, - 0x82180d00, 0x00000c00, 0x04000004, 0x59340200, - 0x8c00050e, 0x04020032, 0x4a025a06, 0x00000000, - 0x41782000, 0x8c183510, 0x04000007, 0x59cc000c, - 0x82000500, 0x000000ff, 0x04000002, 0x4803c857, - 0x59cc200b, 0x4812580c, 0x41780000, 0x8c183512, - 0x04000002, 0x59cc000a, 0x4802580b, 0x80100c00, - 0x040007b8, 0x82041480, 0x0000001d, 0x04001006, - 0x592c0404, 0x8c00051e, 0x0400000e, 0x42000800, - 0x0000001c, 0x4c500000, 0x4c540000, 0x83cca400, - 0x0000000c, 0x832cac00, 0x0000000d, 0x0201f800, - 0x00108b9f, 0x5c00a800, 0x5c00a000, 0x0401f7a5, - 0x59300011, 0x59301402, 0x480a5c06, 0x48025807, - 0x480e580a, 0x48165c09, 0x0201f800, 0x00108b48, - 0x0201f800, 0x00108b84, 0x0401f7a6, 0x592c020a, - 0x8c000502, 0x040007cd, 0x592c0208, 0x8c00050e, - 0x040207ca, 0x59300011, 0x800c0d80, 0x040007c7, - 0x4803c857, 0x480fc857, 0x8c183514, 0x02000000, - 0x0010920f, 0x80000540, 0x040007c0, 0x4807c856, - 0x0201f000, 0x0010920f, 0x592c020a, 0x8c000502, - 0x04000782, 0x59300011, 0x800001c0, 0x0400077f, - 0x592c0208, 0x8c00050e, 0x0402077c, 0x0201f000, - 0x0010920f, 0x59cc2006, 0x59cc2807, 0x0401f035, - 0x0401f034, 0x1c01f000, 0x4933c857, 0x5930001c, - 0x800001c0, 0x02020800, 0x0010984e, 0x59325808, - 0x592c0c08, 0x41782800, 0x41781800, 0x84040d58, - 0x48065c08, 0x41783000, 0x59340200, 0x8c00050e, - 0x04020018, 0x0201f800, 0x0002082b, 0x04020007, - 0x4a025a06, 0x00000000, 0x59300811, 0x4807c857, - 0x800409c0, 0x040208ac, 0x4a025a04, 0x00000103, - 0x48065807, 0x480e580a, 0x48165c09, 0x4933c857, - 0x59300c02, 0x48065c06, 0x0201f800, 0x000202c1, - 0x0201f800, 0x001049b2, 0x0201f000, 0x0002077d, - 0x592c020a, 0x8c000502, 0x040007ea, 0x59300011, - 0x4803c857, 0x800001c0, 0x040007e6, 0x592c0208, - 0x8c00050e, 0x040207e3, 0x0201f000, 0x0010920f, - 0x5930001c, 0x800001c0, 0x4c100000, 0x4c140000, - 0x02020800, 0x0010984e, 0x5c002800, 0x5c002000, - 0x4a026203, 0x00000002, 0x4a026403, 0x00000043, - 0x59325808, 0x592c020a, 0x8c000502, 0x04020018, - 0x40100000, 0x592c080f, 0x80040c80, 0x40140000, - 0x80040480, 0x04001014, 0x48126013, 0x48166011, - 0x59300004, 0x8c00053e, 0x04020008, 0x497a6205, - 0x0201f800, 0x00100f93, 0x04020009, 0x59300804, - 0x0201f000, 0x00106721, 0x0201f800, 0x00106f60, - 0x040007f7, 0x0201f000, 0x00107974, 0x4933c857, - 0x1c01f000, 0x4807c857, 0x40042800, 0x0401f7eb, - 0x83380480, 0x00000058, 0x04021005, 0x83380480, - 0x00000040, 0x04001002, 0x0c01f002, 0x1c01f000, - 0x00108740, 0x00108740, 0x00108740, 0x00108740, - 0x00108740, 0x00108740, 0x00108740, 0x00108740, - 0x00108740, 0x00108740, 0x00108742, 0x00108740, - 0x00108740, 0x00108740, 0x00108740, 0x0010874f, - 0x00108740, 0x00108740, 0x00108740, 0x00108740, - 0x0010877d, 0x00108740, 0x00108740, 0x00108740, - 0x0201f800, 0x001005d8, 0x4933c857, 0x0201f800, - 0x00106dc3, 0x4a026203, 0x00000002, 0x59a80039, - 0x48026205, 0x59300011, 0x59300815, 0x80040c80, - 0x48066015, 0x0201f000, 0x00106b8a, 0x4933c857, - 0x0201f800, 0x00106b8a, 0x4d3c0000, 0x417a7800, - 0x0201f800, 0x0010203c, 0x5c027800, 0x42000000, - 0x0010b864, 0x0201f800, 0x0010aa47, 0x0201f800, - 0x00109037, 0x04000010, 0x4d2c0000, 0x59325808, - 0x4a025a04, 0x00000103, 0x59300402, 0x48025c06, - 0x4a025a06, 0x00000029, 0x497a5c09, 0x592c0c08, - 0x84040d50, 0x48065c08, 0x0201f800, 0x000202da, - 0x5c025800, 0x42003000, 0x00000014, 0x41782800, - 0x4d400000, 0x4d440000, 0x59368c03, 0x42002000, - 0x00000002, 0x42028000, 0x00000029, 0x0201f800, - 0x0010985e, 0x5c028800, 0x5c028000, 0x0201f000, - 0x0002077d, 0x4933c857, 0x59300808, 0x49780c09, - 0x4978080a, 0x58041408, 0x84081558, 0x48080c08, - 0x1c01f000, 0x4807c857, 0x8c040d3e, 0x04020023, - 0x497a5a06, 0x5930001f, 0x80000540, 0x04000017, - 0x497a5a06, 0x4c040000, 0x4c080000, 0x4c0c0000, - 0x4c100000, 0x4c140000, 0x58f41003, 0x40040000, - 0x80081480, 0x5930001f, 0x4809e803, 0x0201f800, - 0x00100d56, 0x5c002800, 0x5c002000, 0x5c001800, - 0x5c001000, 0x5c000800, 0x592c0206, 0x80000540, - 0x04020009, 0x0401f005, 0x592c0408, 0x8c00051c, - 0x04000002, 0x592c0803, 0x4807c857, 0x4a025a06, - 0x00000015, 0x1c01f000, 0x5930001f, 0x80000540, - 0x04000009, 0x4a025a06, 0x00000011, 0x5930001f, - 0x4c040000, 0x0201f800, 0x00100d56, 0x5c000800, - 0x0401f7f5, 0x4807c856, 0x4a025a06, 0x00000007, - 0x1c01f000, 0x83380480, 0x00000058, 0x04021007, - 0x83380480, 0x00000040, 0x04001004, 0x4d2c0000, - 0x0c01f803, 0x5c025800, 0x1c01f000, 0x001087db, - 0x001087db, 0x001087db, 0x001087db, 0x001087db, - 0x001087dd, 0x001087db, 0x001087db, 0x00108860, - 0x001087db, 0x001087db, 0x001087db, 0x001087db, - 0x001087db, 0x001087db, 0x001087db, 0x001087db, - 0x001087db, 0x001087db, 0x00108910, 0x00108939, - 0x00108918, 0x001087db, 0x00108945, 0x0201f800, - 0x001005d8, 0x5930001c, 0x800001c0, 0x02020800, - 0x0010984e, 0x59300007, 0x8c00050e, 0x0400007c, - 0x8c000500, 0x0400006e, 0x8c00051c, 0x04000009, - 0x84000500, 0x48026007, 0x59325808, 0x592c3c08, - 0x841c3d58, 0x481e5c08, 0x0201f000, 0x000207dd, - 0x59325808, 0x592c3c08, 0x841c3d58, 0x59300007, - 0x8c00051c, 0x040207f3, 0x481e5c08, 0x42000000, - 0x00000005, 0x40000000, 0x80000040, 0x040207fe, - 0x59300007, 0x8c00051c, 0x040207ea, 0x59cc0a08, - 0x592c0204, 0x82000500, 0x000000ff, 0x82000580, - 0x00000048, 0x0402000c, 0x497a580b, 0x82040500, - 0x000000ff, 0x04000008, 0x592c0407, 0x800001c0, - 0x04000005, 0x0201f800, 0x0010973f, 0x0201f000, - 0x00100e56, 0x48065c09, 0x41782000, 0x82040500, - 0x00000c00, 0x04000002, 0x59cc2009, 0x82043500, - 0x00000fff, 0x04020027, 0x481e5c08, 0x4a025a06, - 0x00000000, 0x801831c0, 0x02000000, 0x00100e56, - 0x41782000, 0x8c183510, 0x04000002, 0x59cc200b, - 0x4812580c, 0x41780000, 0x8c183512, 0x04000002, - 0x59cc000a, 0x4802580b, 0x80100c00, 0x02001800, - 0x001005d8, 0x02000000, 0x00100e56, 0x82041480, - 0x0000001d, 0x0402100c, 0x4c500000, 0x4c540000, - 0x83cca400, 0x0000000c, 0x832cac00, 0x0000000d, - 0x0401fb67, 0x5c00a800, 0x5c00a000, 0x0201f000, - 0x00100e56, 0x0401fb0b, 0x0201f000, 0x00100e56, - 0x412c7800, 0x0201f800, 0x001007e4, 0x02000800, - 0x001005d8, 0x492c7809, 0x841c3d52, 0x481c7c08, - 0x4a025a04, 0x00000103, 0x4812580a, 0x48065c09, - 0x583c0404, 0x583c1005, 0x583c2208, 0x48025c04, - 0x480a5805, 0x48125a08, 0x0401f7c8, 0x8c000524, - 0x04000794, 0x59325808, 0x4c000000, 0x592c0408, - 0x8c00051c, 0x5c000000, 0x04020003, 0x4a026011, - 0xffffffff, 0x84000524, 0x0401f78a, 0x1c01f000, - 0x59a80039, 0x48026205, 0x59325808, 0x4a026203, - 0x00000002, 0x592c2408, 0x59300807, 0x4933c857, - 0x4807c857, 0x592c0204, 0x82000500, 0x000000ff, - 0x82000580, 0x00000048, 0x04020004, 0x8c102500, - 0x02020000, 0x00109787, 0x4a025a06, 0x00000000, - 0x8c040d1e, 0x04000027, 0x41780800, 0x497a5c09, - 0x592c1c09, 0x59300011, 0x59341200, 0x497a6205, - 0x8c08150e, 0x0402006e, 0x4807c857, 0x4806580a, - 0x80000d40, 0x04020f04, 0x59300402, 0x48025c06, - 0x48065807, 0x4a025a04, 0x00000103, 0x4c040000, - 0x4c0c0000, 0x4c100000, 0x0201f800, 0x0010959c, - 0x5c002000, 0x5c001800, 0x5c000800, 0x8c102512, - 0x0402001a, 0x4c0c0000, 0x0201f800, 0x000202c1, - 0x0201f800, 0x001049b2, 0x5c001800, 0x8c0c1d18, - 0x02000000, 0x0002077d, 0x0201f000, 0x001091d1, - 0x4813c857, 0x8c102518, 0x0400004b, 0x41780800, - 0x592c1c09, 0x820c0580, 0x00001000, 0x040007d6, - 0x8c102512, 0x040007d4, 0x592c7809, 0x583c080a, - 0x583c1c09, 0x0401f7d0, 0x4807c857, 0x592c7809, - 0x59300402, 0x592c1404, 0x8c08151e, 0x0402000d, - 0x592c1206, 0x48007c06, 0x48047807, 0x48087a06, - 0x84102512, 0x48107c08, 0x4c0c0000, 0x0201f800, - 0x001007fd, 0x403e5800, 0x0401faca, 0x0401f7d9, - 0x48025c06, 0x48065807, 0x583c080c, 0x583c000b, - 0x80040c00, 0x82041480, 0x0000001d, 0x04001006, - 0x583c1001, 0x480a5801, 0x49787801, 0x42000800, - 0x0000001c, 0x82040c00, 0x00000014, 0x4c0c0000, - 0x4c500000, 0x4c540000, 0x823ca400, 0x00000008, - 0x832cac00, 0x00000008, 0x4c100000, 0x4c3c0000, - 0x0401facb, 0x5c007800, 0x5c002000, 0x5c00a800, - 0x5c00a000, 0x84102512, 0x48125c08, 0x403e5800, - 0x0201f800, 0x001007fd, 0x42034000, 0x0010b4a4, - 0x59a1d81e, 0x80edd9c0, 0x02000800, 0x001005d8, - 0x48efc857, 0x58ec0009, 0x4803c857, 0x0801f800, - 0x0401f7ac, 0x4933c857, 0x1c01f000, 0x59301414, - 0x480bc857, 0x8c08151c, 0x0402000e, 0x80000540, - 0x4803c857, 0x0400078d, 0x80042c80, 0x0402178b, - 0x8c081514, 0x04020005, 0x592c080f, 0x4807c857, - 0x80040480, 0x48026016, 0x8408155c, 0x480a6414, - 0x59301007, 0x8408151e, 0x480a6007, 0x4a025c09, - 0x00000001, 0x0201f800, 0x0010959c, 0x497a5c09, - 0x8c102512, 0x04000006, 0x4d2c0000, 0x403e5800, - 0x0201f800, 0x001007fd, 0x5c025800, 0x82102500, - 0xffffedff, 0x48125c08, 0x0201f000, 0x0010920f, - 0x59325808, 0x592c0408, 0x8c000518, 0x04000004, - 0x412df800, 0x0201f000, 0x00100e6f, 0x1c01f000, - 0x4933c857, 0x59325808, 0x497a5c09, 0x4a025a06, - 0x00000000, 0x4a025a04, 0x00000103, 0x59300811, - 0x4807c857, 0x800409c0, 0x0402000a, 0x48065807, - 0x59300c02, 0x48065c06, 0x0201f800, 0x000202c1, - 0x0201f800, 0x001049b2, 0x0201f000, 0x0002077d, - 0x59340200, 0x8c00050e, 0x04020005, 0x59300811, - 0x0401fe55, 0x48065807, 0x0401f7f2, 0x592c0208, - 0x8c00050e, 0x040207fa, 0x4933c857, 0x0201f000, - 0x0010920f, 0x4933c857, 0x59325808, 0x812e59c0, - 0x02000800, 0x001005d8, 0x592c020a, 0x8c000502, - 0x02000800, 0x001005d8, 0x4a026206, 0x00000002, - 0x1c01f000, 0x5930001c, 0x800001c0, 0x02020800, - 0x0010984e, 0x59300007, 0x4933c857, 0x4803c857, - 0x8c00050e, 0x04000037, 0x8c000500, 0x04000029, - 0x8c00051c, 0x0400000a, 0x84000500, 0x48026007, - 0x59325808, 0x592c3c08, 0x481fc857, 0x841c3d58, - 0x481e5c08, 0x0201f000, 0x000207dd, 0x59325808, - 0x592c3c08, 0x841c3d58, 0x59300007, 0x8c00051c, - 0x040207f2, 0x481e5c08, 0x42000000, 0x00000005, - 0x40000000, 0x80000040, 0x040207fe, 0x59300007, - 0x8c00051c, 0x040207e9, 0x592c0204, 0x82000500, - 0x000000ff, 0x82000580, 0x00000048, 0x04020003, - 0x497a580b, 0x0401f002, 0x497a5c09, 0x481e5c08, - 0x4a025a06, 0x00000000, 0x0201f000, 0x00100e56, - 0x8c000524, 0x040007d9, 0x59325808, 0x4c000000, - 0x592c0408, 0x8c00051c, 0x5c000000, 0x04020003, - 0x4a026011, 0xffffffff, 0x84000524, 0x0401f7cf, - 0x1c01f000, 0x4933c857, 0x41780800, 0x83380480, - 0x00000058, 0x0402100b, 0x83380480, 0x00000040, - 0x04001008, 0x4d2c0000, 0x59325808, 0x812e59c0, - 0x0c020806, 0x5c025800, 0x0201f000, 0x0002077d, - 0x493bc857, 0x1c01f000, 0x001089ae, 0x001089ae, - 0x001089ae, 0x001089ae, 0x001089ae, 0x001089b0, - 0x001089ae, 0x001089ae, 0x001089ae, 0x001089ae, - 0x001089ae, 0x001089ae, 0x001089ae, 0x001089ae, - 0x001089ae, 0x001089ae, 0x001089ae, 0x001089ae, - 0x001089ae, 0x001089ae, 0x001089b5, 0x001089ae, - 0x001089ae, 0x001089ae, 0x0201f800, 0x001005d8, - 0x59cc0a08, 0x497a5807, 0x4807c857, 0x82040d00, - 0x00000fff, 0x59300402, 0x48025c06, 0x4a025a04, - 0x00000103, 0x48065c09, 0x4a025a06, 0x00000000, - 0x800409c0, 0x02000000, 0x000202c1, 0x59cc0009, - 0x4802580a, 0x82042500, 0x00000100, 0x04000002, - 0x59cc200b, 0x4812580c, 0x82040500, 0x00000200, - 0x04000002, 0x59cc000a, 0x4802580b, 0x80100c00, - 0x02001800, 0x001005d8, 0x02000000, 0x000202da, - 0x82041480, 0x0000001d, 0x04001006, 0x592c0404, - 0x8c00051e, 0x0400000e, 0x42000800, 0x0000001c, - 0x4c500000, 0x4c540000, 0x83cca400, 0x0000000c, - 0x832cac00, 0x0000000d, 0x0401f9c1, 0x5c00a800, - 0x5c00a000, 0x0201f000, 0x000202da, 0x0401f965, - 0x0401f1a0, 0x83380480, 0x00000093, 0x02021800, - 0x001005d8, 0x83380480, 0x00000085, 0x02001800, - 0x001005d8, 0x0c01f001, 0x001089fd, 0x001089fb, - 0x001089fb, 0x00108a04, 0x001089fb, 0x001089fb, - 0x001089fb, 0x001089fb, 0x001089fb, 0x001089fb, - 0x001089fb, 0x001089fb, 0x001089fb, 0x0201f800, - 0x001005d8, 0x4a026203, 0x00000001, 0x493a6403, - 0x42000800, 0x80000040, 0x0201f000, 0x00020721, - 0x4933c857, 0x59cc1204, 0x480a601c, 0x59cc1404, - 0x0201f800, 0x00109410, 0x0400001b, 0x591c0203, - 0x82000580, 0x00000000, 0x04000017, 0x591c0009, - 0x81340580, 0x04020014, 0x4d300000, 0x4d1c0000, - 0x411e6000, 0x0401f9c2, 0x5c023800, 0x5c026000, - 0x0400000b, 0x59cc0005, 0x8c000500, 0x04020003, - 0x0401f98c, 0x0401f003, 0x4a023a03, 0x00000002, - 0x4a026403, 0x00000086, 0x0401f005, 0x0401f9a6, - 0x040007f5, 0x4a026403, 0x00000087, 0x4a026203, - 0x00000001, 0x42000800, 0x80000040, 0x0201f800, - 0x00020721, 0x59340200, 0x8c00050e, 0x0400000d, - 0x59cc1404, 0x0201f800, 0x00109410, 0x04000009, - 0x591c0414, 0x8c00051a, 0x04000006, 0x4d300000, - 0x411e6000, 0x0201f800, 0x0010921e, 0x5c026000, - 0x1c01f000, 0x83380580, 0x00000013, 0x0402000a, - 0x59300403, 0x82000d80, 0x00000086, 0x04000012, - 0x82000d80, 0x00000087, 0x02020800, 0x001005d8, - 0x0401f00d, 0x83380580, 0x00000027, 0x04000005, - 0x83380580, 0x00000014, 0x02020800, 0x001005d8, - 0x493bc857, 0x0201f800, 0x00106bbf, 0x0201f000, - 0x00107911, 0x4933c857, 0x0201f000, 0x00107911, - 0x83380580, 0x00000013, 0x04020005, 0x59300403, - 0x82000480, 0x00000085, 0x0c01f04d, 0x83380580, - 0x00000027, 0x04020041, 0x4933c857, 0x0201f800, - 0x00106bbf, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x0010203c, 0x5c027800, 0x42003000, 0x00000015, - 0x41782800, 0x42002000, 0x00000003, 0x42028000, - 0x00000029, 0x4d400000, 0x4d440000, 0x59368c03, - 0x0201f800, 0x0010985e, 0x5c028800, 0x5c028000, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x00109037, 0x0400000c, 0x4d2c0000, - 0x59325808, 0x4a025a04, 0x00000103, 0x59300402, - 0x48025c06, 0x497a5c09, 0x49425a06, 0x0201f800, - 0x000202da, 0x5c025800, 0x0201f800, 0x0010912a, - 0x0201f000, 0x0002077d, 0x83380580, 0x00000089, - 0x04000005, 0x83380580, 0x0000008a, 0x02020000, - 0x00107974, 0x0201f800, 0x00106f60, 0x02020000, - 0x00107974, 0x59300a03, 0x82040580, 0x0000000a, - 0x0400002a, 0x82040580, 0x0000000c, 0x04000027, - 0x0201f800, 0x001005d8, 0x83380580, 0x00000014, - 0x040207ea, 0x4933c857, 0x0201f800, 0x00106bbf, - 0x42028000, 0x00000006, 0x0401f7d2, 0x00108aba, - 0x00108ab8, 0x00108ab8, 0x00108ab8, 0x00108ab8, - 0x00108ab8, 0x00108ac0, 0x00108ab8, 0x00108ab8, - 0x00108ab8, 0x00108ab8, 0x00108ab8, 0x00108ab8, - 0x0201f800, 0x001005d8, 0x4933c857, 0x59a80037, - 0x48026206, 0x4a026203, 0x0000000a, 0x1c01f000, - 0x4933c857, 0x59a80037, 0x48026206, 0x4a026203, - 0x0000000c, 0x1c01f000, 0x83380580, 0x00000089, - 0x04000008, 0x83380580, 0x0000008a, 0x04000032, - 0x4933c857, 0x493bc857, 0x0201f000, 0x00107974, - 0x4933c857, 0x59325808, 0x59300a1d, 0x82040580, - 0x00000003, 0x04020004, 0x0201f800, 0x001049b2, - 0x0401f00c, 0x5930021d, 0x82000580, 0x00000001, - 0x04020008, 0x59300c16, 0x82040580, 0x00000039, - 0x0400002c, 0x82040580, 0x00000035, 0x04000029, - 0x4c340000, 0x41306800, 0x0201f800, 0x0002075a, - 0x04000010, 0x4a026203, 0x00000001, 0x4a026403, - 0x0000001e, 0x59cc0c07, 0x48066419, 0x59cc0a07, - 0x48066219, 0x49366009, 0x4a026406, 0x00000001, - 0x42000800, 0x80000040, 0x0201f800, 0x00020721, - 0x40366000, 0x0201f800, 0x0002077d, 0x5c006800, - 0x1c01f000, 0x4933c857, 0x5930021d, 0x82000580, - 0x00000001, 0x04020040, 0x59300c16, 0x82040580, - 0x00000035, 0x04000007, 0x82040580, 0x0000001e, - 0x04000004, 0x82040580, 0x00000039, 0x04020036, - 0x4933c857, 0x4c500000, 0x4d1c0000, 0x4130a000, - 0x40067000, 0x0201f800, 0x001093ba, 0x04020029, - 0x0201f800, 0x0002075a, 0x04000026, 0x491fc857, - 0x4933c857, 0x83380580, 0x00000035, 0x04000004, - 0x83380580, 0x00000039, 0x04020002, 0x4932381c, - 0x493a6403, 0x4a026203, 0x00000001, 0x4a026406, - 0x00000001, 0x58500809, 0x4807c857, 0x48066009, - 0x58500c15, 0x4807c857, 0x48066415, 0x58500a15, - 0x4807c857, 0x48066215, 0x58500a16, 0x4807c857, - 0x48066216, 0x58500c19, 0x4807c857, 0x48066419, - 0x58500a19, 0x4807c857, 0x48066219, 0x491e601e, - 0x42000800, 0x80000040, 0x0201f800, 0x00020721, - 0x40526000, 0x5c023800, 0x5c00a000, 0x0201f000, - 0x0002077d, 0x5930021d, 0x82000580, 0x00000003, - 0x02000800, 0x001049b2, 0x0201f000, 0x0002077d, - 0x4803c856, 0x4c500000, 0x4c540000, 0x412c7800, - 0x4c3c0000, 0x42002800, 0x00000001, 0x82040480, - 0x00000101, 0x04001003, 0x42000800, 0x00000100, - 0x40043000, 0x42000800, 0x0000001c, 0x83cca400, - 0x0000000c, 0x832cac00, 0x0000000d, 0x0401f844, - 0x82183480, 0x0000001c, 0x592e5801, 0x812e59c0, - 0x02020800, 0x001007fd, 0x0201f800, 0x001007e4, - 0x04000017, 0x80142800, 0x4a025a04, 0x00000110, - 0x497a5c04, 0x492c7801, 0x82180c80, 0x0000003d, - 0x04021006, 0x40180800, 0x832cac00, 0x00000005, - 0x0401f82f, 0x0401f00a, 0x82183480, 0x0000003c, - 0x42000800, 0x0000003c, 0x412c7800, 0x832cac00, - 0x00000005, 0x0401f826, 0x0401f7e8, 0x5c007800, - 0x841429c0, 0x82142d40, 0x00000003, 0x48147a04, - 0x403e5800, 0x5c00a800, 0x5c00a000, 0x1c01f000, - 0x492fc857, 0x812e59c0, 0x0400000f, 0x4d2c0000, - 0x4c3c0000, 0x592c7801, 0x803c79c0, 0x04000006, - 0x497a5801, 0x0201f800, 0x000202da, 0x403e5800, - 0x0401f7f9, 0x5c007800, 0x0201f800, 0x000202da, - 0x5c025800, 0x1c01f000, 0x4803c856, 0x4c580000, - 0x82040c00, 0x00000003, 0x8004b104, 0x0201f800, - 0x0010ab17, 0x5c00b000, 0x1c01f000, 0x4803c856, - 0x4c580000, 0x82040c00, 0x00000003, 0x8004b104, - 0x0201f800, 0x0010ab17, 0x5c00b000, 0x1c01f000, - 0x591c0c06, 0x82040580, 0x00000003, 0x04000004, - 0x82040580, 0x00000002, 0x0402001a, 0x4d300000, - 0x4d2c0000, 0x411e6000, 0x59325808, 0x0201f800, - 0x00109037, 0x0400000f, 0x4d400000, 0x42028000, - 0x00000013, 0x592c0a08, 0x84040d54, 0x0201f800, - 0x00104e70, 0x5c028000, 0x0201f800, 0x0010959c, - 0x0201f800, 0x000202da, 0x0201f800, 0x0010912a, - 0x0201f800, 0x00107911, 0x5c025800, 0x5c026000, - 0x1c01f000, 0x59cc0005, 0x8c000500, 0x0402000b, - 0x591c0406, 0x82000580, 0x00000002, 0x04020007, - 0x591c0c03, 0x82040580, 0x00000085, 0x04000003, - 0x82040580, 0x0000008b, 0x1c01f000, 0x4933c857, - 0x4d3c0000, 0x42027800, 0x00000002, 0x59300406, - 0x82000c80, 0x00000012, 0x02021800, 0x001005d8, - 0x0c01f80a, 0x5c027800, 0x1c01f000, 0x4933c857, - 0x59300406, 0x82000c80, 0x00000012, 0x02021800, - 0x001005d8, 0x0c01f001, 0x00108c01, 0x00108bfe, - 0x00108bfe, 0x00108c29, 0x00108bfc, 0x00108bfe, - 0x00108c1a, 0x00108bfe, 0x00108bfc, 0x001065f4, - 0x00108bfe, 0x00108bfe, 0x00108bfe, 0x00108bfc, - 0x00108bfc, 0x00108bfc, 0x00108cf9, 0x00108bfe, - 0x0201f800, 0x001005d8, 0x4803c856, 0x80000580, - 0x1c01f000, 0x4803c856, 0x8d3e7d02, 0x04020016, - 0x0201f800, 0x00109037, 0x0400000f, 0x59325808, - 0x41780800, 0x4d400000, 0x42028000, 0x00000005, - 0x0201f800, 0x00104e70, 0x5c028000, 0x0201f800, - 0x0010959c, 0x0201f800, 0x001091cc, 0x0201f800, - 0x000202da, 0x0201f800, 0x00107911, 0x82000540, - 0x00000001, 0x1c01f000, 0x4933c857, 0x0201f800, - 0x001048d9, 0x0402000c, 0x4d400000, 0x42028000, - 0x00000010, 0x0201f800, 0x0010a1d1, 0x4a026406, - 0x00000006, 0x4a026203, 0x00000007, 0x5c028000, - 0x1c01f000, 0x4933c857, 0x0201f800, 0x00106c55, - 0x4df00000, 0x0401f8b8, 0x82000c80, 0x0000000e, - 0x02021800, 0x001005d8, 0x0c01f001, 0x00108c43, - 0x00108cb0, 0x00108c5a, 0x00108cc3, 0x00108cab, - 0x00108c41, 0x00108c43, 0x00108c43, 0x00108c47, - 0x00108c43, 0x00108c43, 0x00108c43, 0x00108c43, - 0x00108c5a, 0x0201f800, 0x001005d8, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x0401f7b8, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x59300406, 0x82000580, - 0x00000003, 0x040207b4, 0x59300203, 0x82000580, - 0x0000000d, 0x040007b0, 0x8d3e7d02, 0x040207ae, - 0x4d340000, 0x59326809, 0x0201f800, 0x001049b2, - 0x5c026800, 0x0401f7a8, 0x59300004, 0x8400055c, - 0x48026004, 0x0201f800, 0x00106c4b, 0x59300406, - 0x82000580, 0x00000006, 0x04000043, 0x8d3e7d02, - 0x04020041, 0x497a621d, 0x59300203, 0x82000580, - 0x0000000d, 0x04000003, 0x4a02621d, 0x00000003, - 0x0401fbcb, 0x04000024, 0x4d2c0000, 0x4d400000, - 0x59325808, 0x0201f800, 0x001091cc, 0x592c0408, - 0x8c000512, 0x04000009, 0x4d2c0000, 0x84000512, - 0x48025c08, 0x592c0809, 0x40065800, 0x0201f800, - 0x001007fd, 0x5c025800, 0x4d400000, 0x42028000, - 0x00000005, 0x592c0a08, 0x8c040d0e, 0x04000004, - 0x42028000, 0x00000002, 0x0401f001, 0x0201f800, - 0x00104e70, 0x5c028000, 0x0201f800, 0x0010959c, - 0x0201f800, 0x000202da, 0x497a6008, 0x5c028000, - 0x5c025800, 0x8d3e7d00, 0x04000009, 0x4d340000, - 0x59326809, 0x0201f800, 0x001049b2, 0x5c026800, - 0x0201f800, 0x00107911, 0x0401f00b, 0x4a026403, - 0x00000085, 0x4a026203, 0x00000009, 0x4a026406, - 0x00000002, 0x42000800, 0x8000404b, 0x0201f800, - 0x00020721, 0x5c03e000, 0x02020800, 0x00106c55, - 0x82000540, 0x00000001, 0x1c01f000, 0x0201f800, - 0x00106c4b, 0x0201f800, 0x00100e99, 0x0401f7ab, - 0x598c000d, 0x81300580, 0x04020004, 0x0201f800, - 0x00106e8e, 0x0402001b, 0x0201f800, 0x001068d3, - 0x04020006, 0x59300c03, 0x82040580, 0x00000040, - 0x0400078b, 0x0401f79d, 0x0201f800, 0x00106b6c, - 0x04000010, 0x0201f800, 0x001005d8, 0x0401f813, - 0x04020004, 0x0201f800, 0x00106e62, 0x04020009, - 0x0201f800, 0x001067ae, 0x040207f4, 0x59300c03, - 0x82040580, 0x00000040, 0x04000779, 0x0401f78b, - 0x59300203, 0x82000c80, 0x0000000e, 0x02021800, - 0x001005d8, 0x0c01f75e, 0x417a3000, 0x42032000, - 0x0000bf32, 0x59900004, 0x81300580, 0x04000009, - 0x83932400, 0x00000010, 0x811a3000, 0x83180480, - 0x00000005, 0x040017f8, 0x82000540, 0x00000001, - 0x1c01f000, 0x59300004, 0x8c00053e, 0x04000010, - 0x8c00050c, 0x0402000e, 0x8c000516, 0x04020006, - 0x82000d00, 0x0000001f, 0x82040580, 0x00000005, - 0x04020004, 0x42000000, 0x00000003, 0x0401f005, - 0x42000000, 0x00000001, 0x0401f002, 0x59300203, - 0x1c01f000, 0x4933c857, 0x0201f800, 0x00106c55, - 0x4df00000, 0x59300203, 0x82000c80, 0x0000000e, - 0x02021800, 0x001005d8, 0x0c01f001, 0x00108d13, - 0x00108d30, 0x00108d17, 0x00108d11, 0x00108d11, - 0x00108d11, 0x00108d11, 0x00108d11, 0x00108d11, - 0x00108d11, 0x00108d11, 0x00108d11, 0x00108d11, - 0x00108d11, 0x0201f800, 0x001005d8, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x0401f6e8, 0x5c03e000, - 0x02000800, 0x00106c4b, 0x4d2c0000, 0x59325808, - 0x59300403, 0x82000580, 0x00000052, 0x02000800, - 0x00101231, 0x0401fb16, 0x02000800, 0x001005d8, - 0x4a025a06, 0x00000005, 0x0201f800, 0x000202da, - 0x0201f800, 0x00104c19, 0x0201f800, 0x00107911, - 0x5c025800, 0x82000540, 0x00000001, 0x1c01f000, - 0x598c000d, 0x81300580, 0x0402001a, 0x59300004, - 0x8c000520, 0x04000004, 0x84000520, 0x48026004, - 0x0401f01a, 0x42001000, 0x0010b7f6, 0x50081000, - 0x58080002, 0x82000580, 0x00000100, 0x0400000a, - 0x5808000c, 0x81300580, 0x02020800, 0x001005d8, - 0x0201f800, 0x001068d3, 0x02020800, 0x001005d8, - 0x0401f7cf, 0x0201f800, 0x00106e8e, 0x0402000c, - 0x59300004, 0x8c000520, 0x04000004, 0x84000520, - 0x48026004, 0x0401f7c6, 0x0201f800, 0x001068d3, - 0x040007c3, 0x0201f800, 0x001005d8, 0x59300203, - 0x82000c80, 0x0000000e, 0x02021800, 0x001005d8, - 0x0c01f7a7, 0x59300406, 0x4933c857, 0x4803c857, - 0x82000c80, 0x00000012, 0x02021800, 0x001005d8, - 0x0c01f001, 0x00108d7c, 0x00108e41, 0x00108f79, - 0x00108d88, 0x00107911, 0x00108d7c, 0x0010a1c0, - 0x0002077d, 0x00108e41, 0x001065ce, 0x00108fda, - 0x00108d77, 0x00108d77, 0x00108d77, 0x00108d77, - 0x00108d77, 0x001096eb, 0x001096eb, 0x0201f800, - 0x001005d8, 0x0401fbd5, 0x02000000, 0x0010801c, - 0x1c01f000, 0x0201f800, 0x00106c55, 0x0201f800, - 0x00106bbf, 0x0201f800, 0x00106c4b, 0x0201f000, - 0x0002077d, 0x4a026206, 0x00000001, 0x1c01f000, - 0x42000000, 0x0010b872, 0x0201f800, 0x0010aa47, - 0x4d2c0000, 0x4d400000, 0x417a5800, 0x0401faa8, - 0x04000007, 0x59325808, 0x592c0208, 0x8400054c, - 0x48025a08, 0x42028000, 0x00000006, 0x0201f800, - 0x00106c55, 0x0401ff4c, 0x4803c857, 0x82000c80, - 0x0000000e, 0x02021800, 0x001005d8, 0x0c01f806, - 0x0201f800, 0x00106c4b, 0x5c028000, 0x5c025800, - 0x1c01f000, 0x00108e40, 0x00108db5, 0x00108dc3, - 0x00108de5, 0x00108e11, 0x00108db3, 0x00108d7c, - 0x00108d7c, 0x00108d7c, 0x00108db3, 0x00108db3, - 0x00108db3, 0x00108db3, 0x00108dc3, 0x0201f800, - 0x001005d8, 0x598c000d, 0x81300580, 0x04020004, - 0x0201f800, 0x00106e8e, 0x04020038, 0x0201f800, - 0x001068d3, 0x0400003b, 0x0201f800, 0x00106b6c, - 0x04000032, 0x0201f800, 0x001005d8, 0x497a621d, - 0x812e59c0, 0x02000800, 0x001005d8, 0x592c0204, - 0x82000500, 0x000000ff, 0x82000580, 0x00000014, - 0x04000003, 0x4a02621d, 0x00000003, 0x592c0a08, - 0x0201f800, 0x00104e70, 0x0201f800, 0x0010959c, - 0x0201f800, 0x000202da, 0x497a6008, 0x4a026403, - 0x00000085, 0x4a026203, 0x00000009, 0x4a026406, - 0x00000002, 0x4a026004, 0x8000404b, 0x0201f800, - 0x00106c4b, 0x42000800, 0x8000404b, 0x0201f000, - 0x00020721, 0x0401fef1, 0x04020004, 0x0201f800, - 0x00106e62, 0x04020009, 0x0201f800, 0x001067ae, - 0x040207d2, 0x59300c03, 0x82040580, 0x00000040, - 0x04000008, 0x0401f7d2, 0x59300203, 0x82000c80, - 0x0000000e, 0x02021800, 0x001005d8, 0x0c01f7ae, - 0x0201f800, 0x00106c4b, 0x812e59c0, 0x04000013, - 0x592c0a08, 0x0201f800, 0x00104e70, 0x0201f800, - 0x0010959c, 0x0201f800, 0x000202da, 0x59300203, - 0x82000580, 0x0000000d, 0x04000008, 0x0201f800, - 0x00106c4b, 0x4d340000, 0x59326809, 0x0201f800, - 0x001049b2, 0x5c026800, 0x0201f800, 0x00107911, - 0x0401f030, 0x812e59c0, 0x02000800, 0x001005d8, - 0x0201f800, 0x0010940a, 0x04020004, 0x0201f800, - 0x00100e99, 0x0401f7aa, 0x0201f800, 0x00106c4b, - 0x592c0208, 0x8400050c, 0x48025a08, 0x592c0406, - 0x800000c2, 0x800008c4, 0x80040c00, 0x48066206, - 0x42000000, 0x10000000, 0x41300800, 0x0201f800, - 0x00100b94, 0x0400000d, 0x592c0208, 0x8c00051c, - 0x04020006, 0x8400055c, 0x48025a08, 0x4a026206, - 0x00000002, 0x0401f00f, 0x4d300000, 0x0201f800, - 0x001012e5, 0x5c026000, 0x59300203, 0x82000580, - 0x00000004, 0x04020007, 0x4d380000, 0x42027000, - 0x00000048, 0x0201f800, 0x000207a1, 0x5c027000, - 0x1c01f000, 0x42000000, 0x0010b86e, 0x0201f800, - 0x0010aa47, 0x59300203, 0x82000c80, 0x0000000e, - 0x02021800, 0x001005d8, 0x4803c857, 0x0c01f001, - 0x00108e5a, 0x00108d85, 0x00108e5c, 0x00108e5a, - 0x00108e5c, 0x00108e5c, 0x00108d7d, 0x00108e5a, - 0x00108d79, 0x00108e5a, 0x00108e5a, 0x00108e5a, - 0x00108e5a, 0x00108e5a, 0x0201f800, 0x001005d8, - 0x4d340000, 0x4d2c0000, 0x59326809, 0x59340400, - 0x82000500, 0x000000ff, 0x82000c80, 0x0000000c, - 0x02021800, 0x001005d8, 0x59303403, 0x82180d80, - 0x00000004, 0x04020004, 0x42000000, 0x00000001, - 0x0401f006, 0x82180d80, 0x00000000, 0x04020003, - 0x42000000, 0x00000001, 0x4803c857, 0x0c01f804, - 0x5c025800, 0x5c026800, 0x1c01f000, 0x00108e83, - 0x00108f22, 0x00108e85, 0x00108eba, 0x00108e85, - 0x00108f3f, 0x00108e85, 0x00108e8f, 0x00108e83, - 0x00108f3f, 0x00108e83, 0x00108e9e, 0x0201f800, - 0x001005d8, 0x59300403, 0x82000d80, 0x00000016, - 0x0400002e, 0x82000d80, 0x00000004, 0x0400002b, - 0x82000d80, 0x00000002, 0x04000028, 0x0401fabf, - 0x04000079, 0x59300403, 0x82000d80, 0x00000022, - 0x040000ae, 0x82000d80, 0x00000039, 0x040000b3, - 0x82000d80, 0x00000035, 0x040000b0, 0x82000d80, - 0x0000001e, 0x0400001b, 0x0401f999, 0x04000007, - 0x0201f800, 0x00109597, 0x04020004, 0x0201f800, - 0x00104a14, 0x0401f011, 0x59300403, 0x82000d80, - 0x00000001, 0x04020004, 0x0201f800, 0x001049e7, - 0x0400000a, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x0010203c, 0x5c027800, 0x42000000, 0x0010b864, - 0x0201f800, 0x0010aa47, 0x0201f800, 0x0010801c, - 0x0201f000, 0x00107911, 0x0401f97d, 0x04000004, - 0x0201f800, 0x00109597, 0x040000a9, 0x59300c03, - 0x82040580, 0x00000016, 0x04000056, 0x82040580, - 0x00000002, 0x04020034, 0x59a80026, 0x8c000502, - 0x04020013, 0x0201f800, 0x0010513b, 0x04020010, - 0x0201f800, 0x00105151, 0x04020006, 0x42000000, - 0x00000001, 0x0201f800, 0x00105113, 0x0401f094, - 0x4a035033, 0x00000001, 0x4202d800, 0x00000001, - 0x0201f800, 0x001050a2, 0x0401f08d, 0x59340403, - 0x82000580, 0x000007fc, 0x04000008, 0x59a80026, - 0x8c00050a, 0x04020084, 0x59340212, 0x82000500, - 0x0000ff00, 0x04000082, 0x59340412, 0x82000500, - 0x000000ff, 0x04000010, 0x80000040, 0x48026c12, - 0x497a6008, 0x4a026406, 0x00000007, 0x4a026206, - 0x00000398, 0x497a6205, 0x0201f800, 0x0002075a, - 0x04000005, 0x49366009, 0x4a026406, 0x00000001, - 0x0401f020, 0x59300403, 0x82000d80, 0x00000002, - 0x0402000d, 0x59340403, 0x82000580, 0x000007fe, - 0x04020009, 0x59a80026, 0x84000540, 0x48035026, - 0x0201f800, 0x00104237, 0x0201f800, 0x0010801c, - 0x0401f00c, 0x0201f800, 0x0010801c, 0x4d3c0000, - 0x417a7800, 0x0201f800, 0x0010203c, 0x5c027800, - 0x42000000, 0x0010b864, 0x0201f800, 0x0010aa47, - 0x0201f800, 0x00102074, 0x0201f000, 0x00107911, - 0x42000800, 0x00000003, 0x0201f800, 0x00104571, - 0x4a026203, 0x00000001, 0x4a026403, 0x00000002, - 0x0201f000, 0x0010672b, 0x0401f915, 0x04020793, - 0x0201f800, 0x00102074, 0x4d3c0000, 0x417a7800, - 0x0201f800, 0x0010203c, 0x5c027800, 0x42000000, - 0x0010b864, 0x0201f800, 0x0010aa47, 0x42003000, - 0x00000018, 0x41782800, 0x42002000, 0x00000000, - 0x4d400000, 0x4d440000, 0x59368c03, 0x42028000, - 0x00000029, 0x0201f800, 0x0010985e, 0x5c028800, - 0x5c028000, 0x0201f000, 0x00107911, 0x0201f800, - 0x00104a14, 0x0401f7c8, 0x42000000, 0x0010b86d, - 0x0201f800, 0x0010aa47, 0x0201f800, 0x00107b76, - 0x040207c1, 0x1c01f000, 0x4d380000, 0x59327403, - 0x0201f800, 0x001093ba, 0x5c027000, 0x02020000, - 0x0002077d, 0x836c0580, 0x00000003, 0x04000004, - 0x4a026206, 0x00000002, 0x1c01f000, 0x59300403, - 0x48026416, 0x4a02621d, 0x00000001, 0x4a026403, - 0x00000085, 0x4a026203, 0x00000009, 0x4a026406, - 0x00000002, 0x42000800, 0x8000004b, 0x0201f000, - 0x00020721, 0x0201f800, 0x00102074, 0x0201f800, - 0x0010801c, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x0010203c, 0x5c027800, 0x42000000, 0x0010b864, - 0x0201f800, 0x0010aa47, 0x497a6008, 0x4a026406, - 0x00000007, 0x4a026206, 0x00000398, 0x497a6205, - 0x1c01f000, 0x42000000, 0x0010b870, 0x0201f800, - 0x0010aa47, 0x4d340000, 0x59326809, 0x59300203, - 0x82000c80, 0x0000000e, 0x02021800, 0x001005d8, - 0x4803c857, 0x0c01f803, 0x5c026800, 0x1c01f000, - 0x00108f96, 0x00108d85, 0x00108f96, 0x00108f96, - 0x00108f96, 0x00108f96, 0x00108f96, 0x00108f96, - 0x00108f96, 0x00108d85, 0x00108f98, 0x00108d85, - 0x00108fa0, 0x00108f96, 0x0201f800, 0x001005d8, - 0x4a026403, 0x0000008b, 0x4a026203, 0x0000000b, - 0x42000800, 0x8000404b, 0x0201f000, 0x00020721, - 0x59300a1d, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x0010203c, 0x5c027800, 0x42003000, 0x00000011, - 0x0201f800, 0x0010a942, 0x42000000, 0x0010b864, - 0x0201f800, 0x0010aa47, 0x41306800, 0x0201f800, - 0x0002075a, 0x04000008, 0x49366009, 0x4d300000, - 0x40366000, 0x0201f800, 0x00107911, 0x5c026000, - 0x0401f002, 0x40366000, 0x497a6008, 0x4a026406, - 0x00000001, 0x4a026403, 0x00000001, 0x0201f800, - 0x00103b25, 0x04000011, 0x4a026406, 0x00000004, - 0x4a026203, 0x00000007, 0x4a026420, 0x00000001, - 0x42003000, 0x00000004, 0x4d400000, 0x42028000, - 0x00000029, 0x41782800, 0x0201f800, 0x0010a43e, - 0x5c028000, 0x1c01f000, 0x42000800, 0x0000000b, - 0x0201f800, 0x00104571, 0x4a026203, 0x00000001, - 0x0201f000, 0x0010672b, 0x42000000, 0x0010b876, - 0x0201f800, 0x0010aa47, 0x59300203, 0x82000c80, - 0x0000000e, 0x02021800, 0x001005d8, 0x4803c857, - 0x0c01f001, 0x0010900b, 0x00108ff3, 0x00108ff7, - 0x0010900c, 0x00108ff5, 0x00108ff3, 0x00108ff3, - 0x00108ff3, 0x00108ff3, 0x00108ff3, 0x00108ff3, - 0x00108ff3, 0x00108ff3, 0x00108ff3, 0x0201f800, - 0x001005d8, 0x0201f800, 0x00100e99, 0x4d2c0000, - 0x59325808, 0x4a025a06, 0x00000006, 0x0201f800, - 0x000202da, 0x5c025800, 0x497a6008, 0x4a02621d, - 0x0000000a, 0x4a026403, 0x00000085, 0x4a026203, - 0x00000009, 0x4a026406, 0x00000002, 0x42000800, - 0x8000404b, 0x0201f000, 0x00020721, 0x1c01f000, - 0x0201f800, 0x00106c55, 0x4df00000, 0x0401fcc7, - 0x04020004, 0x0201f800, 0x00106e62, 0x0402000c, - 0x0201f800, 0x001067ae, 0x04020005, 0x5c03e000, - 0x0201f800, 0x00106c4b, 0x0401f7dd, 0x0201f800, - 0x00106b6c, 0x02020800, 0x001005d8, 0x5c03e000, - 0x0201f800, 0x00106c4b, 0x59300203, 0x82000d80, - 0x00000003, 0x02000800, 0x001005d8, 0x82000c80, - 0x0000000e, 0x02021800, 0x001005d8, 0x0c01f7ba, - 0x4803c856, 0x59a8000e, 0x59a80867, 0x80040400, - 0x80080480, 0x04021004, 0x82000540, 0x00000001, - 0x1c01f000, 0x80000580, 0x1c01f000, 0x4803c856, - 0x4c080000, 0x59301008, 0x82081500, 0xfff00000, - 0x5c001000, 0x1c01f000, 0x4803c856, 0x4d300000, - 0x0201f800, 0x0002075a, 0x0400000a, 0x0401f82f, - 0x4d380000, 0x42027000, 0x0000004b, 0x0201f800, - 0x000207a1, 0x5c027000, 0x82000540, 0x00000001, - 0x5c026000, 0x1c01f000, 0x4803c856, 0x4d300000, - 0x0201f800, 0x00107942, 0x0400001b, 0x0401f81f, - 0x4d300000, 0x0201f800, 0x00106c55, 0x4d3c0000, - 0x417a7800, 0x0201f800, 0x00106ab4, 0x0201f800, - 0x001067fd, 0x5c027800, 0x0201f800, 0x0010a2ff, - 0x0201f800, 0x00106c4b, 0x5c026000, 0x8d3e7d3e, - 0x0402000b, 0x4d380000, 0x42027000, 0x0000004c, - 0x0201f800, 0x000207a1, 0x5c027000, 0x82000540, - 0x00000001, 0x5c026000, 0x1c01f000, 0x0201f800, - 0x0002077d, 0x0401f7fa, 0x592c0407, 0x494a6017, - 0x494e6018, 0x49366009, 0x492e6008, 0x4a026406, - 0x00000003, 0x800000c2, 0x800008c4, 0x80040400, - 0x48026206, 0x1c01f000, 0x493bc857, 0x4d300000, - 0x0201f800, 0x0002075a, 0x0400000d, 0x0401ffef, - 0x4d400000, 0x42028000, 0x00000005, 0x0401f80d, - 0x5c028000, 0x8d3e7d3e, 0x04020007, 0x0201f800, - 0x000207a1, 0x82000540, 0x00000001, 0x5c026000, - 0x1c01f000, 0x0201f800, 0x0002077d, 0x0401f7fa, - 0x4803c856, 0x0201f800, 0x00106c55, 0x4d3c0000, - 0x4d440000, 0x59368c03, 0x42027800, 0x00000001, - 0x0201f800, 0x001069b6, 0x0201f800, 0x0010692e, - 0x0201f800, 0x001067fd, 0x0201f800, 0x0010a2ff, - 0x5c028800, 0x5c027800, 0x0201f000, 0x00106c4b, - 0x4803c856, 0x4d300000, 0x0201f800, 0x0002075a, - 0x0400000f, 0x481a601c, 0x48ee6021, 0x49366009, - 0x4a026406, 0x00000001, 0x492e6008, 0x4d380000, - 0x42027000, 0x0000001f, 0x0201f800, 0x000207a1, - 0x5c027000, 0x82000540, 0x00000001, 0x5c026000, - 0x1c01f000, 0x4803c856, 0x4d300000, 0x0201f800, - 0x0002075a, 0x0400000e, 0x48ee6021, 0x49366009, - 0x4a026406, 0x00000001, 0x492e6008, 0x4d380000, - 0x42027000, 0x00000055, 0x0201f800, 0x000207a1, - 0x5c027000, 0x82000540, 0x00000001, 0x5c026000, - 0x1c01f000, 0x4803c856, 0x4d300000, 0x0201f800, - 0x0002075a, 0x0400000f, 0x481a601c, 0x48ee6021, - 0x49366009, 0x4a026406, 0x00000001, 0x492e6008, - 0x4d380000, 0x42027000, 0x0000003d, 0x0201f800, - 0x000207a1, 0x5c027000, 0x82000540, 0x00000001, - 0x5c026000, 0x1c01f000, 0x4803c856, 0x4d300000, - 0x0201f800, 0x00107942, 0x04000014, 0x49366009, - 0x492fc857, 0x4933c857, 0x592c0404, 0x8c00051e, - 0x04000003, 0x48efc857, 0x48ee6021, 0x4a026406, - 0x00000001, 0x492e6008, 0x4d380000, 0x42027000, - 0x00000000, 0x0201f800, 0x000207a1, 0x5c027000, - 0x82000540, 0x00000001, 0x5c026000, 0x1c01f000, - 0x4803c856, 0x4d300000, 0x0201f800, 0x0002075a, - 0x0400000f, 0x48ee6021, 0x481a601c, 0x49366009, - 0x4a026406, 0x00000001, 0x492e6008, 0x4d380000, - 0x42027000, 0x00000044, 0x0201f800, 0x000207a1, - 0x5c027000, 0x82000540, 0x00000001, 0x5c026000, - 0x1c01f000, 0x4803c856, 0x4d300000, 0x0201f800, - 0x0002075a, 0x0400000f, 0x481a601c, 0x48ee6021, - 0x49366009, 0x4a026406, 0x00000001, 0x492e6008, - 0x4d380000, 0x42027000, 0x00000049, 0x0201f800, - 0x000207a1, 0x5c027000, 0x82000540, 0x00000001, - 0x5c026000, 0x1c01f000, 0x59300009, 0x80001540, - 0x02000800, 0x001005d8, 0x5808040b, 0x4803c856, - 0x80000040, 0x04001002, 0x4800140b, 0x1c01f000, - 0x4803c856, 0x59300403, 0x82000d80, 0x00000002, - 0x04000015, 0x82000d80, 0x00000003, 0x04000012, - 0x82000d80, 0x00000004, 0x0400000f, 0x82000d80, - 0x00000008, 0x0400000c, 0x82000d80, 0x0000000a, - 0x04000009, 0x599c0819, 0x8c040d0e, 0x04000004, - 0x82000d80, 0x00000000, 0x04000003, 0x82000540, - 0x00000001, 0x1c01f000, 0x4803c856, 0x4c000000, - 0x4d2c0000, 0x59300406, 0x82000580, 0x00000004, - 0x0400001d, 0x59300008, 0x80025d40, 0x800001c0, - 0x04000019, 0x0201f800, 0x00109597, 0x04000014, - 0x59300406, 0x82004580, 0x00000010, 0x04000010, - 0x82004580, 0x00000011, 0x0400000d, 0x82004580, - 0x00000003, 0x0400000c, 0x82004580, 0x00000002, - 0x04000009, 0x82004580, 0x0000000a, 0x04000006, - 0x592c0404, 0x8c00051e, 0x04000003, 0x80000580, - 0x0401f003, 0x82000540, 0x00000001, 0x5c025800, - 0x5c000000, 0x1c01f000, 0x4803c856, 0x4d300000, - 0x0201f800, 0x00107942, 0x04000013, 0x49366009, - 0x48ee6021, 0x4a026406, 0x00000001, 0x492e6008, - 0x4d3c0000, 0x417a7800, 0x0201f800, 0x0010203c, - 0x5c027800, 0x4d380000, 0x42027000, 0x00000028, - 0x0201f800, 0x000207a1, 0x5c027000, 0x82000540, - 0x00000001, 0x5c026000, 0x1c01f000, 0x4803c856, - 0x83380580, 0x00000015, 0x0402000d, 0x59a80016, - 0x82000580, 0x00000074, 0x04020009, 0x0201f800, - 0x0010462a, 0x4a026203, 0x00000001, 0x4a026403, - 0x00000029, 0x0201f000, 0x0010672b, 0x0201f800, - 0x0010801c, 0x0201f000, 0x0002077d, 0x4803c856, - 0x83380580, 0x00000016, 0x04020007, 0x42000800, - 0x00000004, 0x0201f800, 0x00104571, 0x0201f000, - 0x00107b38, 0x83380580, 0x00000015, 0x04020013, - 0x59a80016, 0x82000580, 0x00000014, 0x0402000f, - 0x0201f800, 0x0010468d, 0x0201f800, 0x0010846f, - 0x0402000a, 0x59340404, 0x80000540, 0x04000007, - 0x42000800, 0x00000006, 0x0201f800, 0x00104571, - 0x0201f000, 0x00107b38, 0x0201f800, 0x0010801c, - 0x0201f000, 0x0002077d, 0x4803c856, 0x592c0206, - 0x82000580, 0x00000005, 0x04000002, 0x1c01f000, - 0x4803c856, 0x592c0208, 0x8400054a, 0x48025a08, - 0x1c01f000, 0x497a6205, 0x497a6008, 0x4a026203, - 0x00000001, 0x4a026403, 0x00000050, 0x42000800, - 0x80000043, 0x0201f000, 0x00020721, 0x4933c857, - 0x4d340000, 0x59326809, 0x59340200, 0x8c00050e, - 0x04000006, 0x59300406, 0x82000c80, 0x00000012, - 0x04021004, 0x0c01f806, 0x5c026800, 0x1c01f000, - 0x0201f800, 0x00108d7c, 0x0401f7fc, 0x00108d7c, - 0x001091fd, 0x00109201, 0x00109204, 0x0010a49b, - 0x0010a4b8, 0x0010a4bc, 0x00108d7c, 0x00108d7c, - 0x00108d7c, 0x00108d7c, 0x00108d7c, 0x00108d7c, - 0x00108d7c, 0x00108d7c, 0x00108d7c, 0x00108d7c, - 0x00108d7c, 0x4803c856, 0x40000000, 0x40000000, - 0x1c01f000, 0x40000000, 0x40000000, 0x1c01f000, - 0x5930001c, 0x4803c857, 0x59300414, 0x4933c857, - 0x4803c857, 0x8c000502, 0x04000005, 0x84000502, - 0x84000540, 0x48026414, 0x1c01f000, 0x42000000, - 0xd0000000, 0x41300800, 0x0201f800, 0x00100b94, - 0x0401f80a, 0x04020008, 0x59a80037, 0x82000400, - 0x0000000a, 0x48026205, 0x59300414, 0x84000542, - 0x48026414, 0x1c01f000, 0x4933c857, 0x4d340000, - 0x59326809, 0x59340200, 0x8c00050e, 0x02000800, - 0x001005d8, 0x5930001c, 0x80000540, 0x0402002f, - 0x59a80021, 0x80000540, 0x0402002a, 0x4d1c0000, - 0x41323800, 0x0201f800, 0x0002075a, 0x04000023, - 0x4932381c, 0x591c0414, 0x84000542, 0x48023c14, - 0x49366009, 0x591c0406, 0x82000580, 0x00000003, - 0x04000006, 0x591c0202, 0x48026419, 0x591c0402, - 0x48026219, 0x0401f005, 0x591c0202, 0x48026219, - 0x591c0402, 0x48026419, 0x491e601e, 0x4a026406, - 0x00000001, 0x4a026403, 0x00000035, 0x4a026203, - 0x00000001, 0x42000800, 0x80000040, 0x0201f800, - 0x00020721, 0x411e6000, 0x5c023800, 0x80000580, - 0x5c026800, 0x1c01f000, 0x411e6000, 0x5c023800, - 0x59a80039, 0x48026205, 0x82000540, 0x00000001, - 0x0401f7f8, 0x4933c857, 0x4d2c0000, 0x4932381c, - 0x4a026202, 0x0000ffff, 0x591e5808, 0x591c0007, - 0x8c00051e, 0x04000005, 0x8400051e, 0x48023807, - 0x497a5c09, 0x0401f014, 0x592c0408, 0x8c000518, - 0x04000011, 0x84000518, 0x48025c08, 0x4a025c09, - 0x00000001, 0x0401fb2f, 0x497a5c09, 0x592c0408, - 0x8c000512, 0x04000008, 0x4d2c0000, 0x84000512, - 0x48025c08, 0x592e5809, 0x0201f800, 0x001007fd, - 0x5c025800, 0x59a80039, 0x48026205, 0x591c0214, - 0x48026216, 0x82000d80, 0x00000001, 0x04000008, - 0x4a023a03, 0x00000002, 0x82000580, 0x00000005, - 0x04000008, 0x497a6015, 0x0401f01e, 0x591c0007, - 0x84000540, 0x48023807, 0x4a023a03, 0x00000004, - 0x591c0414, 0x4803c857, 0x8400051c, 0x84000554, - 0x48023c14, 0x592c000f, 0x40001000, 0x591c0816, - 0x80040480, 0x040217f0, 0x591c0016, 0x82000500, - 0xfffffffc, 0x48026015, 0x48023816, 0x591c0a14, - 0x4807c857, 0x82040d80, 0x00000005, 0x04020005, - 0x480bc857, 0x4803c857, 0x4a023812, 0xffffffff, - 0x591c0402, 0x48026419, 0x591c0202, 0x48026219, - 0x591e6809, 0x49366009, 0x4a026406, 0x00000001, - 0x4a026403, 0x00000039, 0x4a026203, 0x00000001, - 0x42000800, 0x80000040, 0x0201f800, 0x00020721, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x59300414, - 0x8c000514, 0x04000015, 0x8c00051c, 0x04020012, - 0x59300016, 0x80100480, 0x04001006, 0x04000005, - 0x59300414, 0x84000514, 0x8400055c, 0x0401f009, - 0x48126016, 0x48126012, 0x40100000, 0x592c180f, - 0x800c0480, 0x48026011, 0x59300414, 0x84000514, - 0x48026414, 0x1c01f000, 0x4933c857, 0x8c00051c, - 0x04020006, 0x59300012, 0x48026016, 0x59300414, - 0x8400055c, 0x48026414, 0x1c01f000, 0x59300c03, - 0x4933c857, 0x4807c857, 0x82040480, 0x00000034, - 0x04001006, 0x82040480, 0x0000003c, 0x04021003, - 0x80000580, 0x1c01f000, 0x82000540, 0x00000001, - 0x0401f7fd, 0x41780800, 0x59a81035, 0x42000000, - 0x00000032, 0x0201f800, 0x001066a0, 0x800811c0, - 0x04020003, 0x42001000, 0x00000014, 0x480b5037, - 0x59a81036, 0x480b502d, 0x41780800, 0x42000000, - 0x00000064, 0x0201f800, 0x001066a0, 0x800811c0, - 0x04020003, 0x42001000, 0x00000014, 0x480b5038, - 0x82081400, 0x0000000a, 0x480b5039, 0x42000800, - 0x00000001, 0x0201f800, 0x00106c78, 0x42000000, - 0x30000000, 0x40080800, 0x0201f800, 0x00100b68, - 0x42000800, 0x00000003, 0x59a81010, 0x0201f800, - 0x00106c78, 0x0201f000, 0x00104906, 0x4a035037, - 0x00000028, 0x4a035038, 0x00000014, 0x4a03502d, - 0x000007d0, 0x42001000, 0x0000001e, 0x480b5039, - 0x42000800, 0x00000001, 0x0201f800, 0x00106c78, - 0x42000000, 0x30000000, 0x40080800, 0x0201f800, - 0x00100b68, 0x42000800, 0x00000003, 0x59a81010, - 0x0201f000, 0x00106c78, 0x4933c857, 0x4d2c0000, - 0x59300403, 0x82000580, 0x0000003e, 0x04020005, - 0x59325817, 0x812e59c0, 0x02020800, 0x001007f4, - 0x5c025800, 0x1c01f000, 0x4937c857, 0x4d300000, - 0x0201f800, 0x0002075a, 0x04000011, 0x49366009, - 0x4a026406, 0x00000001, 0x492e6008, 0x42000800, - 0x00000009, 0x0201f800, 0x00104571, 0x4d380000, - 0x42027000, 0x00000033, 0x0201f800, 0x000207a1, - 0x5c027000, 0x82000540, 0x00000001, 0x5c026000, - 0x1c01f000, 0x4933c857, 0x4d2c0000, 0x4c580000, - 0x4d3c0000, 0x59325808, 0x83380580, 0x00000015, - 0x04020022, 0x59a8b016, 0x82580c80, 0x00000019, - 0x04001003, 0x4200b000, 0x00000018, 0x8058b104, - 0x0401fa07, 0x80000580, 0x0401fa17, 0x832cac00, - 0x00000009, 0x83cca400, 0x00000006, 0x0201f800, - 0x0010ab17, 0x42027800, 0x00000001, 0x592c100a, - 0x8c081518, 0x04020006, 0x59a80010, 0x592c100d, - 0x80080580, 0x04020006, 0x417a7800, 0x59301009, - 0x58081403, 0x0201f800, 0x001020a1, 0x0201f800, - 0x00107b38, 0x0401f008, 0x4200b000, 0x00000002, - 0x0401fa09, 0x0201f800, 0x0010801c, 0x0201f800, - 0x0002077d, 0x5c027800, 0x5c00b000, 0x5c025800, - 0x1c01f000, 0x4933c856, 0x49366009, 0x4a026406, - 0x00000001, 0x492e6008, 0x4d380000, 0x42027000, - 0x0000004d, 0x0201f800, 0x000207a1, 0x5c027000, - 0x82000540, 0x00000001, 0x1c01f000, 0x4803c856, - 0x4d2c0000, 0x83380580, 0x00000015, 0x04020027, - 0x59a80816, 0x59325808, 0x5930040b, 0x800000c4, - 0x80040580, 0x04020021, 0x4c500000, 0x4c540000, - 0x4c580000, 0x83cca400, 0x00000006, 0x4050a800, - 0x5930b40b, 0x0201f800, 0x0010ab28, 0x83cca400, - 0x00000006, 0x592cb205, 0x832cac00, 0x00000006, - 0x0201f800, 0x0010ab17, 0x592e5801, 0x812e59c0, - 0x040207f9, 0x5931d821, 0x58ef400b, 0x58ee580d, - 0x4a025a04, 0x00000103, 0x58ec0009, 0x0801f800, - 0x59300402, 0x5c00b000, 0x5c00a800, 0x5c00a000, - 0x5c025800, 0x1c01f000, 0x0201f800, 0x0010801c, - 0x5c025800, 0x1c01f000, 0x4933c857, 0x83380580, - 0x00000035, 0x04000005, 0x59301419, 0x0401f851, - 0x04000027, 0x0401f006, 0x4d300000, 0x5932601e, - 0x0401f856, 0x5c026000, 0x04000020, 0x591c0c06, - 0x82040580, 0x00000003, 0x04000004, 0x82040580, - 0x00000006, 0x0402001c, 0x591c0c02, 0x59300419, - 0x80040580, 0x04000009, 0x59300219, 0x80040580, - 0x04020015, 0x591c0a02, 0x59300419, 0x80040580, - 0x04020011, 0x0401f009, 0x59300a19, 0x82040580, - 0x0000ffff, 0x04000005, 0x591c0202, 0x59300a19, - 0x80040580, 0x04020008, 0x591c0009, 0x59300809, - 0x80040580, 0x1c01f000, 0x417a3800, 0x82000540, - 0x00000001, 0x1c01f000, 0x4803c856, 0x59b800e4, - 0x8c000538, 0x02020800, 0x001005d8, 0x42000800, - 0x0000012c, 0x4a0370e4, 0x20000000, 0x59b800e4, - 0x80040840, 0x02000800, 0x001005d8, 0x8c00053c, - 0x040207f9, 0x4a0370e4, 0x30000000, 0x40000000, - 0x40000000, 0x40000000, 0x59b800e4, 0x8c00053c, - 0x040207f1, 0x1c01f000, 0x4803c856, 0x4a0370e4, - 0x20000000, 0x40000000, 0x59b800e4, 0x8c000538, - 0x040207fb, 0x1c01f000, 0x59300807, 0x8c040d1e, - 0x592c0c08, 0x04020002, 0x8c040d18, 0x1c01f000, - 0x0401fc1c, 0x04000008, 0x42000800, 0x00000024, - 0x0201f800, 0x00106681, 0x82063c00, 0x0010d1c0, - 0x491fc857, 0x1c01f000, 0x83300480, 0x0010d1c0, - 0x0400100a, 0x59a8000b, 0x81300480, 0x04021007, - 0x59301402, 0x0401ffef, 0x04000007, 0x411c0000, - 0x81300580, 0x04000003, 0x81780500, 0x0401f002, - 0x81300540, 0x1c01f000, 0x4947c857, 0x4d300000, - 0x0201f800, 0x00020245, 0x0402000a, 0x42026000, - 0x0010bde9, 0x49366009, 0x492e6008, 0x0201f800, - 0x0010203c, 0x80000580, 0x5c026000, 0x1c01f000, - 0x82000540, 0x00000001, 0x0401f7fc, 0x4933c857, - 0x0201f800, 0x00109037, 0x02000800, 0x001005d8, - 0x4d2c0000, 0x4d340000, 0x4d440000, 0x4c580000, - 0x59325808, 0x59326809, 0x49425a06, 0x0201f800, - 0x00105755, 0x592e8c06, 0x592c4207, 0x82200500, - 0x0000000f, 0x0c01f806, 0x5c00b000, 0x5c028800, - 0x5c026800, 0x5c025800, 0x1c01f000, 0x00109466, - 0x00109488, 0x0010948f, 0x00109493, 0x0010949c, - 0x00109463, 0x00109463, 0x00109463, 0x001094a0, - 0x001094ac, 0x001094ac, 0x00109463, 0x00109463, - 0x00109463, 0x00109463, 0x00109463, 0x4803c857, - 0x0201f800, 0x001005d8, 0x814281c0, 0x04020012, - 0x41785800, 0x592c0404, 0x8c00051c, 0x04020002, - 0x59345c05, 0x442c2800, 0x59340008, 0x48002802, - 0x59340009, 0x48002801, 0x59340006, 0x48002804, - 0x59340007, 0x48002803, 0x4200b000, 0x0000000b, - 0x0401f037, 0x592c0207, 0x8c00051e, 0x4200b000, - 0x00000002, 0x04020032, 0x8204b540, 0x00000000, - 0x0400002f, 0x44042800, 0x59326809, 0x59340400, - 0x48002801, 0x4200b000, 0x00000002, 0x0401f028, - 0x814281c0, 0x04020030, 0x59345c05, 0x442c2800, - 0x4200b000, 0x00000001, 0x0401f021, 0x8340b540, - 0x00000000, 0x0400001e, 0x0401f027, 0x814281c0, - 0x04020025, 0x59340200, 0x44002800, 0x59340001, - 0x48002801, 0x4200b000, 0x00000002, 0x0401f014, - 0x8340b540, 0x00000000, 0x0402001b, 0x0401f010, - 0x8340b540, 0x00000000, 0x0400000d, 0x0201f800, - 0x00104a1f, 0x04000014, 0x8c20450e, 0x04000002, - 0x497a6009, 0x4178b000, 0x497a5a06, 0x0401f004, - 0x8340b540, 0x00000000, 0x0402000b, 0x592c0404, - 0x8400051c, 0x48025c04, 0x592c0207, 0x8400051e, - 0x48025a07, 0x0401f8aa, 0x497a6008, 0x0201f000, - 0x000202da, 0x592c0207, 0x8c00051e, 0x4200b000, - 0x00000002, 0x040207f2, 0x8204b540, 0x00000000, - 0x040007ef, 0x44042800, 0x4200b000, 0x00000001, - 0x0401f7eb, 0x4937c857, 0x4d300000, 0x0201f800, - 0x0002075a, 0x04000011, 0x49366009, 0x4a026406, - 0x00000001, 0x492e6008, 0x42000800, 0x0000000b, - 0x0201f800, 0x00104571, 0x4d380000, 0x42027000, - 0x00000043, 0x0201f800, 0x000207a1, 0x5c027000, - 0x82000540, 0x00000001, 0x5c026000, 0x1c01f000, - 0x4937c857, 0x4d2c0000, 0x59325808, 0x83380580, - 0x00000015, 0x04020025, 0x59a80016, 0x82000580, - 0x00000004, 0x04020021, 0x59a80010, 0x592c1009, - 0x80080580, 0x04020010, 0x4d440000, 0x592e8c06, - 0x592c0207, 0x4803c856, 0x82000500, 0x00000080, - 0x84000548, 0x4d3c0000, 0x42027800, 0x00001000, - 0x0201f800, 0x001049bb, 0x5c027800, 0x5c028800, - 0x0401f004, 0x4803c856, 0x0201f800, 0x00104a1f, - 0x0201f800, 0x00109037, 0x04000017, 0x4d400000, - 0x42028000, 0x00000000, 0x41780800, 0x0401ff38, - 0x5c028000, 0x0401f00e, 0x0201f800, 0x00104a1f, - 0x040207f4, 0x0201f800, 0x00109037, 0x0400000a, - 0x4c580000, 0x4200b000, 0x00000002, 0x0401f86e, - 0x5c00b000, 0x0201f800, 0x0010801c, 0x0201f800, - 0x0002077d, 0x5c025800, 0x1c01f000, 0x4937c857, - 0x4d300000, 0x0201f800, 0x0002075a, 0x04000012, - 0x49366009, 0x4a026406, 0x00000001, 0x4d3c0000, - 0x4d380000, 0x417a7800, 0x0201f800, 0x00104567, - 0x492e6008, 0x42027000, 0x00000004, 0x0201f800, - 0x000207a1, 0x5c027000, 0x5c027800, 0x82000540, - 0x00000001, 0x5c026000, 0x1c01f000, 0x4937c857, - 0x4d300000, 0x0201f800, 0x00107942, 0x0400000d, - 0x49366009, 0x4a026406, 0x00000001, 0x492e6008, - 0x4d380000, 0x42027000, 0x00000051, 0x0201f800, - 0x000207a1, 0x5c027000, 0x82000540, 0x00000001, - 0x5c026000, 0x1c01f000, 0x4933c857, 0x4c580000, - 0x59325808, 0x83383580, 0x00000015, 0x04020011, - 0x592c0008, 0x82000500, 0x00ffffff, 0x0402000a, - 0x0201f800, 0x00105755, 0x59cc0000, 0x82000500, - 0x00ffffff, 0x44002800, 0x4200b000, 0x00000001, - 0x0401f80b, 0x0201f800, 0x00107b38, 0x0401f006, - 0x4200b000, 0x00000002, 0x0401f823, 0x0201f800, - 0x0010801c, 0x5c00b000, 0x1c01f000, 0x492fc857, - 0x4c580000, 0x4c000000, 0x8058b1c0, 0x0400000b, - 0x82580500, 0xfffffff0, 0x02020800, 0x001005d8, - 0x8058b0d0, 0x592c0408, 0x82000500, 0xfffff0ff, - 0x80580540, 0x48025c08, 0x5c000000, 0x5c00b000, - 0x1c01f000, 0x492fc857, 0x4c000000, 0x4c040000, - 0x800000d8, 0x592c0c08, 0x82040d00, 0xffff0fff, - 0x80040540, 0x48025c08, 0x5c000800, 0x5c000000, - 0x1c01f000, 0x4933c857, 0x4d2c0000, 0x59325808, - 0x592c0207, 0x8400055e, 0x48025a07, 0x4c500000, - 0x4c540000, 0x4c580000, 0x0401ffd9, 0x0201f800, - 0x00105755, 0x46002800, 0x00000018, 0x80142800, - 0x8058b040, 0x83cca400, 0x00000007, 0x4014a800, - 0x0201f800, 0x0010ab17, 0x5c00b000, 0x5c00a800, - 0x5c00a000, 0x5c025800, 0x1c01f000, 0x59325808, - 0x592c0204, 0x82000580, 0x00000152, 0x1c01f000, - 0x5930001f, 0x80000540, 0x02020800, 0x00100d56, - 0x1c01f000, 0x4d2c0000, 0x59325808, 0x59300203, - 0x4933c857, 0x492fc857, 0x493bc857, 0x4803c857, - 0x82003480, 0x0000000e, 0x02021800, 0x001005d8, - 0x0c01f803, 0x5c025800, 0x1c01f000, 0x001095bd, - 0x001095c8, 0x00109603, 0x001095bd, 0x001095bd, - 0x001095bd, 0x001095bd, 0x001095bd, 0x001095bf, - 0x001095bd, 0x001095bd, 0x001095bd, 0x001095bd, - 0x001095bd, 0x0201f800, 0x001005d8, 0x83383480, - 0x00000056, 0x02021800, 0x001005d8, 0x493a6403, - 0x4a026203, 0x00000001, 0x0201f000, 0x0010672b, - 0x83380580, 0x00000013, 0x0402000f, 0x592c000c, - 0x800001c0, 0x04000006, 0x4a026203, 0x00000002, - 0x59a80037, 0x48026206, 0x1c01f000, 0x4a025a06, - 0x00000000, 0x0201f800, 0x000202da, 0x0201f000, - 0x0002077d, 0x83380580, 0x00000027, 0x0400001a, - 0x83380580, 0x00000014, 0x04000012, 0x83380580, - 0x00000015, 0x04000005, 0x83380580, 0x00000016, - 0x02020800, 0x001005d8, 0x0201f800, 0x00106f60, - 0x02020000, 0x00107974, 0x59300203, 0x82000580, - 0x00000002, 0x02020800, 0x001005d8, 0x0401f014, - 0x0201f800, 0x00106bbf, 0x4a02580e, 0x00000011, - 0x0401f005, 0x0201f800, 0x00106bbf, 0x4a02580e, - 0x00000010, 0x4a025a06, 0x00000031, 0x4a02580d, - 0x00000004, 0x0201f800, 0x000202da, 0x0201f800, - 0x00104c19, 0x0201f000, 0x00107911, 0x59341400, - 0x82081d00, 0x000000ff, 0x59300c03, 0x480bc857, - 0x4807c857, 0x82040580, 0x00000053, 0x0400002e, - 0x82040580, 0x00000002, 0x04000016, 0x82040580, - 0x00000001, 0x04000017, 0x82040580, 0x00000003, - 0x0400001c, 0x82040580, 0x00000005, 0x0400001d, - 0x82040580, 0x00000033, 0x0400001a, 0x82040580, - 0x00000000, 0x0400001b, 0x82040580, 0x00000004, - 0x02020800, 0x001005d8, 0x0401f8a1, 0x0401f016, - 0x820c0580, 0x00000003, 0x0400084c, 0x0401f012, - 0x820c0580, 0x0000000b, 0x0402000f, 0x42000800, - 0x00000007, 0x0201f800, 0x00104571, 0x0401f00a, - 0x820c0580, 0x00000005, 0x04000864, 0x0401f006, - 0x820c0580, 0x00000009, 0x04000889, 0x0401f002, - 0x0401f893, 0x4a026403, 0x00000052, 0x59a81016, - 0x592c040b, 0x8c000500, 0x04000003, 0x42001000, - 0x00000008, 0x592c040b, 0x8c000516, 0x04000003, - 0x82081400, 0x00000018, 0x592c000c, 0x497a580d, - 0x497a580e, 0x80080c80, 0x04000009, 0x04001005, - 0x4a025a06, 0x00000007, 0x40001000, 0x0401f006, - 0x4a025a06, 0x00000015, 0x0401f003, 0x4a025a06, - 0x00000000, 0x480a580c, 0x82081400, 0x00000003, - 0x80081104, 0x0201f800, 0x00107ab5, 0x04000010, - 0x592c1001, 0x480a600b, 0x58080800, 0x82080400, - 0x00000002, 0x592c1011, 0x592c1812, 0x42003000, - 0x00000000, 0x42002000, 0x00101200, 0x0201f800, - 0x00107c32, 0x04000002, 0x1c01f000, 0x4a025a06, - 0x0000002c, 0x497a580c, 0x0201f800, 0x000202da, - 0x0201f000, 0x0002077d, 0x83380580, 0x00000015, - 0x0402000a, 0x59a80005, 0x8c000514, 0x0402000b, - 0x0201f800, 0x0010462a, 0x42000800, 0x00000004, - 0x0201f000, 0x00104571, 0x42000800, 0x00000007, - 0x0201f000, 0x00104571, 0x0201f800, 0x0010513b, - 0x42001000, 0x00000010, 0x04020009, 0x59340002, - 0x82000500, 0x00ff0000, 0x82000580, 0x00ff0000, - 0x040007ec, 0x42001000, 0x00000008, 0x0201f800, - 0x00104c6d, 0x040007e7, 0x592c040b, 0x84000540, - 0x48025c0b, 0x0401f7e9, 0x83380580, 0x00000015, - 0x0402000f, 0x59a80005, 0x8c000514, 0x04020010, - 0x0201f800, 0x0010468d, 0x4d3c0000, 0x417a7800, - 0x0201f800, 0x00104567, 0x5c027800, 0x42000800, - 0x00000006, 0x0201f000, 0x00104571, 0x42000800, - 0x00000004, 0x0201f000, 0x00104571, 0x0201f800, - 0x0010513b, 0x42001000, 0x00000010, 0x04020009, - 0x59340002, 0x82000500, 0x00ff0000, 0x82000580, - 0x00ff0000, 0x040007e7, 0x42001000, 0x00000008, - 0x0201f800, 0x00104c6d, 0x040007e2, 0x592c040b, - 0x84000540, 0x48025c0b, 0x0401f7e9, 0x42000800, - 0x00000004, 0x0201f000, 0x00104571, 0x83380580, - 0x00000015, 0x04020005, 0x0201f800, 0x0010a2c8, - 0x02000800, 0x001048c1, 0x1c01f000, 0x83380580, - 0x00000015, 0x0402001d, 0x4c580000, 0x83cc1400, - 0x00000008, 0x4200b000, 0x00000002, 0x83341c00, - 0x00000006, 0x0201f800, 0x0010855a, 0x04020012, - 0x83cc1400, 0x0000000a, 0x4200b000, 0x00000002, - 0x83341c00, 0x00000008, 0x0201f800, 0x0010855a, - 0x04020009, 0x59342200, 0x59cc1007, 0x800811c0, - 0x04000003, 0x480a6801, 0x84102542, 0x8410251a, - 0x48126a00, 0x5c00b000, 0x1c01f000, 0x42000000, - 0x0010b87b, 0x0201f800, 0x0010aa47, 0x0201f800, - 0x00106c55, 0x59300203, 0x4933c857, 0x4803c857, - 0x82000c80, 0x0000000e, 0x02021800, 0x001005d8, - 0x0c01f803, 0x0201f000, 0x00106c4b, 0x0010970b, - 0x0010971a, 0x0010970c, 0x00109709, 0x00109709, - 0x00109709, 0x00109709, 0x00109709, 0x00109709, - 0x00109709, 0x00109709, 0x00109709, 0x00109709, - 0x00109709, 0x0201f800, 0x001005d8, 0x1c01f000, - 0x59300403, 0x82000580, 0x00000052, 0x02000000, - 0x00108d85, 0x0201f800, 0x00104c19, 0x59325808, - 0x4a025a06, 0x00000006, 0x0201f800, 0x000202da, - 0x0201f000, 0x00107911, 0x59301804, 0x840c0520, - 0x48026004, 0x598c000d, 0x81300580, 0x04020010, - 0x8c0c1d20, 0x04020010, 0x42001000, 0x0010b7f6, - 0x50081000, 0x58080002, 0x82000580, 0x00000100, - 0x0400000e, 0x5808000c, 0x81300580, 0x02020800, - 0x001005d8, 0x4978100c, 0x0401f003, 0x8c0c1d20, - 0x040207dc, 0x0201f800, 0x001068d3, 0x040007d9, - 0x0201f800, 0x001005d8, 0x0201f800, 0x00106e8e, - 0x040007f9, 0x59300203, 0x82000c80, 0x0000000e, - 0x02021800, 0x001005d8, 0x0c01f7bd, 0x4933c857, - 0x4c500000, 0x4c540000, 0x4c580000, 0x592c0c07, - 0x4806580a, 0x59cc0809, 0x48065807, 0x59cc0a08, - 0x4806580b, 0x59c80817, 0x82040500, 0x000003ff, - 0x800010c4, 0x8c040d14, 0x04000005, 0x59cc0002, - 0x82000500, 0x00000003, 0x80081480, 0x82080480, - 0x000000f1, 0x02021800, 0x001005d8, 0x480a621a, - 0x412c0800, 0x0201f800, 0x001007d3, 0x02000800, - 0x001005d8, 0x492c0809, 0x58040408, 0x84000552, - 0x84000540, 0x48000c08, 0x82081400, 0x00000003, - 0x80081104, 0x83cca400, 0x00000006, 0x832cac00, - 0x00000004, 0x42000800, 0x00000010, 0x82080480, - 0x00000010, 0x04021003, 0x40080800, 0x80000580, - 0x4004b000, 0x4c000000, 0x0201f800, 0x0010ab28, - 0x5c000000, 0x800001c0, 0x0400000d, 0x412c1000, - 0x4c000000, 0x0201f800, 0x001007d3, 0x02000800, - 0x001005d8, 0x492c1001, 0x832cac00, 0x00000004, - 0x5c000000, 0x40001000, 0x0401f7e9, 0x5c00b000, - 0x5c00a800, 0x5c00a000, 0x1c01f000, 0x4933c857, - 0x4d2c0000, 0x4c380000, 0x59325808, 0x5930021a, - 0x48025a08, 0x59301011, 0x800811c0, 0x04020008, - 0x4a025a06, 0x00000000, 0x592c000b, 0x82000500, - 0x00000c00, 0x0400000b, 0x0401f00b, 0x8c08153e, - 0x04000006, 0x4a025a06, 0x00000007, 0x80081080, - 0x80081000, 0x0401f003, 0x4a025a06, 0x00000015, - 0x480a5807, 0x42000000, 0x0010bed9, 0x50007000, - 0x5838000b, 0x80000540, 0x04020008, 0x4930700c, - 0x4930700b, 0x58380002, 0x82000580, 0x00000000, - 0x04020809, 0x0401f005, 0x82001400, 0x00000000, - 0x45301000, 0x4930700b, 0x5c007000, 0x5c025800, - 0x1c01f000, 0x4933c857, 0x592c0009, 0x40001000, - 0x4800700a, 0x82080400, 0x00000004, 0x48007003, - 0x592c000d, 0x592c100e, 0x48007007, 0x48087008, - 0x592c000a, 0x592c1208, 0x80080c80, 0x04001002, - 0x40001000, 0x82081400, 0x00000003, 0x80081104, - 0x82080480, 0x00000010, 0x04021003, 0x80000580, - 0x0401f003, 0x42001000, 0x00000010, 0x4800700d, - 0x48087004, 0x800810c4, 0x48087005, 0x40381000, - 0x0201f800, 0x00100858, 0x1c01f000, 0x4d2c0000, - 0x0201f800, 0x001007d3, 0x02000800, 0x001005d8, - 0x42000800, 0x0010bed9, 0x452c0800, 0x497a580b, - 0x497a580c, 0x497a580d, 0x4a025809, 0x001097ea, - 0x4a025802, 0x00000100, 0x4a025801, 0x00000000, - 0x5c025800, 0x1c01f000, 0x4833c857, 0x4d300000, - 0x4d2c0000, 0x4c5c0000, 0x4030b800, 0x585c000a, - 0x80025d40, 0x04020004, 0x585c000c, 0x4c000000, - 0x0401f044, 0x585c0002, 0x82000580, 0x00000100, - 0x04020022, 0x592c0801, 0x4c040000, 0x0201f800, - 0x001007f4, 0x5c000800, 0x800409c0, 0x0400001c, - 0x4804b80a, 0x585c100d, 0x800811c0, 0x04020005, - 0x40065800, 0x0201f800, 0x001007fd, 0x0401f014, - 0x82080480, 0x00000010, 0x04021003, 0x80000580, - 0x0401f003, 0x42001000, 0x00000010, 0x4800b80d, - 0x4808b804, 0x800810c4, 0x4808b805, 0x82040400, - 0x00000004, 0x4800b803, 0x405c1000, 0x0201f800, - 0x00100858, 0x0401f025, 0x0401f828, 0x585c000c, - 0x80026540, 0x59300000, 0x80000d40, 0x04020002, - 0x4800b80b, 0x4800b80c, 0x497a6000, 0x4c000000, - 0x4978b80a, 0x59325808, 0x4a025a04, 0x00000103, - 0x59300402, 0x48025c06, 0x592c100b, 0x4c080000, - 0x0201f800, 0x000202c1, 0x0201f800, 0x0010912a, - 0x5c001000, 0x8c081518, 0x04000004, 0x0201f800, - 0x001091d1, 0x0401f003, 0x0201f800, 0x0002077d, - 0x405c7000, 0x5c000000, 0x80026540, 0x04000003, - 0x59325808, 0x0401ff78, 0x5c00b800, 0x5c025800, - 0x5c026000, 0x1c01f000, 0x483bc857, 0x5838000a, - 0x40025800, 0x0201f800, 0x001007fd, 0x5838000c, - 0x80026540, 0x59300008, 0x80025d40, 0x4a025a06, - 0x00000002, 0x1c01f000, 0x4803c857, 0x4d1c0000, - 0x497a601c, 0x41323800, 0x40026000, 0x4d3c0000, - 0x42027800, 0x00000005, 0x0401f83c, 0x5c027800, - 0x411e6000, 0x59300414, 0x84000502, 0x48026414, - 0x5c023800, 0x1c01f000, 0x481bc857, 0x4933c857, - 0x4c5c0000, 0x4c600000, 0x4010b800, 0x4014c000, - 0x0201f800, 0x0010a942, 0x0201f800, 0x00103b25, - 0x04000008, 0x40602800, 0x405c3000, 0x0201f800, - 0x0010a446, 0x82000540, 0x00000001, 0x0401f002, - 0x80000580, 0x5c00c000, 0x5c00b800, 0x1c01f000, - 0x4803c856, 0x4d300000, 0x42026000, 0x0010d1c0, - 0x59a8000e, 0x81640580, 0x04000016, 0x59300c06, - 0x82040580, 0x00000001, 0x04000009, 0x82040580, - 0x00000004, 0x04000006, 0x82040580, 0x00000010, - 0x02000800, 0x00108cf9, 0x0401f005, 0x4807c857, - 0x0201f800, 0x001092d7, 0x04020808, 0x83326400, - 0x00000024, 0x41580000, 0x81300480, 0x040017e9, - 0x5c026000, 0x1c01f000, 0x4933c857, 0x59300403, - 0x4803c857, 0x0201f800, 0x00106c55, 0x4df00000, - 0x59300406, 0x4803c857, 0x82000d80, 0x00000002, - 0x04000018, 0x82000d80, 0x00000001, 0x04000009, - 0x82000d80, 0x00000004, 0x04000006, 0x4933c856, - 0x5c03e000, 0x02000800, 0x00106c4b, 0x0401f03c, - 0x59300203, 0x82000d80, 0x00000001, 0x04000018, - 0x82000d80, 0x00000002, 0x04000026, 0x82000d80, - 0x00000005, 0x04000023, 0x0201f800, 0x001005d8, - 0x59300203, 0x82000d80, 0x00000009, 0x0400000c, - 0x82000d80, 0x0000000b, 0x04000009, 0x82000d80, - 0x0000000a, 0x04000017, 0x82000d80, 0x0000000c, - 0x04000014, 0x0201f800, 0x001005d8, 0x598c000d, - 0x81300580, 0x04020004, 0x0201f800, 0x00106e8e, - 0x0402000c, 0x59300004, 0x4803c857, 0x8c000520, - 0x04000004, 0x84000520, 0x48026004, 0x0401f005, - 0x0201f800, 0x001068d3, 0x02020800, 0x001005d8, - 0x5c03e000, 0x02000800, 0x00106c4b, 0x59300406, - 0x82000d80, 0x00000002, 0x04000009, 0x0201f800, - 0x00104c19, 0x0201f800, 0x0010914e, 0x02000800, - 0x0010801c, 0x8d3e7d00, 0x04000003, 0x0201f000, - 0x00107911, 0x4a02621d, 0x00000001, 0x4a026403, - 0x00000085, 0x4a026203, 0x00000009, 0x4a026406, - 0x00000002, 0x42000800, 0x8000004b, 0x0201f000, - 0x00020721, 0x4933c857, 0x59368c03, 0x4c180000, - 0x59300203, 0x82003480, 0x0000000e, 0x02021800, - 0x001005d8, 0x0c01f803, 0x5c003000, 0x1c01f000, - 0x0010990a, 0x00109dcf, 0x00109edb, 0x0010990a, - 0x0010990a, 0x0010990a, 0x0010990a, 0x0010990a, - 0x0010992d, 0x0010990a, 0x0010990a, 0x0010990a, - 0x0010990a, 0x0010990a, 0x0201f800, 0x001005d8, - 0x4933c857, 0x42028800, 0x0000ffff, 0x813669c0, - 0x04000002, 0x59368c03, 0x4c180000, 0x59300203, - 0x82003480, 0x0000000e, 0x02021800, 0x001005d8, - 0x0c01f803, 0x5c003000, 0x1c01f000, 0x00109929, - 0x0010a180, 0x00109929, 0x00109929, 0x00109929, - 0x00109929, 0x00109929, 0x0010a952, 0x0010a0ed, - 0x0010a52c, 0x0010a562, 0x0010a52c, 0x0010a562, - 0x00109929, 0x0201f800, 0x001005d8, 0x0201f800, - 0x001005d8, 0x83383480, 0x00000051, 0x02021800, - 0x001005d8, 0x41380000, 0x493bc857, 0x4d1c0000, - 0x4d400000, 0x0c01f804, 0x5c028000, 0x5c023800, - 0x1c01f000, 0x0010998a, 0x00109b69, 0x0010998a, - 0x0010998a, 0x0010998a, 0x00109b74, 0x0010998a, - 0x0010998a, 0x0010998a, 0x0010998a, 0x0010998a, - 0x0010998a, 0x0010998a, 0x0010998a, 0x0010998a, - 0x0010998a, 0x0010998a, 0x0010998a, 0x0010998a, - 0x0010998a, 0x0010998a, 0x0010998a, 0x0010998a, - 0x001099ac, 0x001099f5, 0x00109a0c, 0x00109a62, - 0x00109ac6, 0x00109b04, 0x00109b34, 0x0010998a, - 0x0010998a, 0x00109b7c, 0x0010998a, 0x0010998a, - 0x00109b8a, 0x00109b93, 0x0010998a, 0x0010998a, - 0x0010998a, 0x0010998a, 0x0010998a, 0x00109c15, - 0x0010998a, 0x0010998a, 0x00109a9a, 0x0010998a, - 0x0010998a, 0x00109bec, 0x0010998a, 0x0010998a, - 0x0010998a, 0x00109c23, 0x0010998a, 0x0010998a, - 0x0010998a, 0x00109c6c, 0x0010998a, 0x0010998a, - 0x0010998a, 0x0010998a, 0x0010998a, 0x0010998a, - 0x00109cb9, 0x0010998a, 0x00109ce5, 0x00109cf0, - 0x0010998a, 0x0010998a, 0x0010998c, 0x00109cfb, - 0x0010998a, 0x0010998a, 0x0010998a, 0x0010999b, - 0x0010998a, 0x0010998a, 0x0010998a, 0x00109d02, - 0x00109d0a, 0x00109d28, 0x0201f800, 0x001005d8, - 0x4933c857, 0x0201f800, 0x0010a592, 0x040203a4, - 0x0201f800, 0x0010210a, 0x040203a1, 0x59cc0407, - 0x4802601c, 0x4a026403, 0x00000045, 0x4a026203, - 0x00000001, 0x0201f000, 0x0010672b, 0x4933c857, - 0x0201f800, 0x0010a592, 0x04020395, 0x0201f800, - 0x0010210a, 0x04020392, 0x0401fbce, 0x040201a0, - 0x59cc0007, 0x4802601c, 0x4a026403, 0x0000004a, - 0x4a026203, 0x00000001, 0x0201f000, 0x0010672b, - 0x4933c857, 0x0201f800, 0x0010210a, 0x04020009, - 0x0201f800, 0x001048ec, 0x04020006, 0x82000500, - 0x00000009, 0x82000580, 0x00000008, 0x04020008, - 0x4a026403, 0x00000009, 0x4a02641a, 0x00000009, - 0x4a02621a, 0x00000000, 0x0401f1b2, 0x0201f800, - 0x001048c1, 0x0201f800, 0x00104a09, 0x04000021, - 0x0201f800, 0x001049ed, 0x0400001e, 0x0201f800, - 0x0010a252, 0x04020025, 0x42028000, 0x00000029, - 0x4d3c0000, 0x417a7800, 0x0201f800, 0x0010203c, - 0x5c027800, 0x0201f800, 0x0010462a, 0x836c0580, - 0x00000002, 0x04020004, 0x59a8001b, 0x80000000, - 0x4803501b, 0x4a026403, 0x00000008, 0x42003000, - 0x00000003, 0x0201f800, 0x00103b25, 0x04000191, - 0x4a026203, 0x00000007, 0x41782800, 0x0401f180, - 0x0201f800, 0x0010a3da, 0x040207e1, 0x4a026403, - 0x00000009, 0x4a02641a, 0x0000000e, 0x4a02621a, - 0x00001900, 0x0401f183, 0x4a026403, 0x00000009, - 0x4a02641a, 0x00000003, 0x4a02621a, 0x00000f00, - 0x0401f17c, 0x4933c857, 0x0201f800, 0x0010210a, - 0x0402033b, 0x0201f800, 0x001048ec, 0x04020338, - 0x493a6403, 0x0201f800, 0x0010a22d, 0x04020006, - 0x42003000, 0x00000005, 0x4a026403, 0x00000006, - 0x0401f7d9, 0x4a026403, 0x00000007, 0x4a02641a, - 0x00000009, 0x4a02621a, 0x00000000, 0x0401f165, - 0x4933c857, 0x0201f800, 0x001048ec, 0x04020324, - 0x0201f800, 0x0010a592, 0x02000800, 0x0010210a, - 0x0402031f, 0x0201f800, 0x00104a09, 0x04020005, - 0x42027800, 0x00000001, 0x0201f800, 0x00104567, - 0x0201f800, 0x001049fc, 0x0402002b, 0x59cc0206, - 0x82003500, 0x00000003, 0x0402002e, 0x82003480, - 0x00000014, 0x0400102b, 0x5934300a, 0x84183516, - 0x82000580, 0x00000014, 0x04020002, 0x84183556, - 0x481a680a, 0x59cc0406, 0x82000500, 0x00000003, - 0x04020020, 0x0201f800, 0x0010a29f, 0x04020028, - 0x0201f800, 0x001049e7, 0x0402000c, 0x417a7800, - 0x0201f800, 0x001020a1, 0x42003000, 0x00000006, - 0x0201f800, 0x0010a93a, 0x42000000, 0x0010b865, - 0x0201f800, 0x0010aa47, 0x0201f800, 0x0010468d, - 0x4a026403, 0x0000000a, 0x42003000, 0x00000020, - 0x0401f795, 0x4a026403, 0x0000000b, 0x4a02641a, - 0x00000009, 0x4a02621a, 0x00001e00, 0x0401f121, - 0x42000000, 0x0010b860, 0x0201f800, 0x0010aa47, - 0x4a026403, 0x0000000b, 0x4a02641a, 0x00000007, - 0x4a02621a, 0x00000000, 0x0401f116, 0x4a026403, - 0x0000000b, 0x4a02641a, 0x00000003, 0x4a02621a, - 0x00000000, 0x0401f10f, 0x4933c857, 0x0201f800, - 0x001048ec, 0x040202ce, 0x0201f800, 0x0010a592, - 0x040202cb, 0x0201f800, 0x0010210a, 0x040202c8, - 0x59cc0206, 0x82003500, 0x00000003, 0x0402001d, - 0x82003480, 0x00000014, 0x0400101a, 0x59cc0406, - 0x82000500, 0x00000003, 0x04020016, 0x59340400, - 0x82000580, 0x00000707, 0x04000019, 0x417a7800, - 0x0201f800, 0x001020a1, 0x42003000, 0x0000000a, - 0x0201f800, 0x0010a93a, 0x42000000, 0x0010b862, - 0x0201f800, 0x0010aa47, 0x4a026403, 0x0000000c, - 0x41782800, 0x42003000, 0x00000021, 0x0401f752, - 0x4a026403, 0x0000000d, 0x4a02641a, 0x00000007, - 0x4a02621a, 0x00000000, 0x0401f0de, 0x4a026403, - 0x0000000d, 0x4a02641a, 0x00000009, 0x4a02621a, - 0x00001e00, 0x0401f0d7, 0x4933c857, 0x0201f800, - 0x001048ec, 0x04020296, 0x0201f800, 0x0010a592, - 0x04020293, 0x0201f800, 0x0010210a, 0x04020290, - 0x0401facc, 0x0402001a, 0x493a6403, 0x4c5c0000, - 0x0401fad2, 0x0402000e, 0x4a026403, 0x0000002e, - 0x405c2800, 0x42003000, 0x00000024, 0x0201f800, - 0x00103b25, 0x0400000c, 0x4a026203, 0x00000007, - 0x405c2800, 0x5c00b800, 0x0401f0ad, 0x4a026403, - 0x0000000d, 0x4a02641a, 0x00000007, 0x4a02621a, - 0x00000000, 0x5c00b800, 0x0401f0b2, 0x4a026403, - 0x0000000d, 0x4a02641a, 0x00000009, 0x4a02621a, - 0x00001e00, 0x0401f0ab, 0x4933c857, 0x0201f800, - 0x001048ec, 0x040206ef, 0x59a80026, 0x82000500, - 0x00000009, 0x82000580, 0x00000008, 0x040006e9, - 0x0201f800, 0x001049fc, 0x0402002d, 0x0201f800, - 0x0010a2a7, 0x04020007, 0x4a026403, 0x0000000e, - 0x41782800, 0x42003000, 0x00000052, 0x0401f702, - 0x4933c857, 0x42003000, 0x00000003, 0x0201f800, - 0x0010a942, 0x4d3c0000, 0x417a7800, 0x0201f800, - 0x0010203c, 0x5c027800, 0x42000000, 0x0010b864, - 0x0201f800, 0x0010aa47, 0x59340200, 0x84000558, - 0x48026a00, 0x42000800, 0x0000000b, 0x0201f800, - 0x00104571, 0x0201f800, 0x00103b25, 0x04000076, - 0x42003000, 0x00000007, 0x0401f062, 0x4933c857, - 0x4a026403, 0x0000000f, 0x4a02641a, 0x00000003, - 0x4a02621a, 0x00001e00, 0x0401f072, 0x59340400, - 0x82000580, 0x00000703, 0x040007f5, 0x0401f040, - 0x4933c857, 0x0201f800, 0x001048ec, 0x0402022c, - 0x59a80026, 0x82000500, 0x00000009, 0x82000580, - 0x00000008, 0x04000226, 0x0201f800, 0x001049f3, - 0x0402002f, 0x0201f800, 0x0010a2c8, 0x02000800, - 0x0010a252, 0x04020007, 0x4a026403, 0x00000010, - 0x41782800, 0x42003000, 0x00000050, 0x0401f6c2, - 0x4d3c0000, 0x417a7800, 0x0201f800, 0x0010203c, - 0x5c027800, 0x42003000, 0x00000003, 0x0201f800, - 0x0010a942, 0x42000000, 0x0010b864, 0x0201f800, - 0x0010aa47, 0x59340200, 0x84000558, 0x48026a00, - 0x0401f7c5, 0x4a026403, 0x00000011, 0x4a02641a, - 0x00000003, 0x4a02621a, 0x00001e00, 0x0401f03d, - 0x4933c857, 0x0201f800, 0x0010210a, 0x02000800, - 0x0010a592, 0x040201fa, 0x0401fa36, 0x04020008, - 0x4a026403, 0x00000012, 0x0401f032, 0x59340400, - 0x82000580, 0x00000703, 0x040007eb, 0x4d3c0000, - 0x417a7800, 0x42028000, 0x00000029, 0x0201f800, - 0x0010203c, 0x5c027800, 0x42003000, 0x00000017, - 0x0201f800, 0x0010a942, 0x42000000, 0x0010b864, - 0x0201f800, 0x0010aa47, 0x0201f800, 0x00103b25, - 0x04000015, 0x42003000, 0x00000006, 0x41782800, - 0x42028000, 0x00000029, 0x4933c857, 0x4a026403, - 0x00000001, 0x4a026203, 0x00000007, 0x0201f800, - 0x0010a974, 0x0201f000, 0x0010a43e, 0x42028000, - 0x00000046, 0x0201f800, 0x0010a974, 0x0201f000, - 0x0010a43e, 0x4933c857, 0x4a026403, 0x00000001, - 0x42000800, 0x0000000b, 0x0201f800, 0x00104571, - 0x4a026203, 0x00000001, 0x0201f000, 0x0010672b, - 0x4933c857, 0x42000800, 0x00000009, 0x0201f800, - 0x00104571, 0x4a026403, 0x00000005, 0x0401f7f5, - 0x0201f800, 0x0010a592, 0x040201b5, 0x0201f800, - 0x0010210a, 0x040201b2, 0x0401f9ee, 0x040207c0, - 0x4a026403, 0x00000020, 0x4a026203, 0x00000001, - 0x0201f000, 0x0010672b, 0x0201f800, 0x0010210a, - 0x040201a7, 0x4a026403, 0x00000023, 0x4a026203, - 0x00000001, 0x0201f000, 0x0010672b, 0x0201f800, - 0x0010a592, 0x02000800, 0x0010210a, 0x0402019c, - 0x0401f9d8, 0x040207aa, 0x40300800, 0x59a81010, - 0x59cc0007, 0x82000500, 0x00ffffff, 0x80080580, - 0x04000019, 0x59cc1408, 0x0201f800, 0x0010902c, - 0x0400002d, 0x59cc0c08, 0x4d300000, 0x0201f800, - 0x00105dd7, 0x41323800, 0x5c026000, 0x04000026, - 0x591c0202, 0x82000580, 0x0000ffff, 0x04000005, - 0x59cc1208, 0x591c0202, 0x80080580, 0x0402001e, - 0x591c0406, 0x82000580, 0x00000007, 0x0402001a, - 0x0401f02c, 0x59cc1208, 0x82080580, 0x0000ffff, - 0x0400000c, 0x0201f800, 0x00109410, 0x04000012, - 0x59cc1408, 0x591c0202, 0x80080580, 0x0402000e, - 0x591c0009, 0x81340580, 0x04000016, 0x0401f00a, - 0x59cc1408, 0x417a7800, 0x0201f800, 0x0010a405, - 0x04020010, 0x59cc1208, 0x82080580, 0x0000ffff, - 0x04000019, 0x4a026403, 0x00000026, 0x4a02621a, - 0x00001700, 0x59cc1204, 0x82081580, 0x0000ffff, - 0x04020798, 0x4a026403, 0x00000025, 0x0401f795, - 0x591c0406, 0x82000580, 0x00000007, 0x040207f2, - 0x591c0403, 0x82000580, 0x00000024, 0x04020006, - 0x4d300000, 0x411e6000, 0x0201f800, 0x0002077d, - 0x5c026000, 0x4a026403, 0x00000025, 0x0401f785, - 0x4933c857, 0x4d3c0000, 0x42027800, 0x00000001, - 0x0201f800, 0x00104567, 0x5c027800, 0x4c580000, - 0x4200b000, 0x00000002, 0x83a81c00, 0x00000002, - 0x83cc1400, 0x0000000b, 0x0201f800, 0x0010855a, - 0x5c00b000, 0x04000004, 0x4a026403, 0x00000031, - 0x0401f770, 0x0201f800, 0x00107911, 0x0201f800, - 0x0010513b, 0x0402000f, 0x0201f800, 0x00105149, - 0x04020008, 0x4a035033, 0x00000001, 0x4202d800, - 0x00000001, 0x0201f800, 0x001050a2, 0x0401f005, - 0x42000000, 0x00000001, 0x0201f800, 0x00105113, - 0x1c01f000, 0x0201f800, 0x0010210a, 0x0402011c, - 0x0401f958, 0x0402072a, 0x493a6403, 0x0401f996, - 0x04020004, 0x4a026403, 0x0000002b, 0x0401f751, - 0x4a026403, 0x0000002c, 0x0401f74e, 0x4933c857, - 0x0201f800, 0x0010210a, 0x0402010d, 0x0201f800, - 0x001049e7, 0x04020740, 0x0201f800, 0x001048d9, - 0x0400003c, 0x59cc0408, 0x48026419, 0x59cc0208, - 0x48026219, 0x59cc0807, 0x59340002, 0x82000500, - 0x00ffffff, 0x80040580, 0x04000012, 0x59a80010, - 0x80040580, 0x04020021, 0x59cc1408, 0x0201f800, - 0x00109410, 0x04000023, 0x0201f800, 0x0010a4ca, - 0x04000020, 0x0201f800, 0x0010a921, 0x0400001d, - 0x491e601e, 0x4a026403, 0x00000036, 0x0401f0e6, - 0x59cc1208, 0x82080580, 0x0000ffff, 0x04000009, - 0x0201f800, 0x00109410, 0x04000012, 0x591c0202, - 0x59cc0c08, 0x80040580, 0x0402000e, 0x0401f7eb, - 0x59cc1408, 0x41327800, 0x0201f800, 0x0010a405, - 0x04000008, 0x0401f7e5, 0x4803c856, 0x4a02641a, - 0x00000009, 0x4a02621a, 0x00001500, 0x0401f006, - 0x4803c856, 0x4a02641a, 0x00000003, 0x4a02621a, - 0x00001700, 0x4a026403, 0x00000037, 0x0401f0c6, - 0x4803c856, 0x4a026403, 0x00000012, 0x0401f0c2, - 0x4933c857, 0x0201f800, 0x0010210a, 0x040200c4, - 0x0201f800, 0x001049e7, 0x040206f7, 0x0201f800, - 0x001048d9, 0x0400003e, 0x59cc0407, 0x48026419, - 0x59cc1207, 0x480a6219, 0x82080580, 0x0000ffff, - 0x04000005, 0x0201f800, 0x00109410, 0x0400002c, - 0x0401f006, 0x59cc1407, 0x41327800, 0x0201f800, - 0x0010a405, 0x04000026, 0x59cc0c07, 0x591c0202, - 0x80040580, 0x04020022, 0x4d300000, 0x411e6000, - 0x0201f800, 0x00108bd7, 0x5c026000, 0x59cc0c09, - 0x82040d00, 0x0000ff00, 0x840409c0, 0x0201f800, - 0x0010a921, 0x04000016, 0x82040580, 0x00000001, - 0x0400000a, 0x82040580, 0x00000005, 0x04000004, - 0x82040580, 0x00000007, 0x04020007, 0x591c0008, - 0x80000540, 0x04000004, 0x59cc2808, 0x0201f000, - 0x0010a4de, 0x4803c856, 0x4a02641a, 0x00000009, - 0x4a02621a, 0x00002a00, 0x0401f006, 0x4803c856, - 0x4a02641a, 0x00000003, 0x4a02621a, 0x00000300, - 0x4a026403, 0x0000003b, 0x0401f07b, 0x4803c856, - 0x4a02641a, 0x0000000b, 0x4a02621a, 0x00000000, - 0x0401f7f8, 0x4c080000, 0x0201f800, 0x001048ec, - 0x04000026, 0x0201f800, 0x001048c1, 0x0201f800, - 0x0010a601, 0x0402001e, 0x59a80026, 0x82000540, - 0x00000003, 0x48035026, 0x59a8001d, 0x800000d0, - 0x59a80810, 0x82040d00, 0x000000ff, 0x80041540, - 0x480b5010, 0x42000800, 0x00000003, 0x0201f800, - 0x00106c78, 0x497b5028, 0x0201f800, 0x00103b25, - 0x04000003, 0x4a032804, 0x000007d0, 0x8c00050a, - 0x0402000a, 0x0201f800, 0x0002077d, 0x0201f800, - 0x00101e45, 0x5c001000, 0x1c01f000, 0x0201f800, - 0x0010a623, 0x0401f7fc, 0x5c001000, 0x0201f000, - 0x0002077d, 0x0201f800, 0x0010210a, 0x0402004c, - 0x0201f800, 0x0010a628, 0x4a026403, 0x00000047, - 0x4a026203, 0x00000001, 0x0201f000, 0x0010672b, - 0x0201f800, 0x0010210a, 0x04020041, 0x0201f800, - 0x0010a628, 0x4a026403, 0x00000047, 0x4a026203, - 0x00000001, 0x0201f000, 0x0010672b, 0x0201f800, - 0x0010210a, 0x04020036, 0x0201f800, 0x0010a628, - 0x0201f000, 0x0002077d, 0x0401f834, 0x04000030, - 0x4a026403, 0x0000004e, 0x4a026203, 0x00000001, - 0x0201f000, 0x0010672b, 0x4a026403, 0x0000004f, - 0x497a601c, 0x59cc0a06, 0x82040d00, 0x000000ff, - 0x800409c0, 0x0400065f, 0x82040580, 0x00000001, - 0x04020005, 0x59cc0808, 0x59a80005, 0x80040580, - 0x04000658, 0x82040580, 0x00000002, 0x0402000a, - 0x83cc1400, 0x0000000b, 0x4200b000, 0x00000002, - 0x83341c00, 0x00000006, 0x0201f800, 0x0010855a, - 0x0400064c, 0x4a02601c, 0x00000001, 0x0401f649, - 0x4a026403, 0x00000050, 0x59cc0207, 0x4802601c, - 0x0401f644, 0x4a026203, 0x00000001, 0x42000800, - 0x80000040, 0x0201f000, 0x00020721, 0x4803c857, - 0x0201f000, 0x0002077d, 0x4d2c0000, 0x4c500000, - 0x4c580000, 0x4c540000, 0x59a80016, 0x82000c80, - 0x00000829, 0x04021029, 0x0201f800, 0x001007d3, - 0x04000026, 0x492e6008, 0x59a80016, 0x80000104, - 0x48025802, 0x83cca400, 0x00000006, 0x82000c80, - 0x0000000b, 0x04001013, 0x4a025811, 0x0000000b, - 0x4200b000, 0x0000000b, 0x832c0400, 0x00000005, - 0x4000a800, 0x0201f800, 0x0010ab17, 0x412c7000, - 0x0201f800, 0x001007d3, 0x04000010, 0x492c7001, - 0x40040000, 0x800409c0, 0x04000009, 0x0401f7ec, - 0x48025811, 0x4000b000, 0x832c0400, 0x00000005, - 0x4000a800, 0x0201f800, 0x0010ab17, 0x82000540, - 0x00000001, 0x0401f006, 0x497b5016, 0x59325808, - 0x0201f800, 0x001007fd, 0x80000580, 0x5c00a800, - 0x5c00b000, 0x5c00a000, 0x5c025800, 0x1c01f000, - 0x4d340000, 0x59326809, 0x59343400, 0x4933c857, - 0x4937c857, 0x481bc857, 0x0201f800, 0x001049f3, - 0x5c026800, 0x1c01f000, 0x4933c857, 0x4c5c0000, - 0x4d3c0000, 0x0401f840, 0x0402002c, 0x59cc0207, - 0x82000d00, 0x0000ff00, 0x900411c0, 0x59cc000a, - 0x82000500, 0x00ffffff, 0x80081540, 0x480a601c, - 0x8c040d18, 0x0400000e, 0x42003000, 0x00000008, - 0x0201f800, 0x0010a932, 0x42000000, 0x0010b863, - 0x0201f800, 0x0010aa47, 0x4200b800, 0x00000002, - 0x42027800, 0x00000001, 0x0401f011, 0x4178b800, - 0x8c040d1a, 0x04000011, 0x59cc000a, 0x0201f800, - 0x00105c9a, 0x0402000d, 0x42003000, 0x00000009, - 0x0201f800, 0x0010a93a, 0x42000000, 0x0010b863, - 0x0201f800, 0x0010aa47, 0x417a7800, 0x0201f800, - 0x001020a1, 0x0401f004, 0x82000540, 0x00000001, - 0x0401f002, 0x80000580, 0x5c027800, 0x5c00b800, - 0x1c01f000, 0x4933c857, 0x59cc0206, 0x82000480, - 0x00000010, 0x04021006, 0x4a02621a, 0x00000000, - 0x82000540, 0x00000001, 0x0401f002, 0x80000580, - 0x1c01f000, 0x4933c857, 0x4a02621a, 0x00000000, - 0x59cc0407, 0x82000500, 0x0000ff00, 0x82000580, - 0x00000800, 0x04020009, 0x59cc0006, 0x82000500, - 0x00ff0000, 0x82000d80, 0x00140000, 0x04000003, - 0x82000d80, 0x00100000, 0x1c01f000, 0x4933c857, - 0x59300403, 0x82003480, 0x00000051, 0x02021800, - 0x001005d8, 0x83383580, 0x00000013, 0x04020003, - 0x4803c857, 0x0c01f012, 0x83383580, 0x00000027, - 0x04000005, 0x83383580, 0x00000014, 0x02020800, - 0x001005d8, 0x0201f800, 0x001048c1, 0x42000800, - 0x00000007, 0x0201f800, 0x00104571, 0x0201f800, - 0x00106bbf, 0x0201f000, 0x00107911, 0x00109e3c, - 0x00109e45, 0x00109e3c, 0x00109e3c, 0x00109e3c, - 0x00109e45, 0x00109e50, 0x00109ecd, 0x00109e95, - 0x00109ecd, 0x00109ead, 0x00109ecd, 0x00109ebe, - 0x00109ecd, 0x00109ec6, 0x00109ecd, 0x00109ec6, - 0x00109ecd, 0x00109ecd, 0x00109e3c, 0x00109e3c, - 0x00109e3c, 0x00109e3c, 0x00109e3c, 0x00109e3c, - 0x00109e3c, 0x00109e3c, 0x00109e3c, 0x00109e3c, - 0x00109e3c, 0x00109e45, 0x00109e3c, 0x00109ecd, - 0x00109e3c, 0x00109e3c, 0x00109ecd, 0x00109e3c, - 0x00109eca, 0x00109ecd, 0x00109e3c, 0x00109e3c, - 0x00109e3c, 0x00109e3c, 0x00109ecd, 0x00109ecd, - 0x00109e3c, 0x00109ec3, 0x00109ecd, 0x00109e3c, - 0x00109e4a, 0x00109e3c, 0x00109e3c, 0x00109e3c, - 0x00109e3c, 0x00109ec9, 0x00109ecd, 0x00109e3c, - 0x00109e3c, 0x00109ecd, 0x00109ecd, 0x00109e3c, - 0x00109e3c, 0x00109e3c, 0x00109e3c, 0x00109e3c, - 0x00109e3c, 0x00109e3c, 0x00109e3c, 0x00109e3c, - 0x00109e3e, 0x00109e3c, 0x00109e3e, 0x00109e3c, - 0x00109e3c, 0x00109e3e, 0x00109e3c, 0x00109e3c, - 0x00109e3c, 0x00109e3e, 0x00109e3e, 0x00109e3e, - 0x0201f800, 0x001005d8, 0x4d2c0000, 0x59325808, - 0x0201f800, 0x001007fd, 0x5c025800, 0x0201f000, - 0x0002077d, 0x59a80037, 0x48026206, 0x4a026203, - 0x00000002, 0x1c01f000, 0x4d3c0000, 0x417a7800, - 0x0201f800, 0x00104567, 0x5c027800, 0x0401f07e, - 0x42000800, 0x00000007, 0x0201f800, 0x00104571, - 0x59a80026, 0x8c000508, 0x04000012, 0x59326809, - 0x4c580000, 0x4200b000, 0x00000002, 0x83a81c00, - 0x00000002, 0x83341400, 0x00000006, 0x0201f800, - 0x0010855a, 0x80000540, 0x5c00b000, 0x0402006a, - 0x59340200, 0x8400051a, 0x48026a00, 0x0401f01b, - 0x599c0017, 0x8c00050a, 0x04020063, 0x4d3c0000, - 0x417a7800, 0x0201f800, 0x00104567, 0x5c027800, - 0x42000800, 0x00000007, 0x0201f800, 0x00104571, - 0x59340212, 0x82000500, 0x0000ff00, 0x04000056, - 0x599c0019, 0x8c00050e, 0x04020053, 0x416c0000, - 0x82000580, 0x00000002, 0x04020004, 0x59a8001b, - 0x80000000, 0x4803501b, 0x42000800, 0x00000003, - 0x0201f800, 0x00104571, 0x4a026406, 0x00000001, - 0x4a026203, 0x00000001, 0x4a026403, 0x00000002, - 0x0201f800, 0x0010672b, 0x4ce80000, 0x4201d000, - 0x00000001, 0x0201f800, 0x00105fae, 0x5c01d000, - 0x1c01f000, 0x0201f800, 0x001049f3, 0x04000036, - 0x0201f800, 0x0010645e, 0x42000800, 0x00000004, - 0x0201f800, 0x00104571, 0x0201f800, 0x0010a96a, - 0x0402002d, 0x42000800, 0x00000005, 0x0201f800, - 0x00104571, 0x4a026406, 0x00000001, 0x4a026203, - 0x00000001, 0x4a026403, 0x00000003, 0x0201f000, - 0x0010672b, 0x42000800, 0x00000006, 0x0401f820, - 0x59303009, 0x599c0017, 0x8c00050a, 0x0402001a, - 0x59a80026, 0x8c000508, 0x04000017, 0x0201f800, - 0x001049e7, 0x04000014, 0x59a8001b, 0x80000000, - 0x4803501b, 0x0401f7c5, 0x42000800, 0x00000004, - 0x0201f800, 0x00104571, 0x0401f792, 0x42000800, - 0x00000004, 0x0401f006, 0x0201f800, 0x001048c1, - 0x0401f005, 0x0401f004, 0x0401f003, 0x0201f800, - 0x00104571, 0x0201f000, 0x0002077d, 0x4933c857, - 0x4807c857, 0x0201f800, 0x00104571, 0x4d3c0000, - 0x417a7800, 0x0201f800, 0x00104567, 0x5c027800, - 0x0201f800, 0x00102074, 0x1c01f000, 0x4933c857, - 0x59340400, 0x80000110, 0x82003480, 0x0000000c, - 0x02021800, 0x001005d8, 0x83383580, 0x00000015, - 0x04020002, 0x0c01f006, 0x83383580, 0x00000016, - 0x02020800, 0x001005d8, 0x0c01f00d, 0x001080b8, - 0x001080b8, 0x001080b8, 0x001080b8, 0x001080b8, - 0x001080b8, 0x00109f30, 0x00109f03, 0x001080b8, - 0x001080b8, 0x001080b8, 0x001080b8, 0x001080b8, - 0x001080b8, 0x001080b8, 0x001080b8, 0x001080b8, - 0x001080b8, 0x00109f30, 0x00109f37, 0x001080b8, - 0x001080b8, 0x001080b8, 0x001080b8, 0x4933c857, - 0x599c0017, 0x8c00050a, 0x0402001b, 0x813669c0, - 0x04000019, 0x59340212, 0x82000500, 0x0000ff00, - 0x04000015, 0x599c0019, 0x8c00050e, 0x04020012, - 0x4d3c0000, 0x417a7800, 0x0201f800, 0x00104567, - 0x5c027800, 0x42000800, 0x00000003, 0x0201f800, - 0x00104571, 0x4a026406, 0x00000001, 0x4a026203, - 0x00000001, 0x4a026403, 0x00000002, 0x0201f000, - 0x0010672b, 0x59cc0001, 0x0201f800, 0x00105c9a, - 0x0402000b, 0x0201f800, 0x00020245, 0x02020000, - 0x0002077d, 0x59345002, 0x0201f800, 0x001042b4, - 0x482a6802, 0x0201f000, 0x0002077d, 0x1c01f000, - 0x4933c857, 0x59303403, 0x82183580, 0x0000001e, - 0x02000000, 0x0002077d, 0x1c01f000, 0x4933c857, - 0x0201f800, 0x001083df, 0x02020000, 0x0002077d, - 0x4a026203, 0x00000001, 0x4a026403, 0x00000001, - 0x0201f000, 0x0010672b, 0x493bc857, 0x83380580, - 0x00000051, 0x0402000b, 0x0201f800, 0x00106f60, - 0x02020000, 0x00107974, 0x59300203, 0x82000580, - 0x00000002, 0x0400006d, 0x0201f800, 0x001005d8, - 0x83380580, 0x00000027, 0x04000014, 0x83380580, - 0x00000048, 0x04000006, 0x83380580, 0x00000014, - 0x0400000e, 0x02020800, 0x001005d8, 0x0201f800, - 0x00106f60, 0x02020000, 0x00107974, 0x59300203, - 0x82000580, 0x00000004, 0x02000000, 0x0002086e, - 0x0201f800, 0x001005d8, 0x59300403, 0x82000c80, - 0x00000044, 0x02021800, 0x001005d8, 0x82000480, - 0x00000040, 0x02001800, 0x001005d8, 0x40027000, - 0x4803c857, 0x0c01f001, 0x00109f76, 0x00109f78, - 0x00109f78, 0x00109f93, 0x0201f800, 0x001005d8, - 0x0201f800, 0x00106bbf, 0x59325808, 0x812e59c0, - 0x04000016, 0x832c0500, 0x00ff0000, 0x04000013, - 0x4a026203, 0x00000002, 0x59326809, 0x59340200, - 0x8c00050e, 0x0402000d, 0x42028000, 0x00000004, - 0x0201f800, 0x0010a3ef, 0x497a6008, 0x59300206, - 0x80000540, 0x04020003, 0x59a80038, 0x48026206, - 0x4a026203, 0x00000007, 0x1c01f000, 0x0201f800, - 0x00106bbf, 0x0201f800, 0x00109037, 0x02000000, - 0x00107911, 0x59325808, 0x0201f800, 0x001007f4, - 0x0201f000, 0x00107911, 0x0201f800, 0x001005d8, - 0x59325808, 0x592c040a, 0x8c000502, 0x04000007, - 0x4a026203, 0x00000007, 0x42027000, 0x00000043, - 0x0201f000, 0x000207a1, 0x4a026203, 0x00000004, - 0x1c01f000, 0x0201f800, 0x0010a597, 0x02000000, - 0x0002086c, 0x1c01f000, 0x4a026203, 0x00000001, - 0x4a026403, 0x00000041, 0x42027800, 0x80002042, - 0x0201f000, 0x00020721, 0x83380580, 0x00000051, - 0x04000006, 0x83380580, 0x00000041, 0x02020800, - 0x001005d8, 0x1c01f000, 0x0201f800, 0x000206fd, - 0x0201f800, 0x0010a5df, 0x0201f000, 0x0002077d, - 0x83380480, 0x00000050, 0x02021800, 0x001005d8, - 0x83380480, 0x00000049, 0x02001800, 0x001005d8, - 0x0c01f001, 0x00109fda, 0x00109ffb, 0x00109fd8, - 0x00109fd8, 0x00109fd8, 0x00109fd8, 0x00109ffb, - 0x0201f800, 0x001005d8, 0x59325808, 0x592c040a, - 0x8c00051e, 0x0400000d, 0x82000d00, 0x000000c0, - 0x82040d80, 0x00000080, 0x0400000d, 0x59300804, - 0x8c040d18, 0x0402000a, 0x42027000, 0x00000041, - 0x0201f000, 0x0002088d, 0x4a026203, 0x00000007, - 0x497a6206, 0x0201f000, 0x000206fd, 0x59325808, - 0x592c0c0a, 0x8c040d1a, 0x04020005, 0x0201f800, - 0x000206fd, 0x0201f000, 0x0002077d, 0x0201f800, - 0x0010a597, 0x040007fa, 0x1c01f000, 0x0201f800, - 0x00106b8a, 0x59325808, 0x59326809, 0x59340200, - 0x8c00050e, 0x0400000e, 0x592c040a, 0x82000500, - 0x000000c0, 0x82000580, 0x00000080, 0x04000005, - 0x592c000f, 0x59301815, 0x800c1c80, 0x480e6015, - 0x4a026203, 0x00000002, 0x0401f00d, 0x42028000, - 0x00000004, 0x0401fbde, 0x59300206, 0x80000540, - 0x04020004, 0x59a80038, 0x800000c2, 0x48026206, - 0x497a6008, 0x4a026203, 0x00000007, 0x1c01f000, - 0x4a026203, 0x00000007, 0x497a6206, 0x0201f000, - 0x000206fd, 0x4a026203, 0x00000007, 0x497a6206, - 0x0201f000, 0x000206f8, 0x59300414, 0x8c00051c, - 0x02020000, 0x0002087e, 0x59325808, 0x592c200f, - 0x40080000, 0x80102480, 0x59300015, 0x80102400, - 0x48126015, 0x0201f000, 0x0002087e, 0x8c040d0e, - 0x0402000a, 0x4a026203, 0x00000006, 0x0401f823, - 0x5930001f, 0x80000540, 0x02020800, 0x00100d7c, - 0x0201f000, 0x000206f8, 0x4a026203, 0x00000002, - 0x1c01f000, 0x42000800, 0x00000001, 0x0201f800, - 0x00100d7c, 0x82040580, 0x00000001, 0x02000000, - 0x00020885, 0x0401f7d8, 0x59300414, 0x8c00051c, - 0x04000006, 0x0201f800, 0x00100b63, 0x02000000, - 0x00020877, 0x1c01f000, 0x59300011, 0x80000540, - 0x04020005, 0x0201f800, 0x00100b63, 0x02000000, - 0x00020877, 0x1c01f000, 0x492fc857, 0x480bc857, - 0x8c08153e, 0x04000006, 0x80081080, 0x80081000, - 0x42000800, 0x00000009, 0x0401f003, 0x42000800, - 0x00000015, 0x480a580b, 0x1c01f000, 0x83380580, - 0x00000013, 0x04000005, 0x83380580, 0x00000014, - 0x02020800, 0x001005d8, 0x59300414, 0x8c000516, - 0x02000800, 0x001005d8, 0x1c01f000, 0x0201f800, - 0x001005d8, 0x59300008, 0x80000540, 0x02020800, - 0x001005d8, 0x1c01f000, 0x59300414, 0x8c000516, - 0x02000800, 0x001005d8, 0x1c01f000, 0x4a026203, - 0x00000004, 0x493a6403, 0x42000800, 0x80002001, - 0x0201f000, 0x00020721, 0x4a026203, 0x00000003, - 0x493a6403, 0x0201f800, 0x000200c9, 0x59325808, - 0x592c040a, 0x8c00051e, 0x04000012, 0x82000500, - 0x000000c0, 0x82000580, 0x00000080, 0x04000011, - 0x59300414, 0x8c000512, 0x0402000a, 0x8c000510, - 0x04020008, 0x592c040c, 0x80000540, 0x04020005, - 0x82080d40, 0x80003065, 0x0201f000, 0x00106721, - 0x82080d40, 0x80002065, 0x0201f000, 0x00106721, - 0x82080d40, 0x80002042, 0x0201f000, 0x00106721, - 0x4933c857, 0x493bc857, 0x83380480, 0x00000044, - 0x02021800, 0x001005d8, 0x83380480, 0x00000041, - 0x02001800, 0x001005d8, 0x0c01f001, 0x0010a0b6, - 0x0010a0c6, 0x0010a0db, 0x59325808, 0x592c040a, - 0x8c00051e, 0x0400001d, 0x82001d00, 0x000000c0, - 0x820c1d80, 0x000000c0, 0x04000018, 0x4a026203, - 0x00000001, 0x493a6403, 0x42000800, 0x80002042, - 0x0201f000, 0x00020721, 0x59325808, 0x592c040a, - 0x8c00051e, 0x0400000d, 0x82001d00, 0x000000c0, - 0x820c1d80, 0x000000c0, 0x04000008, 0x4a026203, - 0x00000001, 0x493a6403, 0x42000800, 0x80002001, - 0x0201f000, 0x00020721, 0x497a6008, 0x497a6206, - 0x42028000, 0x00000004, 0x0401f315, 0x59325808, - 0x592c040a, 0x8c00051e, 0x040007f8, 0x82001d00, - 0x000000c0, 0x820c1d80, 0x000000c0, 0x040007f3, - 0x4a026203, 0x00000003, 0x493a6403, 0x0201f800, - 0x000200c9, 0x82080d40, 0x80002065, 0x0201f000, - 0x00106721, 0x4933c857, 0x493bc857, 0x83380580, - 0x00000085, 0x04000006, 0x83380580, 0x00000088, - 0x0400000a, 0x0201f800, 0x001005d8, 0x4a026203, - 0x00000009, 0x493a6403, 0x42000800, 0x8000004b, - 0x0201f000, 0x00020721, 0x4d1c0000, 0x813669c0, - 0x04000004, 0x0201f800, 0x0010a592, 0x04020044, - 0x59cc1404, 0x0401f846, 0x04000018, 0x591c0406, - 0x82000500, 0x0000001f, 0x82002580, 0x00000006, - 0x04000007, 0x82002580, 0x00000004, 0x0400002e, - 0x82002580, 0x00000011, 0x0402000c, 0x497a3a05, - 0x42002000, 0x00000054, 0x0201f800, 0x00107a4a, - 0x4a026203, 0x00000007, 0x493a6403, 0x0201f800, - 0x0010a974, 0x0401f02c, 0x0201f800, 0x00103b25, - 0x04000004, 0x42023800, 0xffffffff, 0x0401f7f1, - 0x813669c0, 0x04020009, 0x59cc0001, 0x0201f800, - 0x00105c9a, 0x0402001e, 0x0201f800, 0x001045a6, - 0x0402001b, 0x49366009, 0x4a026403, 0x00000087, - 0x59cc1204, 0x82081580, 0x0000ffff, 0x04020003, - 0x4a026403, 0x00000086, 0x4a026203, 0x00000001, - 0x42000800, 0x80000040, 0x0201f800, 0x00020721, - 0x0401f00d, 0x591c0203, 0x82000580, 0x00000007, - 0x040207de, 0x4d300000, 0x411e6000, 0x0201f800, - 0x00107911, 0x5c026000, 0x0401f7d8, 0x0201f800, - 0x00107911, 0x5c023800, 0x1c01f000, 0x4933c857, - 0x480bc857, 0x42002800, 0x0010d1c0, 0x41300000, - 0x80140580, 0x04000017, 0x58140203, 0x82000580, - 0x00000000, 0x04000013, 0x58140202, 0x80080580, - 0x04020010, 0x58141c06, 0x820c0580, 0x00000005, - 0x0400000c, 0x820c0580, 0x00000009, 0x0400001d, - 0x59302009, 0x58140009, 0x800001c0, 0x0400000b, - 0x801021c0, 0x04000003, 0x80100580, 0x04000010, - 0x82142c00, 0x00000024, 0x41540000, 0x80140480, - 0x0402100e, 0x0401f7e2, 0x5814001e, 0x801021c0, - 0x04000005, 0x58102002, 0x82102500, 0x00ffffff, - 0x0401f7f2, 0x5810201e, 0x0401f7f0, 0x40163800, - 0x81300540, 0x0401f002, 0x80000580, 0x1c01f000, - 0x58141807, 0x8c0c1d10, 0x040207ea, 0x0401f7e1, - 0x4933c857, 0x493bc857, 0x83380580, 0x00000013, - 0x0402000e, 0x59300403, 0x82000c80, 0x00000085, - 0x02001800, 0x001005d8, 0x82000c80, 0x00000093, - 0x02021800, 0x001005d8, 0x82000480, 0x00000085, - 0x4803c857, 0x0c01f018, 0x83380580, 0x00000027, - 0x04000005, 0x83380580, 0x00000014, 0x02020000, - 0x00107974, 0x0201f800, 0x00106bbf, 0x59325808, - 0x812e59c0, 0x02000000, 0x00107911, 0x4a025a06, - 0x00000031, 0x4a025811, 0x00000004, 0x4a025812, - 0x000000ff, 0x0201f800, 0x000202da, 0x0201f000, - 0x00107911, 0x0010a1b7, 0x0010a1be, 0x0010a1be, - 0x0010a1b7, 0x0010a1b7, 0x0010a1b7, 0x0010a1b7, - 0x0010a1b7, 0x0010a1b7, 0x0010a1b7, 0x0010a1b7, - 0x0010a1b7, 0x0010a1b7, 0x0010a1b9, 0x0201f800, - 0x001005d8, 0x59325808, 0x4a025a06, 0x00000000, - 0x0201f800, 0x000202da, 0x0201f000, 0x00107911, - 0x4933c857, 0x42000000, 0x0010b873, 0x0201f800, - 0x0010aa47, 0x0201f800, 0x0010a5df, 0x497a6205, - 0x42028000, 0x0000000b, 0x0401f807, 0x4a026406, - 0x00000006, 0x4a026203, 0x00000007, 0x497a6206, - 0x1c01f000, 0x4933c857, 0x4943c857, 0x59300406, - 0x82000580, 0x00000007, 0x04020002, 0x1c01f000, - 0x0201f800, 0x00106c55, 0x4df00000, 0x0201f800, - 0x00108ce5, 0x82000c80, 0x0000000e, 0x02021800, - 0x001005d8, 0x0c01f001, 0x0010a205, 0x0010a209, - 0x0010a1f0, 0x0010a217, 0x0010a22a, 0x0010a1f0, - 0x0010a1f0, 0x0010a1f0, 0x0010a1f0, 0x0010a1f0, - 0x0010a1f0, 0x0010a1f0, 0x0010a1f0, 0x0010a1f0, - 0x4d400000, 0x5930001f, 0x80000540, 0x04000005, - 0x41400800, 0x0201f800, 0x00100d7c, 0x40068000, - 0x4d2c0000, 0x59325808, 0x0201f800, 0x00109037, - 0x040209f3, 0x4c5c0000, 0x5930b809, 0x0201f800, - 0x00107911, 0x485e6009, 0x5c00b800, 0x5c025800, - 0x5c028000, 0x5c03e000, 0x02000000, 0x00106c4b, - 0x1c01f000, 0x598c000d, 0x81300580, 0x04020004, - 0x0201f800, 0x00106e8e, 0x04020016, 0x0201f800, - 0x001068d3, 0x040007df, 0x0201f800, 0x00106b6c, - 0x04000010, 0x0201f800, 0x001005d8, 0x0201f800, - 0x00108cd6, 0x04020004, 0x0201f800, 0x00106e62, - 0x04020008, 0x0201f800, 0x001067ae, 0x040007d1, - 0x0201f800, 0x00106b6c, 0x02020800, 0x001005d8, - 0x59300203, 0x82000c80, 0x0000000e, 0x02021800, - 0x001005d8, 0x0c01f7b9, 0x0201f800, 0x00100e99, - 0x0401f7c4, 0x4933c857, 0x4d440000, 0x4d340000, - 0x59cc0007, 0x0201f800, 0x00105c9a, 0x02000800, - 0x00020245, 0x0402001a, 0x59300009, 0x4c000000, - 0x49366009, 0x42003000, 0x0000000b, 0x0201f800, - 0x0010a942, 0x42000000, 0x0010b861, 0x0201f800, - 0x0010aa47, 0x4d3c0000, 0x4d400000, 0x42028000, - 0x00000029, 0x417a7800, 0x0201f800, 0x0010203c, - 0x5c028000, 0x5c027800, 0x5c000000, 0x48026009, - 0x59cc0007, 0x48026802, 0x80000580, 0x5c026800, - 0x5c028800, 0x1c01f000, 0x4933c857, 0x4c040000, - 0x59a80016, 0x82000580, 0x00000074, 0x04020040, - 0x59cc0a08, 0x82040480, 0x00000100, 0x04001033, - 0x59cc0c08, 0x82040500, 0x00008000, 0x04000035, - 0x59a80032, 0x80000540, 0x04020009, 0x59301009, - 0x58080212, 0x82000500, 0x0000ff00, 0x04000004, - 0x82040500, 0x00000800, 0x0400002a, 0x59cc0c09, - 0x80040840, 0x04001024, 0x59a80826, 0x8c040d06, - 0x04000004, 0x59cc0c0f, 0x8c040d1e, 0x04020012, - 0x59cc0a17, 0x800409c0, 0x04020012, 0x59cc0a18, - 0x82040480, 0x00000100, 0x04001014, 0x59cc0c18, - 0x800409c0, 0x0402000e, 0x59cc0c19, 0x80040840, - 0x04001011, 0x59cc0c1a, 0x80040840, 0x04001011, - 0x0401f018, 0x4a02621a, 0x00000100, 0x0401f012, - 0x4a02621a, 0x00000300, 0x0401f00f, 0x4a02621a, - 0x00000500, 0x0401f00c, 0x4a02621a, 0x00000700, - 0x0401f009, 0x4a02621a, 0x00000900, 0x0401f006, - 0x4a02621a, 0x00000f00, 0x0401f003, 0x4a02621a, - 0x00002d00, 0x82000540, 0x00000001, 0x0401f002, - 0x80000580, 0x5c000800, 0x1c01f000, 0x59cc0407, - 0x4803c857, 0x82000580, 0x00000800, 0x04000003, - 0x4a02621a, 0x00000000, 0x1c01f000, 0x4933c857, - 0x4c040000, 0x4c080000, 0x4c0c0000, 0x4c580000, - 0x59cc000c, 0x0201f800, 0x00105c9a, 0x02000800, - 0x00020245, 0x04020012, 0x83cc1400, 0x00000008, - 0x4200b000, 0x00000002, 0x83341c00, 0x00000006, - 0x0201f800, 0x0010855a, 0x04020009, 0x83cc1400, - 0x0000000a, 0x4200b000, 0x00000002, 0x83341c00, - 0x00000008, 0x0201f800, 0x0010855a, 0x5c00b000, - 0x5c001800, 0x5c001000, 0x5c000800, 0x1c01f000, - 0x4933c857, 0x4c000000, 0x4c040000, 0x4c080000, - 0x4c0c0000, 0x4c580000, 0x59cc0001, 0x0201f800, - 0x00105c9a, 0x02000800, 0x00020245, 0x04020014, - 0x83cc1400, 0x0000000b, 0x4200b000, 0x00000002, - 0x83341c00, 0x00000006, 0x0201f800, 0x0010855a, - 0x0402000c, 0x83cc1400, 0x0000000d, 0x4200b000, - 0x00000002, 0x83341c00, 0x00000008, 0x0201f800, - 0x0010855a, 0x04000014, 0x4933c856, 0x4933c856, - 0x4933c857, 0x59340009, 0x4803c857, 0x5934000e, - 0x4803c857, 0x59340008, 0x4803c857, 0x5934000d, - 0x4803c857, 0x59340007, 0x4803c857, 0x5934000c, - 0x4803c857, 0x59340006, 0x4803c857, 0x5934000b, - 0x4803c857, 0x5c00b000, 0x5c001800, 0x5c001000, - 0x5c000800, 0x5c000000, 0x1c01f000, 0x4933c857, - 0x4947c857, 0x4943c857, 0x4c600000, 0x0201f800, - 0x00106c55, 0x4df00000, 0x4d2c0000, 0x4d300000, - 0x4d340000, 0x4130c000, 0x42026000, 0x0010d1c0, - 0x59a8000e, 0x8060c1c0, 0x04000005, 0x82601580, - 0x0010bde9, 0x04000002, 0x80000040, 0x81640480, - 0x040210be, 0x40600000, 0x81300580, 0x040000b6, - 0x0401f97a, 0x040200b4, 0x59326809, 0x59300406, - 0x82000c80, 0x00000012, 0x02021800, 0x001005d8, - 0x0c01f001, 0x0010a3cd, 0x0010a338, 0x0010a351, - 0x0010a35c, 0x0010a335, 0x0010a34c, 0x0010a387, - 0x0010a3cd, 0x0010a333, 0x0010a39a, 0x0010a3ae, - 0x0010a333, 0x0010a333, 0x0010a333, 0x0010a333, - 0x0010a3cd, 0x0010a3c4, 0x0010a3bc, 0x0201f800, - 0x001005d8, 0x59300420, 0x8c000500, 0x04020096, - 0x59300403, 0x82000580, 0x00000043, 0x04000092, - 0x0201f800, 0x00109134, 0x04000007, 0x0201f800, - 0x0010914e, 0x0402008a, 0x0201f800, 0x0010801c, - 0x0401f087, 0x0201f800, 0x00102074, 0x0201f800, - 0x0010914e, 0x02000800, 0x0010801c, 0x0401f080, - 0x8d3e7d18, 0x04000004, 0x59300420, 0x8c000500, - 0x0402007d, 0x59325808, 0x0201f800, 0x00109037, - 0x04000077, 0x49425a06, 0x497a5c09, 0x0201f800, - 0x000202da, 0x0201f800, 0x0010912a, 0x0401f070, - 0x8d3e7d00, 0x04000007, 0x59300017, 0x81480580, - 0x0402006d, 0x59300018, 0x814c0580, 0x0402006a, - 0x59300203, 0x82000580, 0x00000004, 0x02000800, - 0x00100e99, 0x59325808, 0x0201f800, 0x00109037, - 0x0400005f, 0x4a025a04, 0x00000103, 0x59300004, - 0x8400055c, 0x48026004, 0x592c0408, 0x8c000512, - 0x04000007, 0x4d2c0000, 0x592c0009, 0x40025800, - 0x0201f800, 0x001007fd, 0x5c025800, 0x49425a06, - 0x497a5c09, 0x0401fb16, 0x0201f800, 0x0010959c, - 0x0201f800, 0x001091c6, 0x0201f800, 0x000202da, - 0x0201f800, 0x0010912a, 0x0401f045, 0x8d3e7d18, - 0x04000045, 0x59300203, 0x82000580, 0x00000004, - 0x02000800, 0x00100e99, 0x59325808, 0x0201f800, - 0x00109037, 0x0400003a, 0x49425a06, 0x497a5c09, - 0x0401faff, 0x0201f800, 0x0010959c, 0x0201f800, - 0x000202da, 0x0401f032, 0x0201f800, 0x001062d5, - 0x04000031, 0x59300203, 0x82000580, 0x00000004, - 0x0400002d, 0x59300203, 0x82000580, 0x00000003, - 0x04020029, 0x0201f800, 0x00106b8a, 0x59325808, - 0x0201f800, 0x00109037, 0x04000021, 0x0201f800, - 0x000202da, 0x0401f01e, 0x59300203, 0x82000580, - 0x00000004, 0x02000800, 0x00100e99, 0x59325808, - 0x0201f800, 0x00109037, 0x04000015, 0x49425a06, - 0x497a5c09, 0x0201f800, 0x000202da, 0x0401f010, - 0x833c0500, 0x00001800, 0x0400000f, 0x8d3e7d16, - 0x0402000d, 0x59325817, 0x0201f800, 0x001007fd, - 0x59325808, 0x0201f800, 0x00109037, 0x04000004, - 0x49425a06, 0x0201f800, 0x000202da, 0x0201f800, - 0x00107911, 0x83326400, 0x00000024, 0x41580000, - 0x81300480, 0x0400173b, 0x5c026800, 0x5c026000, - 0x5c025800, 0x5c03e000, 0x02000800, 0x00106c4b, - 0x5c00c000, 0x1c01f000, 0x5c000000, 0x4c000000, - 0x4803c857, 0x4d3c0000, 0x42027800, 0x00000001, - 0x0201f800, 0x00104567, 0x5c027800, 0x4c580000, - 0x4200b000, 0x00000002, 0x83a81c00, 0x00000002, - 0x83cc1400, 0x0000000b, 0x0201f800, 0x0010855a, - 0x5c00b000, 0x80000540, 0x1c01f000, 0x492fc857, - 0x4943c857, 0x59a8000c, 0x812c0480, 0x04001011, - 0x59a8000d, 0x812c0480, 0x0402100e, 0x592c0000, - 0x80005d40, 0x04000008, 0x497a5800, 0x49425a06, - 0x4c2c0000, 0x0201f800, 0x000202da, 0x5c025800, - 0x0401f7f7, 0x49425a06, 0x0201f000, 0x000202da, - 0x1c01f000, 0x493fc857, 0x4933c857, 0x480bc857, - 0x0201f800, 0x00103b25, 0x0400002e, 0x41502800, - 0x813e79c0, 0x04020006, 0x59a80066, 0x80000000, - 0x59a8086a, 0x80040580, 0x04000026, 0x41300000, - 0x80140580, 0x0400001a, 0x58140203, 0x82000580, - 0x00000000, 0x04000016, 0x58140202, 0x80080580, - 0x04020013, 0x58141c06, 0x820c0580, 0x00000005, - 0x0400000f, 0x820c0580, 0x00000009, 0x04000017, - 0x59300009, 0x58142009, 0x801021c0, 0x04020006, - 0x5814201e, 0x59301809, 0x580c0002, 0x82000500, - 0x00ffffff, 0x80100580, 0x04000007, 0x82142c00, - 0x00000024, 0x41540000, 0x80140480, 0x04021005, - 0x0401f7df, 0x40163800, 0x81300540, 0x0401f002, - 0x80000580, 0x1c01f000, 0x58141807, 0x8c0c1d10, - 0x040207f3, 0x0401f7e7, 0x42002000, 0x0000ffff, - 0x59301009, 0x800811c0, 0x04000002, 0x58082403, - 0x41301000, 0x0401f007, 0x41781000, 0x41442000, - 0x0401f004, 0x41781000, 0x42002000, 0x0000ffff, - 0x5c000000, 0x4c000000, 0x4803c857, 0x480bc857, - 0x4813c857, 0x492fc857, 0x4943c857, 0x4d2c0000, - 0x0201f800, 0x001007e4, 0x02000800, 0x001005d8, - 0x4a025a04, 0x0000010d, 0x800811c0, 0x04000017, - 0x83400580, 0x00000029, 0x04020010, 0x82180580, - 0x00000002, 0x0400000a, 0x82180580, 0x00000003, - 0x04000007, 0x82180580, 0x00000008, 0x04000004, - 0x82180580, 0x00000009, 0x04020004, 0x4a025809, - 0xffffffff, 0x0401f002, 0x480a5809, 0x58080202, - 0x48025c13, 0x0401f005, 0x4a025809, 0xffffffff, - 0x4a025c13, 0x0000ffff, 0x49425a08, 0x48125a06, - 0x82100580, 0x0000ffff, 0x0400000e, 0x4d440000, - 0x4d340000, 0x40128800, 0x0201f800, 0x00020245, - 0x02020800, 0x001005d8, 0x59340002, 0x82000500, - 0x00ffffff, 0x48025812, 0x5c026800, 0x5c028800, - 0x497a5800, 0x497a5c04, 0x83400580, 0x00000046, - 0x04020002, 0x48165a07, 0x481a5c08, 0x0401fbed, - 0x5c025800, 0x1c01f000, 0x59300809, 0x800409c0, - 0x04000004, 0x58040403, 0x81440580, 0x1c01f000, - 0x82000540, 0x00000001, 0x0401f7fd, 0x4933c857, - 0x4c040000, 0x59300403, 0x82000d80, 0x0000001e, - 0x04020016, 0x800000d0, 0x59300a16, 0x82040d00, - 0x000000ff, 0x80040540, 0x4803c857, 0x48026416, - 0x4a026403, 0x00000085, 0x4a026203, 0x00000009, - 0x4a026406, 0x00000005, 0x4a02621d, 0x00000004, - 0x59a80038, 0x48026206, 0x42000800, 0x8000004b, - 0x0201f800, 0x00020721, 0x5c000800, 0x1c01f000, - 0x4933c857, 0x40000000, 0x40000000, 0x1c01f000, - 0x59300414, 0x4933c857, 0x4803c857, 0x8c000518, - 0x04000009, 0x8c000512, 0x02020000, 0x0010921e, - 0x0401f91b, 0x0201f800, 0x000206fd, 0x0201f800, - 0x0002077d, 0x1c01f000, 0x591c0406, 0x4803c857, - 0x82000c80, 0x00000009, 0x0402100b, 0x0c01f001, - 0x0010a4d9, 0x0010a4d9, 0x0010a4d9, 0x0010a4db, - 0x0010a4d9, 0x0010a4db, 0x0010a4db, 0x0010a4d9, - 0x0010a4db, 0x80000580, 0x1c01f000, 0x82000540, - 0x00000001, 0x1c01f000, 0x591c0406, 0x82000500, - 0x0000001f, 0x82000580, 0x00000006, 0x0400000e, - 0x4803c857, 0x4a026403, 0x0000003b, 0x4a02641a, - 0x00000009, 0x4a02621a, 0x00002a00, 0x4a026203, - 0x00000001, 0x42000800, 0x80000040, 0x0201f000, - 0x00020721, 0x4803c856, 0x4c040000, 0x4c140000, - 0x4d300000, 0x411e6000, 0x0401f8e9, 0x497a6205, - 0x59300414, 0x4803c857, 0x82000500, 0xffffadff, - 0x48026414, 0x497a6405, 0x5c026000, 0x0201f800, - 0x001007e4, 0x02000800, 0x001005d8, 0x5c002800, - 0x5c000800, 0x4a025a04, 0x0000010d, 0x497a5800, - 0x497a5c04, 0x4a025a08, 0x00000045, 0x491e5809, - 0x59300402, 0x48025c07, 0x59300419, 0x48025c0b, - 0x591c0414, 0x84000556, 0x48023c14, 0x591c1809, - 0x580c0403, 0x48025a06, 0x4816580a, 0x48065a0b, - 0x0401f99d, 0x4d400000, 0x42028000, 0x00000045, - 0x591c0202, 0x4c000000, 0x4d300000, 0x411e6000, - 0x0401fcb1, 0x5c026000, 0x5c000000, 0x48023a02, - 0x5c028000, 0x4a023c06, 0x00000006, 0x4a023a03, - 0x00000007, 0x497a3a06, 0x497a3a05, 0x1c01f000, - 0x4933c857, 0x83380580, 0x00000013, 0x0402000b, - 0x59300403, 0x4803c857, 0x82000d80, 0x00000085, - 0x0400002b, 0x82000d80, 0x0000008b, 0x04000028, - 0x0201f800, 0x001005d8, 0x83380580, 0x00000027, - 0x0402000c, 0x0201f800, 0x00106bbf, 0x4d2c0000, - 0x4d400000, 0x59325808, 0x42028000, 0x00000004, - 0x0401feab, 0x5c028000, 0x5c025800, 0x1c01f000, - 0x83380580, 0x00000014, 0x040007f3, 0x83380580, - 0x00000089, 0x04000005, 0x83380580, 0x0000008a, - 0x02020000, 0x00107974, 0x0201f800, 0x00106f60, - 0x02020000, 0x00107974, 0x59300a03, 0x82040580, - 0x0000000a, 0x04000009, 0x82040580, 0x0000000c, - 0x04000006, 0x0201f800, 0x001005d8, 0x4a026203, - 0x0000000a, 0x1c01f000, 0x83380480, 0x00000093, - 0x0402100c, 0x83380480, 0x00000085, 0x04001009, - 0x83380580, 0x00000089, 0x0400000a, 0x83380580, - 0x0000008a, 0x04000022, 0x0201f800, 0x001005d8, - 0x493bc857, 0x4933c857, 0x0201f000, 0x00107974, - 0x4933c857, 0x4c340000, 0x41306800, 0x0201f800, - 0x0002075a, 0x04000011, 0x4a026203, 0x00000001, - 0x4a026403, 0x0000001e, 0x59cc0c07, 0x48066419, - 0x59cc0a07, 0x48066219, 0x58340809, 0x48066009, - 0x4a026406, 0x00000004, 0x42000800, 0x80000040, - 0x0201f800, 0x00020721, 0x40366000, 0x0201f800, - 0x0002077d, 0x5c006800, 0x1c01f000, 0x4933c857, - 0x0201f000, 0x0002077d, 0x4933c857, 0x59300809, - 0x58040200, 0x8c00051a, 0x1c01f000, 0x0201f800, - 0x001048df, 0x0400001e, 0x4a026203, 0x00000002, - 0x59300414, 0x84000558, 0x48026414, 0x8c000512, - 0x04000004, 0x59a80039, 0x48026205, 0x0401f007, - 0x59a80839, 0x59a80037, 0x80040400, 0x82000400, - 0x0000000a, 0x48026205, 0x59300009, 0x82000c00, - 0x00000011, 0x50040000, 0x80000540, 0x04000004, - 0x82000c00, 0x00000000, 0x0401f7fb, 0x45300800, - 0x497a6000, 0x82000540, 0x00000001, 0x1c01f000, - 0x82100500, 0xfffffeef, 0x04020020, 0x4d2c0000, - 0x4937c857, 0x59340811, 0x83341400, 0x00000011, - 0x800409c0, 0x0400000e, 0x40040000, 0x81300580, - 0x04000005, 0x58040800, 0x82041400, 0x00000000, - 0x0401f7f8, 0x59300800, 0x497a6000, 0x44041000, - 0x0201f800, 0x000206fd, 0x0401f002, 0x4933c857, - 0x592c0000, 0x80000540, 0x02020800, 0x001005d8, - 0x5c025800, 0x492e6008, 0x0201f800, 0x000206fd, - 0x0201f000, 0x0002077d, 0x492fc857, 0x4a025a06, - 0x00000006, 0x0201f000, 0x000202da, 0x4c340000, - 0x59300009, 0x800001c0, 0x04000010, 0x82006c00, - 0x00000011, 0x50340000, 0x80000540, 0x04000009, - 0x81300580, 0x04000005, 0x50340000, 0x82006c00, - 0x00000000, 0x0401f7f8, 0x59300000, 0x44006800, - 0x5c006800, 0x1c01f000, 0x59300c06, 0x82040580, - 0x00000005, 0x040007fb, 0x82040580, 0x00000011, - 0x040007f8, 0x82040580, 0x00000006, 0x040007f5, - 0x82040580, 0x00000001, 0x040007f2, 0x0201f800, - 0x001005d8, 0x4933c857, 0x4c080000, 0x4c0c0000, - 0x4c580000, 0x59a8101d, 0x59cc1807, 0x820c1d00, - 0x00ffffff, 0x800c0110, 0x80083580, 0x04020014, - 0x83cc1400, 0x00000008, 0x4200b000, 0x00000002, - 0x59300009, 0x82001c00, 0x00000006, 0x0201f800, - 0x0010855a, 0x0402000a, 0x83cc1400, 0x0000000a, - 0x4200b000, 0x00000002, 0x59300009, 0x82001c00, - 0x00000008, 0x0201f800, 0x0010855a, 0x5c00b000, - 0x5c001800, 0x5c001000, 0x1c01f000, 0x4933c856, - 0x0201f800, 0x0010421b, 0x0201f000, 0x00101e45, - 0x493bc857, 0x4d2c0000, 0x0201f800, 0x001007e4, - 0x02000800, 0x001005d8, 0x832cac00, 0x00000005, - 0x4c580000, 0x4c540000, 0x4200b000, 0x00000006, - 0x4578a800, 0x8054a800, 0x8058b040, 0x040207fd, - 0x83380580, 0x00000046, 0x04020004, 0x4a025a04, - 0x00000144, 0x0401f008, 0x4a025a04, 0x00000146, - 0x83380580, 0x00000041, 0x04000003, 0x4a025a06, - 0x00000001, 0x59cc0007, 0x82000500, 0xff000000, - 0x80000110, 0x59cc1008, 0x82081500, 0xff000000, - 0x80081540, 0x480a580a, 0x83380580, 0x00000046, - 0x04020006, 0x59cc0007, 0x82000500, 0x00ffffff, - 0x4802580b, 0x0401f005, 0x59cc0008, 0x82000500, - 0x00ffffff, 0x4802580b, 0x83380580, 0x00000046, - 0x04020004, 0x83cc1400, 0x00000009, 0x0401f003, - 0x83cc1400, 0x0000000d, 0x50080000, 0x9c0001c0, - 0x4802580c, 0x80081000, 0x50080000, 0x9c0001c0, - 0x4802580d, 0x83380580, 0x00000046, 0x04020008, - 0x59cc000b, 0x9c0001c0, 0x4802580e, 0x59cc000c, - 0x9c0001c0, 0x4802580f, 0x0401f007, 0x59cc000f, - 0x9c0001c0, 0x4802580e, 0x59cc0010, 0x9c0001c0, - 0x4802580f, 0x83380580, 0x00000046, 0x04020004, - 0x83cc1400, 0x00000011, 0x0401f003, 0x83cc1400, - 0x00000015, 0x412c3000, 0x82183400, 0x00000010, - 0x4200b000, 0x00000004, 0x50080000, 0x9c0001c0, - 0x44003000, 0x80081000, 0x80183000, 0x8058b040, - 0x040207fa, 0x5c00a800, 0x5c00b000, 0x0201f800, - 0x000202da, 0x5c025800, 0x1c01f000, 0x4933c857, - 0x492fc857, 0x59300809, 0x58040200, 0x8c00051e, - 0x04000004, 0x592c0208, 0x84000558, 0x48025a08, - 0x1c01f000, 0x59e0180f, 0x599c0413, 0x800c1000, - 0x80080580, 0x04020002, 0x41781000, 0x59e00010, - 0x59e00810, 0x80040d80, 0x040207fd, 0x80080580, - 0x0400000b, 0x4c080000, 0x599c0814, 0x599c1015, - 0x800c00cc, 0x80040c00, 0x82081440, 0x00000000, - 0x5c001800, 0x82000540, 0x00000001, 0x4803c857, - 0x1c01f000, 0x492fc857, 0x42007000, 0x0010b7f8, - 0x58380807, 0x800409c0, 0x04020005, 0x492c7008, - 0x492c7007, 0x0201f000, 0x00100875, 0x492c0800, - 0x492c7007, 0x1c01f000, 0x59300203, 0x4933c857, - 0x4937c857, 0x493bc857, 0x4803c857, 0x82003480, - 0x0000000e, 0x02021800, 0x001005d8, 0x0c01f001, - 0x0010a6da, 0x0010a82c, 0x0010a6da, 0x0010a6da, - 0x0010a6da, 0x0010a6da, 0x0010a6da, 0x0010a791, - 0x0010a6dc, 0x0010a6da, 0x0010a6da, 0x0010a6da, - 0x0010a6da, 0x0010a6da, 0x0201f800, 0x001005d8, - 0x83380580, 0x0000004c, 0x02020800, 0x001005d8, - 0x0201f800, 0x001048ec, 0x04020020, 0x59a80826, - 0x82040500, 0x00000009, 0x82000580, 0x00000008, - 0x0400001a, 0x8c040d12, 0x0400003d, 0x59cc0806, - 0x82040d00, 0xff000000, 0x82040580, 0x03000000, - 0x0400001f, 0x82040580, 0x50000000, 0x04000005, - 0x82040580, 0x52000000, 0x02020000, 0x0002077d, - 0x813669c0, 0x04000006, 0x4d3c0000, 0x417a7800, - 0x0201f800, 0x0010203c, 0x5c027800, 0x4a026403, - 0x00000001, 0x0401f014, 0x59cc0806, 0x82040d00, - 0xff000000, 0x82040580, 0x03000000, 0x04000008, - 0x82040580, 0x50000000, 0x04000005, 0x82040580, - 0x52000000, 0x02020000, 0x0002077d, 0x4a026403, - 0x00000009, 0x4a02641a, 0x00000009, 0x4a02621a, - 0x00000000, 0x813669c0, 0x0402000b, 0x59cc0001, - 0x0201f800, 0x00105c9a, 0x02020000, 0x0002077d, - 0x0201f800, 0x001045a6, 0x02020000, 0x0002077d, - 0x49366009, 0x4a026406, 0x00000004, 0x4a026203, - 0x00000001, 0x0201f000, 0x0010672b, 0x0201f800, - 0x00103b25, 0x04000023, 0x59cc0806, 0x4807c857, - 0x82040d00, 0xff000000, 0x82040580, 0x03000000, - 0x04000033, 0x82040580, 0x20000000, 0x04000041, - 0x82040580, 0x21000000, 0x04000052, 0x82040580, - 0x24000000, 0x0400004f, 0x82040580, 0x50000000, - 0x0400004c, 0x82040580, 0x52000000, 0x04000049, - 0x82040580, 0x05000000, 0x0402000d, 0x59cc0806, - 0x82040d00, 0xff000000, 0x9c0431c0, 0x42028000, - 0x00000046, 0x42002800, 0x00000001, 0x0401fcf3, - 0x0401f93c, 0x02000800, 0x001005d8, 0x42002000, - 0x00000051, 0x0201f800, 0x00107a4a, 0x59cc0000, - 0x82000500, 0x00ffffff, 0x82000580, 0x00ffffff, - 0x04000005, 0x4a026203, 0x00000007, 0x493a6403, - 0x1c01f000, 0x59325817, 0x812e59c0, 0x02020800, - 0x001007fd, 0x0201f000, 0x0002077d, 0x813669c0, - 0x040007df, 0x59340400, 0x82000500, 0x000000ff, - 0x82000580, 0x00000003, 0x040207d9, 0x0401fc6f, - 0x040207d7, 0x4a026403, 0x00000009, 0x4a02641a, - 0x0000000e, 0x4a02621a, 0x00001900, 0x0401f7a2, - 0x813669c0, 0x0400000c, 0x59340c00, 0x82040500, - 0x000000ff, 0x82000580, 0x00000009, 0x04000794, - 0x82040500, 0x0000ff00, 0x82000580, 0x00000700, - 0x040207c3, 0x4a026403, 0x00000009, 0x4a02641a, - 0x00000009, 0x4a02621a, 0x00001e00, 0x0401f78e, - 0x813669c0, 0x040007f8, 0x59340c00, 0x82040500, - 0x0000ff00, 0x82000580, 0x00000700, 0x040007f2, - 0x0401f7b3, 0x4d2c0000, 0x4c580000, 0x4c500000, - 0x4c540000, 0x41385000, 0x83380580, 0x00000054, - 0x02020800, 0x001005d8, 0x59325808, 0x592c0c0b, - 0x82040d00, 0x0000e000, 0x82040580, 0x00002000, - 0x04020076, 0x59300817, 0x800409c0, 0x04000014, - 0x58041404, 0x41cca800, 0x8204a400, 0x00000005, - 0x82080480, 0x00000010, 0x04021004, 0x4008b000, - 0x0401fb6b, 0x0401f00a, 0x40001000, 0x4200b000, - 0x0000000f, 0x0401fb66, 0x58040801, 0x800409c0, - 0x040207f2, 0x0201f800, 0x001005d8, 0x813669c0, - 0x0400005e, 0x59344c00, 0x592c0c09, 0x4807c857, - 0x4827c857, 0x82040d00, 0x000000ff, 0x82040580, - 0x00000003, 0x0400002a, 0x82040580, 0x00000005, - 0x04000032, 0x82040580, 0x00000020, 0x04000036, - 0x82040580, 0x00000052, 0x04000042, 0x82040580, - 0x00000050, 0x04000042, 0x82040580, 0x00000021, - 0x04000004, 0x82040580, 0x00000024, 0x04020043, - 0x82240500, 0x0000ff00, 0x82000580, 0x00000007, - 0x04000008, 0x42000800, 0x00000009, 0x0201f800, - 0x00104571, 0x42005000, 0x0000000c, 0x0401f037, - 0x4a025a06, 0x00000031, 0x4a02580d, 0x00000009, - 0x59340400, 0x4802580e, 0x0201f800, 0x000202da, - 0x0201f800, 0x00107911, 0x0401f03d, 0x0201f800, - 0x001042b4, 0x0201f800, 0x0010462a, 0x42000800, - 0x00000003, 0x0201f800, 0x00104571, 0x42005000, - 0x00000008, 0x0401f021, 0x59cc0007, 0x0201f800, - 0x00105eec, 0x0402001d, 0x0201f800, 0x001042b4, - 0x0401f01a, 0x82240500, 0x0000ff00, 0x82000580, - 0x00000007, 0x040007df, 0x82240500, 0x000000ff, - 0x82000580, 0x00000009, 0x040007da, 0x0201f800, - 0x0010468d, 0x42005000, 0x0000000a, 0x0401f00b, - 0x42005000, 0x0000000e, 0x0401f003, 0x42005000, - 0x00000010, 0x82240500, 0x0000ff00, 0x82000580, - 0x00000007, 0x040007cb, 0x482a6403, 0x4a026203, - 0x00000001, 0x592c000d, 0x48026011, 0x497a6013, - 0x59a80038, 0x48026206, 0x417a7800, 0x0201f800, - 0x0010672b, 0x59325817, 0x812e59c0, 0x04000004, - 0x0201f800, 0x001007fd, 0x497a6017, 0x5c00a800, - 0x5c00a000, 0x5c00b000, 0x5c025800, 0x1c01f000, - 0x4d2c0000, 0x59325808, 0x83380580, 0x00000013, - 0x04020029, 0x59300c03, 0x82040580, 0x00000054, - 0x0400001e, 0x82040580, 0x00000010, 0x04000018, - 0x82040580, 0x0000000e, 0x04000015, 0x82040580, - 0x00000008, 0x0400000d, 0x82040580, 0x0000000c, - 0x0400000a, 0x82040580, 0x0000000a, 0x02020800, - 0x001005d8, 0x42000800, 0x00000006, 0x0201f800, - 0x00104571, 0x0401f009, 0x42000800, 0x00000004, - 0x0201f800, 0x00104571, 0x0401f004, 0x59340200, - 0x8400051a, 0x48026a00, 0x4a025a06, 0x00000000, - 0x0201f800, 0x000202da, 0x0201f800, 0x0002077d, - 0x0401f022, 0x83380580, 0x00000027, 0x0400000e, - 0x83380580, 0x00000014, 0x02020800, 0x001005d8, - 0x0201f800, 0x00106bbf, 0x42028000, 0x00000031, - 0x42000800, 0x00000004, 0x42001000, 0x000000ff, - 0x0401f009, 0x0201f800, 0x00106bbf, 0x42028000, - 0x00000031, 0x42000800, 0x00000004, 0x42001000, - 0x00000010, 0x49425a06, 0x4806580d, 0x480a580e, - 0x0201f800, 0x000202da, 0x0201f800, 0x00104c19, - 0x0201f800, 0x00107911, 0x5c025800, 0x1c01f000, - 0x42007000, 0x0010b7f8, 0x58380807, 0x800409c0, - 0x04020005, 0x492c7008, 0x492c7007, 0x0201f000, - 0x00100875, 0x492c0800, 0x492c7007, 0x1c01f000, - 0x4d2c0000, 0x4c580000, 0x4c500000, 0x4c540000, - 0x4933c857, 0x4937c857, 0x59cc0806, 0x4807c857, - 0x82040d00, 0xff000000, 0x82040580, 0x03000000, - 0x0400000d, 0x82040580, 0x05000000, 0x0400000a, - 0x82040580, 0x21000000, 0x04000030, 0x82040580, - 0x24000000, 0x0400002d, 0x82040580, 0x20000000, - 0x0402002f, 0x0201f800, 0x001007e4, 0x0400002c, - 0x492fc857, 0x492e6017, 0x59a8b016, 0x8258b400, - 0x0000001b, 0x8258b500, 0xfffffffc, 0x8058b104, - 0x485a5c04, 0x412c7800, 0x41cca000, 0x82580480, - 0x00000010, 0x04021005, 0x832cac00, 0x00000005, - 0x0401fa63, 0x0401f015, 0x40580800, 0x4200b000, - 0x0000000f, 0x832cac00, 0x00000005, 0x0401fa5c, - 0x8204b480, 0x0000000f, 0x0201f800, 0x001007e4, - 0x04000004, 0x492c7801, 0x412c7800, 0x0401f7ec, - 0x59325817, 0x0201f800, 0x001007fd, 0x497a6017, - 0x80000580, 0x0401f006, 0x59340200, 0x84000554, - 0x48026a00, 0x82000540, 0x00000001, 0x5c00a800, - 0x5c00a000, 0x5c00b000, 0x5c025800, 0x1c01f000, - 0x4933c857, 0x492fc857, 0x4d2c0000, 0x59300a03, - 0x82040580, 0x00000007, 0x04000036, 0x82040580, - 0x00000001, 0x02020800, 0x001005d8, 0x0201f800, - 0x00106c55, 0x4df00000, 0x598c000d, 0x81300580, - 0x04020016, 0x59300004, 0x8c000520, 0x04000004, - 0x84000520, 0x48026004, 0x0401f016, 0x42001000, - 0x0010b7f6, 0x50081000, 0x58080002, 0x82000580, - 0x00000100, 0x04000006, 0x5808000c, 0x81300580, - 0x02020800, 0x001005d8, 0x0401f00a, 0x0201f800, - 0x00106e8e, 0x04020020, 0x59300004, 0x8c000520, - 0x04000004, 0x84000520, 0x48026004, 0x0401f003, - 0x0201f800, 0x001068d3, 0x5c03e000, 0x02000800, - 0x00106c4b, 0x0201f800, 0x00109037, 0x02000800, - 0x001005d8, 0x59325808, 0x4a025a06, 0x00000005, - 0x0201f800, 0x000202da, 0x0201f800, 0x00104c19, - 0x59325817, 0x812e59c0, 0x02020800, 0x001007fd, - 0x0201f800, 0x00107911, 0x80000580, 0x5c025800, - 0x1c01f000, 0x5c03e000, 0x02000800, 0x00106c4b, - 0x59300406, 0x82000580, 0x00000011, 0x040007b8, - 0x0401f7f7, 0x4c040000, 0x59340200, 0x4803c857, - 0x8c00051c, 0x04000009, 0x59cc0805, 0x591c0019, - 0x4803c857, 0x80040580, 0x04000004, 0x80000580, - 0x4803c856, 0x0401f003, 0x82000540, 0x00000001, - 0x5c000800, 0x1c01f000, 0x4c000000, 0x4c0c0000, - 0x4c100000, 0x42001800, 0x0000ffff, 0x42002000, - 0x00000004, 0x0401f010, 0x4c000000, 0x4c0c0000, - 0x4c100000, 0x59302009, 0x58101c03, 0x42002000, - 0x00000004, 0x0401f008, 0x4c000000, 0x4c0c0000, - 0x4c100000, 0x59302009, 0x58101c03, 0x42002000, - 0x00000007, 0x480fc857, 0x4813c857, 0x481bc857, - 0x0201f800, 0x00103aae, 0x5c002000, 0x5c001800, - 0x5c000000, 0x1c01f000, 0x83380580, 0x00000092, - 0x02020800, 0x001005d8, 0x42000800, 0x80000040, - 0x4a026203, 0x00000001, 0x493a6403, 0x0201f000, - 0x00020721, 0x4d400000, 0x0201f800, 0x00103b25, - 0x04000008, 0x59a80005, 0x84000544, 0x48035005, - 0x42028000, 0x0000002a, 0x0201f800, 0x0010a449, - 0x5c028000, 0x1c01f000, 0x59a80026, 0x8c000508, - 0x04000005, 0x599c0017, 0x8c00050a, 0x04020002, - 0x1c01f000, 0x82000540, 0x00000001, 0x1c01f000, - 0x59300420, 0x84000540, 0x48026420, 0x1c01f000, - 0x4817c857, 0x4c000000, 0x4c040000, 0x8c142d2a, - 0x04000004, 0x598800b8, 0x80000000, 0x480310b8, - 0x8c142d2e, 0x04000004, 0x598800b9, 0x80000000, - 0x480310b9, 0x8c142d2c, 0x04000013, 0x40140000, - 0x82000500, 0x00070000, 0x82000d80, 0x00030000, - 0x0400000d, 0x82000d80, 0x00040000, 0x0400000a, - 0x82000d80, 0x00050000, 0x04000007, 0x59880005, - 0x80000000, 0x48031005, 0x598800ba, 0x80000000, - 0x480310ba, 0x5c000800, 0x5c000000, 0x1c01f000, - 0x4817c857, 0x4c000000, 0x4c040000, 0x8c142d2a, - 0x04000004, 0x598800bb, 0x80000000, 0x480310bb, - 0x8c142d2e, 0x04000004, 0x598800bc, 0x80000000, - 0x480310bc, 0x8c142d2c, 0x04000013, 0x40140000, - 0x82000500, 0x00070000, 0x82000d80, 0x00030000, - 0x0400000d, 0x82000d80, 0x00040000, 0x0400000a, - 0x82000d80, 0x00050000, 0x04000007, 0x59880005, - 0x80000000, 0x48031005, 0x598800bd, 0x80000000, - 0x480310bd, 0x5c000800, 0x5c000000, 0x1c01f000, - 0x4c000000, 0x59880001, 0x80000000, 0x4803c857, - 0x48031001, 0x5c000000, 0x1c01f000, 0x4c000000, - 0x59880000, 0x80000000, 0x4803c857, 0x48031000, - 0x5c000000, 0x1c01f000, 0x4c000000, 0x59880002, - 0x80000000, 0x4803c857, 0x48031002, 0x5c000000, - 0x1c01f000, 0x4807c857, 0x4c000000, 0x8c040d2c, - 0x04000004, 0x598800a6, 0x80000000, 0x480310a6, - 0x8c040d2a, 0x04000004, 0x598800a7, 0x80000000, - 0x480310a7, 0x8c040d28, 0x04000004, 0x598800a8, - 0x80000000, 0x480310a8, 0x8c040d26, 0x04000004, - 0x598800a9, 0x80000000, 0x480310a9, 0x8c040d24, - 0x04000004, 0x598800aa, 0x80000000, 0x480310aa, - 0x8c040d22, 0x04000004, 0x598800ab, 0x80000000, - 0x480310ab, 0x8c040d20, 0x04000004, 0x598800ac, - 0x80000000, 0x480310ac, 0x5c000000, 0x1c01f000, - 0x4807c857, 0x4c000000, 0x598800ad, 0x80000000, - 0x480310ad, 0x5c000000, 0x1c01f000, 0x4807c857, - 0x4c000000, 0x8c040d1c, 0x04000004, 0x598800ae, - 0x80000000, 0x480310ae, 0x8c040d1a, 0x04000004, - 0x598800af, 0x80000000, 0x480310af, 0x5c000000, - 0x1c01f000, 0x4807c857, 0x4c000000, 0x8c040d18, - 0x04000004, 0x598800b0, 0x80000000, 0x480310b0, - 0x8c040d16, 0x04000004, 0x598800b1, 0x80000000, - 0x480310b1, 0x8c040d14, 0x04000004, 0x598800b2, - 0x80000000, 0x480310b2, 0x5c000000, 0x1c01f000, - 0x4807c857, 0x4c000000, 0x8c040d10, 0x04000004, - 0x598800b3, 0x80000000, 0x480310b3, 0x8c040d0c, - 0x04000004, 0x598800b4, 0x80000000, 0x480310b4, - 0x5c000000, 0x1c01f000, 0x4807c857, 0x4c000000, - 0x8c040d08, 0x04000004, 0x598800b5, 0x80000000, - 0x480310b5, 0x8c040d04, 0x04000004, 0x598800b6, - 0x80000000, 0x480310b6, 0x5c000000, 0x1c01f000, - 0x4807c856, 0x4c000000, 0x5988007f, 0x80000000, - 0x4803107f, 0x5c000000, 0x1c01f000, 0x4803c857, - 0x4c040000, 0x50000800, 0x80040800, 0x4807c857, - 0x44040000, 0x5c000800, 0x1c01f000, 0x480fc857, - 0x4c000000, 0x820c0580, 0x00000000, 0x04020004, - 0x42000000, 0x0010b819, 0x0401f014, 0x820c0580, - 0x00001001, 0x04020004, 0x42000000, 0x0010b81a, - 0x0401f00e, 0x820c0580, 0x00001002, 0x04020004, - 0x42000000, 0x0010b81b, 0x0401f008, 0x820c0c80, - 0x0000201c, 0x02021800, 0x001005d8, 0x820c0500, - 0x0000001f, 0x0c01f804, 0x0401ffdd, 0x5c000000, - 0x1c01f000, 0x0010aa89, 0x0010aa8c, 0x0010aa8f, - 0x0010aa92, 0x0010aa95, 0x0010aa98, 0x0010aa9b, - 0x0010aa9e, 0x0010aaa1, 0x0010aaa4, 0x0010aaa7, - 0x0010aaaa, 0x0010aaad, 0x0010aab0, 0x0010aab3, - 0x0010aab6, 0x0010aab9, 0x0010aabc, 0x0010aabf, - 0x0010aac2, 0x0010aac5, 0x0010aac8, 0x0010aacb, - 0x0010aace, 0x0010aad1, 0x0010aad4, 0x0010aad7, - 0x0010aada, 0x42000000, 0x0010b81c, 0x1c01f000, - 0x42000000, 0x0010b81d, 0x1c01f000, 0x42000000, - 0x0010b81e, 0x1c01f000, 0x42000000, 0x0010b81f, - 0x1c01f000, 0x42000000, 0x0010b820, 0x1c01f000, - 0x42000000, 0x0010b821, 0x1c01f000, 0x42000000, - 0x0010b822, 0x1c01f000, 0x42000000, 0x0010b823, - 0x1c01f000, 0x42000000, 0x0010b824, 0x1c01f000, - 0x42000000, 0x0010b825, 0x1c01f000, 0x42000000, - 0x0010b826, 0x1c01f000, 0x42000000, 0x0010b827, - 0x1c01f000, 0x42000000, 0x0010b828, 0x1c01f000, - 0x42000000, 0x0010b829, 0x1c01f000, 0x42000000, - 0x0010b82a, 0x1c01f000, 0x42000000, 0x0010b82b, - 0x1c01f000, 0x42000000, 0x0010b82c, 0x1c01f000, - 0x42000000, 0x0010b82d, 0x1c01f000, 0x42000000, - 0x0010b82e, 0x1c01f000, 0x42000000, 0x0010b82f, - 0x1c01f000, 0x42000000, 0x0010b830, 0x1c01f000, - 0x42000000, 0x0010b831, 0x1c01f000, 0x42000000, - 0x0010b832, 0x1c01f000, 0x42000000, 0x0010b833, - 0x1c01f000, 0x42000000, 0x0010b834, 0x1c01f000, - 0x42000000, 0x0010b835, 0x1c01f000, 0x42000000, - 0x0010b836, 0x1c01f000, 0x42000000, 0x0010b837, - 0x1c01f000, 0x480fc857, 0x4c000000, 0x820c0580, - 0x00000001, 0x04020004, 0x42000000, 0x0010b80e, - 0x0401f012, 0x820c0580, 0x00000002, 0x04020004, - 0x42000000, 0x0010b80f, 0x0401f00c, 0x820c0580, - 0x00000003, 0x04020004, 0x42000000, 0x0010b810, - 0x0401f006, 0x820c0580, 0x00000004, 0x04020004, - 0x42000000, 0x0010b811, 0x0401ff51, 0x5c000000, - 0x1c01f000, 0x4c000000, 0x59a80026, 0x4803c857, - 0x8c000502, 0x04000010, 0x8c000506, 0x04000004, - 0x42000000, 0x0010b841, 0x0401f012, 0x8c00050a, - 0x04000004, 0x42000000, 0x0010b840, 0x0401f00d, - 0x8c000508, 0x04000004, 0x42000000, 0x0010b843, - 0x0401f008, 0x0201f800, 0x0010513b, 0x04000006, - 0x8c000506, 0x04020004, 0x42000000, 0x0010b842, - 0x0401ff33, 0x5c000000, 0x1c01f000, 0x8058b1c0, - 0x02000800, 0x001005d8, 0x5450a800, 0x8050a000, - 0x8054a800, 0x8058b040, 0x040207fc, 0x1c01f000, - 0x8058b1c0, 0x02000800, 0x001005d8, 0x4450a800, - 0x8054a800, 0x8058b040, 0x040207fd, 0x1c01f000, - 0x8058b1c0, 0x02000800, 0x001005d8, 0x50500000, - 0x9c0001c0, 0x4400a800, 0x8050a000, 0x8054a800, - 0x8058b040, 0x040207fa, 0x1c01f000, 0x4c000000, - 0x59a80008, 0x8c00051c, 0x5c000000, 0x1c01f000, - 0x00000001, 0x00000002, 0x00000004, 0x00000008, - 0x00000010, 0x00000020, 0x00000040, 0x00000080, - 0x00000100, 0x00000200, 0x00000400, 0x00000800, - 0x00001000, 0x00002000, 0x00004000, 0x00008000, - 0x00010000, 0xa5f2b3ac -}; - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_length01 = 0x0000ab4a ; -#else -uint32_t risc_code_length01 = 0x0000ab4a ; -#endif - - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_addr02 = 0x0010e000 ; -#else -uint32_t risc_code_addr02 = 0x0010e000 ; -#endif - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_code02[] = { -#else -uint32_t risc_code02[] = { -#endif - 0x00000000, 0x00000000, 0x0010e000, 0x000014ff, - 0x00000000, 0x00000000, 0x00020000, 0x000008c0, - 0x836c0580, 0x00000003, 0x02020000, 0x001002e3, - 0x42000000, 0x0010b4bb, 0x50000000, 0x800001c0, - 0x04020956, 0x0401f923, 0x0401fbe3, 0x0401fb5c, - 0x0201f800, 0x00020718, 0x0201f800, 0x0002057b, - 0x0401f7f0, 0x59b800ea, 0x82000d00, 0xf0000038, - 0x02020000, 0x00100a7a, 0x8c000510, 0x02000000, - 0x00100a79, 0x59ba60e0, 0x81300182, 0x0402104e, - 0x04002030, 0x8532653e, 0x59300406, 0x82000580, - 0x00000003, 0x04020028, 0x59300203, 0x82000580, - 0x00000004, 0x04020024, 0x59325808, 0x59300402, - 0x4a025a04, 0x00000103, 0x900001c0, 0x48025806, - 0x497a5807, 0x497a5c09, 0x5930001f, 0x80000540, - 0x02020800, 0x00100d56, 0x59300004, 0x8c00053e, - 0x04020010, 0x0401fa88, 0x59326809, 0x0201f800, - 0x0002077d, 0x5934000f, 0x5934140b, 0x80081040, - 0x04001002, 0x480a6c0b, 0x80000540, 0x04020a10, - 0x59b800ea, 0x8c000510, 0x040207d7, 0x1c01f000, - 0x0201f800, 0x00106f60, 0x040007ef, 0x0201f000, - 0x00100a65, 0x42027000, 0x00000055, 0x0401f027, - 0x83326500, 0x3fffffff, 0x59300406, 0x82000580, - 0x00000003, 0x04020015, 0x59325808, 0x59326809, - 0x59301402, 0x4a025a04, 0x00000103, 0x900811c0, - 0x480a5806, 0x497a5c09, 0x497a5807, 0x0401fa62, - 0x0201f800, 0x0002077d, 0x5934000f, 0x5934140b, - 0x80081040, 0x04001002, 0x480a6c0b, 0x80000540, - 0x040209eb, 0x0401f7db, 0x42027000, 0x00000054, - 0x0401f00a, 0x83300500, 0x60000000, 0x02000000, - 0x00100a68, 0x81326580, 0x8000013a, 0x82000400, - 0x00100a80, 0x50027000, 0x59300c06, 0x82040580, - 0x00000002, 0x02000000, 0x00100a65, 0x59300004, - 0x8c00053e, 0x04020004, 0x0201f800, 0x000207a1, - 0x0401f7c4, 0x0201f800, 0x00106f60, 0x040007fb, - 0x0201f000, 0x00100a65, 0x59325808, 0x412c7000, - 0x58380a04, 0x82040500, 0x0000000f, 0x82000c00, - 0x001010bd, 0x50044000, 0x0c01f001, 0x00100dd9, - 0x00100dd9, 0x0002009f, 0x00100dd9, 0x00100dd9, - 0x00100dd9, 0x00100dd9, 0x00100dd9, 0x000200af, - 0x00100ded, 0x00100dd9, 0x00100dd9, 0x00100ddb, - 0x00100dd9, 0x00100dd9, 0x00100dd9, 0x5838040a, - 0x8c000500, 0x02000800, 0x001005d8, 0x50200000, - 0x80387c00, 0x583c1002, 0x583c2800, 0x583c2001, - 0x58380a07, 0x5838300f, 0x59303807, 0x58384c08, - 0x5838000d, 0x48026012, 0x0401f010, 0x5838020a, - 0x8c000502, 0x02000000, 0x00100dd9, 0x50200000, - 0x80387c00, 0x583c2800, 0x583c2001, 0x583c1002, - 0x592c0a07, 0x592c4c08, 0x592c300f, 0x59303807, - 0x497a6012, 0x497a6013, 0x4816600e, 0x4812600f, - 0x480a6010, 0x481a6011, 0x80040840, 0x4806600d, - 0x02020000, 0x00100e1a, 0x841c3d40, 0x481e6007, - 0x1c01f000, 0x41787800, 0x59325808, 0x592c0c0a, - 0x8c040d02, 0x02000000, 0x00100f8c, 0x592c000d, - 0x592c100f, 0x592c0a04, 0x480a6011, 0x48026012, - 0x48026013, 0x412c3000, 0x82040500, 0x0000000f, - 0x82000400, 0x001010bd, 0x50003800, 0x501c0000, - 0x401c1000, 0x592c1a07, 0x4802600a, 0x481a600b, - 0x480a600c, 0x480e600d, 0x843c7d4a, 0x403c1000, - 0x1c01f000, 0x41787800, 0x497a6012, 0x592c0a04, - 0x412c3000, 0x592c1a07, 0x82040500, 0x0000000f, - 0x82000400, 0x001010bd, 0x50004000, 0x50200000, - 0x40201000, 0x4802600a, 0x481a600b, 0x480a600c, - 0x480e600d, 0x80000580, 0x483e6004, 0x1c01f000, - 0x4c000000, 0x4df00000, 0x0201f800, 0x00020729, - 0x0401f005, 0x4c000000, 0x4df00000, 0x0401ff16, - 0x0401f001, 0x5c03e000, 0x5c000000, 0x1801f000, - 0x4203e000, 0xb0100000, 0x41fc0000, 0x82000500, - 0x00000011, 0x0c01f001, 0x0002012a, 0x00020697, - 0x0002012a, 0x0002012a, 0x0002012a, 0x0002012a, - 0x0002012a, 0x0002012a, 0x0002012a, 0x0002012a, - 0x0002012a, 0x0002012a, 0x0002012a, 0x0002012a, - 0x0002012a, 0x0002012a, 0x0010115a, 0x0002012c, - 0x0002012a, 0x0002012a, 0x0002012a, 0x0002012a, - 0x0002012a, 0x0002012a, 0x0002012a, 0x0002012a, - 0x0002012a, 0x0002012a, 0x0002012a, 0x0002012a, - 0x0002012a, 0x0002012a, 0x0201f800, 0x001005d8, - 0x0201f800, 0x00020697, 0x0201f000, 0x0010115a, - 0x42000000, 0x0010b4c1, 0x50000000, 0x8c000504, - 0x04000014, 0x42000000, 0x0010b4c1, 0x50000000, - 0x8c000502, 0x04020002, 0x1c01f000, 0x4df00000, - 0x4203e000, 0x50000000, 0x42034000, 0x0010b4a4, - 0x59a0001d, 0x59a1d81e, 0x84000502, 0x4803401d, - 0x58ec0009, 0x0801f800, 0x5c03e000, 0x1c01f000, - 0x04027002, 0x04026002, 0x1c01f000, 0x4df00000, - 0x4203e000, 0x50000000, 0x0201f800, 0x001007e4, - 0x04000010, 0x412dd800, 0x48efc857, 0x0201f800, - 0x00103b28, 0x42034000, 0x0010b4a4, 0x49a1d80b, - 0x48ef401e, 0x59a0001d, 0x84000544, 0x4803401d, - 0x0201f800, 0x00102214, 0x0201f800, 0x00102233, - 0x5c03e000, 0x1c01f000, 0x4da00000, 0x4df00000, - 0x4203e000, 0x50000000, 0x04006051, 0x40001000, - 0x42034000, 0x0010b4a4, 0x59a01818, 0x800c19c0, - 0x04020008, 0x59a0381b, 0x801c39c0, 0x02000800, - 0x001005d8, 0x59a0041c, 0x801c3c00, 0x0401f00c, - 0x59a00419, 0x82000400, 0x00000002, 0x48034419, - 0x82000c80, 0x00000013, 0x04001003, 0x497b4419, - 0x41780000, 0x59a03816, 0x801c3c00, 0x80081040, - 0x480b4017, 0x581c0200, 0x4803c021, 0x581c0401, - 0x4803c022, 0x581c0201, 0x4803c023, 0x581c0400, - 0x4803c020, 0x900001c0, 0x82000540, 0x00000012, - 0x4803c011, 0x59e00017, 0x8c000508, 0x04000003, - 0x4a03c017, 0x00000002, 0x4203e000, 0x30000001, - 0x800c19c0, 0x04000007, 0x800c1840, 0x480f4018, - 0x0402001f, 0x497b4419, 0x497b4219, 0x0401f01c, - 0x800811c0, 0x0402000b, 0x4d2c0000, 0x59a2581b, - 0x0201f800, 0x001007f4, 0x5c025800, 0x497b401b, - 0x497b401a, 0x497b441c, 0x497b421c, 0x0401f010, - 0x59a0041c, 0x82000400, 0x00000002, 0x82000c80, - 0x00000012, 0x4803441c, 0x04001009, 0x4d2c0000, - 0x59a2581b, 0x592c3813, 0x481f401b, 0x497b441c, - 0x0201f800, 0x001007f4, 0x5c025800, 0x5c03e000, - 0x5c034000, 0x1c01f000, 0x59a80005, 0x82000500, - 0x00000003, 0x02020000, 0x00104315, 0x59340400, - 0x82000580, 0x00000606, 0x02020000, 0x001042e6, - 0x5934000d, 0x80027d40, 0x02020000, 0x00104321, - 0x0401f803, 0x80000580, 0x1c01f000, 0x5934000f, - 0x59341203, 0x80080540, 0x0402006f, 0x5934020b, - 0x5934140b, 0x80080480, 0x0402106b, 0x0201f800, - 0x0002075a, 0x04000064, 0x80081000, 0x592c0406, - 0x480a6c0b, 0x49366009, 0x492e6008, 0x4a026406, - 0x00000003, 0x4a026403, 0x00000040, 0x800000c2, - 0x800018c4, 0x800c0400, 0x48026206, 0x592c0808, - 0x592c1809, 0x592c020a, 0x48066017, 0x480e6018, - 0x8c000502, 0x04000030, 0x4a026203, 0x00000004, - 0x592c0207, 0x80000040, 0x04020020, 0x59a80005, - 0x8c000514, 0x42000000, 0x00000055, 0x04020003, - 0x42000000, 0x00000033, 0x80000040, 0x040207ff, - 0x592c0204, 0x82000500, 0x000000ff, 0x82000580, - 0x00000018, 0x04020011, 0x592c180f, 0x59300007, - 0x82000540, 0x00000091, 0x480e6011, 0x48026007, - 0x42000000, 0x80000004, 0x48026004, 0x59bc00ea, - 0x8c000516, 0x040207fe, 0x83300400, 0x20000000, - 0x480378e1, 0x1c01f000, 0x0401fe78, 0x59300007, - 0x8400054e, 0x48026007, 0x592c1a04, 0x820c1d00, - 0x000000ff, 0x820c0580, 0x00000048, 0x04000017, - 0x0401f7ec, 0x8c000500, 0x04020ecb, 0x4a026203, - 0x00000002, 0x59a80805, 0x82040500, 0x00000600, - 0x04020012, 0x42000000, 0x00000030, 0x80000040, - 0x040207ff, 0x592c1a04, 0x820c1d00, 0x000000ff, - 0x820c0580, 0x00000018, 0x040007da, 0x820c0580, - 0x00000048, 0x040207d7, 0x42000800, 0x80000804, - 0x0201f000, 0x00106721, 0x8c040d12, 0x42000000, - 0x00000010, 0x040207ee, 0x42000000, 0x00000051, - 0x0401f7eb, 0x800811c0, 0x04020003, 0x4a026a03, - 0x00000001, 0x59340010, 0x492e6810, 0x80000d40, - 0x04020003, 0x492e680f, 0x1c01f000, 0x492c0800, - 0x1c01f000, 0x83440c80, 0x00000800, 0x04021009, - 0x83440400, 0x0010ac00, 0x50000000, 0x80000540, - 0x04000004, 0x40026800, 0x80000580, 0x1c01f000, - 0x82000540, 0x00000001, 0x1c01f000, 0x59340203, - 0x80000540, 0x0402004b, 0x4d300000, 0x4d2c0000, - 0x5934000f, 0x80025d40, 0x04000044, 0x0201f800, - 0x0002075a, 0x0400003f, 0x592c0000, 0x4802680f, - 0x80000540, 0x04020002, 0x48026810, 0x592c2a04, - 0x80081000, 0x480a6c0b, 0x49366009, 0x492e6008, - 0x82142d00, 0x000000ff, 0x82140580, 0x00000012, - 0x04000035, 0x4a026406, 0x00000003, 0x4a026403, - 0x00000040, 0x592c0406, 0x800000c2, 0x800018c4, - 0x800c0400, 0x48026206, 0x592c0808, 0x592c1809, - 0x592c020a, 0x48066017, 0x480e6018, 0x8c000502, - 0x02000000, 0x0010474d, 0x4a026203, 0x00000004, - 0x592c0207, 0x80000040, 0x02020000, 0x00104740, - 0x82140580, 0x00000018, 0x02020000, 0x00104740, - 0x592c180f, 0x59300007, 0x82000540, 0x00000091, - 0x480e6011, 0x48026007, 0x42000000, 0x80000004, - 0x48026004, 0x59bc00ea, 0x8c000516, 0x040207fe, - 0x83300400, 0x20000000, 0x480378e1, 0x5934020b, - 0x5934140b, 0x80080480, 0x040017be, 0x0401f003, - 0x4a026a03, 0x00000001, 0x5c025800, 0x5c026000, - 0x1c01f000, 0x497a5800, 0x49325809, 0x4a026406, - 0x00000006, 0x4a026203, 0x00000007, 0x0401f802, - 0x0401f7ef, 0x59a80021, 0x800001c0, 0x02020000, - 0x0010476f, 0x59a80005, 0x8c000504, 0x02020000, - 0x0010476b, 0x59340200, 0x8c000518, 0x02020000, - 0x00104767, 0x592c0a0c, 0x48066202, 0x4a025a06, - 0x00000000, 0x8c000508, 0x02020000, 0x00104763, - 0x4d3c0000, 0x417a7800, 0x0401fbdf, 0x5c027800, - 0x1c01f000, 0x592c0404, 0x8c00051e, 0x02020000, - 0x00104ce4, 0x59980022, 0x80000540, 0x04000017, - 0x592c0a06, 0x592c0409, 0x80040540, 0x04020013, - 0x0201f000, 0x00104cfa, 0x592c0404, 0x8c00051e, - 0x02020000, 0x00104cf3, 0x59980022, 0x80000540, - 0x0400000a, 0x82040580, 0x00000001, 0x04020007, - 0x0201f000, 0x00104cfa, 0x592c0404, 0x8c00051e, - 0x02020000, 0x00104dca, 0x59980026, 0x497a5800, - 0x80000540, 0x02020000, 0x00104e1d, 0x59d80105, - 0x82000d00, 0x00018780, 0x02020000, 0x00104edb, - 0x80000106, 0x82000500, 0x00000003, 0x0c01f001, - 0x000202f0, 0x00104e1d, 0x000202f6, 0x00020341, - 0x592c0001, 0x492fb107, 0x80000d40, 0x02020000, - 0x00104ddb, 0x1c01f000, 0x592c0001, 0x492fb107, - 0x80000d40, 0x02020000, 0x00104de8, 0x59da5908, - 0x835c0480, 0x00000020, 0x0400102c, 0x0402b034, - 0x492fb007, 0x0400e7fa, 0x59d80105, 0x82000500, - 0x00018780, 0x02020000, 0x00104edb, 0x0400601f, - 0x59d8010a, 0x59d8090a, 0x80040580, 0x040207fd, - 0x800408e0, 0x599c1017, 0x8c081508, 0x04020028, - 0x82040d40, 0x00000013, 0x5998002b, 0x4807c011, - 0x84000500, 0x4803302b, 0x59e00017, 0x8c000508, - 0x04020004, 0x4203e000, 0x30000001, 0x1c01f000, - 0x4a03c017, 0x00000003, 0x82040500, 0x000000ff, - 0x82000580, 0x0000001d, 0x040207f7, 0x4a03c017, - 0x0000000d, 0x0401f7f4, 0x5998082b, 0x84040d40, - 0x4807302b, 0x1c01f000, 0x496a5800, 0x412ed000, - 0x815eb800, 0x59c80000, 0x82000540, 0x00001200, - 0x48039000, 0x0400e7ca, 0x0401f7d0, 0x0402f7f7, - 0x492fa807, 0x0400e7c6, 0x0401f7cc, 0x59e0000f, - 0x59e0100f, 0x80081580, 0x040207fd, 0x81281580, - 0x040007d4, 0x40025000, 0x82040d40, 0x0000001d, - 0x0401f7d2, 0x59d80908, 0x45680800, 0x4006d000, - 0x815eb800, 0x0400e7fc, 0x59c80000, 0x82000540, - 0x00001200, 0x48039000, 0x02006000, 0x00104df8, - 0x59d8010a, 0x59d8090a, 0x80040d80, 0x040207fd, - 0x900001c0, 0x82000540, 0x00000013, 0x4803c011, - 0x5998002b, 0x84000500, 0x4803302b, 0x59e00017, - 0x8c000508, 0x04000003, 0x4a03c017, 0x00000003, - 0x4203e000, 0x30000001, 0x59d80105, 0x82000500, - 0x00018780, 0x02020000, 0x00104edb, 0x0202d000, - 0x00104dfd, 0x592c0001, 0x492fb107, 0x80000d40, - 0x02020000, 0x00104e10, 0x1c01f000, 0x59980020, - 0x0c01f001, 0x00020370, 0x00020371, 0x00104e88, - 0x1c01f000, 0x4df00000, 0x4203e000, 0x50000000, - 0x0402681e, 0x04006004, 0x599c0017, 0x8c000508, - 0x04020865, 0x59980029, 0x80025d40, 0x0400000a, - 0x0402d00b, 0x59980026, 0x80000040, 0x48033026, - 0x592c0000, 0x492fb107, 0x48033029, 0x04020002, - 0x48033028, 0x5c03e000, 0x1c01f000, 0x59d80105, - 0x82000500, 0x00018780, 0x02020000, 0x00104edb, - 0x42000000, 0x0010b855, 0x0201f800, 0x0010aa47, - 0x5c03e000, 0x1c01f000, 0x5998002b, 0x8c000500, - 0x0402003b, 0x0400e007, 0x59d80105, 0x82000500, - 0x00018780, 0x02020000, 0x00104edb, 0x1c01f000, - 0x59da5908, 0x835c0c80, 0x00000020, 0x04001003, - 0x0400b029, 0x0400f02b, 0x496a5800, 0x412ed000, - 0x815eb800, 0x59c80000, 0x82000540, 0x00001200, - 0x48039000, 0x0400e7f3, 0x59d8010a, 0x59d8090a, - 0x80040580, 0x040207fd, 0x800408e0, 0x599c1017, - 0x8c081508, 0x04020022, 0x82040d40, 0x00000013, - 0x4807c011, 0x59e00017, 0x8c000508, 0x0400000a, - 0x4a03c017, 0x00000003, 0x82040500, 0x000000ff, - 0x82000580, 0x0000001d, 0x04020003, 0x4a03c017, - 0x0000000d, 0x4203e000, 0x30000001, 0x59d80105, - 0x82000500, 0x00018780, 0x02020000, 0x00104edb, - 0x1c01f000, 0x492fb007, 0x0400e7d2, 0x0401f7df, - 0x492fa807, 0x0400e7cf, 0x0401f7dc, 0x84000500, - 0x4803302b, 0x0400e7cb, 0x0401f7d8, 0x59e0000f, - 0x59e0100f, 0x80081580, 0x040207fd, 0x81281580, - 0x040007da, 0x40025000, 0x82040d40, 0x0000001d, - 0x0401f7d8, 0x59e0000f, 0x59e0100f, 0x80080d80, - 0x040207fd, 0x81280580, 0x04020002, 0x1c01f000, - 0x400a5000, 0x900811c0, 0x82081540, 0x0000001c, - 0x480bc011, 0x59e00017, 0x8c000508, 0x04000003, - 0x4a03c017, 0x0000000c, 0x4203e000, 0x30000001, - 0x1c01f000, 0x41700000, 0x0c01f001, 0x00105420, - 0x000203fc, 0x00105420, 0x00105421, 0x0010541e, - 0x0010541e, 0x0010541e, 0x0010541e, 0x001058b0, - 0x04010037, 0x59980006, 0x80000540, 0x0402003c, - 0x0402c01c, 0x4202f800, 0x00000010, 0x4df00000, - 0x4203e000, 0x50000000, 0x49db3005, 0x59da5808, - 0x592c0204, 0x497a5800, 0x497a5801, 0x82000500, - 0x000000ff, 0x82000c80, 0x00000079, 0x04021036, - 0x0c01f839, 0x5c03e000, 0x817ef840, 0x04000009, - 0x836c0580, 0x00000003, 0x04020006, 0x83700580, - 0x00000001, 0x04020010, 0x0401001b, 0x0400c7e8, - 0x0400f94a, 0x0400b134, 0x59d40005, 0x82000500, - 0x43018780, 0x02020000, 0x0010583f, 0x59d80005, - 0x82000500, 0x43018780, 0x02020000, 0x00105846, - 0x1c01f000, 0x83700580, 0x00000003, 0x02000800, - 0x00105421, 0x83700580, 0x00000001, 0x040207ed, - 0x04010005, 0x0400c7d2, 0x0401f7ea, 0x4202f800, - 0x00000010, 0x4df00000, 0x4203e000, 0x50000000, - 0x49d73005, 0x59d65808, 0x0401f7ce, 0x4df00000, - 0x4203e000, 0x50000000, 0x40025800, 0x592c0204, - 0x497b3005, 0x497b3006, 0x4202f800, 0x00000010, - 0x0401f7c7, 0x0201f800, 0x00105491, 0x5c03e000, - 0x0401f7d4, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105527, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x001054a1, - 0x00105491, 0x00105491, 0x00105491, 0x00105551, - 0x00105491, 0x00105491, 0x00105491, 0x000204ef, - 0x00105491, 0x001056b4, 0x00105491, 0x00105491, - 0x00105491, 0x000204c2, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x001054c9, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x001057d3, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x0010581e, 0x00105491, - 0x001054bb, 0x00105491, 0x00105797, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105765, 0x00105491, - 0x00105765, 0x00105872, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105725, - 0x00105855, 0x00105491, 0x00105865, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x00105491, 0x00105491, - 0x00105491, 0x00105491, 0x592c0204, 0x80000110, - 0x02000000, 0x00105499, 0x80000040, 0x04000009, - 0x48033002, 0x492f3003, 0x492f3004, 0x4a033008, - 0x000204d0, 0x4202e000, 0x00000003, 0x1c01f000, - 0x592c0406, 0x82000c80, 0x0000199a, 0x02021000, - 0x001054a9, 0x59a80021, 0x80000540, 0x02020000, - 0x001054d7, 0x592e8a06, 0x83440c80, 0x000007f0, - 0x02021000, 0x001054a9, 0x83440400, 0x0010ac00, - 0x50000000, 0x80026d40, 0x02000000, 0x001054db, - 0x59340002, 0x592c0810, 0x80040580, 0x82000500, - 0x00ffffff, 0x02020000, 0x001054a9, 0x0401fccf, - 0x02020000, 0x001054de, 0x1c01f000, 0x592c0204, - 0x80000110, 0x02000000, 0x00105499, 0x80000040, - 0x0402000b, 0x592c040a, 0x8c000504, 0x04000010, - 0x592c0207, 0x82000c80, 0x00001001, 0x02021000, - 0x001054a9, 0x0201f000, 0x0010588a, 0x48033002, - 0x492f3003, 0x492f3004, 0x4a033008, 0x00020507, - 0x4202e000, 0x00000003, 0x1c01f000, 0x592c0406, - 0x82000c80, 0x0000199a, 0x02021000, 0x001054a9, - 0x592e8a06, 0x417a7800, 0x0401fd37, 0x02020000, - 0x00105658, 0x59340002, 0x592c0808, 0x80040580, - 0x82000500, 0x00ffffff, 0x02020000, 0x001054a9, - 0x497a5808, 0x592e6009, 0x83300580, 0xffffffff, - 0x02000000, 0x00105618, 0x83300480, 0x0010d1c0, - 0x02001000, 0x00105675, 0x59a8000b, 0x81300480, - 0x02021000, 0x00105675, 0x592c240a, 0x49366009, - 0x8c10251c, 0x02020000, 0x00105606, 0x59a80068, - 0x8c000510, 0x02020000, 0x0010568e, 0x59a80821, - 0x800409c0, 0x02020000, 0x001055ec, 0x59a80805, - 0x8c040d04, 0x02020000, 0x0010567f, 0x59340200, - 0x8c000518, 0x02020000, 0x00105670, 0x59300c06, - 0x82040580, 0x00000006, 0x02020000, 0x00105610, - 0x59300414, 0x8c000516, 0x02020000, 0x0010567a, - 0x8c102508, 0x02020000, 0x0010a5b8, 0x59300808, - 0x4a025a06, 0x00000000, 0x800409c0, 0x02020000, - 0x001055e7, 0x592c0a0c, 0x48066202, 0x492e6008, - 0x0401f14d, 0x4df00000, 0x4203e000, 0x50000000, - 0x0402b00b, 0x835c0480, 0x00000020, 0x0400100d, - 0x815eb840, 0x416a5800, 0x592ed000, 0x492fb007, - 0x497a5800, 0x497a5801, 0x0400b7f7, 0x59d80005, - 0x82000500, 0x43018780, 0x02020000, 0x00105846, - 0x5c03e000, 0x1c01f000, 0x4df00000, 0x4203e000, - 0x50000000, 0x0402f00b, 0x835c0480, 0x00000020, - 0x0400100d, 0x815eb840, 0x416a5800, 0x592ed000, - 0x492fa807, 0x497a5800, 0x497a5801, 0x0400f7f7, - 0x59d40005, 0x82000500, 0x43018780, 0x02020000, - 0x0010583f, 0x5c03e000, 0x1c01f000, 0x4df00000, - 0x4203e000, 0x50000000, 0x59940024, 0x80000540, - 0x04000112, 0x4c000000, 0x42000000, 0x00001000, - 0x50000000, 0x82000480, 0x24320001, 0x04020015, - 0x42000800, 0x00000064, 0x80040840, 0x04000007, - 0x4a030000, 0x00000001, 0x40000000, 0x59800000, - 0x8c000500, 0x040007f9, 0x04000008, 0x42000800, - 0x00007a01, 0x50040000, 0x8c000510, 0x04000003, - 0x84000510, 0x44000800, 0x4a030000, 0x00000000, - 0x59e00002, 0x8c00051e, 0x0402001b, 0x42000000, - 0x00001000, 0x50000000, 0x82000480, 0x24320002, - 0x04020015, 0x42000800, 0x00000064, 0x80040840, - 0x04000007, 0x4a030000, 0x00000001, 0x40000000, - 0x59800000, 0x8c000500, 0x040007f9, 0x04000008, - 0x42000800, 0x00007a17, 0x50040000, 0x8c00050e, - 0x04020003, 0x8400054e, 0x44000800, 0x4a030000, - 0x00000000, 0x5c000000, 0x5994781a, 0x48032825, - 0x803c0480, 0x04001004, 0x04000003, 0x4803281a, - 0x0401f022, 0x41787800, 0x803c7800, 0x82000400, - 0x000003e8, 0x040027fd, 0x4803281a, 0x59a80024, - 0x803c1400, 0x480b5024, 0x803c0040, 0x04000002, - 0x483fc857, 0x59e40852, 0x59a80025, 0x80040580, - 0x04000004, 0x480bc857, 0x59e40052, 0x48035025, - 0x59940026, 0x803c0400, 0x48032826, 0x0201f800, - 0x00106021, 0x59940000, 0x82000580, 0x00000000, - 0x04020006, 0x59940026, 0x48032827, 0x497b2826, - 0x4a032800, 0x00000001, 0x4c0c0000, 0x59940007, - 0x80000d40, 0x0400001d, 0x59941006, 0x59940025, - 0x80081c80, 0x04001004, 0x04000003, 0x480f2806, - 0x0401f016, 0x80040840, 0x48072807, 0x82040580, - 0x000003e8, 0x04020007, 0x4c040000, 0x4c0c0000, - 0x59940008, 0x0801f800, 0x5c001800, 0x5c000800, - 0x800409c0, 0x04020004, 0x59940008, 0x0801f800, - 0x0401f006, 0x400c0000, 0x820c1c00, 0x0000000a, - 0x040027ed, 0x480f2806, 0x5c001800, 0x4d180000, - 0x59c40008, 0x8c000534, 0x04020025, 0x417a3000, - 0x83947c00, 0x00000009, 0x583c0001, 0x80000d40, - 0x04020008, 0x823c7c00, 0x00000003, 0x811a3000, - 0x83180580, 0x00000005, 0x040207f8, 0x0401f018, - 0x583c1000, 0x59940025, 0x80080480, 0x04001005, - 0x04000004, 0x48007800, 0x80000040, 0x04021010, - 0x80040840, 0x48047801, 0x04000008, 0x82000400, - 0x0000000a, 0x48007800, 0x040027fa, 0x82040500, - 0x0000007f, 0x0401f7e8, 0x583c0002, 0x4c3c0000, - 0x0801f800, 0x5c007800, 0x0401f7e3, 0x5c023000, - 0x59940019, 0x80001540, 0x04000008, 0x04002007, - 0x59940025, 0x80080480, 0x497b2819, 0x04001003, - 0x04000002, 0x48032819, 0x59940004, 0x80000d40, - 0x0400002a, 0x4c040000, 0x5994001c, 0x80000d40, - 0x04000013, 0x5994101b, 0x59940025, 0x80080480, - 0x04001005, 0x04000004, 0x4803281b, 0x80000040, - 0x0402100b, 0x80040840, 0x4807281c, 0x04020004, - 0x5994001d, 0x0801f800, 0x0401f005, 0x82000400, - 0x0000000a, 0x4803281b, 0x040027f7, 0x5c000800, - 0x59941003, 0x59940025, 0x80080480, 0x04001005, - 0x04000004, 0x48032803, 0x80000040, 0x0402100b, - 0x80040840, 0x48072804, 0x04020004, 0x59940005, - 0x0801f800, 0x0401f005, 0x82000400, 0x0000000a, - 0x48032803, 0x040027f7, 0x5994001f, 0x80000d40, - 0x04000013, 0x5994101e, 0x59940025, 0x80080480, - 0x04001005, 0x04000004, 0x4803281e, 0x80000040, - 0x0402100b, 0x80040840, 0x4807281f, 0x04020004, - 0x59940020, 0x0801f800, 0x0401f005, 0x82000400, - 0x00000001, 0x4803281e, 0x040027f7, 0x59940022, - 0x80000d40, 0x04000013, 0x59941021, 0x59940025, - 0x80080480, 0x04001005, 0x04000004, 0x48032821, - 0x80000040, 0x0402100b, 0x80040840, 0x48072822, - 0x04020004, 0x59940023, 0x0801f800, 0x0401f005, - 0x82000400, 0x0000000a, 0x48032821, 0x040027f7, - 0x59940824, 0x59940025, 0x80040480, 0x02001800, - 0x001005d8, 0x48032824, 0x59940000, 0x0c01f001, - 0x00105fb5, 0x00105fb7, 0x00105fdd, 0x59940024, - 0x80000000, 0x48032824, 0x4203e000, 0x70000000, - 0x1c01f000, 0x592c0406, 0x800000c2, 0x800008c4, - 0x80040c00, 0x592c040a, 0x48066206, 0x82000d00, - 0x00000003, 0x02000000, 0x0010615e, 0x8c000500, - 0x04020029, 0x8c00051e, 0x02000000, 0x00106139, - 0x82000d00, 0x000000c0, 0x02020000, 0x0010612f, - 0x82000d00, 0x00002020, 0x02020000, 0x0010612c, - 0x813e79c0, 0x02020000, 0x0010612c, 0x592c0c0c, - 0x800409c0, 0x02020000, 0x0010612c, 0x59300a03, - 0x82040d80, 0x00000007, 0x02020000, 0x0010612c, - 0x4a026203, 0x00000003, 0x4a026403, 0x00000043, - 0x0201f800, 0x000200c9, 0x82080d40, 0x80003465, - 0x48066004, 0x497a6000, 0x59bc00ea, 0x8c000516, - 0x040207fe, 0x83300400, 0xa0000000, 0x480378e1, - 0x1c01f000, 0x8c000502, 0x02020000, 0x00106181, - 0x8c00051e, 0x0400000e, 0x82000d00, 0x000000c0, - 0x04000005, 0x82040d80, 0x000000c0, 0x02020000, - 0x00106186, 0x82000d00, 0x00002020, 0x82040d80, - 0x00002020, 0x02000000, 0x0010614d, 0x592c0207, - 0x80000040, 0x02020000, 0x00106157, 0x592c180d, - 0x800c19c0, 0x02020000, 0x00106157, 0x592c180f, - 0x59300007, 0x82000540, 0x00000011, 0x480e6011, - 0x48026007, 0x4a026203, 0x00000004, 0x4a026403, - 0x00000042, 0x42000800, 0x80002001, 0x0401f02a, - 0x5c000000, 0x4c000000, 0x4803c857, 0x4807c857, - 0x0401f003, 0x42000800, 0x00000001, 0x59325808, - 0x832c0500, 0x00ff0000, 0x0400000d, 0x592c0000, - 0x48065a06, 0x48026008, 0x592c040a, 0x8c000510, - 0x04020008, 0x0201f800, 0x000202ce, 0x417a7800, - 0x59300008, 0x80025d40, 0x0402078f, 0x1c01f000, - 0x456a5800, 0x412ed000, 0x815eb800, 0x59c80000, - 0x82000540, 0x00001200, 0x48039000, 0x0401f7f4, - 0x59840000, 0x80000540, 0x04020002, 0x1c01f000, - 0x59840003, 0x80000540, 0x02020000, 0x001061fe, - 0x1c01f000, 0x48066004, 0x59bc00ea, 0x8c000516, - 0x040207fe, 0x83300400, 0x40000000, 0x480378e1, - 0x1c01f000, 0x59bc00ea, 0x82001500, 0xb0000018, - 0x02020000, 0x00106c81, 0x8c000510, 0x0400002a, - 0x59bc10e0, 0x82080500, 0xfffff000, 0x0402000a, - 0x80080108, 0x820a3500, 0x0000000f, 0x4803c857, - 0x1201f000, 0x00106c87, 0x84000510, 0x48026004, - 0x0401f016, 0x840a653e, 0x59300004, 0x8c000520, - 0x040007fa, 0x82000500, 0xfffefeff, 0x48026004, - 0x8c08153e, 0x04020005, 0x42027000, 0x00000013, - 0x0401f859, 0x0401f009, 0x59300004, 0x8c000514, - 0x04000003, 0x0401ffb0, 0x0401f02f, 0x42027000, - 0x00000049, 0x0401f850, 0x59bc00ea, 0x82001500, - 0xb0000018, 0x02020000, 0x00106c81, 0x8c000510, - 0x040207d8, 0x1c01f000, 0x83640480, 0x00000010, - 0x0400101a, 0x41626000, 0x41580000, 0x59300a03, - 0x82040d80, 0x00000000, 0x04000008, 0x83326400, - 0x00000024, 0x81300c80, 0x040017f9, 0x42026000, - 0x0010d1c0, 0x0401f7f6, 0x8166c840, 0x83300c00, - 0x00000024, 0x80040480, 0x04021005, 0x4006c000, - 0x4a026203, 0x00000008, 0x1c01f000, 0x837ac540, - 0x0010d1c0, 0x0401f7fb, 0x42000000, 0x0010b854, - 0x0201f800, 0x0010aa47, 0x4967c857, 0x80026580, - 0x1c01f000, 0x83300480, 0x0010d1c0, 0x02001800, - 0x001005d8, 0x41580000, 0x81300480, 0x0402100c, - 0x04011000, 0x457a6000, 0x4a026202, 0x0000ffff, - 0x83300400, 0x00000003, 0x4803c840, 0x4a03c842, - 0x00000021, 0x8166c800, 0x1c01f000, 0x41540000, - 0x81300480, 0x02021800, 0x001005d8, 0x04011000, - 0x457a6000, 0x4a026202, 0x0000ffff, 0x83300400, - 0x00000003, 0x4803c840, 0x4a03c842, 0x00000021, - 0x59a80066, 0x49335065, 0x80000000, 0x48035066, - 0x1c01f000, 0x4d340000, 0x59326809, 0x59300406, - 0x82000500, 0x0000001f, 0x0c01f803, 0x5c026800, - 0x1c01f000, 0x00107966, 0x00107979, 0x00107993, - 0x000207c9, 0x001098f1, 0x0010990c, 0x0002083e, - 0x00107966, 0x00107979, 0x001064ee, 0x001079ac, - 0x00107966, 0x00107966, 0x00107966, 0x00107966, - 0x00107966, 0x001095a1, 0x0010a6c2, 0x00107966, - 0x00107966, 0x00107966, 0x00107966, 0x00107966, - 0x00107966, 0x00107966, 0x00107966, 0x00107966, - 0x00107966, 0x00107966, 0x00107966, 0x00107966, - 0x00107966, 0x59300203, 0x82000c80, 0x0000000e, - 0x02021800, 0x001005d8, 0x0c01f001, 0x001079aa, - 0x00108592, 0x000207dd, 0x00108720, 0x001087b9, - 0x001079aa, 0x001079aa, 0x001079aa, 0x00108577, - 0x001079aa, 0x001079aa, 0x001079aa, 0x001079aa, - 0x00108985, 0x83380480, 0x00000058, 0x04021007, - 0x83380480, 0x00000040, 0x04001004, 0x4d2c0000, - 0x0c01f803, 0x5c025800, 0x1c01f000, 0x0010861b, - 0x0010861b, 0x0010861b, 0x0010861b, 0x0010861b, - 0x0010861d, 0x001086bd, 0x0010861b, 0x0010861b, - 0x0010861b, 0x0010861b, 0x0010861b, 0x0010861b, - 0x0010861b, 0x0010861b, 0x0010861b, 0x0010861b, - 0x0010861b, 0x0010861b, 0x001086c1, 0x000207ff, - 0x0010861b, 0x001086c0, 0x001086c2, 0x59325808, - 0x59300811, 0x59301402, 0x59340200, 0x8c00050e, - 0x0402001c, 0x0401f826, 0x04000005, 0x4a025a04, - 0x00000103, 0x497a5c09, 0x0401f009, 0x4a025a04, - 0x00000103, 0x4a025a06, 0x00000000, 0x497a5c09, - 0x800409c0, 0x02020800, 0x00108785, 0x48065807, - 0x480a5c06, 0x0201f800, 0x000202c1, 0x5934000f, - 0x5934140b, 0x80081040, 0x04001002, 0x480a6c0b, - 0x80000540, 0x02020800, 0x00020253, 0x0401f75e, - 0x592c020a, 0x8c000502, 0x040007e9, 0x800409c0, - 0x040007e7, 0x592c0208, 0x8c00050e, 0x040207e4, - 0x4933c857, 0x0201f000, 0x0010920f, 0x592c020a, - 0x8c000500, 0x04000010, 0x59300015, 0x592c380f, - 0x801c3c80, 0x0400000c, 0x4a025a06, 0x00000015, - 0x8c1c3d3e, 0x04000005, 0x4a025a06, 0x00000007, - 0x801c3880, 0x801c3800, 0x481fc857, 0x821c0d40, - 0x00000000, 0x1c01f000, 0x59300203, 0x82003480, - 0x0000000e, 0x02021800, 0x001005d8, 0x0c01f001, - 0x0010992b, 0x00020852, 0x00109fba, 0x00109fc8, - 0x0002086e, 0x0010992b, 0x0010a0a8, 0x0002088d, - 0x0010992b, 0x0010992b, 0x0010992b, 0x0010992b, - 0x0010992b, 0x0010992b, 0x83380580, 0x00000013, - 0x02020000, 0x00109f42, 0x59300403, 0x82027480, - 0x00000044, 0x02021800, 0x001005d8, 0x82000480, - 0x00000040, 0x02001800, 0x001005d8, 0x0c01f001, - 0x00109f9e, 0x00020864, 0x00109fa0, 0x00109fb2, - 0x59325808, 0x832c0500, 0x00ff0000, 0x04000005, - 0x592c0c0a, 0x8c040d1a, 0x02020000, 0x00109fad, - 0x0401fe91, 0x0401f710, 0x83380580, 0x00000048, - 0x04000007, 0x83380580, 0x00000053, 0x02000000, - 0x0010a04a, 0x0201f800, 0x001005d8, 0x5930001f, - 0x59301011, 0x59300809, 0x58040a00, 0x8c040d0e, - 0x02020000, 0x0010a026, 0x800811c0, 0x02020000, - 0x0010a033, 0x5930001f, 0x80000540, 0x02020000, - 0x0010a041, 0x59325808, 0x592c040a, 0x8c00051e, - 0x02000000, 0x0010a01c, 0x42027000, 0x00000041, - 0x0401f001, 0x83380480, 0x00000054, 0x02021800, - 0x001005d8, 0x83380480, 0x00000040, 0x02001000, - 0x0010a067, 0x0c01f001, 0x0010a073, 0x000208aa, - 0x0010a07f, 0x0010a086, 0x0010a073, 0x0010a073, - 0x0010a073, 0x0010a073, 0x0010a075, 0x0010a07a, - 0x0010a07a, 0x0010a073, 0x0010a073, 0x0010a073, - 0x0010a073, 0x0010a07a, 0x0010a073, 0x0010a07a, - 0x0010a073, 0x0010a075, 0x4a026203, 0x00000001, - 0x493a6403, 0x42000800, 0x80002042, 0x0401f672, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x14aa62b1, - 0x00000000, 0x00000000, 0x00000000, 0x00000005, - 0xfffffffb, 0x02800004, 0x00000000, 0x0000c000, - 0x0000071d, 0x073fca5a, 0x0705a5a5, 0x01928009, - 0x070ff0e1, 0x03800006, 0x04958010, 0x05308000, - 0x05008000, 0x0600902f, 0x04a004dc, 0x0202f051, - 0x042e4020, 0x018f021b, 0x033e5000, 0x03020000, - 0x078d0018, 0x0493041a, 0x0092041c, 0x038a0305, - 0x078b0303, 0x048e8010, 0x0678aae5, 0x06000001, - 0x07818174, 0x040010e6, 0x0448e0e6, 0x04818010, - 0x002fb008, 0x0448e0e6, 0x04818010, 0x060ff0e6, - 0x00580401, 0x054880ff, 0x04818010, 0x022a5001, - 0x030430d4, 0x06780043, 0x030e0000, 0x030450ff, - 0x06780043, 0x03019000, 0x058185c6, 0x027c0045, - 0x03020000, 0x06810037, 0x027c0045, 0x03040000, - 0x068100c7, 0x027c0045, 0x03080000, 0x0781061e, - 0x04908037, 0x029105c4, 0x010410a6, 0x0379ff41, - 0x037fffff, 0x072d6000, 0x07601241, 0x050f80ff, - 0x032fa009, 0x05600400, 0x050f80ff, 0x056c04ff, - 0x068105dc, 0x073fa009, 0x06000001, 0x0279ff02, - 0x0700ffff, 0x070ff0d1, 0x0179feff, 0x0700ffff, - 0x045c0402, 0x048185dc, 0x060ff0d0, 0x0179feff, - 0x0700ffff, 0x057dfeff, 0x0700ffff, 0x078105be, - 0x05600e41, 0x050f80ff, 0x032fa069, 0x07480000, - 0x068105d0, 0x06780043, 0x070000f0, 0x0781005f, - 0x037c00ff, 0x06000010, 0x0781005f, 0x038005cc, - 0x0379ff00, 0x070fffff, 0x06780043, 0x07f00000, - 0x075a0000, 0x020ef001, 0x028605ce, 0x05484000, - 0x02a1819e, 0x062d6001, 0x002fb001, 0x070ff069, - 0x01868072, 0x060ff079, 0x055c0441, 0x06810010, - 0x012fb000, 0x060560fb, 0x03800078, 0x060ff079, - 0x02868198, 0x070ff069, 0x055c0441, 0x06810010, - 0x060560fb, 0x0400d0d0, 0x062d6002, 0x0648300d, - 0x06810086, 0x070ff0d1, 0x062d6001, 0x045c040b, - 0x06810089, 0x05488000, 0x04818086, 0x072e500c, - 0x00208001, 0x05a004e1, 0x02800010, 0x062d6001, - 0x07f00000, 0x07f00000, 0x070ff0d1, 0x0179feff, - 0x070000ff, 0x055c040c, 0x058180bb, 0x0007b001, - 0x03079041, 0x0307a000, 0x06600a79, 0x050f80ff, - 0x053fa80a, 0x06000010, 0x072d5003, 0x078d0096, - 0x0307c003, 0x0007d004, 0x0107e005, 0x0307f006, - 0x02080007, 0x00081008, 0x01082009, 0x0308300a, - 0x0008400b, 0x0308500c, 0x068d00a1, 0x0678007a, - 0x07f00000, 0x010880ff, 0x03386000, 0x03010000, - 0x072e6300, 0x020ef07f, 0x02860010, 0x070ff07d, - 0x0450047c, 0x050f80ff, 0x002fa819, 0x068d00ae, - 0x02080001, 0x00081002, 0x0448807a, 0x068100b5, - 0x0379ff03, 0x070000ff, 0x01082003, 0x068d00b6, - 0x02386004, 0x03010000, 0x072e6c00, 0x02800010, - 0x06780043, 0x070000f0, 0x078105d7, 0x050020ff, - 0x027c0002, 0x06000010, 0x078100c3, 0x038005d7, - 0x0700c0d1, 0x0379ff0c, 0x070000ff, 0x0380008e, - 0x0204a051, 0x06780043, 0x070000f0, 0x037c00ff, - 0x06000010, 0x0781816a, 0x072d6000, 0x019485c0, - 0x050fb056, 0x044880e6, 0x04818010, 0x060ff0d0, - 0x0179feff, 0x0700ffff, 0x057dfeff, 0x0700ffff, - 0x078105be, 0x05a00212, 0x0349c0e4, 0x0781811d, - 0x070ff093, 0x050010ff, 0x070ff093, 0x045c0401, - 0x058180db, 0x02046092, 0x04002046, 0x04600202, - 0x00540401, 0x048280e6, 0x04500425, 0x070060ff, - 0x0730ffff, 0x0700000f, 0x0742000f, 0x05810190, - 0x07a005a6, 0x0648a002, 0x048180e9, 0x00047089, - 0x070ff047, 0x045c0443, 0x077800ff, 0x07f00000, - 0x0781818e, 0x07780047, 0x0500e000, 0x048185ad, - 0x070ff006, 0x01860117, 0x0179fe47, 0x0700000f, - 0x010480ff, 0x056c7048, 0x06818102, 0x007a0d4a, - 0x04003801, 0x0220f001, 0x0180010f, 0x07608e48, - 0x034a60ff, 0x0700f0ff, 0x074b88ff, 0x037000ff, - 0x07000600, 0x05500448, 0x074d00ff, 0x045a044a, - 0x0304a0ff, 0x070ff00f, 0x01540406, 0x05820117, - 0x04950120, 0x05a001bd, 0x02868123, 0x0134bfff, - 0x070fffff, 0x0104102e, 0x050fd041, 0x00800126, - 0x0595011d, 0x05a001bd, 0x0186011d, 0x0202f00e, - 0x052e4030, 0x040fd02f, 0x070fc0ff, 0x05a00218, - 0x02800010, 0x0400e02f, 0x042e4020, 0x0202f051, - 0x0004100e, 0x0004b00e, 0x050fd041, 0x024a6c46, - 0x04500423, 0x050070ff, 0x03620024, 0x050080ff, - 0x04004046, 0x0700500f, 0x03206000, 0x05601048, - 0x0700a0ff, 0x0700900a, 0x070ff005, 0x04500446, - 0x00540425, 0x04820157, 0x05601622, 0x050f80ff, - 0x063fa032, 0x06000002, 0x03203000, 0x01204000, - 0x03205000, 0x0120b000, 0x0320c000, 0x07601441, - 0x050f80ff, 0x043fa852, 0x06000001, 0x070ff056, - 0x056c02ff, 0x050fb0ff, 0x070560ff, 0x03079041, - 0x05600e41, 0x050f80ff, 0x073fa011, 0x0600003d, - 0x06780043, 0x07f00000, 0x065a007a, 0x010880ff, - 0x04a001b6, 0x058d0150, 0x0208a04a, 0x0108b04b, - 0x02386001, 0x03010000, 0x072e6300, 0x028000a8, - 0x0500d00a, 0x05500405, 0x014a68ff, 0x070090ff, - 0x0154040a, 0x0700c0ff, 0x0600a023, 0x0500b024, - 0x02206001, 0x05601622, 0x050f80ff, 0x063fa04a, - 0x06000002, 0x05601022, 0x050f80ff, 0x043fa819, - 0x06000001, 0x0600a00d, 0x0180013c, 0x06780043, - 0x070000f0, 0x050010ff, 0x027c0001, 0x07000030, - 0x078105b4, 0x027c0001, 0x06000020, 0x078105b4, - 0x038005cc, 0x054880ff, 0x06810010, 0x070ff056, - 0x050fb0ff, 0x044880e5, 0x0581017d, 0x044880e6, - 0x04818010, 0x00800183, 0x056c02ff, 0x050fb0ff, - 0x070560ff, 0x072e5300, 0x044880e6, 0x04818010, - 0x072d5003, 0x06780043, 0x07f00000, 0x010880ff, - 0x058d0187, 0x03386005, 0x03010000, 0x033e6000, - 0x0700000c, 0x052e5200, 0x02800010, 0x0120918e, - 0x018004e4, 0x01209190, 0x018004e4, 0x00209192, - 0x018004e4, 0x03209000, 0x018004e4, 0x01209196, - 0x018004e4, 0x00209198, 0x018004e4, 0x02493075, - 0x06810510, 0x0120919a, 0x018004e4, 0x06601e01, - 0x050f80ff, 0x063fa029, 0x06000008, 0x02015010, - 0x02016051, 0x00017051, 0x00011051, 0x05601a41, - 0x050f80ff, 0x053fa83a, 0x06000008, 0x05600e41, - 0x050f80ff, 0x01464000, 0x032fa00a, 0x07006011, - 0x05007012, 0x04008013, 0x07009014, 0x0600a015, - 0x0400b016, 0x0700c017, 0x07c00000, 0x072d5003, - 0x06601479, 0x050f80ff, 0x048d01b9, 0x063fa051, - 0x0600003e, 0x07c00000, 0x06005051, 0x0400e02c, - 0x0660060e, 0x050f80ff, 0x032fa009, 0x0379ff00, - 0x070000ff, 0x076c0000, 0x058101dd, 0x0660480e, - 0x0500e0ff, 0x034000ff, 0x01540427, 0x0582020a, - 0x03400005, 0x070ff005, 0x055c0428, 0x0481020e, - 0x01680e05, 0x056c0405, 0x068181bf, 0x040f8029, - 0x053fa809, 0x07000024, 0x06600649, 0x050f80ff, - 0x032fa009, 0x0379ff00, 0x070000ff, 0x076c0000, - 0x068181bf, 0x0400e049, 0x0340002d, 0x050f802b, - 0x053fa80a, 0x06000016, 0x0660480e, 0x0302c0ff, - 0x034000ff, 0x01540427, 0x0582020c, 0x072d6000, - 0x0460040e, 0x050f80ff, 0x0104e0d1, 0x0379ff4e, - 0x0700ffff, 0x062d6002, 0x032fa009, 0x0004d0d0, - 0x074b004d, 0x07780000, 0x07ffff00, 0x055a044d, - 0x070000ff, 0x00201008, 0x04002051, 0x06003051, - 0x05304000, 0x07000060, 0x03205009, 0x07006022, - 0x0460040e, 0x050f80ff, 0x032fa03a, 0x06603c0e, - 0x050f80ff, 0x073fa00a, 0x07000027, 0x050010d1, - 0x0460320e, 0x050f80ff, 0x012fa80a, 0x060ff00e, - 0x055c042e, 0x04810210, 0x07c00000, 0x0400e026, - 0x008001cb, 0x0202c026, 0x008001e6, 0x0500e02e, - 0x008001e6, 0x0400e051, 0x01800209, 0x0349c0e4, - 0x04810215, 0x07c00000, 0x013e4000, 0x070c0000, - 0x07c00000, 0x013e4000, 0x03080000, 0x07c00000, - 0x009702f4, 0x022a5002, 0x0790821d, 0x00910291, - 0x030400a6, 0x0678aae5, 0x06000001, 0x00a1860e, - 0x06600c40, 0x050f80ff, 0x032fa021, 0x074b0000, - 0x076c0600, 0x07818293, 0x05600403, 0x050f80ff, - 0x073fa009, 0x06000002, 0x0279ff04, 0x0700ffff, - 0x010440d7, 0x0179fe44, 0x0700ffff, 0x045c0404, - 0x07818295, 0x0349f044, 0x0681829e, 0x02495001, - 0x06818297, 0x060ff079, 0x045c0440, 0x0781823c, - 0x0644f07a, 0x002fb008, 0x060ff079, 0x045c0440, - 0x07818241, 0x0644f07a, 0x002fb008, 0x0648f001, - 0x07818288, 0x04600e40, 0x050f80ff, 0x06480001, - 0x04810257, 0x0448e001, 0x04810273, 0x02460001, - 0x0644f001, 0x012fa80a, 0x04008040, 0x05a004ee, - 0x0286828c, 0x05a004d8, 0x062da001, 0x013e4000, - 0x06000080, 0x06930013, 0x02920013, 0x02800010, - 0x0644f001, 0x012fa80a, 0x020ef002, 0x00860275, - 0x04600840, 0x050f80ff, 0x053fa809, 0x06000002, - 0x05780105, 0x00800440, 0x017c0105, 0x05000400, - 0x06818275, 0x06601e02, 0x050f80ff, 0x053fa809, - 0x06000002, 0x04602a40, 0x050f80ff, 0x070ff005, - 0x053fa809, 0x06000002, 0x055c0405, 0x06818275, - 0x04008040, 0x0045e008, 0x05a004d8, 0x00800251, - 0x0644f001, 0x012fa80a, 0x050020d8, 0x04600440, - 0x050f80ff, 0x073fa00a, 0x06000001, 0x06480001, - 0x07818281, 0x05308000, 0x03040000, 0x06009040, - 0x04a004dc, 0x00800251, 0x06a0060e, 0x054b0800, - 0x056a0700, 0x06600c40, 0x050f80ff, 0x032fa00a, - 0x00800251, 0x013e4000, 0x06000080, 0x01209288, - 0x018004e4, 0x06009008, 0x05308000, 0x05004000, - 0x04a004dc, 0x00800251, 0x02209002, 0x008002e5, - 0x03209000, 0x008002e5, 0x02209004, 0x008002e5, - 0x04a002fd, 0x062da001, 0x05308000, 0x05002000, - 0x06009040, 0x04a004dc, 0x02800013, 0x013e4000, - 0x06000080, 0x02495001, 0x078182db, 0x04600840, - 0x050f80ff, 0x053fa809, 0x06000001, 0x0721f000, - 0x0349f003, 0x058102aa, 0x0245f01f, 0x06000002, - 0x018602db, 0x07601400, 0x050f80ff, 0x012fa809, - 0x06480001, 0x058102db, 0x06602440, 0x050f80ff, - 0x012fa809, 0x020ef001, 0x038682db, 0x019b02db, - 0x050020d8, 0x062da001, 0x06303002, 0x05000430, - 0x04600440, 0x050f80ff, 0x073fa012, 0x06000001, - 0x028f82bf, 0x050040d8, 0x062da001, 0x07601e00, - 0x050f80ff, 0x073fa009, 0x06000001, 0x060ff004, - 0x00540402, 0x048202d9, 0x06005051, 0x06006051, - 0x06602240, 0x050f80ff, 0x063fa01a, 0x06000002, - 0x06600a40, 0x050f80ff, 0x073fa00a, 0x07000003, - 0x060ff040, 0x045a041f, 0x010eb0ff, 0x06930013, - 0x02920013, 0x02800010, 0x04004002, 0x018002c9, - 0x04a002fd, 0x062da001, 0x05308000, 0x07005000, - 0x06009040, 0x04a004dc, 0x050080d8, 0x05a004e1, - 0x062da001, 0x02800013, 0x050fd009, 0x050fd041, - 0x013e4000, 0x06000080, 0x05308000, 0x03013000, - 0x04a004dc, 0x010440d7, 0x0349f044, 0x048102f2, - 0x062da001, 0x008f02f2, 0x03e00000, 0x062da001, - 0x02800013, 0x0249c0e5, 0x06810013, 0x062da001, - 0x07f00000, 0x07f00000, 0x033e5000, 0x070c0000, - 0x018f02f6, 0x03800011, 0x050020d8, 0x04600440, - 0x050f80ff, 0x073fa00a, 0x06000001, 0x07c00000, - 0x002fb001, 0x03800306, 0x012fb000, 0x03075087, - 0x068d0307, 0x03386000, 0x03020000, 0x04482075, - 0x06810352, 0x0648a0e6, 0x07810347, 0x0642007f, - 0x06810345, 0x0340007e, 0x060ff038, 0x0154047e, - 0x02d00334, 0x0560027d, 0x050f80ff, 0x032fa009, - 0x030ef000, 0x02860504, 0x0107d000, 0x05600800, - 0x050f80ff, 0x032fa009, 0x03681e00, 0x04500420, - 0x050f80ff, 0x073fa009, 0x0700003f, 0x03800311, - 0x070ff07d, 0x0450047c, 0x050f80ff, 0x002fa819, - 0x078d0327, 0x02080001, 0x00081002, 0x0448807a, - 0x0781032e, 0x0379ff03, 0x070000ff, 0x01082003, - 0x068d032f, 0x02386004, 0x03010000, 0x072e6c00, - 0x02800352, 0x0380033a, 0x0380033c, 0x0280033e, - 0x02800340, 0x03800342, 0x03800344, 0x0727c005, - 0x02800323, 0x0627c008, 0x02800323, 0x0627c00b, - 0x02800323, 0x0627c00e, 0x02800323, 0x0727c011, - 0x02800323, 0x03800314, 0x052e6800, 0x02800352, - 0x044880e6, 0x07810533, 0x052e6200, 0x070ff088, - 0x0179feff, 0x070fffff, 0x04818501, 0x060ff083, - 0x0086836d, 0x033e6000, 0x07000003, 0x068d0352, - 0x07286000, 0x07f00000, 0x078d0355, 0x038c0306, - 0x0648c0e6, 0x05818372, 0x0448e0e6, 0x0781036a, - 0x004920e6, 0x07810365, 0x07a0056f, 0x05001088, - 0x00700101, 0x03100000, 0x00088001, 0x033e6000, - 0x07000088, 0x03800560, 0x02386001, 0x07030000, - 0x033e6000, 0x06000008, 0x028003f1, 0x02799075, - 0x0500040f, 0x06810010, 0x06601479, 0x050080ff, - 0x06309052, 0x0600003e, 0x02800376, 0x06602279, - 0x050080ff, 0x05309812, 0x07000041, 0x0648007a, - 0x0781037e, 0x04488075, 0x0581837e, 0x040f8008, - 0x070fa009, 0x0049107a, 0x01a183f3, 0x00798075, - 0x06000507, 0x05818521, 0x0448b075, 0x06810385, - 0x02493075, 0x0681050e, 0x0249c0e6, 0x048183e0, - 0x0648c0e6, 0x0581839a, 0x068d0389, 0x02386001, - 0x07030000, 0x0049107a, 0x07810390, 0x020ef083, - 0x0386039a, 0x06483075, 0x068103ef, 0x0678007a, - 0x07000035, 0x03a184cf, 0x05308000, 0x07060000, - 0x06009079, 0x04a004dc, 0x028003ef, 0x0448807a, - 0x0681039e, 0x06483075, 0x058104f9, 0x0448d07a, - 0x068103a2, 0x06483075, 0x058104f9, 0x068d03a2, - 0x02386001, 0x07030000, 0x0444e07a, 0x0648307a, - 0x048183c7, 0x0448707a, 0x068103ea, 0x0648f07a, - 0x078103b2, 0x05a004cf, 0x04008079, 0x05a004ee, - 0x008683c2, 0x05a004d8, 0x028003ef, 0x0560107b, - 0x050f80ff, 0x032fa009, 0x0349c000, 0x058183c0, - 0x04600e79, 0x050f80ff, 0x073fa00a, 0x0600003d, - 0x06600a79, 0x050f80ff, 0x053fa80a, 0x06000010, - 0x028003ef, 0x0046e07a, 0x028003ea, 0x06009008, - 0x05308000, 0x05004000, 0x04a004dc, 0x028003ef, - 0x0560167b, 0x050f80ff, 0x032fa011, 0x070ff000, - 0x04500401, 0x030460ff, 0x060ff025, 0x00540446, - 0x078203d1, 0x030460ff, 0x04092046, 0x05a00218, - 0x06600679, 0x050f80ff, 0x00201007, 0x012fa80a, - 0x0046047a, 0x034630ff, 0x050020ff, 0x06003051, - 0x04600e79, 0x050f80ff, 0x073fa012, 0x06000001, - 0x028003ef, 0x033e6a00, 0x0202000e, 0x02079051, - 0x07000088, 0x078d03e4, 0x0744c000, 0x01088000, - 0x03386006, 0x03010000, 0x02800010, 0x05a004cf, - 0x05308000, 0x03020000, 0x06009079, 0x04a004dc, - 0x033e6a00, 0x0302000a, 0x02079051, 0x02800010, - 0x04603e79, 0x050f80ff, 0x032fa009, 0x070ff000, - 0x0186040c, 0x057dfeff, 0x07ffffff, 0x0581040c, - 0x050f8000, 0x012fa811, 0x0079fe02, 0x070000ff, - 0x077d66ff, 0x060000dc, 0x0781840c, 0x060ff001, - 0x0286840d, 0x064b0002, 0x06420002, 0x060ff002, - 0x05500400, 0x050f80ff, 0x05004084, 0x073fa00a, - 0x06000002, 0x07c00000, 0x04600201, 0x050f80ff, - 0x073fa009, 0x06000001, 0x0079fe02, 0x070000ff, - 0x077d72ff, 0x070000dd, 0x0781840c, 0x064b0002, - 0x06420002, 0x06000001, 0x01800406, 0x0605004c, - 0x0180041e, 0x0493041a, 0x04a004d5, 0x054bc450, - 0x05810421, 0x01d00422, 0x01800421, 0x00800432, - 0x00800434, 0x00800432, 0x008004a7, 0x0180043f, - 0x00800434, 0x01800471, 0x00800432, 0x00800432, - 0x008004ab, 0x00800432, 0x018004af, 0x008004c4, - 0x01800488, 0x00800432, 0x00800432, 0x00209432, - 0x018004e4, 0x0379ff50, 0x070fffff, 0x060ff079, - 0x055c0450, 0x048104a4, 0x002fb008, 0x060ff079, - 0x055c0450, 0x058104a3, 0x04a004c7, 0x0180049c, - 0x0179fe50, 0x070fffff, 0x070050ff, 0x060ff079, - 0x055c0405, 0x04810449, 0x002fb008, 0x060ff079, - 0x055c0405, 0x078184a0, 0x070ff087, 0x017980ff, - 0x06000507, 0x06818451, 0x02203040, 0x05002087, - 0x0049d002, 0x0481046b, 0x04930458, 0x01257000, - 0x073c3fff, 0x0700000f, 0x052e4003, 0x072e5030, - 0x0304c050, 0x02400057, 0x06740057, 0x06000002, - 0x06820016, 0x04002083, 0x07003084, 0x04004085, - 0x06602279, 0x050f80ff, 0x063fa01a, 0x06000001, - 0x05a004cf, 0x07a00578, 0x033e6a00, 0x0302000a, - 0x062e5020, 0x003e4002, 0x07000a00, 0x028003f1, - 0x07420003, 0x0781844e, 0x00798002, 0x06000507, - 0x06818451, 0x0180045c, 0x05930478, 0x01257000, - 0x073c3fff, 0x0700000f, 0x052e4003, 0x072e5030, - 0x0304c050, 0x067800e6, 0x07000041, 0x0581047d, - 0x07a00581, 0x04818016, 0x002fb008, 0x067800e6, - 0x07000041, 0x04810483, 0x07a00581, 0x04818016, - 0x062e5020, 0x003e4002, 0x07000a00, 0x03e00000, - 0x02800010, 0x0379ff50, 0x070fffff, 0x060ff079, - 0x055c0450, 0x0781848e, 0x0245507a, 0x002fb008, - 0x060ff079, 0x055c0450, 0x07818493, 0x0245507a, - 0x002fb008, 0x05600e50, 0x050f80ff, 0x012fa809, - 0x02455001, 0x05600e50, 0x050f80ff, 0x012fa80a, - 0x0080049d, 0x002fb008, 0x003e4002, 0x07000a00, - 0x02800016, 0x079384a3, 0x062e5020, 0x042e4002, - 0x002fb008, 0x013e4000, 0x05000e00, 0x02800016, - 0x0179fe50, 0x070fffff, 0x010210ff, 0x02800016, - 0x0179fe50, 0x070fffff, 0x050340ff, 0x0080049d, - 0x0179fe50, 0x070fffff, 0x0102e0ff, 0x0760282e, - 0x050f80ff, 0x05222000, 0x07223000, 0x05224000, - 0x07225000, 0x07226000, 0x05227000, 0x05228000, - 0x07229000, 0x0722a000, 0x0522b000, 0x063fa051, - 0x07000011, 0x0202c026, 0x0522d000, 0x052e400c, - 0x02800016, 0x030430d4, 0x062e5008, 0x00800176, - 0x05600e50, 0x050f80ff, 0x032fa009, 0x03460000, - 0x018004d2, 0x0246007a, 0x0045207a, 0x008004d0, - 0x0246007a, 0x0600007a, 0x04600e79, 0x050f80ff, - 0x032fa00a, 0x07c00000, 0x029284d5, 0x070500e1, - 0x07c00000, 0x0245f008, 0x048404d9, 0x020e0008, - 0x07c00000, 0x070ff009, 0x065a0008, 0x058404de, - 0x020e0008, 0x07c00000, 0x058404e1, 0x020e0008, - 0x07c00000, 0x05308000, 0x0500d000, 0x04a004dc, - 0x04a004e9, 0x02800010, 0x052e4300, 0x072e500c, - 0x073c3fff, 0x0700000f, 0x07c00000, 0x06602208, - 0x050f80ff, 0x032fa011, 0x076a0000, 0x068184f7, - 0x066a0001, 0x048104f7, 0x04002051, 0x07c00000, - 0x00202001, 0x07c00000, 0x0648307a, 0x00a18608, - 0x05a004cc, 0x05308000, 0x05001000, 0x06009079, - 0x04a004dc, 0x03800560, 0x0249c0e6, 0x058104f9, - 0x0280036d, 0x0648307a, 0x07818196, 0x05a004cf, - 0x05308000, 0x03013000, 0x03209006, 0x04a004dc, - 0x033e6000, 0x07030000, 0x02800345, 0x02490075, - 0x0781051e, 0x04002089, 0x04780102, 0x07f00000, - 0x05001088, 0x07a0056f, 0x04740101, 0x03100000, - 0x060ff002, 0x045c0401, 0x0481851f, 0x00088001, - 0x033e6000, 0x070000c0, 0x0380055c, 0x07f00000, - 0x0220951f, 0x018004e4, 0x0648307a, 0x07810527, - 0x06780075, 0x06000007, 0x0581852e, 0x06a00608, - 0x06486075, 0x06818194, 0x02490075, 0x0781819a, - 0x04487075, 0x05818536, 0x0280053d, 0x05308000, - 0x03010000, 0x06009079, 0x04a004dc, 0x02800010, - 0x0448e0e6, 0x04818352, 0x00800192, 0x05308000, - 0x0500e000, 0x06009079, 0x04a004dc, 0x04008089, - 0x05a004e1, 0x0380055c, 0x05a004cc, 0x05308000, - 0x0700f000, 0x06009079, 0x07000088, 0x06a00545, - 0x04a004dc, 0x02800010, 0x03386000, 0x07030000, - 0x07f00000, 0x078d0548, 0x033e6a00, 0x0202000e, - 0x02079051, 0x0448b075, 0x07810553, 0x02493075, - 0x07810553, 0x05301005, 0x03010000, 0x03800555, - 0x05301006, 0x03010000, 0x05002087, 0x06485002, - 0x05818555, 0x0744c000, 0x01088000, 0x02086001, - 0x07c00000, 0x05001088, 0x07a0056f, 0x0644c001, - 0x00088001, 0x033e6a00, 0x0202000e, 0x004920e6, - 0x05818565, 0x02079051, 0x078d0565, 0x060ff089, - 0x034990ff, 0x0781056c, 0x03386005, 0x03010000, - 0x02800010, 0x03386006, 0x03010000, 0x02800010, - 0x078d056f, 0x03386000, 0x07030000, 0x07f00000, - 0x068d0573, 0x070ff087, 0x074850ff, 0x05818574, - 0x07c00000, 0x078d0578, 0x02386001, 0x07030000, - 0x07f00000, 0x068d057c, 0x070ff087, 0x074850ff, - 0x0581857d, 0x07c00000, 0x05002087, 0x0049d002, - 0x05818590, 0x002fb008, 0x067800e6, 0x07000041, - 0x002fb008, 0x05818590, 0x07a005a6, 0x0448e002, - 0x07810593, 0x0648a002, 0x0481859d, 0x06486002, - 0x06810597, 0x02400057, 0x056a02ff, 0x07c00000, - 0x07a005a6, 0x06788102, 0x06000004, 0x05818590, - 0x04002089, 0x070ff0d4, 0x045c0402, 0x077800ff, - 0x07f00000, 0x05818590, 0x00202010, 0x038c0590, - 0x07f00000, 0x06420002, 0x0481859e, 0x07a00578, - 0x033e6a00, 0x0302000a, 0x07c00000, 0x07f00000, - 0x060ff0a2, 0x050020ff, 0x060ff0a2, 0x045c0402, - 0x048185a7, 0x07c00000, 0x05a00218, 0x03495047, - 0x078105b2, 0x0320901d, 0x02800604, 0x0220901f, - 0x02800604, 0x014980e4, 0x04818010, 0x013e4000, - 0x07003000, 0x05600e35, 0x050f80ff, 0x07a006fc, - 0x01208003, 0x05a004e1, 0x038005cc, 0x03209009, - 0x02800604, 0x03209011, 0x02800604, 0x02209007, - 0x02800604, 0x03209003, 0x02800604, 0x00498043, - 0x058185be, 0x00497043, 0x048185c2, 0x02209001, - 0x02800604, 0x0220900d, 0x02800604, 0x0320900f, - 0x02800604, 0x03493000, 0x068105d5, 0x027c0045, - 0x070a0000, 0x078105de, 0x0220900b, 0x02800604, - 0x02209013, 0x05308000, 0x01012000, 0x04a004dc, - 0x00800183, 0x03209005, 0x02800604, 0x072e500c, - 0x00208002, 0x05a004e1, 0x02800010, 0x02209015, - 0x02800604, 0x072d6000, 0x05308000, 0x05007000, - 0x07f00000, 0x070090d1, 0x0379ff09, 0x0700ffff, - 0x04a004dc, 0x03209017, 0x02800604, 0x033e5000, - 0x06000080, 0x02209019, 0x02800604, 0x072d6000, - 0x033e5000, 0x06000080, 0x07f00000, 0x060ff0d0, - 0x0179feff, 0x0700ffff, 0x057dfeff, 0x0700ffff, - 0x04818010, 0x02400058, 0x00642058, 0x06820010, - 0x033e5000, 0x06000080, 0x04058051, 0x0320901b, - 0x02800604, 0x05308000, 0x01012000, 0x04a004dc, - 0x00800176, 0x05a00218, 0x05308000, 0x05008000, - 0x06009079, 0x04a004dc, 0x07c00000, 0x034900e4, - 0x05818618, 0x013e4000, 0x070000c0, 0x07f00000, - 0x034900e4, 0x04818616, 0x07c00000, 0x013e4000, - 0x06000080, 0x07f00000, 0x07f00000, 0x07f00000, - 0x034900e4, 0x06810610, 0x03800618, 0x072d6000, - 0x00498043, 0x06810632, 0x060ff0d0, 0x0179feff, - 0x0700ffff, 0x057dfeff, 0x0700ffff, 0x058185e2, - 0x050f8030, 0x032fa009, 0x0379ff00, 0x0700ffff, - 0x070ff0d1, 0x0179feff, 0x0700ffff, 0x055c0400, - 0x078105e2, 0x04004051, 0x0280067a, 0x06a006dc, - 0x062d6001, 0x020ef004, 0x038605e4, 0x06600004, - 0x050f80ff, 0x032fa009, 0x074b0000, 0x05002000, - 0x0769ff00, 0x01640800, 0x078205e4, 0x01640e00, - 0x058285e4, 0x070ff036, 0x045c0404, 0x0581864d, - 0x072d6000, 0x050f8030, 0x032fa009, 0x0379ff00, - 0x0700ffff, 0x070ff0d1, 0x0179feff, 0x0700ffff, - 0x055c0400, 0x078105e2, 0x04482034, 0x078105ff, - 0x06483034, 0x058185ff, 0x070ff0d4, 0x077800ff, - 0x070000f0, 0x037c00ff, 0x06000010, 0x0681067a, - 0x06a006d6, 0x024900e5, 0x0681065d, 0x033e5000, - 0x06000080, 0x02800010, 0x04601c04, 0x050f80ff, - 0x053fa809, 0x06000020, 0x030ef041, 0x038605ee, - 0x062d6002, 0x05602a41, 0x050f80ff, 0x012fa809, - 0x060ff0d0, 0x074b00ff, 0x045c0401, 0x05818678, - 0x062d6001, 0x07602841, 0x050f80ff, 0x053fa809, - 0x06000001, 0x070ff0d1, 0x054b80ff, 0x074b0003, - 0x055c0403, 0x05818678, 0x033e5000, 0x06000080, - 0x0080070e, 0x07600041, 0x0280065e, 0x06a006d6, - 0x024900e5, 0x06810680, 0x033e5000, 0x06000080, - 0x02800010, 0x06a006c2, 0x030ef041, 0x028605f2, - 0x04058051, 0x072d6000, 0x05601041, 0x050f80ff, - 0x012fa809, 0x0600a0d0, 0x0500b0d1, 0x062d6001, - 0x07f00000, 0x07f00000, 0x0600c0d0, 0x0500d0d1, - 0x062d6002, 0x0279ff0d, 0x07ff0000, 0x044d800d, - 0x060ff0d0, 0x074b00ff, 0x065a000d, 0x06601201, - 0x050f80ff, 0x073fa022, 0x07000005, 0x0079fe0d, - 0x070000ff, 0x050020ff, 0x05602a41, 0x050f80ff, - 0x073fa00a, 0x06000001, 0x020ef004, 0x028606bf, - 0x04601c04, 0x050f80ff, 0x053fa809, 0x06000001, - 0x050f80ff, 0x053fa80a, 0x06000020, 0x07602841, - 0x050f80ff, 0x073fa009, 0x06000001, 0x0279ff02, - 0x070000ff, 0x0678000d, 0x0700ff00, 0x065a0002, - 0x07602841, 0x050f80ff, 0x073fa00a, 0x06000001, - 0x07600041, 0x050f80ff, 0x053fa80a, 0x06000001, - 0x07601241, 0x050f80ff, 0x073fa00a, 0x06000002, - 0x033e5000, 0x06000080, 0x0080070e, 0x040f8032, - 0x073fa011, 0x06000001, 0x060ff002, 0x055c0403, - 0x058186ca, 0x00041051, 0x07c00000, 0x04600402, - 0x04500432, 0x050f80ff, 0x053fa809, 0x06000020, - 0x00400402, 0x01680eff, 0x070030ff, 0x040f8032, - 0x053fa80a, 0x06000001, 0x07c00000, 0x024900e5, - 0x068106d9, 0x07c00000, 0x033e5000, 0x070000c0, - 0x07c00000, 0x05004036, 0x060000d0, 0x0179fe00, - 0x0700ffff, 0x057dfeff, 0x0700ffff, 0x068106fb, - 0x070000d1, 0x0379ff00, 0x0700ffff, 0x06005051, - 0x060ff031, 0x05500405, 0x050f80ff, 0x073fa009, - 0x06000002, 0x020ef004, 0x038606f5, 0x04600404, - 0x050f80ff, 0x012fa809, 0x0079fe01, 0x0700ffff, - 0x055c0400, 0x068106fb, 0x01400405, 0x070050ff, - 0x057de0ff, 0x06000007, 0x058186e7, 0x04004051, - 0x07c00000, 0x072d6000, 0x07f00000, 0x07f00000, - 0x000110d0, 0x010120d1, 0x062d6001, 0x07f00000, - 0x07f00000, 0x020130d0, 0x010140d1, 0x062d6002, - 0x010170d4, 0x07f00000, 0x020150d0, 0x030160d1, - 0x053fa83a, 0x06000008, 0x07c00000, 0x07600c41, - 0x050f80ff, 0x073fa009, 0x06000001, 0x04780102, - 0x07ffff00, 0x046a0702, 0x050f80ff, 0x073fa00a, - 0x06000001, 0x05600e41, 0x050f80ff, 0x032fa069, - 0x03800053, 0xba6b4e34, 0x02800004, 0x00000000, - 0x00008000, 0x00000518, 0x040f801f, 0x012fa8c9, - 0x040f801f, 0x073fa081, 0x06000010, 0x03200005, - 0x07420000, 0x050fb000, 0x040f801f, 0x073fa011, - 0x06000038, 0x040f801f, 0x053fa859, 0x0700003a, - 0x050fe000, 0x0581800a, 0x0684003d, 0x04958019, - 0x030e0011, 0x072e4200, 0x03800014, 0x0291001f, - 0x050010c0, 0x04482001, 0x058180e8, 0x06483001, - 0x0781814b, 0x02920029, 0x068b0029, 0x018a0150, - 0x050010c0, 0x06780001, 0x050007c0, 0x06818223, - 0x06780001, 0x0500f800, 0x07818263, 0x03910030, - 0x040fe029, 0x03860030, 0x076c001d, 0x04810294, - 0x076c0a1d, 0x048102b9, 0x0292003d, 0x040fe02f, - 0x0286003d, 0x06000013, 0x050fb000, 0x066c0073, - 0x068103c2, 0x0297003d, 0x014920e4, 0x0481803d, - 0x03400000, 0x076c0a00, 0x04818034, 0x0796003f, - 0x03b900b8, 0x05908014, 0x010170e1, 0x07780017, - 0x03e00000, 0x06810092, 0x050010ff, 0x0179fe17, - 0x031fffff, 0x070000ff, 0x05600800, 0x050f80ff, - 0x073fa009, 0x06000001, 0x06780002, 0x02800040, - 0x037c00ff, 0x03800000, 0x0681005e, 0x0249f002, - 0x068100ab, 0x0448e002, 0x0681005e, 0x07600c00, - 0x050f80ff, 0x073fa009, 0x06000001, 0x06780002, - 0x07ffff00, 0x037c00ff, 0x05000200, 0x048180ab, - 0x064bd401, 0x03d00060, 0x038000a9, 0x02800068, - 0x03800072, 0x0280007c, 0x02800086, 0x03800090, - 0x038000a9, 0x038000a9, 0x050fe027, 0x0186806c, - 0x01028000, 0x0380006f, 0x07600027, 0x050f80ff, - 0x032fa00a, 0x01027000, 0x02400029, 0x028000ab, - 0x040fe025, 0x00868076, 0x03026000, 0x02800079, - 0x06600025, 0x050f80ff, 0x032fa00a, 0x03025000, - 0x02400029, 0x028000ab, 0x050fe021, 0x00868080, - 0x01022000, 0x02800083, 0x07600021, 0x050f80ff, - 0x032fa00a, 0x01021000, 0x02400029, 0x028000ab, - 0x040fe023, 0x0086808a, 0x01024000, 0x0380008d, - 0x06600023, 0x050f80ff, 0x032fa00a, 0x03023000, - 0x02400029, 0x028000ab, 0x06a000c8, 0x028000ab, - 0x01640817, 0x058280a9, 0x070ff017, 0x03d00096, - 0x0280009e, 0x038000a0, 0x038000a3, 0x038000a6, - 0x038000a9, 0x038000a9, 0x038000a9, 0x038000a9, - 0x03e00000, 0x03800014, 0x059080a0, 0x030160e1, - 0x028000ab, 0x059080a3, 0x030150e1, 0x028000ab, - 0x059080a6, 0x010140e1, 0x028000ab, 0x060fc013, - 0x06a00510, 0x03800014, 0x072e4800, 0x07000012, - 0x038000bb, 0x0747f000, 0x05600800, 0x050f80ff, - 0x012fa809, 0x0249f001, 0x078100bb, 0x01012000, - 0x052e4c00, 0x07c00000, 0x070000eb, 0x0349f000, - 0x058180af, 0x05600800, 0x050f80ff, 0x012fa809, - 0x0448e001, 0x068100c1, 0x07c00000, 0x0079c101, - 0x07ffffff, 0x027a4b01, 0x03800000, 0x05600800, - 0x050f80ff, 0x012fa80a, 0x07600c00, 0x050f80ff, - 0x012fa821, 0x06780001, 0x07ffff00, 0x037c00ff, - 0x05000700, 0x078100dd, 0x06601804, 0x070030ff, - 0x050f80ff, 0x012fa809, 0x05002000, 0x050f8003, - 0x073fa00a, 0x06000001, 0x040fe001, 0x038600de, - 0x04600201, 0x050f80ff, 0x032fa00a, 0x07c00000, - 0x050fe02e, 0x008680e3, 0x0102e000, 0x0302f000, - 0x038000e7, 0x0760002e, 0x050f80ff, 0x032fa00a, - 0x0102e000, 0x07c00000, 0x022c0004, 0x056c041d, - 0x078100fc, 0x056c021d, 0x04810113, 0x056c081d, - 0x04810125, 0x076c061d, 0x0581013f, 0x0521d000, - 0x0202c013, 0x0202a013, 0x02020013, 0x0460021a, - 0x050f80ff, 0x053fa80a, 0x07000009, 0x03b600ac, - 0x0484801f, 0x0280003d, 0x040fe02a, 0x028600f2, - 0x06000013, 0x04001013, 0x0560102b, 0x050f80ff, - 0x032fa012, 0x06420029, 0x0660002a, 0x050f80ff, - 0x053fa809, 0x06000001, 0x050fe003, 0x00860110, - 0x01028003, 0x0660002a, 0x050f80ff, 0x053fa80a, - 0x07000009, 0x00800140, 0x00028013, 0x00027013, - 0x00800140, 0x040fe02a, 0x028600f1, 0x06420029, - 0x0660002a, 0x050f80ff, 0x053fa809, 0x06000001, - 0x050fe003, 0x01860122, 0x03026003, 0x0660002a, - 0x050f80ff, 0x053fa80a, 0x07000009, 0x00800140, - 0x02026013, 0x02025013, 0x00800140, 0x040fe02a, - 0x028600f1, 0x06420029, 0x0660002a, 0x050f80ff, - 0x053fa809, 0x06000001, 0x050fe003, 0x00860134, - 0x01022003, 0x0660002a, 0x050f80ff, 0x053fa80a, - 0x07000009, 0x01800136, 0x00022013, 0x00021013, - 0x0647f020, 0x007a0120, 0x04000101, 0x04a00285, - 0x0400802a, 0x05a004f5, 0x009480f1, 0x0521d005, - 0x028000f2, 0x038000fa, 0x0647f020, 0x06486020, - 0x06818145, 0x04a00285, 0x028000f1, 0x007a0120, - 0x04000101, 0x04a00285, 0x0400802a, 0x05a004f5, - 0x028000f1, 0x040fd02a, 0x052e4003, 0x00208010, - 0x05a004f5, 0x038000fa, 0x00018098, 0x07480018, - 0x06818161, 0x05481018, 0x0781815f, 0x05482018, - 0x0681815d, 0x07483018, 0x0681815b, 0x002fb004, - 0x00800162, 0x012fb003, 0x00800162, 0x002fb002, - 0x00800162, 0x002fb001, 0x00800162, 0x012fb000, - 0x0179fe78, 0x070000ff, 0x030190ff, 0x00017086, - 0x058b0166, 0x03385000, 0x03020000, 0x07780017, - 0x00430407, 0x078181ee, 0x046c0419, 0x048101a2, - 0x046c0219, 0x05810172, 0x07219000, 0x00800186, - 0x07219000, 0x07483017, 0x0481018c, 0x05482017, - 0x05810193, 0x0448b075, 0x06818186, 0x06601476, - 0x050f80ff, 0x073fa022, 0x0600003e, 0x06000080, - 0x05001081, 0x05002082, 0x06003083, 0x05004084, - 0x04601c76, 0x050f80ff, 0x022fa02a, 0x07219000, - 0x07780078, 0x07ffff00, 0x045a0419, 0x010780ff, - 0x0484801f, 0x0280003d, 0x040fe07f, 0x0086019b, - 0x05a001bb, 0x00920186, 0x040fe07f, 0x07a681bb, - 0x00800186, 0x0560107b, 0x050f80ff, 0x032fa009, - 0x0744f000, 0x0560107b, 0x050f80ff, 0x032fa00a, - 0x00800179, 0x052e400c, 0x040080fb, 0x046aa108, - 0x06009076, 0x04002075, 0x05a004fc, 0x00800186, - 0x06219001, 0x05482017, 0x058101af, 0x058b01a5, - 0x060ff086, 0x0349f0ff, 0x07818165, 0x07483017, - 0x058101ac, 0x050fd0ff, 0x040fe07f, 0x07a681bb, - 0x00800186, 0x05004084, 0x05a00205, 0x00920186, - 0x070ff07d, 0x0450047c, 0x056004ff, 0x050f80ff, - 0x032fa009, 0x070ff000, 0x00540479, 0x030790ff, - 0x01800193, 0x060ff079, 0x0054047a, 0x058201e7, - 0x058101e7, 0x070ff07d, 0x0450047c, 0x050f80ff, - 0x002fa819, 0x058b01c3, 0x02080001, 0x00081002, - 0x01082003, 0x048b01c7, 0x03385000, 0x03010000, - 0x02400019, 0x070ff003, 0x04500479, 0x030790ff, - 0x0340007e, 0x0642007f, 0x058101e7, 0x070ff07e, - 0x050f80ff, 0x032fa009, 0x050fe000, 0x028681e6, - 0x070ff07d, 0x056002ff, 0x050f80ff, 0x032fa009, - 0x0107d000, 0x018601e8, 0x0560087d, 0x050f80ff, - 0x032fa009, 0x0569fe00, 0x0550041b, 0x050f80ff, - 0x032fa009, 0x0107e000, 0x070ff07e, 0x018001d2, - 0x0307c000, 0x07c00000, 0x052e400c, 0x040080fb, - 0x046aa108, 0x06009076, 0x04002075, 0x018004fc, - 0x040fd076, 0x050fd017, 0x060ff086, 0x077800ff, - 0x07000060, 0x037c00ff, 0x07000060, 0x078181f0, - 0x07780078, 0x07ffff00, 0x045a0419, 0x010780ff, - 0x06601476, 0x050f80ff, 0x073fa022, 0x0600003e, - 0x052e400c, 0x040080fb, 0x066a8108, 0x06009076, - 0x04002075, 0x05a004fc, 0x02800029, 0x0240007f, - 0x0742007e, 0x050f807e, 0x032fa009, 0x050fe000, - 0x0286821f, 0x070ff07d, 0x055c047b, 0x05810214, - 0x0760007d, 0x050f80ff, 0x032fa009, 0x050fe000, - 0x03868214, 0x070ff07b, 0x0107d0ff, 0x0560087d, - 0x050f80ff, 0x032fa009, 0x03681e00, 0x0450041c, - 0x0107e0ff, 0x050f80ff, 0x032fa009, 0x050fe000, - 0x01860221, 0x0307c000, 0x07c00000, 0x040fd076, - 0x02800510, 0x010180c0, 0x0548e018, 0x0781823c, - 0x0748f018, 0x06818238, 0x03490018, 0x06818234, - 0x01491018, 0x07818230, 0x073c0000, 0x06000040, - 0x02200004, 0x0180023f, 0x073c0000, 0x06000020, - 0x03200003, 0x0180023f, 0x073c0000, 0x06000010, - 0x02200002, 0x0180023f, 0x073c0000, 0x06000008, - 0x02200001, 0x0180023f, 0x073c0000, 0x06000004, - 0x06000013, 0x050fb000, 0x040fe076, 0x00860258, - 0x046c0273, 0x04810268, 0x066c0073, 0x04810249, - 0x040fd076, 0x06a00510, 0x03800014, 0x040fd076, - 0x0080024c, 0x00452075, 0x00077013, 0x0647f075, - 0x06486075, 0x06818252, 0x05a0028b, 0x00800258, - 0x007a0175, 0x04000101, 0x05a0028b, 0x04008076, - 0x0245f008, 0x05a004f5, 0x07273000, 0x05600272, - 0x050f80ff, 0x053fa80a, 0x07000009, 0x0379ff78, - 0x070000ff, 0x02076013, 0x02075013, 0x0484801f, - 0x0280003d, 0x070fc0ff, 0x052e400c, 0x00208020, - 0x05a004f5, 0x00800261, 0x04600276, 0x050010ff, - 0x040f8001, 0x032fa009, 0x040f8001, 0x053fa80a, - 0x07000009, 0x070ff000, 0x0286827a, 0x06601276, - 0x050f80ff, 0x073fa009, 0x0700000c, 0x07601818, - 0x050f80ff, 0x053fa80a, 0x07000009, 0x0180027b, - 0x07a000de, 0x0448b075, 0x0581024b, 0x06000013, - 0x04001013, 0x0560107b, 0x050f80ff, 0x032fa012, - 0x0046b075, 0x03b600ac, 0x0080024c, 0x06000020, - 0x04001016, 0x0460082a, 0x050f80ff, 0x032fa012, - 0x07c00000, 0x06000075, 0x040010a2, 0x044b0801, - 0x060ff016, 0x065a0001, 0x04600876, 0x050f80ff, - 0x032fa012, 0x07c00000, 0x050fe022, 0x0186029a, - 0x0421d004, 0x0302a022, 0x04a002c1, 0x018002b1, - 0x040fe026, 0x008602b3, 0x0421d001, 0x0202a026, - 0x04a002c1, 0x0202c013, 0x00683e20, 0x070060ff, - 0x056c0206, 0x048102f4, 0x056c0406, 0x0781030a, - 0x076c0606, 0x06810379, 0x056c1606, 0x078182b1, - 0x04488020, 0x07810387, 0x040fd02a, 0x0521d000, - 0x0202a013, 0x02020013, 0x008002b3, 0x04a004ec, - 0x008002bf, 0x050fe028, 0x008602bf, 0x0302a028, - 0x0421d002, 0x04a002c1, 0x008002c8, 0x050fe022, - 0x008602bf, 0x0421d004, 0x0302a022, 0x04a002c1, - 0x04a004ec, 0x05848030, 0x0280003d, 0x0460082a, - 0x050f80ff, 0x022fa031, 0x03020000, 0x0002b004, - 0x01018005, 0x07c00000, 0x0400702a, 0x06a003ba, - 0x007a0101, 0x07060000, 0x07303000, 0x07008290, - 0x07600018, 0x050f80ff, 0x053fa809, 0x07000003, - 0x0448e007, 0x068182d6, 0x06006013, 0x018002dd, - 0x02400010, 0x048102d6, 0x06006010, 0x0460322a, - 0x050f80ff, 0x073fa00a, 0x07000003, 0x050f801e, - 0x032fa03a, 0x063aa020, 0x06000002, 0x013e4000, - 0x07000030, 0x009802e3, 0x070ff0f6, 0x036830ff, - 0x078182e4, 0x070f001e, 0x0560102b, 0x050f10ff, - 0x063f3c08, 0x0600000d, 0x013e4000, 0x06000020, - 0x040f801a, 0x0320000a, 0x022017d0, 0x032fa012, - 0x0202c013, 0x008002bf, 0x04007013, 0x06a003ba, - 0x007a0101, 0x07050000, 0x07303000, 0x07008890, - 0x074d0005, 0x06006013, 0x050f801e, 0x032fa03a, - 0x05601a2b, 0x050f80ff, 0x022fa019, 0x04001002, - 0x04002013, 0x040f801f, 0x022fa01a, 0x073aa00c, - 0x06000002, 0x07300c03, 0x0600000d, 0x028003a7, - 0x04007013, 0x06a003ba, 0x007a0101, 0x03070000, - 0x0660282a, 0x050f80ff, 0x073fa009, 0x06000004, - 0x02499008, 0x07810317, 0x07303000, 0x07008890, - 0x02800319, 0x07303000, 0x04008980, 0x05007003, - 0x074d0005, 0x06006013, 0x050f801e, 0x032fa03a, - 0x0760142b, 0x050f80ff, 0x032fa021, 0x064b0002, - 0x02499008, 0x06810325, 0x0644c002, 0x054b0400, - 0x050040ff, 0x06698104, 0x0581833a, 0x06000013, - 0x04001013, 0x04780102, 0x06000010, 0x06003013, - 0x04004013, 0x06005013, 0x06006013, 0x04007013, - 0x00644015, 0x07820336, 0x04448002, 0x02205008, - 0x040f801f, 0x032fa042, 0x04008015, 0x03800371, - 0x046c8004, 0x05818348, 0x01208018, 0x06780002, - 0x07000003, 0x0581834b, 0x06003001, 0x06000013, - 0x04001013, 0x04004013, 0x06005013, 0x040f801f, - 0x022fa032, 0x03800371, 0x040fd02a, 0x06a00510, - 0x03800014, 0x04488002, 0x07810350, 0x070ff003, - 0x04500408, 0x050080ff, 0x06489002, 0x06810357, - 0x0379ff00, 0x070000ff, 0x070ff000, 0x04500408, - 0x050080ff, 0x07005003, 0x05004000, 0x06003001, - 0x06000013, 0x04001013, 0x040f801f, 0x022fa032, - 0x05601c2b, 0x050f80ff, 0x022fa031, 0x06600c1f, - 0x050f80ff, 0x022fa032, 0x02680608, 0x07810371, - 0x016408ff, 0x057dfeff, 0x07ffffff, 0x034000ff, - 0x045a0407, 0x070000ff, 0x0760061e, 0x050f80ff, - 0x032fa00a, 0x06600908, 0x0669f908, 0x027a0008, - 0x06000020, 0x070aa0ff, 0x014a20ff, 0x037a00ff, - 0x060000dc, 0x070000ff, 0x028003a7, 0x04007013, - 0x06a003ba, 0x007a0101, 0x07030000, 0x07303000, - 0x07008190, 0x06006013, 0x050f801e, 0x032fa03a, - 0x073aa000, 0x06000002, 0x07300c00, 0x07000005, - 0x028003a7, 0x04007013, 0x06a003ba, 0x007a0101, - 0x07810000, 0x07303000, 0x07000090, 0x06006013, - 0x06600c2a, 0x050f80ff, 0x053fa809, 0x07000003, - 0x04780107, 0x07ffff00, 0x007c0107, 0x07000500, - 0x0581839a, 0x07303000, 0x05000890, 0x074d0005, - 0x0660282a, 0x050f80ff, 0x053fa809, 0x07000003, - 0x0049d007, 0x068103a1, 0x02206001, 0x050f801e, - 0x032fa03a, 0x073aa000, 0x06000002, 0x07300c00, - 0x07000005, 0x013e4000, 0x07000030, 0x039803a9, - 0x070ff0f6, 0x036830ff, 0x058183aa, 0x070f001e, - 0x040f101f, 0x070f3000, 0x013e4000, 0x06000020, - 0x040f801a, 0x0320000a, 0x022017d0, 0x032fa012, - 0x008002bf, 0x03200000, 0x06006076, 0x028003bc, - 0x03200011, 0x0600602a, 0x05a00441, 0x05600406, - 0x050f80ff, 0x053fa809, 0x06000002, 0x07c00000, - 0x0207602f, 0x04600876, 0x050f80ff, 0x022fa031, - 0x03075000, 0x0007b004, 0x01018005, 0x06600076, - 0x050020ff, 0x050f80ff, 0x012fa809, 0x0202f001, - 0x008683d0, 0x0002e013, 0x040f8002, 0x053fa80a, - 0x07000009, 0x06273001, 0x0448b075, 0x048183da, - 0x04602076, 0x050f80ff, 0x053fa811, 0x0700003c, - 0x0179fe78, 0x070000ff, 0x030190ff, 0x018683e2, - 0x07a003f6, 0x00078019, 0x039203f5, 0x0180043a, - 0x040fd076, 0x040fd019, 0x04600276, 0x050020ff, - 0x050f80ff, 0x032fa009, 0x040f8002, 0x053fa80a, - 0x07000009, 0x050fe000, 0x008683f2, 0x07601818, - 0x050f80ff, 0x053fa80a, 0x07000009, 0x038003f3, - 0x07a000de, 0x07273000, 0x02076013, 0x0280003d, - 0x078b03f6, 0x03385000, 0x07030000, 0x05600818, - 0x050f80ff, 0x032fa009, 0x054b0400, 0x0308a0ff, - 0x0179fe00, 0x070000ff, 0x010880ff, 0x0448b075, - 0x04810410, 0x0760147b, 0x050f80ff, 0x002fa819, - 0x064b0001, 0x02080002, 0x01081003, 0x00082001, - 0x02083001, 0x02079001, 0x0207a001, 0x00084013, - 0x0207f013, 0x00800432, 0x06485075, 0x05810428, - 0x02465075, 0x06601476, 0x050f80ff, 0x073fa021, - 0x0600003e, 0x070ff07d, 0x0450047c, 0x050f80ff, - 0x002fa819, 0x058b041b, 0x02080001, 0x00081002, - 0x01082003, 0x03079003, 0x0208307a, 0x0340007e, - 0x0642007f, 0x0581042d, 0x070ff07e, 0x05a001d2, - 0x0392842d, 0x01800439, 0x058b0428, 0x06601476, - 0x050f80ff, 0x073fa041, 0x0600003e, 0x06602476, - 0x050f80ff, 0x073fa009, 0x06000007, 0x0008400e, - 0x048b0432, 0x03385000, 0x03010000, 0x06219001, - 0x040fe07f, 0x01860439, 0x018001bb, 0x07c00000, - 0x00683e75, 0x0581043f, 0x0448d075, 0x05810465, - 0x01800493, 0x05a004f0, 0x038003f5, 0x0297844c, - 0x07602418, 0x050f80ff, 0x012fa809, 0x06780001, - 0x070000ff, 0x075a0000, 0x070ff014, 0x0569feff, - 0x054b08ff, 0x075a0000, 0x05600418, 0x050f80ff, - 0x012fa809, 0x040fe007, 0x03868453, 0x01204000, - 0x00800461, 0x00700101, 0x03010000, 0x06780001, - 0x07ff0000, 0x076c00ff, 0x0681845b, 0x00700101, - 0x03010000, 0x05600418, 0x050f80ff, 0x012fa80a, - 0x06780001, 0x07ff0000, 0x050040ff, 0x0279ff01, - 0x0700ffff, 0x05002014, 0x07c00000, 0x04007076, - 0x0448b075, 0x0481047f, 0x03200011, 0x06006076, - 0x06a003bc, 0x007a0101, 0x07060000, 0x07303000, - 0x07008290, 0x07600018, 0x050f80ff, 0x053fa809, - 0x07000003, 0x0448e007, 0x07818477, 0x06006013, - 0x0180048e, 0x02400010, 0x05810477, 0x06006010, - 0x04603276, 0x050f80ff, 0x073fa00a, 0x07000003, - 0x0180048e, 0x04602a76, 0x050f80ff, 0x032fa009, - 0x060ff07a, 0x05500400, 0x070000ff, 0x04602a76, - 0x050f80ff, 0x032fa00a, 0x07a003b7, 0x007a0101, - 0x03010000, 0x06303008, 0x05008000, 0x0600600e, - 0x050f8074, 0x032fa03a, 0x053079a0, 0x0700000c, - 0x008004d3, 0x00683e75, 0x076c0aff, 0x058104b2, - 0x04007013, 0x03200011, 0x06006076, 0x06a003bc, - 0x007a0101, 0x03070000, 0x06602876, 0x050f80ff, - 0x053fa809, 0x06000001, 0x03499003, 0x048104a7, - 0x07303000, 0x07008890, 0x053079a0, 0x0700000c, - 0x008004ab, 0x07303000, 0x04008980, 0x04307920, - 0x0700000c, 0x074d0005, 0x06006013, 0x050f8074, - 0x032fa03a, 0x04307920, 0x0700000c, 0x008004d3, - 0x04602a76, 0x050f80ff, 0x032fa009, 0x060ff07a, - 0x05500400, 0x070000ff, 0x04602a76, 0x050f80ff, - 0x032fa00a, 0x04007076, 0x07a003b7, 0x007a0101, - 0x03010000, 0x06303008, 0x07008800, 0x074d0005, - 0x06600a76, 0x050f80ff, 0x073fa009, 0x07000003, - 0x054b0406, 0x045a0404, 0x050040ff, 0x0600600e, - 0x050f8074, 0x032fa03a, 0x0648c075, 0x058104d1, - 0x06307d20, 0x0700000c, 0x008004d3, 0x04307920, - 0x0700000c, 0x013e4000, 0x07000030, 0x009804d5, - 0x070ff0f6, 0x074850ff, 0x068184d6, 0x050f2074, - 0x060a0007, 0x040070fb, 0x046a7007, 0x050f40ff, - 0x013e4000, 0x06000020, 0x0678007a, 0x07fff000, - 0x068184e6, 0x0320000a, 0x022017d0, 0x008004e9, - 0x0320000a, 0x06301b58, 0x06000001, 0x050f8072, - 0x032fa012, 0x038003f5, 0x01208060, 0x0600902a, - 0x04002020, 0x018004fc, 0x040080fb, 0x066ae108, - 0x06009076, 0x04002075, 0x018004fc, 0x03201100, - 0x078484fa, 0x06420001, 0x078184f6, 0x02800513, - 0x020e0008, 0x07c00000, 0x050fd009, 0x040fd008, - 0x03201100, 0x05848503, 0x06420001, 0x078184ff, - 0x02800513, 0x007a0102, 0x04000101, 0x05600809, - 0x050f80ff, 0x073fa00a, 0x06000001, 0x020e0008, - 0x0684050d, 0x030e0009, 0x07c00000, 0x01011009, - 0x052e4300, 0x07c00000, 0x052e400f, 0x01208090, - 0x018004f5, 0x070fc0ff, 0x040f8013, 0x032fa009, - 0x02800516, 0x15416ea9, 0xffef0b01 -}; - -#ifdef UNIQUE_FW_NAME -uint32_t fw2400_length02 = 0x000014ff ; -#else -uint32_t risc_code_length02 = 0x000014ff ; -#endif - diff --git a/trunk/drivers/scsi/qla2xxx/qla_attr.c b/trunk/drivers/scsi/qla2xxx/qla_attr.c index 2efca52dff50..48e460eef05a 100644 --- a/trunk/drivers/scsi/qla2xxx/qla_attr.c +++ b/trunk/drivers/scsi/qla2xxx/qla_attr.c @@ -232,7 +232,7 @@ static ssize_t qla2x00_isp_name_show(struct class_device *cdev, char *buf) { scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); - return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device); + return snprintf(buf, PAGE_SIZE, "%s\n", ha->brd_info->isp_name); } static ssize_t diff --git a/trunk/drivers/scsi/qla2xxx/qla_def.h b/trunk/drivers/scsi/qla2xxx/qla_def.h index 79d8a914f9d0..7b3efd531297 100644 --- a/trunk/drivers/scsi/qla2xxx/qla_def.h +++ b/trunk/drivers/scsi/qla2xxx/qla_def.h @@ -22,7 +22,6 @@ #include #include #include -#include #include #include @@ -30,7 +29,6 @@ #include #include -#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) #if defined(CONFIG_SCSI_QLA21XX) || defined(CONFIG_SCSI_QLA21XX_MODULE) #define IS_QLA2100(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2100) #else @@ -81,23 +79,9 @@ #define IS_QLA2522(ha) 0 #endif -#else /* !defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) */ - -#define IS_QLA2100(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2100) -#define IS_QLA2200(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2200) -#define IS_QLA2300(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2300) -#define IS_QLA2312(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2312) -#define IS_QLA2322(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2322) -#define IS_QLA6312(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP6312) -#define IS_QLA6322(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP6322) -#define IS_QLA2422(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422) -#define IS_QLA2432(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432) -#define IS_QLA2512(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2512) -#define IS_QLA2522(ha) ((ha)->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2522) -#endif - #define IS_QLA23XX(ha) (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA2322(ha) || \ IS_QLA6312(ha) || IS_QLA6322(ha)) + #define IS_QLA24XX(ha) (IS_QLA2422(ha) || IS_QLA2432(ha)) #define IS_QLA25XX(ha) (IS_QLA2512(ha) || IS_QLA2522(ha)) @@ -2140,12 +2124,6 @@ struct qla_board_info { struct scsi_host_template *sht; }; -struct fw_blob { - char *name; - uint32_t segs[4]; - const struct firmware *fw; -}; - /* Return data from MBC_GET_ID_LIST call. */ struct gid_list_info { uint8_t al_pa; diff --git a/trunk/drivers/scsi/qla2xxx/qla_gbl.h b/trunk/drivers/scsi/qla2xxx/qla_gbl.h index bec81adcf4fd..fedcb0d3fc72 100644 --- a/trunk/drivers/scsi/qla2xxx/qla_gbl.h +++ b/trunk/drivers/scsi/qla2xxx/qla_gbl.h @@ -33,8 +33,8 @@ extern int qla24xx_nvram_config(struct scsi_qla_host *); extern void qla2x00_update_fw_options(struct scsi_qla_host *); extern void qla24xx_update_fw_options(scsi_qla_host_t *); extern int qla2x00_load_risc(struct scsi_qla_host *, uint32_t *); -extern int qla24xx_load_risc(scsi_qla_host_t *, uint32_t *); extern int qla24xx_load_risc_flash(scsi_qla_host_t *, uint32_t *); +extern int qla24xx_load_risc_hotplug(scsi_qla_host_t *, uint32_t *); extern fc_port_t *qla2x00_alloc_fcport(scsi_qla_host_t *, gfp_t); @@ -76,8 +76,6 @@ extern void qla2x00_blink_led(scsi_qla_host_t *); extern int qla2x00_down_timeout(struct semaphore *, unsigned long); -extern struct fw_blob *qla2x00_request_firmware(scsi_qla_host_t *); - /* * Global Function Prototypes in qla_iocb.c source file. */ diff --git a/trunk/drivers/scsi/qla2xxx/qla_init.c b/trunk/drivers/scsi/qla2xxx/qla_init.c index 7d973bd9022b..c46d2469b85f 100644 --- a/trunk/drivers/scsi/qla2xxx/qla_init.c +++ b/trunk/drivers/scsi/qla2xxx/qla_init.c @@ -8,6 +8,7 @@ #include #include +#include #include #include "qla_devtbl.h" @@ -3483,16 +3484,17 @@ qla24xx_nvram_config(scsi_qla_host_t *ha) return (rval); } -#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) - int qla2x00_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) { - int rval, num, i; - uint32_t cnt; - uint16_t *risc_code; - uint32_t risc_addr, risc_size; - uint16_t *req_ring; + int rval; + uint16_t cnt; + uint16_t *risc_code; + unsigned long risc_address; + unsigned long risc_code_size; + int num; + int i; + uint16_t *req_ring; struct qla_fw_info *fw_iter; rval = QLA_SUCCESS; @@ -3502,90 +3504,37 @@ qla2x00_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) *srisc_addr = *ha->brd_info->fw_info->fwstart; while (fw_iter->addressing != FW_INFO_ADDR_NOMORE) { risc_code = fw_iter->fwcode; - risc_size = *fw_iter->fwlen; - if (fw_iter->addressing == FW_INFO_ADDR_NORMAL) - risc_addr = *fw_iter->fwstart; - else - risc_addr = *fw_iter->lfwstart; + risc_code_size = *fw_iter->fwlen; + + if (fw_iter->addressing == FW_INFO_ADDR_NORMAL) { + risc_address = *fw_iter->fwstart; + } else { + /* Extended address */ + risc_address = *fw_iter->lfwstart; + } num = 0; rval = 0; - while (risc_size > 0 && !rval) { + while (risc_code_size > 0 && !rval) { cnt = (uint16_t)(ha->fw_transfer_size >> 1); - if (cnt > risc_size) - cnt = risc_size; + if (cnt > risc_code_size) + cnt = risc_code_size; DEBUG7(printk("scsi(%ld): Loading risc segment@ " "addr %p, number of bytes 0x%x, offset 0x%lx.\n", - ha->host_no, risc_code, cnt, risc_addr)); + ha->host_no, risc_code, cnt, risc_address)); req_ring = (uint16_t *)ha->request_ring; for (i = 0; i < cnt; i++) req_ring[i] = cpu_to_le16(risc_code[i]); - rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr, - cnt); - if (rval) { - DEBUG(printk("scsi(%ld): [ERROR] Failed to " - "load segment %d of firmware\n", - ha->host_no, num)); - qla_printk(KERN_WARNING, ha, - "[ERROR] Failed to load segment %d of " - "firmware\n", num); - - qla2x00_dump_regs(ha); - break; + if (fw_iter->addressing == FW_INFO_ADDR_NORMAL) { + rval = qla2x00_load_ram(ha, ha->request_dma, + risc_address, cnt); + } else { + rval = qla2x00_load_ram_ext(ha, + ha->request_dma, risc_address, cnt); } - - risc_code += cnt; - risc_addr += cnt; - risc_size -= cnt; - num++; - } - - /* Next firmware sequence */ - fw_iter++; - } - return rval; -} - -int -qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) -{ - int rval, num, i; - uint32_t cnt; - uint32_t *risc_code; - uint32_t risc_addr, risc_size; - uint32_t *req_ring; - struct qla_fw_info *fw_iter; - - rval = QLA_SUCCESS; - - /* Load firmware sequences */ - fw_iter = ha->brd_info->fw_info; - *srisc_addr = *((uint32_t *)fw_iter->lfwstart); - while (fw_iter->addressing != FW_INFO_ADDR_NOMORE) { - risc_code = (uint32_t *)fw_iter->fwcode; - risc_size = *((uint32_t *)fw_iter->fwlen); - risc_addr = *((uint32_t *)fw_iter->lfwstart); - - num = 0; - rval = 0; - while (risc_size > 0 && !rval) { - cnt = (uint32_t)(ha->fw_transfer_size >> 2); - if (cnt > risc_size) - cnt = risc_size; - - DEBUG7(printk("scsi(%ld): Loading risc segment@ " - "addr %p, number of bytes 0x%x, offset 0x%lx.\n", - ha->host_no, risc_code, cnt, risc_addr)); - - req_ring = (uint32_t *)ha->request_ring; - for (i = 0; i < cnt; i++) - req_ring[i] = cpu_to_le32(risc_code[i]); - - rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr, - cnt); if (rval) { DEBUG(printk("scsi(%ld): [ERROR] Failed to " "load segment %d of firmware\n", @@ -3599,15 +3548,16 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) } risc_code += cnt; - risc_addr += cnt; - risc_size -= cnt; + risc_address += cnt; + risc_code_size -= cnt; num++; } /* Next firmware sequence */ fw_iter++; } - return rval; + + return (rval); } int @@ -3692,108 +3642,8 @@ qla24xx_load_risc_flash(scsi_qla_host_t *ha, uint32_t *srisc_addr) return rval; } -#else /* !defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) */ - int -qla2x00_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) -{ - int rval; - int i, fragment; - uint16_t *wcode, *fwcode; - uint32_t risc_addr, risc_size, fwclen, wlen, *seg; - struct fw_blob *blob; - - /* Load firmware blob. */ - blob = qla2x00_request_firmware(ha); - if (!blob) { - qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n"); - return QLA_FUNCTION_FAILED; - } - - rval = QLA_SUCCESS; - - wcode = (uint16_t *)ha->request_ring; - *srisc_addr = 0; - fwcode = (uint16_t *)blob->fw->data; - fwclen = 0; - - /* Validate firmware image by checking version. */ - if (blob->fw->size < 8 * sizeof(uint16_t)) { - qla_printk(KERN_WARNING, ha, - "Unable to verify integrity of firmware image (%Zd)!\n", - blob->fw->size); - goto fail_fw_integrity; - } - for (i = 0; i < 4; i++) - wcode[i] = be16_to_cpu(fwcode[i + 4]); - if ((wcode[0] == 0xffff && wcode[1] == 0xffff && wcode[2] == 0xffff && - wcode[3] == 0xffff) || (wcode[0] == 0 && wcode[1] == 0 && - wcode[2] == 0 && wcode[3] == 0)) { - qla_printk(KERN_WARNING, ha, - "Unable to verify integrity of firmware image!\n"); - qla_printk(KERN_WARNING, ha, - "Firmware data: %04x %04x %04x %04x!\n", wcode[0], - wcode[1], wcode[2], wcode[3]); - goto fail_fw_integrity; - } - - seg = blob->segs; - while (*seg && rval == QLA_SUCCESS) { - risc_addr = *seg; - *srisc_addr = *srisc_addr == 0 ? *seg : *srisc_addr; - risc_size = be16_to_cpu(fwcode[3]); - - /* Validate firmware image size. */ - fwclen += risc_size * sizeof(uint16_t); - if (blob->fw->size < fwclen) { - qla_printk(KERN_WARNING, ha, - "Unable to verify integrity of firmware image " - "(%Zd)!\n", blob->fw->size); - goto fail_fw_integrity; - } - - fragment = 0; - while (risc_size > 0 && rval == QLA_SUCCESS) { - wlen = (uint16_t)(ha->fw_transfer_size >> 1); - if (wlen > risc_size) - wlen = risc_size; - - DEBUG7(printk("scsi(%ld): Loading risc segment@ risc " - "addr %x, number of words 0x%x.\n", ha->host_no, - risc_addr, wlen)); - - for (i = 0; i < wlen; i++) - wcode[i] = swab16(fwcode[i]); - - rval = qla2x00_load_ram(ha, ha->request_dma, risc_addr, - wlen); - if (rval) { - DEBUG(printk("scsi(%ld):[ERROR] Failed to load " - "segment %d of firmware\n", ha->host_no, - fragment)); - qla_printk(KERN_WARNING, ha, - "[ERROR] Failed to load segment %d of " - "firmware\n", fragment); - break; - } - - fwcode += wlen; - risc_addr += wlen; - risc_size -= wlen; - fragment++; - } - - /* Next segment. */ - seg++; - } - return rval; - -fail_fw_integrity: - return QLA_FUNCTION_FAILED; -} - -int -qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) +qla24xx_load_risc_hotplug(scsi_qla_host_t *ha, uint32_t *srisc_addr) { int rval; int segments, fragment; @@ -3801,13 +3651,14 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) uint32_t risc_addr; uint32_t risc_size; uint32_t i; - struct fw_blob *blob; + const struct firmware *fw_entry; uint32_t *fwcode, fwclen; - /* Load firmware blob. */ - blob = qla2x00_request_firmware(ha); - if (!blob) { - qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n"); + if (request_firmware(&fw_entry, ha->brd_info->fw_fname, + &ha->pdev->dev)) { + qla_printk(KERN_ERR, ha, + "Firmware image file not available: '%s'\n", + ha->brd_info->fw_fname); return QLA_FUNCTION_FAILED; } @@ -3816,14 +3667,14 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) segments = FA_RISC_CODE_SEGMENTS; dcode = (uint32_t *)ha->request_ring; *srisc_addr = 0; - fwcode = (uint32_t *)blob->fw->data; + fwcode = (uint32_t *)fw_entry->data; fwclen = 0; /* Validate firmware image by checking version. */ - if (blob->fw->size < 8 * sizeof(uint32_t)) { + if (fw_entry->size < 8 * sizeof(uint32_t)) { qla_printk(KERN_WARNING, ha, - "Unable to verify integrity of firmware image (%Zd)!\n", - blob->fw->size); + "Unable to verify integrity of flash firmware image " + "(%Zd)!\n", fw_entry->size); goto fail_fw_integrity; } for (i = 0; i < 4; i++) @@ -3833,7 +3684,7 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 && dcode[3] == 0)) { qla_printk(KERN_WARNING, ha, - "Unable to verify integrity of firmware image!\n"); + "Unable to verify integrity of flash firmware image!\n"); qla_printk(KERN_WARNING, ha, "Firmware data: %08x %08x %08x %08x!\n", dcode[0], dcode[1], dcode[2], dcode[3]); @@ -3847,11 +3698,10 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) /* Validate firmware image size. */ fwclen += risc_size * sizeof(uint32_t); - if (blob->fw->size < fwclen) { + if (fw_entry->size < fwclen) { qla_printk(KERN_WARNING, ha, - "Unable to verify integrity of firmware image " - "(%Zd)!\n", blob->fw->size); - + "Unable to verify integrity of flash firmware " + "image (%Zd)!\n", fw_entry->size); goto fail_fw_integrity; } @@ -3889,9 +3739,13 @@ qla24xx_load_risc(scsi_qla_host_t *ha, uint32_t *srisc_addr) /* Next segment. */ segments--; } + + release_firmware(fw_entry); return rval; fail_fw_integrity: + + release_firmware(fw_entry); return QLA_FUNCTION_FAILED; + } -#endif diff --git a/trunk/drivers/scsi/qla2xxx/qla_os.c b/trunk/drivers/scsi/qla2xxx/qla_os.c index 24304300d7b5..c58c9d97b041 100644 --- a/trunk/drivers/scsi/qla2xxx/qla_os.c +++ b/trunk/drivers/scsi/qla2xxx/qla_os.c @@ -54,12 +54,10 @@ module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR); MODULE_PARM_DESC(ql2xloginretrycount, "Specify an alternate value for the NVRAM login retry count."); -#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) -int ql2xfwloadflash; -module_param(ql2xfwloadflash, int, S_IRUGO|S_IRUSR); -MODULE_PARM_DESC(ql2xfwloadflash, - "Load ISP24xx firmware image from FLASH (onboard memory)."); -#endif +int ql2xfwloadbin=1; +module_param(ql2xfwloadbin, int, S_IRUGO|S_IRUSR); +MODULE_PARM_DESC(ql2xfwloadbin, + "Load ISP2xxx firmware image via hotplug."); static void qla2x00_free_device(scsi_qla_host_t *); @@ -1263,16 +1261,12 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) char pci_info[20]; char fw_str[30]; fc_port_t *fcport; - struct scsi_host_template *sht; if (pci_enable_device(pdev)) goto probe_out; - sht = &qla2x00_driver_template; - if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 || - pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432) - sht = &qla24xx_driver_template; - host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t)); + host = scsi_host_alloc(brd_info->sht ? brd_info->sht: + &qla2x00_driver_template, sizeof(scsi_qla_host_t)); if (host == NULL) { printk(KERN_WARNING "qla2xxx: Couldn't allocate host from scsi layer!\n"); @@ -1297,8 +1291,8 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) goto probe_failed; qla_printk(KERN_INFO, ha, - "Found an ISP%04X, irq %d, iobase 0x%p\n", pdev->device, pdev->irq, - ha->iobase); + "Found an %s, irq %d, iobase 0x%p\n", ha->brd_info->isp_name, + pdev->irq, ha->iobase); spin_lock_init(&ha->hardware_lock); @@ -1374,11 +1368,9 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) ha->isp_ops.reset_adapter = qla24xx_reset_adapter; ha->isp_ops.nvram_config = qla24xx_nvram_config; ha->isp_ops.update_fw_options = qla24xx_update_fw_options; - ha->isp_ops.load_risc = qla24xx_load_risc; -#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) - if (ql2xfwloadflash) - ha->isp_ops.load_risc = qla24xx_load_risc_flash; -#endif + ha->isp_ops.load_risc = qla24xx_load_risc_flash; + if (ql2xfwloadbin) + ha->isp_ops.load_risc = qla24xx_load_risc_hotplug; ha->isp_ops.pci_info_str = qla24xx_pci_info_str; ha->isp_ops.fw_version_str = qla24xx_fw_version_str; ha->isp_ops.intr_handler = qla24xx_intr_handler; @@ -1539,12 +1531,11 @@ int qla2x00_probe_one(struct pci_dev *pdev, struct qla_board_info *brd_info) qla_printk(KERN_INFO, ha, "\n" " QLogic Fibre Channel HBA Driver: %s\n" " QLogic %s - %s\n" - " ISP%04X: %s @ %s hdma%c, host#=%ld, fw=%s\n", - qla2x00_version_str, ha->model_number, - ha->model_desc ? ha->model_desc: "", pdev->device, - ha->isp_ops.pci_info_str(ha, pci_info), pci_name(pdev), - ha->flags.enable_64bit_addressing ? '+': '-', ha->host_no, - ha->isp_ops.fw_version_str(ha, fw_str)); + " %s: %s @ %s hdma%c, host#=%ld, fw=%s\n", qla2x00_version_str, + ha->model_number, ha->model_desc ? ha->model_desc: "", + ha->brd_info->isp_name, ha->isp_ops.pci_info_str(ha, pci_info), + pci_name(pdev), ha->flags.enable_64bit_addressing ? '+': '-', + ha->host_no, ha->isp_ops.fw_version_str(ha, fw_str)); /* Go with fc_rport registration. */ list_for_each_entry(fcport, &ha->fcports, list) @@ -2492,115 +2483,45 @@ qla2x00_down_timeout(struct semaphore *sema, unsigned long timeout) return -ETIMEDOUT; } -#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) - -#define qla2x00_release_firmware() do { } while (0) -#define qla2x00_pci_module_init() (0) -#define qla2x00_pci_module_exit() do { } while (0) - -#else /* !defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) */ - -/* Firmware interface routines. */ - -#define FW_BLOBS 6 -#define FW_ISP21XX 0 -#define FW_ISP22XX 1 -#define FW_ISP2300 2 -#define FW_ISP2322 3 -#define FW_ISP63XX 4 -#define FW_ISP24XX 5 - -static DECLARE_MUTEX(qla_fw_lock); - -static struct fw_blob qla_fw_blobs[FW_BLOBS] = { - { .name = "ql2100_fw.bin", .segs = { 0x1000, 0 }, }, - { .name = "ql2200_fw.bin", .segs = { 0x1000, 0 }, }, - { .name = "ql2300_fw.bin", .segs = { 0x800, 0 }, }, - { .name = "ql2322_fw.bin", .segs = { 0x800, 0x1c000, 0x1e000, 0 }, }, - { .name = "ql6312_fw.bin", .segs = { 0x800, 0 }, }, - { .name = "ql2400_fw.bin", }, -}; - -struct fw_blob * -qla2x00_request_firmware(scsi_qla_host_t *ha) -{ - struct fw_blob *blob; - - blob = NULL; - if (IS_QLA2100(ha)) { - blob = &qla_fw_blobs[FW_ISP21XX]; - } else if (IS_QLA2200(ha)) { - blob = &qla_fw_blobs[FW_ISP22XX]; - } else if (IS_QLA2300(ha) || IS_QLA2312(ha)) { - blob = &qla_fw_blobs[FW_ISP2300]; - } else if (IS_QLA2322(ha)) { - blob = &qla_fw_blobs[FW_ISP2322]; - } else if (IS_QLA6312(ha) || IS_QLA6322(ha)) { - blob = &qla_fw_blobs[FW_ISP63XX]; - } else if (IS_QLA24XX(ha)) { - blob = &qla_fw_blobs[FW_ISP24XX]; - } - - down(&qla_fw_lock); - if (blob->fw) - goto out; - - if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) { - DEBUG2(printk("scsi(%ld): Failed to load firmware image " - "(%s).\n", ha->host_no, blob->name)); - blob->fw = NULL; - blob = NULL; - goto out; - } - -out: - up(&qla_fw_lock); - return blob; -} - -static void -qla2x00_release_firmware(void) -{ - int idx; - - down(&qla_fw_lock); - for (idx = 0; idx < FW_BLOBS; idx++) - if (qla_fw_blobs[idx].fw) - release_firmware(qla_fw_blobs[idx].fw); - up(&qla_fw_lock); -} - -static struct qla_board_info qla_board_tbl = { - .drv_name = "qla2xxx", +static struct qla_board_info qla_board_tbl[] = { + { + .drv_name = "qla2400", + .isp_name = "ISP2422", + .fw_fname = "ql2400_fw.bin", + .sht = &qla24xx_driver_template, + }, + { + .drv_name = "qla2400", + .isp_name = "ISP2432", + .fw_fname = "ql2400_fw.bin", + .sht = &qla24xx_driver_template, + }, }; static struct pci_device_id qla2xxx_pci_tbl[] = { - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422, - PCI_ANY_ID, PCI_ANY_ID, }, - { PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432, - PCI_ANY_ID, PCI_ANY_ID, }, - { 0 }, + { + .vendor = PCI_VENDOR_ID_QLOGIC, + .device = PCI_DEVICE_ID_QLOGIC_ISP2422, + .subvendor = PCI_ANY_ID, + .subdevice = PCI_ANY_ID, + .driver_data = (unsigned long)&qla_board_tbl[0], + }, + { + .vendor = PCI_VENDOR_ID_QLOGIC, + .device = PCI_DEVICE_ID_QLOGIC_ISP2432, + .subvendor = PCI_ANY_ID, + .subdevice = PCI_ANY_ID, + .driver_data = (unsigned long)&qla_board_tbl[1], + }, + {0, 0}, }; MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl); static int __devinit qla2xxx_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) { - return qla2x00_probe_one(pdev, &qla_board_tbl); + return qla2x00_probe_one(pdev, + (struct qla_board_info *)id->driver_data); } static void __devexit @@ -2611,28 +2532,11 @@ qla2xxx_remove_one(struct pci_dev *pdev) static struct pci_driver qla2xxx_pci_driver = { .name = "qla2xxx", - .driver = { - .owner = THIS_MODULE, - }, .id_table = qla2xxx_pci_tbl, .probe = qla2xxx_probe_one, .remove = __devexit_p(qla2xxx_remove_one), }; -static inline int -qla2x00_pci_module_init(void) -{ - return pci_module_init(&qla2xxx_pci_driver); -} - -static inline void -qla2x00_pci_module_exit(void) -{ - pci_unregister_driver(&qla2xxx_pci_driver); -} - -#endif - /** * qla2x00_module_init - Module initialization. **/ @@ -2652,9 +2556,6 @@ qla2x00_module_init(void) /* Derive version string. */ strcpy(qla2x00_version_str, QLA2XXX_VERSION); -#if defined(CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE) - strcat(qla2x00_version_str, "-fw"); -#endif #if DEBUG_QLA2100 strcat(qla2x00_version_str, "-debug"); #endif @@ -2664,7 +2565,7 @@ qla2x00_module_init(void) return -ENODEV; printk(KERN_INFO "QLogic Fibre Channel HBA Driver\n"); - ret = qla2x00_pci_module_init(); + ret = pci_module_init(&qla2xxx_pci_driver); if (ret) { kmem_cache_destroy(srb_cachep); fc_release_transport(qla2xxx_transport_template); @@ -2678,8 +2579,7 @@ qla2x00_module_init(void) static void __exit qla2x00_module_exit(void) { - qla2x00_pci_module_exit(); - qla2x00_release_firmware(); + pci_unregister_driver(&qla2xxx_pci_driver); kmem_cache_destroy(srb_cachep); fc_release_transport(qla2xxx_transport_template); } diff --git a/trunk/drivers/scsi/raid_class.c b/trunk/drivers/scsi/raid_class.c index 5ec5f44602ac..5b1c12041a4f 100644 --- a/trunk/drivers/scsi/raid_class.c +++ b/trunk/drivers/scsi/raid_class.c @@ -115,7 +115,7 @@ static DECLARE_TRANSPORT_CLASS(raid_class, raid_remove, NULL); -static const struct { +static struct { enum raid_state value; char *name; } raid_states[] = { diff --git a/trunk/drivers/scsi/sata_mv.c b/trunk/drivers/scsi/sata_mv.c index b2bf16a9bf4b..9321cdf45680 100644 --- a/trunk/drivers/scsi/sata_mv.c +++ b/trunk/drivers/scsi/sata_mv.c @@ -431,7 +431,7 @@ static const struct ata_port_operations mv6_ops = { .host_stop = mv_host_stop, }; -static const struct ata_port_info mv_port_info[] = { +static struct ata_port_info mv_port_info[] = { { /* chip_504x */ .sht = &mv_sht, .host_flags = MV_COMMON_FLAGS, @@ -1243,10 +1243,8 @@ static void mv_host_intr(struct ata_host_set *host_set, u32 relevant, VPRINTK("port %u IRQ found for qc, " "ata_status 0x%x\n", port,ata_status); /* mark qc status appropriately */ - if (!(qc->tf.ctl & ATA_NIEN)) { - qc->err_mask |= err_mask; - ata_qc_complete(qc); - } + if (!(qc->tf.ctl & ATA_NIEN)) + ata_qc_complete(qc, err_mask); } } } @@ -1867,8 +1865,7 @@ static void mv_eng_timeout(struct ata_port *ap) */ spin_lock_irqsave(&ap->host_set->lock, flags); qc->scsidone = scsi_finish_command; - qc->err_mask |= AC_ERR_OTHER; - ata_qc_complete(qc); + ata_qc_complete(qc, AC_ERR_OTHER); spin_unlock_irqrestore(&ap->host_set->lock, flags); } } diff --git a/trunk/drivers/scsi/sata_promise.c b/trunk/drivers/scsi/sata_promise.c index da7fa04b8a73..2691625f9bce 100644 --- a/trunk/drivers/scsi/sata_promise.c +++ b/trunk/drivers/scsi/sata_promise.c @@ -161,7 +161,7 @@ static const struct ata_port_operations pdc_pata_ops = { .host_stop = ata_pci_host_stop, }; -static const struct ata_port_info pdc_port_info[] = { +static struct ata_port_info pdc_port_info[] = { /* board_2037x */ { .sht = &pdc_ata_sht, @@ -401,8 +401,7 @@ static void pdc_eng_timeout(struct ata_port *ap) case ATA_PROT_NODATA: printk(KERN_ERR "ata%u: command timeout\n", ap->id); drv_stat = ata_wait_idle(ap); - qc->err_mask |= __ac_err_mask(drv_stat); - ata_qc_complete(qc); + ata_qc_complete(qc, __ac_err_mask(drv_stat)); break; default: @@ -411,8 +410,7 @@ static void pdc_eng_timeout(struct ata_port *ap) printk(KERN_ERR "ata%u: unknown timeout, cmd 0x%x stat 0x%x\n", ap->id, qc->tf.command, drv_stat); - qc->err_mask |= ac_err_mask(drv_stat); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(drv_stat)); break; } @@ -424,21 +422,21 @@ static void pdc_eng_timeout(struct ata_port *ap) static inline unsigned int pdc_host_intr( struct ata_port *ap, struct ata_queued_cmd *qc) { - unsigned int handled = 0; + unsigned int handled = 0, err_mask = 0; u32 tmp; void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr + PDC_GLOBAL_CTL; tmp = readl(mmio); if (tmp & PDC_ERR_MASK) { - qc->err_mask |= AC_ERR_DEV; + err_mask = AC_ERR_DEV; pdc_reset_port(ap); } switch (qc->tf.protocol) { case ATA_PROT_DMA: case ATA_PROT_NODATA: - qc->err_mask |= ac_err_mask(ata_wait_idle(ap)); - ata_qc_complete(qc); + err_mask |= ac_err_mask(ata_wait_idle(ap)); + ata_qc_complete(qc, err_mask); handled = 1; break; @@ -705,7 +703,7 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e probe_ent->port[3].scr_addr = base + 0x700; break; case board_2037x: - probe_ent->n_ports = 2; + probe_ent->n_ports = 2; break; case board_20619: probe_ent->n_ports = 4; @@ -715,7 +713,7 @@ static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *e probe_ent->port[2].scr_addr = base + 0x600; probe_ent->port[3].scr_addr = base + 0x700; - break; + break; default: BUG(); break; diff --git a/trunk/drivers/scsi/sata_qstor.c b/trunk/drivers/scsi/sata_qstor.c index de05e2883f9c..a8987f5ff5cc 100644 --- a/trunk/drivers/scsi/sata_qstor.c +++ b/trunk/drivers/scsi/sata_qstor.c @@ -170,7 +170,7 @@ static const struct ata_port_operations qs_ata_ops = { .bmdma_status = qs_bmdma_status, }; -static const struct ata_port_info qs_port_info[] = { +static struct ata_port_info qs_port_info[] = { /* board_2068_idx */ { .sht = &qs_ata_sht, @@ -409,8 +409,8 @@ static inline unsigned int qs_intr_pkt(struct ata_host_set *host_set) case 3: /* device error */ pp->state = qs_state_idle; qs_enter_reg_mode(qc->ap); - qc->err_mask |= ac_err_mask(sDST); - ata_qc_complete(qc); + ata_qc_complete(qc, + ac_err_mask(sDST)); break; default: break; @@ -447,8 +447,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host_set *host_set) /* complete taskfile transaction */ pp->state = qs_state_idle; - qc->err_mask |= ac_err_mask(status); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(status)); handled = 1; } } diff --git a/trunk/drivers/scsi/sata_sil.c b/trunk/drivers/scsi/sata_sil.c index d2053487c73b..36091868560d 100644 --- a/trunk/drivers/scsi/sata_sil.c +++ b/trunk/drivers/scsi/sata_sil.c @@ -176,7 +176,7 @@ static const struct ata_port_operations sil_ops = { .host_stop = ata_pci_host_stop, }; -static const struct ata_port_info sil_port_info[] = { +static struct ata_port_info sil_port_info[] = { /* sil_3112 */ { .sht = &sil_sht, diff --git a/trunk/drivers/scsi/sata_sil24.c b/trunk/drivers/scsi/sata_sil24.c index a0ad3ed2200a..e0d6f194f54f 100644 --- a/trunk/drivers/scsi/sata_sil24.c +++ b/trunk/drivers/scsi/sata_sil24.c @@ -654,8 +654,7 @@ static void sil24_eng_timeout(struct ata_port *ap) */ printk(KERN_ERR "ata%u: command timeout\n", ap->id); qc->scsidone = scsi_finish_command; - qc->err_mask |= AC_ERR_OTHER; - ata_qc_complete(qc); + ata_qc_complete(qc, AC_ERR_OTHER); sil24_reset_controller(ap); } @@ -712,10 +711,8 @@ static void sil24_error_intr(struct ata_port *ap, u32 slot_stat) sil24_reset_controller(ap); } - if (qc) { - qc->err_mask |= err_mask; - ata_qc_complete(qc); - } + if (qc) + ata_qc_complete(qc, err_mask); } static inline void sil24_host_intr(struct ata_port *ap) @@ -737,10 +734,8 @@ static inline void sil24_host_intr(struct ata_port *ap) */ sil24_update_tf(ap); - if (qc) { - qc->err_mask |= ac_err_mask(pp->tf.command); - ata_qc_complete(qc); - } + if (qc) + ata_qc_complete(qc, ac_err_mask(pp->tf.command)); } else sil24_error_intr(ap, slot_stat); } diff --git a/trunk/drivers/scsi/sata_sx4.c b/trunk/drivers/scsi/sata_sx4.c index 94b253b80da8..ac7b0d819ebc 100644 --- a/trunk/drivers/scsi/sata_sx4.c +++ b/trunk/drivers/scsi/sata_sx4.c @@ -215,7 +215,7 @@ static const struct ata_port_operations pdc_20621_ops = { .host_stop = pdc20621_host_stop, }; -static const struct ata_port_info pdc_port_info[] = { +static struct ata_port_info pdc_port_info[] = { /* board_20621 */ { .sht = &pdc_sata_sht, @@ -719,8 +719,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap, VPRINTK("ata%u: read hdma, 0x%x 0x%x\n", ap->id, readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT)); /* get drive status; clear intr; complete txn */ - qc->err_mask |= ac_err_mask(ata_wait_idle(ap)); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(ata_wait_idle(ap))); pdc20621_pop_hdma(qc); } @@ -758,8 +757,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap, VPRINTK("ata%u: write ata, 0x%x 0x%x\n", ap->id, readl(mmio + 0x104), readl(mmio + PDC_HDMA_CTLSTAT)); /* get drive status; clear intr; complete txn */ - qc->err_mask |= ac_err_mask(ata_wait_idle(ap)); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(ata_wait_idle(ap))); pdc20621_pop_hdma(qc); } handled = 1; @@ -769,8 +767,7 @@ static inline unsigned int pdc20621_host_intr( struct ata_port *ap, status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000); DPRINTK("BUS_NODATA (drv_stat 0x%X)\n", status); - qc->err_mask |= ac_err_mask(status); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(status)); handled = 1; } else { @@ -885,8 +882,7 @@ static void pdc_eng_timeout(struct ata_port *ap) case ATA_PROT_DMA: case ATA_PROT_NODATA: printk(KERN_ERR "ata%u: command timeout\n", ap->id); - qc->err_mask |= __ac_err_mask(ata_wait_idle(ap)); - ata_qc_complete(qc); + ata_qc_complete(qc, __ac_err_mask(ata_wait_idle(ap))); break; default: @@ -895,8 +891,7 @@ static void pdc_eng_timeout(struct ata_port *ap) printk(KERN_ERR "ata%u: unknown timeout, cmd 0x%x stat 0x%x\n", ap->id, qc->tf.command, drv_stat); - qc->err_mask |= ac_err_mask(drv_stat); - ata_qc_complete(qc); + ata_qc_complete(qc, ac_err_mask(drv_stat)); break; } diff --git a/trunk/drivers/scsi/scsi_devinfo.c b/trunk/drivers/scsi/scsi_devinfo.c index f01ec0a7c506..e69477d1889b 100644 --- a/trunk/drivers/scsi/scsi_devinfo.c +++ b/trunk/drivers/scsi/scsi_devinfo.c @@ -354,9 +354,8 @@ static int scsi_dev_info_list_add_str(char *dev_list) * @model, if found, return the matching flags value, else return * the host or global default settings. **/ -int scsi_get_device_flags(struct scsi_device *sdev, - const unsigned char *vendor, - const unsigned char *model) +int scsi_get_device_flags(struct scsi_device *sdev, unsigned char *vendor, + unsigned char *model) { struct scsi_dev_info_list *devinfo; unsigned int bflags; diff --git a/trunk/drivers/scsi/scsi_error.c b/trunk/drivers/scsi/scsi_error.c index a2333d2c7af0..c0ae9e965f6f 100644 --- a/trunk/drivers/scsi/scsi_error.c +++ b/trunk/drivers/scsi/scsi_error.c @@ -1319,6 +1319,23 @@ int scsi_decide_disposition(struct scsi_cmnd *scmd) } } +/** + * scsi_eh_lock_done - done function for eh door lock request + * @scmd: SCSI command block for the door lock request + * + * Notes: + * We completed the asynchronous door lock request, and it has either + * locked the door or failed. We must free the command structures + * associated with this request. + **/ +static void scsi_eh_lock_done(struct scsi_cmnd *scmd) +{ + struct scsi_request *sreq = scmd->sc_request; + + scsi_release_request(sreq); +} + + /** * scsi_eh_lock_door - Prevent medium removal for the specified device * @sdev: SCSI device to prevent medium removal @@ -1341,17 +1358,29 @@ int scsi_decide_disposition(struct scsi_cmnd *scmd) **/ static void scsi_eh_lock_door(struct scsi_device *sdev) { - unsigned char cmnd[MAX_COMMAND_SIZE]; + struct scsi_request *sreq = scsi_allocate_request(sdev, GFP_KERNEL); - cmnd[0] = ALLOW_MEDIUM_REMOVAL; - cmnd[1] = 0; - cmnd[2] = 0; - cmnd[3] = 0; - cmnd[4] = SCSI_REMOVAL_PREVENT; - cmnd[5] = 0; + if (unlikely(!sreq)) { + printk(KERN_ERR "%s: request allocate failed," + "prevent media removal cmd not sent\n", __FUNCTION__); + return; + } - scsi_execute_async(sdev, cmnd, DMA_NONE, NULL, 0, 0, 10 * HZ, - 5, NULL, NULL, GFP_KERNEL); + sreq->sr_cmnd[0] = ALLOW_MEDIUM_REMOVAL; + sreq->sr_cmnd[1] = 0; + sreq->sr_cmnd[2] = 0; + sreq->sr_cmnd[3] = 0; + sreq->sr_cmnd[4] = SCSI_REMOVAL_PREVENT; + sreq->sr_cmnd[5] = 0; + sreq->sr_data_direction = DMA_NONE; + sreq->sr_bufflen = 0; + sreq->sr_buffer = NULL; + sreq->sr_allowed = 5; + sreq->sr_done = scsi_eh_lock_done; + sreq->sr_timeout_per_command = 10 * HZ; + sreq->sr_cmd_len = COMMAND_SIZE(sreq->sr_cmnd[0]); + + scsi_insert_special_req(sreq, 1); } diff --git a/trunk/drivers/scsi/scsi_lib.c b/trunk/drivers/scsi/scsi_lib.c index a7f3f0c84db7..dc249cb970ea 100644 --- a/trunk/drivers/scsi/scsi_lib.c +++ b/trunk/drivers/scsi/scsi_lib.c @@ -63,6 +63,39 @@ static struct scsi_host_sg_pool scsi_sg_pools[] = { }; #undef SP + +/* + * Function: scsi_insert_special_req() + * + * Purpose: Insert pre-formed request into request queue. + * + * Arguments: sreq - request that is ready to be queued. + * at_head - boolean. True if we should insert at head + * of queue, false if we should insert at tail. + * + * Lock status: Assumed that lock is not held upon entry. + * + * Returns: Nothing + * + * Notes: This function is called from character device and from + * ioctl types of functions where the caller knows exactly + * what SCSI command needs to be issued. The idea is that + * we merely inject the command into the queue (at the head + * for now), and then call the queue request function to actually + * process it. + */ +int scsi_insert_special_req(struct scsi_request *sreq, int at_head) +{ + /* + * Because users of this function are apt to reuse requests with no + * modification, we have to sanitise the request flags here + */ + sreq->sr_request->flags &= ~REQ_DONTPREP; + blk_insert_request(sreq->sr_device->request_queue, sreq->sr_request, + at_head, sreq); + return 0; +} + static void scsi_run_queue(struct request_queue *q); /* @@ -216,13 +249,8 @@ void scsi_do_req(struct scsi_request *sreq, const void *cmnd, /* * head injection *required* here otherwise quiesce won't work - * - * Because users of this function are apt to reuse requests with no - * modification, we have to sanitise the request flags here */ - sreq->sr_request->flags &= ~REQ_DONTPREP; - blk_insert_request(sreq->sr_device->request_queue, sreq->sr_request, - 1, sreq); + scsi_insert_special_req(sreq, 1); } EXPORT_SYMBOL(scsi_do_req); @@ -259,7 +287,6 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd, memcpy(req->cmd, cmd, req->cmd_len); req->sense = sense; req->sense_len = 0; - req->retries = retries; req->timeout = timeout; req->flags |= flags | REQ_BLOCK_PC | REQ_SPECIAL | REQ_QUIET; @@ -300,200 +327,6 @@ int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd, } EXPORT_SYMBOL(scsi_execute_req); -struct scsi_io_context { - void *data; - void (*done)(void *data, char *sense, int result, int resid); - char sense[SCSI_SENSE_BUFFERSIZE]; -}; - -static kmem_cache_t *scsi_io_context_cache; - -static void scsi_end_async(struct request *req) -{ - struct scsi_io_context *sioc = req->end_io_data; - - if (sioc->done) - sioc->done(sioc->data, sioc->sense, req->errors, req->data_len); - - kmem_cache_free(scsi_io_context_cache, sioc); - __blk_put_request(req->q, req); -} - -static int scsi_merge_bio(struct request *rq, struct bio *bio) -{ - struct request_queue *q = rq->q; - - bio->bi_flags &= ~(1 << BIO_SEG_VALID); - if (rq_data_dir(rq) == WRITE) - bio->bi_rw |= (1 << BIO_RW); - blk_queue_bounce(q, &bio); - - if (!rq->bio) - blk_rq_bio_prep(q, rq, bio); - else if (!q->back_merge_fn(q, rq, bio)) - return -EINVAL; - else { - rq->biotail->bi_next = bio; - rq->biotail = bio; - rq->hard_nr_sectors += bio_sectors(bio); - rq->nr_sectors = rq->hard_nr_sectors; - } - - return 0; -} - -static int scsi_bi_endio(struct bio *bio, unsigned int bytes_done, int error) -{ - if (bio->bi_size) - return 1; - - bio_put(bio); - return 0; -} - -/** - * scsi_req_map_sg - map a scatterlist into a request - * @rq: request to fill - * @sg: scatterlist - * @nsegs: number of elements - * @bufflen: len of buffer - * @gfp: memory allocation flags - * - * scsi_req_map_sg maps a scatterlist into a request so that the - * request can be sent to the block layer. We do not trust the scatterlist - * sent to use, as some ULDs use that struct to only organize the pages. - */ -static int scsi_req_map_sg(struct request *rq, struct scatterlist *sgl, - int nsegs, unsigned bufflen, gfp_t gfp) -{ - struct request_queue *q = rq->q; - int nr_pages = (bufflen + PAGE_SIZE - 1) >> PAGE_SHIFT; - unsigned int data_len = 0, len, bytes, off; - struct page *page; - struct bio *bio = NULL; - int i, err, nr_vecs = 0; - - for (i = 0; i < nsegs; i++) { - page = sgl[i].page; - off = sgl[i].offset; - len = sgl[i].length; - data_len += len; - - while (len > 0) { - bytes = min_t(unsigned int, len, PAGE_SIZE - off); - - if (!bio) { - nr_vecs = min_t(int, BIO_MAX_PAGES, nr_pages); - nr_pages -= nr_vecs; - - bio = bio_alloc(gfp, nr_vecs); - if (!bio) { - err = -ENOMEM; - goto free_bios; - } - bio->bi_end_io = scsi_bi_endio; - } - - if (bio_add_pc_page(q, bio, page, bytes, off) != - bytes) { - bio_put(bio); - err = -EINVAL; - goto free_bios; - } - - if (bio->bi_vcnt >= nr_vecs) { - err = scsi_merge_bio(rq, bio); - if (err) { - bio_endio(bio, bio->bi_size, 0); - goto free_bios; - } - bio = NULL; - } - - page++; - len -= bytes; - off = 0; - } - } - - rq->buffer = rq->data = NULL; - rq->data_len = data_len; - return 0; - -free_bios: - while ((bio = rq->bio) != NULL) { - rq->bio = bio->bi_next; - /* - * call endio instead of bio_put incase it was bounced - */ - bio_endio(bio, bio->bi_size, 0); - } - - return err; -} - -/** - * scsi_execute_async - insert request - * @sdev: scsi device - * @cmd: scsi command - * @data_direction: data direction - * @buffer: data buffer (this can be a kernel buffer or scatterlist) - * @bufflen: len of buffer - * @use_sg: if buffer is a scatterlist this is the number of elements - * @timeout: request timeout in seconds - * @retries: number of times to retry request - * @flags: or into request flags - **/ -int scsi_execute_async(struct scsi_device *sdev, const unsigned char *cmd, - int data_direction, void *buffer, unsigned bufflen, - int use_sg, int timeout, int retries, void *privdata, - void (*done)(void *, char *, int, int), gfp_t gfp) -{ - struct request *req; - struct scsi_io_context *sioc; - int err = 0; - int write = (data_direction == DMA_TO_DEVICE); - - sioc = kmem_cache_alloc(scsi_io_context_cache, gfp); - if (!sioc) - return DRIVER_ERROR << 24; - memset(sioc, 0, sizeof(*sioc)); - - req = blk_get_request(sdev->request_queue, write, gfp); - if (!req) - goto free_sense; - req->flags |= REQ_BLOCK_PC | REQ_QUIET; - - if (use_sg) - err = scsi_req_map_sg(req, buffer, use_sg, bufflen, gfp); - else if (bufflen) - err = blk_rq_map_kern(req->q, req, buffer, bufflen, gfp); - - if (err) - goto free_req; - - req->cmd_len = COMMAND_SIZE(cmd[0]); - memcpy(req->cmd, cmd, req->cmd_len); - req->sense = sioc->sense; - req->sense_len = 0; - req->timeout = timeout; - req->retries = retries; - req->end_io_data = sioc; - - sioc->data = privdata; - sioc->done = done; - - blk_execute_rq_nowait(req->q, NULL, req, 1, scsi_end_async); - return 0; - -free_req: - blk_put_request(req); -free_sense: - kfree(sioc); - return DRIVER_ERROR << 24; -} -EXPORT_SYMBOL_GPL(scsi_execute_async); - /* * Function: scsi_init_cmd_errh() * @@ -1051,8 +884,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes, * system where READ CAPACITY failed, we may have read * past the end of the disk. */ - if ((cmd->device->use_10_for_rw && - sshdr.asc == 0x20 && sshdr.ascq == 0x00) && + if (cmd->device->use_10_for_rw && (cmd->cmnd[0] == READ_10 || cmd->cmnd[0] == WRITE_10)) { cmd->device->use_10_for_rw = 0; @@ -1250,16 +1082,10 @@ static int scsi_issue_flush_fn(request_queue_t *q, struct gendisk *disk, static void scsi_generic_done(struct scsi_cmnd *cmd) { BUG_ON(!blk_pc_request(cmd->request)); - /* - * This will complete the whole command with uptodate=1 so - * as far as the block layer is concerned the command completed - * successfully. Since this is a REQ_BLOCK_PC command the - * caller should check the request's errors value - */ - scsi_io_completion(cmd, cmd->bufflen, 0); + scsi_io_completion(cmd, cmd->result == 0 ? cmd->bufflen : 0, 0); } -void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd) +void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd, int retries) { struct request *req = cmd->request; @@ -1274,7 +1100,7 @@ void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd) cmd->sc_data_direction = DMA_FROM_DEVICE; cmd->transfersize = req->data_len; - cmd->allowed = req->retries; + cmd->allowed = retries; cmd->timeout_per_command = req->timeout; } EXPORT_SYMBOL_GPL(scsi_setup_blk_pc_cmnd); @@ -1414,7 +1240,7 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req) goto kill; } } else { - scsi_setup_blk_pc_cmnd(cmd); + scsi_setup_blk_pc_cmnd(cmd, 3); cmd->done = scsi_generic_done; } } @@ -1777,14 +1603,6 @@ int __init scsi_init_queue(void) { int i; - scsi_io_context_cache = kmem_cache_create("scsi_io_context", - sizeof(struct scsi_io_context), - 0, 0, NULL, NULL); - if (!scsi_io_context_cache) { - printk(KERN_ERR "SCSI: can't init scsi io context cache\n"); - return -ENOMEM; - } - for (i = 0; i < SG_MEMPOOL_NR; i++) { struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; int size = sgp->size * sizeof(struct scatterlist); @@ -1812,8 +1630,6 @@ void scsi_exit_queue(void) { int i; - kmem_cache_destroy(scsi_io_context_cache); - for (i = 0; i < SG_MEMPOOL_NR; i++) { struct scsi_host_sg_pool *sgp = scsi_sg_pools + i; mempool_destroy(sgp->pool); diff --git a/trunk/drivers/scsi/scsi_priv.h b/trunk/drivers/scsi/scsi_priv.h index f04e7e11f57a..d632d9e1493c 100644 --- a/trunk/drivers/scsi/scsi_priv.h +++ b/trunk/drivers/scsi/scsi_priv.h @@ -40,6 +40,7 @@ extern void scsi_exit_hosts(void); extern int scsi_dispatch_cmd(struct scsi_cmnd *cmd); extern int scsi_setup_command_freelist(struct Scsi_Host *shost); extern void scsi_destroy_command_freelist(struct Scsi_Host *shost); +extern int scsi_insert_special_req(struct scsi_request *sreq, int); extern void scsi_init_cmd_from_req(struct scsi_cmnd *cmd, struct scsi_request *sreq); extern void __scsi_release_request(struct scsi_request *sreq); @@ -56,8 +57,7 @@ static inline void scsi_log_completion(struct scsi_cmnd *cmd, int disposition) /* scsi_devinfo.c */ extern int scsi_get_device_flags(struct scsi_device *sdev, - const unsigned char *vendor, - const unsigned char *model); + unsigned char *vendor, unsigned char *model); extern int __init scsi_init_devinfo(void); extern void scsi_exit_devinfo(void); diff --git a/trunk/drivers/scsi/scsi_scan.c b/trunk/drivers/scsi/scsi_scan.c index 05ebb9cef961..4e6709f448e1 100644 --- a/trunk/drivers/scsi/scsi_scan.c +++ b/trunk/drivers/scsi/scsi_scan.c @@ -74,7 +74,7 @@ #define SCSI_SCAN_TARGET_PRESENT 1 #define SCSI_SCAN_LUN_PRESENT 2 -static const char *scsi_null_device_strs = "nullnullnullnull"; +static char *scsi_null_device_strs = "nullnullnullnull"; #define MAX_SCSI_LUNS 512 diff --git a/trunk/drivers/scsi/scsi_sysfs.c b/trunk/drivers/scsi/scsi_sysfs.c index 15842b1f0f4a..46349293de08 100644 --- a/trunk/drivers/scsi/scsi_sysfs.c +++ b/trunk/drivers/scsi/scsi_sysfs.c @@ -21,7 +21,7 @@ #include "scsi_priv.h" #include "scsi_logging.h" -static const struct { +static struct { enum scsi_device_state value; char *name; } sdev_states[] = { @@ -48,7 +48,7 @@ const char *scsi_device_state_name(enum scsi_device_state state) return name; } -static const struct { +static struct { enum scsi_host_state value; char *name; } shost_states[] = { diff --git a/trunk/drivers/scsi/scsi_transport_fc.c b/trunk/drivers/scsi/scsi_transport_fc.c index 685b997306cf..2a1a99a2ef56 100644 --- a/trunk/drivers/scsi/scsi_transport_fc.c +++ b/trunk/drivers/scsi/scsi_transport_fc.c @@ -112,7 +112,7 @@ fc_enum_name_search(port_state, fc_port_state, fc_port_state_names) /* Convert fc_tgtid_binding_type values to ascii string name */ -static const struct { +static struct { enum fc_tgtid_binding_type value; char *name; int matchlen; @@ -150,7 +150,7 @@ get_fc_##title##_names(u32 table_key, char *buf) \ /* Convert FC_COS bit values to ascii string name */ -static const struct { +static struct { u32 value; char *name; } fc_cos_names[] = { @@ -164,7 +164,7 @@ fc_bitfield_name_search(cos, fc_cos_names) /* Convert FC_PORTSPEED bit values to ascii string name */ -static const struct { +static struct { u32 value; char *name; } fc_port_speed_names[] = { @@ -190,7 +190,7 @@ show_fc_fc4s (char *buf, u8 *fc4_list) /* Convert FC_RPORT_ROLE bit values to ascii string name */ -static const struct { +static struct { u32 value; char *name; } fc_remote_port_role_names[] = { diff --git a/trunk/drivers/scsi/scsi_transport_spi.c b/trunk/drivers/scsi/scsi_transport_spi.c index 46da6fe10ad5..38a53b5f9e9a 100644 --- a/trunk/drivers/scsi/scsi_transport_spi.c +++ b/trunk/drivers/scsi/scsi_transport_spi.c @@ -18,7 +18,6 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -#include #include #include #include @@ -379,7 +378,9 @@ static CLASS_DEVICE_ATTR(revalidate, S_IWUSR, NULL, store_spi_revalidate); /* Translate the period into ns according to the current spec * for SDTR/PPR messages */ -static int period_to_str(char *buf, int period) +static ssize_t +show_spi_transport_period_helper(struct class_device *cdev, char *buf, + int period) { int len, picosec; @@ -397,14 +398,6 @@ static int period_to_str(char *buf, int period) len = sprint_frac(buf, picosec, 1000); } - return len; -} - -static ssize_t -show_spi_transport_period_helper(struct class_device *cdev, char *buf, - int period) -{ - int len = period_to_str(buf, period); buf[len++] = '\n'; buf[len] = '\0'; return len; @@ -1048,133 +1041,12 @@ void spi_display_xfer_agreement(struct scsi_target *starget) tp->hold_mcs ? " HMCS" : "", tmp, tp->offset); } else { - dev_info(&starget->dev, "%sasynchronous\n", + dev_info(&starget->dev, "%sasynchronous.\n", tp->width ? "wide " : ""); } } EXPORT_SYMBOL(spi_display_xfer_agreement); -#ifdef CONFIG_SCSI_CONSTANTS -static const char * const one_byte_msgs[] = { -/* 0x00 */ "Command Complete", NULL, "Save Pointers", -/* 0x03 */ "Restore Pointers", "Disconnect", "Initiator Error", -/* 0x06 */ "Abort", "Message Reject", "Nop", "Message Parity Error", -/* 0x0a */ "Linked Command Complete", "Linked Command Complete w/flag", -/* 0x0c */ "Bus device reset", "Abort Tag", "Clear Queue", -/* 0x0f */ "Initiate Recovery", "Release Recovery" -}; - -static const char * const two_byte_msgs[] = { -/* 0x20 */ "Simple Queue Tag", "Head of Queue Tag", "Ordered Queue Tag", -/* 0x23 */ "Ignore Wide Residue" -}; - -static const char * const extended_msgs[] = { -/* 0x00 */ "Modify Data Pointer", "Synchronous Data Transfer Request", -/* 0x02 */ "SCSI-I Extended Identify", "Wide Data Transfer Request", -/* 0x04 */ "Parallel Protocol Request" -}; - -void print_nego(const unsigned char *msg, int per, int off, int width) -{ - if (per) { - char buf[20]; - period_to_str(buf, msg[per]); - printk("period = %s ns ", buf); - } - - if (off) - printk("offset = %d ", msg[off]); - if (width) - printk("width = %d ", 8 << msg[width]); -} - -int spi_print_msg(const unsigned char *msg) -{ - int len = 0, i; - if (msg[0] == EXTENDED_MESSAGE) { - len = 3 + msg[1]; - if (msg[2] < ARRAY_SIZE(extended_msgs)) - printk ("%s ", extended_msgs[msg[2]]); - else - printk ("Extended Message, reserved code (0x%02x) ", - (int) msg[2]); - switch (msg[2]) { - case EXTENDED_MODIFY_DATA_POINTER: - printk("pointer = %d", (int) (msg[3] << 24) | - (msg[4] << 16) | (msg[5] << 8) | msg[6]); - break; - case EXTENDED_SDTR: - print_nego(msg, 3, 4, 0); - break; - case EXTENDED_WDTR: - print_nego(msg, 0, 0, 3); - break; - case EXTENDED_PPR: - print_nego(msg, 3, 5, 6); - break; - default: - for (i = 2; i < len; ++i) - printk("%02x ", msg[i]); - } - /* Identify */ - } else if (msg[0] & 0x80) { - printk("Identify disconnect %sallowed %s %d ", - (msg[0] & 0x40) ? "" : "not ", - (msg[0] & 0x20) ? "target routine" : "lun", - msg[0] & 0x7); - len = 1; - /* Normal One byte */ - } else if (msg[0] < 0x1f) { - if (msg[0] < ARRAY_SIZE(one_byte_msgs)) - printk(one_byte_msgs[msg[0]]); - else - printk("reserved (%02x) ", msg[0]); - len = 1; - /* Two byte */ - } else if (msg[0] <= 0x2f) { - if ((msg[0] - 0x20) < ARRAY_SIZE(two_byte_msgs)) - printk("%s %02x ", two_byte_msgs[msg[0] - 0x20], - msg[1]); - else - printk("reserved two byte (%02x %02x) ", - msg[0], msg[1]); - len = 2; - } else - printk("reserved"); - return len; -} -EXPORT_SYMBOL(spi_print_msg); - -#else /* ifndef CONFIG_SCSI_CONSTANTS */ - -int spi_print_msg(const unsigned char *msg) -{ - int len = 0, i; - - if (msg[0] == EXTENDED_MESSAGE) { - len = 3 + msg[1]; - for (i = 0; i < len; ++i) - printk("%02x ", msg[i]); - /* Identify */ - } else if (msg[0] & 0x80) { - printk("%02x ", msg[0]); - len = 1; - /* Normal One byte */ - } else if (msg[0] < 0x1f) { - printk("%02x ", msg[0]); - len = 1; - /* Two byte */ - } else if (msg[0] <= 0x2f) { - printk("%02x %02x", msg[0], msg[1]); - len = 2; - } else - printk("%02x ", msg[0]); - return len; -} -EXPORT_SYMBOL(spi_print_msg); -#endif /* ! CONFIG_SCSI_CONSTANTS */ - #define SETUP_ATTRIBUTE(field) \ i->private_attrs[count] = class_device_attr_##field; \ if (!i->f->set_##field) { \ diff --git a/trunk/drivers/scsi/sd.c b/trunk/drivers/scsi/sd.c index 3d3ad7d1b779..03fcbab30033 100644 --- a/trunk/drivers/scsi/sd.c +++ b/trunk/drivers/scsi/sd.c @@ -245,7 +245,7 @@ static int sd_init_command(struct scsi_cmnd * SCpnt) * SG_IO from block layer already setup, just copy cdb basically */ if (blk_pc_request(rq)) { - scsi_setup_blk_pc_cmnd(SCpnt); + scsi_setup_blk_pc_cmnd(SCpnt, SD_PASSTHROUGH_RETRIES); if (rq->timeout) timeout = rq->timeout; @@ -1495,7 +1495,9 @@ static int sd_revalidate_disk(struct gendisk *disk) */ if (sdkp->media_present) { sd_read_capacity(sdkp, disk->disk_name, buffer); - sd_read_write_protect_flag(sdkp, disk->disk_name, buffer); + if (sdp->removable) + sd_read_write_protect_flag(sdkp, disk->disk_name, + buffer); sd_read_cache_type(sdkp, disk->disk_name, buffer); } diff --git a/trunk/drivers/scsi/sg.c b/trunk/drivers/scsi/sg.c index 221e96e2620a..b55c2a8a547c 100644 --- a/trunk/drivers/scsi/sg.c +++ b/trunk/drivers/scsi/sg.c @@ -104,6 +104,8 @@ static int sg_allow_dio = SG_ALLOW_DIO_DEF; static int sg_add(struct class_device *, struct class_interface *); static void sg_remove(struct class_device *, struct class_interface *); +static Scsi_Request *dummy_cmdp; /* only used for sizeof */ + static DEFINE_RWLOCK(sg_dev_arr_lock); /* Also used to lock file descriptor list for device */ @@ -117,7 +119,7 @@ typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */ unsigned short sglist_len; /* size of malloc'd scatter-gather list ++ */ unsigned bufflen; /* Size of (aggregate) data buffer */ unsigned b_malloc_len; /* actual len malloc'ed in buffer */ - struct scatterlist *buffer;/* scatter list */ + void *buffer; /* Data buffer or scatter list (k_use_sg>0) */ char dio_in_use; /* 0->indirect IO (or mmap), 1->dio */ unsigned char cmd_opcode; /* first byte of command */ } Sg_scatter_hold; @@ -126,11 +128,12 @@ struct sg_device; /* forward declarations */ struct sg_fd; typedef struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */ + Scsi_Request *my_cmdp; /* != 0 when request with lower levels */ struct sg_request *nextrp; /* NULL -> tail request (slist) */ struct sg_fd *parentfp; /* NULL -> not in use */ Sg_scatter_hold data; /* hold buffer, perhaps scatter list */ sg_io_hdr_t header; /* scsi command+info, see */ - unsigned char sense_b[SCSI_SENSE_BUFFERSIZE]; + unsigned char sense_b[sizeof (dummy_cmdp->sr_sense_buffer)]; char res_used; /* 1 -> using reserve buffer, 0 -> not ... */ char orphan; /* 1 -> drop on sight, 0 -> normal */ char sg_io_owned; /* 1 -> packet belongs to SG_IO */ @@ -171,8 +174,7 @@ typedef struct sg_device { /* holds the state of each scsi generic device */ } Sg_device; static int sg_fasync(int fd, struct file *filp, int mode); -/* tasklet or soft irq callback */ -static void sg_cmd_done(void *data, char *sense, int result, int resid); +static void sg_cmd_done(Scsi_Cmnd * SCpnt); /* tasklet or soft irq callback */ static int sg_start_req(Sg_request * srp); static void sg_finish_rem_req(Sg_request * srp); static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size); @@ -193,8 +195,8 @@ static void sg_remove_scat(Sg_scatter_hold * schp); static void sg_build_reserve(Sg_fd * sfp, int req_size); static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size); static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp); -static struct page *sg_page_malloc(int rqSz, int lowDma, int *retSzp); -static void sg_page_free(struct page *page, int size); +static char *sg_page_malloc(int rqSz, int lowDma, int *retSzp); +static void sg_page_free(char *buff, int size); static Sg_fd *sg_add_sfp(Sg_device * sdp, int dev); static int sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp); static void __sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp); @@ -205,6 +207,7 @@ static int sg_res_in_use(Sg_fd * sfp); static int sg_allow_access(unsigned char opcode, char dev_type); static int sg_build_direct(Sg_request * srp, Sg_fd * sfp, int dxfer_len); static Sg_device *sg_get_dev(int dev); +static inline unsigned char *sg_scatg2virt(const struct scatterlist *sclp); #ifdef CONFIG_SCSI_PROC_FS static int sg_last_dev(void); #endif @@ -223,7 +226,6 @@ sg_open(struct inode *inode, struct file *filp) { int dev = iminor(inode); int flags = filp->f_flags; - struct request_queue *q; Sg_device *sdp; Sg_fd *sfp; int res; @@ -285,9 +287,7 @@ sg_open(struct inode *inode, struct file *filp) } if (!sdp->headfp) { /* no existing opens on this device */ sdp->sgdebug = 0; - q = sdp->device->request_queue; - sdp->sg_tablesize = min(q->max_hw_segments, - q->max_phys_segments); + sdp->sg_tablesize = sdp->device->host->sg_tablesize; } if ((sfp = sg_add_sfp(sdp, dev))) filp->private_data = sfp; @@ -340,7 +340,6 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) return -ENXIO; SCSI_LOG_TIMEOUT(3, printk("sg_read: %s, count=%d\n", sdp->disk->disk_name, (int) count)); - if (!access_ok(VERIFY_WRITE, buf, count)) return -EFAULT; if (sfp->force_packid && (count >= SZ_SG_HEADER)) { @@ -492,7 +491,7 @@ sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp) if ((hp->mx_sb_len > 0) && hp->sbp) { if ((CHECK_CONDITION & hp->masked_status) || (DRIVER_SENSE & hp->driver_status)) { - int sb_len = SCSI_SENSE_BUFFERSIZE; + int sb_len = sizeof (dummy_cmdp->sr_sense_buffer); sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len; len = 8 + (int) srp->sense_b[7]; /* Additional sense length field */ len = (len > sb_len) ? sb_len : len; @@ -526,7 +525,7 @@ sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) Sg_request *srp; struct sg_header old_hdr; sg_io_hdr_t *hp; - unsigned char cmnd[MAX_COMMAND_SIZE]; + unsigned char cmnd[sizeof (dummy_cmdp->sr_cmnd)]; if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))) return -ENXIO; @@ -625,7 +624,7 @@ sg_new_write(Sg_fd * sfp, const char __user *buf, size_t count, int k; Sg_request *srp; sg_io_hdr_t *hp; - unsigned char cmnd[MAX_COMMAND_SIZE]; + unsigned char cmnd[sizeof (dummy_cmdp->sr_cmnd)]; int timeout; unsigned long ul_timeout; @@ -693,9 +692,11 @@ static int sg_common_write(Sg_fd * sfp, Sg_request * srp, unsigned char *cmnd, int timeout, int blocking) { - int k, data_dir; + int k; + Scsi_Request *SRpnt; Sg_device *sdp = sfp->parentdp; sg_io_hdr_t *hp = &srp->header; + request_queue_t *q; srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */ hp->status = 0; @@ -722,36 +723,51 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp, sg_finish_rem_req(srp); return -ENODEV; } + SRpnt = scsi_allocate_request(sdp->device, GFP_ATOMIC); + if (SRpnt == NULL) { + SCSI_LOG_TIMEOUT(1, printk("sg_write: no mem\n")); + sg_finish_rem_req(srp); + return -ENOMEM; + } + srp->my_cmdp = SRpnt; + q = SRpnt->sr_device->request_queue; + SRpnt->sr_request->rq_disk = sdp->disk; + SRpnt->sr_sense_buffer[0] = 0; + SRpnt->sr_cmd_len = hp->cmd_len; + SRpnt->sr_use_sg = srp->data.k_use_sg; + SRpnt->sr_sglist_len = srp->data.sglist_len; + SRpnt->sr_bufflen = srp->data.bufflen; + SRpnt->sr_underflow = 0; + SRpnt->sr_buffer = srp->data.buffer; switch (hp->dxfer_direction) { case SG_DXFER_TO_FROM_DEV: case SG_DXFER_FROM_DEV: - data_dir = DMA_FROM_DEVICE; + SRpnt->sr_data_direction = DMA_FROM_DEVICE; break; case SG_DXFER_TO_DEV: - data_dir = DMA_TO_DEVICE; + SRpnt->sr_data_direction = DMA_TO_DEVICE; break; case SG_DXFER_UNKNOWN: - data_dir = DMA_BIDIRECTIONAL; + SRpnt->sr_data_direction = DMA_BIDIRECTIONAL; break; default: - data_dir = DMA_NONE; + SRpnt->sr_data_direction = DMA_NONE; break; } + SRpnt->upper_private_data = srp; + srp->data.k_use_sg = 0; + srp->data.sglist_len = 0; + srp->data.bufflen = 0; + srp->data.buffer = NULL; hp->duration = jiffies_to_msecs(jiffies); /* Now send everything of to mid-level. The next time we hear about this packet is when sg_cmd_done() is called (i.e. a callback). */ - if (scsi_execute_async(sdp->device, cmnd, data_dir, srp->data.buffer, - hp->dxfer_len, srp->data.k_use_sg, timeout, - SG_DEFAULT_RETRIES, srp, sg_cmd_done, - GFP_ATOMIC)) { - SCSI_LOG_TIMEOUT(1, printk("sg_write: scsi_execute_async failed\n")); - /* - * most likely out of mem, but could also be a bad map - */ - return -ENOMEM; - } else - return 0; + scsi_do_req(SRpnt, (void *) cmnd, + (void *) SRpnt->sr_buffer, hp->dxfer_len, + sg_cmd_done, timeout, SG_DEFAULT_RETRIES); + /* dxfer_len overwrites SRpnt->sr_bufflen, hence need for b_malloc_len */ + return 0; } static int @@ -1140,22 +1156,45 @@ sg_fasync(int fd, struct file *filp, int mode) return (retval < 0) ? retval : 0; } +static inline unsigned char * +sg_scatg2virt(const struct scatterlist *sclp) +{ + return (sclp && sclp->page) ? + (unsigned char *) page_address(sclp->page) + sclp->offset : NULL; +} + /* When startFinish==1 increments page counts for pages other than the - first of scatter gather elements obtained from alloc_pages(). + first of scatter gather elements obtained from __get_free_pages(). When startFinish==0 decrements ... */ static void sg_rb_correct4mmap(Sg_scatter_hold * rsv_schp, int startFinish) { - struct scatterlist *sg = rsv_schp->buffer; + void *page_ptr; struct page *page; int k, m; SCSI_LOG_TIMEOUT(3, printk("sg_rb_correct4mmap: startFinish=%d, scatg=%d\n", startFinish, rsv_schp->k_use_sg)); /* N.B. correction _not_ applied to base page of each allocation */ - for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sg) { - for (m = PAGE_SIZE; m < sg->length; m += PAGE_SIZE) { - page = sg->page; + if (rsv_schp->k_use_sg) { /* reserve buffer is a scatter gather list */ + struct scatterlist *sclp = rsv_schp->buffer; + + for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sclp) { + for (m = PAGE_SIZE; m < sclp->length; m += PAGE_SIZE) { + page_ptr = sg_scatg2virt(sclp) + m; + page = virt_to_page(page_ptr); + if (startFinish) + get_page(page); + else { + if (page_count(page) > 0) + __put_page(page); + } + } + } + } else { /* reserve buffer is just a single allocation */ + for (m = PAGE_SIZE; m < rsv_schp->bufflen; m += PAGE_SIZE) { + page_ptr = (unsigned char *) rsv_schp->buffer + m; + page = virt_to_page(page_ptr); if (startFinish) get_page(page); else { @@ -1171,10 +1210,9 @@ sg_vma_nopage(struct vm_area_struct *vma, unsigned long addr, int *type) { Sg_fd *sfp; struct page *page = NOPAGE_SIGBUS; - unsigned long offset, len, sa; + void *page_ptr = NULL; + unsigned long offset; Sg_scatter_hold *rsv_schp; - struct scatterlist *sg; - int k; if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data))) return page; @@ -1184,21 +1222,30 @@ sg_vma_nopage(struct vm_area_struct *vma, unsigned long addr, int *type) return page; SCSI_LOG_TIMEOUT(3, printk("sg_vma_nopage: offset=%lu, scatg=%d\n", offset, rsv_schp->k_use_sg)); - sg = rsv_schp->buffer; - sa = vma->vm_start; - for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end); - ++k, ++sg) { - len = vma->vm_end - sa; - len = (len < sg->length) ? len : sg->length; - if (offset < len) { - page = sg->page; - get_page(page); /* increment page count */ - break; + if (rsv_schp->k_use_sg) { /* reserve buffer is a scatter gather list */ + int k; + unsigned long sa = vma->vm_start; + unsigned long len; + struct scatterlist *sclp = rsv_schp->buffer; + + for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end); + ++k, ++sclp) { + len = vma->vm_end - sa; + len = (len < sclp->length) ? len : sclp->length; + if (offset < len) { + page_ptr = sg_scatg2virt(sclp) + offset; + page = virt_to_page(page_ptr); + get_page(page); /* increment page count */ + break; + } + sa += len; + offset -= len; } - sa += len; - offset -= len; + } else { /* reserve buffer is just a single allocation */ + page_ptr = (unsigned char *) rsv_schp->buffer + offset; + page = virt_to_page(page_ptr); + get_page(page); /* increment page count */ } - if (type) *type = VM_FAULT_MINOR; return page; @@ -1212,10 +1259,8 @@ static int sg_mmap(struct file *filp, struct vm_area_struct *vma) { Sg_fd *sfp; - unsigned long req_sz, len, sa; + unsigned long req_sz; Sg_scatter_hold *rsv_schp; - int k; - struct scatterlist *sg; if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data))) return -ENXIO; @@ -1228,15 +1273,24 @@ sg_mmap(struct file *filp, struct vm_area_struct *vma) if (req_sz > rsv_schp->bufflen) return -ENOMEM; /* cannot map more than reserved buffer */ - sa = vma->vm_start; - sg = rsv_schp->buffer; - for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end); - ++k, ++sg) { - len = vma->vm_end - sa; - len = (len < sg->length) ? len : sg->length; - sa += len; + if (rsv_schp->k_use_sg) { /* reserve buffer is a scatter gather list */ + int k; + unsigned long sa = vma->vm_start; + unsigned long len; + struct scatterlist *sclp = rsv_schp->buffer; + + for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end); + ++k, ++sclp) { + if (0 != sclp->offset) + return -EFAULT; /* non page aligned memory ?? */ + len = vma->vm_end - sa; + len = (len < sclp->length) ? len : sclp->length; + sa += len; + } + } else { /* reserve buffer is just a single allocation */ + if ((unsigned long) rsv_schp->buffer & (PAGE_SIZE - 1)) + return -EFAULT; /* non page aligned memory ?? */ } - if (0 == sfp->mmap_called) { sg_rb_correct4mmap(rsv_schp, 1); /* do only once per fd lifetime */ sfp->mmap_called = 1; @@ -1250,16 +1304,21 @@ sg_mmap(struct file *filp, struct vm_area_struct *vma) /* This function is a "bottom half" handler that is called by the * mid level when a command is completed (or has failed). */ static void -sg_cmd_done(void *data, char *sense, int result, int resid) +sg_cmd_done(Scsi_Cmnd * SCpnt) { - Sg_request *srp = data; + Scsi_Request *SRpnt = NULL; Sg_device *sdp = NULL; Sg_fd *sfp; + Sg_request *srp = NULL; unsigned long iflags; unsigned int ms; + if (SCpnt && (SRpnt = SCpnt->sc_request)) + srp = (Sg_request *) SRpnt->upper_private_data; if (NULL == srp) { printk(KERN_ERR "sg_cmd_done: NULL request\n"); + if (SRpnt) + scsi_release_request(SRpnt); return; } sfp = srp->parentfp; @@ -1267,34 +1326,49 @@ sg_cmd_done(void *data, char *sense, int result, int resid) sdp = sfp->parentdp; if ((NULL == sdp) || sdp->detached) { printk(KERN_INFO "sg_cmd_done: device detached\n"); + scsi_release_request(SRpnt); return; } + /* First transfer ownership of data buffers to sg_device object. */ + srp->data.k_use_sg = SRpnt->sr_use_sg; + srp->data.sglist_len = SRpnt->sr_sglist_len; + srp->data.bufflen = SRpnt->sr_bufflen; + srp->data.buffer = SRpnt->sr_buffer; + /* now clear out request structure */ + SRpnt->sr_use_sg = 0; + SRpnt->sr_sglist_len = 0; + SRpnt->sr_bufflen = 0; + SRpnt->sr_buffer = NULL; + SRpnt->sr_underflow = 0; + SRpnt->sr_request->rq_disk = NULL; /* "sg" _disowns_ request blk */ + + srp->my_cmdp = NULL; SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n", - sdp->disk->disk_name, srp->header.pack_id, result)); - srp->header.resid = resid; + sdp->disk->disk_name, srp->header.pack_id, (int) SRpnt->sr_result)); + srp->header.resid = SCpnt->resid; ms = jiffies_to_msecs(jiffies); srp->header.duration = (ms > srp->header.duration) ? (ms - srp->header.duration) : 0; - if (0 != result) { + if (0 != SRpnt->sr_result) { struct scsi_sense_hdr sshdr; - memcpy(srp->sense_b, sense, sizeof (srp->sense_b)); - srp->header.status = 0xff & result; - srp->header.masked_status = status_byte(result); - srp->header.msg_status = msg_byte(result); - srp->header.host_status = host_byte(result); - srp->header.driver_status = driver_byte(result); + memcpy(srp->sense_b, SRpnt->sr_sense_buffer, + sizeof (srp->sense_b)); + srp->header.status = 0xff & SRpnt->sr_result; + srp->header.masked_status = status_byte(SRpnt->sr_result); + srp->header.msg_status = msg_byte(SRpnt->sr_result); + srp->header.host_status = host_byte(SRpnt->sr_result); + srp->header.driver_status = driver_byte(SRpnt->sr_result); if ((sdp->sgdebug > 0) && ((CHECK_CONDITION == srp->header.masked_status) || (COMMAND_TERMINATED == srp->header.masked_status))) - __scsi_print_sense("sg_cmd_done", sense, - SCSI_SENSE_BUFFERSIZE); + scsi_print_req_sense("sg_cmd_done", SRpnt); /* Following if statement is a patch supplied by Eric Youngdale */ - if (driver_byte(result) != 0 - && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr) + if (driver_byte(SRpnt->sr_result) != 0 + && scsi_command_normalize_sense(SCpnt, &sshdr) && !scsi_sense_is_deferred(&sshdr) && sshdr.sense_key == UNIT_ATTENTION && sdp->device->removable) { @@ -1305,6 +1379,8 @@ sg_cmd_done(void *data, char *sense, int result, int resid) } /* Rely on write phase to clean out srp status values, so no "else" */ + scsi_release_request(SRpnt); + SRpnt = NULL; if (sfp->closed) { /* whoops this fd already released, cleanup */ SCSI_LOG_TIMEOUT(1, printk("sg_cmd_done: already closed, freeing ...\n")); sg_finish_rem_req(srp); @@ -1355,7 +1431,6 @@ static int sg_sysfs_valid = 0; static int sg_alloc(struct gendisk *disk, struct scsi_device *scsidp) { - struct request_queue *q = scsidp->request_queue; Sg_device *sdp; unsigned long iflags; void *old_sg_dev_arr = NULL; @@ -1398,7 +1473,7 @@ static int sg_alloc(struct gendisk *disk, struct scsi_device *scsidp) sdp->disk = disk; sdp->device = scsidp; init_waitqueue_head(&sdp->o_excl_wait); - sdp->sg_tablesize = min(q->max_hw_segments, q->max_phys_segments); + sdp->sg_tablesize = scsidp->host ? scsidp->host->sg_tablesize : 0; sg_nr_dev++; sg_dev_arr[k] = sdp; @@ -1678,35 +1753,36 @@ sg_finish_rem_req(Sg_request * srp) static int sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize) { - int sg_bufflen = tablesize * sizeof(struct scatterlist); - unsigned int gfp_flags = GFP_ATOMIC | __GFP_NOWARN; + int ret_sz; + int elem_sz = sizeof (struct scatterlist); + int sg_bufflen = tablesize * elem_sz; + int mx_sc_elems = tablesize; - /* - * TODO: test without low_dma, we should not need it since - * the block layer will bounce the buffer for us - * - * XXX(hch): we shouldn't need GFP_DMA for the actual S/G list. - */ - if (sfp->low_dma) - gfp_flags |= GFP_DMA; - schp->buffer = kzalloc(sg_bufflen, gfp_flags); + schp->buffer = sg_page_malloc(sg_bufflen, sfp->low_dma, &ret_sz); if (!schp->buffer) return -ENOMEM; + else if (ret_sz != sg_bufflen) { + sg_bufflen = ret_sz; + mx_sc_elems = sg_bufflen / elem_sz; + } schp->sglist_len = sg_bufflen; - return tablesize; /* number of scat_gath elements allocated */ + memset(schp->buffer, 0, sg_bufflen); + return mx_sc_elems; /* number of scat_gath elements allocated */ } #ifdef SG_ALLOW_DIO_CODE /* vvvvvvvv following code borrowed from st driver's direct IO vvvvvvvvv */ - /* TODO: hopefully we can use the generic block layer code */ + /* hopefully this generic code will moved to a library */ /* Pin down user pages and put them into a scatter gather list. Returns <= 0 if - mapping of all pages not successful + - any page is above max_pfn (i.e., either completely successful or fails) */ static int st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, - unsigned long uaddr, size_t count, int rw) + unsigned long uaddr, size_t count, int rw, + unsigned long max_pfn) { unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT; unsigned long start = uaddr >> PAGE_SHIFT; @@ -1752,17 +1828,21 @@ st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, * probably wrong function for rw==WRITE */ flush_dcache_page(pages[i]); + if (page_to_pfn(pages[i]) > max_pfn) + goto out_unlock; /* ?? Is locking needed? I don't think so */ /* if (TestSetPageLocked(pages[i])) goto out_unlock; */ } - sgl[0].page = pages[0]; + /* Populate the scatter/gather list */ + sgl[0].page = pages[0]; sgl[0].offset = uaddr & ~PAGE_MASK; if (nr_pages > 1) { sgl[0].length = PAGE_SIZE - sgl[0].offset; count -= sgl[0].length; for (i=1; i < nr_pages ; i++) { + sgl[i].offset = 0; sgl[i].page = pages[i]; sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE; count -= PAGE_SIZE; @@ -1775,6 +1855,10 @@ st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, kfree(pages); return nr_pages; + out_unlock: + /* for (j=0; j < i; j++) + unlock_page(pages[j]); */ + res = 0; out_unmap: if (res > 0) { for (j=0; j < res; j++) @@ -1820,20 +1904,20 @@ sg_build_direct(Sg_request * srp, Sg_fd * sfp, int dxfer_len) sg_io_hdr_t *hp = &srp->header; Sg_scatter_hold *schp = &srp->data; int sg_tablesize = sfp->parentdp->sg_tablesize; + struct scatterlist *sgl; int mx_sc_elems, res; struct scsi_device *sdev = sfp->parentdp->device; if (((unsigned long)hp->dxferp & queue_dma_alignment(sdev->request_queue)) != 0) return 1; - mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize); if (mx_sc_elems <= 0) { return 1; } - res = st_map_user_pages(schp->buffer, mx_sc_elems, - (unsigned long)hp->dxferp, dxfer_len, - (SG_DXFER_TO_DEV == hp->dxfer_direction) ? 1 : 0); + sgl = (struct scatterlist *)schp->buffer; + res = st_map_user_pages(sgl, mx_sc_elems, (unsigned long)hp->dxferp, dxfer_len, + (SG_DXFER_TO_DEV == hp->dxfer_direction) ? 1 : 0, ULONG_MAX); if (res <= 0) return 1; schp->k_use_sg = res; @@ -1848,11 +1932,9 @@ sg_build_direct(Sg_request * srp, Sg_fd * sfp, int dxfer_len) static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size) { - struct scatterlist *sg; - int ret_sz = 0, k, rem_sz, num, mx_sc_elems; - int sg_tablesize = sfp->parentdp->sg_tablesize; + int ret_sz; int blk_size = buff_size; - struct page *p = NULL; + unsigned char *p = NULL; if ((blk_size < 0) || (!sfp)) return -EFAULT; @@ -1862,35 +1944,59 @@ sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size) blk_size = (blk_size + SG_SECTOR_MSK) & (~SG_SECTOR_MSK); SCSI_LOG_TIMEOUT(4, printk("sg_build_indirect: buff_size=%d, blk_size=%d\n", buff_size, blk_size)); - - /* N.B. ret_sz carried into this block ... */ - mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize); - if (mx_sc_elems < 0) - return mx_sc_elems; /* most likely -ENOMEM */ - - for (k = 0, sg = schp->buffer, rem_sz = blk_size; - (rem_sz > 0) && (k < mx_sc_elems); - ++k, rem_sz -= ret_sz, ++sg) { - - num = (rem_sz > SG_SCATTER_SZ) ? SG_SCATTER_SZ : rem_sz; - p = sg_page_malloc(num, sfp->low_dma, &ret_sz); + if (blk_size <= SG_SCATTER_SZ) { + p = sg_page_malloc(blk_size, sfp->low_dma, &ret_sz); if (!p) return -ENOMEM; - - sg->page = p; - sg->length = ret_sz; - - SCSI_LOG_TIMEOUT(5, printk("sg_build_build: k=%d, a=0x%p, len=%d\n", - k, p, ret_sz)); - } /* end of for loop */ - - schp->k_use_sg = k; - SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, rem_sz=%d\n", k, rem_sz)); - - schp->bufflen = blk_size; - if (rem_sz > 0) /* must have failed */ - return -ENOMEM; - + if (blk_size == ret_sz) { /* got it on the first attempt */ + schp->k_use_sg = 0; + schp->buffer = p; + schp->bufflen = blk_size; + schp->b_malloc_len = blk_size; + return 0; + } + } else { + p = sg_page_malloc(SG_SCATTER_SZ, sfp->low_dma, &ret_sz); + if (!p) + return -ENOMEM; + } +/* Want some local declarations, so start new block ... */ + { /* lets try and build a scatter gather list */ + struct scatterlist *sclp; + int k, rem_sz, num; + int mx_sc_elems; + int sg_tablesize = sfp->parentdp->sg_tablesize; + int first = 1; + + /* N.B. ret_sz carried into this block ... */ + mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize); + if (mx_sc_elems < 0) + return mx_sc_elems; /* most likely -ENOMEM */ + + for (k = 0, sclp = schp->buffer, rem_sz = blk_size; + (rem_sz > 0) && (k < mx_sc_elems); + ++k, rem_sz -= ret_sz, ++sclp) { + if (first) + first = 0; + else { + num = + (rem_sz > + SG_SCATTER_SZ) ? SG_SCATTER_SZ : rem_sz; + p = sg_page_malloc(num, sfp->low_dma, &ret_sz); + if (!p) + break; + } + sg_set_buf(sclp, p, ret_sz); + + SCSI_LOG_TIMEOUT(5, printk("sg_build_build: k=%d, a=0x%p, len=%d\n", + k, sg_scatg2virt(sclp), ret_sz)); + } /* end of for loop */ + schp->k_use_sg = k; + SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k_use_sg=%d, rem_sz=%d\n", k, rem_sz)); + schp->bufflen = blk_size; + if (rem_sz > 0) /* must have failed */ + return -ENOMEM; + } return 0; } @@ -1899,7 +2005,6 @@ sg_write_xfer(Sg_request * srp) { sg_io_hdr_t *hp = &srp->header; Sg_scatter_hold *schp = &srp->data; - struct scatterlist *sg = schp->buffer; int num_xfer = 0; int j, k, onum, usglen, ksglen, res; int iovec_count = (int) hp->iovec_count; @@ -1928,45 +2033,63 @@ sg_write_xfer(Sg_request * srp) } else onum = 1; - ksglen = sg->length; - p = page_address(sg->page); - for (j = 0, k = 0; j < onum; ++j) { - res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up); - if (res) - return res; - - for (; p; ++sg, ksglen = sg->length, - p = page_address(sg->page)) { - if (usglen <= 0) - break; - if (ksglen > usglen) { - if (usglen >= num_xfer) { - if (__copy_from_user(p, up, num_xfer)) + if (0 == schp->k_use_sg) { /* kernel has single buffer */ + for (j = 0, p = schp->buffer; j < onum; ++j) { + res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up); + if (res) + return res; + usglen = (num_xfer > usglen) ? usglen : num_xfer; + if (__copy_from_user(p, up, usglen)) + return -EFAULT; + p += usglen; + num_xfer -= usglen; + if (num_xfer <= 0) + return 0; + } + } else { /* kernel using scatter gather list */ + struct scatterlist *sclp = (struct scatterlist *) schp->buffer; + + ksglen = (int) sclp->length; + p = sg_scatg2virt(sclp); + for (j = 0, k = 0; j < onum; ++j) { + res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up); + if (res) + return res; + + for (; p; ++sclp, ksglen = (int) sclp->length, + p = sg_scatg2virt(sclp)) { + if (usglen <= 0) + break; + if (ksglen > usglen) { + if (usglen >= num_xfer) { + if (__copy_from_user + (p, up, num_xfer)) + return -EFAULT; + return 0; + } + if (__copy_from_user(p, up, usglen)) return -EFAULT; - return 0; - } - if (__copy_from_user(p, up, usglen)) - return -EFAULT; - p += usglen; - ksglen -= usglen; - break; - } else { - if (ksglen >= num_xfer) { - if (__copy_from_user(p, up, num_xfer)) + p += usglen; + ksglen -= usglen; + break; + } else { + if (ksglen >= num_xfer) { + if (__copy_from_user + (p, up, num_xfer)) + return -EFAULT; + return 0; + } + if (__copy_from_user(p, up, ksglen)) return -EFAULT; - return 0; + up += ksglen; + usglen -= ksglen; } - if (__copy_from_user(p, up, ksglen)) - return -EFAULT; - up += ksglen; - usglen -= ksglen; + ++k; + if (k >= schp->k_use_sg) + return 0; } - ++k; - if (k >= schp->k_use_sg) - return 0; } } - return 0; } @@ -2004,25 +2127,29 @@ sg_remove_scat(Sg_scatter_hold * schp) { SCSI_LOG_TIMEOUT(4, printk("sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg)); if (schp->buffer && (schp->sglist_len > 0)) { - struct scatterlist *sg = schp->buffer; + struct scatterlist *sclp = (struct scatterlist *) schp->buffer; if (schp->dio_in_use) { #ifdef SG_ALLOW_DIO_CODE - st_unmap_user_pages(sg, schp->k_use_sg, TRUE); + st_unmap_user_pages(sclp, schp->k_use_sg, TRUE); #endif } else { int k; - for (k = 0; (k < schp->k_use_sg) && sg->page; - ++k, ++sg) { + for (k = 0; (k < schp->k_use_sg) && sg_scatg2virt(sclp); + ++k, ++sclp) { SCSI_LOG_TIMEOUT(5, printk( "sg_remove_scat: k=%d, a=0x%p, len=%d\n", - k, sg->page, sg->length)); - sg_page_free(sg->page, sg->length); + k, sg_scatg2virt(sclp), sclp->length)); + sg_page_free(sg_scatg2virt(sclp), sclp->length); + sclp->page = NULL; + sclp->offset = 0; + sclp->length = 0; } } - kfree(schp->buffer); - } + sg_page_free(schp->buffer, schp->sglist_len); + } else if (schp->buffer) + sg_page_free(schp->buffer, schp->b_malloc_len); memset(schp, 0, sizeof (*schp)); } @@ -2031,7 +2158,6 @@ sg_read_xfer(Sg_request * srp) { sg_io_hdr_t *hp = &srp->header; Sg_scatter_hold *schp = &srp->data; - struct scatterlist *sg = schp->buffer; int num_xfer = 0; int j, k, onum, usglen, ksglen, res; int iovec_count = (int) hp->iovec_count; @@ -2060,45 +2186,63 @@ sg_read_xfer(Sg_request * srp) } else onum = 1; - p = page_address(sg->page); - ksglen = sg->length; - for (j = 0, k = 0; j < onum; ++j) { - res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up); - if (res) - return res; - - for (; p; ++sg, ksglen = sg->length, - p = page_address(sg->page)) { - if (usglen <= 0) - break; - if (ksglen > usglen) { - if (usglen >= num_xfer) { - if (__copy_to_user(up, p, num_xfer)) + if (0 == schp->k_use_sg) { /* kernel has single buffer */ + for (j = 0, p = schp->buffer; j < onum; ++j) { + res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up); + if (res) + return res; + usglen = (num_xfer > usglen) ? usglen : num_xfer; + if (__copy_to_user(up, p, usglen)) + return -EFAULT; + p += usglen; + num_xfer -= usglen; + if (num_xfer <= 0) + return 0; + } + } else { /* kernel using scatter gather list */ + struct scatterlist *sclp = (struct scatterlist *) schp->buffer; + + ksglen = (int) sclp->length; + p = sg_scatg2virt(sclp); + for (j = 0, k = 0; j < onum; ++j) { + res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up); + if (res) + return res; + + for (; p; ++sclp, ksglen = (int) sclp->length, + p = sg_scatg2virt(sclp)) { + if (usglen <= 0) + break; + if (ksglen > usglen) { + if (usglen >= num_xfer) { + if (__copy_to_user + (up, p, num_xfer)) + return -EFAULT; + return 0; + } + if (__copy_to_user(up, p, usglen)) return -EFAULT; - return 0; - } - if (__copy_to_user(up, p, usglen)) - return -EFAULT; - p += usglen; - ksglen -= usglen; - break; - } else { - if (ksglen >= num_xfer) { - if (__copy_to_user(up, p, num_xfer)) + p += usglen; + ksglen -= usglen; + break; + } else { + if (ksglen >= num_xfer) { + if (__copy_to_user + (up, p, num_xfer)) + return -EFAULT; + return 0; + } + if (__copy_to_user(up, p, ksglen)) return -EFAULT; - return 0; + up += ksglen; + usglen -= ksglen; } - if (__copy_to_user(up, p, ksglen)) - return -EFAULT; - up += ksglen; - usglen -= ksglen; + ++k; + if (k >= schp->k_use_sg) + return 0; } - ++k; - if (k >= schp->k_use_sg) - return 0; } } - return 0; } @@ -2106,32 +2250,37 @@ static int sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer) { Sg_scatter_hold *schp = &srp->data; - struct scatterlist *sg = schp->buffer; - int k, num; SCSI_LOG_TIMEOUT(4, printk("sg_read_oxfer: num_read_xfer=%d\n", num_read_xfer)); if ((!outp) || (num_read_xfer <= 0)) return 0; - - for (k = 0; (k < schp->k_use_sg) && sg->page; ++k, ++sg) { - num = sg->length; - if (num > num_read_xfer) { - if (__copy_to_user(outp, page_address(sg->page), - num_read_xfer)) - return -EFAULT; - break; - } else { - if (__copy_to_user(outp, page_address(sg->page), - num)) - return -EFAULT; - num_read_xfer -= num; - if (num_read_xfer <= 0) + if (schp->k_use_sg > 0) { + int k, num; + struct scatterlist *sclp = (struct scatterlist *) schp->buffer; + + for (k = 0; (k < schp->k_use_sg) && sg_scatg2virt(sclp); + ++k, ++sclp) { + num = (int) sclp->length; + if (num > num_read_xfer) { + if (__copy_to_user + (outp, sg_scatg2virt(sclp), num_read_xfer)) + return -EFAULT; break; - outp += num; + } else { + if (__copy_to_user + (outp, sg_scatg2virt(sclp), num)) + return -EFAULT; + num_read_xfer -= num; + if (num_read_xfer <= 0) + break; + outp += num; + } } + } else { + if (__copy_to_user(outp, schp->buffer, num_read_xfer)) + return -EFAULT; } - return 0; } @@ -2157,31 +2306,44 @@ sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size) { Sg_scatter_hold *req_schp = &srp->data; Sg_scatter_hold *rsv_schp = &sfp->reserve; - struct scatterlist *sg = rsv_schp->buffer; - int k, num, rem; srp->res_used = 1; SCSI_LOG_TIMEOUT(4, printk("sg_link_reserve: size=%d\n", size)); - rem = size = (size + 1) & (~1); /* round to even for aha1542 */ - - for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sg) { - num = sg->length; - if (rem <= num) { - sfp->save_scat_len = num; - sg->length = rem; - req_schp->k_use_sg = k + 1; - req_schp->sglist_len = rsv_schp->sglist_len; - req_schp->buffer = rsv_schp->buffer; - - req_schp->bufflen = size; - req_schp->b_malloc_len = rsv_schp->b_malloc_len; - break; - } else - rem -= num; + size = (size + 1) & (~1); /* round to even for aha1542 */ + if (rsv_schp->k_use_sg > 0) { + int k, num; + int rem = size; + struct scatterlist *sclp = + (struct scatterlist *) rsv_schp->buffer; + + for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sclp) { + num = (int) sclp->length; + if (rem <= num) { + if (0 == k) { + req_schp->k_use_sg = 0; + req_schp->buffer = sg_scatg2virt(sclp); + } else { + sfp->save_scat_len = num; + sclp->length = (unsigned) rem; + req_schp->k_use_sg = k + 1; + req_schp->sglist_len = + rsv_schp->sglist_len; + req_schp->buffer = rsv_schp->buffer; + } + req_schp->bufflen = size; + req_schp->b_malloc_len = rsv_schp->b_malloc_len; + break; + } else + rem -= num; + } + if (k >= rsv_schp->k_use_sg) + SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n")); + } else { + req_schp->k_use_sg = 0; + req_schp->bufflen = size; + req_schp->buffer = rsv_schp->buffer; + req_schp->b_malloc_len = rsv_schp->b_malloc_len; } - - if (k >= rsv_schp->k_use_sg) - SCSI_LOG_TIMEOUT(1, printk("sg_link_reserve: BAD size\n")); } static void @@ -2193,10 +2355,11 @@ sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp) SCSI_LOG_TIMEOUT(4, printk("sg_unlink_reserve: req->k_use_sg=%d\n", (int) req_schp->k_use_sg)); if ((rsv_schp->k_use_sg > 0) && (req_schp->k_use_sg > 0)) { - struct scatterlist *sg = rsv_schp->buffer; + struct scatterlist *sclp = + (struct scatterlist *) rsv_schp->buffer; if (sfp->save_scat_len > 0) - (sg + (req_schp->k_use_sg - 1))->length = + (sclp + (req_schp->k_use_sg - 1))->length = (unsigned) sfp->save_scat_len; else SCSI_LOG_TIMEOUT(1, printk ("sg_unlink_reserve: BAD save_scat_len\n")); @@ -2282,6 +2445,7 @@ sg_add_request(Sg_fd * sfp) if (resp) { resp->nextrp = NULL; resp->header.duration = jiffies_to_msecs(jiffies); + resp->my_cmdp = NULL; } write_unlock_irqrestore(&sfp->rq_list_lock, iflags); return resp; @@ -2299,6 +2463,8 @@ sg_remove_request(Sg_fd * sfp, Sg_request * srp) if ((!sfp) || (!srp) || (!sfp->headrp)) return res; write_lock_irqsave(&sfp->rq_list_lock, iflags); + if (srp->my_cmdp) + srp->my_cmdp->upper_private_data = NULL; prev_rp = sfp->headrp; if (srp == prev_rp) { sfp->headrp = prev_rp->nextrp; @@ -2341,10 +2507,10 @@ sg_add_sfp(Sg_device * sdp, int dev) Sg_fd *sfp; unsigned long iflags; - sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN); + sfp = (Sg_fd *) sg_page_malloc(sizeof (Sg_fd), 0, NULL); if (!sfp) return NULL; - + memset(sfp, 0, sizeof (Sg_fd)); init_waitqueue_head(&sfp->read_wait); rwlock_init(&sfp->rq_list_lock); @@ -2401,7 +2567,7 @@ __sg_remove_sfp(Sg_device * sdp, Sg_fd * sfp) } sfp->parentdp = NULL; SCSI_LOG_TIMEOUT(6, printk("__sg_remove_sfp: sfp=0x%p\n", sfp)); - kfree(sfp); + sg_page_free((char *) sfp, sizeof (Sg_fd)); } /* Returns 0 in normal case, 1 when detached and sdp object removed */ @@ -2466,10 +2632,10 @@ sg_res_in_use(Sg_fd * sfp) } /* If retSzp==NULL want exact size or fail */ -static struct page * +static char * sg_page_malloc(int rqSz, int lowDma, int *retSzp) { - struct page *resp = NULL; + char *resp = NULL; gfp_t page_mask; int order, a_size; int resSz = rqSz; @@ -2484,11 +2650,11 @@ sg_page_malloc(int rqSz, int lowDma, int *retSzp) for (order = 0, a_size = PAGE_SIZE; a_size < rqSz; order++, a_size <<= 1) ; - resp = alloc_pages(page_mask, order); + resp = (char *) __get_free_pages(page_mask, order); while ((!resp) && order && retSzp) { --order; a_size >>= 1; /* divide by 2, until PAGE_SIZE */ - resp = alloc_pages(page_mask, order); /* try half */ + resp = (char *) __get_free_pages(page_mask, order); /* try half */ resSz = a_size; } if (resp) { @@ -2501,15 +2667,15 @@ sg_page_malloc(int rqSz, int lowDma, int *retSzp) } static void -sg_page_free(struct page *page, int size) +sg_page_free(char *buff, int size) { int order, a_size; - if (!page) + if (!buff) return; for (order = 0, a_size = PAGE_SIZE; a_size < size; order++, a_size <<= 1) ; - __free_pages(page, order); + free_pages((unsigned long) buff, order); } #ifndef MAINTENANCE_IN_CMD @@ -2901,11 +3067,13 @@ static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp) cp = " "; } seq_printf(s, cp); - blen = srp->data.bufflen; - usg = srp->data.k_use_sg; + blen = srp->my_cmdp ? + srp->my_cmdp->sr_bufflen : srp->data.bufflen; + usg = srp->my_cmdp ? + srp->my_cmdp->sr_use_sg : srp->data.k_use_sg; seq_printf(s, srp->done ? ((1 == srp->done) ? "rcv:" : "fin:") - : "act:"); + : (srp->my_cmdp ? "act:" : "prior:")); seq_printf(s, " id=%d blen=%d", srp->header.pack_id, blen); if (srp->done) diff --git a/trunk/drivers/scsi/sr.c b/trunk/drivers/scsi/sr.c index a4d9be7c6874..fb4012b5c188 100644 --- a/trunk/drivers/scsi/sr.c +++ b/trunk/drivers/scsi/sr.c @@ -320,7 +320,7 @@ static int sr_init_command(struct scsi_cmnd * SCpnt) * these are already setup, just copy cdb basically */ if (SCpnt->request->flags & REQ_BLOCK_PC) { - scsi_setup_blk_pc_cmnd(SCpnt); + scsi_setup_blk_pc_cmnd(SCpnt, MAX_RETRIES); if (SCpnt->timeout_per_command) timeout = SCpnt->timeout_per_command; @@ -716,7 +716,7 @@ static void get_capabilities(struct scsi_cd *cd) unsigned int the_result; int retries, rc, n; - static const char *loadmech[] = + static char *loadmech[] = { "caddy", "tray", diff --git a/trunk/drivers/scsi/sr_vendor.c b/trunk/drivers/scsi/sr_vendor.c index 9dde8df2f5c9..78274dc91f5c 100644 --- a/trunk/drivers/scsi/sr_vendor.c +++ b/trunk/drivers/scsi/sr_vendor.c @@ -68,8 +68,8 @@ void sr_vendor_init(Scsi_CD *cd) #ifndef CONFIG_BLK_DEV_SR_VENDOR cd->vendor = VENDOR_SCSI3; #else - const char *vendor = cd->device->vendor; - const char *model = cd->device->model; + char *vendor = cd->device->vendor; + char *model = cd->device->model; /* default */ cd->vendor = VENDOR_SCSI3; diff --git a/trunk/drivers/scsi/st.c b/trunk/drivers/scsi/st.c index c4aade8f5345..dd592f6a2529 100644 --- a/trunk/drivers/scsi/st.c +++ b/trunk/drivers/scsi/st.c @@ -17,7 +17,7 @@ Last modified: 18-JAN-1998 Richard Gooch Devfs support */ -static const char *verstr = "20050830"; +static char *verstr = "20050830"; #include @@ -50,6 +50,7 @@ static const char *verstr = "20050830"; #include #include #include +#include #include @@ -133,7 +134,7 @@ static struct st_dev_parm { #endif /* Bit reversed order to get same names for same minors with all mode counts */ -static const char *st_formats[] = { +static char *st_formats[] = { "", "r", "k", "s", "l", "t", "o", "u", "m", "v", "p", "x", "a", "y", "q", "z"}; @@ -187,6 +188,8 @@ static int from_buffer(struct st_buffer *, char __user *, int); static void move_buffer_data(struct st_buffer *, int); static void buf_to_sg(struct st_buffer *, unsigned int); +static int st_map_user_pages(struct scatterlist *, const unsigned int, + unsigned long, size_t, int, unsigned long); static int sgl_map_user_pages(struct scatterlist *, const unsigned int, unsigned long, size_t, int); static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int); @@ -310,13 +313,12 @@ static inline char *tape_name(struct scsi_tape *tape) } -static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s) +static void st_analyze_sense(struct scsi_request *SRpnt, struct st_cmdstatus *s) { const u8 *ucp; - const u8 *sense = SRpnt->sense; + const u8 *sense = SRpnt->sr_sense_buffer; - s->have_sense = scsi_normalize_sense(SRpnt->sense, - SCSI_SENSE_BUFFERSIZE, &s->sense_hdr); + s->have_sense = scsi_request_normalize_sense(SRpnt, &s->sense_hdr); s->flags = 0; if (s->have_sense) { @@ -343,9 +345,9 @@ static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s) /* Convert the result to success code */ -static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) +static int st_chk_result(struct scsi_tape *STp, struct scsi_request * SRpnt) { - int result = SRpnt->result; + int result = SRpnt->sr_result; u8 scode; DEB(const char *stp;) char *name = tape_name(STp); @@ -364,12 +366,13 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) DEB( if (debugging) { - printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n", + printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n", name, result, - SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2], - SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]); + SRpnt->sr_cmnd[0], SRpnt->sr_cmnd[1], SRpnt->sr_cmnd[2], + SRpnt->sr_cmnd[3], SRpnt->sr_cmnd[4], SRpnt->sr_cmnd[5], + SRpnt->sr_bufflen); if (cmdstatp->have_sense) - __scsi_print_sense("st", SRpnt->sense, SCSI_SENSE_BUFFERSIZE); + scsi_print_req_sense("st", SRpnt); } ) /* end DEB */ if (!debugging) { /* Abnormal conditions for tape */ if (!cmdstatp->have_sense) @@ -383,21 +386,20 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) /* scode != UNIT_ATTENTION && */ scode != BLANK_CHECK && scode != VOLUME_OVERFLOW && - SRpnt->cmd[0] != MODE_SENSE && - SRpnt->cmd[0] != TEST_UNIT_READY) { + SRpnt->sr_cmnd[0] != MODE_SENSE && + SRpnt->sr_cmnd[0] != TEST_UNIT_READY) { printk(KERN_WARNING "%s: Error with sense data: ", name); - __scsi_print_sense("st", SRpnt->sense, - SCSI_SENSE_BUFFERSIZE); + scsi_print_req_sense("st", SRpnt); } } if (cmdstatp->fixed_format && STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */ if (STp->cln_sense_value) - STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & + STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] & STp->cln_sense_mask) == STp->cln_sense_value); else - STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] & + STp->cleaning_req |= ((SRpnt->sr_sense_buffer[STp->cln_mode] & STp->cln_sense_mask) != 0); } if (cmdstatp->have_sense && @@ -409,8 +411,8 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) if (cmdstatp->have_sense && scode == RECOVERED_ERROR #if ST_RECOVERED_WRITE_FATAL - && SRpnt->cmd[0] != WRITE_6 - && SRpnt->cmd[0] != WRITE_FILEMARKS + && SRpnt->sr_cmnd[0] != WRITE_6 + && SRpnt->sr_cmnd[0] != WRITE_FILEMARKS #endif ) { STp->recover_count++; @@ -418,9 +420,9 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) DEB( if (debugging) { - if (SRpnt->cmd[0] == READ_6) + if (SRpnt->sr_cmnd[0] == READ_6) stp = "read"; - else if (SRpnt->cmd[0] == WRITE_6) + else if (SRpnt->sr_cmnd[0] == WRITE_6) stp = "write"; else stp = "ioctl"; @@ -436,37 +438,28 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt) /* Wakeup from interrupt */ -static void st_sleep_done(void *data, char *sense, int result, int resid) +static void st_sleep_done(struct scsi_cmnd * SCpnt) { - struct st_request *SRpnt = data; - struct scsi_tape *STp = SRpnt->stp; + struct scsi_tape *STp = container_of(SCpnt->request->rq_disk->private_data, + struct scsi_tape, driver); - memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE); - (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result; + (STp->buffer)->cmdstat.midlevel_result = SCpnt->result; + SCpnt->request->rq_status = RQ_SCSI_DONE; DEB( STp->write_pending = 0; ) - if (SRpnt->waiting) - complete(SRpnt->waiting); -} - -static struct st_request *st_allocate_request(void) -{ - return kzalloc(sizeof(struct st_request), GFP_KERNEL); -} - -static void st_release_request(struct st_request *streq) -{ - kfree(streq); + if (SCpnt->request->waiting) + complete(SCpnt->request->waiting); } /* Do the scsi command. Waits until command performed if do_wait is true. Otherwise write_behind_check() is used to check that the command has finished. */ -static struct st_request * -st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd, +static struct scsi_request * +st_do_scsi(struct scsi_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd, int bytes, int direction, int timeout, int retries, int do_wait) { struct completion *waiting; + unsigned char *bp; /* if async, make sure there's no command outstanding */ if (!do_wait && ((STp->buffer)->last_SRpnt)) { @@ -480,7 +473,7 @@ st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd } if (SRpnt == NULL) { - SRpnt = st_allocate_request(); + SRpnt = scsi_allocate_request(STp->device, GFP_ATOMIC); if (SRpnt == NULL) { DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n", tape_name(STp)); ); @@ -490,7 +483,6 @@ st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd (STp->buffer)->syscall_result = (-EBUSY); return NULL; } - SRpnt->stp = STp; } /* If async IO, set last_SRpnt. This ptr tells write_behind_check @@ -500,28 +492,32 @@ st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd waiting = &STp->wait; init_completion(waiting); - SRpnt->waiting = waiting; + SRpnt->sr_use_sg = STp->buffer->do_dio || (bytes > (STp->buffer)->frp[0].length); + if (SRpnt->sr_use_sg) { + if (!STp->buffer->do_dio) + buf_to_sg(STp->buffer, bytes); + SRpnt->sr_use_sg = (STp->buffer)->sg_segs; + bp = (char *) &((STp->buffer)->sg[0]); + } else + bp = (STp->buffer)->b_data; + SRpnt->sr_data_direction = direction; + SRpnt->sr_cmd_len = 0; + SRpnt->sr_request->waiting = waiting; + SRpnt->sr_request->rq_status = RQ_SCSI_BUSY; + SRpnt->sr_request->rq_disk = STp->disk; + SRpnt->sr_request->end_io = blk_end_sync_rq; + STp->buffer->cmdstat.have_sense = 0; - if (!STp->buffer->do_dio) - buf_to_sg(STp->buffer, bytes); + scsi_do_req(SRpnt, (void *) cmd, bp, bytes, + st_sleep_done, timeout, retries); - memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd)); - STp->buffer->cmdstat.have_sense = 0; - STp->buffer->syscall_result = 0; - - if (scsi_execute_async(STp->device, cmd, direction, - &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs, - timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) { - /* could not allocate the buffer or request was too large */ - (STp->buffer)->syscall_result = (-EBUSY); - (STp->buffer)->last_SRpnt = NULL; - } - else if (do_wait) { + if (do_wait) { wait_for_completion(waiting); - SRpnt->waiting = NULL; + SRpnt->sr_request->waiting = NULL; + if (SRpnt->sr_request->rq_status != RQ_SCSI_DONE) + SRpnt->sr_result |= (DRIVER_ERROR << 24); (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); } - return SRpnt; } @@ -536,7 +532,7 @@ static int write_behind_check(struct scsi_tape * STp) struct st_buffer *STbuffer; struct st_partstat *STps; struct st_cmdstatus *cmdstatp; - struct st_request *SRpnt; + struct scsi_request *SRpnt; STbuffer = STp->buffer; if (!STbuffer->writing) @@ -552,10 +548,12 @@ static int write_behind_check(struct scsi_tape * STp) wait_for_completion(&(STp->wait)); SRpnt = STbuffer->last_SRpnt; STbuffer->last_SRpnt = NULL; - SRpnt->waiting = NULL; + SRpnt->sr_request->waiting = NULL; + if (SRpnt->sr_request->rq_status != RQ_SCSI_DONE) + SRpnt->sr_result |= (DRIVER_ERROR << 24); (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt); - st_release_request(SRpnt); + scsi_release_request(SRpnt); STbuffer->buffer_bytes -= STbuffer->writing; STps = &(STp->ps[STp->partition]); @@ -595,7 +593,7 @@ static int write_behind_check(struct scsi_tape * STp) it messes up the block number). */ static int cross_eof(struct scsi_tape * STp, int forward) { - struct st_request *SRpnt; + struct scsi_request *SRpnt; unsigned char cmd[MAX_COMMAND_SIZE]; cmd[0] = SPACE; @@ -615,7 +613,7 @@ static int cross_eof(struct scsi_tape * STp, int forward) if (!SRpnt) return (STp->buffer)->syscall_result; - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; if ((STp->buffer)->cmdstat.midlevel_result != 0) @@ -632,7 +630,7 @@ static int flush_write_buffer(struct scsi_tape * STp) int offset, transfer, blks; int result; unsigned char cmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt; + struct scsi_request *SRpnt; struct st_partstat *STps; result = write_behind_check(STp); @@ -690,7 +688,7 @@ static int flush_write_buffer(struct scsi_tape * STp) STp->dirty = 0; (STp->buffer)->buffer_bytes = 0; } - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; } return result; @@ -787,7 +785,7 @@ static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm) } -/* Lock or unlock the drive door. Don't use when st_request allocated. */ +/* Lock or unlock the drive door. Don't use when scsi_request allocated. */ static int do_door_lock(struct scsi_tape * STp, int do_lock) { int retval, cmd; @@ -846,7 +844,7 @@ static int test_ready(struct scsi_tape *STp, int do_wait) int attentions, waits, max_wait, scode; int retval = CHKRES_READY, new_session = 0; unsigned char cmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt = NULL; + struct scsi_request *SRpnt = NULL; struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat; max_wait = do_wait ? ST_BLOCK_SECONDS : 0; @@ -905,7 +903,7 @@ static int test_ready(struct scsi_tape *STp, int do_wait) } if (SRpnt != NULL) - st_release_request(SRpnt); + scsi_release_request(SRpnt); return retval; } @@ -920,7 +918,7 @@ static int check_tape(struct scsi_tape *STp, struct file *filp) int i, retval, new_session = 0, do_wait; unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning; unsigned short st_flags = filp->f_flags; - struct st_request *SRpnt = NULL; + struct scsi_request *SRpnt = NULL; struct st_modedef *STm; struct st_partstat *STps; char *name = tape_name(STp); @@ -995,7 +993,7 @@ static int check_tape(struct scsi_tape *STp, struct file *filp) goto err_out; } - if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) { + if (!SRpnt->sr_result && !STp->buffer->cmdstat.have_sense) { STp->max_block = ((STp->buffer)->b_data[1] << 16) | ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3]; STp->min_block = ((STp->buffer)->b_data[4] << 8) | @@ -1047,7 +1045,7 @@ static int check_tape(struct scsi_tape *STp, struct file *filp) } STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0; } - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; STp->inited = 1; @@ -1198,7 +1196,7 @@ static int st_flush(struct file *filp) { int result = 0, result2; unsigned char cmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt; + struct scsi_request *SRpnt; struct scsi_tape *STp = filp->private_data; struct st_modedef *STm = &(STp->modes[STp->current_mode]); struct st_partstat *STps = &(STp->ps[STp->partition]); @@ -1251,7 +1249,7 @@ static int st_flush(struct file *filp) cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) && (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) { /* Write successful at EOM */ - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; if (STps->drv_file >= 0) STps->drv_file++; @@ -1261,7 +1259,7 @@ static int st_flush(struct file *filp) STps->eof = ST_FM; } else { /* Write error */ - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; printk(KERN_ERR "%s: Error on write filemark.\n", name); if (result == 0) @@ -1402,11 +1400,11 @@ static int setup_buffering(struct scsi_tape *STp, const char __user *buf, i = STp->try_dio && try_rdio; else i = STp->try_dio && try_wdio; - if (i && ((unsigned long)buf & queue_dma_alignment( STp->device->request_queue)) == 0) { - i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg, - (unsigned long)buf, count, (is_read ? READ : WRITE)); + i = st_map_user_pages(&(STbp->sg[0]), STbp->use_sg, + (unsigned long)buf, count, (is_read ? READ : WRITE), + STp->max_pfn); if (i > 0) { STbp->do_dio = i; STbp->buffer_bytes = 0; /* can be used as transfer counter */ @@ -1451,15 +1449,14 @@ static int setup_buffering(struct scsi_tape *STp, const char __user *buf, /* Can be called more than once after each setup_buffer() */ -static void release_buffering(struct scsi_tape *STp, int is_read) +static void release_buffering(struct scsi_tape *STp) { struct st_buffer *STbp; STbp = STp->buffer; if (STbp->do_dio) { - sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read); + sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, 0); STbp->do_dio = 0; - STbp->sg_segs = 0; } } @@ -1475,7 +1472,7 @@ st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) int async_write; unsigned char cmd[MAX_COMMAND_SIZE]; const char __user *b_point; - struct st_request *SRpnt = NULL; + struct scsi_request *SRpnt = NULL; struct scsi_tape *STp = filp->private_data; struct st_modedef *STm; struct st_partstat *STps; @@ -1627,7 +1624,7 @@ st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) retval = STbp->syscall_result; goto out; } - if (async_write && !STbp->syscall_result) { + if (async_write) { STbp->writing = transfer; STp->dirty = !(STbp->writing == STbp->buffer_bytes); @@ -1701,7 +1698,7 @@ st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) } else { count += do_count; STps->drv_block = (-1); /* Too cautious? */ - retval = STbp->syscall_result; + retval = (-EIO); } } @@ -1731,8 +1728,8 @@ st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) out: if (SRpnt != NULL) - st_release_request(SRpnt); - release_buffering(STp, 0); + scsi_release_request(SRpnt); + release_buffering(STp); up(&STp->lock); return retval; @@ -1745,11 +1742,11 @@ st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos) Does release user buffer mapping if it is set. */ static long read_tape(struct scsi_tape *STp, long count, - struct st_request ** aSRpnt) + struct scsi_request ** aSRpnt) { int transfer, blks, bytes; unsigned char cmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt; + struct scsi_request *SRpnt; struct st_modedef *STm; struct st_partstat *STps; struct st_buffer *STbp; @@ -1790,7 +1787,7 @@ static long read_tape(struct scsi_tape *STp, long count, SRpnt = *aSRpnt; SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE, STp->device->timeout, MAX_RETRIES, 1); - release_buffering(STp, 1); + release_buffering(STp); *aSRpnt = SRpnt; if (!SRpnt) return STbp->syscall_result; @@ -1805,10 +1802,10 @@ static long read_tape(struct scsi_tape *STp, long count, retval = 1; DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", name, - SRpnt->sense[0], SRpnt->sense[1], - SRpnt->sense[2], SRpnt->sense[3], - SRpnt->sense[4], SRpnt->sense[5], - SRpnt->sense[6], SRpnt->sense[7])); + SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[1], + SRpnt->sr_sense_buffer[2], SRpnt->sr_sense_buffer[3], + SRpnt->sr_sense_buffer[4], SRpnt->sr_sense_buffer[5], + SRpnt->sr_sense_buffer[6], SRpnt->sr_sense_buffer[7])); if (cmdstatp->have_sense) { if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) @@ -1838,7 +1835,7 @@ static long read_tape(struct scsi_tape *STp, long count, } STbp->buffer_bytes = bytes - transfer; } else { - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = *aSRpnt = NULL; if (transfer == blks) { /* We did not get anything, error */ printk(KERN_NOTICE "%s: Incorrect block size.\n", name); @@ -1932,7 +1929,7 @@ st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) ssize_t retval = 0; ssize_t i, transfer; int special, do_dio = 0; - struct st_request *SRpnt = NULL; + struct scsi_request *SRpnt = NULL; struct scsi_tape *STp = filp->private_data; struct st_modedef *STm; struct st_partstat *STps; @@ -2057,11 +2054,11 @@ st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos) out: if (SRpnt != NULL) { - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; } if (do_dio) { - release_buffering(STp, 1); + release_buffering(STp); STbp->buffer_bytes = 0; } up(&STp->lock); @@ -2287,7 +2284,7 @@ static int st_set_options(struct scsi_tape *STp, long options) static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs) { unsigned char cmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt = NULL; + struct scsi_request *SRpnt = NULL; memset(cmd, 0, MAX_COMMAND_SIZE); cmd[0] = MODE_SENSE; @@ -2301,7 +2298,7 @@ static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs) if (SRpnt == NULL) return (STp->buffer)->syscall_result; - st_release_request(SRpnt); + scsi_release_request(SRpnt); return (STp->buffer)->syscall_result; } @@ -2313,7 +2310,7 @@ static int write_mode_page(struct scsi_tape *STp, int page, int slow) { int pgo; unsigned char cmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt = NULL; + struct scsi_request *SRpnt = NULL; memset(cmd, 0, MAX_COMMAND_SIZE); cmd[0] = MODE_SELECT; @@ -2332,7 +2329,7 @@ static int write_mode_page(struct scsi_tape *STp, int page, int slow) if (SRpnt == NULL) return (STp->buffer)->syscall_result; - st_release_request(SRpnt); + scsi_release_request(SRpnt); return (STp->buffer)->syscall_result; } @@ -2415,7 +2412,7 @@ static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_cod DEB( char *name = tape_name(STp); ) unsigned char cmd[MAX_COMMAND_SIZE]; struct st_partstat *STps; - struct st_request *SRpnt; + struct scsi_request *SRpnt; if (STp->ready != ST_READY && !load_code) { if (STp->ready == ST_NO_TAPE) @@ -2458,7 +2455,7 @@ static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_cod return (STp->buffer)->syscall_result; retval = (STp->buffer)->syscall_result; - st_release_request(SRpnt); + scsi_release_request(SRpnt); if (!retval) { /* SCSI command successful */ @@ -2506,7 +2503,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon int ioctl_result; int chg_eof = 1; unsigned char cmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt; + struct scsi_request *SRpnt; struct st_partstat *STps; int fileno, blkno, at_sm, undone; int datalen = 0, direction = DMA_NONE; @@ -2760,7 +2757,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon ioctl_result = (STp->buffer)->syscall_result; if (!ioctl_result) { /* SCSI command successful */ - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; STps->drv_block = blkno; STps->drv_file = fileno; @@ -2875,7 +2872,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon /* Try the other possible state of Page Format if not already tried */ STp->use_pf = !STp->use_pf | PF_TESTED; - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; return st_int_ioctl(STp, cmd_in, arg); } @@ -2885,7 +2882,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK) STps->eof = ST_EOD; - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; } @@ -2901,7 +2898,7 @@ static int get_location(struct scsi_tape *STp, unsigned int *block, int *partiti { int result; unsigned char scmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt; + struct scsi_request *SRpnt; DEB( char *name = tape_name(STp); ) if (STp->ready != ST_READY) @@ -2947,7 +2944,7 @@ static int get_location(struct scsi_tape *STp, unsigned int *block, int *partiti DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name, *block, *partition)); } - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; return result; @@ -2964,7 +2961,7 @@ static int set_location(struct scsi_tape *STp, unsigned int block, int partition unsigned int blk; int timeout; unsigned char scmd[MAX_COMMAND_SIZE]; - struct st_request *SRpnt; + struct scsi_request *SRpnt; DEB( char *name = tape_name(STp); ) if (STp->ready != ST_READY) @@ -3050,7 +3047,7 @@ static int set_location(struct scsi_tape *STp, unsigned int block, int partition result = 0; } - st_release_request(SRpnt); + scsi_release_request(SRpnt); SRpnt = NULL; return result; @@ -3580,7 +3577,7 @@ static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long a static struct st_buffer * new_tape_buffer(int from_initialization, int need_dma, int max_sg) { - int i, got = 0; + int i, got = 0, segs = 0; gfp_t priority; struct st_buffer *tb; @@ -3597,8 +3594,10 @@ static struct st_buffer * return NULL; } memset(tb, 0, i); - tb->frp_segs = tb->orig_frp_segs = 0; + tb->frp_segs = tb->orig_frp_segs = segs; tb->use_sg = max_sg; + if (segs > 0) + tb->b_data = page_address(tb->sg[0].page); tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg); tb->in_use = 1; @@ -3629,7 +3628,7 @@ static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dm priority = GFP_KERNEL | __GFP_NOWARN; if (need_dma) priority |= GFP_DMA; - for (b_size = PAGE_SIZE, order=0; order <= 6 && + for (b_size = PAGE_SIZE, order=0; b_size < new_size - STbuffer->buffer_size; order++, b_size *= 2) ; /* empty */ @@ -3671,7 +3670,6 @@ static void normalize_buffer(struct st_buffer * STbuffer) } STbuffer->frp_segs = STbuffer->orig_frp_segs; STbuffer->frp_sg_current = 0; - STbuffer->sg_segs = 0; } @@ -3884,6 +3882,7 @@ static int st_probe(struct device *dev) struct st_buffer *buffer; int i, j, mode, dev_num, error; char *stp; + u64 bounce_limit; if (SDp->type != TYPE_TAPE) return -ENODEV; @@ -3893,8 +3892,7 @@ static int st_probe(struct device *dev) return -ENODEV; } - i = min(SDp->request_queue->max_hw_segments, - SDp->request_queue->max_phys_segments); + i = SDp->host->sg_tablesize; if (st_max_sg_segs < i) i = st_max_sg_segs; buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i); @@ -3996,6 +3994,11 @@ static int st_probe(struct device *dev) tpnt->long_timeout = ST_LONG_TIMEOUT; tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma; + bounce_limit = scsi_calculate_bounce_limit(SDp->host) >> PAGE_SHIFT; + if (bounce_limit > ULONG_MAX) + bounce_limit = ULONG_MAX; + tpnt->max_pfn = bounce_limit; + for (i = 0; i < ST_NBR_MODES; i++) { STm = &(tpnt->modes[i]); STm->defined = 0; @@ -4074,9 +4077,9 @@ static int st_probe(struct device *dev) sdev_printk(KERN_WARNING, SDp, "Attached scsi tape %s", tape_name(tpnt)); - printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B)\n", + printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B), max page reachable by HBA %lu\n", tape_name(tpnt), tpnt->try_dio ? "yes" : "no", - queue_dma_alignment(SDp->request_queue) + 1); + queue_dma_alignment(SDp->request_queue) + 1, tpnt->max_pfn); return 0; @@ -4182,11 +4185,7 @@ static void scsi_tape_release(struct kref *kref) static void st_intr(struct scsi_cmnd *SCpnt) { - /* - * The caller should be checking the request's errors - * value. - */ - scsi_io_completion(SCpnt, SCpnt->bufflen, 0); + scsi_io_completion(SCpnt, (SCpnt->result ? 0: SCpnt->bufflen), 1); } /* @@ -4198,7 +4197,7 @@ static int st_init_command(struct scsi_cmnd *SCpnt) if (!(SCpnt->request->flags & REQ_BLOCK_PC)) return 0; - scsi_setup_blk_pc_cmnd(SCpnt); + scsi_setup_blk_pc_cmnd(SCpnt, 0); SCpnt->done = st_intr; return 1; } @@ -4391,6 +4390,34 @@ static void do_create_class_files(struct scsi_tape *STp, int dev_num, int mode) return; } + +/* Pin down user pages and put them into a scatter gather list. Returns <= 0 if + - mapping of all pages not successful + - any page is above max_pfn + (i.e., either completely successful or fails) +*/ +static int st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, + unsigned long uaddr, size_t count, int rw, + unsigned long max_pfn) +{ + int i, nr_pages; + + nr_pages = sgl_map_user_pages(sgl, max_pages, uaddr, count, rw); + if (nr_pages <= 0) + return nr_pages; + + for (i=0; i < nr_pages; i++) { + if (page_to_pfn(sgl[i].page) > max_pfn) + goto out_unmap; + } + return nr_pages; + + out_unmap: + sgl_unmap_user_pages(sgl, nr_pages, 0); + return 0; +} + + /* The following functions may be useful for a larger audience. */ static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages, unsigned long uaddr, size_t count, int rw) diff --git a/trunk/drivers/scsi/st.h b/trunk/drivers/scsi/st.h index 411209048d74..790acac160bc 100644 --- a/trunk/drivers/scsi/st.h +++ b/trunk/drivers/scsi/st.h @@ -4,7 +4,6 @@ #include #include -#include /* Descriptor for analyzed sense data */ struct st_cmdstatus { @@ -18,17 +17,6 @@ struct st_cmdstatus { u8 deferred; }; -struct scsi_tape; - -/* scsi tape command */ -struct st_request { - unsigned char cmd[MAX_COMMAND_SIZE]; - unsigned char sense[SCSI_SENSE_BUFFERSIZE]; - int result; - struct scsi_tape *stp; - struct completion *waiting; -}; - /* The tape buffer descriptor. */ struct st_buffer { unsigned char in_use; @@ -40,7 +28,7 @@ struct st_buffer { int read_pointer; int writing; int syscall_result; - struct st_request *last_SRpnt; + struct scsi_request *last_SRpnt; struct st_cmdstatus cmdstat; unsigned char *b_data; unsigned short use_sg; /* zero or max number of s/g segments for this adapter */ diff --git a/trunk/drivers/scsi/sun3_NCR5380.c b/trunk/drivers/scsi/sun3_NCR5380.c index 25cced91c8a6..c041bfd56e12 100644 --- a/trunk/drivers/scsi/sun3_NCR5380.c +++ b/trunk/drivers/scsi/sun3_NCR5380.c @@ -70,7 +70,6 @@ * */ #include -#include /* * Further development / testing that should be done : @@ -2379,7 +2378,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance) * 3..length+1 arguments * * Start the extended message buffer with the EXTENDED_MESSAGE - * byte, since spi_print_msg() wants the whole thing. + * byte, since scsi_print_msg() wants the whole thing. */ extended_msg[0] = EXTENDED_MESSAGE; /* Accept first byte by clearing ACK */ @@ -2432,7 +2431,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance) default: if (!tmp) { printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO); - spi_print_msg(extended_msg); + scsi_print_msg (extended_msg); printk("\n"); } else if (tmp != EXTENDED_MESSAGE) printk(KERN_DEBUG "scsi%d: rejecting unknown " @@ -2567,7 +2566,7 @@ static void NCR5380_reselect (struct Scsi_Host *instance) if (!(msg[0] & 0x80)) { printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO); - spi_print_msg(msg); + scsi_print_msg(msg); do_abort(instance); return; } diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_defs.h b/trunk/drivers/scsi/sym53c8xx_2/sym_defs.h index 3659dd7b9d76..2d9437d7242b 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_defs.h +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_defs.h @@ -40,7 +40,7 @@ #ifndef SYM_DEFS_H #define SYM_DEFS_H -#define SYM_VERSION "2.2.2" +#define SYM_VERSION "2.2.1" #define SYM_DRIVER_NAME "sym-" SYM_VERSION /* diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_fw.c b/trunk/drivers/scsi/sym53c8xx_2/sym_fw.c index 9916a2a22558..fd36cf9858cb 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_fw.c +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_fw.c @@ -37,7 +37,11 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#ifdef __FreeBSD__ +#include +#else #include "sym_glue.h" +#endif /* * Macros used for all firmwares. @@ -56,12 +60,19 @@ #define SYM_FWA_SCR sym_fw1a_scr #define SYM_FWB_SCR sym_fw1b_scr #define SYM_FWZ_SCR sym_fw1z_scr +#ifdef __FreeBSD__ +#include +#else #include "sym_fw1.h" +#endif static struct sym_fwa_ofs sym_fw1a_ofs = { SYM_GEN_FW_A(struct SYM_FWA_SCR) }; static struct sym_fwb_ofs sym_fw1b_ofs = { SYM_GEN_FW_B(struct SYM_FWB_SCR) +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + SYM_GEN_B(struct SYM_FWB_SCR, data_io) +#endif }; static struct sym_fwz_ofs sym_fw1z_ofs = { SYM_GEN_FW_Z(struct SYM_FWZ_SCR) @@ -77,12 +88,19 @@ static struct sym_fwz_ofs sym_fw1z_ofs = { #define SYM_FWA_SCR sym_fw2a_scr #define SYM_FWB_SCR sym_fw2b_scr #define SYM_FWZ_SCR sym_fw2z_scr +#ifdef __FreeBSD__ +#include +#else #include "sym_fw2.h" +#endif static struct sym_fwa_ofs sym_fw2a_ofs = { SYM_GEN_FW_A(struct SYM_FWA_SCR) }; static struct sym_fwb_ofs sym_fw2b_ofs = { SYM_GEN_FW_B(struct SYM_FWB_SCR) +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + SYM_GEN_B(struct SYM_FWB_SCR, data_io) +#endif SYM_GEN_B(struct SYM_FWB_SCR, start64) SYM_GEN_B(struct SYM_FWB_SCR, pm_handle) }; diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_fw.h b/trunk/drivers/scsi/sym53c8xx_2/sym_fw.h index 66ec35beab5b..43f6810a4045 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_fw.h +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_fw.h @@ -92,6 +92,9 @@ struct sym_fwa_ofs { }; struct sym_fwb_ofs { SYM_GEN_FW_B(u_short) +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + SYM_GEN_B(u_short, data_io) +#endif SYM_GEN_B(u_short, start64) SYM_GEN_B(u_short, pm_handle) }; @@ -108,6 +111,9 @@ struct sym_fwa_ba { }; struct sym_fwb_ba { SYM_GEN_FW_B(u32) +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + SYM_GEN_B(u32, data_io) +#endif SYM_GEN_B(u32, start64); SYM_GEN_B(u32, pm_handle); }; diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_fw1.h b/trunk/drivers/scsi/sym53c8xx_2/sym_fw1.h index 7b39f4a35e98..cdd92d82f4b2 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_fw1.h +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_fw1.h @@ -197,6 +197,12 @@ struct SYM_FWB_SCR { u32 bad_status [ 7]; u32 wsr_ma_helper [ 4]; +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + /* Unknown direction handling */ + u32 data_io [ 2]; + u32 data_io_com [ 8]; + u32 data_io_out [ 7]; +#endif /* Data area */ u32 zero [ 1]; u32 scratch [ 1]; @@ -1741,6 +1747,48 @@ static struct SYM_FWB_SCR SYM_FWB_SCR = { SCR_JUMP, PADDR_A (dispatch), +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN +}/*-------------------------< DATA_IO >--------------------------*/,{ + /* + * We jump here if the data direction was unknown at the + * time we had to queue the command to the scripts processor. + * Pointers had been set as follow in this situation: + * savep --> DATA_IO + * lastp --> start pointer when DATA_IN + * wlastp --> start pointer when DATA_OUT + * This script sets savep and lastp according to the + * direction chosen by the target. + */ + SCR_JUMP ^ IFTRUE (WHEN (SCR_DATA_OUT)), + PADDR_B (data_io_out), +}/*-------------------------< DATA_IO_COM >----------------------*/,{ + /* + * Direction is DATA IN. + */ + SCR_COPY (4), + HADDR_1 (ccb_head.lastp), + HADDR_1 (ccb_head.savep), + /* + * Jump to the SCRIPTS according to actual direction. + */ + SCR_COPY (4), + HADDR_1 (ccb_head.savep), + RADDR_1 (temp), + SCR_RETURN, + 0, +}/*-------------------------< DATA_IO_OUT >----------------------*/,{ + /* + * Direction is DATA OUT. + */ + SCR_REG_REG (HF_REG, SCR_AND, (~HF_DATA_IN)), + 0, + SCR_COPY (4), + HADDR_1 (ccb_head.wlastp), + HADDR_1 (ccb_head.lastp), + SCR_JUMP, + PADDR_B(data_io_com), +#endif /* SYM_OPT_HANDLE_DIR_UNKNOWN */ + }/*-------------------------< ZERO >-----------------------------*/,{ SCR_DATA_ZERO, }/*-------------------------< SCRATCH >--------------------------*/,{ diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_fw2.h b/trunk/drivers/scsi/sym53c8xx_2/sym_fw2.h index 851f2706f220..7ea7151f5d1d 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_fw2.h +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_fw2.h @@ -191,6 +191,13 @@ struct SYM_FWB_SCR { u32 pm_wsr_handle [ 38]; u32 wsr_ma_helper [ 4]; +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + /* Unknown direction handling */ + u32 data_io [ 2]; + u32 data_io_in [ 2]; + u32 data_io_com [ 6]; + u32 data_io_out [ 8]; +#endif /* Data area */ u32 zero [ 1]; u32 scratch [ 1]; @@ -1831,6 +1838,51 @@ static struct SYM_FWB_SCR SYM_FWB_SCR = { SCR_JUMP, PADDR_A (dispatch), +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN +}/*-------------------------< DATA_IO >--------------------------*/,{ + /* + * We jump here if the data direction was unknown at the + * time we had to queue the command to the scripts processor. + * Pointers had been set as follow in this situation: + * savep --> DATA_IO + * lastp --> start pointer when DATA_IN + * wlastp --> start pointer when DATA_OUT + * This script sets savep and lastp according to the + * direction chosen by the target. + */ + SCR_JUMP ^ IFTRUE (WHEN (SCR_DATA_OUT)), + PADDR_B (data_io_out), +}/*-------------------------< DATA_IO_IN >-----------------------*/,{ + /* + * Direction is DATA IN. + */ + SCR_LOAD_REL (scratcha, 4), + offsetof (struct sym_ccb, phys.head.lastp), +}/*-------------------------< DATA_IO_COM >----------------------*/,{ + SCR_STORE_REL (scratcha, 4), + offsetof (struct sym_ccb, phys.head.savep), + + /* + * Jump to the SCRIPTS according to actual direction. + */ + SCR_LOAD_REL (temp, 4), + offsetof (struct sym_ccb, phys.head.savep), + SCR_RETURN, + 0, +}/*-------------------------< DATA_IO_OUT >----------------------*/,{ + /* + * Direction is DATA OUT. + */ + SCR_REG_REG (HF_REG, SCR_AND, (~HF_DATA_IN)), + 0, + SCR_LOAD_REL (scratcha, 4), + offsetof (struct sym_ccb, phys.head.wlastp), + SCR_STORE_REL (scratcha, 4), + offsetof (struct sym_ccb, phys.head.lastp), + SCR_JUMP, + PADDR_B(data_io_com), +#endif /* SYM_OPT_HANDLE_DIR_UNKNOWN */ + }/*-------------------------< ZERO >-----------------------------*/,{ SCR_DATA_ZERO, }/*-------------------------< SCRATCH >--------------------------*/,{ diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_glue.c b/trunk/drivers/scsi/sym53c8xx_2/sym_glue.c index 1fffd2b3c654..7fc0b97173e1 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_glue.c +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_glue.c @@ -514,10 +514,9 @@ static inline int sym_setup_cdb(struct sym_hcb *np, struct scsi_cmnd *cmd, struc */ int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct sym_ccb *cp) { + int dir; struct sym_tcb *tp = &np->target[cp->target]; struct sym_lcb *lp = sym_lp(tp, cp->lun); - u32 lastp, goalp; - int dir; /* * Build the CDB. @@ -535,47 +534,15 @@ int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct s sym_set_cam_status(cmd, DID_ERROR); goto out_abort; } - - /* - * No segments means no data. - */ - if (!cp->segments) - dir = DMA_NONE; } else { cp->data_len = 0; cp->segments = 0; } /* - * Set the data pointer. + * Set data pointers. */ - switch (dir) { - case DMA_BIDIRECTIONAL: - printk("%s: got DMA_BIDIRECTIONAL command", sym_name(np)); - sym_set_cam_status(cmd, DID_ERROR); - goto out_abort; - case DMA_TO_DEVICE: - goalp = SCRIPTA_BA(np, data_out2) + 8; - lastp = goalp - 8 - (cp->segments * (2*4)); - break; - case DMA_FROM_DEVICE: - cp->host_flags |= HF_DATA_IN; - goalp = SCRIPTA_BA(np, data_in2) + 8; - lastp = goalp - 8 - (cp->segments * (2*4)); - break; - case DMA_NONE: - default: - lastp = goalp = SCRIPTB_BA(np, no_data); - break; - } - - /* - * Set all pointers values needed by SCRIPTS. - */ - cp->phys.head.lastp = cpu_to_scr(lastp); - cp->phys.head.savep = cpu_to_scr(lastp); - cp->startp = cp->phys.head.savep; - cp->goalp = cpu_to_scr(goalp); + sym_setup_data_pointers(np, cp, dir); /* * When `#ifed 1', the code below makes the driver @@ -596,7 +563,10 @@ int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct s /* * activate this job. */ - sym_start_next_ccbs(np, lp, 2); + if (lp) + sym_start_next_ccbs(np, lp, 2); + else + sym_put_start_queue(np, cp); return 0; out_abort: @@ -1011,14 +981,15 @@ static int device_queue_depth(struct sym_hcb *np, int target, int lun) static int sym53c8xx_slave_alloc(struct scsi_device *sdev) { - struct sym_hcb *np = sym_get_hcb(sdev->host); - struct sym_tcb *tp = &np->target[sdev->id]; - struct sym_lcb *lp; + struct sym_hcb *np; + struct sym_tcb *tp; if (sdev->id >= SYM_CONF_MAX_TARGET || sdev->lun >= SYM_CONF_MAX_LUN) return -ENXIO; - tp->starget = sdev->sdev_target; + np = sym_get_hcb(sdev->host); + tp = &np->target[sdev->id]; + /* * Fail the device init if the device is flagged NOSCAN at BOOT in * the NVRAM. This may speed up boot and maintain coherency with @@ -1028,40 +999,34 @@ static int sym53c8xx_slave_alloc(struct scsi_device *sdev) * lun devices behave badly when asked for a non zero LUN. */ - if (tp->usrflags & SYM_SCAN_BOOT_DISABLED) { + if ((tp->usrflags & SYM_SCAN_BOOT_DISABLED) || + ((tp->usrflags & SYM_SCAN_LUNS_DISABLED) && sdev->lun != 0)) { tp->usrflags &= ~SYM_SCAN_BOOT_DISABLED; - starget_printk(KERN_INFO, tp->starget, - "Scan at boot disabled in NVRAM\n"); return -ENXIO; } - if (tp->usrflags & SYM_SCAN_LUNS_DISABLED) { - if (sdev->lun != 0) - return -ENXIO; - starget_printk(KERN_INFO, tp->starget, - "Multiple LUNs disabled in NVRAM\n"); - } - - lp = sym_alloc_lcb(np, sdev->id, sdev->lun); - if (!lp) - return -ENOMEM; - - spi_min_period(tp->starget) = tp->usr_period; - spi_max_width(tp->starget) = tp->usr_width; - + tp->starget = sdev->sdev_target; return 0; } /* * Linux entry point for device queue sizing. */ -static int sym53c8xx_slave_configure(struct scsi_device *sdev) +static int sym53c8xx_slave_configure(struct scsi_device *device) { - struct sym_hcb *np = sym_get_hcb(sdev->host); - struct sym_tcb *tp = &np->target[sdev->id]; - struct sym_lcb *lp = sym_lp(tp, sdev->lun); + struct sym_hcb *np = sym_get_hcb(device->host); + struct sym_tcb *tp = &np->target[device->id]; + struct sym_lcb *lp; int reqtags, depth_to_use; + /* + * Allocate the LCB if not yet. + * If it fail, we may well be in the sh*t. :) + */ + lp = sym_alloc_lcb(np, device->id, device->lun); + if (!lp) + return -ENOMEM; + /* * Get user flags. */ @@ -1073,10 +1038,10 @@ static int sym53c8xx_slave_configure(struct scsi_device *sdev) * Use at least 2. * Donnot use more than our maximum. */ - reqtags = device_queue_depth(np, sdev->id, sdev->lun); + reqtags = device_queue_depth(np, device->id, device->lun); if (reqtags > tp->usrtags) reqtags = tp->usrtags; - if (!sdev->tagged_supported) + if (!device->tagged_supported) reqtags = 0; #if 1 /* Avoid to locally queue commands for no good reasons */ if (reqtags > SYM_CONF_MAX_TAG) @@ -1085,30 +1050,19 @@ static int sym53c8xx_slave_configure(struct scsi_device *sdev) #else depth_to_use = (reqtags ? SYM_CONF_MAX_TAG : 2); #endif - scsi_adjust_queue_depth(sdev, - (sdev->tagged_supported ? + scsi_adjust_queue_depth(device, + (device->tagged_supported ? MSG_SIMPLE_TAG : 0), depth_to_use); lp->s.scdev_depth = depth_to_use; - sym_tune_dev_queuing(tp, sdev->lun, reqtags); + sym_tune_dev_queuing(tp, device->lun, reqtags); - if (!spi_initial_dv(sdev->sdev_target)) - spi_dv_device(sdev); + if (!spi_initial_dv(device->sdev_target)) + spi_dv_device(device); return 0; } -static void sym53c8xx_slave_destroy(struct scsi_device *sdev) -{ - struct sym_hcb *np = sym_get_hcb(sdev->host); - struct sym_lcb *lp = sym_lp(&np->target[sdev->id], sdev->lun); - - if (lp->itlq_tbl) - sym_mfree_dma(lp->itlq_tbl, SYM_CONF_MAX_TASK * 4, "ITLQ_TBL"); - kfree(lp->cb_tags); - sym_mfree_dma(lp, sizeof(*lp), "LCB"); -} - /* * Linux entry point for info() function */ @@ -1543,7 +1497,7 @@ static int sym_setup_bus_dma_mask(struct sym_hcb *np) { #if SYM_CONF_DMA_ADDRESSING_MODE > 0 #if SYM_CONF_DMA_ADDRESSING_MODE == 1 -#define DMA_DAC_MASK DMA_40BIT_MASK +#define DMA_DAC_MASK 0x000000ffffffffffULL /* 40-bit */ #elif SYM_CONF_DMA_ADDRESSING_MODE == 2 #define DMA_DAC_MASK DMA_64BIT_MASK #endif @@ -1972,7 +1926,6 @@ static struct scsi_host_template sym2_template = { .queuecommand = sym53c8xx_queue_command, .slave_alloc = sym53c8xx_slave_alloc, .slave_configure = sym53c8xx_slave_configure, - .slave_destroy = sym53c8xx_slave_destroy, .eh_abort_handler = sym53c8xx_eh_abort_handler, .eh_device_reset_handler = sym53c8xx_eh_device_reset_handler, .eh_bus_reset_handler = sym53c8xx_eh_bus_reset_handler, diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_glue.h b/trunk/drivers/scsi/sym53c8xx_2/sym_glue.h index cc92d0c70cd7..d3d52f14d7c0 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_glue.h +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_glue.h @@ -68,6 +68,7 @@ */ #define SYM_CONF_TIMER_INTERVAL ((HZ+1)/2) +#define SYM_OPT_HANDLE_DIR_UNKNOWN #define SYM_OPT_HANDLE_DEVICE_QUEUEING #define SYM_OPT_LIMIT_COMMAND_REORDERING @@ -267,5 +268,6 @@ void sym_xpt_async_bus_reset(struct sym_hcb *np); void sym_xpt_async_sent_bdr(struct sym_hcb *np, int target); int sym_setup_data_and_start (struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp); void sym_log_bus_error(struct sym_hcb *np); +void sym_sniff_inquiry(struct sym_hcb *np, struct scsi_cmnd *cmd, int resid); #endif /* SYM_GLUE_H */ diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.c b/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.c index 8260f040d39c..1564ca203a3e 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.c +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.c @@ -40,7 +40,6 @@ #include #include /* for timeouts in units of HZ */ -#include #include "sym_glue.h" #include "sym_nvram.h" @@ -71,12 +70,32 @@ static void sym_printl_hex(u_char *p, int n) printf (".\n"); } +/* + * Print out the content of a SCSI message. + */ +static int sym_show_msg (u_char * msg) +{ + u_char i; + printf ("%x",*msg); + if (*msg==M_EXTENDED) { + for (i=1;i<8;i++) { + if (i-1>msg[1]) break; + printf ("-%x",msg[i]); + } + return (i+1); + } else if ((*msg & 0xf0) == 0x20) { + printf ("-%x",msg[1]); + return (2); + } + return (1); +} + static void sym_print_msg(struct sym_ccb *cp, char *label, u_char *msg) { sym_print_addr(cp->cmd, "%s: ", label); - spi_print_msg(msg); - printf("\n"); + sym_show_msg(msg); + printf(".\n"); } static void sym_print_nego_msg(struct sym_hcb *np, int target, char *label, u_char *msg) @@ -84,8 +103,8 @@ static void sym_print_nego_msg(struct sym_hcb *np, int target, char *label, u_ch struct sym_tcb *tp = &np->target[target]; dev_info(&tp->starget->dev, "%s: ", label); - spi_print_msg(msg); - printf("\n"); + sym_show_msg(msg); + printf(".\n"); } /* @@ -616,6 +635,29 @@ static __inline void sym_init_burst(struct sym_hcb *np, u_char bc) } } + +/* + * Print out the list of targets that have some flag disabled by user. + */ +static void sym_print_targets_flag(struct sym_hcb *np, int mask, char *msg) +{ + int cnt; + int i; + + for (cnt = 0, i = 0 ; i < SYM_CONF_MAX_TARGET ; i++) { + if (i == np->myaddr) + continue; + if (np->target[i].usrflags & mask) { + if (!cnt++) + printf("%s: %s disabled for targets", + sym_name(np), msg); + printf(" %d", i); + } + } + if (cnt) + printf(".\n"); +} + /* * Save initial settings of some IO registers. * Assumed to have been set by BIOS. @@ -920,7 +962,7 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru tp->usrflags |= (SYM_DISC_ENABLED | SYM_TAGS_ENABLED); tp->usrtags = SYM_SETUP_MAX_TAG; - sym_nvram_setup_target(tp, i, nvram); + sym_nvram_setup_target(np, i, nvram); if (!tp->usrtags) tp->usrflags &= ~SYM_TAGS_ENABLED; @@ -963,6 +1005,13 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru sym_name(np), np->rv_scntl3, np->rv_dmode, np->rv_dcntl, np->rv_ctest3, np->rv_ctest4, np->rv_ctest5); } + /* + * Let user be aware of targets that have some disable flags set. + */ + sym_print_targets_flag(np, SYM_SCAN_BOOT_DISABLED, "SCAN AT BOOT"); + if (sym_verbose) + sym_print_targets_flag(np, SYM_SCAN_LUNS_DISABLED, + "SCAN FOR LUNS"); return 0; } @@ -1474,7 +1523,7 @@ static int sym_prepare_nego(struct sym_hcb *np, struct sym_ccb *cp, u_char *msgp /* * Insert a job into the start queue. */ -static void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp) +void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp) { u_short qidx; @@ -3605,7 +3654,7 @@ static int sym_evaluate_dp(struct sym_hcb *np, struct sym_ccb *cp, u32 scr, int * If result is dp_sg = SYM_CONF_MAX_SG, then we are at the * end of the data. */ - tmp = scr_to_cpu(cp->goalp); + tmp = scr_to_cpu(sym_goalp(cp)); dp_sg = SYM_CONF_MAX_SG; if (dp_scr != tmp) dp_sg -= (tmp - 8 - (int)dp_scr) / (2*4); @@ -3712,7 +3761,7 @@ static void sym_modify_dp(struct sym_hcb *np, struct sym_tcb *tp, struct sym_ccb * And our alchemy:) allows to easily calculate the data * script address we want to return for the next data phase. */ - dp_ret = cpu_to_scr(cp->goalp); + dp_ret = cpu_to_scr(sym_goalp(cp)); dp_ret = dp_ret - 8 - (SYM_CONF_MAX_SG - dp_sg) * (2*4); /* @@ -3808,7 +3857,7 @@ int sym_compute_residual(struct sym_hcb *np, struct sym_ccb *cp) * If all data has been transferred, * there is no residual. */ - if (cp->phys.head.lastp == cp->goalp) + if (cp->phys.head.lastp == sym_goalp(cp)) return resid; /* @@ -4615,7 +4664,30 @@ struct sym_ccb *sym_get_ccb (struct sym_hcb *np, struct scsi_cmnd *cmd, u_char t goto out; cp = sym_que_entry(qp, struct sym_ccb, link_ccbq); - { +#ifndef SYM_OPT_HANDLE_DEVICE_QUEUEING + /* + * If the LCB is not yet available and the LUN + * has been probed ok, try to allocate the LCB. + */ + if (!lp && sym_is_bit(tp->lun_map, ln)) { + lp = sym_alloc_lcb(np, tn, ln); + if (!lp) + goto out_free; + } +#endif + + /* + * If the LCB is not available here, then the + * logical unit is not yet discovered. For those + * ones only accept 1 SCSI IO per logical unit, + * since we cannot allow disconnections. + */ + if (!lp) { + if (!sym_is_bit(tp->busy0_map, ln)) + sym_set_bit(tp->busy0_map, ln); + else + goto out_free; + } else { /* * If we have been asked for a tagged command. */ @@ -4768,6 +4840,12 @@ void sym_free_ccb (struct sym_hcb *np, struct sym_ccb *cp) lp->head.resel_sa = cpu_to_scr(SCRIPTB_BA(np, resel_bad_lun)); } + /* + * Otherwise, we only accept 1 IO per LUN. + * Clear the bit that keeps track of this IO. + */ + else + sym_clr_bit(tp->busy0_map, cp->lun); /* * We donnot queue more than 1 ccb per target @@ -4919,7 +4997,20 @@ static void sym_init_tcb (struct sym_hcb *np, u_char tn) struct sym_lcb *sym_alloc_lcb (struct sym_hcb *np, u_char tn, u_char ln) { struct sym_tcb *tp = &np->target[tn]; - struct sym_lcb *lp = NULL; + struct sym_lcb *lp = sym_lp(tp, ln); + + /* + * Already done, just return. + */ + if (lp) + return lp; + + /* + * Donnot allow LUN control block + * allocation for not probed LUNs. + */ + if (!sym_is_bit(tp->lun_map, ln)) + return NULL; /* * Initialize the target control block if not yet. @@ -4991,7 +5082,13 @@ struct sym_lcb *sym_alloc_lcb (struct sym_hcb *np, u_char tn, u_char ln) lp->started_max = SYM_CONF_MAX_TASK; lp->started_limit = SYM_CONF_MAX_TASK; #endif - + /* + * If we are busy, count the IO. + */ + if (sym_is_bit(tp->busy0_map, ln)) { + lp->busy_itl = 1; + sym_clr_bit(tp->busy0_map, ln); + } fail: return lp; } @@ -5005,6 +5102,12 @@ static void sym_alloc_lcb_tags (struct sym_hcb *np, u_char tn, u_char ln) struct sym_lcb *lp = sym_lp(tp, ln); int i; + /* + * If LCB not available, try to allocate it. + */ + if (!lp && !(lp = sym_alloc_lcb(np, tn, ln))) + goto fail; + /* * Allocate the task table and and the tag allocation * circular buffer. We want both or none. @@ -5378,7 +5481,8 @@ if (resid) /* * Donnot start more than 1 command after an error. */ - sym_start_next_ccbs(np, lp, 1); + if (lp) + sym_start_next_ccbs(np, lp, 1); #endif } @@ -5416,12 +5520,18 @@ void sym_complete_ok (struct sym_hcb *np, struct sym_ccb *cp) tp = &np->target[cp->target]; lp = sym_lp(tp, cp->lun); + /* + * Assume device discovered on first success. + */ + if (!lp) + sym_set_bit(tp->lun_map, cp->lun); + /* * If all data have been transferred, given than no * extended error did occur, there is no residual. */ resid = 0; - if (cp->phys.head.lastp != cp->goalp) + if (cp->phys.head.lastp != sym_goalp(cp)) resid = sym_compute_residual(np, cp); /* @@ -5441,6 +5551,15 @@ if (resid) */ sym_set_cam_result_ok(cp, cmd, resid); +#ifdef SYM_OPT_SNIFF_INQUIRY + /* + * On standard INQUIRY response (EVPD and CmDt + * not set), sniff out device capabilities. + */ + if (cp->cdb_buf[0] == INQUIRY && !(cp->cdb_buf[1] & 0x3)) + sym_sniff_inquiry(np, cmd, resid); +#endif + #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING /* * If max number of started ccbs had been reduced, @@ -5468,7 +5587,7 @@ if (resid) /* * Requeue a couple of awaiting scsi commands. */ - if (!sym_que_empty(&lp->waiting_ccbq)) + if (lp && !sym_que_empty(&lp->waiting_ccbq)) sym_start_next_ccbs(np, lp, 2); #endif /* @@ -5711,7 +5830,8 @@ void sym_hcb_free(struct sym_hcb *np) SYM_QUEHEAD *qp; struct sym_ccb *cp; struct sym_tcb *tp; - int target; + struct sym_lcb *lp; + int target, lun; if (np->scriptz0) sym_mfree_dma(np->scriptz0, np->scriptz_sz, "SCRIPTZ0"); @@ -5737,6 +5857,16 @@ void sym_hcb_free(struct sym_hcb *np) for (target = 0; target < SYM_CONF_MAX_TARGET ; target++) { tp = &np->target[target]; + for (lun = 0 ; lun < SYM_CONF_MAX_LUN ; lun++) { + lp = sym_lp(tp, lun); + if (!lp) + continue; + if (lp->itlq_tbl) + sym_mfree_dma(lp->itlq_tbl, SYM_CONF_MAX_TASK*4, + "ITLQ_TBL"); + kfree(lp->cb_tags); + sym_mfree_dma(lp, sizeof(*lp), "LCB"); + } #if SYM_CONF_MAX_LUN > 1 kfree(tp->lunmp); #endif diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.h b/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.h index 2456090bb241..3a264a408216 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.h +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_hipd.h @@ -48,6 +48,12 @@ * They may be defined in platform specific headers, if they * are useful. * + * SYM_OPT_HANDLE_DIR_UNKNOWN + * When this option is set, the SCRIPTS used by the driver + * are able to handle SCSI transfers with direction not + * supplied by user. + * (set for Linux-2.0.X) + * * SYM_OPT_HANDLE_DEVICE_QUEUEING * When this option is set, the driver will use a queue per * device and handle QUEUE FULL status requeuing internally. @@ -58,6 +64,7 @@ * (set for Linux) */ #if 0 +#define SYM_OPT_HANDLE_DIR_UNKNOWN #define SYM_OPT_HANDLE_DEVICE_QUEUEING #define SYM_OPT_LIMIT_COMMAND_REORDERING #endif @@ -409,6 +416,19 @@ struct sym_tcb { struct sym_lcb **lunmp; /* Other LCBs [1..MAX_LUN] */ #endif + /* + * Bitmap that tells about LUNs that succeeded at least + * 1 IO and therefore assumed to be a real device. + * Avoid useless allocation of the LCB structure. + */ + u32 lun_map[(SYM_CONF_MAX_LUN+31)/32]; + + /* + * Bitmap that tells about LUNs that haven't yet an LCB + * allocated (not discovered or LCB allocation failed). + */ + u32 busy0_map[(SYM_CONF_MAX_LUN+31)/32]; + #ifdef SYM_HAVE_STCB /* * O/S specific data structure. @@ -434,10 +454,8 @@ struct sym_tcb { * Other user settable limits and options. * These limits are read from the NVRAM if present. */ - unsigned char usrflags; - unsigned char usr_period; - unsigned char usr_width; - unsigned short usrtags; + u_char usrflags; + u_short usrtags; struct scsi_target *starget; }; @@ -654,6 +672,9 @@ struct sym_ccbh { */ u32 savep; /* Jump address to saved data pointer */ u32 lastp; /* SCRIPTS address at end of data */ +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + u32 wlastp; +#endif /* * Status fields. @@ -783,6 +804,9 @@ struct sym_ccb { SYM_QUEHEAD link_ccbq; /* Link to free/busy CCB queue */ u32 startp; /* Initial data pointer */ u32 goalp; /* Expected last data pointer */ +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + u32 wgoalp; +#endif int ext_sg; /* Extreme data pointer, used */ int ext_ofs; /* to calculate the residual. */ #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING @@ -797,6 +821,12 @@ struct sym_ccb { #define CCB_BA(cp,lbl) cpu_to_scr(cp->ccb_ba + offsetof(struct sym_ccb, lbl)) +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN +#define sym_goalp(cp) ((cp->host_flags & HF_DATA_IN) ? cp->goalp : cp->wgoalp) +#else +#define sym_goalp(cp) (cp->goalp) +#endif + typedef struct device *m_pool_ident_t; /* @@ -1047,6 +1077,7 @@ char *sym_driver_name(void); void sym_print_xerr(struct scsi_cmnd *cmd, int x_status); int sym_reset_scsi_bus(struct sym_hcb *np, int enab_int); struct sym_chip *sym_lookup_chip_table(u_short device_id, u_char revision); +void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp); #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn); #endif @@ -1104,6 +1135,71 @@ sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len) #error "Unsupported DMA addressing mode" #endif +/* + * Set up data pointers used by SCRIPTS. + * Called from O/S specific code. + */ +static inline void sym_setup_data_pointers(struct sym_hcb *np, + struct sym_ccb *cp, int dir) +{ + u32 lastp, goalp; + + /* + * No segments means no data. + */ + if (!cp->segments) + dir = DMA_NONE; + + /* + * Set the data pointer. + */ + switch(dir) { +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + case DMA_BIDIRECTIONAL: +#endif + case DMA_TO_DEVICE: + goalp = SCRIPTA_BA(np, data_out2) + 8; + lastp = goalp - 8 - (cp->segments * (2*4)); +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + cp->wgoalp = cpu_to_scr(goalp); + if (dir != DMA_BIDIRECTIONAL) + break; + cp->phys.head.wlastp = cpu_to_scr(lastp); + /* fall through */ +#else + break; +#endif + case DMA_FROM_DEVICE: + cp->host_flags |= HF_DATA_IN; + goalp = SCRIPTA_BA(np, data_in2) + 8; + lastp = goalp - 8 - (cp->segments * (2*4)); + break; + case DMA_NONE: + default: +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + cp->host_flags |= HF_DATA_IN; +#endif + lastp = goalp = SCRIPTB_BA(np, no_data); + break; + } + + /* + * Set all pointers values needed by SCRIPTS. + */ + cp->phys.head.lastp = cpu_to_scr(lastp); + cp->phys.head.savep = cpu_to_scr(lastp); + cp->startp = cp->phys.head.savep; + cp->goalp = cpu_to_scr(goalp); + +#ifdef SYM_OPT_HANDLE_DIR_UNKNOWN + /* + * If direction is unknown, start at data_io. + */ + if (dir == DMA_BIDIRECTIONAL) + cp->phys.head.savep = cpu_to_scr(SCRIPTB_BA(np, data_io)); +#endif +} + /* * MEMORY ALLOCATOR. */ diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_malloc.c b/trunk/drivers/scsi/sym53c8xx_2/sym_malloc.c index 92bf9b14a7a2..a34d403ccc6c 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_malloc.c +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_malloc.c @@ -37,7 +37,11 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#ifdef __FreeBSD__ +#include +#else #include "sym_glue.h" +#endif /* * Simple power of two buddy-like generic allocator. diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.c b/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.c index 15d69298ab6e..994b7566bcac 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.c +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.c @@ -92,32 +92,29 @@ void sym_nvram_setup_host(struct Scsi_Host *shost, struct sym_hcb *np, struct sy * Get target set-up from Symbios format NVRAM. */ static void -sym_Symbios_setup_target(struct sym_tcb *tp, int target, Symbios_nvram *nvram) +sym_Symbios_setup_target(struct sym_hcb *np, int target, Symbios_nvram *nvram) { + struct sym_tcb *tp = &np->target[target]; Symbios_target *tn = &nvram->target[target]; - if (!(tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)) - tp->usrtags = 0; + tp->usrtags = + (tn->flags & SYMBIOS_QUEUE_TAGS_ENABLED)? SYM_SETUP_MAX_TAG : 0; + if (!(tn->flags & SYMBIOS_DISCONNECT_ENABLE)) tp->usrflags &= ~SYM_DISC_ENABLED; if (!(tn->flags & SYMBIOS_SCAN_AT_BOOT_TIME)) tp->usrflags |= SYM_SCAN_BOOT_DISABLED; if (!(tn->flags & SYMBIOS_SCAN_LUNS)) tp->usrflags |= SYM_SCAN_LUNS_DISABLED; - tp->usr_period = (tn->sync_period + 3) / 4; - tp->usr_width = (tn->bus_width == 0x8) ? 0 : 1; } -static const unsigned char Tekram_sync[16] = { - 25, 31, 37, 43, 50, 62, 75, 125, 12, 15, 18, 21, 6, 7, 9, 10 -}; - /* * Get target set-up from Tekram format NVRAM. */ static void -sym_Tekram_setup_target(struct sym_tcb *tp, int target, Tekram_nvram *nvram) +sym_Tekram_setup_target(struct sym_hcb *np, int target, Tekram_nvram *nvram) { + struct sym_tcb *tp = &np->target[target]; struct Tekram_target *tn = &nvram->target[target]; if (tn->flags & TEKRAM_TAGGED_COMMANDS) { @@ -127,22 +124,22 @@ sym_Tekram_setup_target(struct sym_tcb *tp, int target, Tekram_nvram *nvram) if (tn->flags & TEKRAM_DISCONNECT_ENABLE) tp->usrflags |= SYM_DISC_ENABLED; - if (tn->flags & TEKRAM_SYNC_NEGO) - tp->usr_period = Tekram_sync[tn->sync_index & 0xf]; - tp->usr_width = (tn->flags & TEKRAM_WIDE_NEGO) ? 1 : 0; + /* If any device does not support parity, we will not use this option */ + if (!(tn->flags & TEKRAM_PARITY_CHECK)) + np->rv_scntl0 &= ~0x0a; /* SCSI parity checking disabled */ } /* * Get target setup from NVRAM. */ -void sym_nvram_setup_target(struct sym_tcb *tp, int target, struct sym_nvram *nvp) +void sym_nvram_setup_target(struct sym_hcb *np, int target, struct sym_nvram *nvp) { switch (nvp->type) { case SYM_SYMBIOS_NVRAM: - sym_Symbios_setup_target(tp, target, &nvp->data.Symbios); + sym_Symbios_setup_target(np, target, &nvp->data.Symbios); break; case SYM_TEKRAM_NVRAM: - sym_Tekram_setup_target(tp, target, &nvp->data.Tekram); + sym_Tekram_setup_target(np, target, &nvp->data.Tekram); break; default: break; diff --git a/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.h b/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.h index bdfbbb083b69..1538bede5277 100644 --- a/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.h +++ b/trunk/drivers/scsi/sym53c8xx_2/sym_nvram.h @@ -194,12 +194,12 @@ struct sym_nvram { #if SYM_CONF_NVRAM_SUPPORT void sym_nvram_setup_host(struct Scsi_Host *shost, struct sym_hcb *np, struct sym_nvram *nvram); -void sym_nvram_setup_target (struct sym_tcb *tp, int target, struct sym_nvram *nvp); +void sym_nvram_setup_target (struct sym_hcb *np, int target, struct sym_nvram *nvp); int sym_read_nvram (struct sym_device *np, struct sym_nvram *nvp); char *sym_nvram_type(struct sym_nvram *nvp); #else static inline void sym_nvram_setup_host(struct Scsi_Host *shost, struct sym_hcb *np, struct sym_nvram *nvram) { } -static inline void sym_nvram_setup_target(struct sym_tcb *tp, struct sym_nvram *nvram) { } +static inline void sym_nvram_setup_target(struct sym_hcb *np, struct sym_nvram *nvram) { } static inline int sym_read_nvram(struct sym_device *np, struct sym_nvram *nvp) { nvp->type = 0; diff --git a/trunk/drivers/scsi/sym53c8xx_comm.h b/trunk/drivers/scsi/sym53c8xx_comm.h new file mode 100644 index 000000000000..20ae2b17df58 --- /dev/null +++ b/trunk/drivers/scsi/sym53c8xx_comm.h @@ -0,0 +1,792 @@ +/****************************************************************************** +** High Performance device driver for the Symbios 53C896 controller. +** +** Copyright (C) 1998-2001 Gerard Roudier +** +** This driver also supports all the Symbios 53C8XX controller family, +** except 53C810 revisions < 16, 53C825 revisions < 16 and all +** revisions of 53C815 controllers. +** +** This driver is based on the Linux port of the FreeBSD ncr driver. +** +** Copyright (C) 1994 Wolfgang Stanglmeier +** +**----------------------------------------------------------------------------- +** +** This program is free software; you can redistribute it and/or modify +** it under the terms of the GNU General Public License as published by +** the Free Software Foundation; either version 2 of the License, or +** (at your option) any later version. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License +** along with this program; if not, write to the Free Software +** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +** +**----------------------------------------------------------------------------- +** +** The Linux port of the FreeBSD ncr driver has been achieved in +** november 1995 by: +** +** Gerard Roudier +** +** Being given that this driver originates from the FreeBSD version, and +** in order to keep synergy on both, any suggested enhancements and corrections +** received on Linux are automatically a potential candidate for the FreeBSD +** version. +** +** The original driver has been written for 386bsd and FreeBSD by +** Wolfgang Stanglmeier +** Stefan Esser +** +**----------------------------------------------------------------------------- +** +** Major contributions: +** -------------------- +** +** NVRAM detection and reading. +** Copyright (C) 1997 Richard Waltham +** +******************************************************************************* +*/ + +/*========================================================== +** +** Debugging tags +** +**========================================================== +*/ + +#define DEBUG_ALLOC (0x0001) +#define DEBUG_PHASE (0x0002) +#define DEBUG_QUEUE (0x0008) +#define DEBUG_RESULT (0x0010) +#define DEBUG_POINTER (0x0020) +#define DEBUG_SCRIPT (0x0040) +#define DEBUG_TINY (0x0080) +#define DEBUG_TIMING (0x0100) +#define DEBUG_NEGO (0x0200) +#define DEBUG_TAGS (0x0400) +#define DEBUG_SCATTER (0x0800) +#define DEBUG_IC (0x1000) + +/* +** Enable/Disable debug messages. +** Can be changed at runtime too. +*/ + +#ifdef SCSI_NCR_DEBUG_INFO_SUPPORT +static int ncr_debug = SCSI_NCR_DEBUG_FLAGS; + #define DEBUG_FLAGS ncr_debug +#else + #define DEBUG_FLAGS SCSI_NCR_DEBUG_FLAGS +#endif + +static inline struct list_head *ncr_list_pop(struct list_head *head) +{ + if (!list_empty(head)) { + struct list_head *elem = head->next; + + list_del(elem); + return elem; + } + + return NULL; +} + +#ifdef __sparc__ +#include +#endif + +/*========================================================== +** +** Simple power of two buddy-like allocator. +** +** This simple code is not intended to be fast, but to +** provide power of 2 aligned memory allocations. +** Since the SCRIPTS processor only supplies 8 bit +** arithmetic, this allocator allows simple and fast +** address calculations from the SCRIPTS code. +** In addition, cache line alignment is guaranteed for +** power of 2 cache line size. +** Enhanced in linux-2.3.44 to provide a memory pool +** per pcidev to support dynamic dma mapping. (I would +** have preferred a real bus astraction, btw). +** +**========================================================== +*/ + +#define MEMO_SHIFT 4 /* 16 bytes minimum memory chunk */ +#if PAGE_SIZE >= 8192 +#define MEMO_PAGE_ORDER 0 /* 1 PAGE maximum */ +#else +#define MEMO_PAGE_ORDER 1 /* 2 PAGES maximum */ +#endif +#define MEMO_FREE_UNUSED /* Free unused pages immediately */ +#define MEMO_WARN 1 +#define MEMO_GFP_FLAGS GFP_ATOMIC +#define MEMO_CLUSTER_SHIFT (PAGE_SHIFT+MEMO_PAGE_ORDER) +#define MEMO_CLUSTER_SIZE (1UL << MEMO_CLUSTER_SHIFT) +#define MEMO_CLUSTER_MASK (MEMO_CLUSTER_SIZE-1) + +typedef u_long m_addr_t; /* Enough bits to bit-hack addresses */ +typedef struct device *m_bush_t; /* Something that addresses DMAable */ + +typedef struct m_link { /* Link between free memory chunks */ + struct m_link *next; +} m_link_s; + +typedef struct m_vtob { /* Virtual to Bus address translation */ + struct m_vtob *next; + m_addr_t vaddr; + m_addr_t baddr; +} m_vtob_s; +#define VTOB_HASH_SHIFT 5 +#define VTOB_HASH_SIZE (1UL << VTOB_HASH_SHIFT) +#define VTOB_HASH_MASK (VTOB_HASH_SIZE-1) +#define VTOB_HASH_CODE(m) \ + ((((m_addr_t) (m)) >> MEMO_CLUSTER_SHIFT) & VTOB_HASH_MASK) + +typedef struct m_pool { /* Memory pool of a given kind */ + m_bush_t bush; + m_addr_t (*getp)(struct m_pool *); + void (*freep)(struct m_pool *, m_addr_t); + int nump; + m_vtob_s *(vtob[VTOB_HASH_SIZE]); + struct m_pool *next; + struct m_link h[PAGE_SHIFT-MEMO_SHIFT+MEMO_PAGE_ORDER+1]; +} m_pool_s; + +static void *___m_alloc(m_pool_s *mp, int size) +{ + int i = 0; + int s = (1 << MEMO_SHIFT); + int j; + m_addr_t a; + m_link_s *h = mp->h; + + if (size > (PAGE_SIZE << MEMO_PAGE_ORDER)) + return NULL; + + while (size > s) { + s <<= 1; + ++i; + } + + j = i; + while (!h[j].next) { + if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) { + h[j].next = (m_link_s *)mp->getp(mp); + if (h[j].next) + h[j].next->next = NULL; + break; + } + ++j; + s <<= 1; + } + a = (m_addr_t) h[j].next; + if (a) { + h[j].next = h[j].next->next; + while (j > i) { + j -= 1; + s >>= 1; + h[j].next = (m_link_s *) (a+s); + h[j].next->next = NULL; + } + } +#ifdef DEBUG + printk("___m_alloc(%d) = %p\n", size, (void *) a); +#endif + return (void *) a; +} + +static void ___m_free(m_pool_s *mp, void *ptr, int size) +{ + int i = 0; + int s = (1 << MEMO_SHIFT); + m_link_s *q; + m_addr_t a, b; + m_link_s *h = mp->h; + +#ifdef DEBUG + printk("___m_free(%p, %d)\n", ptr, size); +#endif + + if (size > (PAGE_SIZE << MEMO_PAGE_ORDER)) + return; + + while (size > s) { + s <<= 1; + ++i; + } + + a = (m_addr_t) ptr; + + while (1) { +#ifdef MEMO_FREE_UNUSED + if (s == (PAGE_SIZE << MEMO_PAGE_ORDER)) { + mp->freep(mp, a); + break; + } +#endif + b = a ^ s; + q = &h[i]; + while (q->next && q->next != (m_link_s *) b) { + q = q->next; + } + if (!q->next) { + ((m_link_s *) a)->next = h[i].next; + h[i].next = (m_link_s *) a; + break; + } + q->next = q->next->next; + a = a & b; + s <<= 1; + ++i; + } +} + +static DEFINE_SPINLOCK(ncr53c8xx_lock); + +static void *__m_calloc2(m_pool_s *mp, int size, char *name, int uflags) +{ + void *p; + + p = ___m_alloc(mp, size); + + if (DEBUG_FLAGS & DEBUG_ALLOC) + printk ("new %-10s[%4d] @%p.\n", name, size, p); + + if (p) + memset(p, 0, size); + else if (uflags & MEMO_WARN) + printk (NAME53C8XX ": failed to allocate %s[%d]\n", name, size); + + return p; +} + +#define __m_calloc(mp, s, n) __m_calloc2(mp, s, n, MEMO_WARN) + +static void __m_free(m_pool_s *mp, void *ptr, int size, char *name) +{ + if (DEBUG_FLAGS & DEBUG_ALLOC) + printk ("freeing %-10s[%4d] @%p.\n", name, size, ptr); + + ___m_free(mp, ptr, size); + +} + +/* + * With pci bus iommu support, we use a default pool of unmapped memory + * for memory we donnot need to DMA from/to and one pool per pcidev for + * memory accessed by the PCI chip. `mp0' is the default not DMAable pool. + */ + +static m_addr_t ___mp0_getp(m_pool_s *mp) +{ + m_addr_t m = __get_free_pages(MEMO_GFP_FLAGS, MEMO_PAGE_ORDER); + if (m) + ++mp->nump; + return m; +} + +static void ___mp0_freep(m_pool_s *mp, m_addr_t m) +{ + free_pages(m, MEMO_PAGE_ORDER); + --mp->nump; +} + +static m_pool_s mp0 = {NULL, ___mp0_getp, ___mp0_freep}; + +/* + * DMAable pools. + */ + +/* + * With pci bus iommu support, we maintain one pool per pcidev and a + * hashed reverse table for virtual to bus physical address translations. + */ +static m_addr_t ___dma_getp(m_pool_s *mp) +{ + m_addr_t vp; + m_vtob_s *vbp; + + vbp = __m_calloc(&mp0, sizeof(*vbp), "VTOB"); + if (vbp) { + dma_addr_t daddr; + vp = (m_addr_t) dma_alloc_coherent(mp->bush, + PAGE_SIZE<vaddr = vp; + vbp->baddr = daddr; + vbp->next = mp->vtob[hc]; + mp->vtob[hc] = vbp; + ++mp->nump; + return vp; + } + } + if (vbp) + __m_free(&mp0, vbp, sizeof(*vbp), "VTOB"); + return 0; +} + +static void ___dma_freep(m_pool_s *mp, m_addr_t m) +{ + m_vtob_s **vbpp, *vbp; + int hc = VTOB_HASH_CODE(m); + + vbpp = &mp->vtob[hc]; + while (*vbpp && (*vbpp)->vaddr != m) + vbpp = &(*vbpp)->next; + if (*vbpp) { + vbp = *vbpp; + *vbpp = (*vbpp)->next; + dma_free_coherent(mp->bush, PAGE_SIZE<vaddr, (dma_addr_t)vbp->baddr); + __m_free(&mp0, vbp, sizeof(*vbp), "VTOB"); + --mp->nump; + } +} + +static inline m_pool_s *___get_dma_pool(m_bush_t bush) +{ + m_pool_s *mp; + for (mp = mp0.next; mp && mp->bush != bush; mp = mp->next); + return mp; +} + +static m_pool_s *___cre_dma_pool(m_bush_t bush) +{ + m_pool_s *mp; + mp = __m_calloc(&mp0, sizeof(*mp), "MPOOL"); + if (mp) { + memset(mp, 0, sizeof(*mp)); + mp->bush = bush; + mp->getp = ___dma_getp; + mp->freep = ___dma_freep; + mp->next = mp0.next; + mp0.next = mp; + } + return mp; +} + +static void ___del_dma_pool(m_pool_s *p) +{ + struct m_pool **pp = &mp0.next; + + while (*pp && *pp != p) + pp = &(*pp)->next; + if (*pp) { + *pp = (*pp)->next; + __m_free(&mp0, p, sizeof(*p), "MPOOL"); + } +} + +static void *__m_calloc_dma(m_bush_t bush, int size, char *name) +{ + u_long flags; + struct m_pool *mp; + void *m = NULL; + + spin_lock_irqsave(&ncr53c8xx_lock, flags); + mp = ___get_dma_pool(bush); + if (!mp) + mp = ___cre_dma_pool(bush); + if (mp) + m = __m_calloc(mp, size, name); + if (mp && !mp->nump) + ___del_dma_pool(mp); + spin_unlock_irqrestore(&ncr53c8xx_lock, flags); + + return m; +} + +static void __m_free_dma(m_bush_t bush, void *m, int size, char *name) +{ + u_long flags; + struct m_pool *mp; + + spin_lock_irqsave(&ncr53c8xx_lock, flags); + mp = ___get_dma_pool(bush); + if (mp) + __m_free(mp, m, size, name); + if (mp && !mp->nump) + ___del_dma_pool(mp); + spin_unlock_irqrestore(&ncr53c8xx_lock, flags); +} + +static m_addr_t __vtobus(m_bush_t bush, void *m) +{ + u_long flags; + m_pool_s *mp; + int hc = VTOB_HASH_CODE(m); + m_vtob_s *vp = NULL; + m_addr_t a = ((m_addr_t) m) & ~MEMO_CLUSTER_MASK; + + spin_lock_irqsave(&ncr53c8xx_lock, flags); + mp = ___get_dma_pool(bush); + if (mp) { + vp = mp->vtob[hc]; + while (vp && (m_addr_t) vp->vaddr != a) + vp = vp->next; + } + spin_unlock_irqrestore(&ncr53c8xx_lock, flags); + return vp ? vp->baddr + (((m_addr_t) m) - a) : 0; +} + +#define _m_calloc_dma(np, s, n) __m_calloc_dma(np->dev, s, n) +#define _m_free_dma(np, p, s, n) __m_free_dma(np->dev, p, s, n) +#define m_calloc_dma(s, n) _m_calloc_dma(np, s, n) +#define m_free_dma(p, s, n) _m_free_dma(np, p, s, n) +#define _vtobus(np, p) __vtobus(np->dev, p) +#define vtobus(p) _vtobus(np, p) + +/* + * Deal with DMA mapping/unmapping. + */ + +/* To keep track of the dma mapping (sg/single) that has been set */ +#define __data_mapped SCp.phase +#define __data_mapping SCp.have_data_in + +static void __unmap_scsi_data(struct device *dev, struct scsi_cmnd *cmd) +{ + switch(cmd->__data_mapped) { + case 2: + dma_unmap_sg(dev, cmd->buffer, cmd->use_sg, + cmd->sc_data_direction); + break; + case 1: + dma_unmap_single(dev, cmd->__data_mapping, + cmd->request_bufflen, + cmd->sc_data_direction); + break; + } + cmd->__data_mapped = 0; +} + +static u_long __map_scsi_single_data(struct device *dev, struct scsi_cmnd *cmd) +{ + dma_addr_t mapping; + + if (cmd->request_bufflen == 0) + return 0; + + mapping = dma_map_single(dev, cmd->request_buffer, + cmd->request_bufflen, + cmd->sc_data_direction); + cmd->__data_mapped = 1; + cmd->__data_mapping = mapping; + + return mapping; +} + +static int __map_scsi_sg_data(struct device *dev, struct scsi_cmnd *cmd) +{ + int use_sg; + + if (cmd->use_sg == 0) + return 0; + + use_sg = dma_map_sg(dev, cmd->buffer, cmd->use_sg, + cmd->sc_data_direction); + cmd->__data_mapped = 2; + cmd->__data_mapping = use_sg; + + return use_sg; +} + +#define unmap_scsi_data(np, cmd) __unmap_scsi_data(np->dev, cmd) +#define map_scsi_single_data(np, cmd) __map_scsi_single_data(np->dev, cmd) +#define map_scsi_sg_data(np, cmd) __map_scsi_sg_data(np->dev, cmd) + +/*========================================================== +** +** Driver setup. +** +** This structure is initialized from linux config +** options. It can be overridden at boot-up by the boot +** command line. +** +**========================================================== +*/ +static struct ncr_driver_setup + driver_setup = SCSI_NCR_DRIVER_SETUP; + +#ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT +static struct ncr_driver_setup + driver_safe_setup __initdata = SCSI_NCR_DRIVER_SAFE_SETUP; +#endif + +#define initverbose (driver_setup.verbose) +#define bootverbose (np->verbose) + + +/*=================================================================== +** +** Driver setup from the boot command line +** +**=================================================================== +*/ + +#ifdef MODULE +#define ARG_SEP ' ' +#else +#define ARG_SEP ',' +#endif + +#define OPT_TAGS 1 +#define OPT_MASTER_PARITY 2 +#define OPT_SCSI_PARITY 3 +#define OPT_DISCONNECTION 4 +#define OPT_SPECIAL_FEATURES 5 +#define OPT_UNUSED_1 6 +#define OPT_FORCE_SYNC_NEGO 7 +#define OPT_REVERSE_PROBE 8 +#define OPT_DEFAULT_SYNC 9 +#define OPT_VERBOSE 10 +#define OPT_DEBUG 11 +#define OPT_BURST_MAX 12 +#define OPT_LED_PIN 13 +#define OPT_MAX_WIDE 14 +#define OPT_SETTLE_DELAY 15 +#define OPT_DIFF_SUPPORT 16 +#define OPT_IRQM 17 +#define OPT_PCI_FIX_UP 18 +#define OPT_BUS_CHECK 19 +#define OPT_OPTIMIZE 20 +#define OPT_RECOVERY 21 +#define OPT_SAFE_SETUP 22 +#define OPT_USE_NVRAM 23 +#define OPT_EXCLUDE 24 +#define OPT_HOST_ID 25 + +#ifdef SCSI_NCR_IARB_SUPPORT +#define OPT_IARB 26 +#endif + +static char setup_token[] __initdata = + "tags:" "mpar:" + "spar:" "disc:" + "specf:" "ultra:" + "fsn:" "revprob:" + "sync:" "verb:" + "debug:" "burst:" + "led:" "wide:" + "settle:" "diff:" + "irqm:" "pcifix:" + "buschk:" "optim:" + "recovery:" + "safe:" "nvram:" + "excl:" "hostid:" +#ifdef SCSI_NCR_IARB_SUPPORT + "iarb:" +#endif + ; /* DONNOT REMOVE THIS ';' */ + +#ifdef MODULE +#define ARG_SEP ' ' +#else +#define ARG_SEP ',' +#endif + +static int __init get_setup_token(char *p) +{ + char *cur = setup_token; + char *pc; + int i = 0; + + while (cur != NULL && (pc = strchr(cur, ':')) != NULL) { + ++pc; + ++i; + if (!strncmp(p, cur, pc - cur)) + return i; + cur = pc; + } + return 0; +} + + +static int __init sym53c8xx__setup(char *str) +{ +#ifdef SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT + char *cur = str; + char *pc, *pv; + int i, val, c; + int xi = 0; + + while (cur != NULL && (pc = strchr(cur, ':')) != NULL) { + char *pe; + + val = 0; + pv = pc; + c = *++pv; + + if (c == 'n') + val = 0; + else if (c == 'y') + val = 1; + else + val = (int) simple_strtoul(pv, &pe, 0); + + switch (get_setup_token(cur)) { + case OPT_TAGS: + driver_setup.default_tags = val; + if (pe && *pe == '/') { + i = 0; + while (*pe && *pe != ARG_SEP && + i < sizeof(driver_setup.tag_ctrl)-1) { + driver_setup.tag_ctrl[i++] = *pe++; + } + driver_setup.tag_ctrl[i] = '\0'; + } + break; + case OPT_MASTER_PARITY: + driver_setup.master_parity = val; + break; + case OPT_SCSI_PARITY: + driver_setup.scsi_parity = val; + break; + case OPT_DISCONNECTION: + driver_setup.disconnection = val; + break; + case OPT_SPECIAL_FEATURES: + driver_setup.special_features = val; + break; + case OPT_FORCE_SYNC_NEGO: + driver_setup.force_sync_nego = val; + break; + case OPT_REVERSE_PROBE: + driver_setup.reverse_probe = val; + break; + case OPT_DEFAULT_SYNC: + driver_setup.default_sync = val; + break; + case OPT_VERBOSE: + driver_setup.verbose = val; + break; + case OPT_DEBUG: + driver_setup.debug = val; + break; + case OPT_BURST_MAX: + driver_setup.burst_max = val; + break; + case OPT_LED_PIN: + driver_setup.led_pin = val; + break; + case OPT_MAX_WIDE: + driver_setup.max_wide = val? 1:0; + break; + case OPT_SETTLE_DELAY: + driver_setup.settle_delay = val; + break; + case OPT_DIFF_SUPPORT: + driver_setup.diff_support = val; + break; + case OPT_IRQM: + driver_setup.irqm = val; + break; + case OPT_PCI_FIX_UP: + driver_setup.pci_fix_up = val; + break; + case OPT_BUS_CHECK: + driver_setup.bus_check = val; + break; + case OPT_OPTIMIZE: + driver_setup.optimize = val; + break; + case OPT_RECOVERY: + driver_setup.recovery = val; + break; + case OPT_USE_NVRAM: + driver_setup.use_nvram = val; + break; + case OPT_SAFE_SETUP: + memcpy(&driver_setup, &driver_safe_setup, + sizeof(driver_setup)); + break; + case OPT_EXCLUDE: + if (xi < SCSI_NCR_MAX_EXCLUDES) + driver_setup.excludes[xi++] = val; + break; + case OPT_HOST_ID: + driver_setup.host_id = val; + break; +#ifdef SCSI_NCR_IARB_SUPPORT + case OPT_IARB: + driver_setup.iarb = val; + break; +#endif + default: + printk("sym53c8xx_setup: unexpected boot option '%.*s' ignored\n", (int)(pc-cur+1), cur); + break; + } + + if ((cur = strchr(cur, ARG_SEP)) != NULL) + ++cur; + } +#endif /* SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT */ + return 1; +} + +/*=================================================================== +** +** Get device queue depth from boot command line. +** +**=================================================================== +*/ +#define DEF_DEPTH (driver_setup.default_tags) +#define ALL_TARGETS -2 +#define NO_TARGET -1 +#define ALL_LUNS -2 +#define NO_LUN -1 + +static int device_queue_depth(int unit, int target, int lun) +{ + int c, h, t, u, v; + char *p = driver_setup.tag_ctrl; + char *ep; + + h = -1; + t = NO_TARGET; + u = NO_LUN; + while ((c = *p++) != 0) { + v = simple_strtoul(p, &ep, 0); + switch(c) { + case '/': + ++h; + t = ALL_TARGETS; + u = ALL_LUNS; + break; + case 't': + if (t != target) + t = (target == v) ? v : NO_TARGET; + u = ALL_LUNS; + break; + case 'u': + if (u != lun) + u = (lun == v) ? v : NO_LUN; + break; + case 'q': + if (h == unit && + (t == ALL_TARGETS || t == target) && + (u == ALL_LUNS || u == lun)) + return v; + break; + case '-': + t = ALL_TARGETS; + u = ALL_LUNS; + break; + default: + break; + } + p = ep; + } + return DEF_DEPTH; +} diff --git a/trunk/drivers/scsi/sym53c8xx_defs.h b/trunk/drivers/scsi/sym53c8xx_defs.h new file mode 100644 index 000000000000..139cd0e12e62 --- /dev/null +++ b/trunk/drivers/scsi/sym53c8xx_defs.h @@ -0,0 +1,1320 @@ +/****************************************************************************** +** High Performance device driver for the Symbios 53C896 controller. +** +** Copyright (C) 1998-2001 Gerard Roudier +** +** This driver also supports all the Symbios 53C8XX controller family, +** except 53C810 revisions < 16, 53C825 revisions < 16 and all +** revisions of 53C815 controllers. +** +** This driver is based on the Linux port of the FreeBSD ncr driver. +** +** Copyright (C) 1994 Wolfgang Stanglmeier +** +**----------------------------------------------------------------------------- +** +** This program is free software; you can redistribute it and/or modify +** it under the terms of the GNU General Public License as published by +** the Free Software Foundation; either version 2 of the License, or +** (at your option) any later version. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License +** along with this program; if not, write to the Free Software +** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +** +**----------------------------------------------------------------------------- +** +** The Linux port of the FreeBSD ncr driver has been achieved in +** november 1995 by: +** +** Gerard Roudier +** +** Being given that this driver originates from the FreeBSD version, and +** in order to keep synergy on both, any suggested enhancements and corrections +** received on Linux are automatically a potential candidate for the FreeBSD +** version. +** +** The original driver has been written for 386bsd and FreeBSD by +** Wolfgang Stanglmeier +** Stefan Esser +** +**----------------------------------------------------------------------------- +** +** Major contributions: +** -------------------- +** +** NVRAM detection and reading. +** Copyright (C) 1997 Richard Waltham +** +** Added support for MIPS big endian systems. +** Carsten Langgaard, carstenl@mips.com +** Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. +** +** Added support for HP PARISC big endian systems. +** Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. +** +******************************************************************************* +*/ + +#ifndef SYM53C8XX_DEFS_H +#define SYM53C8XX_DEFS_H + +#include + +/* +** If you want a driver as small as possible, donnot define the +** following options. +*/ +#define SCSI_NCR_BOOT_COMMAND_LINE_SUPPORT +#define SCSI_NCR_DEBUG_INFO_SUPPORT + +/* +** To disable integrity checking, do not define the +** following option. +*/ +#ifdef CONFIG_SCSI_NCR53C8XX_INTEGRITY_CHECK +# define SCSI_NCR_ENABLE_INTEGRITY_CHECK +#endif + +/* --------------------------------------------------------------------- +** Take into account kernel configured parameters. +** Most of these options can be overridden at startup by a command line. +** --------------------------------------------------------------------- +*/ + +/* + * For Ultra2 and Ultra3 SCSI support option, use special features. + * + * Value (default) means: + * bit 0 : all features enabled, except: + * bit 1 : PCI Write And Invalidate. + * bit 2 : Data Phase Mismatch handling from SCRIPTS. + * + * Use boot options ncr53c8xx=specf:1 if you want all chip features to be + * enabled by the driver. + */ +#define SCSI_NCR_SETUP_SPECIAL_FEATURES (3) + +#define SCSI_NCR_MAX_SYNC (80) + +/* + * Allow tags from 2 to 256, default 8 + */ +#ifdef CONFIG_SCSI_NCR53C8XX_MAX_TAGS +#if CONFIG_SCSI_NCR53C8XX_MAX_TAGS < 2 +#define SCSI_NCR_MAX_TAGS (2) +#elif CONFIG_SCSI_NCR53C8XX_MAX_TAGS > 256 +#define SCSI_NCR_MAX_TAGS (256) +#else +#define SCSI_NCR_MAX_TAGS CONFIG_SCSI_NCR53C8XX_MAX_TAGS +#endif +#else +#define SCSI_NCR_MAX_TAGS (8) +#endif + +/* + * Allow tagged command queuing support if configured with default number + * of tags set to max (see above). + */ +#ifdef CONFIG_SCSI_NCR53C8XX_DEFAULT_TAGS +#define SCSI_NCR_SETUP_DEFAULT_TAGS CONFIG_SCSI_NCR53C8XX_DEFAULT_TAGS +#elif defined CONFIG_SCSI_NCR53C8XX_TAGGED_QUEUE +#define SCSI_NCR_SETUP_DEFAULT_TAGS SCSI_NCR_MAX_TAGS +#else +#define SCSI_NCR_SETUP_DEFAULT_TAGS (0) +#endif + +/* + * Immediate arbitration + */ +#if defined(CONFIG_SCSI_NCR53C8XX_IARB) +#define SCSI_NCR_IARB_SUPPORT +#endif + +/* + * Sync transfer frequency at startup. + * Allow from 5Mhz to 80Mhz default 20 Mhz. + */ +#ifndef CONFIG_SCSI_NCR53C8XX_SYNC +#define CONFIG_SCSI_NCR53C8XX_SYNC (20) +#elif CONFIG_SCSI_NCR53C8XX_SYNC > SCSI_NCR_MAX_SYNC +#undef CONFIG_SCSI_NCR53C8XX_SYNC +#define CONFIG_SCSI_NCR53C8XX_SYNC SCSI_NCR_MAX_SYNC +#endif + +#if CONFIG_SCSI_NCR53C8XX_SYNC == 0 +#define SCSI_NCR_SETUP_DEFAULT_SYNC (255) +#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 5 +#define SCSI_NCR_SETUP_DEFAULT_SYNC (50) +#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 20 +#define SCSI_NCR_SETUP_DEFAULT_SYNC (250/(CONFIG_SCSI_NCR53C8XX_SYNC)) +#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 33 +#define SCSI_NCR_SETUP_DEFAULT_SYNC (11) +#elif CONFIG_SCSI_NCR53C8XX_SYNC <= 40 +#define SCSI_NCR_SETUP_DEFAULT_SYNC (10) +#else +#define SCSI_NCR_SETUP_DEFAULT_SYNC (9) +#endif + +/* + * Disallow disconnections at boot-up + */ +#ifdef CONFIG_SCSI_NCR53C8XX_NO_DISCONNECT +#define SCSI_NCR_SETUP_DISCONNECTION (0) +#else +#define SCSI_NCR_SETUP_DISCONNECTION (1) +#endif + +/* + * Force synchronous negotiation for all targets + */ +#ifdef CONFIG_SCSI_NCR53C8XX_FORCE_SYNC_NEGO +#define SCSI_NCR_SETUP_FORCE_SYNC_NEGO (1) +#else +#define SCSI_NCR_SETUP_FORCE_SYNC_NEGO (0) +#endif + +/* + * Disable master parity checking (flawed hardwares need that) + */ +#ifdef CONFIG_SCSI_NCR53C8XX_DISABLE_MPARITY_CHECK +#define SCSI_NCR_SETUP_MASTER_PARITY (0) +#else +#define SCSI_NCR_SETUP_MASTER_PARITY (1) +#endif + +/* + * Disable scsi parity checking (flawed devices may need that) + */ +#ifdef CONFIG_SCSI_NCR53C8XX_DISABLE_PARITY_CHECK +#define SCSI_NCR_SETUP_SCSI_PARITY (0) +#else +#define SCSI_NCR_SETUP_SCSI_PARITY (1) +#endif + +/* + * Settle time after reset at boot-up + */ +#define SCSI_NCR_SETUP_SETTLE_TIME (2) + +/* +** Bridge quirks work-around option defaulted to 1. +*/ +#ifndef SCSI_NCR_PCIQ_WORK_AROUND_OPT +#define SCSI_NCR_PCIQ_WORK_AROUND_OPT 1 +#endif + +/* +** Work-around common bridge misbehaviour. +** +** - Do not flush posted writes in the opposite +** direction on read. +** - May reorder DMA writes to memory. +** +** This option should not affect performances +** significantly, so it is the default. +*/ +#if SCSI_NCR_PCIQ_WORK_AROUND_OPT == 1 +#define SCSI_NCR_PCIQ_MAY_NOT_FLUSH_PW_UPSTREAM +#define SCSI_NCR_PCIQ_MAY_REORDER_WRITES +#define SCSI_NCR_PCIQ_MAY_MISS_COMPLETIONS + +/* +** Same as option 1, but also deal with +** misconfigured interrupts. +** +** - Edge triggerred instead of level sensitive. +** - No interrupt line connected. +** - IRQ number misconfigured. +** +** If no interrupt is delivered, the driver will +** catch the interrupt conditions 10 times per +** second. No need to say that this option is +** not recommended. +*/ +#elif SCSI_NCR_PCIQ_WORK_AROUND_OPT == 2 +#define SCSI_NCR_PCIQ_MAY_NOT_FLUSH_PW_UPSTREAM +#define SCSI_NCR_PCIQ_MAY_REORDER_WRITES +#define SCSI_NCR_PCIQ_MAY_MISS_COMPLETIONS +#define SCSI_NCR_PCIQ_BROKEN_INTR + +/* +** Some bridge designers decided to flush +** everything prior to deliver the interrupt. +** This option tries to deal with such a +** behaviour. +*/ +#elif SCSI_NCR_PCIQ_WORK_AROUND_OPT == 3 +#define SCSI_NCR_PCIQ_SYNC_ON_INTR +#endif + +/* +** Other parameters not configurable with "make config" +** Avoid to change these constants, unless you know what you are doing. +*/ + +#define SCSI_NCR_ALWAYS_SIMPLE_TAG +#define SCSI_NCR_MAX_SCATTER (127) +#define SCSI_NCR_MAX_TARGET (16) + +/* +** Compute some desirable value for CAN_QUEUE +** and CMD_PER_LUN. +** The driver will use lower values if these +** ones appear to be too large. +*/ +#define SCSI_NCR_CAN_QUEUE (8*SCSI_NCR_MAX_TAGS + 2*SCSI_NCR_MAX_TARGET) +#define SCSI_NCR_CMD_PER_LUN (SCSI_NCR_MAX_TAGS) + +#define SCSI_NCR_SG_TABLESIZE (SCSI_NCR_MAX_SCATTER) +#define SCSI_NCR_TIMER_INTERVAL (HZ) + +#if 1 /* defined CONFIG_SCSI_MULTI_LUN */ +#define SCSI_NCR_MAX_LUN (16) +#else +#define SCSI_NCR_MAX_LUN (1) +#endif + +/* + * IO functions definition for big/little endian CPU support. + * For now, the NCR is only supported in little endian addressing mode, + */ + +#ifdef __BIG_ENDIAN + +#define inw_l2b inw +#define inl_l2b inl +#define outw_b2l outw +#define outl_b2l outl + +#define readb_raw readb +#define writeb_raw writeb + +#if defined(SCSI_NCR_BIG_ENDIAN) +#define readw_l2b __raw_readw +#define readl_l2b __raw_readl +#define writew_b2l __raw_writew +#define writel_b2l __raw_writel +#define readw_raw __raw_readw +#define readl_raw __raw_readl +#define writew_raw __raw_writew +#define writel_raw __raw_writel +#else /* Other big-endian */ +#define readw_l2b readw +#define readl_l2b readl +#define writew_b2l writew +#define writel_b2l writel +#define readw_raw readw +#define readl_raw readl +#define writew_raw writew +#define writel_raw writel +#endif + +#else /* little endian */ + +#define inw_raw inw +#define inl_raw inl +#define outw_raw outw +#define outl_raw outl + +#define readb_raw readb +#define readw_raw readw +#define readl_raw readl +#define writeb_raw writeb +#define writew_raw writew +#define writel_raw writel + +#endif + +#if !defined(__hppa__) && !defined(__mips__) +#ifdef SCSI_NCR_BIG_ENDIAN +#error "The NCR in BIG ENDIAN addressing mode is not (yet) supported" +#endif +#endif + +#define MEMORY_BARRIER() mb() + + +/* + * If the NCR uses big endian addressing mode over the + * PCI, actual io register addresses for byte and word + * accesses must be changed according to lane routing. + * Btw, ncr_offb() and ncr_offw() macros only apply to + * constants and so donnot generate bloated code. + */ + +#if defined(SCSI_NCR_BIG_ENDIAN) + +#define ncr_offb(o) (((o)&~3)+((~((o)&3))&3)) +#define ncr_offw(o) (((o)&~3)+((~((o)&3))&2)) + +#else + +#define ncr_offb(o) (o) +#define ncr_offw(o) (o) + +#endif + +/* + * If the CPU and the NCR use same endian-ness addressing, + * no byte reordering is needed for script patching. + * Macro cpu_to_scr() is to be used for script patching. + * Macro scr_to_cpu() is to be used for getting a DWORD + * from the script. + */ + +#if defined(__BIG_ENDIAN) && !defined(SCSI_NCR_BIG_ENDIAN) + +#define cpu_to_scr(dw) cpu_to_le32(dw) +#define scr_to_cpu(dw) le32_to_cpu(dw) + +#elif defined(__LITTLE_ENDIAN) && defined(SCSI_NCR_BIG_ENDIAN) + +#define cpu_to_scr(dw) cpu_to_be32(dw) +#define scr_to_cpu(dw) be32_to_cpu(dw) + +#else + +#define cpu_to_scr(dw) (dw) +#define scr_to_cpu(dw) (dw) + +#endif + +/* + * Access to the controller chip. + * + * If the CPU and the NCR use same endian-ness addressing, + * no byte reordering is needed for accessing chip io + * registers. Functions suffixed by '_raw' are assumed + * to access the chip over the PCI without doing byte + * reordering. Functions suffixed by '_l2b' are + * assumed to perform little-endian to big-endian byte + * reordering, those suffixed by '_b2l' blah, blah, + * blah, ... + */ + +/* + * MEMORY mapped IO input / output + */ + +#define INB_OFF(o) readb_raw((char __iomem *)np->reg + ncr_offb(o)) +#define OUTB_OFF(o, val) writeb_raw((val), (char __iomem *)np->reg + ncr_offb(o)) + +#if defined(__BIG_ENDIAN) && !defined(SCSI_NCR_BIG_ENDIAN) + +#define INW_OFF(o) readw_l2b((char __iomem *)np->reg + ncr_offw(o)) +#define INL_OFF(o) readl_l2b((char __iomem *)np->reg + (o)) + +#define OUTW_OFF(o, val) writew_b2l((val), (char __iomem *)np->reg + ncr_offw(o)) +#define OUTL_OFF(o, val) writel_b2l((val), (char __iomem *)np->reg + (o)) + +#elif defined(__LITTLE_ENDIAN) && defined(SCSI_NCR_BIG_ENDIAN) + +#define INW_OFF(o) readw_b2l((char __iomem *)np->reg + ncr_offw(o)) +#define INL_OFF(o) readl_b2l((char __iomem *)np->reg + (o)) + +#define OUTW_OFF(o, val) writew_l2b((val), (char __iomem *)np->reg + ncr_offw(o)) +#define OUTL_OFF(o, val) writel_l2b((val), (char __iomem *)np->reg + (o)) + +#else + +#ifdef CONFIG_SCSI_NCR53C8XX_NO_WORD_TRANSFERS +/* Only 8 or 32 bit transfers allowed */ +#define INW_OFF(o) (readb((char __iomem *)np->reg + ncr_offw(o)) << 8 | readb((char __iomem *)np->reg + ncr_offw(o) + 1)) +#else +#define INW_OFF(o) readw_raw((char __iomem *)np->reg + ncr_offw(o)) +#endif +#define INL_OFF(o) readl_raw((char __iomem *)np->reg + (o)) + +#ifdef CONFIG_SCSI_NCR53C8XX_NO_WORD_TRANSFERS +/* Only 8 or 32 bit transfers allowed */ +#define OUTW_OFF(o, val) do { writeb((char)((val) >> 8), (char __iomem *)np->reg + ncr_offw(o)); writeb((char)(val), (char __iomem *)np->reg + ncr_offw(o) + 1); } while (0) +#else +#define OUTW_OFF(o, val) writew_raw((val), (char __iomem *)np->reg + ncr_offw(o)) +#endif +#define OUTL_OFF(o, val) writel_raw((val), (char __iomem *)np->reg + (o)) + +#endif + +#define INB(r) INB_OFF (offsetof(struct ncr_reg,r)) +#define INW(r) INW_OFF (offsetof(struct ncr_reg,r)) +#define INL(r) INL_OFF (offsetof(struct ncr_reg,r)) + +#define OUTB(r, val) OUTB_OFF (offsetof(struct ncr_reg,r), (val)) +#define OUTW(r, val) OUTW_OFF (offsetof(struct ncr_reg,r), (val)) +#define OUTL(r, val) OUTL_OFF (offsetof(struct ncr_reg,r), (val)) + +/* + * Set bit field ON, OFF + */ + +#define OUTONB(r, m) OUTB(r, INB(r) | (m)) +#define OUTOFFB(r, m) OUTB(r, INB(r) & ~(m)) +#define OUTONW(r, m) OUTW(r, INW(r) | (m)) +#define OUTOFFW(r, m) OUTW(r, INW(r) & ~(m)) +#define OUTONL(r, m) OUTL(r, INL(r) | (m)) +#define OUTOFFL(r, m) OUTL(r, INL(r) & ~(m)) + +/* + * We normally want the chip to have a consistent view + * of driver internal data structures when we restart it. + * Thus these macros. + */ +#define OUTL_DSP(v) \ + do { \ + MEMORY_BARRIER(); \ + OUTL (nc_dsp, (v)); \ + } while (0) + +#define OUTONB_STD() \ + do { \ + MEMORY_BARRIER(); \ + OUTONB (nc_dcntl, (STD|NOCOM)); \ + } while (0) + + +/* +** NCR53C8XX devices features table. +*/ +struct ncr_chip { + unsigned short revision_id; + unsigned char burst_max; /* log-base-2 of max burst */ + unsigned char offset_max; + unsigned char nr_divisor; + unsigned int features; +#define FE_LED0 (1<<0) +#define FE_WIDE (1<<1) /* Wide data transfers */ +#define FE_ULTRA (1<<2) /* Ultra speed 20Mtrans/sec */ +#define FE_DBLR (1<<4) /* Clock doubler present */ +#define FE_QUAD (1<<5) /* Clock quadrupler present */ +#define FE_ERL (1<<6) /* Enable read line */ +#define FE_CLSE (1<<7) /* Cache line size enable */ +#define FE_WRIE (1<<8) /* Write & Invalidate enable */ +#define FE_ERMP (1<<9) /* Enable read multiple */ +#define FE_BOF (1<<10) /* Burst opcode fetch */ +#define FE_DFS (1<<11) /* DMA fifo size */ +#define FE_PFEN (1<<12) /* Prefetch enable */ +#define FE_LDSTR (1<<13) /* Load/Store supported */ +#define FE_RAM (1<<14) /* On chip RAM present */ +#define FE_VARCLK (1<<15) /* SCSI clock may vary */ +#define FE_RAM8K (1<<16) /* On chip RAM sized 8Kb */ +#define FE_64BIT (1<<17) /* Have a 64-bit PCI interface */ +#define FE_IO256 (1<<18) /* Requires full 256 bytes in PCI space */ +#define FE_NOPM (1<<19) /* Scripts handles phase mismatch */ +#define FE_LEDC (1<<20) /* Hardware control of LED */ +#define FE_DIFF (1<<21) /* Support Differential SCSI */ +#define FE_66MHZ (1<<23) /* 66MHz PCI Support */ +#define FE_DAC (1<<24) /* Support DAC cycles (64 bit addressing) */ +#define FE_ISTAT1 (1<<25) /* Have ISTAT1, MBOX0, MBOX1 registers */ +#define FE_DAC_IN_USE (1<<26) /* Platform does DAC cycles */ +#define FE_EHP (1<<27) /* 720: Even host parity */ +#define FE_MUX (1<<28) /* 720: Multiplexed bus */ +#define FE_EA (1<<29) /* 720: Enable Ack */ + +#define FE_CACHE_SET (FE_ERL|FE_CLSE|FE_WRIE|FE_ERMP) +#define FE_SCSI_SET (FE_WIDE|FE_ULTRA|FE_DBLR|FE_QUAD|F_CLK80) +#define FE_SPECIAL_SET (FE_CACHE_SET|FE_BOF|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM) +}; + + +/* +** Driver setup structure. +** +** This structure is initialized from linux config options. +** It can be overridden at boot-up by the boot command line. +*/ +#define SCSI_NCR_MAX_EXCLUDES 8 +struct ncr_driver_setup { + u8 master_parity; + u8 scsi_parity; + u8 disconnection; + u8 special_features; + u8 force_sync_nego; + u8 reverse_probe; + u8 pci_fix_up; + u8 use_nvram; + u8 verbose; + u8 default_tags; + u16 default_sync; + u16 debug; + u8 burst_max; + u8 led_pin; + u8 max_wide; + u8 settle_delay; + u8 diff_support; + u8 irqm; + u8 bus_check; + u8 optimize; + u8 recovery; + u8 host_id; + u16 iarb; + u32 excludes[SCSI_NCR_MAX_EXCLUDES]; + char tag_ctrl[100]; +}; + +/* +** Initial setup. +** Can be overriden at startup by a command line. +*/ +#define SCSI_NCR_DRIVER_SETUP \ +{ \ + SCSI_NCR_SETUP_MASTER_PARITY, \ + SCSI_NCR_SETUP_SCSI_PARITY, \ + SCSI_NCR_SETUP_DISCONNECTION, \ + SCSI_NCR_SETUP_SPECIAL_FEATURES, \ + SCSI_NCR_SETUP_FORCE_SYNC_NEGO, \ + 0, \ + 0, \ + 1, \ + 0, \ + SCSI_NCR_SETUP_DEFAULT_TAGS, \ + SCSI_NCR_SETUP_DEFAULT_SYNC, \ + 0x00, \ + 7, \ + 0, \ + 1, \ + SCSI_NCR_SETUP_SETTLE_TIME, \ + 0, \ + 0, \ + 1, \ + 0, \ + 0, \ + 255, \ + 0x00 \ +} + +/* +** Boot fail safe setup. +** Override initial setup from boot command line: +** ncr53c8xx=safe:y +*/ +#define SCSI_NCR_DRIVER_SAFE_SETUP \ +{ \ + 0, \ + 1, \ + 0, \ + 0, \ + 0, \ + 0, \ + 0, \ + 1, \ + 2, \ + 0, \ + 255, \ + 0x00, \ + 255, \ + 0, \ + 0, \ + 10, \ + 1, \ + 1, \ + 1, \ + 0, \ + 0, \ + 255 \ +} + +/**************** ORIGINAL CONTENT of ncrreg.h from FreeBSD ******************/ + +/*----------------------------------------------------------------- +** +** The ncr 53c810 register structure. +** +**----------------------------------------------------------------- +*/ + +struct ncr_reg { +/*00*/ u8 nc_scntl0; /* full arb., ena parity, par->ATN */ + +/*01*/ u8 nc_scntl1; /* no reset */ + #define ISCON 0x10 /* connected to scsi */ + #define CRST 0x08 /* force reset */ + #define IARB 0x02 /* immediate arbitration */ + +/*02*/ u8 nc_scntl2; /* no disconnect expected */ + #define SDU 0x80 /* cmd: disconnect will raise error */ + #define CHM 0x40 /* sta: chained mode */ + #define WSS 0x08 /* sta: wide scsi send [W]*/ + #define WSR 0x01 /* sta: wide scsi received [W]*/ + +/*03*/ u8 nc_scntl3; /* cnf system clock dependent */ + #define EWS 0x08 /* cmd: enable wide scsi [W]*/ + #define ULTRA 0x80 /* cmd: ULTRA enable */ + /* bits 0-2, 7 rsvd for C1010 */ + +/*04*/ u8 nc_scid; /* cnf host adapter scsi address */ + #define RRE 0x40 /* r/w:e enable response to resel. */ + #define SRE 0x20 /* r/w:e enable response to select */ + +/*05*/ u8 nc_sxfer; /* ### Sync speed and count */ + /* bits 6-7 rsvd for C1010 */ + +/*06*/ u8 nc_sdid; /* ### Destination-ID */ + +/*07*/ u8 nc_gpreg; /* ??? IO-Pins */ + +/*08*/ u8 nc_sfbr; /* ### First byte in phase */ + +/*09*/ u8 nc_socl; + #define CREQ 0x80 /* r/w: SCSI-REQ */ + #define CACK 0x40 /* r/w: SCSI-ACK */ + #define CBSY 0x20 /* r/w: SCSI-BSY */ + #define CSEL 0x10 /* r/w: SCSI-SEL */ + #define CATN 0x08 /* r/w: SCSI-ATN */ + #define CMSG 0x04 /* r/w: SCSI-MSG */ + #define CC_D 0x02 /* r/w: SCSI-C_D */ + #define CI_O 0x01 /* r/w: SCSI-I_O */ + +/*0a*/ u8 nc_ssid; + +/*0b*/ u8 nc_sbcl; + +/*0c*/ u8 nc_dstat; + #define DFE 0x80 /* sta: dma fifo empty */ + #define MDPE 0x40 /* int: master data parity error */ + #define BF 0x20 /* int: script: bus fault */ + #define ABRT 0x10 /* int: script: command aborted */ + #define SSI 0x08 /* int: script: single step */ + #define SIR 0x04 /* int: script: interrupt instruct. */ + #define IID 0x01 /* int: script: illegal instruct. */ + +/*0d*/ u8 nc_sstat0; + #define ILF 0x80 /* sta: data in SIDL register lsb */ + #define ORF 0x40 /* sta: data in SODR register lsb */ + #define OLF 0x20 /* sta: data in SODL register lsb */ + #define AIP 0x10 /* sta: arbitration in progress */ + #define LOA 0x08 /* sta: arbitration lost */ + #define WOA 0x04 /* sta: arbitration won */ + #define IRST 0x02 /* sta: scsi reset signal */ + #define SDP 0x01 /* sta: scsi parity signal */ + +/*0e*/ u8 nc_sstat1; + #define FF3210 0xf0 /* sta: bytes in the scsi fifo */ + +/*0f*/ u8 nc_sstat2; + #define ILF1 0x80 /* sta: data in SIDL register msb[W]*/ + #define ORF1 0x40 /* sta: data in SODR register msb[W]*/ + #define OLF1 0x20 /* sta: data in SODL register msb[W]*/ + #define DM 0x04 /* sta: DIFFSENS mismatch (895/6 only) */ + #define LDSC 0x02 /* sta: disconnect & reconnect */ + +/*10*/ u8 nc_dsa; /* --> Base page */ +/*11*/ u8 nc_dsa1; +/*12*/ u8 nc_dsa2; +/*13*/ u8 nc_dsa3; + +/*14*/ u8 nc_istat; /* --> Main Command and status */ + #define CABRT 0x80 /* cmd: abort current operation */ + #define SRST 0x40 /* mod: reset chip */ + #define SIGP 0x20 /* r/w: message from host to ncr */ + #define SEM 0x10 /* r/w: message between host + ncr */ + #define CON 0x08 /* sta: connected to scsi */ + #define INTF 0x04 /* sta: int on the fly (reset by wr)*/ + #define SIP 0x02 /* sta: scsi-interrupt */ + #define DIP 0x01 /* sta: host/script interrupt */ + +/*15*/ u8 nc_istat1; /* 896 and later cores only */ + #define FLSH 0x04 /* sta: chip is flushing */ + #define SRUN 0x02 /* sta: scripts are running */ + #define SIRQD 0x01 /* r/w: disable INT pin */ + +/*16*/ u8 nc_mbox0; /* 896 and later cores only */ +/*17*/ u8 nc_mbox1; /* 896 and later cores only */ + +/*18*/ u8 nc_ctest0; + #define EHP 0x04 /* 720 even host parity */ +/*19*/ u8 nc_ctest1; + +/*1a*/ u8 nc_ctest2; + #define CSIGP 0x40 + /* bits 0-2,7 rsvd for C1010 */ + +/*1b*/ u8 nc_ctest3; + #define FLF 0x08 /* cmd: flush dma fifo */ + #define CLF 0x04 /* cmd: clear dma fifo */ + #define FM 0x02 /* mod: fetch pin mode */ + #define WRIE 0x01 /* mod: write and invalidate enable */ + /* bits 4-7 rsvd for C1010 */ + +/*1c*/ u32 nc_temp; /* ### Temporary stack */ + +/*20*/ u8 nc_dfifo; +/*21*/ u8 nc_ctest4; + #define MUX 0x80 /* 720 host bus multiplex mode */ + #define BDIS 0x80 /* mod: burst disable */ + #define MPEE 0x08 /* mod: master parity error enable */ + +/*22*/ u8 nc_ctest5; + #define DFS 0x20 /* mod: dma fifo size */ + /* bits 0-1, 3-7 rsvd for C1010 */ +/*23*/ u8 nc_ctest6; + +/*24*/ u32 nc_dbc; /* ### Byte count and command */ +/*28*/ u32 nc_dnad; /* ### Next command register */ +/*2c*/ u32 nc_dsp; /* --> Script Pointer */ +/*30*/ u32 nc_dsps; /* --> Script pointer save/opcode#2 */ + +/*34*/ u8 nc_scratcha; /* Temporary register a */ +/*35*/ u8 nc_scratcha1; +/*36*/ u8 nc_scratcha2; +/*37*/ u8 nc_scratcha3; + +/*38*/ u8 nc_dmode; + #define BL_2 0x80 /* mod: burst length shift value +2 */ + #define BL_1 0x40 /* mod: burst length shift value +1 */ + #define ERL 0x08 /* mod: enable read line */ + #define ERMP 0x04 /* mod: enable read multiple */ + #define BOF 0x02 /* mod: burst op code fetch */ + +/*39*/ u8 nc_dien; +/*3a*/ u8 nc_sbr; + +/*3b*/ u8 nc_dcntl; /* --> Script execution control */ + #define CLSE 0x80 /* mod: cache line size enable */ + #define PFF 0x40 /* cmd: pre-fetch flush */ + #define PFEN 0x20 /* mod: pre-fetch enable */ + #define EA 0x20 /* mod: 720 enable-ack */ + #define SSM 0x10 /* mod: single step mode */ + #define IRQM 0x08 /* mod: irq mode (1 = totem pole !) */ + #define STD 0x04 /* cmd: start dma mode */ + #define IRQD 0x02 /* mod: irq disable */ + #define NOCOM 0x01 /* cmd: protect sfbr while reselect */ + /* bits 0-1 rsvd for C1010 */ + +/*3c*/ u32 nc_adder; + +/*40*/ u16 nc_sien; /* -->: interrupt enable */ +/*42*/ u16 nc_sist; /* <--: interrupt status */ + #define SBMC 0x1000/* sta: SCSI Bus Mode Change (895/6 only) */ + #define STO 0x0400/* sta: timeout (select) */ + #define GEN 0x0200/* sta: timeout (general) */ + #define HTH 0x0100/* sta: timeout (handshake) */ + #define MA 0x80 /* sta: phase mismatch */ + #define CMP 0x40 /* sta: arbitration complete */ + #define SEL 0x20 /* sta: selected by another device */ + #define RSL 0x10 /* sta: reselected by another device*/ + #define SGE 0x08 /* sta: gross error (over/underflow)*/ + #define UDC 0x04 /* sta: unexpected disconnect */ + #define RST 0x02 /* sta: scsi bus reset detected */ + #define PAR 0x01 /* sta: scsi parity error */ + +/*44*/ u8 nc_slpar; +/*45*/ u8 nc_swide; +/*46*/ u8 nc_macntl; +/*47*/ u8 nc_gpcntl; +/*48*/ u8 nc_stime0; /* cmd: timeout for select&handshake*/ +/*49*/ u8 nc_stime1; /* cmd: timeout user defined */ +/*4a*/ u16 nc_respid; /* sta: Reselect-IDs */ + +/*4c*/ u8 nc_stest0; + +/*4d*/ u8 nc_stest1; + #define SCLK 0x80 /* Use the PCI clock as SCSI clock */ + #define DBLEN 0x08 /* clock doubler running */ + #define DBLSEL 0x04 /* clock doubler selected */ + + +/*4e*/ u8 nc_stest2; + #define ROF 0x40 /* reset scsi offset (after gross error!) */ + #define DIF 0x20 /* 720 SCSI differential mode */ + #define EXT 0x02 /* extended filtering */ + +/*4f*/ u8 nc_stest3; + #define TE 0x80 /* c: tolerAnt enable */ + #define HSC 0x20 /* c: Halt SCSI Clock */ + #define CSF 0x02 /* c: clear scsi fifo */ + +/*50*/ u16 nc_sidl; /* Lowlevel: latched from scsi data */ +/*52*/ u8 nc_stest4; + #define SMODE 0xc0 /* SCSI bus mode (895/6 only) */ + #define SMODE_HVD 0x40 /* High Voltage Differential */ + #define SMODE_SE 0x80 /* Single Ended */ + #define SMODE_LVD 0xc0 /* Low Voltage Differential */ + #define LCKFRQ 0x20 /* Frequency Lock (895/6 only) */ + /* bits 0-5 rsvd for C1010 */ + +/*53*/ u8 nc_53_; +/*54*/ u16 nc_sodl; /* Lowlevel: data out to scsi data */ +/*56*/ u8 nc_ccntl0; /* Chip Control 0 (896) */ + #define ENPMJ 0x80 /* Enable Phase Mismatch Jump */ + #define PMJCTL 0x40 /* Phase Mismatch Jump Control */ + #define ENNDJ 0x20 /* Enable Non Data PM Jump */ + #define DISFC 0x10 /* Disable Auto FIFO Clear */ + #define DILS 0x02 /* Disable Internal Load/Store */ + #define DPR 0x01 /* Disable Pipe Req */ + +/*57*/ u8 nc_ccntl1; /* Chip Control 1 (896) */ + #define ZMOD 0x80 /* High Impedance Mode */ + #define DIC 0x10 /* Disable Internal Cycles */ + #define DDAC 0x08 /* Disable Dual Address Cycle */ + #define XTIMOD 0x04 /* 64-bit Table Ind. Indexing Mode */ + #define EXTIBMV 0x02 /* Enable 64-bit Table Ind. BMOV */ + #define EXDBMV 0x01 /* Enable 64-bit Direct BMOV */ + +/*58*/ u16 nc_sbdl; /* Lowlevel: data from scsi data */ +/*5a*/ u16 nc_5a_; + +/*5c*/ u8 nc_scr0; /* Working register B */ +/*5d*/ u8 nc_scr1; /* */ +/*5e*/ u8 nc_scr2; /* */ +/*5f*/ u8 nc_scr3; /* */ + +/*60*/ u8 nc_scrx[64]; /* Working register C-R */ +/*a0*/ u32 nc_mmrs; /* Memory Move Read Selector */ +/*a4*/ u32 nc_mmws; /* Memory Move Write Selector */ +/*a8*/ u32 nc_sfs; /* Script Fetch Selector */ +/*ac*/ u32 nc_drs; /* DSA Relative Selector */ +/*b0*/ u32 nc_sbms; /* Static Block Move Selector */ +/*b4*/ u32 nc_dbms; /* Dynamic Block Move Selector */ +/*b8*/ u32 nc_dnad64; /* DMA Next Address 64 */ +/*bc*/ u16 nc_scntl4; /* C1010 only */ + #define U3EN 0x80 /* Enable Ultra 3 */ + #define AIPEN 0x40 /* Allow check upper byte lanes */ + #define XCLKH_DT 0x08 /* Extra clock of data hold on DT + transfer edge */ + #define XCLKH_ST 0x04 /* Extra clock of data hold on ST + transfer edge */ + +/*be*/ u8 nc_aipcntl0; /* Epat Control 1 C1010 only */ +/*bf*/ u8 nc_aipcntl1; /* AIP Control C1010_66 Only */ + +/*c0*/ u32 nc_pmjad1; /* Phase Mismatch Jump Address 1 */ +/*c4*/ u32 nc_pmjad2; /* Phase Mismatch Jump Address 2 */ +/*c8*/ u8 nc_rbc; /* Remaining Byte Count */ +/*c9*/ u8 nc_rbc1; /* */ +/*ca*/ u8 nc_rbc2; /* */ +/*cb*/ u8 nc_rbc3; /* */ + +/*cc*/ u8 nc_ua; /* Updated Address */ +/*cd*/ u8 nc_ua1; /* */ +/*ce*/ u8 nc_ua2; /* */ +/*cf*/ u8 nc_ua3; /* */ +/*d0*/ u32 nc_esa; /* Entry Storage Address */ +/*d4*/ u8 nc_ia; /* Instruction Address */ +/*d5*/ u8 nc_ia1; +/*d6*/ u8 nc_ia2; +/*d7*/ u8 nc_ia3; +/*d8*/ u32 nc_sbc; /* SCSI Byte Count (3 bytes only) */ +/*dc*/ u32 nc_csbc; /* Cumulative SCSI Byte Count */ + + /* Following for C1010 only */ +/*e0*/ u16 nc_crcpad; /* CRC Value */ +/*e2*/ u8 nc_crccntl0; /* CRC control register */ + #define SNDCRC 0x10 /* Send CRC Request */ +/*e3*/ u8 nc_crccntl1; /* CRC control register */ +/*e4*/ u32 nc_crcdata; /* CRC data register */ +/*e8*/ u32 nc_e8_; /* rsvd */ +/*ec*/ u32 nc_ec_; /* rsvd */ +/*f0*/ u16 nc_dfbc; /* DMA FIFO byte count */ + +}; + +/*----------------------------------------------------------- +** +** Utility macros for the script. +** +**----------------------------------------------------------- +*/ + +#define REGJ(p,r) (offsetof(struct ncr_reg, p ## r)) +#define REG(r) REGJ (nc_, r) + +typedef u32 ncrcmd; + +/*----------------------------------------------------------- +** +** SCSI phases +** +** DT phases illegal for ncr driver. +** +**----------------------------------------------------------- +*/ + +#define SCR_DATA_OUT 0x00000000 +#define SCR_DATA_IN 0x01000000 +#define SCR_COMMAND 0x02000000 +#define SCR_STATUS 0x03000000 +#define SCR_DT_DATA_OUT 0x04000000 +#define SCR_DT_DATA_IN 0x05000000 +#define SCR_MSG_OUT 0x06000000 +#define SCR_MSG_IN 0x07000000 + +#define SCR_ILG_OUT 0x04000000 +#define SCR_ILG_IN 0x05000000 + +/*----------------------------------------------------------- +** +** Data transfer via SCSI. +** +**----------------------------------------------------------- +** +** MOVE_ABS (LEN) +** <> +** +** MOVE_IND (LEN) +** <> +** +** MOVE_TBL +** <> +** +**----------------------------------------------------------- +*/ + +#define OPC_MOVE 0x08000000 + +#define SCR_MOVE_ABS(l) ((0x00000000 | OPC_MOVE) | (l)) +#define SCR_MOVE_IND(l) ((0x20000000 | OPC_MOVE) | (l)) +#define SCR_MOVE_TBL (0x10000000 | OPC_MOVE) + +#define SCR_CHMOV_ABS(l) ((0x00000000) | (l)) +#define SCR_CHMOV_IND(l) ((0x20000000) | (l)) +#define SCR_CHMOV_TBL (0x10000000) + +struct scr_tblmove { + u32 size; + u32 addr; +}; + +/*----------------------------------------------------------- +** +** Selection +** +**----------------------------------------------------------- +** +** SEL_ABS | SCR_ID (0..15) [ | REL_JMP] +** <> +** +** SEL_TBL | << dnad_offset>> [ | REL_JMP] +** <> +** +**----------------------------------------------------------- +*/ + +#define SCR_SEL_ABS 0x40000000 +#define SCR_SEL_ABS_ATN 0x41000000 +#define SCR_SEL_TBL 0x42000000 +#define SCR_SEL_TBL_ATN 0x43000000 + + +#ifdef SCSI_NCR_BIG_ENDIAN +struct scr_tblsel { + u8 sel_scntl3; + u8 sel_id; + u8 sel_sxfer; + u8 sel_scntl4; +}; +#else +struct scr_tblsel { + u8 sel_scntl4; + u8 sel_sxfer; + u8 sel_id; + u8 sel_scntl3; +}; +#endif + +#define SCR_JMP_REL 0x04000000 +#define SCR_ID(id) (((u32)(id)) << 16) + +/*----------------------------------------------------------- +** +** Waiting for Disconnect or Reselect +** +**----------------------------------------------------------- +** +** WAIT_DISC +** dummy: <> +** +** WAIT_RESEL +** <> +** +**----------------------------------------------------------- +*/ + +#define SCR_WAIT_DISC 0x48000000 +#define SCR_WAIT_RESEL 0x50000000 + +/*----------------------------------------------------------- +** +** Bit Set / Reset +** +**----------------------------------------------------------- +** +** SET (flags {|.. }) +** +** CLR (flags {|.. }) +** +**----------------------------------------------------------- +*/ + +#define SCR_SET(f) (0x58000000 | (f)) +#define SCR_CLR(f) (0x60000000 | (f)) + +#define SCR_CARRY 0x00000400 +#define SCR_TRG 0x00000200 +#define SCR_ACK 0x00000040 +#define SCR_ATN 0x00000008 + + + + +/*----------------------------------------------------------- +** +** Memory to memory move +** +**----------------------------------------------------------- +** +** COPY (bytecount) +** << source_address >> +** << destination_address >> +** +** SCR_COPY sets the NO FLUSH option by default. +** SCR_COPY_F does not set this option. +** +** For chips which do not support this option, +** ncr_copy_and_bind() will remove this bit. +**----------------------------------------------------------- +*/ + +#define SCR_NO_FLUSH 0x01000000 + +#define SCR_COPY(n) (0xc0000000 | SCR_NO_FLUSH | (n)) +#define SCR_COPY_F(n) (0xc0000000 | (n)) + +/*----------------------------------------------------------- +** +** Register move and binary operations +** +**----------------------------------------------------------- +** +** SFBR_REG (reg, op, data) reg = SFBR op data +** << 0 >> +** +** REG_SFBR (reg, op, data) SFBR = reg op data +** << 0 >> +** +** REG_REG (reg, op, data) reg = reg op data +** << 0 >> +** +**----------------------------------------------------------- +** On 810A, 860, 825A, 875, 895 and 896 chips the content +** of SFBR register can be used as data (SCR_SFBR_DATA). +** The 896 has additionnal IO registers starting at +** offset 0x80. Bit 7 of register offset is stored in +** bit 7 of the SCRIPTS instruction first DWORD. +**----------------------------------------------------------- +*/ + +#define SCR_REG_OFS(ofs) ((((ofs) & 0x7f) << 16ul) + ((ofs) & 0x80)) + +#define SCR_SFBR_REG(reg,op,data) \ + (0x68000000 | (SCR_REG_OFS(REG(reg))) | (op) | (((data)&0xff)<<8ul)) + +#define SCR_REG_SFBR(reg,op,data) \ + (0x70000000 | (SCR_REG_OFS(REG(reg))) | (op) | (((data)&0xff)<<8ul)) + +#define SCR_REG_REG(reg,op,data) \ + (0x78000000 | (SCR_REG_OFS(REG(reg))) | (op) | (((data)&0xff)<<8ul)) + + +#define SCR_LOAD 0x00000000 +#define SCR_SHL 0x01000000 +#define SCR_OR 0x02000000 +#define SCR_XOR 0x03000000 +#define SCR_AND 0x04000000 +#define SCR_SHR 0x05000000 +#define SCR_ADD 0x06000000 +#define SCR_ADDC 0x07000000 + +#define SCR_SFBR_DATA (0x00800000>>8ul) /* Use SFBR as data */ + +/*----------------------------------------------------------- +** +** FROM_REG (reg) SFBR = reg +** << 0 >> +** +** TO_REG (reg) reg = SFBR +** << 0 >> +** +** LOAD_REG (reg, data) reg = +** << 0 >> +** +** LOAD_SFBR(data) SFBR = +** << 0 >> +** +**----------------------------------------------------------- +*/ + +#define SCR_FROM_REG(reg) \ + SCR_REG_SFBR(reg,SCR_OR,0) + +#define SCR_TO_REG(reg) \ + SCR_SFBR_REG(reg,SCR_OR,0) + +#define SCR_LOAD_REG(reg,data) \ + SCR_REG_REG(reg,SCR_LOAD,data) + +#define SCR_LOAD_SFBR(data) \ + (SCR_REG_SFBR (gpreg, SCR_LOAD, data)) + +/*----------------------------------------------------------- +** +** LOAD from memory to register. +** STORE from register to memory. +** +** Only supported by 810A, 860, 825A, 875, 895 and 896. +** +**----------------------------------------------------------- +** +** LOAD_ABS (LEN) +** <> +** +** LOAD_REL (LEN) (DSA relative) +** <> +** +**----------------------------------------------------------- +*/ + +#define SCR_REG_OFS2(ofs) (((ofs) & 0xff) << 16ul) +#define SCR_NO_FLUSH2 0x02000000 +#define SCR_DSA_REL2 0x10000000 + +#define SCR_LOAD_R(reg, how, n) \ + (0xe1000000 | how | (SCR_REG_OFS2(REG(reg))) | (n)) + +#define SCR_STORE_R(reg, how, n) \ + (0xe0000000 | how | (SCR_REG_OFS2(REG(reg))) | (n)) + +#define SCR_LOAD_ABS(reg, n) SCR_LOAD_R(reg, SCR_NO_FLUSH2, n) +#define SCR_LOAD_REL(reg, n) SCR_LOAD_R(reg, SCR_NO_FLUSH2|SCR_DSA_REL2, n) +#define SCR_LOAD_ABS_F(reg, n) SCR_LOAD_R(reg, 0, n) +#define SCR_LOAD_REL_F(reg, n) SCR_LOAD_R(reg, SCR_DSA_REL2, n) + +#define SCR_STORE_ABS(reg, n) SCR_STORE_R(reg, SCR_NO_FLUSH2, n) +#define SCR_STORE_REL(reg, n) SCR_STORE_R(reg, SCR_NO_FLUSH2|SCR_DSA_REL2,n) +#define SCR_STORE_ABS_F(reg, n) SCR_STORE_R(reg, 0, n) +#define SCR_STORE_REL_F(reg, n) SCR_STORE_R(reg, SCR_DSA_REL2, n) + + +/*----------------------------------------------------------- +** +** Waiting for Disconnect or Reselect +** +**----------------------------------------------------------- +** +** JUMP [ | IFTRUE/IFFALSE ( ... ) ] +** <
> +** +** JUMPR [ | IFTRUE/IFFALSE ( ... ) ] +** <> +** +** CALL [ | IFTRUE/IFFALSE ( ... ) ] +** <
> +** +** CALLR [ | IFTRUE/IFFALSE ( ... ) ] +** <> +** +** RETURN [ | IFTRUE/IFFALSE ( ... ) ] +** <> +** +** INT [ | IFTRUE/IFFALSE ( ... ) ] +** <> +** +** INT_FLY [ | IFTRUE/IFFALSE ( ... ) ] +** <> +** +** Conditions: +** WHEN (phase) +** IF (phase) +** CARRYSET +** DATA (data, mask) +** +**----------------------------------------------------------- +*/ + +#define SCR_NO_OP 0x80000000 +#define SCR_JUMP 0x80080000 +#define SCR_JUMP64 0x80480000 +#define SCR_JUMPR 0x80880000 +#define SCR_CALL 0x88080000 +#define SCR_CALLR 0x88880000 +#define SCR_RETURN 0x90080000 +#define SCR_INT 0x98080000 +#define SCR_INT_FLY 0x98180000 + +#define IFFALSE(arg) (0x00080000 | (arg)) +#define IFTRUE(arg) (0x00000000 | (arg)) + +#define WHEN(phase) (0x00030000 | (phase)) +#define IF(phase) (0x00020000 | (phase)) + +#define DATA(D) (0x00040000 | ((D) & 0xff)) +#define MASK(D,M) (0x00040000 | (((M ^ 0xff) & 0xff) << 8ul)|((D) & 0xff)) + +#define CARRYSET (0x00200000) + +/*----------------------------------------------------------- +** +** SCSI constants. +** +**----------------------------------------------------------- +*/ + +/* +** Messages +*/ + +#define M_COMPLETE COMMAND_COMPLETE +#define M_EXTENDED EXTENDED_MESSAGE +#define M_SAVE_DP SAVE_POINTERS +#define M_RESTORE_DP RESTORE_POINTERS +#define M_DISCONNECT DISCONNECT +#define M_ID_ERROR INITIATOR_ERROR +#define M_ABORT ABORT_TASK_SET +#define M_REJECT MESSAGE_REJECT +#define M_NOOP NOP +#define M_PARITY MSG_PARITY_ERROR +#define M_LCOMPLETE LINKED_CMD_COMPLETE +#define M_FCOMPLETE LINKED_FLG_CMD_COMPLETE +#define M_RESET TARGET_RESET +#define M_ABORT_TAG ABORT_TASK +#define M_CLEAR_QUEUE CLEAR_TASK_SET +#define M_INIT_REC INITIATE_RECOVERY +#define M_REL_REC RELEASE_RECOVERY +#define M_TERMINATE (0x11) +#define M_SIMPLE_TAG SIMPLE_QUEUE_TAG +#define M_HEAD_TAG HEAD_OF_QUEUE_TAG +#define M_ORDERED_TAG ORDERED_QUEUE_TAG +#define M_IGN_RESIDUE IGNORE_WIDE_RESIDUE +#define M_IDENTIFY (0x80) + +#define M_X_MODIFY_DP EXTENDED_MODIFY_DATA_POINTER +#define M_X_SYNC_REQ EXTENDED_SDTR +#define M_X_WIDE_REQ EXTENDED_WDTR +#define M_X_PPR_REQ EXTENDED_PPR + +/* +** Status +*/ + +#define S_GOOD (0x00) +#define S_CHECK_COND (0x02) +#define S_COND_MET (0x04) +#define S_BUSY (0x08) +#define S_INT (0x10) +#define S_INT_COND_MET (0x14) +#define S_CONFLICT (0x18) +#define S_TERMINATED (0x20) +#define S_QUEUE_FULL (0x28) +#define S_ILLEGAL (0xff) +#define S_SENSE (0x80) + +/* + * End of ncrreg from FreeBSD + */ + +#endif /* defined SYM53C8XX_DEFS_H */ diff --git a/trunk/drivers/serial/serial_cs.c b/trunk/drivers/serial/serial_cs.c index 96969cb960a9..7ce0c7e66d37 100644 --- a/trunk/drivers/serial/serial_cs.c +++ b/trunk/drivers/serial/serial_cs.c @@ -114,7 +114,15 @@ struct serial_cfg_mem { static void serial_config(dev_link_t * link); +static int serial_event(event_t event, int priority, + event_callback_args_t * args); +static dev_info_t dev_info = "serial_cs"; + +static dev_link_t *serial_attach(void); +static void serial_detach(dev_link_t *); + +static dev_link_t *dev_list = NULL; /*====================================================================== @@ -151,9 +159,8 @@ static void serial_remove(dev_link_t *link) } } -static int serial_suspend(struct pcmcia_device *dev) +static void serial_suspend(dev_link_t *link) { - dev_link_t *link = dev_to_instance(dev); link->state |= DEV_SUSPEND; if (link->state & DEV_CONFIG) { @@ -166,13 +173,10 @@ static int serial_suspend(struct pcmcia_device *dev) if (!info->slave) pcmcia_release_configuration(link->handle); } - - return 0; } -static int serial_resume(struct pcmcia_device *dev) +static void serial_resume(dev_link_t *link) { - dev_link_t *link = dev_to_instance(dev); link->state &= ~DEV_SUSPEND; if (DEV_OK(link)) { @@ -185,8 +189,6 @@ static int serial_resume(struct pcmcia_device *dev) for (i = 0; i < info->ndev; i++) serial8250_resume_port(info->line[i]); } - - return 0; } /*====================================================================== @@ -197,17 +199,19 @@ static int serial_resume(struct pcmcia_device *dev) ======================================================================*/ -static int serial_probe(struct pcmcia_device *p_dev) +static dev_link_t *serial_attach(void) { struct serial_info *info; + client_reg_t client_reg; dev_link_t *link; + int ret; DEBUG(0, "serial_attach()\n"); /* Create new serial device */ info = kmalloc(sizeof (*info), GFP_KERNEL); if (!info) - return -ENOMEM; + return NULL; memset(info, 0, sizeof (*info)); link = &info->link; link->priv = info; @@ -223,12 +227,20 @@ static int serial_probe(struct pcmcia_device *p_dev) } link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - serial_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + serial_detach(link); + return NULL; + } - return 0; + return link; } /*====================================================================== @@ -240,13 +252,21 @@ static int serial_probe(struct pcmcia_device *p_dev) ======================================================================*/ -static void serial_detach(struct pcmcia_device *p_dev) +static void serial_detach(dev_link_t * link) { - dev_link_t *link = dev_to_instance(p_dev); struct serial_info *info = link->priv; + dev_link_t **linkp; + int ret; DEBUG(0, "serial_detach(0x%p)\n", link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + if (*linkp == NULL) + return; + /* * Ensure any outstanding scheduled tasks are completed. */ @@ -257,7 +277,14 @@ static void serial_detach(struct pcmcia_device *p_dev) */ serial_remove(link); - /* free bits */ + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + + /* Unlink device structure, free bits */ + *linkp = link->next; kfree(info); } @@ -691,6 +718,54 @@ void serial_config(dev_link_t * link) kfree(cfg_mem); } +/*====================================================================== + + The card status event handler. Mostly, this schedules other + stuff to run after an event is received. A CARD_REMOVAL event + also sets some flags to discourage the serial drivers from + talking to the ports. + +======================================================================*/ + +static int +serial_event(event_t event, int priority, event_callback_args_t * args) +{ + dev_link_t *link = args->client_data; + struct serial_info *info = link->priv; + + DEBUG(1, "serial_event(0x%06x)\n", event); + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + serial_remove(link); + break; + + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + serial_config(link); + break; + + case CS_EVENT_PM_SUSPEND: + serial_suspend(link); + break; + + case CS_EVENT_RESET_PHYSICAL: + if ((link->state & DEV_CONFIG) && !info->slave) + pcmcia_release_configuration(link->handle); + break; + + case CS_EVENT_PM_RESUME: + serial_resume(link); + break; + + case CS_EVENT_CARD_RESET: + if (DEV_OK(link) && !info->slave) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } + return 0; +} + static struct pcmcia_device_id serial_ids[] = { PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021), PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a), @@ -802,11 +877,10 @@ static struct pcmcia_driver serial_cs_driver = { .drv = { .name = "serial_cs", }, - .probe = serial_probe, - .remove = serial_detach, + .attach = serial_attach, + .event = serial_event, + .detach = serial_detach, .id_table = serial_ids, - .suspend = serial_suspend, - .resume = serial_resume, }; static int __init init_serial_cs(void) @@ -817,6 +891,7 @@ static int __init init_serial_cs(void) static void __exit exit_serial_cs(void) { pcmcia_unregister_driver(&serial_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_serial_cs); diff --git a/trunk/drivers/telephony/ixj_pcmcia.c b/trunk/drivers/telephony/ixj_pcmcia.c index d3a7b0c3d38b..57c0c6e3fbed 100644 --- a/trunk/drivers/telephony/ixj_pcmcia.c +++ b/trunk/drivers/telephony/ixj_pcmcia.c @@ -34,19 +34,24 @@ typedef struct ixj_info_t { struct ixj *port; } ixj_info_t; -static void ixj_detach(struct pcmcia_device *p_dev); +static dev_link_t *ixj_attach(void); +static void ixj_detach(dev_link_t *); static void ixj_config(dev_link_t * link); static void ixj_cs_release(dev_link_t * link); +static int ixj_event(event_t event, int priority, event_callback_args_t * args); +static dev_info_t dev_info = "ixj_cs"; +static dev_link_t *dev_list = NULL; -static int ixj_attach(struct pcmcia_device *p_dev) +static dev_link_t *ixj_attach(void) { + client_reg_t client_reg; dev_link_t *link; - + int ret; DEBUG(0, "ixj_attach()\n"); /* Create new ixj device */ link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL); if (!link) - return -ENOMEM; + return NULL; memset(link, 0, sizeof(struct dev_link_t)); link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; link->io.Attributes2 = IO_DATA_PATH_WIDTH_8; @@ -56,29 +61,44 @@ static int ixj_attach(struct pcmcia_device *p_dev) link->priv = kmalloc(sizeof(struct ixj_info_t), GFP_KERNEL); if (!link->priv) { kfree(link); - return -ENOMEM; + return NULL; } memset(link->priv, 0, sizeof(struct ixj_info_t)); - - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - ixj_config(link); - - return 0; + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + ixj_detach(link); + return NULL; + } + return link; } -static void ixj_detach(struct pcmcia_device *p_dev) +static void ixj_detach(dev_link_t * link) { - dev_link_t *link = dev_to_instance(p_dev); - + dev_link_t **linkp; + int ret; DEBUG(0, "ixj_detach(0x%p)\n", link); - + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + if (*linkp == NULL) + return; link->state &= ~DEV_RELEASE_PENDING; if (link->state & DEV_CONFIG) ixj_cs_release(link); - + if (link->handle) { + ret = pcmcia_deregister_client(link->handle); + if (ret != CS_SUCCESS) + cs_error(link->handle, DeregisterClient, ret); + } + /* Unlink device structure, free bits */ + *linkp = link->next; kfree(link->priv); kfree(link); } @@ -235,25 +255,37 @@ static void ixj_cs_release(dev_link_t *link) link->state &= ~DEV_CONFIG; } -static int ixj_suspend(struct pcmcia_device *dev) +static int ixj_event(event_t event, int priority, event_callback_args_t * args) { - dev_link_t *link = dev_to_instance(dev); - - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int ixj_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - - link->state &= ~DEV_SUSPEND; - if (DEV_OK(link)) - pcmcia_request_configuration(link->handle, &link->conf); - + dev_link_t *link = args->client_data; + DEBUG(1, "ixj_event(0x%06x)\n", event); + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + link->state |= DEV_RELEASE_PENDING; + ixj_cs_release(link); + } + break; + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + ixj_config(link); + break; + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (DEV_OK(link)) + pcmcia_request_configuration(link->handle, &link->conf); + break; + } return 0; } @@ -268,11 +300,10 @@ static struct pcmcia_driver ixj_driver = { .drv = { .name = "ixj_cs", }, - .probe = ixj_attach, - .remove = ixj_detach, + .attach = ixj_attach, + .event = ixj_event, + .detach = ixj_detach, .id_table = ixj_ids, - .suspend = ixj_suspend, - .resume = ixj_resume, }; static int __init ixj_pcmcia_init(void) @@ -283,6 +314,7 @@ static int __init ixj_pcmcia_init(void) static void ixj_pcmcia_exit(void) { pcmcia_unregister_driver(&ixj_driver); + BUG_ON(dev_list != NULL); } module_init(ixj_pcmcia_init); diff --git a/trunk/drivers/usb/Makefile b/trunk/drivers/usb/Makefile index 3639c3f8d357..a50c2bc506f2 100644 --- a/trunk/drivers/usb/Makefile +++ b/trunk/drivers/usb/Makefile @@ -22,7 +22,6 @@ obj-$(CONFIG_USB_MIDI) += class/ obj-$(CONFIG_USB_PRINTER) += class/ obj-$(CONFIG_USB_STORAGE) += storage/ -obj-$(CONFIG_USB) += storage/ obj-$(CONFIG_USB_AIPTEK) += input/ obj-$(CONFIG_USB_ATI_REMOTE) += input/ diff --git a/trunk/drivers/usb/atm/Kconfig b/trunk/drivers/usb/atm/Kconfig index 550ddfa71a43..f429862e0974 100644 --- a/trunk/drivers/usb/atm/Kconfig +++ b/trunk/drivers/usb/atm/Kconfig @@ -44,19 +44,6 @@ config USB_CXACRU To compile this driver as a module, choose M here: the module will be called cxacru. -config USB_UEAGLEATM - tristate "ADI 930 and eagle USB DSL modem" - depends on USB_ATM - select FW_LOADER - help - Say Y here if you have an ADSL USB modem based on the ADI 930 - or eagle chipset. In order to use your modem you will need to - install firmwares and CMV (Command Management Variables); see - for details. - - To compile this driver as a module, choose M here: the - module will be called ueagle-atm. - config USB_XUSBATM tristate "Other USB DSL modem support" depends on USB_ATM diff --git a/trunk/drivers/usb/atm/Makefile b/trunk/drivers/usb/atm/Makefile index 4c4a776ab1cd..85099718c683 100644 --- a/trunk/drivers/usb/atm/Makefile +++ b/trunk/drivers/usb/atm/Makefile @@ -4,7 +4,6 @@ obj-$(CONFIG_USB_CXACRU) += cxacru.o obj-$(CONFIG_USB_SPEEDTOUCH) += speedtch.o -obj-$(CONFIG_USB_UEAGLEATM) += ueagle-atm.o obj-$(CONFIG_USB_ATM) += usbatm.o obj-$(CONFIG_USB_XUSBATM) += xusbatm.o diff --git a/trunk/drivers/usb/atm/cxacru.c b/trunk/drivers/usb/atm/cxacru.c index af0a41e7870e..9d59dc62e6d2 100644 --- a/trunk/drivers/usb/atm/cxacru.c +++ b/trunk/drivers/usb/atm/cxacru.c @@ -853,6 +853,7 @@ static int cxacru_usb_probe(struct usb_interface *intf, const struct usb_device_ } static struct usb_driver cxacru_usb_driver = { + .owner = THIS_MODULE, .name = cxacru_driver_name, .probe = cxacru_usb_probe, .disconnect = usbatm_usb_disconnect, diff --git a/trunk/drivers/usb/atm/speedtch.c b/trunk/drivers/usb/atm/speedtch.c index b28336148658..d0cbbb7f0385 100644 --- a/trunk/drivers/usb/atm/speedtch.c +++ b/trunk/drivers/usb/atm/speedtch.c @@ -659,6 +659,7 @@ MODULE_DEVICE_TABLE(usb, speedtch_usb_ids); static int speedtch_usb_probe(struct usb_interface *, const struct usb_device_id *); static struct usb_driver speedtch_usb_driver = { + .owner = THIS_MODULE, .name = speedtch_driver_name, .probe = speedtch_usb_probe, .disconnect = usbatm_usb_disconnect, diff --git a/trunk/drivers/usb/atm/ueagle-atm.c b/trunk/drivers/usb/atm/ueagle-atm.c deleted file mode 100644 index 7d2a679989ed..000000000000 --- a/trunk/drivers/usb/atm/ueagle-atm.c +++ /dev/null @@ -1,1820 +0,0 @@ -/*- - * Copyright (c) 2003, 2004 - * Damien Bergamini . All rights reserved. - * - * Copyright (c) 2005 Matthieu Castet - * - * This software is available to you under a choice of one of two - * licenses. You may choose to be licensed under the terms of the GNU - * General Public License (GPL) Version 2, available from the file - * COPYING in the main directory of this source tree, or the - * BSD license below: - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice unmodified, this list of conditions, and the following - * disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * GPL license : - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * - * HISTORY : some part of the code was base on ueagle 1.3 BSD driver, - * Damien Bergamini agree to put his code under a DUAL GPL/BSD license. - * - * The rest of the code was was rewritten from scratch. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "usbatm.h" - -#define EAGLEUSBVERSION "ueagle 1.1" - - -/* - * Debug macros - */ -#define uea_dbg(usb_dev, format, args...) \ - do { \ - if (debug >= 1) \ - dev_dbg(&(usb_dev)->dev, \ - "[ueagle-atm dbg] %s: " format, \ - __FUNCTION__, ##args); \ - } while (0) - -#define uea_vdbg(usb_dev, format, args...) \ - do { \ - if (debug >= 2) \ - dev_dbg(&(usb_dev)->dev, \ - "[ueagle-atm vdbg] " format, ##args); \ - } while (0) - -#define uea_enters(usb_dev) \ - uea_vdbg(usb_dev, "entering %s\n", __FUNCTION__) - -#define uea_leaves(usb_dev) \ - uea_vdbg(usb_dev, "leaving %s\n", __FUNCTION__) - -#define uea_err(usb_dev, format,args...) \ - dev_err(&(usb_dev)->dev ,"[UEAGLE-ATM] " format , ##args) - -#define uea_warn(usb_dev, format,args...) \ - dev_warn(&(usb_dev)->dev ,"[Ueagle-atm] " format, ##args) - -#define uea_info(usb_dev, format,args...) \ - dev_info(&(usb_dev)->dev ,"[ueagle-atm] " format, ##args) - -struct uea_cmvs { - u32 address; - u16 offset; - u32 data; -} __attribute__ ((packed)); - -struct uea_softc { - struct usb_device *usb_dev; - struct usbatm_data *usbatm; - - int modem_index; - unsigned int driver_info; - - int booting; - int reset; - - wait_queue_head_t sync_q; - - struct task_struct *kthread; - u32 data; - wait_queue_head_t cmv_ack_wait; - int cmv_ack; - - struct work_struct task; - u16 pageno; - u16 ovl; - - const struct firmware *dsp_firm; - struct urb *urb_int; - - u8 cmv_function; - u16 cmv_idx; - u32 cmv_address; - u16 cmv_offset; - - /* keep in sync with eaglectl */ - struct uea_stats { - struct { - u32 state; - u32 flags; - u32 mflags; - u32 vidcpe; - u32 vidco; - u32 dsrate; - u32 usrate; - u32 dsunc; - u32 usunc; - u32 dscorr; - u32 uscorr; - u32 txflow; - u32 rxflow; - u32 usattenuation; - u32 dsattenuation; - u32 dsmargin; - u32 usmargin; - u32 firmid; - } phy; - } stats; -}; - -/* - * Elsa IDs - */ -#define ELSA_VID 0x05CC -#define ELSA_PID_PSTFIRM 0x3350 -#define ELSA_PID_PREFIRM 0x3351 - -/* - * Sagem USB IDs - */ -#define EAGLE_VID 0x1110 -#define EAGLE_I_PID_PREFIRM 0x9010 /* Eagle I */ -#define EAGLE_I_PID_PSTFIRM 0x900F /* Eagle I */ - -#define EAGLE_IIC_PID_PREFIRM 0x9024 /* Eagle IIC */ -#define EAGLE_IIC_PID_PSTFIRM 0x9023 /* Eagle IIC */ - -#define EAGLE_II_PID_PREFIRM 0x9022 /* Eagle II */ -#define EAGLE_II_PID_PSTFIRM 0x9021 /* Eagle II */ - -/* - * Eagle III Pid - */ -#define EAGLE_III_PID_PREFIRM 0x9032 /* Eagle III */ -#define EAGLE_III_PID_PSTFIRM 0x9031 /* Eagle III */ - -/* - * USR USB IDs - */ -#define USR_VID 0x0BAF -#define MILLER_A_PID_PREFIRM 0x00F2 -#define MILLER_A_PID_PSTFIRM 0x00F1 -#define MILLER_B_PID_PREFIRM 0x00FA -#define MILLER_B_PID_PSTFIRM 0x00F9 -#define HEINEKEN_A_PID_PREFIRM 0x00F6 -#define HEINEKEN_A_PID_PSTFIRM 0x00F5 -#define HEINEKEN_B_PID_PREFIRM 0x00F8 -#define HEINEKEN_B_PID_PSTFIRM 0x00F7 - -#define PREFIRM 0 -#define PSTFIRM (1<<7) -enum { - ADI930 = 0, - EAGLE_I, - EAGLE_II, - EAGLE_III -}; - -/* macros for both struct usb_device_id and struct uea_softc */ -#define UEA_IS_PREFIRM(x) \ - (!((x)->driver_info & PSTFIRM)) -#define UEA_CHIP_VERSION(x) \ - ((x)->driver_info & 0xf) - -#define IS_ISDN(sc) \ - (le16_to_cpu(sc->usb_dev->descriptor.bcdDevice) & 0x80) - -#define INS_TO_USBDEV(ins) ins->usb_dev - -#define GET_STATUS(data) \ - ((data >> 8) & 0xf) -#define IS_OPERATIONAL(sc) \ - (GET_STATUS(sc->stats.phy.state) == 2) - -/* - * Set of macros to handle unaligned data in the firmware blob. - * The FW_GET_BYTE() macro is provided only for consistency. - */ - -#define FW_GET_BYTE(p) *((__u8 *) (p)) -#define FW_GET_WORD(p) le16_to_cpu(get_unaligned((__le16 *) (p))) -#define FW_GET_LONG(p) le32_to_cpu(get_unaligned((__le32 *) (p))) - -#define FW_DIR "ueagle-atm/" -#define NB_MODEM 4 - -#define BULK_TIMEOUT 300 -#define CTRL_TIMEOUT 1000 - -#define ACK_TIMEOUT msecs_to_jiffies(1500) - -#define UEA_INTR_IFACE_NO 0 -#define UEA_US_IFACE_NO 1 -#define UEA_DS_IFACE_NO 2 - -#define FASTEST_ISO_INTF 8 - -#define UEA_BULK_DATA_PIPE 0x02 -#define UEA_IDMA_PIPE 0x04 -#define UEA_INTR_PIPE 0x04 -#define UEA_ISO_DATA_PIPE 0x08 - -#define UEA_SET_BLOCK 0x0001 -#define UEA_SET_MODE 0x0003 -#define UEA_SET_2183_DATA 0x0004 -#define UEA_SET_TIMEOUT 0x0011 - -#define UEA_LOOPBACK_OFF 0x0002 -#define UEA_LOOPBACK_ON 0x0003 -#define UEA_BOOT_IDMA 0x0006 -#define UEA_START_RESET 0x0007 -#define UEA_END_RESET 0x0008 - -#define UEA_SWAP_MAILBOX (0x3fcd | 0x4000) -#define UEA_MPTX_START (0x3fce | 0x4000) -#define UEA_MPTX_MAILBOX (0x3fd6 | 0x4000) -#define UEA_MPRX_MAILBOX (0x3fdf | 0x4000) - -/* structure describing a block within a DSP page */ -struct block_info { - __le16 wHdr; -#define UEA_BIHDR 0xabcd - __le16 wAddress; - __le16 wSize; - __le16 wOvlOffset; - __le16 wOvl; /* overlay */ - __le16 wLast; -} __attribute__ ((packed)); -#define BLOCK_INFO_SIZE 12 - -/* structure representing a CMV (Configuration and Management Variable) */ -struct cmv { - __le16 wPreamble; -#define PREAMBLE 0x535c - __u8 bDirection; -#define MODEMTOHOST 0x01 -#define HOSTTOMODEM 0x10 - __u8 bFunction; -#define FUNCTION_TYPE(f) ((f) >> 4) -#define MEMACCESS 0x1 -#define ADSLDIRECTIVE 0x7 - -#define FUNCTION_SUBTYPE(f) ((f) & 0x0f) -/* for MEMACCESS */ -#define REQUESTREAD 0x0 -#define REQUESTWRITE 0x1 -#define REPLYREAD 0x2 -#define REPLYWRITE 0x3 -/* for ADSLDIRECTIVE */ -#define KERNELREADY 0x0 -#define MODEMREADY 0x1 - -#define MAKEFUNCTION(t, s) (((t) & 0xf) << 4 | ((s) & 0xf)) - __le16 wIndex; - __le32 dwSymbolicAddress; -#define MAKESA(a, b, c, d) \ - (((c) & 0xff) << 24 | \ - ((d) & 0xff) << 16 | \ - ((a) & 0xff) << 8 | \ - ((b) & 0xff)) - -#define SA_CNTL MAKESA('C', 'N', 'T', 'L') -#define SA_DIAG MAKESA('D', 'I', 'A', 'G') -#define SA_INFO MAKESA('I', 'N', 'F', 'O') -#define SA_OPTN MAKESA('O', 'P', 'T', 'N') -#define SA_RATE MAKESA('R', 'A', 'T', 'E') -#define SA_STAT MAKESA('S', 'T', 'A', 'T') - __le16 wOffsetAddress; - __le32 dwData; -} __attribute__ ((packed)); -#define CMV_SIZE 16 - -/* structure representing swap information */ -struct swap_info { - __u8 bSwapPageNo; - __u8 bOvl; /* overlay */ -} __attribute__ ((packed)); - -/* structure representing interrupt data */ -struct intr_pkt { - __u8 bType; - __u8 bNotification; - __le16 wValue; - __le16 wIndex; - __le16 wLength; - __le16 wInterrupt; -#define INT_LOADSWAPPAGE 0x0001 -#define INT_INCOMINGCMV 0x0002 - union { - struct { - struct swap_info swapinfo; - __le16 wDataSize; - } __attribute__ ((packed)) s1; - - struct { - struct cmv cmv; - __le16 wDataSize; - } __attribute__ ((packed)) s2; - } __attribute__ ((packed)) u; -#define bSwapPageNo u.s1.swapinfo.bSwapPageNo -#define bOvl u.s1.swapinfo.bOvl -} __attribute__ ((packed)); -#define INTR_PKT_SIZE 28 - -static struct usb_driver uea_driver; -static DECLARE_MUTEX(uea_semaphore); -static const char *chip_name[] = {"ADI930", "Eagle I", "Eagle II", "Eagle III"}; - -static int modem_index; -static unsigned int debug; -static int sync_wait[NB_MODEM]; -static char *cmv_file[NB_MODEM]; - -module_param(debug, uint, 0644); -MODULE_PARM_DESC(debug, "module debug level (0=off,1=on,2=verbose)"); -module_param_array(sync_wait, bool, NULL, 0644); -MODULE_PARM_DESC(sync_wait, "wait the synchronisation before starting ATM"); -module_param_array(cmv_file, charp, NULL, 0644); -MODULE_PARM_DESC(cmv_file, - "file name with configuration and management variables"); - -#define UPDATE_ATM_STAT(type, val) \ - do { \ - if (sc->usbatm->atm_dev) \ - sc->usbatm->atm_dev->type = val; \ - } while (0) - -/* Firmware loading */ -#define LOAD_INTERNAL 0xA0 -#define F8051_USBCS 0x7f92 - -/** - * uea_send_modem_cmd - Send a command for pre-firmware devices. - */ -static int uea_send_modem_cmd(struct usb_device *usb, - u16 addr, u16 size, u8 * buff) -{ - int ret = -ENOMEM; - u8 *xfer_buff; - - xfer_buff = kmalloc(size, GFP_KERNEL); - if (xfer_buff) { - memcpy(xfer_buff, buff, size); - ret = usb_control_msg(usb, - usb_sndctrlpipe(usb, 0), - LOAD_INTERNAL, - USB_DIR_OUT | USB_TYPE_VENDOR | - USB_RECIP_DEVICE, addr, 0, xfer_buff, - size, CTRL_TIMEOUT); - kfree(xfer_buff); - } - - if (ret < 0) - return ret; - - return (ret == size) ? 0 : -EIO; -} - -static void uea_upload_pre_firmware(const struct firmware *fw_entry, void *context) -{ - struct usb_device *usb = context; - u8 *pfw, value; - u32 crc = 0; - int ret, size; - - uea_enters(usb); - if (!fw_entry) { - uea_err(usb, "firmware is not available\n"); - goto err; - } - - pfw = fw_entry->data; - size = fw_entry->size; - if (size < 4) - goto err_fw_corrupted; - - crc = FW_GET_LONG(pfw); - pfw += 4; - size -= 4; - if (crc32_be(0, pfw, size) != crc) - goto err_fw_corrupted; - - /* - * Start to upload formware : send reset - */ - value = 1; - ret = uea_send_modem_cmd(usb, F8051_USBCS, sizeof(value), &value); - - if (ret < 0) { - uea_err(usb, "modem reset failed with error %d\n", ret); - goto err; - } - - while (size > 3) { - u8 len = FW_GET_BYTE(pfw); - u16 add = FW_GET_WORD(pfw + 1); - - size -= len + 3; - if (size < 0) - goto err_fw_corrupted; - - ret = uea_send_modem_cmd(usb, add, len, pfw + 3); - if (ret < 0) { - uea_err(usb, "uploading firmware data failed " - "with error %d\n", ret); - goto err; - } - pfw += len + 3; - } - - if (size != 0) - goto err_fw_corrupted; - - /* - * Tell the modem we finish : de-assert reset - */ - value = 0; - ret = uea_send_modem_cmd(usb, F8051_USBCS, 1, &value); - if (ret < 0) - uea_err(usb, "modem de-assert failed with error %d\n", ret); - else - uea_info(usb, "firmware uploaded\n"); - - uea_leaves(usb); - return; - -err_fw_corrupted: - uea_err(usb, "firmware is corrupted\n"); -err: - uea_leaves(usb); -} - -/** - * uea_load_firmware - Load usb firmware for pre-firmware devices. - */ -static int uea_load_firmware(struct usb_device *usb, unsigned int ver) -{ - int ret; - char *fw_name = FW_DIR "eagle.fw"; - - uea_enters(usb); - uea_info(usb, "pre-firmware device, uploading firmware\n"); - - switch (ver) { - case ADI930: - fw_name = FW_DIR "adi930.fw"; - break; - case EAGLE_I: - fw_name = FW_DIR "eagleI.fw"; - break; - case EAGLE_II: - fw_name = FW_DIR "eagleII.fw"; - break; - case EAGLE_III: - fw_name = FW_DIR "eagleIII.fw"; - break; - } - - ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev, usb, uea_upload_pre_firmware); - if (ret) - uea_err(usb, "firmware %s is not available\n", fw_name); - else - uea_info(usb, "loading firmware %s\n", fw_name); - - uea_leaves(usb); - return ret; -} - -/* modem management : dsp firmware, send/read CMV, monitoring statistic - */ - -/* - * Make sure that the DSP code provided is safe to use. - */ -static int check_dsp(u8 *dsp, unsigned int len) -{ - u8 pagecount, blockcount; - u16 blocksize; - u32 pageoffset; - unsigned int i, j, p, pp; - - pagecount = FW_GET_BYTE(dsp); - p = 1; - - /* enough space for page offsets? */ - if (p + 4 * pagecount > len) - return 1; - - for (i = 0; i < pagecount; i++) { - - pageoffset = FW_GET_LONG(dsp + p); - p += 4; - - if (pageoffset == 0) - continue; - - /* enough space for blockcount? */ - if (pageoffset >= len) - return 1; - - pp = pageoffset; - blockcount = FW_GET_BYTE(dsp + pp); - pp += 1; - - for (j = 0; j < blockcount; j++) { - - /* enough space for block header? */ - if (pp + 4 > len) - return 1; - - pp += 2; /* skip blockaddr */ - blocksize = FW_GET_WORD(dsp + pp); - pp += 2; - - /* enough space for block data? */ - if (pp + blocksize > len) - return 1; - - pp += blocksize; - } - } - - return 0; -} - -/* - * send data to the idma pipe - * */ -static int uea_idma_write(struct uea_softc *sc, void *data, u32 size) -{ - int ret = -ENOMEM; - u8 *xfer_buff; - int bytes_read; - - xfer_buff = kmalloc(size, GFP_KERNEL); - if (!xfer_buff) { - uea_err(INS_TO_USBDEV(sc), "can't allocate xfer_buff\n"); - return ret; - } - - memcpy(xfer_buff, data, size); - - ret = usb_bulk_msg(sc->usb_dev, - usb_sndbulkpipe(sc->usb_dev, UEA_IDMA_PIPE), - xfer_buff, size, &bytes_read, BULK_TIMEOUT); - - kfree(xfer_buff); - if (ret < 0) - return ret; - if (size != bytes_read) { - uea_err(INS_TO_USBDEV(sc), "size != bytes_read %d %d\n", size, - bytes_read); - return -EIO; - } - - return 0; -} - -static int request_dsp(struct uea_softc *sc) -{ - int ret; - char *dsp_name; - - if (UEA_CHIP_VERSION(sc) == ADI930) { - if (IS_ISDN(sc)) - dsp_name = FW_DIR "DSP9i.bin"; - else - dsp_name = FW_DIR "DSP9p.bin"; - } else { - if (IS_ISDN(sc)) - dsp_name = FW_DIR "DSPei.bin"; - else - dsp_name = FW_DIR "DSPep.bin"; - } - - ret = request_firmware(&sc->dsp_firm, - dsp_name, &sc->usb_dev->dev); - if (ret < 0) { - uea_err(INS_TO_USBDEV(sc), - "requesting firmware %s failed with error %d\n", - dsp_name, ret); - return ret; - } - - if (check_dsp(sc->dsp_firm->data, sc->dsp_firm->size)) { - uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", - dsp_name); - release_firmware(sc->dsp_firm); - sc->dsp_firm = NULL; - return -EILSEQ; - } - - return 0; -} - -/* - * The uea_load_page() function must be called within a process context - */ -static void uea_load_page(void *xsc) -{ - struct uea_softc *sc = xsc; - u16 pageno = sc->pageno; - u16 ovl = sc->ovl; - struct block_info bi; - - u8 *p; - u8 pagecount, blockcount; - u16 blockaddr, blocksize; - u32 pageoffset; - int i; - - /* reload firmware when reboot start and it's loaded already */ - if (ovl == 0 && pageno == 0 && sc->dsp_firm) { - release_firmware(sc->dsp_firm); - sc->dsp_firm = NULL; - } - - if (sc->dsp_firm == NULL && request_dsp(sc) < 0) - return; - - p = sc->dsp_firm->data; - pagecount = FW_GET_BYTE(p); - p += 1; - - if (pageno >= pagecount) - goto bad1; - - p += 4 * pageno; - pageoffset = FW_GET_LONG(p); - - if (pageoffset == 0) - goto bad1; - - p = sc->dsp_firm->data + pageoffset; - blockcount = FW_GET_BYTE(p); - p += 1; - - uea_dbg(INS_TO_USBDEV(sc), - "sending %u blocks for DSP page %u\n", blockcount, pageno); - - bi.wHdr = cpu_to_le16(UEA_BIHDR); - bi.wOvl = cpu_to_le16(ovl); - bi.wOvlOffset = cpu_to_le16(ovl | 0x8000); - - for (i = 0; i < blockcount; i++) { - blockaddr = FW_GET_WORD(p); - p += 2; - - blocksize = FW_GET_WORD(p); - p += 2; - - bi.wSize = cpu_to_le16(blocksize); - bi.wAddress = cpu_to_le16(blockaddr); - bi.wLast = cpu_to_le16((i == blockcount - 1) ? 1 : 0); - - /* send block info through the IDMA pipe */ - if (uea_idma_write(sc, &bi, BLOCK_INFO_SIZE)) - goto bad2; - - /* send block data through the IDMA pipe */ - if (uea_idma_write(sc, p, blocksize)) - goto bad2; - - p += blocksize; - } - - return; - -bad2: - uea_err(INS_TO_USBDEV(sc), "sending DSP block %u failed\n", i); - return; -bad1: - uea_err(INS_TO_USBDEV(sc), "invalid DSP page %u requested\n",pageno); -} - -static inline void wake_up_cmv_ack(struct uea_softc *sc) -{ - sc->cmv_ack = 1; - wake_up(&sc->cmv_ack_wait); -} - -static inline int wait_cmv_ack(struct uea_softc *sc) -{ - int ret = wait_event_timeout(sc->cmv_ack_wait, - sc->cmv_ack, ACK_TIMEOUT); - sc->cmv_ack = 0; - - if (ret < 0) - return ret; - - return (ret == 0) ? -ETIMEDOUT : 0; - -} - -#define UCDC_SEND_ENCAPSULATED_COMMAND 0x00 - -static int uea_request(struct uea_softc *sc, - u16 value, u16 index, u16 size, void *data) -{ - u8 *xfer_buff; - int ret = -ENOMEM; - - xfer_buff = kmalloc(size, GFP_KERNEL); - if (!xfer_buff) { - uea_err(INS_TO_USBDEV(sc), "can't allocate xfer_buff\n"); - return ret; - } - memcpy(xfer_buff, data, size); - - ret = usb_control_msg(sc->usb_dev, usb_sndctrlpipe(sc->usb_dev, 0), - UCDC_SEND_ENCAPSULATED_COMMAND, - USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, - value, index, xfer_buff, size, CTRL_TIMEOUT); - - kfree(xfer_buff); - if (ret < 0) { - uea_err(INS_TO_USBDEV(sc), "usb_control_msg error %d\n", ret); - return ret; - } - - if (ret != size) { - uea_err(INS_TO_USBDEV(sc), - "usb_control_msg send only %d bytes (instead of %d)\n", - ret, size); - return -EIO; - } - - return 0; -} - -static int uea_cmv(struct uea_softc *sc, - u8 function, u32 address, u16 offset, u32 data) -{ - struct cmv cmv; - int ret; - - /* we send a request, but we expect a reply */ - sc->cmv_function = function | 0x2; - sc->cmv_idx++; - sc->cmv_address = address; - sc->cmv_offset = offset; - - cmv.wPreamble = cpu_to_le16(PREAMBLE); - cmv.bDirection = HOSTTOMODEM; - cmv.bFunction = function; - cmv.wIndex = cpu_to_le16(sc->cmv_idx); - put_unaligned(cpu_to_le32(address), &cmv.dwSymbolicAddress); - cmv.wOffsetAddress = cpu_to_le16(offset); - put_unaligned(cpu_to_le32(data >> 16 | data << 16), &cmv.dwData); - - ret = uea_request(sc, UEA_SET_BLOCK, UEA_MPTX_START, CMV_SIZE, &cmv); - if (ret < 0) - return ret; - return wait_cmv_ack(sc); -} - -static inline int uea_read_cmv(struct uea_softc *sc, - u32 address, u16 offset, u32 *data) -{ - int ret = uea_cmv(sc, MAKEFUNCTION(MEMACCESS, REQUESTREAD), - address, offset, 0); - if (ret < 0) - uea_err(INS_TO_USBDEV(sc), - "reading cmv failed with error %d\n", ret); - else - *data = sc->data; - - return ret; -} - -static inline int uea_write_cmv(struct uea_softc *sc, - u32 address, u16 offset, u32 data) -{ - int ret = uea_cmv(sc, MAKEFUNCTION(MEMACCESS, REQUESTWRITE), - address, offset, data); - if (ret < 0) - uea_err(INS_TO_USBDEV(sc), - "writing cmv failed with error %d\n", ret); - - return ret; -} - -/* - * Monitor the modem and update the stat - * return 0 if everything is ok - * return < 0 if an error occurs (-EAGAIN reboot needed) - */ -static int uea_stat(struct uea_softc *sc) -{ - u32 data; - int ret; - - uea_enters(INS_TO_USBDEV(sc)); - data = sc->stats.phy.state; - - ret = uea_read_cmv(sc, SA_STAT, 0, &sc->stats.phy.state); - if (ret < 0) - return ret; - - switch (GET_STATUS(sc->stats.phy.state)) { - case 0: /* not yet synchronized */ - uea_dbg(INS_TO_USBDEV(sc), - "modem not yet synchronized\n"); - return 0; - - case 1: /* initialization */ - uea_dbg(INS_TO_USBDEV(sc), "modem initializing\n"); - return 0; - - case 2: /* operational */ - uea_vdbg(INS_TO_USBDEV(sc), "modem operational\n"); - break; - - case 3: /* fail ... */ - uea_info(INS_TO_USBDEV(sc), "modem synchronization failed\n"); - return -EAGAIN; - - case 4 ... 6: /* test state */ - uea_warn(INS_TO_USBDEV(sc), - "modem in test mode - not supported\n"); - return -EAGAIN; - - case 7: /* fast-retain ... */ - uea_info(INS_TO_USBDEV(sc), "modem in fast-retain mode\n"); - return 0; - default: - uea_err(INS_TO_USBDEV(sc), "modem invalid SW mode %d\n", - GET_STATUS(sc->stats.phy.state)); - return -EAGAIN; - } - - if (GET_STATUS(data) != 2) { - uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_OFF, 0, NULL); - uea_info(INS_TO_USBDEV(sc), "modem operational\n"); - - /* release the dsp firmware as it is not needed until - * the next failure - */ - if (sc->dsp_firm) { - release_firmware(sc->dsp_firm); - sc->dsp_firm = NULL; - } - - ret = uea_read_cmv(sc, SA_INFO, 10, &sc->stats.phy.firmid); - if (ret < 0) - return ret; - uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n", - sc->stats.phy.firmid); - } - - /* always update it as atm layer could not be init when we switch to - * operational state - */ - UPDATE_ATM_STAT(signal, ATM_PHY_SIG_FOUND); - - /* wake up processes waiting for synchronization */ - wake_up(&sc->sync_q); - - ret = uea_read_cmv(sc, SA_DIAG, 2, &sc->stats.phy.flags); - if (ret < 0) - return ret; - sc->stats.phy.mflags |= sc->stats.phy.flags; - - /* in case of a flags ( for example delineation LOSS (& 0x10)), - * we check the status again in order to detect the failure earlier - */ - if (sc->stats.phy.flags) { - uea_dbg(INS_TO_USBDEV(sc), "Stat flag = %d\n", - sc->stats.phy.flags); - return 0; - } - - ret = uea_read_cmv(sc, SA_RATE, 0, &data); - if (ret < 0) - return ret; - - /* in bulk mode the modem have problem with high rate - * changing internal timing could improve things, but the - * value is misterious. - * ADI930 don't support it (-EPIPE error). - */ - if (UEA_CHIP_VERSION(sc) != ADI930 - && sc->stats.phy.dsrate != (data >> 16) * 32) { - /* Original timming from ADI(used in windows driver) - * 0x20ffff>>16 * 32 = 32 * 32 = 1Mbits - */ - u16 timeout = (data <= 0x20ffff) ? 0 : 1; - ret = uea_request(sc, UEA_SET_TIMEOUT, timeout, 0, NULL); - uea_info(INS_TO_USBDEV(sc), - "setting new timeout %d%s\n", timeout, - ret < 0?" failed":""); - } - sc->stats.phy.dsrate = (data >> 16) * 32; - sc->stats.phy.usrate = (data & 0xffff) * 32; - UPDATE_ATM_STAT(link_rate, sc->stats.phy.dsrate * 1000 / 424); - - ret = uea_read_cmv(sc, SA_DIAG, 23, &data); - if (ret < 0) - return ret; - sc->stats.phy.dsattenuation = (data & 0xff) / 2; - - ret = uea_read_cmv(sc, SA_DIAG, 47, &data); - if (ret < 0) - return ret; - sc->stats.phy.usattenuation = (data & 0xff) / 2; - - ret = uea_read_cmv(sc, SA_DIAG, 25, &sc->stats.phy.dsmargin); - if (ret < 0) - return ret; - - ret = uea_read_cmv(sc, SA_DIAG, 49, &sc->stats.phy.usmargin); - if (ret < 0) - return ret; - - ret = uea_read_cmv(sc, SA_DIAG, 51, &sc->stats.phy.rxflow); - if (ret < 0) - return ret; - - ret = uea_read_cmv(sc, SA_DIAG, 52, &sc->stats.phy.txflow); - if (ret < 0) - return ret; - - ret = uea_read_cmv(sc, SA_DIAG, 54, &sc->stats.phy.dsunc); - if (ret < 0) - return ret; - - /* only for atu-c */ - ret = uea_read_cmv(sc, SA_DIAG, 58, &sc->stats.phy.usunc); - if (ret < 0) - return ret; - - ret = uea_read_cmv(sc, SA_DIAG, 53, &sc->stats.phy.dscorr); - if (ret < 0) - return ret; - - /* only for atu-c */ - ret = uea_read_cmv(sc, SA_DIAG, 57, &sc->stats.phy.uscorr); - if (ret < 0) - return ret; - - ret = uea_read_cmv(sc, SA_INFO, 8, &sc->stats.phy.vidco); - if (ret < 0) - return ret; - - ret = uea_read_cmv(sc, SA_INFO, 13, &sc->stats.phy.vidcpe); - if (ret < 0) - return ret; - - return 0; -} - -static int request_cmvs(struct uea_softc *sc, - struct uea_cmvs **cmvs, const struct firmware **fw) -{ - int ret, size; - u8 *data; - char *file; - static char cmv_name[256] = FW_DIR; - - if (cmv_file[sc->modem_index] == NULL) { - if (UEA_CHIP_VERSION(sc) == ADI930) - file = (IS_ISDN(sc)) ? "CMV9i.bin" : "CMV9p.bin"; - else - file = (IS_ISDN(sc)) ? "CMVei.bin" : "CMVep.bin"; - } else - file = cmv_file[sc->modem_index]; - - strcpy(cmv_name, FW_DIR); - strlcat(cmv_name, file, sizeof(cmv_name)); - - ret = request_firmware(fw, cmv_name, &sc->usb_dev->dev); - if (ret < 0) { - uea_err(INS_TO_USBDEV(sc), - "requesting firmware %s failed with error %d\n", - cmv_name, ret); - return ret; - } - - data = (u8 *) (*fw)->data; - size = *data * sizeof(struct uea_cmvs) + 1; - if (size != (*fw)->size) { - uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", - cmv_name); - release_firmware(*fw); - return -EILSEQ; - } - - *cmvs = (struct uea_cmvs *)(data + 1); - return *data; -} - -/* Start boot post firmware modem: - * - send reset commands through usb control pipe - * - start workqueue for DSP loading - * - send CMV options to modem - */ - -static int uea_start_reset(struct uea_softc *sc) -{ - u16 zero = 0; /* ;-) */ - int i, len, ret; - struct uea_cmvs *cmvs; - const struct firmware *cmvs_fw; - - uea_enters(INS_TO_USBDEV(sc)); - uea_info(INS_TO_USBDEV(sc), "(re)booting started\n"); - - sc->booting = 1; - UPDATE_ATM_STAT(signal, ATM_PHY_SIG_LOST); - - /* reset statistics */ - memset(&sc->stats, 0, sizeof(struct uea_stats)); - - /* tell the modem that we want to boot in IDMA mode */ - uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL); - uea_request(sc, UEA_SET_MODE, UEA_BOOT_IDMA, 0, NULL); - - /* enter reset mode */ - uea_request(sc, UEA_SET_MODE, UEA_START_RESET, 0, NULL); - - /* original driver use 200ms, but windows driver use 100ms */ - msleep(100); - - /* leave reset mode */ - uea_request(sc, UEA_SET_MODE, UEA_END_RESET, 0, NULL); - - /* clear tx and rx mailboxes */ - uea_request(sc, UEA_SET_2183_DATA, UEA_MPTX_MAILBOX, 2, &zero); - uea_request(sc, UEA_SET_2183_DATA, UEA_MPRX_MAILBOX, 2, &zero); - uea_request(sc, UEA_SET_2183_DATA, UEA_SWAP_MAILBOX, 2, &zero); - - msleep(1000); - sc->cmv_function = MAKEFUNCTION(ADSLDIRECTIVE, MODEMREADY); - sc->booting = 0; - - /* start loading DSP */ - sc->pageno = 0; - sc->ovl = 0; - schedule_work(&sc->task); - - /* wait for modem ready CMV */ - ret = wait_cmv_ack(sc); - if (ret < 0) - return ret; - - /* Enter in R-IDLE (cmv) until instructed otherwise */ - ret = uea_write_cmv(sc, SA_CNTL, 0, 1); - if (ret < 0) - return ret; - - /* get options */ - ret = len = request_cmvs(sc, &cmvs, &cmvs_fw); - if (ret < 0) - return ret; - - /* send options */ - for (i = 0; i < len; i++) { - ret = uea_write_cmv(sc, FW_GET_LONG(&cmvs[i].address), - FW_GET_WORD(&cmvs[i].offset), - FW_GET_LONG(&cmvs[i].data)); - if (ret < 0) - goto out; - } - /* Enter in R-ACT-REQ */ - ret = uea_write_cmv(sc, SA_CNTL, 0, 2); -out: - release_firmware(cmvs_fw); - sc->reset = 0; - uea_leaves(INS_TO_USBDEV(sc)); - return ret; -} - -/* - * In case of an error wait 1s before rebooting the modem - * if the modem don't request reboot (-EAGAIN). - * Monitor the modem every 1s. - */ - -static int uea_kthread(void *data) -{ - struct uea_softc *sc = data; - int ret = -EAGAIN; - - uea_enters(INS_TO_USBDEV(sc)); - while (!kthread_should_stop()) { - if (ret < 0 || sc->reset) - ret = uea_start_reset(sc); - if (!ret) - ret = uea_stat(sc); - if (ret != -EAGAIN) - msleep(1000); - } - uea_leaves(INS_TO_USBDEV(sc)); - return ret; -} - -/* Load second usb firmware for ADI930 chip */ -static int load_XILINX_firmware(struct uea_softc *sc) -{ - const struct firmware *fw_entry; - int ret, size, u, ln; - u8 *pfw, value; - char *fw_name = FW_DIR "930-fpga.bin"; - - uea_enters(INS_TO_USBDEV(sc)); - - ret = request_firmware(&fw_entry, fw_name, &sc->usb_dev->dev); - if (ret) { - uea_err(INS_TO_USBDEV(sc), "firmware %s is not available\n", - fw_name); - goto err0; - } - - pfw = fw_entry->data; - size = fw_entry->size; - if (size != 0x577B) { - uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", - fw_name); - ret = -EILSEQ; - goto err1; - } - for (u = 0; u < size; u += ln) { - ln = min(size - u, 64); - ret = uea_request(sc, 0xe, 0, ln, pfw + u); - if (ret < 0) { - uea_err(INS_TO_USBDEV(sc), - "elsa download data failed (%d)\n", ret); - goto err1; - } - } - - /* finish to send the fpga - */ - ret = uea_request(sc, 0xe, 1, 0, NULL); - if (ret < 0) { - uea_err(INS_TO_USBDEV(sc), - "elsa download data failed (%d)\n", ret); - goto err1; - } - - /* - * Tell the modem we finish : de-assert reset - */ - value = 0; - ret = uea_send_modem_cmd(sc->usb_dev, 0xe, 1, &value); - if (ret < 0) - uea_err(sc->usb_dev, "elsa de-assert failed with error %d\n", ret); - - -err1: - release_firmware(fw_entry); -err0: - uea_leaves(INS_TO_USBDEV(sc)); - return ret; -} - -static void uea_dispatch_cmv(struct uea_softc *sc, struct cmv* cmv) -{ - uea_enters(INS_TO_USBDEV(sc)); - if (le16_to_cpu(cmv->wPreamble) != PREAMBLE) - goto bad1; - - if (cmv->bDirection != MODEMTOHOST) - goto bad1; - - /* FIXME : ADI930 reply wrong preambule (func = 2, sub = 2) to - * the first MEMACESS cmv. Ignore it... - */ - if (cmv->bFunction != sc->cmv_function) { - if (UEA_CHIP_VERSION(sc) == ADI930 - && cmv->bFunction == MAKEFUNCTION(2, 2)) { - cmv->wIndex = cpu_to_le16(sc->cmv_idx); - put_unaligned(cpu_to_le32(sc->cmv_address), &cmv->dwSymbolicAddress); - cmv->wOffsetAddress = cpu_to_le16(sc->cmv_offset); - } - else - goto bad2; - } - - if (cmv->bFunction == MAKEFUNCTION(ADSLDIRECTIVE, MODEMREADY)) { - wake_up_cmv_ack(sc); - return; - } - - /* in case of MEMACCESS */ - if (le16_to_cpu(cmv->wIndex) != sc->cmv_idx || - le32_to_cpu(get_unaligned(&cmv->dwSymbolicAddress)) != - sc->cmv_address - || le16_to_cpu(cmv->wOffsetAddress) != sc->cmv_offset) - goto bad2; - - sc->data = le32_to_cpu(get_unaligned(&cmv->dwData)); - sc->data = sc->data << 16 | sc->data >> 16; - - wake_up_cmv_ack(sc); - return; - -bad2: - uea_err(INS_TO_USBDEV(sc), "unexpected cmv received," - "Function : %d, Subfunction : %d\n", - FUNCTION_TYPE(cmv->bFunction), - FUNCTION_SUBTYPE(cmv->bFunction)); - return; - -bad1: - uea_err(INS_TO_USBDEV(sc), "invalid cmv received, " - "wPreamble %d, bDirection %d\n", - le16_to_cpu(cmv->wPreamble), cmv->bDirection); -} - -/* - * interrupt handler - */ -static void uea_intr(struct urb *urb, struct pt_regs *regs) -{ - struct uea_softc *sc = (struct uea_softc *)urb->context; - struct intr_pkt *intr; - uea_enters(INS_TO_USBDEV(sc)); - - if (urb->status < 0) { - uea_err(INS_TO_USBDEV(sc), "uea_intr() failed with %d\n", - urb->status); - return; - } - - intr = (struct intr_pkt *) urb->transfer_buffer; - - /* device-to-host interrupt */ - if (intr->bType != 0x08 || sc->booting) { - uea_err(INS_TO_USBDEV(sc), "wrong intr\n"); - // rebooting ? - // sc->reset = 1; - goto resubmit; - } - - switch (le16_to_cpu(intr->wInterrupt)) { - case INT_LOADSWAPPAGE: - sc->pageno = intr->bSwapPageNo; - sc->ovl = intr->bOvl >> 4 | intr->bOvl << 4; - schedule_work(&sc->task); - break; - - case INT_INCOMINGCMV: - uea_dispatch_cmv(sc, &intr->u.s2.cmv); - break; - - default: - uea_err(INS_TO_USBDEV(sc), "unknown intr %u\n", - le16_to_cpu(intr->wInterrupt)); - } - -resubmit: - usb_submit_urb(sc->urb_int, GFP_ATOMIC); -} - -/* - * Start the modem : init the data and start kernel thread - */ -static int uea_boot(struct uea_softc *sc) -{ - int ret; - struct intr_pkt *intr; - - uea_enters(INS_TO_USBDEV(sc)); - - INIT_WORK(&sc->task, uea_load_page, sc); - init_waitqueue_head(&sc->sync_q); - init_waitqueue_head(&sc->cmv_ack_wait); - - if (UEA_CHIP_VERSION(sc) == ADI930) - load_XILINX_firmware(sc); - - intr = kmalloc(INTR_PKT_SIZE, GFP_KERNEL); - if (!intr) { - uea_err(INS_TO_USBDEV(sc), - "cannot allocate interrupt package\n"); - uea_leaves(INS_TO_USBDEV(sc)); - return -ENOMEM; - } - - sc->urb_int = usb_alloc_urb(0, GFP_KERNEL); - if (!sc->urb_int) { - uea_err(INS_TO_USBDEV(sc), "cannot allocate interrupt URB\n"); - goto err; - } - - usb_fill_int_urb(sc->urb_int, sc->usb_dev, - usb_rcvintpipe(sc->usb_dev, UEA_INTR_PIPE), - intr, INTR_PKT_SIZE, uea_intr, sc, - sc->usb_dev->actconfig->interface[0]->altsetting[0]. - endpoint[0].desc.bInterval); - - ret = usb_submit_urb(sc->urb_int, GFP_KERNEL); - if (ret < 0) { - uea_err(INS_TO_USBDEV(sc), - "urb submition failed with error %d\n", ret); - goto err1; - } - - sc->kthread = kthread_run(uea_kthread, sc, "ueagle-atm"); - if (sc->kthread == ERR_PTR(-ENOMEM)) { - uea_err(INS_TO_USBDEV(sc), "failed to create thread\n"); - goto err2; - } - - uea_leaves(INS_TO_USBDEV(sc)); - return 0; - -err2: - usb_kill_urb(sc->urb_int); -err1: - kfree(intr); -err: - usb_free_urb(sc->urb_int); - uea_leaves(INS_TO_USBDEV(sc)); - return -ENOMEM; -} - -/* - * Stop the modem : kill kernel thread and free data - */ -static void uea_stop(struct uea_softc *sc) -{ - int ret; - uea_enters(INS_TO_USBDEV(sc)); - ret = kthread_stop(sc->kthread); - uea_info(INS_TO_USBDEV(sc), "kthread finish with status %d\n", ret); - - /* stop any pending boot process */ - flush_scheduled_work(); - - uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL); - - usb_kill_urb(sc->urb_int); - kfree(sc->urb_int->transfer_buffer); - usb_free_urb(sc->urb_int); - - if (sc->dsp_firm) - release_firmware(sc->dsp_firm); - uea_leaves(INS_TO_USBDEV(sc)); -} - -/* syfs interface */ -static struct uea_softc *dev_to_uea(struct device *dev) -{ - struct usb_interface *intf; - struct usbatm_data *usbatm; - - intf = to_usb_interface(dev); - if (!intf) - return NULL; - - usbatm = usb_get_intfdata(intf); - if (!usbatm) - return NULL; - - return usbatm->driver_data; -} - -static ssize_t read_status(struct device *dev, struct device_attribute *attr, - char *buf) -{ - int ret = -ENODEV; - struct uea_softc *sc; - - down(&uea_semaphore); - sc = dev_to_uea(dev); - if (!sc) - goto out; - ret = snprintf(buf, 10, "%08x\n", sc->stats.phy.state); -out: - up(&uea_semaphore); - return ret; -} - -static ssize_t reboot(struct device *dev, struct device_attribute *attr, - const char *buf, size_t count) -{ - int ret = -ENODEV; - struct uea_softc *sc; - - down(&uea_semaphore); - sc = dev_to_uea(dev); - if (!sc) - goto out; - sc->reset = 1; - ret = count; -out: - up(&uea_semaphore); - return ret; -} - -static DEVICE_ATTR(stat_status, S_IWUGO | S_IRUGO, read_status, reboot); - -static ssize_t read_human_status(struct device *dev, struct device_attribute *attr, - char *buf) -{ - int ret = -ENODEV; - struct uea_softc *sc; - - down(&uea_semaphore); - sc = dev_to_uea(dev); - if (!sc) - goto out; - - switch (GET_STATUS(sc->stats.phy.state)) { - case 0: - ret = sprintf(buf, "Modem is booting\n"); - break; - case 1: - ret = sprintf(buf, "Modem is initializing\n"); - break; - case 2: - ret = sprintf(buf, "Modem is operational\n"); - break; - default: - ret = sprintf(buf, "Modem synchronization failed\n"); - break; - } -out: - up(&uea_semaphore); - return ret; -} - -static DEVICE_ATTR(stat_human_status, S_IWUGO | S_IRUGO, read_human_status, NULL); - -static ssize_t read_delin(struct device *dev, struct device_attribute *attr, - char *buf) -{ - int ret = -ENODEV; - struct uea_softc *sc; - - down(&uea_semaphore); - sc = dev_to_uea(dev); - if (!sc) - goto out; - - if (sc->stats.phy.flags & 0x0C00) - ret = sprintf(buf, "ERROR\n"); - else if (sc->stats.phy.flags & 0x0030) - ret = sprintf(buf, "LOSS\n"); - else - ret = sprintf(buf, "GOOD\n"); -out: - up(&uea_semaphore); - return ret; -} - -static DEVICE_ATTR(stat_delin, S_IWUGO | S_IRUGO, read_delin, NULL); - -#define UEA_ATTR(name, reset) \ - \ -static ssize_t read_##name(struct device *dev, \ - struct device_attribute *attr, char *buf) \ -{ \ - int ret = -ENODEV; \ - struct uea_softc *sc; \ - \ - down(&uea_semaphore); \ - sc = dev_to_uea(dev); \ - if (!sc) \ - goto out; \ - ret = snprintf(buf, 10, "%08x\n", sc->stats.phy.name); \ - if (reset) \ - sc->stats.phy.name = 0; \ -out: \ - up(&uea_semaphore); \ - return ret; \ -} \ - \ -static DEVICE_ATTR(stat_##name, S_IRUGO, read_##name, NULL) - -UEA_ATTR(mflags, 1); -UEA_ATTR(vidcpe, 0); -UEA_ATTR(usrate, 0); -UEA_ATTR(dsrate, 0); -UEA_ATTR(usattenuation, 0); -UEA_ATTR(dsattenuation, 0); -UEA_ATTR(usmargin, 0); -UEA_ATTR(dsmargin, 0); -UEA_ATTR(txflow, 0); -UEA_ATTR(rxflow, 0); -UEA_ATTR(uscorr, 0); -UEA_ATTR(dscorr, 0); -UEA_ATTR(usunc, 0); -UEA_ATTR(dsunc, 0); - -/* Retrieve the device End System Identifier (MAC) */ - -#define htoi(x) (isdigit(x) ? x-'0' : toupper(x)-'A'+10) -static int uea_getesi(struct uea_softc *sc, u_char * esi) -{ - unsigned char mac_str[2 * ETH_ALEN + 1]; - int i; - if (usb_string - (sc->usb_dev, sc->usb_dev->descriptor.iSerialNumber, mac_str, - sizeof(mac_str)) != 2 * ETH_ALEN) - return 1; - - for (i = 0; i < ETH_ALEN; i++) - esi[i] = htoi(mac_str[2 * i]) * 16 + htoi(mac_str[2 * i + 1]); - - return 0; -} - -/* ATM stuff */ -static int uea_atm_open(struct usbatm_data *usbatm, struct atm_dev *atm_dev) -{ - struct uea_softc *sc = usbatm->driver_data; - - return uea_getesi(sc, atm_dev->esi); -} - -static int uea_heavy(struct usbatm_data *usbatm, struct usb_interface *intf) -{ - struct uea_softc *sc = usbatm->driver_data; - - wait_event(sc->sync_q, IS_OPERATIONAL(sc)); - - return 0; - -} - -static int claim_interface(struct usb_device *usb_dev, - struct usbatm_data *usbatm, int ifnum) -{ - int ret; - struct usb_interface *intf = usb_ifnum_to_if(usb_dev, ifnum); - - if (!intf) { - uea_err(usb_dev, "interface %d not found\n", ifnum); - return -ENODEV; - } - - ret = usb_driver_claim_interface(&uea_driver, intf, usbatm); - if (ret != 0) - uea_err(usb_dev, "can't claim interface %d, error %d\n", ifnum, - ret); - return ret; -} - -static void create_fs_entries(struct uea_softc *sc, struct usb_interface *intf) -{ - /* sysfs interface */ - device_create_file(&intf->dev, &dev_attr_stat_status); - device_create_file(&intf->dev, &dev_attr_stat_mflags); - device_create_file(&intf->dev, &dev_attr_stat_human_status); - device_create_file(&intf->dev, &dev_attr_stat_delin); - device_create_file(&intf->dev, &dev_attr_stat_vidcpe); - device_create_file(&intf->dev, &dev_attr_stat_usrate); - device_create_file(&intf->dev, &dev_attr_stat_dsrate); - device_create_file(&intf->dev, &dev_attr_stat_usattenuation); - device_create_file(&intf->dev, &dev_attr_stat_dsattenuation); - device_create_file(&intf->dev, &dev_attr_stat_usmargin); - device_create_file(&intf->dev, &dev_attr_stat_dsmargin); - device_create_file(&intf->dev, &dev_attr_stat_txflow); - device_create_file(&intf->dev, &dev_attr_stat_rxflow); - device_create_file(&intf->dev, &dev_attr_stat_uscorr); - device_create_file(&intf->dev, &dev_attr_stat_dscorr); - device_create_file(&intf->dev, &dev_attr_stat_usunc); - device_create_file(&intf->dev, &dev_attr_stat_dsunc); -} - -static int uea_bind(struct usbatm_data *usbatm, struct usb_interface *intf, - const struct usb_device_id *id, int *heavy) -{ - struct usb_device *usb = interface_to_usbdev(intf); - struct uea_softc *sc; - int ret, ifnum = intf->altsetting->desc.bInterfaceNumber; - - uea_enters(usb); - - /* interface 0 is for firmware/monitoring */ - if (ifnum != UEA_INTR_IFACE_NO) - return -ENODEV; - - *heavy = sync_wait[modem_index]; - - /* interface 1 is for outbound traffic */ - ret = claim_interface(usb, usbatm, UEA_US_IFACE_NO); - if (ret < 0) - return ret; - - /* ADI930 has only 2 interfaces and inbound traffic - * is on interface 1 - */ - if (UEA_CHIP_VERSION(id) != ADI930) { - /* interface 2 is for inbound traffic */ - ret = claim_interface(usb, usbatm, UEA_DS_IFACE_NO); - if (ret < 0) - return ret; - } - - sc = kzalloc(sizeof(struct uea_softc), GFP_KERNEL); - if (!sc) { - uea_err(INS_TO_USBDEV(sc), "uea_init: not enough memory !\n"); - return -ENOMEM; - } - - sc->usb_dev = usb; - usbatm->driver_data = sc; - sc->usbatm = usbatm; - sc->modem_index = (modem_index < NB_MODEM) ? modem_index++ : 0; - sc->driver_info = id->driver_info; - - ret = uea_boot(sc); - if (ret < 0) { - kfree(sc); - return ret; - } - - create_fs_entries(sc, intf); - return 0; -} - -static void destroy_fs_entries(struct uea_softc *sc, struct usb_interface *intf) -{ - /* sysfs interface */ - device_remove_file(&intf->dev, &dev_attr_stat_status); - device_remove_file(&intf->dev, &dev_attr_stat_mflags); - device_remove_file(&intf->dev, &dev_attr_stat_human_status); - device_remove_file(&intf->dev, &dev_attr_stat_delin); - device_remove_file(&intf->dev, &dev_attr_stat_vidcpe); - device_remove_file(&intf->dev, &dev_attr_stat_usrate); - device_remove_file(&intf->dev, &dev_attr_stat_dsrate); - device_remove_file(&intf->dev, &dev_attr_stat_usattenuation); - device_remove_file(&intf->dev, &dev_attr_stat_dsattenuation); - device_remove_file(&intf->dev, &dev_attr_stat_usmargin); - device_remove_file(&intf->dev, &dev_attr_stat_dsmargin); - device_remove_file(&intf->dev, &dev_attr_stat_txflow); - device_remove_file(&intf->dev, &dev_attr_stat_rxflow); - device_remove_file(&intf->dev, &dev_attr_stat_uscorr); - device_remove_file(&intf->dev, &dev_attr_stat_dscorr); - device_remove_file(&intf->dev, &dev_attr_stat_usunc); - device_remove_file(&intf->dev, &dev_attr_stat_dsunc); -} - -static void uea_unbind(struct usbatm_data *usbatm, struct usb_interface *intf) -{ - struct uea_softc *sc = usbatm->driver_data; - - destroy_fs_entries(sc, intf); - uea_stop(sc); - kfree(sc); -} - -static struct usbatm_driver uea_usbatm_driver = { - .driver_name = "ueagle-atm", - .owner = THIS_MODULE, - .bind = uea_bind, - .atm_start = uea_atm_open, - .unbind = uea_unbind, - .heavy_init = uea_heavy, - .in = UEA_BULK_DATA_PIPE, - .out = UEA_BULK_DATA_PIPE, -}; - -static int uea_probe(struct usb_interface *intf, const struct usb_device_id *id) -{ - struct usb_device *usb = interface_to_usbdev(intf); - - uea_enters(usb); - uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) : %s\n", - le16_to_cpu(usb->descriptor.idVendor), - le16_to_cpu(usb->descriptor.idProduct), - chip_name[UEA_CHIP_VERSION(id)]); - - usb_reset_device(usb); - - if (UEA_IS_PREFIRM(id)) - return uea_load_firmware(usb, UEA_CHIP_VERSION(id)); - - return usbatm_usb_probe(intf, id, &uea_usbatm_driver); -} - -static void uea_disconnect(struct usb_interface *intf) -{ - struct usb_device *usb = interface_to_usbdev(intf); - int ifnum = intf->altsetting->desc.bInterfaceNumber; - uea_enters(usb); - - /* ADI930 has 2 interfaces and eagle 3 interfaces. - * Pre-firmware device has one interface - */ - if (usb->config->desc.bNumInterfaces != 1 && ifnum == 0) { - down(&uea_semaphore); - usbatm_usb_disconnect(intf); - up(&uea_semaphore); - uea_info(usb, "ADSL device removed\n"); - } - - uea_leaves(usb); -} - -/* - * List of supported VID/PID - */ -static const struct usb_device_id uea_ids[] = { - {USB_DEVICE(ELSA_VID, ELSA_PID_PREFIRM), .driver_info = ADI930 | PREFIRM}, - {USB_DEVICE(ELSA_VID, ELSA_PID_PSTFIRM), .driver_info = ADI930 | PSTFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_I_PID_PREFIRM), .driver_info = EAGLE_I | PREFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_I_PID_PSTFIRM), .driver_info = EAGLE_I | PSTFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_II_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_II_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_IIC_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_IIC_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_III_PID_PREFIRM), .driver_info = EAGLE_III | PREFIRM}, - {USB_DEVICE(EAGLE_VID, EAGLE_III_PID_PSTFIRM), .driver_info = EAGLE_III | PSTFIRM}, - {USB_DEVICE(USR_VID, MILLER_A_PID_PREFIRM), .driver_info = EAGLE_I | PREFIRM}, - {USB_DEVICE(USR_VID, MILLER_A_PID_PSTFIRM), .driver_info = EAGLE_I | PSTFIRM}, - {USB_DEVICE(USR_VID, MILLER_B_PID_PREFIRM), .driver_info = EAGLE_I | PREFIRM}, - {USB_DEVICE(USR_VID, MILLER_B_PID_PSTFIRM), .driver_info = EAGLE_I | PSTFIRM}, - {USB_DEVICE(USR_VID, HEINEKEN_A_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM}, - {USB_DEVICE(USR_VID, HEINEKEN_A_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM}, - {USB_DEVICE(USR_VID, HEINEKEN_B_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM}, - {USB_DEVICE(USR_VID, HEINEKEN_B_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM}, - {} -}; - -/* - * USB driver descriptor - */ -static struct usb_driver uea_driver = { - .name = "ueagle-atm", - .id_table = uea_ids, - .probe = uea_probe, - .disconnect = uea_disconnect, -}; - -MODULE_DEVICE_TABLE(usb, uea_ids); - -/** - * uea_init - Initialize the module. - * Register to USB subsystem - */ -static int __init uea_init(void) -{ - printk(KERN_INFO "[ueagle-atm] driver " EAGLEUSBVERSION " loaded\n"); - - usb_register(&uea_driver); - - return 0; -} - -module_init(uea_init); - -/** - * uea_exit - Destroy module - * Deregister with USB subsystem - */ -static void __exit uea_exit(void) -{ - /* - * This calls automatically the uea_disconnect method if necessary: - */ - usb_deregister(&uea_driver); - - printk(KERN_INFO "[ueagle-atm] driver unloaded\n"); -} - -module_exit(uea_exit); - -MODULE_AUTHOR("Damien Bergamini/Matthieu Castet/Stanislaw W. Gruszka"); -MODULE_DESCRIPTION("ADI 930/Eagle USB ADSL Modem driver"); -MODULE_LICENSE("Dual BSD/GPL"); diff --git a/trunk/drivers/usb/atm/usbatm.c b/trunk/drivers/usb/atm/usbatm.c index 9baa6296fc95..2e6593e6c1bd 100644 --- a/trunk/drivers/usb/atm/usbatm.c +++ b/trunk/drivers/usb/atm/usbatm.c @@ -646,14 +646,14 @@ static void usbatm_destroy_instance(struct kref *kref) kfree(instance); } -static void usbatm_get_instance(struct usbatm_data *instance) +void usbatm_get_instance(struct usbatm_data *instance) { dbg("%s", __func__); kref_get(&instance->refcount); } -static void usbatm_put_instance(struct usbatm_data *instance) +void usbatm_put_instance(struct usbatm_data *instance) { dbg("%s", __func__); diff --git a/trunk/drivers/usb/atm/xusbatm.c b/trunk/drivers/usb/atm/xusbatm.c index 5c76e3aaaa5e..7fe7fb484d10 100644 --- a/trunk/drivers/usb/atm/xusbatm.c +++ b/trunk/drivers/usb/atm/xusbatm.c @@ -140,6 +140,7 @@ static int xusbatm_usb_probe(struct usb_interface *intf, } static struct usb_driver xusbatm_usb_driver = { + .owner = THIS_MODULE, .name = xusbatm_driver_name, .probe = xusbatm_usb_probe, .disconnect = usbatm_usb_disconnect, diff --git a/trunk/drivers/usb/class/audio.c b/trunk/drivers/usb/class/audio.c index 3ad9ee8b84a9..50858273f8d3 100644 --- a/trunk/drivers/usb/class/audio.c +++ b/trunk/drivers/usb/class/audio.c @@ -2732,6 +2732,7 @@ static struct usb_device_id usb_audio_ids [] = { MODULE_DEVICE_TABLE (usb, usb_audio_ids); static struct usb_driver usb_audio_driver = { + .owner = THIS_MODULE, .name = "audio", .probe = usb_audio_probe, .disconnect = usb_audio_disconnect, diff --git a/trunk/drivers/usb/class/cdc-acm.c b/trunk/drivers/usb/class/cdc-acm.c index 248279e44c99..1b4751412970 100644 --- a/trunk/drivers/usb/class/cdc-acm.c +++ b/trunk/drivers/usb/class/cdc-acm.c @@ -6,7 +6,6 @@ * Copyright (c) 1999 Johannes Erdfelt * Copyright (c) 2000 Vojtech Pavlik * Copyright (c) 2004 Oliver Neukum - * Copyright (c) 2005 David Kubicek * * USB Abstract Control Model driver for USB modems and ISDN adapters * @@ -30,7 +29,6 @@ * config we want, sysadmin changes bConfigurationValue in sysfs. * v0.23 - use softirq for rx processing, as needed by tty layer * v0.24 - change probe method to evaluate CDC union descriptor - * v0.25 - downstream tasks paralelized to maximize throughput */ /* @@ -65,15 +63,14 @@ #include #include #include -#include #include "cdc-acm.h" /* * Version Information */ -#define DRIVER_VERSION "v0.25" -#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek" +#define DRIVER_VERSION "v0.23" +#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik" #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters" static struct usb_driver acm_driver; @@ -287,9 +284,7 @@ static void acm_ctrl_irq(struct urb *urb, struct pt_regs *regs) /* data interface returns incoming bytes, or we got unthrottled */ static void acm_read_bulk(struct urb *urb, struct pt_regs *regs) { - struct acm_rb *buf; - struct acm_ru *rcv = urb->context; - struct acm *acm = rcv->instance; + struct acm *acm = urb->context; dbg("Entering acm_read_bulk with status %d\n", urb->status); if (!ACM_READY(acm)) @@ -298,109 +293,49 @@ static void acm_read_bulk(struct urb *urb, struct pt_regs *regs) if (urb->status) dev_dbg(&acm->data->dev, "bulk rx status %d\n", urb->status); - buf = rcv->buffer; - buf->size = urb->actual_length; - - spin_lock(&acm->read_lock); - list_add_tail(&rcv->list, &acm->spare_read_urbs); - list_add_tail(&buf->list, &acm->filled_read_bufs); - spin_unlock(&acm->read_lock); - - tasklet_schedule(&acm->urb_task); + /* calling tty_flip_buffer_push() in_irq() isn't allowed */ + tasklet_schedule(&acm->bh); } static void acm_rx_tasklet(unsigned long _acm) { struct acm *acm = (void *)_acm; - struct acm_rb *buf; + struct urb *urb = acm->readurb; struct tty_struct *tty = acm->tty; - struct acm_ru *rcv; - //unsigned long flags; + unsigned char *data = urb->transfer_buffer; int i = 0; dbg("Entering acm_rx_tasklet"); - if (!ACM_READY(acm) || acm->throttle) - return; - -next_buffer: - spin_lock(&acm->read_lock); - if (list_empty(&acm->filled_read_bufs)) { - spin_unlock(&acm->read_lock); - goto urbs; + if (urb->actual_length > 0 && !acm->throttle) { + for (i = 0; i < urb->actual_length && !acm->throttle; i++) { + /* if we insert more than TTY_FLIPBUF_SIZE characters, + * we drop them. */ + if (tty->flip.count >= TTY_FLIPBUF_SIZE) { + tty_flip_buffer_push(tty); + } + tty_insert_flip_char(tty, data[i], 0); + } + dbg("Handed %d bytes to tty layer", i+1); + tty_flip_buffer_push(tty); } - buf = list_entry(acm->filled_read_bufs.next, - struct acm_rb, list); - list_del(&buf->list); - spin_unlock(&acm->read_lock); - - dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d\n", buf, buf->size); - - for (i = 0; i < buf->size && !acm->throttle; i++) { - /* if we insert more than TTY_FLIPBUF_SIZE characters, - we drop them. */ - if (tty->flip.count >= TTY_FLIPBUF_SIZE) { - tty_flip_buffer_push(tty); - } - tty_insert_flip_char(tty, buf->base[i], 0); - } - tty_flip_buffer_push(tty); spin_lock(&acm->throttle_lock); if (acm->throttle) { dbg("Throtteling noticed"); - memmove(buf->base, buf->base + i, buf->size - i); - buf->size -= i; + memmove(data, data + i, urb->actual_length - i); + urb->actual_length -= i; + acm->resubmit_to_unthrottle = 1; spin_unlock(&acm->throttle_lock); - spin_lock(&acm->read_lock); - list_add(&buf->list, &acm->filled_read_bufs); - spin_unlock(&acm->read_lock); return; } spin_unlock(&acm->throttle_lock); - spin_lock(&acm->read_lock); - list_add(&buf->list, &acm->spare_read_bufs); - spin_unlock(&acm->read_lock); - goto next_buffer; - -urbs: - while (!list_empty(&acm->spare_read_bufs)) { - spin_lock(&acm->read_lock); - if (list_empty(&acm->spare_read_urbs)) { - spin_unlock(&acm->read_lock); - return; - } - rcv = list_entry(acm->spare_read_urbs.next, - struct acm_ru, list); - list_del(&rcv->list); - spin_unlock(&acm->read_lock); - - buf = list_entry(acm->spare_read_bufs.next, - struct acm_rb, list); - list_del(&buf->list); - - rcv->buffer = buf; - - usb_fill_bulk_urb(rcv->urb, acm->dev, - acm->rx_endpoint, - buf->base, - acm->readsize, - acm_read_bulk, rcv); - rcv->urb->transfer_dma = buf->dma; - rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - - dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p\n", rcv->urb, rcv, buf); - - /* This shouldn't kill the driver as unsuccessful URBs are returned to the - free-urbs-pool and resubmited ASAP */ - if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) { - list_add(&buf->list, &acm->spare_read_bufs); - spin_lock(&acm->read_lock); - list_add(&rcv->list, &acm->spare_read_urbs); - spin_unlock(&acm->read_lock); - return; - } - } + urb->actual_length = 0; + urb->dev = acm->dev; + + i = usb_submit_urb(urb, GFP_ATOMIC); + if (i) + dev_dbg(&acm->data->dev, "bulk rx resubmit %d\n", i); } /* data interface wrote those outgoing bytes */ @@ -434,7 +369,6 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp) { struct acm *acm; int rv = -EINVAL; - int i; dbg("Entering acm_tty_open.\n"); down(&open_sem); @@ -448,9 +382,7 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp) tty->driver_data = acm; acm->tty = tty; - /* force low_latency on so that our tty_push actually forces the data through, - otherwise it is scheduled, and with high data rates data can get lost. */ - tty->low_latency = 1; + if (acm->used++) { goto done; @@ -462,20 +394,18 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp) goto bail_out; } + acm->readurb->dev = acm->dev; + if (usb_submit_urb(acm->readurb, GFP_KERNEL)) { + dbg("usb_submit_urb(read bulk) failed"); + goto bail_out_and_unlink; + } + if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS)) goto full_bailout; - INIT_LIST_HEAD(&acm->spare_read_urbs); - INIT_LIST_HEAD(&acm->spare_read_bufs); - INIT_LIST_HEAD(&acm->filled_read_bufs); - for (i = 0; i < ACM_NRU; i++) { - list_add(&(acm->ru[i].list), &acm->spare_read_urbs); - } - for (i = 0; i < ACM_NRB; i++) { - list_add(&(acm->rb[i].list), &acm->spare_read_bufs); - } - - tasklet_schedule(&acm->urb_task); + /* force low_latency on so that our tty_push actually forces the data through, + otherwise it is scheduled, and with high data rates data can get lost. */ + tty->low_latency = 1; done: err_out: @@ -483,6 +413,8 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp) return rv; full_bailout: + usb_kill_urb(acm->readurb); +bail_out_and_unlink: usb_kill_urb(acm->ctrlurb); bail_out: acm->used--; @@ -492,22 +424,18 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp) static void acm_tty_unregister(struct acm *acm) { - int i; - tty_unregister_device(acm_tty_driver, acm->minor); usb_put_intf(acm->control); acm_table[acm->minor] = NULL; usb_free_urb(acm->ctrlurb); + usb_free_urb(acm->readurb); usb_free_urb(acm->writeurb); - for (i = 0; i < ACM_NRU; i++) - usb_free_urb(acm->ru[i].urb); kfree(acm); } static void acm_tty_close(struct tty_struct *tty, struct file *filp) { struct acm *acm = tty->driver_data; - int i; if (!acm || !acm->used) return; @@ -518,8 +446,7 @@ static void acm_tty_close(struct tty_struct *tty, struct file *filp) acm_set_control(acm, acm->ctrlout = 0); usb_kill_urb(acm->ctrlurb); usb_kill_urb(acm->writeurb); - for (i = 0; i < ACM_NRU; i++) - usb_kill_urb(acm->ru[i].urb); + usb_kill_urb(acm->readurb); } else acm_tty_unregister(acm); } @@ -601,7 +528,10 @@ static void acm_tty_unthrottle(struct tty_struct *tty) spin_lock_bh(&acm->throttle_lock); acm->throttle = 0; spin_unlock_bh(&acm->throttle_lock); - tasklet_schedule(&acm->urb_task); + if (acm->resubmit_to_unthrottle) { + acm->resubmit_to_unthrottle = 0; + acm_read_bulk(acm->readurb, NULL); + } } static void acm_tty_break_ctl(struct tty_struct *tty, int state) @@ -658,7 +588,7 @@ static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int return -ENOIOCTLCMD; } -static const __u32 acm_tty_speed[] = { +static __u32 acm_tty_speed[] = { 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 230400, 460800, 500000, 576000, @@ -666,7 +596,7 @@ static const __u32 acm_tty_speed[] = { 2500000, 3000000, 3500000, 4000000 }; -static const __u8 acm_tty_size[] = { +static __u8 acm_tty_size[] = { 5, 6, 7, 8 }; @@ -764,7 +694,6 @@ static int acm_probe (struct usb_interface *intf, int call_interface_num = -1; int data_interface_num; unsigned long quirks; - int i; /* handle quirks deadly to normal probing*/ quirks = (unsigned long)id->driver_info; @@ -904,7 +833,7 @@ static int acm_probe (struct usb_interface *intf, } ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize); - readsize = le16_to_cpu(epread->wMaxPacketSize)*2; + readsize = le16_to_cpu(epread->wMaxPacketSize); acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize); acm->control = control_interface; acm->data = data_interface; @@ -913,14 +842,12 @@ static int acm_probe (struct usb_interface *intf, acm->ctrl_caps = ac_management_function; acm->ctrlsize = ctrlsize; acm->readsize = readsize; - acm->urb_task.func = acm_rx_tasklet; - acm->urb_task.data = (unsigned long) acm; + acm->bh.func = acm_rx_tasklet; + acm->bh.data = (unsigned long) acm; INIT_WORK(&acm->work, acm_softint, acm); spin_lock_init(&acm->throttle_lock); spin_lock_init(&acm->write_lock); - spin_lock_init(&acm->read_lock); acm->write_ready = 1; - acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress); buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); if (!buf) { @@ -929,6 +856,13 @@ static int acm_probe (struct usb_interface *intf, } acm->ctrl_buffer = buf; + buf = usb_buffer_alloc(usb_dev, readsize, GFP_KERNEL, &acm->read_dma); + if (!buf) { + dev_dbg(&intf->dev, "out of memory (read buffer alloc)\n"); + goto alloc_fail3; + } + acm->read_buffer = buf; + if (acm_write_buffers_alloc(acm) < 0) { dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n"); goto alloc_fail4; @@ -939,25 +873,10 @@ static int acm_probe (struct usb_interface *intf, dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n"); goto alloc_fail5; } - for (i = 0; i < ACM_NRU; i++) { - struct acm_ru *rcv = &(acm->ru[i]); - - if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) { - dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n"); - goto alloc_fail7; - } - - rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - rcv->instance = acm; - } - for (i = 0; i < ACM_NRB; i++) { - struct acm_rb *buf = &(acm->rb[i]); - - // Using usb_buffer_alloc instead of kmalloc as Oliver suggested - if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) { - dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n"); - goto alloc_fail7; - } + acm->readurb = usb_alloc_urb(0, GFP_KERNEL); + if (!acm->readurb) { + dev_dbg(&intf->dev, "out of memory (readurb kmalloc)\n"); + goto alloc_fail6; } acm->writeurb = usb_alloc_urb(0, GFP_KERNEL); if (!acm->writeurb) { @@ -970,9 +889,15 @@ static int acm_probe (struct usb_interface *intf, acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; acm->ctrlurb->transfer_dma = acm->ctrl_dma; + usb_fill_bulk_urb(acm->readurb, usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress), + acm->read_buffer, readsize, acm_read_bulk, acm); + acm->readurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP; + acm->readurb->transfer_dma = acm->read_dma; + usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), NULL, acm->writesize, acm_write_bulk, acm); acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP; + /* acm->writeurb->transfer_dma = 0; */ dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor); @@ -992,14 +917,14 @@ static int acm_probe (struct usb_interface *intf, return 0; alloc_fail7: - for (i = 0; i < ACM_NRB; i++) - usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma); - for (i = 0; i < ACM_NRU; i++) - usb_free_urb(acm->ru[i].urb); + usb_free_urb(acm->readurb); +alloc_fail6: usb_free_urb(acm->ctrlurb); alloc_fail5: acm_write_buffers_free(acm); alloc_fail4: + usb_buffer_free(usb_dev, readsize, acm->read_buffer, acm->read_dma); +alloc_fail3: usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); alloc_fail2: kfree(acm); @@ -1011,7 +936,6 @@ static void acm_disconnect(struct usb_interface *intf) { struct acm *acm = usb_get_intfdata (intf); struct usb_device *usb_dev = interface_to_usbdev(intf); - int i; if (!acm || !acm->dev) { dbg("disconnect on nonexisting interface"); @@ -1022,24 +946,15 @@ static void acm_disconnect(struct usb_interface *intf) acm->dev = NULL; usb_set_intfdata (intf, NULL); - tasklet_disable(&acm->urb_task); - usb_kill_urb(acm->ctrlurb); + usb_kill_urb(acm->readurb); usb_kill_urb(acm->writeurb); - for (i = 0; i < ACM_NRU; i++) - usb_kill_urb(acm->ru[i].urb); - - INIT_LIST_HEAD(&acm->filled_read_bufs); - INIT_LIST_HEAD(&acm->spare_read_bufs); - - tasklet_enable(&acm->urb_task); flush_scheduled_work(); /* wait for acm_softint */ acm_write_buffers_free(acm); + usb_buffer_free(usb_dev, acm->readsize, acm->read_buffer, acm->read_dma); usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); - for (i = 0; i < ACM_NRB; i++) - usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma); usb_driver_release_interface(&acm_driver, acm->data); @@ -1088,6 +1003,7 @@ static struct usb_device_id acm_ids[] = { MODULE_DEVICE_TABLE (usb, acm_ids); static struct usb_driver acm_driver = { + .owner = THIS_MODULE, .name = "cdc_acm", .probe = acm_probe, .disconnect = acm_disconnect, diff --git a/trunk/drivers/usb/class/cdc-acm.h b/trunk/drivers/usb/class/cdc-acm.h index fd2aaccdcbac..963a5dfd2096 100644 --- a/trunk/drivers/usb/class/cdc-acm.h +++ b/trunk/drivers/usb/class/cdc-acm.h @@ -59,9 +59,6 @@ * when processing onlcr, so we only need 2 buffers. */ #define ACM_NWB 2 -#define ACM_NRU 16 -#define ACM_NRB 16 - struct acm_wb { unsigned char *buf; dma_addr_t dmah; @@ -69,43 +66,22 @@ struct acm_wb { int use; }; -struct acm_rb { - struct list_head list; - int size; - unsigned char *base; - dma_addr_t dma; -}; - -struct acm_ru { - struct list_head list; - struct acm_rb *buffer; - struct urb *urb; - struct acm *instance; -}; - struct acm { struct usb_device *dev; /* the corresponding usb device */ struct usb_interface *control; /* control interface */ struct usb_interface *data; /* data interface */ struct tty_struct *tty; /* the corresponding tty */ - struct urb *ctrlurb, *writeurb; /* urbs */ - u8 *ctrl_buffer; /* buffers of urbs */ - dma_addr_t ctrl_dma; /* dma handles of buffers */ + struct urb *ctrlurb, *readurb, *writeurb; /* urbs */ + u8 *ctrl_buffer, *read_buffer; /* buffers of urbs */ + dma_addr_t ctrl_dma, read_dma; /* dma handles of buffers */ struct acm_wb wb[ACM_NWB]; - struct acm_ru ru[ACM_NRU]; - struct acm_rb rb[ACM_NRB]; - int rx_endpoint; - spinlock_t read_lock; - struct list_head spare_read_urbs; - struct list_head spare_read_bufs; - struct list_head filled_read_bufs; int write_current; /* current write buffer */ int write_used; /* number of non-empty write buffers */ int write_ready; /* write urb is not running */ spinlock_t write_lock; struct usb_cdc_line_coding line; /* bits, stop, parity */ struct work_struct work; /* work queue entry for line discipline waking up */ - struct tasklet_struct urb_task; /* rx processing */ + struct tasklet_struct bh; /* rx processing */ spinlock_t throttle_lock; /* synchronize throtteling and read callback */ unsigned int ctrlin; /* input control lines (DCD, DSR, RI, break, overruns) */ unsigned int ctrlout; /* output control lines (DTR, RTS) */ @@ -115,6 +91,7 @@ struct acm { unsigned int minor; /* acm minor number */ unsigned char throttle; /* throttled by tty layer */ unsigned char clocal; /* termios CLOCAL */ + unsigned char resubmit_to_unthrottle; /* throtteling has disabled the read urb */ unsigned int ctrl_caps; /* control capabilities from the class specific header */ }; diff --git a/trunk/drivers/usb/class/usb-midi.c b/trunk/drivers/usb/class/usb-midi.c index f13f004d311f..5f8af35e7633 100644 --- a/trunk/drivers/usb/class/usb-midi.c +++ b/trunk/drivers/usb/class/usb-midi.c @@ -2027,6 +2027,7 @@ static struct usb_device_id id_table[] = { }; static struct usb_driver usb_midi_driver = { + .owner = THIS_MODULE, .name = "midi", .probe = usb_midi_probe, .disconnect = usb_midi_disconnect, diff --git a/trunk/drivers/usb/class/usblp.c b/trunk/drivers/usb/class/usblp.c index dba4cc026077..357e75335f17 100644 --- a/trunk/drivers/usb/class/usblp.c +++ b/trunk/drivers/usb/class/usblp.c @@ -3,7 +3,7 @@ * * Copyright (c) 1999 Michael Gee * Copyright (c) 1999 Pavel Machek - * Copyright (c) 2000 Randy Dunlap + * Copyright (c) 2000 Randy Dunlap * Copyright (c) 2000 Vojtech Pavlik # Copyright (c) 2001 Pete Zaitcev # Copyright (c) 2001 David Paschal @@ -199,7 +199,7 @@ struct quirk_printer_struct { #define USBLP_QUIRK_BIDIR 0x1 /* reports bidir but requires unidirectional mode (no INs/reads) */ #define USBLP_QUIRK_USB_INIT 0x2 /* needs vendor USB init string */ -static const struct quirk_printer_struct quirk_printers[] = { +static struct quirk_printer_struct quirk_printers[] = { { 0x03f0, 0x0004, USBLP_QUIRK_BIDIR }, /* HP DeskJet 895C */ { 0x03f0, 0x0104, USBLP_QUIRK_BIDIR }, /* HP DeskJet 880C */ { 0x03f0, 0x0204, USBLP_QUIRK_BIDIR }, /* HP DeskJet 815C */ @@ -301,7 +301,7 @@ static void usblp_bulk_write(struct urb *urb, struct pt_regs *regs) * Get and print printer errors. */ -static const char *usblp_messages[] = { "ok", "out of paper", "off-line", "on fire" }; +static char *usblp_messages[] = { "ok", "out of paper", "off-line", "on fire" }; static int usblp_check_status(struct usblp *usblp, int err) { @@ -438,7 +438,7 @@ static unsigned int usblp_poll(struct file *file, struct poll_table_struct *wait | (!usblp->wcomplete ? 0 : POLLOUT | POLLWRNORM); } -static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +static int usblp_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { struct usblp *usblp = file->private_data; int length, err, i; @@ -838,8 +838,7 @@ static struct file_operations usblp_fops = { .read = usblp_read, .write = usblp_write, .poll = usblp_poll, - .unlocked_ioctl = usblp_ioctl, - .compat_ioctl = usblp_ioctl, + .ioctl = usblp_ioctl, .open = usblp_open, .release = usblp_release, }; @@ -850,20 +849,6 @@ static struct usb_class_driver usblp_class = { .minor_base = USBLP_MINOR_BASE, }; -static ssize_t usblp_show_ieee1284_id(struct device *dev, struct device_attribute *attr, char *buf) -{ - struct usb_interface *intf = to_usb_interface(dev); - struct usblp *usblp = usb_get_intfdata (intf); - - if (usblp->device_id_string[0] == 0 && - usblp->device_id_string[1] == 0) - return 0; - - return sprintf(buf, "%s", usblp->device_id_string+2); -} - -static DEVICE_ATTR(ieee1284_id, S_IRUGO, usblp_show_ieee1284_id, NULL); - static int usblp_probe(struct usb_interface *intf, const struct usb_device_id *id) { @@ -948,12 +933,20 @@ static int usblp_probe(struct usb_interface *intf, /* Retrieve and store the device ID string. */ usblp_cache_device_id_string(usblp); - device_create_file(&intf->dev, &dev_attr_ieee1284_id); #ifdef DEBUG usblp_check_status(usblp, 0); #endif + info("usblp%d: USB %sdirectional printer dev %d " + "if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X", + usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum, + usblp->ifnum, + usblp->protocol[usblp->current_protocol].alt_setting, + usblp->current_protocol, + le16_to_cpu(usblp->dev->descriptor.idVendor), + le16_to_cpu(usblp->dev->descriptor.idProduct)); + usb_set_intfdata (intf, usblp); usblp->present = 1; @@ -964,20 +957,11 @@ static int usblp_probe(struct usb_interface *intf, goto abort_intfdata; } usblp->minor = intf->minor; - info("usblp%d: USB %sdirectional printer dev %d " - "if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X", - usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum, - usblp->ifnum, - usblp->protocol[usblp->current_protocol].alt_setting, - usblp->current_protocol, - le16_to_cpu(usblp->dev->descriptor.idVendor), - le16_to_cpu(usblp->dev->descriptor.idProduct)); return 0; abort_intfdata: usb_set_intfdata (intf, NULL); - device_remove_file(&intf->dev, &dev_attr_ieee1284_id); abort: if (usblp) { if (usblp->writebuf) @@ -1172,8 +1156,6 @@ static void usblp_disconnect(struct usb_interface *intf) BUG (); } - device_remove_file(&intf->dev, &dev_attr_ieee1284_id); - down (&usblp_sem); down (&usblp->sem); usblp->present = 0; @@ -1204,6 +1186,7 @@ static struct usb_device_id usblp_ids [] = { MODULE_DEVICE_TABLE (usb, usblp_ids); static struct usb_driver usblp_driver = { + .owner = THIS_MODULE, .name = "usblp", .probe = usblp_probe, .disconnect = usblp_disconnect, diff --git a/trunk/drivers/usb/core/Makefile b/trunk/drivers/usb/core/Makefile index 28329ddf187c..86d5c380892d 100644 --- a/trunk/drivers/usb/core/Makefile +++ b/trunk/drivers/usb/core/Makefile @@ -2,7 +2,7 @@ # Makefile for USB Core files and filesystem # -usbcore-objs := usb.o hub.o hcd.o urb.o message.o driver.o \ +usbcore-objs := usb.o hub.o hcd.o urb.o message.o \ config.o file.o buffer.o sysfs.o devio.o notify.o ifeq ($(CONFIG_PCI),y) diff --git a/trunk/drivers/usb/core/buffer.c b/trunk/drivers/usb/core/buffer.c index ad742cec94fa..419c9943a7cb 100644 --- a/trunk/drivers/usb/core/buffer.c +++ b/trunk/drivers/usb/core/buffer.c @@ -55,9 +55,6 @@ int hcd_buffer_create (struct usb_hcd *hcd) char name [16]; int i, size; - if (!hcd->self.controller->dma_mask) - return 0; - for (i = 0; i < HCD_BUFFER_POOLS; i++) { if (!(size = pool_max [i])) continue; diff --git a/trunk/drivers/usb/core/devices.c b/trunk/drivers/usb/core/devices.c index 2684e15b813b..83e815d3cd52 100644 --- a/trunk/drivers/usb/core/devices.c +++ b/trunk/drivers/usb/core/devices.c @@ -67,45 +67,45 @@ /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */ #define ALLOW_SERIAL_NUMBER -static const char *format_topo = +static char *format_topo = /* T: Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=ddd MxCh=dd */ "\nT: Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%3s MxCh=%2d\n"; -static const char *format_string_manufacturer = +static char *format_string_manufacturer = /* S: Manufacturer=xxxx */ "S: Manufacturer=%.100s\n"; -static const char *format_string_product = +static char *format_string_product = /* S: Product=xxxx */ "S: Product=%.100s\n"; #ifdef ALLOW_SERIAL_NUMBER -static const char *format_string_serialnumber = +static char *format_string_serialnumber = /* S: SerialNumber=xxxx */ "S: SerialNumber=%.100s\n"; #endif -static const char *format_bandwidth = +static char *format_bandwidth = /* B: Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd */ "B: Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n"; -static const char *format_device1 = +static char *format_device1 = /* D: Ver=xx.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd */ "D: Ver=%2x.%02x Cls=%02x(%-5s) Sub=%02x Prot=%02x MxPS=%2d #Cfgs=%3d\n"; -static const char *format_device2 = +static char *format_device2 = /* P: Vendor=xxxx ProdID=xxxx Rev=xx.xx */ "P: Vendor=%04x ProdID=%04x Rev=%2x.%02x\n"; -static const char *format_config = +static char *format_config = /* C: #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA */ "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n"; -static const char *format_iface = +static char *format_iface = /* I: If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=xxxx*/ "I: If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n"; -static const char *format_endpt = +static char *format_endpt = /* E: Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=D?s */ "E: Ad=%02x(%c) Atr=%02x(%-4s) MxPS=%4d Ivl=%d%cs\n"; @@ -545,10 +545,10 @@ static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes, loff_t *ski struct usb_device *childdev = usbdev->children[chix]; if (childdev) { - usb_lock_device(childdev); + down(&childdev->serialize); ret = usb_device_dump(buffer, nbytes, skip_bytes, file_offset, childdev, bus, level + 1, chix, ++cnt); - usb_unlock_device(childdev); + up(&childdev->serialize); if (ret == -EFAULT) return total_written; total_written += ret; diff --git a/trunk/drivers/usb/core/devio.c b/trunk/drivers/usb/core/devio.c index 2b68998fe4b3..b1d6e9af732d 100644 --- a/trunk/drivers/usb/core/devio.c +++ b/trunk/drivers/usb/core/devio.c @@ -402,6 +402,7 @@ static void driver_disconnect(struct usb_interface *intf) } struct usb_driver usbfs_driver = { + .owner = THIS_MODULE, .name = "usbfs", .probe = driver_probe, .disconnect = driver_disconnect, @@ -1349,7 +1350,9 @@ static int proc_ioctl(struct dev_state *ps, struct usbdevfs_ioctl *ctl) /* let kernel drivers try to (re)bind to the interface */ case USBDEVFS_CONNECT: usb_unlock_device(ps->dev); + usb_lock_all_devices(); bus_rescan_devices(intf->dev.bus); + usb_unlock_all_devices(); usb_lock_device(ps->dev); break; diff --git a/trunk/drivers/usb/core/driver.c b/trunk/drivers/usb/core/driver.c deleted file mode 100644 index 076462c8ba2a..000000000000 --- a/trunk/drivers/usb/core/driver.c +++ /dev/null @@ -1,472 +0,0 @@ -/* - * drivers/usb/driver.c - most of the driver model stuff for usb - * - * (C) Copyright 2005 Greg Kroah-Hartman - * - * based on drivers/usb/usb.c which had the following copyrights: - * (C) Copyright Linus Torvalds 1999 - * (C) Copyright Johannes Erdfelt 1999-2001 - * (C) Copyright Andreas Gal 1999 - * (C) Copyright Gregory P. Smith 1999 - * (C) Copyright Deti Fliegl 1999 (new USB architecture) - * (C) Copyright Randy Dunlap 2000 - * (C) Copyright David Brownell 2000-2004 - * (C) Copyright Yggdrasil Computing, Inc. 2000 - * (usb_device_id matching changes by Adam J. Richter) - * (C) Copyright Greg Kroah-Hartman 2002-2003 - * - * NOTE! This is not actually a driver at all, rather this is - * just a collection of helper routines that implement the - * generic USB things that the real drivers can use.. - * - */ - -#include -#include -#include -#include "hcd.h" -#include "usb.h" - -static int usb_match_one_id(struct usb_interface *interface, - const struct usb_device_id *id); - -struct usb_dynid { - struct list_head node; - struct usb_device_id id; -}; - - -static int generic_probe(struct device *dev) -{ - return 0; -} -static int generic_remove(struct device *dev) -{ - struct usb_device *udev = to_usb_device(dev); - - /* if this is only an unbind, not a physical disconnect, then - * unconfigure the device */ - if (udev->state == USB_STATE_CONFIGURED) - usb_set_configuration(udev, 0); - - /* in case the call failed or the device was suspended */ - if (udev->state >= USB_STATE_CONFIGURED) - usb_disable_device(udev, 0); - return 0; -} - -struct device_driver usb_generic_driver = { - .owner = THIS_MODULE, - .name = "usb", - .bus = &usb_bus_type, - .probe = generic_probe, - .remove = generic_remove, -}; - -/* Fun hack to determine if the struct device is a - * usb device or a usb interface. */ -int usb_generic_driver_data; - -#ifdef CONFIG_HOTPLUG - -/* - * Adds a new dynamic USBdevice ID to this driver, - * and cause the driver to probe for all devices again. - */ -static ssize_t store_new_id(struct device_driver *driver, - const char *buf, size_t count) -{ - struct usb_driver *usb_drv = to_usb_driver(driver); - struct usb_dynid *dynid; - u32 idVendor = 0; - u32 idProduct = 0; - int fields = 0; - - fields = sscanf(buf, "%x %x", &idVendor, &idProduct); - if (fields < 2) - return -EINVAL; - - dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); - if (!dynid) - return -ENOMEM; - - INIT_LIST_HEAD(&dynid->node); - dynid->id.idVendor = idVendor; - dynid->id.idProduct = idProduct; - dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE; - - spin_lock(&usb_drv->dynids.lock); - list_add_tail(&usb_drv->dynids.list, &dynid->node); - spin_unlock(&usb_drv->dynids.lock); - - if (get_driver(driver)) { - driver_attach(driver); - put_driver(driver); - } - - return count; -} -static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id); - -static int usb_create_newid_file(struct usb_driver *usb_drv) -{ - int error = 0; - - if (usb_drv->no_dynamic_id) - goto exit; - - if (usb_drv->probe != NULL) - error = sysfs_create_file(&usb_drv->driver.kobj, - &driver_attr_new_id.attr); -exit: - return error; -} - -static void usb_remove_newid_file(struct usb_driver *usb_drv) -{ - if (usb_drv->no_dynamic_id) - return; - - if (usb_drv->probe != NULL) - sysfs_remove_file(&usb_drv->driver.kobj, - &driver_attr_new_id.attr); -} - -static void usb_free_dynids(struct usb_driver *usb_drv) -{ - struct usb_dynid *dynid, *n; - - spin_lock(&usb_drv->dynids.lock); - list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) { - list_del(&dynid->node); - kfree(dynid); - } - spin_unlock(&usb_drv->dynids.lock); -} -#else -static inline int usb_create_newid_file(struct usb_driver *usb_drv) -{ - return 0; -} - -static void usb_remove_newid_file(struct usb_driver *usb_drv) -{ -} - -static inline void usb_free_dynids(struct usb_driver *usb_drv) -{ -} -#endif - -static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf, - struct usb_driver *drv) -{ - struct usb_dynid *dynid; - - spin_lock(&drv->dynids.lock); - list_for_each_entry(dynid, &drv->dynids.list, node) { - if (usb_match_one_id(intf, &dynid->id)) { - spin_unlock(&drv->dynids.lock); - return &dynid->id; - } - } - spin_unlock(&drv->dynids.lock); - return NULL; -} - - -/* called from driver core with usb_bus_type.subsys writelock */ -static int usb_probe_interface(struct device *dev) -{ - struct usb_interface * intf = to_usb_interface(dev); - struct usb_driver * driver = to_usb_driver(dev->driver); - const struct usb_device_id *id; - int error = -ENODEV; - - dev_dbg(dev, "%s\n", __FUNCTION__); - - if (!driver->probe) - return error; - /* FIXME we'd much prefer to just resume it ... */ - if (interface_to_usbdev(intf)->state == USB_STATE_SUSPENDED) - return -EHOSTUNREACH; - - id = usb_match_id(intf, driver->id_table); - if (!id) - id = usb_match_dynamic_id(intf, driver); - if (id) { - dev_dbg(dev, "%s - got id\n", __FUNCTION__); - - /* Interface "power state" doesn't correspond to any hardware - * state whatsoever. We use it to record when it's bound to - * a driver that may start I/0: it's not frozen/quiesced. - */ - mark_active(intf); - intf->condition = USB_INTERFACE_BINDING; - error = driver->probe(intf, id); - if (error) { - mark_quiesced(intf); - intf->condition = USB_INTERFACE_UNBOUND; - } else - intf->condition = USB_INTERFACE_BOUND; - } - - return error; -} - -/* called from driver core with usb_bus_type.subsys writelock */ -static int usb_unbind_interface(struct device *dev) -{ - struct usb_interface *intf = to_usb_interface(dev); - struct usb_driver *driver = to_usb_driver(intf->dev.driver); - - intf->condition = USB_INTERFACE_UNBINDING; - - /* release all urbs for this interface */ - usb_disable_interface(interface_to_usbdev(intf), intf); - - if (driver && driver->disconnect) - driver->disconnect(intf); - - /* reset other interface state */ - usb_set_interface(interface_to_usbdev(intf), - intf->altsetting[0].desc.bInterfaceNumber, - 0); - usb_set_intfdata(intf, NULL); - intf->condition = USB_INTERFACE_UNBOUND; - mark_quiesced(intf); - - return 0; -} - -/* returns 0 if no match, 1 if match */ -static int usb_match_one_id(struct usb_interface *interface, - const struct usb_device_id *id) -{ - struct usb_host_interface *intf; - struct usb_device *dev; - - /* proc_connectinfo in devio.c may call us with id == NULL. */ - if (id == NULL) - return 0; - - intf = interface->cur_altsetting; - dev = interface_to_usbdev(interface); - - if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) && - id->idVendor != le16_to_cpu(dev->descriptor.idVendor)) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) && - id->idProduct != le16_to_cpu(dev->descriptor.idProduct)) - return 0; - - /* No need to test id->bcdDevice_lo != 0, since 0 is never - greater than any unsigned number. */ - if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) && - (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice))) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) && - (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice))) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) && - (id->bDeviceClass != dev->descriptor.bDeviceClass)) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) && - (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass)) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) && - (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol)) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) && - (id->bInterfaceClass != intf->desc.bInterfaceClass)) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) && - (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass)) - return 0; - - if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) && - (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol)) - return 0; - - return 1; -} -/** - * usb_match_id - find first usb_device_id matching device or interface - * @interface: the interface of interest - * @id: array of usb_device_id structures, terminated by zero entry - * - * usb_match_id searches an array of usb_device_id's and returns - * the first one matching the device or interface, or null. - * This is used when binding (or rebinding) a driver to an interface. - * Most USB device drivers will use this indirectly, through the usb core, - * but some layered driver frameworks use it directly. - * These device tables are exported with MODULE_DEVICE_TABLE, through - * modutils, to support the driver loading functionality of USB hotplugging. - * - * What Matches: - * - * The "match_flags" element in a usb_device_id controls which - * members are used. If the corresponding bit is set, the - * value in the device_id must match its corresponding member - * in the device or interface descriptor, or else the device_id - * does not match. - * - * "driver_info" is normally used only by device drivers, - * but you can create a wildcard "matches anything" usb_device_id - * as a driver's "modules.usbmap" entry if you provide an id with - * only a nonzero "driver_info" field. If you do this, the USB device - * driver's probe() routine should use additional intelligence to - * decide whether to bind to the specified interface. - * - * What Makes Good usb_device_id Tables: - * - * The match algorithm is very simple, so that intelligence in - * driver selection must come from smart driver id records. - * Unless you have good reasons to use another selection policy, - * provide match elements only in related groups, and order match - * specifiers from specific to general. Use the macros provided - * for that purpose if you can. - * - * The most specific match specifiers use device descriptor - * data. These are commonly used with product-specific matches; - * the USB_DEVICE macro lets you provide vendor and product IDs, - * and you can also match against ranges of product revisions. - * These are widely used for devices with application or vendor - * specific bDeviceClass values. - * - * Matches based on device class/subclass/protocol specifications - * are slightly more general; use the USB_DEVICE_INFO macro, or - * its siblings. These are used with single-function devices - * where bDeviceClass doesn't specify that each interface has - * its own class. - * - * Matches based on interface class/subclass/protocol are the - * most general; they let drivers bind to any interface on a - * multiple-function device. Use the USB_INTERFACE_INFO - * macro, or its siblings, to match class-per-interface style - * devices (as recorded in bDeviceClass). - * - * Within those groups, remember that not all combinations are - * meaningful. For example, don't give a product version range - * without vendor and product IDs; or specify a protocol without - * its associated class and subclass. - */ -const struct usb_device_id *usb_match_id(struct usb_interface *interface, - const struct usb_device_id *id) -{ - /* proc_connectinfo in devio.c may call us with id == NULL. */ - if (id == NULL) - return NULL; - - /* It is important to check that id->driver_info is nonzero, - since an entry that is all zeroes except for a nonzero - id->driver_info is the way to create an entry that - indicates that the driver want to examine every - device and interface. */ - for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass || - id->driver_info; id++) { - if (usb_match_one_id(interface, id)) - return id; - } - - return NULL; -} -EXPORT_SYMBOL_GPL(usb_match_id); - -int usb_device_match(struct device *dev, struct device_driver *drv) -{ - struct usb_interface *intf; - struct usb_driver *usb_drv; - const struct usb_device_id *id; - - /* check for generic driver, which we don't match any device with */ - if (drv == &usb_generic_driver) - return 0; - - intf = to_usb_interface(dev); - usb_drv = to_usb_driver(drv); - - id = usb_match_id(intf, usb_drv->id_table); - if (id) - return 1; - - id = usb_match_dynamic_id(intf, usb_drv); - if (id) - return 1; - return 0; -} - -/** - * usb_register_driver - register a USB driver - * @new_driver: USB operations for the driver - * @owner: module owner of this driver. - * - * Registers a USB driver with the USB core. The list of unattached - * interfaces will be rescanned whenever a new driver is added, allowing - * the new driver to attach to any recognized devices. - * Returns a negative error code on failure and 0 on success. - * - * NOTE: if you want your driver to use the USB major number, you must call - * usb_register_dev() to enable that functionality. This function no longer - * takes care of that. - */ -int usb_register_driver(struct usb_driver *new_driver, struct module *owner) -{ - int retval = 0; - - if (usb_disabled()) - return -ENODEV; - - new_driver->driver.name = (char *)new_driver->name; - new_driver->driver.bus = &usb_bus_type; - new_driver->driver.probe = usb_probe_interface; - new_driver->driver.remove = usb_unbind_interface; - new_driver->driver.owner = owner; - spin_lock_init(&new_driver->dynids.lock); - INIT_LIST_HEAD(&new_driver->dynids.list); - - retval = driver_register(&new_driver->driver); - - if (!retval) { - pr_info("%s: registered new driver %s\n", - usbcore_name, new_driver->name); - usbfs_update_special(); - usb_create_newid_file(new_driver); - } else { - printk(KERN_ERR "%s: error %d registering driver %s\n", - usbcore_name, retval, new_driver->name); - } - - return retval; -} -EXPORT_SYMBOL_GPL(usb_register_driver); - -/** - * usb_deregister - unregister a USB driver - * @driver: USB operations of the driver to unregister - * Context: must be able to sleep - * - * Unlinks the specified driver from the internal USB driver list. - * - * NOTE: If you called usb_register_dev(), you still need to call - * usb_deregister_dev() to clean up your driver's allocated minor numbers, - * this * call will no longer do it for you. - */ -void usb_deregister(struct usb_driver *driver) -{ - pr_info("%s: deregistering driver %s\n", usbcore_name, driver->name); - - usb_remove_newid_file(driver); - usb_free_dynids(driver); - driver_unregister(&driver->driver); - - usbfs_update_special(); -} -EXPORT_SYMBOL_GPL(usb_deregister); diff --git a/trunk/drivers/usb/core/hcd.c b/trunk/drivers/usb/core/hcd.c index 0018bbc4de34..da24c31ee00d 100644 --- a/trunk/drivers/usb/core/hcd.c +++ b/trunk/drivers/usb/core/hcd.c @@ -857,7 +857,9 @@ static int register_root_hub (struct usb_device *usb_dev, return (retval < 0) ? retval : -EMSGSIZE; } + usb_lock_device (usb_dev); retval = usb_new_device (usb_dev); + usb_unlock_device (usb_dev); if (retval) { usb_dev->bus->root_hub = NULL; dev_err (parent_dev, "can't register root hub for %s, %d\n", @@ -1825,6 +1827,8 @@ int usb_add_hcd(struct usb_hcd *hcd, retval = -ENOMEM; goto err_allocate_root_hub; } + rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH : + USB_SPEED_FULL; /* Although in principle hcd->driver->start() might need to use rhdev, * none of the current drivers do. @@ -1842,9 +1846,6 @@ int usb_add_hcd(struct usb_hcd *hcd, dev_dbg(hcd->self.controller, "supports USB remote wakeup\n"); hcd->remote_wakeup = hcd->can_wakeup; - rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH : - USB_SPEED_FULL; - rhdev->bus_mA = min(500u, hcd->power_budget); if ((retval = register_root_hub(rhdev, hcd)) != 0) goto err_register_root_hub; @@ -1890,10 +1891,7 @@ void usb_remove_hcd(struct usb_hcd *hcd) spin_lock_irq (&hcd_root_hub_lock); hcd->rh_registered = 0; spin_unlock_irq (&hcd_root_hub_lock); - - down(&usb_bus_list_lock); usb_disconnect(&hcd->self.root_hub); - up(&usb_bus_list_lock); hcd->poll_rh = 0; del_timer_sync(&hcd->rh_timer); diff --git a/trunk/drivers/usb/core/hcd.h b/trunk/drivers/usb/core/hcd.h index 591b5aad1a18..c8a1b350e2cf 100644 --- a/trunk/drivers/usb/core/hcd.h +++ b/trunk/drivers/usb/core/hcd.h @@ -380,7 +380,6 @@ extern int usb_find_interface_driver (struct usb_device *dev, #ifdef CONFIG_PM extern void usb_hcd_suspend_root_hub (struct usb_hcd *hcd); extern void usb_hcd_resume_root_hub (struct usb_hcd *hcd); -extern void usb_root_hub_lost_power (struct usb_device *rhdev); extern int hcd_bus_suspend (struct usb_bus *bus); extern int hcd_bus_resume (struct usb_bus *bus); #else diff --git a/trunk/drivers/usb/core/hub.c b/trunk/drivers/usb/core/hub.c index 650d5ee5871b..f78bd124d290 100644 --- a/trunk/drivers/usb/core/hub.c +++ b/trunk/drivers/usb/core/hub.c @@ -32,7 +32,7 @@ #include "hub.h" /* Protect struct usb_device->state and ->children members - * Note: Both are also protected by ->dev.sem, except that ->state can + * Note: Both are also protected by ->serialize, except that ->state can * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */ static DEFINE_SPINLOCK(device_state_lock); @@ -515,31 +515,6 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state) return ret; } - -/* caller has locked the hub device */ -static void hub_pre_reset(struct usb_hub *hub, int disable_ports) -{ - struct usb_device *hdev = hub->hdev; - int port1; - - for (port1 = 1; port1 <= hdev->maxchild; ++port1) { - if (hdev->children[port1 - 1]) { - usb_disconnect(&hdev->children[port1 - 1]); - if (disable_ports) - hub_port_disable(hub, port1, 0); - } - } - hub_quiesce(hub); -} - -/* caller has locked the hub device */ -static void hub_post_reset(struct usb_hub *hub) -{ - hub_activate(hub); - hub_power_on(hub); -} - - static int hub_configure(struct usb_hub *hub, struct usb_endpoint_descriptor *endpoint) { @@ -702,40 +677,26 @@ static int hub_configure(struct usb_hub *hub, * and battery-powered root hubs (may provide just 8 mA). */ ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus); - if (ret < 2) { + if (ret < 0) { message = "can't get hub status"; goto fail; } le16_to_cpus(&hubstatus); if (hdev == hdev->bus->root_hub) { - if (hdev->bus_mA == 0 || hdev->bus_mA >= 500) - hub->mA_per_port = 500; - else { - hub->mA_per_port = hdev->bus_mA; - hub->limited_power = 1; - } + struct usb_hcd *hcd = + container_of(hdev->bus, struct usb_hcd, self); + + hub->power_budget = min(500u, hcd->power_budget) / 2; } else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) { dev_dbg(hub_dev, "hub controller current requirement: %dmA\n", hub->descriptor->bHubContrCurrent); - hub->limited_power = 1; - if (hdev->maxchild > 0) { - int remaining = hdev->bus_mA - - hub->descriptor->bHubContrCurrent; - - if (remaining < hdev->maxchild * 100) - dev_warn(hub_dev, - "insufficient power available " - "to use all downstream ports\n"); - hub->mA_per_port = 100; /* 7.2.1.1 */ - } - } else { /* Self-powered external hub */ - /* FIXME: What about battery-powered external hubs that - * provide less current per port? */ - hub->mA_per_port = 500; + hub->power_budget = (501 - hub->descriptor->bHubContrCurrent) + / 2; } - if (hub->mA_per_port < 500) - dev_dbg(hub_dev, "%umA bus power budget for each child\n", - hub->mA_per_port); + if (hub->power_budget) + dev_dbg(hub_dev, "%dmA bus power budget for children\n", + hub->power_budget * 2); + ret = hub_hub_status(hub, &hubstatus, &hubchange); if (ret < 0) { @@ -789,10 +750,29 @@ static int hub_configure(struct usb_hub *hub, static unsigned highspeed_hubs; +/* Called after the hub driver is unbound from a hub with children */ +static void hub_remove_children_work(void *__hub) +{ + struct usb_hub *hub = __hub; + struct usb_device *hdev = hub->hdev; + int i; + + kfree(hub); + + usb_lock_device(hdev); + for (i = 0; i < hdev->maxchild; ++i) { + if (hdev->children[i]) + usb_disconnect(&hdev->children[i]); + } + usb_unlock_device(hdev); + usb_put_dev(hdev); +} + static void hub_disconnect(struct usb_interface *intf) { struct usb_hub *hub = usb_get_intfdata (intf); struct usb_device *hdev; + int n, port1; usb_set_intfdata (intf, NULL); hdev = hub->hdev; @@ -800,9 +780,7 @@ static void hub_disconnect(struct usb_interface *intf) if (hdev->speed == USB_SPEED_HIGH) highspeed_hubs--; - /* Disconnect all children and quiesce the hub */ - hub_pre_reset(hub, 1); - + hub_quiesce(hub); usb_free_urb(hub->urb); hub->urb = NULL; @@ -822,7 +800,27 @@ static void hub_disconnect(struct usb_interface *intf) hub->buffer = NULL; } - kfree(hub); + /* If there are any children then this is an unbind only, not a + * physical disconnection. The active ports must be disabled + * and later on we must call usb_disconnect(). We can't call + * it now because we may not hold the hub's device lock. + */ + n = 0; + for (port1 = 1; port1 <= hdev->maxchild; ++port1) { + if (hdev->children[port1 - 1]) { + ++n; + hub_port_disable(hub, port1, 1); + } + } + + if (n == 0) + kfree(hub); + else { + /* Reuse the hub->leds work_struct for our own purposes */ + INIT_WORK(&hub->leds, hub_remove_children_work, hub); + schedule_work(&hub->leds); + usb_get_dev(hdev); + } } static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id) @@ -919,6 +917,26 @@ hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data) } } +/* caller has locked the hub device */ +static void hub_pre_reset(struct usb_hub *hub) +{ + struct usb_device *hdev = hub->hdev; + int i; + + for (i = 0; i < hdev->maxchild; ++i) { + if (hdev->children[i]) + usb_disconnect(&hdev->children[i]); + } + hub_quiesce(hub); +} + +/* caller has locked the hub device */ +static void hub_post_reset(struct usb_hub *hub) +{ + hub_activate(hub); + hub_power_on(hub); +} + /* grab device/port lock, returning index of that port (zero based). * protects the upstream link used by this device from concurrent @@ -946,21 +964,24 @@ static int locktree(struct usb_device *udev) t = locktree(hdev); if (t < 0) return t; + for (t = 0; t < hdev->maxchild; t++) { + if (hdev->children[t] == udev) { + /* everything is fail-fast once disconnect + * processing starts + */ + if (udev->state == USB_STATE_NOTATTACHED) + break; - /* everything is fail-fast once disconnect - * processing starts - */ - if (udev->state == USB_STATE_NOTATTACHED) { - usb_unlock_device(hdev); - return -ENODEV; + /* when everyone grabs locks top->bottom, + * non-overlapping work may be concurrent + */ + down(&udev->serialize); + up(&hdev->serialize); + return t + 1; + } } - - /* when everyone grabs locks top->bottom, - * non-overlapping work may be concurrent - */ - usb_lock_device(udev); usb_unlock_device(hdev); - return udev->portnum; + return -ENODEV; } static void recursively_mark_NOTATTACHED(struct usb_device *udev) @@ -1018,39 +1039,6 @@ void usb_set_device_state(struct usb_device *udev, EXPORT_SYMBOL(usb_set_device_state); -#ifdef CONFIG_PM - -/** - * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power - * @rhdev: struct usb_device for the root hub - * - * The USB host controller driver calls this function when its root hub - * is resumed and Vbus power has been interrupted or the controller - * has been reset. The routine marks all the children of the root hub - * as NOTATTACHED and marks logical connect-change events on their ports. - */ -void usb_root_hub_lost_power(struct usb_device *rhdev) -{ - struct usb_hub *hub; - int port1; - unsigned long flags; - - dev_warn(&rhdev->dev, "root hub lost power or was reset\n"); - spin_lock_irqsave(&device_state_lock, flags); - hub = hdev_to_hub(rhdev); - for (port1 = 1; port1 <= rhdev->maxchild; ++port1) { - if (rhdev->children[port1 - 1]) { - recursively_mark_NOTATTACHED( - rhdev->children[port1 - 1]); - set_bit(port1, hub->change_bits); - } - } - spin_unlock_irqrestore(&device_state_lock, flags); -} -EXPORT_SYMBOL_GPL(usb_root_hub_lost_power); - -#endif - static void choose_address(struct usb_device *udev) { int devnum; @@ -1111,9 +1099,15 @@ void usb_disconnect(struct usb_device **pdev) * this quiesces everyting except pending urbs. */ usb_set_device_state(udev, USB_STATE_NOTATTACHED); - dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum); - usb_lock_device(udev); + /* lock the bus list on behalf of HCDs unregistering their root hubs */ + if (!udev->parent) { + down(&usb_bus_list_lock); + usb_lock_device(udev); + } else + down(&udev->serialize); + + dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum); /* Free up all the children before we remove this device */ for (i = 0; i < USB_MAXCHILDREN; i++) { @@ -1142,112 +1136,54 @@ void usb_disconnect(struct usb_device **pdev) *pdev = NULL; spin_unlock_irq(&device_state_lock); - usb_unlock_device(udev); + if (!udev->parent) { + usb_unlock_device(udev); + up(&usb_bus_list_lock); + } else + up(&udev->serialize); device_unregister(&udev->dev); } -static inline const char *plural(int n) -{ - return (n == 1 ? "" : "s"); -} - static int choose_configuration(struct usb_device *udev) { - int i; - u16 devstatus; - int bus_powered; - int num_configs; - struct usb_host_config *c, *best; - - /* If this fails, assume the device is bus-powered */ - devstatus = 0; - usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus); - le16_to_cpus(&devstatus); - bus_powered = ((devstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0); - dev_dbg(&udev->dev, "device is %s-powered\n", - bus_powered ? "bus" : "self"); - - best = NULL; - c = udev->config; - num_configs = udev->descriptor.bNumConfigurations; - for (i = 0; i < num_configs; (i++, c++)) { - struct usb_interface_descriptor *desc = - &c->intf_cache[0]->altsetting->desc; - - /* - * HP's USB bus-powered keyboard has only one configuration - * and it claims to be self-powered; other devices may have - * similar errors in their descriptors. If the next test - * were allowed to execute, such configurations would always - * be rejected and the devices would not work as expected. - */ -#if 0 - /* Rule out self-powered configs for a bus-powered device */ - if (bus_powered && (c->desc.bmAttributes & - USB_CONFIG_ATT_SELFPOWER)) - continue; -#endif + int c, i; - /* - * The next test may not be as effective as it should be. - * Some hubs have errors in their descriptor, claiming - * to be self-powered when they are really bus-powered. - * We will overestimate the amount of current such hubs - * make available for each port. - * - * This is a fairly benign sort of failure. It won't - * cause us to reject configurations that we should have - * accepted. - */ + /* NOTE: this should interact with hub power budgeting */ - /* Rule out configs that draw too much bus current */ - if (c->desc.bMaxPower * 2 > udev->bus_mA) - continue; + c = udev->config[0].desc.bConfigurationValue; + if (udev->descriptor.bNumConfigurations != 1) { + for (i = 0; i < udev->descriptor.bNumConfigurations; i++) { + struct usb_interface_descriptor *desc; - /* If the first config's first interface is COMM/2/0xff - * (MSFT RNDIS), rule it out unless Linux has host-side - * RNDIS support. */ - if (i == 0 && desc->bInterfaceClass == USB_CLASS_COMM - && desc->bInterfaceSubClass == 2 - && desc->bInterfaceProtocol == 0xff) { -#ifndef CONFIG_USB_NET_RNDIS - continue; -#else - best = c; -#endif - } - - /* From the remaining configs, choose the first one whose - * first interface is for a non-vendor-specific class. - * Reason: Linux is more likely to have a class driver - * than a vendor-specific driver. */ - else if (udev->descriptor.bDeviceClass != - USB_CLASS_VENDOR_SPEC && - desc->bInterfaceClass != - USB_CLASS_VENDOR_SPEC) { - best = c; + /* heuristic: Linux is more likely to have class + * drivers, so avoid vendor-specific interfaces. + */ + desc = &udev->config[i].intf_cache[0] + ->altsetting->desc; + if (desc->bInterfaceClass == USB_CLASS_VENDOR_SPEC) + continue; + /* COMM/2/all is CDC ACM, except 0xff is MSFT RNDIS. + * MSFT needs this to be the first config; never use + * it as the default unless Linux has host-side RNDIS. + * A second config would ideally be CDC-Ethernet, but + * may instead be the "vendor specific" CDC subset + * long used by ARM Linux for sa1100 or pxa255. + */ + if (desc->bInterfaceClass == USB_CLASS_COMM + && desc->bInterfaceSubClass == 2 + && desc->bInterfaceProtocol == 0xff) { + c = udev->config[1].desc.bConfigurationValue; + continue; + } + c = udev->config[i].desc.bConfigurationValue; break; } - - /* If all the remaining configs are vendor-specific, - * choose the first one. */ - else if (!best) - best = c; - } - - if (best) { - i = best->desc.bConfigurationValue; dev_info(&udev->dev, - "configuration #%d chosen from %d choice%s\n", - i, num_configs, plural(num_configs)); - } else { - i = -1; - dev_warn(&udev->dev, - "no configuration chosen from %d choice%s\n", - num_configs, plural(num_configs)); + "configuration #%d chosen from %d choices\n", + c, udev->descriptor.bNumConfigurations); } - return i; + return c; } #ifdef DEBUG @@ -1274,8 +1210,8 @@ static inline void show_string(struct usb_device *udev, char *id, char *string) * * This is called with devices which have been enumerated, but not yet * configured. The device descriptor is available, but not descriptors - * for any device configuration. The caller must have locked either - * the parent hub (if udev is a normal device) or else the + * for any device configuration. The caller must have locked udev and + * either the parent hub (if udev is a normal device) or else the * usb_bus_list_lock (if udev is a root hub). The parent's pointer to * udev has already been installed, but udev is not yet visible through * sysfs or other filesystem code. @@ -1285,7 +1221,8 @@ static inline void show_string(struct usb_device *udev, char *id, char *string) * * This call is synchronous, and may not be used in an interrupt context. * - * Only the hub driver or root-hub registrar should ever call this. + * Only the hub driver should ever call this; root hub registration + * uses it indirectly. */ int usb_new_device(struct usb_device *udev) { @@ -1332,9 +1269,15 @@ int usb_new_device(struct usb_device *udev) le16_to_cpu(udev->config[0].desc.wTotalLength), USB_DT_OTG, (void **) &desc) == 0) { if (desc->bmAttributes & USB_OTG_HNP) { - unsigned port1 = udev->portnum; + unsigned port1; struct usb_device *root = udev->parent; + for (port1 = 1; port1 <= root->maxchild; + port1++) { + if (root->children[port1-1] == udev) + break; + } + dev_info(&udev->dev, "Dual-Role OTG device on %sHNP port\n", (port1 == bus->otg_port) @@ -1388,27 +1331,27 @@ int usb_new_device(struct usb_device *udev) } usb_create_sysfs_dev_files (udev); - usb_lock_device(udev); - /* choose and set the configuration. that registers the interfaces * with the driver core, and lets usb device drivers bind to them. */ c = choose_configuration(udev); - if (c >= 0) { + if (c < 0) + dev_warn(&udev->dev, + "can't choose an initial configuration\n"); + else { err = usb_set_configuration(udev, c); if (err) { dev_err(&udev->dev, "can't set config #%d, error %d\n", c, err); - /* This need not be fatal. The user can try to - * set other configurations. */ + usb_remove_sysfs_dev_files(udev); + device_del(&udev->dev); + goto fail; } } /* USB device state == configured ... usable */ usb_notify_add_device(udev); - usb_unlock_device(udev); - return 0; fail: @@ -1711,9 +1654,15 @@ static int __usb_suspend_device (struct usb_device *udev, int port1) int usb_suspend_device(struct usb_device *udev) { #ifdef CONFIG_USB_SUSPEND - if (udev->state == USB_STATE_NOTATTACHED) - return -ENODEV; - return __usb_suspend_device(udev, udev->portnum); + int port1, status; + + port1 = locktree(udev); + if (port1 < 0) + return port1; + + status = __usb_suspend_device(udev, port1); + usb_unlock_device(udev); + return status; #else /* NOTE: udev->state unchanged, it's not lying ... */ udev->dev.power.power_state = PMSG_SUSPEND; @@ -1745,14 +1694,13 @@ static int finish_device_resume(struct usb_device *udev) usb_set_device_state(udev, udev->actconfig ? USB_STATE_CONFIGURED : USB_STATE_ADDRESS); - udev->dev.power.power_state = PMSG_ON; /* 10.5.4.5 says be sure devices in the tree are still there. * For now let's assume the device didn't go crazy on resume, * and device drivers will know about any resume quirks. */ status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus); - if (status < 2) + if (status < 0) dev_dbg(&udev->dev, "gone after usb resume? status %d\n", status); @@ -1761,7 +1709,7 @@ static int finish_device_resume(struct usb_device *udev) int (*resume)(struct device *); le16_to_cpus(&devstatus); - if ((devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) + if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP) && udev->parent) { status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), @@ -1781,14 +1729,8 @@ static int finish_device_resume(struct usb_device *udev) * may have a child resume event to deal with soon */ resume = udev->dev.bus->resume; - for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { - struct device *dev = - &udev->actconfig->interface[i]->dev; - - down(&dev->sem); - (void) resume(dev); - up(&dev->sem); - } + for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) + (void) resume(&udev->actconfig->interface[i]->dev); status = 0; } else if (udev->devnum <= 0) { @@ -1871,10 +1813,11 @@ hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev) */ int usb_resume_device(struct usb_device *udev) { - int status; + int port1, status; - if (udev->state == USB_STATE_NOTATTACHED) - return -ENODEV; + port1 = locktree(udev); + if (port1 < 0) + return port1; #ifdef CONFIG_USB_SUSPEND /* selective resume of one downstream hub-to-device port */ @@ -1883,7 +1826,7 @@ int usb_resume_device(struct usb_device *udev) // NOTE swsusp may bork us, device state being wrong... // NOTE this fails if parent is also suspended... status = hub_port_resume(hdev_to_hub(udev->parent), - udev->portnum, udev); + port1, udev); } else status = 0; } else @@ -1893,11 +1836,13 @@ int usb_resume_device(struct usb_device *udev) dev_dbg(&udev->dev, "can't resume, status %d\n", status); + usb_unlock_device(udev); + /* rebind drivers that had no suspend() */ if (status == 0) { - usb_unlock_device(udev); + usb_lock_all_devices(); bus_rescan_devices(&usb_bus_type); - usb_lock_device(udev); + usb_unlock_all_devices(); } return status; } @@ -1911,14 +1856,14 @@ static int remote_wakeup(struct usb_device *udev) /* don't repeat RESUME sequence if this device * was already woken up by some other task */ - usb_lock_device(udev); + down(&udev->serialize); if (udev->state == USB_STATE_SUSPENDED) { dev_dbg(&udev->dev, "RESUME (wakeup)\n"); /* TRSMRCY = 10 msec */ msleep(10); status = finish_device_resume(udev); } - usb_unlock_device(udev); + up(&udev->serialize); #endif return status; } @@ -2019,7 +1964,7 @@ static int hub_resume(struct usb_interface *intf) if (!udev || status < 0) continue; - usb_lock_device(udev); + down (&udev->serialize); if (portstat & USB_PORT_STAT_SUSPEND) status = hub_port_resume(hub, port1, udev); else { @@ -2030,7 +1975,7 @@ static int hub_resume(struct usb_interface *intf) hub_port_logical_disconnect(hub, port1); } } - usb_unlock_device(udev); + up(&udev->serialize); } } #endif @@ -2414,36 +2359,39 @@ hub_power_remaining (struct usb_hub *hub) { struct usb_device *hdev = hub->hdev; int remaining; - int port1; + unsigned i; - if (!hub->limited_power) + remaining = hub->power_budget; + if (!remaining) /* self-powered */ return 0; - remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent; - for (port1 = 1; port1 <= hdev->maxchild; ++port1) { - struct usb_device *udev = hdev->children[port1 - 1]; - int delta; + for (i = 0; i < hdev->maxchild; i++) { + struct usb_device *udev = hdev->children[i]; + int delta, ceiling; if (!udev) continue; - /* Unconfigured devices may not use more than 100mA, - * or 8mA for OTG ports */ + /* 100mA per-port ceiling, or 8mA for OTG ports */ + if (i != (udev->bus->otg_port - 1) || hdev->parent) + ceiling = 50; + else + ceiling = 4; + if (udev->actconfig) - delta = udev->actconfig->desc.bMaxPower * 2; - else if (port1 != udev->bus->otg_port || hdev->parent) - delta = 100; + delta = udev->actconfig->desc.bMaxPower; else - delta = 8; - if (delta > hub->mA_per_port) - dev_warn(&udev->dev, "%dmA is over %umA budget " - "for port %d!\n", - delta, hub->mA_per_port, port1); + delta = ceiling; + // dev_dbg(&udev->dev, "budgeted %dmA\n", 2 * delta); + if (delta > ceiling) + dev_warn(&udev->dev, "%dmA over %dmA budget!\n", + 2 * (delta - ceiling), 2 * ceiling); remaining -= delta; } if (remaining < 0) { - dev_warn(hub->intfdev, "%dmA over power budget!\n", - - remaining); + dev_warn(hub->intfdev, + "%dmA over power budget!\n", + -2 * remaining); remaining = 0; } return remaining; @@ -2538,8 +2486,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1, usb_set_device_state(udev, USB_STATE_POWERED); udev->speed = USB_SPEED_UNKNOWN; - udev->bus_mA = hub->mA_per_port; - + /* set the address */ choose_address(udev); if (udev->devnum <= 0) { @@ -2559,16 +2506,16 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1, * on the parent. */ if (udev->descriptor.bDeviceClass == USB_CLASS_HUB - && udev->bus_mA <= 100) { + && hub->power_budget) { u16 devstat; status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstat); - if (status < 2) { + if (status < 0) { dev_dbg(&udev->dev, "get status %d ?\n", status); goto loop_disable; } - le16_to_cpus(&devstat); + cpu_to_le16s(&devstat); if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) { dev_err(&udev->dev, "can't connect bus-powered hub " @@ -2593,6 +2540,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1, * udev becomes globally accessible, although presumably * no one will look at it until hdev is unlocked. */ + down (&udev->serialize); status = 0; /* We mustn't add new devices if the parent hub has @@ -2616,12 +2564,15 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1, } } + up (&udev->serialize); if (status) goto loop_disable; status = hub_power_remaining(hub); if (status) - dev_dbg(hub_dev, "%dmA power budget left\n", status); + dev_dbg(hub_dev, + "%dmA power budget left\n", + 2 * status); return; @@ -2697,8 +2648,6 @@ static void hub_events(void) if (i) { dpm_runtime_resume(&hdev->dev); dpm_runtime_resume(&intf->dev); - usb_put_intf(intf); - continue; } /* Lock the device, then check to see if we were @@ -2712,7 +2661,7 @@ static void hub_events(void) /* If the hub has died, clean up after it */ if (hdev->state == USB_STATE_NOTATTACHED) { - hub_pre_reset(hub, 0); + hub_pre_reset(hub); goto loop; } @@ -2835,11 +2784,6 @@ static void hub_events(void) if (hubchange & HUB_CHANGE_LOCAL_POWER) { dev_dbg (hub_dev, "power change\n"); clear_hub_feature(hdev, C_HUB_LOCAL_POWER); - if (hubstatus & HUB_STATUS_LOCAL_POWER) - /* FIXME: Is this always true? */ - hub->limited_power = 0; - else - hub->limited_power = 1; } if (hubchange & HUB_CHANGE_OVERCURRENT) { dev_dbg (hub_dev, "overcurrent change\n"); @@ -2888,6 +2832,7 @@ static struct usb_device_id hub_id_table [] = { MODULE_DEVICE_TABLE (usb, hub_id_table); static struct usb_driver hub_driver = { + .owner = THIS_MODULE, .name = "hub", .probe = hub_probe, .disconnect = hub_disconnect, @@ -2999,8 +2944,7 @@ int usb_reset_device(struct usb_device *udev) struct usb_hub *parent_hub; struct usb_device_descriptor descriptor = udev->descriptor; struct usb_hub *hub = NULL; - int i, ret = 0; - int port1 = udev->portnum; + int i, ret = 0, port1 = -1; if (udev->state == USB_STATE_NOTATTACHED || udev->state == USB_STATE_SUSPENDED) { @@ -3014,6 +2958,18 @@ int usb_reset_device(struct usb_device *udev) dev_dbg(&udev->dev, "%s for root hub!\n", __FUNCTION__); return -EISDIR; } + + for (i = 0; i < parent_hdev->maxchild; i++) + if (parent_hdev->children[i] == udev) { + port1 = i + 1; + break; + } + + if (port1 < 0) { + /* If this ever happens, it's very bad */ + dev_err(&udev->dev, "Can't locate device's port!\n"); + return -ENOENT; + } parent_hub = hdev_to_hub(parent_hdev); /* If we're resetting an active hub, take some special actions */ @@ -3021,7 +2977,7 @@ int usb_reset_device(struct usb_device *udev) udev->actconfig->interface[0]->dev.driver == &hub_driver.driver && (hub = hdev_to_hub(udev)) != NULL) { - hub_pre_reset(hub, 0); + hub_pre_reset(hub); } set_bit(port1, parent_hub->busy_bits); diff --git a/trunk/drivers/usb/core/hub.h b/trunk/drivers/usb/core/hub.h index 29d5f45a8456..bf23f8978024 100644 --- a/trunk/drivers/usb/core/hub.h +++ b/trunk/drivers/usb/core/hub.h @@ -220,9 +220,8 @@ struct usb_hub { struct usb_hub_descriptor *descriptor; /* class descriptor */ struct usb_tt tt; /* Transaction Translator */ - unsigned mA_per_port; /* current for each child */ + u8 power_budget; /* in 2mA units; or zero */ - unsigned limited_power:1; unsigned quiescing:1; unsigned activating:1; unsigned resume_root_hub:1; diff --git a/trunk/drivers/usb/core/message.c b/trunk/drivers/usb/core/message.c index 319de03944e7..fe74f99ca5f4 100644 --- a/trunk/drivers/usb/core/message.c +++ b/trunk/drivers/usb/core/message.c @@ -1387,12 +1387,6 @@ int usb_set_configuration(struct usb_device *dev, int configuration) if (dev->state != USB_STATE_ADDRESS) usb_disable_device (dev, 1); // Skip ep0 - i = dev->bus_mA - cp->desc.bMaxPower * 2; - if (i < 0) - dev_warn(&dev->dev, "new config #%d exceeds power " - "limit by %dmA\n", - configuration, -i); - if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION, 0, configuration, 0, NULL, 0, USB_CTRL_SET_TIMEOUT)) < 0) diff --git a/trunk/drivers/usb/core/usb.c b/trunk/drivers/usb/core/usb.c index 13d1d367f7f1..e80ef9467825 100644 --- a/trunk/drivers/usb/core/usb.c +++ b/trunk/drivers/usb/core/usb.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -46,7 +47,165 @@ const char *usbcore_name = "usbcore"; static int nousb; /* Disable USB when built into kernel image */ + /* Not honored on modular build */ +static DECLARE_RWSEM(usb_all_devices_rwsem); + + +static int generic_probe (struct device *dev) +{ + return 0; +} +static int generic_remove (struct device *dev) +{ + struct usb_device *udev = to_usb_device(dev); + + /* if this is only an unbind, not a physical disconnect, then + * unconfigure the device */ + if (udev->state == USB_STATE_CONFIGURED) + usb_set_configuration(udev, 0); + + /* in case the call failed or the device was suspended */ + if (udev->state >= USB_STATE_CONFIGURED) + usb_disable_device(udev, 0); + return 0; +} + +static struct device_driver usb_generic_driver = { + .owner = THIS_MODULE, + .name = "usb", + .bus = &usb_bus_type, + .probe = generic_probe, + .remove = generic_remove, +}; + +static int usb_generic_driver_data; + +/* called from driver core with usb_bus_type.subsys writelock */ +static int usb_probe_interface(struct device *dev) +{ + struct usb_interface * intf = to_usb_interface(dev); + struct usb_driver * driver = to_usb_driver(dev->driver); + const struct usb_device_id *id; + int error = -ENODEV; + + dev_dbg(dev, "%s\n", __FUNCTION__); + + if (!driver->probe) + return error; + /* FIXME we'd much prefer to just resume it ... */ + if (interface_to_usbdev(intf)->state == USB_STATE_SUSPENDED) + return -EHOSTUNREACH; + + id = usb_match_id (intf, driver->id_table); + if (id) { + dev_dbg (dev, "%s - got id\n", __FUNCTION__); + + /* Interface "power state" doesn't correspond to any hardware + * state whatsoever. We use it to record when it's bound to + * a driver that may start I/0: it's not frozen/quiesced. + */ + mark_active(intf); + intf->condition = USB_INTERFACE_BINDING; + error = driver->probe (intf, id); + if (error) { + mark_quiesced(intf); + intf->condition = USB_INTERFACE_UNBOUND; + } else + intf->condition = USB_INTERFACE_BOUND; + } + + return error; +} + +/* called from driver core with usb_bus_type.subsys writelock */ +static int usb_unbind_interface(struct device *dev) +{ + struct usb_interface *intf = to_usb_interface(dev); + struct usb_driver *driver = to_usb_driver(intf->dev.driver); + + intf->condition = USB_INTERFACE_UNBINDING; + + /* release all urbs for this interface */ + usb_disable_interface(interface_to_usbdev(intf), intf); + + if (driver && driver->disconnect) + driver->disconnect(intf); + + /* reset other interface state */ + usb_set_interface(interface_to_usbdev(intf), + intf->altsetting[0].desc.bInterfaceNumber, + 0); + usb_set_intfdata(intf, NULL); + intf->condition = USB_INTERFACE_UNBOUND; + mark_quiesced(intf); + + return 0; +} + +/** + * usb_register - register a USB driver + * @new_driver: USB operations for the driver + * + * Registers a USB driver with the USB core. The list of unattached + * interfaces will be rescanned whenever a new driver is added, allowing + * the new driver to attach to any recognized devices. + * Returns a negative error code on failure and 0 on success. + * + * NOTE: if you want your driver to use the USB major number, you must call + * usb_register_dev() to enable that functionality. This function no longer + * takes care of that. + */ +int usb_register(struct usb_driver *new_driver) +{ + int retval = 0; + + if (nousb) + return -ENODEV; + + new_driver->driver.name = (char *)new_driver->name; + new_driver->driver.bus = &usb_bus_type; + new_driver->driver.probe = usb_probe_interface; + new_driver->driver.remove = usb_unbind_interface; + new_driver->driver.owner = new_driver->owner; + + usb_lock_all_devices(); + retval = driver_register(&new_driver->driver); + usb_unlock_all_devices(); + + if (!retval) { + pr_info("%s: registered new driver %s\n", + usbcore_name, new_driver->name); + usbfs_update_special(); + } else { + printk(KERN_ERR "%s: error %d registering driver %s\n", + usbcore_name, retval, new_driver->name); + } + + return retval; +} + +/** + * usb_deregister - unregister a USB driver + * @driver: USB operations of the driver to unregister + * Context: must be able to sleep + * + * Unlinks the specified driver from the internal USB driver list. + * + * NOTE: If you called usb_register_dev(), you still need to call + * usb_deregister_dev() to clean up your driver's allocated minor numbers, + * this * call will no longer do it for you. + */ +void usb_deregister(struct usb_driver *driver) +{ + pr_info("%s: deregistering driver %s\n", usbcore_name, driver->name); + + usb_lock_all_devices(); + driver_unregister (&driver->driver); + usb_unlock_all_devices(); + + usbfs_update_special(); +} /** * usb_ifnum_to_if - get the interface object with a given interface number @@ -193,23 +352,151 @@ void usb_driver_release_interface(struct usb_driver *driver, mark_quiesced(iface); } -struct find_interface_arg { - int minor; - struct usb_interface *interface; -}; +/** + * usb_match_id - find first usb_device_id matching device or interface + * @interface: the interface of interest + * @id: array of usb_device_id structures, terminated by zero entry + * + * usb_match_id searches an array of usb_device_id's and returns + * the first one matching the device or interface, or null. + * This is used when binding (or rebinding) a driver to an interface. + * Most USB device drivers will use this indirectly, through the usb core, + * but some layered driver frameworks use it directly. + * These device tables are exported with MODULE_DEVICE_TABLE, through + * modutils and "modules.usbmap", to support the driver loading + * functionality of USB hotplugging. + * + * What Matches: + * + * The "match_flags" element in a usb_device_id controls which + * members are used. If the corresponding bit is set, the + * value in the device_id must match its corresponding member + * in the device or interface descriptor, or else the device_id + * does not match. + * + * "driver_info" is normally used only by device drivers, + * but you can create a wildcard "matches anything" usb_device_id + * as a driver's "modules.usbmap" entry if you provide an id with + * only a nonzero "driver_info" field. If you do this, the USB device + * driver's probe() routine should use additional intelligence to + * decide whether to bind to the specified interface. + * + * What Makes Good usb_device_id Tables: + * + * The match algorithm is very simple, so that intelligence in + * driver selection must come from smart driver id records. + * Unless you have good reasons to use another selection policy, + * provide match elements only in related groups, and order match + * specifiers from specific to general. Use the macros provided + * for that purpose if you can. + * + * The most specific match specifiers use device descriptor + * data. These are commonly used with product-specific matches; + * the USB_DEVICE macro lets you provide vendor and product IDs, + * and you can also match against ranges of product revisions. + * These are widely used for devices with application or vendor + * specific bDeviceClass values. + * + * Matches based on device class/subclass/protocol specifications + * are slightly more general; use the USB_DEVICE_INFO macro, or + * its siblings. These are used with single-function devices + * where bDeviceClass doesn't specify that each interface has + * its own class. + * + * Matches based on interface class/subclass/protocol are the + * most general; they let drivers bind to any interface on a + * multiple-function device. Use the USB_INTERFACE_INFO + * macro, or its siblings, to match class-per-interface style + * devices (as recorded in bDeviceClass). + * + * Within those groups, remember that not all combinations are + * meaningful. For example, don't give a product version range + * without vendor and product IDs; or specify a protocol without + * its associated class and subclass. + */ +const struct usb_device_id * +usb_match_id(struct usb_interface *interface, const struct usb_device_id *id) +{ + struct usb_host_interface *intf; + struct usb_device *dev; + + /* proc_connectinfo in devio.c may call us with id == NULL. */ + if (id == NULL) + return NULL; + + intf = interface->cur_altsetting; + dev = interface_to_usbdev(interface); + + /* It is important to check that id->driver_info is nonzero, + since an entry that is all zeroes except for a nonzero + id->driver_info is the way to create an entry that + indicates that the driver want to examine every + device and interface. */ + for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass || + id->driver_info; id++) { + + if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) && + id->idVendor != le16_to_cpu(dev->descriptor.idVendor)) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) && + id->idProduct != le16_to_cpu(dev->descriptor.idProduct)) + continue; + + /* No need to test id->bcdDevice_lo != 0, since 0 is never + greater than any unsigned number. */ + if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) && + (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice))) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) && + (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice))) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) && + (id->bDeviceClass != dev->descriptor.bDeviceClass)) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) && + (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass)) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) && + (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol)) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) && + (id->bInterfaceClass != intf->desc.bInterfaceClass)) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) && + (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass)) + continue; + + if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) && + (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol)) + continue; + + return id; + } + + return NULL; +} + static int __find_interface(struct device * dev, void * data) { - struct find_interface_arg *arg = data; - struct usb_interface *intf; + struct usb_interface ** ret = (struct usb_interface **)data; + struct usb_interface * intf = *ret; + int *minor = (int *)data; /* can't look at usb devices, only interfaces */ if (dev->driver == &usb_generic_driver) return 0; intf = to_usb_interface(dev); - if (intf->minor != -1 && intf->minor == arg->minor) { - arg->interface = intf; + if (intf->minor != -1 && intf->minor == *minor) { + *ret = intf; return 1; } return 0; @@ -226,18 +513,42 @@ static int __find_interface(struct device * dev, void * data) */ struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor) { - struct find_interface_arg argb; + struct usb_interface *intf = (struct usb_interface *)(long)minor; + int ret; + + ret = driver_for_each_device(&drv->driver, NULL, &intf, __find_interface); + + return ret ? intf : NULL; +} + +static int usb_device_match (struct device *dev, struct device_driver *drv) +{ + struct usb_interface *intf; + struct usb_driver *usb_drv; + const struct usb_device_id *id; + + /* check for generic driver, which we don't match any device with */ + if (drv == &usb_generic_driver) + return 0; + + intf = to_usb_interface(dev); + usb_drv = to_usb_driver(drv); + + id = usb_match_id (intf, usb_drv->id_table); + if (id) + return 1; - argb.minor = minor; - argb.interface = NULL; - driver_for_each_device(&drv->driver, NULL, &argb, __find_interface); - return argb.interface; + return 0; } + #ifdef CONFIG_HOTPLUG /* - * This sends an uevent to userspace, typically helping to load driver + * USB hotplugging invokes what /proc/sys/kernel/hotplug says + * (normally /sbin/hotplug) when USB devices get added or removed. + * + * This invokes a user mode policy agent, typically helping to load driver * or other modules, configure the device, and more. Drivers can provide * a MODULE_DEVICE_TABLE to help with module loading subtasks. * @@ -246,8 +557,8 @@ struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor) * delays in event delivery. Use sysfs (and DEVPATH) to make sure the * device (and this configuration!) are still present. */ -static int usb_uevent(struct device *dev, char **envp, int num_envp, - char *buffer, int buffer_size) +static int usb_hotplug (struct device *dev, char **envp, int num_envp, + char *buffer, int buffer_size) { struct usb_interface *intf; struct usb_device *usb_dev; @@ -259,7 +570,7 @@ static int usb_uevent(struct device *dev, char **envp, int num_envp, return -ENODEV; /* driver is often null here; dev_dbg() would oops */ - pr_debug ("usb %s: uevent\n", dev->bus_id); + pr_debug ("usb %s: hotplug\n", dev->bus_id); /* Must check driver_data here, as on remove driver is always NULL */ if ((dev->driver == &usb_generic_driver) || @@ -286,51 +597,51 @@ static int usb_uevent(struct device *dev, char **envp, int num_envp, * * FIXME reduce hardwired intelligence here */ - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "DEVICE=/proc/bus/usb/%03d/%03d", - usb_dev->bus->busnum, usb_dev->devnum)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "DEVICE=/proc/bus/usb/%03d/%03d", + usb_dev->bus->busnum, usb_dev->devnum)) return -ENOMEM; #endif /* per-device configurations are common */ - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "PRODUCT=%x/%x/%x", - le16_to_cpu(usb_dev->descriptor.idVendor), - le16_to_cpu(usb_dev->descriptor.idProduct), - le16_to_cpu(usb_dev->descriptor.bcdDevice))) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "PRODUCT=%x/%x/%x", + le16_to_cpu(usb_dev->descriptor.idVendor), + le16_to_cpu(usb_dev->descriptor.idProduct), + le16_to_cpu(usb_dev->descriptor.bcdDevice))) return -ENOMEM; /* class-based driver binding models */ - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "TYPE=%d/%d/%d", - usb_dev->descriptor.bDeviceClass, - usb_dev->descriptor.bDeviceSubClass, - usb_dev->descriptor.bDeviceProtocol)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "TYPE=%d/%d/%d", + usb_dev->descriptor.bDeviceClass, + usb_dev->descriptor.bDeviceSubClass, + usb_dev->descriptor.bDeviceProtocol)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "INTERFACE=%d/%d/%d", - alt->desc.bInterfaceClass, - alt->desc.bInterfaceSubClass, - alt->desc.bInterfaceProtocol)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "INTERFACE=%d/%d/%d", + alt->desc.bInterfaceClass, + alt->desc.bInterfaceSubClass, + alt->desc.bInterfaceProtocol)) return -ENOMEM; - if (add_uevent_var(envp, num_envp, &i, - buffer, buffer_size, &length, - "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X", - le16_to_cpu(usb_dev->descriptor.idVendor), - le16_to_cpu(usb_dev->descriptor.idProduct), - le16_to_cpu(usb_dev->descriptor.bcdDevice), - usb_dev->descriptor.bDeviceClass, - usb_dev->descriptor.bDeviceSubClass, - usb_dev->descriptor.bDeviceProtocol, - alt->desc.bInterfaceClass, - alt->desc.bInterfaceSubClass, - alt->desc.bInterfaceProtocol)) + if (add_hotplug_env_var(envp, num_envp, &i, + buffer, buffer_size, &length, + "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X", + le16_to_cpu(usb_dev->descriptor.idVendor), + le16_to_cpu(usb_dev->descriptor.idProduct), + le16_to_cpu(usb_dev->descriptor.bcdDevice), + usb_dev->descriptor.bDeviceClass, + usb_dev->descriptor.bDeviceSubClass, + usb_dev->descriptor.bDeviceProtocol, + alt->desc.bInterfaceClass, + alt->desc.bInterfaceSubClass, + alt->desc.bInterfaceProtocol)) return -ENOMEM; envp[i] = NULL; @@ -340,7 +651,7 @@ static int usb_uevent(struct device *dev, char **envp, int num_envp, #else -static int usb_uevent(struct device *dev, char **envp, +static int usb_hotplug (struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { return -ENODEV; @@ -439,11 +750,12 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1) /* hub driver sets up TT records */ } - dev->portnum = port1; dev->bus = bus; dev->parent = parent; INIT_LIST_HEAD(&dev->filelist); + init_MUTEX(&dev->serialize); + return dev; } @@ -516,20 +828,75 @@ void usb_put_intf(struct usb_interface *intf) /* USB device locking * - * USB devices and interfaces are locked using the semaphore in their - * embedded struct device. The hub driver guarantees that whenever a - * device is connected or disconnected, drivers are called with the - * USB device locked as well as their particular interface. + * Although locking USB devices should be straightforward, it is + * complicated by the way the driver-model core works. When a new USB + * driver is registered or unregistered, the core will automatically + * probe or disconnect all matching interfaces on all USB devices while + * holding the USB subsystem writelock. There's no good way for us to + * tell which devices will be used or to lock them beforehand; our only + * option is to effectively lock all the USB devices. + * + * We do that by using a private rw-semaphore, usb_all_devices_rwsem. + * When locking an individual device you must first acquire the rwsem's + * readlock. When a driver is registered or unregistered the writelock + * must be held. These actions are encapsulated in the subroutines + * below, so all a driver needs to do is call usb_lock_device() and + * usb_unlock_device(). * * Complications arise when several devices are to be locked at the same * time. Only hub-aware drivers that are part of usbcore ever have to - * do this; nobody else needs to worry about it. The rule for locking - * is simple: + * do this; nobody else needs to worry about it. The problem is that + * usb_lock_device() must not be called to lock a second device since it + * would acquire the rwsem's readlock reentrantly, leading to deadlock if + * another thread was waiting for the writelock. The solution is simple: + * + * When locking more than one device, call usb_lock_device() + * to lock the first one. Lock the others by calling + * down(&udev->serialize) directly. + * + * When unlocking multiple devices, use up(&udev->serialize) + * to unlock all but the last one. Unlock the last one by + * calling usb_unlock_device(). * * When locking both a device and its parent, always lock the * the parent first. */ +/** + * usb_lock_device - acquire the lock for a usb device structure + * @udev: device that's being locked + * + * Use this routine when you don't hold any other device locks; + * to acquire nested inner locks call down(&udev->serialize) directly. + * This is necessary for proper interaction with usb_lock_all_devices(). + */ +void usb_lock_device(struct usb_device *udev) +{ + down_read(&usb_all_devices_rwsem); + down(&udev->serialize); +} + +/** + * usb_trylock_device - attempt to acquire the lock for a usb device structure + * @udev: device that's being locked + * + * Don't use this routine if you already hold a device lock; + * use down_trylock(&udev->serialize) instead. + * This is necessary for proper interaction with usb_lock_all_devices(). + * + * Returns 1 if successful, 0 if contention. + */ +int usb_trylock_device(struct usb_device *udev) +{ + if (!down_read_trylock(&usb_all_devices_rwsem)) + return 0; + if (down_trylock(&udev->serialize)) { + up_read(&usb_all_devices_rwsem); + return 0; + } + return 1; +} + /** * usb_lock_device_for_reset - cautiously acquire the lock for a * usb device structure @@ -568,7 +935,7 @@ int usb_lock_device_for_reset(struct usb_device *udev, } } - while (usb_trylock_device(udev) != 0) { + while (!usb_trylock_device(udev)) { /* If we can't acquire the lock after waiting one second, * we're probably deadlocked */ @@ -586,6 +953,39 @@ int usb_lock_device_for_reset(struct usb_device *udev, return 1; } +/** + * usb_unlock_device - release the lock for a usb device structure + * @udev: device that's being unlocked + * + * Use this routine when releasing the only device lock you hold; + * to release inner nested locks call up(&udev->serialize) directly. + * This is necessary for proper interaction with usb_lock_all_devices(). + */ +void usb_unlock_device(struct usb_device *udev) +{ + up(&udev->serialize); + up_read(&usb_all_devices_rwsem); +} + +/** + * usb_lock_all_devices - acquire the lock for all usb device structures + * + * This is necessary when registering a new driver or probing a bus, + * since the driver-model core may try to use any usb_device. + */ +void usb_lock_all_devices(void) +{ + down_write(&usb_all_devices_rwsem); +} + +/** + * usb_unlock_all_devices - release the lock for all usb device structures + */ +void usb_unlock_all_devices(void) +{ + up_write(&usb_all_devices_rwsem); +} + static struct usb_device *match_device(struct usb_device *dev, u16 vendor_id, u16 product_id) @@ -608,10 +1008,10 @@ static struct usb_device *match_device(struct usb_device *dev, /* look through all of the children of this device */ for (child = 0; child < dev->maxchild; ++child) { if (dev->children[child]) { - usb_lock_device(dev->children[child]); + down(&dev->children[child]->serialize); ret_dev = match_device(dev->children[child], vendor_id, product_id); - usb_unlock_device(dev->children[child]); + up(&dev->children[child]->serialize); if (ret_dev) goto exit; } @@ -1091,13 +1491,23 @@ static int usb_generic_resume(struct device *dev) struct bus_type usb_bus_type = { .name = "usb", .match = usb_device_match, - .uevent = usb_uevent, + .hotplug = usb_hotplug, .suspend = usb_generic_suspend, .resume = usb_generic_resume, }; +#ifndef MODULE + +static int __init usb_setup_disable(char *str) +{ + nousb = 1; + return 1; +} + /* format to disable USB on kernel command line is: nousb */ -__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444); +__setup("nousb", usb_setup_disable); + +#endif /* * for external read access to @@ -1188,6 +1598,8 @@ module_exit(usb_exit); * driver modules to use. */ +EXPORT_SYMBOL(usb_register); +EXPORT_SYMBOL(usb_deregister); EXPORT_SYMBOL(usb_disabled); EXPORT_SYMBOL_GPL(usb_get_intf); @@ -1198,10 +1610,14 @@ EXPORT_SYMBOL(usb_put_dev); EXPORT_SYMBOL(usb_get_dev); EXPORT_SYMBOL(usb_hub_tt_clear_buffer); +EXPORT_SYMBOL(usb_lock_device); +EXPORT_SYMBOL(usb_trylock_device); EXPORT_SYMBOL(usb_lock_device_for_reset); +EXPORT_SYMBOL(usb_unlock_device); EXPORT_SYMBOL(usb_driver_claim_interface); EXPORT_SYMBOL(usb_driver_release_interface); +EXPORT_SYMBOL(usb_match_id); EXPORT_SYMBOL(usb_find_interface); EXPORT_SYMBOL(usb_ifnum_to_if); EXPORT_SYMBOL(usb_altnum_to_altsetting); diff --git a/trunk/drivers/usb/core/usb.h b/trunk/drivers/usb/core/usb.h index 4647e1ebc68d..1c4a68499dce 100644 --- a/trunk/drivers/usb/core/usb.h +++ b/trunk/drivers/usb/core/usb.h @@ -16,6 +16,9 @@ extern int usb_get_device_descriptor(struct usb_device *dev, extern char *usb_cache_string(struct usb_device *udev, int index); extern int usb_set_configuration(struct usb_device *dev, int configuration); +extern void usb_lock_all_devices(void); +extern void usb_unlock_all_devices(void); + extern void usb_kick_khubd(struct usb_device *dev); extern void usb_suspend_root_hub(struct usb_device *hdev); extern void usb_resume_root_hub(struct usb_device *dev); @@ -30,9 +33,6 @@ extern void usb_host_cleanup(void); extern int usb_suspend_device(struct usb_device *dev); extern int usb_resume_device(struct usb_device *dev); -extern struct device_driver usb_generic_driver; -extern int usb_generic_driver_data; -extern int usb_device_match(struct device *dev, struct device_driver *drv); /* Interfaces and their "power state" are owned by usbcore */ diff --git a/trunk/drivers/usb/gadget/dummy_hcd.c b/trunk/drivers/usb/gadget/dummy_hcd.c index 9734cb76dd6c..c655d46c8aed 100644 --- a/trunk/drivers/usb/gadget/dummy_hcd.c +++ b/trunk/drivers/usb/gadget/dummy_hcd.c @@ -138,7 +138,7 @@ static const char *const ep_name [] = { /* or like sa1100: two fixed function endpoints */ "ep1out-bulk", "ep2in-bulk", }; -#define DUMMY_ENDPOINTS ARRAY_SIZE(ep_name) +#define DUMMY_ENDPOINTS (sizeof(ep_name)/sizeof(char *)) /*-------------------------------------------------------------------------*/ @@ -896,7 +896,7 @@ dummy_gadget_release (struct device *dev) #endif } -static int dummy_udc_probe (struct platform_device *pdev) +static int dummy_udc_probe (struct platform_device *dev) { struct dummy *dum = the_controller; int rc; @@ -909,7 +909,7 @@ static int dummy_udc_probe (struct platform_device *pdev) dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0); strcpy (dum->gadget.dev.bus_id, "gadget"); - dum->gadget.dev.parent = &pdev->dev; + dum->gadget.dev.parent = &dev->dev; dum->gadget.dev.release = dummy_gadget_release; rc = device_register (&dum->gadget.dev); if (rc < 0) @@ -919,47 +919,47 @@ static int dummy_udc_probe (struct platform_device *pdev) usb_bus_get (&dummy_to_hcd (dum)->self); #endif - platform_set_drvdata (pdev, dum); + platform_set_drvdata (dev, dum); device_create_file (&dum->gadget.dev, &dev_attr_function); return rc; } -static int dummy_udc_remove (struct platform_device *pdev) +static int dummy_udc_remove (struct platform_device *dev) { - struct dummy *dum = platform_get_drvdata (pdev); + struct dummy *dum = platform_get_drvdata (dev); - platform_set_drvdata (pdev, NULL); + platform_set_drvdata (dev, NULL); device_remove_file (&dum->gadget.dev, &dev_attr_function); device_unregister (&dum->gadget.dev); return 0; } -static int dummy_udc_suspend (struct platform_device *pdev, pm_message_t state) +static int dummy_udc_suspend (struct platform_device *dev, pm_message_t state) { - struct dummy *dum = platform_get_drvdata(pdev); + struct dummy *dum = platform_get_drvdata(dev); - dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); + dev_dbg (&dev->dev, "%s\n", __FUNCTION__); spin_lock_irq (&dum->lock); dum->udc_suspended = 1; set_link_state (dum); spin_unlock_irq (&dum->lock); - pdev->dev.power.power_state = state; + dev->dev.power.power_state = state; usb_hcd_poll_rh_status (dummy_to_hcd (dum)); return 0; } -static int dummy_udc_resume (struct platform_device *pdev) +static int dummy_udc_resume (struct platform_device *dev) { - struct dummy *dum = platform_get_drvdata(pdev); + struct dummy *dum = platform_get_drvdata(dev); - dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); + dev_dbg (&dev->dev, "%s\n", __FUNCTION__); spin_lock_irq (&dum->lock); dum->udc_suspended = 0; set_link_state (dum); spin_unlock_irq (&dum->lock); - pdev->dev.power.power_state = PMSG_ON; + dev->dev.power.power_state = PMSG_ON; usb_hcd_poll_rh_status (dummy_to_hcd (dum)); return 0; } @@ -1576,7 +1576,7 @@ static int dummy_hub_status (struct usb_hcd *hcd, char *buf) dum = hcd_to_dummy (hcd); spin_lock_irqsave (&dum->lock, flags); - if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) + if (hcd->state != HC_STATE_RUNNING) goto done; if (dum->resuming && time_after_eq (jiffies, dum->re_timeout)) { @@ -1623,7 +1623,7 @@ static int dummy_hub_control ( int retval = 0; unsigned long flags; - if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) + if (hcd->state != HC_STATE_RUNNING) return -ETIMEDOUT; dum = hcd_to_dummy (hcd); @@ -1756,12 +1756,9 @@ static int dummy_bus_suspend (struct usb_hcd *hcd) { struct dummy *dum = hcd_to_dummy (hcd); - dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__); - spin_lock_irq (&dum->lock); dum->rh_state = DUMMY_RH_SUSPENDED; set_link_state (dum); - hcd->state = HC_STATE_SUSPENDED; spin_unlock_irq (&dum->lock); return 0; } @@ -1769,23 +1766,14 @@ static int dummy_bus_suspend (struct usb_hcd *hcd) static int dummy_bus_resume (struct usb_hcd *hcd) { struct dummy *dum = hcd_to_dummy (hcd); - int rc = 0; - - dev_dbg (&hcd->self.root_hub->dev, "%s\n", __FUNCTION__); spin_lock_irq (&dum->lock); - if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) { - dev_warn (&hcd->self.root_hub->dev, "HC isn't running!\n"); - rc = -ENODEV; - } else { - dum->rh_state = DUMMY_RH_RUNNING; - set_link_state (dum); - if (!list_empty(&dum->urbp_list)) - mod_timer (&dum->timer, jiffies); - hcd->state = HC_STATE_RUNNING; - } + dum->rh_state = DUMMY_RH_RUNNING; + set_link_state (dum); + if (!list_empty(&dum->urbp_list)) + mod_timer (&dum->timer, jiffies); spin_unlock_irq (&dum->lock); - return rc; + return 0; } /*-------------------------------------------------------------------------*/ @@ -1911,14 +1899,14 @@ static const struct hc_driver dummy_hcd = { .bus_resume = dummy_bus_resume, }; -static int dummy_hcd_probe(struct platform_device *pdev) +static int dummy_hcd_probe (struct platform_device *dev) { struct usb_hcd *hcd; int retval; - dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc); + dev_info(&dev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc); - hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, pdev->dev.bus_id); + hcd = usb_create_hcd (&dummy_hcd, &dev->dev, dev->dev.bus_id); if (!hcd) return -ENOMEM; the_controller = hcd_to_dummy (hcd); @@ -1931,43 +1919,36 @@ static int dummy_hcd_probe(struct platform_device *pdev) return retval; } -static int dummy_hcd_remove (struct platform_device *pdev) +static int dummy_hcd_remove (struct platform_device *dev) { struct usb_hcd *hcd; - hcd = platform_get_drvdata (pdev); + hcd = platform_get_drvdata (dev); usb_remove_hcd (hcd); usb_put_hcd (hcd); the_controller = NULL; return 0; } -static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state) +static int dummy_hcd_suspend (struct platform_device *dev, pm_message_t state) { struct usb_hcd *hcd; - struct dummy *dum; - int rc = 0; - dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); + dev_dbg (&dev->dev, "%s\n", __FUNCTION__); + hcd = platform_get_drvdata (dev); - hcd = platform_get_drvdata (pdev); - dum = hcd_to_dummy (hcd); - if (dum->rh_state == DUMMY_RH_RUNNING) { - dev_warn(&pdev->dev, "Root hub isn't suspended!\n"); - rc = -EBUSY; - } else - clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); - return rc; + hcd->state = HC_STATE_SUSPENDED; + return 0; } -static int dummy_hcd_resume (struct platform_device *pdev) +static int dummy_hcd_resume (struct platform_device *dev) { struct usb_hcd *hcd; - dev_dbg (&pdev->dev, "%s\n", __FUNCTION__); + dev_dbg (&dev->dev, "%s\n", __FUNCTION__); + hcd = platform_get_drvdata (dev); + hcd->state = HC_STATE_RUNNING; - hcd = platform_get_drvdata (pdev); - set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); usb_hcd_poll_rh_status (hcd); return 0; } diff --git a/trunk/drivers/usb/gadget/file_storage.c b/trunk/drivers/usb/gadget/file_storage.c index 0cea9782d7d4..ea09aaa3cab6 100644 --- a/trunk/drivers/usb/gadget/file_storage.c +++ b/trunk/drivers/usb/gadget/file_storage.c @@ -224,7 +224,6 @@ #include #include #include -#include #include #include #include @@ -239,6 +238,7 @@ #include #include #include +#include #include #include @@ -250,7 +250,7 @@ #define DRIVER_DESC "File-backed Storage Gadget" #define DRIVER_NAME "g_file_storage" -#define DRIVER_VERSION "28 November 2005" +#define DRIVER_VERSION "20 October 2004" static const char longname[] = DRIVER_DESC; static const char shortname[] = DRIVER_NAME; @@ -335,8 +335,8 @@ MODULE_LICENSE("Dual BSD/GPL"); #define MAX_LUNS 8 /* Arggh! There should be a module_param_array_named macro! */ -static char *file[MAX_LUNS]; -static int ro[MAX_LUNS]; +static char *file[MAX_LUNS] = {NULL, }; +static int ro[MAX_LUNS] = {0, }; static struct { int num_filenames; @@ -587,7 +587,7 @@ enum fsg_buffer_state { struct fsg_buffhd { void *buf; dma_addr_t dma; - enum fsg_buffer_state state; + volatile enum fsg_buffer_state state; struct fsg_buffhd *next; /* The NetChip 2280 is faster, and handles some protocol faults @@ -596,9 +596,9 @@ struct fsg_buffhd { unsigned int bulk_out_intended_length; struct usb_request *inreq; - int inreq_busy; + volatile int inreq_busy; struct usb_request *outreq; - int outreq_busy; + volatile int outreq_busy; }; enum fsg_state { @@ -631,16 +631,13 @@ struct fsg_dev { /* filesem protects: backing files in use */ struct rw_semaphore filesem; - /* reference counting: wait until all LUNs are released */ - struct kref ref; - struct usb_ep *ep0; // Handy copy of gadget->ep0 struct usb_request *ep0req; // For control responses - unsigned int ep0_req_tag; + volatile unsigned int ep0_req_tag; const char *ep0req_name; struct usb_request *intreq; // For interrupt responses - int intreq_busy; + volatile int intreq_busy; struct fsg_buffhd *intr_buffhd; unsigned int bulk_out_maxpacket; @@ -670,6 +667,7 @@ struct fsg_dev { struct fsg_buffhd *next_buffhd_to_drain; struct fsg_buffhd buffhds[NUM_BUFFERS]; + wait_queue_head_t thread_wqh; int thread_wakeup_needed; struct completion thread_notifier; struct task_struct *thread_task; @@ -696,6 +694,7 @@ struct fsg_dev { unsigned int nluns; struct lun *luns; struct lun *curlun; + struct completion lun_released; }; typedef void (*fsg_routine_t)(struct fsg_dev *); @@ -1074,13 +1073,11 @@ static int populate_config_buf(struct usb_gadget *gadget, /* These routines may be called in process context or in_irq */ -/* Caller must hold fsg->lock */ static void wakeup_thread(struct fsg_dev *fsg) { /* Tell the main thread that something has happened */ fsg->thread_wakeup_needed = 1; - if (fsg->thread_task) - wake_up_process(fsg->thread_task); + wake_up_all(&fsg->thread_wqh); } @@ -1167,12 +1164,11 @@ static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req) usb_ep_fifo_flush(ep); /* Hold the lock while we update the request and buffer states */ - smp_wmb(); spin_lock(&fsg->lock); bh->inreq_busy = 0; bh->state = BUF_STATE_EMPTY; - wakeup_thread(fsg); spin_unlock(&fsg->lock); + wakeup_thread(fsg); } static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req) @@ -1189,12 +1185,11 @@ static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req) usb_ep_fifo_flush(ep); /* Hold the lock while we update the request and buffer states */ - smp_wmb(); spin_lock(&fsg->lock); bh->outreq_busy = 0; bh->state = BUF_STATE_FULL; - wakeup_thread(fsg); spin_unlock(&fsg->lock); + wakeup_thread(fsg); } @@ -1211,12 +1206,11 @@ static void intr_in_complete(struct usb_ep *ep, struct usb_request *req) usb_ep_fifo_flush(ep); /* Hold the lock while we update the request and buffer states */ - smp_wmb(); spin_lock(&fsg->lock); fsg->intreq_busy = 0; bh->state = BUF_STATE_EMPTY; - wakeup_thread(fsg); spin_unlock(&fsg->lock); + wakeup_thread(fsg); } #else @@ -1267,8 +1261,8 @@ static void received_cbi_adsc(struct fsg_dev *fsg, struct fsg_buffhd *bh) fsg->cbbuf_cmnd_size = req->actual; memcpy(fsg->cbbuf_cmnd, req->buf, fsg->cbbuf_cmnd_size); - wakeup_thread(fsg); spin_unlock(&fsg->lock); + wakeup_thread(fsg); } #else @@ -1520,8 +1514,8 @@ static int fsg_setup(struct usb_gadget *gadget, /* Use this for bulk or interrupt transfers, not ep0 */ static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep, - struct usb_request *req, int *pbusy, - enum fsg_buffer_state *state) + struct usb_request *req, volatile int *pbusy, + volatile enum fsg_buffer_state *state) { int rc; @@ -1529,11 +1523,8 @@ static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep, dump_msg(fsg, "bulk-in", req->buf, req->length); else if (ep == fsg->intr_in) dump_msg(fsg, "intr-in", req->buf, req->length); - - spin_lock_irq(&fsg->lock); *pbusy = 1; *state = BUF_STATE_BUSY; - spin_unlock_irq(&fsg->lock); rc = usb_ep_queue(ep, req, GFP_KERNEL); if (rc != 0) { *pbusy = 0; @@ -1553,23 +1544,14 @@ static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep, static int sleep_thread(struct fsg_dev *fsg) { - int rc = 0; + int rc; /* Wait until a signal arrives or we are woken up */ - for (;;) { - try_to_freeze(); - set_current_state(TASK_INTERRUPTIBLE); - if (signal_pending(current)) { - rc = -EINTR; - break; - } - if (fsg->thread_wakeup_needed) - break; - schedule(); - } - __set_current_state(TASK_RUNNING); + rc = wait_event_interruptible(fsg->thread_wqh, + fsg->thread_wakeup_needed); fsg->thread_wakeup_needed = 0; - return rc; + try_to_freeze(); + return (rc ? -EINTR : 0); } @@ -1806,7 +1788,6 @@ static int do_write(struct fsg_dev *fsg) if (bh->state == BUF_STATE_EMPTY && !get_some_more) break; // We stopped early if (bh->state == BUF_STATE_FULL) { - smp_rmb(); fsg->next_buffhd_to_drain = bh->next; bh->state = BUF_STATE_EMPTY; @@ -2375,7 +2356,6 @@ static int throw_away_data(struct fsg_dev *fsg) /* Throw away the data in a filled buffer */ if (bh->state == BUF_STATE_FULL) { - smp_rmb(); bh->state = BUF_STATE_EMPTY; fsg->next_buffhd_to_drain = bh->next; @@ -3041,7 +3021,6 @@ static int get_next_command(struct fsg_dev *fsg) if ((rc = sleep_thread(fsg)) != 0) return rc; } - smp_rmb(); rc = received_cbw(fsg, bh); bh->state = BUF_STATE_EMPTY; @@ -3663,19 +3642,11 @@ static DEVICE_ATTR(file, 0444, show_file, NULL); /*-------------------------------------------------------------------------*/ -static void fsg_release(struct kref *ref) -{ - struct fsg_dev *fsg = container_of(ref, struct fsg_dev, ref); - - kfree(fsg->luns); - kfree(fsg); -} - static void lun_release(struct device *dev) { struct fsg_dev *fsg = (struct fsg_dev *) dev_get_drvdata(dev); - kref_put(&fsg->ref, fsg_release); + complete(&fsg->lun_released); } static void fsg_unbind(struct usb_gadget *gadget) @@ -3689,12 +3660,14 @@ static void fsg_unbind(struct usb_gadget *gadget) clear_bit(REGISTERED, &fsg->atomic_bitflags); /* Unregister the sysfs attribute files and the LUNs */ + init_completion(&fsg->lun_released); for (i = 0; i < fsg->nluns; ++i) { curlun = &fsg->luns[i]; if (curlun->registered) { device_remove_file(&curlun->dev, &dev_attr_ro); device_remove_file(&curlun->dev, &dev_attr_file); device_unregister(&curlun->dev); + wait_for_completion(&fsg->lun_released); curlun->registered = 0; } } @@ -3873,7 +3846,6 @@ static int __init fsg_bind(struct usb_gadget *gadget) curlun->dev.release = lun_release; device_create_file(&curlun->dev, &dev_attr_ro); device_create_file(&curlun->dev, &dev_attr_file); - kref_get(&fsg->ref); } if (file[i] && *file[i]) { @@ -4089,7 +4061,7 @@ static int __init fsg_alloc(void) return -ENOMEM; spin_lock_init(&fsg->lock); init_rwsem(&fsg->filesem); - kref_init(&fsg->ref); + init_waitqueue_head(&fsg->thread_wqh); init_completion(&fsg->thread_notifier); the_fsg = fsg; @@ -4097,6 +4069,13 @@ static int __init fsg_alloc(void) } +static void fsg_free(struct fsg_dev *fsg) +{ + kfree(fsg->luns); + kfree(fsg); +} + + static int __init fsg_init(void) { int rc; @@ -4106,7 +4085,7 @@ static int __init fsg_init(void) return rc; fsg = the_fsg; if ((rc = usb_gadget_register_driver(&fsg_driver)) != 0) - kref_put(&fsg->ref, fsg_release); + fsg_free(fsg); return rc; } module_init(fsg_init); @@ -4124,6 +4103,6 @@ static void __exit fsg_cleanup(void) wait_for_completion(&fsg->thread_notifier); close_all_backing_files(fsg); - kref_put(&fsg->ref, fsg_release); + fsg_free(fsg); } module_exit(fsg_cleanup); diff --git a/trunk/drivers/usb/gadget/serial.c b/trunk/drivers/usb/gadget/serial.c index 65e084a2c87e..b35ac6d334f8 100644 --- a/trunk/drivers/usb/gadget/serial.c +++ b/trunk/drivers/usb/gadget/serial.c @@ -890,12 +890,10 @@ static void gs_close(struct tty_struct *tty, struct file *file) /* wait for write buffer to drain, or */ /* at most GS_CLOSE_TIMEOUT seconds */ if (gs_buf_data_avail(port->port_write_buf) > 0) { - spin_unlock_irqrestore(&port->port_lock, flags); wait_cond_interruptible_timeout(port->port_write_wait, port->port_dev == NULL || gs_buf_data_avail(port->port_write_buf) == 0, &port->port_lock, flags, GS_CLOSE_TIMEOUT * HZ); - spin_lock_irqsave(&port->port_lock, flags); } /* free disconnected port on final close */ diff --git a/trunk/drivers/usb/host/Makefile b/trunk/drivers/usb/host/Makefile index e3020f4b17be..58321d3f314c 100644 --- a/trunk/drivers/usb/host/Makefile +++ b/trunk/drivers/usb/host/Makefile @@ -2,10 +2,6 @@ # Makefile for USB Host Controller Drivers # -ifeq ($(CONFIG_USB_DEBUG),y) - EXTRA_CFLAGS += -DDEBUG -endif - obj-$(CONFIG_PCI) += pci-quirks.o obj-$(CONFIG_USB_EHCI_HCD) += ehci-hcd.o diff --git a/trunk/drivers/usb/host/ehci-hcd.c b/trunk/drivers/usb/host/ehci-hcd.c index 9dd3d14c64f3..29f52a44b928 100644 --- a/trunk/drivers/usb/host/ehci-hcd.c +++ b/trunk/drivers/usb/host/ehci-hcd.c @@ -17,6 +17,13 @@ */ #include + +#ifdef CONFIG_USB_DEBUG + #define DEBUG +#else + #undef DEBUG +#endif + #include #include #include @@ -617,7 +624,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd, struct pt_regs *regs) } /* remote wakeup [4.3.1] */ - if (status & STS_PCD) { + if ((status & STS_PCD) && hcd->remote_wakeup) { unsigned i = HCS_N_PORTS (ehci->hcs_params); /* resume root hub? */ diff --git a/trunk/drivers/usb/host/ehci-hub.c b/trunk/drivers/usb/host/ehci-hub.c index 69b0b9be7a64..82caf336e9b6 100644 --- a/trunk/drivers/usb/host/ehci-hub.c +++ b/trunk/drivers/usb/host/ehci-hub.c @@ -59,7 +59,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd) if ((t1 & PORT_PE) && !(t1 & PORT_OWNER)) t2 |= PORT_SUSPEND; - if (device_may_wakeup(&hcd->self.root_hub->dev)) + if (hcd->remote_wakeup) t2 |= PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E; else t2 &= ~(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E); @@ -517,7 +517,7 @@ static int ehci_hub_control ( if ((temp & PORT_PE) == 0 || (temp & PORT_RESET) != 0) goto error; - if (device_may_wakeup(&hcd->self.root_hub->dev)) + if (hcd->remote_wakeup) temp |= PORT_WAKE_BITS; writel (temp | PORT_SUSPEND, &ehci->regs->port_status [wIndex]); diff --git a/trunk/drivers/usb/host/ehci-pci.c b/trunk/drivers/usb/host/ehci-pci.c index 08ca0f849dab..13f73a836e45 100644 --- a/trunk/drivers/usb/host/ehci-pci.c +++ b/trunk/drivers/usb/host/ehci-pci.c @@ -210,16 +210,7 @@ static int ehci_pci_setup(struct usb_hcd *hcd) /* Serial Bus Release Number is at PCI 0x60 offset */ pci_read_config_byte(pdev, 0x60, &ehci->sbrn); - /* Workaround current PCI init glitch: wakeup bits aren't - * being set from PCI PM capability. - */ - if (!device_can_wakeup(&pdev->dev)) { - u16 port_wake; - - pci_read_config_word(pdev, 0x62, &port_wake); - if (port_wake & 0x0001) - device_init_wakeup(&pdev->dev, 1); - } + /* REVISIT: per-port wake capability (PCI 0x62) currently unused */ retval = ehci_pci_reinit(ehci, pdev); done: @@ -278,6 +269,7 @@ static int ehci_pci_resume(struct usb_hcd *hcd) { struct ehci_hcd *ehci = hcd_to_ehci(hcd); unsigned port; + struct usb_device *root = hcd->self.root_hub; struct pci_dev *pdev = to_pci_dev(hcd->self.controller); int retval = -EINVAL; @@ -311,7 +303,13 @@ static int ehci_pci_resume(struct usb_hcd *hcd) restart: ehci_dbg(ehci, "lost power, restarting\n"); - usb_root_hub_lost_power(hcd->self.root_hub); + for (port = HCS_N_PORTS(ehci->hcs_params); port > 0; ) { + port--; + if (!root->children [port]) + continue; + usb_set_device_state(root->children[port], + USB_STATE_NOTATTACHED); + } /* Else reset, to cope with power loss or flush-to-storage * style "resume" having let BIOS kick in during reboot. diff --git a/trunk/drivers/usb/host/ehci-q.c b/trunk/drivers/usb/host/ehci-q.c index 9b13bf2fa98d..bf03ec0d8ee2 100644 --- a/trunk/drivers/usb/host/ehci-q.c +++ b/trunk/drivers/usb/host/ehci-q.c @@ -514,18 +514,18 @@ qh_urb_transaction ( qtd->urb = urb; qtd_prev->hw_next = QTD_NEXT (qtd->qtd_dma); list_add_tail (&qtd->qtd_list, head); - - /* for zero length DATA stages, STATUS is always IN */ - if (len == 0) - token |= (1 /* "in" */ << 8); } /* * data transfer stage: buffer setup */ - buf = urb->transfer_dma; + if (likely (len > 0)) + buf = urb->transfer_dma; + else + buf = 0; - if (is_input) + /* for zero length DATA stages, STATUS is always IN */ + if (!buf || is_input) token |= (1 /* "in" */ << 8); /* else it's already initted to "out" pid (0 << 8) */ @@ -572,7 +572,7 @@ qh_urb_transaction ( * control requests may need a terminating data "status" ack; * bulk ones may need a terminating short packet (zero length). */ - if (likely (urb->transfer_buffer_length != 0)) { + if (likely (buf != 0)) { int one_more = 0; if (usb_pipecontrol (urb->pipe)) { diff --git a/trunk/drivers/usb/host/hc_crisv10.c b/trunk/drivers/usb/host/hc_crisv10.c index 641268d7e6f3..0eaabeb37ac3 100644 --- a/trunk/drivers/usb/host/hc_crisv10.c +++ b/trunk/drivers/usb/host/hc_crisv10.c @@ -4397,7 +4397,7 @@ static int __init etrax_usb_hc_init(void) device_initialize(&fake_device); kobject_set_name(&fake_device.kobj, "etrax_usb"); kobject_add(&fake_device.kobj); - kobject_uevent(&fake_device.kobj, KOBJ_ADD); + kobject_hotplug(&fake_device.kobj, KOBJ_ADD); hc->bus->controller = &fake_device; usb_register_bus(hc->bus); diff --git a/trunk/drivers/usb/host/isp116x-hcd.c b/trunk/drivers/usb/host/isp116x-hcd.c index 584b8dc65119..82f64986bc22 100644 --- a/trunk/drivers/usb/host/isp116x-hcd.c +++ b/trunk/drivers/usb/host/isp116x-hcd.c @@ -55,13 +55,19 @@ /* enqueuing/finishing log of urbs */ //#define URB_TRACE +#include #include +#include +#include #include -#include -#include +#include +#include +#include +#include #include #include #include +#include #include #include #include @@ -71,10 +77,14 @@ #include #include +#ifndef DEBUG +# define STUB_DEBUG_FILE +#endif + #include "../core/hcd.h" #include "isp116x.h" -#define DRIVER_VERSION "03 Nov 2005" +#define DRIVER_VERSION "05 Aug 2005" #define DRIVER_DESC "ISP116x USB Host Controller Driver" MODULE_DESCRIPTION(DRIVER_DESC); @@ -154,11 +164,13 @@ static void pack_fifo(struct isp116x *isp116x) struct ptd *ptd; int buflen = isp116x->atl_last_dir == PTD_DIR_IN ? isp116x->atl_bufshrt : isp116x->atl_buflen; + int ptd_count = 0; isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT); isp116x_write_reg16(isp116x, HCXFERCTR, buflen); isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET); for (ep = isp116x->atl_active; ep; ep = ep->active) { + ++ptd_count; ptd = &ep->ptd; dump_ptd(ptd); dump_ptd_out_data(ptd, ep->data); @@ -293,8 +305,9 @@ static void postproc_atl_queue(struct isp116x *isp116x) udev = urb->dev; ptd = &ep->ptd; cc = PTD_GET_CC(ptd); - short_not_ok = 1; + spin_lock(&urb->lock); + short_not_ok = 1; /* Data underrun is special. For allowed underrun we clear the error and continue as normal. For @@ -407,7 +420,7 @@ static void postproc_atl_queue(struct isp116x *isp116x) ep->nextpid = 0; break; default: - BUG(); + BUG_ON(1); } spin_unlock(&urb->lock); } @@ -615,12 +628,8 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs) u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT); isp116x_write_reg32(isp116x, HCINTSTAT, intstat); if (intstat & HCINT_UE) { - ERR("Unrecoverable error, HC is dead!\n"); - /* IRQ's are off, we do no DMA, - perfectly ready to die ... */ - hcd->state = HC_STATE_HALT; - ret = IRQ_HANDLED; - goto done; + ERR("Unrecoverable error\n"); + /* What should we do here? Reset? */ } if (intstat & HCINT_RHSC) /* When root hub or any of its ports is going @@ -631,6 +640,7 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs) if (intstat & HCINT_RD) { DBG("---- remote wakeup\n"); usb_hcd_resume_root_hub(hcd); + ret = IRQ_HANDLED; } irqstat &= ~HCuPINT_OPR; ret = IRQ_HANDLED; @@ -641,7 +651,6 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs) } isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb); - done: spin_unlock(&isp116x->lock); return ret; } @@ -715,7 +724,6 @@ static int isp116x_urb_enqueue(struct usb_hcd *hcd, spin_lock_irqsave(&isp116x->lock, flags); if (!HC_IS_RUNNING(hcd->state)) { - kfree(ep); ret = -ENODEV; goto fail; } @@ -880,7 +888,7 @@ static void isp116x_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) { int i; - struct isp116x_ep *ep = hep->hcpriv; + struct isp116x_ep *ep = hep->hcpriv;; if (!ep) return; @@ -908,6 +916,8 @@ static int isp116x_get_frame(struct usb_hcd *hcd) return (int)fmnum; } +/*----------------------------------------------------------------*/ + /* Adapted from ohci-hub.c. Currently we don't support autosuspend. */ @@ -958,10 +968,11 @@ static void isp116x_hub_descriptor(struct isp116x *isp116x, desc->bHubContrCurrent = 0; desc->bNbrPorts = (u8) (reg & 0x3); /* Power switching, device type, overcurrent. */ - desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f)); + desc->wHubCharacteristics = + (__force __u16) cpu_to_le16((u16) ((reg >> 8) & 0x1f)); desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff); /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */ - desc->bitmap[0] = 0; + desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1; desc->bitmap[1] = ~0; } @@ -1148,9 +1159,135 @@ static int isp116x_hub_control(struct usb_hcd *hcd, return ret; } +#ifdef CONFIG_PM + +static int isp116x_bus_suspend(struct usb_hcd *hcd) +{ + struct isp116x *isp116x = hcd_to_isp116x(hcd); + unsigned long flags; + u32 val; + int ret = 0; + + spin_lock_irqsave(&isp116x->lock, flags); + + val = isp116x_read_reg32(isp116x, HCCONTROL); + switch (val & HCCONTROL_HCFS) { + case HCCONTROL_USB_OPER: + hcd->state = HC_STATE_QUIESCING; + val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE); + val |= HCCONTROL_USB_SUSPEND; + if (hcd->remote_wakeup) + val |= HCCONTROL_RWE; + /* Wait for usb transfers to finish */ + mdelay(2); + isp116x_write_reg32(isp116x, HCCONTROL, val); + hcd->state = HC_STATE_SUSPENDED; + /* Wait for devices to suspend */ + mdelay(5); + case HCCONTROL_USB_SUSPEND: + break; + case HCCONTROL_USB_RESUME: + isp116x_write_reg32(isp116x, HCCONTROL, + (val & ~HCCONTROL_HCFS) | + HCCONTROL_USB_RESET); + case HCCONTROL_USB_RESET: + ret = -EBUSY; + break; + default: + ret = -EINVAL; + } + + spin_unlock_irqrestore(&isp116x->lock, flags); + return ret; +} + +static int isp116x_bus_resume(struct usb_hcd *hcd) +{ + struct isp116x *isp116x = hcd_to_isp116x(hcd); + u32 val; + int ret = -EINPROGRESS; + + msleep(5); + spin_lock_irq(&isp116x->lock); + + val = isp116x_read_reg32(isp116x, HCCONTROL); + switch (val & HCCONTROL_HCFS) { + case HCCONTROL_USB_SUSPEND: + val &= ~HCCONTROL_HCFS; + val |= HCCONTROL_USB_RESUME; + isp116x_write_reg32(isp116x, HCCONTROL, val); + case HCCONTROL_USB_RESUME: + break; + case HCCONTROL_USB_OPER: + /* Without setting power_state here the + SUSPENDED state won't be removed from + sysfs/usbN/power.state as a response to remote + wakeup. Maybe in the future. */ + hcd->self.root_hub->dev.power.power_state = PMSG_ON; + ret = 0; + break; + default: + ret = -EBUSY; + } + + if (ret != -EINPROGRESS) { + spin_unlock_irq(&isp116x->lock); + return ret; + } + + val = isp116x->rhdesca & RH_A_NDP; + while (val--) { + u32 stat = + isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1); + /* force global, not selective, resume */ + if (!(stat & RH_PS_PSS)) + continue; + DBG("%s: Resuming port %d\n", __func__, val); + isp116x_write_reg32(isp116x, RH_PS_POCI, val + ? HCRHPORT2 : HCRHPORT1); + } + spin_unlock_irq(&isp116x->lock); + + hcd->state = HC_STATE_RESUMING; + mdelay(20); + + /* Go operational */ + spin_lock_irq(&isp116x->lock); + val = isp116x_read_reg32(isp116x, HCCONTROL); + isp116x_write_reg32(isp116x, HCCONTROL, + (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER); + spin_unlock_irq(&isp116x->lock); + /* see analogous comment above */ + hcd->self.root_hub->dev.power.power_state = PMSG_ON; + hcd->state = HC_STATE_RUNNING; + + return 0; +} + + +#else + +#define isp116x_bus_suspend NULL +#define isp116x_bus_resume NULL + +#endif + /*-----------------------------------------------------------------*/ -#ifdef CONFIG_DEBUG_FS +#ifdef STUB_DEBUG_FILE + +static inline void create_debug_file(struct isp116x *isp116x) +{ +} + +static inline void remove_debug_file(struct isp116x *isp116x) +{ +} + +#else + +#include +#include static void dump_irq(struct seq_file *s, char *label, u16 mask) { @@ -1174,9 +1311,13 @@ static void dump_int(struct seq_file *s, char *label, u32 mask) mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : ""); } -static int isp116x_show_dbg(struct seq_file *s, void *unused) +static int proc_isp116x_show(struct seq_file *s, void *unused) { struct isp116x *isp116x = s->private; + struct isp116x_ep *ep; + struct urb *urb; + unsigned i; + char *str; seq_printf(s, "%s\n%s version %s\n", isp116x_to_hcd(isp116x)->product_desc, hcd_name, @@ -1192,50 +1333,105 @@ static int isp116x_show_dbg(struct seq_file *s, void *unused) } spin_lock_irq(&isp116x->lock); + dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB)); dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT)); dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB)); dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT)); - isp116x_show_regs_seq(isp116x, s); + + list_for_each_entry(ep, &isp116x->async, schedule) { + + switch (ep->nextpid) { + case USB_PID_IN: + str = "in"; + break; + case USB_PID_OUT: + str = "out"; + break; + case USB_PID_SETUP: + str = "setup"; + break; + case USB_PID_ACK: + str = "status"; + break; + default: + str = "?"; + break; + }; + seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep, + ep->epnum, str, ep->maxpacket); + list_for_each_entry(urb, &ep->hep->urb_list, urb_list) { + seq_printf(s, " urb%p, %d/%d\n", urb, + urb->actual_length, + urb->transfer_buffer_length); + } + } + if (!list_empty(&isp116x->async)) + seq_printf(s, "\n"); + + seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE); + + for (i = 0; i < PERIODIC_SIZE; i++) { + ep = isp116x->periodic[i]; + if (!ep) + continue; + seq_printf(s, "%2d [%3d]:\n", i, isp116x->load[i]); + + /* DUMB: prints shared entries multiple times */ + do { + seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n", + ep->period, ep, + (ep->udev->speed == + USB_SPEED_FULL) ? "" : "ls ", + ep->udev->devnum, ep->epnum, + (ep->epnum == + 0) ? "" : ((ep->nextpid == + USB_PID_IN) ? "in" : "out"), + ep->maxpacket); + ep = ep->next; + } while (ep); + } spin_unlock_irq(&isp116x->lock); seq_printf(s, "\n"); return 0; } -static int isp116x_open_seq(struct inode *inode, struct file *file) +static int proc_isp116x_open(struct inode *inode, struct file *file) { - return single_open(file, isp116x_show_dbg, inode->u.generic_ip); + return single_open(file, proc_isp116x_show, PDE(inode)->data); } -static struct file_operations isp116x_debug_fops = { - .open = isp116x_open_seq, +static struct file_operations proc_ops = { + .open = proc_isp116x_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, }; -static int create_debug_file(struct isp116x *isp116x) +/* expect just one isp116x per system */ +static const char proc_filename[] = "driver/isp116x"; + +static void create_debug_file(struct isp116x *isp116x) { - isp116x->dentry = debugfs_create_file(hcd_name, - S_IRUGO, NULL, isp116x, - &isp116x_debug_fops); - if (!isp116x->dentry) - return -ENOMEM; - return 0; + struct proc_dir_entry *pde; + + pde = create_proc_entry(proc_filename, 0, NULL); + if (pde == NULL) + return; + + pde->proc_fops = &proc_ops; + pde->data = isp116x; + isp116x->pde = pde; } static void remove_debug_file(struct isp116x *isp116x) { - debugfs_remove(isp116x->dentry); + if (isp116x->pde) + remove_proc_entry(proc_filename, NULL); } -#else - -#define create_debug_file(d) 0 -#define remove_debug_file(d) do{}while(0) - -#endif /* CONFIG_DEBUG_FS */ +#endif /*-----------------------------------------------------------------*/ @@ -1270,7 +1466,7 @@ static int isp116x_reset(struct usb_hcd *hcd) struct isp116x *isp116x = hcd_to_isp116x(hcd); unsigned long t; u16 clkrdy = 0; - int ret, timeout = 15 /* ms */ ; + int ret = 0, timeout = 15 /* ms */ ; ret = isp116x_sw_reset(isp116x); if (ret) @@ -1286,7 +1482,7 @@ static int isp116x_reset(struct usb_hcd *hcd) break; } if (!clkrdy) { - ERR("Clock not ready after %dms\n", timeout); + ERR("Clock not ready after 20ms\n"); /* After sw_reset the clock won't report to be ready, if H_WAKEUP pin is high. */ ERR("Please make sure that the H_WAKEUP pin is pulled low!\n"); @@ -1376,8 +1572,7 @@ static int isp116x_start(struct usb_hcd *hcd) val = 0; if (board->remote_wakeup_enable) { - if (!device_can_wakeup(hcd->self.controller)) - device_init_wakeup(hcd->self.controller, 1); + hcd->can_wakeup = 1; val |= RH_HS_DRWE; } isp116x_write_reg32(isp116x, HCRHSTATUS, val); @@ -1405,126 +1600,12 @@ static int isp116x_start(struct usb_hcd *hcd) isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS); isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS); - isp116x_show_regs_log(isp116x); + isp116x_show_regs(isp116x); spin_unlock_irqrestore(&isp116x->lock, flags); return 0; } -#ifdef CONFIG_PM - -static int isp116x_bus_suspend(struct usb_hcd *hcd) -{ - struct isp116x *isp116x = hcd_to_isp116x(hcd); - unsigned long flags; - u32 val; - int ret = 0; - - spin_lock_irqsave(&isp116x->lock, flags); - - val = isp116x_read_reg32(isp116x, HCCONTROL); - switch (val & HCCONTROL_HCFS) { - case HCCONTROL_USB_OPER: - val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE); - val |= HCCONTROL_USB_SUSPEND; - if (device_may_wakeup(&hcd->self.root_hub->dev)) - val |= HCCONTROL_RWE; - /* Wait for usb transfers to finish */ - mdelay(2); - isp116x_write_reg32(isp116x, HCCONTROL, val); - /* Wait for devices to suspend */ - mdelay(5); - case HCCONTROL_USB_SUSPEND: - break; - case HCCONTROL_USB_RESUME: - isp116x_write_reg32(isp116x, HCCONTROL, - (val & ~HCCONTROL_HCFS) | - HCCONTROL_USB_RESET); - case HCCONTROL_USB_RESET: - ret = -EBUSY; - break; - default: - ret = -EINVAL; - } - - spin_unlock_irqrestore(&isp116x->lock, flags); - return ret; -} - -static int isp116x_bus_resume(struct usb_hcd *hcd) -{ - struct isp116x *isp116x = hcd_to_isp116x(hcd); - u32 val; - - msleep(5); - spin_lock_irq(&isp116x->lock); - - val = isp116x_read_reg32(isp116x, HCCONTROL); - switch (val & HCCONTROL_HCFS) { - case HCCONTROL_USB_SUSPEND: - val &= ~HCCONTROL_HCFS; - val |= HCCONTROL_USB_RESUME; - isp116x_write_reg32(isp116x, HCCONTROL, val); - case HCCONTROL_USB_RESUME: - break; - case HCCONTROL_USB_OPER: - spin_unlock_irq(&isp116x->lock); - /* Without setting power_state here the - SUSPENDED state won't be removed from - sysfs/usbN/power.state as a response to remote - wakeup. Maybe in the future. */ - hcd->self.root_hub->dev.power.power_state = PMSG_ON; - return 0; - default: - /* HCCONTROL_USB_RESET: this may happen, when during - suspension the HC lost power. Reinitialize completely */ - spin_unlock_irq(&isp116x->lock); - DBG("Chip has been reset while suspended. Reinit from scratch.\n"); - isp116x_reset(hcd); - isp116x_start(hcd); - isp116x_hub_control(hcd, SetPortFeature, - USB_PORT_FEAT_POWER, 1, NULL, 0); - if ((isp116x->rhdesca & RH_A_NDP) == 2) - isp116x_hub_control(hcd, SetPortFeature, - USB_PORT_FEAT_POWER, 2, NULL, 0); - hcd->self.root_hub->dev.power.power_state = PMSG_ON; - return 0; - } - - val = isp116x->rhdesca & RH_A_NDP; - while (val--) { - u32 stat = - isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1); - /* force global, not selective, resume */ - if (!(stat & RH_PS_PSS)) - continue; - DBG("%s: Resuming port %d\n", __func__, val); - isp116x_write_reg32(isp116x, RH_PS_POCI, val - ? HCRHPORT2 : HCRHPORT1); - } - spin_unlock_irq(&isp116x->lock); - - hcd->state = HC_STATE_RESUMING; - msleep(20); - - /* Go operational */ - spin_lock_irq(&isp116x->lock); - val = isp116x_read_reg32(isp116x, HCCONTROL); - isp116x_write_reg32(isp116x, HCCONTROL, - (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER); - spin_unlock_irq(&isp116x->lock); - /* see analogous comment above */ - hcd->self.root_hub->dev.power.power_state = PMSG_ON; - hcd->state = HC_STATE_RUNNING; - - return 0; -} - -#else - -#define isp116x_bus_suspend NULL -#define isp116x_bus_resume NULL - -#endif +/*-----------------------------------------------------------------*/ static struct hc_driver isp116x_hc_driver = { .description = hcd_name, @@ -1654,19 +1735,12 @@ static int __init isp116x_probe(struct platform_device *pdev) } ret = usb_add_hcd(hcd, irq, SA_INTERRUPT); - if (ret) + if (ret != 0) goto err6; - ret = create_debug_file(isp116x); - if (ret) { - ERR("Couldn't create debugfs entry\n"); - goto err7; - } - + create_debug_file(isp116x); return 0; - err7: - usb_remove_hcd(hcd); err6: usb_put_hcd(hcd); err5: @@ -1688,9 +1762,13 @@ static int __init isp116x_probe(struct platform_device *pdev) */ static int isp116x_suspend(struct platform_device *dev, pm_message_t state) { - VDBG("%s: state %x\n", __func__, state.event); + int ret = 0; + + VDBG("%s: state %x\n", __func__, state); + dev->dev.power.power_state = state; - return 0; + + return ret; } /* @@ -1698,9 +1776,13 @@ static int isp116x_suspend(struct platform_device *dev, pm_message_t state) */ static int isp116x_resume(struct platform_device *dev) { - VDBG("%s: state %x\n", __func__, dev->power.power_state.event); + int ret = 0; + + VDBG("%s: state %x\n", __func__, dev->dev.power.power_state); + dev->dev.power.power_state = PMSG_ON; - return 0; + + return ret; } #else diff --git a/trunk/drivers/usb/host/isp116x.h b/trunk/drivers/usb/host/isp116x.h index a1b7c3813d3a..c6fec96785fe 100644 --- a/trunk/drivers/usb/host/isp116x.h +++ b/trunk/drivers/usb/host/isp116x.h @@ -259,7 +259,7 @@ struct isp116x { struct isp116x_platform_data *board; - struct dentry *dentry; + struct proc_dir_entry *pde; unsigned long stat1, stat2, stat4, stat8, stat16; /* HC registers */ @@ -450,7 +450,7 @@ static void isp116x_write_reg32(struct isp116x *isp116x, unsigned reg, isp116x_write_data32(isp116x, (u32) val); } -#define isp116x_show_reg_log(d,r,s) { \ +#define isp116x_show_reg(d,r) { \ if ((r) < 0x20) { \ DBG("%-12s[%02x]: %08x\n", #r, \ r, isp116x_read_reg32(d, r)); \ @@ -459,60 +459,35 @@ static void isp116x_write_reg32(struct isp116x *isp116x, unsigned reg, r, isp116x_read_reg16(d, r)); \ } \ } -#define isp116x_show_reg_seq(d,r,s) { \ - if ((r) < 0x20) { \ - seq_printf(s, "%-12s[%02x]: %08x\n", #r, \ - r, isp116x_read_reg32(d, r)); \ - } else { \ - seq_printf(s, "%-12s[%02x]: %04x\n", #r, \ - r, isp116x_read_reg16(d, r)); \ - } \ -} -#define isp116x_show_regs(d,type,s) { \ - isp116x_show_reg_##type(d, HCREVISION, s); \ - isp116x_show_reg_##type(d, HCCONTROL, s); \ - isp116x_show_reg_##type(d, HCCMDSTAT, s); \ - isp116x_show_reg_##type(d, HCINTSTAT, s); \ - isp116x_show_reg_##type(d, HCINTENB, s); \ - isp116x_show_reg_##type(d, HCFMINTVL, s); \ - isp116x_show_reg_##type(d, HCFMREM, s); \ - isp116x_show_reg_##type(d, HCFMNUM, s); \ - isp116x_show_reg_##type(d, HCLSTHRESH, s); \ - isp116x_show_reg_##type(d, HCRHDESCA, s); \ - isp116x_show_reg_##type(d, HCRHDESCB, s); \ - isp116x_show_reg_##type(d, HCRHSTATUS, s); \ - isp116x_show_reg_##type(d, HCRHPORT1, s); \ - isp116x_show_reg_##type(d, HCRHPORT2, s); \ - isp116x_show_reg_##type(d, HCHWCFG, s); \ - isp116x_show_reg_##type(d, HCDMACFG, s); \ - isp116x_show_reg_##type(d, HCXFERCTR, s); \ - isp116x_show_reg_##type(d, HCuPINT, s); \ - isp116x_show_reg_##type(d, HCuPINTENB, s); \ - isp116x_show_reg_##type(d, HCCHIPID, s); \ - isp116x_show_reg_##type(d, HCSCRATCH, s); \ - isp116x_show_reg_##type(d, HCITLBUFLEN, s); \ - isp116x_show_reg_##type(d, HCATLBUFLEN, s); \ - isp116x_show_reg_##type(d, HCBUFSTAT, s); \ - isp116x_show_reg_##type(d, HCRDITL0LEN, s); \ - isp116x_show_reg_##type(d, HCRDITL1LEN, s); \ -} - -/* - Dump registers for debugfs. -*/ -static inline void isp116x_show_regs_seq(struct isp116x *isp116x, - struct seq_file *s) -{ - isp116x_show_regs(isp116x, seq, s); -} - -/* - Dump registers to syslog. -*/ -static inline void isp116x_show_regs_log(struct isp116x *isp116x) +static inline void isp116x_show_regs(struct isp116x *isp116x) { - isp116x_show_regs(isp116x, log, NULL); + isp116x_show_reg(isp116x, HCREVISION); + isp116x_show_reg(isp116x, HCCONTROL); + isp116x_show_reg(isp116x, HCCMDSTAT); + isp116x_show_reg(isp116x, HCINTSTAT); + isp116x_show_reg(isp116x, HCINTENB); + isp116x_show_reg(isp116x, HCFMINTVL); + isp116x_show_reg(isp116x, HCFMREM); + isp116x_show_reg(isp116x, HCFMNUM); + isp116x_show_reg(isp116x, HCLSTHRESH); + isp116x_show_reg(isp116x, HCRHDESCA); + isp116x_show_reg(isp116x, HCRHDESCB); + isp116x_show_reg(isp116x, HCRHSTATUS); + isp116x_show_reg(isp116x, HCRHPORT1); + isp116x_show_reg(isp116x, HCRHPORT2); + isp116x_show_reg(isp116x, HCHWCFG); + isp116x_show_reg(isp116x, HCDMACFG); + isp116x_show_reg(isp116x, HCXFERCTR); + isp116x_show_reg(isp116x, HCuPINT); + isp116x_show_reg(isp116x, HCuPINTENB); + isp116x_show_reg(isp116x, HCCHIPID); + isp116x_show_reg(isp116x, HCSCRATCH); + isp116x_show_reg(isp116x, HCITLBUFLEN); + isp116x_show_reg(isp116x, HCATLBUFLEN); + isp116x_show_reg(isp116x, HCBUFSTAT); + isp116x_show_reg(isp116x, HCRDITL0LEN); + isp116x_show_reg(isp116x, HCRDITL1LEN); } #if defined(URB_TRACE) diff --git a/trunk/drivers/usb/host/ohci-hcd.c b/trunk/drivers/usb/host/ohci-hcd.c index a4b12404ae08..bf1d9abc07ac 100644 --- a/trunk/drivers/usb/host/ohci-hcd.c +++ b/trunk/drivers/usb/host/ohci-hcd.c @@ -75,6 +75,13 @@ */ #include + +#ifdef CONFIG_USB_DEBUG +# define DEBUG +#else +# undef DEBUG +#endif + #include #include #include @@ -795,6 +802,7 @@ static int ohci_restart (struct ohci_hcd *ohci) int temp; int i; struct urb_priv *priv; + struct usb_device *root = ohci_to_hcd(ohci)->self.root_hub; /* mark any devices gone, so they do nothing till khubd disconnects. * recycle any "live" eds/tds (and urbs) right away. @@ -803,7 +811,11 @@ static int ohci_restart (struct ohci_hcd *ohci) */ spin_lock_irq(&ohci->lock); disable (ohci); - usb_root_hub_lost_power(ohci_to_hcd(ohci)->self.root_hub); + for (i = 0; i < root->maxchild; i++) { + if (root->children [i]) + usb_set_device_state (root->children[i], + USB_STATE_NOTATTACHED); + } if (!list_empty (&ohci->pending)) ohci_dbg(ohci, "abort schedule...\n"); list_for_each_entry (priv, &ohci->pending, pending) { diff --git a/trunk/drivers/usb/host/ohci-hub.c b/trunk/drivers/usb/host/ohci-hub.c index 4b2226d77b34..72e3b12a1926 100644 --- a/trunk/drivers/usb/host/ohci-hub.c +++ b/trunk/drivers/usb/host/ohci-hub.c @@ -372,7 +372,7 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf) & ohci->hc_control) == OHCI_USB_OPER && time_after (jiffies, ohci->next_statechange) - && usb_trylock_device (hcd->self.root_hub) == 0 + && usb_trylock_device (hcd->self.root_hub) ) { ohci_vdbg (ohci, "autosuspend\n"); (void) ohci_bus_suspend (hcd); diff --git a/trunk/drivers/usb/host/ohci-pxa27x.c b/trunk/drivers/usb/host/ohci-pxa27x.c index acde8868da21..9d65ec307990 100644 --- a/trunk/drivers/usb/host/ohci-pxa27x.c +++ b/trunk/drivers/usb/host/ohci-pxa27x.c @@ -26,12 +26,18 @@ #include #include #include -#include + + +#define PMM_NPS_MODE 1 +#define PMM_GLOBAL_MODE 2 +#define PMM_PERPORT_MODE 3 #define PXA_UHC_MAX_PORTNUM 3 #define UHCRHPS(x) __REG2( 0x4C000050, (x)<<2 ) +static int pxa27x_ohci_pmm_state; + /* PMM_NPS_MODE -- PMM Non-power switching mode Ports are powered continuously. @@ -44,6 +50,8 @@ */ static int pxa27x_ohci_select_pmm( int mode ) { + pxa27x_ohci_pmm_state = mode; + switch ( mode ) { case PMM_NPS_MODE: UHCRHDA |= RH_A_NPS; @@ -63,6 +71,7 @@ static int pxa27x_ohci_select_pmm( int mode ) "Invalid mode %d, set to non-power switch mode.\n", mode ); + pxa27x_ohci_pmm_state = PMM_NPS_MODE; UHCRHDA |= RH_A_NPS; } @@ -73,13 +82,8 @@ extern int usb_disabled(void); /*-------------------------------------------------------------------------*/ -static int pxa27x_start_hc(struct device *dev) +static void pxa27x_start_hc(struct platform_device *dev) { - int retval = 0; - struct pxaohci_platform_data *inf; - - inf = dev->platform_data; - pxa_set_cken(CKEN10_USBHOST, 1); UHCHR |= UHCHR_FHR; @@ -90,11 +94,21 @@ static int pxa27x_start_hc(struct device *dev) while (UHCHR & UHCHR_FSBIR) cpu_relax(); - if (inf->init) - retval = inf->init(dev); + /* This could be properly abstracted away through the + device data the day more machines are supported and + their differences can be figured out correctly. */ + if (machine_is_mainstone()) { + /* setup Port1 GPIO pin. */ + pxa_gpio_mode( 88 | GPIO_ALT_FN_1_IN); /* USBHPWR1 */ + pxa_gpio_mode( 89 | GPIO_ALT_FN_2_OUT); /* USBHPEN1 */ - if (retval < 0) - return retval; + /* Set the Power Control Polarity Low and Power Sense + Polarity Low to active low. Supply power to USB ports. */ + UHCHR = (UHCHR | UHCHR_PCPL | UHCHR_PSPL) & + ~(UHCHR_SSEP1 | UHCHR_SSEP2 | UHCHR_SSEP3 | UHCHR_SSE); + + pxa27x_ohci_pmm_state = PMM_PERPORT_MODE; + } UHCHR &= ~UHCHR_SSE; @@ -103,19 +117,10 @@ static int pxa27x_start_hc(struct device *dev) /* Clear any OTG Pin Hold */ if (PSSR & PSSR_OTGPH) PSSR |= PSSR_OTGPH; - - return 0; } -static void pxa27x_stop_hc(struct device *dev) +static void pxa27x_stop_hc(struct platform_device *dev) { - struct pxaohci_platform_data *inf; - - inf = dev->platform_data; - - if (inf->exit) - inf->exit(dev); - UHCHR |= UHCHR_FHR; udelay(11); UHCHR &= ~UHCHR_FHR; @@ -142,27 +147,22 @@ static void pxa27x_stop_hc(struct device *dev) * through the hotplug entry's driver_data. * */ -int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device *pdev) +int usb_hcd_pxa27x_probe (const struct hc_driver *driver, + struct platform_device *dev) { int retval; struct usb_hcd *hcd; - struct pxaohci_platform_data *inf; - inf = pdev->dev.platform_data; - - if (!inf) - return -ENODEV; - - if (pdev->resource[1].flags != IORESOURCE_IRQ) { + if (dev->resource[1].flags != IORESOURCE_IRQ) { pr_debug ("resource[1] is not IORESOURCE_IRQ"); return -ENOMEM; } - hcd = usb_create_hcd (driver, &pdev->dev, "pxa27x"); + hcd = usb_create_hcd (driver, &dev->dev, "pxa27x"); if (!hcd) return -ENOMEM; - hcd->rsrc_start = pdev->resource[0].start; - hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1; + hcd->rsrc_start = dev->resource[0].start; + hcd->rsrc_len = dev->resource[0].end - dev->resource[0].start + 1; if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { pr_debug("request_mem_region failed"); @@ -177,22 +177,18 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device goto err2; } - if ((retval = pxa27x_start_hc(&pdev->dev)) < 0) { - pr_debug("pxa27x_start_hc failed"); - goto err3; - } + pxa27x_start_hc(dev); /* Select Power Management Mode */ - pxa27x_ohci_select_pmm(inf->port_mode); + pxa27x_ohci_select_pmm(pxa27x_ohci_pmm_state); ohci_hcd_init(hcd_to_ohci(hcd)); - retval = usb_add_hcd(hcd, pdev->resource[1].start, SA_INTERRUPT); + retval = usb_add_hcd(hcd, dev->resource[1].start, SA_INTERRUPT); if (retval == 0) return retval; - pxa27x_stop_hc(&pdev->dev); - err3: + pxa27x_stop_hc(dev); iounmap(hcd->regs); err2: release_mem_region(hcd->rsrc_start, hcd->rsrc_len); @@ -215,10 +211,10 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device * context, normally "rmmod", "apmd", or something similar. * */ -void usb_hcd_pxa27x_remove (struct usb_hcd *hcd, struct platform_device *pdev) +void usb_hcd_pxa27x_remove (struct usb_hcd *hcd, struct platform_device *dev) { usb_remove_hcd(hcd); - pxa27x_stop_hc(&pdev->dev); + pxa27x_stop_hc(dev); iounmap(hcd->regs); release_mem_region(hcd->rsrc_start, hcd->rsrc_len); usb_put_hcd(hcd); @@ -296,12 +292,15 @@ static const struct hc_driver ohci_pxa27x_hc_driver = { static int ohci_hcd_pxa27x_drv_probe(struct platform_device *pdev) { + int ret; + pr_debug ("In ohci_hcd_pxa27x_drv_probe"); if (usb_disabled()) return -ENODEV; - return usb_hcd_pxa27x_probe(&ohci_pxa27x_hc_driver, pdev); + ret = usb_hcd_pxa27x_probe(&ohci_pxa27x_hc_driver, pdev); + return ret; } static int ohci_hcd_pxa27x_drv_remove(struct platform_device *pdev) @@ -309,55 +308,31 @@ static int ohci_hcd_pxa27x_drv_remove(struct platform_device *pdev) struct usb_hcd *hcd = platform_get_drvdata(pdev); usb_hcd_pxa27x_remove(hcd, pdev); - platform_set_drvdata(pdev, NULL); return 0; } -#ifdef CONFIG_PM -static int ohci_hcd_pxa27x_drv_suspend(struct platform_device *pdev, pm_message_t state) +static int ohci_hcd_pxa27x_drv_suspend(struct platform_device *dev, pm_message_t state) { - struct usb_hcd *hcd = platform_get_drvdata(pdev); - struct ohci_hcd *ohci = hcd_to_ohci(hcd); - - if (time_before(jiffies, ohci->next_statechange)) - msleep(5); - ohci->next_statechange = jiffies; - - pxa27x_stop_hc(&pdev->dev); - hcd->state = HC_STATE_SUSPENDED; - pdev->dev.power.power_state = PMSG_SUSPEND; +// struct usb_hcd *hcd = platform_get_drvdata(dev); + printk("%s: not implemented yet\n", __FUNCTION__); return 0; } -static int ohci_hcd_pxa27x_drv_resume(struct platform_device *pdev) +static int ohci_hcd_pxa27x_drv_resume(struct platform_device *dev) { - struct usb_hcd *hcd = platform_get_drvdata(pdev); - struct ohci_hcd *ohci = hcd_to_ohci(hcd); - int status; - - if (time_before(jiffies, ohci->next_statechange)) - msleep(5); - ohci->next_statechange = jiffies; - - if ((status = pxa27x_start_hc(&pdev->dev)) < 0) - return status; - - pdev->dev.power.power_state = PMSG_ON; - usb_hcd_resume_root_hub(hcd); +// struct usb_hcd *hcd = platform_get_drvdata(dev); + printk("%s: not implemented yet\n", __FUNCTION__); return 0; } -#endif static struct platform_driver ohci_hcd_pxa27x_driver = { .probe = ohci_hcd_pxa27x_drv_probe, .remove = ohci_hcd_pxa27x_drv_remove, -#ifdef CONFIG_PM .suspend = ohci_hcd_pxa27x_drv_suspend, .resume = ohci_hcd_pxa27x_drv_resume, -#endif .driver = { .name = "pxa27x-ohci", }, diff --git a/trunk/drivers/usb/host/pci-quirks.c b/trunk/drivers/usb/host/pci-quirks.c index 3ef2c0cdf1db..e46528c825bf 100644 --- a/trunk/drivers/usb/host/pci-quirks.c +++ b/trunk/drivers/usb/host/pci-quirks.c @@ -9,6 +9,12 @@ */ #include +#ifdef CONFIG_USB_DEBUG +#define DEBUG +#else +#undef DEBUG +#endif + #include #include #include diff --git a/trunk/drivers/usb/host/sl811-hcd.c b/trunk/drivers/usb/host/sl811-hcd.c index 517360b77d8e..a7722a6a5a5b 100644 --- a/trunk/drivers/usb/host/sl811-hcd.c +++ b/trunk/drivers/usb/host/sl811-hcd.c @@ -32,6 +32,13 @@ #undef PACKET_TRACE #include + +#ifdef CONFIG_USB_DEBUG +# define DEBUG +#else +# undef DEBUG +#endif + #include #include #include @@ -1574,9 +1581,7 @@ sl811h_start(struct usb_hcd *hcd) hcd->state = HC_STATE_RUNNING; if (sl811->board) { - if (!device_can_wakeup(hcd->self.controller)) - device_init_wakeup(hcd->self.controller, - sl811->board->can_wakeup); + hcd->can_wakeup = sl811->board->can_wakeup; hcd->power_budget = sl811->board->power * 2; } @@ -1800,10 +1805,9 @@ sl811h_resume(struct platform_device *dev) * let's assume it'd only be powered to enable remote wakeup. */ if (dev->dev.power.power_state.event == PM_EVENT_SUSPEND - || !device_can_wakeup(&hcd->self.root_hub->dev)) { + || !hcd->can_wakeup) { sl811->port1 = 0; port_power(sl811, 1); - usb_root_hub_lost_power(hcd->self.root_hub); return 0; } diff --git a/trunk/drivers/usb/host/sl811_cs.c b/trunk/drivers/usb/host/sl811_cs.c index 466384d7c79f..e73faf831b24 100644 --- a/trunk/drivers/usb/host/sl811_cs.c +++ b/trunk/drivers/usb/host/sl811_cs.c @@ -38,7 +38,7 @@ MODULE_LICENSE("GPL"); /* MACROS */ /*====================================================================*/ -#if defined(DEBUG) || defined(PCMCIA_DEBUG) +#if defined(DEBUG) || defined(CONFIG_USB_DEBUG) || defined(PCMCIA_DEBUG) static int pc_debug = 0; module_param(pc_debug, int, 0644); @@ -66,13 +66,13 @@ module_param(pc_debug, int, 0644); static const char driver_name[DEV_NAME_LEN] = "sl811_cs"; +static dev_link_t *dev_list = NULL; + typedef struct local_info_t { dev_link_t link; dev_node_t node; } local_info_t; -static void sl811_cs_release(dev_link_t * link); - /*====================================================================*/ static void release_platform_dev(struct device * dev) @@ -129,8 +129,7 @@ static int sl811_hc_init(struct device *parent, ioaddr_t base_addr, int irq) resources[2].end = base_addr + 1; /* The driver core will probe for us. We know sl811-hcd has been - * initialized already because of the link order dependency created - * by referencing "sl811h_driver". + * initialized already because of the link order dependency. */ platform_dev.name = sl811h_driver.name; return platform_device_register(&platform_dev); @@ -138,16 +137,26 @@ static int sl811_hc_init(struct device *parent, ioaddr_t base_addr, int irq) /*====================================================================*/ -static void sl811_cs_detach(struct pcmcia_device *p_dev) +static void sl811_cs_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); + dev_link_t **linkp; DBG(0, "sl811_cs_detach(0x%p)\n", link); - link->state &= ~DEV_PRESENT; - if (link->state & DEV_CONFIG) - sl811_cs_release(link); + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) { + if (*linkp == link) + break; + } + if (*linkp == NULL) + return; + + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + /* Unlink device structure, and free it */ + *linkp = link->next; /* This points to the parent local_info_t struct */ kfree(link->priv); } @@ -157,6 +166,13 @@ static void sl811_cs_release(dev_link_t * link) DBG(0, "sl811_cs_release(0x%p)\n", link); + if (link->open) { + DBG(1, "sl811_cs: release postponed, '%s' still open\n", + link->dev->dev_name); + link->state |= DEV_STALE_CONFIG; + return; + } + /* Unlink the device chain */ link->dev = NULL; @@ -167,6 +183,9 @@ static void sl811_cs_release(dev_link_t * link) if (link->irq.AssignedIRQ) pcmcia_release_irq(link->handle, &link->irq); link->state &= ~DEV_CONFIG; + + if (link->state & DEV_STALE_LINK) + sl811_cs_detach(link); } static void sl811_cs_config(dev_link_t *link) @@ -303,36 +322,55 @@ static void sl811_cs_config(dev_link_t *link) } } -static int sl811_suspend(struct pcmcia_device *dev) +static int +sl811_cs_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); + dev_link_t *link = args->client_data; - link->state |= DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); + DBG(1, "sl811_cs_event(0x%06x)\n", event); - return 0; -} + switch (event) { + case CS_EVENT_CARD_REMOVAL: + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + sl811_cs_release(link); + break; -static int sl811_resume(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); + case CS_EVENT_CARD_INSERTION: + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + sl811_cs_config(link); + break; - link->state &= ~DEV_SUSPEND; - if (link->state & DEV_CONFIG) - pcmcia_request_configuration(link->handle, &link->conf); + case CS_EVENT_PM_SUSPEND: + link->state |= DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + if (link->state & DEV_CONFIG) + pcmcia_request_configuration(link->handle, &link->conf); + DBG(0, "reset sl811-hcd here?\n"); + break; + } return 0; } -static int sl811_cs_attach(struct pcmcia_device *p_dev) +static dev_link_t *sl811_cs_attach(void) { local_info_t *local; dev_link_t *link; + client_reg_t client_reg; + int ret; local = kmalloc(sizeof(local_info_t), GFP_KERNEL); if (!local) - return -ENOMEM; + return NULL; memset(local, 0, sizeof(local_info_t)); link = &local->link; link->priv = local; @@ -346,13 +384,21 @@ static int sl811_cs_attach(struct pcmcia_device *p_dev) link->conf.Vcc = 33; link->conf.IntType = INT_MEMORY_AND_IO; - link->handle = p_dev; - p_dev->instance = link; - - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - sl811_cs_config(link); + /* Register with Card Services */ + link->next = dev_list; + dev_list = link; + client_reg.dev_info = (dev_info_t *) &driver_name; + client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + sl811_cs_detach(link); + return NULL; + } - return 0; + return link; } static struct pcmcia_device_id sl811_ids[] = { @@ -366,11 +412,10 @@ static struct pcmcia_driver sl811_cs_driver = { .drv = { .name = (char *)driver_name, }, - .probe = sl811_cs_attach, - .remove = sl811_cs_detach, + .attach = sl811_cs_attach, + .event = sl811_cs_event, + .detach = sl811_cs_detach, .id_table = sl811_ids, - .suspend = sl811_suspend, - .resume = sl811_resume, }; /*====================================================================*/ diff --git a/trunk/drivers/usb/host/uhci-debug.c b/trunk/drivers/usb/host/uhci-debug.c index 5832953086f8..151154df37fa 100644 --- a/trunk/drivers/usb/host/uhci-debug.c +++ b/trunk/drivers/usb/host/uhci-debug.c @@ -2,8 +2,8 @@ * UHCI-specific debugging code. Invaluable when something * goes wrong, but don't get in my face. * - * Kernel visible pointers are surrounded in []s and bus - * visible pointers are surrounded in ()s + * Kernel visible pointers are surrounded in []'s and bus + * visible pointers are surrounded in ()'s * * (C) Copyright 1999 Linus Torvalds * (C) Copyright 1999-2001 Johannes Erdfelt @@ -19,7 +19,7 @@ static struct dentry *uhci_debugfs_root = NULL; -/* Handle REALLY large printks so we don't overflow buffers */ +/* Handle REALLY large printk's so we don't overflow buffers */ static inline void lprintk(char *buf) { char *p; @@ -160,7 +160,7 @@ static int uhci_show_qh(struct uhci_qh *qh, char *buf, int len, int space) } if (active && ni > i) { - out += sprintf(out, "%*s[skipped %d active TDs]\n", space, "", ni - i); + out += sprintf(out, "%*s[skipped %d active TD's]\n", space, "", ni - i); tmp = ntmp; td = ntd; i = ni; @@ -173,7 +173,7 @@ static int uhci_show_qh(struct uhci_qh *qh, char *buf, int len, int space) if (list_empty(&urbp->queue_list) || urbp->queued) goto out; - out += sprintf(out, "%*sQueued QHs:\n", -space, "--"); + out += sprintf(out, "%*sQueued QH's:\n", -space, "--"); head = &urbp->queue_list; tmp = head->next; @@ -197,7 +197,7 @@ static int uhci_show_qh(struct uhci_qh *qh, char *buf, int len, int space) } #ifdef CONFIG_PROC_FS -static const char * const qh_names[] = { +static const char *qh_names[] = { "skel_int128_qh", "skel_int64_qh", "skel_int32_qh", "skel_int16_qh", "skel_int8_qh", "skel_int4_qh", @@ -464,7 +464,7 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len) } while (tmp != head); } - out += sprintf(out, "Skeleton QHs\n"); + out += sprintf(out, "Skeleton QH's\n"); for (i = 0; i < UHCI_NUM_SKELQH; ++i) { int shown = 0; diff --git a/trunk/drivers/usb/host/uhci-hcd.c b/trunk/drivers/usb/host/uhci-hcd.c index dfe121d35887..79efaf7d86a3 100644 --- a/trunk/drivers/usb/host/uhci-hcd.c +++ b/trunk/drivers/usb/host/uhci-hcd.c @@ -23,6 +23,11 @@ */ #include +#ifdef CONFIG_USB_DEBUG +#define DEBUG +#else +#undef DEBUG +#endif #include #include #include @@ -62,10 +67,10 @@ Alan Stern" /* * debug = 0, no debugging messages - * debug = 1, dump failed URBs except for stalls - * debug = 2, dump all failed URBs (including stalls) + * debug = 1, dump failed URB's except for stalls + * debug = 2, dump all failed URB's (including stalls) * show all queues in /debug/uhci/[pci_addr] - * debug = 3, show all TDs in URBs when dumping + * debug = 3, show all TD's in URB's when dumping */ #ifdef DEBUG static int debug = 1; @@ -88,7 +93,7 @@ static void uhci_get_current_frame_number(struct uhci_hcd *uhci); #define FSBR_DELAY msecs_to_jiffies(50) /* When we timeout an idle transfer for FSBR, we'll switch it over to */ -/* depth first traversal. We'll do it in groups of this number of TDs */ +/* depth first traversal. We'll do it in groups of this number of TD's */ /* to make sure it doesn't hog all of the bandwidth */ #define DEPTH_INTERVAL 5 @@ -473,6 +478,8 @@ static int uhci_start(struct usb_hcd *hcd) struct dentry *dentry; hcd->uses_new_polling = 1; + if (pci_find_capability(to_pci_dev(uhci_dev(uhci)), PCI_CAP_ID_PM)) + hcd->can_wakeup = 1; /* Assume it supports PME# */ dentry = debugfs_create_file(hcd->self.bus_name, S_IFREG|S_IRUGO|S_IWUSR, uhci_debugfs_root, uhci, @@ -566,7 +573,7 @@ static int uhci_start(struct usb_hcd *hcd) uhci->skel_bulk_qh->link = cpu_to_le32(uhci->skel_term_qh->dma_handle) | UHCI_PTR_QH; /* This dummy TD is to work around a bug in Intel PIIX controllers */ - uhci_fill_td(uhci->term_td, 0, uhci_explen(0) | + uhci_fill_td(uhci->term_td, 0, (UHCI_NULL_DATA_SIZE << 21) | (0x7f << TD_TOKEN_DEVADDR_SHIFT) | USB_PID_IN, 0); uhci->term_td->link = cpu_to_le32(uhci->term_td->dma_handle); @@ -728,9 +735,8 @@ static int uhci_resume(struct usb_hcd *hcd) dev_dbg(uhci_dev(uhci), "%s\n", __FUNCTION__); - /* Since we aren't in D3 any more, it's safe to set this flag - * even if the controller was dead. It might not even be dead - * any more, if the firmware or quirks code has reset it. + /* We aren't in D3 state anymore, we do that even if dead as I + * really don't want to keep a stale HCD_FLAG_HW_ACCESSIBLE=0 */ set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); mb(); @@ -749,12 +755,8 @@ static int uhci_resume(struct usb_hcd *hcd) check_and_reset_hc(uhci); configure_hc(uhci); - if (uhci->rh_state == UHCI_RH_RESET) { - - /* The controller had to be reset */ - usb_root_hub_lost_power(hcd->self.root_hub); + if (uhci->rh_state == UHCI_RH_RESET) suspend_rh(uhci, UHCI_RH_SUSPENDED); - } spin_unlock_irq(&uhci->lock); @@ -880,7 +882,7 @@ static int __init uhci_hcd_init(void) init_failed: if (kmem_cache_destroy(uhci_up_cachep)) - warn("not all urb_privs were freed!"); + warn("not all urb_priv's were freed!"); up_failed: debugfs_remove(uhci_debugfs_root); @@ -898,7 +900,7 @@ static void __exit uhci_hcd_cleanup(void) pci_unregister_driver(&uhci_pci_driver); if (kmem_cache_destroy(uhci_up_cachep)) - warn("not all urb_privs were freed!"); + warn("not all urb_priv's were freed!"); debugfs_remove(uhci_debugfs_root); kfree(errbuf); diff --git a/trunk/drivers/usb/host/uhci-hcd.h b/trunk/drivers/usb/host/uhci-hcd.h index 8b4b887a7d41..e576db57a926 100644 --- a/trunk/drivers/usb/host/uhci-hcd.h +++ b/trunk/drivers/usb/host/uhci-hcd.h @@ -71,6 +71,8 @@ #define USBLEGSUP_RWC 0x8f00 /* the R/WC bits */ #define USBLEGSUP_RO 0x5040 /* R/O and reserved bits */ +#define UHCI_NULL_DATA_SIZE 0x7FF /* for UHCI controller TD */ + #define UHCI_PTR_BITS cpu_to_le32(0x000F) #define UHCI_PTR_TERM cpu_to_le32(0x0001) #define UHCI_PTR_QH cpu_to_le32(0x0002) @@ -166,11 +168,9 @@ static __le32 inline qh_element(struct uhci_qh *qh) { #define TD_TOKEN_EXPLEN_MASK 0x7FF /* expected length, encoded as n - 1 */ #define TD_TOKEN_PID_MASK 0xFF -#define uhci_explen(len) ((((len) - 1) & TD_TOKEN_EXPLEN_MASK) << \ - TD_TOKEN_EXPLEN_SHIFT) +#define uhci_explen(len) ((len) << TD_TOKEN_EXPLEN_SHIFT) -#define uhci_expected_length(token) ((((token) >> TD_TOKEN_EXPLEN_SHIFT) + \ - 1) & TD_TOKEN_EXPLEN_MASK) +#define uhci_expected_length(token) ((((token) >> 21) + 1) & TD_TOKEN_EXPLEN_MASK) #define uhci_toggle(token) (((token) >> TD_TOKEN_TOGGLE_SHIFT) & 1) #define uhci_endpoint(token) (((token) >> 15) & 0xf) #define uhci_devaddr(token) (((token) >> TD_TOKEN_DEVADDR_SHIFT) & 0x7f) @@ -223,10 +223,10 @@ static u32 inline td_status(struct uhci_td *td) { */ /* - * The UHCI driver places Interrupt, Control and Bulk into QHs both - * to group together TDs for one transfer, and also to facilitate queuing - * of URBs. To make it easy to insert entries into the schedule, we have - * a skeleton of QHs for each predefined Interrupt latency, low-speed + * The UHCI driver places Interrupt, Control and Bulk into QH's both + * to group together TD's for one transfer, and also to faciliate queuing + * of URB's. To make it easy to insert entries into the schedule, we have + * a skeleton of QH's for each predefined Interrupt latency, low-speed * control, full-speed control and terminating QH (see explanation for * the terminating QH below). * @@ -257,8 +257,8 @@ static u32 inline td_status(struct uhci_td *td) { * reclamation. * * Isochronous transfers are stored before the start of the skeleton - * schedule and don't use QHs. While the UHCI spec doesn't forbid the - * use of QHs for Isochronous, it doesn't use them either. And the spec + * schedule and don't use QH's. While the UHCI spec doesn't forbid the + * use of QH's for Isochronous, it doesn't use them either. And the spec * says that queues never advance on an error completion status, which * makes them totally unsuitable for Isochronous transfers. */ @@ -359,7 +359,7 @@ struct uhci_hcd { struct dma_pool *td_pool; struct uhci_td *term_td; /* Terminating TD, see UHCI bug */ - struct uhci_qh *skelqh[UHCI_NUM_SKELQH]; /* Skeleton QHs */ + struct uhci_qh *skelqh[UHCI_NUM_SKELQH]; /* Skeleton QH's */ spinlock_t lock; @@ -389,22 +389,22 @@ struct uhci_hcd { unsigned long resuming_ports; unsigned long ports_timeout; /* Time to stop signalling */ - /* Main list of URBs currently controlled by this HC */ + /* Main list of URB's currently controlled by this HC */ struct list_head urb_list; - /* List of QHs that are done, but waiting to be unlinked (race) */ + /* List of QH's that are done, but waiting to be unlinked (race) */ struct list_head qh_remove_list; unsigned int qh_remove_age; /* Age in frames */ - /* List of TDs that are done, but waiting to be freed (race) */ + /* List of TD's that are done, but waiting to be freed (race) */ struct list_head td_remove_list; unsigned int td_remove_age; /* Age in frames */ - /* List of asynchronously unlinked URBs */ + /* List of asynchronously unlinked URB's */ struct list_head urb_remove_list; unsigned int urb_remove_age; /* Age in frames */ - /* List of URBs awaiting completion callback */ + /* List of URB's awaiting completion callback */ struct list_head complete_list; int rh_numports; /* Number of root-hub ports */ diff --git a/trunk/drivers/usb/host/uhci-q.c b/trunk/drivers/usb/host/uhci-q.c index b6076004a437..7e46887d9e12 100644 --- a/trunk/drivers/usb/host/uhci-q.c +++ b/trunk/drivers/usb/host/uhci-q.c @@ -80,7 +80,7 @@ static inline void uhci_fill_td(struct uhci_td *td, u32 status, } /* - * We insert Isochronous URBs directly into the frame list at the beginning + * We insert Isochronous URB's directly into the frame list at the beginning */ static void uhci_insert_td_frame_list(struct uhci_hcd *uhci, struct uhci_td *td, unsigned framenum) { @@ -369,7 +369,7 @@ static void uhci_append_queued_urb(struct uhci_hcd *uhci, struct urb *eurb, stru uhci_fixup_toggle(urb, uhci_toggle(td_token(lltd)) ^ 1)); - /* All qhs in the queue need to link to the next queue */ + /* All qh's in the queue need to link to the next queue */ urbp->qh->link = eurbp->qh->link; wmb(); /* Make sure we flush everything */ @@ -502,7 +502,7 @@ static void uhci_destroy_urb_priv(struct uhci_hcd *uhci, struct urb *urb) } /* Check to see if the remove list is empty. Set the IOC bit */ - /* to force an interrupt so we can remove the TDs*/ + /* to force an interrupt so we can remove the TD's*/ if (list_empty(&uhci->td_remove_list)) uhci_set_next_interrupt(uhci); @@ -596,7 +596,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb, struct ur return -ENOMEM; uhci_add_td_to_urb(urb, td); - uhci_fill_td(td, status, destination | uhci_explen(8), + uhci_fill_td(td, status, destination | uhci_explen(7), urb->setup_dma); /* @@ -612,7 +612,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb, struct ur } /* - * Build the DATA TDs + * Build the DATA TD's */ while (len > 0) { int pktsze = len; @@ -628,7 +628,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb, struct ur destination ^= TD_TOKEN_TOGGLE; uhci_add_td_to_urb(urb, td); - uhci_fill_td(td, status, destination | uhci_explen(pktsze), + uhci_fill_td(td, status, destination | uhci_explen(pktsze - 1), data); data += pktsze; @@ -658,7 +658,7 @@ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb, struct ur uhci_add_td_to_urb(urb, td); uhci_fill_td(td, status | TD_CTRL_IOC, - destination | uhci_explen(0), 0); + destination | uhci_explen(UHCI_NULL_DATA_SIZE), 0); qh = uhci_alloc_qh(uhci); if (!qh) @@ -744,7 +744,7 @@ static int uhci_result_control(struct uhci_hcd *uhci, struct urb *urb) urb->actual_length = 0; - /* The rest of the TDs (but the last) are data */ + /* The rest of the TD's (but the last) are data */ tmp = tmp->next; while (tmp != head && tmp->next != head) { unsigned int ctrlstat; @@ -848,7 +848,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb, struct urb status |= TD_CTRL_SPD; /* - * Build the DATA TDs + * Build the DATA TD's */ do { /* Allow zero length packets */ int pktsze = maxsze; @@ -864,7 +864,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb, struct urb return -ENOMEM; uhci_add_td_to_urb(urb, td); - uhci_fill_td(td, status, destination | uhci_explen(pktsze) | + uhci_fill_td(td, status, destination | uhci_explen(pktsze - 1) | (usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe)) << TD_TOKEN_TOGGLE_SHIFT), data); @@ -890,7 +890,7 @@ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb, struct urb return -ENOMEM; uhci_add_td_to_urb(urb, td); - uhci_fill_td(td, status, destination | uhci_explen(0) | + uhci_fill_td(td, status, destination | uhci_explen(UHCI_NULL_DATA_SIZE) | (usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe)) << TD_TOKEN_TOGGLE_SHIFT), data); @@ -1025,7 +1025,7 @@ static int isochronous_find_limits(struct uhci_hcd *uhci, struct urb *urb, unsig list_for_each_entry(up, &uhci->urb_list, urb_list) { struct urb *u = up->urb; - /* look for pending URBs with identical pipe handle */ + /* look for pending URB's with identical pipe handle */ if ((urb->pipe == u->pipe) && (urb->dev == u->dev) && (u->status == -EINPROGRESS) && (u != urb)) { if (!last_urb) @@ -1092,7 +1092,7 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb) return -ENOMEM; uhci_add_td_to_urb(urb, td); - uhci_fill_td(td, status, destination | uhci_explen(urb->iso_frame_desc[i].length), + uhci_fill_td(td, status, destination | uhci_explen(urb->iso_frame_desc[i].length - 1), urb->transfer_dma + urb->iso_frame_desc[i].offset); if (i + 1 >= urb->number_of_packets) @@ -1355,7 +1355,7 @@ static void uhci_unlink_generic(struct uhci_hcd *uhci, struct urb *urb) uhci_delete_queued_urb(uhci, urb); - /* The interrupt loop will reclaim the QHs */ + /* The interrupt loop will reclaim the QH's */ uhci_remove_qh(uhci, urbp->qh); urbp->qh = NULL; } @@ -1413,7 +1413,7 @@ static int uhci_fsbr_timeout(struct uhci_hcd *uhci, struct urb *urb) list_for_each_entry(td, head, list) { /* * Make sure we don't do the last one (since it'll have the - * TERM bit set) as well as we skip every so many TDs to + * TERM bit set) as well as we skip every so many TD's to * make sure it doesn't hog the bandwidth */ if (td->list.next != head && (count % DEPTH_INTERVAL) == diff --git a/trunk/drivers/usb/image/mdc800.c b/trunk/drivers/usb/image/mdc800.c index 049871145d63..1d973bcf56aa 100644 --- a/trunk/drivers/usb/image/mdc800.c +++ b/trunk/drivers/usb/image/mdc800.c @@ -962,6 +962,7 @@ MODULE_DEVICE_TABLE (usb, mdc800_table); */ static struct usb_driver mdc800_usb_driver = { + .owner = THIS_MODULE, .name = "mdc800", .probe = mdc800_usb_probe, .disconnect = mdc800_usb_disconnect, diff --git a/trunk/drivers/usb/image/microtek.c b/trunk/drivers/usb/image/microtek.c index 458f2acdeb0a..950543aa5ac7 100644 --- a/trunk/drivers/usb/image/microtek.c +++ b/trunk/drivers/usb/image/microtek.c @@ -160,6 +160,7 @@ static void mts_usb_disconnect(struct usb_interface *intf); static struct usb_device_id mts_usb_ids []; static struct usb_driver mts_usb_driver = { + .owner = THIS_MODULE, .name = "microtekX6", .probe = mts_usb_probe, .disconnect = mts_usb_disconnect, diff --git a/trunk/drivers/usb/input/Kconfig b/trunk/drivers/usb/input/Kconfig index 509dd0a04c54..1e53934907c0 100644 --- a/trunk/drivers/usb/input/Kconfig +++ b/trunk/drivers/usb/input/Kconfig @@ -273,20 +273,6 @@ config USB_ATI_REMOTE To compile this driver as a module, choose M here: the module will be called ati_remote. -config USB_ATI_REMOTE2 - tristate "ATI / Philips USB RF remote control" - depends on USB && INPUT - ---help--- - Say Y here if you want to use an ATI or Philips USB RF remote control. - These are RF remotes with USB receivers. - ATI Remote Wonder II comes with some ATI's All-In-Wonder video cards - and is also available as a separate product. - This driver provides mouse pointer, left and right mouse buttons, - and maps all the other remote buttons to keypress events. - - To compile this driver as a module, choose M here: the module will be - called ati_remote2. - config USB_KEYSPAN_REMOTE tristate "Keyspan DMR USB remote control (EXPERIMENTAL)" depends on USB && INPUT && EXPERIMENTAL diff --git a/trunk/drivers/usb/input/Makefile b/trunk/drivers/usb/input/Makefile index d512d9f488fe..07cb17db42fc 100644 --- a/trunk/drivers/usb/input/Makefile +++ b/trunk/drivers/usb/input/Makefile @@ -28,7 +28,6 @@ endif obj-$(CONFIG_USB_AIPTEK) += aiptek.o obj-$(CONFIG_USB_ATI_REMOTE) += ati_remote.o -obj-$(CONFIG_USB_ATI_REMOTE2) += ati_remote2.o obj-$(CONFIG_USB_HID) += usbhid.o obj-$(CONFIG_USB_KBD) += usbkbd.o obj-$(CONFIG_USB_KBTAB) += kbtab.o diff --git a/trunk/drivers/usb/input/acecad.c b/trunk/drivers/usb/input/acecad.c index df29b8078b54..a32558b4048e 100644 --- a/trunk/drivers/usb/input/acecad.c +++ b/trunk/drivers/usb/input/acecad.c @@ -261,6 +261,7 @@ static struct usb_device_id usb_acecad_id_table [] = { MODULE_DEVICE_TABLE(usb, usb_acecad_id_table); static struct usb_driver usb_acecad_driver = { + .owner = THIS_MODULE, .name = "usb_acecad", .probe = usb_acecad_probe, .disconnect = usb_acecad_disconnect, diff --git a/trunk/drivers/usb/input/aiptek.c b/trunk/drivers/usb/input/aiptek.c index a6693b0d1c4c..0e2505c073db 100644 --- a/trunk/drivers/usb/input/aiptek.c +++ b/trunk/drivers/usb/input/aiptek.c @@ -338,7 +338,7 @@ struct aiptek { * the bitmap which comes from the tablet. This hides the * issue that the F_keys are not sequentially numbered. */ -static const int macroKeyEvents[] = { +static int macroKeyEvents[] = { KEY_ESC, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11, KEY_F12, KEY_F13, KEY_F14, KEY_F15, KEY_F16, KEY_F17, @@ -2093,7 +2093,7 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id) /* Programming the tablet macro keys needs to be done with a for loop * as the keycodes are discontiguous. */ - for (i = 0; i < ARRAY_SIZE(macroKeyEvents); ++i) + for (i = 0; i < sizeof(macroKeyEvents) / sizeof(macroKeyEvents[0]); ++i) set_bit(macroKeyEvents[i], inputdev->keybit); /* @@ -2135,7 +2135,7 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id) * not an error :-) */ - for (i = 0; i < ARRAY_SIZE(speeds); ++i) { + for (i = 0; i < sizeof(speeds) / sizeof(speeds[0]); ++i) { aiptek->curSetting.programmableDelay = speeds[i]; (void)aiptek_program_tablet(aiptek); if (aiptek->inputdev->absmax[ABS_X] > 0) { @@ -2190,6 +2190,7 @@ fail1: input_free_device(inputdev); static void aiptek_disconnect(struct usb_interface *intf); static struct usb_driver aiptek_driver = { + .owner = THIS_MODULE, .name = "aiptek", .probe = aiptek_probe, .disconnect = aiptek_disconnect, diff --git a/trunk/drivers/usb/input/appletouch.c b/trunk/drivers/usb/input/appletouch.c index 1949b54f41f2..15840db092a5 100644 --- a/trunk/drivers/usb/input/appletouch.c +++ b/trunk/drivers/usb/input/appletouch.c @@ -452,6 +452,7 @@ static int atp_resume(struct usb_interface *iface) } static struct usb_driver atp_driver = { + .owner = THIS_MODULE, .name = "appletouch", .probe = atp_probe, .disconnect = atp_disconnect, diff --git a/trunk/drivers/usb/input/ati_remote.c b/trunk/drivers/usb/input/ati_remote.c index f7bdc506e613..9a2a47db9494 100644 --- a/trunk/drivers/usb/input/ati_remote.c +++ b/trunk/drivers/usb/input/ati_remote.c @@ -96,7 +96,6 @@ #include #include #include -#include /* * Module and Version Information, Module Parameters @@ -147,7 +146,7 @@ static char init1[] = { 0x01, 0x00, 0x20, 0x14 }; static char init2[] = { 0x01, 0x00, 0x20, 0x14, 0x20, 0x20, 0x20 }; /* Acceleration curve for directional control pad */ -static const char accel[] = { 1, 2, 4, 6, 9, 13, 20 }; +static char accel[] = { 1, 2, 4, 6, 9, 13, 20 }; /* Duplicate event filtering time. * Sequential, identical KIND_FILTERED inputs with less than @@ -198,7 +197,7 @@ struct ati_remote { #define KIND_ACCEL 7 /* Directional keypad - left, right, up, down.*/ /* Translation table from hardware messages to input events. */ -static const struct { +static struct { short kind; unsigned char data1, data2; int type; @@ -296,6 +295,7 @@ static void ati_remote_disconnect (struct usb_interface *interface); /* usb specific object to register with the usb subsystem */ static struct usb_driver ati_remote_driver = { + .owner = THIS_MODULE, .name = "ati_remote", .probe = ati_remote_probe, .disconnect = ati_remote_disconnect, @@ -472,7 +472,7 @@ static void ati_remote_input_report(struct urb *urb, struct pt_regs *regs) /* Filter duplicate events which happen "too close" together. */ if ((ati_remote->old_data[0] == data[1]) && (ati_remote->old_data[1] == data[2]) && - time_before(jiffies, ati_remote->old_jiffies + FILTER_TIME)) { + ((ati_remote->old_jiffies + FILTER_TIME) > jiffies)) { ati_remote->repeat_count++; } else { ati_remote->repeat_count = 0; @@ -507,16 +507,16 @@ static void ati_remote_input_report(struct urb *urb, struct pt_regs *regs) * pad down, so we increase acceleration, ramping up over two seconds to * a maximum speed. The acceleration curve is #defined above. */ - if (time_after(jiffies, ati_remote->old_jiffies + (HZ >> 2))) { + if ((jiffies - ati_remote->old_jiffies) > (HZ >> 2)) { acc = 1; ati_remote->acc_jiffies = jiffies; } - else if (time_before(jiffies, ati_remote->acc_jiffies + (HZ >> 3))) acc = accel[0]; - else if (time_before(jiffies, ati_remote->acc_jiffies + (HZ >> 2))) acc = accel[1]; - else if (time_before(jiffies, ati_remote->acc_jiffies + (HZ >> 1))) acc = accel[2]; - else if (time_before(jiffies, ati_remote->acc_jiffies + HZ)) acc = accel[3]; - else if (time_before(jiffies, ati_remote->acc_jiffies + HZ+(HZ>>1))) acc = accel[4]; - else if (time_before(jiffies, ati_remote->acc_jiffies + (HZ << 1))) acc = accel[5]; + else if ((jiffies - ati_remote->acc_jiffies) < (HZ >> 3)) acc = accel[0]; + else if ((jiffies - ati_remote->acc_jiffies) < (HZ >> 2)) acc = accel[1]; + else if ((jiffies - ati_remote->acc_jiffies) < (HZ >> 1)) acc = accel[2]; + else if ((jiffies - ati_remote->acc_jiffies) < HZ ) acc = accel[3]; + else if ((jiffies - ati_remote->acc_jiffies) < HZ+(HZ>>1)) acc = accel[4]; + else if ((jiffies - ati_remote->acc_jiffies) < (HZ << 1)) acc = accel[5]; else acc = accel[6]; input_regs(dev, regs); diff --git a/trunk/drivers/usb/input/ati_remote2.c b/trunk/drivers/usb/input/ati_remote2.c deleted file mode 100644 index ab1a1ae24be9..000000000000 --- a/trunk/drivers/usb/input/ati_remote2.c +++ /dev/null @@ -1,477 +0,0 @@ -/* - * ati_remote2 - ATI/Philips USB RF remote driver - * - * Copyright (C) 2005 Ville Syrjala - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation. - */ - -#include - -#define DRIVER_DESC "ATI/Philips USB RF remote driver" -#define DRIVER_VERSION "0.1" - -MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_VERSION(DRIVER_VERSION); -MODULE_AUTHOR("Ville Syrjala "); -MODULE_LICENSE("GPL"); - -static unsigned int mode_mask = 0x1F; -module_param(mode_mask, uint, 0644); -MODULE_PARM_DESC(mode_mask, "Bitmask of modes to accept <4:PC><3:AUX4><2:AUX3><1:AUX2><0:AUX1>"); - -static struct usb_device_id ati_remote2_id_table[] = { - { USB_DEVICE(0x0471, 0x0602) }, /* ATI Remote Wonder II */ - { } -}; -MODULE_DEVICE_TABLE(usb, ati_remote2_id_table); - -static struct { - int hw_code; - int key_code; -} ati_remote2_key_table[] = { - { 0x00, KEY_0 }, - { 0x01, KEY_1 }, - { 0x02, KEY_2 }, - { 0x03, KEY_3 }, - { 0x04, KEY_4 }, - { 0x05, KEY_5 }, - { 0x06, KEY_6 }, - { 0x07, KEY_7 }, - { 0x08, KEY_8 }, - { 0x09, KEY_9 }, - { 0x0c, KEY_POWER }, - { 0x0d, KEY_MUTE }, - { 0x10, KEY_VOLUMEUP }, - { 0x11, KEY_VOLUMEDOWN }, - { 0x20, KEY_CHANNELUP }, - { 0x21, KEY_CHANNELDOWN }, - { 0x28, KEY_FORWARD }, - { 0x29, KEY_REWIND }, - { 0x2c, KEY_PLAY }, - { 0x30, KEY_PAUSE }, - { 0x31, KEY_STOP }, - { 0x37, KEY_RECORD }, - { 0x38, KEY_DVD }, - { 0x39, KEY_TV }, - { 0x54, KEY_MENU }, - { 0x58, KEY_UP }, - { 0x59, KEY_DOWN }, - { 0x5a, KEY_LEFT }, - { 0x5b, KEY_RIGHT }, - { 0x5c, KEY_OK }, - { 0x78, KEY_A }, - { 0x79, KEY_B }, - { 0x7a, KEY_C }, - { 0x7b, KEY_D }, - { 0x7c, KEY_E }, - { 0x7d, KEY_F }, - { 0x82, KEY_ENTER }, - { 0x8e, KEY_VENDOR }, - { 0x96, KEY_COFFEE }, - { 0xa9, BTN_LEFT }, - { 0xaa, BTN_RIGHT }, - { 0xbe, KEY_QUESTION }, - { 0xd5, KEY_FRONT }, - { 0xd0, KEY_EDIT }, - { 0xf9, KEY_INFO }, - { (0x00 << 8) | 0x3f, KEY_PROG1 }, - { (0x01 << 8) | 0x3f, KEY_PROG2 }, - { (0x02 << 8) | 0x3f, KEY_PROG3 }, - { (0x03 << 8) | 0x3f, KEY_PROG4 }, - { (0x04 << 8) | 0x3f, KEY_PC }, - { 0, KEY_RESERVED } -}; - -struct ati_remote2 { - struct input_dev *idev; - struct usb_device *udev; - - struct usb_interface *intf[2]; - struct usb_endpoint_descriptor *ep[2]; - struct urb *urb[2]; - void *buf[2]; - dma_addr_t buf_dma[2]; - - unsigned long jiffies; - int mode; - - char name[64]; - char phys[64]; -}; - -static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id); -static void ati_remote2_disconnect(struct usb_interface *interface); - -static struct usb_driver ati_remote2_driver = { - .name = "ati_remote2", - .probe = ati_remote2_probe, - .disconnect = ati_remote2_disconnect, - .id_table = ati_remote2_id_table, -}; - -static int ati_remote2_open(struct input_dev *idev) -{ - struct ati_remote2 *ar2 = idev->private; - int r; - - r = usb_submit_urb(ar2->urb[0], GFP_KERNEL); - if (r) { - dev_err(&ar2->intf[0]->dev, - "%s: usb_submit_urb() = %d\n", __FUNCTION__, r); - return r; - } - r = usb_submit_urb(ar2->urb[1], GFP_KERNEL); - if (r) { - usb_kill_urb(ar2->urb[0]); - dev_err(&ar2->intf[1]->dev, - "%s: usb_submit_urb() = %d\n", __FUNCTION__, r); - return r; - } - - return 0; -} - -static void ati_remote2_close(struct input_dev *idev) -{ - struct ati_remote2 *ar2 = idev->private; - - usb_kill_urb(ar2->urb[0]); - usb_kill_urb(ar2->urb[1]); -} - -static void ati_remote2_input_mouse(struct ati_remote2 *ar2, struct pt_regs *regs) -{ - struct input_dev *idev = ar2->idev; - u8 *data = ar2->buf[0]; - - if (data[0] > 4) { - dev_err(&ar2->intf[0]->dev, - "Unknown mode byte (%02x %02x %02x %02x)\n", - data[3], data[2], data[1], data[0]); - return; - } - - if (!((1 << data[0]) & mode_mask)) - return; - - input_regs(idev, regs); - input_event(idev, EV_REL, REL_X, (s8) data[1]); - input_event(idev, EV_REL, REL_Y, (s8) data[2]); - input_sync(idev); -} - -static int ati_remote2_lookup(unsigned int hw_code) -{ - int i; - - for (i = 0; ati_remote2_key_table[i].key_code != KEY_RESERVED; i++) - if (ati_remote2_key_table[i].hw_code == hw_code) - return i; - - return -1; -} - -static void ati_remote2_input_key(struct ati_remote2 *ar2, struct pt_regs *regs) -{ - struct input_dev *idev = ar2->idev; - u8 *data = ar2->buf[1]; - int hw_code, index; - - if (data[0] > 4) { - dev_err(&ar2->intf[1]->dev, - "Unknown mode byte (%02x %02x %02x %02x)\n", - data[3], data[2], data[1], data[0]); - return; - } - - hw_code = data[2]; - /* - * Mode keys (AUX1-AUX4, PC) all generate the same code byte. - * Use the mode byte to figure out which one was pressed. - */ - if (hw_code == 0x3f) { - /* - * For some incomprehensible reason the mouse pad generates - * events which look identical to the events from the last - * pressed mode key. Naturally we don't want to generate key - * events for the mouse pad so we filter out any subsequent - * events from the same mode key. - */ - if (ar2->mode == data[0]) - return; - - if (data[1] == 0) - ar2->mode = data[0]; - - hw_code |= data[0] << 8; - } - - if (!((1 << data[0]) & mode_mask)) - return; - - index = ati_remote2_lookup(hw_code); - if (index < 0) { - dev_err(&ar2->intf[1]->dev, - "Unknown code byte (%02x %02x %02x %02x)\n", - data[3], data[2], data[1], data[0]); - return; - } - - switch (data[1]) { - case 0: /* release */ - break; - case 1: /* press */ - ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_DELAY]); - break; - case 2: /* repeat */ - - /* No repeat for mouse buttons. */ - if (ati_remote2_key_table[index].key_code == BTN_LEFT || - ati_remote2_key_table[index].key_code == BTN_RIGHT) - return; - - if (!time_after_eq(jiffies, ar2->jiffies)) - return; - - ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_PERIOD]); - break; - default: - dev_err(&ar2->intf[1]->dev, - "Unknown state byte (%02x %02x %02x %02x)\n", - data[3], data[2], data[1], data[0]); - return; - } - - input_regs(idev, regs); - input_event(idev, EV_KEY, ati_remote2_key_table[index].key_code, data[1]); - input_sync(idev); -} - -static void ati_remote2_complete_mouse(struct urb *urb, struct pt_regs *regs) -{ - struct ati_remote2 *ar2 = urb->context; - int r; - - switch (urb->status) { - case 0: - ati_remote2_input_mouse(ar2, regs); - break; - case -ENOENT: - case -EILSEQ: - case -ECONNRESET: - case -ESHUTDOWN: - dev_dbg(&ar2->intf[0]->dev, - "%s(): urb status = %d\n", __FUNCTION__, urb->status); - return; - default: - dev_err(&ar2->intf[0]->dev, - "%s(): urb status = %d\n", __FUNCTION__, urb->status); - } - - r = usb_submit_urb(urb, GFP_ATOMIC); - if (r) - dev_err(&ar2->intf[0]->dev, - "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r); -} - -static void ati_remote2_complete_key(struct urb *urb, struct pt_regs *regs) -{ - struct ati_remote2 *ar2 = urb->context; - int r; - - switch (urb->status) { - case 0: - ati_remote2_input_key(ar2, regs); - break; - case -ENOENT: - case -EILSEQ: - case -ECONNRESET: - case -ESHUTDOWN: - dev_dbg(&ar2->intf[1]->dev, - "%s(): urb status = %d\n", __FUNCTION__, urb->status); - return; - default: - dev_err(&ar2->intf[1]->dev, - "%s(): urb status = %d\n", __FUNCTION__, urb->status); - } - - r = usb_submit_urb(urb, GFP_ATOMIC); - if (r) - dev_err(&ar2->intf[1]->dev, - "%s(): usb_submit_urb() = %d\n", __FUNCTION__, r); -} - -static int ati_remote2_input_init(struct ati_remote2 *ar2) -{ - struct input_dev *idev; - int i; - - idev = input_allocate_device(); - if (!idev) - return -ENOMEM; - - ar2->idev = idev; - idev->private = ar2; - - idev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_REL); - idev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT); - idev->relbit[0] = BIT(REL_X) | BIT(REL_Y); - for (i = 0; ati_remote2_key_table[i].key_code != KEY_RESERVED; i++) - set_bit(ati_remote2_key_table[i].key_code, idev->keybit); - - idev->rep[REP_DELAY] = 250; - idev->rep[REP_PERIOD] = 33; - - idev->open = ati_remote2_open; - idev->close = ati_remote2_close; - - idev->name = ar2->name; - idev->phys = ar2->phys; - - usb_to_input_id(ar2->udev, &idev->id); - idev->cdev.dev = &ar2->udev->dev; - - i = input_register_device(idev); - if (i) - input_free_device(idev); - - return i; -} - -static int ati_remote2_urb_init(struct ati_remote2 *ar2) -{ - struct usb_device *udev = ar2->udev; - int i, pipe, maxp; - - for (i = 0; i < 2; i++) { - ar2->buf[i] = usb_buffer_alloc(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]); - if (!ar2->buf[i]) - return -ENOMEM; - - ar2->urb[i] = usb_alloc_urb(0, GFP_KERNEL); - if (!ar2->urb[i]) - return -ENOMEM; - - pipe = usb_rcvintpipe(udev, ar2->ep[i]->bEndpointAddress); - maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe)); - maxp = maxp > 4 ? 4 : maxp; - - usb_fill_int_urb(ar2->urb[i], udev, pipe, ar2->buf[i], maxp, - i ? ati_remote2_complete_key : ati_remote2_complete_mouse, - ar2, ar2->ep[i]->bInterval); - ar2->urb[i]->transfer_dma = ar2->buf_dma[i]; - ar2->urb[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - } - - return 0; -} - -static void ati_remote2_urb_cleanup(struct ati_remote2 *ar2) -{ - int i; - - for (i = 0; i < 2; i++) { - if (ar2->urb[i]) - usb_free_urb(ar2->urb[i]); - - if (ar2->buf[i]) - usb_buffer_free(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]); - } -} - -static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id) -{ - struct usb_device *udev = interface_to_usbdev(interface); - struct usb_host_interface *alt = interface->cur_altsetting; - struct ati_remote2 *ar2; - int r; - - if (alt->desc.bInterfaceNumber) - return -ENODEV; - - ar2 = kzalloc(sizeof (struct ati_remote2), GFP_KERNEL); - if (!ar2) - return -ENOMEM; - - ar2->udev = udev; - - ar2->intf[0] = interface; - ar2->ep[0] = &alt->endpoint[0].desc; - - ar2->intf[1] = usb_ifnum_to_if(udev, 1); - r = usb_driver_claim_interface(&ati_remote2_driver, ar2->intf[1], ar2); - if (r) - goto fail1; - alt = ar2->intf[1]->cur_altsetting; - ar2->ep[1] = &alt->endpoint[0].desc; - - r = ati_remote2_urb_init(ar2); - if (r) - goto fail2; - - usb_make_path(udev, ar2->phys, sizeof(ar2->phys)); - strlcat(ar2->phys, "/input0", sizeof(ar2->phys)); - - strlcat(ar2->name, "ATI Remote Wonder II", sizeof(ar2->name)); - - r = ati_remote2_input_init(ar2); - if (r) - goto fail2; - - usb_set_intfdata(interface, ar2); - - return 0; - - fail2: - ati_remote2_urb_cleanup(ar2); - - usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]); - fail1: - kfree(ar2); - - return r; -} - -static void ati_remote2_disconnect(struct usb_interface *interface) -{ - struct ati_remote2 *ar2; - struct usb_host_interface *alt = interface->cur_altsetting; - - if (alt->desc.bInterfaceNumber) - return; - - ar2 = usb_get_intfdata(interface); - usb_set_intfdata(interface, NULL); - - input_unregister_device(ar2->idev); - - ati_remote2_urb_cleanup(ar2); - - usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]); - - kfree(ar2); -} - -static int __init ati_remote2_init(void) -{ - int r; - - r = usb_register(&ati_remote2_driver); - if (r) - printk(KERN_ERR "ati_remote2: usb_register() = %d\n", r); - else - printk(KERN_INFO "ati_remote2: " DRIVER_DESC " " DRIVER_VERSION "\n"); - - return r; -} - -static void __exit ati_remote2_exit(void) -{ - usb_deregister(&ati_remote2_driver); -} - -module_init(ati_remote2_init); -module_exit(ati_remote2_exit); diff --git a/trunk/drivers/usb/input/fixp-arith.h b/trunk/drivers/usb/input/fixp-arith.h index b44d398de071..26ca5b890a61 100644 --- a/trunk/drivers/usb/input/fixp-arith.h +++ b/trunk/drivers/usb/input/fixp-arith.h @@ -38,7 +38,7 @@ typedef s16 fixp_t; #define FRAC_MASK ((1< + * Copyright (C) 2004 by Daniel Ritz * Copyright (C) by Todd E. Johnson (mtouchusb.c) * * This program is free software; you can redistribute it and/or @@ -41,13 +41,15 @@ #define TOUCHKIT_MAX_YC 0x07ff #define TOUCHKIT_YC_FUZZ 0x0 #define TOUCHKIT_YC_FLAT 0x0 -#define TOUCHKIT_REPORT_DATA_SIZE 16 +#define TOUCHKIT_REPORT_DATA_SIZE 8 #define TOUCHKIT_DOWN 0x01 +#define TOUCHKIT_POINT_TOUCH 0x81 +#define TOUCHKIT_POINT_NOTOUCH 0x80 -#define TOUCHKIT_PKT_TYPE_MASK 0xFE -#define TOUCHKIT_PKT_TYPE_REPT 0x80 -#define TOUCHKIT_PKT_TYPE_DIAG 0x0A +#define TOUCHKIT_GET_TOUCHED(dat) ((((dat)[0]) & TOUCHKIT_DOWN) ? 1 : 0) +#define TOUCHKIT_GET_X(dat) (((dat)[3] << 7) | (dat)[4]) +#define TOUCHKIT_GET_Y(dat) (((dat)[1] << 7) | (dat)[2]) #define DRIVER_VERSION "v0.1" #define DRIVER_AUTHOR "Daniel Ritz " @@ -60,8 +62,6 @@ MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped."); struct touchkit_usb { unsigned char *data; dma_addr_t data_dma; - char buffer[TOUCHKIT_REPORT_DATA_SIZE]; - int buf_len; struct urb *irq; struct usb_device *udev; struct input_dev *input; @@ -77,128 +77,11 @@ static struct usb_device_id touchkit_devices[] = { {} }; -/* helpers to read the data */ -static inline int touchkit_get_touched(char *data) -{ - return (data[0] & TOUCHKIT_DOWN) ? 1 : 0; -} - -static inline int touchkit_get_x(char *data) -{ - return ((data[3] & 0x0F) << 7) | (data[4] & 0x7F); -} - -static inline int touchkit_get_y(char *data) -{ - return ((data[1] & 0x0F) << 7) | (data[2] & 0x7F); -} - - -/* processes one input packet. */ -static void touchkit_process_pkt(struct touchkit_usb *touchkit, - struct pt_regs *regs, char *pkt) -{ - int x, y; - - /* only process report packets */ - if ((pkt[0] & TOUCHKIT_PKT_TYPE_MASK) != TOUCHKIT_PKT_TYPE_REPT) - return; - - if (swap_xy) { - y = touchkit_get_x(pkt); - x = touchkit_get_y(pkt); - } else { - x = touchkit_get_x(pkt); - y = touchkit_get_y(pkt); - } - - input_regs(touchkit->input, regs); - input_report_key(touchkit->input, BTN_TOUCH, touchkit_get_touched(pkt)); - input_report_abs(touchkit->input, ABS_X, x); - input_report_abs(touchkit->input, ABS_Y, y); - input_sync(touchkit->input); -} - - -static int touchkit_get_pkt_len(char *buf) -{ - switch (buf[0] & TOUCHKIT_PKT_TYPE_MASK) { - case TOUCHKIT_PKT_TYPE_REPT: - return 5; - - case TOUCHKIT_PKT_TYPE_DIAG: - return buf[1] + 2; - } - - return 0; -} - -static void touchkit_process(struct touchkit_usb *touchkit, int len, - struct pt_regs *regs) -{ - char *buffer; - int pkt_len, buf_len, pos; - - /* if the buffer contains data, append */ - if (unlikely(touchkit->buf_len)) { - int tmp; - - /* if only 1 byte in buffer, add another one to get length */ - if (touchkit->buf_len == 1) - touchkit->buffer[1] = touchkit->data[0]; - - pkt_len = touchkit_get_pkt_len(touchkit->buffer); - - /* unknown packet: drop everything */ - if (!pkt_len) - return; - - /* append, process */ - tmp = pkt_len - touchkit->buf_len; - memcpy(touchkit->buffer + touchkit->buf_len, touchkit->data, tmp); - touchkit_process_pkt(touchkit, regs, touchkit->buffer); - - buffer = touchkit->data + tmp; - buf_len = len - tmp; - } else { - buffer = touchkit->data; - buf_len = len; - } - - /* only one byte left in buffer */ - if (unlikely(buf_len == 1)) { - touchkit->buffer[0] = buffer[0]; - touchkit->buf_len = 1; - return; - } - - /* loop over the buffer */ - pos = 0; - while (pos < buf_len) { - /* get packet len */ - pkt_len = touchkit_get_pkt_len(buffer + pos); - - /* unknown packet: drop everything */ - if (unlikely(!pkt_len)) - return; - - /* full packet: process */ - if (likely(pkt_len <= buf_len)) { - touchkit_process_pkt(touchkit, regs, buffer + pos); - } else { - /* incomplete packet: save in buffer */ - memcpy(touchkit->buffer, buffer + pos, buf_len - pos); - touchkit->buf_len = buf_len - pos; - } - pos += pkt_len; - } -} - - static void touchkit_irq(struct urb *urb, struct pt_regs *regs) { struct touchkit_usb *touchkit = urb->context; int retval; + int x, y; switch (urb->status) { case 0: @@ -222,7 +105,20 @@ static void touchkit_irq(struct urb *urb, struct pt_regs *regs) goto exit; } - touchkit_process(touchkit, urb->actual_length, regs); + if (swap_xy) { + y = TOUCHKIT_GET_X(touchkit->data); + x = TOUCHKIT_GET_Y(touchkit->data); + } else { + x = TOUCHKIT_GET_X(touchkit->data); + y = TOUCHKIT_GET_Y(touchkit->data); + } + + input_regs(touchkit->input, regs); + input_report_key(touchkit->input, BTN_TOUCH, + TOUCHKIT_GET_TOUCHED(touchkit->data)); + input_report_abs(touchkit->input, ABS_X, x); + input_report_abs(touchkit->input, ABS_Y, y); + input_sync(touchkit->input); exit: retval = usb_submit_urb(urb, GFP_ATOMIC); @@ -371,6 +267,7 @@ static void touchkit_disconnect(struct usb_interface *intf) MODULE_DEVICE_TABLE(usb, touchkit_devices); static struct usb_driver touchkit_driver = { + .owner = THIS_MODULE, .name = "touchkitusb", .probe = touchkit_probe, .disconnect = touchkit_disconnect, diff --git a/trunk/drivers/usb/input/usbkbd.c b/trunk/drivers/usb/input/usbkbd.c index 2f3edc26cb50..226b6f90a907 100644 --- a/trunk/drivers/usb/input/usbkbd.c +++ b/trunk/drivers/usb/input/usbkbd.c @@ -345,6 +345,7 @@ static struct usb_device_id usb_kbd_id_table [] = { MODULE_DEVICE_TABLE (usb, usb_kbd_id_table); static struct usb_driver usb_kbd_driver = { + .owner = THIS_MODULE, .name = "usbkbd", .probe = usb_kbd_probe, .disconnect = usb_kbd_disconnect, diff --git a/trunk/drivers/usb/input/usbmouse.c b/trunk/drivers/usb/input/usbmouse.c index af526135d210..230f6b1b314a 100644 --- a/trunk/drivers/usb/input/usbmouse.c +++ b/trunk/drivers/usb/input/usbmouse.c @@ -226,6 +226,7 @@ static struct usb_device_id usb_mouse_id_table [] = { MODULE_DEVICE_TABLE (usb, usb_mouse_id_table); static struct usb_driver usb_mouse_driver = { + .owner = THIS_MODULE, .name = "usbmouse", .probe = usb_mouse_probe, .disconnect = usb_mouse_disconnect, diff --git a/trunk/drivers/usb/input/wacom.c b/trunk/drivers/usb/input/wacom.c index 48df4cfd5a42..dc099bbe12bf 100644 --- a/trunk/drivers/usb/input/wacom.c +++ b/trunk/drivers/usb/input/wacom.c @@ -945,6 +945,7 @@ static void wacom_disconnect(struct usb_interface *intf) } static struct usb_driver wacom_driver = { + .owner = THIS_MODULE, .name = "wacom", .probe = wacom_probe, .disconnect = wacom_disconnect, diff --git a/trunk/drivers/usb/input/xpad.c b/trunk/drivers/usb/input/xpad.c index e278489a80c6..43112f040b6d 100644 --- a/trunk/drivers/usb/input/xpad.c +++ b/trunk/drivers/usb/input/xpad.c @@ -70,7 +70,7 @@ #define XPAD_PKT_LEN 32 -static const struct xpad_device { +static struct xpad_device { u16 idVendor; u16 idProduct; char *name; @@ -81,13 +81,13 @@ static const struct xpad_device { { 0x0000, 0x0000, "X-Box pad" } }; -static const signed short xpad_btn[] = { +static signed short xpad_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, /* "analog" buttons */ BTN_START, BTN_BACK, BTN_THUMBL, BTN_THUMBR, /* start/back/sticks */ -1 /* terminating entry */ }; -static const signed short xpad_abs[] = { +static signed short xpad_abs[] = { ABS_X, ABS_Y, /* left stick */ ABS_RX, ABS_RY, /* right stick */ ABS_Z, ABS_RZ, /* triggers left/right */ @@ -316,6 +316,7 @@ static void xpad_disconnect(struct usb_interface *intf) } static struct usb_driver xpad_driver = { + .owner = THIS_MODULE, .name = "xpad", .probe = xpad_probe, .disconnect = xpad_disconnect, diff --git a/trunk/drivers/usb/input/yealink.c b/trunk/drivers/usb/input/yealink.c index 1bfc105ad4d6..f526aebea502 100644 --- a/trunk/drivers/usb/input/yealink.c +++ b/trunk/drivers/usb/input/yealink.c @@ -987,6 +987,7 @@ static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id) } static struct usb_driver yealink_driver = { + .owner = THIS_MODULE, .name = "yealink", .probe = usb_probe, .disconnect = usb_disconnect, diff --git a/trunk/drivers/usb/media/dabusb.c b/trunk/drivers/usb/media/dabusb.c index 18d8eaf408d5..27b23c55bbc7 100644 --- a/trunk/drivers/usb/media/dabusb.c +++ b/trunk/drivers/usb/media/dabusb.c @@ -812,6 +812,7 @@ static struct usb_device_id dabusb_ids [] = { MODULE_DEVICE_TABLE (usb, dabusb_ids); static struct usb_driver dabusb_driver = { + .owner = THIS_MODULE, .name = "dabusb", .probe = dabusb_probe, .disconnect = dabusb_disconnect, diff --git a/trunk/drivers/usb/media/dsbr100.c b/trunk/drivers/usb/media/dsbr100.c index 6a5700e9d428..7503f5b96f59 100644 --- a/trunk/drivers/usb/media/dsbr100.c +++ b/trunk/drivers/usb/media/dsbr100.c @@ -150,6 +150,7 @@ MODULE_DEVICE_TABLE (usb, usb_dsbr100_device_table); /* USB subsystem interface */ static struct usb_driver usb_dsbr100_driver = { + .owner = THIS_MODULE, .name = "dsbr100", .probe = usb_dsbr100_probe, .disconnect = usb_dsbr100_disconnect, diff --git a/trunk/drivers/usb/media/ibmcam.c b/trunk/drivers/usb/media/ibmcam.c index a42c22294124..ba41fc7b95c2 100644 --- a/trunk/drivers/usb/media/ibmcam.c +++ b/trunk/drivers/usb/media/ibmcam.c @@ -3457,7 +3457,7 @@ static void ibmcam_model3_setup_after_video_if(struct uvd *uvd) if(init_model3_input) { if (debug > 0) info("Setting input to RCA."); - for (i=0; i < ARRAY_SIZE(initData); i++) { + for (i=0; i < (sizeof(initData)/sizeof(initData[0])); i++) { ibmcam_veio(uvd, initData[i].req, initData[i].value, initData[i].index); } } diff --git a/trunk/drivers/usb/media/konicawc.c b/trunk/drivers/usb/media/konicawc.c index e2ede583518f..9fe2c2710d13 100644 --- a/trunk/drivers/usb/media/konicawc.c +++ b/trunk/drivers/usb/media/konicawc.c @@ -77,14 +77,14 @@ static int saturation = MAX_SATURATION/2; static int sharpness = MAX_SHARPNESS/2; static int whitebal = 3*(MAX_WHITEBAL/4); -static const int spd_to_iface[] = { 1, 0, 3, 2, 4, 5, 6 }; +static int spd_to_iface[] = { 1, 0, 3, 2, 4, 5, 6 }; /* These FPS speeds are from the windows config box. They are * indexed on size (0-2) and speed (0-6). Divide by 3 to get the * real fps. */ -static const int spd_to_fps[][7] = { { 24, 40, 48, 60, 72, 80, 100 }, +static int spd_to_fps[][7] = { { 24, 40, 48, 60, 72, 80, 100 }, { 24, 40, 48, 60, 72, 80, 100 }, { 18, 30, 36, 45, 54, 60, 75 }, { 6, 10, 12, 15, 18, 21, 25 } }; @@ -95,7 +95,7 @@ struct cam_size { u8 cmd; }; -static const struct cam_size camera_sizes[] = { { 160, 120, 0x7 }, +static struct cam_size camera_sizes[] = { { 160, 120, 0x7 }, { 160, 136, 0xa }, { 176, 144, 0x4 }, { 320, 240, 0x5 } }; diff --git a/trunk/drivers/usb/media/ov511.c b/trunk/drivers/usb/media/ov511.c index 3a0e8ce67ebe..036c485d1d1e 100644 --- a/trunk/drivers/usb/media/ov511.c +++ b/trunk/drivers/usb/media/ov511.c @@ -211,7 +211,7 @@ static struct ov51x_decomp_ops *ov518_mmx_decomp_ops; /* Number of times to retry a failed I2C transaction. Increase this if you * are getting "Failed to read sensor ID..." */ -static const int i2c_detect_tries = 5; +static int i2c_detect_tries = 5; /* MMX support is present in kernel and CPU. Checked upon decomp module load. */ #if defined(__i386__) || defined(__x86_64__) @@ -6008,6 +6008,7 @@ ov51x_disconnect(struct usb_interface *intf) } static struct usb_driver ov511_driver = { + .owner = THIS_MODULE, .name = "ov511", .id_table = device_table, .probe = ov51x_probe, diff --git a/trunk/drivers/usb/media/pwc/pwc-ctrl.c b/trunk/drivers/usb/media/pwc/pwc-ctrl.c index 359c4b2df735..53099190952c 100644 --- a/trunk/drivers/usb/media/pwc/pwc-ctrl.c +++ b/trunk/drivers/usb/media/pwc/pwc-ctrl.c @@ -109,7 +109,7 @@ #define PT_RESET_CONTROL_FORMATTER 0x02 #define PT_STATUS_FORMATTER 0x03 -static const char *size2name[PSZ_MAX] = +static char *size2name[PSZ_MAX] = { "subQCIF", "QSIF", diff --git a/trunk/drivers/usb/media/pwc/pwc-if.c b/trunk/drivers/usb/media/pwc/pwc-if.c index 09ca6128ac20..5524fd70210b 100644 --- a/trunk/drivers/usb/media/pwc/pwc-if.c +++ b/trunk/drivers/usb/media/pwc/pwc-if.c @@ -111,6 +111,7 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id static void usb_pwc_disconnect(struct usb_interface *intf); static struct usb_driver pwc_driver = { + .owner = THIS_MODULE, .name = "Philips webcam", /* name */ .id_table = pwc_device_table, .probe = usb_pwc_probe, /* probe() */ diff --git a/trunk/drivers/usb/media/se401.c b/trunk/drivers/usb/media/se401.c index b2ae29af5940..f69e443cd1bc 100644 --- a/trunk/drivers/usb/media/se401.c +++ b/trunk/drivers/usb/media/se401.c @@ -1401,6 +1401,7 @@ static void se401_disconnect(struct usb_interface *intf) } static struct usb_driver se401_driver = { + .owner = THIS_MODULE, .name = "se401", .id_table = device_table, .probe = se401_probe, diff --git a/trunk/drivers/usb/media/sn9c102_core.c b/trunk/drivers/usb/media/sn9c102_core.c index 8d1a1c357d5a..b2e66e3b90aa 100644 --- a/trunk/drivers/usb/media/sn9c102_core.c +++ b/trunk/drivers/usb/media/sn9c102_core.c @@ -1316,7 +1316,7 @@ static int sn9c102_init(struct sn9c102_device* cam) struct v4l2_control ctrl; struct v4l2_queryctrl *qctrl; struct v4l2_rect* rect; - u8 i = 0; + u8 i = 0, n = 0; int err = 0; if (!(cam->state & DEV_INITIALIZED)) { @@ -1352,7 +1352,7 @@ static int sn9c102_init(struct sn9c102_device* cam) return err; if (s->pix_format.pixelformat == V4L2_PIX_FMT_SN9C10X) - DBG(3, "Compressed video format is active, quality %d", + DBG(3, "Compressed video format is active, quality %d", cam->compression.quality) else DBG(3, "Uncompressed video format is active") @@ -1364,8 +1364,9 @@ static int sn9c102_init(struct sn9c102_device* cam) } if (s->set_ctrl) { - for (i = 0; i < ARRAY_SIZE(s->qctrl); i++) - if (s->qctrl[i].id != 0 && + n = sizeof(s->qctrl) / sizeof(s->qctrl[0]); + for (i = 0; i < n; i++) + if (s->qctrl[i].id != 0 && !(s->qctrl[i].flags & V4L2_CTRL_FLAG_DISABLED)) { ctrl.id = s->qctrl[i].id; ctrl.value = qctrl[i].default_value; @@ -1387,7 +1388,7 @@ static int sn9c102_init(struct sn9c102_device* cam) init_waitqueue_head(&cam->wait_stream); cam->nreadbuffers = 2; memcpy(s->_qctrl, s->qctrl, sizeof(s->qctrl)); - memcpy(&(s->_rect), &(s->cropcap.defrect), + memcpy(&(s->_rect), &(s->cropcap.defrect), sizeof(struct v4l2_rect)); cam->state |= DEV_INITIALIZED; } @@ -1809,12 +1810,13 @@ static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp, { struct sn9c102_sensor* s = cam->sensor; struct v4l2_queryctrl qc; - u8 i; + u8 i, n; if (copy_from_user(&qc, arg, sizeof(qc))) return -EFAULT; - for (i = 0; i < ARRAY_SIZE(s->qctrl); i++) + n = sizeof(s->qctrl) / sizeof(s->qctrl[0]); + for (i = 0; i < n; i++) if (qc.id && qc.id == s->qctrl[i].id) { memcpy(&qc, &(s->qctrl[i]), sizeof(qc)); if (copy_to_user(arg, &qc, sizeof(qc))) @@ -1850,7 +1852,7 @@ static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp, { struct sn9c102_sensor* s = cam->sensor; struct v4l2_control ctrl; - u8 i; + u8 i, n; int err = 0; if (!s->set_ctrl) @@ -1859,7 +1861,8 @@ static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp, if (copy_from_user(&ctrl, arg, sizeof(ctrl))) return -EFAULT; - for (i = 0; i < ARRAY_SIZE(s->qctrl); i++) + n = sizeof(s->qctrl) / sizeof(s->qctrl[0]); + for (i = 0; i < n; i++) if (ctrl.id == s->qctrl[i].id) { if (ctrl.value < s->qctrl[i].minimum || ctrl.value > s->qctrl[i].maximum) @@ -2541,7 +2544,7 @@ sn9c102_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) unsigned int i, n; int err = 0, r; - n = ARRAY_SIZE(sn9c102_id_table); + n = sizeof(sn9c102_id_table)/sizeof(sn9c102_id_table[0]); for (i = 0; i < n-1; i++) if (le16_to_cpu(udev->descriptor.idVendor) == sn9c102_id_table[i].idVendor && @@ -2708,6 +2711,7 @@ static void sn9c102_usb_disconnect(struct usb_interface* intf) static struct usb_driver sn9c102_usb_driver = { + .owner = THIS_MODULE, .name = "sn9c102", .id_table = sn9c102_id_table, .probe = sn9c102_usb_probe, diff --git a/trunk/drivers/usb/media/stv680.c b/trunk/drivers/usb/media/stv680.c index 774038b352cd..0fd0fa9fec21 100644 --- a/trunk/drivers/usb/media/stv680.c +++ b/trunk/drivers/usb/media/stv680.c @@ -1477,6 +1477,7 @@ static void stv680_disconnect (struct usb_interface *intf) } static struct usb_driver stv680_driver = { + .owner = THIS_MODULE, .name = "stv680", .probe = stv680_probe, .disconnect = stv680_disconnect, diff --git a/trunk/drivers/usb/media/stv680.h b/trunk/drivers/usb/media/stv680.h index b0551cdb280b..445940612603 100644 --- a/trunk/drivers/usb/media/stv680.h +++ b/trunk/drivers/usb/media/stv680.h @@ -151,7 +151,7 @@ struct usb_stv { }; -static const unsigned char red[256] = { +static unsigned char red[256] = { 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 25, 30, 35, 38, 42, 44, 47, 50, 53, 54, 57, 59, 61, 63, 65, 67, 69, @@ -176,7 +176,7 @@ static const unsigned char red[256] = { 220, 220, 221, 221 }; -static const unsigned char green[256] = { +static unsigned char green[256] = { 0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 28, 34, 39, 43, 47, 50, 53, 56, 59, 61, 64, 66, 68, 71, 73, 75, 77, @@ -201,7 +201,7 @@ static const unsigned char green[256] = { 245, 245, 246, 246 }; -static const unsigned char blue[256] = { +static unsigned char blue[256] = { 0, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 30, 37, 42, 47, 51, 55, 58, 61, 64, 67, 70, 72, 74, 78, 80, 82, 84, diff --git a/trunk/drivers/usb/media/usbvideo.c b/trunk/drivers/usb/media/usbvideo.c index 4bd113325ef9..24efb21969c6 100644 --- a/trunk/drivers/usb/media/usbvideo.c +++ b/trunk/drivers/usb/media/usbvideo.c @@ -725,7 +725,7 @@ int usbvideo_register( /* Allocate user_data separately because of kmalloc's limits */ if (num_extra > 0) { up->user_size = num_cams * num_extra; - up->user_data = kmalloc(up->user_size, GFP_KERNEL); + up->user_data = (char *) kmalloc(up->user_size, GFP_KERNEL); if (up->user_data == NULL) { err("%s: Failed to allocate user_data (%d. bytes)", __FUNCTION__, up->user_size); @@ -955,7 +955,7 @@ static struct file_operations usbvideo_fops = { .ioctl = usbvideo_v4l_ioctl, .llseek = no_llseek, }; -static const struct video_device usbvideo_template = { +static struct video_device usbvideo_template = { .owner = THIS_MODULE, .type = VID_TYPE_CAPTURE, .hardware = VID_HARDWARE_CPIA, diff --git a/trunk/drivers/usb/media/vicam.c b/trunk/drivers/usb/media/vicam.c index 1c73155c8d77..0bc0b1247a6b 100644 --- a/trunk/drivers/usb/media/vicam.c +++ b/trunk/drivers/usb/media/vicam.c @@ -1257,6 +1257,7 @@ static struct usb_device_id vicam_table[] = { MODULE_DEVICE_TABLE(usb, vicam_table); static struct usb_driver vicam_driver = { + .owner = THIS_MODULE, .name = "vicam", .probe = vicam_probe, .disconnect = vicam_disconnect, diff --git a/trunk/drivers/usb/media/w9968cf.c b/trunk/drivers/usb/media/w9968cf.c index 04d69339c054..67612c81cb9f 100644 --- a/trunk/drivers/usb/media/w9968cf.c +++ b/trunk/drivers/usb/media/w9968cf.c @@ -2958,7 +2958,7 @@ static int w9968cf_v4l_ioctl(struct inode* inode, struct file* filp, }; #define V4L1_IOCTL(cmd) \ - ((_IOC_NR((cmd)) < ARRAY_SIZE(v4l1_ioctls)) ? \ + ((_IOC_NR((cmd)) < sizeof(v4l1_ioctls)/sizeof(char*)) ? \ v4l1_ioctls[_IOC_NR((cmd))] : "?") cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp)); @@ -3554,7 +3554,7 @@ w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) /* Allocate 2 bytes of memory for camera control USB transfers */ - if (!(cam->control_buffer = kmalloc(2, GFP_KERNEL))) { + if (!(cam->control_buffer = (u16*)kmalloc(2, GFP_KERNEL))) { DBG(1,"Couldn't allocate memory for camera control transfers") err = -ENOMEM; goto fail; @@ -3562,7 +3562,7 @@ w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id) memset(cam->control_buffer, 0, 2); /* Allocate 8 bytes of memory for USB data transfers to the FSB */ - if (!(cam->data_buffer = kmalloc(8, GFP_KERNEL))) { + if (!(cam->data_buffer = (u16*)kmalloc(8, GFP_KERNEL))) { DBG(1, "Couldn't allocate memory for data " "transfers to the FSB") err = -ENOMEM; @@ -3668,6 +3668,7 @@ static void w9968cf_usb_disconnect(struct usb_interface* intf) static struct usb_driver w9968cf_usb_driver = { + .owner = THIS_MODULE, .name = "w9968cf", .id_table = winbond_id_table, .probe = w9968cf_usb_probe, diff --git a/trunk/drivers/usb/misc/auerswald.c b/trunk/drivers/usb/misc/auerswald.c index 449b2501acf3..b293db3c28c3 100644 --- a/trunk/drivers/usb/misc/auerswald.c +++ b/trunk/drivers/usb/misc/auerswald.c @@ -767,7 +767,7 @@ static int auerbuf_setup (pauerbufctl_t bcp, unsigned int numElements, unsigned memset (bep, 0, sizeof (auerbuf_t)); bep->list = bcp; INIT_LIST_HEAD (&bep->buff_list); - bep->bufp = kmalloc (bufsize, GFP_KERNEL); + bep->bufp = (char *) kmalloc (bufsize, GFP_KERNEL); if (!bep->bufp) goto bl_fail; bep->dr = (struct usb_ctrlrequest *) kmalloc (sizeof (struct usb_ctrlrequest), GFP_KERNEL); @@ -1123,7 +1123,7 @@ static int auerswald_int_open (pauerswald_t cp) } } if (!cp->intbufp) { - cp->intbufp = kmalloc (irqsize, GFP_KERNEL); + cp->intbufp = (char *) kmalloc (irqsize, GFP_KERNEL); if (!cp->intbufp) { ret = -ENOMEM; goto intoend; @@ -2103,6 +2103,7 @@ MODULE_DEVICE_TABLE (usb, auerswald_ids); /* Standard usb driver struct */ static struct usb_driver auerswald_driver = { + .owner = THIS_MODULE, .name = "auerswald", .probe = auerswald_probe, .disconnect = auerswald_disconnect, diff --git a/trunk/drivers/usb/misc/cytherm.c b/trunk/drivers/usb/misc/cytherm.c index 6671317b495f..b33044d56a1e 100644 --- a/trunk/drivers/usb/misc/cytherm.c +++ b/trunk/drivers/usb/misc/cytherm.c @@ -50,6 +50,7 @@ static void cytherm_disconnect(struct usb_interface *interface); /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver cytherm_driver = { + .owner = THIS_MODULE, .name = "cytherm", .probe = cytherm_probe, .disconnect = cytherm_disconnect, diff --git a/trunk/drivers/usb/misc/emi26.c b/trunk/drivers/usb/misc/emi26.c index 3824df33094e..c8155209bf4b 100644 --- a/trunk/drivers/usb/misc/emi26.c +++ b/trunk/drivers/usb/misc/emi26.c @@ -227,6 +227,7 @@ static void emi26_disconnect(struct usb_interface *intf) } static struct usb_driver emi26_driver = { + .owner = THIS_MODULE, .name = "emi26 - firmware loader", .probe = emi26_probe, .disconnect = emi26_disconnect, diff --git a/trunk/drivers/usb/misc/emi62.c b/trunk/drivers/usb/misc/emi62.c index 52fea2e08db8..189986af2ac7 100644 --- a/trunk/drivers/usb/misc/emi62.c +++ b/trunk/drivers/usb/misc/emi62.c @@ -266,6 +266,7 @@ static void emi62_disconnect(struct usb_interface *intf) } static struct usb_driver emi62_driver = { + .owner = THIS_MODULE, .name = "emi62 - firmware loader", .probe = emi62_probe, .disconnect = emi62_disconnect, diff --git a/trunk/drivers/usb/misc/idmouse.c b/trunk/drivers/usb/misc/idmouse.c index d8cde1017985..1dc3e0f73014 100644 --- a/trunk/drivers/usb/misc/idmouse.c +++ b/trunk/drivers/usb/misc/idmouse.c @@ -114,6 +114,7 @@ static struct usb_class_driver idmouse_class = { /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver idmouse_driver = { + .owner = THIS_MODULE, .name = DRIVER_SHORT, .probe = idmouse_probe, .disconnect = idmouse_disconnect, diff --git a/trunk/drivers/usb/misc/ldusb.c b/trunk/drivers/usb/misc/ldusb.c index 981d8a5fbfd9..7e93ac96490f 100644 --- a/trunk/drivers/usb/misc/ldusb.c +++ b/trunk/drivers/usb/misc/ldusb.c @@ -763,6 +763,7 @@ static void ld_usb_disconnect(struct usb_interface *intf) /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver ld_usb_driver = { + .owner = THIS_MODULE, .name = "ldusb", .probe = ld_usb_probe, .disconnect = ld_usb_disconnect, diff --git a/trunk/drivers/usb/misc/legousbtower.c b/trunk/drivers/usb/misc/legousbtower.c index 1336745b8f55..2703e205bc8f 100644 --- a/trunk/drivers/usb/misc/legousbtower.c +++ b/trunk/drivers/usb/misc/legousbtower.c @@ -282,6 +282,7 @@ static struct usb_class_driver tower_class = { /* usb specific object needed to register this driver with the usb subsystem */ static struct usb_driver tower_driver = { + .owner = THIS_MODULE, .name = "legousbtower", .probe = tower_probe, .disconnect = tower_disconnect, diff --git a/trunk/drivers/usb/misc/phidgetkit.c b/trunk/drivers/usb/misc/phidgetkit.c index 605a3c87e05c..067a81486921 100644 --- a/trunk/drivers/usb/misc/phidgetkit.c +++ b/trunk/drivers/usb/misc/phidgetkit.c @@ -555,6 +555,7 @@ static void interfacekit_disconnect(struct usb_interface *interface) } static struct usb_driver interfacekit_driver = { + .owner = THIS_MODULE, .name = "phidgetkit", .probe = interfacekit_probe, .disconnect = interfacekit_disconnect, diff --git a/trunk/drivers/usb/misc/phidgetservo.c b/trunk/drivers/usb/misc/phidgetservo.c index b3418d2bcc69..a30d4a6ee824 100644 --- a/trunk/drivers/usb/misc/phidgetservo.c +++ b/trunk/drivers/usb/misc/phidgetservo.c @@ -306,6 +306,7 @@ servo_disconnect(struct usb_interface *interface) } static struct usb_driver servo_driver = { + .owner = THIS_MODULE, .name = "phidgetservo", .probe = servo_probe, .disconnect = servo_disconnect, diff --git a/trunk/drivers/usb/misc/rio500.c b/trunk/drivers/usb/misc/rio500.c index 384fa3769805..9590dbac5d9a 100644 --- a/trunk/drivers/usb/misc/rio500.c +++ b/trunk/drivers/usb/misc/rio500.c @@ -465,14 +465,14 @@ static int probe_rio(struct usb_interface *intf, rio->rio_dev = dev; - if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) { + if (!(rio->obuf = (char *) kmalloc(OBUF_SIZE, GFP_KERNEL))) { err("probe_rio: Not enough memory for the output buffer"); usb_deregister_dev(intf, &usb_rio_class); return -ENOMEM; } dbg("probe_rio: obuf address:%p", rio->obuf); - if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) { + if (!(rio->ibuf = (char *) kmalloc(IBUF_SIZE, GFP_KERNEL))) { err("probe_rio: Not enough memory for the input buffer"); usb_deregister_dev(intf, &usb_rio_class); kfree(rio->obuf); @@ -522,6 +522,7 @@ static struct usb_device_id rio_table [] = { MODULE_DEVICE_TABLE (usb, rio_table); static struct usb_driver rio_driver = { + .owner = THIS_MODULE, .name = "rio500", .probe = probe_rio, .disconnect = disconnect_rio, diff --git a/trunk/drivers/usb/misc/sisusbvga/sisusb.c b/trunk/drivers/usb/misc/sisusbvga/sisusb.c index 3260d595441f..41ef2b606751 100644 --- a/trunk/drivers/usb/misc/sisusbvga/sisusb.c +++ b/trunk/drivers/usb/misc/sisusbvga/sisusb.c @@ -863,6 +863,9 @@ static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr, switch (length) { + case 0: + return ret; + case 1: if (userbuffer) { if (get_user(swap8, (u8 __user *)userbuffer)) @@ -1218,6 +1221,9 @@ static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr, switch (length) { + case 0: + return ret; + case 1: ret |= sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, @@ -2437,8 +2443,8 @@ sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init) u8 *tempbuf; u16 *tempbufb; size_t written; - static const char bootstring[] = "SiSUSB VGA text console, (C) 2005 Thomas Winischhofer."; - static const char bootlogo[] = "(o_ //\\ V_/_"; + static char bootstring[] = "SiSUSB VGA text console, (C) 2005 Thomas Winischhofer."; + static char bootlogo[] = "(o_ //\\ V_/_"; /* sisusb->lock is down */ @@ -3483,6 +3489,7 @@ static struct usb_device_id sisusb_table [] = { MODULE_DEVICE_TABLE (usb, sisusb_table); static struct usb_driver sisusb_driver = { + .owner = THIS_MODULE, .name = "sisusb", .probe = sisusb_probe, .disconnect = sisusb_disconnect, diff --git a/trunk/drivers/usb/misc/usblcd.c b/trunk/drivers/usb/misc/usblcd.c index cc3dae3f34e0..85f3725334b0 100644 --- a/trunk/drivers/usb/misc/usblcd.c +++ b/trunk/drivers/usb/misc/usblcd.c @@ -371,6 +371,7 @@ static void lcd_disconnect(struct usb_interface *interface) } static struct usb_driver lcd_driver = { + .owner = THIS_MODULE, .name = "usblcd", .probe = lcd_probe, .disconnect = lcd_disconnect, diff --git a/trunk/drivers/usb/misc/usbled.c b/trunk/drivers/usb/misc/usbled.c index 877b081a3a6e..3c93921cb6b3 100644 --- a/trunk/drivers/usb/misc/usbled.c +++ b/trunk/drivers/usb/misc/usbled.c @@ -148,6 +148,7 @@ static void led_disconnect(struct usb_interface *interface) } static struct usb_driver led_driver = { + .owner = THIS_MODULE, .name = "usbled", .probe = led_probe, .disconnect = led_disconnect, diff --git a/trunk/drivers/usb/misc/usbtest.c b/trunk/drivers/usb/misc/usbtest.c index 84fa1728f052..605a2afe34ed 100644 --- a/trunk/drivers/usb/misc/usbtest.c +++ b/trunk/drivers/usb/misc/usbtest.c @@ -2134,6 +2134,7 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver usbtest_driver = { + .owner = THIS_MODULE, .name = "usbtest", .id_table = id_table, .probe = usbtest_probe, diff --git a/trunk/drivers/usb/misc/uss720.c b/trunk/drivers/usb/misc/uss720.c index 4081990b7d1a..1cabe7ed91f5 100644 --- a/trunk/drivers/usb/misc/uss720.c +++ b/trunk/drivers/usb/misc/uss720.c @@ -780,6 +780,7 @@ MODULE_DEVICE_TABLE (usb, uss720_table); static struct usb_driver uss720_driver = { + .owner = THIS_MODULE, .name = "uss720", .probe = uss720_probe, .disconnect = uss720_disconnect, diff --git a/trunk/drivers/usb/mon/mon_text.c b/trunk/drivers/usb/mon/mon_text.c index 611612146ae9..17d0190ef64e 100644 --- a/trunk/drivers/usb/mon/mon_text.c +++ b/trunk/drivers/usb/mon/mon_text.c @@ -97,12 +97,19 @@ static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb, if (len >= DATA_MAX) len = DATA_MAX; - if (usb_pipein(pipe)) { - if (ev_type == 'S') - return '<'; - } else { - if (ev_type == 'C') - return '>'; + /* + * Bulk is easy to shortcut reliably. + * XXX Other pipe types need consideration. Currently, we overdo it + * and collect garbage for them: better more than less. + */ + if (usb_pipebulk(pipe) || usb_pipecontrol(pipe)) { + if (usb_pipein(pipe)) { + if (ev_type == 'S') + return '<'; + } else { + if (ev_type == 'C') + return '>'; + } } /* diff --git a/trunk/drivers/usb/net/asix.c b/trunk/drivers/usb/net/asix.c index 541181695040..542120ef1fd2 100644 --- a/trunk/drivers/usb/net/asix.c +++ b/trunk/drivers/usb/net/asix.c @@ -912,16 +912,13 @@ static const struct usb_device_id products [] = { // ASIX AX88772 10/100 USB_DEVICE (0x0b95, 0x7720), .driver_info = (unsigned long) &ax88772_info, -}, { - // Linksys USB200M Rev 2 - USB_DEVICE (0x13b1, 0x0018), - .driver_info = (unsigned long) &ax88772_info, }, { }, // END }; MODULE_DEVICE_TABLE(usb, products); static struct usb_driver asix_driver = { + .owner = THIS_MODULE, .name = "asix", .id_table = products, .probe = usbnet_probe, diff --git a/trunk/drivers/usb/net/catc.c b/trunk/drivers/usb/net/catc.c index be5f5e142dd0..37ef365a2472 100644 --- a/trunk/drivers/usb/net/catc.c +++ b/trunk/drivers/usb/net/catc.c @@ -934,6 +934,7 @@ static struct usb_device_id catc_id_table [] = { MODULE_DEVICE_TABLE(usb, catc_id_table); static struct usb_driver catc_driver = { + .owner = THIS_MODULE, .name = driver_name, .probe = catc_probe, .disconnect = catc_disconnect, diff --git a/trunk/drivers/usb/net/cdc_ether.c b/trunk/drivers/usb/net/cdc_ether.c index 63f1f3ba8e0b..c008c981862b 100644 --- a/trunk/drivers/usb/net/cdc_ether.c +++ b/trunk/drivers/usb/net/cdc_ether.c @@ -476,6 +476,7 @@ static const struct usb_device_id products [] = { MODULE_DEVICE_TABLE(usb, products); static struct usb_driver cdc_driver = { + .owner = THIS_MODULE, .name = "cdc_ether", .id_table = products, .probe = usbnet_probe, diff --git a/trunk/drivers/usb/net/cdc_subset.c b/trunk/drivers/usb/net/cdc_subset.c index ec801e8bb1bb..f05cfb83c82d 100644 --- a/trunk/drivers/usb/net/cdc_subset.c +++ b/trunk/drivers/usb/net/cdc_subset.c @@ -306,6 +306,7 @@ MODULE_DEVICE_TABLE(usb, products); /*-------------------------------------------------------------------------*/ static struct usb_driver cdc_subset_driver = { + .owner = THIS_MODULE, .name = "cdc_subset", .probe = usbnet_probe, .suspend = usbnet_suspend, diff --git a/trunk/drivers/usb/net/gl620a.c b/trunk/drivers/usb/net/gl620a.c index faf1e86be687..2455e9a85674 100644 --- a/trunk/drivers/usb/net/gl620a.c +++ b/trunk/drivers/usb/net/gl620a.c @@ -377,6 +377,7 @@ static const struct usb_device_id products [] = { MODULE_DEVICE_TABLE(usb, products); static struct usb_driver gl620a_driver = { + .owner = THIS_MODULE, .name = "gl620a", .id_table = products, .probe = usbnet_probe, diff --git a/trunk/drivers/usb/net/kaweth.c b/trunk/drivers/usb/net/kaweth.c index def3bb8e2290..b5776518020f 100644 --- a/trunk/drivers/usb/net/kaweth.c +++ b/trunk/drivers/usb/net/kaweth.c @@ -175,6 +175,7 @@ MODULE_DEVICE_TABLE (usb, usb_klsi_table); * kaweth_driver ****************************************************************/ static struct usb_driver kaweth_driver = { + .owner = THIS_MODULE, .name = driver_name, .probe = kaweth_probe, .disconnect = kaweth_disconnect, diff --git a/trunk/drivers/usb/net/net1080.c b/trunk/drivers/usb/net/net1080.c index 78e6a43b1087..b3799b1a2b0d 100644 --- a/trunk/drivers/usb/net/net1080.c +++ b/trunk/drivers/usb/net/net1080.c @@ -593,6 +593,7 @@ static const struct usb_device_id products [] = { MODULE_DEVICE_TABLE(usb, products); static struct usb_driver net1080_driver = { + .owner = THIS_MODULE, .name = "net1080", .id_table = products, .probe = usbnet_probe, diff --git a/trunk/drivers/usb/net/pegasus.c b/trunk/drivers/usb/net/pegasus.c index 156a2f1cb39a..683e3df5d607 100644 --- a/trunk/drivers/usb/net/pegasus.c +++ b/trunk/drivers/usb/net/pegasus.c @@ -45,7 +45,7 @@ /* * Version Information */ -#define DRIVER_VERSION "v0.6.13 (2005/11/13)" +#define DRIVER_VERSION "v0.6.12 (2005/01/13)" #define DRIVER_AUTHOR "Petko Manolov " #define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver" @@ -57,14 +57,12 @@ static const char driver_name[] = "pegasus"; static int loopback = 0; static int mii_mode = 0; -static char *devid=NULL; static struct usb_eth_dev usb_dev_id[] = { #define PEGASUS_DEV(pn, vid, pid, flags) \ {.name = pn, .vendor = vid, .device = pid, .private = flags}, #include "pegasus.h" #undef PEGASUS_DEV - {NULL, 0, 0, 0}, {NULL, 0, 0, 0} }; @@ -73,7 +71,6 @@ static struct usb_device_id pegasus_ids[] = { {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid}, #include "pegasus.h" #undef PEGASUS_DEV - {}, {} }; @@ -82,10 +79,8 @@ MODULE_DESCRIPTION(DRIVER_DESC); MODULE_LICENSE("GPL"); module_param(loopback, bool, 0); module_param(mii_mode, bool, 0); -module_param(devid, charp, 0); MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)"); MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0"); -MODULE_PARM_DESC(devid, "The format is: 'DEV_name:VendorID:DeviceID:Flags'"); /* use ethtool to change the level for any given device */ static int msg_level = -1; @@ -118,7 +113,7 @@ static void ctrl_callback(struct urb *urb, struct pt_regs *regs) break; default: if (netif_msg_drv(pegasus)) - dev_dbg(&pegasus->intf->dev, "%s, status %d\n", + dev_err(&pegasus->intf->dev, "%s, status %d\n", __FUNCTION__, urb->status); } pegasus->flags &= ~ETH_REGS_CHANGED; @@ -313,9 +308,9 @@ static int read_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 * regd) __le16 regdi; int ret; - set_register(pegasus, PhyCtrl, 0); - set_registers(pegasus, PhyAddr, sizeof (data), data); - set_register(pegasus, PhyCtrl, (indx | PHY_READ)); + ret = set_register(pegasus, PhyCtrl, 0); + ret = set_registers(pegasus, PhyAddr, sizeof (data), data); + ret = set_register(pegasus, PhyCtrl, (indx | PHY_READ)); for (i = 0; i < REG_TIMEOUT; i++) { ret = get_registers(pegasus, PhyCtrl, 1, data); if (data[0] & PHY_DONE) @@ -324,12 +319,12 @@ static int read_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 * regd) if (i < REG_TIMEOUT) { ret = get_registers(pegasus, PhyData, 2, ®di); *regd = le16_to_cpu(regdi); - return ret; + return 1; } if (netif_msg_drv(pegasus)) dev_warn(&pegasus->intf->dev, "fail %s\n", __FUNCTION__); - return ret; + return 0; } static int mdio_read(struct net_device *dev, int phy_id, int loc) @@ -349,20 +344,20 @@ static int write_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 regd) data[1] = (u8) regd; data[2] = (u8) (regd >> 8); - set_register(pegasus, PhyCtrl, 0); - set_registers(pegasus, PhyAddr, sizeof(data), data); - set_register(pegasus, PhyCtrl, (indx | PHY_WRITE)); + ret = set_register(pegasus, PhyCtrl, 0); + ret = set_registers(pegasus, PhyAddr, sizeof(data), data); + ret = set_register(pegasus, PhyCtrl, (indx | PHY_WRITE)); for (i = 0; i < REG_TIMEOUT; i++) { ret = get_registers(pegasus, PhyCtrl, 1, data); if (data[0] & PHY_DONE) break; } if (i < REG_TIMEOUT) - return ret; + return 0; if (netif_msg_drv(pegasus)) dev_warn(&pegasus->intf->dev, "fail %s\n", __FUNCTION__); - return -ETIMEDOUT; + return 1; } static void mdio_write(struct net_device *dev, int phy_id, int loc, int val) @@ -379,9 +374,9 @@ static int read_eprom_word(pegasus_t * pegasus, __u8 index, __u16 * retdata) __le16 retdatai; int ret; - set_register(pegasus, EpromCtrl, 0); - set_register(pegasus, EpromOffset, index); - set_register(pegasus, EpromCtrl, EPROM_READ); + ret = set_register(pegasus, EpromCtrl, 0); + ret = set_register(pegasus, EpromOffset, index); + ret = set_register(pegasus, EpromCtrl, EPROM_READ); for (i = 0; i < REG_TIMEOUT; i++) { ret = get_registers(pegasus, EpromCtrl, 1, &tmp); @@ -391,12 +386,12 @@ static int read_eprom_word(pegasus_t * pegasus, __u8 index, __u16 * retdata) if (i < REG_TIMEOUT) { ret = get_registers(pegasus, EpromData, 2, &retdatai); *retdata = le16_to_cpu(retdatai); - return ret; + return 0; } if (netif_msg_drv(pegasus)) dev_warn(&pegasus->intf->dev, "fail %s\n", __FUNCTION__); - return -ETIMEDOUT; + return -1; } #ifdef PEGASUS_WRITE_EEPROM @@ -405,8 +400,8 @@ static inline void enable_eprom_write(pegasus_t * pegasus) __u8 tmp; int ret; - get_registers(pegasus, EthCtrl2, 1, &tmp); - set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE); + ret = get_registers(pegasus, EthCtrl2, 1, &tmp); + ret = set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE); } static inline void disable_eprom_write(pegasus_t * pegasus) @@ -414,9 +409,9 @@ static inline void disable_eprom_write(pegasus_t * pegasus) __u8 tmp; int ret; - get_registers(pegasus, EthCtrl2, 1, &tmp); - set_register(pegasus, EpromCtrl, 0); - set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE); + ret = get_registers(pegasus, EthCtrl2, 1, &tmp); + ret = set_register(pegasus, EpromCtrl, 0); + ret = set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE); } static int write_eprom_word(pegasus_t * pegasus, __u8 index, __u16 data) @@ -425,11 +420,11 @@ static int write_eprom_word(pegasus_t * pegasus, __u8 index, __u16 data) __u8 tmp, d[4] = { 0x3f, 0, 0, EPROM_WRITE }; int ret; - set_registers(pegasus, EpromOffset, 4, d); + ret = set_registers(pegasus, EpromOffset, 4, d); enable_eprom_write(pegasus); - set_register(pegasus, EpromOffset, index); - set_registers(pegasus, EpromData, 2, &data); - set_register(pegasus, EpromCtrl, EPROM_WRITE); + ret = set_register(pegasus, EpromOffset, index); + ret = set_registers(pegasus, EpromData, 2, &data); + ret = set_register(pegasus, EpromCtrl, EPROM_WRITE); for (i = 0; i < REG_TIMEOUT; i++) { ret = get_registers(pegasus, EpromCtrl, 1, &tmp); @@ -438,10 +433,10 @@ static int write_eprom_word(pegasus_t * pegasus, __u8 index, __u16 data) } disable_eprom_write(pegasus); if (i < REG_TIMEOUT) - return ret; + return 0; if (netif_msg_drv(pegasus)) dev_warn(&pegasus->intf->dev, "fail %s\n", __FUNCTION__); - return -ETIMEDOUT; + return -1; } #endif /* PEGASUS_WRITE_EEPROM */ @@ -459,9 +454,10 @@ static inline void get_node_id(pegasus_t * pegasus, __u8 * id) static void set_ethernet_addr(pegasus_t * pegasus) { __u8 node_id[6]; + int ret; get_node_id(pegasus, node_id); - set_registers(pegasus, EthID, sizeof (node_id), node_id); + ret = set_registers(pegasus, EthID, sizeof (node_id), node_id); memcpy(pegasus->net->dev_addr, node_id, sizeof (node_id)); } @@ -469,29 +465,30 @@ static inline int reset_mac(pegasus_t * pegasus) { __u8 data = 0x8; int i; + int ret; - set_register(pegasus, EthCtrl1, data); + ret = set_register(pegasus, EthCtrl1, data); for (i = 0; i < REG_TIMEOUT; i++) { - get_registers(pegasus, EthCtrl1, 1, &data); + ret = get_registers(pegasus, EthCtrl1, 1, &data); if (~data & 0x08) { if (loopback & 1) break; if (mii_mode && (pegasus->features & HAS_HOME_PNA)) - set_register(pegasus, Gpio1, 0x34); + ret = set_register(pegasus, Gpio1, 0x34); else - set_register(pegasus, Gpio1, 0x26); - set_register(pegasus, Gpio0, pegasus->features); - set_register(pegasus, Gpio0, DEFAULT_GPIO_SET); + ret = set_register(pegasus, Gpio1, 0x26); + ret = set_register(pegasus, Gpio0, pegasus->features); + ret = set_register(pegasus, Gpio0, DEFAULT_GPIO_SET); break; } } if (i == REG_TIMEOUT) - return -ETIMEDOUT; + return 1; if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS || usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) { - set_register(pegasus, Gpio0, 0x24); - set_register(pegasus, Gpio0, 0x26); + ret = set_register(pegasus, Gpio0, 0x24); + ret = set_register(pegasus, Gpio0, 0x26); } if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) { __u16 auxmode; @@ -530,7 +527,7 @@ static int enable_net_traffic(struct net_device *dev, struct usb_device *usb) write_mii_word(pegasus, 0, 0x1b, auxmode | 4); } - return ret; + return 0; } static void fill_skb_pool(pegasus_t * pegasus) @@ -884,8 +881,9 @@ static struct net_device_stats *pegasus_netdev_stats(struct net_device *dev) static inline void disable_net_traffic(pegasus_t * pegasus) { int tmp = 0; + int ret; - set_registers(pegasus, EthCtrl0, 2, &tmp); + ret = set_registers(pegasus, EthCtrl0, 2, &tmp); } static inline void get_interrupt_interval(pegasus_t * pegasus) @@ -1208,17 +1206,18 @@ static __u8 mii_phy_probe(pegasus_t * pegasus) static inline void setup_pegasus_II(pegasus_t * pegasus) { __u8 data = 0xa5; + int ret; - set_register(pegasus, Reg1d, 0); - set_register(pegasus, Reg7b, 1); + ret = set_register(pegasus, Reg1d, 0); + ret = set_register(pegasus, Reg7b, 1); mdelay(100); if ((pegasus->features & HAS_HOME_PNA) && mii_mode) - set_register(pegasus, Reg7b, 0); + ret = set_register(pegasus, Reg7b, 0); else - set_register(pegasus, Reg7b, 2); + ret = set_register(pegasus, Reg7b, 2); - set_register(pegasus, 0x83, data); - get_registers(pegasus, 0x83, 1, &data); + ret = set_register(pegasus, 0x83, data); + ret = get_registers(pegasus, 0x83, 1, &data); if (data == 0xa5) { pegasus->chip = 0x8513; @@ -1226,14 +1225,14 @@ static inline void setup_pegasus_II(pegasus_t * pegasus) pegasus->chip = 0; } - set_register(pegasus, 0x80, 0xc0); - set_register(pegasus, 0x83, 0xff); - set_register(pegasus, 0x84, 0x01); + ret = set_register(pegasus, 0x80, 0xc0); + ret = set_register(pegasus, 0x83, 0xff); + ret = set_register(pegasus, 0x84, 0x01); if (pegasus->features & HAS_HOME_PNA && mii_mode) - set_register(pegasus, Reg81, 6); + ret = set_register(pegasus, Reg81, 6); else - set_register(pegasus, Reg81, 2); + ret = set_register(pegasus, Reg81, 2); } @@ -1415,42 +1414,9 @@ static struct usb_driver pegasus_driver = { .resume = pegasus_resume, }; -static void parse_id(char *id) -{ - unsigned int vendor_id=0, device_id=0, flags=0, i=0; - char *token, *name=NULL; - - if ((token = strsep(&id, ":")) != NULL) - name = token; - /* name now points to a null terminated string*/ - if ((token = strsep(&id, ":")) != NULL) - vendor_id = simple_strtoul(token, NULL, 16); - if ((token = strsep(&id, ":")) != NULL) - device_id = simple_strtoul(token, NULL, 16); - flags = simple_strtoul(id, NULL, 16); - pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n", - driver_name, name, vendor_id, device_id, flags); - - if (vendor_id > 0x10000 || vendor_id == 0) - return; - if (device_id > 0x10000 || device_id == 0) - return; - - for (i=0; usb_dev_id[i].name; i++); - usb_dev_id[i].name = name; - usb_dev_id[i].vendor = vendor_id; - usb_dev_id[i].device = device_id; - usb_dev_id[i].private = flags; - pegasus_ids[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE; - pegasus_ids[i].idVendor = vendor_id; - pegasus_ids[i].idProduct = device_id; -} - static int __init pegasus_init(void) { pr_info("%s: %s, " DRIVER_DESC "\n", driver_name, DRIVER_VERSION); - if (devid) - parse_id(devid); pegasus_workqueue = create_singlethread_workqueue("pegasus"); if (!pegasus_workqueue) return -ENOMEM; diff --git a/trunk/drivers/usb/net/plusb.c b/trunk/drivers/usb/net/plusb.c index 4fe863389cb7..89856aa0e3b8 100644 --- a/trunk/drivers/usb/net/plusb.c +++ b/trunk/drivers/usb/net/plusb.c @@ -127,6 +127,7 @@ static const struct usb_device_id products [] = { MODULE_DEVICE_TABLE(usb, products); static struct usb_driver plusb_driver = { + .owner = THIS_MODULE, .name = "plusb", .id_table = products, .probe = usbnet_probe, diff --git a/trunk/drivers/usb/net/rndis_host.c b/trunk/drivers/usb/net/rndis_host.c index 49991ac1bf3b..c0ecbab6f6ba 100644 --- a/trunk/drivers/usb/net/rndis_host.c +++ b/trunk/drivers/usb/net/rndis_host.c @@ -586,6 +586,7 @@ static const struct usb_device_id products [] = { MODULE_DEVICE_TABLE(usb, products); static struct usb_driver rndis_driver = { + .owner = THIS_MODULE, .name = "rndis_host", .id_table = products, .probe = usbnet_probe, diff --git a/trunk/drivers/usb/net/rtl8150.c b/trunk/drivers/usb/net/rtl8150.c index 8ca52be23976..787dd3591d6a 100644 --- a/trunk/drivers/usb/net/rtl8150.c +++ b/trunk/drivers/usb/net/rtl8150.c @@ -177,6 +177,7 @@ static int rtl8150_probe(struct usb_interface *intf, static const char driver_name [] = "rtl8150"; static struct usb_driver rtl8150_driver = { + .owner = THIS_MODULE, .name = driver_name, .probe = rtl8150_probe, .disconnect = rtl8150_disconnect, diff --git a/trunk/drivers/usb/net/zaurus.c b/trunk/drivers/usb/net/zaurus.c index 9c5ab251370c..680d13957af4 100644 --- a/trunk/drivers/usb/net/zaurus.c +++ b/trunk/drivers/usb/net/zaurus.c @@ -357,6 +357,7 @@ static const struct usb_device_id products [] = { MODULE_DEVICE_TABLE(usb, products); static struct usb_driver zaurus_driver = { + .owner = THIS_MODULE, .name = "zaurus", .id_table = products, .probe = usbnet_probe, diff --git a/trunk/drivers/usb/net/zd1201.c b/trunk/drivers/usb/net/zd1201.c index f3a8e2807c3b..2f52261c7cc1 100644 --- a/trunk/drivers/usb/net/zd1201.c +++ b/trunk/drivers/usb/net/zd1201.c @@ -1722,7 +1722,7 @@ static const struct iw_priv_args zd1201_private_args[] = { IW_PRIV_TYPE_NONE, "sethostauth" }, { ZD1201GIWHOSTAUTH, IW_PRIV_TYPE_NONE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostauth" }, - { ZD1201SIWAUTHSTA, IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, + { ZD1201SIWAUTHSTA, IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, IW_PRIV_TYPE_NONE, "authstation" }, { ZD1201SIWMAXASSOC, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, IW_PRIV_TYPE_NONE, "setmaxassoc" }, @@ -1731,9 +1731,9 @@ static const struct iw_priv_args zd1201_private_args[] = { }; static const struct iw_handler_def zd1201_iw_handlers = { - .num_standard = ARRAY_SIZE(zd1201_iw_handler), - .num_private = ARRAY_SIZE(zd1201_private_handler), - .num_private_args = ARRAY_SIZE(zd1201_private_args), + .num_standard = sizeof(zd1201_iw_handler)/sizeof(iw_handler), + .num_private = sizeof(zd1201_private_handler)/sizeof(iw_handler), + .num_private_args = sizeof(zd1201_private_args)/sizeof(struct iw_priv_args), .standard = (iw_handler *)zd1201_iw_handler, .private = (iw_handler *)zd1201_private_handler, .private_args = (struct iw_priv_args *) zd1201_private_args, @@ -1829,8 +1829,6 @@ static int zd1201_probe(struct usb_interface *interface, if (err) goto err_net; - SET_NETDEV_DEV(zd->dev, &usb->dev); - err = register_netdev(zd->dev); if (err) goto err_net; @@ -1925,6 +1923,7 @@ static int zd1201_resume(struct usb_interface *interface) #endif static struct usb_driver zd1201_usb = { + .owner = THIS_MODULE, .name = "zd1201", .probe = zd1201_probe, .disconnect = zd1201_disconnect, diff --git a/trunk/drivers/usb/serial/airprime.c b/trunk/drivers/usb/serial/airprime.c index dbf1f063098c..1f29d8837327 100644 --- a/trunk/drivers/usb/serial/airprime.c +++ b/trunk/drivers/usb/serial/airprime.c @@ -23,11 +23,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE(usb, id_table); static struct usb_driver airprime_driver = { + .owner = THIS_MODULE, .name = "airprime", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; static struct usb_serial_driver airprime_device = { diff --git a/trunk/drivers/usb/serial/anydata.c b/trunk/drivers/usb/serial/anydata.c index 343f6f228220..18022a74a3dc 100644 --- a/trunk/drivers/usb/serial/anydata.c +++ b/trunk/drivers/usb/serial/anydata.c @@ -27,11 +27,11 @@ static int buffer_size; static int debug; static struct usb_driver anydata_driver = { + .owner = THIS_MODULE, .name = "anydata", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; static int anydata_open(struct usb_serial_port *port, struct file *filp) diff --git a/trunk/drivers/usb/serial/belkin_sa.c b/trunk/drivers/usb/serial/belkin_sa.c index 4144777ea18b..84bc0ee4f061 100644 --- a/trunk/drivers/usb/serial/belkin_sa.c +++ b/trunk/drivers/usb/serial/belkin_sa.c @@ -113,11 +113,11 @@ static struct usb_device_id id_table_combined [] = { MODULE_DEVICE_TABLE (usb, id_table_combined); static struct usb_driver belkin_driver = { + .owner = THIS_MODULE, .name = "belkin", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; /* All of the device info needed for the serial converters */ diff --git a/trunk/drivers/usb/serial/cp2101.c b/trunk/drivers/usb/serial/cp2101.c index da46b351e188..c9787001cf2a 100644 --- a/trunk/drivers/usb/serial/cp2101.c +++ b/trunk/drivers/usb/serial/cp2101.c @@ -67,11 +67,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver cp2101_driver = { + .owner = THIS_MODULE, .name = "cp2101", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; static struct usb_serial_driver cp2101_device = { diff --git a/trunk/drivers/usb/serial/cyberjack.c b/trunk/drivers/usb/serial/cyberjack.c index 6d18d4eaba35..e581e4ae8483 100644 --- a/trunk/drivers/usb/serial/cyberjack.c +++ b/trunk/drivers/usb/serial/cyberjack.c @@ -76,11 +76,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver cyberjack_driver = { + .owner = THIS_MODULE, .name = "cyberjack", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; static struct usb_serial_driver cyberjack_device = { diff --git a/trunk/drivers/usb/serial/cypress_m8.c b/trunk/drivers/usb/serial/cypress_m8.c index af18355e94cc..af9290ed257b 100644 --- a/trunk/drivers/usb/serial/cypress_m8.c +++ b/trunk/drivers/usb/serial/cypress_m8.c @@ -112,7 +112,6 @@ static struct usb_driver cypress_driver = { .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; struct cypress_private { diff --git a/trunk/drivers/usb/serial/digi_acceleport.c b/trunk/drivers/usb/serial/digi_acceleport.c index 8fc414bd5b24..dc74644a603d 100644 --- a/trunk/drivers/usb/serial/digi_acceleport.c +++ b/trunk/drivers/usb/serial/digi_acceleport.c @@ -493,11 +493,11 @@ static struct usb_device_id id_table_4 [] = { MODULE_DEVICE_TABLE (usb, id_table_combined); static struct usb_driver digi_driver = { + .owner = THIS_MODULE, .name = "digi_acceleport", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; diff --git a/trunk/drivers/usb/serial/empeg.c b/trunk/drivers/usb/serial/empeg.c index 79a766e9ca23..0b0546dcc7b9 100644 --- a/trunk/drivers/usb/serial/empeg.c +++ b/trunk/drivers/usb/serial/empeg.c @@ -105,11 +105,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver empeg_driver = { + .owner = THIS_MODULE, .name = "empeg", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; static struct usb_serial_driver empeg_device = { diff --git a/trunk/drivers/usb/serial/ftdi_sio.c b/trunk/drivers/usb/serial/ftdi_sio.c index eb863b3f2d79..06e04b442ff1 100644 --- a/trunk/drivers/usb/serial/ftdi_sio.c +++ b/trunk/drivers/usb/serial/ftdi_sio.c @@ -471,15 +471,12 @@ static struct usb_device_id id_table_combined [] = { { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) }, { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) }, { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) }, - { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) }, - { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) }, { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) }, { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) }, { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) }, { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) }, { USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) }, { USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) }, - { USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) }, { }, /* Optional parameter entry */ { } /* Terminating entry */ }; @@ -491,10 +488,9 @@ static struct usb_driver ftdi_driver = { .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; -static const char *ftdi_chip_name[] = { +static char *ftdi_chip_name[] = { [SIO] = "SIO", /* the serial part of FT8U100AX */ [FT8U232AM] = "FT8U232AM", [FT232BM] = "FT232BM", diff --git a/trunk/drivers/usb/serial/ftdi_sio.h b/trunk/drivers/usb/serial/ftdi_sio.h index 00d45f8600de..773ea3eca086 100644 --- a/trunk/drivers/usb/serial/ftdi_sio.h +++ b/trunk/drivers/usb/serial/ftdi_sio.h @@ -342,13 +342,6 @@ #define XSENS_CONVERTER_6_PID 0xD38E #define XSENS_CONVERTER_7_PID 0xD38F -/* - * Teratronik product ids. - * Submitted by O. Wölfelschneider. - */ -#define FTDI_TERATRONIK_VCP_PID 0xEC88 /* Teratronik device (preferring VCP driver on windows) */ -#define FTDI_TERATRONIK_D2XX_PID 0xEC89 /* Teratronik device (preferring D2XX driver on windows) */ - /* * Evolution Robotics products (http://www.evolution.com/). * Submitted by Shawn M. Lavelle. @@ -359,12 +352,6 @@ /* Pyramid Computer GmbH */ #define FTDI_PYRAMID_PID 0xE6C8 /* Pyramid Appliance Display */ -/* - * Posiflex inc retail equipment (http://www.posiflex.com.tw) - */ -#define POSIFLEX_VID 0x0d3a /* Vendor ID */ -#define POSIFLEX_PP7000_PID 0x0300 /* PP-7000II thermal printer */ - /* Commands */ #define FTDI_SIO_RESET 0 /* Reset the port */ #define FTDI_SIO_MODEM_CTRL 1 /* Set the modem control register */ @@ -727,7 +714,7 @@ typedef enum { */ /* FTDI_SIO_GET_MODEM_STATUS */ -/* Retrieve the current value of the modem status register */ +/* Retreive the current value of the modem status register */ #define FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE 0xc0 #define FTDI_SIO_GET_MODEM_STATUS_REQUEST FTDI_SIO_GET_MODEM_STATUS diff --git a/trunk/drivers/usb/serial/garmin_gps.c b/trunk/drivers/usb/serial/garmin_gps.c index 452efce72714..35820bda7ae1 100644 --- a/trunk/drivers/usb/serial/garmin_gps.c +++ b/trunk/drivers/usb/serial/garmin_gps.c @@ -222,11 +222,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver garmin_driver = { + .owner = THIS_MODULE, .name = "garmin_gps", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; diff --git a/trunk/drivers/usb/serial/generic.c b/trunk/drivers/usb/serial/generic.c index 4ddac620fc0c..53a47c31cd0e 100644 --- a/trunk/drivers/usb/serial/generic.c +++ b/trunk/drivers/usb/serial/generic.c @@ -68,11 +68,11 @@ static int generic_probe(struct usb_interface *interface, } static struct usb_driver generic_driver = { + .owner = THIS_MODULE, .name = "usbserial_generic", .probe = generic_probe, .disconnect = usb_serial_disconnect, .id_table = generic_serial_ids, - .no_dynamic_id = 1, }; #endif diff --git a/trunk/drivers/usb/serial/hp4x.c b/trunk/drivers/usb/serial/hp4x.c index e9719da2aca1..8eadfb705601 100644 --- a/trunk/drivers/usb/serial/hp4x.c +++ b/trunk/drivers/usb/serial/hp4x.c @@ -37,11 +37,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE(usb, id_table); static struct usb_driver hp49gp_driver = { + .owner = THIS_MODULE, .name = "hp4X", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; static struct usb_serial_driver hp49gp_device = { diff --git a/trunk/drivers/usb/serial/io_edgeport.c b/trunk/drivers/usb/serial/io_edgeport.c index faedbeb6ba49..dc4c498bd1ed 100644 --- a/trunk/drivers/usb/serial/io_edgeport.c +++ b/trunk/drivers/usb/serial/io_edgeport.c @@ -184,7 +184,7 @@ struct divisor_table_entry { // These assume a 3.6864MHz crystal, the standard /16, and // MCR.7 = 0. // -static const struct divisor_table_entry divisor_table[] = { +static struct divisor_table_entry divisor_table[] = { { 50, 4608}, { 75, 3072}, { 110, 2095}, /* 2094.545455 => 230450 => .0217 % over */ @@ -242,11 +242,11 @@ static void edge_shutdown (struct usb_serial *serial); #include "io_tables.h" /* all of the devices that this driver supports */ static struct usb_driver io_driver = { + .owner = THIS_MODULE, .name = "io_edgeport", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; /* function prototypes for all of our local functions */ @@ -2353,7 +2353,7 @@ static int calc_baud_rate_divisor (int baudrate, int *divisor) dbg("%s - %d", __FUNCTION__, baudrate); - for (i = 0; i < ARRAY_SIZE(divisor_table); i++) { + for (i = 0; i < NUM_ENTRIES(divisor_table); i++) { if ( divisor_table[i].BaudRate == baudrate ) { *divisor = divisor_table[i].Divisor; return 0; diff --git a/trunk/drivers/usb/serial/io_edgeport.h b/trunk/drivers/usb/serial/io_edgeport.h index 123fa8a904e6..5112d7aac055 100644 --- a/trunk/drivers/usb/serial/io_edgeport.h +++ b/trunk/drivers/usb/serial/io_edgeport.h @@ -31,6 +31,9 @@ #ifndef HIGH8 #define HIGH8(a) ((unsigned char)((a & 0xff00) >> 8)) #endif +#ifndef NUM_ENTRIES + #define NUM_ENTRIES(x) (sizeof(x)/sizeof((x)[0])) +#endif #ifndef __KERNEL__ #define __KERNEL__ diff --git a/trunk/drivers/usb/serial/io_fw_boot2.h b/trunk/drivers/usb/serial/io_fw_boot2.h index e3463de99de4..c7c3a3c305fe 100644 --- a/trunk/drivers/usb/serial/io_fw_boot2.h +++ b/trunk/drivers/usb/serial/io_fw_boot2.h @@ -537,7 +537,7 @@ static unsigned char IMAGE_ARRAY_NAME[] = { }; -static const struct edge_firmware_version_info IMAGE_VERSION_NAME = { +static struct edge_firmware_version_info IMAGE_VERSION_NAME = { 2, 0, 3 }; // Major, Minor, Build #undef IMAGE_VERSION_NAME diff --git a/trunk/drivers/usb/serial/io_ti.c b/trunk/drivers/usb/serial/io_ti.c index 2edf9cabad20..832b6d6734c0 100644 --- a/trunk/drivers/usb/serial/io_ti.c +++ b/trunk/drivers/usb/serial/io_ti.c @@ -216,11 +216,11 @@ static struct usb_device_id id_table_combined [] = { MODULE_DEVICE_TABLE (usb, id_table_combined); static struct usb_driver io_driver = { + .owner = THIS_MODULE, .name = "io_ti", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; @@ -2843,7 +2843,7 @@ static struct edge_buf *edge_buf_alloc(unsigned int size) * Free the buffer and all associated memory. */ -static void edge_buf_free(struct edge_buf *eb) +void edge_buf_free(struct edge_buf *eb) { if (eb) { kfree(eb->buf_buf); diff --git a/trunk/drivers/usb/serial/ipaq.c b/trunk/drivers/usb/serial/ipaq.c index 06d07cea0b70..d5d066488100 100644 --- a/trunk/drivers/usb/serial/ipaq.c +++ b/trunk/drivers/usb/serial/ipaq.c @@ -542,11 +542,11 @@ static struct usb_device_id ipaq_id_table [] = { MODULE_DEVICE_TABLE (usb, ipaq_id_table); static struct usb_driver ipaq_driver = { + .owner = THIS_MODULE, .name = "ipaq", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = ipaq_id_table, - .no_dynamic_id = 1, }; diff --git a/trunk/drivers/usb/serial/ipw.c b/trunk/drivers/usb/serial/ipw.c index 2dd191f5fe76..7744b8148bc5 100644 --- a/trunk/drivers/usb/serial/ipw.c +++ b/trunk/drivers/usb/serial/ipw.c @@ -152,11 +152,11 @@ static struct usb_device_id usb_ipw_ids[] = { MODULE_DEVICE_TABLE(usb, usb_ipw_ids); static struct usb_driver usb_ipw_driver = { + .owner = THIS_MODULE, .name = "ipwtty", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = usb_ipw_ids, - .no_dynamic_id = 1, }; static int debug; diff --git a/trunk/drivers/usb/serial/ir-usb.c b/trunk/drivers/usb/serial/ir-usb.c index a59010421444..19f329e9bdcf 100644 --- a/trunk/drivers/usb/serial/ir-usb.c +++ b/trunk/drivers/usb/serial/ir-usb.c @@ -125,11 +125,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver ir_driver = { + .owner = THIS_MODULE, .name = "ir-usb", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; diff --git a/trunk/drivers/usb/serial/keyspan.h b/trunk/drivers/usb/serial/keyspan.h index 7472ed6bf626..5cfc13b5e56f 100644 --- a/trunk/drivers/usb/serial/keyspan.h +++ b/trunk/drivers/usb/serial/keyspan.h @@ -520,11 +520,11 @@ static struct usb_device_id keyspan_ids_combined[] = { MODULE_DEVICE_TABLE(usb, keyspan_ids_combined); static struct usb_driver keyspan_driver = { + .owner = THIS_MODULE, .name = "keyspan", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = keyspan_ids_combined, - .no_dynamic_id = 1, }; /* usb_device_id table for the pre-firmware download keyspan devices */ diff --git a/trunk/drivers/usb/serial/keyspan_pda.c b/trunk/drivers/usb/serial/keyspan_pda.c index b0441c35f98f..cd4f48bd83b6 100644 --- a/trunk/drivers/usb/serial/keyspan_pda.c +++ b/trunk/drivers/usb/serial/keyspan_pda.c @@ -150,11 +150,11 @@ static struct usb_device_id id_table_combined [] = { MODULE_DEVICE_TABLE (usb, id_table_combined); static struct usb_driver keyspan_pda_driver = { + .owner = THIS_MODULE, .name = "keyspan_pda", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; static struct usb_device_id id_table_std [] = { diff --git a/trunk/drivers/usb/serial/kl5kusb105.c b/trunk/drivers/usb/serial/kl5kusb105.c index 4e2f7dfb58b2..a8951c0fd020 100644 --- a/trunk/drivers/usb/serial/kl5kusb105.c +++ b/trunk/drivers/usb/serial/kl5kusb105.c @@ -116,11 +116,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver kl5kusb105d_driver = { + .owner = THIS_MODULE, .name = "kl5kusb105d", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; static struct usb_serial_driver kl5kusb105d_device = { diff --git a/trunk/drivers/usb/serial/kobil_sct.c b/trunk/drivers/usb/serial/kobil_sct.c index d9c21e275130..9456dd9dd136 100644 --- a/trunk/drivers/usb/serial/kobil_sct.c +++ b/trunk/drivers/usb/serial/kobil_sct.c @@ -97,11 +97,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver kobil_driver = { + .owner = THIS_MODULE, .name = "kobil", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; diff --git a/trunk/drivers/usb/serial/mct_u232.c b/trunk/drivers/usb/serial/mct_u232.c index b6d6cab9c859..ca5dbadb9b7e 100644 --- a/trunk/drivers/usb/serial/mct_u232.c +++ b/trunk/drivers/usb/serial/mct_u232.c @@ -125,11 +125,11 @@ static struct usb_device_id id_table_combined [] = { MODULE_DEVICE_TABLE (usb, id_table_combined); static struct usb_driver mct_u232_driver = { + .owner = THIS_MODULE, .name = "mct_u232", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; static struct usb_serial_driver mct_u232_device = { diff --git a/trunk/drivers/usb/serial/omninet.c b/trunk/drivers/usb/serial/omninet.c index 762d8ff9a1e4..3caf97072ac0 100644 --- a/trunk/drivers/usb/serial/omninet.c +++ b/trunk/drivers/usb/serial/omninet.c @@ -80,11 +80,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver omninet_driver = { + .owner = THIS_MODULE, .name = "omninet", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; diff --git a/trunk/drivers/usb/serial/option.c b/trunk/drivers/usb/serial/option.c index 3fd2405304fd..7716000045b7 100644 --- a/trunk/drivers/usb/serial/option.c +++ b/trunk/drivers/usb/serial/option.c @@ -95,11 +95,11 @@ static struct usb_device_id option_ids[] = { MODULE_DEVICE_TABLE(usb, option_ids); static struct usb_driver option_driver = { + .owner = THIS_MODULE, .name = "option", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = option_ids, - .no_dynamic_id = 1, }; /* The card has three separate interfaces, wich the serial driver diff --git a/trunk/drivers/usb/serial/pl2303.c b/trunk/drivers/usb/serial/pl2303.c index f03721056190..41a45a5025b2 100644 --- a/trunk/drivers/usb/serial/pl2303.c +++ b/trunk/drivers/usb/serial/pl2303.c @@ -82,11 +82,11 @@ static struct usb_device_id id_table [] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver pl2303_driver = { + .owner = THIS_MODULE, .name = "pl2303", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; #define SET_LINE_REQUEST_TYPE 0x21 @@ -810,7 +810,7 @@ static void pl2303_update_line_status(struct usb_serial_port *port, struct pl2303_private *priv = usb_get_serial_port_data(port); unsigned long flags; u8 status_idx = UART_STATE; - u8 length = UART_STATE + 1; + u8 length = UART_STATE; if ((le16_to_cpu(port->serial->dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) && (le16_to_cpu(port->serial->dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_X65 || diff --git a/trunk/drivers/usb/serial/safe_serial.c b/trunk/drivers/usb/serial/safe_serial.c index f0215f850d2d..c22bdc0c4dfd 100644 --- a/trunk/drivers/usb/serial/safe_serial.c +++ b/trunk/drivers/usb/serial/safe_serial.c @@ -160,14 +160,14 @@ static struct usb_device_id id_table[] = { MODULE_DEVICE_TABLE (usb, id_table); static struct usb_driver safe_driver = { + .owner = THIS_MODULE, .name = "safe_serial", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table, - .no_dynamic_id = 1, }; -static const __u16 crc10_table[256] = { +static __u16 crc10_table[256] = { 0x000, 0x233, 0x255, 0x066, 0x299, 0x0aa, 0x0cc, 0x2ff, 0x301, 0x132, 0x154, 0x367, 0x198, 0x3ab, 0x3cd, 0x1fe, 0x031, 0x202, 0x264, 0x057, 0x2a8, 0x09b, 0x0fd, 0x2ce, 0x330, 0x103, 0x165, 0x356, 0x1a9, 0x39a, 0x3fc, 0x1cf, 0x062, 0x251, 0x237, 0x004, 0x2fb, 0x0c8, 0x0ae, 0x29d, 0x363, 0x150, 0x136, 0x305, 0x1fa, 0x3c9, 0x3af, 0x19c, @@ -425,7 +425,7 @@ static int __init safe_init (void) if (vendor || product) { info ("vendor: %x product: %x\n", vendor, product); - for (i = 0; i < ARRAY_SIZE(id_table); i++) { + for (i = 0; i < (sizeof (id_table) / sizeof (struct usb_device_id)); i++) { if (!id_table[i].idVendor && !id_table[i].idProduct) { id_table[i].idVendor = vendor; id_table[i].idProduct = product; diff --git a/trunk/drivers/usb/serial/ti_usb_3410_5052.c b/trunk/drivers/usb/serial/ti_usb_3410_5052.c index abb830cb77bd..205dbf7201da 100644 --- a/trunk/drivers/usb/serial/ti_usb_3410_5052.c +++ b/trunk/drivers/usb/serial/ti_usb_3410_5052.c @@ -248,11 +248,11 @@ static struct usb_device_id ti_id_table_combined[] = { }; static struct usb_driver ti_usb_driver = { + .owner = THIS_MODULE, .name = "ti_usb_3410_5052", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = ti_id_table_combined, - .no_dynamic_id = 1, }; static struct usb_serial_driver ti_1port_device = { @@ -351,14 +351,17 @@ static int __init ti_init(void) int i,j; int ret; + /* insert extra vendor and product ids */ - j = ARRAY_SIZE(ti_id_table_3410) - TI_EXTRA_VID_PID_COUNT - 1; + j = sizeof(ti_id_table_3410)/sizeof(struct usb_device_id) + - TI_EXTRA_VID_PID_COUNT - 1; for (i=0; i #include #include -#include #include #include "usb-serial.h" #include "pl2303.h" @@ -43,10 +42,10 @@ /* Driver structure we register with the USB core */ static struct usb_driver usb_serial_driver = { + .owner = THIS_MODULE, .name = "usbserial", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, - .no_dynamic_id = 1, }; /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead @@ -189,11 +188,6 @@ static int serial_open (struct tty_struct *tty, struct file * filp) portNumber = tty->index - serial->minor; port = serial->port[portNumber]; - if (!port) - return -ENODEV; - - if (down_interruptible(&port->sem)) - return -ERESTARTSYS; ++port->open_count; @@ -219,7 +213,6 @@ static int serial_open (struct tty_struct *tty, struct file * filp) goto bailout_module_put; } - up(&port->sem); return 0; bailout_module_put: @@ -227,7 +220,6 @@ static int serial_open (struct tty_struct *tty, struct file * filp) bailout_kref_put: kref_put(&serial->kref, destroy_serial); port->open_count = 0; - up(&port->sem); return retval; } @@ -240,10 +232,8 @@ static void serial_close(struct tty_struct *tty, struct file * filp) dbg("%s - port %d", __FUNCTION__, port->number); - down(&port->sem); - if (port->open_count == 0) - goto out; + return; --port->open_count; if (port->open_count == 0) { @@ -261,9 +251,6 @@ static void serial_close(struct tty_struct *tty, struct file * filp) } kref_put(&port->serial->kref, destroy_serial); - -out: - up(&port->sem); } static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count) @@ -271,9 +258,6 @@ static int serial_write (struct tty_struct * tty, const unsigned char *buf, int struct usb_serial_port *port = tty->driver_data; int retval = -EINVAL; - if (!port) - goto exit; - dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count); if (!port->open_count) { @@ -293,9 +277,6 @@ static int serial_write_room (struct tty_struct *tty) struct usb_serial_port *port = tty->driver_data; int retval = -EINVAL; - if (!port) - goto exit; - dbg("%s - port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -315,9 +296,6 @@ static int serial_chars_in_buffer (struct tty_struct *tty) struct usb_serial_port *port = tty->driver_data; int retval = -EINVAL; - if (!port) - goto exit; - dbg("%s = port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -336,9 +314,6 @@ static void serial_throttle (struct tty_struct * tty) { struct usb_serial_port *port = tty->driver_data; - if (!port) - return; - dbg("%s - port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -355,9 +330,6 @@ static void serial_unthrottle (struct tty_struct * tty) { struct usb_serial_port *port = tty->driver_data; - if (!port) - return; - dbg("%s - port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -375,9 +347,6 @@ static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned in struct usb_serial_port *port = tty->driver_data; int retval = -ENODEV; - if (!port) - goto exit; - dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd); if (!port->open_count) { @@ -399,9 +368,6 @@ static void serial_set_termios (struct tty_struct *tty, struct termios * old) { struct usb_serial_port *port = tty->driver_data; - if (!port) - return; - dbg("%s - port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -418,9 +384,6 @@ static void serial_break (struct tty_struct *tty, int break_state) { struct usb_serial_port *port = tty->driver_data; - if (!port) - return; - dbg("%s - port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -482,9 +445,6 @@ static int serial_tiocmget (struct tty_struct *tty, struct file *file) { struct usb_serial_port *port = tty->driver_data; - if (!port) - goto exit; - dbg("%s - port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -504,9 +464,6 @@ static int serial_tiocmset (struct tty_struct *tty, struct file *file, { struct usb_serial_port *port = tty->driver_data; - if (!port) - goto exit; - dbg("%s - port %d", __FUNCTION__, port->number); if (!port->open_count) { @@ -785,7 +742,6 @@ int usb_serial_probe(struct usb_interface *interface, port->number = i + serial->minor; port->serial = serial; spin_lock_init(&port->lock); - sema_init(&port->sem, 1); INIT_WORK(&port->work, usb_serial_port_softint, port); serial->port[i] = port; } diff --git a/trunk/drivers/usb/serial/usb-serial.h b/trunk/drivers/usb/serial/usb-serial.h index d7d27c3385b3..238a5a871ed6 100644 --- a/trunk/drivers/usb/serial/usb-serial.h +++ b/trunk/drivers/usb/serial/usb-serial.h @@ -16,7 +16,6 @@ #include #include -#include #define SERIAL_TTY_MAJOR 188 /* Nice legal number now */ #define SERIAL_TTY_MINORS 255 /* loads of devices :) */ @@ -31,8 +30,6 @@ * @serial: pointer back to the struct usb_serial owner of this port. * @tty: pointer to the corresponding tty for this port. * @lock: spinlock to grab when updating portions of this structure. - * @sem: semaphore used to synchronize serial_open() and serial_close() - * access for this port. * @number: the number of the port (the minor number). * @interrupt_in_buffer: pointer to the interrupt in buffer for this port. * @interrupt_in_urb: pointer to the interrupt in struct urb for this port. @@ -63,7 +60,6 @@ struct usb_serial_port { struct usb_serial * serial; struct tty_struct * tty; spinlock_t lock; - struct semaphore sem; unsigned char number; unsigned char * interrupt_in_buffer; diff --git a/trunk/drivers/usb/serial/visor.c b/trunk/drivers/usb/serial/visor.c index 49b1fbe61f25..a473c1c34559 100644 --- a/trunk/drivers/usb/serial/visor.c +++ b/trunk/drivers/usb/serial/visor.c @@ -173,11 +173,11 @@ static struct usb_device_id id_table_combined [] = { MODULE_DEVICE_TABLE (usb, id_table_combined); static struct usb_driver visor_driver = { + .owner = THIS_MODULE, .name = "visor", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; /* All of the device info needed for the Handspring Visor, and Palm 4.0 devices */ diff --git a/trunk/drivers/usb/serial/whiteheat.c b/trunk/drivers/usb/serial/whiteheat.c index a7c3c4734d83..18c3183be769 100644 --- a/trunk/drivers/usb/serial/whiteheat.c +++ b/trunk/drivers/usb/serial/whiteheat.c @@ -127,11 +127,11 @@ static struct usb_device_id id_table_combined [] = { MODULE_DEVICE_TABLE (usb, id_table_combined); static struct usb_driver whiteheat_driver = { + .owner = THIS_MODULE, .name = "whiteheat", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .id_table = id_table_combined, - .no_dynamic_id = 1, }; /* function prototypes for the Connect Tech WhiteHEAT prerenumeration device */ diff --git a/trunk/drivers/usb/storage/Kconfig b/trunk/drivers/usb/storage/Kconfig index 92be101feba7..c41d64dbb0f0 100644 --- a/trunk/drivers/usb/storage/Kconfig +++ b/trunk/drivers/usb/storage/Kconfig @@ -112,15 +112,6 @@ config USB_STORAGE_JUMPSHOT Say Y here to include additional code to support the Lexar Jumpshot USB CompactFlash reader. -config USB_STORAGE_ALAUDA - bool "Olympus MAUSB-10/Fuji DPC-R1 support (EXPERIMENTAL)" - depends on USB_STORAGE && EXPERIMENTAL - help - Say Y here to include additional code to support the Olympus MAUSB-10 - and Fujifilm DPC-R1 USB Card reader/writer devices. - - These devices are based on the Alauda chip and support support both - XD and SmartMedia cards. config USB_STORAGE_ONETOUCH bool "Support OneTouch Button on Maxtor Hard Drives (EXPERIMENTAL)" @@ -133,17 +124,3 @@ config USB_STORAGE_ONETOUCH hard drive's as an input device. An action can be associated with this input in any keybinding software. (e.g. gnome's keyboard short- cuts) - -config USB_LIBUSUAL - bool "The shared table of common (or usual) storage devices" - depends on USB - help - This module contains a table of common (or usual) devices - for usb-storage and ub drivers, and allows to switch binding - of these devices without rebuilding modules. - - Typical syntax of /etc/modprobe.conf is: - - options libusual bias="ub" - - If unsure, say N. diff --git a/trunk/drivers/usb/storage/Makefile b/trunk/drivers/usb/storage/Makefile index 8cbba22508a4..44ab8f9978fe 100644 --- a/trunk/drivers/usb/storage/Makefile +++ b/trunk/drivers/usb/storage/Makefile @@ -18,12 +18,7 @@ usb-storage-obj-$(CONFIG_USB_STORAGE_DPCM) += dpcm.o usb-storage-obj-$(CONFIG_USB_STORAGE_ISD200) += isd200.o usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB) += datafab.o usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT) += jumpshot.o -usb-storage-obj-$(CONFIG_USB_STORAGE_ALAUDA) += alauda.o usb-storage-obj-$(CONFIG_USB_STORAGE_ONETOUCH) += onetouch.o usb-storage-objs := scsiglue.o protocol.o transport.o usb.o \ initializers.o $(usb-storage-obj-y) - -ifneq ($(CONFIG_USB_LIBUSUAL),) - obj-$(CONFIG_USB) += libusual.o -endif diff --git a/trunk/drivers/usb/storage/alauda.c b/trunk/drivers/usb/storage/alauda.c deleted file mode 100644 index 4d3cbb12b713..000000000000 --- a/trunk/drivers/usb/storage/alauda.c +++ /dev/null @@ -1,1119 +0,0 @@ -/* - * Driver for Alauda-based card readers - * - * Current development and maintenance by: - * (c) 2005 Daniel Drake - * - * The 'Alauda' is a chip manufacturered by RATOC for OEM use. - * - * Alauda implements a vendor-specific command set to access two media reader - * ports (XD, SmartMedia). This driver converts SCSI commands to the commands - * which are accepted by these devices. - * - * The driver was developed through reverse-engineering, with the help of the - * sddr09 driver which has many similarities, and with some help from the - * (very old) vendor-supplied GPL sma03 driver. - * - * For protocol info, see http://alauda.sourceforge.net - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2, or (at your option) any - * later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include -#include -#include - -#include "usb.h" -#include "transport.h" -#include "protocol.h" -#include "debug.h" -#include "alauda.h" - -#define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) ) -#define LSB_of(s) ((s)&0xFF) -#define MSB_of(s) ((s)>>8) - -#define MEDIA_PORT(us) us->srb->device->lun -#define MEDIA_INFO(us) ((struct alauda_info *)us->extra)->port[MEDIA_PORT(us)] - -#define PBA_LO(pba) ((pba & 0xF) << 5) -#define PBA_HI(pba) (pba >> 3) -#define PBA_ZONE(pba) (pba >> 11) - -/* - * Media handling - */ - -struct alauda_card_info { - unsigned char id; /* id byte */ - unsigned char chipshift; /* 1< LBA mappings for a particular port - */ -static void alauda_free_maps (struct alauda_media_info *media_info) -{ - unsigned int shift = media_info->zoneshift - + media_info->blockshift + media_info->pageshift; - unsigned int num_zones = media_info->capacity >> shift; - unsigned int i; - - if (media_info->lba_to_pba != NULL) - for (i = 0; i < num_zones; i++) { - kfree(media_info->lba_to_pba[i]); - media_info->lba_to_pba[i] = NULL; - } - - if (media_info->pba_to_lba != NULL) - for (i = 0; i < num_zones; i++) { - kfree(media_info->pba_to_lba[i]); - media_info->pba_to_lba[i] = NULL; - } -} - -/* - * Returns 2 bytes of status data - * The first byte describes media status, and second byte describes door status - */ -static int alauda_get_media_status(struct us_data *us, unsigned char *data) -{ - int rc; - unsigned char command; - - if (MEDIA_PORT(us) == ALAUDA_PORT_XD) - command = ALAUDA_GET_XD_MEDIA_STATUS; - else - command = ALAUDA_GET_SM_MEDIA_STATUS; - - rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe, - command, 0xc0, 0, 1, data, 2); - - US_DEBUGP("alauda_get_media_status: Media status %02X %02X\n", - data[0], data[1]); - - return rc; -} - -/* - * Clears the "media was changed" bit so that we know when it changes again - * in the future. - */ -static int alauda_ack_media(struct us_data *us) -{ - unsigned char command; - - if (MEDIA_PORT(us) == ALAUDA_PORT_XD) - command = ALAUDA_ACK_XD_MEDIA_CHANGE; - else - command = ALAUDA_ACK_SM_MEDIA_CHANGE; - - return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe, - command, 0x40, 0, 1, NULL, 0); -} - -/* - * Retrieves a 4-byte media signature, which indicates manufacturer, capacity, - * and some other details. - */ -static int alauda_get_media_signature(struct us_data *us, unsigned char *data) -{ - unsigned char command; - - if (MEDIA_PORT(us) == ALAUDA_PORT_XD) - command = ALAUDA_GET_XD_MEDIA_SIG; - else - command = ALAUDA_GET_SM_MEDIA_SIG; - - return usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe, - command, 0xc0, 0, 0, data, 4); -} - -/* - * Resets the media status (but not the whole device?) - */ -static int alauda_reset_media(struct us_data *us) -{ - unsigned char *command = us->iobuf; - - memset(command, 0, 9); - command[0] = ALAUDA_BULK_CMD; - command[1] = ALAUDA_BULK_RESET_MEDIA; - command[8] = MEDIA_PORT(us); - - return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, - command, 9, NULL); -} - -/* - * Examines the media and deduces capacity, etc. - */ -static int alauda_init_media(struct us_data *us) -{ - unsigned char *data = us->iobuf; - int ready = 0; - struct alauda_card_info *media_info; - unsigned int num_zones; - - while (ready == 0) { - msleep(20); - - if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD) - return USB_STOR_TRANSPORT_ERROR; - - if (data[0] & 0x10) - ready = 1; - } - - US_DEBUGP("alauda_init_media: We are ready for action!\n"); - - if (alauda_ack_media(us) != USB_STOR_XFER_GOOD) - return USB_STOR_TRANSPORT_ERROR; - - msleep(10); - - if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD) - return USB_STOR_TRANSPORT_ERROR; - - if (data[0] != 0x14) { - US_DEBUGP("alauda_init_media: Media not ready after ack\n"); - return USB_STOR_TRANSPORT_ERROR; - } - - if (alauda_get_media_signature(us, data) != USB_STOR_XFER_GOOD) - return USB_STOR_TRANSPORT_ERROR; - - US_DEBUGP("alauda_init_media: Media signature: %02X %02X %02X %02X\n", - data[0], data[1], data[2], data[3]); - media_info = alauda_card_find_id(data[1]); - if (media_info == NULL) { - printk("alauda_init_media: Unrecognised media signature: " - "%02X %02X %02X %02X\n", - data[0], data[1], data[2], data[3]); - return USB_STOR_TRANSPORT_ERROR; - } - - MEDIA_INFO(us).capacity = 1 << media_info->chipshift; - US_DEBUGP("Found media with capacity: %ldMB\n", - MEDIA_INFO(us).capacity >> 20); - - MEDIA_INFO(us).pageshift = media_info->pageshift; - MEDIA_INFO(us).blockshift = media_info->blockshift; - MEDIA_INFO(us).zoneshift = media_info->zoneshift; - - MEDIA_INFO(us).pagesize = 1 << media_info->pageshift; - MEDIA_INFO(us).blocksize = 1 << media_info->blockshift; - MEDIA_INFO(us).zonesize = 1 << media_info->zoneshift; - - MEDIA_INFO(us).uzonesize = ((1 << media_info->zoneshift) / 128) * 125; - MEDIA_INFO(us).blockmask = MEDIA_INFO(us).blocksize - 1; - - num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift - + MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift); - MEDIA_INFO(us).pba_to_lba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO); - MEDIA_INFO(us).lba_to_pba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO); - - if (alauda_reset_media(us) != USB_STOR_XFER_GOOD) - return USB_STOR_TRANSPORT_ERROR; - - return USB_STOR_TRANSPORT_GOOD; -} - -/* - * Examines the media status and does the right thing when the media has gone, - * appeared, or changed. - */ -static int alauda_check_media(struct us_data *us) -{ - struct alauda_info *info = (struct alauda_info *) us->extra; - unsigned char status[2]; - int rc; - - rc = alauda_get_media_status(us, status); - - /* Check for no media or door open */ - if ((status[0] & 0x80) || ((status[0] & 0x1F) == 0x10) - || ((status[1] & 0x01) == 0)) { - US_DEBUGP("alauda_check_media: No media, or door open\n"); - alauda_free_maps(&MEDIA_INFO(us)); - info->sense_key = 0x02; - info->sense_asc = 0x3A; - info->sense_ascq = 0x00; - return USB_STOR_TRANSPORT_FAILED; - } - - /* Check for media change */ - if (status[0] & 0x08) { - US_DEBUGP("alauda_check_media: Media change detected\n"); - alauda_free_maps(&MEDIA_INFO(us)); - alauda_init_media(us); - - info->sense_key = UNIT_ATTENTION; - info->sense_asc = 0x28; - info->sense_ascq = 0x00; - return USB_STOR_TRANSPORT_FAILED; - } - - return USB_STOR_TRANSPORT_GOOD; -} - -/* - * Checks the status from the 2nd status register - * Returns 3 bytes of status data, only the first is known - */ -static int alauda_check_status2(struct us_data *us) -{ - int rc; - unsigned char command[] = { - ALAUDA_BULK_CMD, ALAUDA_BULK_GET_STATUS2, - 0, 0, 0, 0, 3, 0, MEDIA_PORT(us) - }; - unsigned char data[3]; - - rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, - command, 9, NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, - data, 3, NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - US_DEBUGP("alauda_check_status2: %02X %02X %02X\n", data[0], data[1], data[2]); - if (data[0] & ALAUDA_STATUS_ERROR) - return USB_STOR_XFER_ERROR; - - return USB_STOR_XFER_GOOD; -} - -/* - * Gets the redundancy data for the first page of a PBA - * Returns 16 bytes. - */ -static int alauda_get_redu_data(struct us_data *us, u16 pba, unsigned char *data) -{ - int rc; - unsigned char command[] = { - ALAUDA_BULK_CMD, ALAUDA_BULK_GET_REDU_DATA, - PBA_HI(pba), PBA_ZONE(pba), 0, PBA_LO(pba), 0, 0, MEDIA_PORT(us) - }; - - rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, - command, 9, NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, - data, 16, NULL); -} - -/* - * Finds the first unused PBA in a zone - * Returns the absolute PBA of an unused PBA, or 0 if none found. - */ -static u16 alauda_find_unused_pba(struct alauda_media_info *info, - unsigned int zone) -{ - u16 *pba_to_lba = info->pba_to_lba[zone]; - unsigned int i; - - for (i = 0; i < info->zonesize; i++) - if (pba_to_lba[i] == UNDEF) - return (zone << info->zoneshift) + i; - - return 0; -} - -/* - * Reads the redundancy data for all PBA's in a zone - * Produces lba <--> pba mappings - */ -static int alauda_read_map(struct us_data *us, unsigned int zone) -{ - unsigned char *data = us->iobuf; - int result; - int i, j; - unsigned int zonesize = MEDIA_INFO(us).zonesize; - unsigned int uzonesize = MEDIA_INFO(us).uzonesize; - unsigned int lba_offset, lba_real, blocknum; - unsigned int zone_base_lba = zone * uzonesize; - unsigned int zone_base_pba = zone * zonesize; - u16 *lba_to_pba = kcalloc(zonesize, sizeof(u16), GFP_NOIO); - u16 *pba_to_lba = kcalloc(zonesize, sizeof(u16), GFP_NOIO); - if (lba_to_pba == NULL || pba_to_lba == NULL) { - result = USB_STOR_TRANSPORT_ERROR; - goto error; - } - - US_DEBUGP("alauda_read_map: Mapping blocks for zone %d\n", zone); - - /* 1024 PBA's per zone */ - for (i = 0; i < zonesize; i++) - lba_to_pba[i] = pba_to_lba[i] = UNDEF; - - for (i = 0; i < zonesize; i++) { - blocknum = zone_base_pba + i; - - result = alauda_get_redu_data(us, blocknum, data); - if (result != USB_STOR_XFER_GOOD) { - result = USB_STOR_TRANSPORT_ERROR; - goto error; - } - - /* special PBAs have control field 0^16 */ - for (j = 0; j < 16; j++) - if (data[j] != 0) - goto nonz; - pba_to_lba[i] = UNUSABLE; - US_DEBUGP("alauda_read_map: PBA %d has no logical mapping\n", blocknum); - continue; - - nonz: - /* unwritten PBAs have control field FF^16 */ - for (j = 0; j < 16; j++) - if (data[j] != 0xff) - goto nonff; - continue; - - nonff: - /* normal PBAs start with six FFs */ - if (j < 6) { - US_DEBUGP("alauda_read_map: PBA %d has no logical mapping: " - "reserved area = %02X%02X%02X%02X " - "data status %02X block status %02X\n", - blocknum, data[0], data[1], data[2], data[3], - data[4], data[5]); - pba_to_lba[i] = UNUSABLE; - continue; - } - - if ((data[6] >> 4) != 0x01) { - US_DEBUGP("alauda_read_map: PBA %d has invalid address " - "field %02X%02X/%02X%02X\n", - blocknum, data[6], data[7], data[11], data[12]); - pba_to_lba[i] = UNUSABLE; - continue; - } - - /* check even parity */ - if (parity[data[6] ^ data[7]]) { - printk("alauda_read_map: Bad parity in LBA for block %d" - " (%02X %02X)\n", i, data[6], data[7]); - pba_to_lba[i] = UNUSABLE; - continue; - } - - lba_offset = short_pack(data[7], data[6]); - lba_offset = (lba_offset & 0x07FF) >> 1; - lba_real = lba_offset + zone_base_lba; - - /* - * Every 1024 physical blocks ("zone"), the LBA numbers - * go back to zero, but are within a higher block of LBA's. - * Also, there is a maximum of 1000 LBA's per zone. - * In other words, in PBA 1024-2047 you will find LBA 0-999 - * which are really LBA 1000-1999. This allows for 24 bad - * or special physical blocks per zone. - */ - - if (lba_offset >= uzonesize) { - printk("alauda_read_map: Bad low LBA %d for block %d\n", - lba_real, blocknum); - continue; - } - - if (lba_to_pba[lba_offset] != UNDEF) { - printk("alauda_read_map: LBA %d seen for PBA %d and %d\n", - lba_real, lba_to_pba[lba_offset], blocknum); - continue; - } - - pba_to_lba[i] = lba_real; - lba_to_pba[lba_offset] = blocknum; - continue; - } - - MEDIA_INFO(us).lba_to_pba[zone] = lba_to_pba; - MEDIA_INFO(us).pba_to_lba[zone] = pba_to_lba; - result = 0; - goto out; - -error: - kfree(lba_to_pba); - kfree(pba_to_lba); -out: - return result; -} - -/* - * Checks to see whether we have already mapped a certain zone - * If we haven't, the map is generated - */ -static void alauda_ensure_map_for_zone(struct us_data *us, unsigned int zone) -{ - if (MEDIA_INFO(us).lba_to_pba[zone] == NULL - || MEDIA_INFO(us).pba_to_lba[zone] == NULL) - alauda_read_map(us, zone); -} - -/* - * Erases an entire block - */ -static int alauda_erase_block(struct us_data *us, u16 pba) -{ - int rc; - unsigned char command[] = { - ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba), - PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, MEDIA_PORT(us) - }; - unsigned char buf[2]; - - US_DEBUGP("alauda_erase_block: Erasing PBA %d\n", pba); - - rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, - command, 9, NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, - buf, 2, NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - US_DEBUGP("alauda_erase_block: Erase result: %02X %02X\n", - buf[0], buf[1]); - return rc; -} - -/* - * Reads data from a certain offset page inside a PBA, including interleaved - * redundancy data. Returns (pagesize+64)*pages bytes in data. - */ -static int alauda_read_block_raw(struct us_data *us, u16 pba, - unsigned int page, unsigned int pages, unsigned char *data) -{ - int rc; - unsigned char command[] = { - ALAUDA_BULK_CMD, ALAUDA_BULK_READ_BLOCK, PBA_HI(pba), - PBA_ZONE(pba), 0, PBA_LO(pba) + page, pages, 0, MEDIA_PORT(us) - }; - - US_DEBUGP("alauda_read_block: pba %d page %d count %d\n", - pba, page, pages); - - rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, - command, 9, NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, - data, (MEDIA_INFO(us).pagesize + 64) * pages, NULL); -} - -/* - * Reads data from a certain offset page inside a PBA, excluding redundancy - * data. Returns pagesize*pages bytes in data. Note that data must be big enough - * to hold (pagesize+64)*pages bytes of data, but you can ignore those 'extra' - * trailing bytes outside this function. - */ -static int alauda_read_block(struct us_data *us, u16 pba, - unsigned int page, unsigned int pages, unsigned char *data) -{ - int i, rc; - unsigned int pagesize = MEDIA_INFO(us).pagesize; - - rc = alauda_read_block_raw(us, pba, page, pages, data); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - /* Cut out the redundancy data */ - for (i = 0; i < pages; i++) { - int dest_offset = i * pagesize; - int src_offset = i * (pagesize + 64); - memmove(data + dest_offset, data + src_offset, pagesize); - } - - return rc; -} - -/* - * Writes an entire block of data and checks status after write. - * Redundancy data must be already included in data. Data should be - * (pagesize+64)*blocksize bytes in length. - */ -static int alauda_write_block(struct us_data *us, u16 pba, unsigned char *data) -{ - int rc; - struct alauda_info *info = (struct alauda_info *) us->extra; - unsigned char command[] = { - ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_BLOCK, PBA_HI(pba), - PBA_ZONE(pba), 0, PBA_LO(pba), 32, 0, MEDIA_PORT(us) - }; - - US_DEBUGP("alauda_write_block: pba %d\n", pba); - - rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, - command, 9, NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - rc = usb_stor_bulk_transfer_buf(us, info->wr_ep, data, - (MEDIA_INFO(us).pagesize + 64) * MEDIA_INFO(us).blocksize, - NULL); - if (rc != USB_STOR_XFER_GOOD) - return rc; - - return alauda_check_status2(us); -} - -/* - * Write some data to a specific LBA. - */ -static int alauda_write_lba(struct us_data *us, u16 lba, - unsigned int page, unsigned int pages, - unsigned char *ptr, unsigned char *blockbuffer) -{ - u16 pba, lbap, new_pba; - unsigned char *bptr, *cptr, *xptr; - unsigned char ecc[3]; - int i, result; - unsigned int uzonesize = MEDIA_INFO(us).uzonesize; - unsigned int zonesize = MEDIA_INFO(us).zonesize; - unsigned int pagesize = MEDIA_INFO(us).pagesize; - unsigned int blocksize = MEDIA_INFO(us).blocksize; - unsigned int lba_offset = lba % uzonesize; - unsigned int new_pba_offset; - unsigned int zone = lba / uzonesize; - - alauda_ensure_map_for_zone(us, zone); - - pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset]; - if (pba == 1) { - /* Maybe it is impossible to write to PBA 1. - Fake success, but don't do anything. */ - printk("alauda_write_lba: avoid writing to pba 1\n"); - return USB_STOR_TRANSPORT_GOOD; - } - - new_pba = alauda_find_unused_pba(&MEDIA_INFO(us), zone); - if (!new_pba) { - printk("alauda_write_lba: Out of unused blocks\n"); - return USB_STOR_TRANSPORT_ERROR; - } - - /* read old contents */ - if (pba != UNDEF) { - result = alauda_read_block_raw(us, pba, 0, - blocksize, blockbuffer); - if (result != USB_STOR_XFER_GOOD) - return result; - } else { - memset(blockbuffer, 0, blocksize * (pagesize + 64)); - } - - lbap = (lba_offset << 1) | 0x1000; - if (parity[MSB_of(lbap) ^ LSB_of(lbap)]) - lbap ^= 1; - - /* check old contents and fill lba */ - for (i = 0; i < blocksize; i++) { - bptr = blockbuffer + (i * (pagesize + 64)); - cptr = bptr + pagesize; - nand_compute_ecc(bptr, ecc); - if (!nand_compare_ecc(cptr+13, ecc)) { - US_DEBUGP("Warning: bad ecc in page %d- of pba %d\n", - i, pba); - nand_store_ecc(cptr+13, ecc); - } - nand_compute_ecc(bptr + (pagesize / 2), ecc); - if (!nand_compare_ecc(cptr+8, ecc)) { - US_DEBUGP("Warning: bad ecc in page %d+ of pba %d\n", - i, pba); - nand_store_ecc(cptr+8, ecc); - } - cptr[6] = cptr[11] = MSB_of(lbap); - cptr[7] = cptr[12] = LSB_of(lbap); - } - - /* copy in new stuff and compute ECC */ - xptr = ptr; - for (i = page; i < page+pages; i++) { - bptr = blockbuffer + (i * (pagesize + 64)); - cptr = bptr + pagesize; - memcpy(bptr, xptr, pagesize); - xptr += pagesize; - nand_compute_ecc(bptr, ecc); - nand_store_ecc(cptr+13, ecc); - nand_compute_ecc(bptr + (pagesize / 2), ecc); - nand_store_ecc(cptr+8, ecc); - } - - result = alauda_write_block(us, new_pba, blockbuffer); - if (result != USB_STOR_XFER_GOOD) - return result; - - new_pba_offset = new_pba - (zone * zonesize); - MEDIA_INFO(us).pba_to_lba[zone][new_pba_offset] = lba; - MEDIA_INFO(us).lba_to_pba[zone][lba_offset] = new_pba; - US_DEBUGP("alauda_write_lba: Remapped LBA %d to PBA %d\n", - lba, new_pba); - - if (pba != UNDEF) { - unsigned int pba_offset = pba - (zone * zonesize); - result = alauda_erase_block(us, pba); - if (result != USB_STOR_XFER_GOOD) - return result; - MEDIA_INFO(us).pba_to_lba[zone][pba_offset] = UNDEF; - } - - return USB_STOR_TRANSPORT_GOOD; -} - -/* - * Read data from a specific sector address - */ -static int alauda_read_data(struct us_data *us, unsigned long address, - unsigned int sectors) -{ - unsigned char *buffer; - u16 lba, max_lba; - unsigned int page, len, index, offset; - unsigned int blockshift = MEDIA_INFO(us).blockshift; - unsigned int pageshift = MEDIA_INFO(us).pageshift; - unsigned int blocksize = MEDIA_INFO(us).blocksize; - unsigned int pagesize = MEDIA_INFO(us).pagesize; - unsigned int uzonesize = MEDIA_INFO(us).uzonesize; - int result; - - /* - * Since we only read in one block at a time, we have to create - * a bounce buffer and move the data a piece at a time between the - * bounce buffer and the actual transfer buffer. - * We make this buffer big enough to hold temporary redundancy data, - * which we use when reading the data blocks. - */ - - len = min(sectors, blocksize) * (pagesize + 64); - buffer = kmalloc(len, GFP_NOIO); - if (buffer == NULL) { - printk("alauda_read_data: Out of memory\n"); - return USB_STOR_TRANSPORT_ERROR; - } - - /* Figure out the initial LBA and page */ - lba = address >> blockshift; - page = (address & MEDIA_INFO(us).blockmask); - max_lba = MEDIA_INFO(us).capacity >> (blockshift + pageshift); - - result = USB_STOR_TRANSPORT_GOOD; - index = offset = 0; - - while (sectors > 0) { - unsigned int zone = lba / uzonesize; /* integer division */ - unsigned int lba_offset = lba - (zone * uzonesize); - unsigned int pages; - u16 pba; - alauda_ensure_map_for_zone(us, zone); - - /* Not overflowing capacity? */ - if (lba >= max_lba) { - US_DEBUGP("Error: Requested lba %u exceeds " - "maximum %u\n", lba, max_lba); - result = USB_STOR_TRANSPORT_ERROR; - break; - } - - /* Find number of pages we can read in this block */ - pages = min(sectors, blocksize - page); - len = pages << pageshift; - - /* Find where this lba lives on disk */ - pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset]; - - if (pba == UNDEF) { /* this lba was never written */ - US_DEBUGP("Read %d zero pages (LBA %d) page %d\n", - pages, lba, page); - - /* This is not really an error. It just means - that the block has never been written. - Instead of returning USB_STOR_TRANSPORT_ERROR - it is better to return all zero data. */ - - memset(buffer, 0, len); - } else { - US_DEBUGP("Read %d pages, from PBA %d" - " (LBA %d) page %d\n", - pages, pba, lba, page); - - result = alauda_read_block(us, pba, page, pages, buffer); - if (result != USB_STOR_TRANSPORT_GOOD) - break; - } - - /* Store the data in the transfer buffer */ - usb_stor_access_xfer_buf(buffer, len, us->srb, - &index, &offset, TO_XFER_BUF); - - page = 0; - lba++; - sectors -= pages; - } - - kfree(buffer); - return result; -} - -/* - * Write data to a specific sector address - */ -static int alauda_write_data(struct us_data *us, unsigned long address, - unsigned int sectors) -{ - unsigned char *buffer, *blockbuffer; - unsigned int page, len, index, offset; - unsigned int blockshift = MEDIA_INFO(us).blockshift; - unsigned int pageshift = MEDIA_INFO(us).pageshift; - unsigned int blocksize = MEDIA_INFO(us).blocksize; - unsigned int pagesize = MEDIA_INFO(us).pagesize; - u16 lba, max_lba; - int result; - - /* - * Since we don't write the user data directly to the device, - * we have to create a bounce buffer and move the data a piece - * at a time between the bounce buffer and the actual transfer buffer. - */ - - len = min(sectors, blocksize) * pagesize; - buffer = kmalloc(len, GFP_NOIO); - if (buffer == NULL) { - printk("alauda_write_data: Out of memory\n"); - return USB_STOR_TRANSPORT_ERROR; - } - - /* - * We also need a temporary block buffer, where we read in the old data, - * overwrite parts with the new data, and manipulate the redundancy data - */ - blockbuffer = kmalloc((pagesize + 64) * blocksize, GFP_NOIO); - if (blockbuffer == NULL) { - printk("alauda_write_data: Out of memory\n"); - kfree(buffer); - return USB_STOR_TRANSPORT_ERROR; - } - - /* Figure out the initial LBA and page */ - lba = address >> blockshift; - page = (address & MEDIA_INFO(us).blockmask); - max_lba = MEDIA_INFO(us).capacity >> (pageshift + blockshift); - - result = USB_STOR_TRANSPORT_GOOD; - index = offset = 0; - - while (sectors > 0) { - /* Write as many sectors as possible in this block */ - unsigned int pages = min(sectors, blocksize - page); - len = pages << pageshift; - - /* Not overflowing capacity? */ - if (lba >= max_lba) { - US_DEBUGP("alauda_write_data: Requested lba %u exceeds " - "maximum %u\n", lba, max_lba); - result = USB_STOR_TRANSPORT_ERROR; - break; - } - - /* Get the data from the transfer buffer */ - usb_stor_access_xfer_buf(buffer, len, us->srb, - &index, &offset, FROM_XFER_BUF); - - result = alauda_write_lba(us, lba, page, pages, buffer, - blockbuffer); - if (result != USB_STOR_TRANSPORT_GOOD) - break; - - page = 0; - lba++; - sectors -= pages; - } - - kfree(buffer); - kfree(blockbuffer); - return result; -} - -/* - * Our interface with the rest of the world - */ - -static void alauda_info_destructor(void *extra) -{ - struct alauda_info *info = (struct alauda_info *) extra; - int port; - - if (!info) - return; - - for (port = 0; port < 2; port++) { - struct alauda_media_info *media_info = &info->port[port]; - - alauda_free_maps(media_info); - kfree(media_info->lba_to_pba); - kfree(media_info->pba_to_lba); - } -} - -/* - * Initialize alauda_info struct and find the data-write endpoint - */ -int init_alauda(struct us_data *us) -{ - struct alauda_info *info; - struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting; - nand_init_ecc(); - - us->extra = kzalloc(sizeof(struct alauda_info), GFP_NOIO); - if (!us->extra) { - US_DEBUGP("init_alauda: Gah! Can't allocate storage for" - "alauda info struct!\n"); - return USB_STOR_TRANSPORT_ERROR; - } - info = (struct alauda_info *) us->extra; - us->extra_destructor = alauda_info_destructor; - - info->wr_ep = usb_sndbulkpipe(us->pusb_dev, - altsetting->endpoint[0].desc.bEndpointAddress - & USB_ENDPOINT_NUMBER_MASK); - - return USB_STOR_TRANSPORT_GOOD; -} - -int alauda_transport(struct scsi_cmnd *srb, struct us_data *us) -{ - int rc; - struct alauda_info *info = (struct alauda_info *) us->extra; - unsigned char *ptr = us->iobuf; - static unsigned char inquiry_response[36] = { - 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 - }; - - if (srb->cmnd[0] == INQUIRY) { - US_DEBUGP("alauda_transport: INQUIRY. " - "Returning bogus response.\n"); - memcpy(ptr, inquiry_response, sizeof(inquiry_response)); - fill_inquiry_response(us, ptr, 36); - return USB_STOR_TRANSPORT_GOOD; - } - - if (srb->cmnd[0] == TEST_UNIT_READY) { - US_DEBUGP("alauda_transport: TEST_UNIT_READY.\n"); - return alauda_check_media(us); - } - - if (srb->cmnd[0] == READ_CAPACITY) { - unsigned int num_zones; - unsigned long capacity; - - rc = alauda_check_media(us); - if (rc != USB_STOR_TRANSPORT_GOOD) - return rc; - - num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift - + MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift); - - capacity = num_zones * MEDIA_INFO(us).uzonesize - * MEDIA_INFO(us).blocksize; - - /* Report capacity and page size */ - ((__be32 *) ptr)[0] = cpu_to_be32(capacity - 1); - ((__be32 *) ptr)[1] = cpu_to_be32(512); - - usb_stor_set_xfer_buf(ptr, 8, srb); - return USB_STOR_TRANSPORT_GOOD; - } - - if (srb->cmnd[0] == READ_10) { - unsigned int page, pages; - - rc = alauda_check_media(us); - if (rc != USB_STOR_TRANSPORT_GOOD) - return rc; - - page = short_pack(srb->cmnd[3], srb->cmnd[2]); - page <<= 16; - page |= short_pack(srb->cmnd[5], srb->cmnd[4]); - pages = short_pack(srb->cmnd[8], srb->cmnd[7]); - - US_DEBUGP("alauda_transport: READ_10: page %d pagect %d\n", - page, pages); - - return alauda_read_data(us, page, pages); - } - - if (srb->cmnd[0] == WRITE_10) { - unsigned int page, pages; - - rc = alauda_check_media(us); - if (rc != USB_STOR_TRANSPORT_GOOD) - return rc; - - page = short_pack(srb->cmnd[3], srb->cmnd[2]); - page <<= 16; - page |= short_pack(srb->cmnd[5], srb->cmnd[4]); - pages = short_pack(srb->cmnd[8], srb->cmnd[7]); - - US_DEBUGP("alauda_transport: WRITE_10: page %d pagect %d\n", - page, pages); - - return alauda_write_data(us, page, pages); - } - - if (srb->cmnd[0] == REQUEST_SENSE) { - US_DEBUGP("alauda_transport: REQUEST_SENSE.\n"); - - memset(ptr, 0, 18); - ptr[0] = 0xF0; - ptr[2] = info->sense_key; - ptr[7] = 11; - ptr[12] = info->sense_asc; - ptr[13] = info->sense_ascq; - usb_stor_set_xfer_buf(ptr, 18, srb); - - return USB_STOR_TRANSPORT_GOOD; - } - - if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { - /* sure. whatever. not like we can stop the user from popping - the media out of the device (no locking doors, etc) */ - return USB_STOR_TRANSPORT_GOOD; - } - - US_DEBUGP("alauda_transport: Gah! Unknown command: %d (0x%x)\n", - srb->cmnd[0], srb->cmnd[0]); - info->sense_key = 0x05; - info->sense_asc = 0x20; - info->sense_ascq = 0x00; - return USB_STOR_TRANSPORT_FAILED; -} - diff --git a/trunk/drivers/usb/storage/alauda.h b/trunk/drivers/usb/storage/alauda.h deleted file mode 100644 index a700f87d0803..000000000000 --- a/trunk/drivers/usb/storage/alauda.h +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Driver for Alauda-based card readers - * - * Current development and maintenance by: - * (c) 2005 Daniel Drake - * - * See alauda.c for more explanation. - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2, or (at your option) any - * later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#ifndef _USB_ALAUDA_H -#define _USB_ALAUDA_H - -/* - * Status bytes - */ -#define ALAUDA_STATUS_ERROR 0x01 -#define ALAUDA_STATUS_READY 0x40 - -/* - * Control opcodes (for request field) - */ -#define ALAUDA_GET_XD_MEDIA_STATUS 0x08 -#define ALAUDA_GET_SM_MEDIA_STATUS 0x98 -#define ALAUDA_ACK_XD_MEDIA_CHANGE 0x0a -#define ALAUDA_ACK_SM_MEDIA_CHANGE 0x9a -#define ALAUDA_GET_XD_MEDIA_SIG 0x86 -#define ALAUDA_GET_SM_MEDIA_SIG 0x96 - -/* - * Bulk command identity (byte 0) - */ -#define ALAUDA_BULK_CMD 0x40 - -/* - * Bulk opcodes (byte 1) - */ -#define ALAUDA_BULK_GET_REDU_DATA 0x85 -#define ALAUDA_BULK_READ_BLOCK 0x94 -#define ALAUDA_BULK_ERASE_BLOCK 0xa3 -#define ALAUDA_BULK_WRITE_BLOCK 0xb4 -#define ALAUDA_BULK_GET_STATUS2 0xb7 -#define ALAUDA_BULK_RESET_MEDIA 0xe0 - -/* - * Port to operate on (byte 8) - */ -#define ALAUDA_PORT_XD 0x00 -#define ALAUDA_PORT_SM 0x01 - -/* - * LBA and PBA are unsigned ints. Special values. - */ -#define UNDEF 0xffff -#define SPARE 0xfffe -#define UNUSABLE 0xfffd - -int init_alauda(struct us_data *us); -int alauda_transport(struct scsi_cmnd *srb, struct us_data *us); - -struct alauda_media_info { - unsigned long capacity; /* total media size in bytes */ - unsigned int pagesize; /* page size in bytes */ - unsigned int blocksize; /* number of pages per block */ - unsigned int uzonesize; /* number of usable blocks per zone */ - unsigned int zonesize; /* number of blocks per zone */ - unsigned int blockmask; /* mask to get page from address */ - - unsigned char pageshift; - unsigned char blockshift; - unsigned char zoneshift; - - u16 **lba_to_pba; /* logical to physical block map */ - u16 **pba_to_lba; /* physical to logical block map */ -}; - -struct alauda_info { - struct alauda_media_info port[2]; - int wr_ep; /* endpoint to write data out of */ - - unsigned char sense_key; - unsigned long sense_asc; /* additional sense code */ - unsigned long sense_ascq; /* additional sense code qualifier */ -}; - -#endif - diff --git a/trunk/drivers/usb/storage/debug.c b/trunk/drivers/usb/storage/debug.c index 01e430654a13..5a9321705a74 100644 --- a/trunk/drivers/usb/storage/debug.c +++ b/trunk/drivers/usb/storage/debug.c @@ -132,7 +132,6 @@ void usb_stor_show_command(struct scsi_cmnd *srb) case 0x5C: what = "READ BUFFER CAPACITY"; break; case 0x5D: what = "SEND CUE SHEET"; break; case GPCMD_BLANK: what = "BLANK"; break; - case REPORT_LUNS: what = "REPORT LUNS"; break; case MOVE_MEDIUM: what = "MOVE_MEDIUM or PLAY AUDIO (12)"; break; case READ_12: what = "READ_12"; break; case WRITE_12: what = "WRITE_12"; break; diff --git a/trunk/drivers/usb/storage/initializers.h b/trunk/drivers/usb/storage/initializers.h index 4c1b2bd2e2e4..7372386f33d5 100644 --- a/trunk/drivers/usb/storage/initializers.h +++ b/trunk/drivers/usb/storage/initializers.h @@ -45,6 +45,10 @@ * mode */ int usb_stor_euscsi_init(struct us_data *us); +#ifdef CONFIG_USB_STORAGE_SDDR09 +int sddr09_init(struct us_data *us); +#endif + /* This function is required to activate all four slots on the UCR-61S2B * flash reader */ int usb_stor_ucr61s2b_init(struct us_data *us); diff --git a/trunk/drivers/usb/storage/libusual.c b/trunk/drivers/usb/storage/libusual.c deleted file mode 100644 index b28151d1b609..000000000000 --- a/trunk/drivers/usb/storage/libusual.c +++ /dev/null @@ -1,266 +0,0 @@ -/* - * libusual - * - * The libusual contains the table of devices common for ub and usb-storage. - */ -#include -#include -#include -#include -#include - -/* - */ -#define USU_MOD_FL_THREAD 1 /* Thread is running */ -#define USU_MOD_FL_PRESENT 2 /* The module is loaded */ - -struct mod_status { - unsigned long fls; -}; - -static struct mod_status stat[3]; -static DEFINE_SPINLOCK(usu_lock); - -/* - */ -#define USB_US_DEFAULT_BIAS USB_US_TYPE_STOR -static atomic_t usu_bias = ATOMIC_INIT(USB_US_DEFAULT_BIAS); - -#define BIAS_NAME_SIZE (sizeof("usb-storage")) -static const char *bias_names[3] = { "none", "usb-storage", "ub" }; - -static DECLARE_MUTEX_LOCKED(usu_init_notify); -static DECLARE_COMPLETION(usu_end_notify); -static atomic_t total_threads = ATOMIC_INIT(0); - -static int usu_probe_thread(void *arg); - -/* - * The table. - */ -#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ - vendorName, productName,useProtocol, useTransport, \ - initFunction, flags) \ -{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \ - .driver_info = (flags)|(USB_US_TYPE_STOR<<24) } - -#define USUAL_DEV(useProto, useTrans, useType) \ -{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \ - .driver_info = ((useType)<<24) } - -struct usb_device_id storage_usb_ids [] = { -# include "unusual_devs.h" - { } /* Terminating entry */ -}; - -#undef USUAL_DEV -#undef UNUSUAL_DEV - -MODULE_DEVICE_TABLE(usb, storage_usb_ids); -EXPORT_SYMBOL_GPL(storage_usb_ids); - -/* - * @type: the module type as an integer - */ -void usb_usual_set_present(int type) -{ - struct mod_status *st; - unsigned long flags; - - if (type <= 0 || type >= 3) - return; - st = &stat[type]; - spin_lock_irqsave(&usu_lock, flags); - st->fls |= USU_MOD_FL_PRESENT; - spin_unlock_irqrestore(&usu_lock, flags); -} -EXPORT_SYMBOL_GPL(usb_usual_set_present); - -void usb_usual_clear_present(int type) -{ - struct mod_status *st; - unsigned long flags; - - if (type <= 0 || type >= 3) - return; - st = &stat[type]; - spin_lock_irqsave(&usu_lock, flags); - st->fls &= ~USU_MOD_FL_PRESENT; - spin_unlock_irqrestore(&usu_lock, flags); -} -EXPORT_SYMBOL_GPL(usb_usual_clear_present); - -/* - * Match the calling driver type against the table. - * Returns: 0 if the device matches. - */ -int usb_usual_check_type(const struct usb_device_id *id, int caller_type) -{ - int id_type = USB_US_TYPE(id->driver_info); - - if (caller_type <= 0 || caller_type >= 3) - return -EINVAL; - - /* Drivers grab fixed assignment devices */ - if (id_type == caller_type) - return 0; - /* Drivers grab devices biased to them */ - if (id_type == USB_US_TYPE_NONE && caller_type == atomic_read(&usu_bias)) - return 0; - return -ENODEV; -} -EXPORT_SYMBOL_GPL(usb_usual_check_type); - -/* - */ -static int usu_probe(struct usb_interface *intf, - const struct usb_device_id *id) -{ - int type; - int rc; - unsigned long flags; - - type = USB_US_TYPE(id->driver_info); - if (type == 0) - type = atomic_read(&usu_bias); - - spin_lock_irqsave(&usu_lock, flags); - if ((stat[type].fls & (USU_MOD_FL_THREAD|USU_MOD_FL_PRESENT)) != 0) { - spin_unlock_irqrestore(&usu_lock, flags); - return -ENXIO; - } - stat[type].fls |= USU_MOD_FL_THREAD; - spin_unlock_irqrestore(&usu_lock, flags); - - rc = kernel_thread(usu_probe_thread, (void*)type, CLONE_VM); - if (rc < 0) { - printk(KERN_WARNING "libusual: " - "Unable to start the thread for %s: %d\n", - bias_names[type], rc); - spin_lock_irqsave(&usu_lock, flags); - stat[type].fls &= ~USU_MOD_FL_THREAD; - spin_unlock_irqrestore(&usu_lock, flags); - return rc; /* Not being -ENXIO causes a message printed */ - } - atomic_inc(&total_threads); - - return -ENXIO; -} - -static void usu_disconnect(struct usb_interface *intf) -{ - ; /* We should not be here. */ -} - -static struct usb_driver usu_driver = { - .name = "libusual", - .probe = usu_probe, - .disconnect = usu_disconnect, - .id_table = storage_usb_ids, -}; - -/* - * A whole new thread for a purpose of request_module seems quite stupid. - * The request_module forks once inside again. However, if we attempt - * to load a storage module from our own modprobe thread, that module - * references our symbols, which cannot be resolved until our module is - * initialized. I wish there was a way to wait for the end of initialization. - * The module notifier reports MODULE_STATE_COMING only. - * So, we wait until module->init ends as the next best thing. - */ -static int usu_probe_thread(void *arg) -{ - int type = (unsigned long) arg; - struct mod_status *st = &stat[type]; - int rc; - unsigned long flags; - - daemonize("libusual_%d", type); /* "usb-storage" is kinda too long */ - - /* A completion does not work here because it's counted. */ - down(&usu_init_notify); - up(&usu_init_notify); - - rc = request_module(bias_names[type]); - spin_lock_irqsave(&usu_lock, flags); - if (rc == 0 && (st->fls & USU_MOD_FL_PRESENT) == 0) { - /* - * This should not happen, but let us keep tabs on it. - */ - printk(KERN_NOTICE "libusual: " - "modprobe for %s succeeded, but module is not present\n", - bias_names[type]); - } - st->fls &= ~USU_MOD_FL_THREAD; - spin_unlock_irqrestore(&usu_lock, flags); - - complete_and_exit(&usu_end_notify, 0); -} - -/* - */ -static int __init usb_usual_init(void) -{ - int rc; - - rc = usb_register(&usu_driver); - up(&usu_init_notify); - return rc; -} - -static void __exit usb_usual_exit(void) -{ - /* - * We do not check for any drivers present, because - * they keep us pinned with symbol references. - */ - - usb_deregister(&usu_driver); - - while (atomic_read(&total_threads) > 0) { - wait_for_completion(&usu_end_notify); - atomic_dec(&total_threads); - } -} - -/* - * Validate and accept the bias parameter. - */ -static int usu_set_bias(const char *bias_s, struct kernel_param *kp) -{ - int i; - int len; - int bias_n = 0; - - len = strlen(bias_s); - if (len == 0) - return -EDOM; - if (bias_s[len-1] == '\n') - --len; - - for (i = 1; i < 3; i++) { - if (strncmp(bias_s, bias_names[i], len) == 0) { - bias_n = i; - break; - } - } - if (bias_n == 0) - return -EINVAL; - - atomic_set(&usu_bias, bias_n); - return 0; -} - -static int usu_get_bias(char *buffer, struct kernel_param *kp) -{ - return strlen(strcpy(buffer, bias_names[atomic_read(&usu_bias)])); -} - -module_init(usb_usual_init); -module_exit(usb_usual_exit); - -module_param_call(bias, usu_set_bias, usu_get_bias, NULL, S_IRUGO|S_IWUSR); -__MODULE_PARM_TYPE(bias, "string"); -MODULE_PARM_DESC(bias, "Bias to usb-storage or ub"); - -MODULE_LICENSE("GPL"); diff --git a/trunk/drivers/usb/storage/onetouch.c b/trunk/drivers/usb/storage/onetouch.c index 55ee2d36d585..89401a59f952 100644 --- a/trunk/drivers/usb/storage/onetouch.c +++ b/trunk/drivers/usb/storage/onetouch.c @@ -52,7 +52,6 @@ struct usb_onetouch { struct urb *irq; /* urb for interrupt in report */ unsigned char *data; /* input data */ dma_addr_t data_dma; - unsigned int is_open:1; }; static void usb_onetouch_irq(struct urb *urb, struct pt_regs *regs) @@ -90,7 +89,6 @@ static int usb_onetouch_open(struct input_dev *dev) { struct usb_onetouch *onetouch = dev->private; - onetouch->is_open = 1; onetouch->irq->dev = onetouch->udev; if (usb_submit_urb(onetouch->irq, GFP_KERNEL)) { err("usb_submit_urb failed"); @@ -105,30 +103,8 @@ static void usb_onetouch_close(struct input_dev *dev) struct usb_onetouch *onetouch = dev->private; usb_kill_urb(onetouch->irq); - onetouch->is_open = 0; } -#ifdef CONFIG_PM -static void usb_onetouch_pm_hook(struct us_data *us, int action) -{ - struct usb_onetouch *onetouch = (struct usb_onetouch *) us->extra; - - if (onetouch->is_open) { - switch (action) { - case US_SUSPEND: - usb_kill_urb(onetouch->irq); - break; - case US_RESUME: - if (usb_submit_urb(onetouch->irq, GFP_KERNEL) != 0) - err("usb_submit_urb failed"); - break; - default: - break; - } - } -} -#endif /* CONFIG_PM */ - int onetouch_connect_input(struct us_data *ss) { struct usb_device *udev = ss->pusb_dev; @@ -209,9 +185,6 @@ int onetouch_connect_input(struct us_data *ss) ss->extra_destructor = onetouch_release_input; ss->extra = onetouch; -#ifdef CONFIG_PM - ss->suspend_resume_hook = usb_onetouch_pm_hook; -#endif input_register_device(onetouch->dev); diff --git a/trunk/drivers/usb/storage/protocol.h b/trunk/drivers/usb/storage/protocol.h index 845bed4b8031..02bff01ab09c 100644 --- a/trunk/drivers/usb/storage/protocol.h +++ b/trunk/drivers/usb/storage/protocol.h @@ -41,6 +41,20 @@ #ifndef _PROTOCOL_H_ #define _PROTOCOL_H_ +/* Sub Classes */ + +#define US_SC_RBC 0x01 /* Typically, flash devices */ +#define US_SC_8020 0x02 /* CD-ROM */ +#define US_SC_QIC 0x03 /* QIC-157 Tapes */ +#define US_SC_UFI 0x04 /* Floppy */ +#define US_SC_8070 0x05 /* Removable media */ +#define US_SC_SCSI 0x06 /* Transparent */ +#define US_SC_ISD200 0x07 /* ISD200 ATA */ +#define US_SC_MIN US_SC_RBC +#define US_SC_MAX US_SC_ISD200 + +#define US_SC_DEVICE 0xff /* Use device's value */ + /* Protocol handling routines */ extern void usb_stor_ATAPI_command(struct scsi_cmnd*, struct us_data*); extern void usb_stor_qic157_command(struct scsi_cmnd*, struct us_data*); diff --git a/trunk/drivers/usb/storage/sddr09.c b/trunk/drivers/usb/storage/sddr09.c index fb8bacaae27c..0ea2f5ab66ba 100644 --- a/trunk/drivers/usb/storage/sddr09.c +++ b/trunk/drivers/usb/storage/sddr09.c @@ -133,11 +133,13 @@ static struct nand_flash_dev nand_flash_ids[] = { { 0,} }; +#define SIZE(a) (sizeof(a)/sizeof((a)[0])) + static struct nand_flash_dev * nand_find_id(unsigned char id) { int i; - for (i = 0; i < ARRAY_SIZE(nand_flash_ids); i++) + for (i = 0; i < SIZE(nand_flash_ids); i++) if (nand_flash_ids[i].model_id == id) return &(nand_flash_ids[i]); return NULL; @@ -212,20 +214,6 @@ static void nand_store_ecc(unsigned char *data, unsigned char *ecc) { * The actual driver starts here. */ -struct sddr09_card_info { - unsigned long capacity; /* Size of card in bytes */ - int pagesize; /* Size of page in bytes */ - int pageshift; /* log2 of pagesize */ - int blocksize; /* Size of block in pages */ - int blockshift; /* log2 of blocksize */ - int blockmask; /* 2^blockshift - 1 */ - int *lba_to_pba; /* logical to physical map */ - int *pba_to_lba; /* physical to logical map */ - int lbact; /* number of available pages */ - int flags; -#define SDDR09_WP 1 /* write protected */ -}; - /* * On my 16MB card, control blocks have size 64 (16 real control bytes, * and 48 junk bytes). In reality of course the card uses 16 control bytes, @@ -249,7 +237,7 @@ struct sddr09_card_info { #define SPARE 0xfffffffe #define UNUSABLE 0xfffffffd -static const int erase_bad_lba_entries = 0; +static int erase_bad_lba_entries = 0; /* send vendor interface command (0x41) */ /* called for requests 0, 1, 8 */ @@ -272,11 +260,8 @@ sddr09_send_command(struct us_data *us, rc = usb_stor_ctrl_transfer(us, pipe, request, requesttype, 0, 0, xfer_data, xfer_len); - switch (rc) { - case USB_STOR_XFER_GOOD: return 0; - case USB_STOR_XFER_STALLED: return -EPIPE; - default: return -EIO; - } + return (rc == USB_STOR_XFER_GOOD ? USB_STOR_TRANSPORT_GOOD : + USB_STOR_TRANSPORT_ERROR); } static int @@ -323,12 +308,20 @@ sddr09_request_sense(struct us_data *us, unsigned char *sensebuf, int buflen) { command[4] = buflen; result = sddr09_send_scsi_command(us, command, 12); - if (result) + if (result != USB_STOR_TRANSPORT_GOOD) { + US_DEBUGP("request sense failed\n"); return result; + } result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, sensebuf, buflen, NULL); - return (result == USB_STOR_XFER_GOOD ? 0 : -EIO); + if (result != USB_STOR_XFER_GOOD) { + US_DEBUGP("request sense bulk in failed\n"); + return USB_STOR_TRANSPORT_ERROR; + } else { + US_DEBUGP("request sense worked\n"); + return USB_STOR_TRANSPORT_GOOD; + } } /* @@ -376,7 +369,7 @@ sddr09_readX(struct us_data *us, int x, unsigned long fromaddress, result = sddr09_send_scsi_command(us, command, 12); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("Result for send_control in sddr09_read2%d %d\n", x, result); return result; @@ -388,9 +381,9 @@ sddr09_readX(struct us_data *us, int x, unsigned long fromaddress, if (result != USB_STOR_XFER_GOOD) { US_DEBUGP("Result for bulk_transfer in sddr09_read2%d %d\n", x, result); - return -EIO; + return USB_STOR_TRANSPORT_ERROR; } - return 0; + return USB_STOR_TRANSPORT_GOOD; } /* @@ -504,7 +497,7 @@ sddr09_erase(struct us_data *us, unsigned long Eaddress) { result = sddr09_send_scsi_command(us, command, 12); - if (result) + if (result != USB_STOR_TRANSPORT_GOOD) US_DEBUGP("Result for send_control in sddr09_erase %d\n", result); @@ -562,7 +555,7 @@ sddr09_writeX(struct us_data *us, result = sddr09_send_scsi_command(us, command, 12); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("Result for send_control in sddr09_writeX %d\n", result); return result; @@ -574,9 +567,9 @@ sddr09_writeX(struct us_data *us, if (result != USB_STOR_XFER_GOOD) { US_DEBUGP("Result for bulk_transfer in sddr09_writeX %d\n", result); - return -EIO; + return USB_STOR_TRANSPORT_ERROR; } - return 0; + return USB_STOR_TRANSPORT_GOOD; } /* erase address, write same address */ @@ -640,7 +633,7 @@ sddr09_read_sg_test_only(struct us_data *us) { result = sddr09_send_scsi_command(us, command, 4*nsg+3); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("Result for send_control in sddr09_read_sg %d\n", result); return result; @@ -648,7 +641,7 @@ sddr09_read_sg_test_only(struct us_data *us) { buf = (unsigned char *) kmalloc(bulklen, GFP_NOIO); if (!buf) - return -ENOMEM; + return USB_STOR_TRANSPORT_ERROR; result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, buf, bulklen, NULL); @@ -656,10 +649,10 @@ sddr09_read_sg_test_only(struct us_data *us) { if (result != USB_STOR_XFER_GOOD) { US_DEBUGP("Result for bulk_transfer in sddr09_read_sg %d\n", result); - return -EIO; + return USB_STOR_TRANSPORT_ERROR; } - return 0; + return USB_STOR_TRANSPORT_GOOD; } #endif @@ -688,13 +681,14 @@ sddr09_read_status(struct us_data *us, unsigned char *status) { command[1] = LUNBITS; result = sddr09_send_scsi_command(us, command, 12); - if (result) + if (result != USB_STOR_TRANSPORT_GOOD) return result; result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, data, 64, NULL); *status = data[0]; - return (result == USB_STOR_XFER_GOOD ? 0 : -EIO); + return (result == USB_STOR_XFER_GOOD ? + USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR); } static int @@ -709,13 +703,6 @@ sddr09_read_data(struct us_data *us, unsigned int len, index, offset; int result; - // Figure out the initial LBA and page - lba = address >> info->blockshift; - page = (address & info->blockmask); - maxlba = info->capacity >> (info->pageshift + info->blockshift); - if (lba >= maxlba) - return -EIO; - // Since we only read in one block at a time, we have to create // a bounce buffer and move the data a piece at a time between the // bounce buffer and the actual transfer buffer. @@ -724,13 +711,18 @@ sddr09_read_data(struct us_data *us, buffer = kmalloc(len, GFP_NOIO); if (buffer == NULL) { printk("sddr09_read_data: Out of memory\n"); - return -ENOMEM; + return USB_STOR_TRANSPORT_ERROR; } + // Figure out the initial LBA and page + lba = address >> info->blockshift; + page = (address & info->blockmask); + maxlba = info->capacity >> (info->pageshift + info->blockshift); + // This could be made much more efficient by checking for // contiguous LBA's. Another exercise left to the student. - result = 0; + result = USB_STOR_TRANSPORT_GOOD; index = offset = 0; while (sectors > 0) { @@ -743,7 +735,7 @@ sddr09_read_data(struct us_data *us, if (lba >= maxlba) { US_DEBUGP("Error: Requested lba %u exceeds " "maximum %u\n", lba, maxlba); - result = -EIO; + result = USB_STOR_TRANSPORT_ERROR; break; } @@ -757,7 +749,7 @@ sddr09_read_data(struct us_data *us, /* This is not really an error. It just means that the block has never been written. - Instead of returning an error + Instead of returning USB_STOR_TRANSPORT_ERROR it is better to return all zero data. */ memset(buffer, 0, len); @@ -772,7 +764,7 @@ sddr09_read_data(struct us_data *us, result = sddr09_read20(us, address>>1, pages, info->pageshift, buffer, 0); - if (result) + if (result != USB_STOR_TRANSPORT_GOOD) break; } @@ -838,7 +830,7 @@ sddr09_write_lba(struct us_data *us, unsigned int lba, pba = sddr09_find_unused_pba(info, lba); if (!pba) { printk("sddr09_write_lba: Out of unused blocks\n"); - return -ENOSPC; + return USB_STOR_TRANSPORT_ERROR; } info->pba_to_lba[pba] = lba; info->lba_to_pba[lba] = pba; @@ -849,7 +841,7 @@ sddr09_write_lba(struct us_data *us, unsigned int lba, /* Maybe it is impossible to write to PBA 1. Fake success, but don't do anything. */ printk("sddr09: avoid writing to pba 1\n"); - return 0; + return USB_STOR_TRANSPORT_GOOD; } pagelen = (1 << info->pageshift) + (1 << CONTROL_SHIFT); @@ -858,7 +850,7 @@ sddr09_write_lba(struct us_data *us, unsigned int lba, address = (pba << (info->pageshift + info->blockshift)); result = sddr09_read22(us, address>>1, info->blocksize, info->pageshift, blockbuffer, 0); - if (result) + if (result != USB_STOR_TRANSPORT_GOOD) return result; /* check old contents and fill lba */ @@ -905,7 +897,7 @@ sddr09_write_lba(struct us_data *us, unsigned int lba, { unsigned char status = 0; int result2 = sddr09_read_status(us, &status); - if (result2) + if (result2 != USB_STOR_TRANSPORT_GOOD) US_DEBUGP("sddr09_write_inplace: cannot read status\n"); else if (status != 0xc0) US_DEBUGP("sddr09_write_inplace: status after write: 0x%x\n", @@ -928,20 +920,13 @@ sddr09_write_data(struct us_data *us, unsigned int sectors) { struct sddr09_card_info *info = (struct sddr09_card_info *) us->extra; - unsigned int lba, maxlba, page, pages; + unsigned int lba, page, pages; unsigned int pagelen, blocklen; unsigned char *blockbuffer; unsigned char *buffer; unsigned int len, index, offset; int result; - // Figure out the initial LBA and page - lba = address >> info->blockshift; - page = (address & info->blockmask); - maxlba = info->capacity >> (info->pageshift + info->blockshift); - if (lba >= maxlba) - return -EIO; - // blockbuffer is used for reading in the old data, overwriting // with the new data, and performing ECC calculations @@ -953,7 +938,7 @@ sddr09_write_data(struct us_data *us, blockbuffer = kmalloc(blocklen, GFP_NOIO); if (!blockbuffer) { printk("sddr09_write_data: Out of memory\n"); - return -ENOMEM; + return USB_STOR_TRANSPORT_ERROR; } // Since we don't write the user data directly to the device, @@ -965,10 +950,14 @@ sddr09_write_data(struct us_data *us, if (buffer == NULL) { printk("sddr09_write_data: Out of memory\n"); kfree(blockbuffer); - return -ENOMEM; + return USB_STOR_TRANSPORT_ERROR; } - result = 0; + // Figure out the initial LBA and page + lba = address >> info->blockshift; + page = (address & info->blockmask); + + result = USB_STOR_TRANSPORT_GOOD; index = offset = 0; while (sectors > 0) { @@ -978,21 +967,13 @@ sddr09_write_data(struct us_data *us, pages = min(sectors, info->blocksize - page); len = (pages << info->pageshift); - /* Not overflowing capacity? */ - if (lba >= maxlba) { - US_DEBUGP("Error: Requested lba %u exceeds " - "maximum %u\n", lba, maxlba); - result = -EIO; - break; - } - // Get the data from the transfer buffer usb_stor_access_xfer_buf(buffer, len, us->srb, &index, &offset, FROM_XFER_BUF); result = sddr09_write_lba(us, lba, page, pages, buffer, blockbuffer); - if (result) + if (result != USB_STOR_TRANSPORT_GOOD) break; page = 0; @@ -1041,7 +1022,7 @@ sddr09_read_deviceID(struct us_data *us, unsigned char *deviceID) { command[1] = LUNBITS; result = sddr09_send_scsi_command(us, command, 12); - if (result) + if (result != USB_STOR_TRANSPORT_GOOD) return result; result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, @@ -1050,7 +1031,8 @@ sddr09_read_deviceID(struct us_data *us, unsigned char *deviceID) { for (i = 0; i < 4; i++) deviceID[i] = content[i]; - return (result == USB_STOR_XFER_GOOD ? 0 : -EIO); + return (result == USB_STOR_XFER_GOOD ? + USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR); } static int @@ -1059,7 +1041,7 @@ sddr09_get_wp(struct us_data *us, struct sddr09_card_info *info) { unsigned char status; result = sddr09_read_status(us, &status); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("sddr09_get_wp: read_status fails\n"); return result; } @@ -1075,7 +1057,7 @@ sddr09_get_wp(struct us_data *us, struct sddr09_card_info *info) { if (status & 0x1) US_DEBUGP(" Error"); US_DEBUGP("\n"); - return 0; + return USB_STOR_TRANSPORT_GOOD; } #if 0 @@ -1107,7 +1089,7 @@ sddr09_get_cardinfo(struct us_data *us, unsigned char flags) { result = sddr09_read_deviceID(us, deviceID); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("Result of read_deviceID is %d\n", result); printk("sddr09: could not read card info\n"); return NULL; @@ -1218,7 +1200,7 @@ sddr09_read_map(struct us_data *us) { us, address>>1, min(alloc_blocks, numblocks - i), buffer, 0); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { result = -1; goto done; } @@ -1360,53 +1342,29 @@ sddr09_card_info_destructor(void *extra) { kfree(info->pba_to_lba); } -static int -sddr09_common_init(struct us_data *us) { - int result; - - /* set the configuration -- STALL is an acceptable response here */ - if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) { - US_DEBUGP("active config #%d != 1 ??\n", us->pusb_dev - ->actconfig->desc.bConfigurationValue); - return -EINVAL; - } - - result = usb_reset_configuration(us->pusb_dev); - US_DEBUGP("Result of usb_reset_configuration is %d\n", result); - if (result == -EPIPE) { - US_DEBUGP("-- stall on control interface\n"); - } else if (result != 0) { - /* it's not a stall, but another error -- time to bail */ - US_DEBUGP("-- Unknown error. Rejecting device\n"); - return -EINVAL; +static void +sddr09_init_card_info(struct us_data *us) { + if (!us->extra) { + us->extra = kmalloc(sizeof(struct sddr09_card_info), GFP_NOIO); + if (us->extra) { + memset(us->extra, 0, sizeof(struct sddr09_card_info)); + us->extra_destructor = sddr09_card_info_destructor; + } } - - us->extra = kzalloc(sizeof(struct sddr09_card_info), GFP_NOIO); - if (!us->extra) - return -ENOMEM; - us->extra_destructor = sddr09_card_info_destructor; - - nand_init_ecc(); - return 0; } - /* * This is needed at a very early stage. If this is not listed in the * unusual devices list but called from here then LUN 0 of the combo reader * is not recognized. But I do not know what precisely these calls do. */ int -usb_stor_sddr09_dpcm_init(struct us_data *us) { +sddr09_init(struct us_data *us) { int result; unsigned char *data = us->iobuf; - result = sddr09_common_init(us); - if (result) - return result; - result = sddr09_send_command(us, 0x01, USB_DIR_IN, data, 2); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("sddr09_init: send_command fails\n"); return result; } @@ -1415,7 +1373,7 @@ usb_stor_sddr09_dpcm_init(struct us_data *us) { // get 07 02 result = sddr09_send_command(us, 0x08, USB_DIR_IN, data, 2); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("sddr09_init: 2nd send_command fails\n"); return result; } @@ -1424,7 +1382,7 @@ usb_stor_sddr09_dpcm_init(struct us_data *us) { // get 07 00 result = sddr09_request_sense(us, data, 18); - if (result == 0 && data[2] != 0) { + if (result == USB_STOR_TRANSPORT_GOOD && data[2] != 0) { int j; for (j=0; j<18; j++) printk(" %02X", data[j]); @@ -1440,7 +1398,7 @@ usb_stor_sddr09_dpcm_init(struct us_data *us) { // test unit ready - return 0; /* not result */ + return USB_STOR_TRANSPORT_GOOD; /* not result */ } /* @@ -1469,6 +1427,13 @@ int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us) }; info = (struct sddr09_card_info *)us->extra; + if (!info) { + nand_init_ecc(); + sddr09_init_card_info(us); + info = (struct sddr09_card_info *)us->extra; + if (!info) + return USB_STOR_TRANSPORT_ERROR; + } if (srb->cmnd[0] == REQUEST_SENSE && havefakesense) { /* for a faked command, we have to follow with a faked sense */ @@ -1571,9 +1536,7 @@ int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us) US_DEBUGP("READ_10: read page %d pagect %d\n", page, pages); - result = sddr09_read_data(us, page, pages); - return (result == 0 ? USB_STOR_TRANSPORT_GOOD : - USB_STOR_TRANSPORT_ERROR); + return sddr09_read_data(us, page, pages); } if (srb->cmnd[0] == WRITE_10) { @@ -1586,9 +1549,7 @@ int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us) US_DEBUGP("WRITE_10: write page %d pagect %d\n", page, pages); - result = sddr09_write_data(us, page, pages); - return (result == 0 ? USB_STOR_TRANSPORT_GOOD : - USB_STOR_TRANSPORT_ERROR); + return sddr09_write_data(us, page, pages); } /* catch-all for all other commands, except @@ -1614,10 +1575,10 @@ int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us) US_DEBUGP("SDDR09: Send control for command %s\n", ptr); result = sddr09_send_scsi_command(us, srb->cmnd, 12); - if (result) { + if (result != USB_STOR_TRANSPORT_GOOD) { US_DEBUGP("sddr09_transport: sddr09_send_scsi_command " "returns %d\n", result); - return USB_STOR_TRANSPORT_ERROR; + return result; } if (srb->request_bufflen == 0) @@ -1645,10 +1606,3 @@ int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us) return USB_STOR_TRANSPORT_GOOD; } -/* - * Initialization routine for the sddr09 subdriver - */ -int -usb_stor_sddr09_init(struct us_data *us) { - return sddr09_common_init(us); -} diff --git a/trunk/drivers/usb/storage/sddr09.h b/trunk/drivers/usb/storage/sddr09.h index c03089a9ec38..c9d78d6188b1 100644 --- a/trunk/drivers/usb/storage/sddr09.h +++ b/trunk/drivers/usb/storage/sddr09.h @@ -31,7 +31,18 @@ extern int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us); -extern int usb_stor_sddr09_dpcm_init(struct us_data *us); -extern int usb_stor_sddr09_init(struct us_data *us); +struct sddr09_card_info { + unsigned long capacity; /* Size of card in bytes */ + int pagesize; /* Size of page in bytes */ + int pageshift; /* log2 of pagesize */ + int blocksize; /* Size of block in pages */ + int blockshift; /* log2 of blocksize */ + int blockmask; /* 2^blockshift - 1 */ + int *lba_to_pba; /* logical to physical map */ + int *pba_to_lba; /* physical to logical map */ + int lbact; /* number of available pages */ + int flags; +#define SDDR09_WP 1 /* write protected */ +}; #endif diff --git a/trunk/drivers/usb/storage/transport.h b/trunk/drivers/usb/storage/transport.h index 633a715850a4..0a362cc781ad 100644 --- a/trunk/drivers/usb/storage/transport.h +++ b/trunk/drivers/usb/storage/transport.h @@ -41,8 +41,39 @@ #ifndef _TRANSPORT_H_ #define _TRANSPORT_H_ +#include #include +/* Protocols */ + +#define US_PR_CBI 0x00 /* Control/Bulk/Interrupt */ +#define US_PR_CB 0x01 /* Control/Bulk w/o interrupt */ +#define US_PR_BULK 0x50 /* bulk only */ +#ifdef CONFIG_USB_STORAGE_USBAT +#define US_PR_USBAT 0x80 /* SCM-ATAPI bridge */ +#endif +#ifdef CONFIG_USB_STORAGE_SDDR09 +#define US_PR_EUSB_SDDR09 0x81 /* SCM-SCSI bridge for SDDR-09 */ +#endif +#ifdef CONFIG_USB_STORAGE_SDDR55 +#define US_PR_SDDR55 0x82 /* SDDR-55 (made up) */ +#endif +#define US_PR_DPCM_USB 0xf0 /* Combination CB/SDDR09 */ + +#ifdef CONFIG_USB_STORAGE_FREECOM +#define US_PR_FREECOM 0xf1 /* Freecom */ +#endif + +#ifdef CONFIG_USB_STORAGE_DATAFAB +#define US_PR_DATAFAB 0xf2 /* Datafab chipsets */ +#endif + +#ifdef CONFIG_USB_STORAGE_JUMPSHOT +#define US_PR_JUMPSHOT 0xf3 /* Lexar Jumpshot */ +#endif + +#define US_PR_DEVICE 0xff /* Use device's value */ + /* * Bulk only data structures */ diff --git a/trunk/drivers/usb/storage/unusual_devs.h b/trunk/drivers/usb/storage/unusual_devs.h index dc301e567cfc..f5f47a34b168 100644 --- a/trunk/drivers/usb/storage/unusual_devs.h +++ b/trunk/drivers/usb/storage/unusual_devs.h @@ -79,6 +79,13 @@ UNUSUAL_DEV( 0x03f0, 0x0307, 0x0001, 0x0001, US_SC_8070, US_PR_USBAT, init_usbat, 0), #endif +/* Patch submitted by Mihnea-Costin Grigore */ +UNUSUAL_DEV( 0x040d, 0x6205, 0x0003, 0x0003, + "VIA Technologies Inc.", + "USB 2.0 Card Reader", + US_SC_DEVICE, US_PR_DEVICE, NULL, + US_FL_IGNORE_RESIDUE ), + /* Reported by Sebastian Kapfer * and Olaf Hering (different bcd's, same vendor/product) * for USB floppies that need the SINGLE_LUN enforcement. @@ -89,13 +96,6 @@ UNUSUAL_DEV( 0x0409, 0x0040, 0x0000, 0x9999, US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_SINGLE_LUN ), -/* Patch submitted by Mihnea-Costin Grigore */ -UNUSUAL_DEV( 0x040d, 0x6205, 0x0003, 0x0003, - "VIA Technologies Inc.", - "USB 2.0 Card Reader", - US_SC_DEVICE, US_PR_DEVICE, NULL, - US_FL_IGNORE_RESIDUE ), - /* Deduced by Jonathan Woithe * Entry needed for flags: US_FL_FIX_INQUIRY because initial inquiry message * always fails and confuses drive. @@ -187,14 +187,6 @@ UNUSUAL_DEV( 0x04b0, 0x0405, 0x0100, 0x0100, US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_CAPACITY), -/* Patch for Nikon coolpix 2000 - * Submitted by Fabien Cosse */ -UNUSUAL_DEV( 0x04b0, 0x0301, 0x0010, 0x0010, - "NIKON", - "NIKON DSC E2000", - US_SC_DEVICE, US_PR_DEVICE,NULL, - US_FL_NOT_LOCKABLE ), - /* BENQ DC5330 * Reported by Manuel Fombuena and * Frank Copeland */ @@ -284,14 +276,14 @@ UNUSUAL_DEV( 0x04e6, 0x0002, 0x0100, 0x0100, UNUSUAL_DEV( 0x04e6, 0x0003, 0x0000, 0x9999, "Sandisk", "ImageMate SDDR09", - US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init, - 0), + US_SC_SCSI, US_PR_EUSB_SDDR09, NULL, + US_FL_SINGLE_LUN ), /* This entry is from Andries.Brouwer@cwi.nl */ UNUSUAL_DEV( 0x04e6, 0x0005, 0x0100, 0x0208, "SCM Microsystems", "eUSB SmartMedia / CompactFlash Adapter", - US_SC_SCSI, US_PR_DPCM_USB, usb_stor_sddr09_dpcm_init, + US_SC_SCSI, US_PR_DPCM_USB, sddr09_init, 0), #endif @@ -535,13 +527,6 @@ UNUSUAL_DEV( 0x057b, 0x0022, 0x0000, 0x9999, "Silicon Media R/W", US_SC_DEVICE, US_PR_DEVICE, NULL, 0), -#ifdef CONFIG_USB_STORAGE_ALAUDA -UNUSUAL_DEV( 0x0584, 0x0008, 0x0102, 0x0102, - "Fujifilm", - "DPC-R1 (Alauda)", - US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0 ), -#endif - /* Fabrizio Fellini */ UNUSUAL_DEV( 0x0595, 0x4343, 0x0000, 0x2210, "Fujifilm", @@ -688,8 +673,8 @@ UNUSUAL_DEV( 0x0644, 0x0000, 0x0100, 0x0100, UNUSUAL_DEV( 0x066b, 0x0105, 0x0100, 0x0100, "Olympus", "Camedia MAUSB-2", - US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init, - 0), + US_SC_SCSI, US_PR_EUSB_SDDR09, NULL, + US_FL_SINGLE_LUN ), #endif /* Reported by Darsen Lu */ @@ -754,8 +739,8 @@ UNUSUAL_DEV( 0x0781, 0x0100, 0x0100, 0x0100, UNUSUAL_DEV( 0x0781, 0x0200, 0x0000, 0x9999, "Sandisk", "ImageMate SDDR-09", - US_SC_SCSI, US_PR_EUSB_SDDR09, usb_stor_sddr09_init, - 0), + US_SC_SCSI, US_PR_EUSB_SDDR09, NULL, + US_FL_SINGLE_LUN ), #endif #ifdef CONFIG_USB_STORAGE_FREECOM @@ -791,13 +776,6 @@ UNUSUAL_DEV( 0x07af, 0x0006, 0x0100, 0x0100, US_SC_SCSI, US_PR_DPCM_USB, NULL, 0 ), #endif -#ifdef CONFIG_USB_STORAGE_ALAUDA -UNUSUAL_DEV( 0x07b4, 0x010a, 0x0102, 0x0102, - "Olympus", - "MAUSB-10 (Alauda)", - US_SC_SCSI, US_PR_ALAUDA, init_alauda, 0 ), -#endif - #ifdef CONFIG_USB_STORAGE_DATAFAB UNUSUAL_DEV( 0x07c4, 0xa000, 0x0000, 0x0015, "Datafab", @@ -1156,27 +1134,3 @@ UNUSUAL_DEV( 0x55aa, 0xa103, 0x0000, 0x9999, US_SC_SCSI, US_PR_SDDR55, NULL, US_FL_SINGLE_LUN), #endif - -/* Control/Bulk transport for all SubClass values */ -USUAL_DEV(US_SC_RBC, US_PR_CB, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_8020, US_PR_CB, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_QIC, US_PR_CB, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_UFI, US_PR_CB, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_8070, US_PR_CB, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_SCSI, US_PR_CB, USB_US_TYPE_STOR), - -/* Control/Bulk/Interrupt transport for all SubClass values */ -USUAL_DEV(US_SC_RBC, US_PR_CBI, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_8020, US_PR_CBI, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_QIC, US_PR_CBI, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_UFI, US_PR_CBI, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_8070, US_PR_CBI, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_SCSI, US_PR_CBI, USB_US_TYPE_STOR), - -/* Bulk-only transport for all SubClass values */ -USUAL_DEV(US_SC_RBC, US_PR_BULK, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_8020, US_PR_BULK, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_QIC, US_PR_BULK, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_UFI, US_PR_BULK, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_8070, US_PR_BULK, USB_US_TYPE_STOR), -USUAL_DEV(US_SC_SCSI, US_PR_BULK, 0), diff --git a/trunk/drivers/usb/storage/usb.c b/trunk/drivers/usb/storage/usb.c index dbcf23980ff1..3847ebed2aa4 100644 --- a/trunk/drivers/usb/storage/usb.c +++ b/trunk/drivers/usb/storage/usb.c @@ -94,9 +94,6 @@ #ifdef CONFIG_USB_STORAGE_ONETOUCH #include "onetouch.h" #endif -#ifdef CONFIG_USB_STORAGE_ALAUDA -#include "alauda.h" -#endif /* Some informational data */ MODULE_AUTHOR("Matthew Dharm "); @@ -115,33 +112,49 @@ static atomic_t total_threads = ATOMIC_INIT(0); static DECLARE_COMPLETION(threads_gone); -/* - * The entries in this table correspond, line for line, - * with the entries of us_unusual_dev_list[]. +/* The entries in this table, except for final ones here + * (USB_MASS_STORAGE_CLASS and the empty entry), correspond, + * line for line with the entries of us_unsuaul_dev_list[]. */ -#ifndef CONFIG_USB_LIBUSUAL #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ vendorName, productName,useProtocol, useTransport, \ initFunction, flags) \ -{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \ - .driver_info = (flags)|(USB_US_TYPE_STOR<<24) } - -#define USUAL_DEV(useProto, useTrans, useType) \ -{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \ - .driver_info = (USB_US_TYPE_STOR<<24) } +{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax) } static struct usb_device_id storage_usb_ids [] = { # include "unusual_devs.h" #undef UNUSUAL_DEV -#undef USUAL_DEV + /* Control/Bulk transport for all SubClass values */ + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CB) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CB) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CB) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CB) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CB) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CB) }, + + /* Control/Bulk/Interrupt transport for all SubClass values */ + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CBI) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CBI) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CBI) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CBI) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CBI) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CBI) }, + + /* Bulk-only transport for all SubClass values */ + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_BULK) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_BULK) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_BULK) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_BULK) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_BULK) }, + { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) }, + /* Terminating entry */ { } }; MODULE_DEVICE_TABLE (usb, storage_usb_ids); -#endif /* CONFIG_USB_LIBUSUAL */ /* This is the list of devices we recognize, along with their flag data */ @@ -154,6 +167,7 @@ MODULE_DEVICE_TABLE (usb, storage_usb_ids); * are free to use as many characters as you like. */ +#undef UNUSUAL_DEV #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ vendor_name, product_name, use_protocol, use_transport, \ init_function, Flags) \ @@ -163,18 +177,53 @@ MODULE_DEVICE_TABLE (usb, storage_usb_ids); .useProtocol = use_protocol, \ .useTransport = use_transport, \ .initFunction = init_function, \ -} - -#define USUAL_DEV(use_protocol, use_transport, use_type) \ -{ \ - .useProtocol = use_protocol, \ - .useTransport = use_transport, \ + .flags = Flags, \ } static struct us_unusual_dev us_unusual_dev_list[] = { # include "unusual_devs.h" # undef UNUSUAL_DEV -# undef USUAL_DEV + /* Control/Bulk transport for all SubClass values */ + { .useProtocol = US_SC_RBC, + .useTransport = US_PR_CB}, + { .useProtocol = US_SC_8020, + .useTransport = US_PR_CB}, + { .useProtocol = US_SC_QIC, + .useTransport = US_PR_CB}, + { .useProtocol = US_SC_UFI, + .useTransport = US_PR_CB}, + { .useProtocol = US_SC_8070, + .useTransport = US_PR_CB}, + { .useProtocol = US_SC_SCSI, + .useTransport = US_PR_CB}, + + /* Control/Bulk/Interrupt transport for all SubClass values */ + { .useProtocol = US_SC_RBC, + .useTransport = US_PR_CBI}, + { .useProtocol = US_SC_8020, + .useTransport = US_PR_CBI}, + { .useProtocol = US_SC_QIC, + .useTransport = US_PR_CBI}, + { .useProtocol = US_SC_UFI, + .useTransport = US_PR_CBI}, + { .useProtocol = US_SC_8070, + .useTransport = US_PR_CBI}, + { .useProtocol = US_SC_SCSI, + .useTransport = US_PR_CBI}, + + /* Bulk-only transport for all SubClass values */ + { .useProtocol = US_SC_RBC, + .useTransport = US_PR_BULK}, + { .useProtocol = US_SC_8020, + .useTransport = US_PR_BULK}, + { .useProtocol = US_SC_QIC, + .useTransport = US_PR_BULK}, + { .useProtocol = US_SC_UFI, + .useTransport = US_PR_BULK}, + { .useProtocol = US_SC_8070, + .useTransport = US_PR_BULK}, + { .useProtocol = US_SC_SCSI, + .useTransport = US_PR_BULK}, /* Terminating entry */ { NULL } @@ -191,8 +240,6 @@ static int storage_suspend(struct usb_interface *iface, pm_message_t message) down(&us->dev_semaphore); US_DEBUGP("%s\n", __FUNCTION__); - if (us->suspend_resume_hook) - (us->suspend_resume_hook)(us, US_SUSPEND); iface->dev.power.power_state.event = message.event; /* When runtime PM is working, we'll set a flag to indicate @@ -209,8 +256,6 @@ static int storage_resume(struct usb_interface *iface) down(&us->dev_semaphore); US_DEBUGP("%s\n", __FUNCTION__); - if (us->suspend_resume_hook) - (us->suspend_resume_hook)(us, US_RESUME); iface->dev.power.power_state.event = PM_EVENT_ON; up(&us->dev_semaphore); @@ -439,20 +484,14 @@ static int associate_dev(struct us_data *us, struct usb_interface *intf) return 0; } -/* Find an unusual_dev descriptor (always succeeds in the current code) */ -static struct us_unusual_dev *find_unusual(const struct usb_device_id *id) -{ - const int id_index = id - storage_usb_ids; - return &us_unusual_dev_list[id_index]; -} - /* Get the unusual_devs entries and the string descriptors */ -static void get_device_info(struct us_data *us, const struct usb_device_id *id) +static void get_device_info(struct us_data *us, int id_index) { struct usb_device *dev = us->pusb_dev; struct usb_interface_descriptor *idesc = &us->pusb_intf->cur_altsetting->desc; - struct us_unusual_dev *unusual_dev = find_unusual(id); + struct us_unusual_dev *unusual_dev = &us_unusual_dev_list[id_index]; + struct usb_device_id *id = &storage_usb_ids[id_index]; /* Store the entries */ us->unusual_dev = unusual_dev; @@ -462,7 +501,7 @@ static void get_device_info(struct us_data *us, const struct usb_device_id *id) us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? idesc->bInterfaceProtocol : unusual_dev->useTransport; - us->flags = USB_US_ORIG_FLAGS(id->driver_info); + us->flags = unusual_dev->flags; /* * This flag is only needed when we're in high-speed, so let's @@ -477,7 +516,7 @@ static void get_device_info(struct us_data *us, const struct usb_device_id *id) * from the unusual_devs.h table. */ if (id->idVendor || id->idProduct) { - static const char *msgs[3] = { + static char *msgs[3] = { "an unneeded SubClass entry", "an unneeded Protocol entry", "unneeded SubClass and Protocol entries"}; @@ -490,7 +529,7 @@ static void get_device_info(struct us_data *us, const struct usb_device_id *id) if (unusual_dev->useTransport != US_PR_DEVICE && us->protocol == idesc->bInterfaceProtocol) msg += 2; - if (msg >= 0 && !(us->flags & US_FL_NEED_OVERRIDE)) + if (msg >= 0 && !(unusual_dev->flags & US_FL_NEED_OVERRIDE)) printk(KERN_NOTICE USB_STORAGE "This device " "(%04x,%04x,%04x S %02x P %02x)" " has %s in unusual_devs.h\n" @@ -647,15 +686,6 @@ static int get_protocol(struct us_data *us) break; #endif -#ifdef CONFIG_USB_STORAGE_ALAUDA - case US_PR_ALAUDA: - us->transport_name = "Alauda Control/Bulk"; - us->transport = alauda_transport; - us->transport_reset = usb_stor_Bulk_reset; - us->max_lun = 1; - break; -#endif - default: return -EIO; } @@ -891,12 +921,10 @@ static int storage_probe(struct usb_interface *intf, { struct Scsi_Host *host; struct us_data *us; + const int id_index = id - storage_usb_ids; int result; struct task_struct *th; - if (usb_usual_check_type(id, USB_US_TYPE_STOR)) - return -ENXIO; - US_DEBUGP("USB Mass Storage device detected\n"); /* @@ -929,7 +957,29 @@ static int storage_probe(struct usb_interface *intf, * of the match from the usb_device_id table, so we can find the * corresponding entry in the private table. */ - get_device_info(us, id); + get_device_info(us, id_index); + +#ifdef CONFIG_USB_STORAGE_SDDR09 + if (us->protocol == US_PR_EUSB_SDDR09 || + us->protocol == US_PR_DPCM_USB) { + /* set the configuration -- STALL is an acceptable response here */ + if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) { + US_DEBUGP("active config #%d != 1 ??\n", us->pusb_dev + ->actconfig->desc.bConfigurationValue); + goto BadDevice; + } + result = usb_reset_configuration(us->pusb_dev); + + US_DEBUGP("Result of usb_reset_configuration is %d\n", result); + if (result == -EPIPE) { + US_DEBUGP("-- stall on control interface\n"); + } else if (result != 0) { + /* it's not a stall, but another error -- time to bail */ + US_DEBUGP("-- Unknown error. Rejecting device\n"); + goto BadDevice; + } + } +#endif /* Get the transport, protocol, and pipe settings */ result = get_transport(us); @@ -994,6 +1044,7 @@ static void storage_disconnect(struct usb_interface *intf) ***********************************************************************/ static struct usb_driver usb_storage_driver = { + .owner = THIS_MODULE, .name = "usb-storage", .probe = storage_probe, .disconnect = storage_disconnect, @@ -1011,10 +1062,9 @@ static int __init usb_stor_init(void) /* register the driver, return usb_register return code if error */ retval = usb_register(&usb_storage_driver); - if (retval == 0) { + if (retval == 0) printk(KERN_INFO "USB Mass Storage support registered.\n"); - usb_usual_set_present(USB_US_TYPE_STOR); - } + return retval; } @@ -1038,8 +1088,6 @@ static void __exit usb_stor_exit(void) wait_for_completion(&threads_gone); atomic_dec(&total_threads); } - - usb_usual_clear_present(USB_US_TYPE_STOR); } module_init(usb_stor_init); diff --git a/trunk/drivers/usb/storage/usb.h b/trunk/drivers/usb/storage/usb.h index 7259fd1f6b0d..98b09711a739 100644 --- a/trunk/drivers/usb/storage/usb.h +++ b/trunk/drivers/usb/storage/usb.h @@ -45,7 +45,6 @@ #define _USB_H_ #include -#include #include #include #include @@ -64,8 +63,38 @@ struct us_unusual_dev { __u8 useProtocol; __u8 useTransport; int (*initFunction)(struct us_data *); + unsigned int flags; }; +/* + * Static flag definitions. We use this roundabout technique so that the + * proc_info() routine can automatically display a message for each flag. + */ +#define US_DO_ALL_FLAGS \ + US_FLAG(SINGLE_LUN, 0x00000001) \ + /* allow access to only LUN 0 */ \ + US_FLAG(NEED_OVERRIDE, 0x00000002) \ + /* unusual_devs entry is necessary */ \ + US_FLAG(SCM_MULT_TARG, 0x00000004) \ + /* supports multiple targets */ \ + US_FLAG(FIX_INQUIRY, 0x00000008) \ + /* INQUIRY response needs faking */ \ + US_FLAG(FIX_CAPACITY, 0x00000010) \ + /* READ CAPACITY response too big */ \ + US_FLAG(IGNORE_RESIDUE, 0x00000020) \ + /* reported residue is wrong */ \ + US_FLAG(BULK32, 0x00000040) \ + /* Uses 32-byte CBW length */ \ + US_FLAG(NOT_LOCKABLE, 0x00000080) \ + /* PREVENT/ALLOW not supported */ \ + US_FLAG(GO_SLOW, 0x00000100) \ + /* Need delay after Command phase */ \ + US_FLAG(NO_WP_DETECT, 0x00000200) \ + /* Don't check for write-protect */ \ + +#define US_FLAG(name, value) US_FL_##name = value , +enum { US_DO_ALL_FLAGS }; +#undef US_FLAG /* Dynamic flag definitions: used in set_bit() etc. */ #define US_FLIDX_URB_ACTIVE 18 /* 0x00040000 current_urb is in use */ @@ -93,11 +122,7 @@ struct us_unusual_dev { typedef int (*trans_cmnd)(struct scsi_cmnd *, struct us_data*); typedef int (*trans_reset)(struct us_data*); typedef void (*proto_cmnd)(struct scsi_cmnd*, struct us_data*); -typedef void (*extra_data_destructor)(void *); /* extra data destructor */ -typedef void (*pm_hook)(struct us_data *, int); /* power management hook */ - -#define US_SUSPEND 0 -#define US_RESUME 1 +typedef void (*extra_data_destructor)(void *); /* extra data destructor */ /* we allocate one of these for every device that we remember */ struct us_data { @@ -153,9 +178,6 @@ struct us_data { /* subdriver information */ void *extra; /* Any extra data */ extra_data_destructor extra_destructor;/* extra data destructor */ -#ifdef CONFIG_PM - pm_hook suspend_resume_hook; -#endif }; /* Convert between us_data and the corresponding Scsi_Host */ diff --git a/trunk/drivers/usb/usb-skeleton.c b/trunk/drivers/usb/usb-skeleton.c index 5d02f16b7d0e..6c3a53f8f26c 100644 --- a/trunk/drivers/usb/usb-skeleton.c +++ b/trunk/drivers/usb/usb-skeleton.c @@ -39,15 +39,10 @@ MODULE_DEVICE_TABLE (usb, skel_table); /* Get a minor range for your devices from the usb maintainer */ #define USB_SKEL_MINOR_BASE 192 -/* our private defines. if this grows any larger, use your own .h file */ -#define MAX_TRANSFER ( PAGE_SIZE - 512 ) -#define WRITES_IN_FLIGHT 8 - /* Structure to hold all of our device specific stuff */ struct usb_skel { struct usb_device * udev; /* the usb device for this device */ struct usb_interface * interface; /* the interface for this device */ - struct semaphore limit_sem; /* limiting the number of writes in progress */ unsigned char * bulk_in_buffer; /* the buffer to receive data */ size_t bulk_in_size; /* the size of the receive buffer */ __u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */ @@ -157,7 +152,6 @@ static void skel_write_bulk_callback(struct urb *urb, struct pt_regs *regs) /* free up our allocated buffer */ usb_buffer_free(urb->dev, urb->transfer_buffer_length, urb->transfer_buffer, urb->transfer_dma); - up(&dev->limit_sem); } static ssize_t skel_write(struct file *file, const char *user_buffer, size_t count, loff_t *ppos) @@ -166,7 +160,6 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou int retval = 0; struct urb *urb = NULL; char *buf = NULL; - size_t writesize = min(count, (size_t)MAX_TRANSFER); dev = (struct usb_skel *)file->private_data; @@ -174,12 +167,6 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou if (count == 0) goto exit; - /* limit the number of URBs in flight to stop a user from using up all RAM */ - if (down_interruptible(&dev->limit_sem)) { - retval = -ERESTARTSYS; - goto exit; - } - /* create a urb, and a buffer for it, and copy the data to the urb */ urb = usb_alloc_urb(0, GFP_KERNEL); if (!urb) { @@ -187,13 +174,13 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou goto error; } - buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL, &urb->transfer_dma); + buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma); if (!buf) { retval = -ENOMEM; goto error; } - if (copy_from_user(buf, user_buffer, writesize)) { + if (copy_from_user(buf, user_buffer, count)) { retval = -EFAULT; goto error; } @@ -201,7 +188,7 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou /* initialize the urb properly */ usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr), - buf, writesize, skel_write_bulk_callback, dev); + buf, count, skel_write_bulk_callback, dev); urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; /* send the data out the bulk port */ @@ -215,12 +202,11 @@ static ssize_t skel_write(struct file *file, const char *user_buffer, size_t cou usb_free_urb(urb); exit: - return writesize; + return count; error: - usb_buffer_free(dev->udev, writesize, buf, urb->transfer_dma); + usb_buffer_free(dev->udev, count, buf, urb->transfer_dma); usb_free_urb(urb); - up(&dev->limit_sem); return retval; } @@ -252,13 +238,13 @@ static int skel_probe(struct usb_interface *interface, const struct usb_device_i int retval = -ENOMEM; /* allocate memory for our device state and initialize it */ - dev = kzalloc(sizeof(*dev), GFP_KERNEL); + dev = kmalloc(sizeof(*dev), GFP_KERNEL); if (dev == NULL) { err("Out of memory"); goto error; } + memset(dev, 0x00, sizeof(*dev)); kref_init(&dev->kref); - sema_init(&dev->limit_sem, WRITES_IN_FLIGHT); dev->udev = usb_get_dev(interface_to_usbdev(interface)); dev->interface = interface; @@ -344,6 +330,7 @@ static void skel_disconnect(struct usb_interface *interface) } static struct usb_driver skel_driver = { + .owner = THIS_MODULE, .name = "skeleton", .probe = skel_probe, .disconnect = skel_disconnect, diff --git a/trunk/drivers/video/aty/atyfb_base.c b/trunk/drivers/video/aty/atyfb_base.c index 3fefdb0cbf07..08edbfcfca58 100644 --- a/trunk/drivers/video/aty/atyfb_base.c +++ b/trunk/drivers/video/aty/atyfb_base.c @@ -403,7 +403,7 @@ static struct { { PCI_CHIP_MACH64GM, "3D RAGE XL (Mach64 GM, AGP)", 230, 83, 63, ATI_CHIP_264XL }, { PCI_CHIP_MACH64GN, "3D RAGE XL (Mach64 GN, AGP)", 230, 83, 63, ATI_CHIP_264XL }, { PCI_CHIP_MACH64GO, "3D RAGE XL (Mach64 GO, PCI-66/BGA)", 230, 83, 63, ATI_CHIP_264XL }, - { PCI_CHIP_MACH64GR, "3D RAGE XL (Mach64 GR, PCI-33MHz)", 235, 83, 63, ATI_CHIP_264XL | M64F_SDRAM_MAGIC_PLL }, + { PCI_CHIP_MACH64GR, "3D RAGE XL (Mach64 GR, PCI-33MHz)", 230, 83, 63, ATI_CHIP_264XL }, { PCI_CHIP_MACH64GL, "3D RAGE XL (Mach64 GL, PCI)", 230, 83, 63, ATI_CHIP_264XL }, { PCI_CHIP_MACH64GS, "3D RAGE XL (Mach64 GS, PCI)", 230, 83, 63, ATI_CHIP_264XL }, diff --git a/trunk/drivers/video/aty/radeon_base.c b/trunk/drivers/video/aty/radeon_base.c index 156db84cb363..4f01ccc02aa4 100644 --- a/trunk/drivers/video/aty/radeon_base.c +++ b/trunk/drivers/video/aty/radeon_base.c @@ -594,7 +594,7 @@ static int __devinit radeon_probe_pll_params(struct radeonfb_info *rinfo) } /* - * Retrieve PLL infos by different means (BIOS, Open Firmware, register probing...) + * Retreive PLL infos by different means (BIOS, Open Firmware, register probing...) */ static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo) { @@ -660,17 +660,17 @@ static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo) #ifdef CONFIG_PPC_OF /* - * Retrieve PLL infos from Open Firmware first + * Retreive PLL infos from Open Firmware first */ if (!force_measure_pll && radeon_read_xtal_OF(rinfo) == 0) { - printk(KERN_INFO "radeonfb: Retrieved PLL infos from Open Firmware\n"); + printk(KERN_INFO "radeonfb: Retreived PLL infos from Open Firmware\n"); goto found; } #endif /* CONFIG_PPC_OF */ /* * Check out if we have an X86 which gave us some PLL informations - * and if yes, retrieve them + * and if yes, retreive them */ if (!force_measure_pll && rinfo->bios_seg) { u16 pll_info_block = BIOS_IN16(rinfo->fp_bios_start + 0x30); @@ -682,7 +682,7 @@ static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo) rinfo->pll.ppll_min = BIOS_IN32(pll_info_block + 0x12); rinfo->pll.ppll_max = BIOS_IN32(pll_info_block + 0x16); - printk(KERN_INFO "radeonfb: Retrieved PLL infos from BIOS\n"); + printk(KERN_INFO "radeonfb: Retreived PLL infos from BIOS\n"); goto found; } @@ -691,7 +691,7 @@ static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo) * probe them */ if (radeon_probe_pll_params(rinfo) == 0) { - printk(KERN_INFO "radeonfb: Retrieved PLL infos from registers\n"); + printk(KERN_INFO "radeonfb: Retreived PLL infos from registers\n"); goto found; } @@ -702,7 +702,7 @@ static void __devinit radeon_get_pllinfo(struct radeonfb_info *rinfo) found: /* - * Some methods fail to retrieve SCLK and MCLK values, we apply default + * Some methods fail to retreive SCLK and MCLK values, we apply default * settings in this case (200Mhz). If that really happne often, we could * fetch from registers instead... */ @@ -2393,7 +2393,7 @@ static int radeonfb_pci_register (struct pci_dev *pdev, rinfo->mapped_vram/1024); /* - * Map the BIOS ROM if any and retrieve PLL parameters from + * Map the BIOS ROM if any and retreive PLL parameters from * the BIOS. We skip that on mobility chips as the real panel * values we need aren't in the ROM but in the BIOS image in * memory. This is definitely not the best meacnism though, diff --git a/trunk/drivers/w1/dscore.c b/trunk/drivers/w1/dscore.c index b9146306df49..15fb250451e5 100644 --- a/trunk/drivers/w1/dscore.c +++ b/trunk/drivers/w1/dscore.c @@ -52,6 +52,7 @@ static int ds_send_control_cmd(struct ds_device *, u16, u16); static struct usb_driver ds_driver = { + .owner = THIS_MODULE, .name = "DS9490R", .probe = ds_probe, .disconnect = ds_disconnect, diff --git a/trunk/drivers/w1/w1.c b/trunk/drivers/w1/w1.c index 024206c4a0e4..14016b1cd948 100644 --- a/trunk/drivers/w1/w1.c +++ b/trunk/drivers/w1/w1.c @@ -142,12 +142,12 @@ static struct bin_attribute w1_slave_attr_bin_id = { /* Default family */ static struct w1_family w1_default_family; -static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size); +static int w1_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size); static struct bus_type w1_bus_type = { .name = "w1", .match = w1_master_match, - .uevent = w1_uevent, + .hotplug = w1_hotplug, }; struct device_driver w1_master_driver = { @@ -361,7 +361,7 @@ void w1_destroy_master_attributes(struct w1_master *master) } #ifdef CONFIG_HOTPLUG -static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) +static int w1_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { struct w1_master *md = NULL; struct w1_slave *sl = NULL; @@ -377,7 +377,7 @@ static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer event_owner = "slave"; name = sl->name; } else { - dev_dbg(dev, "Unknown event.\n"); + dev_dbg(dev, "Unknown hotplug event.\n"); return -EINVAL; } @@ -386,18 +386,18 @@ static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer if (dev->driver != &w1_slave_driver || !sl) return 0; - err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_FID=%02X", sl->reg_num.family); + err = add_hotplug_env_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_FID=%02X", sl->reg_num.family); if (err) return err; - err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_SLAVE_ID=%024LX", (u64)sl->reg_num.id); + err = add_hotplug_env_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_SLAVE_ID=%024LX", (u64)sl->reg_num.id); if (err) return err; return 0; }; #else -static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) +static int w1_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) { return 0; } diff --git a/trunk/fs/9p/trans_sock.c b/trunk/fs/9p/trans_sock.c index 6a9a75d40f73..a93c2bf94c33 100644 --- a/trunk/fs/9p/trans_sock.c +++ b/trunk/fs/9p/trans_sock.c @@ -26,7 +26,6 @@ */ #include -#include #include #include #include diff --git a/trunk/fs/Kconfig b/trunk/fs/Kconfig index d5255e627b5f..ba1dbe2b2202 100644 --- a/trunk/fs/Kconfig +++ b/trunk/fs/Kconfig @@ -841,6 +841,20 @@ config RELAYFS_FS If unsure, say N. +config CONFIGFS_FS + tristate "Userspace-driven configuration filesystem (EXPERIMENTAL)" + depends on EXPERIMENTAL + help + configfs is a ram-based filesystem that provides the converse + of sysfs's functionality. Where sysfs is a filesystem-based + view of kernel objects, configfs is a filesystem-based manager + of kernel objects, or config_items. + + Both sysfs and configfs can and should exist together on the + same system. One is not a replacement for the other. + + If unsure, say N. + endmenu menu "Miscellaneous filesystems" diff --git a/trunk/fs/Makefile b/trunk/fs/Makefile index 4c2655759078..ff3d48a744f5 100644 --- a/trunk/fs/Makefile +++ b/trunk/fs/Makefile @@ -101,3 +101,4 @@ obj-$(CONFIG_BEFS_FS) += befs/ obj-$(CONFIG_HOSTFS) += hostfs/ obj-$(CONFIG_HPPFS) += hppfs/ obj-$(CONFIG_DEBUG_FS) += debugfs/ +obj-$(CONFIG_CONFIGFS_FS) += configfs/ diff --git a/trunk/fs/bio.c b/trunk/fs/bio.c index 38d3e8023a07..460554b07ff9 100644 --- a/trunk/fs/bio.c +++ b/trunk/fs/bio.c @@ -313,8 +313,7 @@ int bio_get_nr_vecs(struct block_device *bdev) } static int __bio_add_page(request_queue_t *q, struct bio *bio, struct page - *page, unsigned int len, unsigned int offset, - unsigned short max_sectors) + *page, unsigned int len, unsigned int offset) { int retried_segments = 0; struct bio_vec *bvec; @@ -328,7 +327,7 @@ static int __bio_add_page(request_queue_t *q, struct bio *bio, struct page if (bio->bi_vcnt >= bio->bi_max_vecs) return 0; - if (((bio->bi_size + len) >> 9) > max_sectors) + if (((bio->bi_size + len) >> 9) > q->max_sectors) return 0; /* @@ -386,25 +385,6 @@ static int __bio_add_page(request_queue_t *q, struct bio *bio, struct page return len; } -/** - * bio_add_pc_page - attempt to add page to bio - * @bio: destination bio - * @page: page to add - * @len: vec entry length - * @offset: vec entry offset - * - * Attempt to add a page to the bio_vec maplist. This can fail for a - * number of reasons, such as the bio being full or target block - * device limitations. The target block device must allow bio's - * smaller than PAGE_SIZE, so it is always possible to add a single - * page to an empty bio. This should only be used by REQ_PC bios. - */ -int bio_add_pc_page(request_queue_t *q, struct bio *bio, struct page *page, - unsigned int len, unsigned int offset) -{ - return __bio_add_page(q, bio, page, len, offset, q->max_hw_sectors); -} - /** * bio_add_page - attempt to add page to bio * @bio: destination bio @@ -421,8 +401,8 @@ int bio_add_pc_page(request_queue_t *q, struct bio *bio, struct page *page, int bio_add_page(struct bio *bio, struct page *page, unsigned int len, unsigned int offset) { - struct request_queue *q = bdev_get_queue(bio->bi_bdev); - return __bio_add_page(q, bio, page, len, offset, q->max_sectors); + return __bio_add_page(bdev_get_queue(bio->bi_bdev), bio, page, + len, offset); } struct bio_map_data { @@ -534,7 +514,7 @@ struct bio *bio_copy_user(request_queue_t *q, unsigned long uaddr, break; } - if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes) { + if (__bio_add_page(q, bio, page, bytes, 0) < bytes) { ret = -EINVAL; break; } @@ -648,8 +628,7 @@ static struct bio *__bio_map_user_iov(request_queue_t *q, /* * sorry... */ - if (bio_add_pc_page(q, bio, pages[j], bytes, offset) < - bytes) + if (__bio_add_page(q, bio, pages[j], bytes, offset) < bytes) break; len -= bytes; @@ -822,8 +801,8 @@ static struct bio *__bio_map_kern(request_queue_t *q, void *data, if (bytes > len) bytes = len; - if (bio_add_pc_page(q, bio, virt_to_page(data), bytes, - offset) < bytes) + if (__bio_add_page(q, bio, virt_to_page(data), bytes, + offset) < bytes) break; data += bytes; @@ -1249,7 +1228,6 @@ EXPORT_SYMBOL(bio_clone); EXPORT_SYMBOL(bio_phys_segments); EXPORT_SYMBOL(bio_hw_segments); EXPORT_SYMBOL(bio_add_page); -EXPORT_SYMBOL(bio_add_pc_page); EXPORT_SYMBOL(bio_get_nr_vecs); EXPORT_SYMBOL(bio_map_user); EXPORT_SYMBOL(bio_unmap_user); diff --git a/trunk/fs/compat.c b/trunk/fs/compat.c index 55ac0324aaf1..818634120b69 100644 --- a/trunk/fs/compat.c +++ b/trunk/fs/compat.c @@ -1170,7 +1170,7 @@ static ssize_t compat_do_readv_writev(int type, struct file *file, } ret = rw_verify_area(type, file, pos, tot_len); - if (ret < 0) + if (ret) goto out; fnv = NULL; diff --git a/trunk/fs/configfs/Makefile b/trunk/fs/configfs/Makefile new file mode 100644 index 000000000000..00ffb278e98c --- /dev/null +++ b/trunk/fs/configfs/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the configfs virtual filesystem +# + +obj-$(CONFIG_CONFIGFS_FS) += configfs.o + +configfs-objs := inode.o file.o dir.o symlink.o mount.o item.o diff --git a/trunk/fs/configfs/configfs_internal.h b/trunk/fs/configfs/configfs_internal.h new file mode 100644 index 000000000000..8899d9c5f6bf --- /dev/null +++ b/trunk/fs/configfs/configfs_internal.h @@ -0,0 +1,142 @@ +/* -*- mode: c; c-basic-offset:8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * configfs_internal.h - Internal stuff for configfs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + */ + +#include +#include + +struct configfs_dirent { + atomic_t s_count; + struct list_head s_sibling; + struct list_head s_children; + struct list_head s_links; + void * s_element; + int s_type; + umode_t s_mode; + struct dentry * s_dentry; +}; + +#define CONFIGFS_ROOT 0x0001 +#define CONFIGFS_DIR 0x0002 +#define CONFIGFS_ITEM_ATTR 0x0004 +#define CONFIGFS_ITEM_LINK 0x0020 +#define CONFIGFS_USET_DIR 0x0040 +#define CONFIGFS_USET_DEFAULT 0x0080 +#define CONFIGFS_USET_DROPPING 0x0100 +#define CONFIGFS_NOT_PINNED (CONFIGFS_ITEM_ATTR) + +extern struct vfsmount * configfs_mount; + +extern int configfs_is_root(struct config_item *item); + +extern struct inode * configfs_new_inode(mode_t mode); +extern int configfs_create(struct dentry *, int mode, int (*init)(struct inode *)); + +extern int configfs_create_file(struct config_item *, const struct configfs_attribute *); +extern int configfs_make_dirent(struct configfs_dirent *, + struct dentry *, void *, umode_t, int); + +extern int configfs_add_file(struct dentry *, const struct configfs_attribute *, int); +extern void configfs_hash_and_remove(struct dentry * dir, const char * name); + +extern const unsigned char * configfs_get_name(struct configfs_dirent *sd); +extern void configfs_drop_dentry(struct configfs_dirent *sd, struct dentry *parent); + +extern int configfs_pin_fs(void); +extern void configfs_release_fs(void); + +extern struct rw_semaphore configfs_rename_sem; +extern struct super_block * configfs_sb; +extern struct file_operations configfs_dir_operations; +extern struct file_operations configfs_file_operations; +extern struct file_operations bin_fops; +extern struct inode_operations configfs_dir_inode_operations; +extern struct inode_operations configfs_symlink_inode_operations; + +extern int configfs_symlink(struct inode *dir, struct dentry *dentry, + const char *symname); +extern int configfs_unlink(struct inode *dir, struct dentry *dentry); + +struct configfs_symlink { + struct list_head sl_list; + struct config_item *sl_target; +}; + +extern int configfs_create_link(struct configfs_symlink *sl, + struct dentry *parent, + struct dentry *dentry); + +static inline struct config_item * to_item(struct dentry * dentry) +{ + struct configfs_dirent * sd = dentry->d_fsdata; + return ((struct config_item *) sd->s_element); +} + +static inline struct configfs_attribute * to_attr(struct dentry * dentry) +{ + struct configfs_dirent * sd = dentry->d_fsdata; + return ((struct configfs_attribute *) sd->s_element); +} + +static inline struct config_item *configfs_get_config_item(struct dentry *dentry) +{ + struct config_item * item = NULL; + + spin_lock(&dcache_lock); + if (!d_unhashed(dentry)) { + struct configfs_dirent * sd = dentry->d_fsdata; + if (sd->s_type & CONFIGFS_ITEM_LINK) { + struct configfs_symlink * sl = sd->s_element; + item = config_item_get(sl->sl_target); + } else + item = config_item_get(sd->s_element); + } + spin_unlock(&dcache_lock); + + return item; +} + +static inline void release_configfs_dirent(struct configfs_dirent * sd) +{ + if (!(sd->s_type & CONFIGFS_ROOT)) + kfree(sd); +} + +static inline struct configfs_dirent * configfs_get(struct configfs_dirent * sd) +{ + if (sd) { + WARN_ON(!atomic_read(&sd->s_count)); + atomic_inc(&sd->s_count); + } + return sd; +} + +static inline void configfs_put(struct configfs_dirent * sd) +{ + WARN_ON(!atomic_read(&sd->s_count)); + if (atomic_dec_and_test(&sd->s_count)) + release_configfs_dirent(sd); +} + diff --git a/trunk/fs/configfs/dir.c b/trunk/fs/configfs/dir.c new file mode 100644 index 000000000000..e48b539243a1 --- /dev/null +++ b/trunk/fs/configfs/dir.c @@ -0,0 +1,1102 @@ +/* -*- mode: c; c-basic-offset: 8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * dir.c - Operations for configfs directories. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + */ + +#undef DEBUG + +#include +#include +#include +#include + +#include +#include "configfs_internal.h" + +DECLARE_RWSEM(configfs_rename_sem); + +static void configfs_d_iput(struct dentry * dentry, + struct inode * inode) +{ + struct configfs_dirent * sd = dentry->d_fsdata; + + if (sd) { + BUG_ON(sd->s_dentry != dentry); + sd->s_dentry = NULL; + configfs_put(sd); + } + iput(inode); +} + +/* + * We _must_ delete our dentries on last dput, as the chain-to-parent + * behavior is required to clear the parents of default_groups. + */ +static int configfs_d_delete(struct dentry *dentry) +{ + return 1; +} + +static struct dentry_operations configfs_dentry_ops = { + .d_iput = configfs_d_iput, + /* simple_delete_dentry() isn't exported */ + .d_delete = configfs_d_delete, +}; + +/* + * Allocates a new configfs_dirent and links it to the parent configfs_dirent + */ +static struct configfs_dirent *configfs_new_dirent(struct configfs_dirent * parent_sd, + void * element) +{ + struct configfs_dirent * sd; + + sd = kmalloc(sizeof(*sd), GFP_KERNEL); + if (!sd) + return NULL; + + memset(sd, 0, sizeof(*sd)); + atomic_set(&sd->s_count, 1); + INIT_LIST_HEAD(&sd->s_links); + INIT_LIST_HEAD(&sd->s_children); + list_add(&sd->s_sibling, &parent_sd->s_children); + sd->s_element = element; + + return sd; +} + +int configfs_make_dirent(struct configfs_dirent * parent_sd, + struct dentry * dentry, void * element, + umode_t mode, int type) +{ + struct configfs_dirent * sd; + + sd = configfs_new_dirent(parent_sd, element); + if (!sd) + return -ENOMEM; + + sd->s_mode = mode; + sd->s_type = type; + sd->s_dentry = dentry; + if (dentry) { + dentry->d_fsdata = configfs_get(sd); + dentry->d_op = &configfs_dentry_ops; + } + + return 0; +} + +static int init_dir(struct inode * inode) +{ + inode->i_op = &configfs_dir_inode_operations; + inode->i_fop = &configfs_dir_operations; + + /* directory inodes start off with i_nlink == 2 (for "." entry) */ + inode->i_nlink++; + return 0; +} + +static int init_file(struct inode * inode) +{ + inode->i_size = PAGE_SIZE; + inode->i_fop = &configfs_file_operations; + return 0; +} + +static int init_symlink(struct inode * inode) +{ + inode->i_op = &configfs_symlink_inode_operations; + return 0; +} + +static int create_dir(struct config_item * k, struct dentry * p, + struct dentry * d) +{ + int error; + umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO; + + error = configfs_create(d, mode, init_dir); + if (!error) { + error = configfs_make_dirent(p->d_fsdata, d, k, mode, + CONFIGFS_DIR); + if (!error) { + p->d_inode->i_nlink++; + (d)->d_op = &configfs_dentry_ops; + } + } + return error; +} + + +/** + * configfs_create_dir - create a directory for an config_item. + * @item: config_itemwe're creating directory for. + * @dentry: config_item's dentry. + */ + +static int configfs_create_dir(struct config_item * item, struct dentry *dentry) +{ + struct dentry * parent; + int error = 0; + + BUG_ON(!item); + + if (item->ci_parent) + parent = item->ci_parent->ci_dentry; + else if (configfs_mount && configfs_mount->mnt_sb) + parent = configfs_mount->mnt_sb->s_root; + else + return -EFAULT; + + error = create_dir(item,parent,dentry); + if (!error) + item->ci_dentry = dentry; + return error; +} + +int configfs_create_link(struct configfs_symlink *sl, + struct dentry *parent, + struct dentry *dentry) +{ + int err = 0; + umode_t mode = S_IFLNK | S_IRWXUGO; + + err = configfs_create(dentry, mode, init_symlink); + if (!err) { + err = configfs_make_dirent(parent->d_fsdata, dentry, sl, + mode, CONFIGFS_ITEM_LINK); + if (!err) + dentry->d_op = &configfs_dentry_ops; + } + return err; +} + +static void remove_dir(struct dentry * d) +{ + struct dentry * parent = dget(d->d_parent); + struct configfs_dirent * sd; + + sd = d->d_fsdata; + list_del_init(&sd->s_sibling); + configfs_put(sd); + if (d->d_inode) + simple_rmdir(parent->d_inode,d); + + pr_debug(" o %s removing done (%d)\n",d->d_name.name, + atomic_read(&d->d_count)); + + dput(parent); +} + +/** + * configfs_remove_dir - remove an config_item's directory. + * @item: config_item we're removing. + * + * The only thing special about this is that we remove any files in + * the directory before we remove the directory, and we've inlined + * what used to be configfs_rmdir() below, instead of calling separately. + */ + +static void configfs_remove_dir(struct config_item * item) +{ + struct dentry * dentry = dget(item->ci_dentry); + + if (!dentry) + return; + + remove_dir(dentry); + /** + * Drop reference from dget() on entrance. + */ + dput(dentry); +} + + +/* attaches attribute's configfs_dirent to the dentry corresponding to the + * attribute file + */ +static int configfs_attach_attr(struct configfs_dirent * sd, struct dentry * dentry) +{ + struct configfs_attribute * attr = sd->s_element; + int error; + + error = configfs_create(dentry, (attr->ca_mode & S_IALLUGO) | S_IFREG, init_file); + if (error) + return error; + + dentry->d_op = &configfs_dentry_ops; + dentry->d_fsdata = configfs_get(sd); + sd->s_dentry = dentry; + d_rehash(dentry); + + return 0; +} + +static struct dentry * configfs_lookup(struct inode *dir, + struct dentry *dentry, + struct nameidata *nd) +{ + struct configfs_dirent * parent_sd = dentry->d_parent->d_fsdata; + struct configfs_dirent * sd; + int found = 0; + int err = 0; + + list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { + if (sd->s_type & CONFIGFS_NOT_PINNED) { + const unsigned char * name = configfs_get_name(sd); + + if (strcmp(name, dentry->d_name.name)) + continue; + + found = 1; + err = configfs_attach_attr(sd, dentry); + break; + } + } + + if (!found) { + /* + * If it doesn't exist and it isn't a NOT_PINNED item, + * it must be negative. + */ + return simple_lookup(dir, dentry, nd); + } + + return ERR_PTR(err); +} + +/* + * Only subdirectories count here. Files (CONFIGFS_NOT_PINNED) are + * attributes and are removed by rmdir(). We recurse, taking i_sem + * on all children that are candidates for default detach. If the + * result is clean, then configfs_detach_group() will handle dropping + * i_sem. If there is an error, the caller will clean up the i_sem + * holders via configfs_detach_rollback(). + */ +static int configfs_detach_prep(struct dentry *dentry) +{ + struct configfs_dirent *parent_sd = dentry->d_fsdata; + struct configfs_dirent *sd; + int ret; + + ret = -EBUSY; + if (!list_empty(&parent_sd->s_links)) + goto out; + + ret = 0; + list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { + if (sd->s_type & CONFIGFS_NOT_PINNED) + continue; + if (sd->s_type & CONFIGFS_USET_DEFAULT) { + down(&sd->s_dentry->d_inode->i_sem); + /* Mark that we've taken i_sem */ + sd->s_type |= CONFIGFS_USET_DROPPING; + + ret = configfs_detach_prep(sd->s_dentry); + if (!ret) + continue; + } else + ret = -ENOTEMPTY; + + break; + } + +out: + return ret; +} + +/* + * Walk the tree, dropping i_sem wherever CONFIGFS_USET_DROPPING is + * set. + */ +static void configfs_detach_rollback(struct dentry *dentry) +{ + struct configfs_dirent *parent_sd = dentry->d_fsdata; + struct configfs_dirent *sd; + + list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { + if (sd->s_type & CONFIGFS_USET_DEFAULT) { + configfs_detach_rollback(sd->s_dentry); + + if (sd->s_type & CONFIGFS_USET_DROPPING) { + sd->s_type &= ~CONFIGFS_USET_DROPPING; + up(&sd->s_dentry->d_inode->i_sem); + } + } + } +} + +static void detach_attrs(struct config_item * item) +{ + struct dentry * dentry = dget(item->ci_dentry); + struct configfs_dirent * parent_sd; + struct configfs_dirent * sd, * tmp; + + if (!dentry) + return; + + pr_debug("configfs %s: dropping attrs for dir\n", + dentry->d_name.name); + + parent_sd = dentry->d_fsdata; + list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) { + if (!sd->s_element || !(sd->s_type & CONFIGFS_NOT_PINNED)) + continue; + list_del_init(&sd->s_sibling); + configfs_drop_dentry(sd, dentry); + configfs_put(sd); + } + + /** + * Drop reference from dget() on entrance. + */ + dput(dentry); +} + +static int populate_attrs(struct config_item *item) +{ + struct config_item_type *t = item->ci_type; + struct configfs_attribute *attr; + int error = 0; + int i; + + if (!t) + return -EINVAL; + if (t->ct_attrs) { + for (i = 0; (attr = t->ct_attrs[i]) != NULL; i++) { + if ((error = configfs_create_file(item, attr))) + break; + } + } + + if (error) + detach_attrs(item); + + return error; +} + +static int configfs_attach_group(struct config_item *parent_item, + struct config_item *item, + struct dentry *dentry); +static void configfs_detach_group(struct config_item *item); + +static void detach_groups(struct config_group *group) +{ + struct dentry * dentry = dget(group->cg_item.ci_dentry); + struct dentry *child; + struct configfs_dirent *parent_sd; + struct configfs_dirent *sd, *tmp; + + if (!dentry) + return; + + parent_sd = dentry->d_fsdata; + list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) { + if (!sd->s_element || + !(sd->s_type & CONFIGFS_USET_DEFAULT)) + continue; + + child = sd->s_dentry; + + configfs_detach_group(sd->s_element); + child->d_inode->i_flags |= S_DEAD; + + /* + * From rmdir/unregister, a configfs_detach_prep() pass + * has taken our i_sem for us. Drop it. + * From mkdir/register cleanup, there is no sem held. + */ + if (sd->s_type & CONFIGFS_USET_DROPPING) + up(&child->d_inode->i_sem); + + d_delete(child); + dput(child); + } + + /** + * Drop reference from dget() on entrance. + */ + dput(dentry); +} + +/* + * This fakes mkdir(2) on a default_groups[] entry. It + * creates a dentry, attachs it, and then does fixup + * on the sd->s_type. + * + * We could, perhaps, tweak our parent's ->mkdir for a minute and + * try using vfs_mkdir. Just a thought. + */ +static int create_default_group(struct config_group *parent_group, + struct config_group *group) +{ + int ret; + struct qstr name; + struct configfs_dirent *sd; + /* We trust the caller holds a reference to parent */ + struct dentry *child, *parent = parent_group->cg_item.ci_dentry; + + if (!group->cg_item.ci_name) + group->cg_item.ci_name = group->cg_item.ci_namebuf; + name.name = group->cg_item.ci_name; + name.len = strlen(name.name); + name.hash = full_name_hash(name.name, name.len); + + ret = -ENOMEM; + child = d_alloc(parent, &name); + if (child) { + d_add(child, NULL); + + ret = configfs_attach_group(&parent_group->cg_item, + &group->cg_item, child); + if (!ret) { + sd = child->d_fsdata; + sd->s_type |= CONFIGFS_USET_DEFAULT; + } else { + d_delete(child); + dput(child); + } + } + + return ret; +} + +static int populate_groups(struct config_group *group) +{ + struct config_group *new_group; + struct dentry *dentry = group->cg_item.ci_dentry; + int ret = 0; + int i; + + if (group && group->default_groups) { + /* FYI, we're faking mkdir here + * I'm not sure we need this semaphore, as we're called + * from our parent's mkdir. That holds our parent's + * i_sem, so afaik lookup cannot continue through our + * parent to find us, let alone mess with our tree. + * That said, taking our i_sem is closer to mkdir + * emulation, and shouldn't hurt. */ + down(&dentry->d_inode->i_sem); + + for (i = 0; group->default_groups[i]; i++) { + new_group = group->default_groups[i]; + + ret = create_default_group(group, new_group); + if (ret) + break; + } + + up(&dentry->d_inode->i_sem); + } + + if (ret) + detach_groups(group); + + return ret; +} + +/* + * All of link_obj/unlink_obj/link_group/unlink_group require that + * subsys->su_sem is held. + */ + +static void unlink_obj(struct config_item *item) +{ + struct config_group *group; + + group = item->ci_group; + if (group) { + list_del_init(&item->ci_entry); + + item->ci_group = NULL; + item->ci_parent = NULL; + config_item_put(item); + + config_group_put(group); + } +} + +static void link_obj(struct config_item *parent_item, struct config_item *item) +{ + /* Parent seems redundant with group, but it makes certain + * traversals much nicer. */ + item->ci_parent = parent_item; + item->ci_group = config_group_get(to_config_group(parent_item)); + list_add_tail(&item->ci_entry, &item->ci_group->cg_children); + + config_item_get(item); +} + +static void unlink_group(struct config_group *group) +{ + int i; + struct config_group *new_group; + + if (group->default_groups) { + for (i = 0; group->default_groups[i]; i++) { + new_group = group->default_groups[i]; + unlink_group(new_group); + } + } + + group->cg_subsys = NULL; + unlink_obj(&group->cg_item); +} + +static void link_group(struct config_group *parent_group, struct config_group *group) +{ + int i; + struct config_group *new_group; + struct configfs_subsystem *subsys = NULL; /* gcc is a turd */ + + link_obj(&parent_group->cg_item, &group->cg_item); + + if (parent_group->cg_subsys) + subsys = parent_group->cg_subsys; + else if (configfs_is_root(&parent_group->cg_item)) + subsys = to_configfs_subsystem(group); + else + BUG(); + group->cg_subsys = subsys; + + if (group->default_groups) { + for (i = 0; group->default_groups[i]; i++) { + new_group = group->default_groups[i]; + link_group(group, new_group); + } + } +} + +/* + * The goal is that configfs_attach_item() (and + * configfs_attach_group()) can be called from either the VFS or this + * module. That is, they assume that the items have been created, + * the dentry allocated, and the dcache is all ready to go. + * + * If they fail, they must clean up after themselves as if they + * had never been called. The caller (VFS or local function) will + * handle cleaning up the dcache bits. + * + * configfs_detach_group() and configfs_detach_item() behave similarly on + * the way out. They assume that the proper semaphores are held, they + * clean up the configfs items, and they expect their callers will + * handle the dcache bits. + */ +static int configfs_attach_item(struct config_item *parent_item, + struct config_item *item, + struct dentry *dentry) +{ + int ret; + + ret = configfs_create_dir(item, dentry); + if (!ret) { + ret = populate_attrs(item); + if (ret) { + configfs_remove_dir(item); + d_delete(dentry); + } + } + + return ret; +} + +static void configfs_detach_item(struct config_item *item) +{ + detach_attrs(item); + configfs_remove_dir(item); +} + +static int configfs_attach_group(struct config_item *parent_item, + struct config_item *item, + struct dentry *dentry) +{ + int ret; + struct configfs_dirent *sd; + + ret = configfs_attach_item(parent_item, item, dentry); + if (!ret) { + sd = dentry->d_fsdata; + sd->s_type |= CONFIGFS_USET_DIR; + + ret = populate_groups(to_config_group(item)); + if (ret) { + configfs_detach_item(item); + d_delete(dentry); + } + } + + return ret; +} + +static void configfs_detach_group(struct config_item *item) +{ + detach_groups(to_config_group(item)); + configfs_detach_item(item); +} + +/* + * Drop the initial reference from make_item()/make_group() + * This function assumes that reference is held on item + * and that item holds a valid reference to the parent. Also, it + * assumes the caller has validated ci_type. + */ +static void client_drop_item(struct config_item *parent_item, + struct config_item *item) +{ + struct config_item_type *type; + + type = parent_item->ci_type; + BUG_ON(!type); + + if (type->ct_group_ops && type->ct_group_ops->drop_item) + type->ct_group_ops->drop_item(to_config_group(parent_item), + item); + else + config_item_put(item); +} + + +static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) +{ + int ret; + struct config_group *group; + struct config_item *item; + struct config_item *parent_item; + struct configfs_subsystem *subsys; + struct configfs_dirent *sd; + struct config_item_type *type; + struct module *owner; + char *name; + + if (dentry->d_parent == configfs_sb->s_root) + return -EPERM; + + sd = dentry->d_parent->d_fsdata; + if (!(sd->s_type & CONFIGFS_USET_DIR)) + return -EPERM; + + parent_item = configfs_get_config_item(dentry->d_parent); + type = parent_item->ci_type; + subsys = to_config_group(parent_item)->cg_subsys; + BUG_ON(!subsys); + + if (!type || !type->ct_group_ops || + (!type->ct_group_ops->make_group && + !type->ct_group_ops->make_item)) { + config_item_put(parent_item); + return -EPERM; /* What lack-of-mkdir returns */ + } + + name = kmalloc(dentry->d_name.len + 1, GFP_KERNEL); + if (!name) { + config_item_put(parent_item); + return -ENOMEM; + } + snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name); + + down(&subsys->su_sem); + group = NULL; + item = NULL; + if (type->ct_group_ops->make_group) { + group = type->ct_group_ops->make_group(to_config_group(parent_item), name); + if (group) { + link_group(to_config_group(parent_item), group); + item = &group->cg_item; + } + } else { + item = type->ct_group_ops->make_item(to_config_group(parent_item), name); + if (item) + link_obj(parent_item, item); + } + up(&subsys->su_sem); + + kfree(name); + if (!item) { + config_item_put(parent_item); + return -ENOMEM; + } + + ret = -EINVAL; + type = item->ci_type; + if (type) { + owner = type->ct_owner; + if (try_module_get(owner)) { + if (group) { + ret = configfs_attach_group(parent_item, + item, + dentry); + } else { + ret = configfs_attach_item(parent_item, + item, + dentry); + } + + if (ret) { + down(&subsys->su_sem); + if (group) + unlink_group(group); + else + unlink_obj(item); + client_drop_item(parent_item, item); + up(&subsys->su_sem); + + config_item_put(parent_item); + module_put(owner); + } + } + } + + return ret; +} + +static int configfs_rmdir(struct inode *dir, struct dentry *dentry) +{ + struct config_item *parent_item; + struct config_item *item; + struct configfs_subsystem *subsys; + struct configfs_dirent *sd; + struct module *owner = NULL; + int ret; + + if (dentry->d_parent == configfs_sb->s_root) + return -EPERM; + + sd = dentry->d_fsdata; + if (sd->s_type & CONFIGFS_USET_DEFAULT) + return -EPERM; + + parent_item = configfs_get_config_item(dentry->d_parent); + subsys = to_config_group(parent_item)->cg_subsys; + BUG_ON(!subsys); + + if (!parent_item->ci_type) { + config_item_put(parent_item); + return -EINVAL; + } + + ret = configfs_detach_prep(dentry); + if (ret) { + configfs_detach_rollback(dentry); + config_item_put(parent_item); + return ret; + } + + item = configfs_get_config_item(dentry); + + /* Drop reference from above, item already holds one. */ + config_item_put(parent_item); + + if (item->ci_type) + owner = item->ci_type->ct_owner; + + if (sd->s_type & CONFIGFS_USET_DIR) { + configfs_detach_group(item); + + down(&subsys->su_sem); + unlink_group(to_config_group(item)); + } else { + configfs_detach_item(item); + + down(&subsys->su_sem); + unlink_obj(item); + } + + client_drop_item(parent_item, item); + up(&subsys->su_sem); + + /* Drop our reference from above */ + config_item_put(item); + + module_put(owner); + + return 0; +} + +struct inode_operations configfs_dir_inode_operations = { + .mkdir = configfs_mkdir, + .rmdir = configfs_rmdir, + .symlink = configfs_symlink, + .unlink = configfs_unlink, + .lookup = configfs_lookup, +}; + +#if 0 +int configfs_rename_dir(struct config_item * item, const char *new_name) +{ + int error = 0; + struct dentry * new_dentry, * parent; + + if (!strcmp(config_item_name(item), new_name)) + return -EINVAL; + + if (!item->parent) + return -EINVAL; + + down_write(&configfs_rename_sem); + parent = item->parent->dentry; + + down(&parent->d_inode->i_sem); + + new_dentry = lookup_one_len(new_name, parent, strlen(new_name)); + if (!IS_ERR(new_dentry)) { + if (!new_dentry->d_inode) { + error = config_item_set_name(item, "%s", new_name); + if (!error) { + d_add(new_dentry, NULL); + d_move(item->dentry, new_dentry); + } + else + d_delete(new_dentry); + } else + error = -EEXIST; + dput(new_dentry); + } + up(&parent->d_inode->i_sem); + up_write(&configfs_rename_sem); + + return error; +} +#endif + +static int configfs_dir_open(struct inode *inode, struct file *file) +{ + struct dentry * dentry = file->f_dentry; + struct configfs_dirent * parent_sd = dentry->d_fsdata; + + down(&dentry->d_inode->i_sem); + file->private_data = configfs_new_dirent(parent_sd, NULL); + up(&dentry->d_inode->i_sem); + + return file->private_data ? 0 : -ENOMEM; + +} + +static int configfs_dir_close(struct inode *inode, struct file *file) +{ + struct dentry * dentry = file->f_dentry; + struct configfs_dirent * cursor = file->private_data; + + down(&dentry->d_inode->i_sem); + list_del_init(&cursor->s_sibling); + up(&dentry->d_inode->i_sem); + + release_configfs_dirent(cursor); + + return 0; +} + +/* Relationship between s_mode and the DT_xxx types */ +static inline unsigned char dt_type(struct configfs_dirent *sd) +{ + return (sd->s_mode >> 12) & 15; +} + +static int configfs_readdir(struct file * filp, void * dirent, filldir_t filldir) +{ + struct dentry *dentry = filp->f_dentry; + struct configfs_dirent * parent_sd = dentry->d_fsdata; + struct configfs_dirent *cursor = filp->private_data; + struct list_head *p, *q = &cursor->s_sibling; + ino_t ino; + int i = filp->f_pos; + + switch (i) { + case 0: + ino = dentry->d_inode->i_ino; + if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) + break; + filp->f_pos++; + i++; + /* fallthrough */ + case 1: + ino = parent_ino(dentry); + if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0) + break; + filp->f_pos++; + i++; + /* fallthrough */ + default: + if (filp->f_pos == 2) { + list_del(q); + list_add(q, &parent_sd->s_children); + } + for (p=q->next; p!= &parent_sd->s_children; p=p->next) { + struct configfs_dirent *next; + const char * name; + int len; + + next = list_entry(p, struct configfs_dirent, + s_sibling); + if (!next->s_element) + continue; + + name = configfs_get_name(next); + len = strlen(name); + if (next->s_dentry) + ino = next->s_dentry->d_inode->i_ino; + else + ino = iunique(configfs_sb, 2); + + if (filldir(dirent, name, len, filp->f_pos, ino, + dt_type(next)) < 0) + return 0; + + list_del(q); + list_add(q, p); + p = q; + filp->f_pos++; + } + } + return 0; +} + +static loff_t configfs_dir_lseek(struct file * file, loff_t offset, int origin) +{ + struct dentry * dentry = file->f_dentry; + + down(&dentry->d_inode->i_sem); + switch (origin) { + case 1: + offset += file->f_pos; + case 0: + if (offset >= 0) + break; + default: + up(&file->f_dentry->d_inode->i_sem); + return -EINVAL; + } + if (offset != file->f_pos) { + file->f_pos = offset; + if (file->f_pos >= 2) { + struct configfs_dirent *sd = dentry->d_fsdata; + struct configfs_dirent *cursor = file->private_data; + struct list_head *p; + loff_t n = file->f_pos - 2; + + list_del(&cursor->s_sibling); + p = sd->s_children.next; + while (n && p != &sd->s_children) { + struct configfs_dirent *next; + next = list_entry(p, struct configfs_dirent, + s_sibling); + if (next->s_element) + n--; + p = p->next; + } + list_add_tail(&cursor->s_sibling, p); + } + } + up(&dentry->d_inode->i_sem); + return offset; +} + +struct file_operations configfs_dir_operations = { + .open = configfs_dir_open, + .release = configfs_dir_close, + .llseek = configfs_dir_lseek, + .read = generic_read_dir, + .readdir = configfs_readdir, +}; + +int configfs_register_subsystem(struct configfs_subsystem *subsys) +{ + int err; + struct config_group *group = &subsys->su_group; + struct qstr name; + struct dentry *dentry; + struct configfs_dirent *sd; + + err = configfs_pin_fs(); + if (err) + return err; + + if (!group->cg_item.ci_name) + group->cg_item.ci_name = group->cg_item.ci_namebuf; + + sd = configfs_sb->s_root->d_fsdata; + link_group(to_config_group(sd->s_element), group); + + down(&configfs_sb->s_root->d_inode->i_sem); + + name.name = group->cg_item.ci_name; + name.len = strlen(name.name); + name.hash = full_name_hash(name.name, name.len); + + err = -ENOMEM; + dentry = d_alloc(configfs_sb->s_root, &name); + if (!dentry) + goto out_release; + + d_add(dentry, NULL); + + err = configfs_attach_group(sd->s_element, &group->cg_item, + dentry); + if (!err) + dentry = NULL; + else + d_delete(dentry); + + up(&configfs_sb->s_root->d_inode->i_sem); + + if (dentry) { + dput(dentry); +out_release: + unlink_group(group); + configfs_release_fs(); + } + + return err; +} + +void configfs_unregister_subsystem(struct configfs_subsystem *subsys) +{ + struct config_group *group = &subsys->su_group; + struct dentry *dentry = group->cg_item.ci_dentry; + + if (dentry->d_parent != configfs_sb->s_root) { + printk(KERN_ERR "configfs: Tried to unregister non-subsystem!\n"); + return; + } + + down(&configfs_sb->s_root->d_inode->i_sem); + down(&dentry->d_inode->i_sem); + if (configfs_detach_prep(dentry)) { + printk(KERN_ERR "configfs: Tried to unregister non-empty subsystem!\n"); + } + configfs_detach_group(&group->cg_item); + dentry->d_inode->i_flags |= S_DEAD; + up(&dentry->d_inode->i_sem); + + d_delete(dentry); + + up(&configfs_sb->s_root->d_inode->i_sem); + + dput(dentry); + + unlink_group(group); + configfs_release_fs(); +} + +EXPORT_SYMBOL(configfs_register_subsystem); +EXPORT_SYMBOL(configfs_unregister_subsystem); diff --git a/trunk/fs/configfs/file.c b/trunk/fs/configfs/file.c new file mode 100644 index 000000000000..af1ffc9a15c0 --- /dev/null +++ b/trunk/fs/configfs/file.c @@ -0,0 +1,360 @@ +/* -*- mode: c; c-basic-offset: 8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * file.c - operations for regular (text) files. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + */ + +#include +#include +#include +#include +#include +#include + +#include +#include "configfs_internal.h" + + +struct configfs_buffer { + size_t count; + loff_t pos; + char * page; + struct configfs_item_operations * ops; + struct semaphore sem; + int needs_read_fill; +}; + + +/** + * fill_read_buffer - allocate and fill buffer from item. + * @dentry: dentry pointer. + * @buffer: data buffer for file. + * + * Allocate @buffer->page, if it hasn't been already, then call the + * config_item's show() method to fill the buffer with this attribute's + * data. + * This is called only once, on the file's first read. + */ +static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buffer) +{ + struct configfs_attribute * attr = to_attr(dentry); + struct config_item * item = to_item(dentry->d_parent); + struct configfs_item_operations * ops = buffer->ops; + int ret = 0; + ssize_t count; + + if (!buffer->page) + buffer->page = (char *) get_zeroed_page(GFP_KERNEL); + if (!buffer->page) + return -ENOMEM; + + count = ops->show_attribute(item,attr,buffer->page); + buffer->needs_read_fill = 0; + BUG_ON(count > (ssize_t)PAGE_SIZE); + if (count >= 0) + buffer->count = count; + else + ret = count; + return ret; +} + + +/** + * flush_read_buffer - push buffer to userspace. + * @buffer: data buffer for file. + * @userbuf: user-passed buffer. + * @count: number of bytes requested. + * @ppos: file position. + * + * Copy the buffer we filled in fill_read_buffer() to userspace. + * This is done at the reader's leisure, copying and advancing + * the amount they specify each time. + * This may be called continuously until the buffer is empty. + */ +static int flush_read_buffer(struct configfs_buffer * buffer, char __user * buf, + size_t count, loff_t * ppos) +{ + int error; + + if (*ppos > buffer->count) + return 0; + + if (count > (buffer->count - *ppos)) + count = buffer->count - *ppos; + + error = copy_to_user(buf,buffer->page + *ppos,count); + if (!error) + *ppos += count; + return error ? -EFAULT : count; +} + +/** + * configfs_read_file - read an attribute. + * @file: file pointer. + * @buf: buffer to fill. + * @count: number of bytes to read. + * @ppos: starting offset in file. + * + * Userspace wants to read an attribute file. The attribute descriptor + * is in the file's ->d_fsdata. The target item is in the directory's + * ->d_fsdata. + * + * We call fill_read_buffer() to allocate and fill the buffer from the + * item's show() method exactly once (if the read is happening from + * the beginning of the file). That should fill the entire buffer with + * all the data the item has to offer for that attribute. + * We then call flush_read_buffer() to copy the buffer to userspace + * in the increments specified. + */ + +static ssize_t +configfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos) +{ + struct configfs_buffer * buffer = file->private_data; + ssize_t retval = 0; + + down(&buffer->sem); + if (buffer->needs_read_fill) { + if ((retval = fill_read_buffer(file->f_dentry,buffer))) + goto out; + } + pr_debug("%s: count = %d, ppos = %lld, buf = %s\n", + __FUNCTION__,count,*ppos,buffer->page); + retval = flush_read_buffer(buffer,buf,count,ppos); +out: + up(&buffer->sem); + return retval; +} + + +/** + * fill_write_buffer - copy buffer from userspace. + * @buffer: data buffer for file. + * @userbuf: data from user. + * @count: number of bytes in @userbuf. + * + * Allocate @buffer->page if it hasn't been already, then + * copy the user-supplied buffer into it. + */ + +static int +fill_write_buffer(struct configfs_buffer * buffer, const char __user * buf, size_t count) +{ + int error; + + if (!buffer->page) + buffer->page = (char *)get_zeroed_page(GFP_KERNEL); + if (!buffer->page) + return -ENOMEM; + + if (count > PAGE_SIZE) + count = PAGE_SIZE; + error = copy_from_user(buffer->page,buf,count); + buffer->needs_read_fill = 1; + return error ? -EFAULT : count; +} + + +/** + * flush_write_buffer - push buffer to config_item. + * @file: file pointer. + * @buffer: data buffer for file. + * + * Get the correct pointers for the config_item and the attribute we're + * dealing with, then call the store() method for the attribute, + * passing the buffer that we acquired in fill_write_buffer(). + */ + +static int +flush_write_buffer(struct dentry * dentry, struct configfs_buffer * buffer, size_t count) +{ + struct configfs_attribute * attr = to_attr(dentry); + struct config_item * item = to_item(dentry->d_parent); + struct configfs_item_operations * ops = buffer->ops; + + return ops->store_attribute(item,attr,buffer->page,count); +} + + +/** + * configfs_write_file - write an attribute. + * @file: file pointer + * @buf: data to write + * @count: number of bytes + * @ppos: starting offset + * + * Similar to configfs_read_file(), though working in the opposite direction. + * We allocate and fill the data from the user in fill_write_buffer(), + * then push it to the config_item in flush_write_buffer(). + * There is no easy way for us to know if userspace is only doing a partial + * write, so we don't support them. We expect the entire buffer to come + * on the first write. + * Hint: if you're writing a value, first read the file, modify only the + * the value you're changing, then write entire buffer back. + */ + +static ssize_t +configfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos) +{ + struct configfs_buffer * buffer = file->private_data; + + down(&buffer->sem); + count = fill_write_buffer(buffer,buf,count); + if (count > 0) + count = flush_write_buffer(file->f_dentry,buffer,count); + if (count > 0) + *ppos += count; + up(&buffer->sem); + return count; +} + +static int check_perm(struct inode * inode, struct file * file) +{ + struct config_item *item = configfs_get_config_item(file->f_dentry->d_parent); + struct configfs_attribute * attr = to_attr(file->f_dentry); + struct configfs_buffer * buffer; + struct configfs_item_operations * ops = NULL; + int error = 0; + + if (!item || !attr) + goto Einval; + + /* Grab the module reference for this attribute if we have one */ + if (!try_module_get(attr->ca_owner)) { + error = -ENODEV; + goto Done; + } + + if (item->ci_type) + ops = item->ci_type->ct_item_ops; + else + goto Eaccess; + + /* File needs write support. + * The inode's perms must say it's ok, + * and we must have a store method. + */ + if (file->f_mode & FMODE_WRITE) { + + if (!(inode->i_mode & S_IWUGO) || !ops->store_attribute) + goto Eaccess; + + } + + /* File needs read support. + * The inode's perms must say it's ok, and we there + * must be a show method for it. + */ + if (file->f_mode & FMODE_READ) { + if (!(inode->i_mode & S_IRUGO) || !ops->show_attribute) + goto Eaccess; + } + + /* No error? Great, allocate a buffer for the file, and store it + * it in file->private_data for easy access. + */ + buffer = kmalloc(sizeof(struct configfs_buffer),GFP_KERNEL); + if (buffer) { + memset(buffer,0,sizeof(struct configfs_buffer)); + init_MUTEX(&buffer->sem); + buffer->needs_read_fill = 1; + buffer->ops = ops; + file->private_data = buffer; + } else + error = -ENOMEM; + goto Done; + + Einval: + error = -EINVAL; + goto Done; + Eaccess: + error = -EACCES; + module_put(attr->ca_owner); + Done: + if (error && item) + config_item_put(item); + return error; +} + +static int configfs_open_file(struct inode * inode, struct file * filp) +{ + return check_perm(inode,filp); +} + +static int configfs_release(struct inode * inode, struct file * filp) +{ + struct config_item * item = to_item(filp->f_dentry->d_parent); + struct configfs_attribute * attr = to_attr(filp->f_dentry); + struct module * owner = attr->ca_owner; + struct configfs_buffer * buffer = filp->private_data; + + if (item) + config_item_put(item); + /* After this point, attr should not be accessed. */ + module_put(owner); + + if (buffer) { + if (buffer->page) + free_page((unsigned long)buffer->page); + kfree(buffer); + } + return 0; +} + +struct file_operations configfs_file_operations = { + .read = configfs_read_file, + .write = configfs_write_file, + .llseek = generic_file_llseek, + .open = configfs_open_file, + .release = configfs_release, +}; + + +int configfs_add_file(struct dentry * dir, const struct configfs_attribute * attr, int type) +{ + struct configfs_dirent * parent_sd = dir->d_fsdata; + umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG; + int error = 0; + + down(&dir->d_inode->i_sem); + error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode, type); + up(&dir->d_inode->i_sem); + + return error; +} + + +/** + * configfs_create_file - create an attribute file for an item. + * @item: item we're creating for. + * @attr: atrribute descriptor. + */ + +int configfs_create_file(struct config_item * item, const struct configfs_attribute * attr) +{ + BUG_ON(!item || !item->ci_dentry || !attr); + + return configfs_add_file(item->ci_dentry, attr, + CONFIGFS_ITEM_ATTR); +} + diff --git a/trunk/fs/configfs/inode.c b/trunk/fs/configfs/inode.c new file mode 100644 index 000000000000..6b274c6d428f --- /dev/null +++ b/trunk/fs/configfs/inode.c @@ -0,0 +1,162 @@ +/* -*- mode: c; c-basic-offset: 8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * inode.c - basic inode and dentry operations. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + * + * Please see Documentation/filesystems/configfs.txt for more information. + */ + +#undef DEBUG + +#include +#include +#include + +#include +#include "configfs_internal.h" + +extern struct super_block * configfs_sb; + +static struct address_space_operations configfs_aops = { + .readpage = simple_readpage, + .prepare_write = simple_prepare_write, + .commit_write = simple_commit_write +}; + +static struct backing_dev_info configfs_backing_dev_info = { + .ra_pages = 0, /* No readahead */ + .capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK, +}; + +struct inode * configfs_new_inode(mode_t mode) +{ + struct inode * inode = new_inode(configfs_sb); + if (inode) { + inode->i_mode = mode; + inode->i_uid = 0; + inode->i_gid = 0; + inode->i_blksize = PAGE_CACHE_SIZE; + inode->i_blocks = 0; + inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; + inode->i_mapping->a_ops = &configfs_aops; + inode->i_mapping->backing_dev_info = &configfs_backing_dev_info; + } + return inode; +} + +int configfs_create(struct dentry * dentry, int mode, int (*init)(struct inode *)) +{ + int error = 0; + struct inode * inode = NULL; + if (dentry) { + if (!dentry->d_inode) { + if ((inode = configfs_new_inode(mode))) { + if (dentry->d_parent && dentry->d_parent->d_inode) { + struct inode *p_inode = dentry->d_parent->d_inode; + p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME; + } + goto Proceed; + } + else + error = -ENOMEM; + } else + error = -EEXIST; + } else + error = -ENOENT; + goto Done; + + Proceed: + if (init) + error = init(inode); + if (!error) { + d_instantiate(dentry, inode); + if (S_ISDIR(mode) || S_ISLNK(mode)) + dget(dentry); /* pin link and directory dentries in core */ + } else + iput(inode); + Done: + return error; +} + +/* + * Get the name for corresponding element represented by the given configfs_dirent + */ +const unsigned char * configfs_get_name(struct configfs_dirent *sd) +{ + struct attribute * attr; + + if (!sd || !sd->s_element) + BUG(); + + /* These always have a dentry, so use that */ + if (sd->s_type & (CONFIGFS_DIR | CONFIGFS_ITEM_LINK)) + return sd->s_dentry->d_name.name; + + if (sd->s_type & CONFIGFS_ITEM_ATTR) { + attr = sd->s_element; + return attr->name; + } + return NULL; +} + + +/* + * Unhashes the dentry corresponding to given configfs_dirent + * Called with parent inode's i_sem held. + */ +void configfs_drop_dentry(struct configfs_dirent * sd, struct dentry * parent) +{ + struct dentry * dentry = sd->s_dentry; + + if (dentry) { + spin_lock(&dcache_lock); + if (!(d_unhashed(dentry) && dentry->d_inode)) { + dget_locked(dentry); + __d_drop(dentry); + spin_unlock(&dcache_lock); + simple_unlink(parent->d_inode, dentry); + } else + spin_unlock(&dcache_lock); + } +} + +void configfs_hash_and_remove(struct dentry * dir, const char * name) +{ + struct configfs_dirent * sd; + struct configfs_dirent * parent_sd = dir->d_fsdata; + + down(&dir->d_inode->i_sem); + list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { + if (!sd->s_element) + continue; + if (!strcmp(configfs_get_name(sd), name)) { + list_del_init(&sd->s_sibling); + configfs_drop_dentry(sd, dir); + configfs_put(sd); + break; + } + } + up(&dir->d_inode->i_sem); +} + + diff --git a/trunk/fs/configfs/item.c b/trunk/fs/configfs/item.c new file mode 100644 index 000000000000..e07485ac50ad --- /dev/null +++ b/trunk/fs/configfs/item.c @@ -0,0 +1,227 @@ +/* -*- mode: c; c-basic-offset: 8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * item.c - library routines for handling generic config items + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on kobject: + * kobject is Copyright (c) 2002-2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + * + * Please see the file Documentation/filesystems/configfs.txt for + * critical information about using the config_item interface. + */ + +#include +#include +#include +#include + +#include + + +static inline struct config_item * to_item(struct list_head * entry) +{ + return container_of(entry,struct config_item,ci_entry); +} + +/* Evil kernel */ +static void config_item_release(struct kref *kref); + +/** + * config_item_init - initialize item. + * @item: item in question. + */ +void config_item_init(struct config_item * item) +{ + kref_init(&item->ci_kref); + INIT_LIST_HEAD(&item->ci_entry); +} + +/** + * config_item_set_name - Set the name of an item + * @item: item. + * @name: name. + * + * If strlen(name) >= CONFIGFS_ITEM_NAME_LEN, then use a + * dynamically allocated string that @item->ci_name points to. + * Otherwise, use the static @item->ci_namebuf array. + */ + +int config_item_set_name(struct config_item * item, const char * fmt, ...) +{ + int error = 0; + int limit = CONFIGFS_ITEM_NAME_LEN; + int need; + va_list args; + char * name; + + /* + * First, try the static array + */ + va_start(args,fmt); + need = vsnprintf(item->ci_namebuf,limit,fmt,args); + va_end(args); + if (need < limit) + name = item->ci_namebuf; + else { + /* + * Need more space? Allocate it and try again + */ + limit = need + 1; + name = kmalloc(limit,GFP_KERNEL); + if (!name) { + error = -ENOMEM; + goto Done; + } + va_start(args,fmt); + need = vsnprintf(name,limit,fmt,args); + va_end(args); + + /* Still? Give up. */ + if (need >= limit) { + kfree(name); + error = -EFAULT; + goto Done; + } + } + + /* Free the old name, if necessary. */ + if (item->ci_name && item->ci_name != item->ci_namebuf) + kfree(item->ci_name); + + /* Now, set the new name */ + item->ci_name = name; + Done: + return error; +} + +EXPORT_SYMBOL(config_item_set_name); + +void config_item_init_type_name(struct config_item *item, + const char *name, + struct config_item_type *type) +{ + config_item_set_name(item, name); + item->ci_type = type; + config_item_init(item); +} +EXPORT_SYMBOL(config_item_init_type_name); + +void config_group_init_type_name(struct config_group *group, const char *name, + struct config_item_type *type) +{ + config_item_set_name(&group->cg_item, name); + group->cg_item.ci_type = type; + config_group_init(group); +} +EXPORT_SYMBOL(config_group_init_type_name); + +struct config_item * config_item_get(struct config_item * item) +{ + if (item) + kref_get(&item->ci_kref); + return item; +} + +/** + * config_item_cleanup - free config_item resources. + * @item: item. + */ + +void config_item_cleanup(struct config_item * item) +{ + struct config_item_type * t = item->ci_type; + struct config_group * s = item->ci_group; + struct config_item * parent = item->ci_parent; + + pr_debug("config_item %s: cleaning up\n",config_item_name(item)); + if (item->ci_name != item->ci_namebuf) + kfree(item->ci_name); + item->ci_name = NULL; + if (t && t->ct_item_ops && t->ct_item_ops->release) + t->ct_item_ops->release(item); + if (s) + config_group_put(s); + if (parent) + config_item_put(parent); +} + +static void config_item_release(struct kref *kref) +{ + config_item_cleanup(container_of(kref, struct config_item, ci_kref)); +} + +/** + * config_item_put - decrement refcount for item. + * @item: item. + * + * Decrement the refcount, and if 0, call config_item_cleanup(). + */ +void config_item_put(struct config_item * item) +{ + if (item) + kref_put(&item->ci_kref, config_item_release); +} + + +/** + * config_group_init - initialize a group for use + * @k: group + */ + +void config_group_init(struct config_group *group) +{ + config_item_init(&group->cg_item); + INIT_LIST_HEAD(&group->cg_children); +} + + +/** + * config_group_find_obj - search for item in group. + * @group: group we're looking in. + * @name: item's name. + * + * Lock group via @group->cg_subsys, and iterate over @group->cg_list, + * looking for a matching config_item. If matching item is found + * take a reference and return the item. + */ + +struct config_item * config_group_find_obj(struct config_group * group, const char * name) +{ + struct list_head * entry; + struct config_item * ret = NULL; + + /* XXX LOCKING! */ + list_for_each(entry,&group->cg_children) { + struct config_item * item = to_item(entry); + if (config_item_name(item) && + !strcmp(config_item_name(item), name)) { + ret = config_item_get(item); + break; + } + } + return ret; +} + + +EXPORT_SYMBOL(config_item_init); +EXPORT_SYMBOL(config_group_init); +EXPORT_SYMBOL(config_item_get); +EXPORT_SYMBOL(config_item_put); + diff --git a/trunk/fs/configfs/mount.c b/trunk/fs/configfs/mount.c new file mode 100644 index 000000000000..1a2f6f6a4d91 --- /dev/null +++ b/trunk/fs/configfs/mount.c @@ -0,0 +1,159 @@ +/* -*- mode: c; c-basic-offset: 8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * mount.c - operations for initializing and mounting configfs. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + */ + +#include +#include +#include +#include +#include + +#include +#include "configfs_internal.h" + +/* Random magic number */ +#define CONFIGFS_MAGIC 0x62656570 + +struct vfsmount * configfs_mount = NULL; +struct super_block * configfs_sb = NULL; +static int configfs_mnt_count = 0; + +static struct super_operations configfs_ops = { + .statfs = simple_statfs, + .drop_inode = generic_delete_inode, +}; + +static struct config_group configfs_root_group = { + .cg_item = { + .ci_namebuf = "root", + .ci_name = configfs_root_group.cg_item.ci_namebuf, + }, +}; + +int configfs_is_root(struct config_item *item) +{ + return item == &configfs_root_group.cg_item; +} + +static struct configfs_dirent configfs_root = { + .s_sibling = LIST_HEAD_INIT(configfs_root.s_sibling), + .s_children = LIST_HEAD_INIT(configfs_root.s_children), + .s_element = &configfs_root_group.cg_item, + .s_type = CONFIGFS_ROOT, +}; + +static int configfs_fill_super(struct super_block *sb, void *data, int silent) +{ + struct inode *inode; + struct dentry *root; + + sb->s_blocksize = PAGE_CACHE_SIZE; + sb->s_blocksize_bits = PAGE_CACHE_SHIFT; + sb->s_magic = CONFIGFS_MAGIC; + sb->s_op = &configfs_ops; + configfs_sb = sb; + + inode = configfs_new_inode(S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO); + if (inode) { + inode->i_op = &configfs_dir_inode_operations; + inode->i_fop = &configfs_dir_operations; + /* directory inodes start off with i_nlink == 2 (for "." entry) */ + inode->i_nlink++; + } else { + pr_debug("configfs: could not get root inode\n"); + return -ENOMEM; + } + + root = d_alloc_root(inode); + if (!root) { + pr_debug("%s: could not get root dentry!\n",__FUNCTION__); + iput(inode); + return -ENOMEM; + } + config_group_init(&configfs_root_group); + configfs_root_group.cg_item.ci_dentry = root; + root->d_fsdata = &configfs_root; + sb->s_root = root; + return 0; +} + +static struct super_block *configfs_get_sb(struct file_system_type *fs_type, + int flags, const char *dev_name, void *data) +{ + return get_sb_single(fs_type, flags, data, configfs_fill_super); +} + +static struct file_system_type configfs_fs_type = { + .owner = THIS_MODULE, + .name = "configfs", + .get_sb = configfs_get_sb, + .kill_sb = kill_litter_super, +}; + +int configfs_pin_fs(void) +{ + return simple_pin_fs("configfs", &configfs_mount, + &configfs_mnt_count); +} + +void configfs_release_fs(void) +{ + simple_release_fs(&configfs_mount, &configfs_mnt_count); +} + + +static decl_subsys(config, NULL, NULL); + +static int __init configfs_init(void) +{ + int err; + + kset_set_kset_s(&config_subsys, kernel_subsys); + err = subsystem_register(&config_subsys); + if (err) + return err; + + err = register_filesystem(&configfs_fs_type); + if (err) { + printk(KERN_ERR "configfs: Unable to register filesystem!\n"); + subsystem_unregister(&config_subsys); + } + + return err; +} + +static void __exit configfs_exit(void) +{ + unregister_filesystem(&configfs_fs_type); + subsystem_unregister(&config_subsys); +} + +MODULE_AUTHOR("Oracle"); +MODULE_LICENSE("GPL"); +MODULE_VERSION("0.0.1"); +MODULE_DESCRIPTION("Simple RAM filesystem for user driven kernel subsystem configuration."); + +module_init(configfs_init); +module_exit(configfs_exit); diff --git a/trunk/fs/configfs/symlink.c b/trunk/fs/configfs/symlink.c new file mode 100644 index 000000000000..50f5840521a9 --- /dev/null +++ b/trunk/fs/configfs/symlink.c @@ -0,0 +1,281 @@ +/* -*- mode: c; c-basic-offset: 8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * symlink.c - operations for configfs symlinks. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + */ + +#include +#include +#include + +#include +#include "configfs_internal.h" + +static int item_depth(struct config_item * item) +{ + struct config_item * p = item; + int depth = 0; + do { depth++; } while ((p = p->ci_parent) && !configfs_is_root(p)); + return depth; +} + +static int item_path_length(struct config_item * item) +{ + struct config_item * p = item; + int length = 1; + do { + length += strlen(config_item_name(p)) + 1; + p = p->ci_parent; + } while (p && !configfs_is_root(p)); + return length; +} + +static void fill_item_path(struct config_item * item, char * buffer, int length) +{ + struct config_item * p; + + --length; + for (p = item; p && !configfs_is_root(p); p = p->ci_parent) { + int cur = strlen(config_item_name(p)); + + /* back up enough to print this bus id with '/' */ + length -= cur; + strncpy(buffer + length,config_item_name(p),cur); + *(buffer + --length) = '/'; + } +} + +static int create_link(struct config_item *parent_item, + struct config_item *item, + struct dentry *dentry) +{ + struct configfs_dirent *target_sd = item->ci_dentry->d_fsdata; + struct configfs_symlink *sl; + int ret; + + ret = -ENOMEM; + sl = kmalloc(sizeof(struct configfs_symlink), GFP_KERNEL); + if (sl) { + sl->sl_target = config_item_get(item); + /* FIXME: needs a lock, I'd bet */ + list_add(&sl->sl_list, &target_sd->s_links); + ret = configfs_create_link(sl, parent_item->ci_dentry, + dentry); + if (ret) { + list_del_init(&sl->sl_list); + config_item_put(item); + kfree(sl); + } + } + + return ret; +} + + +static int get_target(const char *symname, struct nameidata *nd, + struct config_item **target) +{ + int ret; + + ret = path_lookup(symname, LOOKUP_FOLLOW|LOOKUP_DIRECTORY, nd); + if (!ret) { + if (nd->dentry->d_sb == configfs_sb) { + *target = configfs_get_config_item(nd->dentry); + if (!*target) { + ret = -ENOENT; + path_release(nd); + } + } else + ret = -EPERM; + } + + return ret; +} + + +int configfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) +{ + int ret; + struct nameidata nd; + struct config_item *parent_item; + struct config_item *target_item; + struct config_item_type *type; + + ret = -EPERM; /* What lack-of-symlink returns */ + if (dentry->d_parent == configfs_sb->s_root) + goto out; + + parent_item = configfs_get_config_item(dentry->d_parent); + type = parent_item->ci_type; + + if (!type || !type->ct_item_ops || + !type->ct_item_ops->allow_link) + goto out_put; + + ret = get_target(symname, &nd, &target_item); + if (ret) + goto out_put; + + ret = type->ct_item_ops->allow_link(parent_item, target_item); + if (!ret) + ret = create_link(parent_item, target_item, dentry); + + config_item_put(target_item); + path_release(&nd); + +out_put: + config_item_put(parent_item); + +out: + return ret; +} + +int configfs_unlink(struct inode *dir, struct dentry *dentry) +{ + struct configfs_dirent *sd = dentry->d_fsdata; + struct configfs_symlink *sl; + struct config_item *parent_item; + struct config_item_type *type; + int ret; + + ret = -EPERM; /* What lack-of-symlink returns */ + if (!(sd->s_type & CONFIGFS_ITEM_LINK)) + goto out; + + if (dentry->d_parent == configfs_sb->s_root) + BUG(); + + sl = sd->s_element; + + parent_item = configfs_get_config_item(dentry->d_parent); + type = parent_item->ci_type; + + list_del_init(&sd->s_sibling); + configfs_drop_dentry(sd, dentry->d_parent); + dput(dentry); + configfs_put(sd); + + /* + * drop_link() must be called before + * list_del_init(&sl->sl_list), so that the order of + * drop_link(this, target) and drop_item(target) is preserved. + */ + if (type && type->ct_item_ops && + type->ct_item_ops->drop_link) + type->ct_item_ops->drop_link(parent_item, + sl->sl_target); + + /* FIXME: Needs lock */ + list_del_init(&sl->sl_list); + + /* Put reference from create_link() */ + config_item_put(sl->sl_target); + kfree(sl); + + config_item_put(parent_item); + + ret = 0; + +out: + return ret; +} + +static int configfs_get_target_path(struct config_item * item, struct config_item * target, + char *path) +{ + char * s; + int depth, size; + + depth = item_depth(item); + size = item_path_length(target) + depth * 3 - 1; + if (size > PATH_MAX) + return -ENAMETOOLONG; + + pr_debug("%s: depth = %d, size = %d\n", __FUNCTION__, depth, size); + + for (s = path; depth--; s += 3) + strcpy(s,"../"); + + fill_item_path(target, path, size); + pr_debug("%s: path = '%s'\n", __FUNCTION__, path); + + return 0; +} + +static int configfs_getlink(struct dentry *dentry, char * path) +{ + struct config_item *item, *target_item; + int error = 0; + + item = configfs_get_config_item(dentry->d_parent); + if (!item) + return -EINVAL; + + target_item = configfs_get_config_item(dentry); + if (!target_item) { + config_item_put(item); + return -EINVAL; + } + + down_read(&configfs_rename_sem); + error = configfs_get_target_path(item, target_item, path); + up_read(&configfs_rename_sem); + + config_item_put(item); + config_item_put(target_item); + return error; + +} + +static void *configfs_follow_link(struct dentry *dentry, struct nameidata *nd) +{ + int error = -ENOMEM; + unsigned long page = get_zeroed_page(GFP_KERNEL); + + if (page) { + error = configfs_getlink(dentry, (char *)page); + if (!error) { + nd_set_link(nd, (char *)page); + return (void *)page; + } + } + + nd_set_link(nd, ERR_PTR(error)); + return NULL; +} + +static void configfs_put_link(struct dentry *dentry, struct nameidata *nd, + void *cookie) +{ + if (cookie) { + unsigned long page = (unsigned long)cookie; + free_page(page); + } +} + +struct inode_operations configfs_symlink_inode_operations = { + .follow_link = configfs_follow_link, + .readlink = generic_readlink, + .put_link = configfs_put_link, +}; + diff --git a/trunk/fs/nfs/callback.c b/trunk/fs/nfs/callback.c index 30cae3602867..f2ca782aba33 100644 --- a/trunk/fs/nfs/callback.c +++ b/trunk/fs/nfs/callback.c @@ -14,9 +14,6 @@ #include #include #include - -#include - #include "nfs4_fs.h" #include "callback.h" diff --git a/trunk/fs/ntfs/ChangeLog b/trunk/fs/ntfs/ChangeLog index 02f44094bda9..50a7749cfca1 100644 --- a/trunk/fs/ntfs/ChangeLog +++ b/trunk/fs/ntfs/ChangeLog @@ -884,7 +884,7 @@ ToDo/Notes: - Add handling for initialized_size != data_size in compressed files. - Reduce function local stack usage from 0x3d4 bytes to just noise in - fs/ntfs/upcase.c. (Randy Dunlap ) + fs/ntfs/upcase.c. (Randy Dunlap ) - Remove compiler warnings for newer gcc. - Pages are no longer kmapped by mm/filemap.c::generic_file_write() around calls to ->{prepare,commit}_write. Adapt NTFS appropriately diff --git a/trunk/fs/partitions/check.c b/trunk/fs/partitions/check.c index 7881ce05daef..8dc1822a7022 100644 --- a/trunk/fs/partitions/check.c +++ b/trunk/fs/partitions/check.c @@ -226,7 +226,7 @@ static struct sysfs_ops part_sysfs_ops = { static ssize_t part_uevent_store(struct hd_struct * p, const char *page, size_t count) { - kobject_uevent(&p->kobj, KOBJ_ADD); + kobject_hotplug(&p->kobj, KOBJ_ADD); return count; } static ssize_t part_dev_read(struct hd_struct * p, char *page) @@ -336,31 +336,12 @@ void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len) disk->part[part-1] = p; } -static char *make_block_name(struct gendisk *disk) -{ - char *name; - static char *block_str = "block:"; - int size; - - size = strlen(block_str) + strlen(disk->disk_name) + 1; - name = kmalloc(size, GFP_KERNEL); - if (!name) - return NULL; - strcpy(name, block_str); - strcat(name, disk->disk_name); - return name; -} - static void disk_sysfs_symlinks(struct gendisk *disk) { struct device *target = get_device(disk->driverfs_dev); if (target) { - char *disk_name = make_block_name(disk); sysfs_create_link(&disk->kobj,&target->kobj,"device"); - if (disk_name) { - sysfs_create_link(&target->kobj,&disk->kobj,disk_name); - kfree(disk_name); - } + sysfs_create_link(&target->kobj,&disk->kobj,"block"); } } @@ -379,7 +360,7 @@ void register_disk(struct gendisk *disk) if ((err = kobject_add(&disk->kobj))) return; disk_sysfs_symlinks(disk); - kobject_uevent(&disk->kobj, KOBJ_ADD); + kobject_hotplug(&disk->kobj, KOBJ_ADD); /* No minors to use for partitions */ if (disk->minors == 1) { @@ -480,14 +461,10 @@ void del_gendisk(struct gendisk *disk) devfs_remove_disk(disk); if (disk->driverfs_dev) { - char *disk_name = make_block_name(disk); sysfs_remove_link(&disk->kobj, "device"); - if (disk_name) { - sysfs_remove_link(&disk->driverfs_dev->kobj, disk_name); - kfree(disk_name); - } + sysfs_remove_link(&disk->driverfs_dev->kobj, "block"); put_device(disk->driverfs_dev); } - kobject_uevent(&disk->kobj, KOBJ_REMOVE); + kobject_hotplug(&disk->kobj, KOBJ_REMOVE); kobject_del(&disk->kobj); } diff --git a/trunk/fs/qnx4/bitmap.c b/trunk/fs/qnx4/bitmap.c index 46efbf52cbec..991253927658 100644 --- a/trunk/fs/qnx4/bitmap.c +++ b/trunk/fs/qnx4/bitmap.c @@ -23,12 +23,10 @@ #include #include -#if 0 int qnx4_new_block(struct super_block *sb) { return 0; } -#endif /* 0 */ static void count_bits(register const char *bmPart, register int size, int *const tf) diff --git a/trunk/fs/read_write.c b/trunk/fs/read_write.c index df3468a22fea..a091ee4f430d 100644 --- a/trunk/fs/read_write.c +++ b/trunk/fs/read_write.c @@ -14,7 +14,6 @@ #include #include #include -#include #include #include @@ -183,33 +182,22 @@ asmlinkage long sys_llseek(unsigned int fd, unsigned long offset_high, } #endif -/* - * rw_verify_area doesn't like huge counts. We limit - * them to something that fits in "int" so that others - * won't have to do range checks all the time. - */ -#define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK) int rw_verify_area(int read_write, struct file *file, loff_t *ppos, size_t count) { struct inode *inode; loff_t pos; - if (unlikely((ssize_t) count < 0)) + if (unlikely(count > INT_MAX)) goto Einval; pos = *ppos; if (unlikely((pos < 0) || (loff_t) (pos + count) < 0)) goto Einval; inode = file->f_dentry->d_inode; - if (inode->i_flock && MANDATORY_LOCK(inode)) { - int retval = locks_mandatory_area( - read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE, - inode, file, pos, count); - if (retval < 0) - return retval; - } - return count > MAX_RW_COUNT ? MAX_RW_COUNT : count; + if (inode->i_flock && MANDATORY_LOCK(inode)) + return locks_mandatory_area(read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE, inode, file, pos, count); + return 0; Einval: return -EINVAL; @@ -256,8 +244,7 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos) return -EFAULT; ret = rw_verify_area(READ, file, pos, count); - if (ret >= 0) { - count = ret; + if (!ret) { ret = security_file_permission (file, MAY_READ); if (!ret) { if (file->f_op->read) @@ -308,8 +295,7 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_ return -EFAULT; ret = rw_verify_area(WRITE, file, pos, count); - if (ret >= 0) { - count = ret; + if (!ret) { ret = security_file_permission (file, MAY_WRITE); if (!ret) { if (file->f_op->write) @@ -511,7 +497,7 @@ static ssize_t do_readv_writev(int type, struct file *file, } ret = rw_verify_area(type, file, pos, tot_len); - if (ret < 0) + if (ret) goto out; ret = security_file_permission(file, type == READ ? MAY_READ : MAY_WRITE); if (ret) @@ -667,9 +653,8 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos, if (!(in_file->f_mode & FMODE_PREAD)) goto fput_in; retval = rw_verify_area(READ, in_file, ppos, count); - if (retval < 0) + if (retval) goto fput_in; - count = retval; retval = security_file_permission (in_file, MAY_READ); if (retval) @@ -689,9 +674,8 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos, goto fput_out; out_inode = out_file->f_dentry->d_inode; retval = rw_verify_area(WRITE, out_file, &out_file->f_pos, count); - if (retval < 0) + if (retval) goto fput_out; - count = retval; retval = security_file_permission (out_file, MAY_WRITE); if (retval) diff --git a/trunk/fs/reiserfs/xattr.c b/trunk/fs/reiserfs/xattr.c index 02091eaac0b4..72e120798677 100644 --- a/trunk/fs/reiserfs/xattr.c +++ b/trunk/fs/reiserfs/xattr.c @@ -115,8 +115,8 @@ static struct dentry *__get_xa_root(struct super_block *s) } /* Returns the dentry (or NULL) referring to the root of the extended - * attribute directory tree. If it has already been retrieved, it is used. - * Otherwise, we attempt to retrieve it from disk. It may also return + * attribute directory tree. If it has already been retreived, it is used. + * Otherwise, we attempt to retreive it from disk. It may also return * a pointer-encoded error. */ static inline struct dentry *get_xa_root(struct super_block *s) diff --git a/trunk/fs/super.c b/trunk/fs/super.c index 5a347a4f673a..6689dded3c84 100644 --- a/trunk/fs/super.c +++ b/trunk/fs/super.c @@ -665,6 +665,16 @@ static int test_bdev_super(struct super_block *s, void *data) return (void *)s->s_bdev == data; } +static void bdev_uevent(struct block_device *bdev, enum kobject_action action) +{ + if (bdev->bd_disk) { + if (bdev->bd_part) + kobject_uevent(&bdev->bd_part->kobj, action, NULL); + else + kobject_uevent(&bdev->bd_disk->kobj, action, NULL); + } +} + struct super_block *get_sb_bdev(struct file_system_type *fs_type, int flags, const char *dev_name, void *data, int (*fill_super)(struct super_block *, void *, int)) @@ -707,8 +717,10 @@ struct super_block *get_sb_bdev(struct file_system_type *fs_type, up_write(&s->s_umount); deactivate_super(s); s = ERR_PTR(error); - } else + } else { s->s_flags |= MS_ACTIVE; + bdev_uevent(bdev, KOBJ_MOUNT); + } } return s; @@ -724,6 +736,7 @@ void kill_block_super(struct super_block *sb) { struct block_device *bdev = sb->s_bdev; + bdev_uevent(bdev, KOBJ_UMOUNT); generic_shutdown_super(sb); sync_blockdev(bdev); close_bdev_excl(bdev); diff --git a/trunk/fs/sysfs/dir.c b/trunk/fs/sysfs/dir.c index d36780382176..59734ba1ee60 100644 --- a/trunk/fs/sysfs/dir.c +++ b/trunk/fs/sysfs/dir.c @@ -112,11 +112,7 @@ static int create_dir(struct kobject * k, struct dentry * p, } } if (error && (error != -EEXIST)) { - struct sysfs_dirent *sd = (*d)->d_fsdata; - if (sd) { - list_del_init(&sd->s_sibling); - sysfs_put(sd); - } + sysfs_put((*d)->d_fsdata); d_drop(*d); } dput(*d); diff --git a/trunk/fs/udf/balloc.c b/trunk/fs/udf/balloc.c index 6598a5037ac8..b9ded26b10a9 100644 --- a/trunk/fs/udf/balloc.c +++ b/trunk/fs/udf/balloc.c @@ -4,6 +4,11 @@ * PURPOSE * Block allocation handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/crc.c b/trunk/fs/udf/crc.c index 1b82a4adc2f7..d95c6e38a455 100644 --- a/trunk/fs/udf/crc.c +++ b/trunk/fs/udf/crc.c @@ -14,6 +14,11 @@ * * AT&T gives permission for the free use of the CRC source code. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/dir.c b/trunk/fs/udf/dir.c index f5222527fe39..82440b731142 100644 --- a/trunk/fs/udf/dir.c +++ b/trunk/fs/udf/dir.c @@ -4,6 +4,11 @@ * PURPOSE * Directory handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/directory.c b/trunk/fs/udf/directory.c index fe751a2a0e47..9a61ecc5451b 100644 --- a/trunk/fs/udf/directory.c +++ b/trunk/fs/udf/directory.c @@ -4,6 +4,11 @@ * PURPOSE * Directory related functions * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/file.c b/trunk/fs/udf/file.c index 8a388289040d..01f520c71dc1 100644 --- a/trunk/fs/udf/file.c +++ b/trunk/fs/udf/file.c @@ -4,6 +4,11 @@ * PURPOSE * File handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/fsync.c b/trunk/fs/udf/fsync.c index 5887d78cde43..2dde6b888c2b 100644 --- a/trunk/fs/udf/fsync.c +++ b/trunk/fs/udf/fsync.c @@ -4,6 +4,11 @@ * PURPOSE * Fsync handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/ialloc.c b/trunk/fs/udf/ialloc.c index c9b707b470ca..a7e5d40f1ebc 100644 --- a/trunk/fs/udf/ialloc.c +++ b/trunk/fs/udf/ialloc.c @@ -4,6 +4,11 @@ * PURPOSE * Inode allocation handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/inode.c b/trunk/fs/udf/inode.c index 4014f17d382e..b83890beaaac 100644 --- a/trunk/fs/udf/inode.c +++ b/trunk/fs/udf/inode.c @@ -4,6 +4,11 @@ * PURPOSE * Inode handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/lowlevel.c b/trunk/fs/udf/lowlevel.c index 084216107667..2da5087dfe05 100644 --- a/trunk/fs/udf/lowlevel.c +++ b/trunk/fs/udf/lowlevel.c @@ -4,6 +4,11 @@ * PURPOSE * Low Level Device Routines for the UDF filesystem * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/misc.c b/trunk/fs/udf/misc.c index cc8ca3254db1..fd321f9ace83 100644 --- a/trunk/fs/udf/misc.c +++ b/trunk/fs/udf/misc.c @@ -4,6 +4,11 @@ * PURPOSE * Miscellaneous routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/namei.c b/trunk/fs/udf/namei.c index ca732e79c48b..ac191ed7df0a 100644 --- a/trunk/fs/udf/namei.c +++ b/trunk/fs/udf/namei.c @@ -4,6 +4,11 @@ * PURPOSE * Inode name handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/partition.c b/trunk/fs/udf/partition.c index dabf2b841db8..4d36f264be0d 100644 --- a/trunk/fs/udf/partition.c +++ b/trunk/fs/udf/partition.c @@ -4,6 +4,11 @@ * PURPOSE * Partition handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/super.c b/trunk/fs/udf/super.c index 4a6f49adc609..15bd4f24c5b7 100644 --- a/trunk/fs/udf/super.c +++ b/trunk/fs/udf/super.c @@ -14,6 +14,11 @@ * http://www.ecma.ch/ * http://www.iso.org/ * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/symlink.c b/trunk/fs/udf/symlink.c index 674bb40edc83..43f3051ef756 100644 --- a/trunk/fs/udf/symlink.c +++ b/trunk/fs/udf/symlink.c @@ -4,6 +4,11 @@ * PURPOSE * Symlink handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/truncate.c b/trunk/fs/udf/truncate.c index e1b0e8cfecb4..7dc8a5572ca1 100644 --- a/trunk/fs/udf/truncate.c +++ b/trunk/fs/udf/truncate.c @@ -4,6 +4,11 @@ * PURPOSE * Truncate handling routines for the OSTA-UDF(tm) filesystem. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/fs/udf/unicode.c b/trunk/fs/udf/unicode.c index 706c92e1dcc9..5a80efd8debc 100644 --- a/trunk/fs/udf/unicode.c +++ b/trunk/fs/udf/unicode.c @@ -11,6 +11,11 @@ * UTF-8 is explained in the IETF RFC XXXX. * ftp://ftp.internic.net/rfc/rfcxxxx.txt * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team's mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/include/asm-alpha/bitops.h b/trunk/include/asm-alpha/bitops.h index 302201f1a097..578ed3f1a607 100644 --- a/trunk/include/asm-alpha/bitops.h +++ b/trunk/include/asm-alpha/bitops.h @@ -321,7 +321,6 @@ static inline int fls(int word) #else #define fls generic_fls #endif -#define fls64 generic_fls64 /* Compute powers of two for the given integer. */ static inline long floor_log2(unsigned long word) diff --git a/trunk/include/asm-arm/arch-pxa/ohci.h b/trunk/include/asm-arm/arch-pxa/ohci.h deleted file mode 100644 index 7da89569061e..000000000000 --- a/trunk/include/asm-arm/arch-pxa/ohci.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef ASMARM_ARCH_OHCI_H -#define ASMARM_ARCH_OHCI_H - -struct device; - -struct pxaohci_platform_data { - int (*init)(struct device *); - void (*exit)(struct device *); - - int port_mode; -#define PMM_NPS_MODE 1 -#define PMM_GLOBAL_MODE 2 -#define PMM_PERPORT_MODE 3 -}; - -extern void pxa_set_ohci_info(struct pxaohci_platform_data *info); - -#endif diff --git a/trunk/include/asm-arm/bitops.h b/trunk/include/asm-arm/bitops.h index d02de721ecc1..7399d431edfe 100644 --- a/trunk/include/asm-arm/bitops.h +++ b/trunk/include/asm-arm/bitops.h @@ -332,7 +332,6 @@ static inline unsigned long __ffs(unsigned long word) */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) /* * ffs: find first bit set. This is defined the same way as @@ -352,7 +351,6 @@ static inline unsigned long __ffs(unsigned long word) #define fls(x) \ ( __builtin_constant_p(x) ? generic_fls(x) : \ ({ int __r; asm("clz\t%0, %1" : "=r"(__r) : "r"(x) : "cc"); 32-__r; }) ) -#define fls64(x) generic_fls64(x) #define ffs(x) ({ unsigned long __t = (x); fls(__t & -__t); }) #define __ffs(x) (ffs(x) - 1) #define ffz(x) __ffs( ~(x) ) diff --git a/trunk/include/asm-arm26/bitops.h b/trunk/include/asm-arm26/bitops.h index 15cc6f2da792..7d062fb2e343 100644 --- a/trunk/include/asm-arm26/bitops.h +++ b/trunk/include/asm-arm26/bitops.h @@ -259,7 +259,6 @@ static inline unsigned long __ffs(unsigned long word) */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) /* * ffs: find first bit set. This is defined the same way as diff --git a/trunk/include/asm-cris/bitops.h b/trunk/include/asm-cris/bitops.h index d3eb0f1e4208..1bddb3f3a289 100644 --- a/trunk/include/asm-cris/bitops.h +++ b/trunk/include/asm-cris/bitops.h @@ -240,7 +240,6 @@ static inline int test_bit(int nr, const volatile unsigned long *addr) */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) /* * hweightN - returns the hamming weight of a N-bit word diff --git a/trunk/include/asm-frv/bitops.h b/trunk/include/asm-frv/bitops.h index 02be7b3a8a83..b664bd5b6663 100644 --- a/trunk/include/asm-frv/bitops.h +++ b/trunk/include/asm-frv/bitops.h @@ -228,7 +228,6 @@ static inline int find_next_zero_bit(const void *addr, int size, int offset) \ bit ? 33 - bit : bit; \ }) -#define fls64(x) generic_fls64(x) /* * Every architecture must define this function. It's the fastest diff --git a/trunk/include/asm-generic/bitops.h b/trunk/include/asm-generic/bitops.h index 0e6d9852008c..ce31b739fd80 100644 --- a/trunk/include/asm-generic/bitops.h +++ b/trunk/include/asm-generic/bitops.h @@ -56,7 +56,6 @@ extern __inline__ int test_bit(int nr, const unsigned long * addr) */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #ifdef __KERNEL__ diff --git a/trunk/include/asm-h8300/bitops.h b/trunk/include/asm-h8300/bitops.h index c0411ec9d651..5036f595f8c9 100644 --- a/trunk/include/asm-h8300/bitops.h +++ b/trunk/include/asm-h8300/bitops.h @@ -406,6 +406,5 @@ static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned lon #endif /* __KERNEL__ */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #endif /* _H8300_BITOPS_H */ diff --git a/trunk/include/asm-i386/bitops.h b/trunk/include/asm-i386/bitops.h index 4807aa1d2e3d..ddf1739dc7fd 100644 --- a/trunk/include/asm-i386/bitops.h +++ b/trunk/include/asm-i386/bitops.h @@ -372,7 +372,6 @@ static inline unsigned long ffz(unsigned long word) */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #ifdef __KERNEL__ diff --git a/trunk/include/asm-ia64/bitops.h b/trunk/include/asm-ia64/bitops.h index 36d0fb95ea89..7232528e2d0c 100644 --- a/trunk/include/asm-ia64/bitops.h +++ b/trunk/include/asm-ia64/bitops.h @@ -345,7 +345,6 @@ fls (int t) x |= x >> 16; return ia64_popcnt(x); } -#define fls64(x) generic_fls64(x) /* * ffs: find first bit set. This is defined the same way as the libc and compiler builtin diff --git a/trunk/include/asm-m32r/bitops.h b/trunk/include/asm-m32r/bitops.h index abea2fdd8689..e78443981349 100644 --- a/trunk/include/asm-m32r/bitops.h +++ b/trunk/include/asm-m32r/bitops.h @@ -465,7 +465,6 @@ static __inline__ unsigned long __ffs(unsigned long word) * fls: find last bit set. */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #ifdef __KERNEL__ diff --git a/trunk/include/asm-m68k/bitops.h b/trunk/include/asm-m68k/bitops.h index 13f4c0048463..b1bcf7c66516 100644 --- a/trunk/include/asm-m68k/bitops.h +++ b/trunk/include/asm-m68k/bitops.h @@ -310,7 +310,6 @@ static inline int fls(int x) return 32 - cnt; } -#define fls64(x) generic_fls64(x) /* * Every architecture must define this function. It's the fastest diff --git a/trunk/include/asm-m68knommu/bitops.h b/trunk/include/asm-m68knommu/bitops.h index 4058dd086a02..c42f88a9b9f9 100644 --- a/trunk/include/asm-m68knommu/bitops.h +++ b/trunk/include/asm-m68knommu/bitops.h @@ -499,6 +499,5 @@ static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned lon * fls: find last bit set. */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #endif /* _M68KNOMMU_BITOPS_H */ diff --git a/trunk/include/asm-mips/.gitignore b/trunk/include/asm-mips/.gitignore new file mode 100644 index 000000000000..4ec57ad5bc3c --- /dev/null +++ b/trunk/include/asm-mips/.gitignore @@ -0,0 +1 @@ +asm_offsets.h diff --git a/trunk/include/asm-mips/bitops.h b/trunk/include/asm-mips/bitops.h index 3b0c8aaf6e8b..5496f9064a6a 100644 --- a/trunk/include/asm-mips/bitops.h +++ b/trunk/include/asm-mips/bitops.h @@ -695,7 +695,7 @@ static inline unsigned long fls(unsigned long word) return flz(~word) + 1; } -#define fls64(x) generic_fls64(x) + /* * find_next_zero_bit - find the first zero bit in a memory region diff --git a/trunk/include/asm-parisc/bitops.h b/trunk/include/asm-parisc/bitops.h index 15d8c2b51584..55b98c67fd82 100644 --- a/trunk/include/asm-parisc/bitops.h +++ b/trunk/include/asm-parisc/bitops.h @@ -263,7 +263,6 @@ static __inline__ int fls(int x) return ret; } -#define fls64(x) generic_fls64(x) /* * hweightN: returns the hamming weight (i.e. the number diff --git a/trunk/include/asm-powerpc/bitops.h b/trunk/include/asm-powerpc/bitops.h index 1996eaa8aeae..5727229b0444 100644 --- a/trunk/include/asm-powerpc/bitops.h +++ b/trunk/include/asm-powerpc/bitops.h @@ -310,7 +310,6 @@ static __inline__ int fls(unsigned int x) asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x)); return 32 - lz; } -#define fls64(x) generic_fls64(x) /* * hweightN: returns the hamming weight (i.e. the number diff --git a/trunk/include/asm-s390/bitops.h b/trunk/include/asm-s390/bitops.h index 61232760cc3b..b07c578b22ea 100644 --- a/trunk/include/asm-s390/bitops.h +++ b/trunk/include/asm-s390/bitops.h @@ -839,7 +839,6 @@ static inline int sched_find_first_bit(unsigned long *b) * fls: find last bit set. */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) /* * hweightN: returns the hamming weight (i.e. the number diff --git a/trunk/include/asm-sh/bitops.h b/trunk/include/asm-sh/bitops.h index 1c5260860045..5163d1ff2f1b 100644 --- a/trunk/include/asm-sh/bitops.h +++ b/trunk/include/asm-sh/bitops.h @@ -470,7 +470,6 @@ static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned lon */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #endif /* __KERNEL__ */ diff --git a/trunk/include/asm-sh64/bitops.h b/trunk/include/asm-sh64/bitops.h index ce9c3ad45fe0..e1ff63e09227 100644 --- a/trunk/include/asm-sh64/bitops.h +++ b/trunk/include/asm-sh64/bitops.h @@ -510,7 +510,6 @@ static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned lon #define ffs(x) generic_ffs(x) #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #endif /* __KERNEL__ */ diff --git a/trunk/include/asm-sparc/bitops.h b/trunk/include/asm-sparc/bitops.h index 41722b5e45ef..bfbd795a0a80 100644 --- a/trunk/include/asm-sparc/bitops.h +++ b/trunk/include/asm-sparc/bitops.h @@ -298,7 +298,6 @@ static inline int ffs(int x) * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32. */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) /* * hweightN: returns the hamming weight (i.e. the number diff --git a/trunk/include/asm-sparc64/bitops.h b/trunk/include/asm-sparc64/bitops.h index 6efc0162fb09..6388b8376c50 100644 --- a/trunk/include/asm-sparc64/bitops.h +++ b/trunk/include/asm-sparc64/bitops.h @@ -119,7 +119,6 @@ static inline unsigned long __ffs(unsigned long word) */ #define fls(x) generic_fls(x) -#define fls64(x) generic_fls64(x) #ifdef __KERNEL__ diff --git a/trunk/include/asm-v850/bitops.h b/trunk/include/asm-v850/bitops.h index 8955d2376ac8..b91e799763fd 100644 --- a/trunk/include/asm-v850/bitops.h +++ b/trunk/include/asm-v850/bitops.h @@ -276,7 +276,6 @@ static __inline__ unsigned long find_next_bit(const unsigned long *addr, #define ffs(x) generic_ffs (x) #define fls(x) generic_fls (x) -#define fls64(x) generic_fls64(x) #define __ffs(x) ffs(x) diff --git a/trunk/include/asm-x86_64/bitops.h b/trunk/include/asm-x86_64/bitops.h index a4d5d0909453..05a0d374404b 100644 --- a/trunk/include/asm-x86_64/bitops.h +++ b/trunk/include/asm-x86_64/bitops.h @@ -340,20 +340,6 @@ static __inline__ unsigned long __ffs(unsigned long word) return word; } -/* - * __fls: find last bit set. - * @word: The word to search - * - * Undefined if no zero exists, so code should check against ~0UL first. - */ -static __inline__ unsigned long __fls(unsigned long word) -{ - __asm__("bsrq %1,%0" - :"=r" (word) - :"rm" (word)); - return word; -} - #ifdef __KERNEL__ static inline int sched_find_first_bit(const unsigned long *b) @@ -383,19 +369,6 @@ static __inline__ int ffs(int x) return r+1; } -/** - * fls64 - find last bit set in 64 bit word - * @x: the word to search - * - * This is defined the same way as fls. - */ -static __inline__ int fls64(__u64 x) -{ - if (x == 0) - return 0; - return __fls(x) + 1; -} - /** * hweightN - returns the hamming weight of a N-bit word * @x: the word to weigh diff --git a/trunk/include/asm-xtensa/bitops.h b/trunk/include/asm-xtensa/bitops.h index 0a2065f1a372..e76ee889e21d 100644 --- a/trunk/include/asm-xtensa/bitops.h +++ b/trunk/include/asm-xtensa/bitops.h @@ -245,7 +245,6 @@ static __inline__ int fls (unsigned int x) { return __cntlz(x); } -#define fls64(x) generic_fls64(x) static __inline__ int find_next_bit(const unsigned long *addr, int size, int offset) diff --git a/trunk/include/linux/bio.h b/trunk/include/linux/bio.h index b60ffe32cd21..685fd3720df5 100644 --- a/trunk/include/linux/bio.h +++ b/trunk/include/linux/bio.h @@ -292,8 +292,6 @@ extern struct bio *bio_clone(struct bio *, gfp_t); extern void bio_init(struct bio *); extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int); -extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *, - unsigned int, unsigned int); extern int bio_get_nr_vecs(struct block_device *); extern struct bio *bio_map_user(struct request_queue *, struct block_device *, unsigned long, unsigned int, int); diff --git a/trunk/include/linux/bitops.h b/trunk/include/linux/bitops.h index 6a2a19f14bb2..38c2fb7ebe09 100644 --- a/trunk/include/linux/bitops.h +++ b/trunk/include/linux/bitops.h @@ -76,15 +76,6 @@ static __inline__ int generic_fls(int x) */ #include - -static inline int generic_fls64(__u64 x) -{ - __u32 h = x >> 32; - if (h) - return fls(x) + 32; - return fls(x); -} - static __inline__ int get_bitmask_order(unsigned int count) { int order; diff --git a/trunk/include/linux/blkdev.h b/trunk/include/linux/blkdev.h index a18500d196e1..a33a31e71bbc 100644 --- a/trunk/include/linux/blkdev.h +++ b/trunk/include/linux/blkdev.h @@ -184,7 +184,6 @@ struct request { void *sense; unsigned int timeout; - int retries; /* * For Power Management requests @@ -559,7 +558,6 @@ extern void blk_unregister_queue(struct gendisk *disk); extern void register_disk(struct gendisk *dev); extern void generic_make_request(struct bio *bio); extern void blk_put_request(struct request *); -extern void __blk_put_request(request_queue_t *, struct request *); extern void blk_end_sync_rq(struct request *rq); extern void blk_attempt_remerge(request_queue_t *, struct request *); extern struct request *blk_get_request(request_queue_t *, int, gfp_t); @@ -581,10 +579,6 @@ extern int blk_rq_map_kern(request_queue_t *, struct request *, void *, unsigned extern int blk_rq_map_user_iov(request_queue_t *, struct request *, struct sg_iovec *, int); extern int blk_execute_rq(request_queue_t *, struct gendisk *, struct request *, int); -extern void blk_execute_rq_nowait(request_queue_t *, struct gendisk *, - struct request *, int, - void (*done)(struct request *)); - static inline request_queue_t *bdev_get_queue(struct block_device *bdev) { return bdev->bd_disk->queue; @@ -702,8 +696,7 @@ extern int blkdev_issue_flush(struct block_device *, sector_t *); #define MAX_PHYS_SEGMENTS 128 #define MAX_HW_SEGMENTS 128 -#define SAFE_MAX_SECTORS 255 -#define BLK_DEF_MAX_SECTORS 1024 +#define MAX_SECTORS 255 #define MAX_SEGMENT_SIZE 65536 diff --git a/trunk/include/linux/configfs.h b/trunk/include/linux/configfs.h new file mode 100644 index 000000000000..acffb8c9073a --- /dev/null +++ b/trunk/include/linux/configfs.h @@ -0,0 +1,205 @@ +/* -*- mode: c; c-basic-offset: 8; -*- + * vim: noexpandtab sw=8 ts=8 sts=0: + * + * configfs.h - definitions for the device driver filesystem + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + * + * Based on sysfs: + * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel + * + * Based on kobject.h: + * Copyright (c) 2002-2003 Patrick Mochel + * Copyright (c) 2002-2003 Open Source Development Labs + * + * configfs Copyright (C) 2005 Oracle. All rights reserved. + * + * Please read Documentation/filesystems/configfs.txt before using the + * configfs interface, ESPECIALLY the parts about reference counts and + * item destructors. + */ + +#ifndef _CONFIGFS_H_ +#define _CONFIGFS_H_ + +#ifdef __KERNEL__ + +#include +#include +#include + +#include +#include + +#define CONFIGFS_ITEM_NAME_LEN 20 + +struct module; + +struct configfs_item_operations; +struct configfs_group_operations; +struct configfs_attribute; +struct configfs_subsystem; + +struct config_item { + char *ci_name; + char ci_namebuf[CONFIGFS_ITEM_NAME_LEN]; + struct kref ci_kref; + struct list_head ci_entry; + struct config_item *ci_parent; + struct config_group *ci_group; + struct config_item_type *ci_type; + struct dentry *ci_dentry; +}; + +extern int config_item_set_name(struct config_item *, const char *, ...); + +static inline char *config_item_name(struct config_item * item) +{ + return item->ci_name; +} + +extern void config_item_init(struct config_item *); +extern void config_item_init_type_name(struct config_item *item, + const char *name, + struct config_item_type *type); +extern void config_item_cleanup(struct config_item *); + +extern struct config_item * config_item_get(struct config_item *); +extern void config_item_put(struct config_item *); + +struct config_item_type { + struct module *ct_owner; + struct configfs_item_operations *ct_item_ops; + struct configfs_group_operations *ct_group_ops; + struct configfs_attribute **ct_attrs; +}; + + +/** + * group - a group of config_items of a specific type, belonging + * to a specific subsystem. + */ + +struct config_group { + struct config_item cg_item; + struct list_head cg_children; + struct configfs_subsystem *cg_subsys; + struct config_group **default_groups; +}; + + +extern void config_group_init(struct config_group *group); +extern void config_group_init_type_name(struct config_group *group, + const char *name, + struct config_item_type *type); + + +static inline struct config_group *to_config_group(struct config_item *item) +{ + return item ? container_of(item,struct config_group,cg_item) : NULL; +} + +static inline struct config_group *config_group_get(struct config_group *group) +{ + return group ? to_config_group(config_item_get(&group->cg_item)) : NULL; +} + +static inline void config_group_put(struct config_group *group) +{ + config_item_put(&group->cg_item); +} + +extern struct config_item *config_group_find_obj(struct config_group *, const char *); + + +struct configfs_attribute { + char *ca_name; + struct module *ca_owner; + mode_t ca_mode; +}; + + +/* + * If allow_link() exists, the item can symlink(2) out to other + * items. If the item is a group, it may support mkdir(2). + * Groups supply one of make_group() and make_item(). If the + * group supports make_group(), one can create group children. If it + * supports make_item(), one can create config_item children. If it has + * default_groups on group->default_groups, it has automatically created + * group children. default_groups may coexist alongsize make_group() or + * make_item(), but if the group wishes to have only default_groups + * children (disallowing mkdir(2)), it need not provide either function. + * If the group has commit(), it supports pending and commited (active) + * items. + */ +struct configfs_item_operations { + void (*release)(struct config_item *); + ssize_t (*show_attribute)(struct config_item *, struct configfs_attribute *,char *); + ssize_t (*store_attribute)(struct config_item *,struct configfs_attribute *,const char *, size_t); + int (*allow_link)(struct config_item *src, struct config_item *target); + int (*drop_link)(struct config_item *src, struct config_item *target); +}; + +struct configfs_group_operations { + struct config_item *(*make_item)(struct config_group *group, const char *name); + struct config_group *(*make_group)(struct config_group *group, const char *name); + int (*commit_item)(struct config_item *item); + void (*drop_item)(struct config_group *group, struct config_item *item); +}; + + + +/** + * Use these macros to make defining attributes easier. See include/linux/device.h + * for examples.. + */ + +#if 0 +#define __ATTR(_name,_mode,_show,_store) { \ + .attr = {.ca_name = __stringify(_name), .ca_mode = _mode, .ca_owner = THIS_MODULE }, \ + .show = _show, \ + .store = _store, \ +} + +#define __ATTR_RO(_name) { \ + .attr = { .ca_name = __stringify(_name), .ca_mode = 0444, .ca_owner = THIS_MODULE }, \ + .show = _name##_show, \ +} + +#define __ATTR_NULL { .attr = { .name = NULL } } + +#define attr_name(_attr) (_attr).attr.name +#endif + + +struct configfs_subsystem { + struct config_group su_group; + struct semaphore su_sem; +}; + +static inline struct configfs_subsystem *to_configfs_subsystem(struct config_group *group) +{ + return group ? + container_of(group, struct configfs_subsystem, su_group) : + NULL; +} + +int configfs_register_subsystem(struct configfs_subsystem *subsys); +void configfs_unregister_subsystem(struct configfs_subsystem *subsys); + +#endif /* __KERNEL__ */ + +#endif /* _CONFIGFS_H_ */ diff --git a/trunk/include/linux/cpufreq.h b/trunk/include/linux/cpufreq.h index c31650df9241..d068176b7ad7 100644 --- a/trunk/include/linux/cpufreq.h +++ b/trunk/include/linux/cpufreq.h @@ -256,16 +256,6 @@ int cpufreq_update_policy(unsigned int cpu); /* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */ unsigned int cpufreq_get(unsigned int cpu); -/* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */ -#ifdef CONFIG_CPU_FREQ -unsigned int cpufreq_quick_get(unsigned int cpu); -#else -static inline unsigned int cpufreq_quick_get(unsigned int cpu) -{ - return 0; -} -#endif - /********************************************************************* * CPUFREQ DEFAULT GOVERNOR * diff --git a/trunk/include/linux/dccp.h b/trunk/include/linux/dccp.h index 088529f54965..71fab4311e92 100644 --- a/trunk/include/linux/dccp.h +++ b/trunk/include/linux/dccp.h @@ -192,9 +192,10 @@ enum { #include #include -#include #include +#include #include +#include enum dccp_state { DCCP_OPEN = TCP_ESTABLISHED, @@ -407,6 +408,8 @@ struct dccp_ackvec; * @dccps_gar - greatest valid ack number received on a non-Sync; initialized to %dccps_iss * @dccps_timestamp_time - time of latest TIMESTAMP option * @dccps_timestamp_echo - latest timestamp received on a TIMESTAMP option + * @dccps_ext_header_len - network protocol overhead (IP/IPv6 options) + * @dccps_pmtu_cookie - Last pmtu seen by socket * @dccps_packet_size - Set thru setsockopt * @dccps_role - Role of this sock, one of %dccp_role * @dccps_ndp_count - number of Non Data Packets since last data packet @@ -431,6 +434,8 @@ struct dccp_sock { __u32 dccps_timestamp_echo; __u32 dccps_packet_size; unsigned long dccps_ndp_count; + __u16 dccps_ext_header_len; + __u32 dccps_pmtu_cookie; __u32 dccps_mss_cache; struct dccp_options dccps_options; struct dccp_ackvec *dccps_hc_rx_ackvec; diff --git a/trunk/include/linux/device.h b/trunk/include/linux/device.h index 0cdee78e5ce1..17cbc6db67b4 100644 --- a/trunk/include/linux/device.h +++ b/trunk/include/linux/device.h @@ -47,8 +47,8 @@ struct bus_type { struct driver_attribute * drv_attrs; int (*match)(struct device * dev, struct device_driver * drv); - int (*uevent)(struct device *dev, char **envp, - int num_envp, char *buffer, int buffer_size); + int (*hotplug) (struct device *dev, char **envp, + int num_envp, char *buffer, int buffer_size); int (*suspend)(struct device * dev, pm_message_t state); int (*resume)(struct device * dev); }; @@ -151,7 +151,7 @@ struct class { struct class_attribute * class_attrs; struct class_device_attribute * class_dev_attrs; - int (*uevent)(struct class_device *dev, char **envp, + int (*hotplug)(struct class_device *dev, char **envp, int num_envp, char *buffer, int buffer_size); void (*release)(struct class_device *dev); @@ -209,9 +209,9 @@ extern int class_device_create_file(struct class_device *, * set, this will be called instead of the class specific release function. * Only use this if you want to override the default release function, like * when you are nesting class_device structures. - * @uevent: pointer to a uevent function for this struct class_device. If - * set, this will be called instead of the class specific uevent function. - * Only use this if you want to override the default uevent function, like + * @hotplug: pointer to a hotplug function for this struct class_device. If + * set, this will be called instead of the class specific hotplug function. + * Only use this if you want to override the default hotplug function, like * when you are nesting class_device structures. */ struct class_device { @@ -227,7 +227,7 @@ struct class_device { struct class_device *parent; /* parent of this child device, if there is one */ void (*release)(struct class_device *dev); - int (*uevent)(struct class_device *dev, char **envp, + int (*hotplug)(struct class_device *dev, char **envp, int num_envp, char *buffer, int buffer_size); char class_id[BUS_ID_SIZE]; /* unique to this class */ }; diff --git a/trunk/include/linux/etherdevice.h b/trunk/include/linux/etherdevice.h index 745c988359c0..5f49a30eb6f2 100644 --- a/trunk/include/linux/etherdevice.h +++ b/trunk/include/linux/etherdevice.h @@ -63,11 +63,10 @@ static inline int is_zero_ether_addr(const u8 *addr) * @addr: Pointer to a six-byte array containing the Ethernet address * * Return true if the address is a multicast address. - * By definition the broadcast address is also a multicast address. */ static inline int is_multicast_ether_addr(const u8 *addr) { - return (0x01 & addr[0]); + return ((addr[0] != 0xff) && (0x01 & addr[0])); } /** diff --git a/trunk/include/linux/firmware.h b/trunk/include/linux/firmware.h index 2d716080be4a..2063c0839d4f 100644 --- a/trunk/include/linux/firmware.h +++ b/trunk/include/linux/firmware.h @@ -14,7 +14,7 @@ struct device; int request_firmware(const struct firmware **fw, const char *name, struct device *device); int request_firmware_nowait( - struct module *module, int uevent, + struct module *module, int hotplug, const char *name, struct device *device, void *context, void (*cont)(const struct firmware *fw, void *context)); diff --git a/trunk/include/linux/if_pppox.h b/trunk/include/linux/if_pppox.h index 4fab3d0a4bce..e677f73f13dd 100644 --- a/trunk/include/linux/if_pppox.h +++ b/trunk/include/linux/if_pppox.h @@ -157,7 +157,8 @@ struct pppox_proto { extern int register_pppox_proto(int proto_num, struct pppox_proto *pp); extern void unregister_pppox_proto(int proto_num); extern void pppox_unbind_sock(struct sock *sk);/* delete ppp-channel binding */ -extern int pppox_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg); +extern int pppox_channel_ioctl(struct ppp_channel *pc, unsigned int cmd, + unsigned long arg); /* PPPoX socket states */ enum { diff --git a/trunk/include/linux/input.h b/trunk/include/linux/input.h index 6d4cc3c110d6..3c5823368ddb 100644 --- a/trunk/include/linux/input.h +++ b/trunk/include/linux/input.h @@ -13,7 +13,6 @@ #include #include #include -#include #else #include #include @@ -512,8 +511,6 @@ struct input_absinfo { #define KEY_FN_S 0x1e3 #define KEY_FN_B 0x1e4 -/* We avoid low common keys in module aliases so they don't get huge. */ -#define KEY_MIN_INTERESTING KEY_MUTE #define KEY_MAX 0x1ff /* @@ -796,44 +793,6 @@ struct ff_effect { #define FF_MAX 0x7f -struct input_device_id { - - kernel_ulong_t flags; - - struct input_id id; - - kernel_ulong_t evbit[EV_MAX/BITS_PER_LONG+1]; - kernel_ulong_t keybit[KEY_MAX/BITS_PER_LONG+1]; - kernel_ulong_t relbit[REL_MAX/BITS_PER_LONG+1]; - kernel_ulong_t absbit[ABS_MAX/BITS_PER_LONG+1]; - kernel_ulong_t mscbit[MSC_MAX/BITS_PER_LONG+1]; - kernel_ulong_t ledbit[LED_MAX/BITS_PER_LONG+1]; - kernel_ulong_t sndbit[SND_MAX/BITS_PER_LONG+1]; - kernel_ulong_t ffbit[FF_MAX/BITS_PER_LONG+1]; - kernel_ulong_t swbit[SW_MAX/BITS_PER_LONG+1]; - - kernel_ulong_t driver_info; -}; - -/* - * Structure for hotplug & device<->driver matching. - */ - -#define INPUT_DEVICE_ID_MATCH_BUS 1 -#define INPUT_DEVICE_ID_MATCH_VENDOR 2 -#define INPUT_DEVICE_ID_MATCH_PRODUCT 4 -#define INPUT_DEVICE_ID_MATCH_VERSION 8 - -#define INPUT_DEVICE_ID_MATCH_EVBIT 0x010 -#define INPUT_DEVICE_ID_MATCH_KEYBIT 0x020 -#define INPUT_DEVICE_ID_MATCH_RELBIT 0x040 -#define INPUT_DEVICE_ID_MATCH_ABSBIT 0x080 -#define INPUT_DEVICE_ID_MATCH_MSCIT 0x100 -#define INPUT_DEVICE_ID_MATCH_LEDBIT 0x200 -#define INPUT_DEVICE_ID_MATCH_SNDBIT 0x400 -#define INPUT_DEVICE_ID_MATCH_FFBIT 0x800 -#define INPUT_DEVICE_ID_MATCH_SWBIT 0x1000 - #ifdef __KERNEL__ /* @@ -942,11 +901,49 @@ struct input_dev { }; #define to_input_dev(d) container_of(d, struct input_dev, cdev) +/* + * Structure for hotplug & device<->driver matching. + */ + +#define INPUT_DEVICE_ID_MATCH_BUS 1 +#define INPUT_DEVICE_ID_MATCH_VENDOR 2 +#define INPUT_DEVICE_ID_MATCH_PRODUCT 4 +#define INPUT_DEVICE_ID_MATCH_VERSION 8 + +#define INPUT_DEVICE_ID_MATCH_EVBIT 0x010 +#define INPUT_DEVICE_ID_MATCH_KEYBIT 0x020 +#define INPUT_DEVICE_ID_MATCH_RELBIT 0x040 +#define INPUT_DEVICE_ID_MATCH_ABSBIT 0x080 +#define INPUT_DEVICE_ID_MATCH_MSCIT 0x100 +#define INPUT_DEVICE_ID_MATCH_LEDBIT 0x200 +#define INPUT_DEVICE_ID_MATCH_SNDBIT 0x400 +#define INPUT_DEVICE_ID_MATCH_FFBIT 0x800 +#define INPUT_DEVICE_ID_MATCH_SWBIT 0x1000 + #define INPUT_DEVICE_ID_MATCH_DEVICE\ (INPUT_DEVICE_ID_MATCH_BUS | INPUT_DEVICE_ID_MATCH_VENDOR | INPUT_DEVICE_ID_MATCH_PRODUCT) #define INPUT_DEVICE_ID_MATCH_DEVICE_AND_VERSION\ (INPUT_DEVICE_ID_MATCH_DEVICE | INPUT_DEVICE_ID_MATCH_VERSION) +struct input_device_id { + + unsigned long flags; + + struct input_id id; + + unsigned long evbit[NBITS(EV_MAX)]; + unsigned long keybit[NBITS(KEY_MAX)]; + unsigned long relbit[NBITS(REL_MAX)]; + unsigned long absbit[NBITS(ABS_MAX)]; + unsigned long mscbit[NBITS(MSC_MAX)]; + unsigned long ledbit[NBITS(LED_MAX)]; + unsigned long sndbit[NBITS(SND_MAX)]; + unsigned long ffbit[NBITS(FF_MAX)]; + unsigned long swbit[NBITS(SW_MAX)]; + + unsigned long driver_info; +}; + struct input_handle; struct input_handler { diff --git a/trunk/include/linux/ip.h b/trunk/include/linux/ip.h index 9e2eb9a602eb..33e8a19a1a0f 100644 --- a/trunk/include/linux/ip.h +++ b/trunk/include/linux/ip.h @@ -16,7 +16,6 @@ */ #ifndef _LINUX_IP_H #define _LINUX_IP_H -#include #include #define IPTOS_TOS_MASK 0x1E @@ -79,6 +78,126 @@ #define IPOPT_TS_TSANDADDR 1 /* timestamps and addresses */ #define IPOPT_TS_PRESPEC 3 /* specified modules only */ +#ifdef __KERNEL__ +#include +#include +#include +#include +#include +#include + +struct ip_options { + __u32 faddr; /* Saved first hop address */ + unsigned char optlen; + unsigned char srr; + unsigned char rr; + unsigned char ts; + unsigned char is_setbyuser:1, /* Set by setsockopt? */ + is_data:1, /* Options in __data, rather than skb */ + is_strictroute:1, /* Strict source route */ + srr_is_hit:1, /* Packet destination addr was our one */ + is_changed:1, /* IP checksum more not valid */ + rr_needaddr:1, /* Need to record addr of outgoing dev */ + ts_needtime:1, /* Need to record timestamp */ + ts_needaddr:1; /* Need to record addr of outgoing dev */ + unsigned char router_alert; + unsigned char __pad1; + unsigned char __pad2; + unsigned char __data[0]; +}; + +#define optlength(opt) (sizeof(struct ip_options) + opt->optlen) + +struct inet_request_sock { + struct request_sock req; + u32 loc_addr; + u32 rmt_addr; + u16 rmt_port; + u16 snd_wscale : 4, + rcv_wscale : 4, + tstamp_ok : 1, + sack_ok : 1, + wscale_ok : 1, + ecn_ok : 1, + acked : 1; + struct ip_options *opt; +}; + +static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk) +{ + return (struct inet_request_sock *)sk; +} + +struct ipv6_pinfo; + +struct inet_sock { + /* sk and pinet6 has to be the first two members of inet_sock */ + struct sock sk; +#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) + struct ipv6_pinfo *pinet6; +#endif + /* Socket demultiplex comparisons on incoming packets. */ + __u32 daddr; /* Foreign IPv4 addr */ + __u32 rcv_saddr; /* Bound local IPv4 addr */ + __u16 dport; /* Destination port */ + __u16 num; /* Local port */ + __u32 saddr; /* Sending source */ + __s16 uc_ttl; /* Unicast TTL */ + __u16 cmsg_flags; + struct ip_options *opt; + __u16 sport; /* Source port */ + __u16 id; /* ID counter for DF pkts */ + __u8 tos; /* TOS */ + __u8 mc_ttl; /* Multicasting TTL */ + __u8 pmtudisc; + unsigned recverr : 1, + freebind : 1, + hdrincl : 1, + mc_loop : 1; + int mc_index; /* Multicast device index */ + __u32 mc_addr; + struct ip_mc_socklist *mc_list; /* Group array */ + /* + * Following members are used to retain the infomation to build + * an ip header on each ip fragmentation while the socket is corked. + */ + struct { + unsigned int flags; + unsigned int fragsize; + struct ip_options *opt; + struct rtable *rt; + int length; /* Total length of all frames */ + u32 addr; + struct flowi fl; + } cork; +}; + +#define IPCORK_OPT 1 /* ip-options has been held in ipcork.opt */ +#define IPCORK_ALLFRAG 2 /* always fragment (for ipv6 for now) */ + +static inline struct inet_sock *inet_sk(const struct sock *sk) +{ + return (struct inet_sock *)sk; +} + +static inline void __inet_sk_copy_descendant(struct sock *sk_to, + const struct sock *sk_from, + const int ancestor_size) +{ + memcpy(inet_sk(sk_to) + 1, inet_sk(sk_from) + 1, + sk_from->sk_prot->obj_size - ancestor_size); +} +#if !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) +static inline void inet_sk_copy_descendant(struct sock *sk_to, + const struct sock *sk_from) +{ + __inet_sk_copy_descendant(sk_to, sk_from, sizeof(struct inet_sock)); +} +#endif +#endif + +extern int inet_sk_rebuild_header(struct sock *sk); + struct iphdr { #if defined(__LITTLE_ENDIAN_BITFIELD) __u8 ihl:4, diff --git a/trunk/include/linux/ipv6.h b/trunk/include/linux/ipv6.h index 93bbed5c6cf4..e0b922785d98 100644 --- a/trunk/include/linux/ipv6.h +++ b/trunk/include/linux/ipv6.h @@ -171,13 +171,12 @@ enum { }; #ifdef __KERNEL__ +#include /* struct sockaddr_in6 */ #include +#include /* struct ipv6_mc_socklist */ #include #include -#include /* struct ipv6_mc_socklist */ -#include - /* This structure contains results of exthdrs parsing as offsets from skb->nh. @@ -200,17 +199,18 @@ static inline int inet6_iif(const struct sk_buff *skb) return IP6CB(skb)->iif; } -struct inet6_request_sock { +struct tcp6_request_sock { + struct tcp_request_sock req; struct in6_addr loc_addr; struct in6_addr rmt_addr; struct sk_buff *pktopts; int iif; }; -struct tcp6_request_sock { - struct tcp_request_sock tcp6rsk_tcp; - struct inet6_request_sock tcp6rsk_inet6; -}; +static inline struct tcp6_request_sock *tcp6_rsk(const struct request_sock *sk) +{ + return (struct tcp6_request_sock *)sk; +} /** * struct ipv6_pinfo - ipv6 private area @@ -298,36 +298,12 @@ struct tcp6_sock { struct ipv6_pinfo inet6; }; -extern int inet6_sk_rebuild_header(struct sock *sk); - #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk) { return inet_sk(__sk)->pinet6; } -static inline struct inet6_request_sock * - inet6_rsk(const struct request_sock *rsk) -{ - return (struct inet6_request_sock *)(((u8 *)rsk) + - inet_rsk(rsk)->inet6_rsk_offset); -} - -static inline u32 inet6_rsk_offset(struct request_sock *rsk) -{ - return rsk->rsk_ops->obj_size - sizeof(struct inet6_request_sock); -} - -static inline struct request_sock *inet6_reqsk_alloc(struct request_sock_ops *ops) -{ - struct request_sock *req = reqsk_alloc(ops); - - if (req != NULL) - inet_rsk(req)->inet6_rsk_offset = inet6_rsk_offset(req); - - return req; -} - static inline struct raw6_sock *raw6_sk(const struct sock *sk) { return (struct raw6_sock *)sk; @@ -347,37 +323,28 @@ static inline void inet_sk_copy_descendant(struct sock *sk_to, #define __ipv6_only_sock(sk) (inet6_sk(sk)->ipv6only) #define ipv6_only_sock(sk) ((sk)->sk_family == PF_INET6 && __ipv6_only_sock(sk)) -struct inet6_timewait_sock { - struct in6_addr tw_v6_daddr; - struct in6_addr tw_v6_rcv_saddr; -}; +#include struct tcp6_timewait_sock { - struct tcp_timewait_sock tcp6tw_tcp; - struct inet6_timewait_sock tcp6tw_inet6; + struct tcp_timewait_sock tw_v6_sk; + struct in6_addr tw_v6_daddr; + struct in6_addr tw_v6_rcv_saddr; }; -static inline u16 inet6_tw_offset(const struct proto *prot) +static inline struct tcp6_timewait_sock *tcp6_twsk(const struct sock *sk) { - return prot->twsk_prot->twsk_obj_size - - sizeof(struct inet6_timewait_sock); + return (struct tcp6_timewait_sock *)sk; } -static inline struct inet6_timewait_sock *inet6_twsk(const struct sock *sk) -{ - return (struct inet6_timewait_sock *)(((u8 *)sk) + - inet_twsk(sk)->tw_ipv6_offset); -} - -static inline struct in6_addr *__inet6_rcv_saddr(const struct sock *sk) +static inline struct in6_addr *__tcp_v6_rcv_saddr(const struct sock *sk) { return likely(sk->sk_state != TCP_TIME_WAIT) ? - &inet6_sk(sk)->rcv_saddr : &inet6_twsk(sk)->tw_v6_rcv_saddr; + &inet6_sk(sk)->rcv_saddr : &tcp6_twsk(sk)->tw_v6_rcv_saddr; } -static inline struct in6_addr *inet6_rcv_saddr(const struct sock *sk) +static inline struct in6_addr *tcp_v6_rcv_saddr(const struct sock *sk) { - return sk->sk_family == AF_INET6 ? __inet6_rcv_saddr(sk) : NULL; + return sk->sk_family == AF_INET6 ? __tcp_v6_rcv_saddr(sk) : NULL; } static inline int inet_v6_ipv6only(const struct sock *sk) @@ -394,19 +361,13 @@ static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk) return NULL; } -static inline struct inet6_request_sock * - inet6_rsk(const struct request_sock *rsk) -{ - return NULL; -} - static inline struct raw6_sock *raw6_sk(const struct sock *sk) { return NULL; } -#define __inet6_rcv_saddr(__sk) NULL -#define inet6_rcv_saddr(__sk) NULL +#define __tcp_v6_rcv_saddr(__sk) NULL +#define tcp_v6_rcv_saddr(__sk) NULL #define tcp_twsk_ipv6only(__sk) 0 #define inet_v6_ipv6only(__sk) 0 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */ diff --git a/trunk/include/linux/kobject.h b/trunk/include/linux/kobject.h index 2a8d8da70961..7f7403aa4a41 100644 --- a/trunk/include/linux/kobject.h +++ b/trunk/include/linux/kobject.h @@ -23,27 +23,14 @@ #include #include #include +#include #include #include -#define KOBJ_NAME_LEN 20 -#define UEVENT_HELPER_PATH_LEN 256 +#define KOBJ_NAME_LEN 20 -/* path to the userspace helper executed on an event */ -extern char uevent_helper[]; - -/* counter to tag the uevent, read only except for the kobject core */ -extern u64 uevent_seqnum; - -/* the actions here must match the proper string in lib/kobject_uevent.c */ -typedef int __bitwise kobject_action_t; -enum kobject_action { - KOBJ_ADD = (__force kobject_action_t) 0x01, /* exclusive to core */ - KOBJ_REMOVE = (__force kobject_action_t) 0x02, /* exclusive to core */ - KOBJ_CHANGE = (__force kobject_action_t) 0x03, /* device state change */ - KOBJ_OFFLINE = (__force kobject_action_t) 0x04, /* device offline */ - KOBJ_ONLINE = (__force kobject_action_t) 0x05, /* device online */ -}; +/* counter to tag the hotplug event, read only except for the kobject core */ +extern u64 hotplug_seqnum; struct kobject { const char * k_name; @@ -100,14 +87,15 @@ struct kobj_type { * of object; multiple ksets can belong to one subsystem. All * ksets of a subsystem share the subsystem's lock. * - * Each kset can support specific event variables; it can - * supress the event generation or add subsystem specific - * variables carried with the event. + * Each kset can support hotplugging; if it does, it will be given + * the opportunity to filter out specific kobjects from being + * reported, as well as to add its own "data" elements to the + * environment being passed to the hotplug helper. */ -struct kset_uevent_ops { +struct kset_hotplug_ops { int (*filter)(struct kset *kset, struct kobject *kobj); const char *(*name)(struct kset *kset, struct kobject *kobj); - int (*uevent)(struct kset *kset, struct kobject *kobj, char **envp, + int (*hotplug)(struct kset *kset, struct kobject *kobj, char **envp, int num_envp, char *buffer, int buffer_size); }; @@ -117,7 +105,7 @@ struct kset { struct list_head list; spinlock_t list_lock; struct kobject kobj; - struct kset_uevent_ops * uevent_ops; + struct kset_hotplug_ops * hotplug_ops; }; @@ -165,20 +153,20 @@ struct subsystem { struct rw_semaphore rwsem; }; -#define decl_subsys(_name,_type,_uevent_ops) \ +#define decl_subsys(_name,_type,_hotplug_ops) \ struct subsystem _name##_subsys = { \ .kset = { \ .kobj = { .name = __stringify(_name) }, \ .ktype = _type, \ - .uevent_ops =_uevent_ops, \ + .hotplug_ops =_hotplug_ops, \ } \ } -#define decl_subsys_name(_varname,_name,_type,_uevent_ops) \ +#define decl_subsys_name(_varname,_name,_type,_hotplug_ops) \ struct subsystem _varname##_subsys = { \ .kset = { \ .kobj = { .name = __stringify(_name) }, \ .ktype = _type, \ - .uevent_ops =_uevent_ops, \ + .hotplug_ops =_hotplug_ops, \ } \ } @@ -253,17 +241,15 @@ struct subsys_attribute { extern int subsys_create_file(struct subsystem * , struct subsys_attribute *); extern void subsys_remove_file(struct subsystem * , struct subsys_attribute *); -#if defined(CONFIG_HOTPLUG) & defined(CONFIG_NET) -void kobject_uevent(struct kobject *kobj, enum kobject_action action); - -int add_uevent_var(char **envp, int num_envp, int *cur_index, +#ifdef CONFIG_HOTPLUG +void kobject_hotplug(struct kobject *kobj, enum kobject_action action); +int add_hotplug_env_var(char **envp, int num_envp, int *cur_index, char *buffer, int buffer_size, int *cur_len, const char *format, ...) __attribute__((format (printf, 7, 8))); #else -static inline void kobject_uevent(struct kobject *kobj, enum kobject_action action) { } - -static inline int add_uevent_var(char **envp, int num_envp, int *cur_index, +static inline void kobject_hotplug(struct kobject *kobj, enum kobject_action action) { } +static inline int add_hotplug_env_var(char **envp, int num_envp, int *cur_index, char *buffer, int buffer_size, int *cur_len, const char *format, ...) { return 0; } diff --git a/trunk/include/linux/kobject_uevent.h b/trunk/include/linux/kobject_uevent.h new file mode 100644 index 000000000000..aa664fe7e561 --- /dev/null +++ b/trunk/include/linux/kobject_uevent.h @@ -0,0 +1,57 @@ +/* + * kobject_uevent.h - list of kobject user events that can be generated + * + * Copyright (C) 2004 IBM Corp. + * Copyright (C) 2004 Greg Kroah-Hartman + * + * This file is released under the GPLv2. + * + */ + +#ifndef _KOBJECT_EVENT_H_ +#define _KOBJECT_EVENT_H_ + +#define HOTPLUG_PATH_LEN 256 + +/* path to the hotplug userspace helper executed on an event */ +extern char hotplug_path[]; + +/* + * If you add an action here, you must also add the proper string to the + * lib/kobject_uevent.c file. + */ +typedef int __bitwise kobject_action_t; +enum kobject_action { + KOBJ_ADD = (__force kobject_action_t) 0x01, /* add event, for hotplug */ + KOBJ_REMOVE = (__force kobject_action_t) 0x02, /* remove event, for hotplug */ + KOBJ_CHANGE = (__force kobject_action_t) 0x03, /* a sysfs attribute file has changed */ + KOBJ_MOUNT = (__force kobject_action_t) 0x04, /* mount event for block devices */ + KOBJ_UMOUNT = (__force kobject_action_t) 0x05, /* umount event for block devices */ + KOBJ_OFFLINE = (__force kobject_action_t) 0x06, /* offline event for hotplug devices */ + KOBJ_ONLINE = (__force kobject_action_t) 0x07, /* online event for hotplug devices */ +}; + + +#ifdef CONFIG_KOBJECT_UEVENT +int kobject_uevent(struct kobject *kobj, + enum kobject_action action, + struct attribute *attr); +int kobject_uevent_atomic(struct kobject *kobj, + enum kobject_action action, + struct attribute *attr); +#else +static inline int kobject_uevent(struct kobject *kobj, + enum kobject_action action, + struct attribute *attr) +{ + return 0; +} +static inline int kobject_uevent_atomic(struct kobject *kobj, + enum kobject_action action, + struct attribute *attr) +{ + return 0; +} +#endif + +#endif diff --git a/trunk/include/linux/libata.h b/trunk/include/linux/libata.h index e828e172ccbf..41ea7dbc1755 100644 --- a/trunk/include/linux/libata.h +++ b/trunk/include/linux/libata.h @@ -136,8 +136,6 @@ enum { ATA_TMOUT_BOOT_QUICK = 7 * HZ, /* hueristic */ ATA_TMOUT_CDB = 30 * HZ, ATA_TMOUT_CDB_QUICK = 5 * HZ, - ATA_TMOUT_INTERNAL = 30 * HZ, - ATA_TMOUT_INTERNAL_QUICK = 5 * HZ, /* ATA bus states */ BUS_UNKNOWN = 0, @@ -197,7 +195,7 @@ struct ata_port; struct ata_queued_cmd; /* typedefs */ -typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc); +typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, unsigned int err_mask); struct ata_ioports { unsigned long cmd_addr; @@ -282,10 +280,10 @@ struct ata_queued_cmd { /* DO NOT iterate over __sg manually, use ata_for_each_sg() */ struct scatterlist *__sg; - unsigned int err_mask; - ata_qc_cb_t complete_fn; + struct completion *waiting; + void *private_data; }; @@ -333,6 +331,8 @@ struct ata_port { u8 ctl; /* cache of ATA control register */ u8 last_ctl; /* Cache last written value */ + unsigned int bus_state; + unsigned int port_state; unsigned int pio_mask; unsigned int mwdma_mask; unsigned int udma_mask; @@ -478,7 +478,7 @@ extern void ata_bmdma_start (struct ata_queued_cmd *qc); extern void ata_bmdma_stop(struct ata_queued_cmd *qc); extern u8 ata_bmdma_status(struct ata_port *ap); extern void ata_bmdma_irq_clear(struct ata_port *ap); -extern void ata_qc_complete(struct ata_queued_cmd *qc); +extern void ata_qc_complete(struct ata_queued_cmd *qc, unsigned int err_mask); extern void ata_eng_timeout(struct ata_port *ap); extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)); @@ -670,7 +670,6 @@ static inline void ata_qc_reinit(struct ata_queued_cmd *qc) qc->cursect = qc->cursg = qc->cursg_ofs = 0; qc->nsect = 0; qc->nbytes = qc->curbytes = 0; - qc->err_mask = 0; ata_tf_init(qc->ap, &qc->tf, qc->dev->devno); } diff --git a/trunk/include/linux/net.h b/trunk/include/linux/net.h index 28195a2d8ff0..d6a41e6577f6 100644 --- a/trunk/include/linux/net.h +++ b/trunk/include/linux/net.h @@ -107,7 +107,7 @@ enum sock_type { struct socket { socket_state state; unsigned long flags; - const struct proto_ops *ops; + struct proto_ops *ops; struct fasync_struct *fasync_list; struct file *file; struct sock *sk; @@ -260,7 +260,7 @@ SOCKCALL_WRAP(name, recvmsg, (struct kiocb *iocb, struct socket *sock, struct ms SOCKCALL_WRAP(name, mmap, (struct file *file, struct socket *sock, struct vm_area_struct *vma), \ (file, sock, vma)) \ \ -static const struct proto_ops name##_ops = { \ +static struct proto_ops name##_ops = { \ .family = fam, \ .owner = THIS_MODULE, \ .release = __lock_##name##_release, \ diff --git a/trunk/include/linux/netdevice.h b/trunk/include/linux/netdevice.h index 7fda03d338d1..936f8b76114e 100644 --- a/trunk/include/linux/netdevice.h +++ b/trunk/include/linux/netdevice.h @@ -684,7 +684,6 @@ extern int netif_rx(struct sk_buff *skb); extern int netif_rx_ni(struct sk_buff *skb); #define HAVE_NETIF_RECEIVE_SKB 1 extern int netif_receive_skb(struct sk_buff *skb); -extern int dev_valid_name(const char *name); extern int dev_ioctl(unsigned int cmd, void __user *); extern int dev_ethtool(struct ifreq *); extern unsigned dev_get_flags(const struct net_device *); @@ -802,16 +801,12 @@ static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits) return (1 << debug_value) - 1; } -/* Test if receive needs to be scheduled */ -static inline int __netif_rx_schedule_prep(struct net_device *dev) -{ - return !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state); -} +/* Schedule rx intr now? */ -/* Test if receive needs to be scheduled but only if up */ static inline int netif_rx_schedule_prep(struct net_device *dev) { - return netif_running(dev) && __netif_rx_schedule_prep(dev); + return netif_running(dev) && + !test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state); } /* Add interface to tail of rx poll list. This assumes that _prep has diff --git a/trunk/include/linux/netfilter/nfnetlink_conntrack.h b/trunk/include/linux/netfilter/nfnetlink_conntrack.h index 668ec946c8e2..116fcaced909 100644 --- a/trunk/include/linux/netfilter/nfnetlink_conntrack.h +++ b/trunk/include/linux/netfilter/nfnetlink_conntrack.h @@ -64,9 +64,6 @@ enum ctattr_l4proto { CTA_PROTO_ICMP_ID, CTA_PROTO_ICMP_TYPE, CTA_PROTO_ICMP_CODE, - CTA_PROTO_ICMPV6_ID, - CTA_PROTO_ICMPV6_TYPE, - CTA_PROTO_ICMPV6_CODE, __CTA_PROTO_MAX }; #define CTA_PROTO_MAX (__CTA_PROTO_MAX - 1) @@ -131,4 +128,6 @@ enum ctattr_help { }; #define CTA_HELP_MAX (__CTA_HELP_MAX - 1) +#define CTA_HELP_MAXNAMESIZE 32 + #endif /* _IPCONNTRACK_NETLINK_H */ diff --git a/trunk/include/linux/netfilter_ipv6/ip6_tables.h b/trunk/include/linux/netfilter_ipv6/ip6_tables.h index c163ba31aab7..2efc046d9e94 100644 --- a/trunk/include/linux/netfilter_ipv6/ip6_tables.h +++ b/trunk/include/linux/netfilter_ipv6/ip6_tables.h @@ -474,11 +474,7 @@ extern unsigned int ip6t_do_table(struct sk_buff **pskb, extern int ip6t_ext_hdr(u8 nexthdr); /* find specified header and get offset to it */ extern int ipv6_find_hdr(const struct sk_buff *skb, unsigned int *offset, - int target, unsigned short *fragoff); - -extern int ip6_masked_addrcmp(const struct in6_addr *addr1, - const struct in6_addr *mask, - const struct in6_addr *addr2); + u8 target); #define IP6T_ALIGN(s) (((s) + (__alignof__(struct ip6t_entry)-1)) & ~(__alignof__(struct ip6t_entry)-1)) diff --git a/trunk/include/linux/pci_ids.h b/trunk/include/linux/pci_ids.h index 4f01710485cd..4db67b3b05cc 100644 --- a/trunk/include/linux/pci_ids.h +++ b/trunk/include/linux/pci_ids.h @@ -15,7 +15,6 @@ #define PCI_CLASS_STORAGE_FLOPPY 0x0102 #define PCI_CLASS_STORAGE_IPI 0x0103 #define PCI_CLASS_STORAGE_RAID 0x0104 -#define PCI_CLASS_STORAGE_SAS 0x0107 #define PCI_CLASS_STORAGE_OTHER 0x0180 #define PCI_BASE_CLASS_NETWORK 0x02 @@ -377,10 +376,6 @@ #define PCI_DEVICE_ID_NS_87560_USB 0x0012 #define PCI_DEVICE_ID_NS_83815 0x0020 #define PCI_DEVICE_ID_NS_83820 0x0022 -#define PCI_DEVICE_ID_NS_CS5535_IDE 0x002d -#define PCI_DEVICE_ID_NS_CS5535_AUDIO 0x002e -#define PCI_DEVICE_ID_NS_CS5535_USB 0x002f -#define PCI_DEVICE_ID_NS_CS5535_VIDEO 0x0030 #define PCI_DEVICE_ID_NS_SATURN 0x0035 #define PCI_DEVICE_ID_NS_SCx200_BRIDGE 0x0500 #define PCI_DEVICE_ID_NS_SCx200_SMI 0x0501 diff --git a/trunk/include/linux/pfkeyv2.h b/trunk/include/linux/pfkeyv2.h index 6351c4055ace..724066778aff 100644 --- a/trunk/include/linux/pfkeyv2.h +++ b/trunk/include/linux/pfkeyv2.h @@ -216,16 +216,6 @@ struct sadb_x_nat_t_port { } __attribute__((packed)); /* sizeof(struct sadb_x_nat_t_port) == 8 */ -/* Generic LSM security context */ -struct sadb_x_sec_ctx { - uint16_t sadb_x_sec_len; - uint16_t sadb_x_sec_exttype; - uint8_t sadb_x_ctx_alg; /* LSMs: e.g., selinux == 1 */ - uint8_t sadb_x_ctx_doi; - uint16_t sadb_x_ctx_len; -} __attribute__((packed)); -/* sizeof(struct sadb_sec_ctx) = 8 */ - /* Message types */ #define SADB_RESERVED 0 #define SADB_GETSPI 1 @@ -335,8 +325,7 @@ struct sadb_x_sec_ctx { #define SADB_X_EXT_NAT_T_SPORT 21 #define SADB_X_EXT_NAT_T_DPORT 22 #define SADB_X_EXT_NAT_T_OA 23 -#define SADB_X_EXT_SEC_CTX 24 -#define SADB_EXT_MAX 24 +#define SADB_EXT_MAX 23 /* Identity Extension values */ #define SADB_IDENTTYPE_RESERVED 0 diff --git a/trunk/include/linux/pkt_sched.h b/trunk/include/linux/pkt_sched.h index d10f35338507..e87b233615b3 100644 --- a/trunk/include/linux/pkt_sched.h +++ b/trunk/include/linux/pkt_sched.h @@ -429,7 +429,6 @@ enum TCA_NETEM_CORR, TCA_NETEM_DELAY_DIST, TCA_NETEM_REORDER, - TCA_NETEM_CORRUPT, __TCA_NETEM_MAX, }; @@ -458,12 +457,6 @@ struct tc_netem_reorder __u32 correlation; }; -struct tc_netem_corrupt -{ - __u32 probability; - __u32 correlation; -}; - #define NETEM_DIST_SCALE 8192 #endif diff --git a/trunk/include/linux/platform_device.h b/trunk/include/linux/platform_device.h index 782090c68932..17e336f40b47 100644 --- a/trunk/include/linux/platform_device.h +++ b/trunk/include/linux/platform_device.h @@ -41,7 +41,6 @@ extern struct platform_device *platform_device_alloc(const char *name, unsigned extern int platform_device_add_resources(struct platform_device *pdev, struct resource *res, unsigned int num); extern int platform_device_add_data(struct platform_device *pdev, void *data, size_t size); extern int platform_device_add(struct platform_device *pdev); -extern void platform_device_del(struct platform_device *pdev); extern void platform_device_put(struct platform_device *pdev); struct platform_driver { diff --git a/trunk/include/linux/pnp.h b/trunk/include/linux/pnp.h index 93b0959eb40f..584d57cb393a 100644 --- a/trunk/include/linux/pnp.h +++ b/trunk/include/linux/pnp.h @@ -162,7 +162,6 @@ struct pnp_card_link { struct pnp_card * card; struct pnp_card_driver * driver; void * driver_data; - pm_message_t pm_state; }; static inline void *pnp_get_card_drvdata (struct pnp_card_link *pcard) @@ -295,8 +294,6 @@ struct pnp_driver { unsigned int flags; int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id); void (*remove) (struct pnp_dev *dev); - int (*suspend) (struct pnp_dev *dev, pm_message_t state); - int (*resume) (struct pnp_dev *dev); struct device_driver driver; }; @@ -309,8 +306,6 @@ struct pnp_card_driver { unsigned int flags; int (*probe) (struct pnp_card_link *card, const struct pnp_card_device_id *card_id); void (*remove) (struct pnp_card_link *card); - int (*suspend) (struct pnp_card_link *card, pm_message_t state); - int (*resume) (struct pnp_card_link *card); struct pnp_driver link; }; @@ -385,8 +380,6 @@ void pnp_init_resource_table(struct pnp_resource_table *table); int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode); int pnp_auto_config_dev(struct pnp_dev *dev); int pnp_validate_config(struct pnp_dev *dev); -int pnp_start_dev(struct pnp_dev *dev); -int pnp_stop_dev(struct pnp_dev *dev); int pnp_activate_dev(struct pnp_dev *dev); int pnp_disable_dev(struct pnp_dev *dev); void pnp_resource_change(struct resource *resource, unsigned long start, unsigned long size); @@ -430,8 +423,6 @@ static inline void pnp_init_resource_table(struct pnp_resource_table *table) { } static inline int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode) { return -ENODEV; } static inline int pnp_auto_config_dev(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_validate_config(struct pnp_dev *dev) { return -ENODEV; } -static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; } -static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; } static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; } static inline void pnp_resource_change(struct resource *resource, unsigned long start, unsigned long size) { } diff --git a/trunk/include/linux/random.h b/trunk/include/linux/random.h index 5d6456bcdeba..7b2adb3322d5 100644 --- a/trunk/include/linux/random.h +++ b/trunk/include/linux/random.h @@ -52,9 +52,9 @@ extern void get_random_bytes(void *buf, int nbytes); void generate_random_uuid(unsigned char uuid_out[16]); extern __u32 secure_ip_id(__u32 daddr); -extern u32 secure_ipv4_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport); -extern u32 secure_ipv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, - __u16 dport); +extern u32 secure_tcp_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport); +extern u32 secure_tcpv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, + __u16 dport); extern __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr, __u16 sport, __u16 dport); extern __u32 secure_tcpv6_sequence_number(__u32 *saddr, __u32 *daddr, diff --git a/trunk/include/linux/security.h b/trunk/include/linux/security.h index ef753654daa5..f7e0ae018712 100644 --- a/trunk/include/linux/security.h +++ b/trunk/include/linux/security.h @@ -59,12 +59,6 @@ struct sk_buff; struct sock; struct sockaddr; struct socket; -struct flowi; -struct dst_entry; -struct xfrm_selector; -struct xfrm_policy; -struct xfrm_state; -struct xfrm_user_sec_ctx; extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb); extern int cap_netlink_recv(struct sk_buff *skb); @@ -794,52 +788,6 @@ struct swap_info_struct; * which is used to copy security attributes between local stream sockets. * @sk_free_security: * Deallocate security structure. - * @sk_getsid: - * Retrieve the LSM-specific sid for the sock to enable caching of network - * authorizations. - * - * Security hooks for XFRM operations. - * - * @xfrm_policy_alloc_security: - * @xp contains the xfrm_policy being added to Security Policy Database - * used by the XFRM system. - * @sec_ctx contains the security context information being provided by - * the user-level policy update program (e.g., setkey). - * Allocate a security structure to the xp->selector.security field. - * The security field is initialized to NULL when the xfrm_policy is - * allocated. - * Return 0 if operation was successful (memory to allocate, legal context) - * @xfrm_policy_clone_security: - * @old contains an existing xfrm_policy in the SPD. - * @new contains a new xfrm_policy being cloned from old. - * Allocate a security structure to the new->selector.security field - * that contains the information from the old->selector.security field. - * Return 0 if operation was successful (memory to allocate). - * @xfrm_policy_free_security: - * @xp contains the xfrm_policy - * Deallocate xp->selector.security. - * @xfrm_state_alloc_security: - * @x contains the xfrm_state being added to the Security Association - * Database by the XFRM system. - * @sec_ctx contains the security context information being provided by - * the user-level SA generation program (e.g., setkey or racoon). - * Allocate a security structure to the x->sel.security field. The - * security field is initialized to NULL when the xfrm_state is - * allocated. - * Return 0 if operation was successful (memory to allocate, legal context). - * @xfrm_state_free_security: - * @x contains the xfrm_state. - * Deallocate x>sel.security. - * @xfrm_policy_lookup: - * @xp contains the xfrm_policy for which the access control is being - * checked. - * @sk_sid contains the sock security label that is used to authorize - * access to the policy xp. - * @dir contains the direction of the flow (input or output). - * Check permission when a sock selects a xfrm_policy for processing - * XFRMs on a packet. The hook is called when selecting either a - * per-socket policy or a generic xfrm policy. - * Return 0 if permission is granted. * * Security hooks affecting all Key Management operations * @@ -1289,18 +1237,8 @@ struct security_operations { int (*socket_getpeersec) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len); int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority); void (*sk_free_security) (struct sock *sk); - unsigned int (*sk_getsid) (struct sock *sk, struct flowi *fl, u8 dir); #endif /* CONFIG_SECURITY_NETWORK */ -#ifdef CONFIG_SECURITY_NETWORK_XFRM - int (*xfrm_policy_alloc_security) (struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx); - int (*xfrm_policy_clone_security) (struct xfrm_policy *old, struct xfrm_policy *new); - void (*xfrm_policy_free_security) (struct xfrm_policy *xp); - int (*xfrm_state_alloc_security) (struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx); - void (*xfrm_state_free_security) (struct xfrm_state *x); - int (*xfrm_policy_lookup)(struct xfrm_policy *xp, u32 sk_sid, u8 dir); -#endif /* CONFIG_SECURITY_NETWORK_XFRM */ - /* key management security hooks */ #ifdef CONFIG_KEYS int (*key_alloc)(struct key *key); @@ -2741,11 +2679,6 @@ static inline void security_sk_free(struct sock *sk) { return security_ops->sk_free_security(sk); } - -static inline unsigned int security_sk_sid(struct sock *sk, struct flowi *fl, u8 dir) -{ - return security_ops->sk_getsid(sk, fl, dir); -} #else /* CONFIG_SECURITY_NETWORK */ static inline int security_unix_stream_connect(struct socket * sock, struct socket * other, @@ -2862,73 +2795,8 @@ static inline int security_sk_alloc(struct sock *sk, int family, gfp_t priority) static inline void security_sk_free(struct sock *sk) { } - -static inline unsigned int security_sk_sid(struct sock *sk, struct flowi *fl, u8 dir) -{ - return 0; -} #endif /* CONFIG_SECURITY_NETWORK */ -#ifdef CONFIG_SECURITY_NETWORK_XFRM -static inline int security_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx) -{ - return security_ops->xfrm_policy_alloc_security(xp, sec_ctx); -} - -static inline int security_xfrm_policy_clone(struct xfrm_policy *old, struct xfrm_policy *new) -{ - return security_ops->xfrm_policy_clone_security(old, new); -} - -static inline void security_xfrm_policy_free(struct xfrm_policy *xp) -{ - security_ops->xfrm_policy_free_security(xp); -} - -static inline int security_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx) -{ - return security_ops->xfrm_state_alloc_security(x, sec_ctx); -} - -static inline void security_xfrm_state_free(struct xfrm_state *x) -{ - security_ops->xfrm_state_free_security(x); -} - -static inline int security_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir) -{ - return security_ops->xfrm_policy_lookup(xp, sk_sid, dir); -} -#else /* CONFIG_SECURITY_NETWORK_XFRM */ -static inline int security_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx) -{ - return 0; -} - -static inline int security_xfrm_policy_clone(struct xfrm_policy *old, struct xfrm_policy *new) -{ - return 0; -} - -static inline void security_xfrm_policy_free(struct xfrm_policy *xp) -{ -} - -static inline int security_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx) -{ - return 0; -} - -static inline void security_xfrm_state_free(struct xfrm_state *x) -{ -} - -static inline int security_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir) -{ - return 0; -} -#endif /* CONFIG_SECURITY_NETWORK_XFRM */ - #ifdef CONFIG_KEYS #ifdef CONFIG_SECURITY static inline int security_key_alloc(struct key *key) diff --git a/trunk/include/linux/skbuff.h b/trunk/include/linux/skbuff.h index 483cfc47ec34..8c5d6001a923 100644 --- a/trunk/include/linux/skbuff.h +++ b/trunk/include/linux/skbuff.h @@ -32,6 +32,7 @@ #define HAVE_ALLOC_SKB /* For the drivers to know */ #define HAVE_ALIGNABLE_SKB /* Ditto 8) */ +#define SLAB_SKB /* Slabified skbuffs */ #define CHECKSUM_NONE 0 #define CHECKSUM_HW 1 @@ -133,7 +134,7 @@ struct skb_frag_struct { */ struct skb_shared_info { atomic_t dataref; - unsigned short nr_frags; + unsigned int nr_frags; unsigned short tso_size; unsigned short tso_segs; unsigned short ufo_size; @@ -1238,8 +1239,6 @@ extern int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb, int hlen, struct iovec *iov); extern void skb_free_datagram(struct sock *sk, struct sk_buff *skb); -extern void skb_kill_datagram(struct sock *sk, struct sk_buff *skb, - unsigned int flags); extern unsigned int skb_checksum(const struct sk_buff *skb, int offset, int len, unsigned int csum); extern int skb_copy_bits(const struct sk_buff *skb, int offset, diff --git a/trunk/include/linux/socket.h b/trunk/include/linux/socket.h index 9f4019156fd8..1739c2d5b95b 100644 --- a/trunk/include/linux/socket.h +++ b/trunk/include/linux/socket.h @@ -27,6 +27,7 @@ struct __kernel_sockaddr_storage { #include /* __user */ extern int sysctl_somaxconn; +extern void sock_init(void); #ifdef CONFIG_PROC_FS struct seq_file; extern void socket_seq_show(struct seq_file *seq); diff --git a/trunk/include/linux/spinlock.h b/trunk/include/linux/spinlock.h index 799be6747944..0e9682c9def5 100644 --- a/trunk/include/linux/spinlock.h +++ b/trunk/include/linux/spinlock.h @@ -59,7 +59,8 @@ /* * Must define these before including other files, inline functions need them */ -#define LOCK_SECTION_NAME ".text.lock."KBUILD_BASENAME +#define LOCK_SECTION_NAME \ + ".text.lock." __stringify(KBUILD_BASENAME) #define LOCK_SECTION_START(extra) \ ".subsection 1\n\t" \ diff --git a/trunk/include/linux/sysctl.h b/trunk/include/linux/sysctl.h index a9b80fc7f0f3..4be34ef8c2f7 100644 --- a/trunk/include/linux/sysctl.h +++ b/trunk/include/linux/sysctl.h @@ -124,7 +124,7 @@ enum KERN_OVERFLOWUID=46, /* int: overflow UID */ KERN_OVERFLOWGID=47, /* int: overflow GID */ KERN_SHMPATH=48, /* string: path to shm fs */ - KERN_HOTPLUG=49, /* string: path to uevent helper (deprecated) */ + KERN_HOTPLUG=49, /* string: path to hotplug policy agent */ KERN_IEEE_EMULATION_WARNINGS=50, /* int: unimplemented ieee instructions */ KERN_S390_USER_DEBUG_LOGGING=51, /* int: dumps of user faults */ KERN_CORE_USES_PID=52, /* int: use core or core.%pid */ @@ -390,7 +390,6 @@ enum NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR=109, NET_TCP_CONG_CONTROL=110, NET_TCP_ABC=111, - NET_IPV4_IPFRAG_MAX_DIST=112, }; enum { diff --git a/trunk/include/linux/tcp.h b/trunk/include/linux/tcp.h index f2bb2396853f..0e1da6602e05 100644 --- a/trunk/include/linux/tcp.h +++ b/trunk/include/linux/tcp.h @@ -55,6 +55,22 @@ struct tcphdr { __u16 urg_ptr; }; +#define TCP_ACTION_FIN (1 << 7) + +enum { + TCPF_ESTABLISHED = (1 << 1), + TCPF_SYN_SENT = (1 << 2), + TCPF_SYN_RECV = (1 << 3), + TCPF_FIN_WAIT1 = (1 << 4), + TCPF_FIN_WAIT2 = (1 << 5), + TCPF_TIME_WAIT = (1 << 6), + TCPF_CLOSE = (1 << 7), + TCPF_CLOSE_WAIT = (1 << 8), + TCPF_LAST_ACK = (1 << 9), + TCPF_LISTEN = (1 << 10), + TCPF_CLOSING = (1 << 11) +}; + /* * The union cast uses a gcc extension to avoid aliasing problems * (union is compatible to any of its members) @@ -238,9 +254,10 @@ struct tcp_sock { __u32 snd_wl1; /* Sequence for window update */ __u32 snd_wnd; /* The window we expect to receive */ __u32 max_window; /* Maximal window ever seen from peer */ + __u32 pmtu_cookie; /* Last pmtu seen by socket */ __u32 mss_cache; /* Cached effective mss, not including SACKS */ __u16 xmit_size_goal; /* Goal for segmenting output packets */ - /* XXX Two bytes hole, try to pack */ + __u16 ext_header_len; /* Network protocol overhead (IP/IPv6 options) */ __u32 window_clamp; /* Maximal window to advertise */ __u32 rcv_ssthresh; /* Current window clamp */ @@ -278,6 +295,8 @@ struct tcp_sock { struct sk_buff_head out_of_order_queue; /* Out of order segments go here */ + struct tcp_func *af_specific; /* Operations which are AF_INET{4,6} specific */ + __u32 rcv_wnd; /* Current receiver window */ __u32 rcv_wup; /* rcv_nxt on last window update sent */ __u32 write_seq; /* Tail(+1) of data held in tcp send buffer */ diff --git a/trunk/include/linux/udf_fs.h b/trunk/include/linux/udf_fs.h index 36c684e1b110..46e2bb945353 100644 --- a/trunk/include/linux/udf_fs.h +++ b/trunk/include/linux/udf_fs.h @@ -13,6 +13,11 @@ * http://www.osta.org/ * http://www.ecma.ch/ * http://www.iso.org/ * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/include/linux/udf_fs_i.h b/trunk/include/linux/udf_fs_i.h index 1e7508420fcf..62b15a4214e6 100644 --- a/trunk/include/linux/udf_fs_i.h +++ b/trunk/include/linux/udf_fs_i.h @@ -3,6 +3,11 @@ * * This file is intended for the Linux kernel/module. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/include/linux/udf_fs_sb.h b/trunk/include/linux/udf_fs_sb.h index b15ff2e99c91..1966a6dbb4b6 100644 --- a/trunk/include/linux/udf_fs_sb.h +++ b/trunk/include/linux/udf_fs_sb.h @@ -3,6 +3,11 @@ * * This include file is for the Linux kernel/module. * + * CONTACTS + * E-mail regarding any portion of the Linux UDF file system should be + * directed to the development team mailing list (run by majordomo): + * linux_udf@hpesjro.fc.hp.com + * * COPYRIGHT * This file is distributed under the terms of the GNU General Public * License (GPL). Copies of the GPL can be obtained from: diff --git a/trunk/include/linux/udp.h b/trunk/include/linux/udp.h index 85a55658831c..b60e0b4a25c4 100644 --- a/trunk/include/linux/udp.h +++ b/trunk/include/linux/udp.h @@ -35,10 +35,10 @@ struct udphdr { #define UDP_ENCAP_ESPINUDP 2 /* draft-ietf-ipsec-udp-encaps-06 */ #ifdef __KERNEL__ -#include -#include -#include +#include +#include +#include struct udp_sock { /* inet_sock has to be the first member */ diff --git a/trunk/include/linux/usb.h b/trunk/include/linux/usb.h index 827cc6de5f5c..d81b050e5955 100644 --- a/trunk/include/linux/usb.h +++ b/trunk/include/linux/usb.h @@ -225,7 +225,7 @@ struct usb_interface_cache { * Device drivers should not attempt to activate configurations. The choice * of which configuration to install is a policy decision based on such * considerations as available power, functionality provided, and the user's - * desires (expressed through userspace tools). However, drivers can call + * desires (expressed through hotplug scripts). However, drivers can call * usb_reset_configuration() to reinitialize the current configuration and * all its interfaces. */ @@ -329,6 +329,8 @@ struct usb_device { struct usb_tt *tt; /* low/full speed dev, highspeed hub */ int ttport; /* device port on that tt hub */ + struct semaphore serialize; + unsigned int toggle[2]; /* one bit for each endpoint * ([0] = IN, [1] = OUT) */ @@ -347,9 +349,6 @@ struct usb_device { char **rawdescriptors; /* Raw descriptors for each config */ - unsigned short bus_mA; /* Current available from the bus */ - u8 portnum; /* Parent port number (origin 1) */ - int have_langid; /* whether string_langid is valid */ int string_langid; /* language ID for strings */ @@ -378,12 +377,11 @@ struct usb_device { extern struct usb_device *usb_get_dev(struct usb_device *dev); extern void usb_put_dev(struct usb_device *dev); -/* USB device locking */ -#define usb_lock_device(udev) down(&(udev)->dev.sem) -#define usb_unlock_device(udev) up(&(udev)->dev.sem) -#define usb_trylock_device(udev) down_trylock(&(udev)->dev.sem) +extern void usb_lock_device(struct usb_device *udev); +extern int usb_trylock_device(struct usb_device *udev); extern int usb_lock_device_for_reset(struct usb_device *udev, struct usb_interface *iface); +extern void usb_unlock_device(struct usb_device *udev); /* USB port reset for device reinitialization */ extern int usb_reset_device(struct usb_device *dev); @@ -531,13 +529,10 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, /* ----------------------------------------------------------------------- */ -struct usb_dynids { - spinlock_t lock; - struct list_head list; -}; - /** * struct usb_driver - identifies USB driver to usbcore + * @owner: Pointer to the module owner of this driver; initialize + * it using THIS_MODULE. * @name: The driver name should be unique among USB drivers, * and should normally be the same as the module name. * @probe: Called to see if the driver is willing to manage a particular @@ -558,11 +553,7 @@ struct usb_dynids { * @id_table: USB drivers use ID table to support hotplugging. * Export this with MODULE_DEVICE_TABLE(usb,...). This must be set * or your driver's probe function will never get called. - * @dynids: used internally to hold the list of dynamically added device - * ids for this driver. * @driver: the driver model core driver structure. - * @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be - * added to this driver by preventing the sysfs file from being created. * * USB drivers must provide a name, probe() and disconnect() methods, * and an id_table. Other driver fields are optional. @@ -580,6 +571,8 @@ struct usb_dynids { * them as necessary, and blocking until the unlinks complete). */ struct usb_driver { + struct module *owner; + const char *name; int (*probe) (struct usb_interface *intf, @@ -595,9 +588,7 @@ struct usb_driver { const struct usb_device_id *id_table; - struct usb_dynids dynids; struct device_driver driver; - unsigned int no_dynamic_id:1; }; #define to_usb_driver(d) container_of(d, struct usb_driver, driver) @@ -623,11 +614,7 @@ struct usb_class_driver { * use these in module_init()/module_exit() * and don't forget MODULE_DEVICE_TABLE(usb, ...) */ -int usb_register_driver(struct usb_driver *, struct module *); -static inline int usb_register(struct usb_driver *driver) -{ - return usb_register_driver(driver, THIS_MODULE); -} +extern int usb_register(struct usb_driver *); extern void usb_deregister(struct usb_driver *); extern int usb_register_dev(struct usb_interface *intf, diff --git a/trunk/include/linux/usb_usual.h b/trunk/include/linux/usb_usual.h deleted file mode 100644 index b2d08984a9f7..000000000000 --- a/trunk/include/linux/usb_usual.h +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Interface to the libusual. - * - * Copyright (c) 2005 Pete Zaitcev - * Copyright (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net) - * Copyright (c) 1999 Michael Gee (michael@linuxspecific.com) - */ - -#ifndef __LINUX_USB_USUAL_H -#define __LINUX_USB_USUAL_H - -#include - -/* We should do this for cleanliness... But other usb_foo.h do not do this. */ -/* #include */ - -/* - * The flags field, which we store in usb_device_id.driver_info. - * It is compatible with the old usb-storage flags in lower 24 bits. - */ - -/* - * Static flag definitions. We use this roundabout technique so that the - * proc_info() routine can automatically display a message for each flag. - */ -#define US_DO_ALL_FLAGS \ - US_FLAG(SINGLE_LUN, 0x00000001) \ - /* allow access to only LUN 0 */ \ - US_FLAG(NEED_OVERRIDE, 0x00000002) \ - /* unusual_devs entry is necessary */ \ - US_FLAG(SCM_MULT_TARG, 0x00000004) \ - /* supports multiple targets */ \ - US_FLAG(FIX_INQUIRY, 0x00000008) \ - /* INQUIRY response needs faking */ \ - US_FLAG(FIX_CAPACITY, 0x00000010) \ - /* READ CAPACITY response too big */ \ - US_FLAG(IGNORE_RESIDUE, 0x00000020) \ - /* reported residue is wrong */ \ - US_FLAG(BULK32, 0x00000040) \ - /* Uses 32-byte CBW length */ \ - US_FLAG(NOT_LOCKABLE, 0x00000080) \ - /* PREVENT/ALLOW not supported */ \ - US_FLAG(GO_SLOW, 0x00000100) \ - /* Need delay after Command phase */ \ - US_FLAG(NO_WP_DETECT, 0x00000200) \ - /* Don't check for write-protect */ \ - -#define US_FLAG(name, value) US_FL_##name = value , -enum { US_DO_ALL_FLAGS }; -#undef US_FLAG - -/* - * The bias field for libusual and friends. - */ -#define USB_US_TYPE_NONE 0 -#define USB_US_TYPE_STOR 1 /* usb-storage */ -#define USB_US_TYPE_UB 2 /* ub */ - -#define USB_US_TYPE(flags) (((flags) >> 24) & 0xFF) -#define USB_US_ORIG_FLAGS(flags) ((flags) & 0x00FFFFFF) - -/* - * This is probably not the best place to keep these constants, conceptually. - * But it's the only header included into all places which need them. - */ - -/* Sub Classes */ - -#define US_SC_RBC 0x01 /* Typically, flash devices */ -#define US_SC_8020 0x02 /* CD-ROM */ -#define US_SC_QIC 0x03 /* QIC-157 Tapes */ -#define US_SC_UFI 0x04 /* Floppy */ -#define US_SC_8070 0x05 /* Removable media */ -#define US_SC_SCSI 0x06 /* Transparent */ -#define US_SC_ISD200 0x07 /* ISD200 ATA */ -#define US_SC_MIN US_SC_RBC -#define US_SC_MAX US_SC_ISD200 - -#define US_SC_DEVICE 0xff /* Use device's value */ - -/* Protocols */ - -#define US_PR_CBI 0x00 /* Control/Bulk/Interrupt */ -#define US_PR_CB 0x01 /* Control/Bulk w/o interrupt */ -#define US_PR_BULK 0x50 /* bulk only */ -#ifdef CONFIG_USB_STORAGE_USBAT -#define US_PR_USBAT 0x80 /* SCM-ATAPI bridge */ -#endif -#ifdef CONFIG_USB_STORAGE_SDDR09 -#define US_PR_EUSB_SDDR09 0x81 /* SCM-SCSI bridge for SDDR-09 */ -#endif -#ifdef CONFIG_USB_STORAGE_SDDR55 -#define US_PR_SDDR55 0x82 /* SDDR-55 (made up) */ -#endif -#define US_PR_DPCM_USB 0xf0 /* Combination CB/SDDR09 */ -#ifdef CONFIG_USB_STORAGE_FREECOM -#define US_PR_FREECOM 0xf1 /* Freecom */ -#endif -#ifdef CONFIG_USB_STORAGE_DATAFAB -#define US_PR_DATAFAB 0xf2 /* Datafab chipsets */ -#endif -#ifdef CONFIG_USB_STORAGE_JUMPSHOT -#define US_PR_JUMPSHOT 0xf3 /* Lexar Jumpshot */ -#endif -#ifdef CONFIG_USB_STORAGE_ALAUDA -#define US_PR_ALAUDA 0xf4 /* Alauda chipsets */ -#endif - -#define US_PR_DEVICE 0xff /* Use device's value */ - -/* - */ -#ifdef CONFIG_USB_LIBUSUAL - -extern struct usb_device_id storage_usb_ids[]; -extern void usb_usual_set_present(int type); -extern void usb_usual_clear_present(int type); -extern int usb_usual_check_type(const struct usb_device_id *, int type); -#else - -#define usb_usual_set_present(t) do { } while(0) -#define usb_usual_clear_present(t) do { } while(0) -#define usb_usual_check_type(id, t) (0) -#endif /* CONFIG_USB_LIBUSUAL */ - -#endif /* __LINUX_USB_USUAL_H */ diff --git a/trunk/include/linux/xfrm.h b/trunk/include/linux/xfrm.h index 82fbb758e28f..0fb077d68441 100644 --- a/trunk/include/linux/xfrm.h +++ b/trunk/include/linux/xfrm.h @@ -27,22 +27,6 @@ struct xfrm_id __u8 proto; }; -struct xfrm_sec_ctx { - __u8 ctx_doi; - __u8 ctx_alg; - __u16 ctx_len; - __u32 ctx_sid; - char ctx_str[0]; -}; - -/* Security Context Domains of Interpretation */ -#define XFRM_SC_DOI_RESERVED 0 -#define XFRM_SC_DOI_LSM 1 - -/* Security Context Algorithms */ -#define XFRM_SC_ALG_RESERVED 0 -#define XFRM_SC_ALG_SELINUX 1 - /* Selector, used as selector both on policy rules (SPD) and SAs. */ struct xfrm_selector @@ -162,18 +146,6 @@ enum { #define XFRM_NR_MSGTYPES (XFRM_MSG_MAX + 1 - XFRM_MSG_BASE) -/* - * Generic LSM security context for comunicating to user space - * NOTE: Same format as sadb_x_sec_ctx - */ -struct xfrm_user_sec_ctx { - __u16 len; - __u16 exttype; - __u8 ctx_alg; /* LSMs: e.g., selinux == 1 */ - __u8 ctx_doi; - __u16 ctx_len; -}; - struct xfrm_user_tmpl { struct xfrm_id id; __u16 family; @@ -204,7 +176,6 @@ enum xfrm_attr_type_t { XFRMA_TMPL, /* 1 or more struct xfrm_user_tmpl */ XFRMA_SA, XFRMA_POLICY, - XFRMA_SEC_CTX, /* struct xfrm_sec_ctx */ __XFRMA_MAX #define XFRMA_MAX (__XFRMA_MAX - 1) diff --git a/trunk/include/net/af_unix.h b/trunk/include/net/af_unix.h index bfc1779fc753..b5d785ab4a0e 100644 --- a/trunk/include/net/af_unix.h +++ b/trunk/include/net/af_unix.h @@ -13,7 +13,7 @@ extern void unix_gc(void); #define UNIX_HASH_SIZE 256 extern struct hlist_head unix_socket_table[UNIX_HASH_SIZE + 1]; -extern spinlock_t unix_table_lock; +extern rwlock_t unix_table_lock; extern atomic_t unix_tot_inflight; @@ -58,10 +58,10 @@ struct unix_skb_parms { #define UNIXCB(skb) (*(struct unix_skb_parms*)&((skb)->cb)) #define UNIXCREDS(skb) (&UNIXCB((skb)).creds) -#define unix_state_rlock(s) spin_lock(&unix_sk(s)->lock) -#define unix_state_runlock(s) spin_unlock(&unix_sk(s)->lock) -#define unix_state_wlock(s) spin_lock(&unix_sk(s)->lock) -#define unix_state_wunlock(s) spin_unlock(&unix_sk(s)->lock) +#define unix_state_rlock(s) read_lock(&unix_sk(s)->lock) +#define unix_state_runlock(s) read_unlock(&unix_sk(s)->lock) +#define unix_state_wlock(s) write_lock(&unix_sk(s)->lock) +#define unix_state_wunlock(s) write_unlock(&unix_sk(s)->lock) #ifdef __KERNEL__ /* The AF_UNIX socket */ @@ -76,7 +76,7 @@ struct unix_sock { struct sock *other; struct sock *gc_tree; atomic_t inflight; - spinlock_t lock; + rwlock_t lock; wait_queue_head_t peer_wait; }; #define unix_sk(__sk) ((struct unix_sock *)__sk) diff --git a/trunk/include/net/atmclip.h b/trunk/include/net/atmclip.h index 90fcc98e676f..47048b1d179a 100644 --- a/trunk/include/net/atmclip.h +++ b/trunk/include/net/atmclip.h @@ -7,6 +7,7 @@ #define _ATMCLIP_H #include +#include #include #include #include @@ -17,7 +18,6 @@ #define CLIP_VCC(vcc) ((struct clip_vcc *) ((vcc)->user_back)) #define NEIGH2ENTRY(neigh) ((struct atmarp_entry *) (neigh)->primary_key) -struct sk_buff; struct clip_vcc { struct atm_vcc *vcc; /* VCC descriptor */ diff --git a/trunk/include/net/dst.h b/trunk/include/net/dst.h index bee8b84d329d..6c196a5baf24 100644 --- a/trunk/include/net/dst.h +++ b/trunk/include/net/dst.h @@ -9,7 +9,6 @@ #define _NET_DST_H #include -#include #include #include #include diff --git a/trunk/include/net/flow.h b/trunk/include/net/flow.h index ec7eb86eb203..9a5c94b1a0ec 100644 --- a/trunk/include/net/flow.h +++ b/trunk/include/net/flow.h @@ -84,12 +84,11 @@ struct flowi { #define FLOW_DIR_OUT 1 #define FLOW_DIR_FWD 2 -struct sock; -typedef void (*flow_resolve_t)(struct flowi *key, u32 sk_sid, u16 family, u8 dir, +typedef void (*flow_resolve_t)(struct flowi *key, u16 family, u8 dir, void **objp, atomic_t **obj_refp); -extern void *flow_cache_lookup(struct flowi *key, u32 sk_sid, u16 family, u8 dir, - flow_resolve_t resolver); +extern void *flow_cache_lookup(struct flowi *key, u16 family, u8 dir, + flow_resolve_t resolver); extern void flow_cache_flush(void); extern atomic_t flow_cache_genid; diff --git a/trunk/include/net/genetlink.h b/trunk/include/net/genetlink.h index c5b96b2b8155..52d8b1a73d52 100644 --- a/trunk/include/net/genetlink.h +++ b/trunk/include/net/genetlink.h @@ -60,7 +60,7 @@ struct genl_info */ struct genl_ops { - u8 cmd; + unsigned int cmd; unsigned int flags; struct nla_policy *policy; int (*doit)(struct sk_buff *skb, diff --git a/trunk/include/net/icmp.h b/trunk/include/net/icmp.h index e7c3f20fbafc..6cdebeee5f96 100644 --- a/trunk/include/net/icmp.h +++ b/trunk/include/net/icmp.h @@ -20,9 +20,12 @@ #include #include +#include -#include +#include +#include #include +#include struct icmp_err { int errno; @@ -35,10 +38,6 @@ DECLARE_SNMP_STAT(struct icmp_mib, icmp_statistics); #define ICMP_INC_STATS_BH(field) SNMP_INC_STATS_BH(icmp_statistics, field) #define ICMP_INC_STATS_USER(field) SNMP_INC_STATS_USER(icmp_statistics, field) -struct dst_entry; -struct net_proto_family; -struct sk_buff; - extern void icmp_send(struct sk_buff *skb_in, int type, int code, u32 info); extern int icmp_rcv(struct sk_buff *skb); extern int icmp_ioctl(struct sock *sk, int cmd, unsigned long arg); diff --git a/trunk/include/net/ieee80211_crypt.h b/trunk/include/net/ieee80211_crypt.h index 03b766afdc39..225fc751d464 100644 --- a/trunk/include/net/ieee80211_crypt.h +++ b/trunk/include/net/ieee80211_crypt.h @@ -23,17 +23,12 @@ #ifndef IEEE80211_CRYPT_H #define IEEE80211_CRYPT_H -#include -#include -#include +#include enum { IEEE80211_CRYPTO_TKIP_COUNTERMEASURES = (1 << 0), }; -struct sk_buff; -struct module; - struct ieee80211_crypto_ops { const char *name; struct list_head list; @@ -92,8 +87,6 @@ struct ieee80211_crypt_data { atomic_t refcnt; }; -struct ieee80211_device; - int ieee80211_register_crypto_ops(struct ieee80211_crypto_ops *ops); int ieee80211_unregister_crypto_ops(struct ieee80211_crypto_ops *ops); struct ieee80211_crypto_ops *ieee80211_get_crypto_ops(const char *name); diff --git a/trunk/include/net/inet6_connection_sock.h b/trunk/include/net/inet6_connection_sock.h deleted file mode 100644 index b33b438bffcc..000000000000 --- a/trunk/include/net/inet6_connection_sock.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * NET Generic infrastructure for INET6 connection oriented protocols. - * - * Authors: Many people, see the TCPv6 sources - * - * From code originally in TCPv6 - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version - * 2 of the License, or (at your option) any later version. - */ -#ifndef _INET6_CONNECTION_SOCK_H -#define _INET6_CONNECTION_SOCK_H - -#include - -struct in6_addr; -struct inet_bind_bucket; -struct request_sock; -struct sk_buff; -struct sock; -struct sockaddr; - -extern int inet6_csk_bind_conflict(const struct sock *sk, - const struct inet_bind_bucket *tb); - -extern struct request_sock *inet6_csk_search_req(const struct sock *sk, - struct request_sock ***prevp, - const __u16 rport, - const struct in6_addr *raddr, - const struct in6_addr *laddr, - const int iif); - -extern void inet6_csk_reqsk_queue_hash_add(struct sock *sk, - struct request_sock *req, - const unsigned long timeout); - -extern void inet6_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr); - -extern int inet6_csk_xmit(struct sk_buff *skb, int ipfragok); -#endif /* _INET6_CONNECTION_SOCK_H */ diff --git a/trunk/include/net/inet6_hashtables.h b/trunk/include/net/inet6_hashtables.h index 25f708ff020e..5a2beed5a770 100644 --- a/trunk/include/net/inet6_hashtables.h +++ b/trunk/include/net/inet6_hashtables.h @@ -48,32 +48,6 @@ static inline int inet6_sk_ehashfn(const struct sock *sk) return inet6_ehashfn(laddr, lport, faddr, fport); } -static inline void __inet6_hash(struct inet_hashinfo *hashinfo, - struct sock *sk) -{ - struct hlist_head *list; - rwlock_t *lock; - - BUG_TRAP(sk_unhashed(sk)); - - if (sk->sk_state == TCP_LISTEN) { - list = &hashinfo->listening_hash[inet_sk_listen_hashfn(sk)]; - lock = &hashinfo->lhash_lock; - inet_listen_wlock(hashinfo); - } else { - unsigned int hash; - sk->sk_hash = hash = inet6_sk_ehashfn(sk); - hash &= (hashinfo->ehash_size - 1); - list = &hashinfo->ehash[hash].chain; - lock = &hashinfo->ehash[hash].lock; - write_lock(lock); - } - - __sk_add_node(sk, list); - sock_prot_inc_use(sk->sk_prot); - write_unlock(lock); -} - /* * Sockets in TCP_CLOSE state are _always_ taken out of the hash, so * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM @@ -110,10 +84,10 @@ static inline struct sock * if(*((__u32 *)&(tw->tw_dport)) == ports && sk->sk_family == PF_INET6) { - const struct inet6_timewait_sock *tw6 = inet6_twsk(sk); + const struct tcp6_timewait_sock *tcp6tw = tcp6_twsk(sk); - if (ipv6_addr_equal(&tw6->tw_v6_daddr, saddr) && - ipv6_addr_equal(&tw6->tw_v6_rcv_saddr, daddr) && + if (ipv6_addr_equal(&tcp6tw->tw_v6_daddr, saddr) && + ipv6_addr_equal(&tcp6tw->tw_v6_rcv_saddr, daddr) && (!sk->sk_bound_dev_if || sk->sk_bound_dev_if == dif)) goto hit; } diff --git a/trunk/include/net/inet_common.h b/trunk/include/net/inet_common.h index 227adcbdfec8..f943306ce5ff 100644 --- a/trunk/include/net/inet_common.h +++ b/trunk/include/net/inet_common.h @@ -1,8 +1,8 @@ #ifndef _INET_COMMON_H #define _INET_COMMON_H -extern const struct proto_ops inet_stream_ops; -extern const struct proto_ops inet_dgram_ops; +extern struct proto_ops inet_stream_ops; +extern struct proto_ops inet_dgram_ops; /* * INET4 prototypes used by INET6 diff --git a/trunk/include/net/inet_connection_sock.h b/trunk/include/net/inet_connection_sock.h index 50234fa56a68..b0c99060b78d 100644 --- a/trunk/include/net/inet_connection_sock.h +++ b/trunk/include/net/inet_connection_sock.h @@ -15,11 +15,9 @@ #ifndef _INET_CONNECTION_SOCK_H #define _INET_CONNECTION_SOCK_H -#include +#include #include #include - -#include #include #define INET_CSK_DEBUG 1 @@ -31,29 +29,6 @@ struct inet_bind_bucket; struct inet_hashinfo; struct tcp_congestion_ops; -/* - * Pointers to address related TCP functions - * (i.e. things that depend on the address family) - */ -struct inet_connection_sock_af_ops { - int (*queue_xmit)(struct sk_buff *skb, int ipfragok); - void (*send_check)(struct sock *sk, int len, - struct sk_buff *skb); - int (*rebuild_header)(struct sock *sk); - int (*conn_request)(struct sock *sk, struct sk_buff *skb); - struct sock *(*syn_recv_sock)(struct sock *sk, struct sk_buff *skb, - struct request_sock *req, - struct dst_entry *dst); - int (*remember_stamp)(struct sock *sk); - __u16 net_header_len; - int (*setsockopt)(struct sock *sk, int level, int optname, - char __user *optval, int optlen); - int (*getsockopt)(struct sock *sk, int level, int optname, - char __user *optval, int __user *optlen); - void (*addr2sockaddr)(struct sock *sk, struct sockaddr *); - int sockaddr_len; -}; - /** inet_connection_sock - INET connection oriented sock * * @icsk_accept_queue: FIFO of established children @@ -61,16 +36,13 @@ struct inet_connection_sock_af_ops { * @icsk_timeout: Timeout * @icsk_retransmit_timer: Resend (no ack) * @icsk_rto: Retransmit timeout - * @icsk_pmtu_cookie Last pmtu seen by socket * @icsk_ca_ops Pluggable congestion control hook - * @icsk_af_ops Operations which are AF_INET{4,6} specific * @icsk_ca_state: Congestion control state * @icsk_retransmits: Number of unrecovered [RTO] timeouts * @icsk_pending: Scheduled timer event * @icsk_backoff: Backoff * @icsk_syn_retries: Number of allowed SYN (or equivalent) retries * @icsk_probes_out: unanswered 0 window probes - * @icsk_ext_hdr_len: Network protocol overhead (IP/IPv6 options) * @icsk_ack: Delayed ACK control data */ struct inet_connection_sock { @@ -82,17 +54,14 @@ struct inet_connection_sock { struct timer_list icsk_retransmit_timer; struct timer_list icsk_delack_timer; __u32 icsk_rto; - __u32 icsk_pmtu_cookie; struct tcp_congestion_ops *icsk_ca_ops; - struct inet_connection_sock_af_ops *icsk_af_ops; - unsigned int (*icsk_sync_mss)(struct sock *sk, u32 pmtu); __u8 icsk_ca_state; __u8 icsk_retransmits; __u8 icsk_pending; __u8 icsk_backoff; __u8 icsk_syn_retries; __u8 icsk_probes_out; - __u16 icsk_ext_hdr_len; + /* 2 BYTES HOLE, TRY TO PACK! */ struct { __u8 pending; /* ACK is pending */ __u8 quick; /* Scheduled number of quick acks */ @@ -223,12 +192,8 @@ extern struct request_sock *inet_csk_search_req(const struct sock *sk, const __u16 rport, const __u32 raddr, const __u32 laddr); -extern int inet_csk_bind_conflict(const struct sock *sk, - const struct inet_bind_bucket *tb); extern int inet_csk_get_port(struct inet_hashinfo *hashinfo, - struct sock *sk, unsigned short snum, - int (*bind_conflict)(const struct sock *sk, - const struct inet_bind_bucket *tb)); + struct sock *sk, unsigned short snum); extern struct dst_entry* inet_csk_route_req(struct sock *sk, const struct request_sock *req); @@ -242,7 +207,7 @@ static inline void inet_csk_reqsk_queue_add(struct sock *sk, extern void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req, - unsigned long timeout); + const unsigned timeout); static inline void inet_csk_reqsk_queue_removed(struct sock *sk, struct request_sock *req) @@ -308,6 +273,4 @@ static inline unsigned int inet_csk_listen_poll(const struct sock *sk) extern int inet_csk_listen_start(struct sock *sk, const int nr_table_entries); extern void inet_csk_listen_stop(struct sock *sk); -extern void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr); - #endif /* _INET_CONNECTION_SOCK_H */ diff --git a/trunk/include/net/inet_ecn.h b/trunk/include/net/inet_ecn.h index d599c6bfbb86..b0c47e2eccf1 100644 --- a/trunk/include/net/inet_ecn.h +++ b/trunk/include/net/inet_ecn.h @@ -3,8 +3,6 @@ #include #include - -#include #include enum { diff --git a/trunk/include/net/inet_hashtables.h b/trunk/include/net/inet_hashtables.h index 135d80fd658e..07840baa9341 100644 --- a/trunk/include/net/inet_hashtables.h +++ b/trunk/include/net/inet_hashtables.h @@ -26,7 +26,6 @@ #include #include -#include #include #include #include @@ -129,6 +128,26 @@ struct inet_hashinfo { kmem_cache_t *bind_bucket_cachep; }; +static inline unsigned int inet_ehashfn(const __u32 laddr, const __u16 lport, + const __u32 faddr, const __u16 fport) +{ + unsigned int h = (laddr ^ lport) ^ (faddr ^ fport); + h ^= h >> 16; + h ^= h >> 8; + return h; +} + +static inline int inet_sk_ehashfn(const struct sock *sk) +{ + const struct inet_sock *inet = inet_sk(sk); + const __u32 laddr = inet->rcv_saddr; + const __u16 lport = inet->num; + const __u32 faddr = inet->daddr; + const __u16 fport = inet->dport; + + return inet_ehashfn(laddr, lport, faddr, fport); +} + static inline struct inet_ehash_bucket *inet_ehash_bucket( struct inet_hashinfo *hashinfo, unsigned int hash) @@ -415,7 +434,4 @@ static inline struct sock *inet_lookup(struct inet_hashinfo *hashinfo, return sk; } - -extern int inet_hash_connect(struct inet_timewait_death_row *death_row, - struct sock *sk); #endif /* _INET_HASHTABLES_H */ diff --git a/trunk/include/net/inet_sock.h b/trunk/include/net/inet_sock.h deleted file mode 100644 index 883eb529ef8e..000000000000 --- a/trunk/include/net/inet_sock.h +++ /dev/null @@ -1,193 +0,0 @@ -/* - * INET An implementation of the TCP/IP protocol suite for the LINUX - * operating system. INET is implemented using the BSD Socket - * interface as the means of communication with the user level. - * - * Definitions for inet_sock - * - * Authors: Many, reorganised here by - * Arnaldo Carvalho de Melo - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version - * 2 of the License, or (at your option) any later version. - */ -#ifndef _INET_SOCK_H -#define _INET_SOCK_H - -#include - -#include -#include - -#include -#include -#include - -/** struct ip_options - IP Options - * - * @faddr - Saved first hop address - * @is_setbyuser - Set by setsockopt? - * @is_data - Options in __data, rather than skb - * @is_strictroute - Strict source route - * @srr_is_hit - Packet destination addr was our one - * @is_changed - IP checksum more not valid - * @rr_needaddr - Need to record addr of outgoing dev - * @ts_needtime - Need to record timestamp - * @ts_needaddr - Need to record addr of outgoing dev - */ -struct ip_options { - __u32 faddr; - unsigned char optlen; - unsigned char srr; - unsigned char rr; - unsigned char ts; - unsigned char is_setbyuser:1, - is_data:1, - is_strictroute:1, - srr_is_hit:1, - is_changed:1, - rr_needaddr:1, - ts_needtime:1, - ts_needaddr:1; - unsigned char router_alert; - unsigned char __pad1; - unsigned char __pad2; - unsigned char __data[0]; -}; - -#define optlength(opt) (sizeof(struct ip_options) + opt->optlen) - -struct inet_request_sock { - struct request_sock req; -#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) - u16 inet6_rsk_offset; - /* 2 bytes hole, try to pack */ -#endif - u32 loc_addr; - u32 rmt_addr; - u16 rmt_port; - u16 snd_wscale : 4, - rcv_wscale : 4, - tstamp_ok : 1, - sack_ok : 1, - wscale_ok : 1, - ecn_ok : 1, - acked : 1; - struct ip_options *opt; -}; - -static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk) -{ - return (struct inet_request_sock *)sk; -} - -struct ip_mc_socklist; -struct ipv6_pinfo; -struct rtable; - -/** struct inet_sock - representation of INET sockets - * - * @sk - ancestor class - * @pinet6 - pointer to IPv6 control block - * @daddr - Foreign IPv4 addr - * @rcv_saddr - Bound local IPv4 addr - * @dport - Destination port - * @num - Local port - * @saddr - Sending source - * @uc_ttl - Unicast TTL - * @sport - Source port - * @id - ID counter for DF pkts - * @tos - TOS - * @mc_ttl - Multicasting TTL - * @is_icsk - is this an inet_connection_sock? - * @mc_index - Multicast device index - * @mc_list - Group array - * @cork - info to build ip hdr on each ip frag while socket is corked - */ -struct inet_sock { - /* sk and pinet6 has to be the first two members of inet_sock */ - struct sock sk; -#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) - struct ipv6_pinfo *pinet6; -#endif - /* Socket demultiplex comparisons on incoming packets. */ - __u32 daddr; - __u32 rcv_saddr; - __u16 dport; - __u16 num; - __u32 saddr; - __s16 uc_ttl; - __u16 cmsg_flags; - struct ip_options *opt; - __u16 sport; - __u16 id; - __u8 tos; - __u8 mc_ttl; - __u8 pmtudisc; - __u8 recverr:1, - is_icsk:1, - freebind:1, - hdrincl:1, - mc_loop:1; - int mc_index; - __u32 mc_addr; - struct ip_mc_socklist *mc_list; - struct { - unsigned int flags; - unsigned int fragsize; - struct ip_options *opt; - struct rtable *rt; - int length; /* Total length of all frames */ - u32 addr; - struct flowi fl; - } cork; -}; - -#define IPCORK_OPT 1 /* ip-options has been held in ipcork.opt */ -#define IPCORK_ALLFRAG 2 /* always fragment (for ipv6 for now) */ - -static inline struct inet_sock *inet_sk(const struct sock *sk) -{ - return (struct inet_sock *)sk; -} - -static inline void __inet_sk_copy_descendant(struct sock *sk_to, - const struct sock *sk_from, - const int ancestor_size) -{ - memcpy(inet_sk(sk_to) + 1, inet_sk(sk_from) + 1, - sk_from->sk_prot->obj_size - ancestor_size); -} -#if !(defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)) -static inline void inet_sk_copy_descendant(struct sock *sk_to, - const struct sock *sk_from) -{ - __inet_sk_copy_descendant(sk_to, sk_from, sizeof(struct inet_sock)); -} -#endif - -extern int inet_sk_rebuild_header(struct sock *sk); - -static inline unsigned int inet_ehashfn(const __u32 laddr, const __u16 lport, - const __u32 faddr, const __u16 fport) -{ - unsigned int h = (laddr ^ lport) ^ (faddr ^ fport); - h ^= h >> 16; - h ^= h >> 8; - return h; -} - -static inline int inet_sk_ehashfn(const struct sock *sk) -{ - const struct inet_sock *inet = inet_sk(sk); - const __u32 laddr = inet->rcv_saddr; - const __u16 lport = inet->num; - const __u32 faddr = inet->daddr; - const __u16 fport = inet->dport; - - return inet_ehashfn(laddr, lport, faddr, fport); -} - -#endif /* _INET_SOCK_H */ diff --git a/trunk/include/net/inet_timewait_sock.h b/trunk/include/net/inet_timewait_sock.h index 1da294c47522..28f7b2103505 100644 --- a/trunk/include/net/inet_timewait_sock.h +++ b/trunk/include/net/inet_timewait_sock.h @@ -17,16 +17,15 @@ #include +#include #include #include #include #include #include -#include #include #include -#include #include @@ -128,8 +127,7 @@ struct inet_timewait_sock { __u16 tw_num; /* And these are ours. */ __u8 tw_ipv6only:1; - /* 15 bits hole, try to pack */ - __u16 tw_ipv6_offset; + /* 31 bits hole, try to pack */ int tw_timeout; unsigned long tw_ttd; struct inet_bind_bucket *tw_tb; @@ -201,7 +199,7 @@ static inline void inet_twsk_put(struct inet_timewait_sock *tw) printk(KERN_DEBUG "%s timewait_sock %p released\n", tw->tw_prot->name, tw); #endif - kmem_cache_free(tw->tw_prot->twsk_prot->twsk_slab, tw); + kmem_cache_free(tw->tw_prot->twsk_slab, tw); module_put(owner); } } diff --git a/trunk/include/net/inetpeer.h b/trunk/include/net/inetpeer.h index 0965515f40cf..7fda471002b6 100644 --- a/trunk/include/net/inetpeer.h +++ b/trunk/include/net/inetpeer.h @@ -25,7 +25,6 @@ struct inet_peer __u32 v4daddr; /* peer's address */ __u16 avl_height; __u16 ip_id_count; /* IP ID for the next packet */ - atomic_t rid; /* Frag reception counter */ __u32 tcp_ts; unsigned long tcp_ts_stamp; }; diff --git a/trunk/include/net/ip.h b/trunk/include/net/ip.h index 7bb5804847f2..e4563bbee6ea 100644 --- a/trunk/include/net/ip.h +++ b/trunk/include/net/ip.h @@ -24,10 +24,14 @@ #include #include +#include #include #include - -#include +#include +#include +#include +#include +#include #include struct sock; @@ -41,7 +45,6 @@ struct inet_skb_parm #define IPSKB_TRANSLATED 2 #define IPSKB_FORWARDED 4 #define IPSKB_XFRM_TUNNEL_SIZE 8 -#define IPSKB_FRAG_COMPLETE 16 }; struct ipcm_cookie @@ -71,13 +74,6 @@ extern rwlock_t ip_ra_lock; #define IP_FRAG_TIME (30 * HZ) /* fragment lifetime */ -struct msghdr; -struct net_device; -struct packet_type; -struct rtable; -struct sk_buff; -struct sockaddr; - extern void ip_mc_dropsocket(struct sock *); extern void ip_mc_dropdevice(struct net_device *dev); extern int igmp_mc_proc_init(void); @@ -172,7 +168,6 @@ extern int sysctl_ipfrag_high_thresh; extern int sysctl_ipfrag_low_thresh; extern int sysctl_ipfrag_time; extern int sysctl_ipfrag_secret_interval; -extern int sysctl_ipfrag_max_dist; /* From inetpeer.c */ extern int inet_peer_threshold; @@ -187,8 +182,6 @@ extern int sysctl_ip_dynaddr; extern void ipfrag_init(void); #ifdef CONFIG_INET -#include - /* The function in 2.2 was invalid, producing wrong result for * check=0xFEFF. It was noticed by Arthur Skawina _year_ ago. --ANK(000625) */ static inline @@ -317,6 +310,7 @@ enum ip_defrag_users IP_DEFRAG_CALL_RA_CHAIN, IP_DEFRAG_CONNTRACK_IN, IP_DEFRAG_CONNTRACK_OUT, + IP_DEFRAG_NAT_OUT, IP_DEFRAG_VS_IN, IP_DEFRAG_VS_OUT, IP_DEFRAG_VS_FWD diff --git a/trunk/include/net/ip_fib.h b/trunk/include/net/ip_fib.h index e000fa2cd5f6..14de4ebd1211 100644 --- a/trunk/include/net/ip_fib.h +++ b/trunk/include/net/ip_fib.h @@ -238,8 +238,6 @@ extern int fib_validate_source(u32 src, u32 dst, u8 tos, int oif, struct net_device *dev, u32 *spec_dst, u32 *itag); extern void fib_select_multipath(const struct flowi *flp, struct fib_result *res); -struct rtentry; - /* Exported by fib_semantics.c */ extern int ip_fib_check_default(u32 gw, struct net_device *dev); extern int fib_sync_down(u32 local, struct net_device *dev, int force); diff --git a/trunk/include/net/ip_vs.h b/trunk/include/net/ip_vs.h index 7d2674fde19a..3b5559a023a4 100644 --- a/trunk/include/net/ip_vs.h +++ b/trunk/include/net/ip_vs.h @@ -251,15 +251,16 @@ struct ip_vs_daemon_user { #include #include /* for struct list_head */ #include /* for struct rwlock_t */ +#include /* for struct sk_buff */ +#include /* for struct iphdr */ #include /* for struct atomic_t */ +#include /* for struct neighbour */ +#include /* for struct dst_entry */ +#include #include -#include -#include #ifdef CONFIG_IP_VS_DEBUG -#include - extern int ip_vs_get_debug_level(void); #define IP_VS_DBG(level, msg...) \ do { \ @@ -428,11 +429,8 @@ struct ip_vs_stats spinlock_t lock; /* spin lock */ }; -struct dst_entry; -struct iphdr; struct ip_vs_conn; struct ip_vs_app; -struct sk_buff; struct ip_vs_protocol { struct ip_vs_protocol *next; diff --git a/trunk/include/net/ipv6.h b/trunk/include/net/ipv6.h index 860bbac4c4ee..0a2ad51cff82 100644 --- a/trunk/include/net/ipv6.h +++ b/trunk/include/net/ipv6.h @@ -240,8 +240,6 @@ extern struct ipv6_txoptions * ipv6_renew_options(struct sock *sk, struct ipv6_t struct ipv6_txoptions *ipv6_fixup_options(struct ipv6_txoptions *opt_space, struct ipv6_txoptions *opt); -extern int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb); - extern int ip6_frag_nqueues; extern atomic_t ip6_frag_mem; @@ -527,9 +525,6 @@ extern int inet6_getname(struct socket *sock, struct sockaddr *uaddr, extern int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg); -extern int inet6_hash_connect(struct inet_timewait_death_row *death_row, - struct sock *sk); - /* * reassembly.c */ @@ -538,11 +533,8 @@ extern int sysctl_ip6frag_low_thresh; extern int sysctl_ip6frag_time; extern int sysctl_ip6frag_secret_interval; -extern const struct proto_ops inet6_stream_ops; -extern const struct proto_ops inet6_dgram_ops; - -struct group_source_req; -struct group_filter; +extern struct proto_ops inet6_stream_ops; +extern struct proto_ops inet6_dgram_ops; extern int ip6_mc_source(int add, int omode, struct sock *sk, struct group_source_req *pgsr); diff --git a/trunk/include/net/ndisc.h b/trunk/include/net/ndisc.h index bbac87eeb422..f85d6e4b7442 100644 --- a/trunk/include/net/ndisc.h +++ b/trunk/include/net/ndisc.h @@ -35,20 +35,11 @@ enum { #ifdef __KERNEL__ -#include -#include +#include +#include #include -#include -#include - #include - -struct ctl_table; -struct file; -struct inet6_dev; -struct net_device; -struct net_proto_family; -struct sk_buff; +#include extern struct neigh_table nd_tbl; @@ -117,7 +108,7 @@ extern int igmp6_event_report(struct sk_buff *skb); extern void igmp6_cleanup(void); #ifdef CONFIG_SYSCTL -extern int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, +extern int ndisc_ifinfo_sysctl_change(ctl_table *ctl, int write, struct file * filp, void __user *buffer, diff --git a/trunk/include/net/neighbour.h b/trunk/include/net/neighbour.h index 6fa9ae190741..34c07731933d 100644 --- a/trunk/include/net/neighbour.h +++ b/trunk/include/net/neighbour.h @@ -49,8 +49,8 @@ #ifdef __KERNEL__ #include -#include #include +#include #include #include diff --git a/trunk/include/net/netfilter/nf_conntrack.h b/trunk/include/net/netfilter/nf_conntrack.h index 64b82b74a650..cc4825610795 100644 --- a/trunk/include/net/netfilter/nf_conntrack.h +++ b/trunk/include/net/netfilter/nf_conntrack.h @@ -94,9 +94,6 @@ struct nf_conn /* Current number of expected connections */ unsigned int expecting; - /* Unique ID that identifies this conntrack*/ - unsigned int id; - /* Helper. if any */ struct nf_conntrack_helper *helper; @@ -143,9 +140,6 @@ struct nf_conntrack_expect /* Usage count. */ atomic_t use; - /* Unique ID */ - unsigned int id; - /* Flags */ unsigned int flags; @@ -196,31 +190,6 @@ static inline void nf_ct_put(struct nf_conn *ct) nf_conntrack_put(&ct->ct_general); } -extern struct nf_conntrack_tuple_hash * -__nf_conntrack_find(const struct nf_conntrack_tuple *tuple, - const struct nf_conn *ignored_conntrack); - -extern void nf_conntrack_hash_insert(struct nf_conn *ct); - -extern struct nf_conntrack_expect * -__nf_conntrack_expect_find(const struct nf_conntrack_tuple *tuple); - -extern struct nf_conntrack_expect * -nf_conntrack_expect_find(const struct nf_conntrack_tuple *tuple); - -extern void nf_ct_unlink_expect(struct nf_conntrack_expect *exp); - -extern void nf_ct_remove_expectations(struct nf_conn *ct); - -extern void nf_conntrack_flush(void); - -extern struct nf_conntrack_helper * -nf_ct_helper_find_get( const struct nf_conntrack_tuple *tuple); -extern void nf_ct_helper_put(struct nf_conntrack_helper *helper); - -extern struct nf_conntrack_helper * -__nf_conntrack_helper_find_byname(const char *name); - /* call to create an explicit dependency on nf_conntrack. */ extern void need_nf_conntrack(void); diff --git a/trunk/include/net/netfilter/nf_conntrack_helper.h b/trunk/include/net/netfilter/nf_conntrack_helper.h index 86ec8174ad02..5a66b2a3a623 100644 --- a/trunk/include/net/netfilter/nf_conntrack_helper.h +++ b/trunk/include/net/netfilter/nf_conntrack_helper.h @@ -33,8 +33,6 @@ struct nf_conntrack_helper unsigned int protoff, struct nf_conn *ct, enum ip_conntrack_info conntrackinfo); - - int (*to_nfattr)(struct sk_buff *skb, const struct nf_conn *ct); }; extern int nf_conntrack_helper_register(struct nf_conntrack_helper *); diff --git a/trunk/include/net/netfilter/nf_conntrack_l3proto.h b/trunk/include/net/netfilter/nf_conntrack_l3proto.h index 67856eb93b43..01663e5b33df 100644 --- a/trunk/include/net/netfilter/nf_conntrack_l3proto.h +++ b/trunk/include/net/netfilter/nf_conntrack_l3proto.h @@ -14,8 +14,6 @@ #include #include -struct nfattr; - struct nf_conntrack_l3proto { /* Next pointer. */ @@ -72,12 +70,6 @@ struct nf_conntrack_l3proto u_int32_t (*get_features)(const struct nf_conntrack_tuple *tuple); - int (*tuple_to_nfattr)(struct sk_buff *skb, - const struct nf_conntrack_tuple *t); - - int (*nfattr_to_tuple)(struct nfattr *tb[], - struct nf_conntrack_tuple *t); - /* Module (if any) which this is connected to. */ struct module *me; }; @@ -89,16 +81,11 @@ extern int nf_conntrack_l3proto_register(struct nf_conntrack_l3proto *proto); extern void nf_conntrack_l3proto_unregister(struct nf_conntrack_l3proto *proto); static inline struct nf_conntrack_l3proto * -__nf_ct_l3proto_find(u_int16_t l3proto) +nf_ct_find_l3proto(u_int16_t l3proto) { return nf_ct_l3protos[l3proto]; } -extern struct nf_conntrack_l3proto * -nf_ct_l3proto_find_get(u_int16_t l3proto); - -extern void nf_ct_l3proto_put(struct nf_conntrack_l3proto *p); - /* Existing built-in protocols */ extern struct nf_conntrack_l3proto nf_conntrack_l3proto_ipv4; extern struct nf_conntrack_l3proto nf_conntrack_l3proto_ipv6; diff --git a/trunk/include/net/netfilter/nf_conntrack_protocol.h b/trunk/include/net/netfilter/nf_conntrack_protocol.h index 1f33737fcea5..b3afda35397a 100644 --- a/trunk/include/net/netfilter/nf_conntrack_protocol.h +++ b/trunk/include/net/netfilter/nf_conntrack_protocol.h @@ -12,7 +12,6 @@ #include struct seq_file; -struct nfattr; struct nf_conntrack_protocol { @@ -67,18 +66,6 @@ struct nf_conntrack_protocol enum ip_conntrack_info *ctinfo, int pf, unsigned int hooknum); - /* convert protoinfo to nfnetink attributes */ - int (*to_nfattr)(struct sk_buff *skb, struct nfattr *nfa, - const struct nf_conn *ct); - - /* convert nfnetlink attributes to protoinfo */ - int (*from_nfattr)(struct nfattr *tb[], struct nf_conn *ct); - - int (*tuple_to_nfattr)(struct sk_buff *skb, - const struct nf_conntrack_tuple *t); - int (*nfattr_to_tuple)(struct nfattr *tb[], - struct nf_conntrack_tuple *t); - /* Module (if any) which this is connected to. */ struct module *me; }; @@ -93,23 +80,12 @@ extern struct nf_conntrack_protocol nf_conntrack_generic_protocol; extern struct nf_conntrack_protocol **nf_ct_protos[PF_MAX]; extern struct nf_conntrack_protocol * -__nf_ct_proto_find(u_int16_t l3proto, u_int8_t protocol); - -extern struct nf_conntrack_protocol * -nf_ct_proto_find_get(u_int16_t l3proto, u_int8_t protocol); - -extern void nf_ct_proto_put(struct nf_conntrack_protocol *p); +nf_ct_find_proto(u_int16_t l3proto, u_int8_t protocol); /* Protocol registration. */ extern int nf_conntrack_protocol_register(struct nf_conntrack_protocol *proto); extern void nf_conntrack_protocol_unregister(struct nf_conntrack_protocol *proto); -/* Generic netlink helpers */ -extern int nf_ct_port_tuple_to_nfattr(struct sk_buff *skb, - const struct nf_conntrack_tuple *tuple); -extern int nf_ct_port_nfattr_to_tuple(struct nfattr *tb[], - struct nf_conntrack_tuple *t); - /* Log invalid packets */ extern unsigned int nf_ct_log_invalid; diff --git a/trunk/include/net/pkt_act.h b/trunk/include/net/pkt_act.h index b225d8472b7e..bd08964b72c0 100644 --- a/trunk/include/net/pkt_act.h +++ b/trunk/include/net/pkt_act.h @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include diff --git a/trunk/include/net/protocol.h b/trunk/include/net/protocol.h index 63f7db99c2a6..357691f6a45f 100644 --- a/trunk/include/net/protocol.h +++ b/trunk/include/net/protocol.h @@ -65,7 +65,7 @@ struct inet_protosw { int protocol; /* This is the L4 protocol number. */ struct proto *prot; - const struct proto_ops *ops; + struct proto_ops *ops; int capability; /* Which (if any) capability do * we need to use this socket @@ -76,7 +76,6 @@ struct inet_protosw { }; #define INET_PROTOSW_REUSE 0x01 /* Are ports automatically reusable? */ #define INET_PROTOSW_PERMANENT 0x02 /* Permanent protocols are unremovable. */ -#define INET_PROTOSW_ICSK 0x04 /* Is this an inet_connection_sock? */ extern struct net_protocol *inet_protocol_base; extern struct net_protocol *inet_protos[MAX_INET_PROTOS]; diff --git a/trunk/include/net/raw.h b/trunk/include/net/raw.h index e67b28a0248c..f47917469b12 100644 --- a/trunk/include/net/raw.h +++ b/trunk/include/net/raw.h @@ -19,8 +19,6 @@ #include -#include - extern struct proto raw_prot; extern void raw_err(struct sock *, struct sk_buff *, u32 info); diff --git a/trunk/include/net/request_sock.h b/trunk/include/net/request_sock.h index 11641c9384f7..b52cc52ffe39 100644 --- a/trunk/include/net/request_sock.h +++ b/trunk/include/net/request_sock.h @@ -244,7 +244,7 @@ static inline int reqsk_queue_is_full(const struct request_sock_queue *queue) static inline void reqsk_queue_hash_req(struct request_sock_queue *queue, u32 hash, struct request_sock *req, - unsigned long timeout) + unsigned timeout) { struct listen_sock *lopt = queue->listen_opt; diff --git a/trunk/include/net/sctp/structs.h b/trunk/include/net/sctp/structs.h index f5c22d77feab..8e7794ee27ff 100644 --- a/trunk/include/net/sctp/structs.h +++ b/trunk/include/net/sctp/structs.h @@ -277,24 +277,6 @@ struct sctp_sock { __u32 default_context; __u32 default_timetolive; - /* Heartbeat interval: The endpoint sends out a Heartbeat chunk to - * the destination address every heartbeat interval. This value - * will be inherited by all new associations. - */ - __u32 hbinterval; - - /* This is the max_retrans value for new associations. */ - __u16 pathmaxrxt; - - /* The initial Path MTU to use for new associations. */ - __u32 pathmtu; - - /* The default SACK delay timeout for new associations. */ - __u32 sackdelay; - - /* Flags controling Heartbeat, SACK delay, and Path MTU Discovery. */ - __u32 param_flags; - struct sctp_initmsg initmsg; struct sctp_rtoinfo rtoinfo; struct sctp_paddrparams paddrparam; @@ -863,6 +845,9 @@ struct sctp_transport { /* Data that has been sent, but not acknowledged. */ __u32 flight_size; + /* PMTU : The current known path MTU. */ + __u32 pmtu; + /* Destination */ struct dst_entry *dst; /* Source address. */ @@ -877,22 +862,7 @@ struct sctp_transport { /* Heartbeat interval: The endpoint sends out a Heartbeat chunk to * the destination address every heartbeat interval. */ - __u32 hbinterval; - - /* This is the max_retrans value for the transport and will - * be initialized from the assocs value. This can be changed - * using SCTP_SET_PEER_ADDR_PARAMS socket option. - */ - __u16 pathmaxrxt; - - /* PMTU : The current known path MTU. */ - __u32 pathmtu; - - /* SACK delay timeout */ - __u32 sackdelay; - - /* Flags controling Heartbeat, SACK delay, and Path MTU Discovery. */ - __u32 param_flags; + int hb_interval; /* When was the last time (in jiffies) that we heard from this * transport? We use this to pick new active and retran paths. @@ -912,11 +882,22 @@ struct sctp_transport { */ int state; + /* hb_allowed : The current heartbeat state of this destination, + * : i.e. ALLOW-HB, NO-HEARTBEAT, etc. + */ + int hb_allowed; + /* These are the error stats for this destination. */ /* Error count : The current error count for this destination. */ unsigned short error_count; + /* This is the max_retrans value for the transport and will + * be initialized to proto.max_retrans.path. This can be changed + * using SCTP_SET_PEER_ADDR_PARAMS socket option. + */ + int max_retrans; + /* Per : A timer used by each destination. * Destination : * Timer : @@ -1521,28 +1502,6 @@ struct sctp_association { /* The largest timeout or RTO value to use in attempting an INIT */ __u16 max_init_timeo; - /* Heartbeat interval: The endpoint sends out a Heartbeat chunk to - * the destination address every heartbeat interval. This value - * will be inherited by all new transports. - */ - __u32 hbinterval; - - /* This is the max_retrans value for new transports in the - * association. - */ - __u16 pathmaxrxt; - - /* Association : The smallest PMTU discovered for all of the - * PMTU : peer's transport addresses. - */ - __u32 pathmtu; - - /* SACK delay timeout */ - __u32 sackdelay; - - /* Flags controling Heartbeat, SACK delay, and Path MTU Discovery. */ - __u32 param_flags; - int timeouts[SCTP_NUM_TIMEOUT_TYPES]; struct timer_list timers[SCTP_NUM_TIMEOUT_TYPES]; @@ -1612,6 +1571,11 @@ struct sctp_association { */ wait_queue_head_t wait; + /* Association : The smallest PMTU discovered for all of the + * PMTU : peer's transport addresses. + */ + __u32 pmtu; + /* The message size at which SCTP fragmentation will occur. */ __u32 frag_point; diff --git a/trunk/include/net/sctp/user.h b/trunk/include/net/sctp/user.h index 8a6bef6f91eb..f1c3bc54526a 100644 --- a/trunk/include/net/sctp/user.h +++ b/trunk/include/net/sctp/user.h @@ -93,8 +93,6 @@ enum sctp_optname { #define SCTP_STATUS SCTP_STATUS SCTP_GET_PEER_ADDR_INFO, #define SCTP_GET_PEER_ADDR_INFO SCTP_GET_PEER_ADDR_INFO - SCTP_DELAYED_ACK_TIME, -#define SCTP_DELAYED_ACK_TIME SCTP_DELAYED_ACK_TIME /* Internal Socket Options. Some of the sctp library functions are * implemented using these socket options. @@ -505,41 +503,13 @@ struct sctp_setadaption { * unreachable. The following structure is used to access and modify an * address's parameters: */ -enum sctp_spp_flags { - SPP_HB_ENABLE = 1, /*Enable heartbeats*/ - SPP_HB_DISABLE = 2, /*Disable heartbeats*/ - SPP_HB = SPP_HB_ENABLE | SPP_HB_DISABLE, - SPP_HB_DEMAND = 4, /*Send heartbeat immediately*/ - SPP_PMTUD_ENABLE = 8, /*Enable PMTU discovery*/ - SPP_PMTUD_DISABLE = 16, /*Disable PMTU discovery*/ - SPP_PMTUD = SPP_PMTUD_ENABLE | SPP_PMTUD_DISABLE, - SPP_SACKDELAY_ENABLE = 32, /*Enable SACK*/ - SPP_SACKDELAY_DISABLE = 64, /*Disable SACK*/ - SPP_SACKDELAY = SPP_SACKDELAY_ENABLE | SPP_SACKDELAY_DISABLE, -}; - struct sctp_paddrparams { sctp_assoc_t spp_assoc_id; struct sockaddr_storage spp_address; __u32 spp_hbinterval; __u16 spp_pathmaxrxt; - __u32 spp_pathmtu; - __u32 spp_sackdelay; - __u32 spp_flags; } __attribute__((packed, aligned(4))); -/* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME) - * - * This options will get or set the delayed ack timer. The time is set - * in milliseconds. If the assoc_id is 0, then this sets or gets the - * endpoints default delayed ack timer value. If the assoc_id field is - * non-zero, then the set or get effects the specified association. - */ -struct sctp_assoc_value { - sctp_assoc_t assoc_id; - uint32_t assoc_value; -}; - /* * 7.2.2 Peer Address Information * diff --git a/trunk/include/net/sock.h b/trunk/include/net/sock.h index 6961700ff3a0..982b4ecd187b 100644 --- a/trunk/include/net/sock.h +++ b/trunk/include/net/sock.h @@ -493,7 +493,6 @@ extern void sk_stream_kill_queues(struct sock *sk); extern int sk_wait_data(struct sock *sk, long *timeo); struct request_sock_ops; -struct timewait_sock_ops; /* Networking protocol blocks we attach to sockets. * socket layer -> transport layer interface @@ -558,10 +557,11 @@ struct proto { kmem_cache_t *slab; unsigned int obj_size; + kmem_cache_t *twsk_slab; + unsigned int twsk_obj_size; atomic_t *orphan_count; struct request_sock_ops *rsk_prot; - struct timewait_sock_ops *twsk_prot; struct module *owner; @@ -926,29 +926,6 @@ static inline void sock_put(struct sock *sk) sk_free(sk); } -static inline int sk_receive_skb(struct sock *sk, struct sk_buff *skb) -{ - int rc = NET_RX_SUCCESS; - - if (sk_filter(sk, skb, 0)) - goto discard_and_relse; - - skb->dev = NULL; - - bh_lock_sock(sk); - if (!sock_owned_by_user(sk)) - rc = sk->sk_backlog_rcv(sk, skb); - else - sk_add_backlog(sk, skb); - bh_unlock_sock(sk); -out: - sock_put(sk); - return rc; -discard_and_relse: - kfree_skb(skb); - goto out; -} - /* Detach socket from process context. * Announce socket dead, detach it from wait queue and inode. * Note that parent inode held reference count on this struct sock, @@ -1189,10 +1166,7 @@ static inline int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb) static inline int sock_error(struct sock *sk) { - int err; - if (likely(!sk->sk_err)) - return 0; - err = xchg(&sk->sk_err, 0); + int err = xchg(&sk->sk_err, 0); return -err; } diff --git a/trunk/include/net/tcp.h b/trunk/include/net/tcp.h index 77f21c65bbca..d78025f9fbea 100644 --- a/trunk/include/net/tcp.h +++ b/trunk/include/net/tcp.h @@ -224,6 +224,53 @@ extern atomic_t tcp_memory_allocated; extern atomic_t tcp_sockets_allocated; extern int tcp_memory_pressure; +/* + * Pointers to address related TCP functions + * (i.e. things that depend on the address family) + */ + +struct tcp_func { + int (*queue_xmit) (struct sk_buff *skb, + int ipfragok); + + void (*send_check) (struct sock *sk, + struct tcphdr *th, + int len, + struct sk_buff *skb); + + int (*rebuild_header) (struct sock *sk); + + int (*conn_request) (struct sock *sk, + struct sk_buff *skb); + + struct sock * (*syn_recv_sock) (struct sock *sk, + struct sk_buff *skb, + struct request_sock *req, + struct dst_entry *dst); + + int (*remember_stamp) (struct sock *sk); + + __u16 net_header_len; + + int (*setsockopt) (struct sock *sk, + int level, + int optname, + char __user *optval, + int optlen); + + int (*getsockopt) (struct sock *sk, + int level, + int optname, + char __user *optval, + int __user *optlen); + + + void (*addr2sockaddr) (struct sock *sk, + struct sockaddr *); + + int sockaddr_len; +}; + /* * The next routines deal with comparing 32 bit unsigned ints * and worry about wraparound (automatic with unsigned arithmetic). @@ -287,9 +334,6 @@ extern int tcp_rcv_established(struct sock *sk, extern void tcp_rcv_space_adjust(struct sock *sk); -extern int tcp_twsk_unique(struct sock *sk, - struct sock *sktw, void *twp); - static inline void tcp_dec_quickack_mode(struct sock *sk, const unsigned int pkts) { @@ -361,7 +405,8 @@ extern void tcp_parse_options(struct sk_buff *skb, * TCP v4 functions exported for the inet6 API */ -extern void tcp_v4_send_check(struct sock *sk, int len, +extern void tcp_v4_send_check(struct sock *sk, + struct tcphdr *th, int len, struct sk_buff *skb); extern int tcp_v4_conn_request(struct sock *sk, @@ -445,16 +490,34 @@ typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc, sk_read_actor_t recv_actor); -extern void tcp_initialize_rcv_mss(struct sock *sk); +/* Initialize RCV_MSS value. + * RCV_MSS is an our guess about MSS used by the peer. + * We haven't any direct information about the MSS. + * It's better to underestimate the RCV_MSS rather than overestimate. + * Overestimations make us ACKing less frequently than needed. + * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss(). + */ -static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) +static inline void tcp_initialize_rcv_mss(struct sock *sk) +{ + struct tcp_sock *tp = tcp_sk(sk); + unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache); + + hint = min(hint, tp->rcv_wnd/2); + hint = min(hint, TCP_MIN_RCVMSS); + hint = max(hint, TCP_MIN_MSS); + + inet_csk(sk)->icsk_ack.rcv_mss = hint; +} + +static __inline__ void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd) { tp->pred_flags = htonl((tp->tcp_header_len << 26) | ntohl(TCP_FLAG_ACK) | snd_wnd); } -static inline void tcp_fast_path_on(struct tcp_sock *tp) +static __inline__ void tcp_fast_path_on(struct tcp_sock *tp) { __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale); } @@ -472,7 +535,7 @@ static inline void tcp_fast_path_check(struct sock *sk, struct tcp_sock *tp) * Rcv_nxt can be after the window if our peer push more data * than the offered window. */ -static inline u32 tcp_receive_window(const struct tcp_sock *tp) +static __inline__ u32 tcp_receive_window(const struct tcp_sock *tp) { s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt; @@ -644,7 +707,6 @@ extern void tcp_cleanup_congestion_control(struct sock *sk); extern int tcp_set_default_congestion_control(const char *name); extern void tcp_get_default_congestion_control(char *name); extern int tcp_set_congestion_control(struct sock *sk, const char *name); -extern void tcp_slow_start(struct tcp_sock *tp); extern struct tcp_congestion_ops tcp_init_congestion_ops; extern u32 tcp_reno_ssthresh(struct sock *sk); @@ -684,7 +746,7 @@ static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event) * "Packets left network, but not honestly ACKed yet" PLUS * "Packets fast retransmitted" */ -static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) +static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) { return (tp->packets_out - tp->left_out + tp->retrans_out); } @@ -704,6 +766,33 @@ static inline __u32 tcp_current_ssthresh(const struct sock *sk) (tp->snd_cwnd >> 2))); } +/* + * Linear increase during slow start + */ +static inline void tcp_slow_start(struct tcp_sock *tp) +{ + if (sysctl_tcp_abc) { + /* RFC3465: Slow Start + * TCP sender SHOULD increase cwnd by the number of + * previously unacknowledged bytes ACKed by each incoming + * acknowledgment, provided the increase is not more than L + */ + if (tp->bytes_acked < tp->mss_cache) + return; + + /* We MAY increase by 2 if discovered delayed ack */ + if (sysctl_tcp_abc > 1 && tp->bytes_acked > 2*tp->mss_cache) { + if (tp->snd_cwnd < tp->snd_cwnd_clamp) + tp->snd_cwnd++; + } + } + tp->bytes_acked = 0; + + if (tp->snd_cwnd < tp->snd_cwnd_clamp) + tp->snd_cwnd++; +} + + static inline void tcp_sync_left_out(struct tcp_sock *tp) { if (tp->rx_opt.sack_ok && @@ -712,7 +801,34 @@ static inline void tcp_sync_left_out(struct tcp_sock *tp) tp->left_out = tp->sacked_out + tp->lost_out; } -extern void tcp_enter_cwr(struct sock *sk); +/* Set slow start threshold and cwnd not falling to slow start */ +static inline void __tcp_enter_cwr(struct sock *sk) +{ + const struct inet_connection_sock *icsk = inet_csk(sk); + struct tcp_sock *tp = tcp_sk(sk); + + tp->undo_marker = 0; + tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk); + tp->snd_cwnd = min(tp->snd_cwnd, + tcp_packets_in_flight(tp) + 1U); + tp->snd_cwnd_cnt = 0; + tp->high_seq = tp->snd_nxt; + tp->snd_cwnd_stamp = tcp_time_stamp; + TCP_ECN_queue_cwr(tp); +} + +static inline void tcp_enter_cwr(struct sock *sk) +{ + struct tcp_sock *tp = tcp_sk(sk); + + tp->prior_ssthresh = 0; + tp->bytes_acked = 0; + if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) { + __tcp_enter_cwr(sk); + tcp_set_ca_state(sk, TCP_CA_CWR); + } +} + extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst); /* Slow start with delack produces 3 packets of burst, so that @@ -744,14 +860,14 @@ static inline int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight) return left <= tcp_max_burst(tp); } -static inline void tcp_minshall_update(struct tcp_sock *tp, int mss, - const struct sk_buff *skb) +static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss, + const struct sk_buff *skb) { if (skb->len < mss) tp->snd_sml = TCP_SKB_CB(skb)->end_seq; } -static inline void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp) +static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp) { const struct inet_connection_sock *icsk = inet_csk(sk); if (!tp->packets_out && !icsk->icsk_pending) @@ -759,18 +875,18 @@ static inline void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp) icsk->icsk_rto, TCP_RTO_MAX); } -static inline void tcp_push_pending_frames(struct sock *sk, - struct tcp_sock *tp) +static __inline__ void tcp_push_pending_frames(struct sock *sk, + struct tcp_sock *tp) { __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle); } -static inline void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq) +static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq) { tp->snd_wl1 = seq; } -static inline void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq) +static __inline__ void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq) { tp->snd_wl1 = seq; } @@ -778,19 +894,19 @@ static inline void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq) /* * Calculate(/check) TCP checksum */ -static inline u16 tcp_v4_check(struct tcphdr *th, int len, - unsigned long saddr, unsigned long daddr, - unsigned long base) +static __inline__ u16 tcp_v4_check(struct tcphdr *th, int len, + unsigned long saddr, unsigned long daddr, + unsigned long base) { return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); } -static inline int __tcp_checksum_complete(struct sk_buff *skb) +static __inline__ int __tcp_checksum_complete(struct sk_buff *skb) { return __skb_checksum_complete(skb); } -static inline int tcp_checksum_complete(struct sk_buff *skb) +static __inline__ int tcp_checksum_complete(struct sk_buff *skb) { return skb->ip_summed != CHECKSUM_UNNECESSARY && __tcp_checksum_complete(skb); @@ -798,7 +914,7 @@ static inline int tcp_checksum_complete(struct sk_buff *skb) /* Prequeue for VJ style copy to user, combined with checksumming. */ -static inline void tcp_prequeue_init(struct tcp_sock *tp) +static __inline__ void tcp_prequeue_init(struct tcp_sock *tp) { tp->ucopy.task = NULL; tp->ucopy.len = 0; @@ -814,7 +930,7 @@ static inline void tcp_prequeue_init(struct tcp_sock *tp) * * NOTE: is this not too big to inline? */ -static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb) +static __inline__ int tcp_prequeue(struct sock *sk, struct sk_buff *skb) { struct tcp_sock *tp = tcp_sk(sk); @@ -855,7 +971,7 @@ static const char *statename[]={ }; #endif -static inline void tcp_set_state(struct sock *sk, int state) +static __inline__ void tcp_set_state(struct sock *sk, int state) { int oldstate = sk->sk_state; @@ -889,7 +1005,7 @@ static inline void tcp_set_state(struct sock *sk, int state) #endif } -static inline void tcp_done(struct sock *sk) +static __inline__ void tcp_done(struct sock *sk) { tcp_set_state(sk, TCP_CLOSE); tcp_clear_xmit_timers(sk); @@ -902,13 +1018,81 @@ static inline void tcp_done(struct sock *sk) inet_csk_destroy_sock(sk); } -static inline void tcp_sack_reset(struct tcp_options_received *rx_opt) +static __inline__ void tcp_sack_reset(struct tcp_options_received *rx_opt) { rx_opt->dsack = 0; rx_opt->eff_sacks = 0; rx_opt->num_sacks = 0; } +static __inline__ void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp, __u32 tstamp) +{ + if (tp->rx_opt.tstamp_ok) { + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | + (TCPOPT_NOP << 16) | + (TCPOPT_TIMESTAMP << 8) | + TCPOLEN_TIMESTAMP); + *ptr++ = htonl(tstamp); + *ptr++ = htonl(tp->rx_opt.ts_recent); + } + if (tp->rx_opt.eff_sacks) { + struct tcp_sack_block *sp = tp->rx_opt.dsack ? tp->duplicate_sack : tp->selective_acks; + int this_sack; + + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | + (TCPOPT_NOP << 16) | + (TCPOPT_SACK << 8) | + (TCPOLEN_SACK_BASE + + (tp->rx_opt.eff_sacks * TCPOLEN_SACK_PERBLOCK))); + for(this_sack = 0; this_sack < tp->rx_opt.eff_sacks; this_sack++) { + *ptr++ = htonl(sp[this_sack].start_seq); + *ptr++ = htonl(sp[this_sack].end_seq); + } + if (tp->rx_opt.dsack) { + tp->rx_opt.dsack = 0; + tp->rx_opt.eff_sacks--; + } + } +} + +/* Construct a tcp options header for a SYN or SYN_ACK packet. + * If this is every changed make sure to change the definition of + * MAX_SYN_SIZE to match the new maximum number of options that you + * can generate. + */ +static inline void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack, + int offer_wscale, int wscale, __u32 tstamp, __u32 ts_recent) +{ + /* We always get an MSS option. + * The option bytes which will be seen in normal data + * packets should timestamps be used, must be in the MSS + * advertised. But we subtract them from tp->mss_cache so + * that calculations in tcp_sendmsg are simpler etc. + * So account for this fact here if necessary. If we + * don't do this correctly, as a receiver we won't + * recognize data packets as being full sized when we + * should, and thus we won't abide by the delayed ACK + * rules correctly. + * SACKs don't matter, we never delay an ACK when we + * have any of those going out. + */ + *ptr++ = htonl((TCPOPT_MSS << 24) | (TCPOLEN_MSS << 16) | mss); + if (ts) { + if(sack) + *ptr++ = __constant_htonl((TCPOPT_SACK_PERM << 24) | (TCPOLEN_SACK_PERM << 16) | + (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP); + else + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | + (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP); + *ptr++ = htonl(tstamp); /* TSVAL */ + *ptr++ = htonl(ts_recent); /* TSECR */ + } else if(sack) + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | + (TCPOPT_SACK_PERM << 8) | TCPOLEN_SACK_PERM); + if (offer_wscale) + *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_WINDOW << 16) | (TCPOLEN_WINDOW << 8) | (wscale)); +} + /* Determine a window scaling and initial window to offer. */ extern void tcp_select_initial_window(int __space, __u32 mss, __u32 *rcv_wnd, __u32 *window_clamp, @@ -933,9 +1117,9 @@ static inline int tcp_full_space(const struct sock *sk) return tcp_win_from_space(sk->sk_rcvbuf); } -static inline void tcp_openreq_init(struct request_sock *req, - struct tcp_options_received *rx_opt, - struct sk_buff *skb) +static __inline__ void tcp_openreq_init(struct request_sock *req, + struct tcp_options_received *rx_opt, + struct sk_buff *skb) { struct inet_request_sock *ireq = inet_rsk(req); diff --git a/trunk/include/net/tcp_states.h b/trunk/include/net/tcp_states.h index b0b645988bd8..b9d4176b2d15 100644 --- a/trunk/include/net/tcp_states.h +++ b/trunk/include/net/tcp_states.h @@ -31,20 +31,4 @@ enum { #define TCP_STATE_MASK 0xF -#define TCP_ACTION_FIN (1 << 7) - -enum { - TCPF_ESTABLISHED = (1 << 1), - TCPF_SYN_SENT = (1 << 2), - TCPF_SYN_RECV = (1 << 3), - TCPF_FIN_WAIT1 = (1 << 4), - TCPF_FIN_WAIT2 = (1 << 5), - TCPF_TIME_WAIT = (1 << 6), - TCPF_CLOSE = (1 << 7), - TCPF_CLOSE_WAIT = (1 << 8), - TCPF_LAST_ACK = (1 << 9), - TCPF_LISTEN = (1 << 10), - TCPF_CLOSING = (1 << 11) -}; - #endif /* _LINUX_TCP_STATES_H */ diff --git a/trunk/include/net/timewait_sock.h b/trunk/include/net/timewait_sock.h deleted file mode 100644 index 2544281e1d5e..000000000000 --- a/trunk/include/net/timewait_sock.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * NET Generic infrastructure for Network protocols. - * - * Authors: Arnaldo Carvalho de Melo - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version - * 2 of the License, or (at your option) any later version. - */ -#ifndef _TIMEWAIT_SOCK_H -#define _TIMEWAIT_SOCK_H - -#include -#include - -struct timewait_sock_ops { - kmem_cache_t *twsk_slab; - unsigned int twsk_obj_size; - int (*twsk_unique)(struct sock *sk, - struct sock *sktw, void *twp); -}; - -static inline int twsk_unique(struct sock *sk, struct sock *sktw, void *twp) -{ - if (sk->sk_prot->twsk_prot->twsk_unique != NULL) - return sk->sk_prot->twsk_prot->twsk_unique(sk, sktw, twp); - return 0; -} - -#endif /* _TIMEWAIT_SOCK_H */ diff --git a/trunk/include/net/transp_v6.h b/trunk/include/net/transp_v6.h index 61f724c1036f..4e86f2de6638 100644 --- a/trunk/include/net/transp_v6.h +++ b/trunk/include/net/transp_v6.h @@ -44,7 +44,7 @@ extern int datagram_send_ctl(struct msghdr *msg, /* * address family specific functions */ -extern struct inet_connection_sock_af_ops ipv4_specific; +extern struct tcp_func ipv4_specific; extern int inet6_destroy_sock(struct sock *sk); diff --git a/trunk/include/net/udp.h b/trunk/include/net/udp.h index 766fba1369ce..107b9d791a1f 100644 --- a/trunk/include/net/udp.h +++ b/trunk/include/net/udp.h @@ -22,8 +22,9 @@ #ifndef _UDP_H #define _UDP_H +#include +#include #include -#include #include #include #include @@ -61,7 +62,6 @@ static inline int udp_lport_inuse(u16 num) extern struct proto udp_prot; -struct sk_buff; extern void udp_err(struct sk_buff *, u32); diff --git a/trunk/include/net/xfrm.h b/trunk/include/net/xfrm.h index 07d7b50cdd76..1cdb87912137 100644 --- a/trunk/include/net/xfrm.h +++ b/trunk/include/net/xfrm.h @@ -2,12 +2,11 @@ #define _NET_XFRM_H #include -#include #include #include #include #include -#include +#include #include #include #include @@ -145,9 +144,6 @@ struct xfrm_state * transformer. */ struct xfrm_type *type; - /* Security context */ - struct xfrm_sec_ctx *security; - /* Private data of this transformer, format is opaque, * interpreted by xfrm_type methods. */ void *data; @@ -302,7 +298,6 @@ struct xfrm_policy __u8 flags; __u8 dead; __u8 xfrm_nr; - struct xfrm_sec_ctx *security; struct xfrm_tmpl xfrm_vec[XFRM_MAX_DEPTH]; }; @@ -515,25 +510,6 @@ xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl, return 0; } -#ifdef CONFIG_SECURITY_NETWORK_XFRM -/* If neither has a context --> match - * Otherwise, both must have a context and the sids, doi, alg must match - */ -static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2) -{ - return ((!s1 && !s2) || - (s1 && s2 && - (s1->ctx_sid == s2->ctx_sid) && - (s1->ctx_doi == s2->ctx_doi) && - (s1->ctx_alg == s2->ctx_alg))); -} -#else -static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2) -{ - return 1; -} -#endif - /* A struct encoding bundle of transformations to apply to some set of flow. * * dst->child points to the next element of bundle. @@ -902,8 +878,8 @@ static inline int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsig struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp); extern int xfrm_policy_walk(int (*func)(struct xfrm_policy *, int, int, void*), void *); int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl); -struct xfrm_policy *xfrm_policy_bysel_ctx(int dir, struct xfrm_selector *sel, - struct xfrm_sec_ctx *ctx, int delete); +struct xfrm_policy *xfrm_policy_bysel(int dir, struct xfrm_selector *sel, + int delete); struct xfrm_policy *xfrm_policy_byid(int dir, u32 id, int delete); void xfrm_policy_flush(void); u32 xfrm_get_acqseq(void); diff --git a/trunk/include/pcmcia/cs.h b/trunk/include/pcmcia/cs.h index 52660f32663d..2cab39f49eb2 100644 --- a/trunk/include/pcmcia/cs.h +++ b/trunk/include/pcmcia/cs.h @@ -382,6 +382,7 @@ enum service { struct pcmcia_socket; int pcmcia_access_configuration_register(struct pcmcia_device *p_dev, conf_reg_t *reg); +int pcmcia_deregister_client(struct pcmcia_device *p_dev); int pcmcia_get_configuration_info(struct pcmcia_device *p_dev, config_info_t *config); int pcmcia_get_first_window(window_handle_t *win, win_req_t *req); int pcmcia_get_next_window(window_handle_t *win, win_req_t *req); @@ -389,6 +390,7 @@ int pcmcia_get_status(struct pcmcia_device *p_dev, cs_status_t *status); int pcmcia_get_mem_page(window_handle_t win, memreq_t *req); int pcmcia_map_mem_page(window_handle_t win, memreq_t *req); int pcmcia_modify_configuration(struct pcmcia_device *p_dev, modconf_t *mod); +int pcmcia_register_client(client_handle_t *handle, client_reg_t *req); int pcmcia_release_configuration(struct pcmcia_device *p_dev); int pcmcia_release_io(struct pcmcia_device *p_dev, io_req_t *req); int pcmcia_release_irq(struct pcmcia_device *p_dev, irq_req_t *req); diff --git a/trunk/include/pcmcia/ds.h b/trunk/include/pcmcia/ds.h index 8e2a96396478..cb8b6e6ce66c 100644 --- a/trunk/include/pcmcia/ds.h +++ b/trunk/include/pcmcia/ds.h @@ -133,12 +133,10 @@ typedef struct dev_link_t { struct pcmcia_socket; struct pcmcia_driver { - int (*probe) (struct pcmcia_device *dev); - void (*remove) (struct pcmcia_device *dev); - - int (*suspend) (struct pcmcia_device *dev); - int (*resume) (struct pcmcia_device *dev); - + dev_link_t *(*attach)(void); + int (*event) (event_t event, int priority, + event_callback_args_t *); + void (*detach)(dev_link_t *); struct module *owner; struct pcmcia_device_id *id_table; struct device_driver drv; @@ -166,6 +164,7 @@ struct pcmcia_device { /* deprecated, a cleaned up version will be moved into this struct soon */ dev_link_t *instance; + event_callback_args_t event_callback_args; u_int state; /* information about this device */ @@ -194,8 +193,6 @@ struct pcmcia_device { #define handle_to_pdev(handle) (handle) #define handle_to_dev(handle) (handle->dev) -#define dev_to_instance(dev) (dev->instance) - /* error reporting */ void cs_error(client_handle_t handle, int func, int ret); diff --git a/trunk/include/pcmcia/ss.h b/trunk/include/pcmcia/ss.h index 2889a69a7a8f..e788bbc5657d 100644 --- a/trunk/include/pcmcia/ss.h +++ b/trunk/include/pcmcia/ss.h @@ -118,14 +118,16 @@ struct pcmcia_socket; struct pccard_operations { int (*init)(struct pcmcia_socket *sock); int (*suspend)(struct pcmcia_socket *sock); + int (*register_callback)(struct pcmcia_socket *sock, void (*handler)(void *, unsigned int), void * info); int (*get_status)(struct pcmcia_socket *sock, u_int *value); + int (*get_socket)(struct pcmcia_socket *sock, socket_state_t *state); int (*set_socket)(struct pcmcia_socket *sock, socket_state_t *state); int (*set_io_map)(struct pcmcia_socket *sock, struct pccard_io_map *io); int (*set_mem_map)(struct pcmcia_socket *sock, struct pccard_mem_map *mem); }; struct pccard_resource_ops { - int (*validate_mem) (struct pcmcia_socket *s); + void (*validate_mem) (struct pcmcia_socket *s); int (*adjust_io_region) (struct resource *res, unsigned long r_start, unsigned long r_end, diff --git a/trunk/include/scsi/scsi_cmnd.h b/trunk/include/scsi/scsi_cmnd.h index 41cfc29be899..20da282d4abb 100644 --- a/trunk/include/scsi/scsi_cmnd.h +++ b/trunk/include/scsi/scsi_cmnd.h @@ -151,6 +151,6 @@ extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t); extern void scsi_put_command(struct scsi_cmnd *); extern void scsi_io_completion(struct scsi_cmnd *, unsigned int, unsigned int); extern void scsi_finish_command(struct scsi_cmnd *cmd); -extern void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd); +extern void scsi_setup_blk_pc_cmnd(struct scsi_cmnd *cmd, int retries); #endif /* _SCSI_SCSI_CMND_H */ diff --git a/trunk/include/scsi/scsi_dbg.h b/trunk/include/scsi/scsi_dbg.h index 4d69dee66d4d..b090a11d7e1c 100644 --- a/trunk/include/scsi/scsi_dbg.h +++ b/trunk/include/scsi/scsi_dbg.h @@ -16,6 +16,7 @@ extern void __scsi_print_sense(const char *name, extern void scsi_print_driverbyte(int); extern void scsi_print_hostbyte(int); extern void scsi_print_status(unsigned char); +extern int scsi_print_msg(const unsigned char *); extern const char *scsi_sense_key_string(unsigned char); extern const char *scsi_extd_sense_format(unsigned char, unsigned char); diff --git a/trunk/include/scsi/scsi_device.h b/trunk/include/scsi/scsi_device.h index e94ca4d36035..85cfd88461c8 100644 --- a/trunk/include/scsi/scsi_device.h +++ b/trunk/include/scsi/scsi_device.h @@ -79,9 +79,9 @@ struct scsi_device { char inq_periph_qual; /* PQ from INQUIRY data */ unsigned char inquiry_len; /* valid bytes in 'inquiry' */ unsigned char * inquiry; /* INQUIRY response data */ - const char * vendor; /* [back_compat] point into 'inquiry' ... */ - const char * model; /* ... after scan; point to static string */ - const char * rev; /* ... "nullnullnullnull" before scan */ + char * vendor; /* [back_compat] point into 'inquiry' ... */ + char * model; /* ... after scan; point to static string */ + char * rev; /* ... "nullnullnullnull" before scan */ unsigned char current_tag; /* current tag */ struct scsi_target *sdev_target; /* used only for single_lun */ @@ -274,12 +274,6 @@ extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd, extern int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd, int data_direction, void *buffer, unsigned bufflen, struct scsi_sense_hdr *, int timeout, int retries); -extern int scsi_execute_async(struct scsi_device *sdev, - const unsigned char *cmd, int data_direction, - void *buffer, unsigned bufflen, int use_sg, - int timeout, int retries, void *privdata, - void (*done)(void *, char *, int, int), - gfp_t gfp); static inline unsigned int sdev_channel(struct scsi_device *sdev) { diff --git a/trunk/include/scsi/scsi_transport_spi.h b/trunk/include/scsi/scsi_transport_spi.h index 54a89611e9c5..6bdc4afb2483 100644 --- a/trunk/include/scsi/scsi_transport_spi.h +++ b/trunk/include/scsi/scsi_transport_spi.h @@ -24,9 +24,6 @@ #include struct scsi_transport_template; -struct scsi_target; -struct scsi_device; -struct Scsi_Host; struct spi_transport_attrs { int period; /* value in the PPR/SDTR command */ @@ -146,6 +143,5 @@ void spi_release_transport(struct scsi_transport_template *); void spi_schedule_dv_device(struct scsi_device *); void spi_dv_device(struct scsi_device *); void spi_display_xfer_agreement(struct scsi_target *); -int spi_print_msg(const unsigned char *); #endif /* SCSI_TRANSPORT_SPI_H */ diff --git a/trunk/include/sound/ac97_codec.h b/trunk/include/sound/ac97_codec.h index b0b3ea7b365e..7f0ca79d6c98 100644 --- a/trunk/include/sound/ac97_codec.h +++ b/trunk/include/sound/ac97_codec.h @@ -391,35 +391,65 @@ * */ -struct snd_ac97; +typedef struct _snd_ac97_bus ac97_bus_t; +typedef struct _snd_ac97_bus_ops ac97_bus_ops_t; +typedef struct _snd_ac97_template ac97_template_t; +typedef struct _snd_ac97 ac97_t; + +enum ac97_pcm_cfg { + AC97_PCM_CFG_FRONT = 2, + AC97_PCM_CFG_REAR = 10, /* alias surround */ + AC97_PCM_CFG_LFE = 11, /* center + lfe */ + AC97_PCM_CFG_40 = 4, /* front + rear */ + AC97_PCM_CFG_51 = 6, /* front + rear + center/lfe */ + AC97_PCM_CFG_SPDIF = 20 +}; + +/* PCM allocation */ +struct ac97_pcm { + ac97_bus_t *bus; + unsigned int stream: 1, /* stream type: 1 = capture */ + exclusive: 1, /* exclusive mode, don't override with other pcms */ + copy_flag: 1, /* lowlevel driver must fill all entries */ + spdif: 1; /* spdif pcm */ + unsigned short aslots; /* active slots */ + unsigned int rates; /* available rates */ + struct { + unsigned short slots; /* driver input: requested AC97 slot numbers */ + unsigned short rslots[4]; /* allocated slots per codecs */ + unsigned char rate_table[4]; + ac97_t *codec[4]; /* allocated codecs */ + } r[2]; /* 0 = standard rates, 1 = double rates */ + unsigned long private_value; /* used by the hardware driver */ +}; struct snd_ac97_build_ops { - int (*build_3d) (struct snd_ac97 *ac97); - int (*build_specific) (struct snd_ac97 *ac97); - int (*build_spdif) (struct snd_ac97 *ac97); - int (*build_post_spdif) (struct snd_ac97 *ac97); + int (*build_3d) (ac97_t *ac97); + int (*build_specific) (ac97_t *ac97); + int (*build_spdif) (ac97_t *ac97); + int (*build_post_spdif) (ac97_t *ac97); #ifdef CONFIG_PM - void (*suspend) (struct snd_ac97 *ac97); - void (*resume) (struct snd_ac97 *ac97); + void (*suspend) (ac97_t *ac97); + void (*resume) (ac97_t *ac97); #endif - void (*update_jacks) (struct snd_ac97 *ac97); /* for jack-sharing */ + void (*update_jacks) (ac97_t *ac97); /* for jack-sharing */ }; -struct snd_ac97_bus_ops { - void (*reset) (struct snd_ac97 *ac97); - void (*write) (struct snd_ac97 *ac97, unsigned short reg, unsigned short val); - unsigned short (*read) (struct snd_ac97 *ac97, unsigned short reg); - void (*wait) (struct snd_ac97 *ac97); - void (*init) (struct snd_ac97 *ac97); +struct _snd_ac97_bus_ops { + void (*reset) (ac97_t *ac97); + void (*write) (ac97_t *ac97, unsigned short reg, unsigned short val); + unsigned short (*read) (ac97_t *ac97, unsigned short reg); + void (*wait) (ac97_t *ac97); + void (*init) (ac97_t *ac97); }; -struct snd_ac97_bus { +struct _snd_ac97_bus { /* -- lowlevel (hardware) driver specific -- */ - struct snd_ac97_bus_ops *ops; + ac97_bus_ops_t *ops; void *private_data; - void (*private_free) (struct snd_ac97_bus *bus); + void (*private_free) (ac97_bus_t *bus); /* --- */ - struct snd_card *card; + snd_card_t *card; unsigned short num; /* bus number */ unsigned short no_vra: 1, /* bridge doesn't support VRA */ dra: 1, /* bridge supports double rate */ @@ -429,13 +459,13 @@ struct snd_ac97_bus { unsigned short used_slots[2][4]; /* actually used PCM slots */ unsigned short pcms_count; /* count of PCMs */ struct ac97_pcm *pcms; - struct snd_ac97 *codec[4]; - struct snd_info_entry *proc; + ac97_t *codec[4]; + snd_info_entry_t *proc; }; -struct snd_ac97_template { +struct _snd_ac97_template { void *private_data; - void (*private_free) (struct snd_ac97 *ac97); + void (*private_free) (ac97_t *ac97); struct pci_dev *pci; /* assigned PCI device - used for quirks */ unsigned short num; /* number of codec: 0 = primary, 1 = secondary */ unsigned short addr; /* physical address of codec [0-3] */ @@ -444,16 +474,16 @@ struct snd_ac97_template { DECLARE_BITMAP(reg_accessed, 0x80); /* bit flags */ }; -struct snd_ac97 { +struct _snd_ac97 { /* -- lowlevel (hardware) driver specific -- */ struct snd_ac97_build_ops * build_ops; void *private_data; - void (*private_free) (struct snd_ac97 *ac97); + void (*private_free) (ac97_t *ac97); /* --- */ - struct snd_ac97_bus *bus; + ac97_bus_t *bus; struct pci_dev *pci; /* assigned PCI device - used for quirks */ - struct snd_info_entry *proc; - struct snd_info_entry *proc_regs; + snd_info_entry_t *proc; + snd_info_entry_t *proc_regs; unsigned short subsystem_vendor; unsigned short subsystem_device; struct semaphore reg_mutex; @@ -487,47 +517,43 @@ struct snd_ac97 { struct device dev; }; -#define to_ac97_t(d) container_of(d, struct snd_ac97, dev) +#define to_ac97_t(d) container_of(d, struct _snd_ac97, dev) /* conditions */ -static inline int ac97_is_audio(struct snd_ac97 * ac97) +static inline int ac97_is_audio(ac97_t * ac97) { return (ac97->scaps & AC97_SCAP_AUDIO); } -static inline int ac97_is_modem(struct snd_ac97 * ac97) +static inline int ac97_is_modem(ac97_t * ac97) { return (ac97->scaps & AC97_SCAP_MODEM); } -static inline int ac97_is_rev22(struct snd_ac97 * ac97) +static inline int ac97_is_rev22(ac97_t * ac97) { return (ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_22; } -static inline int ac97_can_amap(struct snd_ac97 * ac97) +static inline int ac97_can_amap(ac97_t * ac97) { return (ac97->ext_id & AC97_EI_AMAP) != 0; } -static inline int ac97_can_spdif(struct snd_ac97 * ac97) +static inline int ac97_can_spdif(ac97_t * ac97) { return (ac97->ext_id & AC97_EI_SPDIF) != 0; } /* functions */ -/* create new AC97 bus */ -int snd_ac97_bus(struct snd_card *card, int num, struct snd_ac97_bus_ops *ops, - void *private_data, struct snd_ac97_bus **rbus); -/* create mixer controls */ -int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, - struct snd_ac97 **rac97); -const char *snd_ac97_get_short_name(struct snd_ac97 *ac97); - -void snd_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short value); -unsigned short snd_ac97_read(struct snd_ac97 *ac97, unsigned short reg); -void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned short value); -int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short value); -int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value); +int snd_ac97_bus(snd_card_t *card, int num, ac97_bus_ops_t *ops, void *private_data, ac97_bus_t **rbus); /* create new AC97 bus */ +int snd_ac97_mixer(ac97_bus_t *bus, ac97_template_t *template, ac97_t **rac97); /* create mixer controls */ +const char *snd_ac97_get_short_name(ac97_t *ac97); + +void snd_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short value); +unsigned short snd_ac97_read(ac97_t *ac97, unsigned short reg); +void snd_ac97_write_cache(ac97_t *ac97, unsigned short reg, unsigned short value); +int snd_ac97_update(ac97_t *ac97, unsigned short reg, unsigned short value); +int snd_ac97_update_bits(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value); #ifdef CONFIG_PM -void snd_ac97_suspend(struct snd_ac97 *ac97); -void snd_ac97_resume(struct snd_ac97 *ac97); +void snd_ac97_suspend(ac97_t *ac97); +void snd_ac97_resume(ac97_t *ac97); #endif /* quirk types */ @@ -541,7 +567,6 @@ enum { AC97_TUNE_ALC_JACK, /* for Realtek, enable JACK detection */ AC97_TUNE_INV_EAPD, /* inverted EAPD implementation */ AC97_TUNE_MUTE_LED, /* EAPD bit works as mute LED */ - AC97_TUNE_HP_MUTE_LED, /* EAPD bit works as mute LED, use headphone control as master */ }; struct ac97_quirk { @@ -553,46 +578,24 @@ struct ac97_quirk { int type; /* quirk type above */ }; -int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, const char *override); -int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate); - -/* - * PCM allocation - */ - -enum ac97_pcm_cfg { - AC97_PCM_CFG_FRONT = 2, - AC97_PCM_CFG_REAR = 10, /* alias surround */ - AC97_PCM_CFG_LFE = 11, /* center + lfe */ - AC97_PCM_CFG_40 = 4, /* front + rear */ - AC97_PCM_CFG_51 = 6, /* front + rear + center/lfe */ - AC97_PCM_CFG_SPDIF = 20 -}; - -struct ac97_pcm { - struct snd_ac97_bus *bus; - unsigned int stream: 1, /* stream type: 1 = capture */ - exclusive: 1, /* exclusive mode, don't override with other pcms */ - copy_flag: 1, /* lowlevel driver must fill all entries */ - spdif: 1; /* spdif pcm */ - unsigned short aslots; /* active slots */ - unsigned int rates; /* available rates */ - struct { - unsigned short slots; /* driver input: requested AC97 slot numbers */ - unsigned short rslots[4]; /* allocated slots per codecs */ - unsigned char rate_table[4]; - struct snd_ac97 *codec[4]; /* allocated codecs */ - } r[2]; /* 0 = standard rates, 1 = double rates */ - unsigned long private_value; /* used by the hardware driver */ -}; +int snd_ac97_tune_hardware(ac97_t *ac97, struct ac97_quirk *quirk, const char *override); +int snd_ac97_set_rate(ac97_t *ac97, int reg, unsigned int rate); -int snd_ac97_pcm_assign(struct snd_ac97_bus *ac97, +int snd_ac97_pcm_assign(ac97_bus_t *ac97, unsigned short pcms_count, const struct ac97_pcm *pcms); int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate, enum ac97_pcm_cfg cfg, unsigned short slots); int snd_ac97_pcm_close(struct ac97_pcm *pcm); -int snd_ac97_pcm_double_rate_rules(struct snd_pcm_runtime *runtime); +int snd_ac97_pcm_double_rate_rules(snd_pcm_runtime_t *runtime); + +struct ac97_enum { + unsigned char reg; + unsigned char shift_l; + unsigned char shift_r; + unsigned short mask; + const char **texts; +}; /* ad hoc AC97 device driver access */ extern struct bus_type ac97_bus_type; diff --git a/trunk/include/sound/ad1816a.h b/trunk/include/sound/ad1816a.h index b3aa62ee3c8d..ca2e0e4fa937 100644 --- a/trunk/include/sound/ad1816a.h +++ b/trunk/include/sound/ad1816a.h @@ -123,7 +123,9 @@ #define AD1816A_CAPTURE_NOT_EQUAL 0x1000 #define AD1816A_WSS_ENABLE 0x8000 -struct snd_ad1816a { +typedef struct _snd_ad1816a ad1816a_t; + +struct _snd_ad1816a { unsigned long port; struct resource *res_port; int irq; @@ -138,15 +140,15 @@ struct snd_ad1816a { unsigned short mode; unsigned int clock_freq; - struct snd_card *card; - struct snd_pcm *pcm; + snd_card_t *card; + snd_pcm_t *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; unsigned int p_dma_size; unsigned int c_dma_size; - struct snd_timer *timer; + snd_timer_t *timer; }; @@ -163,11 +165,11 @@ struct snd_ad1816a { AD1816A_MODE_TIMER) -extern int snd_ad1816a_create(struct snd_card *card, unsigned long port, +extern int snd_ad1816a_create(snd_card_t *card, unsigned long port, int irq, int dma1, int dma2, - struct snd_ad1816a **chip); + ad1816a_t **chip); -extern int snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_pcm **rpcm); -extern int snd_ad1816a_mixer(struct snd_ad1816a *chip); +extern int snd_ad1816a_pcm(ad1816a_t *chip, int device, snd_pcm_t **rpcm); +extern int snd_ad1816a_mixer(ad1816a_t *chip); #endif /* __SOUND_AD1816A_H */ diff --git a/trunk/include/sound/ad1848.h b/trunk/include/sound/ad1848.h index 1a2759f3a292..7e33b11037f2 100644 --- a/trunk/include/sound/ad1848.h +++ b/trunk/include/sound/ad1848.h @@ -127,7 +127,7 @@ #define AD1848_THINKPAD_CTL_PORT2 0x15e9 #define AD1848_THINKPAD_CS4248_ENABLE_BIT 0x02 -struct snd_ad1848 { +struct _snd_ad1848 { unsigned long port; /* i/o port */ struct resource *res_port; int irq; /* IRQ line */ @@ -137,10 +137,10 @@ struct snd_ad1848 { unsigned short hardware; /* see to AD1848_HW_XXXX */ unsigned short single_dma:1; /* forced single DMA mode (GUS 16-bit daughter board) or dma1 == dma2 */ - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; - struct snd_card *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; + snd_card_t *card; unsigned char image[32]; /* SGalaxy needs an access to extended registers */ int mce_bit; @@ -148,28 +148,25 @@ struct snd_ad1848 { int dma_size; int thinkpad_flag; /* Thinkpad CS4248 needs some extra help */ -#ifdef CONFIG_PM - void (*suspend)(struct snd_ad1848 *chip); - void (*resume)(struct snd_ad1848 *chip); -#endif - spinlock_t reg_lock; struct semaphore open_mutex; }; +typedef struct _snd_ad1848 ad1848_t; + /* exported functions */ -void snd_ad1848_out(struct snd_ad1848 *chip, unsigned char reg, unsigned char value); +void snd_ad1848_out(ad1848_t *chip, unsigned char reg, unsigned char value); -int snd_ad1848_create(struct snd_card *card, +int snd_ad1848_create(snd_card_t * card, unsigned long port, int irq, int dma, unsigned short hardware, - struct snd_ad1848 ** chip); + ad1848_t ** chip); -int snd_ad1848_pcm(struct snd_ad1848 * chip, int device, struct snd_pcm **rpcm); -const struct snd_pcm_ops *snd_ad1848_get_pcm_ops(int direction); -int snd_ad1848_mixer(struct snd_ad1848 * chip); +int snd_ad1848_pcm(ad1848_t * chip, int device, snd_pcm_t **rpcm); +const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction); +int snd_ad1848_mixer(ad1848_t * chip); /* exported mixer stuffs */ enum { AD1848_MIX_SINGLE, AD1848_MIX_DOUBLE, AD1848_MIX_CAPTURE }; @@ -179,7 +176,7 @@ enum { AD1848_MIX_SINGLE, AD1848_MIX_DOUBLE, AD1848_MIX_CAPTURE }; #define AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) \ ((left_reg) | ((right_reg) << 8) | ((shift_left) << 16) | ((shift_right) << 19) | ((mask) << 24) | ((invert) << 22)) -int snd_ad1848_add_ctl(struct snd_ad1848 *chip, const char *name, int index, int type, unsigned long value); +int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, unsigned long value); /* for ease of use */ struct ad1848_mix_elem { @@ -201,7 +198,7 @@ struct ad1848_mix_elem { .type = AD1848_MIX_DOUBLE, \ .private_value = AD1848_MIXVAL_DOUBLE(left_reg, right_reg, shift_left, shift_right, mask, invert) } -static inline int snd_ad1848_add_ctl_elem(struct snd_ad1848 *chip, const struct ad1848_mix_elem *c) +static inline int snd_ad1848_add_ctl_elem(ad1848_t *chip, const struct ad1848_mix_elem *c) { return snd_ad1848_add_ctl(chip, c->name, c->index, c->type, c->private_value); } diff --git a/trunk/include/sound/ainstr_fm.h b/trunk/include/sound/ainstr_fm.h index c4afb1f121fe..0ec02953815a 100644 --- a/trunk/include/sound/ainstr_fm.h +++ b/trunk/include/sound/ainstr_fm.h @@ -39,13 +39,13 @@ * FM operator */ -struct fm_operator { +typedef struct fm_operator { unsigned char am_vib; unsigned char ksl_level; unsigned char attack_decay; unsigned char sustain_release; unsigned char wave_select; -}; +} fm_operator_t; /* * Instrument @@ -54,11 +54,11 @@ struct fm_operator { #define FM_PATCH_OPL2 0x01 /* OPL2 2 operators FM instrument */ #define FM_PATCH_OPL3 0x02 /* OPL3 4 operators FM instrument */ -struct fm_instrument { +typedef struct { unsigned int share_id[4]; /* share id - zero = no sharing */ unsigned char type; /* instrument type */ - struct fm_operator op[4]; + fm_operator_t op[4]; unsigned char feedback_connection[2]; unsigned char echo_delay; @@ -68,7 +68,7 @@ struct fm_instrument { unsigned char fix_dur; unsigned char modes; unsigned char fix_key; -}; +} fm_instrument_t; /* * @@ -88,25 +88,25 @@ struct fm_instrument { * FM operator */ -struct fm_xoperator { +typedef struct fm_xoperator { __u8 am_vib; __u8 ksl_level; __u8 attack_decay; __u8 sustain_release; __u8 wave_select; -}; +} fm_xoperator_t; /* * Instrument */ -struct fm_xinstrument { +typedef struct fm_xinstrument { __u32 stype; /* structure type */ __u32 share_id[4]; /* share id - zero = no sharing */ __u8 type; /* instrument type */ - struct fm_xoperator op[4]; /* fm operators */ + fm_xoperator_t op[4]; /* fm operators */ __u8 feedback_connection[2]; __u8 echo_delay; @@ -116,19 +116,15 @@ struct fm_xinstrument { __u8 fix_dur; __u8 modes; __u8 fix_key; -}; +} fm_xinstrument_t; #ifdef __KERNEL__ #include "seq_instr.h" -int snd_seq_fm_init(struct snd_seq_kinstr_ops * ops, - struct snd_seq_kinstr_ops * next); +int snd_seq_fm_init(snd_seq_kinstr_ops_t * ops, + snd_seq_kinstr_ops_t * next); #endif -/* typedefs for compatibility to user-space */ -typedef struct fm_xoperator fm_xoperator_t; -typedef struct fm_xinstrument fm_xinstrument_t; - #endif /* __SOUND_AINSTR_FM_H */ diff --git a/trunk/include/sound/ainstr_gf1.h b/trunk/include/sound/ainstr_gf1.h index 47726fe0f46d..ae2ddda63971 100644 --- a/trunk/include/sound/ainstr_gf1.h +++ b/trunk/include/sound/ainstr_gf1.h @@ -52,7 +52,7 @@ * Wavetable definitions */ -struct gf1_wave { +typedef struct gf1_wave { unsigned int share_id[4]; /* share id - zero = no sharing */ unsigned int format; /* wave format */ @@ -88,7 +88,7 @@ struct gf1_wave { unsigned short scale_factor; /* 0-2048 or 0-2 */ struct gf1_wave *next; -}; +} gf1_wave_t; /* * Instrument @@ -103,7 +103,7 @@ struct gf1_wave { #define IWFFFF_EFFECT_CHORUS 2 #define IWFFFF_EFFECT_ECHO 3 -struct gf1_instrument { +typedef struct { unsigned short exclusion; unsigned short exclusion_group; /* 0 - none, 1-65535 */ @@ -112,8 +112,8 @@ struct gf1_instrument { unsigned char effect2; /* effect 2 */ unsigned char effect2_depth; /* 0-127 */ - struct gf1_wave *wave; /* first waveform */ -}; + gf1_wave_t *wave; /* first waveform */ +} gf1_instrument_t; /* * @@ -135,7 +135,7 @@ struct gf1_instrument { * Wavetable definitions */ -struct gf1_xwave { +typedef struct gf1_xwave { __u32 stype; /* structure type */ __u32 share_id[4]; /* share id - zero = no sharing */ @@ -165,13 +165,13 @@ struct gf1_xwave { __u8 vibrato_depth; __u16 scale_frequency; __u16 scale_factor; /* 0-2048 or 0-2 */ -}; +} gf1_xwave_t; /* * Instrument */ -struct gf1_xinstrument { +typedef struct gf1_xinstrument { __u32 stype; __u16 exclusion; @@ -181,7 +181,7 @@ struct gf1_xinstrument { __u8 effect1_depth; /* 0-127 */ __u8 effect2; /* effect 2 */ __u8 effect2_depth; /* 0-127 */ -}; +} gf1_xinstrument_t; /* * Instrument info @@ -191,39 +191,35 @@ struct gf1_xinstrument { #define GF1_INFO_TREMOLO (1<<1) #define GF1_INFO_VIBRATO (1<<2) -struct gf1_info { +typedef struct gf1_info { unsigned char flags; /* supported wave flags */ unsigned char pad[3]; unsigned int features; /* supported features */ unsigned int max8_len; /* maximum 8-bit wave length */ unsigned int max16_len; /* maximum 16-bit wave length */ -}; +} gf1_info_t; #ifdef __KERNEL__ #include "seq_instr.h" -struct snd_gf1_ops { +typedef struct { void *private_data; - int (*info)(void *private_data, struct gf1_info *info); - int (*put_sample)(void *private_data, struct gf1_wave *wave, + int (*info)(void *private_data, gf1_info_t *info); + int (*put_sample)(void *private_data, gf1_wave_t *wave, char __user *data, long len, int atomic); - int (*get_sample)(void *private_data, struct gf1_wave *wave, + int (*get_sample)(void *private_data, gf1_wave_t *wave, char __user *data, long len, int atomic); - int (*remove_sample)(void *private_data, struct gf1_wave *wave, + int (*remove_sample)(void *private_data, gf1_wave_t *wave, int atomic); - void (*notify)(void *private_data, struct snd_seq_kinstr *instr, int what); - struct snd_seq_kinstr_ops kops; -}; + void (*notify)(void *private_data, snd_seq_kinstr_t *instr, int what); + snd_seq_kinstr_ops_t kops; +} snd_gf1_ops_t; -int snd_seq_gf1_init(struct snd_gf1_ops *ops, +int snd_seq_gf1_init(snd_gf1_ops_t *ops, void *private_data, - struct snd_seq_kinstr_ops *next); + snd_seq_kinstr_ops_t *next); #endif -/* typedefs for compatibility to user-space */ -typedef struct gf1_xwave gf1_xwave_t; -typedef struct gf1_xinstrument gf1_xinstrument_t; - #endif /* __SOUND_AINSTR_GF1_H */ diff --git a/trunk/include/sound/ainstr_iw.h b/trunk/include/sound/ainstr_iw.h index 251feaf1b388..8adf744926ff 100644 --- a/trunk/include/sound/ainstr_iw.h +++ b/trunk/include/sound/ainstr_iw.h @@ -54,7 +54,7 @@ * Wavetable definitions */ -struct iwffff_wave { +typedef struct iwffff_wave { unsigned int share_id[4]; /* share id - zero = no sharing */ unsigned int format; /* wave format */ @@ -76,7 +76,7 @@ struct iwffff_wave { unsigned char pad; struct iwffff_wave *next; -}; +} iwffff_wave_t; /* * Layer @@ -85,13 +85,13 @@ struct iwffff_wave { #define IWFFFF_LFO_SHAPE_TRIANGLE 0 #define IWFFFF_LFO_SHAPE_POSTRIANGLE 1 -struct iwffff_lfo { +typedef struct iwffff_lfo { unsigned short freq; /* (0-2047) 0.01Hz - 21.5Hz */ signed short depth; /* volume +- (0-255) 0.48675dB/step */ signed short sweep; /* 0 - 950 deciseconds */ unsigned char shape; /* see to IWFFFF_LFO_SHAPE_XXXX */ unsigned char delay; /* 0 - 255 deciseconds */ -}; +} iwffff_lfo_t; #define IWFFFF_ENV_FLAG_RETRIGGER 0x0001 /* flag - retrigger */ @@ -102,12 +102,12 @@ struct iwffff_lfo { #define IWFFFF_ENV_INDEX_VELOCITY 0x0001 /* index - velocity */ #define IWFFFF_ENV_INDEX_FREQUENCY 0x0002 /* index - frequency */ -struct iwffff_env_point { +typedef struct iwffff_env_point { unsigned short offset; unsigned short rate; -}; +} iwffff_env_point_t; -struct iwffff_env_record { +typedef struct iwffff_env_record { unsigned short nattack; unsigned short nrelease; unsigned short sustain_offset; @@ -118,15 +118,15 @@ struct iwffff_env_record { struct iwffff_env_record *next; /* points are stored here */ /* count of points = nattack + nrelease */ -}; +} iwffff_env_record_t; -struct iwffff_env { +typedef struct iwffff_env { unsigned char flags; unsigned char mode; unsigned char index; unsigned char pad; struct iwffff_env_record *record; -}; +} iwffff_env_t; #define IWFFFF_LAYER_FLAG_RETRIGGER 0x0001 /* retrigger */ @@ -138,7 +138,7 @@ struct iwffff_env { #define IWFFFF_LAYER_EVENT_RETRIG 0x0002 /* layer event - retrigger */ #define IWFFFF_LAYER_EVENT_LEGATO 0x0003 /* layer event - legato */ -struct iwffff_layer { +typedef struct iwffff_layer { unsigned char flags; unsigned char velocity_mode; unsigned char layer_event; @@ -147,17 +147,17 @@ struct iwffff_layer { unsigned char pan; /* pan offset from CC1 (0 left - 127 right) */ unsigned char pan_freq_scale; /* position based on frequency (0-127) */ unsigned char attenuation; /* 0-127 (no corresponding midi controller) */ - struct iwffff_lfo tremolo; /* tremolo effect */ - struct iwffff_lfo vibrato; /* vibrato effect */ + iwffff_lfo_t tremolo; /* tremolo effect */ + iwffff_lfo_t vibrato; /* vibrato effect */ unsigned short freq_scale; /* 0-2048, 1024 is equal to semitone scaling */ unsigned char freq_center; /* center for keyboard frequency scaling */ unsigned char pad; - struct iwffff_env penv; /* pitch envelope */ - struct iwffff_env venv; /* volume envelope */ + iwffff_env_t penv; /* pitch envelope */ + iwffff_env_t venv; /* volume envelope */ - struct iwffff_wave *wave; + iwffff_wave_t *wave; struct iwffff_layer *next; -}; +} iwffff_layer_t; /* * Instrument @@ -177,7 +177,7 @@ struct iwffff_layer { #define IWFFFF_EFFECT_CHORUS 2 #define IWFFFF_EFFECT_ECHO 3 -struct iwffff_instrument { +typedef struct { unsigned short exclusion; unsigned short layer_type; unsigned short exclusion_group; /* 0 - none, 1-65535 */ @@ -187,8 +187,8 @@ struct iwffff_instrument { unsigned char effect2; /* effect 2 */ unsigned char effect2_depth; /* 0-127 */ - struct iwffff_layer *layer; /* first layer */ -}; + iwffff_layer_t *layer; /* first layer */ +} iwffff_instrument_t; /* * @@ -216,7 +216,7 @@ struct iwffff_instrument { * Wavetable definitions */ -struct iwffff_xwave { +typedef struct iwffff_xwave { __u32 stype; /* structure type */ __u32 share_id[4]; /* share id - zero = no sharing */ @@ -234,26 +234,26 @@ struct iwffff_xwave { __u8 low_note; /* lower frequency range for this waveform */ __u8 high_note; /* higher frequency range for this waveform */ __u8 pad; -}; +} iwffff_xwave_t; /* * Layer */ -struct iwffff_xlfo { +typedef struct iwffff_xlfo { __u16 freq; /* (0-2047) 0.01Hz - 21.5Hz */ __s16 depth; /* volume +- (0-255) 0.48675dB/step */ __s16 sweep; /* 0 - 950 deciseconds */ __u8 shape; /* see to ULTRA_IW_LFO_SHAPE_XXXX */ __u8 delay; /* 0 - 255 deciseconds */ -}; +} iwffff_xlfo_t; -struct iwffff_xenv_point { +typedef struct iwffff_xenv_point { __u16 offset; __u16 rate; -}; +} iwffff_xenv_point_t; -struct iwffff_xenv_record { +typedef struct iwffff_xenv_record { __u32 stype; __u16 nattack; __u16 nrelease; @@ -264,16 +264,16 @@ struct iwffff_xenv_record { __u8 pad; /* points are stored here.. */ /* count of points = nattack + nrelease */ -}; +} iwffff_xenv_record_t; -struct iwffff_xenv { +typedef struct iwffff_xenv { __u8 flags; __u8 mode; __u8 index; __u8 pad; -}; +} iwffff_xenv_t; -struct iwffff_xlayer { +typedef struct iwffff_xlayer { __u32 stype; __u8 flags; __u8 velocity_mode; @@ -283,20 +283,20 @@ struct iwffff_xlayer { __u8 pan; /* pan offset from CC1 (0 left - 127 right) */ __u8 pan_freq_scale; /* position based on frequency (0-127) */ __u8 attenuation; /* 0-127 (no corresponding midi controller) */ - struct iwffff_xlfo tremolo; /* tremolo effect */ - struct iwffff_xlfo vibrato; /* vibrato effect */ + iwffff_xlfo_t tremolo; /* tremolo effect */ + iwffff_xlfo_t vibrato; /* vibrato effect */ __u16 freq_scale; /* 0-2048, 1024 is equal to semitone scaling */ __u8 freq_center; /* center for keyboard frequency scaling */ __u8 pad; - struct iwffff_xenv penv; /* pitch envelope */ - struct iwffff_xenv venv; /* volume envelope */ -}; + iwffff_xenv_t penv; /* pitch envelope */ + iwffff_xenv_t venv; /* volume envelope */ +} iwffff_xlayer_t; /* * Instrument */ -struct iwffff_xinstrument { +typedef struct iwffff_xinstrument { __u32 stype; __u16 exclusion; @@ -307,7 +307,7 @@ struct iwffff_xinstrument { __u8 effect1_depth; /* 0-127 */ __u8 effect2; /* effect 2 */ __u8 effect2_depth; /* 0-127 */ -}; +} iwffff_xinstrument_t; /* * ROM support @@ -316,7 +316,7 @@ struct iwffff_xinstrument { #define IWFFFF_ROM_HDR_SIZE 512 -struct iwffff_rom_header { +typedef struct { __u8 iwave[8]; __u8 revision; __u8 series_number; @@ -328,7 +328,7 @@ struct iwffff_rom_header { __u8 copyright[128]; __u8 vendor_name[64]; __u8 description[128]; -}; +} iwffff_rom_header_t; /* * Instrument info @@ -339,46 +339,35 @@ struct iwffff_rom_header { #define IWFFFF_INFO_LFO_TREMOLO (1<<2) #define IWFFFF_INFO_LFO_TREMOLO_SHAPE (1<<3) -struct iwffff_info { +typedef struct iwffff_info { unsigned int format; /* supported format bits */ unsigned int effects; /* supported effects (1 << IWFFFF_EFFECT*) */ unsigned int lfos; /* LFO effects */ unsigned int max8_len; /* maximum 8-bit wave length */ unsigned int max16_len; /* maximum 16-bit wave length */ -}; +} iwffff_info_t; #ifdef __KERNEL__ #include "seq_instr.h" -struct snd_iwffff_ops { +typedef struct { void *private_data; - int (*info)(void *private_data, struct iwffff_info *info); - int (*put_sample)(void *private_data, struct iwffff_wave *wave, + int (*info)(void *private_data, iwffff_info_t *info); + int (*put_sample)(void *private_data, iwffff_wave_t *wave, char __user *data, long len, int atomic); - int (*get_sample)(void *private_data, struct iwffff_wave *wave, + int (*get_sample)(void *private_data, iwffff_wave_t *wave, char __user *data, long len, int atomic); - int (*remove_sample)(void *private_data, struct iwffff_wave *wave, + int (*remove_sample)(void *private_data, iwffff_wave_t *wave, int atomic); - void (*notify)(void *private_data, struct snd_seq_kinstr *instr, int what); - struct snd_seq_kinstr_ops kops; -}; + void (*notify)(void *private_data, snd_seq_kinstr_t *instr, int what); + snd_seq_kinstr_ops_t kops; +} snd_iwffff_ops_t; -int snd_seq_iwffff_init(struct snd_iwffff_ops *ops, +int snd_seq_iwffff_init(snd_iwffff_ops_t *ops, void *private_data, - struct snd_seq_kinstr_ops *next); + snd_seq_kinstr_ops_t *next); #endif -/* typedefs for compatibility to user-space */ -typedef struct iwffff_xwave iwffff_xwave_t; -typedef struct iwffff_xlfo iwffff_xlfo_t; -typedef struct iwffff_xenv_point iwffff_xenv_point_t; -typedef struct iwffff_xenv_record iwffff_xenv_record_t; -typedef struct iwffff_xenv iwffff_xenv_t; -typedef struct iwffff_xlayer iwffff_xlayer_t; -typedef struct iwffff_xinstrument iwffff_xinstrument_t; -typedef struct iwffff_rom_header iwffff_rom_header_t; -typedef struct iwffff_info iwffff_info_t; - #endif /* __SOUND_AINSTR_IW_H */ diff --git a/trunk/include/sound/ainstr_simple.h b/trunk/include/sound/ainstr_simple.h index 5eead12e58ae..40824b4ab23d 100644 --- a/trunk/include/sound/ainstr_simple.h +++ b/trunk/include/sound/ainstr_simple.h @@ -61,18 +61,18 @@ * instrument info */ -struct simple_instrument_info { +typedef struct simple_instrument_info { unsigned int format; /* supported format bits */ unsigned int effects; /* supported effects (1 << SIMPLE_EFFECT_*) */ unsigned int max8_len; /* maximum 8-bit wave length */ unsigned int max16_len; /* maximum 16-bit wave length */ -}; +} simple_instrument_info_t; /* * Instrument */ -struct simple_instrument { +typedef struct { unsigned int share_id[4]; /* share id - zero = no sharing */ unsigned int format; /* wave format */ @@ -92,7 +92,7 @@ struct simple_instrument { unsigned char effect1_depth; /* 0-127 */ unsigned char effect2; /* effect 2 */ unsigned char effect2_depth; /* 0-127 */ -}; +} simple_instrument_t; /* * @@ -112,7 +112,7 @@ struct simple_instrument { * Instrument */ -struct simple_xinstrument { +typedef struct simple_xinstrument { __u32 stype; __u32 share_id[4]; /* share id - zero = no sharing */ @@ -128,32 +128,29 @@ struct simple_xinstrument { __u8 effect1_depth; /* 0-127 */ __u8 effect2; /* effect 2 */ __u8 effect2_depth; /* 0-127 */ -}; +} simple_xinstrument_t; #ifdef __KERNEL__ #include "seq_instr.h" -struct snd_simple_ops { +typedef struct { void *private_data; - int (*info)(void *private_data, struct simple_instrument_info *info); - int (*put_sample)(void *private_data, struct simple_instrument *instr, + int (*info)(void *private_data, simple_instrument_info_t *info); + int (*put_sample)(void *private_data, simple_instrument_t *instr, char __user *data, long len, int atomic); - int (*get_sample)(void *private_data, struct simple_instrument *instr, + int (*get_sample)(void *private_data, simple_instrument_t *instr, char __user *data, long len, int atomic); - int (*remove_sample)(void *private_data, struct simple_instrument *instr, + int (*remove_sample)(void *private_data, simple_instrument_t *instr, int atomic); - void (*notify)(void *private_data, struct snd_seq_kinstr *instr, int what); - struct snd_seq_kinstr_ops kops; -}; + void (*notify)(void *private_data, snd_seq_kinstr_t *instr, int what); + snd_seq_kinstr_ops_t kops; +} snd_simple_ops_t; -int snd_seq_simple_init(struct snd_simple_ops *ops, +int snd_seq_simple_init(snd_simple_ops_t *ops, void *private_data, - struct snd_seq_kinstr_ops *next); + snd_seq_kinstr_ops_t *next); #endif -/* typedefs for compatibility to user-space */ -typedef struct simple_xinstrument simple_xinstrument_t; - #endif /* __SOUND_AINSTR_SIMPLE_H */ diff --git a/trunk/include/sound/ak4114.h b/trunk/include/sound/ak4114.h index 11702aa0bea9..f3f2c3e5ae51 100644 --- a/trunk/include/sound/ak4114.h +++ b/trunk/include/sound/ak4114.h @@ -163,8 +163,10 @@ typedef void (ak4114_write_t)(void *private_data, unsigned char addr, unsigned char data); typedef unsigned char (ak4114_read_t)(void *private_data, unsigned char addr); +typedef struct ak4114 ak4114_t; + struct ak4114 { - struct snd_card *card; + snd_card_t * card; ak4114_write_t * write; ak4114_read_t * read; void * private_data; @@ -172,9 +174,9 @@ struct ak4114 { spinlock_t lock; unsigned char regmap[7]; unsigned char txcsb[5]; - struct snd_kcontrol *kctls[AK4114_CONTROLS]; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_kcontrol_t *kctls[AK4114_CONTROLS]; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; unsigned long parity_errors; unsigned long v_bit_errors; unsigned long qcrc_errors; @@ -184,20 +186,20 @@ struct ak4114 { struct workqueue_struct *workqueue; struct work_struct work; void *change_callback_private; - void (*change_callback)(struct ak4114 *ak4114, unsigned char c0, unsigned char c1); + void (*change_callback)(ak4114_t *ak4114, unsigned char c0, unsigned char c1); }; -int snd_ak4114_create(struct snd_card *card, +int snd_ak4114_create(snd_card_t *card, ak4114_read_t *read, ak4114_write_t *write, unsigned char pgm[7], unsigned char txcsb[5], - void *private_data, struct ak4114 **r_ak4114); -void snd_ak4114_reg_write(struct ak4114 *ak4114, unsigned char reg, unsigned char mask, unsigned char val); -void snd_ak4114_reinit(struct ak4114 *ak4114); -int snd_ak4114_build(struct ak4114 *ak4114, - struct snd_pcm_substream *playback_substream, - struct snd_pcm_substream *capture_substream); -int snd_ak4114_external_rate(struct ak4114 *ak4114); -int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags); + void *private_data, ak4114_t **r_ak4114); +void snd_ak4114_reg_write(ak4114_t *ak4114, unsigned char reg, unsigned char mask, unsigned char val); +void snd_ak4114_reinit(ak4114_t *ak4114); +int snd_ak4114_build(ak4114_t *ak4114, + snd_pcm_substream_t *playback_substream, + snd_pcm_substream_t *capture_substream); +int snd_ak4114_external_rate(ak4114_t *ak4114); +int snd_ak4114_check_rate_and_errors(ak4114_t *ak4114, unsigned int flags); #endif /* __SOUND_AK4114_H */ diff --git a/trunk/include/sound/ak4117.h b/trunk/include/sound/ak4117.h index 2b96c32f06fd..9e1dab17c33e 100644 --- a/trunk/include/sound/ak4117.h +++ b/trunk/include/sound/ak4117.h @@ -155,16 +155,18 @@ typedef void (ak4117_write_t)(void *private_data, unsigned char addr, unsigned char data); typedef unsigned char (ak4117_read_t)(void *private_data, unsigned char addr); +typedef struct ak4117 ak4117_t; + struct ak4117 { - struct snd_card *card; + snd_card_t * card; ak4117_write_t * write; ak4117_read_t * read; void * private_data; unsigned int init: 1; spinlock_t lock; unsigned char regmap[5]; - struct snd_kcontrol *kctls[AK4117_CONTROLS]; - struct snd_pcm_substream *substream; + snd_kcontrol_t *kctls[AK4117_CONTROLS]; + snd_pcm_substream_t *substream; unsigned long parity_errors; unsigned long v_bit_errors; unsigned long qcrc_errors; @@ -174,16 +176,16 @@ struct ak4117 { unsigned char rcs2; struct timer_list timer; /* statistic timer */ void *change_callback_private; - void (*change_callback)(struct ak4117 *ak4117, unsigned char c0, unsigned char c1); + void (*change_callback)(ak4117_t *ak4117, unsigned char c0, unsigned char c1); }; -int snd_ak4117_create(struct snd_card *card, ak4117_read_t *read, ak4117_write_t *write, - unsigned char pgm[5], void *private_data, struct ak4117 **r_ak4117); -void snd_ak4117_reg_write(struct ak4117 *ak4117, unsigned char reg, unsigned char mask, unsigned char val); -void snd_ak4117_reinit(struct ak4117 *ak4117); -int snd_ak4117_build(struct ak4117 *ak4117, struct snd_pcm_substream *capture_substream); -int snd_ak4117_external_rate(struct ak4117 *ak4117); -int snd_ak4117_check_rate_and_errors(struct ak4117 *ak4117, unsigned int flags); +int snd_ak4117_create(snd_card_t *card, ak4117_read_t *read, ak4117_write_t *write, + unsigned char pgm[5], void *private_data, ak4117_t **r_ak4117); +void snd_ak4117_reg_write(ak4117_t *ak4117, unsigned char reg, unsigned char mask, unsigned char val); +void snd_ak4117_reinit(ak4117_t *ak4117); +int snd_ak4117_build(ak4117_t *ak4117, snd_pcm_substream_t *capture_substream); +int snd_ak4117_external_rate(ak4117_t *ak4117); +int snd_ak4117_check_rate_and_errors(ak4117_t *ak4117, unsigned int flags); #endif /* __SOUND_AK4117_H */ diff --git a/trunk/include/sound/ak4531_codec.h b/trunk/include/sound/ak4531_codec.h index edf04070ce7c..8b18992376d5 100644 --- a/trunk/include/sound/ak4531_codec.h +++ b/trunk/include/sound/ak4531_codec.h @@ -64,22 +64,17 @@ #define AK4531_AD_IN 0x18 /* AD input select */ #define AK4531_MIC_GAIN 0x19 /* MIC amplified gain */ -struct snd_ak4531 { - void (*write) (struct snd_ak4531 *ak4531, unsigned short reg, - unsigned short val); +typedef struct _snd_ak4531 ak4531_t; + +struct _snd_ak4531 { + void (*write) (ak4531_t *ak4531, unsigned short reg, unsigned short val); void *private_data; - void (*private_free) (struct snd_ak4531 *ak4531); + void (*private_free) (ak4531_t *ak4531); /* --- */ unsigned char regs[0x20]; struct semaphore reg_mutex; }; -int snd_ak4531_mixer(struct snd_card *card, struct snd_ak4531 *_ak4531, - struct snd_ak4531 **rak4531); - -#ifdef CONFIG_PM -void snd_ak4531_suspend(struct snd_ak4531 *ak4531); -void snd_ak4531_resume(struct snd_ak4531 *ak4531); -#endif +int snd_ak4531_mixer(snd_card_t * card, ak4531_t * _ak4531, ak4531_t ** rak4531); #endif /* __SOUND_AK4531_CODEC_H */ diff --git a/trunk/include/sound/ak4xxx-adda.h b/trunk/include/sound/ak4xxx-adda.h index 3bf5911fe827..e94ac0282318 100644 --- a/trunk/include/sound/ak4xxx-adda.h +++ b/trunk/include/sound/ak4xxx-adda.h @@ -27,20 +27,20 @@ #define AK4XXX_MAX_CHIPS 4 #endif -struct snd_akm4xxx; +typedef struct snd_akm4xxx akm4xxx_t; struct snd_ak4xxx_ops { - void (*lock)(struct snd_akm4xxx *ak, int chip); - void (*unlock)(struct snd_akm4xxx *ak, int chip); - void (*write)(struct snd_akm4xxx *ak, int chip, unsigned char reg, unsigned char val); - // unsigned char (*read)(struct snd_akm4xxx *ak, int chip, unsigned char reg); - void (*set_rate_val)(struct snd_akm4xxx *ak, unsigned int rate); + void (*lock)(akm4xxx_t *ak, int chip); + void (*unlock)(akm4xxx_t *ak, int chip); + void (*write)(akm4xxx_t *ak, int chip, unsigned char reg, unsigned char val); + // unsigned char (*read)(akm4xxx_t *ak, int chip, unsigned char reg); + void (*set_rate_val)(akm4xxx_t *ak, unsigned int rate); }; #define AK4XXX_IMAGE_SIZE (AK4XXX_MAX_CHIPS * 16) /* 64 bytes */ struct snd_akm4xxx { - struct snd_card *card; + snd_card_t *card; unsigned int num_adcs; /* AK4524 or AK4528 ADCs */ unsigned int num_dacs; /* AK4524 or AK4528 DACs */ unsigned char images[AK4XXX_IMAGE_SIZE]; /* saved register image */ @@ -56,10 +56,10 @@ struct snd_akm4xxx { struct snd_ak4xxx_ops ops; }; -void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg, unsigned char val); -void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state); -void snd_akm4xxx_init(struct snd_akm4xxx *ak); -int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak); +void snd_akm4xxx_write(akm4xxx_t *ak, int chip, unsigned char reg, unsigned char val); +void snd_akm4xxx_reset(akm4xxx_t *ak, int state); +void snd_akm4xxx_init(akm4xxx_t *ak); +int snd_akm4xxx_build_controls(akm4xxx_t *ak); #define snd_akm4xxx_get(ak,chip,reg) (ak)->images[(chip) * 16 + (reg)] #define snd_akm4xxx_set(ak,chip,reg,val) ((ak)->images[(chip) * 16 + (reg)] = (val)) diff --git a/trunk/include/sound/asequencer.h b/trunk/include/sound/asequencer.h index 6691e4aa4ea7..728efd504262 100644 --- a/trunk/include/sound/asequencer.h +++ b/trunk/include/sound/asequencer.h @@ -22,11 +22,12 @@ #ifndef __SOUND_ASEQUENCER_H #define __SOUND_ASEQUENCER_H -#ifdef __KERNEL__ +#ifndef __KERNEL__ #include -#include #endif +#include + /** version of the sequencer */ #define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION (1, 0, 1) @@ -35,13 +36,13 @@ */ /** system messages - * event data type = #snd_seq_result + * event data type = #sndrv_seq_result_t */ #define SNDRV_SEQ_EVENT_SYSTEM 0 #define SNDRV_SEQ_EVENT_RESULT 1 /** note messages (channel specific) - * event data type = #snd_seq_ev_note + * event data type = #sndrv_seq_ev_note */ #define SNDRV_SEQ_EVENT_NOTE 5 #define SNDRV_SEQ_EVENT_NOTEON 6 @@ -49,7 +50,7 @@ #define SNDRV_SEQ_EVENT_KEYPRESS 8 /** control messages (channel specific) - * event data type = #snd_seq_ev_ctrl + * event data type = #sndrv_seq_ev_ctrl */ #define SNDRV_SEQ_EVENT_CONTROLLER 10 #define SNDRV_SEQ_EVENT_PGMCHANGE 11 @@ -60,7 +61,7 @@ #define SNDRV_SEQ_EVENT_REGPARAM 16 /**< 14 bit RPN address + 14 bit unsigned value */ /** synchronisation messages - * event data type = #snd_seq_ev_ctrl + * event data type = #sndrv_seq_ev_ctrl */ #define SNDRV_SEQ_EVENT_SONGPOS 20 /* Song Position Pointer with LSB and MSB values */ #define SNDRV_SEQ_EVENT_SONGSEL 21 /* Song Select with song ID number */ @@ -69,7 +70,7 @@ #define SNDRV_SEQ_EVENT_KEYSIGN 24 /* SMF Key Signature event */ /** timer messages - * event data type = snd_seq_ev_queue_control + * event data type = sndrv_seq_ev_queue_control_t */ #define SNDRV_SEQ_EVENT_START 30 /* midi Real Time Start message */ #define SNDRV_SEQ_EVENT_CONTINUE 31 /* midi Real Time Continue message */ @@ -95,7 +96,7 @@ #define SNDRV_SEQ_EVENT_OSS 51 /* OSS raw event */ /** system status messages (broadcast for subscribers) - * event data type = snd_seq_addr + * event data type = sndrv_seq_addr_t */ #define SNDRV_SEQ_EVENT_CLIENT_START 60 /* new client has connected */ #define SNDRV_SEQ_EVENT_CLIENT_EXIT 61 /* client has left the system */ @@ -105,13 +106,13 @@ #define SNDRV_SEQ_EVENT_PORT_CHANGE 65 /* port status/info has changed */ /** port connection changes - * event data type = snd_seq_connect + * event data type = sndrv_seq_connect_t */ #define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED 66 /* ports connected */ #define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67 /* ports disconnected */ /** synthesizer events - * event data type = snd_seq_eve_sample_control + * event data type = sndrv_seq_eve_sample_control_t */ #define SNDRV_SEQ_EVENT_SAMPLE 70 /* sample select */ #define SNDRV_SEQ_EVENT_SAMPLE_CLUSTER 71 /* sample cluster select */ @@ -162,7 +163,7 @@ /* 119-129: reserved */ /* 130-139: variable length events - * event data type = snd_seq_ev_ext + * event data type = sndrv_seq_ev_ext * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set) */ #define SNDRV_SEQ_EVENT_SYSEX 130 /* system exclusive data (variable length) */ @@ -186,18 +187,18 @@ #define SNDRV_SEQ_EVENT_NONE 255 -typedef unsigned char snd_seq_event_type_t; +typedef unsigned char sndrv_seq_event_type_t; /** event address */ -struct snd_seq_addr { +struct sndrv_seq_addr { unsigned char client; /**< Client number: 0..255, 255 = broadcast to all clients */ unsigned char port; /**< Port within client: 0..255, 255 = broadcast to all ports */ }; /** port connection */ -struct snd_seq_connect { - struct snd_seq_addr sender; - struct snd_seq_addr dest; +struct sndrv_seq_connect { + struct sndrv_seq_addr sender; + struct sndrv_seq_addr dest; }; @@ -226,7 +227,7 @@ struct snd_seq_connect { /* note event */ -struct snd_seq_ev_note { +struct sndrv_seq_ev_note { unsigned char channel; unsigned char note; unsigned char velocity; @@ -235,7 +236,7 @@ struct snd_seq_ev_note { }; /* controller event */ -struct snd_seq_ev_ctrl { +struct sndrv_seq_ev_ctrl { unsigned char channel; unsigned char unused1, unused2, unused3; /* pad */ unsigned int param; @@ -243,59 +244,59 @@ struct snd_seq_ev_ctrl { }; /* generic set of bytes (12x8 bit) */ -struct snd_seq_ev_raw8 { +struct sndrv_seq_ev_raw8 { unsigned char d[12]; /* 8 bit value */ }; /* generic set of integers (3x32 bit) */ -struct snd_seq_ev_raw32 { +struct sndrv_seq_ev_raw32 { unsigned int d[3]; /* 32 bit value */ }; /* external stored data */ -struct snd_seq_ev_ext { +struct sndrv_seq_ev_ext { unsigned int len; /* length of data */ void *ptr; /* pointer to data (note: maybe 64-bit) */ } __attribute__((packed)); /* Instrument cluster type */ -typedef unsigned int snd_seq_instr_cluster_t; +typedef unsigned int sndrv_seq_instr_cluster_t; /* Instrument type */ -struct snd_seq_instr { - snd_seq_instr_cluster_t cluster; +struct sndrv_seq_instr { + sndrv_seq_instr_cluster_t cluster; unsigned int std; /* the upper byte means a private instrument (owner - client #) */ unsigned short bank; unsigned short prg; }; /* sample number */ -struct snd_seq_ev_sample { +struct sndrv_seq_ev_sample { unsigned int std; unsigned short bank; unsigned short prg; }; /* sample cluster */ -struct snd_seq_ev_cluster { - snd_seq_instr_cluster_t cluster; +struct sndrv_seq_ev_cluster { + sndrv_seq_instr_cluster_t cluster; }; /* sample position */ -typedef unsigned int snd_seq_position_t; /* playback position (in samples) * 16 */ +typedef unsigned int sndrv_seq_position_t; /* playback position (in samples) * 16 */ /* sample stop mode */ -enum { +enum sndrv_seq_stop_mode { SAMPLE_STOP_IMMEDIATELY = 0, /* terminate playing immediately */ SAMPLE_STOP_VENVELOPE = 1, /* finish volume envelope */ SAMPLE_STOP_LOOP = 2 /* terminate loop and finish wave */ }; /* sample frequency */ -typedef int snd_seq_frequency_t; /* playback frequency in HZ * 16 */ +typedef int sndrv_seq_frequency_t; /* playback frequency in HZ * 16 */ /* sample volume control; if any value is set to -1 == do not change */ -struct snd_seq_ev_volume { +struct sndrv_seq_ev_volume { signed short volume; /* range: 0-16383 */ signed short lr; /* left-right balance; range: 0-16383 */ signed short fr; /* front-rear balance; range: 0-16383 */ @@ -303,22 +304,22 @@ struct snd_seq_ev_volume { }; /* simple loop redefinition */ -struct snd_seq_ev_loop { +struct sndrv_seq_ev_loop { unsigned int start; /* loop start (in samples) * 16 */ unsigned int end; /* loop end (in samples) * 16 */ }; -struct snd_seq_ev_sample_control { +struct sndrv_seq_ev_sample_control { unsigned char channel; unsigned char unused1, unused2, unused3; /* pad */ union { - struct snd_seq_ev_sample sample; - struct snd_seq_ev_cluster cluster; - snd_seq_position_t position; - int stop_mode; - snd_seq_frequency_t frequency; - struct snd_seq_ev_volume volume; - struct snd_seq_ev_loop loop; + struct sndrv_seq_ev_sample sample; + struct sndrv_seq_ev_cluster cluster; + sndrv_seq_position_t position; + enum sndrv_seq_stop_mode stop_mode; + sndrv_seq_frequency_t frequency; + struct sndrv_seq_ev_volume volume; + struct sndrv_seq_ev_loop loop; unsigned char raw8[8]; } param; }; @@ -326,82 +327,82 @@ struct snd_seq_ev_sample_control { /* INSTR_BEGIN event */ -struct snd_seq_ev_instr_begin { +struct sndrv_seq_ev_instr_begin { int timeout; /* zero = forever, otherwise timeout in ms */ }; -struct snd_seq_result { +struct sndrv_seq_result { int event; /* processed event type */ int result; }; -struct snd_seq_real_time { +struct sndrv_seq_real_time { unsigned int tv_sec; /* seconds */ unsigned int tv_nsec; /* nanoseconds */ }; -typedef unsigned int snd_seq_tick_time_t; /* midi ticks */ +typedef unsigned int sndrv_seq_tick_time_t; /* midi ticks */ -union snd_seq_timestamp { - snd_seq_tick_time_t tick; - struct snd_seq_real_time time; +union sndrv_seq_timestamp { + sndrv_seq_tick_time_t tick; + struct sndrv_seq_real_time time; }; -struct snd_seq_queue_skew { +struct sndrv_seq_queue_skew { unsigned int value; unsigned int base; }; /* queue timer control */ -struct snd_seq_ev_queue_control { +struct sndrv_seq_ev_queue_control { unsigned char queue; /* affected queue */ unsigned char pad[3]; /* reserved */ union { signed int value; /* affected value (e.g. tempo) */ - union snd_seq_timestamp time; /* time */ + union sndrv_seq_timestamp time; /* time */ unsigned int position; /* sync position */ - struct snd_seq_queue_skew skew; + struct sndrv_seq_queue_skew skew; unsigned int d32[2]; unsigned char d8[8]; } param; }; /* quoted event - inside the kernel only */ -struct snd_seq_ev_quote { - struct snd_seq_addr origin; /* original sender */ +struct sndrv_seq_ev_quote { + struct sndrv_seq_addr origin; /* original sender */ unsigned short value; /* optional data */ - struct snd_seq_event *event; /* quoted event */ + struct sndrv_seq_event *event; /* quoted event */ } __attribute__((packed)); /* sequencer event */ -struct snd_seq_event { - snd_seq_event_type_t type; /* event type */ +struct sndrv_seq_event { + sndrv_seq_event_type_t type; /* event type */ unsigned char flags; /* event flags */ char tag; unsigned char queue; /* schedule queue */ - union snd_seq_timestamp time; /* schedule time */ + union sndrv_seq_timestamp time; /* schedule time */ - struct snd_seq_addr source; /* source address */ - struct snd_seq_addr dest; /* destination address */ + struct sndrv_seq_addr source; /* source address */ + struct sndrv_seq_addr dest; /* destination address */ union { /* event data... */ - struct snd_seq_ev_note note; - struct snd_seq_ev_ctrl control; - struct snd_seq_ev_raw8 raw8; - struct snd_seq_ev_raw32 raw32; - struct snd_seq_ev_ext ext; - struct snd_seq_ev_queue_control queue; - union snd_seq_timestamp time; - struct snd_seq_addr addr; - struct snd_seq_connect connect; - struct snd_seq_result result; - struct snd_seq_ev_instr_begin instr_begin; - struct snd_seq_ev_sample_control sample; - struct snd_seq_ev_quote quote; + struct sndrv_seq_ev_note note; + struct sndrv_seq_ev_ctrl control; + struct sndrv_seq_ev_raw8 raw8; + struct sndrv_seq_ev_raw32 raw32; + struct sndrv_seq_ev_ext ext; + struct sndrv_seq_ev_queue_control queue; + union sndrv_seq_timestamp time; + struct sndrv_seq_addr addr; + struct sndrv_seq_connect connect; + struct sndrv_seq_result result; + struct sndrv_seq_ev_instr_begin instr_begin; + struct sndrv_seq_ev_sample_control sample; + struct sndrv_seq_ev_quote quote; } data; }; @@ -409,77 +410,72 @@ struct snd_seq_event { /* * bounce event - stored as variable size data */ -struct snd_seq_event_bounce { +struct sndrv_seq_event_bounce { int err; - struct snd_seq_event event; + struct sndrv_seq_event event; /* external data follows here. */ }; -#ifdef __KERNEL__ - -/* helper macro */ -#define snd_seq_event_bounce_ext_data(ev) ((void*)((char *)(ev)->data.ext.ptr + sizeof(struct snd_seq_event_bounce))) +#define sndrv_seq_event_bounce_ext_data(ev) ((void*)((char *)(ev)->data.ext.ptr + sizeof(sndrv_seq_event_bounce_t))) /* * type check macros */ /* result events: 0-4 */ -#define snd_seq_ev_is_result_type(ev) ((ev)->type < 5) +#define sndrv_seq_ev_is_result_type(ev) ((ev)->type < 5) /* channel specific events: 5-19 */ -#define snd_seq_ev_is_channel_type(ev) ((ev)->type >= 5 && (ev)->type < 20) +#define sndrv_seq_ev_is_channel_type(ev) ((ev)->type >= 5 && (ev)->type < 20) /* note events: 5-9 */ -#define snd_seq_ev_is_note_type(ev) ((ev)->type >= 5 && (ev)->type < 10) +#define sndrv_seq_ev_is_note_type(ev) ((ev)->type >= 5 && (ev)->type < 10) /* control events: 10-19 */ -#define snd_seq_ev_is_control_type(ev) ((ev)->type >= 10 && (ev)->type < 20) +#define sndrv_seq_ev_is_control_type(ev) ((ev)->type >= 10 && (ev)->type < 20) /* queue control events: 30-39 */ -#define snd_seq_ev_is_queue_type(ev) ((ev)->type >= 30 && (ev)->type < 40) +#define sndrv_seq_ev_is_queue_type(ev) ((ev)->type >= 30 && (ev)->type < 40) /* system status messages */ -#define snd_seq_ev_is_message_type(ev) ((ev)->type >= 60 && (ev)->type < 69) +#define sndrv_seq_ev_is_message_type(ev) ((ev)->type >= 60 && (ev)->type < 69) /* sample messages */ -#define snd_seq_ev_is_sample_type(ev) ((ev)->type >= 70 && (ev)->type < 79) +#define sndrv_seq_ev_is_sample_type(ev) ((ev)->type >= 70 && (ev)->type < 79) /* user-defined messages */ -#define snd_seq_ev_is_user_type(ev) ((ev)->type >= 90 && (ev)->type < 99) +#define sndrv_seq_ev_is_user_type(ev) ((ev)->type >= 90 && (ev)->type < 99) /* fixed length events: 0-99 */ -#define snd_seq_ev_is_fixed_type(ev) ((ev)->type < 100) +#define sndrv_seq_ev_is_fixed_type(ev) ((ev)->type < 100) /* instrument layer events: 100-129 */ -#define snd_seq_ev_is_instr_type(ev) ((ev)->type >= 100 && (ev)->type < 130) +#define sndrv_seq_ev_is_instr_type(ev) ((ev)->type >= 100 && (ev)->type < 130) /* variable length events: 130-139 */ -#define snd_seq_ev_is_variable_type(ev) ((ev)->type >= 130 && (ev)->type < 140) +#define sndrv_seq_ev_is_variable_type(ev) ((ev)->type >= 130 && (ev)->type < 140) /* reserved for kernel */ -#define snd_seq_ev_is_reserved(ev) ((ev)->type >= 150) +#define sndrv_seq_ev_is_reserved(ev) ((ev)->type >= 150) /* direct dispatched events */ -#define snd_seq_ev_is_direct(ev) ((ev)->queue == SNDRV_SEQ_QUEUE_DIRECT) +#define sndrv_seq_ev_is_direct(ev) ((ev)->queue == SNDRV_SEQ_QUEUE_DIRECT) /* * macros to check event flags */ /* prior events */ -#define snd_seq_ev_is_prior(ev) (((ev)->flags & SNDRV_SEQ_PRIORITY_MASK) == SNDRV_SEQ_PRIORITY_HIGH) +#define sndrv_seq_ev_is_prior(ev) (((ev)->flags & SNDRV_SEQ_PRIORITY_MASK) == SNDRV_SEQ_PRIORITY_HIGH) /* event length type */ -#define snd_seq_ev_length_type(ev) ((ev)->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) -#define snd_seq_ev_is_fixed(ev) (snd_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_FIXED) -#define snd_seq_ev_is_variable(ev) (snd_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE) -#define snd_seq_ev_is_varusr(ev) (snd_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARUSR) +#define sndrv_seq_ev_length_type(ev) ((ev)->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) +#define sndrv_seq_ev_is_fixed(ev) (sndrv_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_FIXED) +#define sndrv_seq_ev_is_variable(ev) (sndrv_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE) +#define sndrv_seq_ev_is_varusr(ev) (sndrv_seq_ev_length_type(ev) == SNDRV_SEQ_EVENT_LENGTH_VARUSR) /* time-stamp type */ -#define snd_seq_ev_timestamp_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_STAMP_MASK) -#define snd_seq_ev_is_tick(ev) (snd_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_TICK) -#define snd_seq_ev_is_real(ev) (snd_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_REAL) +#define sndrv_seq_ev_timestamp_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_STAMP_MASK) +#define sndrv_seq_ev_is_tick(ev) (sndrv_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_TICK) +#define sndrv_seq_ev_is_real(ev) (sndrv_seq_ev_timestamp_type(ev) == SNDRV_SEQ_TIME_STAMP_REAL) /* time-mode type */ -#define snd_seq_ev_timemode_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_MODE_MASK) -#define snd_seq_ev_is_abstime(ev) (snd_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_ABS) -#define snd_seq_ev_is_reltime(ev) (snd_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_REL) +#define sndrv_seq_ev_timemode_type(ev) ((ev)->flags & SNDRV_SEQ_TIME_MODE_MASK) +#define sndrv_seq_ev_is_abstime(ev) (sndrv_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_ABS) +#define sndrv_seq_ev_is_reltime(ev) (sndrv_seq_ev_timemode_type(ev) == SNDRV_SEQ_TIME_MODE_REL) /* queue sync port */ -#define snd_seq_queue_sync_port(q) ((q) + 16) - -#endif /* __KERNEL__ */ +#define sndrv_seq_queue_sync_port(q) ((q) + 16) /* system information */ -struct snd_seq_system_info { +struct sndrv_seq_system_info { int queues; /* maximum queues count */ int clients; /* maximum clients count */ int ports; /* maximum ports per client */ @@ -491,7 +487,7 @@ struct snd_seq_system_info { /* system running information */ -struct snd_seq_running_info { +struct sndrv_seq_running_info { unsigned char client; /* client id */ unsigned char big_endian; /* 1 = big-endian */ unsigned char cpu_mode; /* 4 = 32bit, 8 = 64bit */ @@ -502,16 +498,16 @@ struct snd_seq_running_info { /* known client numbers */ #define SNDRV_SEQ_CLIENT_SYSTEM 0 - /* internal client numbers */ -#define SNDRV_SEQ_CLIENT_DUMMY 14 /* midi through */ -#define SNDRV_SEQ_CLIENT_OSS 15 /* oss sequencer emulator */ +#define SNDRV_SEQ_CLIENT_DUMMY 62 /* dummy ports */ +#define SNDRV_SEQ_CLIENT_OSS 63 /* oss sequencer emulator */ /* client types */ -typedef int __bitwise snd_seq_client_type_t; -#define NO_CLIENT ((__force snd_seq_client_type_t) 0) -#define USER_CLIENT ((__force snd_seq_client_type_t) 1) -#define KERNEL_CLIENT ((__force snd_seq_client_type_t) 2) +enum sndrv_seq_client_type { + NO_CLIENT = 0, + USER_CLIENT = 1, + KERNEL_CLIENT = 2 +}; /* event filter flags */ #define SNDRV_SEQ_FILTER_BROADCAST (1<<0) /* accept broadcast messages */ @@ -519,9 +515,9 @@ typedef int __bitwise snd_seq_client_type_t; #define SNDRV_SEQ_FILTER_BOUNCE (1<<2) /* accept bounce event in error */ #define SNDRV_SEQ_FILTER_USE_EVENT (1<<31) /* use event filter */ -struct snd_seq_client_info { +struct sndrv_seq_client_info { int client; /* client number to inquire */ - snd_seq_client_type_t type; /* client type */ + enum sndrv_seq_client_type type; /* client type */ char name[64]; /* client name */ unsigned int filter; /* filter flags */ unsigned char multicast_filter[8]; /* multicast filter bitmap */ @@ -533,7 +529,7 @@ struct snd_seq_client_info { /* client pool size */ -struct snd_seq_client_pool { +struct sndrv_seq_client_pool { int client; /* client number to inquire */ int output_pool; /* outgoing (write) pool size */ int input_pool; /* incoming (read) pool size */ @@ -557,13 +553,13 @@ struct snd_seq_client_pool { #define SNDRV_SEQ_REMOVE_IGNORE_OFF (1<<8) /* Do not flush off events */ #define SNDRV_SEQ_REMOVE_TAG_MATCH (1<<9) /* Restrict to events with given tag */ -struct snd_seq_remove_events { +struct sndrv_seq_remove_events { unsigned int remove_mode; /* Flags that determine what gets removed */ - union snd_seq_timestamp time; + union sndrv_seq_timestamp time; unsigned char queue; /* Queue for REMOVE_DEST */ - struct snd_seq_addr dest; /* Address for REMOVE_DEST */ + struct sndrv_seq_addr dest; /* Address for REMOVE_DEST */ unsigned char channel; /* Channel for REMOVE_DEST */ int type; /* For REMOVE_EVENT_TYPE */ @@ -612,8 +608,8 @@ struct snd_seq_remove_events { #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) -struct snd_seq_port_info { - struct snd_seq_addr addr; /* client/port numbers */ +struct sndrv_seq_port_info { + struct sndrv_seq_addr addr; /* client/port numbers */ char name[64]; /* port name */ unsigned int capability; /* port capability bits */ @@ -636,7 +632,7 @@ struct snd_seq_port_info { #define SNDRV_SEQ_QUEUE_FLG_SYNC (1<<0) /* sync enabled */ /* queue information */ -struct snd_seq_queue_info { +struct sndrv_seq_queue_info { int queue; /* queue id */ /* @@ -652,11 +648,11 @@ struct snd_seq_queue_info { }; /* queue info/status */ -struct snd_seq_queue_status { +struct sndrv_seq_queue_status { int queue; /* queue id */ int events; /* read-only - queue size */ - snd_seq_tick_time_t tick; /* current tick */ - struct snd_seq_real_time time; /* current time */ + sndrv_seq_tick_time_t tick; /* current tick */ + struct sndrv_seq_real_time time; /* current time */ int running; /* running state of queue */ int flags; /* various flags */ char reserved[64]; /* for the future */ @@ -664,7 +660,7 @@ struct snd_seq_queue_status { /* queue tempo */ -struct snd_seq_queue_tempo { +struct sndrv_seq_queue_tempo { int queue; /* sequencer queue */ unsigned int tempo; /* current tempo, us/tick */ int ppq; /* time resolution, ticks/quarter */ @@ -680,12 +676,12 @@ struct snd_seq_queue_tempo { #define SNDRV_SEQ_TIMER_MIDI_TICK 2 /* Midi Timer Tick (TICK event) */ /* queue timer info */ -struct snd_seq_queue_timer { +struct sndrv_seq_queue_timer { int queue; /* sequencer queue */ int type; /* source timer type */ union { struct { - struct snd_timer_id id; /* ALSA's timer ID */ + struct sndrv_timer_id id; /* ALSA's timer ID */ unsigned int resolution; /* resolution in Hz */ } alsa; } u; @@ -693,7 +689,7 @@ struct snd_seq_queue_timer { }; -struct snd_seq_queue_client { +struct sndrv_seq_queue_client { int queue; /* sequencer queue */ int client; /* sequencer client */ int used; /* queue is used with this client @@ -707,9 +703,9 @@ struct snd_seq_queue_client { #define SNDRV_SEQ_PORT_SUBS_TIMESTAMP (1<<1) #define SNDRV_SEQ_PORT_SUBS_TIME_REAL (1<<2) -struct snd_seq_port_subscribe { - struct snd_seq_addr sender; /* sender address */ - struct snd_seq_addr dest; /* destination address */ +struct sndrv_seq_port_subscribe { + struct sndrv_seq_addr sender; /* sender address */ + struct sndrv_seq_addr dest; /* destination address */ unsigned int voices; /* number of voices to be allocated (0 = don't care) */ unsigned int flags; /* modes */ unsigned char queue; /* input time-stamp queue (optional) */ @@ -721,12 +717,12 @@ struct snd_seq_port_subscribe { #define SNDRV_SEQ_QUERY_SUBS_READ 0 #define SNDRV_SEQ_QUERY_SUBS_WRITE 1 -struct snd_seq_query_subs { - struct snd_seq_addr root; /* client/port id to be searched */ +struct sndrv_seq_query_subs { + struct sndrv_seq_addr root; /* client/port id to be searched */ int type; /* READ or WRITE */ int index; /* 0..N-1 */ int num_subs; /* R/O: number of subscriptions on this port */ - struct snd_seq_addr addr; /* R/O: result */ + struct sndrv_seq_addr addr; /* R/O: result */ unsigned char queue; /* R/O: result */ unsigned int flags; /* R/O: result */ char reserved[64]; /* for future use */ @@ -783,72 +779,72 @@ struct snd_seq_query_subs { #define SNDRV_SEQ_INSTR_FREE_CMD_SINGLE 3 /* size of ROM/RAM */ -typedef unsigned int snd_seq_instr_size_t; +typedef unsigned int sndrv_seq_instr_size_t; /* INSTR_INFO */ -struct snd_seq_instr_info { +struct sndrv_seq_instr_info { int result; /* operation result */ unsigned int formats[8]; /* bitmap of supported formats */ int ram_count; /* count of RAM banks */ - snd_seq_instr_size_t ram_sizes[16]; /* size of RAM banks */ + sndrv_seq_instr_size_t ram_sizes[16]; /* size of RAM banks */ int rom_count; /* count of ROM banks */ - snd_seq_instr_size_t rom_sizes[8]; /* size of ROM banks */ + sndrv_seq_instr_size_t rom_sizes[8]; /* size of ROM banks */ char reserved[128]; }; /* INSTR_STATUS */ -struct snd_seq_instr_status { +struct sndrv_seq_instr_status { int result; /* operation result */ - snd_seq_instr_size_t free_ram[16]; /* free RAM in banks */ + sndrv_seq_instr_size_t free_ram[16]; /* free RAM in banks */ int instrument_count; /* count of downloaded instruments */ char reserved[128]; }; /* INSTR_FORMAT_INFO */ -struct snd_seq_instr_format_info { +struct sndrv_seq_instr_format_info { char format[16]; /* format identifier - SNDRV_SEQ_INSTR_ID_* */ unsigned int len; /* max data length (without this structure) */ }; -struct snd_seq_instr_format_info_result { +struct sndrv_seq_instr_format_info_result { int result; /* operation result */ char format[16]; /* format identifier */ unsigned int len; /* filled data length (without this structure) */ }; /* instrument data */ -struct snd_seq_instr_data { +struct sndrv_seq_instr_data { char name[32]; /* instrument name */ char reserved[16]; /* for the future use */ int type; /* instrument type */ union { char format[16]; /* format identifier */ - struct snd_seq_instr alias; + struct sndrv_seq_instr alias; } data; }; /* INSTR_PUT/GET, data are stored in one block (extended), header + data */ -struct snd_seq_instr_header { +struct sndrv_seq_instr_header { union { - struct snd_seq_instr instr; - snd_seq_instr_cluster_t cluster; + struct sndrv_seq_instr instr; + sndrv_seq_instr_cluster_t cluster; } id; /* instrument identifier */ unsigned int cmd; /* get/put/free command */ unsigned int flags; /* query flags (only for get) */ unsigned int len; /* real instrument data length (without header) */ int result; /* operation result */ char reserved[16]; /* for the future */ - struct snd_seq_instr_data data; /* instrument data (for put/get result) */ + struct sndrv_seq_instr_data data; /* instrument data (for put/get result) */ }; /* INSTR_CLUSTER_SET */ -struct snd_seq_instr_cluster_set { - snd_seq_instr_cluster_t cluster; /* cluster identifier */ +struct sndrv_seq_instr_cluster_set { + sndrv_seq_instr_cluster_t cluster; /* cluster identifier */ char name[32]; /* cluster name */ int priority; /* cluster priority */ char reserved[64]; /* for the future use */ @@ -856,8 +852,8 @@ struct snd_seq_instr_cluster_set { /* INSTR_CLUSTER_GET */ -struct snd_seq_instr_cluster_get { - snd_seq_instr_cluster_t cluster; /* cluster identifier */ +struct sndrv_seq_instr_cluster_get { + sndrv_seq_instr_cluster_t cluster; /* cluster identifier */ char name[32]; /* cluster name */ int priority; /* cluster priority */ char reserved[64]; /* for the future use */ @@ -869,44 +865,44 @@ struct snd_seq_instr_cluster_get { #define SNDRV_SEQ_IOCTL_PVERSION _IOR ('S', 0x00, int) #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) -#define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) -#define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) - -#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) -#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) - -#define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) -#define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) -#define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct snd_seq_port_info) -#define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct snd_seq_port_info) - -#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct snd_seq_port_subscribe) -#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe) - -#define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct snd_seq_queue_info) -#define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct snd_seq_queue_info) -#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct snd_seq_queue_info) -#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct snd_seq_queue_info) -#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct snd_seq_queue_info) -#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status) -#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct snd_seq_queue_tempo) -#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct snd_seq_queue_tempo) -#define SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER _IOWR('S', 0x43, struct snd_seq_queue_owner) -#define SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER _IOW ('S', 0x44, struct snd_seq_queue_owner) -#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct snd_seq_queue_timer) -#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct snd_seq_queue_timer) +#define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct sndrv_seq_system_info) +#define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct sndrv_seq_running_info) + +#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct sndrv_seq_client_info) +#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct sndrv_seq_client_info) + +#define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct sndrv_seq_port_info) +#define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct sndrv_seq_port_info) +#define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct sndrv_seq_port_info) +#define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct sndrv_seq_port_info) + +#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct sndrv_seq_port_subscribe) +#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct sndrv_seq_port_subscribe) + +#define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct sndrv_seq_queue_info) +#define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct sndrv_seq_queue_info) +#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct sndrv_seq_queue_info) +#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct sndrv_seq_queue_info) +#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct sndrv_seq_queue_info) +#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct sndrv_seq_queue_status) +#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct sndrv_seq_queue_tempo) +#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct sndrv_seq_queue_tempo) +#define SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER _IOWR('S', 0x43, struct sndrv_seq_queue_owner) +#define SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER _IOW ('S', 0x44, struct sndrv_seq_queue_owner) +#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct sndrv_seq_queue_timer) +#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct sndrv_seq_queue_timer) /* XXX -#define SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC _IOWR('S', 0x53, struct snd_seq_queue_sync) -#define SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC _IOW ('S', 0x54, struct snd_seq_queue_sync) +#define SNDRV_SEQ_IOCTL_GET_QUEUE_SYNC _IOWR('S', 0x53, struct sndrv_seq_queue_sync) +#define SNDRV_SEQ_IOCTL_SET_QUEUE_SYNC _IOW ('S', 0x54, struct sndrv_seq_queue_sync) */ -#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct snd_seq_queue_client) -#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct snd_seq_queue_client) -#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct snd_seq_client_pool) -#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct snd_seq_client_pool) -#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct snd_seq_remove_events) -#define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct snd_seq_query_subs) -#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct snd_seq_port_subscribe) -#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct snd_seq_client_info) -#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct snd_seq_port_info) +#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct sndrv_seq_queue_client) +#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct sndrv_seq_queue_client) +#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct sndrv_seq_client_pool) +#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct sndrv_seq_client_pool) +#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct sndrv_seq_remove_events) +#define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct sndrv_seq_query_subs) +#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct sndrv_seq_port_subscribe) +#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct sndrv_seq_client_info) +#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct sndrv_seq_port_info) #endif /* __SOUND_ASEQUENCER_H */ diff --git a/trunk/include/sound/asound.h b/trunk/include/sound/asound.h index 9cc021c7ee11..8e552d627fa5 100644 --- a/trunk/include/sound/asound.h +++ b/trunk/include/sound/asound.h @@ -23,8 +23,12 @@ #ifndef __SOUND_ASOUND_H #define __SOUND_ASOUND_H -#ifdef __KERNEL__ +#if defined(LINUX) || defined(__LINUX__) || defined(__linux__) + #include + +#ifdef __KERNEL__ + #include #include #include @@ -39,7 +43,25 @@ #endif #endif -#endif /* __KERNEL__ **/ +#else /* !__KERNEL__ */ + +#include +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define SNDRV_LITTLE_ENDIAN +#elif __BYTE_ORDER == __BIG_ENDIAN +#define SNDRV_BIG_ENDIAN +#else +#error "Unsupported endian..." +#endif + +#endif /* __KERNEL **/ + +#endif /* LINUX */ + +#ifndef __KERNEL__ +#include +#include +#endif /* * protocol version @@ -60,7 +82,7 @@ * * ****************************************************************************/ -struct snd_aes_iec958 { +struct sndrv_aes_iec958 { unsigned char status[24]; /* AES/IEC958 channel status bits */ unsigned char subcode[147]; /* AES/IEC958 subcode bits */ unsigned char pad; /* nothing */ @@ -75,7 +97,7 @@ struct snd_aes_iec958 { #define SNDRV_HWDEP_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) -enum { +enum sndrv_hwdep_iface { SNDRV_HWDEP_IFACE_OPL2 = 0, SNDRV_HWDEP_IFACE_OPL3, SNDRV_HWDEP_IFACE_OPL4, @@ -97,17 +119,17 @@ enum { SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_SB_RC }; -struct snd_hwdep_info { +struct sndrv_hwdep_info { unsigned int device; /* WR: device number */ int card; /* R: card number */ unsigned char id[64]; /* ID (user selectable) */ unsigned char name[80]; /* hwdep name */ - int iface; /* hwdep interface */ + enum sndrv_hwdep_iface iface; /* hwdep interface */ unsigned char reserved[64]; /* reserved for future */ }; /* generic DSP loader */ -struct snd_hwdep_dsp_status { +struct sndrv_hwdep_dsp_status { unsigned int version; /* R: driver-specific version */ unsigned char id[32]; /* R: driver-specific ID string */ unsigned int num_dsps; /* R: number of DSP images to transfer */ @@ -116,7 +138,7 @@ struct snd_hwdep_dsp_status { unsigned char reserved[16]; /* reserved for future use */ }; -struct snd_hwdep_dsp_image { +struct sndrv_hwdep_dsp_image { unsigned int index; /* W: DSP index */ unsigned char name[64]; /* W: ID (e.g. file name) */ unsigned char __user *image; /* W: binary image */ @@ -126,9 +148,9 @@ struct snd_hwdep_dsp_image { enum { SNDRV_HWDEP_IOCTL_PVERSION = _IOR ('H', 0x00, int), - SNDRV_HWDEP_IOCTL_INFO = _IOR ('H', 0x01, struct snd_hwdep_info), - SNDRV_HWDEP_IOCTL_DSP_STATUS = _IOR('H', 0x02, struct snd_hwdep_dsp_status), - SNDRV_HWDEP_IOCTL_DSP_LOAD = _IOW('H', 0x03, struct snd_hwdep_dsp_image) + SNDRV_HWDEP_IOCTL_INFO = _IOR ('H', 0x01, struct sndrv_hwdep_info), + SNDRV_HWDEP_IOCTL_DSP_STATUS = _IOR('H', 0x02, struct sndrv_hwdep_dsp_status), + SNDRV_HWDEP_IOCTL_DSP_LOAD = _IOW('H', 0x03, struct sndrv_hwdep_dsp_image) }; /***************************************************************************** @@ -139,10 +161,10 @@ enum { #define SNDRV_PCM_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 7) -typedef unsigned long snd_pcm_uframes_t; -typedef signed long snd_pcm_sframes_t; +typedef unsigned long sndrv_pcm_uframes_t; +typedef long sndrv_pcm_sframes_t; -enum { +enum sndrv_pcm_class { SNDRV_PCM_CLASS_GENERIC = 0, /* standard mono or stereo device */ SNDRV_PCM_CLASS_MULTI, /* multichannel device */ SNDRV_PCM_CLASS_MODEM, /* software modem class */ @@ -151,94 +173,97 @@ enum { SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER, }; -enum { +enum sndrv_pcm_subclass { SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */ SNDRV_PCM_SUBCLASS_MULTI_MIX, /* multichannel subdevices are mixed together */ /* Don't forget to change the following: */ SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX, }; -enum { +enum sndrv_pcm_stream { SNDRV_PCM_STREAM_PLAYBACK = 0, SNDRV_PCM_STREAM_CAPTURE, SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE, }; -typedef int __bitwise snd_pcm_access_t; -#define SNDRV_PCM_ACCESS_MMAP_INTERLEAVED ((__force snd_pcm_access_t) 0) /* interleaved mmap */ -#define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED ((__force snd_pcm_access_t) 1) /* noninterleaved mmap */ -#define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((__force snd_pcm_access_t) 2) /* complex mmap */ -#define SNDRV_PCM_ACCESS_RW_INTERLEAVED ((__force snd_pcm_access_t) 3) /* readi/writei */ -#define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED ((__force snd_pcm_access_t) 4) /* readn/writen */ -#define SNDRV_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_RW_NONINTERLEAVED - -typedef int __bitwise snd_pcm_format_t; -#define SNDRV_PCM_FORMAT_S8 ((__force snd_pcm_format_t) 0) -#define SNDRV_PCM_FORMAT_U8 ((__force snd_pcm_format_t) 1) -#define SNDRV_PCM_FORMAT_S16_LE ((__force snd_pcm_format_t) 2) -#define SNDRV_PCM_FORMAT_S16_BE ((__force snd_pcm_format_t) 3) -#define SNDRV_PCM_FORMAT_U16_LE ((__force snd_pcm_format_t) 4) -#define SNDRV_PCM_FORMAT_U16_BE ((__force snd_pcm_format_t) 5) -#define SNDRV_PCM_FORMAT_S24_LE ((__force snd_pcm_format_t) 6) /* low three bytes */ -#define SNDRV_PCM_FORMAT_S24_BE ((__force snd_pcm_format_t) 7) /* low three bytes */ -#define SNDRV_PCM_FORMAT_U24_LE ((__force snd_pcm_format_t) 8) /* low three bytes */ -#define SNDRV_PCM_FORMAT_U24_BE ((__force snd_pcm_format_t) 9) /* low three bytes */ -#define SNDRV_PCM_FORMAT_S32_LE ((__force snd_pcm_format_t) 10) -#define SNDRV_PCM_FORMAT_S32_BE ((__force snd_pcm_format_t) 11) -#define SNDRV_PCM_FORMAT_U32_LE ((__force snd_pcm_format_t) 12) -#define SNDRV_PCM_FORMAT_U32_BE ((__force snd_pcm_format_t) 13) -#define SNDRV_PCM_FORMAT_FLOAT_LE ((__force snd_pcm_format_t) 14) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ -#define SNDRV_PCM_FORMAT_FLOAT_BE ((__force snd_pcm_format_t) 15) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ -#define SNDRV_PCM_FORMAT_FLOAT64_LE ((__force snd_pcm_format_t) 16) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ -#define SNDRV_PCM_FORMAT_FLOAT64_BE ((__force snd_pcm_format_t) 17) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ -#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((__force snd_pcm_format_t) 18) /* IEC-958 subframe, Little Endian */ -#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((__force snd_pcm_format_t) 19) /* IEC-958 subframe, Big Endian */ -#define SNDRV_PCM_FORMAT_MU_LAW ((__force snd_pcm_format_t) 20) -#define SNDRV_PCM_FORMAT_A_LAW ((__force snd_pcm_format_t) 21) -#define SNDRV_PCM_FORMAT_IMA_ADPCM ((__force snd_pcm_format_t) 22) -#define SNDRV_PCM_FORMAT_MPEG ((__force snd_pcm_format_t) 23) -#define SNDRV_PCM_FORMAT_GSM ((__force snd_pcm_format_t) 24) -#define SNDRV_PCM_FORMAT_SPECIAL ((__force snd_pcm_format_t) 31) -#define SNDRV_PCM_FORMAT_S24_3LE ((__force snd_pcm_format_t) 32) /* in three bytes */ -#define SNDRV_PCM_FORMAT_S24_3BE ((__force snd_pcm_format_t) 33) /* in three bytes */ -#define SNDRV_PCM_FORMAT_U24_3LE ((__force snd_pcm_format_t) 34) /* in three bytes */ -#define SNDRV_PCM_FORMAT_U24_3BE ((__force snd_pcm_format_t) 35) /* in three bytes */ -#define SNDRV_PCM_FORMAT_S20_3LE ((__force snd_pcm_format_t) 36) /* in three bytes */ -#define SNDRV_PCM_FORMAT_S20_3BE ((__force snd_pcm_format_t) 37) /* in three bytes */ -#define SNDRV_PCM_FORMAT_U20_3LE ((__force snd_pcm_format_t) 38) /* in three bytes */ -#define SNDRV_PCM_FORMAT_U20_3BE ((__force snd_pcm_format_t) 39) /* in three bytes */ -#define SNDRV_PCM_FORMAT_S18_3LE ((__force snd_pcm_format_t) 40) /* in three bytes */ -#define SNDRV_PCM_FORMAT_S18_3BE ((__force snd_pcm_format_t) 41) /* in three bytes */ -#define SNDRV_PCM_FORMAT_U18_3LE ((__force snd_pcm_format_t) 42) /* in three bytes */ -#define SNDRV_PCM_FORMAT_U18_3BE ((__force snd_pcm_format_t) 43) /* in three bytes */ -#define SNDRV_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_U18_3BE +enum sndrv_pcm_access { + SNDRV_PCM_ACCESS_MMAP_INTERLEAVED = 0, /* interleaved mmap */ + SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED, /* noninterleaved mmap */ + SNDRV_PCM_ACCESS_MMAP_COMPLEX, /* complex mmap */ + SNDRV_PCM_ACCESS_RW_INTERLEAVED, /* readi/writei */ + SNDRV_PCM_ACCESS_RW_NONINTERLEAVED, /* readn/writen */ + SNDRV_PCM_ACCESS_LAST = SNDRV_PCM_ACCESS_RW_NONINTERLEAVED, +}; + +enum sndrv_pcm_format { + SNDRV_PCM_FORMAT_S8 = 0, + SNDRV_PCM_FORMAT_U8, + SNDRV_PCM_FORMAT_S16_LE, + SNDRV_PCM_FORMAT_S16_BE, + SNDRV_PCM_FORMAT_U16_LE, + SNDRV_PCM_FORMAT_U16_BE, + SNDRV_PCM_FORMAT_S24_LE, /* low three bytes */ + SNDRV_PCM_FORMAT_S24_BE, /* low three bytes */ + SNDRV_PCM_FORMAT_U24_LE, /* low three bytes */ + SNDRV_PCM_FORMAT_U24_BE, /* low three bytes */ + SNDRV_PCM_FORMAT_S32_LE, + SNDRV_PCM_FORMAT_S32_BE, + SNDRV_PCM_FORMAT_U32_LE, + SNDRV_PCM_FORMAT_U32_BE, + SNDRV_PCM_FORMAT_FLOAT_LE, /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ + SNDRV_PCM_FORMAT_FLOAT_BE, /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ + SNDRV_PCM_FORMAT_FLOAT64_LE, /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ + SNDRV_PCM_FORMAT_FLOAT64_BE, /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ + SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE, /* IEC-958 subframe, Little Endian */ + SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE, /* IEC-958 subframe, Big Endian */ + SNDRV_PCM_FORMAT_MU_LAW, + SNDRV_PCM_FORMAT_A_LAW, + SNDRV_PCM_FORMAT_IMA_ADPCM, + SNDRV_PCM_FORMAT_MPEG, + SNDRV_PCM_FORMAT_GSM, + SNDRV_PCM_FORMAT_SPECIAL = 31, + SNDRV_PCM_FORMAT_S24_3LE = 32, /* in three bytes */ + SNDRV_PCM_FORMAT_S24_3BE, /* in three bytes */ + SNDRV_PCM_FORMAT_U24_3LE, /* in three bytes */ + SNDRV_PCM_FORMAT_U24_3BE, /* in three bytes */ + SNDRV_PCM_FORMAT_S20_3LE, /* in three bytes */ + SNDRV_PCM_FORMAT_S20_3BE, /* in three bytes */ + SNDRV_PCM_FORMAT_U20_3LE, /* in three bytes */ + SNDRV_PCM_FORMAT_U20_3BE, /* in three bytes */ + SNDRV_PCM_FORMAT_S18_3LE, /* in three bytes */ + SNDRV_PCM_FORMAT_S18_3BE, /* in three bytes */ + SNDRV_PCM_FORMAT_U18_3LE, /* in three bytes */ + SNDRV_PCM_FORMAT_U18_3BE, /* in three bytes */ + SNDRV_PCM_FORMAT_LAST = SNDRV_PCM_FORMAT_U18_3BE, #ifdef SNDRV_LITTLE_ENDIAN -#define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_LE -#define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_LE -#define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_LE -#define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_LE -#define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_LE -#define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_LE -#define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_LE -#define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_LE -#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE + SNDRV_PCM_FORMAT_S16 = SNDRV_PCM_FORMAT_S16_LE, + SNDRV_PCM_FORMAT_U16 = SNDRV_PCM_FORMAT_U16_LE, + SNDRV_PCM_FORMAT_S24 = SNDRV_PCM_FORMAT_S24_LE, + SNDRV_PCM_FORMAT_U24 = SNDRV_PCM_FORMAT_U24_LE, + SNDRV_PCM_FORMAT_S32 = SNDRV_PCM_FORMAT_S32_LE, + SNDRV_PCM_FORMAT_U32 = SNDRV_PCM_FORMAT_U32_LE, + SNDRV_PCM_FORMAT_FLOAT = SNDRV_PCM_FORMAT_FLOAT_LE, + SNDRV_PCM_FORMAT_FLOAT64 = SNDRV_PCM_FORMAT_FLOAT64_LE, + SNDRV_PCM_FORMAT_IEC958_SUBFRAME = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE, #endif #ifdef SNDRV_BIG_ENDIAN -#define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_BE -#define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_BE -#define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_BE -#define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_BE -#define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_BE -#define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_BE -#define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_BE -#define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_BE -#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE + SNDRV_PCM_FORMAT_S16 = SNDRV_PCM_FORMAT_S16_BE, + SNDRV_PCM_FORMAT_U16 = SNDRV_PCM_FORMAT_U16_BE, + SNDRV_PCM_FORMAT_S24 = SNDRV_PCM_FORMAT_S24_BE, + SNDRV_PCM_FORMAT_U24 = SNDRV_PCM_FORMAT_U24_BE, + SNDRV_PCM_FORMAT_S32 = SNDRV_PCM_FORMAT_S32_BE, + SNDRV_PCM_FORMAT_U32 = SNDRV_PCM_FORMAT_U32_BE, + SNDRV_PCM_FORMAT_FLOAT = SNDRV_PCM_FORMAT_FLOAT_BE, + SNDRV_PCM_FORMAT_FLOAT64 = SNDRV_PCM_FORMAT_FLOAT64_BE, + SNDRV_PCM_FORMAT_IEC958_SUBFRAME = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE, #endif +}; -typedef int __bitwise snd_pcm_subformat_t; -#define SNDRV_PCM_SUBFORMAT_STD ((__force snd_pcm_subformat_t) 0) -#define SNDRV_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_STD +enum sndrv_pcm_subformat { + SNDRV_PCM_SUBFORMAT_STD = 0, + SNDRV_PCM_SUBFORMAT_LAST = SNDRV_PCM_SUBFORMAT_STD, +}; #define SNDRV_PCM_INFO_MMAP 0x00000001 /* hardware supports mmap */ #define SNDRV_PCM_INFO_MMAP_VALID 0x00000002 /* period data are valid during transfer */ @@ -255,17 +280,18 @@ typedef int __bitwise snd_pcm_subformat_t; #define SNDRV_PCM_INFO_JOINT_DUPLEX 0x00200000 /* playback and capture stream are somewhat correlated */ #define SNDRV_PCM_INFO_SYNC_START 0x00400000 /* pcm support some kind of sync go */ -typedef int __bitwise snd_pcm_state_t; -#define SNDRV_PCM_STATE_OPEN ((__force snd_pcm_state_t) 0) /* stream is open */ -#define SNDRV_PCM_STATE_SETUP ((__force snd_pcm_state_t) 1) /* stream has a setup */ -#define SNDRV_PCM_STATE_PREPARED ((__force snd_pcm_state_t) 2) /* stream is ready to start */ -#define SNDRV_PCM_STATE_RUNNING ((__force snd_pcm_state_t) 3) /* stream is running */ -#define SNDRV_PCM_STATE_XRUN ((__force snd_pcm_state_t) 4) /* stream reached an xrun */ -#define SNDRV_PCM_STATE_DRAINING ((__force snd_pcm_state_t) 5) /* stream is draining */ -#define SNDRV_PCM_STATE_PAUSED ((__force snd_pcm_state_t) 6) /* stream is paused */ -#define SNDRV_PCM_STATE_SUSPENDED ((__force snd_pcm_state_t) 7) /* hardware is suspended */ -#define SNDRV_PCM_STATE_DISCONNECTED ((__force snd_pcm_state_t) 8) /* hardware is disconnected */ -#define SNDRV_PCM_STATE_LAST SNDRV_PCM_STATE_DISCONNECTED +enum sndrv_pcm_state { + SNDRV_PCM_STATE_OPEN = 0, /* stream is open */ + SNDRV_PCM_STATE_SETUP, /* stream has a setup */ + SNDRV_PCM_STATE_PREPARED, /* stream is ready to start */ + SNDRV_PCM_STATE_RUNNING, /* stream is running */ + SNDRV_PCM_STATE_XRUN, /* stream reached an xrun */ + SNDRV_PCM_STATE_DRAINING, /* stream is draining */ + SNDRV_PCM_STATE_PAUSED, /* stream is paused */ + SNDRV_PCM_STATE_SUSPENDED, /* hardware is suspended */ + SNDRV_PCM_STATE_DISCONNECTED, /* hardware is disconnected */ + SNDRV_PCM_STATE_LAST = SNDRV_PCM_STATE_DISCONNECTED, +}; enum { SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000, @@ -273,53 +299,55 @@ enum { SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000, }; -union snd_pcm_sync_id { +union sndrv_pcm_sync_id { unsigned char id[16]; unsigned short id16[8]; unsigned int id32[4]; }; -struct snd_pcm_info { +struct sndrv_pcm_info { unsigned int device; /* RO/WR (control): device number */ unsigned int subdevice; /* RO/WR (control): subdevice number */ - int stream; /* RO/WR (control): stream direction */ + enum sndrv_pcm_stream stream; /* RO/WR (control): stream number */ int card; /* R: card number */ unsigned char id[64]; /* ID (user selectable) */ unsigned char name[80]; /* name of this device */ unsigned char subname[32]; /* subdevice name */ - int dev_class; /* SNDRV_PCM_CLASS_* */ - int dev_subclass; /* SNDRV_PCM_SUBCLASS_* */ + enum sndrv_pcm_class dev_class; /* SNDRV_PCM_CLASS_* */ + enum sndrv_pcm_subclass dev_subclass; /* SNDRV_PCM_SUBCLASS_* */ unsigned int subdevices_count; unsigned int subdevices_avail; - union snd_pcm_sync_id sync; /* hardware synchronization ID */ + union sndrv_pcm_sync_id sync; /* hardware synchronization ID */ unsigned char reserved[64]; /* reserved for future... */ }; -typedef int __bitwise snd_pcm_hw_param_t; -#define SNDRV_PCM_HW_PARAM_ACCESS ((__force snd_pcm_hw_param_t) 0) /* Access type */ -#define SNDRV_PCM_HW_PARAM_FORMAT ((__force snd_pcm_hw_param_t) 1) /* Format */ -#define SNDRV_PCM_HW_PARAM_SUBFORMAT ((__force snd_pcm_hw_param_t) 2) /* Subformat */ -#define SNDRV_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_ACCESS -#define SNDRV_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_SUBFORMAT - -#define SNDRV_PCM_HW_PARAM_SAMPLE_BITS ((__force snd_pcm_hw_param_t) 8) /* Bits per sample */ -#define SNDRV_PCM_HW_PARAM_FRAME_BITS ((__force snd_pcm_hw_param_t) 9) /* Bits per frame */ -#define SNDRV_PCM_HW_PARAM_CHANNELS ((__force snd_pcm_hw_param_t) 10) /* Channels */ -#define SNDRV_PCM_HW_PARAM_RATE ((__force snd_pcm_hw_param_t) 11) /* Approx rate */ -#define SNDRV_PCM_HW_PARAM_PERIOD_TIME ((__force snd_pcm_hw_param_t) 12) /* Approx distance between interrupts in us */ -#define SNDRV_PCM_HW_PARAM_PERIOD_SIZE ((__force snd_pcm_hw_param_t) 13) /* Approx frames between interrupts */ -#define SNDRV_PCM_HW_PARAM_PERIOD_BYTES ((__force snd_pcm_hw_param_t) 14) /* Approx bytes between interrupts */ -#define SNDRV_PCM_HW_PARAM_PERIODS ((__force snd_pcm_hw_param_t) 15) /* Approx interrupts per buffer */ -#define SNDRV_PCM_HW_PARAM_BUFFER_TIME ((__force snd_pcm_hw_param_t) 16) /* Approx duration of buffer in us */ -#define SNDRV_PCM_HW_PARAM_BUFFER_SIZE ((__force snd_pcm_hw_param_t) 17) /* Size of buffer in frames */ -#define SNDRV_PCM_HW_PARAM_BUFFER_BYTES ((__force snd_pcm_hw_param_t) 18) /* Size of buffer in bytes */ -#define SNDRV_PCM_HW_PARAM_TICK_TIME ((__force snd_pcm_hw_param_t) 19) /* Approx tick duration in us */ -#define SNDRV_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_SAMPLE_BITS -#define SNDRV_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_TICK_TIME +enum sndrv_pcm_hw_param { + SNDRV_PCM_HW_PARAM_ACCESS = 0, /* Access type */ + SNDRV_PCM_HW_PARAM_FIRST_MASK = SNDRV_PCM_HW_PARAM_ACCESS, + SNDRV_PCM_HW_PARAM_FORMAT, /* Format */ + SNDRV_PCM_HW_PARAM_SUBFORMAT, /* Subformat */ + SNDRV_PCM_HW_PARAM_LAST_MASK = SNDRV_PCM_HW_PARAM_SUBFORMAT, + + SNDRV_PCM_HW_PARAM_SAMPLE_BITS = 8, /* Bits per sample */ + SNDRV_PCM_HW_PARAM_FIRST_INTERVAL = SNDRV_PCM_HW_PARAM_SAMPLE_BITS, + SNDRV_PCM_HW_PARAM_FRAME_BITS, /* Bits per frame */ + SNDRV_PCM_HW_PARAM_CHANNELS, /* Channels */ + SNDRV_PCM_HW_PARAM_RATE, /* Approx rate */ + SNDRV_PCM_HW_PARAM_PERIOD_TIME, /* Approx distance between interrupts + in us */ + SNDRV_PCM_HW_PARAM_PERIOD_SIZE, /* Approx frames between interrupts */ + SNDRV_PCM_HW_PARAM_PERIOD_BYTES, /* Approx bytes between interrupts */ + SNDRV_PCM_HW_PARAM_PERIODS, /* Approx interrupts per buffer */ + SNDRV_PCM_HW_PARAM_BUFFER_TIME, /* Approx duration of buffer in us */ + SNDRV_PCM_HW_PARAM_BUFFER_SIZE, /* Size of buffer in frames */ + SNDRV_PCM_HW_PARAM_BUFFER_BYTES, /* Size of buffer in bytes */ + SNDRV_PCM_HW_PARAM_TICK_TIME, /* Approx tick duration in us */ + SNDRV_PCM_HW_PARAM_LAST_INTERVAL = SNDRV_PCM_HW_PARAM_TICK_TIME +}; #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ -struct snd_interval { +struct sndrv_interval { unsigned int min, max; unsigned int openmin:1, openmax:1, @@ -329,137 +357,137 @@ struct snd_interval { #define SNDRV_MASK_MAX 256 -struct snd_mask { +struct sndrv_mask { u_int32_t bits[(SNDRV_MASK_MAX+31)/32]; }; -struct snd_pcm_hw_params { +struct sndrv_pcm_hw_params { unsigned int flags; - struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - + struct sndrv_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; - struct snd_mask mres[5]; /* reserved masks */ - struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - + struct sndrv_mask mres[5]; /* reserved masks */ + struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; - struct snd_interval ires[9]; /* reserved intervals */ + struct sndrv_interval ires[9]; /* reserved intervals */ unsigned int rmask; /* W: requested masks */ unsigned int cmask; /* R: changed masks */ unsigned int info; /* R: Info flags for returned setup */ unsigned int msbits; /* R: used most significant bits */ unsigned int rate_num; /* R: rate numerator */ unsigned int rate_den; /* R: rate denominator */ - snd_pcm_uframes_t fifo_size; /* R: chip FIFO size in frames */ + sndrv_pcm_uframes_t fifo_size; /* R: chip FIFO size in frames */ unsigned char reserved[64]; /* reserved for future */ }; -enum { +enum sndrv_pcm_tstamp { SNDRV_PCM_TSTAMP_NONE = 0, SNDRV_PCM_TSTAMP_MMAP, SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_MMAP, }; -struct snd_pcm_sw_params { - int tstamp_mode; /* timestamp mode */ +struct sndrv_pcm_sw_params { + enum sndrv_pcm_tstamp tstamp_mode; /* timestamp mode */ unsigned int period_step; unsigned int sleep_min; /* min ticks to sleep */ - snd_pcm_uframes_t avail_min; /* min avail frames for wakeup */ - snd_pcm_uframes_t xfer_align; /* xfer size need to be a multiple */ - snd_pcm_uframes_t start_threshold; /* min hw_avail frames for automatic start */ - snd_pcm_uframes_t stop_threshold; /* min avail frames for automatic stop */ - snd_pcm_uframes_t silence_threshold; /* min distance from noise for silence filling */ - snd_pcm_uframes_t silence_size; /* silence block size */ - snd_pcm_uframes_t boundary; /* pointers wrap point */ + sndrv_pcm_uframes_t avail_min; /* min avail frames for wakeup */ + sndrv_pcm_uframes_t xfer_align; /* xfer size need to be a multiple */ + sndrv_pcm_uframes_t start_threshold; /* min hw_avail frames for automatic start */ + sndrv_pcm_uframes_t stop_threshold; /* min avail frames for automatic stop */ + sndrv_pcm_uframes_t silence_threshold; /* min distance from noise for silence filling */ + sndrv_pcm_uframes_t silence_size; /* silence block size */ + sndrv_pcm_uframes_t boundary; /* pointers wrap point */ unsigned char reserved[64]; /* reserved for future */ }; -struct snd_pcm_channel_info { +struct sndrv_pcm_channel_info { unsigned int channel; off_t offset; /* mmap offset */ unsigned int first; /* offset to first sample in bits */ unsigned int step; /* samples distance in bits */ }; -struct snd_pcm_status { - snd_pcm_state_t state; /* stream state */ +struct sndrv_pcm_status { + enum sndrv_pcm_state state; /* stream state */ struct timespec trigger_tstamp; /* time when stream was started/stopped/paused */ struct timespec tstamp; /* reference timestamp */ - snd_pcm_uframes_t appl_ptr; /* appl ptr */ - snd_pcm_uframes_t hw_ptr; /* hw ptr */ - snd_pcm_sframes_t delay; /* current delay in frames */ - snd_pcm_uframes_t avail; /* number of frames available */ - snd_pcm_uframes_t avail_max; /* max frames available on hw since last status */ - snd_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */ - snd_pcm_state_t suspended_state; /* suspended stream state */ + sndrv_pcm_uframes_t appl_ptr; /* appl ptr */ + sndrv_pcm_uframes_t hw_ptr; /* hw ptr */ + sndrv_pcm_sframes_t delay; /* current delay in frames */ + sndrv_pcm_uframes_t avail; /* number of frames available */ + sndrv_pcm_uframes_t avail_max; /* max frames available on hw since last status */ + sndrv_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */ + enum sndrv_pcm_state suspended_state; /* suspended stream state */ unsigned char reserved[60]; /* must be filled with zero */ }; -struct snd_pcm_mmap_status { - snd_pcm_state_t state; /* RO: state - SNDRV_PCM_STATE_XXXX */ +struct sndrv_pcm_mmap_status { + enum sndrv_pcm_state state; /* RO: state - SNDRV_PCM_STATE_XXXX */ int pad1; /* Needed for 64 bit alignment */ - snd_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */ + sndrv_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */ struct timespec tstamp; /* Timestamp */ - snd_pcm_state_t suspended_state; /* RO: suspended stream state */ + enum sndrv_pcm_state suspended_state; /* RO: suspended stream state */ }; -struct snd_pcm_mmap_control { - snd_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */ - snd_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */ +struct sndrv_pcm_mmap_control { + sndrv_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */ + sndrv_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */ }; #define SNDRV_PCM_SYNC_PTR_HWSYNC (1<<0) /* execute hwsync */ #define SNDRV_PCM_SYNC_PTR_APPL (1<<1) /* get appl_ptr from driver (r/w op) */ #define SNDRV_PCM_SYNC_PTR_AVAIL_MIN (1<<2) /* get avail_min from driver */ -struct snd_pcm_sync_ptr { +struct sndrv_pcm_sync_ptr { unsigned int flags; union { - struct snd_pcm_mmap_status status; + struct sndrv_pcm_mmap_status status; unsigned char reserved[64]; } s; union { - struct snd_pcm_mmap_control control; + struct sndrv_pcm_mmap_control control; unsigned char reserved[64]; } c; }; -struct snd_xferi { - snd_pcm_sframes_t result; +struct sndrv_xferi { + sndrv_pcm_sframes_t result; void __user *buf; - snd_pcm_uframes_t frames; + sndrv_pcm_uframes_t frames; }; -struct snd_xfern { - snd_pcm_sframes_t result; +struct sndrv_xfern { + sndrv_pcm_sframes_t result; void __user * __user *bufs; - snd_pcm_uframes_t frames; + sndrv_pcm_uframes_t frames; }; enum { SNDRV_PCM_IOCTL_PVERSION = _IOR('A', 0x00, int), - SNDRV_PCM_IOCTL_INFO = _IOR('A', 0x01, struct snd_pcm_info), + SNDRV_PCM_IOCTL_INFO = _IOR('A', 0x01, struct sndrv_pcm_info), SNDRV_PCM_IOCTL_TSTAMP = _IOW('A', 0x02, int), - SNDRV_PCM_IOCTL_HW_REFINE = _IOWR('A', 0x10, struct snd_pcm_hw_params), - SNDRV_PCM_IOCTL_HW_PARAMS = _IOWR('A', 0x11, struct snd_pcm_hw_params), + SNDRV_PCM_IOCTL_HW_REFINE = _IOWR('A', 0x10, struct sndrv_pcm_hw_params), + SNDRV_PCM_IOCTL_HW_PARAMS = _IOWR('A', 0x11, struct sndrv_pcm_hw_params), SNDRV_PCM_IOCTL_HW_FREE = _IO('A', 0x12), - SNDRV_PCM_IOCTL_SW_PARAMS = _IOWR('A', 0x13, struct snd_pcm_sw_params), - SNDRV_PCM_IOCTL_STATUS = _IOR('A', 0x20, struct snd_pcm_status), - SNDRV_PCM_IOCTL_DELAY = _IOR('A', 0x21, snd_pcm_sframes_t), + SNDRV_PCM_IOCTL_SW_PARAMS = _IOWR('A', 0x13, struct sndrv_pcm_sw_params), + SNDRV_PCM_IOCTL_STATUS = _IOR('A', 0x20, struct sndrv_pcm_status), + SNDRV_PCM_IOCTL_DELAY = _IOR('A', 0x21, sndrv_pcm_sframes_t), SNDRV_PCM_IOCTL_HWSYNC = _IO('A', 0x22), - SNDRV_PCM_IOCTL_SYNC_PTR = _IOWR('A', 0x23, struct snd_pcm_sync_ptr), - SNDRV_PCM_IOCTL_CHANNEL_INFO = _IOR('A', 0x32, struct snd_pcm_channel_info), + SNDRV_PCM_IOCTL_SYNC_PTR = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr), + SNDRV_PCM_IOCTL_CHANNEL_INFO = _IOR('A', 0x32, struct sndrv_pcm_channel_info), SNDRV_PCM_IOCTL_PREPARE = _IO('A', 0x40), SNDRV_PCM_IOCTL_RESET = _IO('A', 0x41), SNDRV_PCM_IOCTL_START = _IO('A', 0x42), SNDRV_PCM_IOCTL_DROP = _IO('A', 0x43), SNDRV_PCM_IOCTL_DRAIN = _IO('A', 0x44), SNDRV_PCM_IOCTL_PAUSE = _IOW('A', 0x45, int), - SNDRV_PCM_IOCTL_REWIND = _IOW('A', 0x46, snd_pcm_uframes_t), + SNDRV_PCM_IOCTL_REWIND = _IOW('A', 0x46, sndrv_pcm_uframes_t), SNDRV_PCM_IOCTL_RESUME = _IO('A', 0x47), SNDRV_PCM_IOCTL_XRUN = _IO('A', 0x48), - SNDRV_PCM_IOCTL_FORWARD = _IOW('A', 0x49, snd_pcm_uframes_t), - SNDRV_PCM_IOCTL_WRITEI_FRAMES = _IOW('A', 0x50, struct snd_xferi), - SNDRV_PCM_IOCTL_READI_FRAMES = _IOR('A', 0x51, struct snd_xferi), - SNDRV_PCM_IOCTL_WRITEN_FRAMES = _IOW('A', 0x52, struct snd_xfern), - SNDRV_PCM_IOCTL_READN_FRAMES = _IOR('A', 0x53, struct snd_xfern), + SNDRV_PCM_IOCTL_FORWARD = _IOW('A', 0x49, sndrv_pcm_uframes_t), + SNDRV_PCM_IOCTL_WRITEI_FRAMES = _IOW('A', 0x50, struct sndrv_xferi), + SNDRV_PCM_IOCTL_READI_FRAMES = _IOR('A', 0x51, struct sndrv_xferi), + SNDRV_PCM_IOCTL_WRITEN_FRAMES = _IOW('A', 0x52, struct sndrv_xfern), + SNDRV_PCM_IOCTL_READN_FRAMES = _IOR('A', 0x53, struct sndrv_xfern), SNDRV_PCM_IOCTL_LINK = _IOW('A', 0x60, int), SNDRV_PCM_IOCTL_UNLINK = _IO('A', 0x61), }; @@ -479,7 +507,7 @@ enum { #define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 0) -enum { +enum sndrv_rawmidi_stream { SNDRV_RAWMIDI_STREAM_OUTPUT = 0, SNDRV_RAWMIDI_STREAM_INPUT, SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT, @@ -489,10 +517,10 @@ enum { #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 -struct snd_rawmidi_info { +struct sndrv_rawmidi_info { unsigned int device; /* RO/WR (control): device number */ unsigned int subdevice; /* RO/WR (control): subdevice number */ - int stream; /* WR: stream */ + enum sndrv_rawmidi_stream stream; /* WR: stream */ int card; /* R: card number */ unsigned int flags; /* SNDRV_RAWMIDI_INFO_XXXX */ unsigned char id[64]; /* ID (user selectable) */ @@ -503,16 +531,16 @@ struct snd_rawmidi_info { unsigned char reserved[64]; /* reserved for future use */ }; -struct snd_rawmidi_params { - int stream; +struct sndrv_rawmidi_params { + enum sndrv_rawmidi_stream stream; size_t buffer_size; /* queue size in bytes */ size_t avail_min; /* minimum avail bytes for wakeup */ unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */ unsigned char reserved[16]; /* reserved for future use */ }; -struct snd_rawmidi_status { - int stream; +struct sndrv_rawmidi_status { + enum sndrv_rawmidi_stream stream; struct timespec tstamp; /* Timestamp */ size_t avail; /* available bytes */ size_t xruns; /* count of overruns since last status (in bytes) */ @@ -521,9 +549,9 @@ struct snd_rawmidi_status { enum { SNDRV_RAWMIDI_IOCTL_PVERSION = _IOR('W', 0x00, int), - SNDRV_RAWMIDI_IOCTL_INFO = _IOR('W', 0x01, struct snd_rawmidi_info), - SNDRV_RAWMIDI_IOCTL_PARAMS = _IOWR('W', 0x10, struct snd_rawmidi_params), - SNDRV_RAWMIDI_IOCTL_STATUS = _IOWR('W', 0x20, struct snd_rawmidi_status), + SNDRV_RAWMIDI_IOCTL_INFO = _IOR('W', 0x01, struct sndrv_rawmidi_info), + SNDRV_RAWMIDI_IOCTL_PARAMS = _IOWR('W', 0x10, struct sndrv_rawmidi_params), + SNDRV_RAWMIDI_IOCTL_STATUS = _IOWR('W', 0x20, struct sndrv_rawmidi_status), SNDRV_RAWMIDI_IOCTL_DROP = _IOW('W', 0x30, int), SNDRV_RAWMIDI_IOCTL_DRAIN = _IOW('W', 0x31, int), }; @@ -534,7 +562,7 @@ enum { #define SNDRV_TIMER_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 5) -enum { +enum sndrv_timer_class { SNDRV_TIMER_CLASS_NONE = -1, SNDRV_TIMER_CLASS_SLAVE = 0, SNDRV_TIMER_CLASS_GLOBAL, @@ -544,7 +572,7 @@ enum { }; /* slave timer classes */ -enum { +enum sndrv_timer_slave_class { SNDRV_TIMER_SCLASS_NONE = 0, SNDRV_TIMER_SCLASS_APPLICATION, SNDRV_TIMER_SCLASS_SEQUENCER, /* alias */ @@ -560,16 +588,16 @@ enum { /* info flags */ #define SNDRV_TIMER_FLG_SLAVE (1<<0) /* cannot be controlled */ -struct snd_timer_id { - int dev_class; - int dev_sclass; +struct sndrv_timer_id { + enum sndrv_timer_class dev_class; + enum sndrv_timer_slave_class dev_sclass; int card; int device; int subdevice; }; -struct snd_timer_ginfo { - struct snd_timer_id tid; /* requested timer ID */ +struct sndrv_timer_ginfo { + struct sndrv_timer_id tid; /* requested timer ID */ unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ int card; /* card number */ unsigned char id[64]; /* timer identification */ @@ -582,27 +610,27 @@ struct snd_timer_ginfo { unsigned char reserved[32]; }; -struct snd_timer_gparams { - struct snd_timer_id tid; /* requested timer ID */ +struct sndrv_timer_gparams { + struct sndrv_timer_id tid; /* requested timer ID */ unsigned long period_num; /* requested precise period duration (in seconds) - numerator */ unsigned long period_den; /* requested precise period duration (in seconds) - denominator */ unsigned char reserved[32]; }; -struct snd_timer_gstatus { - struct snd_timer_id tid; /* requested timer ID */ +struct sndrv_timer_gstatus { + struct sndrv_timer_id tid; /* requested timer ID */ unsigned long resolution; /* current period resolution in ns */ unsigned long resolution_num; /* precise current period resolution (in seconds) - numerator */ unsigned long resolution_den; /* precise current period resolution (in seconds) - denominator */ unsigned char reserved[32]; }; -struct snd_timer_select { - struct snd_timer_id id; /* bind to timer ID */ +struct sndrv_timer_select { + struct sndrv_timer_id id; /* bind to timer ID */ unsigned char reserved[32]; /* reserved */ }; -struct snd_timer_info { +struct sndrv_timer_info { unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ int card; /* card number */ unsigned char id[64]; /* timer identificator */ @@ -616,7 +644,7 @@ struct snd_timer_info { #define SNDRV_TIMER_PSFLG_EXCLUSIVE (1<<1) /* exclusive use, precise start/stop/pause/continue */ #define SNDRV_TIMER_PSFLG_EARLY_EVENT (1<<2) /* write early event to the poll queue */ -struct snd_timer_params { +struct sndrv_timer_params { unsigned int flags; /* flags - SNDRV_MIXER_PSFLG_* */ unsigned int ticks; /* requested resolution in ticks */ unsigned int queue_size; /* total size of queue (32-1024) */ @@ -625,7 +653,7 @@ struct snd_timer_params { unsigned char reserved[60]; /* reserved */ }; -struct snd_timer_status { +struct sndrv_timer_status { struct timespec tstamp; /* Timestamp - last update */ unsigned int resolution; /* current period resolution in ns */ unsigned int lost; /* counter of master tick lost */ @@ -636,15 +664,15 @@ struct snd_timer_status { enum { SNDRV_TIMER_IOCTL_PVERSION = _IOR('T', 0x00, int), - SNDRV_TIMER_IOCTL_NEXT_DEVICE = _IOWR('T', 0x01, struct snd_timer_id), + SNDRV_TIMER_IOCTL_NEXT_DEVICE = _IOWR('T', 0x01, struct sndrv_timer_id), SNDRV_TIMER_IOCTL_TREAD = _IOW('T', 0x02, int), - SNDRV_TIMER_IOCTL_GINFO = _IOWR('T', 0x03, struct snd_timer_ginfo), - SNDRV_TIMER_IOCTL_GPARAMS = _IOW('T', 0x04, struct snd_timer_gparams), - SNDRV_TIMER_IOCTL_GSTATUS = _IOWR('T', 0x05, struct snd_timer_gstatus), - SNDRV_TIMER_IOCTL_SELECT = _IOW('T', 0x10, struct snd_timer_select), - SNDRV_TIMER_IOCTL_INFO = _IOR('T', 0x11, struct snd_timer_info), - SNDRV_TIMER_IOCTL_PARAMS = _IOW('T', 0x12, struct snd_timer_params), - SNDRV_TIMER_IOCTL_STATUS = _IOR('T', 0x14, struct snd_timer_status), + SNDRV_TIMER_IOCTL_GINFO = _IOWR('T', 0x03, struct sndrv_timer_ginfo), + SNDRV_TIMER_IOCTL_GPARAMS = _IOW('T', 0x04, struct sndrv_timer_gparams), + SNDRV_TIMER_IOCTL_GSTATUS = _IOWR('T', 0x05, struct sndrv_timer_gstatus), + SNDRV_TIMER_IOCTL_SELECT = _IOW('T', 0x10, struct sndrv_timer_select), + SNDRV_TIMER_IOCTL_INFO = _IOR('T', 0x11, struct sndrv_timer_info), + SNDRV_TIMER_IOCTL_PARAMS = _IOW('T', 0x12, struct sndrv_timer_params), + SNDRV_TIMER_IOCTL_STATUS = _IOR('T', 0x14, struct sndrv_timer_status), /* The following four ioctls are changed since 1.0.9 due to confliction */ SNDRV_TIMER_IOCTL_START = _IO('T', 0xa0), SNDRV_TIMER_IOCTL_STOP = _IO('T', 0xa1), @@ -652,12 +680,12 @@ enum { SNDRV_TIMER_IOCTL_PAUSE = _IO('T', 0xa3), }; -struct snd_timer_read { +struct sndrv_timer_read { unsigned int resolution; unsigned int ticks; }; -enum { +enum sndrv_timer_event { SNDRV_TIMER_EVENT_RESOLUTION = 0, /* val = resolution in ns */ SNDRV_TIMER_EVENT_TICK, /* val = ticks */ SNDRV_TIMER_EVENT_START, /* val = resolution in ns */ @@ -676,8 +704,8 @@ enum { SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10, }; -struct snd_timer_tread { - int event; +struct sndrv_timer_tread { + enum sndrv_timer_event event; struct timespec tstamp; unsigned int val; }; @@ -690,7 +718,7 @@ struct snd_timer_tread { #define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 3) -struct snd_ctl_card_info { +struct sndrv_ctl_card_info { int card; /* card number */ int pad; /* reserved for future (was type) */ unsigned char id[16]; /* ID of card (user selectable) */ @@ -703,25 +731,27 @@ struct snd_ctl_card_info { unsigned char reserved[48]; /* reserved for future */ }; -typedef int __bitwise snd_ctl_elem_type_t; -#define SNDRV_CTL_ELEM_TYPE_NONE ((__force snd_ctl_elem_type_t) 0) /* invalid */ -#define SNDRV_CTL_ELEM_TYPE_BOOLEAN ((__force snd_ctl_elem_type_t) 1) /* boolean type */ -#define SNDRV_CTL_ELEM_TYPE_INTEGER ((__force snd_ctl_elem_type_t) 2) /* integer type */ -#define SNDRV_CTL_ELEM_TYPE_ENUMERATED ((__force snd_ctl_elem_type_t) 3) /* enumerated type */ -#define SNDRV_CTL_ELEM_TYPE_BYTES ((__force snd_ctl_elem_type_t) 4) /* byte array */ -#define SNDRV_CTL_ELEM_TYPE_IEC958 ((__force snd_ctl_elem_type_t) 5) /* IEC958 (S/PDIF) setup */ -#define SNDRV_CTL_ELEM_TYPE_INTEGER64 ((__force snd_ctl_elem_type_t) 6) /* 64-bit integer type */ -#define SNDRV_CTL_ELEM_TYPE_LAST SNDRV_CTL_ELEM_TYPE_INTEGER64 - -typedef int __bitwise snd_ctl_elem_iface_t; -#define SNDRV_CTL_ELEM_IFACE_CARD ((__force snd_ctl_elem_iface_t) 0) /* global control */ -#define SNDRV_CTL_ELEM_IFACE_HWDEP ((__force snd_ctl_elem_iface_t) 1) /* hardware dependent device */ -#define SNDRV_CTL_ELEM_IFACE_MIXER ((__force snd_ctl_elem_iface_t) 2) /* virtual mixer device */ -#define SNDRV_CTL_ELEM_IFACE_PCM ((__force snd_ctl_elem_iface_t) 3) /* PCM device */ -#define SNDRV_CTL_ELEM_IFACE_RAWMIDI ((__force snd_ctl_elem_iface_t) 4) /* RawMidi device */ -#define SNDRV_CTL_ELEM_IFACE_TIMER ((__force snd_ctl_elem_iface_t) 5) /* timer device */ -#define SNDRV_CTL_ELEM_IFACE_SEQUENCER ((__force snd_ctl_elem_iface_t) 6) /* sequencer client */ -#define SNDRV_CTL_ELEM_IFACE_LAST SNDRV_CTL_ELEM_IFACE_SEQUENCER +enum sndrv_ctl_elem_type { + SNDRV_CTL_ELEM_TYPE_NONE = 0, /* invalid */ + SNDRV_CTL_ELEM_TYPE_BOOLEAN, /* boolean type */ + SNDRV_CTL_ELEM_TYPE_INTEGER, /* integer type */ + SNDRV_CTL_ELEM_TYPE_ENUMERATED, /* enumerated type */ + SNDRV_CTL_ELEM_TYPE_BYTES, /* byte array */ + SNDRV_CTL_ELEM_TYPE_IEC958, /* IEC958 (S/PDIF) setup */ + SNDRV_CTL_ELEM_TYPE_INTEGER64, /* 64-bit integer type */ + SNDRV_CTL_ELEM_TYPE_LAST = SNDRV_CTL_ELEM_TYPE_INTEGER64, +}; + +enum sndrv_ctl_elem_iface { + SNDRV_CTL_ELEM_IFACE_CARD = 0, /* global control */ + SNDRV_CTL_ELEM_IFACE_HWDEP, /* hardware dependent device */ + SNDRV_CTL_ELEM_IFACE_MIXER, /* virtual mixer device */ + SNDRV_CTL_ELEM_IFACE_PCM, /* PCM device */ + SNDRV_CTL_ELEM_IFACE_RAWMIDI, /* RawMidi device */ + SNDRV_CTL_ELEM_IFACE_TIMER, /* timer device */ + SNDRV_CTL_ELEM_IFACE_SEQUENCER, /* sequencer client */ + SNDRV_CTL_ELEM_IFACE_LAST = SNDRV_CTL_ELEM_IFACE_SEQUENCER, +}; #define SNDRV_CTL_ELEM_ACCESS_READ (1<<0) #define SNDRV_CTL_ELEM_ACCESS_WRITE (1<<1) @@ -743,27 +773,27 @@ typedef int __bitwise snd_ctl_elem_iface_t; #define SNDRV_CTL_POWER_D3hot (SNDRV_CTL_POWER_D3|0x0000) /* Off, with power */ #define SNDRV_CTL_POWER_D3cold (SNDRV_CTL_POWER_D3|0x0001) /* Off, without power */ -struct snd_ctl_elem_id { +struct sndrv_ctl_elem_id { unsigned int numid; /* numeric identifier, zero = invalid */ - snd_ctl_elem_iface_t iface; /* interface identifier */ + enum sndrv_ctl_elem_iface iface; /* interface identifier */ unsigned int device; /* device/client number */ unsigned int subdevice; /* subdevice (substream) number */ unsigned char name[44]; /* ASCII name of item */ unsigned int index; /* index of item */ }; -struct snd_ctl_elem_list { +struct sndrv_ctl_elem_list { unsigned int offset; /* W: first element ID to get */ unsigned int space; /* W: count of element IDs to get */ unsigned int used; /* R: count of element IDs set */ unsigned int count; /* R: count of all elements */ - struct snd_ctl_elem_id __user *pids; /* R: IDs */ + struct sndrv_ctl_elem_id __user *pids; /* R: IDs */ unsigned char reserved[50]; }; -struct snd_ctl_elem_info { - struct snd_ctl_elem_id id; /* W: element ID */ - snd_ctl_elem_type_t type; /* R: value type - SNDRV_CTL_ELEM_TYPE_* */ +struct sndrv_ctl_elem_info { + struct sndrv_ctl_elem_id id; /* W: element ID */ + enum sndrv_ctl_elem_type type; /* R: value type - SNDRV_CTL_ELEM_TYPE_* */ unsigned int access; /* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */ unsigned int count; /* count of values */ pid_t owner; /* owner's PID of this control */ @@ -792,8 +822,8 @@ struct snd_ctl_elem_info { unsigned char reserved[64-4*sizeof(unsigned short)]; }; -struct snd_ctl_elem_value { - struct snd_ctl_elem_id id; /* W: element ID */ +struct sndrv_ctl_elem_value { + struct sndrv_ctl_elem_id id; /* W: element ID */ unsigned int indirect: 1; /* W: use indirect pointer (xxx_ptr member) */ union { union { @@ -812,7 +842,7 @@ struct snd_ctl_elem_value { unsigned char data[512]; unsigned char *data_ptr; } bytes; - struct snd_aes_iec958 iec958; + struct sndrv_aes_iec958 iec958; } value; /* RO */ struct timespec tstamp; unsigned char reserved[128-sizeof(struct timespec)]; @@ -820,24 +850,24 @@ struct snd_ctl_elem_value { enum { SNDRV_CTL_IOCTL_PVERSION = _IOR('U', 0x00, int), - SNDRV_CTL_IOCTL_CARD_INFO = _IOR('U', 0x01, struct snd_ctl_card_info), - SNDRV_CTL_IOCTL_ELEM_LIST = _IOWR('U', 0x10, struct snd_ctl_elem_list), - SNDRV_CTL_IOCTL_ELEM_INFO = _IOWR('U', 0x11, struct snd_ctl_elem_info), - SNDRV_CTL_IOCTL_ELEM_READ = _IOWR('U', 0x12, struct snd_ctl_elem_value), - SNDRV_CTL_IOCTL_ELEM_WRITE = _IOWR('U', 0x13, struct snd_ctl_elem_value), - SNDRV_CTL_IOCTL_ELEM_LOCK = _IOW('U', 0x14, struct snd_ctl_elem_id), - SNDRV_CTL_IOCTL_ELEM_UNLOCK = _IOW('U', 0x15, struct snd_ctl_elem_id), + SNDRV_CTL_IOCTL_CARD_INFO = _IOR('U', 0x01, struct sndrv_ctl_card_info), + SNDRV_CTL_IOCTL_ELEM_LIST = _IOWR('U', 0x10, struct sndrv_ctl_elem_list), + SNDRV_CTL_IOCTL_ELEM_INFO = _IOWR('U', 0x11, struct sndrv_ctl_elem_info), + SNDRV_CTL_IOCTL_ELEM_READ = _IOWR('U', 0x12, struct sndrv_ctl_elem_value), + SNDRV_CTL_IOCTL_ELEM_WRITE = _IOWR('U', 0x13, struct sndrv_ctl_elem_value), + SNDRV_CTL_IOCTL_ELEM_LOCK = _IOW('U', 0x14, struct sndrv_ctl_elem_id), + SNDRV_CTL_IOCTL_ELEM_UNLOCK = _IOW('U', 0x15, struct sndrv_ctl_elem_id), SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS = _IOWR('U', 0x16, int), - SNDRV_CTL_IOCTL_ELEM_ADD = _IOWR('U', 0x17, struct snd_ctl_elem_info), - SNDRV_CTL_IOCTL_ELEM_REPLACE = _IOWR('U', 0x18, struct snd_ctl_elem_info), - SNDRV_CTL_IOCTL_ELEM_REMOVE = _IOWR('U', 0x19, struct snd_ctl_elem_id), + SNDRV_CTL_IOCTL_ELEM_ADD = _IOWR('U', 0x17, struct sndrv_ctl_elem_info), + SNDRV_CTL_IOCTL_ELEM_REPLACE = _IOWR('U', 0x18, struct sndrv_ctl_elem_info), + SNDRV_CTL_IOCTL_ELEM_REMOVE = _IOWR('U', 0x19, struct sndrv_ctl_elem_id), SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE = _IOWR('U', 0x20, int), - SNDRV_CTL_IOCTL_HWDEP_INFO = _IOR('U', 0x21, struct snd_hwdep_info), + SNDRV_CTL_IOCTL_HWDEP_INFO = _IOR('U', 0x21, struct sndrv_hwdep_info), SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE = _IOR('U', 0x30, int), - SNDRV_CTL_IOCTL_PCM_INFO = _IOWR('U', 0x31, struct snd_pcm_info), + SNDRV_CTL_IOCTL_PCM_INFO = _IOWR('U', 0x31, struct sndrv_pcm_info), SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE = _IOW('U', 0x32, int), SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE = _IOWR('U', 0x40, int), - SNDRV_CTL_IOCTL_RAWMIDI_INFO = _IOWR('U', 0x41, struct snd_rawmidi_info), + SNDRV_CTL_IOCTL_RAWMIDI_INFO = _IOWR('U', 0x41, struct sndrv_rawmidi_info), SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE = _IOW('U', 0x42, int), SNDRV_CTL_IOCTL_POWER = _IOWR('U', 0xd0, int), SNDRV_CTL_IOCTL_POWER_STATE = _IOR('U', 0xd1, int), @@ -857,12 +887,12 @@ enum sndrv_ctl_event_type { #define SNDRV_CTL_EVENT_MASK_ADD (1<<2) /* element was added */ #define SNDRV_CTL_EVENT_MASK_REMOVE (~0U) /* element was removed */ -struct snd_ctl_event { - int type; /* event type - SNDRV_CTL_EVENT_* */ +struct sndrv_ctl_event { + enum sndrv_ctl_event_type type; /* event type - SNDRV_CTL_EVENT_* */ union { struct { unsigned int mask; - struct snd_ctl_elem_id id; + struct sndrv_ctl_elem_id id; } elem; unsigned char data8[60]; } data; @@ -890,14 +920,14 @@ struct snd_ctl_event { * */ -struct snd_xferv { +struct sndrv_xferv { const struct iovec *vector; unsigned long count; }; enum { - SNDRV_IOCTL_READV = _IOW('K', 0x00, struct snd_xferv), - SNDRV_IOCTL_WRITEV = _IOW('K', 0x01, struct snd_xferv), + SNDRV_IOCTL_READV = _IOW('K', 0x00, struct sndrv_xferv), + SNDRV_IOCTL_WRITEV = _IOW('K', 0x01, struct sndrv_xferv), }; #endif /* __SOUND_ASOUND_H */ diff --git a/trunk/include/sound/asound_fm.h b/trunk/include/sound/asound_fm.h index 956fdc23c595..b0da677f8f75 100644 --- a/trunk/include/sound/asound_fm.h +++ b/trunk/include/sound/asound_fm.h @@ -29,16 +29,16 @@ #define SNDRV_DM_FM_MODE_OPL2 0x00 #define SNDRV_DM_FM_MODE_OPL3 0x01 -struct snd_dm_fm_info { +typedef struct snd_dm_fm_info { unsigned char fm_mode; /* OPL mode, see SNDRV_DM_FM_MODE_XXX */ unsigned char rhythm; /* percussion mode flag */ -}; +} snd_dm_fm_info_t; /* * Data structure composing an FM "note" or sound event. */ -struct snd_dm_fm_voice { +typedef struct snd_dm_fm_voice { unsigned char op; /* operator cell (0 or 1) */ unsigned char voice; /* FM voice (0 to 17) */ @@ -60,25 +60,25 @@ struct snd_dm_fm_voice { unsigned char left; /* stereo left */ unsigned char right; /* stereo right */ unsigned char waveform; /* 3 bits: waveform shape */ -}; +} snd_dm_fm_voice_t; /* * This describes an FM note by its voice, octave, frequency number (10bit) * and key on/off. */ -struct snd_dm_fm_note { +typedef struct snd_dm_fm_note { unsigned char voice; /* 0-17 voice channel */ unsigned char octave; /* 3 bits: what octave to play */ unsigned int fnum; /* 10 bits: frequency number */ unsigned char key_on; /* set for active, clear for silent */ -}; +} snd_dm_fm_note_t; /* * FM parameters that apply globally to all voices, and thus are not "notes" */ -struct snd_dm_fm_params { +typedef struct snd_dm_fm_params { unsigned char am_depth; /* amplitude modulation depth (1=hi) */ unsigned char vib_depth; /* vibrato depth (1=hi) */ unsigned char kbd_split; /* keyboard split */ @@ -90,17 +90,17 @@ struct snd_dm_fm_params { unsigned char tomtom; unsigned char cymbal; unsigned char hihat; -}; +} snd_dm_fm_params_t; /* * FM mode ioctl settings */ -#define SNDRV_DM_FM_IOCTL_INFO _IOR('H', 0x20, struct snd_dm_fm_info) +#define SNDRV_DM_FM_IOCTL_INFO _IOR('H', 0x20, snd_dm_fm_info_t) #define SNDRV_DM_FM_IOCTL_RESET _IO ('H', 0x21) -#define SNDRV_DM_FM_IOCTL_PLAY_NOTE _IOW('H', 0x22, struct snd_dm_fm_note) -#define SNDRV_DM_FM_IOCTL_SET_VOICE _IOW('H', 0x23, struct snd_dm_fm_voice) -#define SNDRV_DM_FM_IOCTL_SET_PARAMS _IOW('H', 0x24, struct snd_dm_fm_params) +#define SNDRV_DM_FM_IOCTL_PLAY_NOTE _IOW('H', 0x22, snd_dm_fm_note_t) +#define SNDRV_DM_FM_IOCTL_SET_VOICE _IOW('H', 0x23, snd_dm_fm_voice_t) +#define SNDRV_DM_FM_IOCTL_SET_PARAMS _IOW('H', 0x24, snd_dm_fm_params_t) #define SNDRV_DM_FM_IOCTL_SET_MODE _IOW('H', 0x25, int) /* for OPL3 only */ #define SNDRV_DM_FM_IOCTL_SET_CONNECTION _IOW('H', 0x26, int) diff --git a/trunk/include/sound/control.h b/trunk/include/sound/control.h index 2489b1eb0110..ef7903c7a327 100644 --- a/trunk/include/sound/control.h +++ b/trunk/include/sound/control.h @@ -24,14 +24,24 @@ #include +typedef struct sndrv_aes_iec958 snd_aes_iec958_t; +typedef struct sndrv_ctl_card_info snd_ctl_card_info_t; +typedef enum sndrv_ctl_elem_type snd_ctl_elem_type_t; +typedef enum sndrv_ctl_elem_iface snd_ctl_elem_iface_t; +typedef struct sndrv_ctl_elem_id snd_ctl_elem_id_t; +typedef struct sndrv_ctl_elem_list snd_ctl_elem_list_t; +typedef struct sndrv_ctl_elem_info snd_ctl_elem_info_t; +typedef struct sndrv_ctl_elem_value snd_ctl_elem_value_t; +typedef enum sndrv_ctl_event_type snd_ctl_event_type_t; +typedef struct sndrv_ctl_event snd_ctl_event_t; + #define snd_kcontrol_chip(kcontrol) ((kcontrol)->private_data) -struct snd_kcontrol; -typedef int (snd_kcontrol_info_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_info * uinfo); -typedef int (snd_kcontrol_get_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_value * ucontrol); -typedef int (snd_kcontrol_put_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_value * ucontrol); +typedef int (snd_kcontrol_info_t) (snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo); +typedef int (snd_kcontrol_get_t) (snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); +typedef int (snd_kcontrol_put_t) (snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); -struct snd_kcontrol_new { +typedef struct _snd_kcontrol_new { snd_ctl_elem_iface_t iface; /* interface identifier */ unsigned int device; /* device/client number */ unsigned int subdevice; /* subdevice (substream) number */ @@ -43,40 +53,40 @@ struct snd_kcontrol_new { snd_kcontrol_get_t *get; snd_kcontrol_put_t *put; unsigned long private_value; -}; +} snd_kcontrol_new_t; -struct snd_kcontrol_volatile { - struct snd_ctl_file *owner; /* locked */ +typedef struct _snd_kcontrol_volatile { + snd_ctl_file_t *owner; /* locked */ pid_t owner_pid; unsigned int access; /* access rights */ -}; +} snd_kcontrol_volatile_t; -struct snd_kcontrol { +struct _snd_kcontrol { struct list_head list; /* list of controls */ - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; unsigned int count; /* count of same elements */ snd_kcontrol_info_t *info; snd_kcontrol_get_t *get; snd_kcontrol_put_t *put; unsigned long private_value; void *private_data; - void (*private_free)(struct snd_kcontrol *kcontrol); - struct snd_kcontrol_volatile vd[0]; /* volatile data */ + void (*private_free)(snd_kcontrol_t *kcontrol); + snd_kcontrol_volatile_t vd[0]; /* volatile data */ }; -#define snd_kcontrol(n) list_entry(n, struct snd_kcontrol, list) +#define snd_kcontrol(n) list_entry(n, snd_kcontrol_t, list) -struct snd_kctl_event { +typedef struct _snd_kctl_event { struct list_head list; /* list of events */ - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; unsigned int mask; -}; +} snd_kctl_event_t; -#define snd_kctl_event(n) list_entry(n, struct snd_kctl_event, list) +#define snd_kctl_event(n) list_entry(n, snd_kctl_event_t, list) -struct snd_ctl_file { +struct _snd_ctl_file { struct list_head list; /* list of all control files */ - struct snd_card *card; + snd_card_t *card; pid_t pid; int prefer_pcm_subdevice; int prefer_rawmidi_subdevice; @@ -87,25 +97,25 @@ struct snd_ctl_file { struct list_head events; /* waiting events for read */ }; -#define snd_ctl_file(n) list_entry(n, struct snd_ctl_file, list) +#define snd_ctl_file(n) list_entry(n, snd_ctl_file_t, list) -typedef int (*snd_kctl_ioctl_func_t) (struct snd_card * card, - struct snd_ctl_file * control, - unsigned int cmd, unsigned long arg); +typedef int (*snd_kctl_ioctl_func_t) (snd_card_t * card, + snd_ctl_file_t * control, + unsigned int cmd, unsigned long arg); -void snd_ctl_notify(struct snd_card * card, unsigned int mask, struct snd_ctl_elem_id * id); +void snd_ctl_notify(snd_card_t * card, unsigned int mask, snd_ctl_elem_id_t * id); -struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol * kcontrol, unsigned int access); -struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new * kcontrolnew, void * private_data); -void snd_ctl_free_one(struct snd_kcontrol * kcontrol); -int snd_ctl_add(struct snd_card * card, struct snd_kcontrol * kcontrol); -int snd_ctl_remove(struct snd_card * card, struct snd_kcontrol * kcontrol); -int snd_ctl_remove_id(struct snd_card * card, struct snd_ctl_elem_id *id); -int snd_ctl_rename_id(struct snd_card * card, struct snd_ctl_elem_id *src_id, struct snd_ctl_elem_id *dst_id); -struct snd_kcontrol *snd_ctl_find_numid(struct snd_card * card, unsigned int numid); -struct snd_kcontrol *snd_ctl_find_id(struct snd_card * card, struct snd_ctl_elem_id *id); +snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * kcontrol, unsigned int access); +snd_kcontrol_t *snd_ctl_new1(const snd_kcontrol_new_t * kcontrolnew, void * private_data); +void snd_ctl_free_one(snd_kcontrol_t * kcontrol); +int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol); +int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol); +int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id); +int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem_id_t *dst_id); +snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid); +snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id); -int snd_ctl_create(struct snd_card *card); +int snd_ctl_create(snd_card_t *card); int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn); int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn); @@ -117,20 +127,20 @@ int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn); #define snd_ctl_unregister_ioctl_compat(fcn) #endif -int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control); -int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file, struct snd_ctl_elem_value *control); +int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control); +int snd_ctl_elem_write(snd_card_t *card, snd_ctl_file_t *file, snd_ctl_elem_value_t *control); -static inline unsigned int snd_ctl_get_ioffnum(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id) +static inline unsigned int snd_ctl_get_ioffnum(snd_kcontrol_t *kctl, snd_ctl_elem_id_t *id) { return id->numid - kctl->id.numid; } -static inline unsigned int snd_ctl_get_ioffidx(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id) +static inline unsigned int snd_ctl_get_ioffidx(snd_kcontrol_t *kctl, snd_ctl_elem_id_t *id) { return id->index - kctl->id.index; } -static inline unsigned int snd_ctl_get_ioff(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id) +static inline unsigned int snd_ctl_get_ioff(snd_kcontrol_t *kctl, snd_ctl_elem_id_t *id) { if (id->numid) { return snd_ctl_get_ioffnum(kctl, id); @@ -139,8 +149,8 @@ static inline unsigned int snd_ctl_get_ioff(struct snd_kcontrol *kctl, struct sn } } -static inline struct snd_ctl_elem_id *snd_ctl_build_ioff(struct snd_ctl_elem_id *dst_id, - struct snd_kcontrol *src_kctl, +static inline snd_ctl_elem_id_t *snd_ctl_build_ioff(snd_ctl_elem_id_t *dst_id, + snd_kcontrol_t *src_kctl, unsigned int offset) { *dst_id = src_kctl->id; diff --git a/trunk/include/sound/core.h b/trunk/include/sound/core.h index 90ac6132ea3b..2be65ad2fd83 100644 --- a/trunk/include/sound/core.h +++ b/trunk/include/sound/core.h @@ -28,6 +28,13 @@ #include /* struct workqueue_struct */ #include /* pm_message_t */ +/* Typedef's */ +typedef struct sndrv_interval snd_interval_t; +typedef enum sndrv_card_type snd_card_type; +typedef struct sndrv_xferi snd_xferi_t; +typedef struct sndrv_xfern snd_xfern_t; +typedef struct sndrv_xferv snd_xferv_t; + /* forward declarations */ #ifdef CONFIG_PCI struct pci_dev; @@ -40,50 +47,76 @@ struct sbus_dev; #define SNDRV_DEV_TYPE_RANGE_SIZE 0x1000 -typedef int __bitwise snd_device_type_t; -#define SNDRV_DEV_TOPLEVEL ((__force snd_device_type_t) 0) -#define SNDRV_DEV_CONTROL ((__force snd_device_type_t) 1) -#define SNDRV_DEV_LOWLEVEL_PRE ((__force snd_device_type_t) 2) -#define SNDRV_DEV_LOWLEVEL_NORMAL ((__force snd_device_type_t) 0x1000) -#define SNDRV_DEV_PCM ((__force snd_device_type_t) 0x1001) -#define SNDRV_DEV_RAWMIDI ((__force snd_device_type_t) 0x1002) -#define SNDRV_DEV_TIMER ((__force snd_device_type_t) 0x1003) -#define SNDRV_DEV_SEQUENCER ((__force snd_device_type_t) 0x1004) -#define SNDRV_DEV_HWDEP ((__force snd_device_type_t) 0x1005) -#define SNDRV_DEV_INFO ((__force snd_device_type_t) 0x1006) -#define SNDRV_DEV_BUS ((__force snd_device_type_t) 0x1007) -#define SNDRV_DEV_CODEC ((__force snd_device_type_t) 0x1008) -#define SNDRV_DEV_LOWLEVEL ((__force snd_device_type_t) 0x2000) - -typedef int __bitwise snd_device_state_t; -#define SNDRV_DEV_BUILD ((__force snd_device_state_t) 0) -#define SNDRV_DEV_REGISTERED ((__force snd_device_state_t) 1) -#define SNDRV_DEV_DISCONNECTED ((__force snd_device_state_t) 2) - -typedef int __bitwise snd_device_cmd_t; -#define SNDRV_DEV_CMD_PRE ((__force snd_device_cmd_t) 0) -#define SNDRV_DEV_CMD_NORMAL ((__force snd_device_cmd_t) 1) -#define SNDRV_DEV_CMD_POST ((__force snd_device_cmd_t) 2) - -struct snd_device; - -struct snd_device_ops { - int (*dev_free)(struct snd_device *dev); - int (*dev_register)(struct snd_device *dev); - int (*dev_disconnect)(struct snd_device *dev); - int (*dev_unregister)(struct snd_device *dev); -}; - -struct snd_device { +typedef enum { + SNDRV_DEV_TOPLEVEL = (0*SNDRV_DEV_TYPE_RANGE_SIZE), + SNDRV_DEV_CONTROL, + SNDRV_DEV_LOWLEVEL_PRE, + SNDRV_DEV_LOWLEVEL_NORMAL = (1*SNDRV_DEV_TYPE_RANGE_SIZE), + SNDRV_DEV_PCM, + SNDRV_DEV_RAWMIDI, + SNDRV_DEV_TIMER, + SNDRV_DEV_SEQUENCER, + SNDRV_DEV_HWDEP, + SNDRV_DEV_INFO, + SNDRV_DEV_BUS, + SNDRV_DEV_CODEC, + SNDRV_DEV_LOWLEVEL = (2*SNDRV_DEV_TYPE_RANGE_SIZE) +} snd_device_type_t; + +typedef enum { + SNDRV_DEV_BUILD, + SNDRV_DEV_REGISTERED, + SNDRV_DEV_DISCONNECTED +} snd_device_state_t; + +typedef enum { + SNDRV_DEV_CMD_PRE = 0, + SNDRV_DEV_CMD_NORMAL = 1, + SNDRV_DEV_CMD_POST = 2 +} snd_device_cmd_t; + +typedef struct _snd_card snd_card_t; +typedef struct _snd_device snd_device_t; + +typedef int (snd_dev_free_t)(snd_device_t *device); +typedef int (snd_dev_register_t)(snd_device_t *device); +typedef int (snd_dev_disconnect_t)(snd_device_t *device); +typedef int (snd_dev_unregister_t)(snd_device_t *device); + +typedef struct { + snd_dev_free_t *dev_free; + snd_dev_register_t *dev_register; + snd_dev_disconnect_t *dev_disconnect; + snd_dev_unregister_t *dev_unregister; +} snd_device_ops_t; + +struct _snd_device { struct list_head list; /* list of registered devices */ - struct snd_card *card; /* card which holds this device */ + snd_card_t *card; /* card which holds this device */ snd_device_state_t state; /* state of the device */ snd_device_type_t type; /* device type */ void *device_data; /* device structure */ - struct snd_device_ops *ops; /* operations */ + snd_device_ops_t *ops; /* operations */ }; -#define snd_device(n) list_entry(n, struct snd_device, list) +#define snd_device(n) list_entry(n, snd_device_t, list) + +/* various typedefs */ + +typedef struct snd_info_entry snd_info_entry_t; +typedef struct _snd_pcm snd_pcm_t; +typedef struct _snd_pcm_str snd_pcm_str_t; +typedef struct _snd_pcm_substream snd_pcm_substream_t; +typedef struct _snd_mixer snd_kmixer_t; +typedef struct _snd_rawmidi snd_rawmidi_t; +typedef struct _snd_ctl_file snd_ctl_file_t; +typedef struct _snd_kcontrol snd_kcontrol_t; +typedef struct _snd_timer snd_timer_t; +typedef struct _snd_timer_instance snd_timer_instance_t; +typedef struct _snd_hwdep snd_hwdep_t; +#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) +typedef struct _snd_oss_mixer snd_mixer_oss_t; +#endif /* monitor files for graceful shutdown (hotplug) */ @@ -96,7 +129,7 @@ struct snd_shutdown_f_ops; /* define it later in init.c */ /* main structure for soundcard */ -struct snd_card { +struct _snd_card { int number; /* number of soundcard (index to snd_cards) */ @@ -110,7 +143,7 @@ struct snd_card { struct module *module; /* top-level module */ void *private_data; /* private data for soundcard */ - void (*private_free) (struct snd_card *card); /* callback for freeing of + void (*private_free) (snd_card_t *card); /* callback for freeing of private data */ struct list_head devices; /* devices */ @@ -122,8 +155,8 @@ struct snd_card { struct list_head controls; /* all controls for this card */ struct list_head ctl_files; /* active control files */ - struct snd_info_entry *proc_root; /* root for soundcard specific files */ - struct snd_info_entry *proc_id; /* the card id */ + snd_info_entry_t *proc_root; /* root for soundcard specific files */ + snd_info_entry_t *proc_id; /* the card id */ struct proc_dir_entry *proc_root_link; /* number link to real id */ struct snd_monitor_file *files; /* all files associated to this card */ @@ -134,64 +167,92 @@ struct snd_card { wait_queue_head_t shutdown_sleep; struct work_struct free_workq; /* for free in workqueue */ struct device *dev; +#ifdef CONFIG_SND_GENERIC_DRIVER + struct snd_generic_device *generic_dev; +#endif #ifdef CONFIG_PM + int (*pm_suspend)(snd_card_t *card, pm_message_t state); + int (*pm_resume)(snd_card_t *card); + void *pm_private_data; unsigned int power_state; /* power state */ struct semaphore power_lock; /* power lock */ wait_queue_head_t power_sleep; #endif #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) - struct snd_mixer_oss *mixer_oss; + snd_mixer_oss_t *mixer_oss; int mixer_oss_change_count; #endif }; #ifdef CONFIG_PM -static inline void snd_power_lock(struct snd_card *card) +static inline void snd_power_lock(snd_card_t *card) { down(&card->power_lock); } -static inline void snd_power_unlock(struct snd_card *card) +static inline void snd_power_unlock(snd_card_t *card) { up(&card->power_lock); } -static inline unsigned int snd_power_get_state(struct snd_card *card) +static inline unsigned int snd_power_get_state(snd_card_t *card) { return card->power_state; } -static inline void snd_power_change_state(struct snd_card *card, unsigned int state) +static inline void snd_power_change_state(snd_card_t *card, unsigned int state) { card->power_state = state; wake_up(&card->power_sleep); } /* init.c */ -int snd_power_wait(struct snd_card *card, unsigned int power_state, struct file *file); +int snd_power_wait(snd_card_t *card, unsigned int power_state, struct file *file); + +int snd_card_set_pm_callback(snd_card_t *card, + int (*suspend)(snd_card_t *, pm_message_t), + int (*resume)(snd_card_t *), + void *private_data); +int snd_card_set_generic_pm_callback(snd_card_t *card, + int (*suspend)(snd_card_t *, pm_message_t), + int (*resume)(snd_card_t *), + void *private_data); +#define snd_card_set_isa_pm_callback(card,suspend,resume,data) \ + snd_card_set_generic_pm_callback(card, suspend, resume, data) +struct pci_dev; +int snd_card_pci_suspend(struct pci_dev *dev, pm_message_t state); +int snd_card_pci_resume(struct pci_dev *dev); +#define SND_PCI_PM_CALLBACKS \ + .suspend = snd_card_pci_suspend, .resume = snd_card_pci_resume #else /* ! CONFIG_PM */ #define snd_power_lock(card) do { (void)(card); } while (0) #define snd_power_unlock(card) do { (void)(card); } while (0) -static inline int snd_power_wait(struct snd_card *card, unsigned int state, struct file *file) { return 0; } +static inline int snd_power_wait(snd_card_t *card, unsigned int state, struct file *file) { return 0; } #define snd_power_get_state(card) SNDRV_CTL_POWER_D0 #define snd_power_change_state(card, state) do { (void)(card); } while (0) +#define snd_card_set_pm_callback(card,suspend,resume,data) +#define snd_card_set_generic_pm_callback(card,suspend,resume,data) +#define snd_card_set_isa_pm_callback(card,suspend,resume,data) +#define SND_PCI_PM_CALLBACKS #endif /* CONFIG_PM */ -struct snd_minor { - int type; /* SNDRV_DEVICE_TYPE_XXX */ - int card; /* card number */ +struct _snd_minor { + struct list_head list; /* list of all minors per card */ + int number; /* minor number */ int device; /* device number */ + const char *comment; /* for /proc/asound/devices */ struct file_operations *f_ops; /* file operations */ - void *private_data; /* private data for f_ops->open */ char name[0]; /* device name (keep at the end of structure) */ }; +typedef struct _snd_minor snd_minor_t; + /* sound.c */ extern int snd_major; @@ -199,18 +260,12 @@ extern int snd_ecards_limit; void snd_request_card(int card); -int snd_register_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, void *private_data, - const char *name); -int snd_unregister_device(int type, struct snd_card *card, int dev); -void *snd_lookup_minor_data(unsigned int minor, int type); +int snd_register_device(int type, snd_card_t *card, int dev, snd_minor_t *reg, const char *name); +int snd_unregister_device(int type, snd_card_t *card, int dev); #ifdef CONFIG_SND_OSSEMUL -int snd_register_oss_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, void *private_data, - const char *name); -int snd_unregister_oss_device(int type, struct snd_card *card, int dev); -void *snd_lookup_oss_minor_data(unsigned int minor, int type); +int snd_register_oss_device(int type, snd_card_t *card, int dev, snd_minor_t *reg, const char *name); +int snd_unregister_oss_device(int type, snd_card_t *card, int dev); #endif int snd_minor_info_init(void); @@ -221,9 +276,11 @@ int snd_minor_info_done(void); #ifdef CONFIG_SND_OSSEMUL int snd_minor_info_oss_init(void); int snd_minor_info_oss_done(void); +int snd_oss_init_module(void); #else #define snd_minor_info_oss_init() /*NOP*/ #define snd_minor_info_oss_done() /*NOP*/ +#define snd_oss_init_module() 0 #endif /* memory.c */ @@ -234,41 +291,43 @@ int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size /* init.c */ extern unsigned int snd_cards_lock; -extern struct snd_card *snd_cards[SNDRV_CARDS]; +extern snd_card_t *snd_cards[SNDRV_CARDS]; extern rwlock_t snd_card_rwlock; #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) #define SND_MIXER_OSS_NOTIFY_REGISTER 0 #define SND_MIXER_OSS_NOTIFY_DISCONNECT 1 #define SND_MIXER_OSS_NOTIFY_FREE 2 -extern int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int cmd); +extern int (*snd_mixer_oss_notify_callback)(snd_card_t *card, int cmd); #endif -struct snd_card *snd_card_new(int idx, const char *id, +snd_card_t *snd_card_new(int idx, const char *id, struct module *module, int extra_size); -int snd_card_disconnect(struct snd_card *card); -int snd_card_free(struct snd_card *card); -int snd_card_free_in_thread(struct snd_card *card); -int snd_card_register(struct snd_card *card); +int snd_card_disconnect(snd_card_t *card); +int snd_card_free(snd_card_t *card); +int snd_card_free_in_thread(snd_card_t *card); +int snd_card_register(snd_card_t *card); int snd_card_info_init(void); int snd_card_info_done(void); -int snd_component_add(struct snd_card *card, const char *component); -int snd_card_file_add(struct snd_card *card, struct file *file); -int snd_card_file_remove(struct snd_card *card, struct file *file); +int snd_component_add(snd_card_t *card, const char *component); +int snd_card_file_add(snd_card_t *card, struct file *file); +int snd_card_file_remove(snd_card_t *card, struct file *file); #ifndef snd_card_set_dev #define snd_card_set_dev(card,devptr) ((card)->dev = (devptr)) #endif +/* register a generic device (for ISA, etc) */ +int snd_card_set_generic_dev(snd_card_t *card); /* device.c */ -int snd_device_new(struct snd_card *card, snd_device_type_t type, - void *device_data, struct snd_device_ops *ops); -int snd_device_register(struct snd_card *card, void *device_data); -int snd_device_register_all(struct snd_card *card); -int snd_device_disconnect(struct snd_card *card, void *device_data); -int snd_device_disconnect_all(struct snd_card *card); -int snd_device_free(struct snd_card *card, void *device_data); -int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd); +int snd_device_new(snd_card_t *card, snd_device_type_t type, + void *device_data, snd_device_ops_t *ops); +int snd_device_register(snd_card_t *card, void *device_data); +int snd_device_register_all(snd_card_t *card); +int snd_device_disconnect(snd_card_t *card, void *device_data); +int snd_device_disconnect_all(snd_card_t *card); +int snd_device_free(snd_card_t *card, void *device_data); +int snd_device_free_all(snd_card_t *card, snd_device_cmd_t cmd); /* isadma.c */ @@ -384,6 +443,4 @@ void snd_verbose_printd(const char *file, int line, const char *format, ...) #endif #endif -#include "typedefs.h" - #endif /* __SOUND_CORE_H */ diff --git a/trunk/include/sound/cs4231.h b/trunk/include/sound/cs4231.h index ac6a5d882088..d7f90823778a 100644 --- a/trunk/include/sound/cs4231.h +++ b/trunk/include/sound/cs4231.h @@ -26,6 +26,21 @@ #include "pcm.h" #include "timer.h" +#ifdef CONFIG_SBUS +#define SBUS_SUPPORT +#include +#endif + +#if defined(CONFIG_PCI) && defined(CONFIG_SPARC64) +#define EBUS_SUPPORT +#include +#include +#endif + +#if !defined(SBUS_SUPPORT) && !defined(EBUS_SUPPORT) +#define LEGACY_SUPPORT +#endif + /* IO ports */ #define CS4231P(x) (c_d_c_CS4231##x) @@ -217,14 +232,18 @@ #define CS4231_HWSHARE_DMA1 (1<<1) #define CS4231_HWSHARE_DMA2 (1<<2) -struct snd_cs4231 { +typedef struct _snd_cs4231 cs4231_t; + +struct _snd_cs4231 { unsigned long port; /* base i/o port */ +#ifdef LEGACY_SUPPORT struct resource *res_port; unsigned long cport; /* control base i/o port (CS4236) */ struct resource *res_cport; int irq; /* IRQ line */ int dma1; /* playback DMA */ int dma2; /* record DMA */ +#endif unsigned short version; /* version of CODEC chip */ unsigned short mode; /* see to CS4231_MODE_XXXX */ unsigned short hardware; /* see to CS4231_HW_XXXX */ @@ -232,11 +251,29 @@ struct snd_cs4231 { unsigned short single_dma:1, /* forced single DMA mode (GUS 16-bit daughter board) or dma1 == dma2 */ ebus_flag:1; /* SPARC: EBUS present */ - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; - struct snd_timer *timer; +#ifdef EBUS_SUPPORT + struct ebus_dma_info eb2c; + struct ebus_dma_info eb2p; +#endif + +#if defined(SBUS_SUPPORT) || defined(EBUS_SUPPORT) + union { +#ifdef SBUS_SUPPORT + struct sbus_dev *sdev; +#endif +#ifdef EBUS_SUPPORT + struct pci_dev *pdev; +#endif + } dev_u; + unsigned int p_periods_sent; + unsigned int c_periods_sent; +#endif + + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; + snd_timer_t *timer; unsigned char image[32]; /* registers image */ unsigned char eimage[32]; /* extended registers image */ @@ -244,59 +281,63 @@ struct snd_cs4231 { int mce_bit; int calibrate_mute; int sw_3d_bit; +#ifdef LEGACY_SUPPORT unsigned int p_dma_size; unsigned int c_dma_size; +#endif spinlock_t reg_lock; struct semaphore mce_mutex; struct semaphore open_mutex; - int (*rate_constraint) (struct snd_pcm_runtime *runtime); - void (*set_playback_format) (struct snd_cs4231 *chip, struct snd_pcm_hw_params *hw_params, unsigned char pdfr); - void (*set_capture_format) (struct snd_cs4231 *chip, struct snd_pcm_hw_params *hw_params, unsigned char cdfr); - void (*trigger) (struct snd_cs4231 *chip, unsigned int what, int start); + int (*rate_constraint) (snd_pcm_runtime_t *runtime); + void (*set_playback_format) (cs4231_t *chip, snd_pcm_hw_params_t *hw_params, unsigned char pdfr); + void (*set_capture_format) (cs4231_t *chip, snd_pcm_hw_params_t *hw_params, unsigned char cdfr); + void (*trigger) (cs4231_t *chip, unsigned int what, int start); #ifdef CONFIG_PM - void (*suspend) (struct snd_cs4231 *chip); - void (*resume) (struct snd_cs4231 *chip); + void (*suspend) (cs4231_t *chip); + void (*resume) (cs4231_t *chip); #endif void *dma_private_data; - int (*claim_dma) (struct snd_cs4231 *chip, void *dma_private_data, int dma); - int (*release_dma) (struct snd_cs4231 *chip, void *dma_private_data, int dma); +#ifdef LEGACY_SUPPORT + int (*claim_dma) (cs4231_t *chip, void *dma_private_data, int dma); + int (*release_dma) (cs4231_t *chip, void *dma_private_data, int dma); +#endif }; /* exported functions */ -void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char val); -unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg); -void snd_cs4236_ext_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char val); -unsigned char snd_cs4236_ext_in(struct snd_cs4231 *chip, unsigned char reg); -void snd_cs4231_mce_up(struct snd_cs4231 *chip); -void snd_cs4231_mce_down(struct snd_cs4231 *chip); +void snd_cs4231_out(cs4231_t *chip, unsigned char reg, unsigned char val); +unsigned char snd_cs4231_in(cs4231_t *chip, unsigned char reg); +void snd_cs4236_ext_out(cs4231_t *chip, unsigned char reg, unsigned char val); +unsigned char snd_cs4236_ext_in(cs4231_t *chip, unsigned char reg); +void snd_cs4231_mce_up(cs4231_t *chip); +void snd_cs4231_mce_down(cs4231_t *chip); irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs); -const char *snd_cs4231_chip_id(struct snd_cs4231 *chip); +const char *snd_cs4231_chip_id(cs4231_t *chip); -int snd_cs4231_create(struct snd_card *card, +int snd_cs4231_create(snd_card_t * card, unsigned long port, unsigned long cport, int irq, int dma1, int dma2, unsigned short hardware, unsigned short hwshare, - struct snd_cs4231 ** rchip); -int snd_cs4231_pcm(struct snd_cs4231 * chip, int device, struct snd_pcm **rpcm); -int snd_cs4231_timer(struct snd_cs4231 * chip, int device, struct snd_timer **rtimer); -int snd_cs4231_mixer(struct snd_cs4231 * chip); + cs4231_t ** rchip); +int snd_cs4231_pcm(cs4231_t * chip, int device, snd_pcm_t **rpcm); +int snd_cs4231_timer(cs4231_t * chip, int device, snd_timer_t **rtimer); +int snd_cs4231_mixer(cs4231_t * chip); -int snd_cs4236_create(struct snd_card *card, +int snd_cs4236_create(snd_card_t * card, unsigned long port, unsigned long cport, int irq, int dma1, int dma2, unsigned short hardware, unsigned short hwshare, - struct snd_cs4231 ** rchip); -int snd_cs4236_pcm(struct snd_cs4231 * chip, int device, struct snd_pcm **rpcm); -int snd_cs4236_mixer(struct snd_cs4231 * chip); + cs4231_t ** rchip); +int snd_cs4236_pcm(cs4231_t * chip, int device, snd_pcm_t **rpcm); +int snd_cs4236_mixer(cs4231_t * chip); /* * mixer library @@ -308,9 +349,9 @@ int snd_cs4236_mixer(struct snd_cs4231 * chip); .get = snd_cs4231_get_single, .put = snd_cs4231_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -int snd_cs4231_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_cs4231_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); +int snd_cs4231_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo); +int snd_cs4231_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); +int snd_cs4231_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); #define CS4231_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ @@ -318,8 +359,8 @@ int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val .get = snd_cs4231_get_double, .put = snd_cs4231_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -int snd_cs4231_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_cs4231_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_cs4231_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); +int snd_cs4231_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo); +int snd_cs4231_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); +int snd_cs4231_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); #endif /* __SOUND_CS4231_H */ diff --git a/trunk/include/sound/cs46xx.h b/trunk/include/sound/cs46xx.h index 199b5098ff7e..b0c0e192eb56 100644 --- a/trunk/include/sound/cs46xx.h +++ b/trunk/include/sound/cs46xx.h @@ -1631,41 +1631,42 @@ #define CS46XX_MIXER_SPDIF_INPUT_ELEMENT 1 #define CS46XX_MIXER_SPDIF_OUTPUT_ELEMENT 2 +typedef struct _snd_cs46xx cs46xx_t; -struct snd_cs46xx_pcm { +typedef struct _snd_cs46xx_pcm_t { struct snd_dma_buffer hw_buf; unsigned int ctl; unsigned int shift; /* Shift count to trasform frames in bytes */ - struct snd_pcm_indirect pcm_rec; - struct snd_pcm_substream *substream; + snd_pcm_indirect_t pcm_rec; + snd_pcm_substream_t *substream; - struct dsp_pcm_channel_descriptor * pcm_channel; + pcm_channel_descriptor_t * pcm_channel; int pcm_channel_id; /* Fron Rear, Center Lfe ... */ -}; +} cs46xx_pcm_t; -struct snd_cs46xx_region { +typedef struct { char name[24]; unsigned long base; void __iomem *remap_addr; unsigned long size; struct resource *resource; -}; +} snd_cs46xx_region_t; -struct snd_cs46xx { +struct _snd_cs46xx { int irq; unsigned long ba0_addr; unsigned long ba1_addr; union { struct { - struct snd_cs46xx_region ba0; - struct snd_cs46xx_region data0; - struct snd_cs46xx_region data1; - struct snd_cs46xx_region pmem; - struct snd_cs46xx_region reg; + snd_cs46xx_region_t ba0; + snd_cs46xx_region_t data0; + snd_cs46xx_region_t data1; + snd_cs46xx_region_t pmem; + snd_cs46xx_region_t reg; } name; - struct snd_cs46xx_region idx[5]; + snd_cs46xx_region_t idx[5]; } region; unsigned int mode; @@ -1675,34 +1676,34 @@ struct snd_cs46xx { unsigned int ctl; unsigned int shift; /* Shift count to trasform frames in bytes */ - struct snd_pcm_indirect pcm_rec; - struct snd_pcm_substream *substream; + snd_pcm_indirect_t pcm_rec; + snd_pcm_substream_t *substream; } capt; int nr_ac97_codecs; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97[MAX_NR_AC97]; + ac97_bus_t *ac97_bus; + ac97_t *ac97[MAX_NR_AC97]; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; + snd_card_t *card; + snd_pcm_t *pcm; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *midi_input; - struct snd_rawmidi_substream *midi_output; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *midi_input; + snd_rawmidi_substream_t *midi_output; spinlock_t reg_lock; unsigned int midcr; unsigned int uartm; int amplifier; - void (*amplifier_ctrl)(struct snd_cs46xx *, int); - void (*active_ctrl)(struct snd_cs46xx *, int); - void (*mixer_init)(struct snd_cs46xx *); + void (*amplifier_ctrl)(cs46xx_t *, int); + void (*active_ctrl)(cs46xx_t *, int); + void (*mixer_init)(cs46xx_t *); int acpi_port; - struct snd_kcontrol *eapd_switch; /* for amplifier hack */ + snd_kcontrol_t *eapd_switch; /* for amplifier hack */ int accept_valid; /* accept mmap valid (for OSS) */ struct gameport *gameport; @@ -1713,31 +1714,29 @@ struct snd_cs46xx { #ifdef CONFIG_SND_CS46XX_NEW_DSP struct semaphore spos_mutex; - struct dsp_spos_instance * dsp_spos_instance; + dsp_spos_instance_t * dsp_spos_instance; - struct snd_pcm *pcm_rear; - struct snd_pcm *pcm_center_lfe; - struct snd_pcm *pcm_iec958; + snd_pcm_t *pcm_rear; + snd_pcm_t *pcm_center_lfe; + snd_pcm_t *pcm_iec958; #else /* for compatibility */ - struct snd_cs46xx_pcm *playback_pcm; + cs46xx_pcm_t *playback_pcm; unsigned int play_ctl; #endif }; -int snd_cs46xx_create(struct snd_card *card, +int snd_cs46xx_create(snd_card_t *card, struct pci_dev *pci, int external_amp, int thinkpad, - struct snd_cs46xx **rcodec); -int snd_cs46xx_suspend(struct pci_dev *pci, pm_message_t state); -int snd_cs46xx_resume(struct pci_dev *pci); - -int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm); -int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm); -int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm); -int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm); -int snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device); -int snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rmidi); -int snd_cs46xx_start_dsp(struct snd_cs46xx *chip); -int snd_cs46xx_gameport(struct snd_cs46xx *chip); + cs46xx_t **rcodec); + +int snd_cs46xx_pcm(cs46xx_t *chip, int device, snd_pcm_t **rpcm); +int snd_cs46xx_pcm_rear(cs46xx_t *chip, int device, snd_pcm_t **rpcm); +int snd_cs46xx_pcm_iec958(cs46xx_t *chip, int device, snd_pcm_t **rpcm); +int snd_cs46xx_pcm_center_lfe(cs46xx_t *chip, int device, snd_pcm_t **rpcm); +int snd_cs46xx_mixer(cs46xx_t *chip, int spdif_device); +int snd_cs46xx_midi(cs46xx_t *chip, int device, snd_rawmidi_t **rmidi); +int snd_cs46xx_start_dsp(cs46xx_t *chip); +int snd_cs46xx_gameport(cs46xx_t *chip); #endif /* __SOUND_CS46XX_H */ diff --git a/trunk/include/sound/cs46xx_dsp_scb_types.h b/trunk/include/sound/cs46xx_dsp_scb_types.h index 9cb6c7d09567..3f990a3a6903 100644 --- a/trunk/include/sound/cs46xx_dsp_scb_types.h +++ b/trunk/include/sound/cs46xx_dsp_scb_types.h @@ -41,7 +41,7 @@ /* This structs are used internally by the SP */ -struct dsp_basic_dma_req { +typedef struct _basic_dma_req_t { /* DMA Requestor Word 0 (DCW) fields: 31 [30-28]27 [26:24] 23 22 21 20 [19:18] [17:16] 15 14 13 12 11 10 9 8 7 6 [5:0] @@ -53,9 +53,9 @@ struct dsp_basic_dma_req { u32 dmw; /* DMA Mode Word */ u32 saw; /* Source Address Word */ u32 daw; /* Destination Address Word */ -}; +} basic_dma_req_t; -struct dsp_scatter_gather_ext { +typedef struct _scatter_gather_ext_t { u32 npaw; /* Next-Page Address Word */ /* DMA Requestor Word 5 (NPCW) fields: @@ -69,9 +69,9 @@ struct dsp_scatter_gather_ext { u32 lbaw; /* Loop-Begin Address Word */ u32 nplbaw; /* Next-Page after Loop-Begin Address Word */ u32 sgaw; /* Scatter/Gather Address Word */ -}; +} scatter_gather_ext_t; -struct dsp_volume_control { +typedef struct _volume_control_t { ___DSP_DUAL_16BIT_ALLOC( rightTarg, /* Target volume for left & right channels */ leftTarg @@ -80,10 +80,10 @@ struct dsp_volume_control { rightVol, /* Current left & right channel volumes */ leftVol ) -}; +} volume_control_t; /* Generic stream control block (SCB) structure definition */ -struct dsp_generic_scb { +typedef struct _generic_scb_t { /* For streaming I/O, the DSP should never alter any words in the DMA requestor or the scatter/gather extension. Only ad hoc DMA request streams are free to alter the requestor (currently only occur in the @@ -99,13 +99,13 @@ struct dsp_generic_scb { /* Initialized by the host, only modified by DMA R/O for the DSP task */ - struct dsp_basic_dma_req basic_req; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ /* Scatter/gather DMA requestor extension (5 ints) Initialized by the host, only modified by DMA DSP task never needs to even read these. */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ /* Sublist pointer & next stream control block (SCB) link. Initialized & modified by the host R/O for the DSP task @@ -179,11 +179,11 @@ struct dsp_generic_scb { These two 32-bit words are redefined for wavetable & 3-D voices. */ - struct dsp_volume_control vol_ctrl_t; /* Optional */ -}; + volume_control_t vol_ctrl_t; /* Optional */ +} generic_scb_t; -struct dsp_spos_control_block { +typedef struct _spos_control_block_t { /* WARNING: Certain items in this structure are modified by the host Any dword that can be modified by the host, must not be modified by the SP as the host can only do atomic dword @@ -273,10 +273,10 @@ struct dsp_spos_control_block { u32 r32_save_for_spurious_int; u32 r32_save_for_trap; u32 r32_save_for_HFG; -}; +} spos_control_block_t; /* SPB for MIX_TO_OSTREAM algorithm family */ -struct dsp_mix2_ostream_spb +typedef struct _mix2_ostream_spb_t { /* 16b.16b integer.frac approximation to the number of 3 sample triplets to output each @@ -290,13 +290,13 @@ struct dsp_mix2_ostream_spb output triplets since the start of group */ u32 accumOutTriplets; -}; +} mix2_ostream_spb_t; /* SCB for Timing master algorithm */ -struct dsp_timing_master_scb { +typedef struct _timing_master_scb_t { /* First 12 dwords from generic_scb_t */ - struct dsp_basic_dma_req basic_req; /* Optional */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ ___DSP_DUAL_16BIT_ALLOC( next_scb, /* REQUIRED */ sub_list_ptr /* REQUIRED */ @@ -358,13 +358,13 @@ struct dsp_timing_master_scb { number of samples to output each frame. (approximation must be floor, to insure */ u32 nsamp_per_frm_q15; -}; +} timing_master_scb_t; /* SCB for CODEC output algorithm */ -struct dsp_codec_output_scb { +typedef struct _codec_output_scb_t { /* First 13 dwords from generic_scb_t */ - struct dsp_basic_dma_req basic_req; /* Optional */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ ___DSP_DUAL_16BIT_ALLOC( next_scb, /* REQUIRED */ sub_list_ptr /* REQUIRED */ @@ -422,13 +422,13 @@ struct dsp_codec_output_scb { reserved, last_sub_ptr ) -}; +} codec_output_scb_t; /* SCB for CODEC input algorithm */ -struct dsp_codec_input_scb { +typedef struct _codec_input_scb_t { /* First 13 dwords from generic_scb_t */ - struct dsp_basic_dma_req basic_req; /* Optional */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ ___DSP_DUAL_16BIT_ALLOC( next_scb, /* REQUIRED */ sub_list_ptr /* REQUIRED */ @@ -479,13 +479,13 @@ struct dsp_codec_input_scb { ) u32 reserved2; -}; +} codec_input_scb_t; -struct dsp_pcm_serial_input_scb { +typedef struct _pcm_serial_input_scb_t { /* First 13 dwords from generic_scb_t */ - struct dsp_basic_dma_req basic_req; /* Optional */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ ___DSP_DUAL_16BIT_ALLOC( next_scb, /* REQUIRED */ sub_list_ptr /* REQUIRED */ @@ -512,11 +512,11 @@ struct dsp_pcm_serial_input_scb { ) /* Initialized by the host (host updates target volumes) */ - struct dsp_volume_control psi_vol_ctrl; + volume_control_t psi_vol_ctrl; -}; +} pcm_serial_input_scb_t; -struct dsp_src_task_scb { +typedef struct _src_task_scb_t { ___DSP_DUAL_16BIT_ALLOC( frames_left_in_gof, gofs_left_in_sec @@ -571,10 +571,10 @@ struct dsp_src_task_scb { u32 phiIncr6int_26frac; - struct dsp_volume_control src_vol_ctrl; -}; + volume_control_t src_vol_ctrl; +} src_task_scb_t; -struct dsp_decimate_by_pow2_scb { +typedef struct _decimate_by_pow2_scb_t { /* decimationFactor = 2, 4, or 8 (larger factors waste too much memory when compared to cascading decimators) */ @@ -648,10 +648,10 @@ struct dsp_decimate_by_pow2_scb { u32 dec2_reserved4; - struct dsp_volume_control dec2_vol_ctrl; /* Not used! */ -}; + volume_control_t dec2_vol_ctrl; /* Not used! */ +} decimate_by_pow2_scb_t; -struct dsp_vari_decimate_scb { +typedef struct _vari_decimate_scb_t { ___DSP_DUAL_16BIT_ALLOC( vdec_frames_left_in_gof, vdec_gofs_left_in_sec @@ -711,15 +711,15 @@ struct dsp_vari_decimate_scb { u32 vdec_phi_incr_6int_26frac; - struct dsp_volume_control vdec_vol_ctrl; -}; + volume_control_t vdec_vol_ctrl; +} vari_decimate_scb_t; /* SCB for MIX_TO_OSTREAM algorithm family */ -struct dsp_mix2_ostream_scb { +typedef struct _mix2_ostream_scb_t { /* First 13 dwords from generic_scb_t */ - struct dsp_basic_dma_req basic_req; /* Optional */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ ___DSP_DUAL_16BIT_ALLOC( next_scb, /* REQUIRED */ sub_list_ptr /* REQUIRED */ @@ -758,14 +758,14 @@ struct dsp_mix2_ostream_scb { const_FFFF, const_zero ) -}; +} mix2_ostream_scb_t; /* SCB for S16_MIX algorithm */ -struct dsp_mix_only_scb { +typedef struct _mix_only_scb_t { /* First 13 dwords from generic_scb_t */ - struct dsp_basic_dma_req basic_req; /* Optional */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ ___DSP_DUAL_16BIT_ALLOC( next_scb, /* REQUIRED */ sub_list_ptr /* REQUIRED */ @@ -780,11 +780,11 @@ struct dsp_mix_only_scb { u32 strm_buf_ptr; /* REQUIRED */ u32 reserved; - struct dsp_volume_control vol_ctrl; -}; + volume_control_t vol_ctrl; +} mix_only_scb_t; /* SCB for the async. CODEC input algorithm */ -struct dsp_async_codec_input_scb { +typedef struct _async_codec_input_scb_t { u32 io_free2; u32 io_current_total; @@ -837,11 +837,11 @@ struct dsp_async_codec_input_scb { ) u32 i_free; -}; +} async_codec_input_scb_t; /* SCB for the SP/DIF CODEC input and output */ -struct dsp_spdifiscb { +typedef struct _spdifiscb_t { ___DSP_DUAL_16BIT_ALLOC( status_ptr, status_start_ptr @@ -895,11 +895,12 @@ struct dsp_spdifiscb { ) u32 free1; -}; +} spdifiscb_t; /* SCB for the SP/DIF CODEC input and output */ -struct dsp_spdifoscb { +typedef struct _spdifoscb_t { + u32 free2; @@ -940,10 +941,11 @@ struct dsp_spdifoscb { ) u32 free1; -}; +} spdifoscb_t; + -struct dsp_asynch_fg_rx_scb { +typedef struct _asynch_fg_rx_scb_t { ___DSP_DUAL_16BIT_ALLOC( bot_buf_mask, buf_Mask @@ -991,10 +993,11 @@ struct dsp_asynch_fg_rx_scb { right_vol, left_vol ) -}; +} asynch_fg_rx_scb_t; + -struct dsp_asynch_fg_tx_scb { +typedef struct _asynch_fg_tx_scb_t { ___DSP_DUAL_16BIT_ALLOC( not_buf_mask, buf_mask @@ -1049,13 +1052,13 @@ struct dsp_asynch_fg_tx_scb { unused_right_vol, unused_left_vol ) -}; +} asynch_fg_tx_scb_t; -struct dsp_output_snoop_scb { +typedef struct _output_snoop_scb_t { /* First 13 dwords from generic_scb_t */ - struct dsp_basic_dma_req basic_req; /* Optional */ - struct dsp_scatter_gather_ext sg_ext; /* Optional */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ ___DSP_DUAL_16BIT_ALLOC( next_scb, /* REQUIRED */ sub_list_ptr /* REQUIRED */ @@ -1080,9 +1083,9 @@ struct dsp_output_snoop_scb { reserved, input_scb ) -}; +} output_snoop_scb_t; -struct dsp_spio_write_scb { +typedef struct _spio_write_scb_t { ___DSP_DUAL_16BIT_ALLOC( address1, address2 @@ -1119,9 +1122,9 @@ struct dsp_spio_write_scb { ) u32 unused3[5]; -}; +} spio_write_scb_t; -struct dsp_magic_snoop_task { +typedef struct _magic_snoop_task_t { u32 i0; u32 i1; @@ -1152,11 +1155,11 @@ struct dsp_magic_snoop_task { u32 i8; - struct dsp_volume_control vdec_vol_ctrl; -}; + volume_control_t vdec_vol_ctrl; +} magic_snoop_task_t; -struct dsp_filter_scb { +typedef struct _filter_scb_t { ___DSP_DUAL_16BIT_ALLOC( a0_right, /* 0x00 */ a0_left @@ -1209,5 +1212,5 @@ struct dsp_filter_scb { b2_right, /* 0x0F */ b2_left ) -}; +} filter_scb_t; #endif /* __DSP_SCB_TYPES_H__ */ diff --git a/trunk/include/sound/cs46xx_dsp_spos.h b/trunk/include/sound/cs46xx_dsp_spos.h index da934def31e9..10014cb62423 100644 --- a/trunk/include/sound/cs46xx_dsp_spos.h +++ b/trunk/include/sound/cs46xx_dsp_spos.h @@ -65,130 +65,133 @@ #define DSP_SPDIF_STATUS_HW_ENABLED 4 #define DSP_SPDIF_STATUS_INPUT_CTRL_ENABLED 8 -struct dsp_symbol_entry { +struct _dsp_module_desc_t; + +typedef struct _symbol_entry_t { u32 address; char symbol_name[DSP_MAX_SYMBOL_NAME]; int symbol_type; /* initialized by driver */ - struct dsp_module_desc * module; + struct _dsp_module_desc_t * module; int deleted; -}; +} symbol_entry_t; -struct dsp_symbol_desc { +typedef struct _symbol_desc_t { int nsymbols; - struct dsp_symbol_entry *symbols; + symbol_entry_t * symbols; /* initialized by driver */ int highest_frag_index; -}; +} symbol_desc_t; + -struct dsp_segment_desc { +typedef struct _segment_desc_t { int segment_type; u32 offset; u32 size; u32 * data; -}; +} segment_desc_t; -struct dsp_module_desc { +typedef struct _dsp_module_desc_t { char * module_name; - struct dsp_symbol_desc symbol_table; + symbol_desc_t symbol_table; int nsegments; - struct dsp_segment_desc * segments; + segment_desc_t * segments; /* initialized by driver */ u32 overlay_begin_address; u32 load_address; int nfixups; -}; +} dsp_module_desc_t; -struct dsp_scb_descriptor { +typedef struct _dsp_scb_descriptor_t { char scb_name[DSP_MAX_SCB_NAME]; u32 address; int index; - struct dsp_scb_descriptor * sub_list_ptr; - struct dsp_scb_descriptor * next_scb_ptr; - struct dsp_scb_descriptor * parent_scb_ptr; + struct _dsp_scb_descriptor_t * sub_list_ptr; + struct _dsp_scb_descriptor_t * next_scb_ptr; + struct _dsp_scb_descriptor_t * parent_scb_ptr; - struct dsp_symbol_entry * task_entry; - struct dsp_symbol_entry * scb_symbol; + symbol_entry_t * task_entry; + symbol_entry_t * scb_symbol; - struct snd_info_entry *proc_info; + snd_info_entry_t *proc_info; int ref_count; spinlock_t lock; int deleted; -}; +} dsp_scb_descriptor_t; -struct dsp_task_descriptor { +typedef struct _dsp_task_descriptor_t { char task_name[DSP_MAX_TASK_NAME]; int size; u32 address; int index; -}; +} dsp_task_descriptor_t; -struct dsp_pcm_channel_descriptor { +typedef struct _pcm_channel_descriptor_t { int active; int src_slot; int pcm_slot; u32 sample_rate; u32 unlinked; - struct dsp_scb_descriptor * pcm_reader_scb; - struct dsp_scb_descriptor * src_scb; - struct dsp_scb_descriptor * mixer_scb; + dsp_scb_descriptor_t * pcm_reader_scb; + dsp_scb_descriptor_t * src_scb; + dsp_scb_descriptor_t * mixer_scb; void * private_data; -}; +} pcm_channel_descriptor_t; -struct dsp_spos_instance { - struct dsp_symbol_desc symbol_table; /* currently availble loaded symbols in SP */ +typedef struct _dsp_spos_instance_t { + symbol_desc_t symbol_table; /* currently availble loaded symbols in SP */ int nmodules; - struct dsp_module_desc * modules; /* modules loaded into SP */ + dsp_module_desc_t * modules; /* modules loaded into SP */ - struct dsp_segment_desc code; + segment_desc_t code; /* Main PCM playback mixer */ - struct dsp_scb_descriptor * master_mix_scb; + dsp_scb_descriptor_t * master_mix_scb; u16 dac_volume_right; u16 dac_volume_left; /* Rear/surround PCM playback mixer */ - struct dsp_scb_descriptor * rear_mix_scb; + dsp_scb_descriptor_t * rear_mix_scb; /* Center/LFE mixer */ - struct dsp_scb_descriptor * center_lfe_mix_scb; + dsp_scb_descriptor_t * center_lfe_mix_scb; int npcm_channels; int nsrc_scb; - struct dsp_pcm_channel_descriptor pcm_channels[DSP_MAX_PCM_CHANNELS]; + pcm_channel_descriptor_t pcm_channels[DSP_MAX_PCM_CHANNELS]; int src_scb_slots[DSP_MAX_SRC_NR]; /* cache this symbols */ - struct dsp_symbol_entry * null_algorithm; /* used by PCMreaderSCB's */ - struct dsp_symbol_entry * s16_up; /* used by SRCtaskSCB's */ + symbol_entry_t * null_algorithm; /* used by PCMreaderSCB's */ + symbol_entry_t * s16_up; /* used by SRCtaskSCB's */ /* proc fs */ - struct snd_card *snd_card; - struct snd_info_entry * proc_dsp_dir; - struct snd_info_entry * proc_sym_info_entry; - struct snd_info_entry * proc_modules_info_entry; - struct snd_info_entry * proc_parameter_dump_info_entry; - struct snd_info_entry * proc_sample_dump_info_entry; + snd_card_t * snd_card; + snd_info_entry_t * proc_dsp_dir; + snd_info_entry_t * proc_sym_info_entry; + snd_info_entry_t * proc_modules_info_entry; + snd_info_entry_t * proc_parameter_dump_info_entry; + snd_info_entry_t * proc_sample_dump_info_entry; /* SCB's descriptors */ int nscb; int scb_highest_frag_index; - struct dsp_scb_descriptor scbs[DSP_MAX_SCB_DESC]; - struct snd_info_entry * proc_scb_info_entry; - struct dsp_scb_descriptor * the_null_scb; + dsp_scb_descriptor_t scbs[DSP_MAX_SCB_DESC]; + snd_info_entry_t * proc_scb_info_entry; + dsp_scb_descriptor_t * the_null_scb; /* Task's descriptors */ int ntask; - struct dsp_task_descriptor tasks[DSP_MAX_TASK_DESC]; - struct snd_info_entry * proc_task_info_entry; + dsp_task_descriptor_t tasks[DSP_MAX_TASK_DESC]; + snd_info_entry_t * proc_task_info_entry; /* SPDIF status */ int spdif_status_out; @@ -201,30 +204,30 @@ struct dsp_spos_instance { unsigned int spdif_csuv_stream; /* SPDIF input sample rate converter */ - struct dsp_scb_descriptor * spdif_in_src; + dsp_scb_descriptor_t * spdif_in_src; /* SPDIF input asynch. receiver */ - struct dsp_scb_descriptor * asynch_rx_scb; + dsp_scb_descriptor_t * asynch_rx_scb; /* Capture record mixer SCB */ - struct dsp_scb_descriptor * record_mixer_scb; + dsp_scb_descriptor_t * record_mixer_scb; /* CODEC input SCB */ - struct dsp_scb_descriptor * codec_in_scb; + dsp_scb_descriptor_t * codec_in_scb; /* reference snooper */ - struct dsp_scb_descriptor * ref_snoop_scb; + dsp_scb_descriptor_t * ref_snoop_scb; /* SPDIF output PCM reference */ - struct dsp_scb_descriptor * spdif_pcm_input_scb; + dsp_scb_descriptor_t * spdif_pcm_input_scb; /* asynch TX task */ - struct dsp_scb_descriptor * asynch_tx_scb; + dsp_scb_descriptor_t * asynch_tx_scb; /* record sources */ - struct dsp_scb_descriptor * pcm_input; - struct dsp_scb_descriptor * adc_input; + dsp_scb_descriptor_t * pcm_input; + dsp_scb_descriptor_t * adc_input; int spdif_in_sample_rate; -}; +} dsp_spos_instance_t; #endif /* __DSP_SPOS_H__ */ diff --git a/trunk/include/sound/cs46xx_dsp_task_types.h b/trunk/include/sound/cs46xx_dsp_task_types.h index b3076c487de6..5dd3bf69cb03 100644 --- a/trunk/include/sound/cs46xx_dsp_task_types.h +++ b/trunk/include/sound/cs46xx_dsp_task_types.h @@ -71,7 +71,7 @@ Ptr____Call (c) at the end of BG */ /* Minimal context save area for Hyper Forground */ -struct dsp_hf_save_area { +typedef struct _hf_save_area_t { u32 r10_save; u32 r54_save; u32 r98_save; @@ -96,11 +96,11 @@ struct dsp_hf_save_area { rsa2Save ) /* saved as part of HFG context */ -}; +} hf_save_area_t; /* Task link data structure */ -struct dsp_tree_link { +typedef struct _tree_link_t { ___DSP_DUAL_16BIT_ALLOC( /* Pointer to sibling task control block */ next_scb, @@ -114,10 +114,10 @@ struct dsp_tree_link { /* Pointer to local data */ this_spb ) -}; +} tree_link_t; -struct dsp_task_tree_data { +typedef struct _task_tree_data_t { ___DSP_DUAL_16BIT_ALLOC( /* Initial tock count; controls task tree execution rate */ tock_count_limit, @@ -155,10 +155,11 @@ struct dsp_task_tree_data { data_stack_base_ptr ) -}; +} task_tree_data_t; -struct dsp_interval_timer_data + +typedef struct _interval_timer_data_t { /* These data items have the same relative locations to those */ ___DSP_DUAL_16BIT_ALLOC( @@ -171,12 +172,12 @@ struct dsp_interval_timer_data num_FG_ticks_this_interval, num_intervals ) -}; +} interval_timer_data_t; /* This structure contains extra storage for the task tree Currently, this additional data is related only to a full context save */ -struct dsp_task_tree_context_block { +typedef struct _task_tree_context_block_t { /* Up to 10 values are saved onto the stack. 8 for the task tree, 1 for The access to the context switch (call or interrupt), and 1 spare that users should never use. This last may be required by the system */ @@ -237,16 +238,16 @@ struct dsp_task_tree_context_block { u32 saveaux2xaux3x; u32 savershouthl; u32 savershoutxmacmode; -}; +} task_tree_context_block_t; -struct dsp_task_tree_control_block { - struct dsp_hf_save_area context; - struct dsp_tree_link links; - struct dsp_task_tree_data data; - struct dsp_task_tree_context_block context_blk; - struct dsp_interval_timer_data int_timer; -}; +typedef struct _task_tree_control_block_t { + hf_save_area_t context; + tree_link_t links; + task_tree_data_t data; + task_tree_context_block_t context_blk; + interval_timer_data_t int_timer; +} task_tree_control_block_t; #endif /* __DSP_TASK_TYPES_H__ */ diff --git a/trunk/include/sound/cs8403.h b/trunk/include/sound/cs8403.h index c6c3f9f0da78..0b7d216e24f1 100644 --- a/trunk/include/sound/cs8403.h +++ b/trunk/include/sound/cs8403.h @@ -36,7 +36,7 @@ #endif -SND_CS8403_DECL void SND_CS8403_DECODE(struct snd_aes_iec958 *diga, unsigned char bits) +SND_CS8403_DECL void SND_CS8403_DECODE(snd_aes_iec958_t *diga, unsigned char bits) { if (bits & 0x01) { /* consumer */ if (!(bits & 0x02)) @@ -79,7 +79,7 @@ SND_CS8403_DECL void SND_CS8403_DECODE(struct snd_aes_iec958 *diga, unsigned cha } } -SND_CS8403_DECL unsigned char SND_CS8403_ENCODE(struct snd_aes_iec958 *diga) +SND_CS8403_DECL unsigned char SND_CS8403_ENCODE(snd_aes_iec958_t *diga) { unsigned char bits; @@ -166,7 +166,7 @@ SND_CS8403_DECL unsigned char SND_CS8403_ENCODE(struct snd_aes_iec958 *diga) #endif -SND_CS8404_DECL void SND_CS8404_DECODE(struct snd_aes_iec958 *diga, unsigned char bits) +SND_CS8404_DECL void SND_CS8404_DECODE(snd_aes_iec958_t *diga, unsigned char bits) { if (bits & 0x10) { /* consumer */ if (!(bits & 0x20)) @@ -205,7 +205,7 @@ SND_CS8404_DECL void SND_CS8404_DECODE(struct snd_aes_iec958 *diga, unsigned cha } } -SND_CS8404_DECL unsigned char SND_CS8404_ENCODE(struct snd_aes_iec958 *diga) +SND_CS8404_DECL unsigned char SND_CS8404_ENCODE(snd_aes_iec958_t *diga) { unsigned char bits; diff --git a/trunk/include/sound/cs8427.h b/trunk/include/sound/cs8427.h index 97fd9acf8028..e725b7049a53 100644 --- a/trunk/include/sound/cs8427.h +++ b/trunk/include/sound/cs8427.h @@ -186,16 +186,11 @@ #define CS8427_VERSHIFT 0 #define CS8427_VER8427A 0x71 -struct snd_pcm_substream; - -int snd_cs8427_create(struct snd_i2c_bus *bus, unsigned char addr, - unsigned int reset_timeout, struct snd_i2c_device **r_cs8427); -int snd_cs8427_reg_write(struct snd_i2c_device *device, unsigned char reg, - unsigned char val); -int snd_cs8427_iec958_build(struct snd_i2c_device *cs8427, - struct snd_pcm_substream *playback_substream, - struct snd_pcm_substream *capture_substream); -int snd_cs8427_iec958_active(struct snd_i2c_device *cs8427, int active); -int snd_cs8427_iec958_pcm(struct snd_i2c_device *cs8427, unsigned int rate); +int snd_cs8427_create(snd_i2c_bus_t *bus, unsigned char addr, + unsigned int reset_timeout, snd_i2c_device_t **r_cs8427); +int snd_cs8427_reg_write(snd_i2c_device_t *device, unsigned char reg, unsigned char val); +int snd_cs8427_iec958_build(snd_i2c_device_t *cs8427, snd_pcm_substream_t *playback_substream, snd_pcm_substream_t *capture_substream); +int snd_cs8427_iec958_active(snd_i2c_device_t *cs8427, int active); +int snd_cs8427_iec958_pcm(snd_i2c_device_t *cs8427, unsigned int rate); #endif /* __SOUND_CS8427_H */ diff --git a/trunk/include/sound/driver.h b/trunk/include/sound/driver.h index 89c6a73f3920..3f0416ac24d9 100644 --- a/trunk/include/sound/driver.h +++ b/trunk/include/sound/driver.h @@ -28,12 +28,7 @@ #include -/* number of supported soundcards */ -#ifdef CONFIG_SND_DYNAMIC_MINORS -#define SNDRV_CARDS 32 -#else -#define SNDRV_CARDS 8 /* don't change - minor numbers */ -#endif +#define SNDRV_CARDS 8 /* number of supported soundcards - don't change - minor numbers */ #ifndef CONFIG_SND_MAJOR /* standard configuration */ #define CONFIG_SND_MAJOR 116 diff --git a/trunk/include/sound/emu10k1.h b/trunk/include/sound/emu10k1.h index 951e40d720d9..8411c7ef6f11 100644 --- a/trunk/include/sound/emu10k1.h +++ b/trunk/include/sound/emu10k1.h @@ -887,45 +887,47 @@ /* ------------------- STRUCTURES -------------------- */ -enum { +typedef struct _snd_emu10k1 emu10k1_t; +typedef struct _snd_emu10k1_voice emu10k1_voice_t; +typedef struct _snd_emu10k1_pcm emu10k1_pcm_t; + +typedef enum { EMU10K1_EFX, EMU10K1_PCM, EMU10K1_SYNTH, EMU10K1_MIDI -}; - -struct snd_emu10k1; +} emu10k1_voice_type_t; -struct snd_emu10k1_voice { - struct snd_emu10k1 *emu; +struct _snd_emu10k1_voice { + emu10k1_t *emu; int number; unsigned int use: 1, pcm: 1, efx: 1, synth: 1, midi: 1; - void (*interrupt)(struct snd_emu10k1 *emu, struct snd_emu10k1_voice *pvoice); + void (*interrupt)(emu10k1_t *emu, emu10k1_voice_t *pvoice); - struct snd_emu10k1_pcm *epcm; + emu10k1_pcm_t *epcm; }; -enum { +typedef enum { PLAYBACK_EMUVOICE, PLAYBACK_EFX, CAPTURE_AC97ADC, CAPTURE_AC97MIC, CAPTURE_EFX -}; - -struct snd_emu10k1_pcm { - struct snd_emu10k1 *emu; - int type; - struct snd_pcm_substream *substream; - struct snd_emu10k1_voice *voices[NUM_EFX_PLAYBACK]; - struct snd_emu10k1_voice *extra; +} snd_emu10k1_pcm_type_t; + +struct _snd_emu10k1_pcm { + emu10k1_t *emu; + snd_emu10k1_pcm_type_t type; + snd_pcm_substream_t *substream; + emu10k1_voice_t *voices[NUM_EFX_PLAYBACK]; + emu10k1_voice_t *extra; unsigned short running; unsigned short first_ptr; - struct snd_util_memblk *memblk; + snd_util_memblk_t *memblk; unsigned int start_addr; unsigned int ccca_start_addr; unsigned int capture_ipr; /* interrupt acknowledge mask */ @@ -939,13 +941,13 @@ struct snd_emu10k1_pcm { unsigned int capture_bufsize; /* buffer size in bytes */ }; -struct snd_emu10k1_pcm_mixer { +typedef struct { /* mono, left, right x 8 sends (4 on emu10k1) */ unsigned char send_routing[3][8]; unsigned char send_volume[3][8]; unsigned short attn[3]; - struct snd_emu10k1_pcm *epcm; -}; + emu10k1_pcm_t *epcm; +} emu10k1_pcm_mixer_t; #define snd_emu10k1_compose_send_routing(route) \ ((route[0] | (route[1] << 4) | (route[2] << 8) | (route[3] << 12)) << 16) @@ -956,20 +958,20 @@ struct snd_emu10k1_pcm_mixer { #define snd_emu10k1_compose_audigy_fxrt2(route) \ ((unsigned int)route[4] | ((unsigned int)route[5] << 8) | ((unsigned int)route[6] << 16) | ((unsigned int)route[7] << 24)) -struct snd_emu10k1_memblk { - struct snd_util_memblk mem; +typedef struct snd_emu10k1_memblk { + snd_util_memblk_t mem; /* private part */ int first_page, last_page, pages, mapped_page; unsigned int map_locked; struct list_head mapped_link; struct list_head mapped_order_link; -}; +} emu10k1_memblk_t; #define snd_emu10k1_memblk_offset(blk) (((blk)->mapped_page << PAGE_SHIFT) | ((blk)->mem.offset & (PAGE_SIZE - 1))) #define EMU10K1_MAX_TRAM_BLOCKS_PER_CODE 16 -struct snd_emu10k1_fx8010_ctl { +typedef struct { struct list_head list; /* list link container */ unsigned int vcount; unsigned int count; /* count of GPR (1..16) */ @@ -978,19 +980,19 @@ struct snd_emu10k1_fx8010_ctl { unsigned int min; /* minimum range */ unsigned int max; /* maximum range */ unsigned int translation; /* translation type (EMU10K1_GPR_TRANSLATION*) */ - struct snd_kcontrol *kcontrol; -}; + snd_kcontrol_t *kcontrol; +} snd_emu10k1_fx8010_ctl_t; -typedef void (snd_fx8010_irq_handler_t)(struct snd_emu10k1 *emu, void *private_data); +typedef void (snd_fx8010_irq_handler_t)(emu10k1_t *emu, void *private_data); -struct snd_emu10k1_fx8010_irq { - struct snd_emu10k1_fx8010_irq *next; +typedef struct _snd_emu10k1_fx8010_irq { + struct _snd_emu10k1_fx8010_irq *next; snd_fx8010_irq_handler_t *handler; unsigned short gpr_running; void *private_data; -}; +} snd_emu10k1_fx8010_irq_t; -struct snd_emu10k1_fx8010_pcm { +typedef struct { unsigned int valid: 1, opened: 1, active: 1; @@ -1004,13 +1006,13 @@ struct snd_emu10k1_fx8010_pcm { unsigned short gpr_trigger; /* GPR containing trigger (activate) information (host) */ unsigned short gpr_running; /* GPR containing info if PCM is running (FX8010) */ unsigned char etram[32]; /* external TRAM address & data */ - struct snd_pcm_indirect pcm_rec; + snd_pcm_indirect_t pcm_rec; unsigned int tram_pos; unsigned int tram_shift; - struct snd_emu10k1_fx8010_irq *irq; -}; + snd_emu10k1_fx8010_irq_t *irq; +} snd_emu10k1_fx8010_pcm_t; -struct snd_emu10k1_fx8010 { +typedef struct { unsigned short fxbus_mask; /* used FX buses (bitmask) */ unsigned short extin_mask; /* used external inputs (bitmask) */ unsigned short extout_mask; /* used external outputs (bitmask) */ @@ -1023,18 +1025,18 @@ struct snd_emu10k1_fx8010 { int gpr_count; /* count of used kcontrols */ struct list_head gpr_ctl; /* GPR controls */ struct semaphore lock; - struct snd_emu10k1_fx8010_pcm pcm[8]; + snd_emu10k1_fx8010_pcm_t pcm[8]; spinlock_t irq_lock; - struct snd_emu10k1_fx8010_irq *irq_handlers; -}; + snd_emu10k1_fx8010_irq_t *irq_handlers; +} snd_emu10k1_fx8010_t; -#define emu10k1_gpr_ctl(n) list_entry(n, struct snd_emu10k1_fx8010_ctl, list) +#define emu10k1_gpr_ctl(n) list_entry(n, snd_emu10k1_fx8010_ctl_t, list) -struct snd_emu10k1_midi { - struct snd_emu10k1 *emu; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *substream_input; - struct snd_rawmidi_substream *substream_output; +typedef struct { + struct _snd_emu10k1 *emu; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *substream_input; + snd_rawmidi_substream_t *substream_output; unsigned int midi_mode; spinlock_t input_lock; spinlock_t output_lock; @@ -1042,10 +1044,10 @@ struct snd_emu10k1_midi { int tx_enable, rx_enable; int port; int ipr_tx, ipr_rx; - void (*interrupt)(struct snd_emu10k1 *emu, unsigned int status); -}; + void (*interrupt)(emu10k1_t *emu, unsigned int status); +} emu10k1_midi_t; -struct snd_emu_chip_details { +typedef struct { u32 vendor; u32 device; u32 subsystem; @@ -1061,23 +1063,18 @@ struct snd_emu_chip_details { unsigned char spdif_bug; /* Has Spdif phasing bug */ unsigned char ac97_chip; /* Has an AC97 chip: 1 = mandatory, 2 = optional */ unsigned char ecard; /* APS EEPROM */ - unsigned char emu1212m; /* EMU 1212m card */ - unsigned char spi_dac; /* SPI interface for DAC */ - unsigned char i2c_adc; /* I2C interface for ADC */ const char *driver; const char *name; const char *id; /* for backward compatibility - can be NULL if not needed */ -}; +} emu_chip_details_t; -struct snd_emu10k1 { +struct _snd_emu10k1 { int irq; unsigned long port; /* I/O port number */ unsigned int tos_link: 1, /* tos link detected */ - rear_ac97: 1, /* rear channels are on AC'97 */ - enable_ir: 1; - /* Contains profile of card capabilities */ - const struct snd_emu_chip_details *card_capabilities; + rear_ac97: 1; /* rear channels are on AC'97 */ + const emu_chip_details_t *card_capabilities; /* Contains profile of card capabilities */ unsigned int audigy; /* is Audigy? */ unsigned int revision; /* chip revision */ unsigned int serial; /* serial number */ @@ -1091,8 +1088,8 @@ struct snd_emu10k1 { struct snd_dma_device p16v_dma_dev; struct snd_dma_buffer p16v_buffer; - struct snd_util_memhdr *memhdr; /* page allocation list */ - struct snd_emu10k1_memblk *reserved_page; /* reserved page */ + snd_util_memhdr_t *memhdr; /* page allocation list */ + emu10k1_memblk_t *reserved_page; /* reserved page */ struct list_head mapped_link_head; struct list_head mapped_order_link_head; @@ -1102,169 +1099,142 @@ struct snd_emu10k1 { unsigned int spdif_bits[3]; /* s/pdif out setup */ - struct snd_emu10k1_fx8010 fx8010; /* FX8010 info */ + snd_emu10k1_fx8010_t fx8010; /* FX8010 info */ int gpr_base; - struct snd_ac97 *ac97; + ac97_t *ac97; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm *pcm_mic; - struct snd_pcm *pcm_efx; - struct snd_pcm *pcm_multi; - struct snd_pcm *pcm_p16v; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_t *pcm_mic; + snd_pcm_t *pcm_efx; + snd_pcm_t *pcm_p16v; spinlock_t synth_lock; void *synth; - int (*get_synth_voice)(struct snd_emu10k1 *emu); + int (*get_synth_voice)(emu10k1_t *emu); spinlock_t reg_lock; spinlock_t emu_lock; spinlock_t voice_lock; struct semaphore ptb_lock; - struct snd_emu10k1_voice voices[NUM_G]; - struct snd_emu10k1_voice p16v_voices[4]; - struct snd_emu10k1_voice p16v_capture_voice; + emu10k1_voice_t voices[NUM_G]; + emu10k1_voice_t p16v_voices[4]; + emu10k1_voice_t p16v_capture_voice; int p16v_device_offset; u32 p16v_capture_source; u32 p16v_capture_channel; - struct snd_emu10k1_pcm_mixer pcm_mixer[32]; - struct snd_emu10k1_pcm_mixer efx_pcm_mixer[NUM_EFX_PLAYBACK]; - struct snd_kcontrol *ctl_send_routing; - struct snd_kcontrol *ctl_send_volume; - struct snd_kcontrol *ctl_attn; - struct snd_kcontrol *ctl_efx_send_routing; - struct snd_kcontrol *ctl_efx_send_volume; - struct snd_kcontrol *ctl_efx_attn; - - void (*hwvol_interrupt)(struct snd_emu10k1 *emu, unsigned int status); - void (*capture_interrupt)(struct snd_emu10k1 *emu, unsigned int status); - void (*capture_mic_interrupt)(struct snd_emu10k1 *emu, unsigned int status); - void (*capture_efx_interrupt)(struct snd_emu10k1 *emu, unsigned int status); - void (*spdif_interrupt)(struct snd_emu10k1 *emu, unsigned int status); - void (*dsp_interrupt)(struct snd_emu10k1 *emu); - - struct snd_pcm_substream *pcm_capture_substream; - struct snd_pcm_substream *pcm_capture_mic_substream; - struct snd_pcm_substream *pcm_capture_efx_substream; - struct snd_pcm_substream *pcm_playback_efx_substream; - - struct snd_timer *timer; - - struct snd_emu10k1_midi midi; - struct snd_emu10k1_midi midi2; /* for audigy */ + emu10k1_pcm_mixer_t pcm_mixer[32]; + emu10k1_pcm_mixer_t efx_pcm_mixer[NUM_EFX_PLAYBACK]; + snd_kcontrol_t *ctl_send_routing; + snd_kcontrol_t *ctl_send_volume; + snd_kcontrol_t *ctl_attn; + snd_kcontrol_t *ctl_efx_send_routing; + snd_kcontrol_t *ctl_efx_send_volume; + snd_kcontrol_t *ctl_efx_attn; + + void (*hwvol_interrupt)(emu10k1_t *emu, unsigned int status); + void (*capture_interrupt)(emu10k1_t *emu, unsigned int status); + void (*capture_mic_interrupt)(emu10k1_t *emu, unsigned int status); + void (*capture_efx_interrupt)(emu10k1_t *emu, unsigned int status); + void (*spdif_interrupt)(emu10k1_t *emu, unsigned int status); + void (*dsp_interrupt)(emu10k1_t *emu); + + snd_pcm_substream_t *pcm_capture_substream; + snd_pcm_substream_t *pcm_capture_mic_substream; + snd_pcm_substream_t *pcm_capture_efx_substream; + snd_pcm_substream_t *pcm_playback_efx_substream; + + snd_timer_t *timer; + + emu10k1_midi_t midi; + emu10k1_midi_t midi2; /* for audigy */ unsigned int efx_voices_mask[2]; unsigned int next_free_voice; - -#ifdef CONFIG_PM - unsigned int *saved_ptr; - unsigned int *saved_gpr; - unsigned int *tram_val_saved; - unsigned int *tram_addr_saved; - unsigned int *saved_icode; - unsigned int *p16v_saved; - unsigned int saved_a_iocfg, saved_hcfg; -#endif - }; -int snd_emu10k1_create(struct snd_card *card, +int snd_emu10k1_create(snd_card_t * card, struct pci_dev *pci, unsigned short extin_mask, unsigned short extout_mask, long max_cache_bytes, int enable_ir, uint subsystem, - struct snd_emu10k1 ** remu); - -int snd_emu10k1_pcm(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm); -int snd_emu10k1_pcm_mic(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm); -int snd_emu10k1_pcm_efx(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm); -int snd_p16v_pcm(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm); -int snd_p16v_free(struct snd_emu10k1 * emu); -int snd_p16v_mixer(struct snd_emu10k1 * emu); -int snd_emu10k1_pcm_multi(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm); -int snd_emu10k1_fx8010_pcm(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm); -int snd_emu10k1_mixer(struct snd_emu10k1 * emu, int pcm_device, int multi_device); -int snd_emu10k1_timer(struct snd_emu10k1 * emu, int device); -int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device, struct snd_hwdep ** rhwdep); + emu10k1_t ** remu); + +int snd_emu10k1_pcm(emu10k1_t * emu, int device, snd_pcm_t ** rpcm); +int snd_emu10k1_pcm_mic(emu10k1_t * emu, int device, snd_pcm_t ** rpcm); +int snd_emu10k1_pcm_efx(emu10k1_t * emu, int device, snd_pcm_t ** rpcm); +int snd_p16v_pcm(emu10k1_t * emu, int device, snd_pcm_t ** rpcm); +int snd_p16v_free(emu10k1_t * emu); +int snd_p16v_mixer(emu10k1_t * emu); +int snd_emu10k1_pcm_multi(emu10k1_t * emu, int device, snd_pcm_t ** rpcm); +int snd_emu10k1_fx8010_pcm(emu10k1_t * emu, int device, snd_pcm_t ** rpcm); +int snd_emu10k1_mixer(emu10k1_t * emu, int pcm_device, int multi_device); +int snd_emu10k1_timer(emu10k1_t * emu, int device); +int snd_emu10k1_fx8010_new(emu10k1_t *emu, int device, snd_hwdep_t ** rhwdep); irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs); -void snd_emu10k1_voice_init(struct snd_emu10k1 * emu, int voice); -int snd_emu10k1_init_efx(struct snd_emu10k1 *emu); -void snd_emu10k1_free_efx(struct snd_emu10k1 *emu); -int snd_emu10k1_fx8010_tram_setup(struct snd_emu10k1 *emu, u32 size); -int snd_emu10k1_done(struct snd_emu10k1 * emu); +/* initialization */ +void snd_emu10k1_voice_init(emu10k1_t * emu, int voice); +int snd_emu10k1_init_efx(emu10k1_t *emu); +void snd_emu10k1_free_efx(emu10k1_t *emu); +int snd_emu10k1_fx8010_tram_setup(emu10k1_t *emu, u32 size); /* I/O functions */ -unsigned int snd_emu10k1_ptr_read(struct snd_emu10k1 * emu, unsigned int reg, unsigned int chn); -void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned int chn, unsigned int data); -unsigned int snd_emu10k1_ptr20_read(struct snd_emu10k1 * emu, unsigned int reg, unsigned int chn); -void snd_emu10k1_ptr20_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned int chn, unsigned int data); -int snd_emu10k1_spi_write(struct snd_emu10k1 * emu, unsigned int data); -unsigned int snd_emu10k1_efx_read(struct snd_emu10k1 *emu, unsigned int pc); -void snd_emu10k1_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb); -void snd_emu10k1_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb); -void snd_emu10k1_voice_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_voice_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_voice_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_voice_half_loop_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_voice_half_loop_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_voice_half_loop_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_voice_set_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_voice_clear_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum); -void snd_emu10k1_wait(struct snd_emu10k1 *emu, unsigned int wait); -static inline unsigned int snd_emu10k1_wc(struct snd_emu10k1 *emu) { return (inl(emu->port + WC) >> 6) & 0xfffff; } -unsigned short snd_emu10k1_ac97_read(struct snd_ac97 *ac97, unsigned short reg); -void snd_emu10k1_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short data); +unsigned int snd_emu10k1_ptr_read(emu10k1_t * emu, unsigned int reg, unsigned int chn); +void snd_emu10k1_ptr_write(emu10k1_t *emu, unsigned int reg, unsigned int chn, unsigned int data); +unsigned int snd_emu10k1_ptr20_read(emu10k1_t * emu, unsigned int reg, unsigned int chn); +void snd_emu10k1_ptr20_write(emu10k1_t *emu, unsigned int reg, unsigned int chn, unsigned int data); +unsigned int snd_emu10k1_efx_read(emu10k1_t *emu, unsigned int pc); +void snd_emu10k1_intr_enable(emu10k1_t *emu, unsigned int intrenb); +void snd_emu10k1_intr_disable(emu10k1_t *emu, unsigned int intrenb); +void snd_emu10k1_voice_intr_enable(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_voice_intr_disable(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_voice_intr_ack(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_voice_half_loop_intr_enable(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_voice_half_loop_intr_disable(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_voice_half_loop_intr_ack(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_voice_set_loop_stop(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_voice_clear_loop_stop(emu10k1_t *emu, unsigned int voicenum); +void snd_emu10k1_wait(emu10k1_t *emu, unsigned int wait); +static inline unsigned int snd_emu10k1_wc(emu10k1_t *emu) { return (inl(emu->port + WC) >> 6) & 0xfffff; } +unsigned short snd_emu10k1_ac97_read(ac97_t *ac97, unsigned short reg); +void snd_emu10k1_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short data); unsigned int snd_emu10k1_rate_to_pitch(unsigned int rate); -#ifdef CONFIG_PM -void snd_emu10k1_suspend_regs(struct snd_emu10k1 *emu); -void snd_emu10k1_resume_init(struct snd_emu10k1 *emu); -void snd_emu10k1_resume_regs(struct snd_emu10k1 *emu); -int snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu); -void snd_emu10k1_efx_free_pm_buffer(struct snd_emu10k1 *emu); -void snd_emu10k1_efx_suspend(struct snd_emu10k1 *emu); -void snd_emu10k1_efx_resume(struct snd_emu10k1 *emu); -int snd_p16v_alloc_pm_buffer(struct snd_emu10k1 *emu); -void snd_p16v_free_pm_buffer(struct snd_emu10k1 *emu); -void snd_p16v_suspend(struct snd_emu10k1 *emu); -void snd_p16v_resume(struct snd_emu10k1 *emu); -#endif - /* memory allocation */ -struct snd_util_memblk *snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *substream); -int snd_emu10k1_free_pages(struct snd_emu10k1 *emu, struct snd_util_memblk *blk); -struct snd_util_memblk *snd_emu10k1_synth_alloc(struct snd_emu10k1 *emu, unsigned int size); -int snd_emu10k1_synth_free(struct snd_emu10k1 *emu, struct snd_util_memblk *blk); -int snd_emu10k1_synth_bzero(struct snd_emu10k1 *emu, struct snd_util_memblk *blk, int offset, int size); -int snd_emu10k1_synth_copy_from_user(struct snd_emu10k1 *emu, struct snd_util_memblk *blk, int offset, const char __user *data, int size); -int snd_emu10k1_memblk_map(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk); +snd_util_memblk_t *snd_emu10k1_alloc_pages(emu10k1_t *emu, snd_pcm_substream_t *substream); +int snd_emu10k1_free_pages(emu10k1_t *emu, snd_util_memblk_t *blk); +snd_util_memblk_t *snd_emu10k1_synth_alloc(emu10k1_t *emu, unsigned int size); +int snd_emu10k1_synth_free(emu10k1_t *emu, snd_util_memblk_t *blk); +int snd_emu10k1_synth_bzero(emu10k1_t *emu, snd_util_memblk_t *blk, int offset, int size); +int snd_emu10k1_synth_copy_from_user(emu10k1_t *emu, snd_util_memblk_t *blk, int offset, const char __user *data, int size); +int snd_emu10k1_memblk_map(emu10k1_t *emu, emu10k1_memblk_t *blk); /* voice allocation */ -int snd_emu10k1_voice_alloc(struct snd_emu10k1 *emu, int type, int pair, struct snd_emu10k1_voice **rvoice); -int snd_emu10k1_voice_free(struct snd_emu10k1 *emu, struct snd_emu10k1_voice *pvoice); +int snd_emu10k1_voice_alloc(emu10k1_t *emu, emu10k1_voice_type_t type, int pair, emu10k1_voice_t **rvoice); +int snd_emu10k1_voice_free(emu10k1_t *emu, emu10k1_voice_t *pvoice); /* MIDI uart */ -int snd_emu10k1_midi(struct snd_emu10k1 * emu); -int snd_emu10k1_audigy_midi(struct snd_emu10k1 * emu); +int snd_emu10k1_midi(emu10k1_t * emu); +int snd_emu10k1_audigy_midi(emu10k1_t * emu); /* proc interface */ -int snd_emu10k1_proc_init(struct snd_emu10k1 * emu); +int snd_emu10k1_proc_init(emu10k1_t * emu); /* fx8010 irq handler */ -int snd_emu10k1_fx8010_register_irq_handler(struct snd_emu10k1 *emu, +int snd_emu10k1_fx8010_register_irq_handler(emu10k1_t *emu, snd_fx8010_irq_handler_t *handler, unsigned char gpr_running, void *private_data, - struct snd_emu10k1_fx8010_irq **r_irq); -int snd_emu10k1_fx8010_unregister_irq_handler(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_irq *irq); + snd_emu10k1_fx8010_irq_t **r_irq); +int snd_emu10k1_fx8010_unregister_irq_handler(emu10k1_t *emu, + snd_emu10k1_fx8010_irq_t *irq); #endif /* __KERNEL__ */ @@ -1499,14 +1469,14 @@ int snd_emu10k1_fx8010_unregister_irq_handler(struct snd_emu10k1 *emu, #define TANKMEMADDRREG_READ 0x00100000 /* Read from tank memory */ #endif -struct snd_emu10k1_fx8010_info { +typedef struct { unsigned int internal_tram_size; /* in samples */ unsigned int external_tram_size; /* in samples */ char fxbus_names[16][32]; /* names of FXBUSes */ char extin_names[16][32]; /* names of external inputs */ char extout_names[32][32]; /* names of external outputs */ unsigned int gpr_controls; /* count of GPR controls */ -}; +} emu10k1_fx8010_info_t; #define EMU10K1_GPR_TRANSLATION_NONE 0 #define EMU10K1_GPR_TRANSLATION_TABLE100 1 @@ -1514,8 +1484,8 @@ struct snd_emu10k1_fx8010_info { #define EMU10K1_GPR_TRANSLATION_TREBLE 3 #define EMU10K1_GPR_TRANSLATION_ONOFF 4 -struct snd_emu10k1_fx8010_control_gpr { - struct snd_ctl_elem_id id; /* full control ID definition */ +typedef struct { + snd_ctl_elem_id_t id; /* full control ID definition */ unsigned int vcount; /* visible count */ unsigned int count; /* count of GPR (1..16) */ unsigned short gpr[32]; /* GPR number(s) */ @@ -1523,23 +1493,23 @@ struct snd_emu10k1_fx8010_control_gpr { unsigned int min; /* minimum range */ unsigned int max; /* maximum range */ unsigned int translation; /* translation type (EMU10K1_GPR_TRANSLATION*) */ -}; +} emu10k1_fx8010_control_gpr_t; -struct snd_emu10k1_fx8010_code { +typedef struct { char name[128]; DECLARE_BITMAP(gpr_valid, 0x200); /* bitmask of valid initializers */ u_int32_t __user *gpr_map; /* initializers */ unsigned int gpr_add_control_count; /* count of GPR controls to add/replace */ - struct snd_emu10k1_fx8010_control_gpr __user *gpr_add_controls; /* GPR controls to add/replace */ + emu10k1_fx8010_control_gpr_t __user *gpr_add_controls; /* GPR controls to add/replace */ unsigned int gpr_del_control_count; /* count of GPR controls to remove */ - struct snd_ctl_elem_id __user *gpr_del_controls; /* IDs of GPR controls to remove */ + snd_ctl_elem_id_t __user *gpr_del_controls; /* IDs of GPR controls to remove */ unsigned int gpr_list_control_count; /* count of GPR controls to list */ unsigned int gpr_list_control_total; /* total count of GPR controls */ - struct snd_emu10k1_fx8010_control_gpr __user *gpr_list_controls; /* listed GPR controls */ + emu10k1_fx8010_control_gpr_t __user *gpr_list_controls; /* listed GPR controls */ DECLARE_BITMAP(tram_valid, 0x100); /* bitmask of valid initializers */ u_int32_t __user *tram_data_map; /* data initializers */ @@ -1547,16 +1517,16 @@ struct snd_emu10k1_fx8010_code { DECLARE_BITMAP(code_valid, 1024); /* bitmask of valid instructions */ u_int32_t __user *code; /* one instruction - 64 bits */ -}; +} emu10k1_fx8010_code_t; -struct snd_emu10k1_fx8010_tram { +typedef struct { unsigned int address; /* 31.bit == 1 -> external TRAM */ unsigned int size; /* size in samples (4 bytes) */ unsigned int *samples; /* pointer to samples (20-bit) */ /* NULL->clear memory */ -}; +} emu10k1_fx8010_tram_t; -struct snd_emu10k1_fx8010_pcm_rec { +typedef struct { unsigned int substream; /* substream number */ unsigned int res1; /* reserved */ unsigned int channels; /* 16-bit channels count, zero = remove this substream */ @@ -1571,27 +1541,20 @@ struct snd_emu10k1_fx8010_pcm_rec { unsigned char pad; /* reserved */ unsigned char etram[32]; /* external TRAM address & data (one per channel) */ unsigned int res2; /* reserved */ -}; +} emu10k1_fx8010_pcm_t; -#define SNDRV_EMU10K1_IOCTL_INFO _IOR ('H', 0x10, struct snd_emu10k1_fx8010_info) -#define SNDRV_EMU10K1_IOCTL_CODE_POKE _IOW ('H', 0x11, struct snd_emu10k1_fx8010_code) -#define SNDRV_EMU10K1_IOCTL_CODE_PEEK _IOWR('H', 0x12, struct snd_emu10k1_fx8010_code) +#define SNDRV_EMU10K1_IOCTL_INFO _IOR ('H', 0x10, emu10k1_fx8010_info_t) +#define SNDRV_EMU10K1_IOCTL_CODE_POKE _IOW ('H', 0x11, emu10k1_fx8010_code_t) +#define SNDRV_EMU10K1_IOCTL_CODE_PEEK _IOWR('H', 0x12, emu10k1_fx8010_code_t) #define SNDRV_EMU10K1_IOCTL_TRAM_SETUP _IOW ('H', 0x20, int) -#define SNDRV_EMU10K1_IOCTL_TRAM_POKE _IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram) -#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK _IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram) -#define SNDRV_EMU10K1_IOCTL_PCM_POKE _IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec) -#define SNDRV_EMU10K1_IOCTL_PCM_PEEK _IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec) +#define SNDRV_EMU10K1_IOCTL_TRAM_POKE _IOW ('H', 0x21, emu10k1_fx8010_tram_t) +#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK _IOWR('H', 0x22, emu10k1_fx8010_tram_t) +#define SNDRV_EMU10K1_IOCTL_PCM_POKE _IOW ('H', 0x30, emu10k1_fx8010_pcm_t) +#define SNDRV_EMU10K1_IOCTL_PCM_PEEK _IOWR('H', 0x31, emu10k1_fx8010_pcm_t) #define SNDRV_EMU10K1_IOCTL_STOP _IO ('H', 0x80) #define SNDRV_EMU10K1_IOCTL_CONTINUE _IO ('H', 0x81) #define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82) #define SNDRV_EMU10K1_IOCTL_SINGLE_STEP _IOW ('H', 0x83, int) #define SNDRV_EMU10K1_IOCTL_DBG_READ _IOR ('H', 0x84, int) -/* typedefs for compatibility to user-space */ -typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t; -typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t; -typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t; -typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t; -typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t; - #endif /* __SOUND_EMU10K1_H */ diff --git a/trunk/include/sound/emu10k1_synth.h b/trunk/include/sound/emu10k1_synth.h index 6ef61c420935..df0df1d09552 100644 --- a/trunk/include/sound/emu10k1_synth.h +++ b/trunk/include/sound/emu10k1_synth.h @@ -27,12 +27,12 @@ #define SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH "emu10k1-synth" /* argument for snd_seq_device_new */ -struct snd_emu10k1_synth_arg { - struct snd_emu10k1 *hwptr; /* chip */ +typedef struct snd_emu10k1_synth_arg { + emu10k1_t *hwptr; /* chip */ int index; /* sequencer client index */ int seq_ports; /* number of sequencer ports to be created */ int max_voices; /* maximum number of voices for wavetable */ -}; +} snd_emu10k1_synth_arg_t; #define EMU10K1_MAX_MEMSIZE (32 * 1024 * 1024) /* 32MB */ diff --git a/trunk/include/sound/emu8000.h b/trunk/include/sound/emu8000.h index c8f66bde6d95..4362c54e09d0 100644 --- a/trunk/include/sound/emu8000.h +++ b/trunk/include/sound/emu8000.h @@ -56,9 +56,9 @@ enum { * some of the channels may be used for other things so max_channels is * the number in use for wave voices. */ -struct snd_emu8000 { +typedef struct snd_emu8000 { - struct snd_emux *emu; + snd_emux_t *emu; int index; /* sequencer client index */ int seq_ports; /* number of sequencer ports */ @@ -77,45 +77,44 @@ struct snd_emu8000 { int dram_checked; - struct snd_card *card; /* The card that this belongs to */ + snd_card_t *card; /* The card that this belongs to */ int chorus_mode; int reverb_mode; int bass_level; int treble_level; - struct snd_util_memhdr *memhdr; + snd_util_memhdr_t *memhdr; spinlock_t control_lock; - struct snd_kcontrol *controls[EMU8000_NUM_CONTROLS]; + snd_kcontrol_t *controls[EMU8000_NUM_CONTROLS]; - struct snd_pcm *pcm; /* pcm on emu8000 wavetable */ + snd_pcm_t *pcm; /* pcm on emu8000 wavetable */ -}; +} emu8000_t; /* sequencer device id */ #define SNDRV_SEQ_DEV_ID_EMU8000 "emu8000-synth" /* exported functions */ -int snd_emu8000_new(struct snd_card *card, int device, long port, int seq_ports, - struct snd_seq_device **ret); -void snd_emu8000_poke(struct snd_emu8000 *emu, unsigned int port, unsigned int reg, +int snd_emu8000_new(snd_card_t *card, int device, long port, int seq_ports, snd_seq_device_t **ret); +void snd_emu8000_poke(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val); -unsigned short snd_emu8000_peek(struct snd_emu8000 *emu, unsigned int port, +unsigned short snd_emu8000_peek(emu8000_t *emu, unsigned int port, unsigned int reg); -void snd_emu8000_poke_dw(struct snd_emu8000 *emu, unsigned int port, unsigned int reg, +void snd_emu8000_poke_dw(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val); -unsigned int snd_emu8000_peek_dw(struct snd_emu8000 *emu, unsigned int port, +unsigned int snd_emu8000_peek_dw(emu8000_t *emu, unsigned int port, unsigned int reg); -void snd_emu8000_dma_chan(struct snd_emu8000 *emu, int ch, int mode); +void snd_emu8000_dma_chan(emu8000_t *emu, int ch, int mode); -void snd_emu8000_init_fm(struct snd_emu8000 *emu); +void snd_emu8000_init_fm(emu8000_t *emu); -void snd_emu8000_update_chorus_mode(struct snd_emu8000 *emu); -void snd_emu8000_update_reverb_mode(struct snd_emu8000 *emu); -void snd_emu8000_update_equalizer(struct snd_emu8000 *emu); -int snd_emu8000_load_chorus_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len); -int snd_emu8000_load_reverb_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len); +void snd_emu8000_update_chorus_mode(emu8000_t *emu); +void snd_emu8000_update_reverb_mode(emu8000_t *emu); +void snd_emu8000_update_equalizer(emu8000_t *emu); +int snd_emu8000_load_chorus_fx(emu8000_t *emu, int mode, const void __user *buf, long len); +int snd_emu8000_load_reverb_fx(emu8000_t *emu, int mode, const void __user *buf, long len); #endif /* __SOUND_EMU8000_H */ diff --git a/trunk/include/sound/emux_synth.h b/trunk/include/sound/emux_synth.h index b2d6b2acc7c7..c6970aac9bdc 100644 --- a/trunk/include/sound/emux_synth.h +++ b/trunk/include/sound/emux_synth.h @@ -36,40 +36,39 @@ */ #define SNDRV_EMUX_USE_RAW_EFFECT -struct snd_emux; -struct snd_emux_port; -struct snd_emux_voice; -struct snd_emux_effect_table; + +/* + * typedefs + */ +typedef struct snd_emux_effect_table snd_emux_effect_table_t; +typedef struct snd_emux_port snd_emux_port_t; +typedef struct snd_emux_voice snd_emux_voice_t; +typedef struct snd_emux snd_emux_t; + /* * operators */ -struct snd_emux_operators { +typedef struct snd_emux_operators { struct module *owner; - struct snd_emux_voice *(*get_voice)(struct snd_emux *emu, - struct snd_emux_port *port); - int (*prepare)(struct snd_emux_voice *vp); - void (*trigger)(struct snd_emux_voice *vp); - void (*release)(struct snd_emux_voice *vp); - void (*update)(struct snd_emux_voice *vp, int update); - void (*terminate)(struct snd_emux_voice *vp); - void (*free_voice)(struct snd_emux_voice *vp); - void (*reset)(struct snd_emux *emu, int ch); - /* the first parameters are struct snd_emux */ - int (*sample_new)(struct snd_emux *emu, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr, - const void __user *data, long count); - int (*sample_free)(struct snd_emux *emu, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr); - void (*sample_reset)(struct snd_emux *emu); - int (*load_fx)(struct snd_emux *emu, int type, int arg, - const void __user *data, long count); - void (*sysex)(struct snd_emux *emu, char *buf, int len, int parsed, - struct snd_midi_channel_set *chset); + snd_emux_voice_t *(*get_voice)(snd_emux_t *emu, snd_emux_port_t *port); + int (*prepare)(snd_emux_voice_t *vp); + void (*trigger)(snd_emux_voice_t *vp); + void (*release)(snd_emux_voice_t *vp); + void (*update)(snd_emux_voice_t *vp, int update); + void (*terminate)(snd_emux_voice_t *vp); + void (*free_voice)(snd_emux_voice_t *vp); + void (*reset)(snd_emux_t *emu, int ch); + /* the first parameters are snd_emux_t */ + int (*sample_new)(snd_emux_t *emu, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr, const void __user *data, long count); + int (*sample_free)(snd_emux_t *emu, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr); + void (*sample_reset)(snd_emux_t *emu); + int (*load_fx)(snd_emux_t *emu, int type, int arg, const void __user *data, long count); + void (*sysex)(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset); #ifdef CONFIG_SND_SEQUENCER_OSS - int (*oss_ioctl)(struct snd_emux *emu, int cmd, int p1, int p2); + int (*oss_ioctl)(snd_emux_t *emu, int cmd, int p1, int p2); #endif -}; +} snd_emux_operators_t; /* @@ -91,46 +90,46 @@ struct snd_emux_operators { */ struct snd_emux { - struct snd_card *card; /* assigned card */ + snd_card_t *card; /* assigned card */ /* following should be initialized before registration */ int max_voices; /* Number of voices */ int mem_size; /* memory size (in byte) */ int num_ports; /* number of ports to be created */ int pitch_shift; /* pitch shift value (for Emu10k1) */ - struct snd_emux_operators ops; /* operators */ + snd_emux_operators_t ops; /* operators */ void *hw; /* hardware */ unsigned long flags; /* other conditions */ int midi_ports; /* number of virtual midi devices */ int midi_devidx; /* device offset of virtual midi */ unsigned int linear_panning: 1; /* panning is linear (sbawe = 1, emu10k1 = 0) */ int hwdep_idx; /* hwdep device index */ - struct snd_hwdep *hwdep; /* hwdep device */ + snd_hwdep_t *hwdep; /* hwdep device */ /* private */ int num_voices; /* current number of voices */ - struct snd_sf_list *sflist; /* root of SoundFont list */ - struct snd_emux_voice *voices; /* Voices (EMU 'channel') */ + snd_sf_list_t *sflist; /* root of SoundFont list */ + snd_emux_voice_t *voices; /* Voices (EMU 'channel') */ int use_time; /* allocation counter */ spinlock_t voice_lock; /* Lock for voice access */ struct semaphore register_mutex; int client; /* For the sequencer client */ int ports[SNDRV_EMUX_MAX_PORTS]; /* The ports for this device */ - struct snd_emux_port *portptrs[SNDRV_EMUX_MAX_PORTS]; + snd_emux_port_t *portptrs[SNDRV_EMUX_MAX_PORTS]; int used; /* use counter */ char *name; /* name of the device (internal) */ - struct snd_rawmidi **vmidi; + snd_rawmidi_t **vmidi; struct timer_list tlist; /* for pending note-offs */ int timer_active; - struct snd_util_memhdr *memhdr; /* memory chunk information */ + snd_util_memhdr_t *memhdr; /* memory chunk information */ #ifdef CONFIG_PROC_FS - struct snd_info_entry *proc; + snd_info_entry_t *proc; #endif #ifdef CONFIG_SND_SEQUENCER_OSS - struct snd_seq_device *oss_synth; + snd_seq_device_t *oss_synth; #endif }; @@ -140,18 +139,18 @@ struct snd_emux { */ struct snd_emux_port { - struct snd_midi_channel_set chset; - struct snd_emux *emu; + snd_midi_channel_set_t chset; + snd_emux_t *emu; char port_mode; /* operation mode */ int volume_atten; /* emuX raw attenuation */ unsigned long drum_flags; /* drum bitmaps */ int ctrls[EMUX_MD_END]; /* control parameters */ #ifdef SNDRV_EMUX_USE_RAW_EFFECT - struct snd_emux_effect_table *effect; + snd_emux_effect_table_t *effect; #endif #ifdef CONFIG_SND_SEQUENCER_OSS - struct snd_seq_oss_arg *oss_arg; + snd_seq_oss_arg_t *oss_arg; #endif }; @@ -180,16 +179,16 @@ struct snd_emux_voice { unsigned char key; unsigned char velocity; /* Velocity of current note */ - struct snd_sf_zone *zone; /* Zone assigned to this note */ + snd_sf_zone_t *zone; /* Zone assigned to this note */ void *block; /* sample block pointer (optional) */ - struct snd_midi_channel *chan; /* Midi channel for this note */ - struct snd_emux_port *port; /* associated port */ - struct snd_emux *emu; /* assigned root info */ - void *hw; /* hardware pointer (emu8000 or emu10k1) */ + snd_midi_channel_t *chan; /* Midi channel for this note */ + snd_emux_port_t *port; /* associated port */ + snd_emux_t *emu; /* assigned root info */ + void *hw; /* hardware pointer (emu8000_t or emu10k1_t) */ unsigned long ontime; /* jiffies at note triggered */ /* Emu8k/Emu10k1 registers */ - struct soundfont_voice_info reg; + soundfont_voice_info_t reg; /* additional registers */ int avol; /* volume attenuation */ @@ -230,15 +229,15 @@ struct snd_emux_effect_table { /* * prototypes - interface to Emu10k1 and Emu8k routines */ -int snd_emux_new(struct snd_emux **remu); -int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, char *name); -int snd_emux_free(struct snd_emux *emu); +int snd_emux_new(snd_emux_t **remu); +int snd_emux_register(snd_emux_t *emu, snd_card_t *card, int index, char *name); +int snd_emux_free(snd_emux_t *emu); /* * exported functions */ -void snd_emux_terminate_all(struct snd_emux *emu); -void snd_emux_lock_voice(struct snd_emux *emu, int voice); -void snd_emux_unlock_voice(struct snd_emux *emu, int voice); +void snd_emux_terminate_all(snd_emux_t *emu); +void snd_emux_lock_voice(snd_emux_t *emu, int voice); +void snd_emux_unlock_voice(snd_emux_t *emu, int voice); #endif /* __SOUND_EMUX_SYNTH_H */ diff --git a/trunk/include/sound/es1688.h b/trunk/include/sound/es1688.h index fc1c47dae3da..604f495bc8b1 100644 --- a/trunk/include/sound/es1688.h +++ b/trunk/include/sound/es1688.h @@ -30,7 +30,7 @@ #define ES1688_HW_688 0x0001 #define ES1688_HW_1688 0x0002 -struct snd_es1688 { +struct _snd_es1688 { unsigned long port; /* port of ESS chip */ struct resource *res_port; unsigned long mpu_port; /* MPU-401 port of ESS chip */ @@ -44,15 +44,17 @@ struct snd_es1688 { unsigned char pad; unsigned int dma_size; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; spinlock_t reg_lock; spinlock_t mixer_lock; }; +typedef struct _snd_es1688 es1688_t; + /* I/O ports */ #define ES1688P(codec, x) ((codec)->port + e_s_s_ESS1688##x) @@ -105,17 +107,17 @@ struct snd_es1688 { */ -void snd_es1688_mixer_write(struct snd_es1688 *chip, unsigned char reg, unsigned char data); +void snd_es1688_mixer_write(es1688_t *chip, unsigned char reg, unsigned char data); -int snd_es1688_create(struct snd_card *card, +int snd_es1688_create(snd_card_t * card, unsigned long port, unsigned long mpu_port, int irq, int mpu_irq, int dma8, unsigned short hardware, - struct snd_es1688 ** rchip); -int snd_es1688_pcm(struct snd_es1688 *chip, int device, struct snd_pcm ** rpcm); -int snd_es1688_mixer(struct snd_es1688 *chip); + es1688_t ** rchip); +int snd_es1688_pcm(es1688_t *chip, int device, snd_pcm_t ** rpcm); +int snd_es1688_mixer(es1688_t *chip); #endif /* __SOUND_ES1688_H */ diff --git a/trunk/include/sound/gus.h b/trunk/include/sound/gus.h index 63da50fae773..7000d9d9199d 100644 --- a/trunk/include/sound/gus.h +++ b/trunk/include/sound/gus.h @@ -49,32 +49,32 @@ #define SNDRV_g_u_s_IRQSTAT (0x226-0x220) #define SNDRV_g_u_s_TIMERCNTRL (0x228-0x220) #define SNDRV_g_u_s_TIMERDATA (0x229-0x220) -#define SNDRV_g_u_s_DRAM (0x327-0x220) +#define SNDRV_g_u_s_DRAM (0x327-0x220) #define SNDRV_g_u_s_MIXCNTRLREG (0x220-0x220) #define SNDRV_g_u_s_IRQDMACNTRLREG (0x22b-0x220) #define SNDRV_g_u_s_REGCNTRLS (0x22f-0x220) -#define SNDRV_g_u_s_BOARDVERSION (0x726-0x220) -#define SNDRV_g_u_s_MIXCNTRLPORT (0x726-0x220) -#define SNDRV_g_u_s_IVER (0x325-0x220) +#define SNDRV_g_u_s_BOARDVERSION (0x726-0x220) +#define SNDRV_g_u_s_MIXCNTRLPORT (0x726-0x220) +#define SNDRV_g_u_s_IVER (0x325-0x220) #define SNDRV_g_u_s_MIXDATAPORT (0x326-0x220) -#define SNDRV_g_u_s_MAXCNTRLPORT (0x326-0x220) +#define SNDRV_g_u_s_MAXCNTRLPORT (0x326-0x220) /* GF1 registers */ /* global registers */ #define SNDRV_GF1_GB_ACTIVE_VOICES 0x0e #define SNDRV_GF1_GB_VOICES_IRQ 0x0f -#define SNDRV_GF1_GB_GLOBAL_MODE 0x19 +#define SNDRV_GF1_GB_GLOBAL_MODE 0x19 #define SNDRV_GF1_GW_LFO_BASE 0x1a #define SNDRV_GF1_GB_VOICES_IRQ_READ 0x1f #define SNDRV_GF1_GB_DRAM_DMA_CONTROL 0x41 -#define SNDRV_GF1_GW_DRAM_DMA_LOW 0x42 -#define SNDRV_GF1_GW_DRAM_IO_LOW 0x43 -#define SNDRV_GF1_GB_DRAM_IO_HIGH 0x44 +#define SNDRV_GF1_GW_DRAM_DMA_LOW 0x42 +#define SNDRV_GF1_GW_DRAM_IO_LOW 0x43 +#define SNDRV_GF1_GB_DRAM_IO_HIGH 0x44 #define SNDRV_GF1_GB_SOUND_BLASTER_CONTROL 0x45 #define SNDRV_GF1_GB_ADLIB_TIMER_1 0x46 #define SNDRV_GF1_GB_ADLIB_TIMER_2 0x47 -#define SNDRV_GF1_GB_RECORD_RATE 0x48 +#define SNDRV_GF1_GB_RECORD_RATE 0x48 #define SNDRV_GF1_GB_REC_DMA_CONTROL 0x49 #define SNDRV_GF1_GB_JOYSTICK_DAC_LEVEL 0x4b #define SNDRV_GF1_GB_RESET 0x4c @@ -83,7 +83,7 @@ #define SNDRV_GF1_GW_MEMORY_CONFIG 0x52 #define SNDRV_GF1_GB_MEMORY_CONTROL 0x53 #define SNDRV_GF1_GW_FIFO_RECORD_BASE_ADDR 0x54 -#define SNDRV_GF1_GW_FIFO_PLAY_BASE_ADDR 0x55 +#define SNDRV_GF1_GW_FIFO_PLAY_BASE_ADDR 0x55 #define SNDRV_GF1_GW_FIFO_SIZE 0x56 #define SNDRV_GF1_GW_INTERLEAVE 0x57 #define SNDRV_GF1_GB_COMPATIBILITY 0x59 @@ -100,39 +100,39 @@ #define SNDRV_GF1_VA_START SNDRV_GF1_VW_START_HIGH #define SNDRV_GF1_VW_END_HIGH 0x04 #define SNDRV_GF1_VW_END_LOW 0x05 -#define SNDRV_GF1_VA_END SNDRV_GF1_VW_END_HIGH -#define SNDRV_GF1_VB_VOLUME_RATE 0x06 -#define SNDRV_GF1_VB_VOLUME_START 0x07 +#define SNDRV_GF1_VA_END SNDRV_GF1_VW_END_HIGH +#define SNDRV_GF1_VB_VOLUME_RATE 0x06 +#define SNDRV_GF1_VB_VOLUME_START 0x07 #define SNDRV_GF1_VB_VOLUME_END 0x08 #define SNDRV_GF1_VW_VOLUME 0x09 -#define SNDRV_GF1_VW_CURRENT_HIGH 0x0a -#define SNDRV_GF1_VW_CURRENT_LOW 0x0b +#define SNDRV_GF1_VW_CURRENT_HIGH 0x0a +#define SNDRV_GF1_VW_CURRENT_LOW 0x0b #define SNDRV_GF1_VA_CURRENT SNDRV_GF1_VW_CURRENT_HIGH -#define SNDRV_GF1_VB_PAN 0x0c -#define SNDRV_GF1_VW_OFFSET_RIGHT 0x0c +#define SNDRV_GF1_VB_PAN 0x0c +#define SNDRV_GF1_VW_OFFSET_RIGHT 0x0c #define SNDRV_GF1_VB_VOLUME_CONTROL 0x0d #define SNDRV_GF1_VB_UPPER_ADDRESS 0x10 -#define SNDRV_GF1_VW_EFFECT_HIGH 0x11 +#define SNDRV_GF1_VW_EFFECT_HIGH 0x11 #define SNDRV_GF1_VW_EFFECT_LOW 0x12 #define SNDRV_GF1_VA_EFFECT SNDRV_GF1_VW_EFFECT_HIGH -#define SNDRV_GF1_VW_OFFSET_LEFT 0x13 -#define SNDRV_GF1_VB_ACCUMULATOR 0x14 -#define SNDRV_GF1_VB_MODE 0x15 +#define SNDRV_GF1_VW_OFFSET_LEFT 0x13 +#define SNDRV_GF1_VB_ACCUMULATOR 0x14 +#define SNDRV_GF1_VB_MODE 0x15 #define SNDRV_GF1_VW_EFFECT_VOLUME 0x16 #define SNDRV_GF1_VB_FREQUENCY_LFO 0x17 #define SNDRV_GF1_VB_VOLUME_LFO 0x18 #define SNDRV_GF1_VW_OFFSET_RIGHT_FINAL 0x1b #define SNDRV_GF1_VW_OFFSET_LEFT_FINAL 0x1c -#define SNDRV_GF1_VW_EFFECT_VOLUME_FINAL 0x1d +#define SNDRV_GF1_VW_EFFECT_VOLUME_FINAL 0x1d /* ICS registers */ #define SNDRV_ICS_MIC_DEV 0 -#define SNDRV_ICS_LINE_DEV 1 +#define SNDRV_ICS_LINE_DEV 1 #define SNDRV_ICS_CD_DEV 2 #define SNDRV_ICS_GF1_DEV 3 -#define SNDRV_ICS_NONE_DEV 4 -#define SNDRV_ICS_MASTER_DEV 5 +#define SNDRV_ICS_NONE_DEV 4 +#define SNDRV_ICS_MASTER_DEV 5 /* LFO */ @@ -143,7 +143,7 @@ #define SNDRV_GF1_DMA_UNSIGNED 0x80 #define SNDRV_GF1_DMA_16BIT 0x40 -#define SNDRV_GF1_DMA_IRQ 0x20 +#define SNDRV_GF1_DMA_IRQ 0x20 #define SNDRV_GF1_DMA_WIDTH16 0x04 #define SNDRV_GF1_DMA_READ 0x02 /* read from GUS's DRAM */ #define SNDRV_GF1_DMA_ENABLE 0x01 @@ -159,7 +159,7 @@ /* defines for memory manager */ -#define SNDRV_GF1_MEM_BLOCK_16BIT 0x0001 +#define SNDRV_GF1_MEM_BLOCK_16BIT 0x0001 #define SNDRV_GF1_MEM_OWNER_DRIVER 0x0001 #define SNDRV_GF1_MEM_OWNER_WAVE_SIMPLE 0x0002 @@ -169,9 +169,9 @@ /* constants for interrupt handlers */ #define SNDRV_GF1_HANDLER_MIDI_OUT 0x00010000 -#define SNDRV_GF1_HANDLER_MIDI_IN 0x00020000 -#define SNDRV_GF1_HANDLER_TIMER1 0x00040000 -#define SNDRV_GF1_HANDLER_TIMER2 0x00080000 +#define SNDRV_GF1_HANDLER_MIDI_IN 0x00020000 +#define SNDRV_GF1_HANDLER_TIMER1 0x00040000 +#define SNDRV_GF1_HANDLER_TIMER2 0x00080000 #define SNDRV_GF1_HANDLER_VOICE 0x00100000 #define SNDRV_GF1_HANDLER_DMA_WRITE 0x00200000 #define SNDRV_GF1_HANDLER_DMA_READ 0x00400000 @@ -183,16 +183,17 @@ /* --- */ -struct snd_gus_card; +struct _snd_gus_card; +typedef struct _snd_gus_card snd_gus_card_t; /* GF1 specific structure */ -struct snd_gf1_bank_info { +typedef struct _snd_gf1_bank_info { unsigned int address; unsigned int size; -}; +} snd_gf1_bank_info_t; -struct snd_gf1_mem_block { +typedef struct _snd_gf1_mem_block { unsigned short flags; /* flags - SNDRV_GF1_MEM_BLOCK_XXXX */ unsigned short owner; /* owner - SNDRV_GF1_MEM_OWNER_XXXX */ unsigned int share; /* share count */ @@ -200,68 +201,68 @@ struct snd_gf1_mem_block { unsigned int ptr; unsigned int size; char *name; - struct snd_gf1_mem_block *next; - struct snd_gf1_mem_block *prev; -}; - -struct snd_gf1_mem { - struct snd_gf1_bank_info banks_8[4]; - struct snd_gf1_bank_info banks_16[4]; - struct snd_gf1_mem_block *first; - struct snd_gf1_mem_block *last; + struct _snd_gf1_mem_block *next; + struct _snd_gf1_mem_block *prev; +} snd_gf1_mem_block_t; + +typedef struct _snd_gf1_mem { + snd_gf1_bank_info_t banks_8[4]; + snd_gf1_bank_info_t banks_16[4]; + snd_gf1_mem_block_t *first; + snd_gf1_mem_block_t *last; struct semaphore memory_mutex; -}; +} snd_gf1_mem_t; -struct snd_gf1_dma_block { +typedef struct snd_gf1_dma_block { void *buffer; /* buffer in computer's RAM */ unsigned long buf_addr; /* buffer address */ unsigned int addr; /* address in onboard memory */ unsigned int count; /* count in bytes */ unsigned int cmd; /* DMA command (format) */ - void (*ack)(struct snd_gus_card * gus, void *private_data); + void (*ack)(snd_gus_card_t * gus, void *private_data); void *private_data; struct snd_gf1_dma_block *next; -}; +} snd_gf1_dma_block_t; -struct snd_gus_port { - struct snd_midi_channel_set * chset; - struct snd_gus_card * gus; +typedef struct { + snd_midi_channel_set_t * chset; + snd_gus_card_t * gus; int mode; /* operation mode */ int client; /* sequencer client number */ int port; /* sequencer port number */ unsigned int midi_has_voices: 1; -}; +} snd_gus_port_t; -struct snd_gus_voice; +typedef struct _snd_gus_voice snd_gus_voice_t; -struct snd_gus_sample_ops { - void (*sample_start)(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_position_t position); - void (*sample_stop)(struct snd_gus_card *gus, struct snd_gus_voice *voice, int mode); - void (*sample_freq)(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_frequency_t freq); - void (*sample_volume)(struct snd_gus_card *gus, struct snd_gus_voice *voice, struct snd_seq_ev_volume *volume); - void (*sample_loop)(struct snd_gus_card *card, struct snd_gus_voice *voice, struct snd_seq_ev_loop *loop); - void (*sample_pos)(struct snd_gus_card *card, struct snd_gus_voice *voice, snd_seq_position_t position); - void (*sample_private1)(struct snd_gus_card *card, struct snd_gus_voice *voice, unsigned char *data); -}; +typedef struct { + void (*sample_start)(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_position_t position); + void (*sample_stop)(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_stop_mode_t mode); + void (*sample_freq)(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_frequency_t freq); + void (*sample_volume)(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_ev_volume_t *volume); + void (*sample_loop)(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_ev_loop_t *loop); + void (*sample_pos)(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_position_t position); + void (*sample_private1)(snd_gus_card_t *card, snd_gus_voice_t *voice, unsigned char *data); +} snd_gus_sample_ops_t; -#define SNDRV_GF1_VOICE_TYPE_PCM 0 +#define SNDRV_GF1_VOICE_TYPE_PCM 0 #define SNDRV_GF1_VOICE_TYPE_SYNTH 1 -#define SNDRV_GF1_VOICE_TYPE_MIDI 2 +#define SNDRV_GF1_VOICE_TYPE_MIDI 2 #define SNDRV_GF1_VFLG_RUNNING (1<<0) #define SNDRV_GF1_VFLG_EFFECT_TIMER1 (1<<1) #define SNDRV_GF1_VFLG_PAN (1<<2) -enum snd_gus_volume_state { +typedef enum { VENV_BEFORE, VENV_ATTACK, VENV_SUSTAIN, VENV_RELEASE, VENV_DONE, VENV_VOLUME -}; +} snd_gus_volume_state_t; -struct snd_gus_voice { +struct _snd_gus_voice { int number; unsigned int use: 1, pcm: 1, @@ -277,18 +278,18 @@ struct snd_gus_voice { unsigned int interrupt_stat_wave; unsigned int interrupt_stat_volume; #endif - void (*handler_wave) (struct snd_gus_card * gus, struct snd_gus_voice * voice); - void (*handler_volume) (struct snd_gus_card * gus, struct snd_gus_voice * voice); - void (*handler_effect) (struct snd_gus_card * gus, struct snd_gus_voice * voice); - void (*volume_change) (struct snd_gus_card * gus); + void (*handler_wave) (snd_gus_card_t * gus, snd_gus_voice_t * voice); + void (*handler_volume) (snd_gus_card_t * gus, snd_gus_voice_t * voice); + void (*handler_effect) (snd_gus_card_t * gus, snd_gus_voice_t * voice); + void (*volume_change) (snd_gus_card_t * gus); - struct snd_gus_sample_ops *sample_ops; + snd_gus_sample_ops_t *sample_ops; - struct snd_seq_instr instr; + snd_seq_instr_t instr; /* running status / registers */ - struct snd_seq_ev_volume sample_volume; + snd_seq_ev_volume_t sample_volume; unsigned short fc_register; unsigned short fc_lfo; @@ -299,8 +300,8 @@ struct snd_gus_voice { unsigned char effect_accumulator; unsigned char volume_control; unsigned char venv_value_next; - enum snd_gus_volume_state venv_state; - enum snd_gus_volume_state venv_state_prev; + snd_gus_volume_state_t venv_state; + snd_gus_volume_state_t venv_state_prev; unsigned short vlo; unsigned short vro; unsigned short gf1_effect_volume; @@ -308,10 +309,10 @@ struct snd_gus_voice { /* --- */ void *private_data; - void (*private_free)(struct snd_gus_voice *voice); + void (*private_free)(snd_gus_voice_t *voice); }; -struct snd_gf1 { +struct _snd_gf1 { unsigned int enh_mode:1, /* enhanced mode (GFA1) */ hw_lfo:1, /* use hardware LFO */ @@ -329,7 +330,7 @@ struct snd_gf1 { unsigned int rom_present; /* bitmask */ unsigned int rom_banks; /* GUS's ROM banks */ - struct snd_gf1_mem mem_alloc; + snd_gf1_mem_t mem_alloc; /* registers */ unsigned short reg_page; @@ -346,7 +347,7 @@ struct snd_gf1 { unsigned char active_voices; /* active voices */ unsigned char active_voice; /* selected voice (GF1PAGE register) */ - struct snd_gus_voice voices[32]; /* GF1 voices */ + snd_gus_voice_t voices[32]; /* GF1 voices */ unsigned int default_voice_address; @@ -361,12 +362,12 @@ struct snd_gf1 { /* interrupt handlers */ - void (*interrupt_handler_midi_out) (struct snd_gus_card * gus); - void (*interrupt_handler_midi_in) (struct snd_gus_card * gus); - void (*interrupt_handler_timer1) (struct snd_gus_card * gus); - void (*interrupt_handler_timer2) (struct snd_gus_card * gus); - void (*interrupt_handler_dma_write) (struct snd_gus_card * gus); - void (*interrupt_handler_dma_read) (struct snd_gus_card * gus); + void (*interrupt_handler_midi_out) (snd_gus_card_t * gus); + void (*interrupt_handler_midi_in) (snd_gus_card_t * gus); + void (*interrupt_handler_timer1) (snd_gus_card_t * gus); + void (*interrupt_handler_timer2) (snd_gus_card_t * gus); + void (*interrupt_handler_dma_write) (snd_gus_card_t * gus); + void (*interrupt_handler_dma_read) (snd_gus_card_t * gus); #ifdef CONFIG_SND_DEBUG unsigned int interrupt_stat_midi_out; @@ -381,17 +382,17 @@ struct snd_gf1 { /* synthesizer */ int seq_client; - struct snd_gus_port seq_ports[4]; - struct snd_seq_kinstr_list *ilist; - struct snd_iwffff_ops iwffff_ops; - struct snd_gf1_ops gf1_ops; - struct snd_simple_ops simple_ops; + snd_gus_port_t seq_ports[4]; + snd_seq_kinstr_list_t *ilist; + snd_iwffff_ops_t iwffff_ops; + snd_gf1_ops_t gf1_ops; + snd_simple_ops_t simple_ops; /* timer */ unsigned short timer_enabled; - struct snd_timer *timer1; - struct snd_timer *timer2; + snd_timer_t *timer1; + snd_timer_t *timer2; /* midi */ @@ -403,11 +404,11 @@ struct snd_gf1 { unsigned int dma_flags; unsigned int dma_shared; - struct snd_gf1_dma_block *dma_data_pcm; - struct snd_gf1_dma_block *dma_data_pcm_last; - struct snd_gf1_dma_block *dma_data_synth; - struct snd_gf1_dma_block *dma_data_synth_last; - void (*dma_ack)(struct snd_gus_card * gus, void *private_data); + snd_gf1_dma_block_t *dma_data_pcm; + snd_gf1_dma_block_t *dma_data_pcm_last; + snd_gf1_dma_block_t *dma_data_synth; + snd_gf1_dma_block_t *dma_data_synth_last; + void (*dma_ack)(snd_gus_card_t * gus, void *private_data); void *dma_private_data; /* pcm */ @@ -424,8 +425,8 @@ struct snd_gf1 { /* main structure for GUS card */ -struct snd_gus_card { - struct snd_card *card; +struct _snd_gus_card { + snd_card_t *card; unsigned int initialized: 1, /* resources were initialized */ @@ -447,18 +448,18 @@ struct snd_gus_card { unsigned short joystick_dac; /* joystick DAC level */ int timer_dev; /* timer device */ - struct snd_gf1 gf1; /* gf1 specific variables */ - struct snd_pcm *pcm; - struct snd_pcm_substream *pcm_cap_substream; + struct _snd_gf1 gf1; /* gf1 specific variables */ + snd_pcm_t *pcm; + snd_pcm_substream_t *pcm_cap_substream; unsigned int c_dma_size; unsigned int c_period_size; unsigned int c_pos; - struct snd_rawmidi *midi_uart; - struct snd_rawmidi_substream *midi_substream_output; - struct snd_rawmidi_substream *midi_substream_input; + snd_rawmidi_t *midi_uart; + snd_rawmidi_substream_t *midi_substream_output; + snd_rawmidi_substream_t *midi_substream_input; - struct snd_seq_device *seq_dev; + snd_seq_device_t *seq_dev; spinlock_t reg_lock; spinlock_t voice_alloc; @@ -473,7 +474,7 @@ struct snd_gus_card { /* I/O functions for GF1/InterWave chip - gus_io.c */ -static inline void snd_gf1_select_voice(struct snd_gus_card * gus, int voice) +static inline void snd_gf1_select_voice(snd_gus_card_t * gus, int voice) { unsigned long flags; @@ -485,63 +486,63 @@ static inline void snd_gf1_select_voice(struct snd_gus_card * gus, int voice) spin_unlock_irqrestore(&gus->active_voice_lock, flags); } -static inline void snd_gf1_uart_cmd(struct snd_gus_card * gus, unsigned char b) +static inline void snd_gf1_uart_cmd(snd_gus_card_t * gus, unsigned char b) { outb(gus->gf1.uart_cmd = b, GUSP(gus, MIDICTRL)); } -static inline unsigned char snd_gf1_uart_stat(struct snd_gus_card * gus) +static inline unsigned char snd_gf1_uart_stat(snd_gus_card_t * gus) { return inb(GUSP(gus, MIDISTAT)); } -static inline void snd_gf1_uart_put(struct snd_gus_card * gus, unsigned char b) +static inline void snd_gf1_uart_put(snd_gus_card_t * gus, unsigned char b) { outb(b, GUSP(gus, MIDIDATA)); } -static inline unsigned char snd_gf1_uart_get(struct snd_gus_card * gus) +static inline unsigned char snd_gf1_uart_get(snd_gus_card_t * gus) { return inb(GUSP(gus, MIDIDATA)); } -extern void snd_gf1_delay(struct snd_gus_card * gus); +extern void snd_gf1_delay(snd_gus_card_t * gus); -extern void snd_gf1_ctrl_stop(struct snd_gus_card * gus, unsigned char reg); +extern void snd_gf1_ctrl_stop(snd_gus_card_t * gus, unsigned char reg); -extern void snd_gf1_write8(struct snd_gus_card * gus, unsigned char reg, unsigned char data); -extern unsigned char snd_gf1_look8(struct snd_gus_card * gus, unsigned char reg); -static inline unsigned char snd_gf1_read8(struct snd_gus_card * gus, unsigned char reg) +extern void snd_gf1_write8(snd_gus_card_t * gus, unsigned char reg, unsigned char data); +extern unsigned char snd_gf1_look8(snd_gus_card_t * gus, unsigned char reg); +static inline unsigned char snd_gf1_read8(snd_gus_card_t * gus, unsigned char reg) { return snd_gf1_look8(gus, reg | 0x80); } -extern void snd_gf1_write16(struct snd_gus_card * gus, unsigned char reg, unsigned int data); -extern unsigned short snd_gf1_look16(struct snd_gus_card * gus, unsigned char reg); -static inline unsigned short snd_gf1_read16(struct snd_gus_card * gus, unsigned char reg) +extern void snd_gf1_write16(snd_gus_card_t * gus, unsigned char reg, unsigned int data); +extern unsigned short snd_gf1_look16(snd_gus_card_t * gus, unsigned char reg); +static inline unsigned short snd_gf1_read16(snd_gus_card_t * gus, unsigned char reg) { return snd_gf1_look16(gus, reg | 0x80); } -extern void snd_gf1_adlib_write(struct snd_gus_card * gus, unsigned char reg, unsigned char data); -extern void snd_gf1_dram_addr(struct snd_gus_card * gus, unsigned int addr); -extern void snd_gf1_poke(struct snd_gus_card * gus, unsigned int addr, unsigned char data); -extern unsigned char snd_gf1_peek(struct snd_gus_card * gus, unsigned int addr); -extern void snd_gf1_write_addr(struct snd_gus_card * gus, unsigned char reg, unsigned int addr, short w_16bit); -extern unsigned int snd_gf1_read_addr(struct snd_gus_card * gus, unsigned char reg, short w_16bit); -extern void snd_gf1_i_ctrl_stop(struct snd_gus_card * gus, unsigned char reg); -extern void snd_gf1_i_write8(struct snd_gus_card * gus, unsigned char reg, unsigned char data); -extern unsigned char snd_gf1_i_look8(struct snd_gus_card * gus, unsigned char reg); -extern void snd_gf1_i_write16(struct snd_gus_card * gus, unsigned char reg, unsigned int data); -static inline unsigned char snd_gf1_i_read8(struct snd_gus_card * gus, unsigned char reg) +extern void snd_gf1_adlib_write(snd_gus_card_t * gus, unsigned char reg, unsigned char data); +extern void snd_gf1_dram_addr(snd_gus_card_t * gus, unsigned int addr); +extern void snd_gf1_poke(snd_gus_card_t * gus, unsigned int addr, unsigned char data); +extern unsigned char snd_gf1_peek(snd_gus_card_t * gus, unsigned int addr); +extern void snd_gf1_write_addr(snd_gus_card_t * gus, unsigned char reg, unsigned int addr, short w_16bit); +extern unsigned int snd_gf1_read_addr(snd_gus_card_t * gus, unsigned char reg, short w_16bit); +extern void snd_gf1_i_ctrl_stop(snd_gus_card_t * gus, unsigned char reg); +extern void snd_gf1_i_write8(snd_gus_card_t * gus, unsigned char reg, unsigned char data); +extern unsigned char snd_gf1_i_look8(snd_gus_card_t * gus, unsigned char reg); +extern void snd_gf1_i_write16(snd_gus_card_t * gus, unsigned char reg, unsigned int data); +static inline unsigned char snd_gf1_i_read8(snd_gus_card_t * gus, unsigned char reg) { return snd_gf1_i_look8(gus, reg | 0x80); } -extern unsigned short snd_gf1_i_look16(struct snd_gus_card * gus, unsigned char reg); -static inline unsigned short snd_gf1_i_read16(struct snd_gus_card * gus, unsigned char reg) +extern unsigned short snd_gf1_i_look16(snd_gus_card_t * gus, unsigned char reg); +static inline unsigned short snd_gf1_i_read16(snd_gus_card_t * gus, unsigned char reg) { return snd_gf1_i_look16(gus, reg | 0x80); } -extern void snd_gf1_select_active_voices(struct snd_gus_card * gus); +extern void snd_gf1_select_active_voices(snd_gus_card_t * gus); /* gus_lfo.c */ @@ -554,98 +555,98 @@ struct _SND_IW_LFO_PROGRAM { }; #if 0 -extern irqreturn_t snd_gf1_lfo_effect_interrupt(struct snd_gus_card * gus, snd_gf1_voice_t * voice); +extern irqreturn_t snd_gf1_lfo_effect_interrupt(snd_gus_card_t * gus, snd_gf1_voice_t * voice); #endif -extern void snd_gf1_lfo_init(struct snd_gus_card * gus); -extern void snd_gf1_lfo_done(struct snd_gus_card * gus); -extern void snd_gf1_lfo_program(struct snd_gus_card * gus, int voice, int lfo_type, struct _SND_IW_LFO_PROGRAM *program); -extern void snd_gf1_lfo_enable(struct snd_gus_card * gus, int voice, int lfo_type); -extern void snd_gf1_lfo_disable(struct snd_gus_card * gus, int voice, int lfo_type); -extern void snd_gf1_lfo_change_freq(struct snd_gus_card * gus, int voice, int lfo_type, int freq); -extern void snd_gf1_lfo_change_depth(struct snd_gus_card * gus, int voice, int lfo_type, int depth); -extern void snd_gf1_lfo_setup(struct snd_gus_card * gus, int voice, int lfo_type, int freq, int current_depth, int depth, int sweep, int shape); -extern void snd_gf1_lfo_shutdown(struct snd_gus_card * gus, int voice, int lfo_type); +extern void snd_gf1_lfo_init(snd_gus_card_t * gus); +extern void snd_gf1_lfo_done(snd_gus_card_t * gus); +extern void snd_gf1_lfo_program(snd_gus_card_t * gus, int voice, int lfo_type, struct _SND_IW_LFO_PROGRAM *program); +extern void snd_gf1_lfo_enable(snd_gus_card_t * gus, int voice, int lfo_type); +extern void snd_gf1_lfo_disable(snd_gus_card_t * gus, int voice, int lfo_type); +extern void snd_gf1_lfo_change_freq(snd_gus_card_t * gus, int voice, int lfo_type, int freq); +extern void snd_gf1_lfo_change_depth(snd_gus_card_t * gus, int voice, int lfo_type, int depth); +extern void snd_gf1_lfo_setup(snd_gus_card_t * gus, int voice, int lfo_type, int freq, int current_depth, int depth, int sweep, int shape); +extern void snd_gf1_lfo_shutdown(snd_gus_card_t * gus, int voice, int lfo_type); #if 0 -extern void snd_gf1_lfo_command(struct snd_gus_card * gus, int voice, unsigned char *command); +extern void snd_gf1_lfo_command(snd_gus_card_t * gus, int voice, unsigned char *command); #endif /* gus_mem.c */ -void snd_gf1_mem_lock(struct snd_gf1_mem * alloc, int xup); -int snd_gf1_mem_xfree(struct snd_gf1_mem * alloc, struct snd_gf1_mem_block * block); -struct snd_gf1_mem_block *snd_gf1_mem_alloc(struct snd_gf1_mem * alloc, int owner, +void snd_gf1_mem_lock(snd_gf1_mem_t * alloc, int xup); +int snd_gf1_mem_xfree(snd_gf1_mem_t * alloc, snd_gf1_mem_block_t * block); +snd_gf1_mem_block_t *snd_gf1_mem_alloc(snd_gf1_mem_t * alloc, int owner, char *name, int size, int w_16, int align, unsigned int *share_id); -int snd_gf1_mem_free(struct snd_gf1_mem * alloc, unsigned int address); -int snd_gf1_mem_free_owner(struct snd_gf1_mem * alloc, int owner); -int snd_gf1_mem_init(struct snd_gus_card * gus); -int snd_gf1_mem_done(struct snd_gus_card * gus); +int snd_gf1_mem_free(snd_gf1_mem_t * alloc, unsigned int address); +int snd_gf1_mem_free_owner(snd_gf1_mem_t * alloc, int owner); +int snd_gf1_mem_init(snd_gus_card_t * gus); +int snd_gf1_mem_done(snd_gus_card_t * gus); /* gus_mem_proc.c */ -int snd_gf1_mem_proc_init(struct snd_gus_card * gus); +int snd_gf1_mem_proc_init(snd_gus_card_t * gus); /* gus_dma.c */ -int snd_gf1_dma_init(struct snd_gus_card * gus); -int snd_gf1_dma_done(struct snd_gus_card * gus); -int snd_gf1_dma_transfer_block(struct snd_gus_card * gus, - struct snd_gf1_dma_block * block, +int snd_gf1_dma_init(snd_gus_card_t * gus); +int snd_gf1_dma_done(snd_gus_card_t * gus); +int snd_gf1_dma_transfer_block(snd_gus_card_t * gus, + snd_gf1_dma_block_t * block, int atomic, int synth); /* gus_volume.c */ unsigned short snd_gf1_lvol_to_gvol_raw(unsigned int vol); -unsigned short snd_gf1_translate_freq(struct snd_gus_card * gus, unsigned int freq2); +unsigned short snd_gf1_translate_freq(snd_gus_card_t * gus, unsigned int freq2); /* gus_reset.c */ -void snd_gf1_set_default_handlers(struct snd_gus_card * gus, unsigned int what); -void snd_gf1_smart_stop_voice(struct snd_gus_card * gus, unsigned short voice); -void snd_gf1_stop_voice(struct snd_gus_card * gus, unsigned short voice); -void snd_gf1_stop_voices(struct snd_gus_card * gus, unsigned short v_min, unsigned short v_max); -struct snd_gus_voice *snd_gf1_alloc_voice(struct snd_gus_card * gus, int type, int client, int port); -void snd_gf1_free_voice(struct snd_gus_card * gus, struct snd_gus_voice *voice); -int snd_gf1_start(struct snd_gus_card * gus); -int snd_gf1_stop(struct snd_gus_card * gus); +void snd_gf1_set_default_handlers(snd_gus_card_t * gus, unsigned int what); +void snd_gf1_smart_stop_voice(snd_gus_card_t * gus, unsigned short voice); +void snd_gf1_stop_voice(snd_gus_card_t * gus, unsigned short voice); +void snd_gf1_stop_voices(snd_gus_card_t * gus, unsigned short v_min, unsigned short v_max); +snd_gus_voice_t *snd_gf1_alloc_voice(snd_gus_card_t * gus, int type, int client, int port); +void snd_gf1_free_voice(snd_gus_card_t * gus, snd_gus_voice_t *voice); +int snd_gf1_start(snd_gus_card_t * gus); +int snd_gf1_stop(snd_gus_card_t * gus); /* gus_mixer.c */ -int snd_gf1_new_mixer(struct snd_gus_card * gus); +int snd_gf1_new_mixer(snd_gus_card_t * gus); /* gus_pcm.c */ -int snd_gf1_pcm_new(struct snd_gus_card * gus, int pcm_dev, int control_index, struct snd_pcm ** rpcm); +int snd_gf1_pcm_new(snd_gus_card_t * gus, int pcm_dev, int control_index, snd_pcm_t ** rpcm); #ifdef CONFIG_SND_DEBUG -extern void snd_gf1_print_voice_registers(struct snd_gus_card * gus); +extern void snd_gf1_print_voice_registers(snd_gus_card_t * gus); #endif /* gus.c */ -int snd_gus_use_inc(struct snd_gus_card * gus); -void snd_gus_use_dec(struct snd_gus_card * gus); -int snd_gus_create(struct snd_card *card, +int snd_gus_use_inc(snd_gus_card_t * gus); +void snd_gus_use_dec(snd_gus_card_t * gus); +int snd_gus_create(snd_card_t * card, unsigned long port, int irq, int dma1, int dma2, int timer_dev, int voices, int pcm_channels, int effect, - struct snd_gus_card ** rgus); -int snd_gus_initialize(struct snd_gus_card * gus); + snd_gus_card_t ** rgus); +int snd_gus_initialize(snd_gus_card_t * gus); /* gus_irq.c */ irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs); #ifdef CONFIG_SND_DEBUG -void snd_gus_irq_profile_init(struct snd_gus_card *gus); +void snd_gus_irq_profile_init(snd_gus_card_t *gus); #endif /* gus_uart.c */ -int snd_gf1_rawmidi_new(struct snd_gus_card * gus, int device, struct snd_rawmidi **rrawmidi); +int snd_gf1_rawmidi_new(snd_gus_card_t * gus, int device, snd_rawmidi_t **rrawmidi); #if 0 extern void snd_engine_instrument_register(unsigned short mode, @@ -656,37 +657,37 @@ extern int snd_engine_instrument_register_ask(unsigned short mode); #endif /* gus_dram.c */ -int snd_gus_dram_write(struct snd_gus_card *gus, char __user *ptr, +int snd_gus_dram_write(snd_gus_card_t *gus, char __user *ptr, unsigned int addr, unsigned int size); -int snd_gus_dram_read(struct snd_gus_card *gus, char __user *ptr, +int snd_gus_dram_read(snd_gus_card_t *gus, char __user *ptr, unsigned int addr, unsigned int size, int rom); #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) /* gus_sample.c */ -void snd_gus_sample_event(struct snd_seq_event *ev, struct snd_gus_port *p); +void snd_gus_sample_event(snd_seq_event_t *ev, snd_gus_port_t *p); /* gus_simple.c */ -void snd_gf1_simple_init(struct snd_gus_voice *voice); +void snd_gf1_simple_init(snd_gus_voice_t *voice); /* gus_instr.c */ -int snd_gus_iwffff_put_sample(void *private_data, struct iwffff_wave *wave, +int snd_gus_iwffff_put_sample(void *private_data, iwffff_wave_t *wave, char __user *data, long len, int atomic); -int snd_gus_iwffff_get_sample(void *private_data, struct iwffff_wave *wave, +int snd_gus_iwffff_get_sample(void *private_data, iwffff_wave_t *wave, char __user *data, long len, int atomic); -int snd_gus_iwffff_remove_sample(void *private_data, struct iwffff_wave *wave, +int snd_gus_iwffff_remove_sample(void *private_data, iwffff_wave_t *wave, int atomic); -int snd_gus_gf1_put_sample(void *private_data, struct gf1_wave *wave, +int snd_gus_gf1_put_sample(void *private_data, gf1_wave_t *wave, char __user *data, long len, int atomic); -int snd_gus_gf1_get_sample(void *private_data, struct gf1_wave *wave, +int snd_gus_gf1_get_sample(void *private_data, gf1_wave_t *wave, char __user *data, long len, int atomic); -int snd_gus_gf1_remove_sample(void *private_data, struct gf1_wave *wave, +int snd_gus_gf1_remove_sample(void *private_data, gf1_wave_t *wave, int atomic); -int snd_gus_simple_put_sample(void *private_data, struct simple_instrument *instr, +int snd_gus_simple_put_sample(void *private_data, simple_instrument_t *instr, char __user *data, long len, int atomic); -int snd_gus_simple_get_sample(void *private_data, struct simple_instrument *instr, +int snd_gus_simple_get_sample(void *private_data, simple_instrument_t *instr, char __user *data, long len, int atomic); -int snd_gus_simple_remove_sample(void *private_data, struct simple_instrument *instr, +int snd_gus_simple_remove_sample(void *private_data, simple_instrument_t *instr, int atomic); #endif /* CONFIG_SND_SEQUENCER */ diff --git a/trunk/include/sound/hdsp.h b/trunk/include/sound/hdsp.h index 25e1951a9955..7ce3aa67e5d6 100644 --- a/trunk/include/sound/hdsp.h +++ b/trunk/include/sound/hdsp.h @@ -21,15 +21,17 @@ #define HDSP_MATRIX_MIXER_SIZE 2048 -enum HDSP_IO_Type { +typedef enum { Digiface, Multiface, H9652, H9632, Undefined, -}; +} HDSP_IO_Type; + +typedef struct _snd_hdsp_peak_rms hdsp_peak_rms_t; -struct hdsp_peak_rms { +struct _snd_hdsp_peak_rms { u32 input_peaks[26]; u32 playback_peaks[26]; u32 output_peaks[28]; @@ -39,9 +41,11 @@ struct hdsp_peak_rms { u64 output_rms[26]; }; -#define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms) +#define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, hdsp_peak_rms_t) -struct hdsp_config_info { +typedef struct _snd_hdsp_config_info hdsp_config_info_t; + +struct _snd_hdsp_config_info { unsigned char pref_sync_ref; unsigned char wordclock_sync_check; unsigned char spdif_sync_check; @@ -67,41 +71,40 @@ struct hdsp_config_info { unsigned char analog_extension_board; }; -#define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdsp_config_info) +#define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, hdsp_config_info_t) + +typedef struct _snd_hdsp_firmware hdsp_firmware_t; -struct hdsp_firmware { +struct _snd_hdsp_firmware { void __user *firmware_data; /* 24413 x 4 bytes */ }; -#define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, struct hdsp_firmware) +#define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, hdsp_firmware_t) -struct hdsp_version { - enum HDSP_IO_Type io_type; +typedef struct _snd_hdsp_version hdsp_version_t; + +struct _snd_hdsp_version { + HDSP_IO_Type io_type; unsigned short firmware_rev; }; -#define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdsp_version) +#define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, hdsp_version_t) + +typedef struct _snd_hdsp_mixer hdsp_mixer_t; -struct hdsp_mixer { +struct _snd_hdsp_mixer { unsigned short matrix[HDSP_MATRIX_MIXER_SIZE]; }; -#define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdsp_mixer) +#define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, hdsp_mixer_t) -struct hdsp_9632_aeb { +typedef struct _snd_hdsp_9632_aeb hdsp_9632_aeb_t; + +struct _snd_hdsp_9632_aeb { int aebi; int aebo; }; -#define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb) - -/* typedefs for compatibility to user-space */ -typedef enum HDSP_IO_Type HDSP_IO_Type; -typedef struct hdsp_peak_rms hdsp_peak_rms_t; -typedef struct hdsp_config_info hdsp_config_info_t; -typedef struct hdsp_firmware hdsp_firmware_t; -typedef struct hdsp_version hdsp_version_t; -typedef struct hdsp_mixer hdsp_mixer_t; -typedef struct hdsp_9632_aeb hdsp_9632_aeb_t; +#define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, hdsp_9632_aeb_t) #endif /* __SOUND_HDSP_H */ diff --git a/trunk/include/sound/hdspm.h b/trunk/include/sound/hdspm.h index c3c854d99c28..c34427ccd0b3 100644 --- a/trunk/include/sound/hdspm.h +++ b/trunk/include/sound/hdspm.h @@ -25,6 +25,8 @@ /* -------------------- IOCTL Peak/RMS Meters -------------------- */ +typedef struct _snd_hdspm_peak_rms hdspm_peak_rms_t; + /* peam rms level structure like we get from hardware maybe in future we can memory map it so I just copy it @@ -34,7 +36,7 @@ (i asume so from the code) */ -struct hdspm_peak_rms { +struct _snd_hdspm_peak_rms { unsigned int level_offset[1024]; @@ -56,16 +58,18 @@ struct hdspm_peak_rms { unsigned int xxx_rms_h[64]; /* not used */ }; -struct hdspm_peak_rms_ioctl { - struct hdspm_peak_rms *peak; +struct sndrv_hdspm_peak_rms_ioctl { + hdspm_peak_rms_t *peak; }; /* use indirect access due to the limit of ioctl bit size */ -#define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdspm_peak_rms_ioctl) +#define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct sndrv_hdspm_peak_rms_ioctl) /* ------------ CONFIG block IOCTL ---------------------- */ -struct hdspm_config_info { +typedef struct _snd_hdspm_config_info hdspm_config_info_t; + +struct _snd_hdspm_config_info { unsigned char pref_sync_ref; unsigned char wordclock_sync_check; unsigned char madi_sync_check; @@ -79,16 +83,18 @@ struct hdspm_config_info { unsigned int analog_out; }; -#define SNDRV_HDSPM_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdspm_config_info) +#define SNDRV_HDSPM_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, hdspm_config_info_t) /* get Soundcard Version */ -struct hdspm_version { +typedef struct _snd_hdspm_version hdspm_version_t; + +struct _snd_hdspm_version { unsigned short firmware_rev; }; -#define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdspm_version) +#define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x43, hdspm_version_t) /* ------------- get Matrix Mixer IOCTL --------------- */ @@ -102,27 +108,24 @@ struct hdspm_version { #define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS -struct hdspm_channelfader { +typedef struct _snd_hdspm_channelfader snd_hdspm_channelfader_t; + +struct _snd_hdspm_channelfader { unsigned int in[HDSPM_MIXER_CHANNELS]; unsigned int pb[HDSPM_MIXER_CHANNELS]; }; -struct hdspm_mixer { - struct hdspm_channelfader ch[HDSPM_MIXER_CHANNELS]; +typedef struct _snd_hdspm_mixer hdspm_mixer_t; + +struct _snd_hdspm_mixer { + snd_hdspm_channelfader_t ch[HDSPM_MIXER_CHANNELS]; }; -struct hdspm_mixer_ioctl { - struct hdspm_mixer *mixer; +struct sndrv_hdspm_mixer_ioctl { + hdspm_mixer_t *mixer; }; /* use indirect access due to the limit of ioctl bit size */ -#define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl) - -/* typedefs for compatibility to user-space */ -typedef struct hdspm_peak_rms hdspm_peak_rms_t; -typedef struct hdspm_config_info hdspm_config_info_t; -typedef struct hdspm_version hdspm_version_t; -typedef struct hdspm_channelfader snd_hdspm_channelfader_t; -typedef struct hdspm_mixer hdspm_mixer_t; +#define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct sndrv_hdspm_mixer_ioctl) #endif /* __SOUND_HDSPM_H */ diff --git a/trunk/include/sound/hwdep.h b/trunk/include/sound/hwdep.h index c679e5b31111..043876348fa1 100644 --- a/trunk/include/sound/hwdep.h +++ b/trunk/include/sound/hwdep.h @@ -25,25 +25,27 @@ #include #include -struct snd_hwdep; +typedef enum sndrv_hwdep_iface snd_hwdep_iface_t; +typedef struct sndrv_hwdep_info snd_hwdep_info_t; +typedef struct sndrv_hwdep_dsp_status snd_hwdep_dsp_status_t; +typedef struct sndrv_hwdep_dsp_image snd_hwdep_dsp_image_t; -struct snd_hwdep_ops { - long long (*llseek) (struct snd_hwdep *hw, struct file * file, long long offset, int orig); - long (*read) (struct snd_hwdep *hw, char __user *buf, long count, loff_t *offset); - long (*write) (struct snd_hwdep *hw, const char __user *buf, long count, loff_t *offset); - int (*open) (struct snd_hwdep * hw, struct file * file); - int (*release) (struct snd_hwdep *hw, struct file * file); - unsigned int (*poll) (struct snd_hwdep *hw, struct file * file, poll_table * wait); - int (*ioctl) (struct snd_hwdep *hw, struct file * file, unsigned int cmd, unsigned long arg); - int (*ioctl_compat) (struct snd_hwdep *hw, struct file * file, unsigned int cmd, unsigned long arg); - int (*mmap) (struct snd_hwdep *hw, struct file * file, struct vm_area_struct * vma); - int (*dsp_status) (struct snd_hwdep *hw, struct snd_hwdep_dsp_status *status); - int (*dsp_load) (struct snd_hwdep *hw, struct snd_hwdep_dsp_image *image); -}; +typedef struct _snd_hwdep_ops { + long long (*llseek) (snd_hwdep_t *hw, struct file * file, long long offset, int orig); + long (*read) (snd_hwdep_t * hw, char __user *buf, long count, loff_t *offset); + long (*write) (snd_hwdep_t * hw, const char __user *buf, long count, loff_t *offset); + int (*open) (snd_hwdep_t * hw, struct file * file); + int (*release) (snd_hwdep_t * hw, struct file * file); + unsigned int (*poll) (snd_hwdep_t * hw, struct file * file, poll_table * wait); + int (*ioctl) (snd_hwdep_t * hw, struct file * file, unsigned int cmd, unsigned long arg); + int (*ioctl_compat) (snd_hwdep_t * hw, struct file * file, unsigned int cmd, unsigned long arg); + int (*mmap) (snd_hwdep_t * hw, struct file * file, struct vm_area_struct * vma); + int (*dsp_status) (snd_hwdep_t * hw, snd_hwdep_dsp_status_t * status); + int (*dsp_load) (snd_hwdep_t * hw, snd_hwdep_dsp_image_t * image); +} snd_hwdep_ops_t; -struct snd_hwdep { - struct snd_card *card; - struct list_head list; +struct _snd_hwdep { + snd_card_t *card; int device; char id[32]; char name[80]; @@ -55,10 +57,10 @@ struct snd_hwdep { int ossreg; #endif - struct snd_hwdep_ops ops; + snd_hwdep_ops_t ops; wait_queue_head_t open_wait; void *private_data; - void (*private_free) (struct snd_hwdep *hwdep); + void (*private_free) (snd_hwdep_t *hwdep); struct semaphore open_mutex; int used; @@ -66,7 +68,6 @@ struct snd_hwdep { unsigned int exclusive: 1; }; -extern int snd_hwdep_new(struct snd_card *card, char *id, int device, - struct snd_hwdep **rhwdep); +extern int snd_hwdep_new(snd_card_t * card, char *id, int device, snd_hwdep_t ** rhwdep); #endif /* __SOUND_HWDEP_H */ diff --git a/trunk/include/sound/i2c.h b/trunk/include/sound/i2c.h index 81eb23ed761f..a665ddf9c146 100644 --- a/trunk/include/sound/i2c.h +++ b/trunk/include/sound/i2c.h @@ -21,84 +21,82 @@ * */ +typedef struct _snd_i2c_device snd_i2c_device_t; +typedef struct _snd_i2c_bus snd_i2c_bus_t; + #define SND_I2C_DEVICE_ADDRTEN (1<<0) /* 10-bit I2C address */ -struct snd_i2c_device { +struct _snd_i2c_device { struct list_head list; - struct snd_i2c_bus *bus; /* I2C bus */ + snd_i2c_bus_t *bus; /* I2C bus */ char name[32]; /* some useful device name */ unsigned short flags; /* device flags */ unsigned short addr; /* device address (might be 10-bit) */ unsigned long private_value; void *private_data; - void (*private_free)(struct snd_i2c_device *device); -}; - -#define snd_i2c_device(n) list_entry(n, struct snd_i2c_device, list) - -struct snd_i2c_bit_ops { - void (*start)(struct snd_i2c_bus *bus); /* transfer start */ - void (*stop)(struct snd_i2c_bus *bus); /* transfer stop */ - void (*direction)(struct snd_i2c_bus *bus, int clock, int data); /* set line direction (0 = write, 1 = read) */ - void (*setlines)(struct snd_i2c_bus *bus, int clock, int data); - int (*getclock)(struct snd_i2c_bus *bus); - int (*getdata)(struct snd_i2c_bus *bus, int ack); + void (*private_free)(snd_i2c_device_t *device); }; -struct snd_i2c_ops { - int (*sendbytes)(struct snd_i2c_device *device, unsigned char *bytes, int count); - int (*readbytes)(struct snd_i2c_device *device, unsigned char *bytes, int count); - int (*probeaddr)(struct snd_i2c_bus *bus, unsigned short addr); -}; - -struct snd_i2c_bus { - struct snd_card *card; /* card which I2C belongs to */ +#define snd_i2c_device(n) list_entry(n, snd_i2c_device_t, list) + +typedef struct _snd_i2c_bit_ops { + void (*start)(snd_i2c_bus_t *bus); /* transfer start */ + void (*stop)(snd_i2c_bus_t *bus); /* transfer stop */ + void (*direction)(snd_i2c_bus_t *bus, int clock, int data); /* set line direction (0 = write, 1 = read) */ + void (*setlines)(snd_i2c_bus_t *bus, int clock, int data); + int (*getclock)(snd_i2c_bus_t *bus); + int (*getdata)(snd_i2c_bus_t *bus, int ack); +} snd_i2c_bit_ops_t; + +typedef struct _snd_i2c_ops { + int (*sendbytes)(snd_i2c_device_t *device, unsigned char *bytes, int count); + int (*readbytes)(snd_i2c_device_t *device, unsigned char *bytes, int count); + int (*probeaddr)(snd_i2c_bus_t *bus, unsigned short addr); +} snd_i2c_ops_t; + +struct _snd_i2c_bus { + snd_card_t *card; /* card which I2C belongs to */ char name[32]; /* some useful label */ struct semaphore lock_mutex; - struct snd_i2c_bus *master; /* master bus when SCK/SCL is shared */ + snd_i2c_bus_t *master; /* master bus when SCK/SCL is shared */ struct list_head buses; /* master: slave buses sharing SCK/SCL, slave: link list */ struct list_head devices; /* attached devices to this bus */ union { - struct snd_i2c_bit_ops *bit; + snd_i2c_bit_ops_t *bit; void *ops; } hw_ops; /* lowlevel operations */ - struct snd_i2c_ops *ops; /* midlevel operations */ + snd_i2c_ops_t *ops; /* midlevel operations */ unsigned long private_value; void *private_data; - void (*private_free)(struct snd_i2c_bus *bus); + void (*private_free)(snd_i2c_bus_t *bus); }; -#define snd_i2c_slave_bus(n) list_entry(n, struct snd_i2c_bus, buses) +#define snd_i2c_slave_bus(n) list_entry(n, snd_i2c_bus_t, buses) -int snd_i2c_bus_create(struct snd_card *card, const char *name, - struct snd_i2c_bus *master, struct snd_i2c_bus **ri2c); -int snd_i2c_device_create(struct snd_i2c_bus *bus, const char *name, - unsigned char addr, struct snd_i2c_device **rdevice); -int snd_i2c_device_free(struct snd_i2c_device *device); +int snd_i2c_bus_create(snd_card_t *card, const char *name, snd_i2c_bus_t *master, snd_i2c_bus_t **ri2c); +int snd_i2c_device_create(snd_i2c_bus_t *bus, const char *name, unsigned char addr, snd_i2c_device_t **rdevice); +int snd_i2c_device_free(snd_i2c_device_t *device); -static inline void snd_i2c_lock(struct snd_i2c_bus *bus) -{ +static inline void snd_i2c_lock(snd_i2c_bus_t *bus) { if (bus->master) down(&bus->master->lock_mutex); else down(&bus->lock_mutex); } - -static inline void snd_i2c_unlock(struct snd_i2c_bus *bus) -{ +static inline void snd_i2c_unlock(snd_i2c_bus_t *bus) { if (bus->master) up(&bus->master->lock_mutex); else up(&bus->lock_mutex); } -int snd_i2c_sendbytes(struct snd_i2c_device *device, unsigned char *bytes, int count); -int snd_i2c_readbytes(struct snd_i2c_device *device, unsigned char *bytes, int count); -int snd_i2c_probeaddr(struct snd_i2c_bus *bus, unsigned short addr); +int snd_i2c_sendbytes(snd_i2c_device_t *device, unsigned char *bytes, int count); +int snd_i2c_readbytes(snd_i2c_device_t *device, unsigned char *bytes, int count); +int snd_i2c_probeaddr(snd_i2c_bus_t *bus, unsigned short addr); #endif /* __SOUND_I2C_H */ diff --git a/trunk/include/sound/info.h b/trunk/include/sound/info.h index 8ea5c7497c03..1d76bf3cb05e 100644 --- a/trunk/include/sound/info.h +++ b/trunk/include/sound/info.h @@ -34,6 +34,8 @@ struct snd_info_buffer { int error; /* error code */ }; +typedef struct snd_info_buffer snd_info_buffer_t; + #define SNDRV_INFO_CONTENT_TEXT 0 #define SNDRV_INFO_CONTENT_DATA 1 @@ -42,28 +44,28 @@ struct snd_info_entry; struct snd_info_entry_text { unsigned long read_size; unsigned long write_size; - void (*read) (struct snd_info_entry *entry, struct snd_info_buffer *buffer); - void (*write) (struct snd_info_entry *entry, struct snd_info_buffer *buffer); + void (*read) (snd_info_entry_t *entry, snd_info_buffer_t * buffer); + void (*write) (snd_info_entry_t *entry, snd_info_buffer_t * buffer); }; struct snd_info_entry_ops { - int (*open) (struct snd_info_entry *entry, + int (*open) (snd_info_entry_t *entry, unsigned short mode, void **file_private_data); - int (*release) (struct snd_info_entry * entry, + int (*release) (snd_info_entry_t * entry, unsigned short mode, void *file_private_data); - long (*read) (struct snd_info_entry *entry, void *file_private_data, + long (*read) (snd_info_entry_t *entry, void *file_private_data, struct file * file, char __user *buf, unsigned long count, unsigned long pos); - long (*write) (struct snd_info_entry *entry, void *file_private_data, + long (*write) (snd_info_entry_t *entry, void *file_private_data, struct file * file, const char __user *buf, unsigned long count, unsigned long pos); - long long (*llseek) (struct snd_info_entry *entry, void *file_private_data, + long long (*llseek) (snd_info_entry_t *entry, void *file_private_data, struct file * file, long long offset, int orig); - unsigned int (*poll) (struct snd_info_entry *entry, void *file_private_data, + unsigned int (*poll) (snd_info_entry_t *entry, void *file_private_data, struct file * file, poll_table * wait); - int (*ioctl) (struct snd_info_entry *entry, void *file_private_data, + int (*ioctl) (snd_info_entry_t *entry, void *file_private_data, struct file * file, unsigned int cmd, unsigned long arg); - int (*mmap) (struct snd_info_entry *entry, void *file_private_data, + int (*mmap) (snd_info_entry_t *entry, void *file_private_data, struct inode * inode, struct file * file, struct vm_area_struct * vma); }; @@ -78,18 +80,20 @@ struct snd_info_entry { struct snd_info_entry_text text; struct snd_info_entry_ops *ops; } c; - struct snd_info_entry *parent; - struct snd_card *card; + snd_info_entry_t *parent; + snd_card_t *card; struct module *module; void *private_data; - void (*private_free)(struct snd_info_entry *entry); + void (*private_free)(snd_info_entry_t *entry); struct proc_dir_entry *p; struct semaphore access; }; +extern int snd_info_check_reserved_words(const char *str); + #if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS) -int snd_info_minor_register(void); -int snd_info_minor_unregister(void); +extern int snd_info_minor_register(void); +extern int snd_info_minor_unregister(void); #else #define snd_info_minor_register() /* NOP */ #define snd_info_minor_unregister() /* NOP */ @@ -98,79 +102,72 @@ int snd_info_minor_unregister(void); #ifdef CONFIG_PROC_FS -extern struct snd_info_entry *snd_seq_root; +extern snd_info_entry_t *snd_seq_root; #ifdef CONFIG_SND_OSSEMUL -extern struct snd_info_entry *snd_oss_root; +extern snd_info_entry_t *snd_oss_root; #else #define snd_oss_root NULL #endif -int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...) __attribute__ ((format (printf, 2, 3))); +int snd_iprintf(snd_info_buffer_t * buffer, char *fmt,...) __attribute__ ((format (printf, 2, 3))); int snd_info_init(void); int snd_info_done(void); -int snd_info_get_line(struct snd_info_buffer * buffer, char *line, int len); +int snd_info_get_line(snd_info_buffer_t * buffer, char *line, int len); char *snd_info_get_str(char *dest, char *src, int len); -struct snd_info_entry *snd_info_create_module_entry(struct module * module, +snd_info_entry_t *snd_info_create_module_entry(struct module * module, const char *name, - struct snd_info_entry * parent); -struct snd_info_entry *snd_info_create_card_entry(struct snd_card * card, + snd_info_entry_t * parent); +snd_info_entry_t *snd_info_create_card_entry(snd_card_t * card, const char *name, - struct snd_info_entry * parent); -void snd_info_free_entry(struct snd_info_entry * entry); -int snd_info_store_text(struct snd_info_entry * entry); -int snd_info_restore_text(struct snd_info_entry * entry); + snd_info_entry_t * parent); +void snd_info_free_entry(snd_info_entry_t * entry); +int snd_info_store_text(snd_info_entry_t * entry); +int snd_info_restore_text(snd_info_entry_t * entry); -int snd_info_card_create(struct snd_card * card); -int snd_info_card_register(struct snd_card * card); -int snd_info_card_free(struct snd_card * card); -int snd_info_register(struct snd_info_entry * entry); -int snd_info_unregister(struct snd_info_entry * entry); +int snd_info_card_create(snd_card_t * card); +int snd_info_card_register(snd_card_t * card); +int snd_info_card_free(snd_card_t * card); +int snd_info_register(snd_info_entry_t * entry); +int snd_info_unregister(snd_info_entry_t * entry); /* for card drivers */ -int snd_card_proc_new(struct snd_card *card, const char *name, struct snd_info_entry **entryp); +int snd_card_proc_new(snd_card_t *card, const char *name, snd_info_entry_t **entryp); -static inline void snd_info_set_text_ops(struct snd_info_entry *entry, +static inline void snd_info_set_text_ops(snd_info_entry_t *entry, void *private_data, long read_size, - void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) + void (*read)(snd_info_entry_t *, snd_info_buffer_t *)) { entry->private_data = private_data; entry->c.text.read_size = read_size; entry->c.text.read = read; } -int snd_info_check_reserved_words(const char *str); #else #define snd_seq_root NULL #define snd_oss_root NULL -static inline int snd_iprintf(struct snd_info_buffer * buffer, char *fmt,...) { return 0; } +static inline int snd_iprintf(snd_info_buffer_t * buffer, char *fmt,...) { return 0; } static inline int snd_info_init(void) { return 0; } static inline int snd_info_done(void) { return 0; } -static inline int snd_info_get_line(struct snd_info_buffer * buffer, char *line, int len) { return 0; } +static inline int snd_info_get_line(snd_info_buffer_t * buffer, char *line, int len) { return 0; } static inline char *snd_info_get_str(char *dest, char *src, int len) { return NULL; } -static inline struct snd_info_entry *snd_info_create_module_entry(struct module * module, const char *name, struct snd_info_entry * parent) { return NULL; } -static inline struct snd_info_entry *snd_info_create_card_entry(struct snd_card * card, const char *name, struct snd_info_entry * parent) { return NULL; } -static inline void snd_info_free_entry(struct snd_info_entry * entry) { ; } - -static inline int snd_info_card_create(struct snd_card * card) { return 0; } -static inline int snd_info_card_register(struct snd_card * card) { return 0; } -static inline int snd_info_card_free(struct snd_card * card) { return 0; } -static inline int snd_info_register(struct snd_info_entry * entry) { return 0; } -static inline int snd_info_unregister(struct snd_info_entry * entry) { return 0; } - -static inline int snd_card_proc_new(struct snd_card *card, const char *name, - struct snd_info_entry **entryp) { return -EINVAL; } -static inline void snd_info_set_text_ops(struct snd_info_entry *entry __attribute__((unused)), - void *private_data, - long read_size, - void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) {} +static inline snd_info_entry_t *snd_info_create_module_entry(struct module * module, const char *name, snd_info_entry_t * parent) { return NULL; } +static inline snd_info_entry_t *snd_info_create_card_entry(snd_card_t * card, const char *name, snd_info_entry_t * parent) { return NULL; } +static inline void snd_info_free_entry(snd_info_entry_t * entry) { ; } + +static inline int snd_info_card_create(snd_card_t * card) { return 0; } +static inline int snd_info_card_register(snd_card_t * card) { return 0; } +static inline int snd_info_card_free(snd_card_t * card) { return 0; } +static inline int snd_info_register(snd_info_entry_t * entry) { return 0; } +static inline int snd_info_unregister(snd_info_entry_t * entry) { return 0; } -static inline int snd_info_check_reserved_words(const char *str) { return 1; } +#define snd_card_proc_new(card,name,entryp) 0 /* always success */ +#define snd_info_set_text_ops(entry,private_data,read_size,read) /*NOP*/ #endif @@ -188,7 +185,7 @@ static inline int snd_info_check_reserved_words(const char *str) { return 1; } #define SNDRV_OSS_INFO_DEV_COUNT 6 -int snd_oss_info_register(int dev, int num, char *string); +extern int snd_oss_info_register(int dev, int num, char *string); #define snd_oss_info_unregister(dev, num) snd_oss_info_register(dev, num, NULL) #endif /* CONFIG_SND_OSSEMUL && CONFIG_PROC_FS */ diff --git a/trunk/include/sound/initval.h b/trunk/include/sound/initval.h index d29e3d31d149..2bf1508825a4 100644 --- a/trunk/include/sound/initval.h +++ b/trunk/include/sound/initval.h @@ -50,6 +50,20 @@ #define SNDRV_DEFAULT_DMA_SIZE { [0 ... (SNDRV_CARDS-1)] = SNDRV_AUTO_DMA_SIZE } #define SNDRV_DEFAULT_PTR SNDRV_DEFAULT_STR +#ifdef SNDRV_LEGACY_AUTO_PROBE +static int snd_legacy_auto_probe(unsigned long *ports, int (*probe)(unsigned long port)) +{ + int result = 0; /* number of detected cards */ + + while ((signed long)*ports != -1) { + if (probe(*ports) >= 0) + result++; + ports++; + } + return result; +} +#endif + #ifdef SNDRV_LEGACY_FIND_FREE_IRQ #include diff --git a/trunk/include/sound/minors.h b/trunk/include/sound/minors.h index 46bcd2023ed8..a17b5c9961bb 100644 --- a/trunk/include/sound/minors.h +++ b/trunk/include/sound/minors.h @@ -26,20 +26,18 @@ #define SNDRV_MINOR_DEVICE(minor) ((minor) & 0x001f) #define SNDRV_MINOR(card, dev) (((card) << 5) | (dev)) -/* these minors can still be used for autoloading devices (/dev/aload*) */ -#define SNDRV_MINOR_CONTROL 0 /* 0 */ +#define SNDRV_MINOR_CONTROL 0 /* 0 - 0 */ #define SNDRV_MINOR_GLOBAL 1 /* 1 */ #define SNDRV_MINOR_SEQUENCER (SNDRV_MINOR_GLOBAL + 0 * 32) #define SNDRV_MINOR_TIMER (SNDRV_MINOR_GLOBAL + 1 * 32) - -#ifndef CONFIG_SND_DYNAMIC_MINORS - /* 2 - 3 (reserved) */ #define SNDRV_MINOR_HWDEP 4 /* 4 - 7 */ +#define SNDRV_MINOR_HWDEPS 4 #define SNDRV_MINOR_RAWMIDI 8 /* 8 - 15 */ +#define SNDRV_MINOR_RAWMIDIS 8 #define SNDRV_MINOR_PCM_PLAYBACK 16 /* 16 - 23 */ #define SNDRV_MINOR_PCM_CAPTURE 24 /* 24 - 31 */ +#define SNDRV_MINOR_PCMS 8 -/* same as first respective minor number to make minor allocation easier */ #define SNDRV_DEVICE_TYPE_CONTROL SNDRV_MINOR_CONTROL #define SNDRV_DEVICE_TYPE_HWDEP SNDRV_MINOR_HWDEP #define SNDRV_DEVICE_TYPE_RAWMIDI SNDRV_MINOR_RAWMIDI @@ -48,25 +46,6 @@ #define SNDRV_DEVICE_TYPE_SEQUENCER SNDRV_MINOR_SEQUENCER #define SNDRV_DEVICE_TYPE_TIMER SNDRV_MINOR_TIMER -#else /* CONFIG_SND_DYNAMIC_MINORS */ - -enum { - SNDRV_DEVICE_TYPE_CONTROL, - SNDRV_DEVICE_TYPE_SEQUENCER, - SNDRV_DEVICE_TYPE_TIMER, - SNDRV_DEVICE_TYPE_HWDEP, - SNDRV_DEVICE_TYPE_RAWMIDI, - SNDRV_DEVICE_TYPE_PCM_PLAYBACK, - SNDRV_DEVICE_TYPE_PCM_CAPTURE, -}; - -#endif /* CONFIG_SND_DYNAMIC_MINORS */ - -#define SNDRV_MINOR_HWDEPS 4 -#define SNDRV_MINOR_RAWMIDIS 8 -#define SNDRV_MINOR_PCMS 8 - - #ifdef CONFIG_SND_OSSEMUL #define SNDRV_MINOR_OSS_DEVICES 16 diff --git a/trunk/include/sound/mixer_oss.h b/trunk/include/sound/mixer_oss.h index ca5b4822b62c..ed75b2fb00ab 100644 --- a/trunk/include/sound/mixer_oss.h +++ b/trunk/include/sound/mixer_oss.h @@ -24,53 +24,51 @@ #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) -#define SNDRV_OSS_MAX_MIXERS 32 +typedef struct _snd_oss_mixer_slot snd_mixer_oss_slot_t; +typedef struct _snd_oss_file snd_mixer_oss_file_t; + +typedef int (*snd_mixer_oss_get_volume_t)(snd_mixer_oss_file_t *fmixer, snd_mixer_oss_slot_t *chn, int *left, int *right); +typedef int (*snd_mixer_oss_put_volume_t)(snd_mixer_oss_file_t *fmixer, snd_mixer_oss_slot_t *chn, int left, int right); +typedef int (*snd_mixer_oss_get_recsrc_t)(snd_mixer_oss_file_t *fmixer, snd_mixer_oss_slot_t *chn, int *active); +typedef int (*snd_mixer_oss_put_recsrc_t)(snd_mixer_oss_file_t *fmixer, snd_mixer_oss_slot_t *chn, int active); +typedef int (*snd_mixer_oss_get_recsrce_t)(snd_mixer_oss_file_t *fmixer, unsigned int *active_index); +typedef int (*snd_mixer_oss_put_recsrce_t)(snd_mixer_oss_file_t *fmixer, unsigned int active_index); -struct snd_mixer_oss_file; +#define SNDRV_OSS_MAX_MIXERS 32 -struct snd_mixer_oss_slot { +struct _snd_oss_mixer_slot { int number; unsigned int stereo: 1; - int (*get_volume)(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *chn, - int *left, int *right); - int (*put_volume)(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *chn, - int left, int right); - int (*get_recsrc)(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *chn, - int *active); - int (*put_recsrc)(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *chn, - int active); + snd_mixer_oss_get_volume_t get_volume; + snd_mixer_oss_put_volume_t put_volume; + snd_mixer_oss_get_recsrc_t get_recsrc; + snd_mixer_oss_put_recsrc_t put_recsrc; unsigned long private_value; void *private_data; - void (*private_free)(struct snd_mixer_oss_slot *slot); + void (*private_free)(snd_mixer_oss_slot_t *slot); int volume[2]; }; -struct snd_mixer_oss { - struct snd_card *card; +struct _snd_oss_mixer { + snd_card_t *card; char id[16]; char name[32]; - struct snd_mixer_oss_slot slots[SNDRV_OSS_MAX_MIXERS]; /* OSS mixer slots */ + snd_mixer_oss_slot_t slots[SNDRV_OSS_MAX_MIXERS]; /* OSS mixer slots */ unsigned int mask_recsrc; /* exclusive recsrc mask */ - int (*get_recsrc)(struct snd_mixer_oss_file *fmixer, - unsigned int *active_index); - int (*put_recsrc)(struct snd_mixer_oss_file *fmixer, - unsigned int active_index); + snd_mixer_oss_get_recsrce_t get_recsrc; + snd_mixer_oss_put_recsrce_t put_recsrc; void *private_data_recsrc; - void (*private_free_recsrc)(struct snd_mixer_oss *mixer); + void (*private_free_recsrc)(snd_mixer_oss_t *mixer); struct semaphore reg_mutex; - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; int oss_dev_alloc; /* --- */ int oss_recsrc; }; -struct snd_mixer_oss_file { - struct snd_card *card; - struct snd_mixer_oss *mixer; +struct _snd_oss_file { + snd_card_t *card; + snd_mixer_oss_t *mixer; }; #endif /* CONFIG_SND_MIXER_OSS */ diff --git a/trunk/include/sound/mpu401.h b/trunk/include/sound/mpu401.h index 8e97ace78f16..ae39e38bf996 100644 --- a/trunk/include/sound/mpu401.h +++ b/trunk/include/sound/mpu401.h @@ -58,8 +58,10 @@ #define MPU401_MODE_INPUT_TIMER (1<<0) #define MPU401_MODE_OUTPUT_TIMER (1<<1) -struct snd_mpu401 { - struct snd_rawmidi *rmidi; +typedef struct _snd_mpu401 mpu401_t; + +struct _snd_mpu401 { + snd_rawmidi_t *rmidi; unsigned short hardware; /* MPU401_HW_XXXX */ unsigned long port; /* base port of MPU-401 chip */ @@ -71,14 +73,14 @@ struct snd_mpu401 { unsigned long mode; /* MPU401_MODE_XXXX */ int timer_invoked; - int (*open_input) (struct snd_mpu401 * mpu); - void (*close_input) (struct snd_mpu401 * mpu); - int (*open_output) (struct snd_mpu401 * mpu); - void (*close_output) (struct snd_mpu401 * mpu); + int (*open_input) (mpu401_t * mpu); + void (*close_input) (mpu401_t * mpu); + int (*open_output) (mpu401_t * mpu); + void (*close_output) (mpu401_t * mpu); void *private_data; - struct snd_rawmidi_substream *substream_input; - struct snd_rawmidi_substream *substream_output; + snd_rawmidi_substream_t *substream_input; + snd_rawmidi_substream_t *substream_output; spinlock_t input_lock; spinlock_t output_lock; @@ -86,8 +88,8 @@ struct snd_mpu401 { struct timer_list timer; - void (*write) (struct snd_mpu401 * mpu, unsigned char data, unsigned long addr); - unsigned char (*read) (struct snd_mpu401 *mpu, unsigned long addr); + void (*write) (mpu401_t * mpu, unsigned char data, unsigned long addr); + unsigned char (*read) (mpu401_t * mpu, unsigned long addr); }; /* I/O ports */ @@ -101,13 +103,13 @@ struct snd_mpu401 { irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *regs); -int snd_mpu401_uart_new(struct snd_card *card, +int snd_mpu401_uart_new(snd_card_t * card, int device, unsigned short hardware, unsigned long port, int integrated, int irq, int irq_flags, - struct snd_rawmidi ** rrawmidi); + snd_rawmidi_t ** rrawmidi); #endif /* __SOUND_MPU401_H */ diff --git a/trunk/include/sound/opl3.h b/trunk/include/sound/opl3.h index 83392641cb47..19f657d4fc06 100644 --- a/trunk/include/sound/opl3.h +++ b/trunk/include/sound/opl3.h @@ -237,12 +237,12 @@ #define MAX_OPL2_VOICES 9 #define MAX_OPL3_VOICES 18 -struct snd_opl3; +typedef struct snd_opl3 opl3_t; /* * A structure to keep track of each hardware voice */ -struct snd_opl3_voice { +typedef struct snd_opl3_voice { int state; /* status */ #define SNDRV_OPL3_ST_OFF 0 /* Not playing */ #define SNDRV_OPL3_ST_ON_2OP 1 /* 2op voice is allocated */ @@ -257,8 +257,8 @@ struct snd_opl3_voice { unsigned char keyon_reg; /* KON register shadow */ - struct snd_midi_channel *chan; /* Midi channel for this note */ -}; + snd_midi_channel_t *chan; /* Midi channel for this note */ +} snd_opl3_voice_t; struct snd_opl3 { unsigned long l_port; @@ -267,18 +267,18 @@ struct snd_opl3 { struct resource *res_r_port; unsigned short hardware; /* hardware access */ - void (*command) (struct snd_opl3 * opl3, unsigned short cmd, unsigned char val); + void (*command) (opl3_t * opl3, unsigned short cmd, unsigned char val); unsigned short timer_enable; int seq_dev_num; /* sequencer device number */ - struct snd_timer *timer1; - struct snd_timer *timer2; + snd_timer_t *timer1; + snd_timer_t *timer2; spinlock_t timer_lock; void *private_data; - void (*private_free)(struct snd_opl3 *); + void (*private_free)(opl3_t *); spinlock_t reg_lock; - struct snd_card *card; /* The card that this belongs to */ + snd_card_t *card; /* The card that this belongs to */ int used; /* usage flag - exclusive */ unsigned char fm_mode; /* OPL mode, see SNDRV_DM_FM_MODE_XXX */ unsigned char rhythm; /* percussion mode flag */ @@ -289,18 +289,18 @@ struct snd_opl3 { int synth_mode; /* synth mode */ int seq_client; - struct snd_seq_device *seq_dev; /* sequencer device */ - struct snd_midi_channel_set * chset; + snd_seq_device_t *seq_dev; /* sequencer device */ + snd_midi_channel_set_t * chset; #ifdef CONFIG_SND_SEQUENCER_OSS - struct snd_seq_device *oss_seq_dev; /* OSS sequencer device */ - struct snd_midi_channel_set * oss_chset; + snd_seq_device_t *oss_seq_dev; /* OSS sequencer device */ + snd_midi_channel_set_t * oss_chset; #endif - struct snd_seq_kinstr_ops fm_ops; - struct snd_seq_kinstr_list *ilist; + snd_seq_kinstr_ops_t fm_ops; + snd_seq_kinstr_list_t *ilist; - struct snd_opl3_voice voices[MAX_OPL3_VOICES]; /* Voices (OPL3 'channel') */ + snd_opl3_voice_t voices[MAX_OPL3_VOICES]; /* Voices (OPL3 'channel') */ int use_time; /* allocation counter */ unsigned short connection_reg; /* connection reg shadow */ @@ -316,25 +316,24 @@ struct snd_opl3 { }; /* opl3.c */ -void snd_opl3_interrupt(struct snd_hwdep * hw); -int snd_opl3_new(struct snd_card *card, unsigned short hardware, - struct snd_opl3 **ropl3); -int snd_opl3_init(struct snd_opl3 *opl3); -int snd_opl3_create(struct snd_card *card, +void snd_opl3_interrupt(snd_hwdep_t * hw); +int snd_opl3_new(snd_card_t *card, unsigned short hardware, opl3_t **ropl3); +int snd_opl3_init(opl3_t *opl3); +int snd_opl3_create(snd_card_t * card, unsigned long l_port, unsigned long r_port, unsigned short hardware, int integrated, - struct snd_opl3 ** opl3); -int snd_opl3_timer_new(struct snd_opl3 * opl3, int timer1_dev, int timer2_dev); -int snd_opl3_hwdep_new(struct snd_opl3 * opl3, int device, int seq_device, - struct snd_hwdep ** rhwdep); + opl3_t ** opl3); +int snd_opl3_timer_new(opl3_t * opl3, int timer1_dev, int timer2_dev); +int snd_opl3_hwdep_new(opl3_t * opl3, int device, int seq_device, + snd_hwdep_t ** rhwdep); /* opl3_synth */ -int snd_opl3_open(struct snd_hwdep * hw, struct file *file); -int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file, +int snd_opl3_open(snd_hwdep_t * hw, struct file *file); +int snd_opl3_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg); -int snd_opl3_release(struct snd_hwdep * hw, struct file *file); +int snd_opl3_release(snd_hwdep_t * hw, struct file *file); -void snd_opl3_reset(struct snd_opl3 * opl3); +void snd_opl3_reset(opl3_t * opl3); #endif /* __SOUND_OPL3_H */ diff --git a/trunk/include/sound/opl4.h b/trunk/include/sound/opl4.h index 60ae8454b3ce..20c04428b139 100644 --- a/trunk/include/sound/opl4.h +++ b/trunk/include/sound/opl4.h @@ -22,11 +22,11 @@ #include -struct snd_opl4; +typedef struct opl4 opl4_t; -extern int snd_opl4_create(struct snd_card *card, +extern int snd_opl4_create(snd_card_t *card, unsigned long fm_port, unsigned long pcm_port, int seq_device, - struct snd_opl3 **opl3, struct snd_opl4 **opl4); + opl3_t **opl3, opl4_t **opl4); #endif /* __SOUND_OPL4_H */ diff --git a/trunk/include/sound/pcm-indirect.h b/trunk/include/sound/pcm-indirect.h index 7003d7702e26..31fa7a54508a 100644 --- a/trunk/include/sound/pcm-indirect.h +++ b/trunk/include/sound/pcm-indirect.h @@ -24,7 +24,7 @@ #include -struct snd_pcm_indirect { +typedef struct sndrv_pcm_indirect { unsigned int hw_buffer_size; /* Byte size of hardware buffer */ unsigned int hw_queue_size; /* Max queue size of hw buffer (0 = buffer size) */ unsigned int hw_data; /* Offset to next dst (or src) in hw ring buffer */ @@ -35,20 +35,20 @@ struct snd_pcm_indirect { unsigned int sw_io; /* Current software pointer in bytes */ int sw_ready; /* Bytes ready to be transferred to/from hw */ snd_pcm_uframes_t appl_ptr; /* Last seen appl_ptr */ -}; +} snd_pcm_indirect_t; -typedef void (*snd_pcm_indirect_copy_t)(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, size_t bytes); +typedef void (*snd_pcm_indirect_copy_t)(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, size_t bytes); /* * helper function for playback ack callback */ static inline void -snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, +snd_pcm_indirect_playback_transfer(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, snd_pcm_indirect_copy_t copy) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr; snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr; int qsize; @@ -89,8 +89,8 @@ snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream, * ptr = current byte pointer */ static inline snd_pcm_uframes_t -snd_pcm_indirect_playback_pointer(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, unsigned int ptr) +snd_pcm_indirect_playback_pointer(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, unsigned int ptr) { int bytes = ptr - rec->hw_io; if (bytes < 0) @@ -110,11 +110,11 @@ snd_pcm_indirect_playback_pointer(struct snd_pcm_substream *substream, * helper function for capture ack callback */ static inline void -snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, +snd_pcm_indirect_capture_transfer(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, snd_pcm_indirect_copy_t copy) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr; snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr; @@ -154,8 +154,8 @@ snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream, * ptr = current byte pointer */ static inline snd_pcm_uframes_t -snd_pcm_indirect_capture_pointer(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, unsigned int ptr) +snd_pcm_indirect_capture_pointer(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, unsigned int ptr) { int qsize; int bytes = ptr - rec->hw_io; diff --git a/trunk/include/sound/pcm.h b/trunk/include/sound/pcm.h index 314268a11048..acc4fa9d5abe 100644 --- a/trunk/include/sound/pcm.h +++ b/trunk/include/sound/pcm.h @@ -28,9 +28,36 @@ #include #include +typedef sndrv_pcm_uframes_t snd_pcm_uframes_t; +typedef sndrv_pcm_sframes_t snd_pcm_sframes_t; +typedef enum sndrv_pcm_class snd_pcm_class_t; +typedef enum sndrv_pcm_subclass snd_pcm_subclass_t; +typedef enum sndrv_pcm_stream snd_pcm_stream_t; +typedef enum sndrv_pcm_access snd_pcm_access_t; +typedef enum sndrv_pcm_format snd_pcm_format_t; +typedef enum sndrv_pcm_subformat snd_pcm_subformat_t; +typedef enum sndrv_pcm_state snd_pcm_state_t; +typedef union sndrv_pcm_sync_id snd_pcm_sync_id_t; +typedef struct sndrv_pcm_info snd_pcm_info_t; +typedef enum sndrv_pcm_hw_param snd_pcm_hw_param_t; +typedef struct sndrv_pcm_hw_params snd_pcm_hw_params_t; +typedef enum sndrv_pcm_start snd_pcm_start_t; +typedef enum sndrv_pcm_xrun snd_pcm_xrun_t; +typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t; +typedef struct sndrv_pcm_sw_params snd_pcm_sw_params_t; +typedef struct sndrv_pcm_channel_info snd_pcm_channel_info_t; +typedef struct sndrv_pcm_status snd_pcm_status_t; +typedef struct sndrv_pcm_mmap_status snd_pcm_mmap_status_t; +typedef struct sndrv_pcm_mmap_control snd_pcm_mmap_control_t; +typedef struct sndrv_mask snd_mask_t; +typedef struct snd_sg_buf snd_pcm_sgbuf_t; + #define snd_pcm_substream_chip(substream) ((substream)->private_data) #define snd_pcm_chip(pcm) ((pcm)->private_data) +typedef struct _snd_pcm_file snd_pcm_file_t; +typedef struct _snd_pcm_runtime snd_pcm_runtime_t; + #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) #include "pcm_oss.h" #endif @@ -39,7 +66,7 @@ * Hardware (lowlevel) section */ -struct snd_pcm_hardware { +typedef struct _snd_pcm_hardware { unsigned int info; /* SNDRV_PCM_INFO_* */ u64 formats; /* SNDRV_PCM_FMTBIT_* */ unsigned int rates; /* SNDRV_PCM_RATE_* */ @@ -53,29 +80,26 @@ struct snd_pcm_hardware { unsigned int periods_min; /* min # of periods */ unsigned int periods_max; /* max # of periods */ size_t fifo_size; /* fifo size in bytes */ -}; +} snd_pcm_hardware_t; -struct snd_pcm_ops { - int (*open)(struct snd_pcm_substream *substream); - int (*close)(struct snd_pcm_substream *substream); - int (*ioctl)(struct snd_pcm_substream * substream, +typedef struct _snd_pcm_ops { + int (*open)(snd_pcm_substream_t *substream); + int (*close)(snd_pcm_substream_t *substream); + int (*ioctl)(snd_pcm_substream_t * substream, unsigned int cmd, void *arg); - int (*hw_params)(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params); - int (*hw_free)(struct snd_pcm_substream *substream); - int (*prepare)(struct snd_pcm_substream *substream); - int (*trigger)(struct snd_pcm_substream *substream, int cmd); - snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream); - int (*copy)(struct snd_pcm_substream *substream, int channel, - snd_pcm_uframes_t pos, + int (*hw_params)(snd_pcm_substream_t * substream, snd_pcm_hw_params_t * params); + int (*hw_free)(snd_pcm_substream_t *substream); + int (*prepare)(snd_pcm_substream_t * substream); + int (*trigger)(snd_pcm_substream_t * substream, int cmd); + snd_pcm_uframes_t (*pointer)(snd_pcm_substream_t * substream); + int (*copy)(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, void __user *buf, snd_pcm_uframes_t count); - int (*silence)(struct snd_pcm_substream *substream, int channel, + int (*silence)(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count); - struct page *(*page)(struct snd_pcm_substream *substream, - unsigned long offset); - int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma); - int (*ack)(struct snd_pcm_substream *substream); -}; + struct page *(*page)(snd_pcm_substream_t *substream, unsigned long offset); + int (*mmap)(snd_pcm_substream_t *substream, struct vm_area_struct *vma); + int (*ack)(snd_pcm_substream_t *substream); +} snd_pcm_ops_t; /* * @@ -188,16 +212,17 @@ struct snd_pcm_ops { #define SNDRV_PCM_FMTBIT_IEC958_SUBFRAME SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE #endif -struct snd_pcm_file { - struct snd_pcm_substream *substream; - struct snd_pcm_file *next; +struct _snd_pcm_file { + snd_pcm_substream_t * substream; + struct _snd_pcm_file * next; }; -struct snd_pcm_hw_rule; -typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule); +typedef struct _snd_pcm_hw_rule snd_pcm_hw_rule_t; -struct snd_pcm_hw_rule { +typedef int (*snd_pcm_hw_rule_func_t)(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule); + +struct _snd_pcm_hw_rule { unsigned int cond; snd_pcm_hw_rule_func_t func; int var; @@ -205,57 +230,57 @@ struct snd_pcm_hw_rule { void *private; }; -struct snd_pcm_hw_constraints { - struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - +typedef struct _snd_pcm_hw_constraints { + snd_mask_t masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; - struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - + snd_interval_t intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; unsigned int rules_num; unsigned int rules_all; - struct snd_pcm_hw_rule *rules; -}; + snd_pcm_hw_rule_t *rules; +} snd_pcm_hw_constraints_t; -static inline struct snd_mask *constrs_mask(struct snd_pcm_hw_constraints *constrs, - snd_pcm_hw_param_t var) +static inline snd_mask_t *constrs_mask(snd_pcm_hw_constraints_t *constrs, + snd_pcm_hw_param_t var) { return &constrs->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; } -static inline struct snd_interval *constrs_interval(struct snd_pcm_hw_constraints *constrs, - snd_pcm_hw_param_t var) +static inline snd_interval_t *constrs_interval(snd_pcm_hw_constraints_t *constrs, + snd_pcm_hw_param_t var) { return &constrs->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; } -struct snd_ratnum { +typedef struct { unsigned int num; unsigned int den_min, den_max, den_step; -}; +} ratnum_t; -struct snd_ratden { +typedef struct { unsigned int num_min, num_max, num_step; unsigned int den; -}; +} ratden_t; -struct snd_pcm_hw_constraint_ratnums { +typedef struct { int nrats; - struct snd_ratnum *rats; -}; + ratnum_t *rats; +} snd_pcm_hw_constraint_ratnums_t; -struct snd_pcm_hw_constraint_ratdens { +typedef struct { int nrats; - struct snd_ratden *rats; -}; + ratden_t *rats; +} snd_pcm_hw_constraint_ratdens_t; -struct snd_pcm_hw_constraint_list { +typedef struct { unsigned int count; unsigned int *list; unsigned int mask; -}; +} snd_pcm_hw_constraint_list_t; -struct snd_pcm_runtime { +struct _snd_pcm_runtime { /* -- Status -- */ - struct snd_pcm_substream *trigger_master; + snd_pcm_substream_t *trigger_master; struct timespec trigger_tstamp; /* trigger timestamp */ int overrange; snd_pcm_uframes_t avail_max; @@ -281,7 +306,7 @@ struct snd_pcm_runtime { unsigned int rate_den; /* -- SW params -- */ - int tstamp_mode; /* mmap timestamp is updated */ + snd_pcm_tstamp_t tstamp_mode; /* mmap timestamp is updated */ unsigned int period_step; unsigned int sleep_min; /* min ticks to sleep */ snd_pcm_uframes_t xfer_align; /* xfer size need to be a multiple */ @@ -295,11 +320,11 @@ struct snd_pcm_runtime { snd_pcm_uframes_t silence_start; /* starting pointer to silence area */ snd_pcm_uframes_t silence_filled; /* size filled with silence */ - union snd_pcm_sync_id sync; /* hardware synchronization ID */ + snd_pcm_sync_id_t sync; /* hardware synchronization ID */ /* -- mmap -- */ - volatile struct snd_pcm_mmap_status *status; - volatile struct snd_pcm_mmap_control *control; + volatile snd_pcm_mmap_status_t *status; + volatile snd_pcm_mmap_control_t *control; atomic_t mmap_count; /* -- locking / scheduling -- */ @@ -309,15 +334,15 @@ struct snd_pcm_runtime { /* -- private section -- */ void *private_data; - void (*private_free)(struct snd_pcm_runtime *runtime); + void (*private_free)(snd_pcm_runtime_t *runtime); /* -- hardware description -- */ - struct snd_pcm_hardware hw; - struct snd_pcm_hw_constraints hw_constraints; + snd_pcm_hardware_t hw; + snd_pcm_hw_constraints_t hw_constraints; /* -- interrupt callbacks -- */ - void (*transfer_ack_begin)(struct snd_pcm_substream *substream); - void (*transfer_ack_end)(struct snd_pcm_substream *substream); + void (*transfer_ack_begin)(snd_pcm_substream_t *substream); + void (*transfer_ack_end)(snd_pcm_substream_t *substream); /* -- timer -- */ unsigned int timer_resolution; /* timer resolution */ @@ -331,19 +356,19 @@ struct snd_pcm_runtime { #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) /* -- OSS things -- */ - struct snd_pcm_oss_runtime oss; + snd_pcm_oss_runtime_t oss; #endif }; -struct snd_pcm_group { /* keep linked substreams */ +typedef struct _snd_pcm_group { /* keep linked substreams */ spinlock_t lock; struct list_head substreams; int count; -}; +} snd_pcm_group_t; -struct snd_pcm_substream { - struct snd_pcm *pcm; - struct snd_pcm_str *pstr; +struct _snd_pcm_substream { + snd_pcm_t *pcm; + snd_pcm_str_t *pstr; void *private_data; /* copied from pcm->private_data */ int number; char name[32]; /* substream name */ @@ -353,32 +378,32 @@ struct snd_pcm_substream { unsigned int dma_buf_id; size_t dma_max; /* -- hardware operations -- */ - struct snd_pcm_ops *ops; + snd_pcm_ops_t *ops; /* -- runtime information -- */ - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; /* -- timer section -- */ - struct snd_timer *timer; /* timer */ + snd_timer_t *timer; /* timer */ unsigned timer_running: 1; /* time is running */ spinlock_t timer_lock; /* -- next substream -- */ - struct snd_pcm_substream *next; + snd_pcm_substream_t *next; /* -- linked substreams -- */ struct list_head link_list; /* linked list member */ - struct snd_pcm_group self_group; /* fake group for non linked substream (with substream lock inside) */ - struct snd_pcm_group *group; /* pointer to current group */ + snd_pcm_group_t self_group; /* fake group for non linked substream (with substream lock inside) */ + snd_pcm_group_t *group; /* pointer to current group */ /* -- assigned files -- */ - struct snd_pcm_file *file; + snd_pcm_file_t *file; struct file *ffile; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) /* -- OSS things -- */ - struct snd_pcm_oss_substream oss; + snd_pcm_oss_substream_t oss; #endif - struct snd_info_entry *proc_root; - struct snd_info_entry *proc_info_entry; - struct snd_info_entry *proc_hw_params_entry; - struct snd_info_entry *proc_sw_params_entry; - struct snd_info_entry *proc_status_entry; - struct snd_info_entry *proc_prealloc_entry; + snd_info_entry_t *proc_root; + snd_info_entry_t *proc_info_entry; + snd_info_entry_t *proc_hw_params_entry; + snd_info_entry_t *proc_sw_params_entry; + snd_info_entry_t *proc_status_entry; + snd_info_entry_t *proc_prealloc_entry; /* misc flags */ unsigned int no_mmap_ctrl: 1; }; @@ -390,64 +415,65 @@ struct snd_pcm_substream { #endif -struct snd_pcm_str { +struct _snd_pcm_str { int stream; /* stream (direction) */ - struct snd_pcm *pcm; + snd_pcm_t *pcm; /* -- substreams -- */ unsigned int substream_count; unsigned int substream_opened; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) /* -- OSS things -- */ - struct snd_pcm_oss_stream oss; + snd_pcm_oss_stream_t oss; #endif - struct snd_pcm_file *files; - struct snd_info_entry *proc_root; - struct snd_info_entry *proc_info_entry; + snd_pcm_file_t *files; + snd_minor_t *reg; + snd_info_entry_t *proc_root; + snd_info_entry_t *proc_info_entry; #ifdef CONFIG_SND_DEBUG unsigned int xrun_debug; /* 0 = disabled, 1 = verbose, 2 = stacktrace */ - struct snd_info_entry *proc_xrun_debug_entry; + snd_info_entry_t *proc_xrun_debug_entry; #endif }; -struct snd_pcm { - struct snd_card *card; - struct list_head list; +struct _snd_pcm { + snd_card_t *card; unsigned int device; /* device number */ unsigned int info_flags; unsigned short dev_class; unsigned short dev_subclass; char id[64]; char name[80]; - struct snd_pcm_str streams[2]; + snd_pcm_str_t streams[2]; struct semaphore open_mutex; wait_queue_head_t open_wait; void *private_data; - void (*private_free) (struct snd_pcm *pcm); + void (*private_free) (snd_pcm_t *pcm); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - struct snd_pcm_oss oss; + snd_pcm_oss_t oss; #endif }; -struct snd_pcm_notify { - int (*n_register) (struct snd_pcm * pcm); - int (*n_disconnect) (struct snd_pcm * pcm); - int (*n_unregister) (struct snd_pcm * pcm); +typedef struct _snd_pcm_notify { + int (*n_register) (snd_pcm_t * pcm); + int (*n_disconnect) (snd_pcm_t * pcm); + int (*n_unregister) (snd_pcm_t * pcm); struct list_head list; -}; +} snd_pcm_notify_t; /* * Registering */ -extern struct file_operations snd_pcm_f_ops[2]; +extern snd_pcm_t *snd_pcm_devices[]; +extern snd_minor_t snd_pcm_reg[2]; -int snd_pcm_new(struct snd_card *card, char *id, int device, +int snd_pcm_new(snd_card_t * card, char *id, int device, int playback_count, int capture_count, - struct snd_pcm **rpcm); -int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count); + snd_pcm_t **rpcm); +int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count); -int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree); +int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree); /* * Native I/O @@ -455,26 +481,24 @@ int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree); extern rwlock_t snd_pcm_link_rwlock; -int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info); -int snd_pcm_info_user(struct snd_pcm_substream *substream, - struct snd_pcm_info __user *info); -int snd_pcm_status(struct snd_pcm_substream *substream, - struct snd_pcm_status *status); -int snd_pcm_prepare(struct snd_pcm_substream *substream); -int snd_pcm_start(struct snd_pcm_substream *substream); -int snd_pcm_stop(struct snd_pcm_substream *substream, int status); -int snd_pcm_drain_done(struct snd_pcm_substream *substream); +int snd_pcm_info(snd_pcm_substream_t * substream, snd_pcm_info_t *info); +int snd_pcm_info_user(snd_pcm_substream_t * substream, snd_pcm_info_t __user *info); +int snd_pcm_status(snd_pcm_substream_t * substream, snd_pcm_status_t *status); +int snd_pcm_prepare(snd_pcm_substream_t *substream); +int snd_pcm_start(snd_pcm_substream_t *substream); +int snd_pcm_stop(snd_pcm_substream_t *substream, int status); +int snd_pcm_drain_done(snd_pcm_substream_t *substream); #ifdef CONFIG_PM -int snd_pcm_suspend(struct snd_pcm_substream *substream); -int snd_pcm_suspend_all(struct snd_pcm *pcm); +int snd_pcm_suspend(snd_pcm_substream_t *substream); +int snd_pcm_suspend_all(snd_pcm_t *pcm); #endif -int snd_pcm_kernel_playback_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); -int snd_pcm_kernel_capture_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); -int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg); -int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, struct snd_pcm_substream **rsubstream); -void snd_pcm_release_substream(struct snd_pcm_substream *substream); +int snd_pcm_kernel_playback_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg); +int snd_pcm_kernel_capture_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg); +int snd_pcm_kernel_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg); +int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, snd_pcm_substream_t **rsubstream); +void snd_pcm_release_substream(snd_pcm_substream_t *substream); void snd_pcm_vma_notify_data(void *client, void *data); -int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area); +int snd_pcm_mmap_data(snd_pcm_substream_t *substream, struct file *file, struct vm_area_struct *area); #if BITS_PER_LONG >= 64 @@ -554,30 +578,30 @@ static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem) * PCM library */ -static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream) +static inline int snd_pcm_stream_linked(snd_pcm_substream_t *substream) { return substream->group != &substream->self_group; } -static inline void snd_pcm_stream_lock(struct snd_pcm_substream *substream) +static inline void snd_pcm_stream_lock(snd_pcm_substream_t *substream) { read_lock(&snd_pcm_link_rwlock); spin_lock(&substream->self_group.lock); } -static inline void snd_pcm_stream_unlock(struct snd_pcm_substream *substream) +static inline void snd_pcm_stream_unlock(snd_pcm_substream_t *substream) { spin_unlock(&substream->self_group.lock); read_unlock(&snd_pcm_link_rwlock); } -static inline void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream) +static inline void snd_pcm_stream_lock_irq(snd_pcm_substream_t *substream) { read_lock_irq(&snd_pcm_link_rwlock); spin_lock(&substream->self_group.lock); } -static inline void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream) +static inline void snd_pcm_stream_unlock_irq(snd_pcm_substream_t *substream) { spin_unlock(&substream->self_group.lock); read_unlock_irq(&snd_pcm_link_rwlock); @@ -599,56 +623,56 @@ do { \ list_for_each(pos, &substream->group->substreams) #define snd_pcm_group_substream_entry(pos) \ - list_entry(pos, struct snd_pcm_substream, link_list) + list_entry(pos, snd_pcm_substream_t, link_list) -static inline int snd_pcm_running(struct snd_pcm_substream *substream) +static inline int snd_pcm_running(snd_pcm_substream_t *substream) { return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING || (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING && substream->stream == SNDRV_PCM_STREAM_PLAYBACK)); } -static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size) +static inline ssize_t bytes_to_samples(snd_pcm_runtime_t *runtime, ssize_t size) { return size * 8 / runtime->sample_bits; } -static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size) +static inline snd_pcm_sframes_t bytes_to_frames(snd_pcm_runtime_t *runtime, ssize_t size) { return size * 8 / runtime->frame_bits; } -static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size) +static inline ssize_t samples_to_bytes(snd_pcm_runtime_t *runtime, ssize_t size) { return size * runtime->sample_bits / 8; } -static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size) +static inline ssize_t frames_to_bytes(snd_pcm_runtime_t *runtime, snd_pcm_sframes_t size) { return size * runtime->frame_bits / 8; } -static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes) +static inline int frame_aligned(snd_pcm_runtime_t *runtime, ssize_t bytes) { return bytes % runtime->byte_align == 0; } -static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream) +static inline size_t snd_pcm_lib_buffer_bytes(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return frames_to_bytes(runtime, runtime->buffer_size); } -static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream) +static inline size_t snd_pcm_lib_period_bytes(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return frames_to_bytes(runtime, runtime->period_size); } /* * result is: 0 ... (boundary - 1) */ -static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime) +static inline snd_pcm_uframes_t snd_pcm_playback_avail(snd_pcm_runtime_t *runtime) { snd_pcm_sframes_t avail = runtime->status->hw_ptr + runtime->buffer_size - runtime->control->appl_ptr; if (avail < 0) @@ -661,7 +685,7 @@ static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *r /* * result is: 0 ... (boundary - 1) */ -static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime) +static inline snd_pcm_uframes_t snd_pcm_capture_avail(snd_pcm_runtime_t *runtime) { snd_pcm_sframes_t avail = runtime->status->hw_ptr - runtime->control->appl_ptr; if (avail < 0) @@ -669,12 +693,12 @@ static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *ru return avail; } -static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime) +static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(snd_pcm_runtime_t *runtime) { return runtime->buffer_size - snd_pcm_playback_avail(runtime); } -static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime) +static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(snd_pcm_runtime_t *runtime) { return runtime->buffer_size - snd_pcm_capture_avail(runtime); } @@ -687,9 +711,9 @@ static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime * * Returns non-zero if available, or zero if not. */ -static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream) +static inline int snd_pcm_playback_ready(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return snd_pcm_playback_avail(runtime) >= runtime->control->avail_min; } @@ -701,9 +725,9 @@ static inline int snd_pcm_playback_ready(struct snd_pcm_substream *substream) * * Returns non-zero if available, or zero if not. */ -static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream) +static inline int snd_pcm_capture_ready(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return snd_pcm_capture_avail(runtime) >= runtime->control->avail_min; } @@ -716,9 +740,9 @@ static inline int snd_pcm_capture_ready(struct snd_pcm_substream *substream) * * Returns non-zero if exists, or zero if not. */ -static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream) +static inline int snd_pcm_playback_data(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->stop_threshold >= runtime->boundary) return 1; @@ -733,9 +757,9 @@ static inline int snd_pcm_playback_data(struct snd_pcm_substream *substream) * * Returns non-zero if empty, or zero if not. */ -static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream) +static inline int snd_pcm_playback_empty(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return snd_pcm_playback_avail(runtime) >= runtime->buffer_size; } @@ -747,14 +771,14 @@ static inline int snd_pcm_playback_empty(struct snd_pcm_substream *substream) * * Returns non-zero if empty, or zero if not. */ -static inline int snd_pcm_capture_empty(struct snd_pcm_substream *substream) +static inline int snd_pcm_capture_empty(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return snd_pcm_capture_avail(runtime) == 0; } -static inline void snd_pcm_trigger_done(struct snd_pcm_substream *substream, - struct snd_pcm_substream *master) +static inline void snd_pcm_trigger_done(snd_pcm_substream_t *substream, + snd_pcm_substream_t *master) { substream->runtime->trigger_master = master; } @@ -771,28 +795,28 @@ static inline int hw_is_interval(int var) var <= SNDRV_PCM_HW_PARAM_LAST_INTERVAL; } -static inline struct snd_mask *hw_param_mask(struct snd_pcm_hw_params *params, +static inline snd_mask_t *hw_param_mask(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { return ¶ms->masks[var - SNDRV_PCM_HW_PARAM_FIRST_MASK]; } -static inline struct snd_interval *hw_param_interval(struct snd_pcm_hw_params *params, +static inline snd_interval_t *hw_param_interval(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { return ¶ms->intervals[var - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; } -static inline const struct snd_mask *hw_param_mask_c(const struct snd_pcm_hw_params *params, +static inline const snd_mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { - return (const struct snd_mask *)hw_param_mask((struct snd_pcm_hw_params*) params, var); + return (const snd_mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var); } -static inline const struct snd_interval *hw_param_interval_c(const struct snd_pcm_hw_params *params, +static inline const snd_interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { - return (const struct snd_interval *)hw_param_interval((struct snd_pcm_hw_params*) params, var); + return (const snd_interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var); } #define params_access(p) snd_mask_min(hw_param_mask((p), SNDRV_PCM_HW_PARAM_ACCESS)) @@ -808,66 +832,66 @@ static inline const struct snd_interval *hw_param_interval_c(const struct snd_pc #define params_tick_time(p) hw_param_interval((p), SNDRV_PCM_HW_PARAM_TICK_TIME)->min -int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v); -void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c); -void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c); -void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, - unsigned int k, struct snd_interval *c); -void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, - const struct snd_interval *b, struct snd_interval *c); -int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask); -int snd_interval_ratnum(struct snd_interval *i, - unsigned int rats_count, struct snd_ratnum *rats, +int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v); +void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); +void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); +void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, + unsigned int k, snd_interval_t *c); +void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, + const snd_interval_t *b, snd_interval_t *c); +int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, unsigned int mask); +int snd_interval_ratnum(snd_interval_t *i, + unsigned int rats_count, ratnum_t *rats, unsigned int *nump, unsigned int *denp); -void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params); -void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var); -int snd_pcm_hw_param_near(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params, +void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params); +void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var); +int snd_pcm_hw_param_near(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int *dir); -int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, - struct snd_pcm_hw_params *params, +int snd_pcm_hw_param_set(snd_pcm_substream_t *pcm, + snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir); -int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params); +int snd_pcm_hw_params_choose(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *params); -int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params); +int snd_pcm_hw_refine(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *params); -int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream); -int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream); +int snd_pcm_hw_constraints_init(snd_pcm_substream_t *substream); +int snd_pcm_hw_constraints_complete(snd_pcm_substream_t *substream); -int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, u_int32_t mask); -int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, u_int64_t mask); -int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, unsigned int min, unsigned int max); -int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var); -int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var); +int snd_pcm_hw_constraint_list(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, - struct snd_pcm_hw_constraint_list *l); -int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, + snd_pcm_hw_constraint_list_t *l); +int snd_pcm_hw_constraint_ratnums(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, - struct snd_pcm_hw_constraint_ratnums *r); -int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, + snd_pcm_hw_constraint_ratnums_t *r); +int snd_pcm_hw_constraint_ratdens(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, - struct snd_pcm_hw_constraint_ratdens *r); -int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, + snd_pcm_hw_constraint_ratdens_t *r); +int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, unsigned int cond, unsigned int width, unsigned int msbits); -int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, unsigned long step); -int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var); -int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, int var, snd_pcm_hw_rule_func_t func, void *private, @@ -901,37 +925,37 @@ int snd_pcm_format_set_silence(snd_pcm_format_t format, void *buf, unsigned int snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian); const char *snd_pcm_format_name(snd_pcm_format_t format); -void snd_pcm_set_ops(struct snd_pcm * pcm, int direction, struct snd_pcm_ops *ops); -void snd_pcm_set_sync(struct snd_pcm_substream *substream); -int snd_pcm_lib_interleave_len(struct snd_pcm_substream *substream); -int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, +void snd_pcm_set_ops(snd_pcm_t * pcm, int direction, snd_pcm_ops_t *ops); +void snd_pcm_set_sync(snd_pcm_substream_t * substream); +int snd_pcm_lib_interleave_len(snd_pcm_substream_t *substream); +int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg); -int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream); -int snd_pcm_playback_xrun_check(struct snd_pcm_substream *substream); -int snd_pcm_capture_xrun_check(struct snd_pcm_substream *substream); -int snd_pcm_playback_xrun_asap(struct snd_pcm_substream *substream); -int snd_pcm_capture_xrun_asap(struct snd_pcm_substream *substream); -void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr); -void snd_pcm_tick_prepare(struct snd_pcm_substream *substream); -void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks); -void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream); -void snd_pcm_period_elapsed(struct snd_pcm_substream *substream); -snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, +int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream); +int snd_pcm_playback_xrun_check(snd_pcm_substream_t *substream); +int snd_pcm_capture_xrun_check(snd_pcm_substream_t *substream); +int snd_pcm_playback_xrun_asap(snd_pcm_substream_t *substream); +int snd_pcm_capture_xrun_asap(snd_pcm_substream_t *substream); +void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t new_hw_ptr); +void snd_pcm_tick_prepare(snd_pcm_substream_t *substream); +void snd_pcm_tick_set(snd_pcm_substream_t *substream, unsigned long ticks); +void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream); +void snd_pcm_period_elapsed(snd_pcm_substream_t *substream); +snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void __user *buf, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, +snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *buf, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, +snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, void __user **bufs, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, +snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, void __user **bufs, snd_pcm_uframes_t frames); -int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime); +int snd_pcm_limit_hw_rates(snd_pcm_runtime_t *runtime); -static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream, +static inline void snd_pcm_set_runtime_buffer(snd_pcm_substream_t *substream, struct snd_dma_buffer *bufp) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (bufp) { runtime->dma_buffer_p = bufp; runtime->dma_area = bufp->area; @@ -949,47 +973,47 @@ static inline void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substrea * Timer interface */ -void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream); -void snd_pcm_timer_init(struct snd_pcm_substream *substream); -void snd_pcm_timer_done(struct snd_pcm_substream *substream); +void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream); +void snd_pcm_timer_init(snd_pcm_substream_t * substream); +void snd_pcm_timer_done(snd_pcm_substream_t * substream); /* * Memory */ -int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream); -int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm); -int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, +int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream); +int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm); +int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream, int type, struct device *data, size_t size, size_t max); -int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, +int snd_pcm_lib_preallocate_pages_for_all(snd_pcm_t *pcm, int type, void *data, size_t size, size_t max); -int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size); -int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream); +int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size); +int snd_pcm_lib_free_pages(snd_pcm_substream_t *substream); #define snd_pcm_substream_sgbuf(substream) ((substream)->runtime->dma_buffer_p->private_data) #define snd_pcm_sgbuf_pages(size) snd_sgbuf_aligned_pages(size) #define snd_pcm_sgbuf_get_addr(sgbuf,ofs) snd_sgbuf_get_addr(sgbuf,ofs) -struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset); +struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset); /* handle mmap counter - PCM mmap callback should handle this counter properly */ static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area) { - struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; atomic_inc(&substream->runtime->mmap_count); } static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area) { - struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; atomic_dec(&substream->runtime->mmap_count); } /* mmap for io-memory area */ #if defined(CONFIG_X86) || defined(CONFIG_PPC) || defined(CONFIG_ALPHA) #define SNDRV_PCM_INFO_MMAP_IOMEM SNDRV_PCM_INFO_MMAP -int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area); +int snd_pcm_lib_mmap_iomem(snd_pcm_substream_t *substream, struct vm_area_struct *area); #else #define SNDRV_PCM_INFO_MMAP_IOMEM 0 #define snd_pcm_lib_mmap_iomem NULL diff --git a/trunk/include/sound/pcm_oss.h b/trunk/include/sound/pcm_oss.h index fddaddde47b4..0b67c9d105af 100644 --- a/trunk/include/sound/pcm_oss.h +++ b/trunk/include/sound/pcm_oss.h @@ -22,7 +22,10 @@ * */ -struct snd_pcm_oss_setup { +typedef struct _snd_pcm_plugin snd_pcm_plugin_t; +typedef struct _snd_pcm_oss_setup snd_pcm_oss_setup_t; + +struct _snd_pcm_oss_setup { char *task_name; unsigned int disable:1, direct:1, @@ -33,10 +36,10 @@ struct snd_pcm_oss_setup { buggyptr:1; unsigned int periods; unsigned int period_size; - struct snd_pcm_oss_setup *next; + snd_pcm_oss_setup_t *next; }; -struct snd_pcm_oss_runtime { +typedef struct _snd_pcm_oss_runtime { unsigned params: 1, /* format/parameter change */ prepare: 1, /* need to prepare the operation */ trigger: 1, /* trigger flag */ @@ -56,30 +59,30 @@ struct snd_pcm_oss_runtime { size_t mmap_bytes; char *buffer; /* vmallocated period */ size_t buffer_used; /* used length from period buffer */ - struct snd_pcm_plugin *plugin_first; - struct snd_pcm_plugin *plugin_last; + snd_pcm_plugin_t *plugin_first; + snd_pcm_plugin_t *plugin_last; unsigned int prev_hw_ptr_interrupt; -}; +} snd_pcm_oss_runtime_t; -struct snd_pcm_oss_file { - struct snd_pcm_substream *streams[2]; -}; +typedef struct _snd_pcm_oss_file { + snd_pcm_substream_t *streams[2]; +} snd_pcm_oss_file_t; -struct snd_pcm_oss_substream { +typedef struct _snd_pcm_oss_substream { unsigned oss: 1; /* oss mode */ - struct snd_pcm_oss_setup *setup; /* active setup */ - struct snd_pcm_oss_file *file; -}; + snd_pcm_oss_setup_t *setup; /* active setup */ + snd_pcm_oss_file_t *file; +} snd_pcm_oss_substream_t; -struct snd_pcm_oss_stream { - struct snd_pcm_oss_setup *setup_list; /* setup list */ +typedef struct _snd_pcm_oss_stream { + snd_pcm_oss_setup_t *setup_list; /* setup list */ struct semaphore setup_mutex; - struct snd_info_entry *proc_entry; -}; + snd_info_entry_t *proc_entry; +} snd_pcm_oss_stream_t; -struct snd_pcm_oss { +typedef struct _snd_pcm_oss { int reg; unsigned int reg_mask; -}; +} snd_pcm_oss_t; #endif /* __SOUND_PCM_OSS_H */ diff --git a/trunk/include/sound/pcm_params.h b/trunk/include/sound/pcm_params.h index fb18aef77341..60b0e92e26f3 100644 --- a/trunk/include/sound/pcm_params.h +++ b/trunk/include/sound/pcm_params.h @@ -22,17 +22,17 @@ * */ -extern int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, - snd_pcm_hw_param_t var, const struct snd_mask *val); -extern unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, +extern int snd_pcm_hw_param_mask(snd_pcm_substream_t *pcm, snd_pcm_hw_params_t *params, + snd_pcm_hw_param_t var, const snd_mask_t *val); +extern unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir); -extern unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params, +extern unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir); -extern int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params, +extern int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir); -extern int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params, +extern int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var); -extern int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, +extern int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir); /* To share the same code we have alsa-lib */ @@ -71,20 +71,20 @@ INLINE unsigned int ld2(u_int32_t v) INLINE size_t snd_mask_sizeof(void) { - return sizeof(struct snd_mask); + return sizeof(snd_mask_t); } -INLINE void snd_mask_none(struct snd_mask *mask) +INLINE void snd_mask_none(snd_mask_t *mask) { memset(mask, 0, sizeof(*mask)); } -INLINE void snd_mask_any(struct snd_mask *mask) +INLINE void snd_mask_any(snd_mask_t *mask) { memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t)); } -INLINE int snd_mask_empty(const struct snd_mask *mask) +INLINE int snd_mask_empty(const snd_mask_t *mask) { int i; for (i = 0; i < SNDRV_MASK_SIZE; i++) @@ -93,7 +93,7 @@ INLINE int snd_mask_empty(const struct snd_mask *mask) return 1; } -INLINE unsigned int snd_mask_min(const struct snd_mask *mask) +INLINE unsigned int snd_mask_min(const snd_mask_t *mask) { int i; assert(!snd_mask_empty(mask)); @@ -104,7 +104,7 @@ INLINE unsigned int snd_mask_min(const struct snd_mask *mask) return 0; } -INLINE unsigned int snd_mask_max(const struct snd_mask *mask) +INLINE unsigned int snd_mask_max(const snd_mask_t *mask) { int i; assert(!snd_mask_empty(mask)); @@ -115,19 +115,19 @@ INLINE unsigned int snd_mask_max(const struct snd_mask *mask) return 0; } -INLINE void snd_mask_set(struct snd_mask *mask, unsigned int val) +INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val) { assert(val <= SNDRV_MASK_BITS); mask->bits[MASK_OFS(val)] |= MASK_BIT(val); } -INLINE void snd_mask_reset(struct snd_mask *mask, unsigned int val) +INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val) { assert(val <= SNDRV_MASK_BITS); mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val); } -INLINE void snd_mask_set_range(struct snd_mask *mask, unsigned int from, unsigned int to) +INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to) { unsigned int i; assert(to <= SNDRV_MASK_BITS && from <= to); @@ -135,7 +135,7 @@ INLINE void snd_mask_set_range(struct snd_mask *mask, unsigned int from, unsigne mask->bits[MASK_OFS(i)] |= MASK_BIT(i); } -INLINE void snd_mask_reset_range(struct snd_mask *mask, unsigned int from, unsigned int to) +INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to) { unsigned int i; assert(to <= SNDRV_MASK_BITS && from <= to); @@ -143,7 +143,7 @@ INLINE void snd_mask_reset_range(struct snd_mask *mask, unsigned int from, unsig mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i); } -INLINE void snd_mask_leave(struct snd_mask *mask, unsigned int val) +INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val) { unsigned int v; assert(val <= SNDRV_MASK_BITS); @@ -152,30 +152,30 @@ INLINE void snd_mask_leave(struct snd_mask *mask, unsigned int val) mask->bits[MASK_OFS(val)] = v; } -INLINE void snd_mask_intersect(struct snd_mask *mask, const struct snd_mask *v) +INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v) { int i; for (i = 0; i < SNDRV_MASK_SIZE; i++) mask->bits[i] &= v->bits[i]; } -INLINE int snd_mask_eq(const struct snd_mask *mask, const struct snd_mask *v) +INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v) { return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t)); } -INLINE void snd_mask_copy(struct snd_mask *mask, const struct snd_mask *v) +INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v) { *mask = *v; } -INLINE int snd_mask_test(const struct snd_mask *mask, unsigned int val) +INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val) { assert(val <= SNDRV_MASK_BITS); return mask->bits[MASK_OFS(val)] & MASK_BIT(val); } -INLINE int snd_mask_single(const struct snd_mask *mask) +INLINE int snd_mask_single(const snd_mask_t *mask) { int i, c = 0; assert(!snd_mask_empty(mask)); @@ -191,9 +191,9 @@ INLINE int snd_mask_single(const struct snd_mask *mask) return 1; } -INLINE int snd_mask_refine(struct snd_mask *mask, const struct snd_mask *v) +INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v) { - struct snd_mask old; + snd_mask_t old; assert(!snd_mask_empty(mask)); snd_mask_copy(&old, mask); snd_mask_intersect(mask, v); @@ -202,7 +202,7 @@ INLINE int snd_mask_refine(struct snd_mask *mask, const struct snd_mask *v) return !snd_mask_eq(mask, &old); } -INLINE int snd_mask_refine_first(struct snd_mask *mask) +INLINE int snd_mask_refine_first(snd_mask_t *mask) { assert(!snd_mask_empty(mask)); if (snd_mask_single(mask)) @@ -211,7 +211,7 @@ INLINE int snd_mask_refine_first(struct snd_mask *mask) return 1; } -INLINE int snd_mask_refine_last(struct snd_mask *mask) +INLINE int snd_mask_refine_last(snd_mask_t *mask) { assert(!snd_mask_empty(mask)); if (snd_mask_single(mask)) @@ -220,7 +220,7 @@ INLINE int snd_mask_refine_last(struct snd_mask *mask) return 1; } -INLINE int snd_mask_refine_min(struct snd_mask *mask, unsigned int val) +INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val) { assert(!snd_mask_empty(mask)); if (snd_mask_min(mask) >= val) @@ -231,7 +231,7 @@ INLINE int snd_mask_refine_min(struct snd_mask *mask, unsigned int val) return 1; } -INLINE int snd_mask_refine_max(struct snd_mask *mask, unsigned int val) +INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val) { assert(!snd_mask_empty(mask)); if (snd_mask_max(mask) <= val) @@ -242,7 +242,7 @@ INLINE int snd_mask_refine_max(struct snd_mask *mask, unsigned int val) return 1; } -INLINE int snd_mask_refine_set(struct snd_mask *mask, unsigned int val) +INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val) { int changed; assert(!snd_mask_empty(mask)); @@ -253,13 +253,13 @@ INLINE int snd_mask_refine_set(struct snd_mask *mask, unsigned int val) return changed; } -INLINE int snd_mask_value(const struct snd_mask *mask) +INLINE int snd_mask_value(const snd_mask_t *mask) { assert(!snd_mask_empty(mask)); return snd_mask_min(mask); } -INLINE void snd_interval_any(struct snd_interval *i) +INLINE void snd_interval_any(snd_interval_t *i) { i->min = 0; i->openmin = 0; @@ -269,42 +269,42 @@ INLINE void snd_interval_any(struct snd_interval *i) i->empty = 0; } -INLINE void snd_interval_none(struct snd_interval *i) +INLINE void snd_interval_none(snd_interval_t *i) { i->empty = 1; } -INLINE int snd_interval_checkempty(const struct snd_interval *i) +INLINE int snd_interval_checkempty(const snd_interval_t *i) { return (i->min > i->max || (i->min == i->max && (i->openmin || i->openmax))); } -INLINE int snd_interval_empty(const struct snd_interval *i) +INLINE int snd_interval_empty(const snd_interval_t *i) { return i->empty; } -INLINE int snd_interval_single(const struct snd_interval *i) +INLINE int snd_interval_single(const snd_interval_t *i) { assert(!snd_interval_empty(i)); return (i->min == i->max || (i->min + 1 == i->max && i->openmax)); } -INLINE int snd_interval_value(const struct snd_interval *i) +INLINE int snd_interval_value(const snd_interval_t *i) { assert(snd_interval_single(i)); return i->min; } -INLINE int snd_interval_min(const struct snd_interval *i) +INLINE int snd_interval_min(const snd_interval_t *i) { assert(!snd_interval_empty(i)); return i->min; } -INLINE int snd_interval_max(const struct snd_interval *i) +INLINE int snd_interval_max(const snd_interval_t *i) { unsigned int v; assert(!snd_interval_empty(i)); @@ -314,18 +314,18 @@ INLINE int snd_interval_max(const struct snd_interval *i) return v; } -INLINE int snd_interval_test(const struct snd_interval *i, unsigned int val) +INLINE int snd_interval_test(const snd_interval_t *i, unsigned int val) { return !((i->min > val || (i->min == val && i->openmin) || i->max < val || (i->max == val && i->openmax))); } -INLINE void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s) +INLINE void snd_interval_copy(snd_interval_t *d, const snd_interval_t *s) { *d = *s; } -INLINE int snd_interval_setinteger(struct snd_interval *i) +INLINE int snd_interval_setinteger(snd_interval_t *i) { if (i->integer) return 0; @@ -335,7 +335,7 @@ INLINE int snd_interval_setinteger(struct snd_interval *i) return 1; } -INLINE int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2) +INLINE int snd_interval_eq(const snd_interval_t *i1, const snd_interval_t *i2) { if (i1->empty) return i2->empty; diff --git a/trunk/include/sound/rawmidi.h b/trunk/include/sound/rawmidi.h index d19bddfbf995..3f9db510dee3 100644 --- a/trunk/include/sound/rawmidi.h +++ b/trunk/include/sound/rawmidi.h @@ -36,6 +36,11 @@ * Raw MIDI interface */ +typedef enum sndrv_rawmidi_stream snd_rawmidi_stream_t; +typedef struct sndrv_rawmidi_info snd_rawmidi_info_t; +typedef struct sndrv_rawmidi_params snd_rawmidi_params_t; +typedef struct sndrv_rawmidi_status snd_rawmidi_status_t; + #define SNDRV_RAWMIDI_DEVICES 8 #define SNDRV_RAWMIDI_LFLG_OUTPUT (1<<0) @@ -44,22 +49,23 @@ #define SNDRV_RAWMIDI_LFLG_APPEND (1<<2) #define SNDRV_RAWMIDI_LFLG_NOOPENLOCK (1<<3) -struct snd_rawmidi; -struct snd_rawmidi_substream; +typedef struct _snd_rawmidi_runtime snd_rawmidi_runtime_t; +typedef struct _snd_rawmidi_substream snd_rawmidi_substream_t; +typedef struct _snd_rawmidi_str snd_rawmidi_str_t; -struct snd_rawmidi_ops { - int (*open) (struct snd_rawmidi_substream * substream); - int (*close) (struct snd_rawmidi_substream * substream); - void (*trigger) (struct snd_rawmidi_substream * substream, int up); - void (*drain) (struct snd_rawmidi_substream * substream); -}; +typedef struct _snd_rawmidi_ops { + int (*open) (snd_rawmidi_substream_t * substream); + int (*close) (snd_rawmidi_substream_t * substream); + void (*trigger) (snd_rawmidi_substream_t * substream, int up); + void (*drain) (snd_rawmidi_substream_t * substream); +} snd_rawmidi_ops_t; -struct snd_rawmidi_global_ops { - int (*dev_register) (struct snd_rawmidi * rmidi); - int (*dev_unregister) (struct snd_rawmidi * rmidi); -}; +typedef struct _snd_rawmidi_global_ops { + int (*dev_register) (snd_rawmidi_t * rmidi); + int (*dev_unregister) (snd_rawmidi_t * rmidi); +} snd_rawmidi_global_ops_t; -struct snd_rawmidi_runtime { +struct _snd_rawmidi_runtime { unsigned int drain: 1, /* drain stage */ oss: 1; /* OSS compatible mode */ /* midi stream buffer */ @@ -74,15 +80,15 @@ struct snd_rawmidi_runtime { spinlock_t lock; wait_queue_head_t sleep; /* event handler (new bytes, input only) */ - void (*event)(struct snd_rawmidi_substream *substream); + void (*event)(snd_rawmidi_substream_t *substream); /* defers calls to event [input] or ops->trigger [output] */ struct tasklet_struct tasklet; /* private data */ void *private_data; - void (*private_free)(struct snd_rawmidi_substream *substream); + void (*private_free)(snd_rawmidi_substream_t *substream); }; -struct snd_rawmidi_substream { +struct _snd_rawmidi_substream { struct list_head list; /* list of all substream for given stream */ int stream; /* direction */ int number; /* substream number */ @@ -91,29 +97,29 @@ struct snd_rawmidi_substream { active_sensing: 1; /* send active sensing when close */ int use_count; /* use counter (for output) */ size_t bytes; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_str *pstr; + snd_rawmidi_t *rmidi; + snd_rawmidi_str_t *pstr; char name[32]; - struct snd_rawmidi_runtime *runtime; + snd_rawmidi_runtime_t *runtime; /* hardware layer */ - struct snd_rawmidi_ops *ops; + snd_rawmidi_ops_t *ops; }; -struct snd_rawmidi_file { - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *input; - struct snd_rawmidi_substream *output; -}; +typedef struct _snd_rawmidi_file { + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *input; + snd_rawmidi_substream_t *output; +} snd_rawmidi_file_t; -struct snd_rawmidi_str { +struct _snd_rawmidi_str { unsigned int substream_count; unsigned int substream_opened; struct list_head substreams; }; -struct snd_rawmidi { - struct snd_card *card; - struct list_head list; +struct _snd_rawmidi { + snd_card_t *card; + unsigned int device; /* device number */ unsigned int info_flags; /* SNDRV_RAWMIDI_INFO_XXXX */ char id[64]; @@ -123,61 +129,52 @@ struct snd_rawmidi { int ossreg; #endif - struct snd_rawmidi_global_ops *ops; + snd_rawmidi_global_ops_t *ops; - struct snd_rawmidi_str streams[2]; + snd_rawmidi_str_t streams[2]; void *private_data; - void (*private_free) (struct snd_rawmidi *rmidi); + void (*private_free) (snd_rawmidi_t *rmidi); struct semaphore open_mutex; wait_queue_head_t open_wait; - struct snd_info_entry *dev; - struct snd_info_entry *proc_entry; + snd_info_entry_t *dev; + snd_info_entry_t *proc_entry; #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) - struct snd_seq_device *seq_dev; + snd_seq_device_t *seq_dev; #endif }; /* main rawmidi functions */ -int snd_rawmidi_new(struct snd_card *card, char *id, int device, +int snd_rawmidi_new(snd_card_t * card, char *id, int device, int output_count, int input_count, - struct snd_rawmidi **rmidi); -void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream, - struct snd_rawmidi_ops *ops); + snd_rawmidi_t ** rmidi); +void snd_rawmidi_set_ops(snd_rawmidi_t * rmidi, int stream, snd_rawmidi_ops_t * ops); /* callbacks */ -void snd_rawmidi_receive_reset(struct snd_rawmidi_substream *substream); -int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, - const unsigned char *buffer, int count); -void snd_rawmidi_transmit_reset(struct snd_rawmidi_substream *substream); -int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream); -int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, - unsigned char *buffer, int count); -int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count); -int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, - unsigned char *buffer, int count); +void snd_rawmidi_receive_reset(snd_rawmidi_substream_t * substream); +int snd_rawmidi_receive(snd_rawmidi_substream_t * substream, const unsigned char *buffer, int count); +void snd_rawmidi_transmit_reset(snd_rawmidi_substream_t * substream); +int snd_rawmidi_transmit_empty(snd_rawmidi_substream_t * substream); +int snd_rawmidi_transmit_peek(snd_rawmidi_substream_t * substream, unsigned char *buffer, int count); +int snd_rawmidi_transmit_ack(snd_rawmidi_substream_t * substream, int count); +int snd_rawmidi_transmit(snd_rawmidi_substream_t * substream, unsigned char *buffer, int count); /* main midi functions */ -int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info); -int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, - int mode, struct snd_rawmidi_file *rfile); -int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile); -int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_params *params); -int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_params *params); -int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream); -int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream); -int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream); -long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream, - unsigned char *buf, long count); -long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream, - const unsigned char *buf, long count); +int snd_rawmidi_info_select(snd_card_t *card, snd_rawmidi_info_t *info); +int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, int mode, snd_rawmidi_file_t * rfile); +int snd_rawmidi_kernel_release(snd_rawmidi_file_t * rfile); +int snd_rawmidi_output_params(snd_rawmidi_substream_t * substream, snd_rawmidi_params_t * params); +int snd_rawmidi_input_params(snd_rawmidi_substream_t * substream, snd_rawmidi_params_t * params); +int snd_rawmidi_drop_output(snd_rawmidi_substream_t * substream); +int snd_rawmidi_drain_output(snd_rawmidi_substream_t * substream); +int snd_rawmidi_drain_input(snd_rawmidi_substream_t * substream); +long snd_rawmidi_kernel_read(snd_rawmidi_substream_t * substream, unsigned char *buf, long count); +long snd_rawmidi_kernel_write(snd_rawmidi_substream_t * substream, const unsigned char *buf, long count); #endif /* __SOUND_RAWMIDI_H */ diff --git a/trunk/include/sound/sb.h b/trunk/include/sound/sb.h index 431d06675e36..7960452445e6 100644 --- a/trunk/include/sound/sb.h +++ b/trunk/include/sound/sb.h @@ -60,7 +60,7 @@ enum sb_hw_type { #define SB_MPU_INPUT 1 -struct snd_sb { +struct _snd_sb { unsigned long port; /* base port of DSP chip */ struct resource *res_port; unsigned long mpu_port; /* MPU port for SB DSP 4.0+ */ @@ -92,27 +92,25 @@ struct snd_sb { void *csp; /* used only when CONFIG_SND_SB16_CSP is set */ - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *midi_substream_input; - struct snd_rawmidi_substream *midi_substream_output; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *midi_substream_input; + snd_rawmidi_substream_t *midi_substream_output; irqreturn_t (*rmidi_callback)(int irq, void *dev_id, struct pt_regs *regs); spinlock_t reg_lock; spinlock_t open_lock; spinlock_t midi_input_lock; - struct snd_info_entry *proc_entry; - -#ifdef CONFIG_PM - unsigned char saved_regs[0x20]; -#endif + snd_info_entry_t *proc_entry; }; +typedef struct _snd_sb sb_t; + /* I/O ports */ #define SBP(chip, x) ((chip)->port + s_b_SB_##x) @@ -269,52 +267,48 @@ struct snd_sb { * */ -static inline void snd_sb_ack_8bit(struct snd_sb *chip) +static inline void snd_sb_ack_8bit(sb_t *chip) { inb(SBP(chip, DATA_AVAIL)); } -static inline void snd_sb_ack_16bit(struct snd_sb *chip) +static inline void snd_sb_ack_16bit(sb_t *chip) { inb(SBP(chip, DATA_AVAIL_16)); } /* sb_common.c */ -int snd_sbdsp_command(struct snd_sb *chip, unsigned char val); -int snd_sbdsp_get_byte(struct snd_sb *chip); -int snd_sbdsp_reset(struct snd_sb *chip); -int snd_sbdsp_create(struct snd_card *card, +int snd_sbdsp_command(sb_t *chip, unsigned char val); +int snd_sbdsp_get_byte(sb_t *chip); +int snd_sbdsp_reset(sb_t *chip); +int snd_sbdsp_create(snd_card_t *card, unsigned long port, int irq, irqreturn_t (*irq_handler)(int, void *, struct pt_regs *), int dma8, int dma16, unsigned short hardware, - struct snd_sb **r_chip); + sb_t **r_chip); /* sb_mixer.c */ -void snd_sbmixer_write(struct snd_sb *chip, unsigned char reg, unsigned char data); -unsigned char snd_sbmixer_read(struct snd_sb *chip, unsigned char reg); -int snd_sbmixer_new(struct snd_sb *chip); -#ifdef CONFIG_PM -void snd_sbmixer_suspend(struct snd_sb *chip); -void snd_sbmixer_resume(struct snd_sb *chip); -#endif +void snd_sbmixer_write(sb_t *chip, unsigned char reg, unsigned char data); +unsigned char snd_sbmixer_read(sb_t *chip, unsigned char reg); +int snd_sbmixer_new(sb_t *chip); /* sb8_init.c */ -int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm); +int snd_sb8dsp_pcm(sb_t *chip, int device, snd_pcm_t ** rpcm); /* sb8.c */ -irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip); -int snd_sb8_playback_open(struct snd_pcm_substream *substream); -int snd_sb8_capture_open(struct snd_pcm_substream *substream); -int snd_sb8_playback_close(struct snd_pcm_substream *substream); -int snd_sb8_capture_close(struct snd_pcm_substream *substream); +irqreturn_t snd_sb8dsp_interrupt(sb_t *chip); +int snd_sb8_playback_open(snd_pcm_substream_t *substream); +int snd_sb8_capture_open(snd_pcm_substream_t *substream); +int snd_sb8_playback_close(snd_pcm_substream_t *substream); +int snd_sb8_capture_close(snd_pcm_substream_t *substream); /* midi8.c */ -irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb *chip); -int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawmidi); +irqreturn_t snd_sb8dsp_midi_interrupt(sb_t *chip); +int snd_sb8dsp_midi(sb_t *chip, int device, snd_rawmidi_t ** rrawmidi); /* sb16_init.c */ -int snd_sb16dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm); -const struct snd_pcm_ops *snd_sb16dsp_get_pcm_ops(int direction); -int snd_sb16dsp_configure(struct snd_sb *chip); +int snd_sb16dsp_pcm(sb_t *chip, int device, snd_pcm_t ** rpcm); +const snd_pcm_ops_t *snd_sb16dsp_get_pcm_ops(int direction); +int snd_sb16dsp_configure(sb_t *chip); /* sb16.c */ irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs); @@ -334,7 +328,7 @@ enum { #define SB_MIXVAL_INPUT_SW(reg1, reg2, left_shift, right_shift) \ ((reg1) | ((reg2) << 8) | ((left_shift) << 16) | ((right_shift) << 24)) -int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int type, unsigned long value); +int snd_sbmixer_add_ctl(sb_t *chip, const char *name, int index, int type, unsigned long value); /* for ease of use */ struct sbmix_elem { @@ -358,7 +352,7 @@ struct sbmix_elem { .type = SB_MIX_INPUT_SW, \ .private_value = SB_MIXVAL_INPUT_SW(reg1, reg2, left_shift, right_shift) } -static inline int snd_sbmixer_add_ctl_elem(struct snd_sb *chip, const struct sbmix_elem *c) +static inline int snd_sbmixer_add_ctl_elem(sb_t *chip, const struct sbmix_elem *c) { return snd_sbmixer_add_ctl(chip, c->name, 0, c->type, c->private_value); } diff --git a/trunk/include/sound/sb16_csp.h b/trunk/include/sound/sb16_csp.h index 3b44d4b370f5..eb8368b56b16 100644 --- a/trunk/include/sound/sb16_csp.h +++ b/trunk/include/sound/sb16_csp.h @@ -63,25 +63,25 @@ #define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE 0x3000 /* microcode header */ -struct snd_sb_csp_mc_header { +typedef struct snd_sb_csp_mc_header { char codec_name[16]; /* id name of codec */ unsigned short func_req; /* requested function */ -}; +} snd_sb_csp_mc_header_t; /* microcode to be loaded */ -struct snd_sb_csp_microcode { - struct snd_sb_csp_mc_header info; +typedef struct snd_sb_csp_microcode { + snd_sb_csp_mc_header_t info; unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE]; -}; +} snd_sb_csp_microcode_t; /* start CSP with sample_width in mono/stereo */ -struct snd_sb_csp_start { +typedef struct snd_sb_csp_start { int sample_width; /* sample width, look above */ int channels; /* channels, look above */ -}; +} snd_sb_csp_start_t; /* CSP information */ -struct snd_sb_csp_info { +typedef struct snd_sb_csp_info { char codec_name[16]; /* id name of codec */ unsigned short func_nr; /* function number */ unsigned int acc_format; /* accepted PCM formats */ @@ -93,17 +93,17 @@ struct snd_sb_csp_info { unsigned short run_width; /* current sample width */ unsigned short version; /* version id: 0x10 - 0x1f */ unsigned short state; /* state bits */ -}; +} snd_sb_csp_info_t; /* HWDEP controls */ /* get CSP information */ -#define SNDRV_SB_CSP_IOCTL_INFO _IOR('H', 0x10, struct snd_sb_csp_info) +#define SNDRV_SB_CSP_IOCTL_INFO _IOR('H', 0x10, snd_sb_csp_info_t) /* load microcode to CSP */ -#define SNDRV_SB_CSP_IOCTL_LOAD_CODE _IOW('H', 0x11, struct snd_sb_csp_microcode) +#define SNDRV_SB_CSP_IOCTL_LOAD_CODE _IOW('H', 0x11, snd_sb_csp_microcode_t) /* unload microcode from CSP */ #define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE _IO('H', 0x12) /* start CSP */ -#define SNDRV_SB_CSP_IOCTL_START _IOW('H', 0x13, struct snd_sb_csp_start) +#define SNDRV_SB_CSP_IOCTL_START _IOW('H', 0x13, snd_sb_csp_start_t) /* stop CSP */ #define SNDRV_SB_CSP_IOCTL_STOP _IO('H', 0x14) /* pause CSP and DMA transfer */ @@ -115,25 +115,25 @@ struct snd_sb_csp_info { #include "sb.h" #include "hwdep.h" -struct snd_sb_csp; +typedef struct snd_sb_csp snd_sb_csp_t; /* * CSP operators */ -struct snd_sb_csp_ops { - int (*csp_use) (struct snd_sb_csp * p); - int (*csp_unuse) (struct snd_sb_csp * p); - int (*csp_autoload) (struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode); - int (*csp_start) (struct snd_sb_csp * p, int sample_width, int channels); - int (*csp_stop) (struct snd_sb_csp * p); - int (*csp_qsound_transfer) (struct snd_sb_csp * p); -}; +typedef struct { + int (*csp_use) (snd_sb_csp_t * p); + int (*csp_unuse) (snd_sb_csp_t * p); + int (*csp_autoload) (snd_sb_csp_t * p, int pcm_sfmt, int play_rec_mode); + int (*csp_start) (snd_sb_csp_t * p, int sample_width, int channels); + int (*csp_stop) (snd_sb_csp_t * p); + int (*csp_qsound_transfer) (snd_sb_csp_t * p); +} snd_sb_csp_ops_t; /* * CSP private data */ struct snd_sb_csp { - struct snd_sb *chip; /* SB16 DSP */ + sb_t *chip; /* SB16 DSP */ int used; /* usage flag - exclusive */ char codec_name[16]; /* name of codec */ unsigned short func_nr; /* function number */ @@ -147,7 +147,7 @@ struct snd_sb_csp { int version; /* CSP version (0x10 - 0x1f) */ int running; /* running state */ - struct snd_sb_csp_ops ops; /* operators */ + snd_sb_csp_ops_t ops; /* operators */ spinlock_t q_lock; /* locking */ int q_enabled; /* enabled flag */ @@ -155,13 +155,13 @@ struct snd_sb_csp { int qpos_right; /* right position */ int qpos_changed; /* position changed flag */ - struct snd_kcontrol *qsound_switch; - struct snd_kcontrol *qsound_space; + snd_kcontrol_t *qsound_switch; + snd_kcontrol_t *qsound_space; struct semaphore access_mutex; /* locking */ }; -int snd_sb_csp_new(struct snd_sb *chip, int device, struct snd_hwdep ** rhwdep); +int snd_sb_csp_new(sb_t *chip, int device, snd_hwdep_t ** rhwdep); #endif #endif /* __SOUND_SB16_CSP */ diff --git a/trunk/include/sound/seq_device.h b/trunk/include/sound/seq_device.h index 2b5f24cc7548..204ca540c28e 100644 --- a/trunk/include/sound/seq_device.h +++ b/trunk/include/sound/seq_device.h @@ -21,6 +21,9 @@ * */ +typedef struct snd_seq_device snd_seq_device_t; +typedef struct snd_seq_dev_ops snd_seq_dev_ops_t; + /* * registered device information */ @@ -33,7 +36,7 @@ struct snd_seq_device { /* device info */ - struct snd_card *card; /* sound card */ + snd_card_t *card; /* sound card */ int device; /* device number */ char id[ID_LEN]; /* driver id */ char name[80]; /* device name */ @@ -41,7 +44,7 @@ struct snd_seq_device { void *driver_data; /* private data for driver */ int status; /* flag - read only */ void *private_data; /* private data for the caller */ - void (*private_free)(struct snd_seq_device *device); + void (*private_free)(snd_seq_device_t *device); struct list_head list; /* link to next device */ }; @@ -60,19 +63,19 @@ struct snd_seq_device { * Typically, call snd_device_free(dev->card, dev->driver_data) */ struct snd_seq_dev_ops { - int (*init_device)(struct snd_seq_device *dev); - int (*free_device)(struct snd_seq_device *dev); + int (*init_device)(snd_seq_device_t *dev); + int (*free_device)(snd_seq_device_t *dev); }; /* * prototypes */ void snd_seq_device_load_drivers(void); -int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize, struct snd_seq_device **result); -int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, int argsize); +int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize, snd_seq_device_t **result); +int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsize); int snd_seq_device_unregister_driver(char *id); -#define SNDRV_SEQ_DEVICE_ARGPTR(dev) (void *)((char *)(dev) + sizeof(struct snd_seq_device)) +#define SNDRV_SEQ_DEVICE_ARGPTR(dev) (void *)((char *)(dev) + sizeof(snd_seq_device_t)) /* @@ -81,4 +84,5 @@ int snd_seq_device_unregister_driver(char *id); #define SNDRV_SEQ_DEV_ID_MIDISYNTH "seq-midi" #define SNDRV_SEQ_DEV_ID_OPL3 "opl3-synth" + #endif /* __SOUND_SEQ_DEVICE_H */ diff --git a/trunk/include/sound/seq_instr.h b/trunk/include/sound/seq_instr.h index db764f09efb7..1a654df4aa97 100644 --- a/trunk/include/sound/seq_instr.h +++ b/trunk/include/sound/seq_instr.h @@ -24,27 +24,29 @@ #include "seq_kernel.h" /* Instrument cluster */ -struct snd_seq_kcluster { +typedef struct _snd_seq_kcluster { snd_seq_instr_cluster_t cluster; char name[32]; int priority; - struct snd_seq_kcluster *next; -}; + struct _snd_seq_kcluster *next; +} snd_seq_kcluster_t; /* return pointer to private data */ -#define KINSTR_DATA(kinstr) (void *)(((char *)kinstr) + sizeof(struct snd_seq_kinstr)) +#define KINSTR_DATA(kinstr) (void *)(((char *)kinstr) + sizeof(snd_seq_kinstr_t)) + +typedef struct snd_seq_kinstr_ops snd_seq_kinstr_ops_t; /* Instrument structure */ -struct snd_seq_kinstr { - struct snd_seq_instr instr; +typedef struct _snd_seq_kinstr { + snd_seq_instr_t instr; char name[32]; int type; /* instrument type */ int use; /* use count */ int busy; /* not useable */ int add_len; /* additional length */ - struct snd_seq_kinstr_ops *ops; /* operations */ - struct snd_seq_kinstr *next; -}; + snd_seq_kinstr_ops_t *ops; /* operations */ + struct _snd_seq_kinstr *next; +} snd_seq_kinstr_t; #define SNDRV_SEQ_INSTR_HASH_SIZE 32 @@ -52,11 +54,11 @@ struct snd_seq_kinstr { #define SNDRV_SEQ_INSTR_FLG_DIRECT (1<<0) /* accept only direct events */ /* List of all instruments */ -struct snd_seq_kinstr_list { - struct snd_seq_kinstr *hash[SNDRV_SEQ_INSTR_HASH_SIZE]; +typedef struct { + snd_seq_kinstr_t *hash[SNDRV_SEQ_INSTR_HASH_SIZE]; int count; /* count of all instruments */ - struct snd_seq_kcluster *chash[SNDRV_SEQ_INSTR_HASH_SIZE]; + snd_seq_kcluster_t *chash[SNDRV_SEQ_INSTR_HASH_SIZE]; int ccount; /* count of all clusters */ int owner; /* current owner of the instrument list */ @@ -66,7 +68,7 @@ struct snd_seq_kinstr_list { spinlock_t ops_lock; struct semaphore ops_mutex; unsigned long ops_flags; -}; +} snd_seq_kinstr_list_t; #define SNDRV_SEQ_INSTR_NOTIFY_REMOVE 0 #define SNDRV_SEQ_INSTR_NOTIFY_CHANGE 1 @@ -76,33 +78,33 @@ struct snd_seq_kinstr_ops { long add_len; /* additional length */ char *instr_type; int (*info)(void *private_data, char *info_data, long len); - int (*put)(void *private_data, struct snd_seq_kinstr *kinstr, + int (*put)(void *private_data, snd_seq_kinstr_t *kinstr, char __user *instr_data, long len, int atomic, int cmd); - int (*get)(void *private_data, struct snd_seq_kinstr *kinstr, + int (*get)(void *private_data, snd_seq_kinstr_t *kinstr, char __user *instr_data, long len, int atomic, int cmd); - int (*get_size)(void *private_data, struct snd_seq_kinstr *kinstr, long *size); - int (*remove)(void *private_data, struct snd_seq_kinstr *kinstr, int atomic); - void (*notify)(void *private_data, struct snd_seq_kinstr *kinstr, int what); + int (*get_size)(void *private_data, snd_seq_kinstr_t *kinstr, long *size); + int (*remove)(void *private_data, snd_seq_kinstr_t *kinstr, int atomic); + void (*notify)(void *private_data, snd_seq_kinstr_t *kinstr, int what); struct snd_seq_kinstr_ops *next; }; /* instrument operations */ -struct snd_seq_kinstr_list *snd_seq_instr_list_new(void); -void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list); -int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list, - struct snd_seq_instr_header *ifree, +snd_seq_kinstr_list_t *snd_seq_instr_list_new(void); +void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list); +int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list, + snd_seq_instr_header_t *ifree, int client, int atomic); -struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list, - struct snd_seq_instr *instr, - int exact, - int follow_alias); -void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list, - struct snd_seq_kinstr *instr); -int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list, + snd_seq_instr_t *instr, + int exact, + int follow_alias); +void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list, + snd_seq_kinstr_t *instr); +int snd_seq_instr_event(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int client, int atomic, int hop); diff --git a/trunk/include/sound/seq_kernel.h b/trunk/include/sound/seq_kernel.h index f023c1b97f8c..4beca1952c76 100644 --- a/trunk/include/sound/seq_kernel.h +++ b/trunk/include/sound/seq_kernel.h @@ -24,8 +24,62 @@ #include #include "asequencer.h" -typedef struct snd_seq_real_time snd_seq_real_time_t; -typedef union snd_seq_timestamp snd_seq_timestamp_t; +typedef sndrv_seq_tick_time_t snd_seq_tick_time_t; +typedef sndrv_seq_position_t snd_seq_position_t; +typedef sndrv_seq_frequency_t snd_seq_frequency_t; +typedef sndrv_seq_instr_cluster_t snd_seq_instr_cluster_t; +typedef enum sndrv_seq_client_type snd_seq_client_type_t; +typedef enum sndrv_seq_stop_mode snd_seq_stop_mode_t; +typedef struct sndrv_seq_port_info snd_seq_port_info_t; +typedef struct sndrv_seq_port_subscribe snd_seq_port_subscribe_t; +typedef struct sndrv_seq_event snd_seq_event_t; +typedef struct sndrv_seq_addr snd_seq_addr_t; +typedef struct sndrv_seq_ev_volume snd_seq_ev_volume_t; +typedef struct sndrv_seq_ev_loop snd_seq_ev_loop_t; +typedef struct sndrv_seq_remove_events snd_seq_remove_events_t; +typedef struct sndrv_seq_query_subs snd_seq_query_subs_t; +typedef struct sndrv_seq_real_time snd_seq_real_time_t; +typedef struct sndrv_seq_system_info snd_seq_system_info_t; +typedef struct sndrv_seq_client_info snd_seq_client_info_t; +typedef struct sndrv_seq_queue_info snd_seq_queue_info_t; +typedef struct sndrv_seq_queue_status snd_seq_queue_status_t; +typedef struct sndrv_seq_queue_tempo snd_seq_queue_tempo_t; +typedef struct sndrv_seq_queue_owner snd_seq_queue_owner_t; +typedef struct sndrv_seq_queue_timer snd_seq_queue_timer_t; +typedef struct sndrv_seq_queue_client snd_seq_queue_client_t; +typedef struct sndrv_seq_client_pool snd_seq_client_pool_t; +typedef struct sndrv_seq_instr snd_seq_instr_t; +typedef struct sndrv_seq_instr_data snd_seq_instr_data_t; +typedef struct sndrv_seq_instr_header snd_seq_instr_header_t; +typedef union sndrv_seq_timestamp snd_seq_timestamp_t; + +#define snd_seq_event_bounce_ext_data sndrv_seq_event_bounce_ext_data +#define snd_seq_ev_is_result_type sndrv_seq_ev_is_result_type +#define snd_seq_ev_is_channel_type sndrv_seq_ev_is_channel_type +#define snd_seq_ev_is_note_type sndrv_seq_ev_is_note_type +#define snd_seq_ev_is_control_type sndrv_seq_ev_is_control_type +#define snd_seq_ev_is_queue_type sndrv_seq_ev_is_queue_type +#define snd_seq_ev_is_message_type sndrv_seq_ev_is_message_type +#define snd_seq_ev_is_sample_type sndrv_seq_ev_is_sample_type +#define snd_seq_ev_is_user_type sndrv_seq_ev_is_user_type +#define snd_seq_ev_is_fixed_type sndrv_seq_ev_is_fixed_type +#define snd_seq_ev_is_instr_type sndrv_seq_ev_is_instr_type +#define snd_seq_ev_is_variable_type sndrv_seq_ev_is_variable_type +#define snd_seq_ev_is_reserved sndrv_seq_ev_is_reserved +#define snd_seq_ev_is_direct sndrv_seq_ev_is_direct +#define snd_seq_ev_is_prior sndrv_seq_ev_is_prior +#define snd_seq_ev_length_type sndrv_seq_ev_length_type +#define snd_seq_ev_is_fixed sndrv_seq_ev_is_fixed +#define snd_seq_ev_is_variable sndrv_seq_ev_is_variable +#define snd_seq_ev_is_varusr sndrv_seq_ev_is_varusr +#define snd_seq_ev_timestamp_type sndrv_seq_ev_timestamp_type +#define snd_seq_ev_is_tick sndrv_seq_ev_is_tick +#define snd_seq_ev_is_real sndrv_seq_ev_is_real +#define snd_seq_ev_timemode_type sndrv_seq_ev_timemode_type +#define snd_seq_ev_is_abstime sndrv_seq_ev_is_abstime +#define snd_seq_ev_is_reltime sndrv_seq_ev_is_reltime +#define snd_seq_queue_sync_port sndrv_seq_queue_sync_port +#define snd_seq_queue_owner sndrv_seq_queue_owner /* maximum number of events dequeued per schedule interval */ #define SNDRV_SEQ_MAX_DEQUEUE 50 @@ -60,48 +114,69 @@ typedef union snd_seq_timestamp snd_seq_timestamp_t; /* max size of event size */ #define SNDRV_SEQ_MAX_EVENT_LEN 0x3fffffff +/* typedefs */ +struct _snd_seq_user_client; +struct _snd_seq_kernel_client; +struct _snd_seq_client; +struct _snd_seq_queue; + +typedef struct _snd_seq_user_client user_client_t; +typedef struct _snd_seq_kernel_client kernel_client_t; +typedef struct _snd_seq_client client_t; +typedef struct _snd_seq_queue queue_t; + +/* call-backs for kernel client */ + +typedef struct { + void *private_data; + unsigned allow_input: 1, + allow_output: 1; + /*...*/ +} snd_seq_client_callback_t; + /* call-backs for kernel port */ -struct snd_seq_port_callback { +typedef int (snd_seq_kernel_port_open_t)(void *private_data, snd_seq_port_subscribe_t *info); +typedef int (snd_seq_kernel_port_close_t)(void *private_data, snd_seq_port_subscribe_t *info); +typedef int (snd_seq_kernel_port_input_t)(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop); +typedef void (snd_seq_kernel_port_private_free_t)(void *private_data); + +typedef struct { struct module *owner; void *private_data; - int (*subscribe)(void *private_data, struct snd_seq_port_subscribe *info); - int (*unsubscribe)(void *private_data, struct snd_seq_port_subscribe *info); - int (*use)(void *private_data, struct snd_seq_port_subscribe *info); - int (*unuse)(void *private_data, struct snd_seq_port_subscribe *info); - int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop); - void (*private_free)(void *private_data); + snd_seq_kernel_port_open_t *subscribe; + snd_seq_kernel_port_close_t *unsubscribe; + snd_seq_kernel_port_open_t *use; + snd_seq_kernel_port_close_t *unuse; + snd_seq_kernel_port_input_t *event_input; + snd_seq_kernel_port_private_free_t *private_free; unsigned int callback_all; /* call subscribe callbacks at each connection/disconnection */ /*...*/ -}; +} snd_seq_port_callback_t; /* interface for kernel client */ -int snd_seq_create_kernel_client(struct snd_card *card, int client_index, - const char *name_fmt, ...) - __attribute__ ((format (printf, 3, 4))); -int snd_seq_delete_kernel_client(int client); -int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop); -int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event *ev, int atomic, int hop); -int snd_seq_kernel_client_ctl(int client, unsigned int cmd, void *arg); +extern int snd_seq_create_kernel_client(snd_card_t *card, int client_index, snd_seq_client_callback_t *callback); +extern int snd_seq_delete_kernel_client(int client); +extern int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t *ev, int atomic, int hop); +extern int snd_seq_kernel_client_dispatch(int client, snd_seq_event_t *ev, int atomic, int hop); +extern int snd_seq_kernel_client_ctl(int client, unsigned int cmd, void *arg); #define SNDRV_SEQ_EXT_MASK 0xc0000000 #define SNDRV_SEQ_EXT_USRPTR 0x80000000 #define SNDRV_SEQ_EXT_CHAINED 0x40000000 typedef int (*snd_seq_dump_func_t)(void *ptr, void *buf, int count); -int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char *buf, - int in_kernel, int size_aligned); -int snd_seq_dump_var_event(const struct snd_seq_event *event, - snd_seq_dump_func_t func, void *private_data); +int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf, int in_kernel, int size_aligned); +int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t func, void *private_data); /* interface for OSS emulation */ -int snd_seq_set_queue_tempo(int client, struct snd_seq_queue_tempo *tempo); +int snd_seq_set_queue_tempo(int client, snd_seq_queue_tempo_t *tempo); /* port callback routines */ -void snd_port_init_callback(struct snd_seq_port_callback *p); -struct snd_seq_port_callback *snd_port_alloc_callback(void); +void snd_port_init_callback(snd_seq_port_callback_t *p); +snd_seq_port_callback_t *snd_port_alloc_callback(void); /* port attach/detach */ -int snd_seq_event_port_attach(int client, struct snd_seq_port_callback *pcbp, +int snd_seq_event_port_attach(int client, snd_seq_port_callback_t *pcbp, int cap, int type, int midi_channels, int midi_voices, char *portname); int snd_seq_event_port_detach(int client, int port); diff --git a/trunk/include/sound/seq_midi_emul.h b/trunk/include/sound/seq_midi_emul.h index d6c4615901b9..e58ca45bc73b 100644 --- a/trunk/include/sound/seq_midi_emul.h +++ b/trunk/include/sound/seq_midi_emul.h @@ -29,7 +29,7 @@ * channel. All drivers for hardware that does not understand midi * directly will probably need to use this structure. */ -struct snd_midi_channel { +typedef struct snd_midi_channel { void *private; /* A back pointer to driver data */ int number; /* The channel number */ int client; /* The client associated with this channel */ @@ -53,43 +53,41 @@ struct snd_midi_channel { short gm_rpn_fine_tuning; /* Master fine tuning */ short gm_rpn_coarse_tuning; /* Master coarse tuning */ -}; +} snd_midi_channel_t; /* * A structure that represets a set of channels bound to a port. There * would usually be 16 channels per port. But fewer could be used for * particular cases. * The channel set consists of information describing the client and - * port for this midi synth and an array of snd_midi_channel structures. - * A driver that had no need for snd_midi_channel could still use the + * port for this midi synth and an array of snd_midi_channel_t structures. + * A driver that had no need for snd_midi_channel_t could still use the * channel set type if it wished with the channel array null. */ -struct snd_midi_channel_set { +typedef struct snd_midi_channel_set { void *private_data; /* Driver data */ int client; /* Client for this port */ int port; /* The port number */ int max_channels; /* Size of the channels array */ - struct snd_midi_channel *channels; + snd_midi_channel_t *channels; unsigned char midi_mode; /* MIDI operating mode */ unsigned char gs_master_volume; /* SYSEX master volume: 0-127 */ unsigned char gs_chorus_mode; unsigned char gs_reverb_mode; -}; +} snd_midi_channel_set_t; -struct snd_midi_op { - void (*note_on)(void *private_data, int note, int vel, struct snd_midi_channel *chan); - void (*note_off)(void *private_data,int note, int vel, struct snd_midi_channel *chan); /* release note */ - void (*key_press)(void *private_data, int note, int vel, struct snd_midi_channel *chan); - void (*note_terminate)(void *private_data, int note, struct snd_midi_channel *chan); /* terminate note immediately */ - void (*control)(void *private_data, int type, struct snd_midi_channel *chan); - void (*nrpn)(void *private_data, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset); - void (*sysex)(void *private_data, unsigned char *buf, int len, int parsed, - struct snd_midi_channel_set *chset); -}; +typedef struct snd_seq_midi_op { + void (*note_on)(void *private_data, int note, int vel, snd_midi_channel_t *chan); + void (*note_off)(void *private_data,int note, int vel, snd_midi_channel_t *chan); /* release note */ + void (*key_press)(void *private_data, int note, int vel, snd_midi_channel_t *chan); + void (*note_terminate)(void *private_data, int note, snd_midi_channel_t *chan); /* terminate note immediately */ + void (*control)(void *private_data, int type, snd_midi_channel_t *chan); + void (*nrpn)(void *private_data, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset); + void (*sysex)(void *private_data, unsigned char *buf, int len, int parsed, snd_midi_channel_set_t *chset); +} snd_midi_op_t; /* * These defines are used so that pitchbend, aftertouch etc, can be @@ -188,10 +186,10 @@ enum { }; /* Prototypes for midi_process.c */ -void snd_midi_process_event(struct snd_midi_op *ops, struct snd_seq_event *ev, - struct snd_midi_channel_set *chanset); -void snd_midi_channel_set_clear(struct snd_midi_channel_set *chset); -struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n); -void snd_midi_channel_free_set(struct snd_midi_channel_set *chset); +void snd_midi_process_event(snd_midi_op_t *ops, snd_seq_event_t *ev, + snd_midi_channel_set_t *chanset); +void snd_midi_channel_set_clear(snd_midi_channel_set_t *chset); +snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n); +void snd_midi_channel_free_set(snd_midi_channel_set_t *chset); #endif /* __SOUND_SEQ_MIDI_EMUL_H */ diff --git a/trunk/include/sound/seq_midi_event.h b/trunk/include/sound/seq_midi_event.h index dd789e7cdb20..8857e2bd31a5 100644 --- a/trunk/include/sound/seq_midi_event.h +++ b/trunk/include/sound/seq_midi_event.h @@ -26,8 +26,10 @@ #define MAX_MIDI_EVENT_BUF 256 +typedef struct snd_midi_event_t snd_midi_event_t; + /* midi status */ -struct snd_midi_event { +struct snd_midi_event_t { int qlen; /* queue length */ int read; /* chars read */ int type; /* current event type */ @@ -38,17 +40,15 @@ struct snd_midi_event { spinlock_t lock; }; -int snd_midi_event_new(int bufsize, struct snd_midi_event **rdev); -void snd_midi_event_free(struct snd_midi_event *dev); -void snd_midi_event_reset_encode(struct snd_midi_event *dev); -void snd_midi_event_reset_decode(struct snd_midi_event *dev); -void snd_midi_event_no_status(struct snd_midi_event *dev, int on); +int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev); +void snd_midi_event_free(snd_midi_event_t *dev); +void snd_midi_event_reset_encode(snd_midi_event_t *dev); +void snd_midi_event_reset_decode(snd_midi_event_t *dev); +void snd_midi_event_no_status(snd_midi_event_t *dev, int on); /* encode from byte stream - return number of written bytes if success */ -long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long count, - struct snd_seq_event *ev); -int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c, struct snd_seq_event *ev); +long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev); +int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev); /* decode from event to bytes - return number of written bytes if success */ -long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long count, - struct snd_seq_event *ev); +long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev); #endif /* __SOUND_SEQ_MIDI_EVENT_H */ diff --git a/trunk/include/sound/seq_oss.h b/trunk/include/sound/seq_oss.h index 9b060bbd6e02..bd7e57322ab6 100644 --- a/trunk/include/sound/seq_oss.h +++ b/trunk/include/sound/seq_oss.h @@ -24,17 +24,23 @@ #include "asequencer.h" #include "seq_kernel.h" +/* + * type definitions + */ +typedef struct snd_seq_oss_arg_t snd_seq_oss_arg_t; +typedef struct snd_seq_oss_callback_t snd_seq_oss_callback_t; + /* * argument structure for synthesizer operations */ -struct snd_seq_oss_arg { +struct snd_seq_oss_arg_t { /* given by OSS sequencer */ int app_index; /* application unique index */ int file_mode; /* file mode - see below */ int seq_mode; /* sequencer mode - see below */ /* following must be initialized in open callback */ - struct snd_seq_addr addr; /* opened port address */ + snd_seq_addr_t addr; /* opened port address */ void *private_data; /* private data for lowlevel drivers */ /* note-on event passing mode: initially given by OSS seq, @@ -47,14 +53,14 @@ struct snd_seq_oss_arg { /* * synthesizer operation callbacks */ -struct snd_seq_oss_callback { +struct snd_seq_oss_callback_t { struct module *owner; - int (*open)(struct snd_seq_oss_arg *p, void *closure); - int (*close)(struct snd_seq_oss_arg *p); - int (*ioctl)(struct snd_seq_oss_arg *p, unsigned int cmd, unsigned long arg); - int (*load_patch)(struct snd_seq_oss_arg *p, int format, const char __user *buf, int offs, int count); - int (*reset)(struct snd_seq_oss_arg *p); - int (*raw_event)(struct snd_seq_oss_arg *p, unsigned char *data); + int (*open)(snd_seq_oss_arg_t *p, void *closure); + int (*close)(snd_seq_oss_arg_t *p); + int (*ioctl)(snd_seq_oss_arg_t *p, unsigned int cmd, unsigned long arg); + int (*load_patch)(snd_seq_oss_arg_t *p, int format, const char __user *buf, int offs, int count); + int (*reset)(snd_seq_oss_arg_t *p); + int (*raw_event)(snd_seq_oss_arg_t *p, unsigned char *data); }; /* flag: file_mode */ @@ -82,13 +88,13 @@ struct snd_seq_oss_callback { /* * data pointer to snd_seq_register_device */ -struct snd_seq_oss_reg { +typedef struct snd_seq_oss_reg { int type; int subtype; int nvoices; - struct snd_seq_oss_callback oper; + snd_seq_oss_callback_t oper; void *private_data; -}; +} snd_seq_oss_reg_t; /* device id */ #define SNDRV_SEQ_DEV_ID_OSS "seq-oss" diff --git a/trunk/include/sound/seq_virmidi.h b/trunk/include/sound/seq_virmidi.h index 8d5aea76d7c3..1ad27e859af3 100644 --- a/trunk/include/sound/seq_virmidi.h +++ b/trunk/include/sound/seq_virmidi.h @@ -25,23 +25,25 @@ #include "rawmidi.h" #include "seq_midi_event.h" +typedef struct _snd_virmidi_dev snd_virmidi_dev_t; + /* * device file instance: * This instance is created at each time the midi device file is * opened. Each instance has its own input buffer and MIDI parser * (buffer), and is associated with the device instance. */ -struct snd_virmidi { +typedef struct _snd_virmidi { struct list_head list; int seq_mode; int client; int port; unsigned int trigger: 1; - struct snd_midi_event *parser; - struct snd_seq_event event; - struct snd_virmidi_dev *rdev; - struct snd_rawmidi_substream *substream; -}; + snd_midi_event_t *parser; + snd_seq_event_t event; + snd_virmidi_dev_t *rdev; + snd_rawmidi_substream_t *substream; +} snd_virmidi_t; #define SNDRV_VIRMIDI_SUBSCRIBE (1<<0) #define SNDRV_VIRMIDI_USE (1<<1) @@ -51,9 +53,9 @@ struct snd_virmidi { * Each virtual midi device has one device instance. It contains * common information and the linked-list of opened files, */ -struct snd_virmidi_dev { - struct snd_card *card; /* associated card */ - struct snd_rawmidi *rmidi; /* rawmidi device */ +struct _snd_virmidi_dev { + snd_card_t *card; /* associated card */ + snd_rawmidi_t *rmidi; /* rawmidi device */ int seq_mode; /* SNDRV_VIRMIDI_XXX */ int device; /* sequencer device */ int client; /* created/attached client */ @@ -76,6 +78,6 @@ struct snd_virmidi_dev { #define SNDRV_VIRMIDI_SEQ_ATTACH 1 #define SNDRV_VIRMIDI_SEQ_DISPATCH 2 -int snd_virmidi_new(struct snd_card *card, int device, struct snd_rawmidi **rrmidi); +int snd_virmidi_new(snd_card_t *card, int device, snd_rawmidi_t **rrmidi); #endif /* __SOUND_SEQ_VIRMIDI */ diff --git a/trunk/include/sound/sfnt_info.h b/trunk/include/sound/sfnt_info.h index 5d1ab9c4950f..674585f88a31 100644 --- a/trunk/include/sound/sfnt_info.h +++ b/trunk/include/sound/sfnt_info.h @@ -35,7 +35,7 @@ #endif /* patch interface header: 16 bytes */ -struct soundfont_patch_info { +typedef struct soundfont_patch_info_t { unsigned short key; /* use the key below */ #define SNDRV_OSS_SOUNDFONT_PATCH SNDRV_OSS_PATCHKEY(0x07) @@ -59,7 +59,7 @@ struct soundfont_patch_info { short reserved; /* word alignment data */ /* the actual patch data begins after this */ -}; +} soundfont_patch_info_t; /* @@ -68,7 +68,7 @@ struct soundfont_patch_info { #define SNDRV_SFNT_PATCH_NAME_LEN 32 -struct soundfont_open_parm { +typedef struct soundfont_open_parm_t { unsigned short type; /* sample type */ #define SNDRV_SFNT_PAT_TYPE_MISC 0 #define SNDRV_SFNT_PAT_TYPE_GUS 6 @@ -78,7 +78,7 @@ struct soundfont_open_parm { short reserved; char name[SNDRV_SFNT_PATCH_NAME_LEN]; -}; +} soundfont_open_parm_t; /* @@ -86,7 +86,7 @@ struct soundfont_open_parm { */ /* wave table envelope & effect parameters to control EMU8000 */ -struct soundfont_voice_parm { +typedef struct soundfont_voice_parm_t { unsigned short moddelay; /* modulation delay (0x8000) */ unsigned short modatkhld; /* modulation attack & hold time (0x7f7f) */ unsigned short moddcysus; /* modulation decay & sustain (0x7f7f) */ @@ -108,11 +108,11 @@ struct soundfont_voice_parm { unsigned char chorus; /* chorus send (0x00) */ unsigned char reverb; /* reverb send (0x00) */ unsigned short reserved[4]; /* not used */ -}; +} soundfont_voice_parm_t; /* wave table parameters: 92 bytes */ -struct soundfont_voice_info { +typedef struct soundfont_voice_info_t { unsigned short sf_id; /* file id (should be zero) */ unsigned short sample; /* sample id */ int start, end; /* sample offset correction */ @@ -135,13 +135,13 @@ struct soundfont_voice_info { unsigned char amplitude; /* sample volume (127 max) */ unsigned char attenuation; /* attenuation (0.375dB) */ short scaleTuning; /* pitch scale tuning(%), normally 100 */ - struct soundfont_voice_parm parm; /* voice envelope parameters */ + soundfont_voice_parm_t parm; /* voice envelope parameters */ unsigned short sample_mode; /* sample mode_flag (set by driver) */ -}; +} soundfont_voice_info_t; /* instrument info header: 4 bytes */ -struct soundfont_voice_rec_hdr { +typedef struct soundfont_voice_rec_hdr_t { unsigned char bank; /* midi bank number */ unsigned char instr; /* midi preset number */ char nvoices; /* number of voices */ @@ -149,7 +149,7 @@ struct soundfont_voice_rec_hdr { #define SNDRV_SFNT_WR_APPEND 0 /* append anyway */ #define SNDRV_SFNT_WR_EXCLUSIVE 1 /* skip if already exists */ #define SNDRV_SFNT_WR_REPLACE 2 /* replace if already exists */ -}; +} soundfont_voice_rec_hdr_t; /* @@ -157,7 +157,7 @@ struct soundfont_voice_rec_hdr { */ /* wave table sample header: 32 bytes */ -struct soundfont_sample_info { +typedef struct soundfont_sample_info_t { unsigned short sf_id; /* file id (should be zero) */ unsigned short sample; /* sample id */ int start, end; /* start & end offset */ @@ -174,17 +174,17 @@ struct soundfont_sample_info { #define SNDRV_SFNT_SAMPLE_STEREO_RIGHT 64 /* stereo right sound */ #define SNDRV_SFNT_SAMPLE_REVERSE_LOOP 128 /* reverse looping */ unsigned int truesize; /* used memory size (set by driver) */ -}; +} soundfont_sample_info_t; /* * voice preset mapping (aliasing) */ -struct soundfont_voice_map { +typedef struct soundfont_voice_map_t { int map_bank, map_instr, map_key; /* key = -1 means all keys */ int src_bank, src_instr, src_key; -}; +} soundfont_voice_map_t; /* @@ -195,7 +195,7 @@ struct soundfont_voice_map { #define SNDRV_EMUX_VERSION ((1 << 16) | (0 << 8) | 0) /* 1.0.0 */ -struct snd_emux_misc_mode { +struct sndrv_emux_misc_mode { int port; /* -1 = all */ int mode; int value; @@ -204,11 +204,11 @@ struct snd_emux_misc_mode { enum { SNDRV_EMUX_IOCTL_VERSION = _IOR('H', 0x80, unsigned int), - SNDRV_EMUX_IOCTL_LOAD_PATCH = _IOWR('H', 0x81, struct soundfont_patch_info), + SNDRV_EMUX_IOCTL_LOAD_PATCH = _IOWR('H', 0x81, soundfont_patch_info_t), SNDRV_EMUX_IOCTL_RESET_SAMPLES = _IO('H', 0x82), SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES = _IO('H', 0x83), SNDRV_EMUX_IOCTL_MEM_AVAIL = _IOW('H', 0x84, int), - SNDRV_EMUX_IOCTL_MISC_MODE = _IOWR('H', 0x84, struct snd_emux_misc_mode), + SNDRV_EMUX_IOCTL_MISC_MODE = _IOWR('H', 0x84, struct sndrv_emux_misc_mode), }; #endif /* __SOUND_SFNT_INFO_H */ diff --git a/trunk/include/sound/snd_wavefront.h b/trunk/include/sound/snd_wavefront.h index 0b9e5de94ff1..4b0b2b9370b9 100644 --- a/trunk/include/sound/snd_wavefront.h +++ b/trunk/include/sound/snd_wavefront.h @@ -26,8 +26,8 @@ struct _snd_wavefront_midi { snd_wavefront_mpu_id output_mpu; /* most-recently-used */ snd_wavefront_mpu_id input_mpu; /* most-recently-used */ unsigned int mode[2]; /* MPU401_MODE_XXX */ - struct snd_rawmidi_substream *substream_output[2]; - struct snd_rawmidi_substream *substream_input[2]; + snd_rawmidi_substream_t *substream_output[2]; + snd_rawmidi_substream_t *substream_input[2]; struct timer_list timer; spinlock_t open; spinlock_t virtual; /* protects isvirtual */ @@ -38,8 +38,8 @@ struct _snd_wavefront_midi { #define MPU_ACK 0xFE #define UART_MODE_ON 0x3F -extern struct snd_rawmidi_ops snd_wavefront_midi_output; -extern struct snd_rawmidi_ops snd_wavefront_midi_input; +extern snd_rawmidi_ops_t snd_wavefront_midi_output; +extern snd_rawmidi_ops_t snd_wavefront_midi_input; extern void snd_wavefront_midi_enable_virtual (snd_wavefront_card_t *); extern void snd_wavefront_midi_disable_virtual (snd_wavefront_card_t *); @@ -116,23 +116,23 @@ extern int snd_wavefront_config_midi (snd_wavefront_t *dev) ; extern int snd_wavefront_cmd (snd_wavefront_t *, int, unsigned char *, unsigned char *); -extern int snd_wavefront_synth_ioctl (struct snd_hwdep *, +extern int snd_wavefront_synth_ioctl (snd_hwdep_t *, struct file *, unsigned int cmd, unsigned long arg); -extern int snd_wavefront_synth_open (struct snd_hwdep *, struct file *); -extern int snd_wavefront_synth_release (struct snd_hwdep *, struct file *); +extern int snd_wavefront_synth_open (snd_hwdep_t *, struct file *); +extern int snd_wavefront_synth_release (snd_hwdep_t *, struct file *); /* FX processor - see also yss225.[ch] */ extern int snd_wavefront_fx_start (snd_wavefront_t *); extern int snd_wavefront_fx_detect (snd_wavefront_t *); -extern int snd_wavefront_fx_ioctl (struct snd_hwdep *, +extern int snd_wavefront_fx_ioctl (snd_hwdep_t *, struct file *, unsigned int cmd, unsigned long arg); -extern int snd_wavefront_fx_open (struct snd_hwdep *, struct file *); -extern int snd_wavefront_fx_release (struct snd_hwdep *, struct file *); +extern int snd_wavefront_fx_open (snd_hwdep_t *, struct file *); +extern int snd_wavefront_fx_release (snd_hwdep_t *, struct file *); /* prefix in all snd_printk() delivered messages */ diff --git a/trunk/include/sound/soundfont.h b/trunk/include/sound/soundfont.h index 61a010c65d02..c992958f5e3c 100644 --- a/trunk/include/sound/soundfont.h +++ b/trunk/include/sound/soundfont.h @@ -29,93 +29,94 @@ #define SF_MAX_PRESETS 256 /* drums are mapped from 128 to 256 */ #define SF_IS_DRUM_BANK(z) ((z) == 128) -struct snd_sf_zone { +typedef struct snd_sf_zone { struct snd_sf_zone *next; /* Link to next */ unsigned char bank; /* Midi bank for this zone */ unsigned char instr; /* Midi program for this zone */ unsigned char mapped; /* True if mapped to something else */ - struct soundfont_voice_info v; /* All the soundfont parameters */ + soundfont_voice_info_t v; /* All the soundfont parameters */ int counter; struct snd_sf_sample *sample; /* Link to sample */ /* The following deals with preset numbers (programs) */ struct snd_sf_zone *next_instr; /* Next zone of this instrument */ struct snd_sf_zone *next_zone; /* Next zone in play list */ -}; +} snd_sf_zone_t; -struct snd_sf_sample { - struct soundfont_sample_info v; +typedef struct snd_sf_sample { + soundfont_sample_info_t v; int counter; - struct snd_util_memblk *block; /* allocated data block */ + snd_util_memblk_t *block; /* allocated data block */ struct snd_sf_sample *next; -}; +} snd_sf_sample_t; /* * This represents all the information relating to a soundfont. */ -struct snd_soundfont { +typedef struct snd_soundfont { struct snd_soundfont *next; /* Link to next */ /*struct snd_soundfont *prev;*/ /* Link to previous */ short id; /* file id */ short type; /* font type */ unsigned char name[SNDRV_SFNT_PATCH_NAME_LEN]; /* identifier */ - struct snd_sf_zone *zones; /* Font information */ - struct snd_sf_sample *samples; /* The sample headers */ -}; + snd_sf_zone_t *zones; /* Font information */ + snd_sf_sample_t *samples; /* The sample headers */ +} snd_soundfont_t; /* * Type of the sample access callback */ -struct snd_sf_callback { +typedef int (*snd_sf_sample_new_t)(void *private_data, snd_sf_sample_t *sp, + snd_util_memhdr_t *hdr, const void __user *buf, long count); +typedef int (*snd_sf_sample_free_t)(void *private_data, snd_sf_sample_t *sp, + snd_util_memhdr_t *hdr); +typedef void (*snd_sf_sample_reset_t)(void *private); + +typedef struct snd_sf_callback { void *private_data; - int (*sample_new)(void *private_data, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr, - const void __user *buf, long count); - int (*sample_free)(void *private_data, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr); - void (*sample_reset)(void *private); -}; + snd_sf_sample_new_t sample_new; + snd_sf_sample_free_t sample_free; + snd_sf_sample_reset_t sample_reset; +} snd_sf_callback_t; /* * List of soundfonts. */ -struct snd_sf_list { - struct snd_soundfont *currsf; /* The currently open soundfont */ +typedef struct snd_sf_list { + snd_soundfont_t *currsf; /* The currently open soundfont */ int open_client; /* client pointer for lock */ int mem_used; /* used memory size */ - struct snd_sf_zone *presets[SF_MAX_PRESETS]; - struct snd_soundfont *fonts; /* The list of soundfonts */ + snd_sf_zone_t *presets[SF_MAX_PRESETS]; + snd_soundfont_t *fonts; /* The list of soundfonts */ int fonts_size; /* number of fonts allocated */ int zone_counter; /* last allocated time for zone */ int sample_counter; /* last allocated time for sample */ int zone_locked; /* locked time for zone */ int sample_locked; /* locked time for sample */ - struct snd_sf_callback callback; /* callback functions */ + snd_sf_callback_t callback; /* callback functions */ int presets_locked; struct semaphore presets_mutex; spinlock_t lock; - struct snd_util_memhdr *memhdr; -}; + snd_util_memhdr_t *memhdr; +} snd_sf_list_t; /* Prototypes for soundfont.c */ -int snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data, - long count, int client); -int snd_soundfont_load_guspatch(struct snd_sf_list *sflist, const char __user *data, +int snd_soundfont_load(snd_sf_list_t *sflist, const void __user *data, long count, int client); +int snd_soundfont_load_guspatch(snd_sf_list_t *sflist, const char __user *data, long count, int client); -int snd_soundfont_close_check(struct snd_sf_list *sflist, int client); +int snd_soundfont_close_check(snd_sf_list_t *sflist, int client); -struct snd_sf_list *snd_sf_new(struct snd_sf_callback *callback, - struct snd_util_memhdr *hdr); -void snd_sf_free(struct snd_sf_list *sflist); +snd_sf_list_t *snd_sf_new(snd_sf_callback_t *callback, snd_util_memhdr_t *hdr); +void snd_sf_free(snd_sf_list_t *sflist); -int snd_soundfont_remove_samples(struct snd_sf_list *sflist); -int snd_soundfont_remove_unlocked(struct snd_sf_list *sflist); +int snd_soundfont_remove_samples(snd_sf_list_t *sflist); +int snd_soundfont_remove_unlocked(snd_sf_list_t *sflist); -int snd_soundfont_search_zone(struct snd_sf_list *sflist, int *notep, int vel, +int snd_soundfont_search_zone(snd_sf_list_t *sflist, int *notep, int vel, int preset, int bank, int def_preset, int def_bank, - struct snd_sf_zone **table, int max_layers); + snd_sf_zone_t **table, int max_layers); /* Parameter conversions */ int snd_sf_calc_parm_hold(int msec); diff --git a/trunk/include/sound/tea575x-tuner.h b/trunk/include/sound/tea575x-tuner.h index a4f554520197..b82e408e758f 100644 --- a/trunk/include/sound/tea575x-tuner.h +++ b/trunk/include/sound/tea575x-tuner.h @@ -24,15 +24,15 @@ #include -struct snd_tea575x; +typedef struct snd_tea575x tea575x_t; struct snd_tea575x_ops { - void (*write)(struct snd_tea575x *tea, unsigned int val); - unsigned int (*read)(struct snd_tea575x *tea); + void (*write)(tea575x_t *tea, unsigned int val); + unsigned int (*read)(tea575x_t *tea); }; struct snd_tea575x { - struct snd_card *card; + snd_card_t *card; struct video_device vd; /* video device */ struct file_operations fops; int dev_nr; /* requested device number + 1 */ @@ -45,7 +45,7 @@ struct snd_tea575x { void *private_data; }; -void snd_tea575x_init(struct snd_tea575x *tea); -void snd_tea575x_exit(struct snd_tea575x *tea); +void snd_tea575x_init(tea575x_t *tea); +void snd_tea575x_exit(tea575x_t *tea); #endif /* __SOUND_TEA575X_TUNER_H */ diff --git a/trunk/include/sound/tea6330t.h b/trunk/include/sound/tea6330t.h index 51b282b76896..3896c0a50907 100644 --- a/trunk/include/sound/tea6330t.h +++ b/trunk/include/sound/tea6330t.h @@ -22,10 +22,21 @@ * */ +#include "control.h" #include "i2c.h" /* generic i2c support */ -int snd_tea6330t_detect(struct snd_i2c_bus *bus, int equalizer); -int snd_tea6330t_update_mixer(struct snd_card *card, struct snd_i2c_bus *bus, - int equalizer, int fader); +typedef struct { + snd_i2c_device_t *device; + snd_i2c_bus_t *bus; + int equalizer; + int fader; + unsigned char regs[8]; + unsigned char mleft, mright; + unsigned char bass, treble; + unsigned char max_bass, max_treble; +} tea6330t_t; + +extern int snd_tea6330t_detect(snd_i2c_bus_t *bus, int equalizer); +extern int snd_tea6330t_update_mixer(snd_card_t * card, snd_i2c_bus_t * bus, int equalizer, int fader); #endif /* __SOUND_TEA6330T_H */ diff --git a/trunk/include/sound/timer.h b/trunk/include/sound/timer.h index 5ece2bf541dc..b55f38ae56e1 100644 --- a/trunk/include/sound/timer.h +++ b/trunk/include/sound/timer.h @@ -26,6 +26,20 @@ #include #include +typedef enum sndrv_timer_class snd_timer_class_t; +typedef enum sndrv_timer_slave_class snd_timer_slave_class_t; +typedef enum sndrv_timer_global snd_timer_global_t; +typedef struct sndrv_timer_id snd_timer_id_t; +typedef struct sndrv_timer_ginfo snd_timer_ginfo_t; +typedef struct sndrv_timer_gparams snd_timer_gparams_t; +typedef struct sndrv_timer_gstatus snd_timer_gstatus_t; +typedef struct sndrv_timer_select snd_timer_select_t; +typedef struct sndrv_timer_info snd_timer_info_t; +typedef struct sndrv_timer_params snd_timer_params_t; +typedef struct sndrv_timer_status snd_timer_status_t; +typedef struct sndrv_timer_read snd_timer_read_t; +typedef struct sndrv_timer_tread snd_timer_tread_t; + #define snd_timer_chip(timer) ((timer)->private_data) #define SNDRV_TIMER_DEVICES 16 @@ -50,9 +64,11 @@ #define SNDRV_TIMER_FLG_CHANGE 0x00000001 #define SNDRV_TIMER_FLG_RESCHED 0x00000002 /* need reschedule */ -struct snd_timer; +typedef void (*snd_timer_callback_t) (snd_timer_instance_t * timeri, unsigned long ticks, unsigned long resolution); +typedef void (*snd_timer_ccallback_t) (snd_timer_instance_t * timeri, enum sndrv_timer_event event, + struct timespec * tstamp, unsigned long resolution); -struct snd_timer_hardware { +struct _snd_timer_hardware { /* -- must be filled with low-level driver */ unsigned int flags; /* various flags */ unsigned long resolution; /* average timer resolution for one tick in nsec */ @@ -60,18 +76,18 @@ struct snd_timer_hardware { unsigned long resolution_max; /* maximal resolution */ unsigned long ticks; /* max timer ticks per interrupt */ /* -- low-level functions -- */ - int (*open) (struct snd_timer * timer); - int (*close) (struct snd_timer * timer); - unsigned long (*c_resolution) (struct snd_timer * timer); - int (*start) (struct snd_timer * timer); - int (*stop) (struct snd_timer * timer); - int (*set_period) (struct snd_timer * timer, unsigned long period_num, unsigned long period_den); - int (*precise_resolution) (struct snd_timer * timer, unsigned long *num, unsigned long *den); + int (*open) (snd_timer_t * timer); + int (*close) (snd_timer_t * timer); + unsigned long (*c_resolution) (snd_timer_t * timer); + int (*start) (snd_timer_t * timer); + int (*stop) (snd_timer_t * timer); + int (*set_period) (snd_timer_t * timer, unsigned long period_num, unsigned long period_den); + int (*precise_resolution) (snd_timer_t * timer, unsigned long *num, unsigned long *den); }; -struct snd_timer { - int tmr_class; - struct snd_card *card; +struct _snd_timer { + snd_timer_class_t tmr_class; + snd_card_t *card; struct module *module; int tmr_device; int tmr_subdevice; @@ -81,8 +97,8 @@ struct snd_timer { int running; /* running instances */ unsigned long sticks; /* schedule ticks */ void *private_data; - void (*private_free) (struct snd_timer *timer); - struct snd_timer_hardware hw; + void (*private_free) (snd_timer_t *timer); + struct _snd_timer_hardware hw; spinlock_t lock; struct list_head device_list; struct list_head open_list_head; @@ -92,53 +108,49 @@ struct snd_timer { struct tasklet_struct task_queue; }; -struct snd_timer_instance { - struct snd_timer *timer; +struct _snd_timer_instance { + snd_timer_t * timer; char *owner; unsigned int flags; void *private_data; - void (*private_free) (struct snd_timer_instance *ti); - void (*callback) (struct snd_timer_instance *timeri, - unsigned long ticks, unsigned long resolution); - void (*ccallback) (struct snd_timer_instance * timeri, - int event, - struct timespec * tstamp, - unsigned long resolution); + void (*private_free) (snd_timer_instance_t *ti); + snd_timer_callback_t callback; + snd_timer_ccallback_t ccallback; void *callback_data; unsigned long ticks; /* auto-load ticks when expired */ unsigned long cticks; /* current ticks */ unsigned long pticks; /* accumulated ticks for callback */ unsigned long resolution; /* current resolution for tasklet */ unsigned long lost; /* lost ticks */ - int slave_class; + snd_timer_slave_class_t slave_class; unsigned int slave_id; struct list_head open_list; struct list_head active_list; struct list_head ack_list; struct list_head slave_list_head; struct list_head slave_active_head; - struct snd_timer_instance *master; + snd_timer_instance_t *master; }; /* * Registering */ -int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid, struct snd_timer **rtimer); -void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstamp); -int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer); -int snd_timer_global_free(struct snd_timer *timer); -int snd_timer_global_register(struct snd_timer *timer); -int snd_timer_global_unregister(struct snd_timer *timer); - -int snd_timer_open(struct snd_timer_instance **ti, char *owner, struct snd_timer_id *tid, unsigned int slave_id); -int snd_timer_close(struct snd_timer_instance *timeri); -unsigned long snd_timer_resolution(struct snd_timer_instance *timeri); -int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks); -int snd_timer_stop(struct snd_timer_instance *timeri); -int snd_timer_continue(struct snd_timer_instance *timeri); -int snd_timer_pause(struct snd_timer_instance *timeri); - -void snd_timer_interrupt(struct snd_timer *timer, unsigned long ticks_left); +extern int snd_timer_new(snd_card_t *card, char *id, snd_timer_id_t *tid, snd_timer_t ** rtimer); +extern void snd_timer_notify(snd_timer_t *timer, enum sndrv_timer_event event, struct timespec *tstamp); +extern int snd_timer_global_new(char *id, int device, snd_timer_t **rtimer); +extern int snd_timer_global_free(snd_timer_t *timer); +extern int snd_timer_global_register(snd_timer_t *timer); +extern int snd_timer_global_unregister(snd_timer_t *timer); + +extern int snd_timer_open(snd_timer_instance_t ** ti, char *owner, snd_timer_id_t *tid, unsigned int slave_id); +extern int snd_timer_close(snd_timer_instance_t * timeri); +extern unsigned long snd_timer_resolution(snd_timer_instance_t * timeri); +extern int snd_timer_start(snd_timer_instance_t * timeri, unsigned int ticks); +extern int snd_timer_stop(snd_timer_instance_t * timeri); +extern int snd_timer_continue(snd_timer_instance_t * timeri); +extern int snd_timer_pause(snd_timer_instance_t * timeri); + +extern void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left); #endif /* __SOUND_TIMER_H */ diff --git a/trunk/include/sound/trident.h b/trunk/include/sound/trident.h index 9752243241e5..a408d3925050 100644 --- a/trunk/include/sound/trident.h +++ b/trunk/include/sound/trident.h @@ -253,43 +253,43 @@ enum serial_intf_ctrl_bits { #define T4D_DEFAULT_PCM_RVOL 127 /* 0 - 127 */ #define T4D_DEFAULT_PCM_CVOL 127 /* 0 - 127 */ -struct snd_trident; -struct snd_trident_voice; -struct snd_trident_pcm_mixer; - -struct snd_trident_sample_ops { - void (*sample_start)(struct snd_trident *gus, struct snd_trident_voice *voice, snd_seq_position_t position); - void (*sample_stop)(struct snd_trident *gus, struct snd_trident_voice *voice, int mode); - void (*sample_freq)(struct snd_trident *gus, struct snd_trident_voice *voice, snd_seq_frequency_t freq); - void (*sample_volume)(struct snd_trident *gus, struct snd_trident_voice *voice, struct snd_seq_ev_volume *volume); - void (*sample_loop)(struct snd_trident *card, struct snd_trident_voice *voice, struct snd_seq_ev_loop *loop); - void (*sample_pos)(struct snd_trident *card, struct snd_trident_voice *voice, snd_seq_position_t position); - void (*sample_private1)(struct snd_trident *card, struct snd_trident_voice *voice, unsigned char *data); -}; - -struct snd_trident_port { - struct snd_midi_channel_set * chset; - struct snd_trident * trident; +typedef struct _snd_trident trident_t; +typedef struct _snd_trident_voice snd_trident_voice_t; +typedef struct _snd_trident_pcm_mixer snd_trident_pcm_mixer_t; + +typedef struct { + void (*sample_start)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_position_t position); + void (*sample_stop)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_stop_mode_t mode); + void (*sample_freq)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_frequency_t freq); + void (*sample_volume)(trident_t *gus, snd_trident_voice_t *voice, snd_seq_ev_volume_t *volume); + void (*sample_loop)(trident_t *card, snd_trident_voice_t *voice, snd_seq_ev_loop_t *loop); + void (*sample_pos)(trident_t *card, snd_trident_voice_t *voice, snd_seq_position_t position); + void (*sample_private1)(trident_t *card, snd_trident_voice_t *voice, unsigned char *data); +} snd_trident_sample_ops_t; + +typedef struct { + snd_midi_channel_set_t * chset; + trident_t * trident; int mode; /* operation mode */ int client; /* sequencer client number */ int port; /* sequencer port number */ unsigned int midi_has_voices: 1; -}; +} snd_trident_port_t; -struct snd_trident_memblk_arg { +typedef struct snd_trident_memblk_arg { short first_page, last_page; -}; +} snd_trident_memblk_arg_t; -struct snd_trident_tlb { +typedef struct { unsigned int * entries; /* 16k-aligned TLB table */ dma_addr_t entries_dmaaddr; /* 16k-aligned PCI address to TLB table */ unsigned long * shadow_entries; /* shadow entries with virtual addresses */ struct snd_dma_buffer buffer; - struct snd_util_memhdr * memhdr; /* page allocation list */ + snd_util_memhdr_t * memhdr; /* page allocation list */ struct snd_dma_buffer silent_page; -}; +} snd_trident_tlb_t; -struct snd_trident_voice { +struct _snd_trident_voice { unsigned int number; unsigned int use: 1, pcm: 1, @@ -300,8 +300,8 @@ struct snd_trident_voice { unsigned char port; unsigned char index; - struct snd_seq_instr instr; - struct snd_trident_sample_ops *sample_ops; + snd_seq_instr_t instr; + snd_trident_sample_ops_t *sample_ops; /* channel parameters */ unsigned int CSO; /* 24 bits (16 on DX) */ @@ -323,13 +323,13 @@ struct snd_trident_voice { unsigned int negCSO; /* nonzero - use negative CSO */ - struct snd_util_memblk *memblk; /* memory block if TLB enabled */ + snd_util_memblk_t *memblk; /* memory block if TLB enabled */ /* PCM data */ - struct snd_trident *trident; - struct snd_pcm_substream *substream; - struct snd_trident_voice *extra; /* extra PCM voice (acts as interrupt generator) */ + trident_t *trident; + snd_pcm_substream_t *substream; + snd_trident_voice_t *extra; /* extra PCM voice (acts as interrupt generator) */ unsigned int running: 1, capture: 1, spdif: 1, @@ -347,25 +347,25 @@ struct snd_trident_voice { /* --- */ void *private_data; - void (*private_free)(struct snd_trident_voice *voice); + void (*private_free)(snd_trident_voice_t *voice); }; -struct snd_4dwave { +struct _snd_4dwave { int seq_client; - struct snd_trident_port seq_ports[4]; - struct snd_simple_ops simple_ops; - struct snd_seq_kinstr_list *ilist; + snd_trident_port_t seq_ports[4]; + snd_simple_ops_t simple_ops; + snd_seq_kinstr_list_t *ilist; - struct snd_trident_voice voices[64]; + snd_trident_voice_t voices[64]; int ChanSynthCount; /* number of allocated synth channels */ int max_size; /* maximum synth memory size in bytes */ int current_size; /* current allocated synth mem in bytes */ }; -struct snd_trident_pcm_mixer { - struct snd_trident_voice *voice; /* active voice */ +struct _snd_trident_pcm_mixer { + snd_trident_voice_t *voice; /* active voice */ unsigned short vol; /* front volume */ unsigned char pan; /* pan control */ unsigned char rvol; /* rear volume */ @@ -373,7 +373,7 @@ struct snd_trident_pcm_mixer { unsigned char pad; }; -struct snd_trident { +struct _snd_trident { int irq; unsigned int device; /* device ID */ @@ -386,13 +386,13 @@ struct snd_trident { unsigned int spurious_irq_count; unsigned int spurious_irq_max_delta; - struct snd_trident_tlb tlb; /* TLB entries for NX cards */ + snd_trident_tlb_t tlb; /* TLB entries for NX cards */ unsigned char spdif_ctrl; unsigned char spdif_pcm_ctrl; unsigned int spdif_bits; unsigned int spdif_pcm_bits; - struct snd_kcontrol *spdif_pcm_ctl; /* S/PDIF settings */ + snd_kcontrol_t *spdif_pcm_ctl; /* S/PDIF settings */ unsigned int ac97_ctrl; unsigned int ChanMap[2]; /* allocation map for hardware channels */ @@ -403,7 +403,7 @@ struct snd_trident { unsigned int ac97_detect: 1; /* 1 = AC97 in detection phase */ unsigned int in_suspend: 1; /* 1 during suspend/resume */ - struct snd_4dwave synth; /* synth specific variables */ + struct _snd_4dwave synth; /* synth specific variables */ spinlock_t event_lock; spinlock_t voice_alloc; @@ -411,57 +411,52 @@ struct snd_trident { struct snd_dma_device dma_dev; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; /* ADC/DAC PCM */ - struct snd_pcm *foldback; /* Foldback PCM */ - struct snd_pcm *spdif; /* SPDIF PCM */ - struct snd_rawmidi *rmidi; - struct snd_seq_device *seq_dev; + snd_card_t *card; + snd_pcm_t *pcm; /* ADC/DAC PCM */ + snd_pcm_t *foldback; /* Foldback PCM */ + snd_pcm_t *spdif; /* SPDIF PCM */ + snd_rawmidi_t *rmidi; + snd_seq_device_t *seq_dev; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; - struct snd_ac97 *ac97_sec; + ac97_bus_t *ac97_bus; + ac97_t *ac97; + ac97_t *ac97_sec; unsigned int musicvol_wavevol; - struct snd_trident_pcm_mixer pcm_mixer[32]; - struct snd_kcontrol *ctl_vol; /* front volume */ - struct snd_kcontrol *ctl_pan; /* pan */ - struct snd_kcontrol *ctl_rvol; /* rear volume */ - struct snd_kcontrol *ctl_cvol; /* center volume */ + snd_trident_pcm_mixer_t pcm_mixer[32]; + snd_kcontrol_t *ctl_vol; /* front volume */ + snd_kcontrol_t *ctl_pan; /* pan */ + snd_kcontrol_t *ctl_rvol; /* rear volume */ + snd_kcontrol_t *ctl_cvol; /* center volume */ spinlock_t reg_lock; struct gameport *gameport; }; -int snd_trident_create(struct snd_card *card, +int snd_trident_create(snd_card_t * card, struct pci_dev *pci, int pcm_streams, int pcm_spdif_device, int max_wavetable_size, - struct snd_trident ** rtrident); -int snd_trident_create_gameport(struct snd_trident *trident); - -int snd_trident_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm); -int snd_trident_foldback_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm); -int snd_trident_spdif_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm); -int snd_trident_attach_synthesizer(struct snd_trident * trident); -struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, - int client, int port); -void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice); -void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice); -void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice); -void snd_trident_write_voice_regs(struct snd_trident * trident, struct snd_trident_voice *voice); -int snd_trident_suspend(struct pci_dev *pci, pm_message_t state); -int snd_trident_resume(struct pci_dev *pci); + trident_t ** rtrident); +int snd_trident_create_gameport(trident_t *trident); + +int snd_trident_pcm(trident_t * trident, int device, snd_pcm_t **rpcm); +int snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_t **rpcm); +int snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t **rpcm); +int snd_trident_attach_synthesizer(trident_t * trident); +snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int client, int port); +void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice); +void snd_trident_start_voice(trident_t * trident, unsigned int voice); +void snd_trident_stop_voice(trident_t * trident, unsigned int voice); +void snd_trident_write_voice_regs(trident_t * trident, snd_trident_voice_t *voice); /* TLB memory allocation */ -struct snd_util_memblk *snd_trident_alloc_pages(struct snd_trident *trident, - struct snd_pcm_substream *substream); -int snd_trident_free_pages(struct snd_trident *trident, struct snd_util_memblk *blk); -struct snd_util_memblk *snd_trident_synth_alloc(struct snd_trident *trident, unsigned int size); -int snd_trident_synth_free(struct snd_trident *trident, struct snd_util_memblk *blk); -int snd_trident_synth_copy_from_user(struct snd_trident *trident, struct snd_util_memblk *blk, - int offset, const char __user *data, int size); +snd_util_memblk_t *snd_trident_alloc_pages(trident_t *trident, snd_pcm_substream_t *substream); +int snd_trident_free_pages(trident_t *trident, snd_util_memblk_t *blk); +snd_util_memblk_t *snd_trident_synth_alloc(trident_t *trident, unsigned int size); +int snd_trident_synth_free(trident_t *trident, snd_util_memblk_t *blk); +int snd_trident_synth_copy_from_user(trident_t *trident, snd_util_memblk_t *blk, int offset, const char __user *data, int size); #endif /* __SOUND_TRIDENT_H */ diff --git a/trunk/include/sound/typedefs.h b/trunk/include/sound/typedefs.h deleted file mode 100644 index f454b0206b93..000000000000 --- a/trunk/include/sound/typedefs.h +++ /dev/null @@ -1,173 +0,0 @@ -/* - * Typedef's for backward compatibility (for out-of-kernel drivers) - * - * This file will be removed soon in future - */ - -/* core stuff */ -typedef struct snd_card snd_card_t; -typedef struct snd_device snd_device_t; -typedef struct snd_device_ops snd_device_ops_t; -typedef enum snd_card_type snd_card_type_t; -typedef struct snd_minor snd_minor_t; - -/* info */ -typedef struct snd_info_entry snd_info_entry_t; -typedef struct snd_info_buffer snd_info_buffer_t; - -/* control */ -typedef struct snd_ctl_file snd_ctl_file_t; -typedef struct snd_kcontrol snd_kcontrol_t; -typedef struct snd_kcontrol_new snd_kcontrol_new_t; -typedef struct snd_kcontrol_volatile snd_kcontrol_volatile_t; -typedef struct snd_kctl_event snd_kctl_event_t; -typedef struct snd_aes_iec958 snd_aes_iec958_t; -typedef struct snd_ctl_card_info snd_ctl_card_info_t; -typedef struct snd_ctl_elem_id snd_ctl_elem_id_t; -typedef struct snd_ctl_elem_list snd_ctl_elem_list_t; -typedef struct snd_ctl_elem_info snd_ctl_elem_info_t; -typedef struct snd_ctl_elem_value snd_ctl_elem_value_t; -typedef struct snd_ctl_event snd_ctl_event_t; -#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) -typedef struct snd_mixer_oss snd_mixer_oss_t; -#endif - -/* timer */ -typedef struct snd_timer snd_timer_t; -typedef struct snd_timer_instance snd_timer_instance_t; -typedef struct snd_timer_id snd_timer_id_t; -typedef struct snd_timer_ginfo snd_timer_ginfo_t; -typedef struct snd_timer_gparams snd_timer_gparams_t; -typedef struct snd_timer_gstatus snd_timer_gstatus_t; -typedef struct snd_timer_select snd_timer_select_t; -typedef struct snd_timer_info snd_timer_info_t; -typedef struct snd_timer_params snd_timer_params_t; -typedef struct snd_timer_status snd_timer_status_t; -typedef struct snd_timer_read snd_timer_read_t; -typedef struct snd_timer_tread snd_timer_tread_t; - -/* PCM */ -typedef struct snd_pcm snd_pcm_t; -typedef struct snd_pcm_str snd_pcm_str_t; -typedef struct snd_pcm_substream snd_pcm_substream_t; -typedef struct snd_pcm_info snd_pcm_info_t; -typedef struct snd_pcm_hw_params snd_pcm_hw_params_t; -typedef struct snd_pcm_sw_params snd_pcm_sw_params_t; -typedef struct snd_pcm_channel_info snd_pcm_channel_info_t; -typedef struct snd_pcm_status snd_pcm_status_t; -typedef struct snd_pcm_mmap_status snd_pcm_mmap_status_t; -typedef struct snd_pcm_mmap_control snd_pcm_mmap_control_t; -typedef struct snd_mask snd_mask_t; -typedef struct snd_sg_buf snd_pcm_sgbuf_t; - -typedef struct snd_interval snd_interval_t; -typedef struct snd_xferi snd_xferi_t; -typedef struct snd_xfern snd_xfern_t; -typedef struct snd_xferv snd_xferv_t; - -typedef struct snd_pcm_file snd_pcm_file_t; -typedef struct snd_pcm_runtime snd_pcm_runtime_t; -typedef struct snd_pcm_hardware snd_pcm_hardware_t; -typedef struct snd_pcm_ops snd_pcm_ops_t; -typedef struct snd_pcm_hw_rule snd_pcm_hw_rule_t; -typedef struct snd_pcm_hw_constraints snd_pcm_hw_constraints_t; -typedef struct snd_ratnum ratnum_t; -typedef struct snd_ratden ratden_t; -typedef struct snd_pcm_hw_constraint_ratnums snd_pcm_hw_constraint_ratnums_t; -typedef struct snd_pcm_hw_constraint_ratdens snd_pcm_hw_constraint_ratdens_t; -typedef struct snd_pcm_hw_constraint_list snd_pcm_hw_constraint_list_t; -typedef struct snd_pcm_group snd_pcm_group_t; -typedef struct snd_pcm_notify snd_pcm_notify_t; - -/* rawmidi */ -typedef struct snd_rawmidi snd_rawmidi_t; -typedef struct snd_rawmidi_info snd_rawmidi_info_t; -typedef struct snd_rawmidi_params snd_rawmidi_params_t; -typedef struct snd_rawmidi_status snd_rawmidi_status_t; -typedef struct snd_rawmidi_runtime snd_rawmidi_runtime_t; -typedef struct snd_rawmidi_substream snd_rawmidi_substream_t; -typedef struct snd_rawmidi_str snd_rawmidi_str_t; -typedef struct snd_rawmidi_ops snd_rawmidi_ops_t; -typedef struct snd_rawmidi_global_ops snd_rawmidi_global_ops_t; -typedef struct snd_rawmidi_file snd_rawmidi_file_t; - -/* hwdep */ -typedef struct snd_hwdep snd_hwdep_t; -typedef struct snd_hwdep_info snd_hwdep_info_t; -typedef struct snd_hwdep_dsp_status snd_hwdep_dsp_status_t; -typedef struct snd_hwdep_dsp_image snd_hwdep_dsp_image_t; -typedef struct snd_hwdep_ops snd_hwdep_ops_t; - -/* sequencer */ -typedef struct snd_seq_port_info snd_seq_port_info_t; -typedef struct snd_seq_port_subscribe snd_seq_port_subscribe_t; -typedef struct snd_seq_event snd_seq_event_t; -typedef struct snd_seq_addr snd_seq_addr_t; -typedef struct snd_seq_ev_volume snd_seq_ev_volume_t; -typedef struct snd_seq_ev_loop snd_seq_ev_loop_t; -typedef struct snd_seq_remove_events snd_seq_remove_events_t; -typedef struct snd_seq_query_subs snd_seq_query_subs_t; -typedef struct snd_seq_system_info snd_seq_system_info_t; -typedef struct snd_seq_client_info snd_seq_client_info_t; -typedef struct snd_seq_queue_info snd_seq_queue_info_t; -typedef struct snd_seq_queue_status snd_seq_queue_status_t; -typedef struct snd_seq_queue_tempo snd_seq_queue_tempo_t; -typedef struct snd_seq_queue_owner snd_seq_queue_owner_t; -typedef struct snd_seq_queue_timer snd_seq_queue_timer_t; -typedef struct snd_seq_queue_client snd_seq_queue_client_t; -typedef struct snd_seq_client_pool snd_seq_client_pool_t; -typedef struct snd_seq_instr snd_seq_instr_t; -typedef struct snd_seq_instr_data snd_seq_instr_data_t; -typedef struct snd_seq_instr_header snd_seq_instr_header_t; - -typedef struct snd_seq_user_client user_client_t; -typedef struct snd_seq_kernel_client kernel_client_t; -typedef struct snd_seq_client client_t; -typedef struct snd_seq_queue queue_t; - -/* seq_device */ -typedef struct snd_seq_device snd_seq_device_t; -typedef struct snd_seq_dev_ops snd_seq_dev_ops_t; - -/* seq_midi */ -typedef struct snd_midi_event snd_midi_event_t; - -/* seq_midi_emul */ -typedef struct snd_midi_channel snd_midi_channel_t; -typedef struct snd_midi_channel_set snd_midi_channel_set_t; -typedef struct snd_midi_op snd_midi_op_t; - -/* seq_oss */ -typedef struct snd_seq_oss_arg snd_seq_oss_arg_t; -typedef struct snd_seq_oss_callback snd_seq_oss_callback_t; -typedef struct snd_seq_oss_reg snd_seq_oss_reg_t; - -/* virmidi */ -typedef struct snd_virmidi_dev snd_virmidi_dev_t; -typedef struct snd_virmidi snd_virmidi_t; - -/* seq_instr */ -typedef struct snd_seq_kcluster snd_seq_kcluster_t; -typedef struct snd_seq_kinstr_ops snd_seq_kinstr_ops_t; -typedef struct snd_seq_kinstr snd_seq_kinstr_t; -typedef struct snd_seq_kinstr_list snd_seq_kinstr_list_t; - -/* ac97 */ -typedef struct snd_ac97_bus ac97_bus_t; -typedef struct snd_ac97_bus_ops ac97_bus_ops_t; -typedef struct snd_ac97_template ac97_template_t; -typedef struct snd_ac97 ac97_t; - -/* opl3/4 */ -typedef struct snd_opl3 opl3_t; -typedef struct snd_opl4 opl4_t; - -/* mpu401 */ -typedef struct snd_mpu401 mpu401_t; - -/* i2c */ -typedef struct snd_i2c_device snd_i2c_device_t; -typedef struct snd_i2c_bus snd_i2c_bus_t; - -typedef struct snd_ak4531 ak4531_t; - diff --git a/trunk/include/sound/uda1341.h b/trunk/include/sound/uda1341.h index 2e564bfb37fe..61ff65a628bc 100644 --- a/trunk/include/sound/uda1341.h +++ b/trunk/include/sound/uda1341.h @@ -15,7 +15,7 @@ * features support */ -/* $Id: uda1341.h,v 1.8 2005/11/17 14:17:21 tiwai Exp $ */ +/* $Id: uda1341.h,v 1.6 2004/05/03 17:36:50 tiwai Exp $ */ #define UDA1341_ALSA_NAME "snd-uda1341" @@ -37,6 +37,11 @@ enum uda1341_onoff { ON, }; +const char *onoff_names[] = { + "Off", + "On", +}; + enum uda1341_format { I2S=0, LSB16, @@ -48,6 +53,17 @@ enum uda1341_format { LSB20MSB, }; +const char *format_names[] = { + "I2S-bus", + "LSB 16bits", + "LSB 18bits", + "LSB 20bits", + "MSB", + "in LSB 16bits/out MSB", + "in LSB 18bits/out MSB", + "in LSB 20bits/out MSB", +}; + enum uda1341_fs { F512=0, F384, @@ -55,11 +71,23 @@ enum uda1341_fs { Funused, }; +const char *fs_names[] = { + "512*fs", + "384*fs", + "256*fs", + "Unused - bad value!", +}; + enum uda1341_peak { BEFORE=0, AFTER, }; +const char *peak_names[] = { + "before", + "after", +}; + enum uda1341_filter { FLAT=0, MIN, @@ -67,6 +95,24 @@ enum uda1341_filter { MAX, }; +const char *filter_names[] = { + "flat", + "min", + "min", + "max", +}; + +const char*bass_values[][16] = { + {"0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", + "0 dB", "0 dB", "0 dB", "0 dB", "undefined", }, //flat + {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "18 dB", + "18 dB", "18 dB", "18 dB", "18 dB", "undefined",}, // min + {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "18 dB", + "18 dB", "18 dB", "18 dB", "18 dB", "undefined",}, // min + {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "20 dB", + "22 dB", "24 dB", "24 dB", "24 dB", "undefined",}, // max +}; + enum uda1341_mixer { DOUBLE, LINE, @@ -74,6 +120,13 @@ enum uda1341_mixer { MIXER, }; +const char *mixer_names[] = { + "double differential", + "input channel 1 (line in)", + "input channel 2 (microphone)", + "digital mixer", +}; + enum uda1341_deemp { NONE, D32, @@ -81,6 +134,58 @@ enum uda1341_deemp { D48, }; +const char *deemp_names[] = { + "none", + "32 kHz", + "44.1 kHz", + "48 kHz", +}; + +const char *mic_sens_value[] = { + "-3 dB", "0 dB", "3 dB", "9 dB", "15 dB", "21 dB", "27 dB", "not used", +}; + +const unsigned short AGC_atime[] = { + 11, 16, 11, 16, 21, 11, 16, 21, +}; + +const unsigned short AGC_dtime[] = { + 100, 100, 200, 200, 200, 400, 400, 400, +}; + +const char *AGC_level[] = { + "-9.0", "-11.5", "-15.0", "-17.5", +}; + +const char *ig_small_value[] = { + "-3.0", "-2.5", "-2.0", "-1.5", "-1.0", "-0.5", +}; + +/* + * this was computed as peak_value[i] = pow((63-i)*1.42,1.013) + * + * UDA1341 datasheet on page 21: Peak value (dB) = (Peak level - 63.5)*5*log2 + * There is an table with these values [level]=value: [3]=-90.31, [7]=-84.29 + * [61]=-2.78, [62] = -1.48, [63] = 0.0 + * I tried to compute it, but using but even using logarithm with base either 10 or 2 + * i was'n able to get values in the table from the formula. So I constructed another + * formula (see above) to interpolate the values as good as possible. If there is some + * mistake, please contact me on tomas.kasparek@seznam.cz. Thanks. + * UDA1341TS datasheet is available at: + * http://www-us9.semiconductors.com/acrobat/datasheets/UDA1341TS_3.pdf + */ +const char *peak_value[] = { + "-INF dB", "N.A.", "N.A", "90.31 dB", "N.A.", "N.A.", "N.A.", "-84.29 dB", + "-82.65 dB", "-81.13 dB", "-79.61 dB", "-78.09 dB", "-76.57 dB", "-75.05 dB", "-73.53 dB", + "-72.01 dB", "-70.49 dB", "-68.97 dB", "-67.45 dB", "-65.93 dB", "-64.41 dB", "-62.90 dB", + "-61.38 dB", "-59.86 dB", "-58.35 dB", "-56.83 dB", "-55.32 dB", "-53.80 dB", "-52.29 dB", + "-50.78 dB", "-49.26 dB", "-47.75 dB", "-46.24 dB", "-44.73 dB", "-43.22 dB", "-41.71 dB", + "-40.20 dB", "-38.69 dB", "-37.19 dB", "-35.68 dB", "-34.17 dB", "-32.67 dB", "-31.17 dB", + "-29.66 dB", "-28.16 dB", "-26.66 dB", "-25.16 dB", "-23.66 dB", "-22.16 dB", "-20.67 dB", + "-19.17 dB", "-17.68 dB", "-16.19 dB", "-14.70 dB", "-13.21 dB", "-11.72 dB", "-10.24 dB", + "-8.76 dB", "-7.28 dB", "-5.81 dB", "-4.34 dB", "-2.88 dB", "-1.43 dB", "0.00 dB", +}; + enum uda1341_config { CMD_READ_REG = 0, CMD_RESET, @@ -119,7 +224,7 @@ enum write_through { FLUSH, }; -int __init snd_chip_uda1341_mixer_new(struct snd_card *card, struct l3_client **clnt); +int __init snd_chip_uda1341_mixer_new(snd_card_t *card, struct l3_client **clnt); /* * Local variables: diff --git a/trunk/include/sound/util_mem.h b/trunk/include/sound/util_mem.h index 69944bbb5445..9d2cdfa0c42a 100644 --- a/trunk/include/sound/util_mem.h +++ b/trunk/include/sound/util_mem.h @@ -20,25 +20,29 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +typedef struct snd_util_memblk snd_util_memblk_t; +typedef struct snd_util_memhdr snd_util_memhdr_t; +typedef unsigned int snd_util_unit_t; + /* * memory block */ struct snd_util_memblk { - unsigned int size; /* size of this block */ - unsigned int offset; /* zero-offset of this block */ + snd_util_unit_t size; /* size of this block */ + snd_util_unit_t offset; /* zero-offset of this block */ struct list_head list; /* link */ }; -#define snd_util_memblk_argptr(blk) (void*)((char*)(blk) + sizeof(struct snd_util_memblk)) +#define snd_util_memblk_argptr(blk) (void*)((char*)(blk) + sizeof(snd_util_memblk_t)) /* * memory management information */ struct snd_util_memhdr { - unsigned int size; /* size of whole data */ + snd_util_unit_t size; /* size of whole data */ struct list_head block; /* block linked-list header */ int nblocks; /* # of allocated blocks */ - unsigned int used; /* used memory size */ + snd_util_unit_t used; /* used memory size */ int block_extra_size; /* extra data size of chunk */ struct semaphore block_mutex; /* lock */ }; @@ -46,17 +50,15 @@ struct snd_util_memhdr { /* * prototypes */ -struct snd_util_memhdr *snd_util_memhdr_new(int memsize); -void snd_util_memhdr_free(struct snd_util_memhdr *hdr); -struct snd_util_memblk *snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size); -int snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk); -int snd_util_mem_avail(struct snd_util_memhdr *hdr); +snd_util_memhdr_t *snd_util_memhdr_new(int memsize); +void snd_util_memhdr_free(snd_util_memhdr_t *hdr); +snd_util_memblk_t *snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size); +int snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk); +int snd_util_mem_avail(snd_util_memhdr_t *hdr); /* functions without mutex */ -struct snd_util_memblk *__snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size); -void __snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk); -struct snd_util_memblk *__snd_util_memblk_new(struct snd_util_memhdr *hdr, - unsigned int units, - struct list_head *prev); +snd_util_memblk_t *__snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size); +void __snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk); +snd_util_memblk_t *__snd_util_memblk_new(snd_util_memhdr_t *hdr, snd_util_unit_t units, struct list_head *prev); #endif /* __SOUND_UTIL_MEM_H */ diff --git a/trunk/include/sound/version.h b/trunk/include/sound/version.h index 919da0dd001c..d1bd3b723967 100644 --- a/trunk/include/sound/version.h +++ b/trunk/include/sound/version.h @@ -1,3 +1,3 @@ /* include/version.h. Generated by configure. */ -#define CONFIG_SND_VERSION "1.0.11rc2" -#define CONFIG_SND_DATE " (Wed Jan 04 08:57:20 2006 UTC)" +#define CONFIG_SND_VERSION "1.0.10rc3" +#define CONFIG_SND_DATE " (Mon Nov 07 13:30:21 2005 UTC)" diff --git a/trunk/include/sound/vx_core.h b/trunk/include/sound/vx_core.h index 5fd6f3305e0d..7a60a3888667 100644 --- a/trunk/include/sound/vx_core.h +++ b/trunk/include/sound/vx_core.h @@ -36,6 +36,9 @@ struct firmware; struct device; +typedef struct snd_vx_core vx_core_t; +typedef struct vx_pipe vx_pipe_t; + #define VX_DRIVER_VERSION 0x010000 /* 1.0.0 */ /* @@ -73,7 +76,7 @@ struct vx_pipe { int channels; unsigned int differed_type; pcx_time_t pcx_time; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int hbuf_size; /* H-buffer size in bytes */ int buffer_bytes; /* the ALSA pcm buffer size in bytes */ @@ -85,38 +88,36 @@ struct vx_pipe { u64 cur_count; /* current sample position (for playback) */ unsigned int references; /* an output pipe may be used for monitoring and/or playback */ - struct vx_pipe *monitoring_pipe; /* pointer to the monitoring pipe (capture pipe only)*/ + vx_pipe_t *monitoring_pipe; /* pointer to the monitoring pipe (capture pipe only)*/ struct tasklet_struct start_tq; }; -struct vx_core; - struct snd_vx_ops { /* low-level i/o */ - unsigned char (*in8)(struct vx_core *chip, int reg); - unsigned int (*in32)(struct vx_core *chip, int reg); - void (*out8)(struct vx_core *chip, int reg, unsigned char val); - void (*out32)(struct vx_core *chip, int reg, unsigned int val); + unsigned char (*in8)(vx_core_t *chip, int reg); + unsigned int (*in32)(vx_core_t *chip, int reg); + void (*out8)(vx_core_t *chip, int reg, unsigned char val); + void (*out32)(vx_core_t *chip, int reg, unsigned int val); /* irq */ - int (*test_and_ack)(struct vx_core *chip); - void (*validate_irq)(struct vx_core *chip, int enable); + int (*test_and_ack)(vx_core_t *chip); + void (*validate_irq)(vx_core_t *chip, int enable); /* codec */ - void (*write_codec)(struct vx_core *chip, int codec, unsigned int data); - void (*akm_write)(struct vx_core *chip, int reg, unsigned int data); - void (*reset_codec)(struct vx_core *chip); - void (*change_audio_source)(struct vx_core *chip, int src); - void (*set_clock_source)(struct vx_core *chp, int src); + void (*write_codec)(vx_core_t *chip, int codec, unsigned int data); + void (*akm_write)(vx_core_t *chip, int reg, unsigned int data); + void (*reset_codec)(vx_core_t *chip); + void (*change_audio_source)(vx_core_t *chip, int src); + void (*set_clock_source)(vx_core_t *chp, int src); /* chip init */ - int (*load_dsp)(struct vx_core *chip, int idx, const struct firmware *fw); - void (*reset_dsp)(struct vx_core *chip); - void (*reset_board)(struct vx_core *chip, int cold_reset); - int (*add_controls)(struct vx_core *chip); + int (*load_dsp)(vx_core_t *chip, int idx, const struct firmware *fw); + void (*reset_dsp)(vx_core_t *chip); + void (*reset_board)(vx_core_t *chip, int cold_reset); + int (*add_controls)(vx_core_t *chip); /* pcm */ - void (*dma_write)(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count); - void (*dma_read)(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count); + void (*dma_write)(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count); + void (*dma_read)(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count); }; struct snd_vx_hardware { @@ -157,10 +158,10 @@ enum { /* min/max values for analog output for old codecs */ #define VX_ANALOG_OUT_LEVEL_MAX 0xe3 -struct vx_core { +struct snd_vx_core { /* ALSA stuff */ - struct snd_card *card; - struct snd_pcm *pcm[VX_MAX_CODECS]; + snd_card_t *card; + snd_pcm_t *pcm[VX_MAX_CODECS]; int type; /* VX_TYPE_XXX */ int irq; @@ -178,7 +179,7 @@ struct vx_core { unsigned int pcm_running; struct device *dev; - struct snd_hwdep *hwdep; + snd_hwdep_t *hwdep; struct vx_rmh irq_rmh; /* RMH used in interrupts */ @@ -215,14 +216,14 @@ struct vx_core { /* * constructor */ -struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw, - struct snd_vx_ops *ops, int extra_size); -int snd_vx_setup_firmware(struct vx_core *chip); -int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *dsp); -int snd_vx_dsp_boot(struct vx_core *chip, const struct firmware *dsp); -int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp); +vx_core_t *snd_vx_create(snd_card_t *card, struct snd_vx_hardware *hw, + struct snd_vx_ops *ops, int extra_size); +int snd_vx_setup_firmware(vx_core_t *chip); +int snd_vx_load_boot_image(vx_core_t *chip, const struct firmware *dsp); +int snd_vx_dsp_boot(vx_core_t *chip, const struct firmware *dsp); +int snd_vx_dsp_load(vx_core_t *chip, const struct firmware *dsp); -void snd_vx_free_firmware(struct vx_core *chip); +void snd_vx_free_firmware(vx_core_t *chip); /* * interrupt handler; exported for pcmcia @@ -232,37 +233,37 @@ irqreturn_t snd_vx_irq_handler(int irq, void *dev, struct pt_regs *regs); /* * lowlevel functions */ -static inline int vx_test_and_ack(struct vx_core *chip) +static inline int vx_test_and_ack(vx_core_t *chip) { snd_assert(chip->ops->test_and_ack, return -ENXIO); return chip->ops->test_and_ack(chip); } -static inline void vx_validate_irq(struct vx_core *chip, int enable) +static inline void vx_validate_irq(vx_core_t *chip, int enable) { snd_assert(chip->ops->validate_irq, return); chip->ops->validate_irq(chip, enable); } -static inline unsigned char snd_vx_inb(struct vx_core *chip, int reg) +static inline unsigned char snd_vx_inb(vx_core_t *chip, int reg) { snd_assert(chip->ops->in8, return 0); return chip->ops->in8(chip, reg); } -static inline unsigned int snd_vx_inl(struct vx_core *chip, int reg) +static inline unsigned int snd_vx_inl(vx_core_t *chip, int reg) { snd_assert(chip->ops->in32, return 0); return chip->ops->in32(chip, reg); } -static inline void snd_vx_outb(struct vx_core *chip, int reg, unsigned char val) +static inline void snd_vx_outb(vx_core_t *chip, int reg, unsigned char val) { snd_assert(chip->ops->out8, return); chip->ops->out8(chip, reg, val); } -static inline void snd_vx_outl(struct vx_core *chip, int reg, unsigned int val) +static inline void snd_vx_outl(vx_core_t *chip, int reg, unsigned int val) { snd_assert(chip->ops->out32, return); chip->ops->out32(chip, reg, val); @@ -273,25 +274,27 @@ static inline void snd_vx_outl(struct vx_core *chip, int reg, unsigned int val) #define vx_inl(chip,reg) snd_vx_inl(chip, VX_##reg) #define vx_outl(chip,reg,val) snd_vx_outl(chip, VX_##reg,val) -static inline void vx_reset_dsp(struct vx_core *chip) +void snd_vx_delay(vx_core_t *chip, int msec); + +static inline void vx_reset_dsp(vx_core_t *chip) { snd_assert(chip->ops->reset_dsp, return); chip->ops->reset_dsp(chip); } -int vx_send_msg(struct vx_core *chip, struct vx_rmh *rmh); -int vx_send_msg_nolock(struct vx_core *chip, struct vx_rmh *rmh); -int vx_send_rih(struct vx_core *chip, int cmd); -int vx_send_rih_nolock(struct vx_core *chip, int cmd); +int vx_send_msg(vx_core_t *chip, struct vx_rmh *rmh); +int vx_send_msg_nolock(vx_core_t *chip, struct vx_rmh *rmh); +int vx_send_rih(vx_core_t *chip, int cmd); +int vx_send_rih_nolock(vx_core_t *chip, int cmd); -void vx_reset_codec(struct vx_core *chip, int cold_reset); +void vx_reset_codec(vx_core_t *chip, int cold_reset); /* * check the bit on the specified register * returns zero if a bit matches, or a negative error code. * exported for vxpocket driver */ -int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int time); +int snd_vx_check_reg_bit(vx_core_t *chip, int reg, int mask, int bit, int time); #define vx_check_isr(chip,mask,bit,time) snd_vx_check_reg_bit(chip, VX_ISR, mask, bit, time) #define vx_wait_isr_bit(chip,bit) vx_check_isr(chip, bit, bit, 200) #define vx_wait_for_rx_full(chip) vx_wait_isr_bit(chip, ISR_RX_FULL) @@ -300,15 +303,15 @@ int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int t /* * pseudo-DMA transfer */ -static inline void vx_pseudo_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count) +static inline void vx_pseudo_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count) { snd_assert(chip->ops->dma_write, return); chip->ops->dma_write(chip, runtime, pipe, count); } -static inline void vx_pseudo_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count) +static inline void vx_pseudo_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count) { snd_assert(chip->ops->dma_read, return); chip->ops->dma_read(chip, runtime, pipe, count); @@ -326,32 +329,26 @@ static inline void vx_pseudo_dma_read(struct vx_core *chip, struct snd_pcm_runti /* * pcm stuff */ -int snd_vx_pcm_new(struct vx_core *chip); -void vx_pcm_update_intr(struct vx_core *chip, unsigned int events); +int snd_vx_pcm_new(vx_core_t *chip); +void vx_pcm_update_intr(vx_core_t *chip, unsigned int events); /* * mixer stuff */ -int snd_vx_mixer_new(struct vx_core *chip); -void vx_toggle_dac_mute(struct vx_core *chip, int mute); -int vx_sync_audio_source(struct vx_core *chip); -int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active); +int snd_vx_mixer_new(vx_core_t *chip); +void vx_toggle_dac_mute(vx_core_t *chip, int mute); +int vx_sync_audio_source(vx_core_t *chip); +int vx_set_monitor_level(vx_core_t *chip, int audio, int level, int active); /* * IEC958 & clock stuff */ -void vx_set_iec958_status(struct vx_core *chip, unsigned int bits); -int vx_set_clock(struct vx_core *chip, unsigned int freq); -void vx_set_internal_clock(struct vx_core *chip, unsigned int freq); -int vx_change_frequency(struct vx_core *chip); +void vx_set_iec958_status(vx_core_t *chip, unsigned int bits); +int vx_set_clock(vx_core_t *chip, unsigned int freq); +void vx_set_internal_clock(vx_core_t *chip, unsigned int freq); +int vx_change_frequency(vx_core_t *chip); -/* - * PM - */ -int snd_vx_suspend(struct vx_core *card, pm_message_t state); -int snd_vx_resume(struct vx_core *card); - /* * hardware constants */ diff --git a/trunk/include/sound/ymfpci.h b/trunk/include/sound/ymfpci.h index d567bfdbf513..c3bccbfd8d4c 100644 --- a/trunk/include/sound/ymfpci.h +++ b/trunk/include/sound/ymfpci.h @@ -184,7 +184,7 @@ * */ -struct snd_ymfpci_playback_bank { +typedef struct _snd_ymfpci_playback_bank { u32 format; u32 loop_default; u32 base; /* 32-bit address */ @@ -215,45 +215,46 @@ struct snd_ymfpci_playback_bank { u32 eff3_gain; u32 lpfD1; u32 lpfD2; - }; +} snd_ymfpci_playback_bank_t; -struct snd_ymfpci_capture_bank { +typedef struct _snd_ymfpci_capture_bank { u32 base; /* 32-bit address */ u32 loop_end; /* 32-bit offset */ u32 start; /* 32-bit offset */ u32 num_of_loops; /* counter */ -}; +} snd_ymfpci_capture_bank_t; -struct snd_ymfpci_effect_bank { +typedef struct _snd_ymfpci_effect_bank { u32 base; /* 32-bit address */ u32 loop_end; /* 32-bit offset */ u32 start; /* 32-bit offset */ u32 temp; -}; +} snd_ymfpci_effect_bank_t; -struct snd_ymfpci_pcm; -struct snd_ymfpci; +typedef struct _snd_ymfpci_voice ymfpci_voice_t; +typedef struct _snd_ymfpci_pcm ymfpci_pcm_t; +typedef struct _snd_ymfpci ymfpci_t; -enum snd_ymfpci_voice_type { +typedef enum { YMFPCI_PCM, YMFPCI_SYNTH, YMFPCI_MIDI -}; +} ymfpci_voice_type_t; -struct snd_ymfpci_voice { - struct snd_ymfpci *chip; +struct _snd_ymfpci_voice { + ymfpci_t *chip; int number; unsigned int use: 1, pcm: 1, synth: 1, midi: 1; - struct snd_ymfpci_playback_bank *bank; + snd_ymfpci_playback_bank_t *bank; dma_addr_t bank_addr; - void (*interrupt)(struct snd_ymfpci *chip, struct snd_ymfpci_voice *voice); - struct snd_ymfpci_pcm *ypcm; + void (*interrupt)(ymfpci_t *chip, ymfpci_voice_t *voice); + ymfpci_pcm_t *ypcm; }; -enum snd_ymfpci_pcm_type { +typedef enum { PLAYBACK_VOICE, CAPTURE_REC, CAPTURE_AC97, @@ -262,13 +263,13 @@ enum snd_ymfpci_pcm_type { EFFECT_EFF1, EFFECT_EFF2, EFFECT_EFF3 -}; +} snd_ymfpci_pcm_type_t; -struct snd_ymfpci_pcm { - struct snd_ymfpci *chip; - enum snd_ymfpci_pcm_type type; - struct snd_pcm_substream *substream; - struct snd_ymfpci_voice *voices[2]; /* playback only */ +struct _snd_ymfpci_pcm { + ymfpci_t *chip; + snd_ymfpci_pcm_type_t type; + snd_pcm_substream_t *substream; + ymfpci_voice_t *voices[2]; /* playback only */ unsigned int running: 1; unsigned int output_front: 1; unsigned int output_rear: 1; @@ -281,7 +282,7 @@ struct snd_ymfpci_pcm { u32 shift; }; -struct snd_ymfpci { +struct _snd_ymfpci { int irq; unsigned int device_id; /* PCI device ID */ @@ -315,47 +316,47 @@ struct snd_ymfpci { struct snd_dma_buffer ac3_tmp_base; u32 *ctrl_playback; - struct snd_ymfpci_playback_bank *bank_playback[YDSXG_PLAYBACK_VOICES][2]; - struct snd_ymfpci_capture_bank *bank_capture[YDSXG_CAPTURE_VOICES][2]; - struct snd_ymfpci_effect_bank *bank_effect[YDSXG_EFFECT_VOICES][2]; + snd_ymfpci_playback_bank_t *bank_playback[YDSXG_PLAYBACK_VOICES][2]; + snd_ymfpci_capture_bank_t *bank_capture[YDSXG_CAPTURE_VOICES][2]; + snd_ymfpci_effect_bank_t *bank_effect[YDSXG_EFFECT_VOICES][2]; int start_count; u32 active_bank; - struct snd_ymfpci_voice voices[64]; + ymfpci_voice_t voices[64]; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; - struct snd_rawmidi *rawmidi; - struct snd_timer *timer; + ac97_bus_t *ac97_bus; + ac97_t *ac97; + snd_rawmidi_t *rawmidi; + snd_timer_t *timer; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm *pcm2; - struct snd_pcm *pcm_spdif; - struct snd_pcm *pcm_4ch; - struct snd_pcm_substream *capture_substream[YDSXG_CAPTURE_VOICES]; - struct snd_pcm_substream *effect_substream[YDSXG_EFFECT_VOICES]; - struct snd_kcontrol *ctl_vol_recsrc; - struct snd_kcontrol *ctl_vol_adcrec; - struct snd_kcontrol *ctl_vol_spdifrec; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_t *pcm2; + snd_pcm_t *pcm_spdif; + snd_pcm_t *pcm_4ch; + snd_pcm_substream_t *capture_substream[YDSXG_CAPTURE_VOICES]; + snd_pcm_substream_t *effect_substream[YDSXG_EFFECT_VOICES]; + snd_kcontrol_t *ctl_vol_recsrc; + snd_kcontrol_t *ctl_vol_adcrec; + snd_kcontrol_t *ctl_vol_spdifrec; unsigned short spdif_bits, spdif_pcm_bits; - struct snd_kcontrol *spdif_pcm_ctl; + snd_kcontrol_t *spdif_pcm_ctl; int mode_dup4ch; int rear_opened; int spdif_opened; struct { u16 left; u16 right; - struct snd_kcontrol *ctl; + snd_kcontrol_t *ctl; } pcm_mixer[32]; spinlock_t reg_lock; spinlock_t voice_lock; wait_queue_head_t interrupt_sleep; atomic_t interrupt_sleep_count; - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; #ifdef CONFIG_PM u32 *saved_regs; @@ -363,20 +364,17 @@ struct snd_ymfpci { #endif }; -int snd_ymfpci_create(struct snd_card *card, +int snd_ymfpci_create(snd_card_t * card, struct pci_dev *pci, unsigned short old_legacy_ctrl, - struct snd_ymfpci ** rcodec); -void snd_ymfpci_free_gameport(struct snd_ymfpci *chip); - -int snd_ymfpci_suspend(struct pci_dev *pci, pm_message_t state); -int snd_ymfpci_resume(struct pci_dev *pci); - -int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm); -int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm); -int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm); -int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm); -int snd_ymfpci_mixer(struct snd_ymfpci *chip, int rear_switch); -int snd_ymfpci_timer(struct snd_ymfpci *chip, int device); + ymfpci_t ** rcodec); +void snd_ymfpci_free_gameport(ymfpci_t *chip); + +int snd_ymfpci_pcm(ymfpci_t *chip, int device, snd_pcm_t **rpcm); +int snd_ymfpci_pcm2(ymfpci_t *chip, int device, snd_pcm_t **rpcm); +int snd_ymfpci_pcm_spdif(ymfpci_t *chip, int device, snd_pcm_t **rpcm); +int snd_ymfpci_pcm_4ch(ymfpci_t *chip, int device, snd_pcm_t **rpcm); +int snd_ymfpci_mixer(ymfpci_t *chip, int rear_switch); +int snd_ymfpci_timer(ymfpci_t *chip, int device); #endif /* __SOUND_YMFPCI_H */ diff --git a/trunk/init/Kconfig b/trunk/init/Kconfig index ce737e02c5a2..9fc0759fa942 100644 --- a/trunk/init/Kconfig +++ b/trunk/init/Kconfig @@ -197,6 +197,33 @@ config AUDITSYSCALL can be used independently or with another kernel subsystem, such as SELinux. +config HOTPLUG + bool "Support for hot-pluggable devices" if !ARCH_S390 + default ARCH_S390 + help + This option is provided for the case where no in-kernel-tree + modules require HOTPLUG functionality, but a module built + outside the kernel tree does. Such modules require Y here. + +config KOBJECT_UEVENT + bool "Kernel Userspace Events" if EMBEDDED + depends on NET + default y + help + This option enables the kernel userspace event layer, which is a + simple mechanism for kernel-to-user communication over a netlink + socket. + The goal of the kernel userspace events layer is to provide a simple + and efficient events system, that notifies userspace about kobject + state changes. This will enable applications to just listen for + events instead of polling system devices and files. + Hotplug events (kobject addition and removal) are also available on + the netlink socket in addition to the execution of /sbin/hotplug if + CONFIG_HOTPLUG is enabled. + + Say Y, unless you are building a system requiring minimal memory + consumption. + config IKCONFIG bool "Kernel .config support" ---help--- @@ -281,15 +308,6 @@ config KALLSYMS_EXTRA_PASS you wait for kallsyms to be fixed. -config HOTPLUG - bool "Support for hot-pluggable devices" if EMBEDDED - default y - help - This option is provided for the case where no hotplug or uevent - capabilities is wanted by the kernel. You should only consider - disabling this option for embedded systems that do not use modules, a - dynamic /dev tree, or dynamic device discovery. Just say Y. - config PRINTK default y bool "Enable support for printk" if EMBEDDED @@ -443,8 +461,8 @@ config OBSOLETE_MODPARM If unsure, say Y. config MODVERSIONS - bool "Module versioning support" - depends on MODULES + bool "Module versioning support (EXPERIMENTAL)" + depends on MODULES && EXPERIMENTAL help Usually, you have to use modules compiled with your kernel. Saying Y here makes it sometimes possible to use modules diff --git a/trunk/init/main.c b/trunk/init/main.c index 54aaf561cf66..27f97f9b4636 100644 --- a/trunk/init/main.c +++ b/trunk/init/main.c @@ -47,6 +47,7 @@ #include #include #include +#include #include #include @@ -613,6 +614,9 @@ static void __init do_basic_setup(void) sysctl_init(); #endif + /* Networking initialization needs a process context */ + sock_init(); + do_initcalls(); } diff --git a/trunk/kernel/.gitignore b/trunk/kernel/.gitignore deleted file mode 100644 index f2ab70073bd4..000000000000 --- a/trunk/kernel/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -# -# Generated files -# -config_data.h -config_data.gz diff --git a/trunk/kernel/configs.c b/trunk/kernel/configs.c index 009e1ebdcb88..986f7af31e0a 100644 --- a/trunk/kernel/configs.c +++ b/trunk/kernel/configs.c @@ -3,7 +3,7 @@ * Echo the kernel .config file used to build the kernel * * Copyright (C) 2002 Khalid Aziz - * Copyright (C) 2002 Randy Dunlap + * Copyright (C) 2002 Randy Dunlap * Copyright (C) 2002 Al Stone * Copyright (C) 2002 Hewlett-Packard Company * diff --git a/trunk/kernel/ksysfs.c b/trunk/kernel/ksysfs.c index 99af8b05eeaa..015fb69ad94d 100644 --- a/trunk/kernel/ksysfs.c +++ b/trunk/kernel/ksysfs.c @@ -15,9 +15,6 @@ #include #include -u64 uevent_seqnum; -char uevent_helper[UEVENT_HELPER_PATH_LEN] = "/sbin/hotplug"; - #define KERNEL_ATTR_RO(_name) \ static struct subsys_attribute _name##_attr = __ATTR_RO(_name) @@ -26,29 +23,11 @@ static struct subsys_attribute _name##_attr = \ __ATTR(_name, 0644, _name##_show, _name##_store) #ifdef CONFIG_HOTPLUG -/* current uevent sequence number */ -static ssize_t uevent_seqnum_show(struct subsystem *subsys, char *page) -{ - return sprintf(page, "%llu\n", (unsigned long long)uevent_seqnum); -} -KERNEL_ATTR_RO(uevent_seqnum); - -/* uevent helper program, used during early boo */ -static ssize_t uevent_helper_show(struct subsystem *subsys, char *page) -{ - return sprintf(page, "%s\n", uevent_helper); -} -static ssize_t uevent_helper_store(struct subsystem *subsys, const char *page, size_t count) +static ssize_t hotplug_seqnum_show(struct subsystem *subsys, char *page) { - if (count+1 > UEVENT_HELPER_PATH_LEN) - return -ENOENT; - memcpy(uevent_helper, page, count); - uevent_helper[count] = '\0'; - if (count && uevent_helper[count-1] == '\n') - uevent_helper[count-1] = '\0'; - return count; + return sprintf(page, "%llu\n", (unsigned long long)hotplug_seqnum); } -KERNEL_ATTR_RW(uevent_helper); +KERNEL_ATTR_RO(hotplug_seqnum); #endif #ifdef CONFIG_KEXEC @@ -66,8 +45,7 @@ EXPORT_SYMBOL_GPL(kernel_subsys); static struct attribute * kernel_attrs[] = { #ifdef CONFIG_HOTPLUG - &uevent_seqnum_attr.attr, - &uevent_helper_attr.attr, + &hotplug_seqnum_attr.attr, #endif #ifdef CONFIG_KEXEC &crash_notes_attr.attr, diff --git a/trunk/kernel/sysctl.c b/trunk/kernel/sysctl.c index 345f4a1d533f..b53115b882e1 100644 --- a/trunk/kernel/sysctl.c +++ b/trunk/kernel/sysctl.c @@ -31,7 +31,6 @@ #include #include #include -#include #include #include #include @@ -84,6 +83,9 @@ static int ngroups_max = NGROUPS_MAX; #ifdef CONFIG_KMOD extern char modprobe_path[]; #endif +#ifdef CONFIG_HOTPLUG +extern char hotplug_path[]; +#endif #ifdef CONFIG_CHR_DEV_SG extern int sg_big_buff; #endif @@ -395,8 +397,8 @@ static ctl_table kern_table[] = { { .ctl_name = KERN_HOTPLUG, .procname = "hotplug", - .data = &uevent_helper, - .maxlen = UEVENT_HELPER_PATH_LEN, + .data = &hotplug_path, + .maxlen = HOTPLUG_PATH_LEN, .mode = 0644, .proc_handler = &proc_dostring, .strategy = &sysctl_string, diff --git a/trunk/lib/klist.c b/trunk/lib/klist.c index 9c94f0b163a1..bb2f3551d50a 100644 --- a/trunk/lib/klist.c +++ b/trunk/lib/klist.c @@ -199,8 +199,6 @@ void klist_iter_init_node(struct klist * k, struct klist_iter * i, struct klist_ i->i_klist = k; i->i_head = &k->k_list; i->i_cur = n; - if (n) - kref_get(&n->n_ref); } EXPORT_SYMBOL_GPL(klist_iter_init_node); diff --git a/trunk/lib/kobject.c b/trunk/lib/kobject.c index 7a0e6809490d..a181abed89f6 100644 --- a/trunk/lib/kobject.c +++ b/trunk/lib/kobject.c @@ -207,7 +207,7 @@ int kobject_register(struct kobject * kobj) kobject_name(kobj),error); dump_stack(); } else - kobject_uevent(kobj, KOBJ_ADD); + kobject_hotplug(kobj, KOBJ_ADD); } else error = -EINVAL; return error; @@ -312,7 +312,7 @@ void kobject_del(struct kobject * kobj) void kobject_unregister(struct kobject * kobj) { pr_debug("kobject %s: unregistering\n",kobject_name(kobj)); - kobject_uevent(kobj, KOBJ_REMOVE); + kobject_hotplug(kobj, KOBJ_REMOVE); kobject_del(kobj); kobject_put(kobj); } diff --git a/trunk/lib/kobject_uevent.c b/trunk/lib/kobject_uevent.c index f56e27ae9d52..3ab375411e38 100644 --- a/trunk/lib/kobject_uevent.c +++ b/trunk/lib/kobject_uevent.c @@ -19,16 +19,14 @@ #include #include #include +#include #include #include -#define BUFFER_SIZE 1024 /* buffer for the variables */ +#define BUFFER_SIZE 1024 /* buffer for the hotplug env */ #define NUM_ENVP 32 /* number of env pointers */ -#if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET) -static DEFINE_SPINLOCK(sequence_lock); -static struct sock *uevent_sock; - +#if defined(CONFIG_KOBJECT_UEVENT) || defined(CONFIG_HOTPLUG) static char *action_to_string(enum kobject_action action) { switch (action) { @@ -38,6 +36,10 @@ static char *action_to_string(enum kobject_action action) return "remove"; case KOBJ_CHANGE: return "change"; + case KOBJ_MOUNT: + return "mount"; + case KOBJ_UMOUNT: + return "umount"; case KOBJ_OFFLINE: return "offline"; case KOBJ_ONLINE: @@ -46,183 +48,306 @@ static char *action_to_string(enum kobject_action action) return NULL; } } +#endif + +#ifdef CONFIG_KOBJECT_UEVENT +static struct sock *uevent_sock; /** - * kobject_uevent - notify userspace by ending an uevent + * send_uevent - notify userspace by sending event through netlink socket * - * @action: action that is happening (usually KOBJ_ADD and KOBJ_REMOVE) + * @signal: signal name + * @obj: object path (kobject) + * @envp: possible hotplug environment to pass with the message + * @gfp_mask: + */ +static int send_uevent(const char *signal, const char *obj, + char **envp, gfp_t gfp_mask) +{ + struct sk_buff *skb; + char *pos; + int len; + + if (!uevent_sock) + return -EIO; + + len = strlen(signal) + 1; + len += strlen(obj) + 1; + + /* allocate buffer with the maximum possible message size */ + skb = alloc_skb(len + BUFFER_SIZE, gfp_mask); + if (!skb) + return -ENOMEM; + + pos = skb_put(skb, len); + sprintf(pos, "%s@%s", signal, obj); + + /* copy the environment key by key to our continuous buffer */ + if (envp) { + int i; + + for (i = 2; envp[i]; i++) { + len = strlen(envp[i]) + 1; + pos = skb_put(skb, len); + strcpy(pos, envp[i]); + } + } + + NETLINK_CB(skb).dst_group = 1; + return netlink_broadcast(uevent_sock, skb, 0, 1, gfp_mask); +} + +static int do_kobject_uevent(struct kobject *kobj, enum kobject_action action, + struct attribute *attr, gfp_t gfp_mask) +{ + char *path; + char *attrpath; + char *signal; + int len; + int rc = -ENOMEM; + + path = kobject_get_path(kobj, gfp_mask); + if (!path) + return -ENOMEM; + + signal = action_to_string(action); + if (!signal) + return -EINVAL; + + if (attr) { + len = strlen(path); + len += strlen(attr->name) + 2; + attrpath = kmalloc(len, gfp_mask); + if (!attrpath) + goto exit; + sprintf(attrpath, "%s/%s", path, attr->name); + rc = send_uevent(signal, attrpath, NULL, gfp_mask); + kfree(attrpath); + } else + rc = send_uevent(signal, path, NULL, gfp_mask); + +exit: + kfree(path); + return rc; +} + +/** + * kobject_uevent - notify userspace by sending event through netlink socket + * + * @signal: signal name + * @kobj: struct kobject that the event is happening to + * @attr: optional struct attribute the event belongs to + */ +int kobject_uevent(struct kobject *kobj, enum kobject_action action, + struct attribute *attr) +{ + return do_kobject_uevent(kobj, action, attr, GFP_KERNEL); +} +EXPORT_SYMBOL_GPL(kobject_uevent); + +int kobject_uevent_atomic(struct kobject *kobj, enum kobject_action action, + struct attribute *attr) +{ + return do_kobject_uevent(kobj, action, attr, GFP_ATOMIC); +} +EXPORT_SYMBOL_GPL(kobject_uevent_atomic); + +static int __init kobject_uevent_init(void) +{ + uevent_sock = netlink_kernel_create(NETLINK_KOBJECT_UEVENT, 1, NULL, + THIS_MODULE); + + if (!uevent_sock) { + printk(KERN_ERR + "kobject_uevent: unable to create netlink socket!\n"); + return -ENODEV; + } + + return 0; +} + +postcore_initcall(kobject_uevent_init); + +#else +static inline int send_uevent(const char *signal, const char *obj, + char **envp, int gfp_mask) +{ + return 0; +} + +#endif /* CONFIG_KOBJECT_UEVENT */ + + +#ifdef CONFIG_HOTPLUG +char hotplug_path[HOTPLUG_PATH_LEN] = "/sbin/hotplug"; +u64 hotplug_seqnum; +static DEFINE_SPINLOCK(sequence_lock); + +/** + * kobject_hotplug - notify userspace by executing /sbin/hotplug + * + * @action: action that is happening (usually "ADD" or "REMOVE") * @kobj: struct kobject that the action is happening to */ -void kobject_uevent(struct kobject *kobj, enum kobject_action action) +void kobject_hotplug(struct kobject *kobj, enum kobject_action action) { - char **envp; - char *buffer; - char *scratch; - const char *action_string; - const char *devpath = NULL; - const char *subsystem; - struct kobject *top_kobj; - struct kset *kset; - struct kset_uevent_ops *uevent_ops; - u64 seq; + char *argv [3]; + char **envp = NULL; + char *buffer = NULL; char *seq_buff; + char *scratch; int i = 0; int retval; + char *kobj_path = NULL; + const char *name = NULL; + char *action_string; + u64 seq; + struct kobject *top_kobj = kobj; + struct kset *kset; + static struct kset_hotplug_ops null_hotplug_ops; + struct kset_hotplug_ops *hotplug_ops = &null_hotplug_ops; - pr_debug("%s\n", __FUNCTION__); - - action_string = action_to_string(action); - if (!action_string) - return; - - /* search the kset we belong to */ - top_kobj = kobj; + /* If this kobj does not belong to a kset, + try to find a parent that does. */ if (!top_kobj->kset && top_kobj->parent) { do { top_kobj = top_kobj->parent; } while (!top_kobj->kset && top_kobj->parent); } - if (!top_kobj->kset) + + if (top_kobj->kset) + kset = top_kobj->kset; + else return; - kset = top_kobj->kset; - uevent_ops = kset->uevent_ops; + if (kset->hotplug_ops) + hotplug_ops = kset->hotplug_ops; - /* skip the event, if the filter returns zero. */ - if (uevent_ops && uevent_ops->filter) - if (!uevent_ops->filter(kset, kobj)) + /* If the kset has a filter operation, call it. + Skip the event, if the filter returns zero. */ + if (hotplug_ops->filter) { + if (!hotplug_ops->filter(kset, kobj)) return; + } - /* environment index */ - envp = kzalloc(NUM_ENVP * sizeof (char *), GFP_KERNEL); + pr_debug ("%s\n", __FUNCTION__); + + action_string = action_to_string(action); + if (!action_string) + return; + + envp = kmalloc(NUM_ENVP * sizeof (char *), GFP_KERNEL); if (!envp) return; + memset (envp, 0x00, NUM_ENVP * sizeof (char *)); - /* environment values */ buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); if (!buffer) goto exit; - /* complete object path */ - devpath = kobject_get_path(kobj, GFP_KERNEL); - if (!devpath) - goto exit; + if (hotplug_ops->name) + name = hotplug_ops->name(kset, kobj); + if (name == NULL) + name = kobject_name(&kset->kobj); - /* originating subsystem */ - if (uevent_ops && uevent_ops->name) - subsystem = uevent_ops->name(kset, kobj); - else - subsystem = kobject_name(&kset->kobj); + argv [0] = hotplug_path; + argv [1] = (char *)name; /* won't be changed but 'const' has to go */ + argv [2] = NULL; - /* event environemnt for helper process only */ - envp[i++] = "HOME=/"; - envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; + /* minimal command environment */ + envp [i++] = "HOME=/"; + envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; - /* default keys */ scratch = buffer; + envp [i++] = scratch; scratch += sprintf(scratch, "ACTION=%s", action_string) + 1; + + kobj_path = kobject_get_path(kobj, GFP_KERNEL); + if (!kobj_path) + goto exit; + envp [i++] = scratch; - scratch += sprintf (scratch, "DEVPATH=%s", devpath) + 1; + scratch += sprintf (scratch, "DEVPATH=%s", kobj_path) + 1; + envp [i++] = scratch; - scratch += sprintf(scratch, "SUBSYSTEM=%s", subsystem) + 1; + scratch += sprintf(scratch, "SUBSYSTEM=%s", name) + 1; - /* just reserve the space, overwrite it after kset call has returned */ + /* reserve space for the sequence, + * put the real one in after the hotplug call */ envp[i++] = seq_buff = scratch; scratch += strlen("SEQNUM=18446744073709551616") + 1; - /* let the kset specific function add its stuff */ - if (uevent_ops && uevent_ops->uevent) { - retval = uevent_ops->uevent(kset, kobj, + if (hotplug_ops->hotplug) { + /* have the kset specific function add its stuff */ + retval = hotplug_ops->hotplug (kset, kobj, &envp[i], NUM_ENVP - i, scratch, BUFFER_SIZE - (scratch - buffer)); if (retval) { - pr_debug ("%s - uevent() returned %d\n", + pr_debug ("%s - hotplug() returned %d\n", __FUNCTION__, retval); goto exit; } } - /* we will send an event, request a new sequence number */ spin_lock(&sequence_lock); - seq = ++uevent_seqnum; + seq = ++hotplug_seqnum; spin_unlock(&sequence_lock); sprintf(seq_buff, "SEQNUM=%llu", (unsigned long long)seq); - /* send netlink message */ - if (uevent_sock) { - struct sk_buff *skb; - size_t len; - - /* allocate message with the maximum possible size */ - len = strlen(action_string) + strlen(devpath) + 2; - skb = alloc_skb(len + BUFFER_SIZE, GFP_KERNEL); - if (skb) { - /* add header */ - scratch = skb_put(skb, len); - sprintf(scratch, "%s@%s", action_string, devpath); - - /* copy keys to our continuous event payload buffer */ - for (i = 2; envp[i]; i++) { - len = strlen(envp[i]) + 1; - scratch = skb_put(skb, len); - strcpy(scratch, envp[i]); - } - - NETLINK_CB(skb).dst_group = 1; - netlink_broadcast(uevent_sock, skb, 0, 1, GFP_KERNEL); - } - } + pr_debug ("%s: %s %s seq=%llu %s %s %s %s %s\n", + __FUNCTION__, argv[0], argv[1], (unsigned long long)seq, + envp[0], envp[1], envp[2], envp[3], envp[4]); - /* call uevent_helper, usually only enabled during early boot */ - if (uevent_helper[0]) { - char *argv [3]; + send_uevent(action_string, kobj_path, envp, GFP_KERNEL); - argv [0] = uevent_helper; - argv [1] = (char *)subsystem; - argv [2] = NULL; - call_usermodehelper (argv[0], argv, envp, 0); - } + if (!hotplug_path[0]) + goto exit; + + retval = call_usermodehelper (argv[0], argv, envp, 0); + if (retval) + pr_debug ("%s - call_usermodehelper returned %d\n", + __FUNCTION__, retval); exit: - kfree(devpath); + kfree(kobj_path); kfree(buffer); kfree(envp); return; } -EXPORT_SYMBOL_GPL(kobject_uevent); +EXPORT_SYMBOL(kobject_hotplug); /** - * add_uevent_var - helper for creating event variables + * add_hotplug_env_var - helper for creating hotplug environment variables * @envp: Pointer to table of environment variables, as passed into - * uevent() method. + * hotplug() method. * @num_envp: Number of environment variable slots available, as - * passed into uevent() method. + * passed into hotplug() method. * @cur_index: Pointer to current index into @envp. It should be - * initialized to 0 before the first call to add_uevent_var(), + * initialized to 0 before the first call to add_hotplug_env_var(), * and will be incremented on success. * @buffer: Pointer to buffer for environment variables, as passed - * into uevent() method. - * @buffer_size: Length of @buffer, as passed into uevent() method. + * into hotplug() method. + * @buffer_size: Length of @buffer, as passed into hotplug() method. * @cur_len: Pointer to current length of space used in @buffer. * Should be initialized to 0 before the first call to - * add_uevent_var(), and will be incremented on success. + * add_hotplug_env_var(), and will be incremented on success. * @format: Format for creating environment variable (of the form * "XXX=%x") for snprintf(). * * Returns 0 if environment variable was added successfully or -ENOMEM * if no space was available. */ -int add_uevent_var(char **envp, int num_envp, int *cur_index, - char *buffer, int buffer_size, int *cur_len, - const char *format, ...) +int add_hotplug_env_var(char **envp, int num_envp, int *cur_index, + char *buffer, int buffer_size, int *cur_len, + const char *format, ...) { va_list args; /* * We check against num_envp - 1 to make sure there is at - * least one slot left after we return, since kobject_uevent() - * needs to set the last slot to NULL. + * least one slot left after we return, since the hotplug + * method needs to set the last slot to NULL. */ if (*cur_index >= num_envp - 1) return -ENOMEM; @@ -241,22 +366,6 @@ int add_uevent_var(char **envp, int num_envp, int *cur_index, (*cur_index)++; return 0; } -EXPORT_SYMBOL_GPL(add_uevent_var); - -static int __init kobject_uevent_init(void) -{ - uevent_sock = netlink_kernel_create(NETLINK_KOBJECT_UEVENT, 1, NULL, - THIS_MODULE); - - if (!uevent_sock) { - printk(KERN_ERR - "kobject_uevent: unable to create netlink socket!\n"); - return -ENODEV; - } - - return 0; -} - -postcore_initcall(kobject_uevent_init); +EXPORT_SYMBOL(add_hotplug_env_var); #endif /* CONFIG_HOTPLUG */ diff --git a/trunk/net/appletalk/ddp.c b/trunk/net/appletalk/ddp.c index a5144e43aae1..7982656b9c83 100644 --- a/trunk/net/appletalk/ddp.c +++ b/trunk/net/appletalk/ddp.c @@ -63,7 +63,7 @@ #include struct datalink_proto *ddp_dl, *aarp_dl; -static const struct proto_ops atalk_dgram_ops; +static struct proto_ops atalk_dgram_ops; /**************************************************************************\ * * @@ -1763,7 +1763,7 @@ static int atalk_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr */ static int atalk_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) { - int rc = -ENOIOCTLCMD; + int rc = -EINVAL; struct sock *sk = sock->sk; void __user *argp = (void __user *)arg; @@ -1813,6 +1813,23 @@ static int atalk_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) rc = atif_ioctl(cmd, argp); rtnl_unlock(); break; + /* Physical layer ioctl calls */ + case SIOCSIFLINK: + case SIOCGIFHWADDR: + case SIOCSIFHWADDR: + case SIOCGIFFLAGS: + case SIOCSIFFLAGS: + case SIOCGIFTXQLEN: + case SIOCSIFTXQLEN: + case SIOCGIFMTU: + case SIOCGIFCONF: + case SIOCADDMULTI: + case SIOCDELMULTI: + case SIOCGIFCOUNT: + case SIOCGIFINDEX: + case SIOCGIFNAME: + rc = dev_ioctl(cmd, argp); + break; } return rc; @@ -1824,7 +1841,7 @@ static struct net_proto_family atalk_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops SOCKOPS_WRAPPED(atalk_dgram_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(atalk_dgram_ops) = { .family = PF_APPLETALK, .owner = THIS_MODULE, .release = atalk_release, diff --git a/trunk/net/atm/pvc.c b/trunk/net/atm/pvc.c index f2c541774dcd..2684a92da22b 100644 --- a/trunk/net/atm/pvc.c +++ b/trunk/net/atm/pvc.c @@ -102,7 +102,7 @@ static int pvc_getname(struct socket *sock,struct sockaddr *sockaddr, } -static const struct proto_ops pvc_proto_ops = { +static struct proto_ops pvc_proto_ops = { .family = PF_ATMPVC, .owner = THIS_MODULE, diff --git a/trunk/net/atm/svc.c b/trunk/net/atm/svc.c index 3a180cfd7b48..d7b266136bf6 100644 --- a/trunk/net/atm/svc.c +++ b/trunk/net/atm/svc.c @@ -613,7 +613,7 @@ static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) return error; } -static const struct proto_ops svc_proto_ops = { +static struct proto_ops svc_proto_ops = { .family = PF_ATMSVC, .owner = THIS_MODULE, diff --git a/trunk/net/ax25/af_ax25.c b/trunk/net/ax25/af_ax25.c index e8753c7fcad1..1b683f302657 100644 --- a/trunk/net/ax25/af_ax25.c +++ b/trunk/net/ax25/af_ax25.c @@ -54,7 +54,7 @@ HLIST_HEAD(ax25_list); DEFINE_SPINLOCK(ax25_list_lock); -static const struct proto_ops ax25_proto_ops; +static struct proto_ops ax25_proto_ops; static void ax25_free_sock(struct sock *sk) { @@ -1827,7 +1827,7 @@ static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) break; default: - res = -ENOIOCTLCMD; + res = dev_ioctl(cmd, argp); break; } release_sock(sk); @@ -1944,7 +1944,7 @@ static struct net_proto_family ax25_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops ax25_proto_ops = { +static struct proto_ops ax25_proto_ops = { .family = PF_AX25, .owner = THIS_MODULE, .release = ax25_release, diff --git a/trunk/net/bluetooth/af_bluetooth.c b/trunk/net/bluetooth/af_bluetooth.c index fb031fe9be9e..ea616e3fc98e 100644 --- a/trunk/net/bluetooth/af_bluetooth.c +++ b/trunk/net/bluetooth/af_bluetooth.c @@ -287,9 +287,10 @@ int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo) timeo = schedule_timeout(timeo); lock_sock(sk); - err = sock_error(sk); - if (err) + if (sk->sk_err) { + err = sock_error(sk); break; + } } set_current_state(TASK_RUNNING); remove_wait_queue(sk->sk_sleep, &wait); diff --git a/trunk/net/bluetooth/bnep/sock.c b/trunk/net/bluetooth/bnep/sock.c index ccbaf69afc5b..9778c6acd53b 100644 --- a/trunk/net/bluetooth/bnep/sock.c +++ b/trunk/net/bluetooth/bnep/sock.c @@ -146,7 +146,7 @@ static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long return 0; } -static const struct proto_ops bnep_sock_ops = { +static struct proto_ops bnep_sock_ops = { .family = PF_BLUETOOTH, .owner = THIS_MODULE, .release = bnep_sock_release, diff --git a/trunk/net/bluetooth/cmtp/sock.c b/trunk/net/bluetooth/cmtp/sock.c index 5e22343b6090..beb045bf5714 100644 --- a/trunk/net/bluetooth/cmtp/sock.c +++ b/trunk/net/bluetooth/cmtp/sock.c @@ -137,7 +137,7 @@ static int cmtp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long return -EINVAL; } -static const struct proto_ops cmtp_sock_ops = { +static struct proto_ops cmtp_sock_ops = { .family = PF_BLUETOOTH, .owner = THIS_MODULE, .release = cmtp_sock_release, diff --git a/trunk/net/bluetooth/hci_sock.c b/trunk/net/bluetooth/hci_sock.c index 84e6c93a044a..1d6d0a15c099 100644 --- a/trunk/net/bluetooth/hci_sock.c +++ b/trunk/net/bluetooth/hci_sock.c @@ -575,7 +575,7 @@ static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char return 0; } -static const struct proto_ops hci_sock_ops = { +static struct proto_ops hci_sock_ops = { .family = PF_BLUETOOTH, .owner = THIS_MODULE, .release = hci_sock_release, diff --git a/trunk/net/bluetooth/hci_sysfs.c b/trunk/net/bluetooth/hci_sysfs.c index 0ed38740388c..bd7568ac87fc 100644 --- a/trunk/net/bluetooth/hci_sysfs.c +++ b/trunk/net/bluetooth/hci_sysfs.c @@ -78,7 +78,7 @@ static struct class_device_attribute *bt_attrs[] = { }; #ifdef CONFIG_HOTPLUG -static int bt_uevent(struct class_device *cdev, char **envp, int num_envp, char *buf, int size) +static int bt_hotplug(struct class_device *cdev, char **envp, int num_envp, char *buf, int size) { struct hci_dev *hdev = class_get_devdata(cdev); int n, i = 0; @@ -107,7 +107,7 @@ struct class bt_class = { .name = "bluetooth", .release = bt_release, #ifdef CONFIG_HOTPLUG - .uevent = bt_uevent, + .hotplug = bt_hotplug, #endif }; diff --git a/trunk/net/bluetooth/hidp/sock.c b/trunk/net/bluetooth/hidp/sock.c index 8f8dd931b294..f8986f881431 100644 --- a/trunk/net/bluetooth/hidp/sock.c +++ b/trunk/net/bluetooth/hidp/sock.c @@ -143,7 +143,7 @@ static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long return -EINVAL; } -static const struct proto_ops hidp_sock_ops = { +static struct proto_ops hidp_sock_ops = { .family = PF_BLUETOOTH, .owner = THIS_MODULE, .release = hidp_sock_release, diff --git a/trunk/net/bluetooth/l2cap.c b/trunk/net/bluetooth/l2cap.c index 7f0781e4326f..e3bb11ca4235 100644 --- a/trunk/net/bluetooth/l2cap.c +++ b/trunk/net/bluetooth/l2cap.c @@ -57,7 +57,7 @@ #define VERSION "2.8" -static const struct proto_ops l2cap_sock_ops; +static struct proto_ops l2cap_sock_ops; static struct bt_sock_list l2cap_sk_list = { .lock = RW_LOCK_UNLOCKED @@ -767,9 +767,8 @@ static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct ms BT_DBG("sock %p, sk %p", sock, sk); - err = sock_error(sk); - if (err) - return err; + if (sk->sk_err) + return sock_error(sk); if (msg->msg_flags & MSG_OOB) return -EOPNOTSUPP; @@ -2161,7 +2160,7 @@ static ssize_t l2cap_sysfs_show(struct class *dev, char *buf) static CLASS_ATTR(l2cap, S_IRUGO, l2cap_sysfs_show, NULL); -static const struct proto_ops l2cap_sock_ops = { +static struct proto_ops l2cap_sock_ops = { .family = PF_BLUETOOTH, .owner = THIS_MODULE, .release = l2cap_sock_release, diff --git a/trunk/net/bluetooth/rfcomm/sock.c b/trunk/net/bluetooth/rfcomm/sock.c index 757d2dd3b02f..6c34261b232e 100644 --- a/trunk/net/bluetooth/rfcomm/sock.c +++ b/trunk/net/bluetooth/rfcomm/sock.c @@ -58,7 +58,7 @@ #define BT_DBG(D...) #endif -static const struct proto_ops rfcomm_sock_ops; +static struct proto_ops rfcomm_sock_ops; static struct bt_sock_list rfcomm_sk_list = { .lock = RW_LOCK_UNLOCKED @@ -907,7 +907,7 @@ static ssize_t rfcomm_sock_sysfs_show(struct class *dev, char *buf) static CLASS_ATTR(rfcomm, S_IRUGO, rfcomm_sock_sysfs_show, NULL); -static const struct proto_ops rfcomm_sock_ops = { +static struct proto_ops rfcomm_sock_ops = { .family = PF_BLUETOOTH, .owner = THIS_MODULE, .release = rfcomm_sock_release, diff --git a/trunk/net/bluetooth/sco.c b/trunk/net/bluetooth/sco.c index 6b61323ce23c..9cb00dc6c08c 100644 --- a/trunk/net/bluetooth/sco.c +++ b/trunk/net/bluetooth/sco.c @@ -56,7 +56,7 @@ #define VERSION "0.5" -static const struct proto_ops sco_sock_ops; +static struct proto_ops sco_sock_ops; static struct bt_sock_list sco_sk_list = { .lock = RW_LOCK_UNLOCKED @@ -637,9 +637,8 @@ static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock, BT_DBG("sock %p, sk %p", sock, sk); - err = sock_error(sk); - if (err) - return err; + if (sk->sk_err) + return sock_error(sk); if (msg->msg_flags & MSG_OOB) return -EOPNOTSUPP; @@ -914,7 +913,7 @@ static ssize_t sco_sysfs_show(struct class *dev, char *buf) static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL); -static const struct proto_ops sco_sock_ops = { +static struct proto_ops sco_sock_ops = { .family = PF_BLUETOOTH, .owner = THIS_MODULE, .release = sco_sock_release, diff --git a/trunk/net/bridge/br.c b/trunk/net/bridge/br.c index 188cc1ac49eb..f8f184942aaf 100644 --- a/trunk/net/bridge/br.c +++ b/trunk/net/bridge/br.c @@ -67,4 +67,3 @@ EXPORT_SYMBOL(br_should_route_hook); module_init(br_init) module_exit(br_deinit) MODULE_LICENSE("GPL"); -MODULE_VERSION(BR_VERSION); diff --git a/trunk/net/bridge/br_device.c b/trunk/net/bridge/br_device.c index 0b33a7b3a00c..f564ee99782d 100644 --- a/trunk/net/bridge/br_device.c +++ b/trunk/net/bridge/br_device.c @@ -15,9 +15,7 @@ #include #include -#include -#include - +#include #include #include "br_private.h" @@ -84,87 +82,6 @@ static int br_change_mtu(struct net_device *dev, int new_mtu) return 0; } -/* Allow setting mac address of pseudo-bridge to be same as - * any of the bound interfaces - */ -static int br_set_mac_address(struct net_device *dev, void *p) -{ - struct net_bridge *br = netdev_priv(dev); - struct sockaddr *addr = p; - struct net_bridge_port *port; - int err = -EADDRNOTAVAIL; - - spin_lock_bh(&br->lock); - list_for_each_entry(port, &br->port_list, list) { - if (!compare_ether_addr(port->dev->dev_addr, addr->sa_data)) { - br_stp_change_bridge_id(br, addr->sa_data); - err = 0; - break; - } - } - spin_unlock_bh(&br->lock); - - return err; -} - -static void br_getinfo(struct net_device *dev, struct ethtool_drvinfo *info) -{ - strcpy(info->driver, "bridge"); - strcpy(info->version, BR_VERSION); - strcpy(info->fw_version, "N/A"); - strcpy(info->bus_info, "N/A"); -} - -static int br_set_sg(struct net_device *dev, u32 data) -{ - struct net_bridge *br = netdev_priv(dev); - - if (data) - br->feature_mask |= NETIF_F_SG; - else - br->feature_mask &= ~NETIF_F_SG; - - br_features_recompute(br); - return 0; -} - -static int br_set_tso(struct net_device *dev, u32 data) -{ - struct net_bridge *br = netdev_priv(dev); - - if (data) - br->feature_mask |= NETIF_F_TSO; - else - br->feature_mask &= ~NETIF_F_TSO; - - br_features_recompute(br); - return 0; -} - -static int br_set_tx_csum(struct net_device *dev, u32 data) -{ - struct net_bridge *br = netdev_priv(dev); - - if (data) - br->feature_mask |= NETIF_F_IP_CSUM; - else - br->feature_mask &= ~NETIF_F_IP_CSUM; - - br_features_recompute(br); - return 0; -} - -static struct ethtool_ops br_ethtool_ops = { - .get_drvinfo = br_getinfo, - .get_link = ethtool_op_get_link, - .get_sg = ethtool_op_get_sg, - .set_sg = br_set_sg, - .get_tx_csum = ethtool_op_get_tx_csum, - .set_tx_csum = br_set_tx_csum, - .get_tso = ethtool_op_get_tso, - .set_tso = br_set_tso, -}; - void br_dev_setup(struct net_device *dev) { memset(dev->dev_addr, 0, ETH_ALEN); @@ -179,12 +96,8 @@ void br_dev_setup(struct net_device *dev) dev->change_mtu = br_change_mtu; dev->destructor = free_netdev; SET_MODULE_OWNER(dev); - SET_ETHTOOL_OPS(dev, &br_ethtool_ops); dev->stop = br_dev_stop; dev->tx_queue_len = 0; - dev->set_mac_address = br_set_mac_address; + dev->set_mac_address = NULL; dev->priv_flags = IFF_EBRIDGE; - - dev->features = NETIF_F_SG | NETIF_F_FRAGLIST - | NETIF_F_HIGHDMA | NETIF_F_TSO | NETIF_F_IP_CSUM; } diff --git a/trunk/net/bridge/br_if.c b/trunk/net/bridge/br_if.c index ba442883e877..975abe254b7a 100644 --- a/trunk/net/bridge/br_if.c +++ b/trunk/net/bridge/br_if.c @@ -20,7 +20,6 @@ #include #include #include -#include #include #include "br_private.h" @@ -33,8 +32,9 @@ * ethtool, use ethtool_ops. Also, since driver might sleep need to * not be holding any locks. */ -static int port_cost(struct net_device *dev) +static int br_initial_port_cost(struct net_device *dev) { + struct ethtool_cmd ecmd = { ETHTOOL_GSET }; struct ifreq ifr; mm_segment_t old_fs; @@ -58,6 +58,10 @@ static int port_cost(struct net_device *dev) return 2; case SPEED_10: return 100; + default: + pr_info("bridge: can't decode speed from %s: %d\n", + dev->name, ecmd.speed); + return 100; } } @@ -71,35 +75,6 @@ static int port_cost(struct net_device *dev) return 100; /* assume old 10Mbps */ } - -/* - * Check for port carrier transistions. - * Called from work queue to allow for calling functions that - * might sleep (such as speed check), and to debounce. - */ -static void port_carrier_check(void *arg) -{ - struct net_bridge_port *p = arg; - - rtnl_lock(); - if (netif_carrier_ok(p->dev)) { - u32 cost = port_cost(p->dev); - - spin_lock_bh(&p->br->lock); - if (p->state == BR_STATE_DISABLED) { - p->path_cost = cost; - br_stp_enable_port(p); - } - spin_unlock_bh(&p->br->lock); - } else { - spin_lock_bh(&p->br->lock); - if (p->state != BR_STATE_DISABLED) - br_stp_disable_port(p); - spin_unlock_bh(&p->br->lock); - } - rtnl_unlock(); -} - static void destroy_nbp(struct net_bridge_port *p) { struct net_device *dev = p->dev; @@ -127,9 +102,6 @@ static void del_nbp(struct net_bridge_port *p) dev->br_port = NULL; dev_set_promiscuity(dev, -1); - cancel_delayed_work(&p->carrier_check); - flush_scheduled_work(); - spin_lock_bh(&br->lock); br_stp_disable_port(p); spin_unlock_bh(&br->lock); @@ -183,7 +155,6 @@ static struct net_device *new_bridge_dev(const char *name) br->bridge_id.prio[1] = 0x00; memset(br->bridge_id.addr, 0, ETH_ALEN); - br->feature_mask = dev->features; br->stp_enabled = 0; br->designated_root = br->bridge_id; br->root_path_cost = 0; @@ -224,9 +195,10 @@ static int find_portno(struct net_bridge *br) return (index >= BR_MAX_PORTS) ? -EXFULL : index; } -/* called with RTNL but without bridge lock */ +/* called with RTNL */ static struct net_bridge_port *new_nbp(struct net_bridge *br, - struct net_device *dev) + struct net_device *dev, + unsigned long cost) { int index; struct net_bridge_port *p; @@ -243,13 +215,12 @@ static struct net_bridge_port *new_nbp(struct net_bridge *br, p->br = br; dev_hold(dev); p->dev = dev; - p->path_cost = port_cost(dev); + p->path_cost = cost; p->priority = 0x8000 >> BR_PORT_BITS; dev->br_port = p; p->port_no = index; br_init_port(p); p->state = BR_STATE_DISABLED; - INIT_WORK(&p->carrier_check, port_carrier_check, p); kobject_init(&p->kobj); return p; @@ -324,7 +295,7 @@ int br_del_bridge(const char *name) return ret; } -/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */ +/* Mtu of the bridge pseudo-device 1500 or the minimum of the ports */ int br_min_mtu(const struct net_bridge *br) { const struct net_bridge_port *p; @@ -333,7 +304,7 @@ int br_min_mtu(const struct net_bridge *br) ASSERT_RTNL(); if (list_empty(&br->port_list)) - mtu = ETH_DATA_LEN; + mtu = 1500; else { list_for_each_entry(p, &br->port_list, list) { if (!mtu || p->dev->mtu < mtu) @@ -351,8 +322,9 @@ void br_features_recompute(struct net_bridge *br) struct net_bridge_port *p; unsigned long features, checksum; - features = br->feature_mask &~ NETIF_F_IP_CSUM; - checksum = br->feature_mask & NETIF_F_IP_CSUM; + features = NETIF_F_SG | NETIF_F_FRAGLIST + | NETIF_F_HIGHDMA | NETIF_F_TSO; + checksum = NETIF_F_IP_CSUM; /* least commmon subset */ list_for_each_entry(p, &br->port_list, list) { if (!(p->dev->features @@ -379,7 +351,7 @@ int br_add_if(struct net_bridge *br, struct net_device *dev) if (dev->br_port != NULL) return -EBUSY; - if (IS_ERR(p = new_nbp(br, dev))) + if (IS_ERR(p = new_nbp(br, dev, br_initial_port_cost(dev)))) return PTR_ERR(p); if ((err = br_fdb_insert(br, p, dev->dev_addr))) diff --git a/trunk/net/bridge/br_input.c b/trunk/net/bridge/br_input.c index c387852f753a..b88220a64cd8 100644 --- a/trunk/net/bridge/br_input.c +++ b/trunk/net/bridge/br_input.c @@ -53,11 +53,6 @@ int br_handle_frame_finish(struct sk_buff *skb) /* insert into forwarding database after filtering to avoid spoofing */ br_fdb_update(p->br, p, eth_hdr(skb)->h_source); - if (p->state == BR_STATE_LEARNING) { - kfree_skb(skb); - goto out; - } - if (br->dev->flags & IFF_PROMISC) { struct sk_buff *skb2; @@ -112,6 +107,9 @@ int br_handle_frame(struct net_bridge_port *p, struct sk_buff **pskb) if (!is_valid_ether_addr(eth_hdr(skb)->h_source)) goto err; + if (p->state == BR_STATE_LEARNING) + br_fdb_update(p->br, p, eth_hdr(skb)->h_source); + if (p->br->stp_enabled && !memcmp(dest, bridge_ula, 5) && !(dest[5] & 0xF0)) { @@ -120,10 +118,9 @@ int br_handle_frame(struct net_bridge_port *p, struct sk_buff **pskb) NULL, br_stp_handle_bpdu); return 1; } - goto err; } - if (p->state == BR_STATE_FORWARDING || p->state == BR_STATE_LEARNING) { + else if (p->state == BR_STATE_FORWARDING) { if (br_should_route_hook) { if (br_should_route_hook(pskb)) return 0; diff --git a/trunk/net/bridge/br_netfilter.c b/trunk/net/bridge/br_netfilter.c index 223f8270daee..23422bd53a5e 100644 --- a/trunk/net/bridge/br_netfilter.c +++ b/trunk/net/bridge/br_netfilter.c @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include @@ -34,11 +33,8 @@ #include #include #include - #include #include -#include - #include #include #include "br_private.h" diff --git a/trunk/net/bridge/br_notify.c b/trunk/net/bridge/br_notify.c index a43a9c1d50d7..917311c6828b 100644 --- a/trunk/net/bridge/br_notify.c +++ b/trunk/net/bridge/br_notify.c @@ -52,9 +52,17 @@ static int br_device_event(struct notifier_block *unused, unsigned long event, v br_stp_recalculate_bridge_id(br); break; - case NETDEV_CHANGE: - if (br->dev->flags & IFF_UP) - schedule_delayed_work(&p->carrier_check, BR_PORT_DEBOUNCE); + case NETDEV_CHANGE: /* device is up but carrier changed */ + if (!(br->dev->flags & IFF_UP)) + break; + + if (netif_carrier_ok(dev)) { + if (p->state == BR_STATE_DISABLED) + br_stp_enable_port(p); + } else { + if (p->state != BR_STATE_DISABLED) + br_stp_disable_port(p); + } break; case NETDEV_FEAT_CHANGE: diff --git a/trunk/net/bridge/br_private.h b/trunk/net/bridge/br_private.h index c5bd631ffcd5..bdf95a74d8cd 100644 --- a/trunk/net/bridge/br_private.h +++ b/trunk/net/bridge/br_private.h @@ -27,10 +27,6 @@ #define BR_PORT_BITS 10 #define BR_MAX_PORTS (1<port_list, list) { if (addr == br_mac_zero || - memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0) + compare_ether_addr(p->dev->dev_addr, addr) < 0) addr = p->dev->dev_addr; } diff --git a/trunk/net/bridge/br_sysfs_if.c b/trunk/net/bridge/br_sysfs_if.c index 2ebdc23bbe26..f6a19d53eaeb 100644 --- a/trunk/net/bridge/br_sysfs_if.c +++ b/trunk/net/bridge/br_sysfs_if.c @@ -248,7 +248,7 @@ int br_sysfs_addif(struct net_bridge_port *p) if (err) goto out2; - kobject_uevent(&p->kobj, KOBJ_ADD); + kobject_hotplug(&p->kobj, KOBJ_ADD); return 0; out2: kobject_del(&p->kobj); @@ -260,7 +260,7 @@ void br_sysfs_removeif(struct net_bridge_port *p) { pr_debug("br_sysfs_removeif\n"); sysfs_remove_link(&p->br->ifobj, p->dev->name); - kobject_uevent(&p->kobj, KOBJ_REMOVE); + kobject_hotplug(&p->kobj, KOBJ_REMOVE); kobject_del(&p->kobj); } diff --git a/trunk/net/bridge/netfilter/Kconfig b/trunk/net/bridge/netfilter/Kconfig index b84fc6075fe1..c70b3be23026 100644 --- a/trunk/net/bridge/netfilter/Kconfig +++ b/trunk/net/bridge/netfilter/Kconfig @@ -196,13 +196,9 @@ config BRIDGE_EBT_LOG To compile it as a module, choose M here. If unsure, say N. config BRIDGE_EBT_ULOG - tristate "ebt: ulog support (OBSOLETE)" + tristate "ebt: ulog support" depends on BRIDGE_NF_EBTABLES help - This option enables the old bridge-specific "ebt_ulog" implementation - which has been obsoleted by the new "nfnetlink_log" code (see - CONFIG_NETFILTER_NETLINK_LOG). - This option adds the ulog watcher, that you can use in any rule in any ebtables table. The packet is passed to a userspace logging daemon using netlink multicast sockets. This differs diff --git a/trunk/net/bridge/netfilter/ebt_log.c b/trunk/net/bridge/netfilter/ebt_log.c index 9f6e0193ae10..662975be3d1d 100644 --- a/trunk/net/bridge/netfilter/ebt_log.c +++ b/trunk/net/bridge/netfilter/ebt_log.c @@ -3,16 +3,13 @@ * * Authors: * Bart De Schuymer - * Harald Welte * * April, 2002 * */ -#include #include #include -#include #include #include #include @@ -58,30 +55,27 @@ static void print_MAC(unsigned char *p) } #define myNIPQUAD(a) a[0], a[1], a[2], a[3] -static void -ebt_log_packet(unsigned int pf, unsigned int hooknum, - const struct sk_buff *skb, const struct net_device *in, - const struct net_device *out, const struct nf_loginfo *loginfo, - const char *prefix) +static void ebt_log(const struct sk_buff *skb, unsigned int hooknr, + const struct net_device *in, const struct net_device *out, + const void *data, unsigned int datalen) { - unsigned int bitmask; + struct ebt_log_info *info = (struct ebt_log_info *)data; + char level_string[4] = "< >"; + level_string[1] = '0' + info->loglevel; spin_lock_bh(&ebt_log_lock); - printk("<%c>%s IN=%s OUT=%s MAC source = ", '0' + loginfo->u.log.level, - prefix, in ? in->name : "", out ? out->name : ""); + printk(level_string); + printk("%s IN=%s OUT=%s ", info->prefix, in ? in->name : "", + out ? out->name : ""); + printk("MAC source = "); print_MAC(eth_hdr(skb)->h_source); printk("MAC dest = "); print_MAC(eth_hdr(skb)->h_dest); printk("proto = 0x%04x", ntohs(eth_hdr(skb)->h_proto)); - if (loginfo->type == NF_LOG_TYPE_LOG) - bitmask = loginfo->u.log.logflags; - else - bitmask = NF_LOG_MASK; - - if ((bitmask & EBT_LOG_IP) && eth_hdr(skb)->h_proto == + if ((info->bitmask & EBT_LOG_IP) && eth_hdr(skb)->h_proto == htons(ETH_P_IP)){ struct iphdr _iph, *ih; @@ -90,9 +84,10 @@ ebt_log_packet(unsigned int pf, unsigned int hooknum, printk(" INCOMPLETE IP header"); goto out; } - printk(" IP SRC=%u.%u.%u.%u IP DST=%u.%u.%u.%u, IP " - "tos=0x%02X, IP proto=%d", NIPQUAD(ih->saddr), - NIPQUAD(ih->daddr), ih->tos, ih->protocol); + printk(" IP SRC=%u.%u.%u.%u IP DST=%u.%u.%u.%u,", + NIPQUAD(ih->saddr), NIPQUAD(ih->daddr)); + printk(" IP tos=0x%02X, IP proto=%d", ih->tos, + ih->protocol); if (ih->protocol == IPPROTO_TCP || ih->protocol == IPPROTO_UDP) { struct tcpudphdr _ports, *pptr; @@ -109,7 +104,7 @@ ebt_log_packet(unsigned int pf, unsigned int hooknum, goto out; } - if ((bitmask & EBT_LOG_ARP) && + if ((info->bitmask & EBT_LOG_ARP) && ((eth_hdr(skb)->h_proto == htons(ETH_P_ARP)) || (eth_hdr(skb)->h_proto == htons(ETH_P_RARP)))) { struct arphdr _arph, *ah; @@ -149,21 +144,6 @@ ebt_log_packet(unsigned int pf, unsigned int hooknum, out: printk("\n"); spin_unlock_bh(&ebt_log_lock); - -} - -static void ebt_log(const struct sk_buff *skb, unsigned int hooknr, - const struct net_device *in, const struct net_device *out, - const void *data, unsigned int datalen) -{ - struct ebt_log_info *info = (struct ebt_log_info *)data; - struct nf_loginfo li; - - li.type = NF_LOG_TYPE_LOG; - li.u.log.level = info->loglevel; - li.u.log.logflags = info->bitmask; - - nf_log_packet(PF_BRIDGE, hooknr, skb, in, out, &li, info->prefix); } static struct ebt_watcher log = @@ -174,32 +154,13 @@ static struct ebt_watcher log = .me = THIS_MODULE, }; -static struct nf_logger ebt_log_logger = { - .name = "ebt_log", - .logfn = &ebt_log_packet, - .me = THIS_MODULE, -}; - static int __init init(void) { - int ret; - - ret = ebt_register_watcher(&log); - if (ret < 0) - return ret; - if (nf_log_register(PF_BRIDGE, &ebt_log_logger) < 0) { - printk(KERN_WARNING "ebt_log: not logging via system console " - "since somebody else already registered for PF_INET\n"); - /* we cannot make module load fail here, since otherwise - * ebtables userspace would abort */ - } - - return 0; + return ebt_register_watcher(&log); } static void __exit fini(void) { - nf_log_unregister_logger(&ebt_log_logger); ebt_unregister_watcher(&log); } diff --git a/trunk/net/bridge/netfilter/ebt_ulog.c b/trunk/net/bridge/netfilter/ebt_ulog.c index ce617b3dbbb8..aae26ae2e61f 100644 --- a/trunk/net/bridge/netfilter/ebt_ulog.c +++ b/trunk/net/bridge/netfilter/ebt_ulog.c @@ -3,7 +3,6 @@ * * Authors: * Bart De Schuymer - * Harald Welte * * November, 2004 * @@ -116,13 +115,14 @@ static struct sk_buff *ulog_alloc_skb(unsigned int size) return skb; } -static void ebt_ulog_packet(unsigned int hooknr, const struct sk_buff *skb, +static void ebt_ulog(const struct sk_buff *skb, unsigned int hooknr, const struct net_device *in, const struct net_device *out, - const struct ebt_ulog_info *uloginfo, const char *prefix) + const void *data, unsigned int datalen) { ebt_ulog_packet_msg_t *pm; size_t size, copy_len; struct nlmsghdr *nlh; + struct ebt_ulog_info *uloginfo = (struct ebt_ulog_info *)data; unsigned int group = uloginfo->nlgroup; ebt_ulog_buff_t *ub = &ulog_buffers[group]; spinlock_t *lock = &ub->lock; @@ -216,39 +216,6 @@ static void ebt_ulog_packet(unsigned int hooknr, const struct sk_buff *skb, goto unlock; } -/* this function is registered with the netfilter core */ -static void ebt_log_packet(unsigned int pf, unsigned int hooknum, - const struct sk_buff *skb, const struct net_device *in, - const struct net_device *out, const struct nf_loginfo *li, - const char *prefix) -{ - struct ebt_ulog_info loginfo; - - if (!li || li->type != NF_LOG_TYPE_ULOG) { - loginfo.nlgroup = EBT_ULOG_DEFAULT_NLGROUP; - loginfo.cprange = 0; - loginfo.qthreshold = EBT_ULOG_DEFAULT_QTHRESHOLD; - loginfo.prefix[0] = '\0'; - } else { - loginfo.nlgroup = li->u.ulog.group; - loginfo.cprange = li->u.ulog.copy_len; - loginfo.qthreshold = li->u.ulog.qthreshold; - strlcpy(loginfo.prefix, prefix, sizeof(loginfo.prefix)); - } - - ebt_ulog_packet(hooknum, skb, in, out, &loginfo, prefix); -} - -static void ebt_ulog(const struct sk_buff *skb, unsigned int hooknr, - const struct net_device *in, const struct net_device *out, - const void *data, unsigned int datalen) -{ - struct ebt_ulog_info *uloginfo = (struct ebt_ulog_info *)data; - - ebt_ulog_packet(hooknr, skb, in, out, uloginfo, NULL); -} - - static int ebt_ulog_check(const char *tablename, unsigned int hookmask, const struct ebt_entry *e, void *data, unsigned int datalen) { @@ -273,12 +240,6 @@ static struct ebt_watcher ulog = { .me = THIS_MODULE, }; -static struct nf_logger ebt_ulog_logger = { - .name = EBT_ULOG_WATCHER, - .logfn = &ebt_log_packet, - .me = THIS_MODULE, -}; - static int __init init(void) { int i, ret = 0; @@ -304,13 +265,6 @@ static int __init init(void) else if ((ret = ebt_register_watcher(&ulog))) sock_release(ebtulognl->sk_socket); - if (nf_log_register(PF_BRIDGE, &ebt_ulog_logger) < 0) { - printk(KERN_WARNING "ebt_ulog: not logging via ulog " - "since somebody else already registered for PF_BRIDGE\n"); - /* we cannot make module load fail here, since otherwise - * ebtables userspace would abort */ - } - return ret; } @@ -319,7 +273,6 @@ static void __exit fini(void) ebt_ulog_buff_t *ub; int i; - nf_log_unregister_logger(&ebt_ulog_logger); ebt_unregister_watcher(&ulog); for (i = 0; i < EBT_ULOG_MAXNLGROUPS; i++) { ub = &ulog_buffers[i]; diff --git a/trunk/net/core/datagram.c b/trunk/net/core/datagram.c index f8d322e1ea92..1bcfef51ac58 100644 --- a/trunk/net/core/datagram.c +++ b/trunk/net/core/datagram.c @@ -47,7 +47,6 @@ #include #include #include -#include #include #include @@ -200,41 +199,6 @@ void skb_free_datagram(struct sock *sk, struct sk_buff *skb) kfree_skb(skb); } -/** - * skb_kill_datagram - Free a datagram skbuff forcibly - * @sk: socket - * @skb: datagram skbuff - * @flags: MSG_ flags - * - * This function frees a datagram skbuff that was received by - * skb_recv_datagram. The flags argument must match the one - * used for skb_recv_datagram. - * - * If the MSG_PEEK flag is set, and the packet is still on the - * receive queue of the socket, it will be taken off the queue - * before it is freed. - * - * This function currently only disables BH when acquiring the - * sk_receive_queue lock. Therefore it must not be used in a - * context where that lock is acquired in an IRQ context. - */ - -void skb_kill_datagram(struct sock *sk, struct sk_buff *skb, unsigned int flags) -{ - if (flags & MSG_PEEK) { - spin_lock_bh(&sk->sk_receive_queue.lock); - if (skb == skb_peek(&sk->sk_receive_queue)) { - __skb_unlink(skb, &sk->sk_receive_queue); - atomic_dec(&skb->users); - } - spin_unlock_bh(&sk->sk_receive_queue.lock); - } - - kfree_skb(skb); -} - -EXPORT_SYMBOL(skb_kill_datagram); - /** * skb_copy_datagram_iovec - Copy a datagram to an iovec. * @skb: buffer to copy diff --git a/trunk/net/core/dev.c b/trunk/net/core/dev.c index 5081287923d5..a5efc9ae010b 100644 --- a/trunk/net/core/dev.c +++ b/trunk/net/core/dev.c @@ -626,7 +626,7 @@ struct net_device * dev_get_by_flags(unsigned short if_flags, unsigned short mas * Network device names need to be valid file names to * to allow sysfs to work */ -int dev_valid_name(const char *name) +static int dev_valid_name(const char *name) { return !(*name == '\0' || !strcmp(name, ".") @@ -3270,13 +3270,13 @@ EXPORT_SYMBOL(__dev_get_by_index); EXPORT_SYMBOL(__dev_get_by_name); EXPORT_SYMBOL(__dev_remove_pack); EXPORT_SYMBOL(__skb_linearize); -EXPORT_SYMBOL(dev_valid_name); EXPORT_SYMBOL(dev_add_pack); EXPORT_SYMBOL(dev_alloc_name); EXPORT_SYMBOL(dev_close); EXPORT_SYMBOL(dev_get_by_flags); EXPORT_SYMBOL(dev_get_by_index); EXPORT_SYMBOL(dev_get_by_name); +EXPORT_SYMBOL(dev_ioctl); EXPORT_SYMBOL(dev_open); EXPORT_SYMBOL(dev_queue_xmit); EXPORT_SYMBOL(dev_remove_pack); diff --git a/trunk/net/core/filter.c b/trunk/net/core/filter.c index 8964d3445588..3a10e0bc90e8 100644 --- a/trunk/net/core/filter.c +++ b/trunk/net/core/filter.c @@ -13,7 +13,6 @@ * 2 of the License, or (at your option) any later version. * * Andi Kleen - Fix a few bad bugs and races. - * Kris Katterjohn - Added many additional checks in sk_chk_filter() */ #include @@ -251,7 +250,7 @@ int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int flen) mem[fentry->k] = X; continue; default: - WARN_ON(1); + /* Invalid instruction counts as RET */ return 0; } @@ -284,8 +283,8 @@ int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int flen) * * Check the user's filter code. If we let some ugly * filter code slip through kaboom! The filter must contain - * no references or jumps that are out of range, no illegal - * instructions, and must end with a RET instruction. + * no references or jumps that are out of range, no illegal instructions + * and no backward jumps. It must end with a RET instruction * * Returns 0 if the rule set is legal or a negative errno code if not. */ @@ -301,85 +300,38 @@ int sk_chk_filter(struct sock_filter *filter, int flen) for (pc = 0; pc < flen; pc++) { /* all jumps are forward as they are not signed */ ftest = &filter[pc]; + if (BPF_CLASS(ftest->code) == BPF_JMP) { + /* but they mustn't jump off the end */ + if (BPF_OP(ftest->code) == BPF_JA) { + /* + * Note, the large ftest->k might cause loops. + * Compare this with conditional jumps below, + * where offsets are limited. --ANK (981016) + */ + if (ftest->k >= (unsigned)(flen-pc-1)) + return -EINVAL; + } else { + /* for conditionals both must be safe */ + if (pc + ftest->jt +1 >= flen || + pc + ftest->jf +1 >= flen) + return -EINVAL; + } + } - /* Only allow valid instructions */ - switch (ftest->code) { - case BPF_ALU|BPF_ADD|BPF_K: - case BPF_ALU|BPF_ADD|BPF_X: - case BPF_ALU|BPF_SUB|BPF_K: - case BPF_ALU|BPF_SUB|BPF_X: - case BPF_ALU|BPF_MUL|BPF_K: - case BPF_ALU|BPF_MUL|BPF_X: - case BPF_ALU|BPF_DIV|BPF_X: - case BPF_ALU|BPF_AND|BPF_K: - case BPF_ALU|BPF_AND|BPF_X: - case BPF_ALU|BPF_OR|BPF_K: - case BPF_ALU|BPF_OR|BPF_X: - case BPF_ALU|BPF_LSH|BPF_K: - case BPF_ALU|BPF_LSH|BPF_X: - case BPF_ALU|BPF_RSH|BPF_K: - case BPF_ALU|BPF_RSH|BPF_X: - case BPF_ALU|BPF_NEG: - case BPF_LD|BPF_W|BPF_ABS: - case BPF_LD|BPF_H|BPF_ABS: - case BPF_LD|BPF_B|BPF_ABS: - case BPF_LD|BPF_W|BPF_LEN: - case BPF_LD|BPF_W|BPF_IND: - case BPF_LD|BPF_H|BPF_IND: - case BPF_LD|BPF_B|BPF_IND: - case BPF_LD|BPF_IMM: - case BPF_LDX|BPF_W|BPF_LEN: - case BPF_LDX|BPF_B|BPF_MSH: - case BPF_LDX|BPF_IMM: - case BPF_MISC|BPF_TAX: - case BPF_MISC|BPF_TXA: - case BPF_RET|BPF_K: - case BPF_RET|BPF_A: - break; - - /* Some instructions need special checks */ - - case BPF_ALU|BPF_DIV|BPF_K: - /* check for division by zero */ - if (ftest->k == 0) - return -EINVAL; - break; - - case BPF_LD|BPF_MEM: - case BPF_LDX|BPF_MEM: - case BPF_ST: - case BPF_STX: - /* check for invalid memory addresses */ - if (ftest->k >= BPF_MEMWORDS) - return -EINVAL; - break; - - case BPF_JMP|BPF_JA: - /* - * Note, the large ftest->k might cause loops. - * Compare this with conditional jumps below, - * where offsets are limited. --ANK (981016) - */ - if (ftest->k >= (unsigned)(flen-pc-1)) - return -EINVAL; - break; + /* check for division by zero -Kris Katterjohn 2005-10-30 */ + if (ftest->code == (BPF_ALU|BPF_DIV|BPF_K) && ftest->k == 0) + return -EINVAL; - case BPF_JMP|BPF_JEQ|BPF_K: - case BPF_JMP|BPF_JEQ|BPF_X: - case BPF_JMP|BPF_JGE|BPF_K: - case BPF_JMP|BPF_JGE|BPF_X: - case BPF_JMP|BPF_JGT|BPF_K: - case BPF_JMP|BPF_JGT|BPF_X: - case BPF_JMP|BPF_JSET|BPF_K: - case BPF_JMP|BPF_JSET|BPF_X: - /* for conditionals both must be safe */ - if (pc + ftest->jt + 1 >= flen || - pc + ftest->jf + 1 >= flen) + /* check that memory operations use valid addresses. */ + if (ftest->k >= BPF_MEMWORDS) { + /* but it might not be a memory operation... */ + switch (ftest->code) { + case BPF_ST: + case BPF_STX: + case BPF_LD|BPF_MEM: + case BPF_LDX|BPF_MEM: return -EINVAL; - break; - - default: - return -EINVAL; + } } } diff --git a/trunk/net/core/flow.c b/trunk/net/core/flow.c index c4f25385029f..7e95b39de9fd 100644 --- a/trunk/net/core/flow.c +++ b/trunk/net/core/flow.c @@ -23,7 +23,6 @@ #include #include #include -#include struct flow_cache_entry { struct flow_cache_entry *next; @@ -31,7 +30,6 @@ struct flow_cache_entry { u8 dir; struct flowi key; u32 genid; - u32 sk_sid; void *object; atomic_t *object_ref; }; @@ -164,7 +162,7 @@ static int flow_key_compare(struct flowi *key1, struct flowi *key2) return 0; } -void *flow_cache_lookup(struct flowi *key, u32 sk_sid, u16 family, u8 dir, +void *flow_cache_lookup(struct flowi *key, u16 family, u8 dir, flow_resolve_t resolver) { struct flow_cache_entry *fle, **head; @@ -188,7 +186,6 @@ void *flow_cache_lookup(struct flowi *key, u32 sk_sid, u16 family, u8 dir, for (fle = *head; fle; fle = fle->next) { if (fle->family == family && fle->dir == dir && - fle->sk_sid == sk_sid && flow_key_compare(key, &fle->key) == 0) { if (fle->genid == atomic_read(&flow_cache_genid)) { void *ret = fle->object; @@ -213,7 +210,6 @@ void *flow_cache_lookup(struct flowi *key, u32 sk_sid, u16 family, u8 dir, *head = fle; fle->family = family; fle->dir = dir; - fle->sk_sid = sk_sid; memcpy(&fle->key, key, sizeof(*key)); fle->object = NULL; flow_count(cpu)++; @@ -225,7 +221,7 @@ void *flow_cache_lookup(struct flowi *key, u32 sk_sid, u16 family, u8 dir, void *obj; atomic_t *obj_ref; - resolver(key, sk_sid, family, dir, &obj, &obj_ref); + resolver(key, family, dir, &obj, &obj_ref); if (fle) { fle->genid = atomic_read(&flow_cache_genid); diff --git a/trunk/net/core/net-sysfs.c b/trunk/net/core/net-sysfs.c index e1da81d261d1..e2137f3e489d 100644 --- a/trunk/net/core/net-sysfs.c +++ b/trunk/net/core/net-sysfs.c @@ -84,11 +84,16 @@ static ssize_t netdev_store(struct class_device *dev, return ret; } -NETDEVICE_SHOW(addr_len, fmt_dec); -NETDEVICE_SHOW(iflink, fmt_dec); -NETDEVICE_SHOW(ifindex, fmt_dec); -NETDEVICE_SHOW(features, fmt_long_hex); -NETDEVICE_SHOW(type, fmt_dec); +/* generate a read-only network device class attribute */ +#define NETDEVICE_ATTR(field, format_string) \ +NETDEVICE_SHOW(field, format_string) \ +static CLASS_DEVICE_ATTR(field, S_IRUGO, show_##field, NULL) \ + +NETDEVICE_ATTR(addr_len, fmt_dec); +NETDEVICE_ATTR(iflink, fmt_dec); +NETDEVICE_ATTR(ifindex, fmt_dec); +NETDEVICE_ATTR(features, fmt_long_hex); +NETDEVICE_ATTR(type, fmt_dec); /* use same locking rules as GIFHWADDR ioctl's */ static ssize_t format_addr(char *buf, const unsigned char *addr, int len) @@ -131,6 +136,10 @@ static ssize_t show_carrier(struct class_device *dev, char *buf) return -EINVAL; } +static CLASS_DEVICE_ATTR(address, S_IRUGO, show_address, NULL); +static CLASS_DEVICE_ATTR(broadcast, S_IRUGO, show_broadcast, NULL); +static CLASS_DEVICE_ATTR(carrier, S_IRUGO, show_carrier, NULL); + /* read-write attributes */ NETDEVICE_SHOW(mtu, fmt_dec); @@ -144,6 +153,8 @@ static ssize_t store_mtu(struct class_device *dev, const char *buf, size_t len) return netdev_store(dev, buf, len, change_mtu); } +static CLASS_DEVICE_ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu); + NETDEVICE_SHOW(flags, fmt_hex); static int change_flags(struct net_device *net, unsigned long new_flags) @@ -156,6 +167,8 @@ static ssize_t store_flags(struct class_device *dev, const char *buf, size_t len return netdev_store(dev, buf, len, change_flags); } +static CLASS_DEVICE_ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags); + NETDEVICE_SHOW(tx_queue_len, fmt_ulong); static int change_tx_queue_len(struct net_device *net, unsigned long new_len) @@ -169,6 +182,9 @@ static ssize_t store_tx_queue_len(struct class_device *dev, const char *buf, siz return netdev_store(dev, buf, len, change_tx_queue_len); } +static CLASS_DEVICE_ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len, + store_tx_queue_len); + NETDEVICE_SHOW(weight, fmt_dec); static int change_weight(struct net_device *net, unsigned long new_weight) @@ -182,21 +198,24 @@ static ssize_t store_weight(struct class_device *dev, const char *buf, size_t le return netdev_store(dev, buf, len, change_weight); } -static struct class_device_attribute net_class_attributes[] = { - __ATTR(addr_len, S_IRUGO, show_addr_len, NULL), - __ATTR(iflink, S_IRUGO, show_iflink, NULL), - __ATTR(ifindex, S_IRUGO, show_ifindex, NULL), - __ATTR(features, S_IRUGO, show_features, NULL), - __ATTR(type, S_IRUGO, show_type, NULL), - __ATTR(address, S_IRUGO, show_address, NULL), - __ATTR(broadcast, S_IRUGO, show_broadcast, NULL), - __ATTR(carrier, S_IRUGO, show_carrier, NULL), - __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu), - __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags), - __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len, - store_tx_queue_len), - __ATTR(weight, S_IRUGO | S_IWUSR, show_weight, store_weight), - {} +static CLASS_DEVICE_ATTR(weight, S_IRUGO | S_IWUSR, show_weight, + store_weight); + + +static struct class_device_attribute *net_class_attributes[] = { + &class_device_attr_ifindex, + &class_device_attr_iflink, + &class_device_attr_addr_len, + &class_device_attr_tx_queue_len, + &class_device_attr_features, + &class_device_attr_mtu, + &class_device_attr_flags, + &class_device_attr_weight, + &class_device_attr_type, + &class_device_attr_address, + &class_device_attr_broadcast, + &class_device_attr_carrier, + NULL }; /* Show a given an attribute in the statistics group */ @@ -350,14 +369,14 @@ static struct attribute_group wireless_group = { #endif #ifdef CONFIG_HOTPLUG -static int netdev_uevent(struct class_device *cd, char **envp, - int num_envp, char *buf, int size) +static int netdev_hotplug(struct class_device *cd, char **envp, + int num_envp, char *buf, int size) { struct net_device *dev = to_net_dev(cd); int i = 0; int n; - /* pass interface to uevent. */ + /* pass interface in env to hotplug. */ envp[i++] = buf; n = snprintf(buf, size, "INTERFACE=%s", dev->name) + 1; buf += n; @@ -388,9 +407,8 @@ static void netdev_release(struct class_device *cd) static struct class net_class = { .name = "net", .release = netdev_release, - .class_dev_attrs = net_class_attributes, #ifdef CONFIG_HOTPLUG - .uevent = netdev_uevent, + .hotplug = netdev_hotplug, #endif }; @@ -413,6 +431,8 @@ void netdev_unregister_sysfs(struct net_device * net) int netdev_register_sysfs(struct net_device *net) { struct class_device *class_dev = &(net->class_dev); + int i; + struct class_device_attribute *attr; int ret; class_dev->class = &net_class; @@ -422,6 +442,12 @@ int netdev_register_sysfs(struct net_device *net) if ((ret = class_device_register(class_dev))) goto out; + for (i = 0; (attr = net_class_attributes[i]) != NULL; i++) { + if ((ret = class_device_create_file(class_dev, attr))) + goto out_unreg; + } + + if (net->get_stats && (ret = sysfs_create_group(&class_dev->kobj, &netstat_group))) goto out_unreg; diff --git a/trunk/net/core/netpoll.c b/trunk/net/core/netpoll.c index 281a632fa6a6..49424a42a2c0 100644 --- a/trunk/net/core/netpoll.c +++ b/trunk/net/core/netpoll.c @@ -13,7 +13,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/core/pktgen.c b/trunk/net/core/pktgen.c index 06cad2d63e8a..7fc3e9e28c34 100644 --- a/trunk/net/core/pktgen.c +++ b/trunk/net/core/pktgen.c @@ -487,9 +487,9 @@ static unsigned int fmt_ip6(char *s,const char ip[16]); /* Module parameters, defaults. */ static int pg_count_d = 1000; /* 1000 pkts by default */ -static int pg_delay_d; -static int pg_clone_skb_d; -static int debug; +static int pg_delay_d = 0; +static int pg_clone_skb_d = 0; +static int debug = 0; static DECLARE_MUTEX(pktgen_sem); static struct pktgen_thread *pktgen_threads = NULL; diff --git a/trunk/net/core/skbuff.c b/trunk/net/core/skbuff.c index 070f91cfde59..83fee37de38e 100644 --- a/trunk/net/core/skbuff.c +++ b/trunk/net/core/skbuff.c @@ -135,13 +135,17 @@ void skb_under_panic(struct sk_buff *skb, int sz, void *here) struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, int fclone) { - struct skb_shared_info *shinfo; struct sk_buff *skb; u8 *data; /* Get the HEAD */ - skb = kmem_cache_alloc(fclone ? skbuff_fclone_cache : skbuff_head_cache, - gfp_mask & ~__GFP_DMA); + if (fclone) + skb = kmem_cache_alloc(skbuff_fclone_cache, + gfp_mask & ~__GFP_DMA); + else + skb = kmem_cache_alloc(skbuff_head_cache, + gfp_mask & ~__GFP_DMA); + if (!skb) goto out; @@ -158,16 +162,6 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, skb->data = data; skb->tail = data; skb->end = data + size; - /* make sure we initialize shinfo sequentially */ - shinfo = skb_shinfo(skb); - atomic_set(&shinfo->dataref, 1); - shinfo->nr_frags = 0; - shinfo->tso_size = 0; - shinfo->tso_segs = 0; - shinfo->ufo_size = 0; - shinfo->ip6_frag_id = 0; - shinfo->frag_list = NULL; - if (fclone) { struct sk_buff *child = skb + 1; atomic_t *fclone_ref = (atomic_t *) (child + 1); @@ -177,6 +171,13 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, child->fclone = SKB_FCLONE_UNAVAILABLE; } + atomic_set(&(skb_shinfo(skb)->dataref), 1); + skb_shinfo(skb)->nr_frags = 0; + skb_shinfo(skb)->tso_size = 0; + skb_shinfo(skb)->tso_segs = 0; + skb_shinfo(skb)->frag_list = NULL; + skb_shinfo(skb)->ufo_size = 0; + skb_shinfo(skb)->ip6_frag_id = 0; out: return skb; nodata: diff --git a/trunk/net/core/sock.c b/trunk/net/core/sock.c index 6465b0e4c8cb..13cc3be4f056 100644 --- a/trunk/net/core/sock.c +++ b/trunk/net/core/sock.c @@ -1488,7 +1488,7 @@ int proto_register(struct proto *prot, int alloc_slab) } } - if (prot->twsk_prot != NULL) { + if (prot->twsk_obj_size) { static const char mask[] = "tw_sock_%s"; timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL); @@ -1497,12 +1497,11 @@ int proto_register(struct proto *prot, int alloc_slab) goto out_free_request_sock_slab; sprintf(timewait_sock_slab_name, mask, prot->name); - prot->twsk_prot->twsk_slab = - kmem_cache_create(timewait_sock_slab_name, - prot->twsk_prot->twsk_obj_size, - 0, SLAB_HWCACHE_ALIGN, - NULL, NULL); - if (prot->twsk_prot->twsk_slab == NULL) + prot->twsk_slab = kmem_cache_create(timewait_sock_slab_name, + prot->twsk_obj_size, + 0, SLAB_HWCACHE_ALIGN, + NULL, NULL); + if (prot->twsk_slab == NULL) goto out_free_timewait_sock_slab_name; } } @@ -1549,12 +1548,12 @@ void proto_unregister(struct proto *prot) prot->rsk_prot->slab = NULL; } - if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) { - const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab); + if (prot->twsk_slab != NULL) { + const char *name = kmem_cache_name(prot->twsk_slab); - kmem_cache_destroy(prot->twsk_prot->twsk_slab); + kmem_cache_destroy(prot->twsk_slab); kfree(name); - prot->twsk_prot->twsk_slab = NULL; + prot->twsk_slab = NULL; } } diff --git a/trunk/net/core/stream.c b/trunk/net/core/stream.c index 35e25259fd95..15bfd03e8024 100644 --- a/trunk/net/core/stream.c +++ b/trunk/net/core/stream.c @@ -55,9 +55,8 @@ int sk_stream_wait_connect(struct sock *sk, long *timeo_p) int done; do { - int err = sock_error(sk); - if (err) - return err; + if (sk->sk_err) + return sock_error(sk); if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV)) return -EPIPE; if (!*timeo_p) @@ -68,7 +67,6 @@ int sk_stream_wait_connect(struct sock *sk, long *timeo_p) prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); sk->sk_write_pending++; done = sk_wait_event(sk, timeo_p, - !sk->sk_err && !((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))); finish_wait(sk->sk_sleep, &wait); @@ -139,9 +137,7 @@ int sk_stream_wait_memory(struct sock *sk, long *timeo_p) set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); sk->sk_write_pending++; - sk_wait_event(sk, ¤t_timeo, !sk->sk_err && - !(sk->sk_shutdown & SEND_SHUTDOWN) && - sk_stream_memory_free(sk) && + sk_wait_event(sk, ¤t_timeo, sk_stream_memory_free(sk) && vm_wait); sk->sk_write_pending--; diff --git a/trunk/net/core/utils.c b/trunk/net/core/utils.c index 587eb7787deb..7b5970fc9e40 100644 --- a/trunk/net/core/utils.c +++ b/trunk/net/core/utils.c @@ -175,7 +175,7 @@ __u32 in_aton(const char *str) if (*str != '\0') { val = 0; - while (*str != '\0' && *str != '.' && *str != '\n') + while (*str != '\0' && *str != '.') { val *= 10; val += *str - '0'; diff --git a/trunk/net/dccp/Makefile b/trunk/net/dccp/Makefile index 87b27fff6e3b..344a8da153fc 100644 --- a/trunk/net/dccp/Makefile +++ b/trunk/net/dccp/Makefile @@ -1,7 +1,3 @@ -obj-$(CONFIG_IPV6) += dccp_ipv6.o - -dccp_ipv6-y := ipv6.o - obj-$(CONFIG_IP_DCCP) += dccp.o dccp-y := ccid.o input.o ipv4.o minisocks.o options.o output.o proto.o \ diff --git a/trunk/net/dccp/ackvec.c b/trunk/net/dccp/ackvec.c index ce9cb77c5c29..c9a62cca22fc 100644 --- a/trunk/net/dccp/ackvec.c +++ b/trunk/net/dccp/ackvec.c @@ -55,8 +55,8 @@ int dccp_insert_option_ackvec(struct sock *sk, struct sk_buff *skb) from = av->dccpav_buf + av->dccpav_buf_head; /* Check if buf_head wraps */ - if ((int)av->dccpav_buf_head + len > av->dccpav_vec_len) { - const u32 tailsize = av->dccpav_vec_len - av->dccpav_buf_head; + if (av->dccpav_buf_head + len > av->dccpav_vec_len) { + const u32 tailsize = (av->dccpav_vec_len - av->dccpav_buf_head); memcpy(to, from, tailsize); to += tailsize; @@ -93,14 +93,8 @@ int dccp_insert_option_ackvec(struct sock *sk, struct sk_buff *skb) struct dccp_ackvec *dccp_ackvec_alloc(const unsigned int len, const gfp_t priority) { - struct dccp_ackvec *av; + struct dccp_ackvec *av = kmalloc(sizeof(*av) + len, priority); - BUG_ON(len == 0); - - if (len > DCCP_MAX_ACKVEC_LEN) - return NULL; - - av = kmalloc(sizeof(*av) + len, priority); if (av != NULL) { av->dccpav_buf_len = len; av->dccpav_buf_head = @@ -123,13 +117,13 @@ void dccp_ackvec_free(struct dccp_ackvec *av) } static inline u8 dccp_ackvec_state(const struct dccp_ackvec *av, - const u8 index) + const unsigned int index) { return av->dccpav_buf[index] & DCCP_ACKVEC_STATE_MASK; } static inline u8 dccp_ackvec_len(const struct dccp_ackvec *av, - const u8 index) + const unsigned int index) { return av->dccpav_buf[index] & DCCP_ACKVEC_LEN_MASK; } @@ -141,7 +135,7 @@ static inline u8 dccp_ackvec_len(const struct dccp_ackvec *av, */ static inline int dccp_ackvec_set_buf_head_state(struct dccp_ackvec *av, const unsigned int packets, - const unsigned char state) + const unsigned char state) { unsigned int gap; signed long new_head; @@ -229,7 +223,7 @@ int dccp_ackvec_add(struct dccp_ackvec *av, const struct sock *sk, * could reduce the complexity of this scan.) */ u64 delta = dccp_delta_seqno(ackno, av->dccpav_buf_ackno); - u8 index = av->dccpav_buf_head; + unsigned int index = av->dccpav_buf_head; while (1) { const u8 len = dccp_ackvec_len(av, index); @@ -297,7 +291,7 @@ void dccp_ackvec_print(const struct dccp_ackvec *av) } #endif -static void dccp_ackvec_throw_away_ack_record(struct dccp_ackvec *av) +static void dccp_ackvec_trow_away_ack_record(struct dccp_ackvec *av) { /* * As we're keeping track of the ack vector size (dccpav_vec_len) and @@ -307,10 +301,9 @@ static void dccp_ackvec_throw_away_ack_record(struct dccp_ackvec *av) * draft-ietf-dccp-spec-11.txt Appendix A. -acme */ #if 0 - u32 new_buf_tail = av->dccpav_ack_ptr + 1; - if (new_buf_tail >= av->dccpav_vec_len) - new_buf_tail -= av->dccpav_vec_len; - av->dccpav_buf_tail = new_buf_tail; + av->dccpav_buf_tail = av->dccpav_ack_ptr + 1; + if (av->dccpav_buf_tail >= av->dccpav_vec_len) + av->dccpav_buf_tail -= av->dccpav_vec_len; #endif av->dccpav_vec_len -= av->dccpav_sent_len; } @@ -333,7 +326,7 @@ void dccp_ackvec_check_rcv_ackno(struct dccp_ackvec *av, struct sock *sk, debug_prefix, 1, (unsigned long long)av->dccpav_ack_seqno, (unsigned long long)av->dccpav_ack_ackno); - dccp_ackvec_throw_away_ack_record(av); + dccp_ackvec_trow_away_ack_record(av); av->dccpav_ack_seqno = DCCP_MAX_SEQNO + 1; } } @@ -396,7 +389,7 @@ static void dccp_ackvec_check_rcv_ackvector(struct dccp_ackvec *av, av->dccpav_ack_seqno, (unsigned long long) av->dccpav_ack_ackno); - dccp_ackvec_throw_away_ack_record(av); + dccp_ackvec_trow_away_ack_record(av); } /* * If dccpav_ack_seqno was not received, no problem diff --git a/trunk/net/dccp/ackvec.h b/trunk/net/dccp/ackvec.h index f7dfb5f67b87..d0fd6c60c574 100644 --- a/trunk/net/dccp/ackvec.h +++ b/trunk/net/dccp/ackvec.h @@ -54,16 +54,16 @@ * @dccpav_buf - circular buffer of acknowledgeable packets */ struct dccp_ackvec { + unsigned int dccpav_buf_head; + unsigned int dccpav_buf_tail; u64 dccpav_buf_ackno; u64 dccpav_ack_seqno; u64 dccpav_ack_ackno; + unsigned int dccpav_ack_ptr; + unsigned int dccpav_sent_len; + unsigned int dccpav_vec_len; + unsigned int dccpav_buf_len; struct timeval dccpav_time; - u8 dccpav_buf_head; - u8 dccpav_buf_tail; - u8 dccpav_ack_ptr; - u8 dccpav_sent_len; - u8 dccpav_vec_len; - u8 dccpav_buf_len; u8 dccpav_buf_nonce; u8 dccpav_ack_nonce; u8 dccpav_buf[0]; diff --git a/trunk/net/dccp/ccid.h b/trunk/net/dccp/ccid.h index de681c6ad081..c37eeeaf5c6e 100644 --- a/trunk/net/dccp/ccid.h +++ b/trunk/net/dccp/ccid.h @@ -21,8 +21,6 @@ #define CCID_MAX 255 -struct tcp_info; - struct ccid { unsigned char ccid_id; const char *ccid_name; diff --git a/trunk/net/dccp/dccp.h b/trunk/net/dccp/dccp.h index 93f26dd6e6cb..f97b85d55ad8 100644 --- a/trunk/net/dccp/dccp.h +++ b/trunk/net/dccp/dccp.h @@ -59,7 +59,7 @@ extern void dccp_time_wait(struct sock *sk, int state, int timeo); #define DCCP_RTO_MAX ((unsigned)(120 * HZ)) /* FIXME: using TCP value */ -extern struct proto dccp_prot; +extern struct proto dccp_v4_prot; /* is seq1 < seq2 ? */ static inline int before48(const u64 seq1, const u64 seq2) @@ -228,9 +228,6 @@ extern int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb, extern int dccp_rcv_established(struct sock *sk, struct sk_buff *skb, const struct dccp_hdr *dh, const unsigned len); -extern int dccp_v4_init_sock(struct sock *sk); -extern int dccp_v4_destroy_sock(struct sock *sk); - extern void dccp_close(struct sock *sk, long timeout); extern struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst, @@ -241,7 +238,6 @@ extern struct sk_buff *dccp_make_reset(struct sock *sk, extern int dccp_connect(struct sock *sk); extern int dccp_disconnect(struct sock *sk, int flags); -extern void dccp_unhash(struct sock *sk); extern int dccp_getsockopt(struct sock *sk, int level, int optname, char __user *optval, int __user *optlen); extern int dccp_setsockopt(struct sock *sk, int level, int optname, @@ -253,13 +249,6 @@ extern int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, size_t len, int nonblock, int flags, int *addr_len); extern void dccp_shutdown(struct sock *sk, int how); -extern int inet_dccp_listen(struct socket *sock, int backlog); -extern unsigned int dccp_poll(struct file *file, struct socket *sock, - poll_table *wait); -extern void dccp_v4_send_check(struct sock *sk, int len, - struct sk_buff *skb); -extern int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, - int addr_len); extern int dccp_v4_checksum(const struct sk_buff *skb, const u32 saddr, const u32 daddr); @@ -267,17 +256,6 @@ extern int dccp_v4_checksum(const struct sk_buff *skb, extern int dccp_v4_send_reset(struct sock *sk, enum dccp_reset_codes code); extern void dccp_send_close(struct sock *sk, const int active); -extern int dccp_invalid_packet(struct sk_buff *skb); - -static inline int dccp_bad_service_code(const struct sock *sk, - const __u32 service) -{ - const struct dccp_sock *dp = dccp_sk(sk); - - if (dp->dccps_service == service) - return 0; - return !dccp_list_has_service(dp->dccps_service_list, service); -} struct dccp_skb_cb { __u8 dccpd_type:4; diff --git a/trunk/net/dccp/diag.c b/trunk/net/dccp/diag.c index 3f78c00e3822..f675d8e642d3 100644 --- a/trunk/net/dccp/diag.c +++ b/trunk/net/dccp/diag.c @@ -28,7 +28,7 @@ static void dccp_get_info(struct sock *sk, struct tcp_info *info) info->tcpi_retransmits = icsk->icsk_retransmits; info->tcpi_probes = icsk->icsk_probes_out; info->tcpi_backoff = icsk->icsk_backoff; - info->tcpi_pmtu = icsk->icsk_pmtu_cookie; + info->tcpi_pmtu = dp->dccps_pmtu_cookie; if (dp->dccps_options.dccpo_send_ack_vector) info->tcpi_options |= TCPI_OPT_SACK; diff --git a/trunk/net/dccp/input.c b/trunk/net/dccp/input.c index b6cba72b44e8..3454d5941900 100644 --- a/trunk/net/dccp/input.c +++ b/trunk/net/dccp/input.c @@ -151,12 +151,29 @@ static int dccp_check_seqno(struct sock *sk, struct sk_buff *skb) return 0; } -static inline int __dccp_rcv_established(struct sock *sk, struct sk_buff *skb, - const struct dccp_hdr *dh, - const unsigned len) +int dccp_rcv_established(struct sock *sk, struct sk_buff *skb, + const struct dccp_hdr *dh, const unsigned len) { struct dccp_sock *dp = dccp_sk(sk); + if (dccp_check_seqno(sk, skb)) + goto discard; + + if (dccp_parse_options(sk, skb)) + goto discard; + + if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ) + dccp_event_ack_recv(sk, skb); + + if (dp->dccps_options.dccpo_send_ack_vector && + dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk, + DCCP_SKB_CB(skb)->dccpd_seq, + DCCP_ACKVEC_STATE_RECEIVED)) + goto discard; + + ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb); + ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb); + switch (dccp_hdr(skb)->dccph_type) { case DCCP_PKT_DATAACK: case DCCP_PKT_DATA: @@ -233,37 +250,6 @@ static inline int __dccp_rcv_established(struct sock *sk, struct sk_buff *skb, return 0; } -int dccp_rcv_established(struct sock *sk, struct sk_buff *skb, - const struct dccp_hdr *dh, const unsigned len) -{ - struct dccp_sock *dp = dccp_sk(sk); - - if (dccp_check_seqno(sk, skb)) - goto discard; - - if (dccp_parse_options(sk, skb)) - goto discard; - - if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ) - dccp_event_ack_recv(sk, skb); - - if (dp->dccps_options.dccpo_send_ack_vector && - dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk, - DCCP_SKB_CB(skb)->dccpd_seq, - DCCP_ACKVEC_STATE_RECEIVED)) - goto discard; - - ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb); - ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb); - - return __dccp_rcv_established(sk, skb, dh, len); -discard: - __kfree_skb(skb); - return 0; -} - -EXPORT_SYMBOL_GPL(dccp_rcv_established); - static int dccp_rcv_request_sent_state_process(struct sock *sk, struct sk_buff *skb, const struct dccp_hdr *dh, @@ -300,12 +286,6 @@ static int dccp_rcv_request_sent_state_process(struct sock *sk, goto out_invalid_packet; } - if (dp->dccps_options.dccpo_send_ack_vector && - dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk, - DCCP_SKB_CB(skb)->dccpd_seq, - DCCP_ACKVEC_STATE_RECEIVED)) - goto out_invalid_packet; /* FIXME: change error code */ - dp->dccps_isr = DCCP_SKB_CB(skb)->dccpd_seq; dccp_update_gsr(sk, dp->dccps_isr); /* @@ -329,7 +309,7 @@ static int dccp_rcv_request_sent_state_process(struct sock *sk, goto out_invalid_packet; } - dccp_sync_mss(sk, icsk->icsk_pmtu_cookie); + dccp_sync_mss(sk, dp->dccps_pmtu_cookie); /* * Step 10: Process REQUEST state (second part) @@ -349,7 +329,7 @@ static int dccp_rcv_request_sent_state_process(struct sock *sk, dccp_set_state(sk, DCCP_PARTOPEN); /* Make sure socket is routed, for correct metrics. */ - icsk->icsk_af_ops->rebuild_header(sk); + inet_sk_rebuild_header(sk); if (!sock_flag(sk, SOCK_DEAD)) { sk->sk_state_change(sk); @@ -418,9 +398,9 @@ static int dccp_rcv_respond_partopen_state_process(struct sock *sk, if (dh->dccph_type == DCCP_PKT_DATAACK || dh->dccph_type == DCCP_PKT_DATA) { - __dccp_rcv_established(sk, skb, dh, len); + dccp_rcv_established(sk, skb, dh, len); queued = 1; /* packet was queued - (by __dccp_rcv_established) */ + (by dccp_rcv_established) */ } break; } @@ -464,8 +444,7 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb, */ if (sk->sk_state == DCCP_LISTEN) { if (dh->dccph_type == DCCP_PKT_REQUEST) { - if (inet_csk(sk)->icsk_af_ops->conn_request(sk, - skb) < 0) + if (dccp_v4_conn_request(sk, skb) < 0) return 1; /* FIXME: do congestion control initialization */ @@ -492,14 +471,14 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb, if (dcb->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ) dccp_event_ack_recv(sk, skb); + ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb); + ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb); + if (dp->dccps_options.dccpo_send_ack_vector && dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk, DCCP_SKB_CB(skb)->dccpd_seq, DCCP_ACKVEC_STATE_RECEIVED)) goto discard; - - ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb); - ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb); } /* @@ -587,5 +566,3 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb, } return 0; } - -EXPORT_SYMBOL_GPL(dccp_rcv_state_process); diff --git a/trunk/net/dccp/ipv4.c b/trunk/net/dccp/ipv4.c index 3f244670764a..656e13e38cfb 100644 --- a/trunk/net/dccp/ipv4.c +++ b/trunk/net/dccp/ipv4.c @@ -19,9 +19,7 @@ #include #include -#include #include -#include #include #include @@ -39,8 +37,7 @@ EXPORT_SYMBOL_GPL(dccp_hashinfo); static int dccp_v4_get_port(struct sock *sk, const unsigned short snum) { - return inet_csk_get_port(&dccp_hashinfo, sk, snum, - inet_csk_bind_conflict); + return inet_csk_get_port(&dccp_hashinfo, sk, snum); } static void dccp_v4_hash(struct sock *sk) @@ -48,14 +45,171 @@ static void dccp_v4_hash(struct sock *sk) inet_hash(&dccp_hashinfo, sk); } -void dccp_unhash(struct sock *sk) +static void dccp_v4_unhash(struct sock *sk) { inet_unhash(&dccp_hashinfo, sk); } -EXPORT_SYMBOL_GPL(dccp_unhash); +/* called with local bh disabled */ +static int __dccp_v4_check_established(struct sock *sk, const __u16 lport, + struct inet_timewait_sock **twp) +{ + struct inet_sock *inet = inet_sk(sk); + const u32 daddr = inet->rcv_saddr; + const u32 saddr = inet->daddr; + const int dif = sk->sk_bound_dev_if; + INET_ADDR_COOKIE(acookie, saddr, daddr) + const __u32 ports = INET_COMBINED_PORTS(inet->dport, lport); + unsigned int hash = inet_ehashfn(daddr, lport, saddr, inet->dport); + struct inet_ehash_bucket *head = inet_ehash_bucket(&dccp_hashinfo, hash); + const struct sock *sk2; + const struct hlist_node *node; + struct inet_timewait_sock *tw; + + prefetch(head->chain.first); + write_lock(&head->lock); + + /* Check TIME-WAIT sockets first. */ + sk_for_each(sk2, node, &(head + dccp_hashinfo.ehash_size)->chain) { + tw = inet_twsk(sk2); + + if (INET_TW_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif)) + goto not_unique; + } + tw = NULL; + + /* And established part... */ + sk_for_each(sk2, node, &head->chain) { + if (INET_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif)) + goto not_unique; + } -int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) + /* Must record num and sport now. Otherwise we will see + * in hash table socket with a funny identity. */ + inet->num = lport; + inet->sport = htons(lport); + sk->sk_hash = hash; + BUG_TRAP(sk_unhashed(sk)); + __sk_add_node(sk, &head->chain); + sock_prot_inc_use(sk->sk_prot); + write_unlock(&head->lock); + + if (twp != NULL) { + *twp = tw; + NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); + } else if (tw != NULL) { + /* Silly. Should hash-dance instead... */ + inet_twsk_deschedule(tw, &dccp_death_row); + NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); + + inet_twsk_put(tw); + } + + return 0; + +not_unique: + write_unlock(&head->lock); + return -EADDRNOTAVAIL; +} + +/* + * Bind a port for a connect operation and hash it. + */ +static int dccp_v4_hash_connect(struct sock *sk) +{ + const unsigned short snum = inet_sk(sk)->num; + struct inet_bind_hashbucket *head; + struct inet_bind_bucket *tb; + int ret; + + if (snum == 0) { + int low = sysctl_local_port_range[0]; + int high = sysctl_local_port_range[1]; + int remaining = (high - low) + 1; + int rover = net_random() % (high - low) + low; + struct hlist_node *node; + struct inet_timewait_sock *tw = NULL; + + local_bh_disable(); + do { + head = &dccp_hashinfo.bhash[inet_bhashfn(rover, + dccp_hashinfo.bhash_size)]; + spin_lock(&head->lock); + + /* Does not bother with rcv_saddr checks, + * because the established check is already + * unique enough. + */ + inet_bind_bucket_for_each(tb, node, &head->chain) { + if (tb->port == rover) { + BUG_TRAP(!hlist_empty(&tb->owners)); + if (tb->fastreuse >= 0) + goto next_port; + if (!__dccp_v4_check_established(sk, + rover, + &tw)) + goto ok; + goto next_port; + } + } + + tb = inet_bind_bucket_create(dccp_hashinfo.bind_bucket_cachep, + head, rover); + if (tb == NULL) { + spin_unlock(&head->lock); + break; + } + tb->fastreuse = -1; + goto ok; + + next_port: + spin_unlock(&head->lock); + if (++rover > high) + rover = low; + } while (--remaining > 0); + + local_bh_enable(); + + return -EADDRNOTAVAIL; + +ok: + /* All locks still held and bhs disabled */ + inet_bind_hash(sk, tb, rover); + if (sk_unhashed(sk)) { + inet_sk(sk)->sport = htons(rover); + __inet_hash(&dccp_hashinfo, sk, 0); + } + spin_unlock(&head->lock); + + if (tw != NULL) { + inet_twsk_deschedule(tw, &dccp_death_row); + inet_twsk_put(tw); + } + + ret = 0; + goto out; + } + + head = &dccp_hashinfo.bhash[inet_bhashfn(snum, + dccp_hashinfo.bhash_size)]; + tb = inet_csk(sk)->icsk_bind_hash; + spin_lock_bh(&head->lock); + if (sk_head(&tb->owners) == sk && sk->sk_bind_node.next == NULL) { + __inet_hash(&dccp_hashinfo, sk, 0); + spin_unlock_bh(&head->lock); + return 0; + } else { + spin_unlock(&head->lock); + /* No definite answer... Walk to established hash table */ + ret = __dccp_v4_check_established(sk, snum, NULL); +out: + local_bh_enable(); + return ret; + } +} + +static int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, + int addr_len) { struct inet_sock *inet = inet_sk(sk); struct dccp_sock *dp = dccp_sk(sk); @@ -105,9 +259,9 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) inet->dport = usin->sin_port; inet->daddr = daddr; - inet_csk(sk)->icsk_ext_hdr_len = 0; + dp->dccps_ext_header_len = 0; if (inet->opt != NULL) - inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen; + dp->dccps_ext_header_len = inet->opt->optlen; /* * Socket identity is still unknown (sport may be zero). * However we set state to DCCP_REQUESTING and not releasing socket @@ -115,7 +269,7 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) * complete initialization after this. */ dccp_set_state(sk, DCCP_REQUESTING); - err = inet_hash_connect(&dccp_death_row, sk); + err = dccp_v4_hash_connect(sk); if (err != 0) goto failure; @@ -133,6 +287,16 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) usin->sin_port); dccp_update_gss(sk, dp->dccps_iss); + /* + * SWL and AWL are initially adjusted so that they are not less than + * the initial Sequence Numbers received and sent, respectively: + * SWL := max(GSR + 1 - floor(W/4), ISR), + * AWL := max(GSS - W' + 1, ISS). + * These adjustments MUST be applied only at the beginning of the + * connection. + */ + dccp_set_seqno(&dp->dccps_awl, max48(dp->dccps_awl, dp->dccps_iss)); + inet->id = dp->dccps_iss ^ jiffies; err = dccp_connect(sk); @@ -152,8 +316,6 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) goto out; } -EXPORT_SYMBOL_GPL(dccp_v4_connect); - /* * This routine does path mtu discovery as defined in RFC1191. */ @@ -192,7 +354,7 @@ static inline void dccp_do_pmtu_discovery(struct sock *sk, mtu = dst_mtu(dst); if (inet->pmtudisc != IP_PMTUDISC_DONT && - inet_csk(sk)->icsk_pmtu_cookie > mtu) { + dp->dccps_pmtu_cookie > mtu) { dccp_sync_mss(sk, mtu); /* @@ -444,17 +606,6 @@ void dccp_v4_err(struct sk_buff *skb, u32 info) sock_put(sk); } -/* This routine computes an IPv4 DCCP checksum. */ -void dccp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb) -{ - const struct inet_sock *inet = inet_sk(sk); - struct dccp_hdr *dh = dccp_hdr(skb); - - dh->dccph_checksum = dccp_v4_checksum(skb, inet->saddr, inet->daddr); -} - -EXPORT_SYMBOL_GPL(dccp_v4_send_check); - int dccp_v4_send_reset(struct sock *sk, enum dccp_reset_codes code) { struct sk_buff *skb; @@ -490,6 +641,16 @@ static inline u64 dccp_v4_init_sequence(const struct sock *sk, dccp_hdr(skb)->dccph_sport); } +static inline int dccp_bad_service_code(const struct sock *sk, + const __u32 service) +{ + const struct dccp_sock *dp = dccp_sk(sk); + + if (dp->dccps_service == service) + return 0; + return !dccp_list_has_service(dp->dccps_service_list, service); +} + int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb) { struct inet_request_sock *ireq; @@ -501,6 +662,7 @@ int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb) const __u32 service = dccp_hdr_request(skb)->dccph_req_service; struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb); __u8 reset_code = DCCP_RESET_CODE_TOO_BUSY; + struct dst_entry *dst = NULL; /* Never answer to DCCP_PKT_REQUESTs send to broadcast or multicast */ if (((struct rtable *)skb->dst)->rt_flags & @@ -541,6 +703,7 @@ int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb) ireq = inet_rsk(req); ireq->loc_addr = daddr; ireq->rmt_addr = saddr; + /* FIXME: Merge Aristeu's option parsing code when ready */ req->rcv_wnd = 100; /* Fake, option parsing will get the right value */ ireq->opt = NULL; @@ -558,22 +721,23 @@ int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb) dreq->dreq_iss = dccp_v4_init_sequence(sk, skb); dreq->dreq_service = service; - if (dccp_v4_send_response(sk, req, NULL)) + if (dccp_v4_send_response(sk, req, dst)) goto drop_and_free; inet_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT); return 0; drop_and_free: - reqsk_free(req); + /* + * FIXME: should be reqsk_free after implementing req->rsk_ops + */ + __reqsk_free(req); drop: DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS); dcb->dccpd_reset_code = reset_code; return -1; } -EXPORT_SYMBOL_GPL(dccp_v4_conn_request); - /* * The three way handshake has completed - we got a valid ACK or DATAACK - * now create the new socket. @@ -628,8 +792,6 @@ struct sock *dccp_v4_request_recv_sock(struct sock *sk, struct sk_buff *skb, return NULL; } -EXPORT_SYMBOL_GPL(dccp_v4_request_recv_sock); - static struct sock *dccp_v4_hnd_req(struct sock *sk, struct sk_buff *skb) { const struct dccp_hdr *dh = dccp_hdr(skb); @@ -849,9 +1011,7 @@ int dccp_v4_do_rcv(struct sock *sk, struct sk_buff *skb) return 0; } -EXPORT_SYMBOL_GPL(dccp_v4_do_rcv); - -int dccp_invalid_packet(struct sk_buff *skb) +static inline int dccp_invalid_packet(struct sk_buff *skb) { const struct dccp_hdr *dh; @@ -905,30 +1065,29 @@ int dccp_invalid_packet(struct sk_buff *skb) return 1; } + /* If the header checksum is incorrect, drop packet and return */ + if (dccp_v4_verify_checksum(skb, skb->nh.iph->saddr, + skb->nh.iph->daddr) < 0) { + LIMIT_NETDEBUG(KERN_WARNING "DCCP: header checksum is " + "incorrect\n"); + return 1; + } + return 0; } -EXPORT_SYMBOL_GPL(dccp_invalid_packet); - /* this is called when real data arrives */ int dccp_v4_rcv(struct sk_buff *skb) { const struct dccp_hdr *dh; struct sock *sk; + int rc; /* Step 1: Check header basics: */ if (dccp_invalid_packet(skb)) goto discard_it; - /* If the header checksum is incorrect, drop packet and return */ - if (dccp_v4_verify_checksum(skb, skb->nh.iph->saddr, - skb->nh.iph->daddr) < 0) { - LIMIT_NETDEBUG(KERN_WARNING "%s: incorrect header checksum\n", - __FUNCTION__); - goto discard_it; - } - dh = dccp_hdr(skb); DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(skb); @@ -984,10 +1143,28 @@ int dccp_v4_rcv(struct sk_buff *skb) goto do_time_wait; } - if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) + if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) { + dccp_pr_debug("xfrm4_policy_check failed\n"); goto discard_and_relse; + } + + if (sk_filter(sk, skb, 0)) { + dccp_pr_debug("sk_filter failed\n"); + goto discard_and_relse; + } + + skb->dev = NULL; + + bh_lock_sock(sk); + rc = 0; + if (!sock_owned_by_user(sk)) + rc = dccp_v4_do_rcv(sk, skb); + else + sk_add_backlog(sk, skb); + bh_unlock_sock(sk); - return sk_receive_skb(sk, skb); + sock_put(sk); + return rc; no_dccp_socket: if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) @@ -1017,23 +1194,9 @@ int dccp_v4_rcv(struct sk_buff *skb) goto no_dccp_socket; } -struct inet_connection_sock_af_ops dccp_ipv4_af_ops = { - .queue_xmit = ip_queue_xmit, - .send_check = dccp_v4_send_check, - .rebuild_header = inet_sk_rebuild_header, - .conn_request = dccp_v4_conn_request, - .syn_recv_sock = dccp_v4_request_recv_sock, - .net_header_len = sizeof(struct iphdr), - .setsockopt = ip_setsockopt, - .getsockopt = ip_getsockopt, - .addr2sockaddr = inet_csk_addr2sockaddr, - .sockaddr_len = sizeof(struct sockaddr_in), -}; - -int dccp_v4_init_sock(struct sock *sk) +static int dccp_v4_init_sock(struct sock *sk) { struct dccp_sock *dp = dccp_sk(sk); - struct inet_connection_sock *icsk = inet_csk(sk); static int dccp_ctl_socket_init = 1; dccp_options_init(&dp->dccps_options); @@ -1073,11 +1236,9 @@ int dccp_v4_init_sock(struct sock *sk) dccp_ctl_socket_init = 0; dccp_init_xmit_timers(sk); - icsk->icsk_rto = DCCP_TIMEOUT_INIT; + inet_csk(sk)->icsk_rto = DCCP_TIMEOUT_INIT; sk->sk_state = DCCP_CLOSED; sk->sk_write_space = dccp_write_space; - icsk->icsk_af_ops = &dccp_ipv4_af_ops; - icsk->icsk_sync_mss = dccp_sync_mss; dp->dccps_mss_cache = 536; dp->dccps_role = DCCP_ROLE_UNDEFINED; dp->dccps_service = DCCP_SERVICE_INVALID_VALUE; @@ -1085,9 +1246,7 @@ int dccp_v4_init_sock(struct sock *sk) return 0; } -EXPORT_SYMBOL_GPL(dccp_v4_init_sock); - -int dccp_v4_destroy_sock(struct sock *sk) +static int dccp_v4_destroy_sock(struct sock *sk) { struct dccp_sock *dp = dccp_sk(sk); @@ -1120,8 +1279,6 @@ int dccp_v4_destroy_sock(struct sock *sk) return 0; } -EXPORT_SYMBOL_GPL(dccp_v4_destroy_sock); - static void dccp_v4_reqsk_destructor(struct request_sock *req) { kfree(inet_rsk(req)->opt); @@ -1136,11 +1293,7 @@ static struct request_sock_ops dccp_request_sock_ops = { .send_reset = dccp_v4_ctl_send_reset, }; -static struct timewait_sock_ops dccp_timewait_sock_ops = { - .twsk_obj_size = sizeof(struct inet_timewait_sock), -}; - -struct proto dccp_prot = { +struct proto dccp_v4_prot = { .name = "DCCP", .owner = THIS_MODULE, .close = dccp_close, @@ -1154,7 +1307,7 @@ struct proto dccp_prot = { .recvmsg = dccp_recvmsg, .backlog_rcv = dccp_v4_do_rcv, .hash = dccp_v4_hash, - .unhash = dccp_unhash, + .unhash = dccp_v4_unhash, .accept = inet_csk_accept, .get_port = dccp_v4_get_port, .shutdown = dccp_shutdown, @@ -1163,7 +1316,5 @@ struct proto dccp_prot = { .max_header = MAX_DCCP_HEADER, .obj_size = sizeof(struct dccp_sock), .rsk_prot = &dccp_request_sock_ops, - .twsk_prot = &dccp_timewait_sock_ops, + .twsk_obj_size = sizeof(struct inet_timewait_sock), }; - -EXPORT_SYMBOL_GPL(dccp_prot); diff --git a/trunk/net/dccp/ipv6.c b/trunk/net/dccp/ipv6.c deleted file mode 100644 index c609dc78f487..000000000000 --- a/trunk/net/dccp/ipv6.c +++ /dev/null @@ -1,1261 +0,0 @@ -/* - * DCCP over IPv6 - * Linux INET6 implementation - * - * Based on net/dccp6/ipv6.c - * - * Arnaldo Carvalho de Melo - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version - * 2 of the License, or (at your option) any later version. - */ - -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "dccp.h" -#include "ipv6.h" - -static void dccp_v6_ctl_send_reset(struct sk_buff *skb); -static void dccp_v6_reqsk_send_ack(struct sk_buff *skb, - struct request_sock *req); -static void dccp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb); - -static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb); - -static struct inet_connection_sock_af_ops dccp_ipv6_mapped; -static struct inet_connection_sock_af_ops dccp_ipv6_af_ops; - -static int dccp_v6_get_port(struct sock *sk, unsigned short snum) -{ - return inet_csk_get_port(&dccp_hashinfo, sk, snum, - inet6_csk_bind_conflict); -} - -static void dccp_v6_hash(struct sock *sk) -{ - if (sk->sk_state != DCCP_CLOSED) { - if (inet_csk(sk)->icsk_af_ops == &dccp_ipv6_mapped) { - dccp_prot.hash(sk); - return; - } - local_bh_disable(); - __inet6_hash(&dccp_hashinfo, sk); - local_bh_enable(); - } -} - -static inline u16 dccp_v6_check(struct dccp_hdr *dh, int len, - struct in6_addr *saddr, - struct in6_addr *daddr, - unsigned long base) -{ - return csum_ipv6_magic(saddr, daddr, len, IPPROTO_DCCP, base); -} - -static __u32 dccp_v6_init_sequence(struct sock *sk, struct sk_buff *skb) -{ - const struct dccp_hdr *dh = dccp_hdr(skb); - - if (skb->protocol == htons(ETH_P_IPV6)) - return secure_tcpv6_sequence_number(skb->nh.ipv6h->daddr.s6_addr32, - skb->nh.ipv6h->saddr.s6_addr32, - dh->dccph_dport, - dh->dccph_sport); - else - return secure_dccp_sequence_number(skb->nh.iph->daddr, - skb->nh.iph->saddr, - dh->dccph_dport, - dh->dccph_sport); -} - -static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr, - int addr_len) -{ - struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr; - struct inet_connection_sock *icsk = inet_csk(sk); - struct inet_sock *inet = inet_sk(sk); - struct ipv6_pinfo *np = inet6_sk(sk); - struct dccp_sock *dp = dccp_sk(sk); - struct in6_addr *saddr = NULL, *final_p = NULL, final; - struct flowi fl; - struct dst_entry *dst; - int addr_type; - int err; - - dp->dccps_role = DCCP_ROLE_CLIENT; - - if (addr_len < SIN6_LEN_RFC2133) - return -EINVAL; - - if (usin->sin6_family != AF_INET6) - return -EAFNOSUPPORT; - - memset(&fl, 0, sizeof(fl)); - - if (np->sndflow) { - fl.fl6_flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK; - IP6_ECN_flow_init(fl.fl6_flowlabel); - if (fl.fl6_flowlabel & IPV6_FLOWLABEL_MASK) { - struct ip6_flowlabel *flowlabel; - flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel); - if (flowlabel == NULL) - return -EINVAL; - ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst); - fl6_sock_release(flowlabel); - } - } - - /* - * connect() to INADDR_ANY means loopback (BSD'ism). - */ - - if (ipv6_addr_any(&usin->sin6_addr)) - usin->sin6_addr.s6_addr[15] = 0x1; - - addr_type = ipv6_addr_type(&usin->sin6_addr); - - if(addr_type & IPV6_ADDR_MULTICAST) - return -ENETUNREACH; - - if (addr_type & IPV6_ADDR_LINKLOCAL) { - if (addr_len >= sizeof(struct sockaddr_in6) && - usin->sin6_scope_id) { - /* If interface is set while binding, indices - * must coincide. - */ - if (sk->sk_bound_dev_if && - sk->sk_bound_dev_if != usin->sin6_scope_id) - return -EINVAL; - - sk->sk_bound_dev_if = usin->sin6_scope_id; - } - - /* Connect to link-local address requires an interface */ - if (!sk->sk_bound_dev_if) - return -EINVAL; - } - - ipv6_addr_copy(&np->daddr, &usin->sin6_addr); - np->flow_label = fl.fl6_flowlabel; - - /* - * DCCP over IPv4 - */ - - if (addr_type == IPV6_ADDR_MAPPED) { - u32 exthdrlen = icsk->icsk_ext_hdr_len; - struct sockaddr_in sin; - - SOCK_DEBUG(sk, "connect: ipv4 mapped\n"); - - if (__ipv6_only_sock(sk)) - return -ENETUNREACH; - - sin.sin_family = AF_INET; - sin.sin_port = usin->sin6_port; - sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3]; - - icsk->icsk_af_ops = &dccp_ipv6_mapped; - sk->sk_backlog_rcv = dccp_v4_do_rcv; - - err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin)); - - if (err) { - icsk->icsk_ext_hdr_len = exthdrlen; - icsk->icsk_af_ops = &dccp_ipv6_af_ops; - sk->sk_backlog_rcv = dccp_v6_do_rcv; - goto failure; - } else { - ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF), - inet->saddr); - ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF), - inet->rcv_saddr); - } - - return err; - } - - if (!ipv6_addr_any(&np->rcv_saddr)) - saddr = &np->rcv_saddr; - - fl.proto = IPPROTO_DCCP; - ipv6_addr_copy(&fl.fl6_dst, &np->daddr); - ipv6_addr_copy(&fl.fl6_src, saddr ? saddr : &np->saddr); - fl.oif = sk->sk_bound_dev_if; - fl.fl_ip_dport = usin->sin6_port; - fl.fl_ip_sport = inet->sport; - - if (np->opt && np->opt->srcrt) { - struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt; - ipv6_addr_copy(&final, &fl.fl6_dst); - ipv6_addr_copy(&fl.fl6_dst, rt0->addr); - final_p = &final; - } - - err = ip6_dst_lookup(sk, &dst, &fl); - if (err) - goto failure; - if (final_p) - ipv6_addr_copy(&fl.fl6_dst, final_p); - - if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) - goto failure; - - if (saddr == NULL) { - saddr = &fl.fl6_src; - ipv6_addr_copy(&np->rcv_saddr, saddr); - } - - /* set the source address */ - ipv6_addr_copy(&np->saddr, saddr); - inet->rcv_saddr = LOOPBACK4_IPV6; - - ip6_dst_store(sk, dst, NULL); - - icsk->icsk_ext_hdr_len = 0; - if (np->opt) - icsk->icsk_ext_hdr_len = (np->opt->opt_flen + - np->opt->opt_nflen); - - inet->dport = usin->sin6_port; - - dccp_set_state(sk, DCCP_REQUESTING); - err = inet6_hash_connect(&dccp_death_row, sk); - if (err) - goto late_failure; - /* FIXME */ -#if 0 - dp->dccps_gar = secure_dccp_v6_sequence_number(np->saddr.s6_addr32, - np->daddr.s6_addr32, - inet->sport, - inet->dport); -#endif - err = dccp_connect(sk); - if (err) - goto late_failure; - - return 0; - -late_failure: - dccp_set_state(sk, DCCP_CLOSED); - __sk_dst_reset(sk); -failure: - inet->dport = 0; - sk->sk_route_caps = 0; - return err; -} - -static void dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, - int type, int code, int offset, __u32 info) -{ - struct ipv6hdr *hdr = (struct ipv6hdr *)skb->data; - const struct dccp_hdr *dh = (struct dccp_hdr *)(skb->data + offset); - struct ipv6_pinfo *np; - struct sock *sk; - int err; - __u64 seq; - - sk = inet6_lookup(&dccp_hashinfo, &hdr->daddr, dh->dccph_dport, - &hdr->saddr, dh->dccph_sport, skb->dev->ifindex); - - if (sk == NULL) { - ICMP6_INC_STATS_BH(__in6_dev_get(skb->dev), ICMP6_MIB_INERRORS); - return; - } - - if (sk->sk_state == DCCP_TIME_WAIT) { - inet_twsk_put((struct inet_timewait_sock *)sk); - return; - } - - bh_lock_sock(sk); - if (sock_owned_by_user(sk)) - NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS); - - if (sk->sk_state == DCCP_CLOSED) - goto out; - - np = inet6_sk(sk); - - if (type == ICMPV6_PKT_TOOBIG) { - struct dst_entry *dst = NULL; - - if (sock_owned_by_user(sk)) - goto out; - if ((1 << sk->sk_state) & (DCCPF_LISTEN | DCCPF_CLOSED)) - goto out; - - /* icmp should have updated the destination cache entry */ - dst = __sk_dst_check(sk, np->dst_cookie); - - if (dst == NULL) { - struct inet_sock *inet = inet_sk(sk); - struct flowi fl; - - /* BUGGG_FUTURE: Again, it is not clear how - to handle rthdr case. Ignore this complexity - for now. - */ - memset(&fl, 0, sizeof(fl)); - fl.proto = IPPROTO_DCCP; - ipv6_addr_copy(&fl.fl6_dst, &np->daddr); - ipv6_addr_copy(&fl.fl6_src, &np->saddr); - fl.oif = sk->sk_bound_dev_if; - fl.fl_ip_dport = inet->dport; - fl.fl_ip_sport = inet->sport; - - if ((err = ip6_dst_lookup(sk, &dst, &fl))) { - sk->sk_err_soft = -err; - goto out; - } - - if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) { - sk->sk_err_soft = -err; - goto out; - } - - } else - dst_hold(dst); - - if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) { - dccp_sync_mss(sk, dst_mtu(dst)); - } /* else let the usual retransmit timer handle it */ - dst_release(dst); - goto out; - } - - icmpv6_err_convert(type, code, &err); - - seq = DCCP_SKB_CB(skb)->dccpd_seq; - /* Might be for an request_sock */ - switch (sk->sk_state) { - struct request_sock *req, **prev; - case DCCP_LISTEN: - if (sock_owned_by_user(sk)) - goto out; - - req = inet6_csk_search_req(sk, &prev, dh->dccph_dport, - &hdr->daddr, &hdr->saddr, - inet6_iif(skb)); - if (!req) - goto out; - - /* ICMPs are not backlogged, hence we cannot get - * an established socket here. - */ - BUG_TRAP(req->sk == NULL); - - if (seq != dccp_rsk(req)->dreq_iss) { - NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS); - goto out; - } - - inet_csk_reqsk_queue_drop(sk, req, prev); - goto out; - - case DCCP_REQUESTING: - case DCCP_RESPOND: /* Cannot happen. - It can, it SYNs are crossed. --ANK */ - if (!sock_owned_by_user(sk)) { - DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS); - sk->sk_err = err; - /* - * Wake people up to see the error - * (see connect in sock.c) - */ - sk->sk_error_report(sk); - - dccp_done(sk); - } else - sk->sk_err_soft = err; - goto out; - } - - if (!sock_owned_by_user(sk) && np->recverr) { - sk->sk_err = err; - sk->sk_error_report(sk); - } else - sk->sk_err_soft = err; - -out: - bh_unlock_sock(sk); - sock_put(sk); -} - - -static int dccp_v6_send_response(struct sock *sk, struct request_sock *req, - struct dst_entry *dst) -{ - struct inet6_request_sock *ireq6 = inet6_rsk(req); - struct ipv6_pinfo *np = inet6_sk(sk); - struct sk_buff *skb; - struct ipv6_txoptions *opt = NULL; - struct in6_addr *final_p = NULL, final; - struct flowi fl; - int err = -1; - - memset(&fl, 0, sizeof(fl)); - fl.proto = IPPROTO_DCCP; - ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr); - ipv6_addr_copy(&fl.fl6_src, &ireq6->loc_addr); - fl.fl6_flowlabel = 0; - fl.oif = ireq6->iif; - fl.fl_ip_dport = inet_rsk(req)->rmt_port; - fl.fl_ip_sport = inet_sk(sk)->sport; - - if (dst == NULL) { - opt = np->opt; - if (opt == NULL && - np->rxopt.bits.osrcrt == 2 && - ireq6->pktopts) { - struct sk_buff *pktopts = ireq6->pktopts; - struct inet6_skb_parm *rxopt = IP6CB(pktopts); - if (rxopt->srcrt) - opt = ipv6_invert_rthdr(sk, - (struct ipv6_rt_hdr *)(pktopts->nh.raw + - rxopt->srcrt)); - } - - if (opt && opt->srcrt) { - struct rt0_hdr *rt0 = (struct rt0_hdr *)opt->srcrt; - ipv6_addr_copy(&final, &fl.fl6_dst); - ipv6_addr_copy(&fl.fl6_dst, rt0->addr); - final_p = &final; - } - - err = ip6_dst_lookup(sk, &dst, &fl); - if (err) - goto done; - if (final_p) - ipv6_addr_copy(&fl.fl6_dst, final_p); - if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) - goto done; - } - - skb = dccp_make_response(sk, dst, req); - if (skb != NULL) { - struct dccp_hdr *dh = dccp_hdr(skb); - dh->dccph_checksum = dccp_v6_check(dh, skb->len, - &ireq6->loc_addr, - &ireq6->rmt_addr, - csum_partial((char *)dh, - skb->len, - skb->csum)); - ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr); - err = ip6_xmit(sk, skb, &fl, opt, 0); - if (err == NET_XMIT_CN) - err = 0; - } - -done: - if (opt && opt != np->opt) - sock_kfree_s(sk, opt, opt->tot_len); - return err; -} - -static void dccp_v6_reqsk_destructor(struct request_sock *req) -{ - if (inet6_rsk(req)->pktopts != NULL) - kfree_skb(inet6_rsk(req)->pktopts); -} - -static struct request_sock_ops dccp6_request_sock_ops = { - .family = AF_INET6, - .obj_size = sizeof(struct dccp6_request_sock), - .rtx_syn_ack = dccp_v6_send_response, - .send_ack = dccp_v6_reqsk_send_ack, - .destructor = dccp_v6_reqsk_destructor, - .send_reset = dccp_v6_ctl_send_reset, -}; - -static struct timewait_sock_ops dccp6_timewait_sock_ops = { - .twsk_obj_size = sizeof(struct dccp6_timewait_sock), -}; - -static void dccp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb) -{ - struct ipv6_pinfo *np = inet6_sk(sk); - struct dccp_hdr *dh = dccp_hdr(skb); - - dh->dccph_checksum = csum_ipv6_magic(&np->saddr, &np->daddr, - len, IPPROTO_DCCP, - csum_partial((char *)dh, - dh->dccph_doff << 2, - skb->csum)); -} - -static void dccp_v6_ctl_send_reset(struct sk_buff *rxskb) -{ - struct dccp_hdr *rxdh = dccp_hdr(rxskb), *dh; - const int dccp_hdr_reset_len = sizeof(struct dccp_hdr) + - sizeof(struct dccp_hdr_ext) + - sizeof(struct dccp_hdr_reset); - struct sk_buff *skb; - struct flowi fl; - u64 seqno; - - if (rxdh->dccph_type == DCCP_PKT_RESET) - return; - - if (!ipv6_unicast_destination(rxskb)) - return; - - /* - * We need to grab some memory, and put together an RST, - * and then put it into the queue to be sent. - */ - - skb = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + - dccp_hdr_reset_len, GFP_ATOMIC); - if (skb == NULL) - return; - - skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr) + - dccp_hdr_reset_len); - - skb->h.raw = skb_push(skb, dccp_hdr_reset_len); - dh = dccp_hdr(skb); - memset(dh, 0, dccp_hdr_reset_len); - - /* Swap the send and the receive. */ - dh->dccph_type = DCCP_PKT_RESET; - dh->dccph_sport = rxdh->dccph_dport; - dh->dccph_dport = rxdh->dccph_sport; - dh->dccph_doff = dccp_hdr_reset_len / 4; - dh->dccph_x = 1; - dccp_hdr_reset(skb)->dccph_reset_code = - DCCP_SKB_CB(rxskb)->dccpd_reset_code; - - /* See "8.3.1. Abnormal Termination" in draft-ietf-dccp-spec-11 */ - seqno = 0; - if (DCCP_SKB_CB(rxskb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ) - dccp_set_seqno(&seqno, DCCP_SKB_CB(rxskb)->dccpd_ack_seq + 1); - - dccp_hdr_set_seq(dh, seqno); - dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), - DCCP_SKB_CB(rxskb)->dccpd_seq); - - memset(&fl, 0, sizeof(fl)); - ipv6_addr_copy(&fl.fl6_dst, &rxskb->nh.ipv6h->saddr); - ipv6_addr_copy(&fl.fl6_src, &rxskb->nh.ipv6h->daddr); - dh->dccph_checksum = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst, - sizeof(*dh), IPPROTO_DCCP, - skb->csum); - fl.proto = IPPROTO_DCCP; - fl.oif = inet6_iif(rxskb); - fl.fl_ip_dport = dh->dccph_dport; - fl.fl_ip_sport = dh->dccph_sport; - - /* sk = NULL, but it is safe for now. RST socket required. */ - if (!ip6_dst_lookup(NULL, &skb->dst, &fl)) { - if (xfrm_lookup(&skb->dst, &fl, NULL, 0) >= 0) { - ip6_xmit(NULL, skb, &fl, NULL, 0); - DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS); - DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS); - return; - } - } - - kfree_skb(skb); -} - -static void dccp_v6_ctl_send_ack(struct sk_buff *rxskb) -{ - struct flowi fl; - struct dccp_hdr *rxdh = dccp_hdr(rxskb), *dh; - const int dccp_hdr_ack_len = sizeof(struct dccp_hdr) + - sizeof(struct dccp_hdr_ext) + - sizeof(struct dccp_hdr_ack_bits); - struct sk_buff *skb; - - skb = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + - dccp_hdr_ack_len, GFP_ATOMIC); - if (skb == NULL) - return; - - skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr) + - dccp_hdr_ack_len); - - skb->h.raw = skb_push(skb, dccp_hdr_ack_len); - dh = dccp_hdr(skb); - memset(dh, 0, dccp_hdr_ack_len); - - /* Build DCCP header and checksum it. */ - dh->dccph_type = DCCP_PKT_ACK; - dh->dccph_sport = rxdh->dccph_dport; - dh->dccph_dport = rxdh->dccph_sport; - dh->dccph_doff = dccp_hdr_ack_len / 4; - dh->dccph_x = 1; - - dccp_hdr_set_seq(dh, DCCP_SKB_CB(rxskb)->dccpd_ack_seq); - dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), - DCCP_SKB_CB(rxskb)->dccpd_seq); - - memset(&fl, 0, sizeof(fl)); - ipv6_addr_copy(&fl.fl6_dst, &rxskb->nh.ipv6h->saddr); - ipv6_addr_copy(&fl.fl6_src, &rxskb->nh.ipv6h->daddr); - - /* FIXME: calculate checksum, IPv4 also should... */ - - fl.proto = IPPROTO_DCCP; - fl.oif = inet6_iif(rxskb); - fl.fl_ip_dport = dh->dccph_dport; - fl.fl_ip_sport = dh->dccph_sport; - - if (!ip6_dst_lookup(NULL, &skb->dst, &fl)) { - if (xfrm_lookup(&skb->dst, &fl, NULL, 0) >= 0) { - ip6_xmit(NULL, skb, &fl, NULL, 0); - DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS); - return; - } - } - - kfree_skb(skb); -} - -static void dccp_v6_reqsk_send_ack(struct sk_buff *skb, - struct request_sock *req) -{ - dccp_v6_ctl_send_ack(skb); -} - -static struct sock *dccp_v6_hnd_req(struct sock *sk,struct sk_buff *skb) -{ - const struct dccp_hdr *dh = dccp_hdr(skb); - const struct ipv6hdr *iph = skb->nh.ipv6h; - struct sock *nsk; - struct request_sock **prev; - /* Find possible connection requests. */ - struct request_sock *req = inet6_csk_search_req(sk, &prev, - dh->dccph_sport, - &iph->saddr, - &iph->daddr, - inet6_iif(skb)); - if (req != NULL) - return dccp_check_req(sk, skb, req, prev); - - nsk = __inet6_lookup_established(&dccp_hashinfo, - &iph->saddr, dh->dccph_sport, - &iph->daddr, ntohs(dh->dccph_dport), - inet6_iif(skb)); - - if (nsk != NULL) { - if (nsk->sk_state != DCCP_TIME_WAIT) { - bh_lock_sock(nsk); - return nsk; - } - inet_twsk_put((struct inet_timewait_sock *)nsk); - return NULL; - } - - return sk; -} - -static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb) -{ - struct inet_request_sock *ireq; - struct dccp_sock dp; - struct request_sock *req; - struct dccp_request_sock *dreq; - struct inet6_request_sock *ireq6; - struct ipv6_pinfo *np = inet6_sk(sk); - const __u32 service = dccp_hdr_request(skb)->dccph_req_service; - struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb); - __u8 reset_code = DCCP_RESET_CODE_TOO_BUSY; - - if (skb->protocol == htons(ETH_P_IP)) - return dccp_v4_conn_request(sk, skb); - - if (!ipv6_unicast_destination(skb)) - goto drop; - - if (dccp_bad_service_code(sk, service)) { - reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE; - goto drop; - } - /* - * There are no SYN attacks on IPv6, yet... - */ - if (inet_csk_reqsk_queue_is_full(sk)) - goto drop; - - if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) - goto drop; - - req = inet6_reqsk_alloc(sk->sk_prot->rsk_prot); - if (req == NULL) - goto drop; - - /* FIXME: process options */ - - dccp_openreq_init(req, &dp, skb); - - ireq6 = inet6_rsk(req); - ireq = inet_rsk(req); - ipv6_addr_copy(&ireq6->rmt_addr, &skb->nh.ipv6h->saddr); - ipv6_addr_copy(&ireq6->loc_addr, &skb->nh.ipv6h->daddr); - req->rcv_wnd = 100; /* Fake, option parsing will get the - right value */ - ireq6->pktopts = NULL; - - if (ipv6_opt_accepted(sk, skb) || - np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo || - np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) { - atomic_inc(&skb->users); - ireq6->pktopts = skb; - } - ireq6->iif = sk->sk_bound_dev_if; - - /* So that link locals have meaning */ - if (!sk->sk_bound_dev_if && - ipv6_addr_type(&ireq6->rmt_addr) & IPV6_ADDR_LINKLOCAL) - ireq6->iif = inet6_iif(skb); - - /* - * Step 3: Process LISTEN state - * - * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie - * - * In fact we defer setting S.GSR, S.SWL, S.SWH to - * dccp_create_openreq_child. - */ - dreq = dccp_rsk(req); - dreq->dreq_isr = dcb->dccpd_seq; - dreq->dreq_iss = dccp_v6_init_sequence(sk, skb); - dreq->dreq_service = service; - - if (dccp_v6_send_response(sk, req, NULL)) - goto drop_and_free; - - inet6_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT); - return 0; - -drop_and_free: - reqsk_free(req); -drop: - DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS); - dcb->dccpd_reset_code = reset_code; - return -1; -} - -static struct sock *dccp_v6_request_recv_sock(struct sock *sk, - struct sk_buff *skb, - struct request_sock *req, - struct dst_entry *dst) -{ - struct inet6_request_sock *ireq6 = inet6_rsk(req); - struct ipv6_pinfo *newnp, *np = inet6_sk(sk); - struct inet_sock *newinet; - struct dccp_sock *newdp; - struct dccp6_sock *newdp6; - struct sock *newsk; - struct ipv6_txoptions *opt; - - if (skb->protocol == htons(ETH_P_IP)) { - /* - * v6 mapped - */ - - newsk = dccp_v4_request_recv_sock(sk, skb, req, dst); - if (newsk == NULL) - return NULL; - - newdp6 = (struct dccp6_sock *)newsk; - newdp = dccp_sk(newsk); - newinet = inet_sk(newsk); - newinet->pinet6 = &newdp6->inet6; - newnp = inet6_sk(newsk); - - memcpy(newnp, np, sizeof(struct ipv6_pinfo)); - - ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF), - newinet->daddr); - - ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF), - newinet->saddr); - - ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr); - - inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped; - newsk->sk_backlog_rcv = dccp_v4_do_rcv; - newnp->pktoptions = NULL; - newnp->opt = NULL; - newnp->mcast_oif = inet6_iif(skb); - newnp->mcast_hops = skb->nh.ipv6h->hop_limit; - - /* - * No need to charge this sock to the relevant IPv6 refcnt debug socks count - * here, dccp_create_openreq_child now does this for us, see the comment in - * that function for the gory details. -acme - */ - - /* It is tricky place. Until this moment IPv4 tcp - worked with IPv6 icsk.icsk_af_ops. - Sync it now. - */ - dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie); - - return newsk; - } - - opt = np->opt; - - if (sk_acceptq_is_full(sk)) - goto out_overflow; - - if (np->rxopt.bits.osrcrt == 2 && - opt == NULL && ireq6->pktopts) { - struct inet6_skb_parm *rxopt = IP6CB(ireq6->pktopts); - if (rxopt->srcrt) - opt = ipv6_invert_rthdr(sk, - (struct ipv6_rt_hdr *)(ireq6->pktopts->nh.raw + - rxopt->srcrt)); - } - - if (dst == NULL) { - struct in6_addr *final_p = NULL, final; - struct flowi fl; - - memset(&fl, 0, sizeof(fl)); - fl.proto = IPPROTO_DCCP; - ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr); - if (opt && opt->srcrt) { - struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt; - ipv6_addr_copy(&final, &fl.fl6_dst); - ipv6_addr_copy(&fl.fl6_dst, rt0->addr); - final_p = &final; - } - ipv6_addr_copy(&fl.fl6_src, &ireq6->loc_addr); - fl.oif = sk->sk_bound_dev_if; - fl.fl_ip_dport = inet_rsk(req)->rmt_port; - fl.fl_ip_sport = inet_sk(sk)->sport; - - if (ip6_dst_lookup(sk, &dst, &fl)) - goto out; - - if (final_p) - ipv6_addr_copy(&fl.fl6_dst, final_p); - - if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0) - goto out; - } - - newsk = dccp_create_openreq_child(sk, req, skb); - if (newsk == NULL) - goto out; - - /* - * No need to charge this sock to the relevant IPv6 refcnt debug socks - * count here, dccp_create_openreq_child now does this for us, see the - * comment in that function for the gory details. -acme - */ - - ip6_dst_store(newsk, dst, NULL); - newsk->sk_route_caps = dst->dev->features & - ~(NETIF_F_IP_CSUM | NETIF_F_TSO); - - newdp6 = (struct dccp6_sock *)newsk; - newinet = inet_sk(newsk); - newinet->pinet6 = &newdp6->inet6; - newdp = dccp_sk(newsk); - newnp = inet6_sk(newsk); - - memcpy(newnp, np, sizeof(struct ipv6_pinfo)); - - ipv6_addr_copy(&newnp->daddr, &ireq6->rmt_addr); - ipv6_addr_copy(&newnp->saddr, &ireq6->loc_addr); - ipv6_addr_copy(&newnp->rcv_saddr, &ireq6->loc_addr); - newsk->sk_bound_dev_if = ireq6->iif; - - /* Now IPv6 options... - - First: no IPv4 options. - */ - newinet->opt = NULL; - - /* Clone RX bits */ - newnp->rxopt.all = np->rxopt.all; - - /* Clone pktoptions received with SYN */ - newnp->pktoptions = NULL; - if (ireq6->pktopts != NULL) { - newnp->pktoptions = skb_clone(ireq6->pktopts, GFP_ATOMIC); - kfree_skb(ireq6->pktopts); - ireq6->pktopts = NULL; - if (newnp->pktoptions) - skb_set_owner_r(newnp->pktoptions, newsk); - } - newnp->opt = NULL; - newnp->mcast_oif = inet6_iif(skb); - newnp->mcast_hops = skb->nh.ipv6h->hop_limit; - - /* Clone native IPv6 options from listening socket (if any) - - Yes, keeping reference count would be much more clever, - but we make one more one thing there: reattach optmem - to newsk. - */ - if (opt) { - newnp->opt = ipv6_dup_options(newsk, opt); - if (opt != np->opt) - sock_kfree_s(sk, opt, opt->tot_len); - } - - inet_csk(newsk)->icsk_ext_hdr_len = 0; - if (newnp->opt) - inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen + - newnp->opt->opt_flen); - - dccp_sync_mss(newsk, dst_mtu(dst)); - - newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6; - - __inet6_hash(&dccp_hashinfo, newsk); - inet_inherit_port(&dccp_hashinfo, sk, newsk); - - return newsk; - -out_overflow: - NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS); -out: - NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS); - if (opt && opt != np->opt) - sock_kfree_s(sk, opt, opt->tot_len); - dst_release(dst); - return NULL; -} - -/* The socket must have it's spinlock held when we get - * here. - * - * We have a potential double-lock case here, so even when - * doing backlog processing we use the BH locking scheme. - * This is because we cannot sleep with the original spinlock - * held. - */ -static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb) -{ - struct ipv6_pinfo *np = inet6_sk(sk); - struct sk_buff *opt_skb = NULL; - - /* Imagine: socket is IPv6. IPv4 packet arrives, - goes to IPv4 receive handler and backlogged. - From backlog it always goes here. Kerboom... - Fortunately, dccp_rcv_established and rcv_established - handle them correctly, but it is not case with - dccp_v6_hnd_req and dccp_v6_ctl_send_reset(). --ANK - */ - - if (skb->protocol == htons(ETH_P_IP)) - return dccp_v4_do_rcv(sk, skb); - - if (sk_filter(sk, skb, 0)) - goto discard; - - /* - * socket locking is here for SMP purposes as backlog rcv - * is currently called with bh processing disabled. - */ - - /* Do Stevens' IPV6_PKTOPTIONS. - - Yes, guys, it is the only place in our code, where we - may make it not affecting IPv4. - The rest of code is protocol independent, - and I do not like idea to uglify IPv4. - - Actually, all the idea behind IPV6_PKTOPTIONS - looks not very well thought. For now we latch - options, received in the last packet, enqueued - by tcp. Feel free to propose better solution. - --ANK (980728) - */ - if (np->rxopt.all) - opt_skb = skb_clone(skb, GFP_ATOMIC); - - if (sk->sk_state == DCCP_OPEN) { /* Fast path */ - if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len)) - goto reset; - return 0; - } - - if (sk->sk_state == DCCP_LISTEN) { - struct sock *nsk = dccp_v6_hnd_req(sk, skb); - if (!nsk) - goto discard; - - /* - * Queue it on the new socket if the new socket is active, - * otherwise we just shortcircuit this and continue with - * the new socket.. - */ - if(nsk != sk) { - if (dccp_child_process(sk, nsk, skb)) - goto reset; - if (opt_skb) - __kfree_skb(opt_skb); - return 0; - } - } - - if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len)) - goto reset; - return 0; - -reset: - dccp_v6_ctl_send_reset(skb); -discard: - if (opt_skb) - __kfree_skb(opt_skb); - kfree_skb(skb); - return 0; -} - -static int dccp_v6_rcv(struct sk_buff **pskb, unsigned int *nhoffp) -{ - const struct dccp_hdr *dh; - struct sk_buff *skb = *pskb; - struct sock *sk; - - /* Step 1: Check header basics: */ - - if (dccp_invalid_packet(skb)) - goto discard_it; - - dh = dccp_hdr(skb); - - DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(skb); - DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type; - - if (dccp_packet_without_ack(skb)) - DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ; - else - DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb); - - /* Step 2: - * Look up flow ID in table and get corresponding socket */ - sk = __inet6_lookup(&dccp_hashinfo, &skb->nh.ipv6h->saddr, - dh->dccph_sport, - &skb->nh.ipv6h->daddr, ntohs(dh->dccph_dport), - inet6_iif(skb)); - /* - * Step 2: - * If no socket ... - * Generate Reset(No Connection) unless P.type == Reset - * Drop packet and return - */ - if (sk == NULL) - goto no_dccp_socket; - - /* - * Step 2: - * ... or S.state == TIMEWAIT, - * Generate Reset(No Connection) unless P.type == Reset - * Drop packet and return - */ - - if (sk->sk_state == DCCP_TIME_WAIT) - goto do_time_wait; - - if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) - goto discard_and_relse; - - return sk_receive_skb(sk, skb) ? -1 : 0; - -no_dccp_socket: - if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) - goto discard_it; - /* - * Step 2: - * Generate Reset(No Connection) unless P.type == Reset - * Drop packet and return - */ - if (dh->dccph_type != DCCP_PKT_RESET) { - DCCP_SKB_CB(skb)->dccpd_reset_code = - DCCP_RESET_CODE_NO_CONNECTION; - dccp_v6_ctl_send_reset(skb); - } -discard_it: - - /* - * Discard frame - */ - - kfree_skb(skb); - return 0; - -discard_and_relse: - sock_put(sk); - goto discard_it; - -do_time_wait: - inet_twsk_put((struct inet_timewait_sock *)sk); - goto no_dccp_socket; -} - -static struct inet_connection_sock_af_ops dccp_ipv6_af_ops = { - .queue_xmit = inet6_csk_xmit, - .send_check = dccp_v6_send_check, - .rebuild_header = inet6_sk_rebuild_header, - .conn_request = dccp_v6_conn_request, - .syn_recv_sock = dccp_v6_request_recv_sock, - .net_header_len = sizeof(struct ipv6hdr), - .setsockopt = ipv6_setsockopt, - .getsockopt = ipv6_getsockopt, - .addr2sockaddr = inet6_csk_addr2sockaddr, - .sockaddr_len = sizeof(struct sockaddr_in6) -}; - -/* - * DCCP over IPv4 via INET6 API - */ -static struct inet_connection_sock_af_ops dccp_ipv6_mapped = { - .queue_xmit = ip_queue_xmit, - .send_check = dccp_v4_send_check, - .rebuild_header = inet_sk_rebuild_header, - .conn_request = dccp_v6_conn_request, - .syn_recv_sock = dccp_v6_request_recv_sock, - .net_header_len = sizeof(struct iphdr), - .setsockopt = ipv6_setsockopt, - .getsockopt = ipv6_getsockopt, - .addr2sockaddr = inet6_csk_addr2sockaddr, - .sockaddr_len = sizeof(struct sockaddr_in6) -}; - -/* NOTE: A lot of things set to zero explicitly by call to - * sk_alloc() so need not be done here. - */ -static int dccp_v6_init_sock(struct sock *sk) -{ - int err = dccp_v4_init_sock(sk); - - if (err == 0) - inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops; - - return err; -} - -static int dccp_v6_destroy_sock(struct sock *sk) -{ - dccp_v4_destroy_sock(sk); - return inet6_destroy_sock(sk); -} - -static struct proto dccp_v6_prot = { - .name = "DCCPv6", - .owner = THIS_MODULE, - .close = dccp_close, - .connect = dccp_v6_connect, - .disconnect = dccp_disconnect, - .ioctl = dccp_ioctl, - .init = dccp_v6_init_sock, - .setsockopt = dccp_setsockopt, - .getsockopt = dccp_getsockopt, - .sendmsg = dccp_sendmsg, - .recvmsg = dccp_recvmsg, - .backlog_rcv = dccp_v6_do_rcv, - .hash = dccp_v6_hash, - .unhash = dccp_unhash, - .accept = inet_csk_accept, - .get_port = dccp_v6_get_port, - .shutdown = dccp_shutdown, - .destroy = dccp_v6_destroy_sock, - .orphan_count = &dccp_orphan_count, - .max_header = MAX_DCCP_HEADER, - .obj_size = sizeof(struct dccp6_sock), - .rsk_prot = &dccp6_request_sock_ops, - .twsk_prot = &dccp6_timewait_sock_ops, -}; - -static struct inet6_protocol dccp_v6_protocol = { - .handler = dccp_v6_rcv, - .err_handler = dccp_v6_err, - .flags = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL, -}; - -static struct proto_ops inet6_dccp_ops = { - .family = PF_INET6, - .owner = THIS_MODULE, - .release = inet6_release, - .bind = inet6_bind, - .connect = inet_stream_connect, - .socketpair = sock_no_socketpair, - .accept = inet_accept, - .getname = inet6_getname, - .poll = dccp_poll, - .ioctl = inet6_ioctl, - .listen = inet_dccp_listen, - .shutdown = inet_shutdown, - .setsockopt = sock_common_setsockopt, - .getsockopt = sock_common_getsockopt, - .sendmsg = inet_sendmsg, - .recvmsg = sock_common_recvmsg, - .mmap = sock_no_mmap, - .sendpage = sock_no_sendpage, -}; - -static struct inet_protosw dccp_v6_protosw = { - .type = SOCK_DCCP, - .protocol = IPPROTO_DCCP, - .prot = &dccp_v6_prot, - .ops = &inet6_dccp_ops, - .capability = -1, - .flags = INET_PROTOSW_ICSK, -}; - -static int __init dccp_v6_init(void) -{ - int err = proto_register(&dccp_v6_prot, 1); - - if (err != 0) - goto out; - - err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP); - if (err != 0) - goto out_unregister_proto; - - inet6_register_protosw(&dccp_v6_protosw); -out: - return err; -out_unregister_proto: - proto_unregister(&dccp_v6_prot); - goto out; -} - -static void __exit dccp_v6_exit(void) -{ - inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP); - inet6_unregister_protosw(&dccp_v6_protosw); - proto_unregister(&dccp_v6_prot); -} - -module_init(dccp_v6_init); -module_exit(dccp_v6_exit); - -/* - * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33) - * values directly, Also cover the case where the protocol is not specified, - * i.e. net-pf-PF_INET6-proto-0-type-SOCK_DCCP - */ -MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-33-type-6"); -MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-0-type-6"); -MODULE_LICENSE("GPL"); -MODULE_AUTHOR("Arnaldo Carvalho de Melo "); -MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol"); diff --git a/trunk/net/dccp/ipv6.h b/trunk/net/dccp/ipv6.h deleted file mode 100644 index e4d4e9309270..000000000000 --- a/trunk/net/dccp/ipv6.h +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef _DCCP_IPV6_H -#define _DCCP_IPV6_H -/* - * net/dccp/ipv6.h - * - * An implementation of the DCCP protocol - * Copyright (c) 2005 Arnaldo Carvalho de Melo - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include -#include -#include - -struct dccp6_sock { - struct dccp_sock dccp; - /* - * ipv6_pinfo has to be the last member of dccp6_sock, - * see inet6_sk_generic. - */ - struct ipv6_pinfo inet6; -}; - -struct dccp6_request_sock { - struct dccp_request_sock dccp; - struct inet6_request_sock inet6; -}; - -struct dccp6_timewait_sock { - struct inet_timewait_sock inet; - struct inet6_timewait_sock tw6; -}; - -#endif /* _DCCP_IPV6_H */ diff --git a/trunk/net/dccp/minisocks.c b/trunk/net/dccp/minisocks.c index 29261fc198e7..1393461898bb 100644 --- a/trunk/net/dccp/minisocks.c +++ b/trunk/net/dccp/minisocks.c @@ -40,8 +40,6 @@ struct inet_timewait_death_row dccp_death_row = { (unsigned long)&dccp_death_row), }; -EXPORT_SYMBOL_GPL(dccp_death_row); - void dccp_time_wait(struct sock *sk, int state, int timeo) { struct inet_timewait_sock *tw = NULL; @@ -52,18 +50,7 @@ void dccp_time_wait(struct sock *sk, int state, int timeo) if (tw != NULL) { const struct inet_connection_sock *icsk = inet_csk(sk); const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1); -#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) - if (tw->tw_family == PF_INET6) { - const struct ipv6_pinfo *np = inet6_sk(sk); - struct inet6_timewait_sock *tw6; - - tw->tw_ipv6_offset = inet6_tw_offset(sk->sk_prot); - tw6 = inet6_twsk((struct sock *)tw); - ipv6_addr_copy(&tw6->tw_v6_daddr, &np->daddr); - ipv6_addr_copy(&tw6->tw_v6_rcv_saddr, &np->rcv_saddr); - tw->tw_ipv6only = np->ipv6only; - } -#endif + /* Linkage updates. */ __inet_twsk_hashdance(tw, sk, &dccp_hashinfo); @@ -183,8 +170,6 @@ struct sock *dccp_create_openreq_child(struct sock *sk, return newsk; } -EXPORT_SYMBOL_GPL(dccp_create_openreq_child); - /* * Process an incoming packet for RESPOND sockets represented * as an request_sock. @@ -229,7 +214,7 @@ struct sock *dccp_check_req(struct sock *sk, struct sk_buff *skb, goto drop; } - child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL); + child = dccp_v4_request_recv_sock(sk, skb, req, NULL); if (child == NULL) goto listen_overflow; @@ -251,8 +236,6 @@ struct sock *dccp_check_req(struct sock *sk, struct sk_buff *skb, goto out; } -EXPORT_SYMBOL_GPL(dccp_check_req); - /* * Queue segment on the new socket if the new socket is active, * otherwise we just shortcircuit this and continue with @@ -283,5 +266,3 @@ int dccp_child_process(struct sock *parent, struct sock *child, sock_put(child); return ret; } - -EXPORT_SYMBOL_GPL(dccp_child_process); diff --git a/trunk/net/dccp/output.c b/trunk/net/dccp/output.c index efd7ffb903a1..74ff87025878 100644 --- a/trunk/net/dccp/output.c +++ b/trunk/net/dccp/output.c @@ -15,7 +15,6 @@ #include #include -#include #include #include "ackvec.h" @@ -44,7 +43,6 @@ static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb) { if (likely(skb != NULL)) { const struct inet_sock *inet = inet_sk(sk); - const struct inet_connection_sock *icsk = inet_csk(sk); struct dccp_sock *dp = dccp_sk(sk); struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb); struct dccp_hdr *dh; @@ -110,7 +108,8 @@ static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb) break; } - icsk->icsk_af_ops->send_check(sk, skb->len, skb); + dh->dccph_checksum = dccp_v4_checksum(skb, inet->saddr, + inet->daddr); if (set_ack) dccp_event_ack_sent(sk); @@ -118,7 +117,7 @@ static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb) DCCP_INC_STATS(DCCP_MIB_OUTSEGS); memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); - err = icsk->icsk_af_ops->queue_xmit(skb, 0); + err = ip_queue_xmit(skb, 0); if (err <= 0) return err; @@ -135,13 +134,20 @@ static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb) unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu) { - struct inet_connection_sock *icsk = inet_csk(sk); struct dccp_sock *dp = dccp_sk(sk); - int mss_now = (pmtu - icsk->icsk_af_ops->net_header_len - - sizeof(struct dccp_hdr) - sizeof(struct dccp_hdr_ext)); + int mss_now; + + /* + * FIXME: we really should be using the af_specific thing to support + * IPv6. + * mss_now = pmtu - tp->af_specific->net_header_len - + * sizeof(struct dccp_hdr) - sizeof(struct dccp_hdr_ext); + */ + mss_now = pmtu - sizeof(struct iphdr) - sizeof(struct dccp_hdr) - + sizeof(struct dccp_hdr_ext); /* Now subtract optional transport overhead */ - mss_now -= icsk->icsk_ext_hdr_len; + mss_now -= dp->dccps_ext_header_len; /* * FIXME: this should come from the CCID infrastructure, where, say, @@ -154,14 +160,12 @@ unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu) mss_now -= ((5 + 6 + 10 + 6 + 6 + 6 + 3) / 4) * 4; /* And store cached results */ - icsk->icsk_pmtu_cookie = pmtu; + dp->dccps_pmtu_cookie = pmtu; dp->dccps_mss_cache = mss_now; return mss_now; } -EXPORT_SYMBOL_GPL(dccp_sync_mss); - void dccp_write_space(struct sock *sk) { read_lock(&sk->sk_callback_lock); @@ -262,7 +266,7 @@ int dccp_write_xmit(struct sock *sk, struct sk_buff *skb, long *timeo) int dccp_retransmit_skb(struct sock *sk, struct sk_buff *skb) { - if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0) + if (inet_sk_rebuild_header(sk) != 0) return -EHOSTUNREACH; /* Routing failure or similar. */ return dccp_transmit_skb(sk, (skb_cloned(skb) ? @@ -317,8 +321,6 @@ struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst, return skb; } -EXPORT_SYMBOL_GPL(dccp_make_response); - struct sk_buff *dccp_make_reset(struct sock *sk, struct dst_entry *dst, const enum dccp_reset_codes code) @@ -375,7 +377,6 @@ struct sk_buff *dccp_make_reset(struct sock *sk, struct dst_entry *dst, */ static inline void dccp_connect_init(struct sock *sk) { - struct dccp_sock *dp = dccp_sk(sk); struct dst_entry *dst = __sk_dst_get(sk); struct inet_connection_sock *icsk = inet_csk(sk); @@ -384,16 +385,10 @@ static inline void dccp_connect_init(struct sock *sk) dccp_sync_mss(sk, dst_mtu(dst)); - dccp_update_gss(sk, dp->dccps_iss); - /* - * SWL and AWL are initially adjusted so that they are not less than - * the initial Sequence Numbers received and sent, respectively: - * SWL := max(GSR + 1 - floor(W/4), ISR), - * AWL := max(GSS - W' + 1, ISS). - * These adjustments MUST be applied only at the beginning of the - * connection. - */ - dccp_set_seqno(&dp->dccps_awl, max48(dp->dccps_awl, dp->dccps_iss)); + /* + * FIXME: set dp->{dccps_swh,dccps_swl}, with + * something like dccp_inc_seq + */ icsk->icsk_retransmits = 0; } @@ -425,8 +420,6 @@ int dccp_connect(struct sock *sk) return 0; } -EXPORT_SYMBOL_GPL(dccp_connect); - void dccp_send_ack(struct sock *sk) { /* If we have been reset, we may not send again. */ diff --git a/trunk/net/dccp/proto.c b/trunk/net/dccp/proto.c index 65b11ea90d85..8a6b2a9e4581 100644 --- a/trunk/net/dccp/proto.c +++ b/trunk/net/dccp/proto.c @@ -24,7 +24,7 @@ #include #include -#include +#include #include #include #include @@ -34,18 +34,15 @@ #include #include #include +#include #include "ccid.h" #include "dccp.h" DEFINE_SNMP_STAT(struct dccp_mib, dccp_statistics) __read_mostly; -EXPORT_SYMBOL_GPL(dccp_statistics); - atomic_t dccp_orphan_count = ATOMIC_INIT(0); -EXPORT_SYMBOL_GPL(dccp_orphan_count); - static struct net_protocol dccp_protocol = { .handler = dccp_v4_rcv, .err_handler = dccp_v4_err, @@ -152,8 +149,6 @@ int dccp_disconnect(struct sock *sk, int flags) return err; } -EXPORT_SYMBOL_GPL(dccp_disconnect); - /* * Wait for a DCCP event. * @@ -161,8 +156,8 @@ EXPORT_SYMBOL_GPL(dccp_disconnect); * take care of normal races (between the test and the event) and we don't * go look at any of the socket buffers directly. */ -unsigned int dccp_poll(struct file *file, struct socket *sock, - poll_table *wait) +static unsigned int dccp_poll(struct file *file, struct socket *sock, + poll_table *wait) { unsigned int mask; struct sock *sk = sock->sk; @@ -210,16 +205,12 @@ unsigned int dccp_poll(struct file *file, struct socket *sock, return mask; } -EXPORT_SYMBOL_GPL(dccp_poll); - int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg) { dccp_pr_debug("entry\n"); return -ENOIOCTLCMD; } -EXPORT_SYMBOL_GPL(dccp_ioctl); - static int dccp_setsockopt_service(struct sock *sk, const u32 service, char __user *optval, int optlen) { @@ -263,9 +254,7 @@ int dccp_setsockopt(struct sock *sk, int level, int optname, int val; if (level != SOL_DCCP) - return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level, - optname, optval, - optlen); + return ip_setsockopt(sk, level, optname, optval, optlen); if (optlen < sizeof(int)) return -EINVAL; @@ -293,8 +282,6 @@ int dccp_setsockopt(struct sock *sk, int level, int optname, return err; } -EXPORT_SYMBOL_GPL(dccp_setsockopt); - static int dccp_getsockopt_service(struct sock *sk, int len, u32 __user *optval, int __user *optlen) @@ -333,9 +320,8 @@ int dccp_getsockopt(struct sock *sk, int level, int optname, int val, len; if (level != SOL_DCCP) - return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level, - optname, optval, - optlen); + return ip_getsockopt(sk, level, optname, optval, optlen); + if (get_user(len, optlen)) return -EFAULT; @@ -368,8 +354,6 @@ int dccp_getsockopt(struct sock *sk, int level, int optname, return 0; } -EXPORT_SYMBOL_GPL(dccp_getsockopt); - int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, size_t len) { @@ -426,8 +410,6 @@ int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, goto out_release; } -EXPORT_SYMBOL_GPL(dccp_sendmsg); - int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, size_t len, int nonblock, int flags, int *addr_len) { @@ -525,9 +507,7 @@ int dccp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, return len; } -EXPORT_SYMBOL_GPL(dccp_recvmsg); - -int inet_dccp_listen(struct socket *sock, int backlog) +static int inet_dccp_listen(struct socket *sock, int backlog) { struct sock *sk = sock->sk; unsigned char old_state; @@ -563,8 +543,6 @@ int inet_dccp_listen(struct socket *sock, int backlog) return err; } -EXPORT_SYMBOL_GPL(inet_dccp_listen); - static const unsigned char dccp_new_state[] = { /* current state: new state: action: */ [0] = DCCP_CLOSED, @@ -670,16 +648,12 @@ void dccp_close(struct sock *sk, long timeout) sock_put(sk); } -EXPORT_SYMBOL_GPL(dccp_close); - void dccp_shutdown(struct sock *sk, int how) { dccp_pr_debug("entry\n"); } -EXPORT_SYMBOL_GPL(dccp_shutdown); - -static const struct proto_ops inet_dccp_ops = { +static struct proto_ops inet_dccp_ops = { .family = PF_INET, .owner = THIS_MODULE, .release = inet_release, @@ -707,11 +681,11 @@ extern struct net_proto_family inet_family_ops; static struct inet_protosw dccp_v4_protosw = { .type = SOCK_DCCP, .protocol = IPPROTO_DCCP, - .prot = &dccp_prot, + .prot = &dccp_v4_prot, .ops = &inet_dccp_ops, .capability = -1, .no_check = 0, - .flags = INET_PROTOSW_ICSK, + .flags = 0, }; /* @@ -786,15 +760,13 @@ MODULE_PARM_DESC(thash_entries, "Number of ehash buckets"); int dccp_debug; module_param(dccp_debug, int, 0444); MODULE_PARM_DESC(dccp_debug, "Enable debug messages"); - -EXPORT_SYMBOL_GPL(dccp_debug); #endif static int __init dccp_init(void) { unsigned long goal; int ehash_order, bhash_order, i; - int rc = proto_register(&dccp_prot, 1); + int rc = proto_register(&dccp_v4_prot, 1); if (rc) goto out; @@ -897,7 +869,7 @@ static int __init dccp_init(void) kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep); dccp_hashinfo.bind_bucket_cachep = NULL; out_proto_unregister: - proto_unregister(&dccp_prot); + proto_unregister(&dccp_v4_prot); goto out; } @@ -920,7 +892,7 @@ static void __exit dccp_fini(void) get_order(dccp_hashinfo.ehash_size * sizeof(struct inet_ehash_bucket))); kmem_cache_destroy(dccp_hashinfo.bind_bucket_cachep); - proto_unregister(&dccp_prot); + proto_unregister(&dccp_v4_prot); } module_init(dccp_init); diff --git a/trunk/net/decnet/af_decnet.c b/trunk/net/decnet/af_decnet.c index 78ec5344be86..d402e9020c68 100644 --- a/trunk/net/decnet/af_decnet.c +++ b/trunk/net/decnet/af_decnet.c @@ -149,7 +149,7 @@ static void dn_keepalive(struct sock *sk); #define DN_SK_HASH_MASK (DN_SK_HASH_SIZE - 1) -static const struct proto_ops dn_proto_ops; +static struct proto_ops dn_proto_ops; static DEFINE_RWLOCK(dn_hash_lock); static struct hlist_head dn_sk_hash[DN_SK_HASH_SIZE]; static struct hlist_head dn_wild_sk; @@ -1252,7 +1252,7 @@ static int dn_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) break; default: - err = -ENOIOCTLCMD; + err = dev_ioctl(cmd, (void __user *)arg); break; } @@ -2342,7 +2342,7 @@ static struct net_proto_family dn_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops dn_proto_ops = { +static struct proto_ops dn_proto_ops = { .family = AF_DECnet, .owner = THIS_MODULE, .release = dn_release, diff --git a/trunk/net/decnet/dn_neigh.c b/trunk/net/decnet/dn_neigh.c index 33ab256cfd4a..8d0cc3cf3e49 100644 --- a/trunk/net/decnet/dn_neigh.c +++ b/trunk/net/decnet/dn_neigh.c @@ -408,14 +408,11 @@ int dn_neigh_router_hello(struct sk_buff *skb) } } - /* Only use routers in our area */ - if ((dn_ntohs(src)>>10) == dn_ntohs((decnet_address)>>10)) { - if (!dn_db->router) { - dn_db->router = neigh_clone(neigh); - } else { - if (msg->priority > ((struct dn_neigh *)dn_db->router)->priority) - neigh_release(xchg(&dn_db->router, neigh_clone(neigh))); - } + if (!dn_db->router) { + dn_db->router = neigh_clone(neigh); + } else { + if (msg->priority > ((struct dn_neigh *)dn_db->router)->priority) + neigh_release(xchg(&dn_db->router, neigh_clone(neigh))); } write_unlock(&neigh->lock); neigh_release(neigh); diff --git a/trunk/net/decnet/dn_nsp_in.c b/trunk/net/decnet/dn_nsp_in.c index 44bda85e678f..369f25b60f3f 100644 --- a/trunk/net/decnet/dn_nsp_in.c +++ b/trunk/net/decnet/dn_nsp_in.c @@ -793,6 +793,7 @@ static int dn_nsp_rx_packet(struct sk_buff *skb) got_it: if (sk != NULL) { struct dn_scp *scp = DN_SK(sk); + int ret; /* Reset backoff */ scp->nsp_rxtshift = 0; @@ -806,7 +807,21 @@ static int dn_nsp_rx_packet(struct sk_buff *skb) goto free_out; } - return sk_receive_skb(sk, skb); + bh_lock_sock(sk); + ret = NET_RX_SUCCESS; + if (decnet_debug_level & 8) + printk(KERN_DEBUG "NSP: 0x%02x 0x%02x 0x%04x 0x%04x %d\n", + (int)cb->rt_flags, (int)cb->nsp_flags, + (int)cb->src_port, (int)cb->dst_port, + !!sock_owned_by_user(sk)); + if (!sock_owned_by_user(sk)) + ret = dn_nsp_backlog_rcv(sk, skb); + else + sk_add_backlog(sk, skb); + bh_unlock_sock(sk); + sock_put(sk); + + return ret; } return dn_nsp_no_socket(skb, reason); diff --git a/trunk/net/econet/af_econet.c b/trunk/net/econet/af_econet.c index c792994d7952..34fdac51df96 100644 --- a/trunk/net/econet/af_econet.c +++ b/trunk/net/econet/af_econet.c @@ -31,7 +31,6 @@ #include #include #include -#include #include #include #include @@ -46,7 +45,7 @@ #include #include -static const struct proto_ops econet_ops; +static struct proto_ops econet_ops; static struct hlist_head econet_sklist; static DEFINE_RWLOCK(econet_lock); @@ -57,7 +56,7 @@ static struct net_device *net2dev_map[256]; #define EC_PORT_IP 0xd2 #ifdef CONFIG_ECONET_AUNUDP -static DEFINE_SPINLOCK(aun_queue_lock); +static spinlock_t aun_queue_lock; static struct socket *udpsock; #define AUN_PORT 0x8000 @@ -687,7 +686,7 @@ static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg break; default: - return -ENOIOCTLCMD; + return dev_ioctl(cmd, argp); } /*NOTREACHED*/ return 0; @@ -699,7 +698,7 @@ static struct net_proto_family econet_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops SOCKOPS_WRAPPED(econet_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(econet_ops) = { .family = PF_ECONET, .owner = THIS_MODULE, .release = econet_release, diff --git a/trunk/net/ethernet/eth.c b/trunk/net/ethernet/eth.c index 9f4dbeb59315..e24577367274 100644 --- a/trunk/net/ethernet/eth.c +++ b/trunk/net/ethernet/eth.c @@ -53,7 +53,6 @@ #include #include #include -#include #include #include #include @@ -252,7 +251,7 @@ static int eth_mac_addr(struct net_device *dev, void *p) static int eth_change_mtu(struct net_device *dev, int new_mtu) { - if (new_mtu < 68 || new_mtu > ETH_DATA_LEN) + if ((new_mtu < 68) || (new_mtu > 1500)) return -EINVAL; dev->mtu = new_mtu; return 0; @@ -273,7 +272,7 @@ void ether_setup(struct net_device *dev) dev->type = ARPHRD_ETHER; dev->hard_header_len = ETH_HLEN; - dev->mtu = ETH_DATA_LEN; + dev->mtu = 1500; /* eth_mtu */ dev->addr_len = ETH_ALEN; dev->tx_queue_len = 1000; /* Ethernet wants good queues */ dev->flags = IFF_BROADCAST|IFF_MULTICAST; diff --git a/trunk/net/ieee80211/ieee80211_rx.c b/trunk/net/ieee80211/ieee80211_rx.c index 4cc6f41c6930..03efaacbdb73 100644 --- a/trunk/net/ieee80211/ieee80211_rx.c +++ b/trunk/net/ieee80211/ieee80211_rx.c @@ -410,8 +410,9 @@ int ieee80211_rx(struct ieee80211_device *ieee, struct sk_buff *skb, return 1; } - if (is_multicast_ether_addr(hdr->addr1) - ? ieee->host_mc_decrypt : ieee->host_decrypt) { + if ((is_multicast_ether_addr(hdr->addr1) || + is_broadcast_ether_addr(hdr->addr2)) ? ieee->host_mc_decrypt : + ieee->host_decrypt) { int idx = 0; if (skb->len >= hdrlen + 3) idx = skb->data[hdrlen + 3] >> 6; diff --git a/trunk/net/ipv4/Kconfig b/trunk/net/ipv4/Kconfig index 011cca7ae02b..e55136ae09f4 100644 --- a/trunk/net/ipv4/Kconfig +++ b/trunk/net/ipv4/Kconfig @@ -456,14 +456,6 @@ config TCP_CONG_BIC increase provides TCP friendliness. See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/ -config TCP_CONG_CUBIC - tristate "CUBIC TCP" - default m - ---help--- - This is version 2.0 of BIC-TCP which uses a cubic growth function - among other techniques. - See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/cubic-paper.pdf - config TCP_CONG_WESTWOOD tristate "TCP Westwood+" default m diff --git a/trunk/net/ipv4/Makefile b/trunk/net/ipv4/Makefile index c54edd76de09..f0435d00db6b 100644 --- a/trunk/net/ipv4/Makefile +++ b/trunk/net/ipv4/Makefile @@ -34,7 +34,6 @@ obj-$(CONFIG_INET_DIAG) += inet_diag.o obj-$(CONFIG_IP_ROUTE_MULTIPATH_CACHED) += multipath.o obj-$(CONFIG_INET_TCP_DIAG) += tcp_diag.o obj-$(CONFIG_TCP_CONG_BIC) += tcp_bic.o -obj-$(CONFIG_TCP_CONG_CUBIC) += tcp_cubic.o obj-$(CONFIG_TCP_CONG_WESTWOOD) += tcp_westwood.o obj-$(CONFIG_TCP_CONG_HSTCP) += tcp_highspeed.o obj-$(CONFIG_TCP_CONG_HYBLA) += tcp_hybla.o diff --git a/trunk/net/ipv4/af_inet.c b/trunk/net/ipv4/af_inet.c index 966a071a408c..d368cf249000 100644 --- a/trunk/net/ipv4/af_inet.c +++ b/trunk/net/ipv4/af_inet.c @@ -93,7 +93,6 @@ #include #include #include -#include #include #include #include @@ -303,7 +302,6 @@ static int inet_create(struct socket *sock, int protocol) sk->sk_reuse = 1; inet = inet_sk(sk); - inet->is_icsk = INET_PROTOSW_ICSK & answer_flags; if (SOCK_RAW == sock->type) { inet->num = protocol; @@ -777,16 +775,16 @@ int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) err = devinet_ioctl(cmd, (void __user *)arg); break; default: - if (sk->sk_prot->ioctl) - err = sk->sk_prot->ioctl(sk, cmd, arg); - else - err = -ENOIOCTLCMD; + if (!sk->sk_prot->ioctl || + (err = sk->sk_prot->ioctl(sk, cmd, arg)) == + -ENOIOCTLCMD) + err = dev_ioctl(cmd, (void __user *)arg); break; } return err; } -const struct proto_ops inet_stream_ops = { +struct proto_ops inet_stream_ops = { .family = PF_INET, .owner = THIS_MODULE, .release = inet_release, @@ -807,7 +805,7 @@ const struct proto_ops inet_stream_ops = { .sendpage = tcp_sendpage }; -const struct proto_ops inet_dgram_ops = { +struct proto_ops inet_dgram_ops = { .family = PF_INET, .owner = THIS_MODULE, .release = inet_release, @@ -832,7 +830,7 @@ const struct proto_ops inet_dgram_ops = { * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without * udp_poll */ -static const struct proto_ops inet_sockraw_ops = { +static struct proto_ops inet_sockraw_ops = { .family = PF_INET, .owner = THIS_MODULE, .release = inet_release, @@ -871,8 +869,7 @@ static struct inet_protosw inetsw_array[] = .ops = &inet_stream_ops, .capability = -1, .no_check = 0, - .flags = INET_PROTOSW_PERMANENT | - INET_PROTOSW_ICSK, + .flags = INET_PROTOSW_PERMANENT, }, { diff --git a/trunk/net/ipv4/ah4.c b/trunk/net/ipv4/ah4.c index aed537fa2c88..035ad2c9e1ba 100644 --- a/trunk/net/ipv4/ah4.c +++ b/trunk/net/ipv4/ah4.c @@ -6,7 +6,6 @@ #include #include #include -#include #include diff --git a/trunk/net/ipv4/arp.c b/trunk/net/ipv4/arp.c index 37432088fe6d..b425748f02d7 100644 --- a/trunk/net/ipv4/arp.c +++ b/trunk/net/ipv4/arp.c @@ -86,7 +86,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/devinet.c b/trunk/net/ipv4/devinet.c index 7b9bb28e2ee9..04a6fe3e95a2 100644 --- a/trunk/net/ipv4/devinet.c +++ b/trunk/net/ipv4/devinet.c @@ -58,7 +58,6 @@ #endif #include -#include #include #include #include diff --git a/trunk/net/ipv4/esp4.c b/trunk/net/ipv4/esp4.c index 73bfcae8af9c..1b18ce66e7b7 100644 --- a/trunk/net/ipv4/esp4.c +++ b/trunk/net/ipv4/esp4.c @@ -9,7 +9,6 @@ #include #include #include -#include #include /* decapsulation data for use when post-processing */ diff --git a/trunk/net/ipv4/fib_frontend.c b/trunk/net/ipv4/fib_frontend.c index 18f5e509281a..19b1b984d687 100644 --- a/trunk/net/ipv4/fib_frontend.c +++ b/trunk/net/ipv4/fib_frontend.c @@ -30,7 +30,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/fib_hash.c b/trunk/net/ipv4/fib_hash.c index e2890ec8159e..7ea0209cb169 100644 --- a/trunk/net/ipv4/fib_hash.c +++ b/trunk/net/ipv4/fib_hash.c @@ -29,7 +29,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/fib_rules.c b/trunk/net/ipv4/fib_rules.c index 0dd4d06e456d..0b298bbc1518 100644 --- a/trunk/net/ipv4/fib_rules.c +++ b/trunk/net/ipv4/fib_rules.c @@ -33,7 +33,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/fib_semantics.c b/trunk/net/ipv4/fib_semantics.c index ef4724de7350..6d2a6ac070e3 100644 --- a/trunk/net/ipv4/fib_semantics.c +++ b/trunk/net/ipv4/fib_semantics.c @@ -29,7 +29,6 @@ #include #include #include -#include #include #include #include @@ -37,7 +36,6 @@ #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/fib_trie.c b/trunk/net/ipv4/fib_trie.c index e320b32373e5..705e3ce86df9 100644 --- a/trunk/net/ipv4/fib_trie.c +++ b/trunk/net/ipv4/fib_trie.c @@ -41,13 +41,6 @@ * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. - * - * Substantial contributions to this work comes from: - * - * David S. Miller, - * Stephen Hemminger - * Paul E. McKenney - * Patrick McHardy */ #define VERSION "0.404" @@ -66,7 +59,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/icmp.c b/trunk/net/ipv4/icmp.c index be5a519cd2f8..92e23b2ad4d2 100644 --- a/trunk/net/ipv4/icmp.c +++ b/trunk/net/ipv4/icmp.c @@ -73,7 +73,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/igmp.c b/trunk/net/ipv4/igmp.c index 34758118c10c..4a195c724f01 100644 --- a/trunk/net/ipv4/igmp.c +++ b/trunk/net/ipv4/igmp.c @@ -91,8 +91,6 @@ #include #include #include - -#include #include #include #include diff --git a/trunk/net/ipv4/inet_connection_sock.c b/trunk/net/ipv4/inet_connection_sock.c index ae20281d8deb..3fe021f1a566 100644 --- a/trunk/net/ipv4/inet_connection_sock.c +++ b/trunk/net/ipv4/inet_connection_sock.c @@ -37,8 +37,7 @@ EXPORT_SYMBOL(inet_csk_timer_bug_msg); */ int sysctl_local_port_range[2] = { 1024, 4999 }; -int inet_csk_bind_conflict(const struct sock *sk, - const struct inet_bind_bucket *tb) +static inline int inet_csk_bind_conflict(struct sock *sk, struct inet_bind_bucket *tb) { const u32 sk_rcv_saddr = inet_rcv_saddr(sk); struct sock *sk2; @@ -63,15 +62,11 @@ int inet_csk_bind_conflict(const struct sock *sk, return node != NULL; } -EXPORT_SYMBOL_GPL(inet_csk_bind_conflict); - /* Obtain a reference to a local port for the given sock, * if snum is zero it means select any available local port. */ int inet_csk_get_port(struct inet_hashinfo *hashinfo, - struct sock *sk, unsigned short snum, - int (*bind_conflict)(const struct sock *sk, - const struct inet_bind_bucket *tb)) + struct sock *sk, unsigned short snum) { struct inet_bind_hashbucket *head; struct hlist_node *node; @@ -130,7 +125,7 @@ int inet_csk_get_port(struct inet_hashinfo *hashinfo, goto success; } else { ret = 1; - if (bind_conflict(sk, tb)) + if (inet_csk_bind_conflict(sk, tb)) goto fail_unlock; } } @@ -385,7 +380,7 @@ struct request_sock *inet_csk_search_req(const struct sock *sk, EXPORT_SYMBOL_GPL(inet_csk_search_req); void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req, - unsigned long timeout) + const unsigned timeout) { struct inet_connection_sock *icsk = inet_csk(sk); struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt; @@ -636,15 +631,3 @@ void inet_csk_listen_stop(struct sock *sk) } EXPORT_SYMBOL_GPL(inet_csk_listen_stop); - -void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr) -{ - struct sockaddr_in *sin = (struct sockaddr_in *)uaddr; - const struct inet_sock *inet = inet_sk(sk); - - sin->sin_family = AF_INET; - sin->sin_addr.s_addr = inet->daddr; - sin->sin_port = inet->dport; -} - -EXPORT_SYMBOL_GPL(inet_csk_addr2sockaddr); diff --git a/trunk/net/ipv4/inet_diag.c b/trunk/net/ipv4/inet_diag.c index c49908192047..39061ed53cfd 100644 --- a/trunk/net/ipv4/inet_diag.c +++ b/trunk/net/ipv4/inet_diag.c @@ -112,12 +112,12 @@ static int inet_diag_fill(struct sk_buff *skb, struct sock *sk, r->idiag_inode = 0; #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) if (r->idiag_family == AF_INET6) { - const struct inet6_timewait_sock *tw6 = inet6_twsk(sk); + const struct tcp6_timewait_sock *tcp6tw = tcp6_twsk(sk); ipv6_addr_copy((struct in6_addr *)r->id.idiag_src, - &tw6->tw_v6_rcv_saddr); + &tcp6tw->tw_v6_rcv_saddr); ipv6_addr_copy((struct in6_addr *)r->id.idiag_dst, - &tw6->tw_v6_daddr); + &tcp6tw->tw_v6_daddr); } #endif nlh->nlmsg_len = skb->tail - b; @@ -489,9 +489,9 @@ static int inet_diag_fill_req(struct sk_buff *skb, struct sock *sk, #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) if (r->idiag_family == AF_INET6) { ipv6_addr_copy((struct in6_addr *)r->id.idiag_src, - &inet6_rsk(req)->loc_addr); + &tcp6_rsk(req)->loc_addr); ipv6_addr_copy((struct in6_addr *)r->id.idiag_dst, - &inet6_rsk(req)->rmt_addr); + &tcp6_rsk(req)->rmt_addr); } #endif nlh->nlmsg_len = skb->tail - b; @@ -553,13 +553,13 @@ static int inet_diag_dump_reqs(struct sk_buff *skb, struct sock *sk, entry.saddr = #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) (entry.family == AF_INET6) ? - inet6_rsk(req)->loc_addr.s6_addr32 : + tcp6_rsk(req)->loc_addr.s6_addr32 : #endif &ireq->loc_addr; entry.daddr = #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) (entry.family == AF_INET6) ? - inet6_rsk(req)->rmt_addr.s6_addr32 : + tcp6_rsk(req)->rmt_addr.s6_addr32 : #endif &ireq->rmt_addr; entry.dport = ntohs(ireq->rmt_port); diff --git a/trunk/net/ipv4/inet_hashtables.c b/trunk/net/ipv4/inet_hashtables.c index 33228115cda4..e8d29fe736d2 100644 --- a/trunk/net/ipv4/inet_hashtables.c +++ b/trunk/net/ipv4/inet_hashtables.c @@ -15,14 +15,12 @@ #include #include -#include #include #include #include #include #include -#include /* * Allocate and initialize a new local port bind bucket. @@ -165,179 +163,3 @@ struct sock *__inet_lookup_listener(const struct hlist_head *head, const u32 dad } EXPORT_SYMBOL_GPL(__inet_lookup_listener); - -/* called with local bh disabled */ -static int __inet_check_established(struct inet_timewait_death_row *death_row, - struct sock *sk, __u16 lport, - struct inet_timewait_sock **twp) -{ - struct inet_hashinfo *hinfo = death_row->hashinfo; - struct inet_sock *inet = inet_sk(sk); - u32 daddr = inet->rcv_saddr; - u32 saddr = inet->daddr; - int dif = sk->sk_bound_dev_if; - INET_ADDR_COOKIE(acookie, saddr, daddr) - const __u32 ports = INET_COMBINED_PORTS(inet->dport, lport); - unsigned int hash = inet_ehashfn(daddr, lport, saddr, inet->dport); - struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash); - struct sock *sk2; - const struct hlist_node *node; - struct inet_timewait_sock *tw; - - prefetch(head->chain.first); - write_lock(&head->lock); - - /* Check TIME-WAIT sockets first. */ - sk_for_each(sk2, node, &(head + hinfo->ehash_size)->chain) { - tw = inet_twsk(sk2); - - if (INET_TW_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif)) { - if (twsk_unique(sk, sk2, twp)) - goto unique; - else - goto not_unique; - } - } - tw = NULL; - - /* And established part... */ - sk_for_each(sk2, node, &head->chain) { - if (INET_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif)) - goto not_unique; - } - -unique: - /* Must record num and sport now. Otherwise we will see - * in hash table socket with a funny identity. */ - inet->num = lport; - inet->sport = htons(lport); - sk->sk_hash = hash; - BUG_TRAP(sk_unhashed(sk)); - __sk_add_node(sk, &head->chain); - sock_prot_inc_use(sk->sk_prot); - write_unlock(&head->lock); - - if (twp) { - *twp = tw; - NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); - } else if (tw) { - /* Silly. Should hash-dance instead... */ - inet_twsk_deschedule(tw, death_row); - NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); - - inet_twsk_put(tw); - } - - return 0; - -not_unique: - write_unlock(&head->lock); - return -EADDRNOTAVAIL; -} - -static inline u32 inet_sk_port_offset(const struct sock *sk) -{ - const struct inet_sock *inet = inet_sk(sk); - return secure_ipv4_port_ephemeral(inet->rcv_saddr, inet->daddr, - inet->dport); -} - -/* - * Bind a port for a connect operation and hash it. - */ -int inet_hash_connect(struct inet_timewait_death_row *death_row, - struct sock *sk) -{ - struct inet_hashinfo *hinfo = death_row->hashinfo; - const unsigned short snum = inet_sk(sk)->num; - struct inet_bind_hashbucket *head; - struct inet_bind_bucket *tb; - int ret; - - if (!snum) { - int low = sysctl_local_port_range[0]; - int high = sysctl_local_port_range[1]; - int range = high - low; - int i; - int port; - static u32 hint; - u32 offset = hint + inet_sk_port_offset(sk); - struct hlist_node *node; - struct inet_timewait_sock *tw = NULL; - - local_bh_disable(); - for (i = 1; i <= range; i++) { - port = low + (i + offset) % range; - head = &hinfo->bhash[inet_bhashfn(port, hinfo->bhash_size)]; - spin_lock(&head->lock); - - /* Does not bother with rcv_saddr checks, - * because the established check is already - * unique enough. - */ - inet_bind_bucket_for_each(tb, node, &head->chain) { - if (tb->port == port) { - BUG_TRAP(!hlist_empty(&tb->owners)); - if (tb->fastreuse >= 0) - goto next_port; - if (!__inet_check_established(death_row, - sk, port, - &tw)) - goto ok; - goto next_port; - } - } - - tb = inet_bind_bucket_create(hinfo->bind_bucket_cachep, head, port); - if (!tb) { - spin_unlock(&head->lock); - break; - } - tb->fastreuse = -1; - goto ok; - - next_port: - spin_unlock(&head->lock); - } - local_bh_enable(); - - return -EADDRNOTAVAIL; - -ok: - hint += i; - - /* Head lock still held and bh's disabled */ - inet_bind_hash(sk, tb, port); - if (sk_unhashed(sk)) { - inet_sk(sk)->sport = htons(port); - __inet_hash(hinfo, sk, 0); - } - spin_unlock(&head->lock); - - if (tw) { - inet_twsk_deschedule(tw, death_row);; - inet_twsk_put(tw); - } - - ret = 0; - goto out; - } - - head = &hinfo->bhash[inet_bhashfn(snum, hinfo->bhash_size)]; - tb = inet_csk(sk)->icsk_bind_hash; - spin_lock_bh(&head->lock); - if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) { - __inet_hash(hinfo, sk, 0); - spin_unlock_bh(&head->lock); - return 0; - } else { - spin_unlock(&head->lock); - /* No definite answer... Walk to established hash table */ - ret = __inet_check_established(death_row, sk, snum, NULL); -out: - local_bh_enable(); - return ret; - } -} - -EXPORT_SYMBOL_GPL(inet_hash_connect); diff --git a/trunk/net/ipv4/inet_timewait_sock.c b/trunk/net/ipv4/inet_timewait_sock.c index 417f126c749e..a010e9a68811 100644 --- a/trunk/net/ipv4/inet_timewait_sock.c +++ b/trunk/net/ipv4/inet_timewait_sock.c @@ -90,9 +90,8 @@ EXPORT_SYMBOL_GPL(__inet_twsk_hashdance); struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk, const int state) { - struct inet_timewait_sock *tw = - kmem_cache_alloc(sk->sk_prot_creator->twsk_prot->twsk_slab, - SLAB_ATOMIC); + struct inet_timewait_sock *tw = kmem_cache_alloc(sk->sk_prot_creator->twsk_slab, + SLAB_ATOMIC); if (tw != NULL) { const struct inet_sock *inet = inet_sk(sk); diff --git a/trunk/net/ipv4/inetpeer.c b/trunk/net/ipv4/inetpeer.c index ce5fe3f74a3d..2fc3fd38924f 100644 --- a/trunk/net/ipv4/inetpeer.c +++ b/trunk/net/ipv4/inetpeer.c @@ -401,7 +401,6 @@ struct inet_peer *inet_getpeer(__u32 daddr, int create) return NULL; n->v4daddr = daddr; atomic_set(&n->refcnt, 1); - atomic_set(&n->rid, 0); n->ip_id_count = secure_ip_id(daddr); n->tcp_ts_stamp = 0; diff --git a/trunk/net/ipv4/ip_fragment.c b/trunk/net/ipv4/ip_fragment.c index ce2b70ce4018..8ce0ce2ee48e 100644 --- a/trunk/net/ipv4/ip_fragment.c +++ b/trunk/net/ipv4/ip_fragment.c @@ -22,7 +22,6 @@ * Patrick McHardy : LRU queue of frag heads for evictor. */ -#include #include #include #include @@ -39,7 +38,6 @@ #include #include #include -#include #include #include #include @@ -58,8 +56,6 @@ int sysctl_ipfrag_high_thresh = 256*1024; int sysctl_ipfrag_low_thresh = 192*1024; -int sysctl_ipfrag_max_dist = 64; - /* Important NOTE! Fragment queue must be destroyed before MSL expires. * RFC791 is wrong proposing to prolongate timer each fragment arrival by TTL. */ @@ -93,10 +89,8 @@ struct ipq { spinlock_t lock; atomic_t refcnt; struct timer_list timer; /* when will this queue expire? */ + int iif; struct timeval stamp; - int iif; - unsigned int rid; - struct inet_peer *peer; }; /* Hash table. */ @@ -201,9 +195,6 @@ static void ip_frag_destroy(struct ipq *qp, int *work) BUG_TRAP(qp->last_in&COMPLETE); BUG_TRAP(del_timer(&qp->timer) == 0); - if (qp->peer) - inet_putpeer(qp->peer); - /* Release all fragment data. */ fp = qp->fragments; while (fp) { @@ -362,7 +353,6 @@ static struct ipq *ip_frag_create(unsigned hash, struct iphdr *iph, u32 user) qp->meat = 0; qp->fragments = NULL; qp->iif = 0; - qp->peer = sysctl_ipfrag_max_dist ? inet_getpeer(iph->saddr, 1) : NULL; /* Initialize a timer for this entry. */ init_timer(&qp->timer); @@ -408,56 +398,6 @@ static inline struct ipq *ip_find(struct iphdr *iph, u32 user) return ip_frag_create(hash, iph, user); } -/* Is the fragment too far ahead to be part of ipq? */ -static inline int ip_frag_too_far(struct ipq *qp) -{ - struct inet_peer *peer = qp->peer; - unsigned int max = sysctl_ipfrag_max_dist; - unsigned int start, end; - - int rc; - - if (!peer || !max) - return 0; - - start = qp->rid; - end = atomic_inc_return(&peer->rid); - qp->rid = end; - - rc = qp->fragments && (end - start) > max; - - if (rc) { - IP_INC_STATS_BH(IPSTATS_MIB_REASMFAILS); - } - - return rc; -} - -static int ip_frag_reinit(struct ipq *qp) -{ - struct sk_buff *fp; - - if (!mod_timer(&qp->timer, jiffies + sysctl_ipfrag_time)) { - atomic_inc(&qp->refcnt); - return -ETIMEDOUT; - } - - fp = qp->fragments; - do { - struct sk_buff *xp = fp->next; - frag_kfree_skb(fp, NULL); - fp = xp; - } while (fp); - - qp->last_in = 0; - qp->len = 0; - qp->meat = 0; - qp->fragments = NULL; - qp->iif = 0; - - return 0; -} - /* Add new segment to existing queue. */ static void ip_frag_queue(struct ipq *qp, struct sk_buff *skb) { @@ -468,12 +408,6 @@ static void ip_frag_queue(struct ipq *qp, struct sk_buff *skb) if (qp->last_in & COMPLETE) goto err; - if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) && - unlikely(ip_frag_too_far(qp)) && unlikely(ip_frag_reinit(qp))) { - ipq_kill(qp); - goto err; - } - offset = ntohs(skb->nh.iph->frag_off); flags = offset & ~IP_OFFSET; offset &= IP_OFFSET; diff --git a/trunk/net/ipv4/ip_gre.c b/trunk/net/ipv4/ip_gre.c index 912c42f57c79..46f9d9cf7a5f 100644 --- a/trunk/net/ipv4/ip_gre.c +++ b/trunk/net/ipv4/ip_gre.c @@ -28,7 +28,6 @@ #include #include #include -#include #include #include @@ -1141,7 +1140,7 @@ static void ipgre_tunnel_setup(struct net_device *dev) dev->type = ARPHRD_IPGRE; dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr) + 4; - dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4; + dev->mtu = 1500 - sizeof(struct iphdr) - 4; dev->flags = IFF_NOARP; dev->iflink = 0; dev->addr_len = 4; @@ -1153,7 +1152,7 @@ static int ipgre_tunnel_init(struct net_device *dev) struct ip_tunnel *tunnel; struct iphdr *iph; int hlen = LL_MAX_HEADER; - int mtu = ETH_DATA_LEN; + int mtu = 1500; int addend = sizeof(struct iphdr) + 4; tunnel = (struct ip_tunnel*)dev->priv; diff --git a/trunk/net/ipv4/ip_input.c b/trunk/net/ipv4/ip_input.c index e45846ae570b..473d0f2b2e0d 100644 --- a/trunk/net/ipv4/ip_input.c +++ b/trunk/net/ipv4/ip_input.c @@ -128,7 +128,6 @@ #include #include #include -#include #include #include diff --git a/trunk/net/ipv4/ip_options.c b/trunk/net/ipv4/ip_options.c index d3f6c468faf4..dbe12da8d8b3 100644 --- a/trunk/net/ipv4/ip_options.c +++ b/trunk/net/ipv4/ip_options.c @@ -22,7 +22,6 @@ #include #include #include -#include /* * Write options to IP header, record destination address to diff --git a/trunk/net/ipv4/ip_output.c b/trunk/net/ipv4/ip_output.c index 71da31818cfc..eba64e2bd397 100644 --- a/trunk/net/ipv4/ip_output.c +++ b/trunk/net/ipv4/ip_output.c @@ -202,11 +202,13 @@ static inline int ip_finish_output2(struct sk_buff *skb) static inline int ip_finish_output(struct sk_buff *skb) { - if (skb->len > dst_mtu(skb->dst) && - !(skb_shinfo(skb)->ufo_size || skb_shinfo(skb)->tso_size)) - return ip_fragment(skb, ip_finish_output2); - else - return ip_finish_output2(skb); + struct net_device *dev = skb->dst->dev; + + skb->dev = dev; + skb->protocol = htons(ETH_P_IP); + + return NF_HOOK(PF_INET, NF_IP_POST_ROUTING, skb, NULL, dev, + ip_finish_output2); } int ip_mc_output(struct sk_buff *skb) @@ -263,21 +265,21 @@ int ip_mc_output(struct sk_buff *skb) newskb->dev, ip_dev_loopback_xmit); } - return NF_HOOK(PF_INET, NF_IP_POST_ROUTING, skb, NULL, skb->dev, - ip_finish_output); + if (skb->len > dst_mtu(&rt->u.dst)) + return ip_fragment(skb, ip_finish_output); + else + return ip_finish_output(skb); } int ip_output(struct sk_buff *skb) { - struct net_device *dev = skb->dst->dev; - IP_INC_STATS(IPSTATS_MIB_OUTREQUESTS); - skb->dev = dev; - skb->protocol = htons(ETH_P_IP); - - return NF_HOOK(PF_INET, NF_IP_POST_ROUTING, skb, NULL, dev, - ip_finish_output); + if (skb->len > dst_mtu(skb->dst) && + !(skb_shinfo(skb)->ufo_size || skb_shinfo(skb)->tso_size)) + return ip_fragment(skb, ip_finish_output); + else + return ip_finish_output(skb); } int ip_queue_xmit(struct sk_buff *skb, int ipfragok) @@ -443,7 +445,6 @@ int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*)) hlen = iph->ihl * 4; mtu = dst_mtu(&rt->u.dst) - hlen; /* Size of data space */ - IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE; /* When frag_list is given, use it. First, check its validity: * some transformers could create wrong frag_list or break existing diff --git a/trunk/net/ipv4/ip_sockglue.c b/trunk/net/ipv4/ip_sockglue.c index 6986e11d65cc..4f2d87257309 100644 --- a/trunk/net/ipv4/ip_sockglue.c +++ b/trunk/net/ipv4/ip_sockglue.c @@ -25,12 +25,12 @@ #include #include #include -#include #include #include #include #include -#include +#include +#include #include #include #include @@ -427,8 +427,8 @@ int ip_setsockopt(struct sock *sk, int level, int optname, char __user *optval, err = ip_options_get_from_user(&opt, optval, optlen); if (err) break; - if (inet->is_icsk) { - struct inet_connection_sock *icsk = inet_csk(sk); + if (sk->sk_type == SOCK_STREAM) { + struct tcp_sock *tp = tcp_sk(sk); #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) if (sk->sk_family == PF_INET || (!((1 << sk->sk_state) & @@ -436,10 +436,10 @@ int ip_setsockopt(struct sock *sk, int level, int optname, char __user *optval, inet->daddr != LOOPBACK4_IPV6)) { #endif if (inet->opt) - icsk->icsk_ext_hdr_len -= inet->opt->optlen; + tp->ext_header_len -= inet->opt->optlen; if (opt) - icsk->icsk_ext_hdr_len += opt->optlen; - icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie); + tp->ext_header_len += opt->optlen; + tcp_sync_mss(sk, tp->pmtu_cookie); #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) } #endif diff --git a/trunk/net/ipv4/ipcomp.c b/trunk/net/ipv4/ipcomp.c index d64e2ec8da7b..fc718df17b40 100644 --- a/trunk/net/ipv4/ipcomp.c +++ b/trunk/net/ipv4/ipcomp.c @@ -28,7 +28,6 @@ #include #include #include -#include struct ipcomp_tfms { struct list_head list; diff --git a/trunk/net/ipv4/ipconfig.c b/trunk/net/ipv4/ipconfig.c index bb3613ec448c..e8674baaa8d9 100644 --- a/trunk/net/ipv4/ipconfig.c +++ b/trunk/net/ipv4/ipconfig.c @@ -42,7 +42,6 @@ #include #include #include -#include #include #include #include @@ -59,7 +58,6 @@ #include #include #include -#include #include #include diff --git a/trunk/net/ipv4/ipip.c b/trunk/net/ipv4/ipip.c index 35571cff81c6..c05c1df0bb04 100644 --- a/trunk/net/ipv4/ipip.c +++ b/trunk/net/ipv4/ipip.c @@ -108,7 +108,6 @@ #include #include #include -#include #include #include @@ -787,7 +786,7 @@ static void ipip_tunnel_setup(struct net_device *dev) dev->type = ARPHRD_TUNNEL; dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr); - dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr); + dev->mtu = 1500 - sizeof(struct iphdr); dev->flags = IFF_NOARP; dev->iflink = 0; dev->addr_len = 4; diff --git a/trunk/net/ipv4/ipmr.c b/trunk/net/ipv4/ipmr.c index 9a5c0ce7ff35..302b7eb507c9 100644 --- a/trunk/net/ipv4/ipmr.c +++ b/trunk/net/ipv4/ipmr.c @@ -49,11 +49,9 @@ #include #include #include -#include #include #include #include -#include #include #include #include @@ -194,7 +192,7 @@ static struct net_device_stats *reg_vif_get_stats(struct net_device *dev) static void reg_vif_setup(struct net_device *dev) { dev->type = ARPHRD_PIMREG; - dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8; + dev->mtu = 1500 - sizeof(struct iphdr) - 8; dev->flags = IFF_NOARP; dev->hard_start_xmit = reg_vif_xmit; dev->get_stats = reg_vif_get_stats; diff --git a/trunk/net/ipv4/ipvs/ip_vs_app.c b/trunk/net/ipv4/ipvs/ip_vs_app.c index 9b176a942ac5..d7eb680101c2 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_app.c +++ b/trunk/net/ipv4/ipvs/ip_vs_app.c @@ -224,6 +224,34 @@ void unregister_ip_vs_app(struct ip_vs_app *app) } +#if 0000 +/* + * Get reference to app by name (called from user context) + */ +struct ip_vs_app *ip_vs_app_get_by_name(char *appname) +{ + struct ip_vs_app *app, *a = NULL; + + down(&__ip_vs_app_mutex); + + list_for_each_entry(ent, &ip_vs_app_list, a_list) { + if (strcmp(app->name, appname)) + continue; + + /* softirq may call ip_vs_app_get too, so the caller + must disable softirq on the current CPU */ + if (ip_vs_app_get(app)) + a = app; + break; + } + + up(&__ip_vs_app_mutex); + + return a; +} +#endif + + /* * Bind ip_vs_conn to its ip_vs_app (called by cp constructor) */ diff --git a/trunk/net/ipv4/ipvs/ip_vs_conn.c b/trunk/net/ipv4/ipvs/ip_vs_conn.c index 87b83813cf2c..2a3a8c59c655 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_conn.c +++ b/trunk/net/ipv4/ipvs/ip_vs_conn.c @@ -24,11 +24,7 @@ * */ -#include -#include -#include #include -#include #include #include /* for proc_net_* */ #include @@ -223,7 +219,7 @@ struct ip_vs_conn *ip_vs_conn_in_get if (!cp && atomic_read(&ip_vs_conn_no_cport_cnt)) cp = __ip_vs_conn_in_get(protocol, s_addr, 0, d_addr, d_port); - IP_VS_DBG(9, "lookup/in %s %u.%u.%u.%u:%d->%u.%u.%u.%u:%d %s\n", + IP_VS_DBG(7, "lookup/in %s %u.%u.%u.%u:%d->%u.%u.%u.%u:%d %s\n", ip_vs_proto_name(protocol), NIPQUAD(s_addr), ntohs(s_port), NIPQUAD(d_addr), ntohs(d_port), @@ -258,7 +254,7 @@ struct ip_vs_conn *ip_vs_ct_in_get out: ct_read_unlock(hash); - IP_VS_DBG(9, "template lookup/in %s %u.%u.%u.%u:%d->%u.%u.%u.%u:%d %s\n", + IP_VS_DBG(7, "template lookup/in %s %u.%u.%u.%u:%d->%u.%u.%u.%u:%d %s\n", ip_vs_proto_name(protocol), NIPQUAD(s_addr), ntohs(s_port), NIPQUAD(d_addr), ntohs(d_port), @@ -299,7 +295,7 @@ struct ip_vs_conn *ip_vs_conn_out_get ct_read_unlock(hash); - IP_VS_DBG(9, "lookup/out %s %u.%u.%u.%u:%d->%u.%u.%u.%u:%d %s\n", + IP_VS_DBG(7, "lookup/out %s %u.%u.%u.%u:%d->%u.%u.%u.%u:%d %s\n", ip_vs_proto_name(protocol), NIPQUAD(s_addr), ntohs(s_port), NIPQUAD(d_addr), ntohs(d_port), @@ -395,9 +391,8 @@ ip_vs_bind_dest(struct ip_vs_conn *cp, struct ip_vs_dest *dest) cp->flags |= atomic_read(&dest->conn_flags); cp->dest = dest; - IP_VS_DBG(7, "Bind-dest %s c:%u.%u.%u.%u:%d v:%u.%u.%u.%u:%d " - "d:%u.%u.%u.%u:%d fwd:%c s:%u conn->flags:%X conn->refcnt:%d " - "dest->refcnt:%d\n", + IP_VS_DBG(9, "Bind-dest %s c:%u.%u.%u.%u:%d v:%u.%u.%u.%u:%d " + "d:%u.%u.%u.%u:%d fwd:%c s:%u flg:%X cnt:%d destcnt:%d\n", ip_vs_proto_name(cp->protocol), NIPQUAD(cp->caddr), ntohs(cp->cport), NIPQUAD(cp->vaddr), ntohs(cp->vport), @@ -435,9 +430,8 @@ static inline void ip_vs_unbind_dest(struct ip_vs_conn *cp) if (!dest) return; - IP_VS_DBG(7, "Unbind-dest %s c:%u.%u.%u.%u:%d v:%u.%u.%u.%u:%d " - "d:%u.%u.%u.%u:%d fwd:%c s:%u conn->flags:%X conn->refcnt:%d " - "dest->refcnt:%d\n", + IP_VS_DBG(9, "Unbind-dest %s c:%u.%u.%u.%u:%d v:%u.%u.%u.%u:%d " + "d:%u.%u.%u.%u:%d fwd:%c s:%u flg:%X cnt:%d destcnt:%d\n", ip_vs_proto_name(cp->protocol), NIPQUAD(cp->caddr), ntohs(cp->cport), NIPQUAD(cp->vaddr), ntohs(cp->vport), @@ -577,7 +571,7 @@ static void ip_vs_conn_expire(unsigned long data) ip_vs_conn_hash(cp); expire_later: - IP_VS_DBG(7, "delayed: conn->refcnt-1=%d conn->n_control=%d\n", + IP_VS_DBG(7, "delayed: refcnt-1=%d conn.n_control=%d\n", atomic_read(&cp->refcnt)-1, atomic_read(&cp->n_control)); diff --git a/trunk/net/ipv4/ipvs/ip_vs_core.c b/trunk/net/ipv4/ipvs/ip_vs_core.c index 3f47ad8e1cad..1a0843cd58a9 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_core.c +++ b/trunk/net/ipv4/ipvs/ip_vs_core.c @@ -426,7 +426,7 @@ ip_vs_schedule(struct ip_vs_service *svc, const struct sk_buff *skb) return NULL; IP_VS_DBG(6, "Schedule fwd:%c c:%u.%u.%u.%u:%u v:%u.%u.%u.%u:%u " - "d:%u.%u.%u.%u:%u conn->flags:%X conn->refcnt:%d\n", + "d:%u.%u.%u.%u:%u flg:%X cnt:%d\n", ip_vs_fwd_tag(cp), NIPQUAD(cp->caddr), ntohs(cp->cport), NIPQUAD(cp->vaddr), ntohs(cp->vport), @@ -532,8 +532,11 @@ static unsigned int ip_vs_post_routing(unsigned int hooknum, { if (!((*pskb)->ipvs_property)) return NF_ACCEPT; + /* The packet was sent from IPVS, exit this chain */ - return NF_STOP; + (*okfn)(*pskb); + + return NF_STOLEN; } u16 ip_vs_checksum_complete(struct sk_buff *skb, int offset) diff --git a/trunk/net/ipv4/ipvs/ip_vs_ctl.c b/trunk/net/ipv4/ipvs/ip_vs_ctl.c index c935c5086d33..9bdcf31b760e 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_ctl.c +++ b/trunk/net/ipv4/ipvs/ip_vs_ctl.c @@ -35,7 +35,6 @@ #include #include -#include #include #include @@ -448,7 +447,7 @@ ip_vs_service_get(__u32 fwmark, __u16 protocol, __u32 vaddr, __u16 vport) out: read_unlock(&__ip_vs_svc_lock); - IP_VS_DBG(9, "lookup service: fwm %u %s %u.%u.%u.%u:%u %s\n", + IP_VS_DBG(6, "lookup service: fwm %u %s %u.%u.%u.%u:%u %s\n", fwmark, ip_vs_proto_name(protocol), NIPQUAD(vaddr), ntohs(vport), svc?"hit":"not hit"); @@ -598,7 +597,7 @@ ip_vs_trash_get_dest(struct ip_vs_service *svc, __u32 daddr, __u16 dport) */ list_for_each_entry_safe(dest, nxt, &ip_vs_dest_trash, n_list) { IP_VS_DBG(3, "Destination %u/%u.%u.%u.%u:%u still in trash, " - "dest->refcnt=%d\n", + "refcnt=%d\n", dest->vfwmark, NIPQUAD(dest->addr), ntohs(dest->port), atomic_read(&dest->refcnt)); @@ -805,7 +804,7 @@ ip_vs_add_dest(struct ip_vs_service *svc, struct ip_vs_dest_user *udest) dest = ip_vs_trash_get_dest(svc, daddr, dport); if (dest != NULL) { IP_VS_DBG(3, "Get destination %u.%u.%u.%u:%u from trash, " - "dest->refcnt=%d, service %u/%u.%u.%u.%u:%u\n", + "refcnt=%d, service %u/%u.%u.%u.%u:%u\n", NIPQUAD(daddr), ntohs(dport), atomic_read(&dest->refcnt), dest->vfwmark, @@ -950,8 +949,7 @@ static void __ip_vs_del_dest(struct ip_vs_dest *dest) atomic_dec(&dest->svc->refcnt); kfree(dest); } else { - IP_VS_DBG(3, "Moving dest %u.%u.%u.%u:%u into trash, " - "dest->refcnt=%d\n", + IP_VS_DBG(3, "Moving dest %u.%u.%u.%u:%u into trash, refcnt=%d\n", NIPQUAD(dest->addr), ntohs(dest->port), atomic_read(&dest->refcnt)); list_add(&dest->n_list, &ip_vs_dest_trash); diff --git a/trunk/net/ipv4/ipvs/ip_vs_dh.c b/trunk/net/ipv4/ipvs/ip_vs_dh.c index 9fee19c4c617..f3bc320dce93 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_dh.c +++ b/trunk/net/ipv4/ipvs/ip_vs_dh.c @@ -37,10 +37,8 @@ * */ -#include #include #include -#include #include diff --git a/trunk/net/ipv4/ipvs/ip_vs_est.c b/trunk/net/ipv4/ipvs/ip_vs_est.c index c453e1e57f4b..67b3e2fc1fa1 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_est.c +++ b/trunk/net/ipv4/ipvs/ip_vs_est.c @@ -13,12 +13,8 @@ * Changes: * */ -#include #include -#include -#include #include -#include #include diff --git a/trunk/net/ipv4/ipvs/ip_vs_lblc.c b/trunk/net/ipv4/ipvs/ip_vs_lblc.c index 6e5cb92a5c83..561cda326fa8 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_lblc.c +++ b/trunk/net/ipv4/ipvs/ip_vs_lblc.c @@ -41,10 +41,8 @@ * me to write this module. */ -#include #include #include -#include /* for sysctl */ #include @@ -230,6 +228,33 @@ ip_vs_lblc_hash(struct ip_vs_lblc_table *tbl, struct ip_vs_lblc_entry *en) } +#if 0000 +/* + * Unhash ip_vs_lblc_entry from ip_vs_lblc_table. + * returns bool success. + */ +static int ip_vs_lblc_unhash(struct ip_vs_lblc_table *tbl, + struct ip_vs_lblc_entry *en) +{ + if (list_empty(&en->list)) { + IP_VS_ERR("ip_vs_lblc_unhash(): request for not hashed entry, " + "called from %p\n", __builtin_return_address(0)); + return 0; + } + + /* + * Remove it from the table + */ + write_lock(&tbl->lock); + list_del(&en->list); + INIT_LIST_HEAD(&en->list); + write_unlock(&tbl->lock); + + return 1; +} +#endif + + /* * Get ip_vs_lblc_entry associated with supplied parameters. */ diff --git a/trunk/net/ipv4/ipvs/ip_vs_lblcr.c b/trunk/net/ipv4/ipvs/ip_vs_lblcr.c index 32ba37ba72d8..ce456dbf09a5 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_lblcr.c +++ b/trunk/net/ipv4/ipvs/ip_vs_lblcr.c @@ -39,10 +39,8 @@ * */ -#include #include #include -#include /* for sysctl */ #include @@ -416,6 +414,33 @@ ip_vs_lblcr_hash(struct ip_vs_lblcr_table *tbl, struct ip_vs_lblcr_entry *en) } +#if 0000 +/* + * Unhash ip_vs_lblcr_entry from ip_vs_lblcr_table. + * returns bool success. + */ +static int ip_vs_lblcr_unhash(struct ip_vs_lblcr_table *tbl, + struct ip_vs_lblcr_entry *en) +{ + if (list_empty(&en->list)) { + IP_VS_ERR("ip_vs_lblcr_unhash(): request for not hashed entry, " + "called from %p\n", __builtin_return_address(0)); + return 0; + } + + /* + * Remove it from the table + */ + write_lock(&tbl->lock); + list_del(&en->list); + INIT_LIST_HEAD(&en->list); + write_unlock(&tbl->lock); + + return 1; +} +#endif + + /* * Get ip_vs_lblcr_entry associated with supplied parameters. */ diff --git a/trunk/net/ipv4/ipvs/ip_vs_proto_ah.c b/trunk/net/ipv4/ipvs/ip_vs_proto_ah.c index 8b0505b09317..453e94a0bbd7 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_proto_ah.c +++ b/trunk/net/ipv4/ipvs/ip_vs_proto_ah.c @@ -12,8 +12,6 @@ * */ -#include -#include #include #include #include diff --git a/trunk/net/ipv4/ipvs/ip_vs_proto_esp.c b/trunk/net/ipv4/ipvs/ip_vs_proto_esp.c index c36ccf057a19..478e5c7c7e8e 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_proto_esp.c +++ b/trunk/net/ipv4/ipvs/ip_vs_proto_esp.c @@ -12,8 +12,6 @@ * */ -#include -#include #include #include #include diff --git a/trunk/net/ipv4/ipvs/ip_vs_proto_tcp.c b/trunk/net/ipv4/ipvs/ip_vs_proto_tcp.c index bc28b1160a3a..0e878fd6215c 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_proto_tcp.c +++ b/trunk/net/ipv4/ipvs/ip_vs_proto_tcp.c @@ -275,6 +275,28 @@ static int tcp_timeouts[IP_VS_TCP_S_LAST+1] = { [IP_VS_TCP_S_LAST] = 2*HZ, }; + +#if 0 + +/* FIXME: This is going to die */ + +static int tcp_timeouts_dos[IP_VS_TCP_S_LAST+1] = { + [IP_VS_TCP_S_NONE] = 2*HZ, + [IP_VS_TCP_S_ESTABLISHED] = 8*60*HZ, + [IP_VS_TCP_S_SYN_SENT] = 60*HZ, + [IP_VS_TCP_S_SYN_RECV] = 10*HZ, + [IP_VS_TCP_S_FIN_WAIT] = 60*HZ, + [IP_VS_TCP_S_TIME_WAIT] = 60*HZ, + [IP_VS_TCP_S_CLOSE] = 10*HZ, + [IP_VS_TCP_S_CLOSE_WAIT] = 60*HZ, + [IP_VS_TCP_S_LAST_ACK] = 30*HZ, + [IP_VS_TCP_S_LISTEN] = 2*60*HZ, + [IP_VS_TCP_S_SYNACK] = 100*HZ, + [IP_VS_TCP_S_LAST] = 2*HZ, +}; + +#endif + static char * tcp_state_name_table[IP_VS_TCP_S_LAST+1] = { [IP_VS_TCP_S_NONE] = "NONE", [IP_VS_TCP_S_ESTABLISHED] = "ESTABLISHED", @@ -426,7 +448,7 @@ set_tcp_state(struct ip_vs_protocol *pp, struct ip_vs_conn *cp, struct ip_vs_dest *dest = cp->dest; IP_VS_DBG(8, "%s %s [%c%c%c%c] %u.%u.%u.%u:%d->" - "%u.%u.%u.%u:%d state: %s->%s conn->refcnt:%d\n", + "%u.%u.%u.%u:%d state: %s->%s cnt:%d\n", pp->name, (state_off==TCP_DIR_OUTPUT)?"output ":"input ", th->syn? 'S' : '.', diff --git a/trunk/net/ipv4/ipvs/ip_vs_proto_udp.c b/trunk/net/ipv4/ipvs/ip_vs_proto_udp.c index 89d9175d8f28..8ae5f2e0aefa 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_proto_udp.c +++ b/trunk/net/ipv4/ipvs/ip_vs_proto_udp.c @@ -15,11 +15,8 @@ * */ -#include -#include #include #include -#include #include diff --git a/trunk/net/ipv4/ipvs/ip_vs_sched.c b/trunk/net/ipv4/ipvs/ip_vs_sched.c index 8bc42b76223d..0f7c56a225bd 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_sched.c +++ b/trunk/net/ipv4/ipvs/ip_vs_sched.c @@ -22,7 +22,6 @@ #include #include #include -#include #include #include diff --git a/trunk/net/ipv4/ipvs/ip_vs_sh.c b/trunk/net/ipv4/ipvs/ip_vs_sh.c index 7775e6cc68be..6f7c50e44a39 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_sh.c +++ b/trunk/net/ipv4/ipvs/ip_vs_sh.c @@ -34,10 +34,8 @@ * */ -#include #include #include -#include #include diff --git a/trunk/net/ipv4/ipvs/ip_vs_sync.c b/trunk/net/ipv4/ipvs/ip_vs_sync.c index 1bca714bda3d..2e5ced3d8062 100644 --- a/trunk/net/ipv4/ipvs/ip_vs_sync.c +++ b/trunk/net/ipv4/ipvs/ip_vs_sync.c @@ -21,14 +21,12 @@ #include #include -#include #include #include #include #include #include #include /* for ip_mc_join_group */ -#include #include #include diff --git a/trunk/net/ipv4/netfilter/arp_tables.c b/trunk/net/ipv4/netfilter/arp_tables.c index bba156304695..3c2e9639bba6 100644 --- a/trunk/net/ipv4/netfilter/arp_tables.c +++ b/trunk/net/ipv4/netfilter/arp_tables.c @@ -68,14 +68,19 @@ struct arpt_table_info { unsigned int initial_entries; unsigned int hook_entry[NF_ARP_NUMHOOKS]; unsigned int underflow[NF_ARP_NUMHOOKS]; - void *entries[NR_CPUS]; + char entries[0] __attribute__((aligned(SMP_CACHE_BYTES))); }; static LIST_HEAD(arpt_target); static LIST_HEAD(arpt_tables); -#define SET_COUNTER(c,b,p) do { (c).bcnt = (b); (c).pcnt = (p); } while(0) #define ADD_COUNTER(c,b,p) do { (c).bcnt += (b); (c).pcnt += (p); } while(0) +#ifdef CONFIG_SMP +#define TABLE_OFFSET(t,p) (SMP_ALIGN((t)->size)*(p)) +#else +#define TABLE_OFFSET(t,p) 0 +#endif + static inline int arp_devaddr_compare(const struct arpt_devaddr_info *ap, char *hdr_addr, int len) { @@ -264,7 +269,9 @@ unsigned int arpt_do_table(struct sk_buff **pskb, outdev = out ? out->name : nulldevname; read_lock_bh(&table->lock); - table_base = (void *)table->private->entries[smp_processor_id()]; + table_base = (void *)table->private->entries + + TABLE_OFFSET(table->private, + smp_processor_id()); e = get_entry(table_base, table->private->hook_entry[hook]); back = get_entry(table_base, table->private->underflow[hook]); @@ -455,8 +462,7 @@ static inline int unconditional(const struct arpt_arp *arp) /* Figures out from what hook each rule can be called: returns 0 if * there are loops. Puts hook bitmask in comefrom. */ -static int mark_source_chains(struct arpt_table_info *newinfo, - unsigned int valid_hooks, void *entry0) +static int mark_source_chains(struct arpt_table_info *newinfo, unsigned int valid_hooks) { unsigned int hook; @@ -466,7 +472,7 @@ static int mark_source_chains(struct arpt_table_info *newinfo, for (hook = 0; hook < NF_ARP_NUMHOOKS; hook++) { unsigned int pos = newinfo->hook_entry[hook]; struct arpt_entry *e - = (struct arpt_entry *)(entry0 + pos); + = (struct arpt_entry *)(newinfo->entries + pos); if (!(valid_hooks & (1 << hook))) continue; @@ -508,13 +514,13 @@ static int mark_source_chains(struct arpt_table_info *newinfo, goto next; e = (struct arpt_entry *) - (entry0 + pos); + (newinfo->entries + pos); } while (oldpos == pos + e->next_offset); /* Move along one */ size = e->next_offset; e = (struct arpt_entry *) - (entry0 + pos + size); + (newinfo->entries + pos + size); e->counters.pcnt = pos; pos += size; } else { @@ -531,7 +537,7 @@ static int mark_source_chains(struct arpt_table_info *newinfo, newpos = pos + e->next_offset; } e = (struct arpt_entry *) - (entry0 + newpos); + (newinfo->entries + newpos); e->counters.pcnt = pos; pos = newpos; } @@ -683,7 +689,6 @@ static inline int cleanup_entry(struct arpt_entry *e, unsigned int *i) static int translate_table(const char *name, unsigned int valid_hooks, struct arpt_table_info *newinfo, - void *entry0, unsigned int size, unsigned int number, const unsigned int *hook_entries, @@ -705,11 +710,11 @@ static int translate_table(const char *name, i = 0; /* Walk through entries, checking offsets. */ - ret = ARPT_ENTRY_ITERATE(entry0, newinfo->size, + ret = ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, check_entry_size_and_hooks, newinfo, - entry0, - entry0 + size, + newinfo->entries, + newinfo->entries + size, hook_entries, underflows, &i); duprintf("translate_table: ARPT_ENTRY_ITERATE gives %d\n", ret); if (ret != 0) @@ -738,26 +743,29 @@ static int translate_table(const char *name, } } - if (!mark_source_chains(newinfo, valid_hooks, entry0)) { + if (!mark_source_chains(newinfo, valid_hooks)) { duprintf("Looping hook\n"); return -ELOOP; } /* Finally, each sanity check must pass */ i = 0; - ret = ARPT_ENTRY_ITERATE(entry0, newinfo->size, + ret = ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, check_entry, name, size, &i); if (ret != 0) { - ARPT_ENTRY_ITERATE(entry0, newinfo->size, + ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, cleanup_entry, &i); return ret; } /* And one copy for every other CPU */ for_each_cpu(i) { - if (newinfo->entries[i] && newinfo->entries[i] != entry0) - memcpy(newinfo->entries[i], entry0, newinfo->size); + if (i == 0) + continue; + memcpy(newinfo->entries + SMP_ALIGN(newinfo->size) * i, + newinfo->entries, + SMP_ALIGN(newinfo->size)); } return ret; @@ -799,42 +807,15 @@ static inline int add_entry_to_counter(const struct arpt_entry *e, return 0; } -static inline int set_entry_to_counter(const struct arpt_entry *e, - struct arpt_counters total[], - unsigned int *i) -{ - SET_COUNTER(total[*i], e->counters.bcnt, e->counters.pcnt); - - (*i)++; - return 0; -} - static void get_counters(const struct arpt_table_info *t, struct arpt_counters counters[]) { unsigned int cpu; unsigned int i; - unsigned int curcpu; - - /* Instead of clearing (by a previous call to memset()) - * the counters and using adds, we set the counters - * with data used by 'current' CPU - * We dont care about preemption here. - */ - curcpu = raw_smp_processor_id(); - - i = 0; - ARPT_ENTRY_ITERATE(t->entries[curcpu], - t->size, - set_entry_to_counter, - counters, - &i); for_each_cpu(cpu) { - if (cpu == curcpu) - continue; i = 0; - ARPT_ENTRY_ITERATE(t->entries[cpu], + ARPT_ENTRY_ITERATE(t->entries + TABLE_OFFSET(t, cpu), t->size, add_entry_to_counter, counters, @@ -850,7 +831,6 @@ static int copy_entries_to_user(unsigned int total_size, struct arpt_entry *e; struct arpt_counters *counters; int ret = 0; - void *loc_cpu_entry; /* We need atomic snapshot of counters: rest doesn't change * (other than comefrom, which userspace doesn't care @@ -863,13 +843,13 @@ static int copy_entries_to_user(unsigned int total_size, return -ENOMEM; /* First, sum counters... */ + memset(counters, 0, countersize); write_lock_bh(&table->lock); get_counters(table->private, counters); write_unlock_bh(&table->lock); - loc_cpu_entry = table->private->entries[raw_smp_processor_id()]; - /* ... then copy entire thing ... */ - if (copy_to_user(userptr, loc_cpu_entry, total_size) != 0) { + /* ... then copy entire thing from CPU 0... */ + if (copy_to_user(userptr, table->private->entries, total_size) != 0) { ret = -EFAULT; goto free_counters; } @@ -879,7 +859,7 @@ static int copy_entries_to_user(unsigned int total_size, for (off = 0, num = 0; off < total_size; off += e->next_offset, num++){ struct arpt_entry_target *t; - e = (struct arpt_entry *)(loc_cpu_entry + off); + e = (struct arpt_entry *)(table->private->entries + off); if (copy_to_user(userptr + off + offsetof(struct arpt_entry, counters), &counters[num], @@ -931,47 +911,6 @@ static int get_entries(const struct arpt_get_entries *entries, return ret; } -static void free_table_info(struct arpt_table_info *info) -{ - int cpu; - for_each_cpu(cpu) { - if (info->size <= PAGE_SIZE) - kfree(info->entries[cpu]); - else - vfree(info->entries[cpu]); - } - kfree(info); -} - -static struct arpt_table_info *alloc_table_info(unsigned int size) -{ - struct arpt_table_info *newinfo; - int cpu; - - newinfo = kzalloc(sizeof(struct arpt_table_info), GFP_KERNEL); - if (!newinfo) - return NULL; - - newinfo->size = size; - - for_each_cpu(cpu) { - if (size <= PAGE_SIZE) - newinfo->entries[cpu] = kmalloc_node(size, - GFP_KERNEL, - cpu_to_node(cpu)); - else - newinfo->entries[cpu] = vmalloc_node(size, - cpu_to_node(cpu)); - - if (newinfo->entries[cpu] == NULL) { - free_table_info(newinfo); - return NULL; - } - } - - return newinfo; -} - static int do_replace(void __user *user, unsigned int len) { int ret; @@ -979,7 +918,6 @@ static int do_replace(void __user *user, unsigned int len) struct arpt_table *t; struct arpt_table_info *newinfo, *oldinfo; struct arpt_counters *counters; - void *loc_cpu_entry, *loc_cpu_old_entry; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; @@ -992,13 +930,13 @@ static int do_replace(void __user *user, unsigned int len) if ((SMP_ALIGN(tmp.size) >> PAGE_SHIFT) + 2 > num_physpages) return -ENOMEM; - newinfo = alloc_table_info(tmp.size); + newinfo = vmalloc(sizeof(struct arpt_table_info) + + SMP_ALIGN(tmp.size) * + (highest_possible_processor_id()+1)); if (!newinfo) return -ENOMEM; - /* choose the copy that is on our node/cpu */ - loc_cpu_entry = newinfo->entries[raw_smp_processor_id()]; - if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + if (copy_from_user(newinfo->entries, user + sizeof(tmp), tmp.size) != 0) { ret = -EFAULT; goto free_newinfo; @@ -1009,9 +947,10 @@ static int do_replace(void __user *user, unsigned int len) ret = -ENOMEM; goto free_newinfo; } + memset(counters, 0, tmp.num_counters * sizeof(struct arpt_counters)); ret = translate_table(tmp.name, tmp.valid_hooks, - newinfo, loc_cpu_entry, tmp.size, tmp.num_entries, + newinfo, tmp.size, tmp.num_entries, tmp.hook_entry, tmp.underflow); if (ret != 0) goto free_newinfo_counters; @@ -1050,10 +989,8 @@ static int do_replace(void __user *user, unsigned int len) /* Get the old counters. */ get_counters(oldinfo, counters); /* Decrease module usage counts and free resource */ - loc_cpu_old_entry = oldinfo->entries[raw_smp_processor_id()]; - ARPT_ENTRY_ITERATE(loc_cpu_old_entry, oldinfo->size, cleanup_entry,NULL); - - free_table_info(oldinfo); + ARPT_ENTRY_ITERATE(oldinfo->entries, oldinfo->size, cleanup_entry,NULL); + vfree(oldinfo); if (copy_to_user(tmp.counters, counters, sizeof(struct arpt_counters) * tmp.num_counters) != 0) ret = -EFAULT; @@ -1065,11 +1002,11 @@ static int do_replace(void __user *user, unsigned int len) module_put(t->me); up(&arpt_mutex); free_newinfo_counters_untrans: - ARPT_ENTRY_ITERATE(loc_cpu_entry, newinfo->size, cleanup_entry, NULL); + ARPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, cleanup_entry, NULL); free_newinfo_counters: vfree(counters); free_newinfo: - free_table_info(newinfo); + vfree(newinfo); return ret; } @@ -1093,7 +1030,6 @@ static int do_add_counters(void __user *user, unsigned int len) struct arpt_counters_info tmp, *paddc; struct arpt_table *t; int ret = 0; - void *loc_cpu_entry; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; @@ -1123,9 +1059,7 @@ static int do_add_counters(void __user *user, unsigned int len) } i = 0; - /* Choose the copy that is on our node */ - loc_cpu_entry = t->private->entries[smp_processor_id()]; - ARPT_ENTRY_ITERATE(loc_cpu_entry, + ARPT_ENTRY_ITERATE(t->private->entries, t->private->size, add_counter_to_entry, paddc->counters, @@ -1286,32 +1220,30 @@ int arpt_register_table(struct arpt_table *table, struct arpt_table_info *newinfo; static struct arpt_table_info bootstrap = { 0, 0, 0, { 0 }, { 0 }, { } }; - void *loc_cpu_entry; - newinfo = alloc_table_info(repl->size); + newinfo = vmalloc(sizeof(struct arpt_table_info) + + SMP_ALIGN(repl->size) * + (highest_possible_processor_id()+1)); if (!newinfo) { ret = -ENOMEM; return ret; } - - /* choose the copy on our node/cpu */ - loc_cpu_entry = newinfo->entries[raw_smp_processor_id()]; - memcpy(loc_cpu_entry, repl->entries, repl->size); + memcpy(newinfo->entries, repl->entries, repl->size); ret = translate_table(table->name, table->valid_hooks, - newinfo, loc_cpu_entry, repl->size, + newinfo, repl->size, repl->num_entries, repl->hook_entry, repl->underflow); duprintf("arpt_register_table: translate table gives %d\n", ret); if (ret != 0) { - free_table_info(newinfo); + vfree(newinfo); return ret; } ret = down_interruptible(&arpt_mutex); if (ret != 0) { - free_table_info(newinfo); + vfree(newinfo); return ret; } @@ -1340,23 +1272,20 @@ int arpt_register_table(struct arpt_table *table, return ret; free_unlock: - free_table_info(newinfo); + vfree(newinfo); goto unlock; } void arpt_unregister_table(struct arpt_table *table) { - void *loc_cpu_entry; - down(&arpt_mutex); LIST_DELETE(&arpt_tables, table); up(&arpt_mutex); /* Decrease module usage counts and free resources */ - loc_cpu_entry = table->private->entries[raw_smp_processor_id()]; - ARPT_ENTRY_ITERATE(loc_cpu_entry, table->private->size, + ARPT_ENTRY_ITERATE(table->private->entries, table->private->size, cleanup_entry, NULL); - free_table_info(table->private); + vfree(table->private); } /* The built-in targets: standard (NULL) and error. */ diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_amanda.c b/trunk/net/ipv4/netfilter/ip_conntrack_amanda.c index 84e4f79b7ffa..e52847fa10f5 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_amanda.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_amanda.c @@ -18,13 +18,11 @@ * */ -#include #include #include #include #include #include -#include #include #include @@ -36,7 +34,7 @@ static unsigned int master_timeout = 300; MODULE_AUTHOR("Brian J. Murrell "); MODULE_DESCRIPTION("Amanda connection tracking module"); MODULE_LICENSE("GPL"); -module_param(master_timeout, uint, 0600); +module_param(master_timeout, int, 0600); MODULE_PARM_DESC(master_timeout, "timeout for the master connection"); static const char *conns[] = { "DATA ", "MESG ", "INDEX " }; diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_ftp.c b/trunk/net/ipv4/netfilter/ip_conntrack_ftp.c index e627e5856172..68b173bcda60 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_ftp.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_ftp.c @@ -34,7 +34,7 @@ static int ports_c; module_param_array(ports, ushort, &ports_c, 0400); static int loose; -module_param(loose, bool, 0600); +module_param(loose, int, 0600); unsigned int (*ip_nat_ftp_hook)(struct sk_buff **pskb, enum ip_conntrack_info ctinfo, diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_irc.c b/trunk/net/ipv4/netfilter/ip_conntrack_irc.c index c51a2cf71b4b..d7c40421d0d1 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_irc.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_irc.c @@ -36,7 +36,7 @@ #define MAX_PORTS 8 static unsigned short ports[MAX_PORTS]; static int ports_c; -static unsigned int max_dcc_channels = 8; +static int max_dcc_channels = 8; static unsigned int dcc_timeout = 300; /* This is slow, but it's simple. --RR */ static char *irc_buffer; @@ -54,9 +54,9 @@ MODULE_DESCRIPTION("IRC (DCC) connection tracking helper"); MODULE_LICENSE("GPL"); module_param_array(ports, ushort, &ports_c, 0400); MODULE_PARM_DESC(ports, "port numbers of IRC servers"); -module_param(max_dcc_channels, uint, 0400); +module_param(max_dcc_channels, int, 0400); MODULE_PARM_DESC(max_dcc_channels, "max number of expected DCC channels per IRC session"); -module_param(dcc_timeout, uint, 0400); +module_param(dcc_timeout, int, 0400); MODULE_PARM_DESC(dcc_timeout, "timeout on for unestablished DCC channels"); static const char *dccprotos[] = { "SEND ", "CHAT ", "MOVE ", "TSEND ", "SCHAT " }; @@ -254,6 +254,10 @@ static int __init init(void) printk("ip_conntrack_irc: max_dcc_channels must be a positive integer\n"); return -EBUSY; } + if (dcc_timeout < 0) { + printk("ip_conntrack_irc: dcc_timeout must be a positive integer\n"); + return -EBUSY; + } irc_buffer = kmalloc(65536, GFP_KERNEL); if (!irc_buffer) diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_netbios_ns.c b/trunk/net/ipv4/netfilter/ip_conntrack_netbios_ns.c index 4e68e16a2612..186646eb249f 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_netbios_ns.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_netbios_ns.c @@ -37,7 +37,7 @@ MODULE_DESCRIPTION("NetBIOS name service broadcast connection tracking helper"); MODULE_LICENSE("GPL"); static unsigned int timeout = 3; -module_param(timeout, uint, 0400); +module_param(timeout, int, 0600); MODULE_PARM_DESC(timeout, "timeout for master connection/replies in seconds"); static int help(struct sk_buff **pskb, diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_netlink.c b/trunk/net/ipv4/netfilter/ip_conntrack_netlink.c index c9ebbe0d2d9c..91fe8f2e38ff 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_netlink.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_netlink.c @@ -79,7 +79,6 @@ ctnetlink_dump_tuples(struct sk_buff *skb, const struct ip_conntrack_tuple *tuple) { struct nfattr *nest_parms; - int ret; nest_parms = NFA_NEST(skb, CTA_TUPLE_IP); NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(u_int32_t), &tuple->src.ip); @@ -87,10 +86,10 @@ ctnetlink_dump_tuples(struct sk_buff *skb, NFA_NEST_END(skb, nest_parms); nest_parms = NFA_NEST(skb, CTA_TUPLE_PROTO); - ret = ctnetlink_dump_tuples_proto(skb, tuple); + ctnetlink_dump_tuples_proto(skb, tuple); NFA_NEST_END(skb, nest_parms); - return ret; + return 0; nfattr_failure: return -1; @@ -161,7 +160,7 @@ ctnetlink_dump_helpinfo(struct sk_buff *skb, const struct ip_conntrack *ct) return 0; nest_helper = NFA_NEST(skb, CTA_HELP); - NFA_PUT(skb, CTA_HELP_NAME, strlen(ct->helper->name), ct->helper->name); + NFA_PUT(skb, CTA_HELP_NAME, CTA_HELP_MAXNAMESIZE, &ct->helper->name); if (ct->helper->to_nfattr) ct->helper->to_nfattr(skb, ct); @@ -230,7 +229,7 @@ ctnetlink_dump_id(struct sk_buff *skb, const struct ip_conntrack *ct) static inline int ctnetlink_dump_use(struct sk_buff *skb, const struct ip_conntrack *ct) { - u_int32_t use = htonl(atomic_read(&ct->ct_general.use)); + unsigned int use = htonl(atomic_read(&ct->ct_general.use)); NFA_PUT(skb, CTA_USE, sizeof(u_int32_t), &use); return 0; @@ -312,22 +311,29 @@ static int ctnetlink_conntrack_event(struct notifier_block *this, if (events & IPCT_DESTROY) { type = IPCTNL_MSG_CT_DELETE; group = NFNLGRP_CONNTRACK_DESTROY; - } else if (events & (IPCT_NEW | IPCT_RELATED)) { + goto alloc_skb; + } + if (events & (IPCT_NEW | IPCT_RELATED)) { type = IPCTNL_MSG_CT_NEW; flags = NLM_F_CREATE|NLM_F_EXCL; /* dump everything */ events = ~0UL; group = NFNLGRP_CONNTRACK_NEW; - } else if (events & (IPCT_STATUS | + goto alloc_skb; + } + if (events & (IPCT_STATUS | IPCT_PROTOINFO | IPCT_HELPER | IPCT_HELPINFO | IPCT_NATINFO)) { type = IPCTNL_MSG_CT_NEW; group = NFNLGRP_CONNTRACK_UPDATE; - } else - return NOTIFY_DONE; + goto alloc_skb; + } + return NOTIFY_DONE; + +alloc_skb: /* FIXME: Check if there are any listeners before, don't hurt performance */ skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC); @@ -1031,11 +1037,6 @@ ctnetlink_create_conntrack(struct nfattr *cda[], return err; } -#if defined(CONFIG_IP_NF_CONNTRACK_MARK) - if (cda[CTA_MARK-1]) - ct->mark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_MARK-1])); -#endif - ct->helper = ip_conntrack_helper_find_get(rtuple); add_timer(&ct->timeout); @@ -1044,6 +1045,11 @@ ctnetlink_create_conntrack(struct nfattr *cda[], if (ct->helper) ip_conntrack_helper_put(ct->helper); +#if defined(CONFIG_IP_NF_CONNTRACK_MARK) + if (cda[CTA_MARK-1]) + ct->mark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_MARK-1])); +#endif + DEBUGP("conntrack with id %u inserted\n", ct->id); return 0; @@ -1203,6 +1209,7 @@ static int ctnetlink_expect_event(struct notifier_block *this, unsigned int type; unsigned char *b; int flags = 0; + u16 proto; if (events & IPEXP_NEW) { type = IPCTNL_MSG_EXP_NEW; @@ -1229,6 +1236,7 @@ static int ctnetlink_expect_event(struct notifier_block *this, goto nfattr_failure; nlh->nlmsg_len = skb->tail - b; + proto = exp->tuple.dst.protonum; nfnetlink_send(skb, 0, NFNLGRP_CONNTRACK_EXP_NEW, 0); return NOTIFY_DONE; diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_proto_gre.c b/trunk/net/ipv4/netfilter/ip_conntrack_proto_gre.c index 57956dee60c8..744abb9d377a 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_proto_gre.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_proto_gre.c @@ -31,7 +31,6 @@ #include #include #include -#include static DEFINE_RWLOCK(ip_ct_gre_lock); #define ASSERT_READ_LOCK(x) diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_proto_icmp.c b/trunk/net/ipv4/netfilter/ip_conntrack_proto_icmp.c index 30fc21d6165a..5f9925db608e 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_proto_icmp.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_proto_icmp.c @@ -47,21 +47,20 @@ static int icmp_pkt_to_tuple(const struct sk_buff *skb, return 1; } -/* Add 1; spaces filled with 0. */ -static const u_int8_t invmap[] = { - [ICMP_ECHO] = ICMP_ECHOREPLY + 1, - [ICMP_ECHOREPLY] = ICMP_ECHO + 1, - [ICMP_TIMESTAMP] = ICMP_TIMESTAMPREPLY + 1, - [ICMP_TIMESTAMPREPLY] = ICMP_TIMESTAMP + 1, - [ICMP_INFO_REQUEST] = ICMP_INFO_REPLY + 1, - [ICMP_INFO_REPLY] = ICMP_INFO_REQUEST + 1, - [ICMP_ADDRESS] = ICMP_ADDRESSREPLY + 1, - [ICMP_ADDRESSREPLY] = ICMP_ADDRESS + 1 -}; - static int icmp_invert_tuple(struct ip_conntrack_tuple *tuple, const struct ip_conntrack_tuple *orig) { + /* Add 1; spaces filled with 0. */ + static const u_int8_t invmap[] + = { [ICMP_ECHO] = ICMP_ECHOREPLY + 1, + [ICMP_ECHOREPLY] = ICMP_ECHO + 1, + [ICMP_TIMESTAMP] = ICMP_TIMESTAMPREPLY + 1, + [ICMP_TIMESTAMPREPLY] = ICMP_TIMESTAMP + 1, + [ICMP_INFO_REQUEST] = ICMP_INFO_REPLY + 1, + [ICMP_INFO_REPLY] = ICMP_INFO_REQUEST + 1, + [ICMP_ADDRESS] = ICMP_ADDRESSREPLY + 1, + [ICMP_ADDRESSREPLY] = ICMP_ADDRESS + 1}; + if (orig->dst.u.icmp.type >= sizeof(invmap) || !invmap[orig->dst.u.icmp.type]) return 0; @@ -111,17 +110,17 @@ static int icmp_packet(struct ip_conntrack *ct, return NF_ACCEPT; } +static const u_int8_t valid_new[] = { + [ICMP_ECHO] = 1, + [ICMP_TIMESTAMP] = 1, + [ICMP_INFO_REQUEST] = 1, + [ICMP_ADDRESS] = 1 +}; + /* Called when a new connection for this protocol found. */ static int icmp_new(struct ip_conntrack *conntrack, const struct sk_buff *skb) { - static const u_int8_t valid_new[] = { - [ICMP_ECHO] = 1, - [ICMP_TIMESTAMP] = 1, - [ICMP_INFO_REQUEST] = 1, - [ICMP_ADDRESS] = 1 - }; - if (conntrack->tuplehash[0].tuple.dst.u.icmp.type >= sizeof(valid_new) || !valid_new[conntrack->tuplehash[0].tuple.dst.u.icmp.type]) { /* Can't create a new ICMP `conn' with this. */ @@ -280,6 +279,10 @@ static int icmp_tuple_to_nfattr(struct sk_buff *skb, NFA_PUT(skb, CTA_PROTO_ICMP_CODE, sizeof(u_int8_t), &t->dst.u.icmp.code); + if (t->dst.u.icmp.type >= sizeof(valid_new) + || !valid_new[t->dst.u.icmp.type]) + return -EINVAL; + return 0; nfattr_failure: @@ -292,7 +295,7 @@ static int icmp_nfattr_to_tuple(struct nfattr *tb[], if (!tb[CTA_PROTO_ICMP_TYPE-1] || !tb[CTA_PROTO_ICMP_CODE-1] || !tb[CTA_PROTO_ICMP_ID-1]) - return -EINVAL; + return -1; tuple->dst.u.icmp.type = *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_TYPE-1]); @@ -301,10 +304,6 @@ static int icmp_nfattr_to_tuple(struct nfattr *tb[], tuple->src.u.icmp.id = *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_ICMP_ID-1]); - if (tuple->dst.u.icmp.type >= sizeof(invmap) - || !invmap[tuple->dst.u.icmp.type]) - return -EINVAL; - return 0; } #endif diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_proto_udp.c b/trunk/net/ipv4/netfilter/ip_conntrack_proto_udp.c index 46becbe4fe58..f2dcac7c7660 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_proto_udp.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_proto_udp.c @@ -11,7 +11,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/netfilter/ip_conntrack_standalone.c b/trunk/net/ipv4/netfilter/ip_conntrack_standalone.c index 7ba97783e741..dd476b191f4b 100644 --- a/trunk/net/ipv4/netfilter/ip_conntrack_standalone.c +++ b/trunk/net/ipv4/netfilter/ip_conntrack_standalone.c @@ -27,7 +27,6 @@ #endif #include #include -#include #define ASSERT_READ_LOCK(x) #define ASSERT_WRITE_LOCK(x) @@ -451,6 +450,30 @@ static unsigned int ip_conntrack_defrag(unsigned int hooknum, return NF_ACCEPT; } +static unsigned int ip_refrag(unsigned int hooknum, + struct sk_buff **pskb, + const struct net_device *in, + const struct net_device *out, + int (*okfn)(struct sk_buff *)) +{ + struct rtable *rt = (struct rtable *)(*pskb)->dst; + + /* We've seen it coming out the other side: confirm */ + if (ip_confirm(hooknum, pskb, in, out, okfn) != NF_ACCEPT) + return NF_DROP; + + /* Local packets are never produced too large for their + interface. We degfragment them at LOCAL_OUT, however, + so we have to refragment them here. */ + if ((*pskb)->len > dst_mtu(&rt->u.dst) && + !skb_shinfo(*pskb)->tso_size) { + /* No hook can be after us, so this should be OK. */ + ip_fragment(*pskb, okfn); + return NF_STOLEN; + } + return NF_ACCEPT; +} + static unsigned int ip_conntrack_local(unsigned int hooknum, struct sk_buff **pskb, const struct net_device *in, @@ -520,7 +543,7 @@ static struct nf_hook_ops ip_conntrack_helper_in_ops = { /* Refragmenter; last chance. */ static struct nf_hook_ops ip_conntrack_out_ops = { - .hook = ip_confirm, + .hook = ip_refrag, .owner = THIS_MODULE, .pf = PF_INET, .hooknum = NF_IP_POST_ROUTING, diff --git a/trunk/net/ipv4/netfilter/ip_nat_snmp_basic.c b/trunk/net/ipv4/netfilter/ip_nat_snmp_basic.c index 4f95d477805c..8acb7ed40b47 100644 --- a/trunk/net/ipv4/netfilter/ip_nat_snmp_basic.c +++ b/trunk/net/ipv4/netfilter/ip_nat_snmp_basic.c @@ -44,7 +44,6 @@ * */ #include -#include #include #include #include @@ -54,7 +53,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/netfilter/ip_nat_standalone.c b/trunk/net/ipv4/netfilter/ip_nat_standalone.c index f04111f74e09..30cd4e18c129 100644 --- a/trunk/net/ipv4/netfilter/ip_nat_standalone.c +++ b/trunk/net/ipv4/netfilter/ip_nat_standalone.c @@ -190,6 +190,23 @@ ip_nat_out(unsigned int hooknum, || (*pskb)->nh.iph->ihl * 4 < sizeof(struct iphdr)) return NF_ACCEPT; + /* We can hit fragment here; forwarded packets get + defragmented by connection tracking coming in, then + fragmented (grr) by the forward code. + + In future: If we have nfct != NULL, AND we have NAT + initialized, AND there is no helper, then we can do full + NAPT on the head, and IP-address-only NAT on the rest. + + I'm starting to have nightmares about fragments. */ + + if ((*pskb)->nh.iph->frag_off & htons(IP_MF|IP_OFFSET)) { + *pskb = ip_ct_gather_frags(*pskb, IP_DEFRAG_NAT_OUT); + + if (!*pskb) + return NF_STOLEN; + } + return ip_nat_fn(hooknum, pskb, in, out, okfn); } diff --git a/trunk/net/ipv4/netfilter/ip_tables.c b/trunk/net/ipv4/netfilter/ip_tables.c index 2a26d167e149..45886c8475e8 100644 --- a/trunk/net/ipv4/netfilter/ip_tables.c +++ b/trunk/net/ipv4/netfilter/ip_tables.c @@ -83,6 +83,11 @@ static DECLARE_MUTEX(ipt_mutex); context stops packets coming through and allows user context to read the counters or update the rules. + To be cache friendly on SMP, we arrange them like so: + [ n-entries ] + ... cache-align padding ... + [ n-entries ] + Hence the start of any table is given by get_table() below. */ /* The table itself */ @@ -100,15 +105,20 @@ struct ipt_table_info unsigned int underflow[NF_IP_NUMHOOKS]; /* ipt_entry tables: one per CPU */ - void *entries[NR_CPUS]; + char entries[0] ____cacheline_aligned; }; static LIST_HEAD(ipt_target); static LIST_HEAD(ipt_match); static LIST_HEAD(ipt_tables); -#define SET_COUNTER(c,b,p) do { (c).bcnt = (b); (c).pcnt = (p); } while(0) #define ADD_COUNTER(c,b,p) do { (c).bcnt += (b); (c).pcnt += (p); } while(0) +#ifdef CONFIG_SMP +#define TABLE_OFFSET(t,p) (SMP_ALIGN((t)->size)*(p)) +#else +#define TABLE_OFFSET(t,p) 0 +#endif + #if 0 #define down(x) do { printk("DOWN:%u:" #x "\n", __LINE__); down(x); } while(0) #define down_interruptible(x) ({ int __r; printk("DOWNi:%u:" #x "\n", __LINE__); __r = down_interruptible(x); if (__r != 0) printk("ABORT-DOWNi:%u\n", __LINE__); __r; }) @@ -280,7 +290,8 @@ ipt_do_table(struct sk_buff **pskb, read_lock_bh(&table->lock); IP_NF_ASSERT(table->valid_hooks & (1 << hook)); - table_base = (void *)table->private->entries[smp_processor_id()]; + table_base = (void *)table->private->entries + + TABLE_OFFSET(table->private, smp_processor_id()); e = get_entry(table_base, table->private->hook_entry[hook]); #ifdef CONFIG_NETFILTER_DEBUG @@ -552,8 +563,7 @@ unconditional(const struct ipt_ip *ip) /* Figures out from what hook each rule can be called: returns 0 if there are loops. Puts hook bitmask in comefrom. */ static int -mark_source_chains(struct ipt_table_info *newinfo, - unsigned int valid_hooks, void *entry0) +mark_source_chains(struct ipt_table_info *newinfo, unsigned int valid_hooks) { unsigned int hook; @@ -562,7 +572,7 @@ mark_source_chains(struct ipt_table_info *newinfo, for (hook = 0; hook < NF_IP_NUMHOOKS; hook++) { unsigned int pos = newinfo->hook_entry[hook]; struct ipt_entry *e - = (struct ipt_entry *)(entry0 + pos); + = (struct ipt_entry *)(newinfo->entries + pos); if (!(valid_hooks & (1 << hook))) continue; @@ -612,13 +622,13 @@ mark_source_chains(struct ipt_table_info *newinfo, goto next; e = (struct ipt_entry *) - (entry0 + pos); + (newinfo->entries + pos); } while (oldpos == pos + e->next_offset); /* Move along one */ size = e->next_offset; e = (struct ipt_entry *) - (entry0 + pos + size); + (newinfo->entries + pos + size); e->counters.pcnt = pos; pos += size; } else { @@ -635,7 +645,7 @@ mark_source_chains(struct ipt_table_info *newinfo, newpos = pos + e->next_offset; } e = (struct ipt_entry *) - (entry0 + newpos); + (newinfo->entries + newpos); e->counters.pcnt = pos; pos = newpos; } @@ -845,7 +855,6 @@ static int translate_table(const char *name, unsigned int valid_hooks, struct ipt_table_info *newinfo, - void *entry0, unsigned int size, unsigned int number, const unsigned int *hook_entries, @@ -866,11 +875,11 @@ translate_table(const char *name, duprintf("translate_table: size %u\n", newinfo->size); i = 0; /* Walk through entries, checking offsets. */ - ret = IPT_ENTRY_ITERATE(entry0, newinfo->size, + ret = IPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, check_entry_size_and_hooks, newinfo, - entry0, - entry0 + size, + newinfo->entries, + newinfo->entries + size, hook_entries, underflows, &i); if (ret != 0) return ret; @@ -898,24 +907,27 @@ translate_table(const char *name, } } - if (!mark_source_chains(newinfo, valid_hooks, entry0)) + if (!mark_source_chains(newinfo, valid_hooks)) return -ELOOP; /* Finally, each sanity check must pass */ i = 0; - ret = IPT_ENTRY_ITERATE(entry0, newinfo->size, + ret = IPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, check_entry, name, size, &i); if (ret != 0) { - IPT_ENTRY_ITERATE(entry0, newinfo->size, + IPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, cleanup_entry, &i); return ret; } /* And one copy for every other CPU */ for_each_cpu(i) { - if (newinfo->entries[i] && newinfo->entries[i] != entry0) - memcpy(newinfo->entries[i], entry0, newinfo->size); + if (i == 0) + continue; + memcpy(newinfo->entries + SMP_ALIGN(newinfo->size) * i, + newinfo->entries, + SMP_ALIGN(newinfo->size)); } return ret; @@ -931,12 +943,15 @@ replace_table(struct ipt_table *table, #ifdef CONFIG_NETFILTER_DEBUG { - int cpu; + struct ipt_entry *table_base; + unsigned int i; - for_each_cpu(cpu) { - struct ipt_entry *table_base = newinfo->entries[cpu]; - if (table_base) - table_base->comefrom = 0xdead57ac; + for_each_cpu(i) { + table_base = + (void *)newinfo->entries + + TABLE_OFFSET(newinfo, i); + + table_base->comefrom = 0xdead57ac; } } #endif @@ -971,44 +986,16 @@ add_entry_to_counter(const struct ipt_entry *e, return 0; } -static inline int -set_entry_to_counter(const struct ipt_entry *e, - struct ipt_counters total[], - unsigned int *i) -{ - SET_COUNTER(total[*i], e->counters.bcnt, e->counters.pcnt); - - (*i)++; - return 0; -} - static void get_counters(const struct ipt_table_info *t, struct ipt_counters counters[]) { unsigned int cpu; unsigned int i; - unsigned int curcpu; - - /* Instead of clearing (by a previous call to memset()) - * the counters and using adds, we set the counters - * with data used by 'current' CPU - * We dont care about preemption here. - */ - curcpu = raw_smp_processor_id(); - - i = 0; - IPT_ENTRY_ITERATE(t->entries[curcpu], - t->size, - set_entry_to_counter, - counters, - &i); for_each_cpu(cpu) { - if (cpu == curcpu) - continue; i = 0; - IPT_ENTRY_ITERATE(t->entries[cpu], + IPT_ENTRY_ITERATE(t->entries + TABLE_OFFSET(t, cpu), t->size, add_entry_to_counter, counters, @@ -1025,29 +1012,24 @@ copy_entries_to_user(unsigned int total_size, struct ipt_entry *e; struct ipt_counters *counters; int ret = 0; - void *loc_cpu_entry; /* We need atomic snapshot of counters: rest doesn't change (other than comefrom, which userspace doesn't care about). */ countersize = sizeof(struct ipt_counters) * table->private->number; - counters = vmalloc_node(countersize, numa_node_id()); + counters = vmalloc(countersize); if (counters == NULL) return -ENOMEM; /* First, sum counters... */ + memset(counters, 0, countersize); write_lock_bh(&table->lock); get_counters(table->private, counters); write_unlock_bh(&table->lock); - /* choose the copy that is on our node/cpu, ... - * This choice is lazy (because current thread is - * allowed to migrate to another cpu) - */ - loc_cpu_entry = table->private->entries[raw_smp_processor_id()]; - /* ... then copy entire thing ... */ - if (copy_to_user(userptr, loc_cpu_entry, total_size) != 0) { + /* ... then copy entire thing from CPU 0... */ + if (copy_to_user(userptr, table->private->entries, total_size) != 0) { ret = -EFAULT; goto free_counters; } @@ -1059,7 +1041,7 @@ copy_entries_to_user(unsigned int total_size, struct ipt_entry_match *m; struct ipt_entry_target *t; - e = (struct ipt_entry *)(loc_cpu_entry + off); + e = (struct ipt_entry *)(table->private->entries + off); if (copy_to_user(userptr + off + offsetof(struct ipt_entry, counters), &counters[num], @@ -1128,45 +1110,6 @@ get_entries(const struct ipt_get_entries *entries, return ret; } -static void free_table_info(struct ipt_table_info *info) -{ - int cpu; - for_each_cpu(cpu) { - if (info->size <= PAGE_SIZE) - kfree(info->entries[cpu]); - else - vfree(info->entries[cpu]); - } - kfree(info); -} - -static struct ipt_table_info *alloc_table_info(unsigned int size) -{ - struct ipt_table_info *newinfo; - int cpu; - - newinfo = kzalloc(sizeof(struct ipt_table_info), GFP_KERNEL); - if (!newinfo) - return NULL; - - newinfo->size = size; - - for_each_cpu(cpu) { - if (size <= PAGE_SIZE) - newinfo->entries[cpu] = kmalloc_node(size, - GFP_KERNEL, - cpu_to_node(cpu)); - else - newinfo->entries[cpu] = vmalloc_node(size, cpu_to_node(cpu)); - if (newinfo->entries[cpu] == 0) { - free_table_info(newinfo); - return NULL; - } - } - - return newinfo; -} - static int do_replace(void __user *user, unsigned int len) { @@ -1175,7 +1118,6 @@ do_replace(void __user *user, unsigned int len) struct ipt_table *t; struct ipt_table_info *newinfo, *oldinfo; struct ipt_counters *counters; - void *loc_cpu_entry, *loc_cpu_old_entry; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; @@ -1188,13 +1130,13 @@ do_replace(void __user *user, unsigned int len) if ((SMP_ALIGN(tmp.size) >> PAGE_SHIFT) + 2 > num_physpages) return -ENOMEM; - newinfo = alloc_table_info(tmp.size); + newinfo = vmalloc(sizeof(struct ipt_table_info) + + SMP_ALIGN(tmp.size) * + (highest_possible_processor_id()+1)); if (!newinfo) return -ENOMEM; - /* choose the copy that is our node/cpu */ - loc_cpu_entry = newinfo->entries[raw_smp_processor_id()]; - if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + if (copy_from_user(newinfo->entries, user + sizeof(tmp), tmp.size) != 0) { ret = -EFAULT; goto free_newinfo; @@ -1205,9 +1147,10 @@ do_replace(void __user *user, unsigned int len) ret = -ENOMEM; goto free_newinfo; } + memset(counters, 0, tmp.num_counters * sizeof(struct ipt_counters)); ret = translate_table(tmp.name, tmp.valid_hooks, - newinfo, loc_cpu_entry, tmp.size, tmp.num_entries, + newinfo, tmp.size, tmp.num_entries, tmp.hook_entry, tmp.underflow); if (ret != 0) goto free_newinfo_counters; @@ -1246,9 +1189,8 @@ do_replace(void __user *user, unsigned int len) /* Get the old counters. */ get_counters(oldinfo, counters); /* Decrease module usage counts and free resource */ - loc_cpu_old_entry = oldinfo->entries[raw_smp_processor_id()]; - IPT_ENTRY_ITERATE(loc_cpu_old_entry, oldinfo->size, cleanup_entry,NULL); - free_table_info(oldinfo); + IPT_ENTRY_ITERATE(oldinfo->entries, oldinfo->size, cleanup_entry,NULL); + vfree(oldinfo); if (copy_to_user(tmp.counters, counters, sizeof(struct ipt_counters) * tmp.num_counters) != 0) ret = -EFAULT; @@ -1260,11 +1202,11 @@ do_replace(void __user *user, unsigned int len) module_put(t->me); up(&ipt_mutex); free_newinfo_counters_untrans: - IPT_ENTRY_ITERATE(loc_cpu_entry, newinfo->size, cleanup_entry,NULL); + IPT_ENTRY_ITERATE(newinfo->entries, newinfo->size, cleanup_entry,NULL); free_newinfo_counters: vfree(counters); free_newinfo: - free_table_info(newinfo); + vfree(newinfo); return ret; } @@ -1297,7 +1239,6 @@ do_add_counters(void __user *user, unsigned int len) struct ipt_counters_info tmp, *paddc; struct ipt_table *t; int ret = 0; - void *loc_cpu_entry; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; @@ -1305,7 +1246,7 @@ do_add_counters(void __user *user, unsigned int len) if (len != sizeof(tmp) + tmp.num_counters*sizeof(struct ipt_counters)) return -EINVAL; - paddc = vmalloc_node(len, numa_node_id()); + paddc = vmalloc(len); if (!paddc) return -ENOMEM; @@ -1327,9 +1268,7 @@ do_add_counters(void __user *user, unsigned int len) } i = 0; - /* Choose the copy that is on our node */ - loc_cpu_entry = t->private->entries[raw_smp_processor_id()]; - IPT_ENTRY_ITERATE(loc_cpu_entry, + IPT_ENTRY_ITERATE(t->private->entries, t->private->size, add_counter_to_entry, paddc->counters, @@ -1521,31 +1460,28 @@ int ipt_register_table(struct ipt_table *table, const struct ipt_replace *repl) struct ipt_table_info *newinfo; static struct ipt_table_info bootstrap = { 0, 0, 0, { 0 }, { 0 }, { } }; - void *loc_cpu_entry; - newinfo = alloc_table_info(repl->size); + newinfo = vmalloc(sizeof(struct ipt_table_info) + + SMP_ALIGN(repl->size) * + (highest_possible_processor_id()+1)); if (!newinfo) return -ENOMEM; - /* choose the copy on our node/cpu - * but dont care of preemption - */ - loc_cpu_entry = newinfo->entries[raw_smp_processor_id()]; - memcpy(loc_cpu_entry, repl->entries, repl->size); + memcpy(newinfo->entries, repl->entries, repl->size); ret = translate_table(table->name, table->valid_hooks, - newinfo, loc_cpu_entry, repl->size, + newinfo, repl->size, repl->num_entries, repl->hook_entry, repl->underflow); if (ret != 0) { - free_table_info(newinfo); + vfree(newinfo); return ret; } ret = down_interruptible(&ipt_mutex); if (ret != 0) { - free_table_info(newinfo); + vfree(newinfo); return ret; } @@ -1574,23 +1510,20 @@ int ipt_register_table(struct ipt_table *table, const struct ipt_replace *repl) return ret; free_unlock: - free_table_info(newinfo); + vfree(newinfo); goto unlock; } void ipt_unregister_table(struct ipt_table *table) { - void *loc_cpu_entry; - down(&ipt_mutex); LIST_DELETE(&ipt_tables, table); up(&ipt_mutex); /* Decrease module usage counts and free resources */ - loc_cpu_entry = table->private->entries[raw_smp_processor_id()]; - IPT_ENTRY_ITERATE(loc_cpu_entry, table->private->size, + IPT_ENTRY_ITERATE(table->private->entries, table->private->size, cleanup_entry, NULL); - free_table_info(table->private); + vfree(table->private); } /* Returns 1 if the port is matched by the range, 0 otherwise */ diff --git a/trunk/net/ipv4/netfilter/ipt_MASQUERADE.c b/trunk/net/ipv4/netfilter/ipt_MASQUERADE.c index 27860510ca6d..275a174c6fe6 100644 --- a/trunk/net/ipv4/netfilter/ipt_MASQUERADE.c +++ b/trunk/net/ipv4/netfilter/ipt_MASQUERADE.c @@ -11,7 +11,6 @@ #include #include -#include #include #include #include @@ -19,7 +18,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/netfilter/ipt_REJECT.c b/trunk/net/ipv4/netfilter/ipt_REJECT.c index 6693526ae128..f057025a719e 100644 --- a/trunk/net/ipv4/netfilter/ipt_REJECT.c +++ b/trunk/net/ipv4/netfilter/ipt_REJECT.c @@ -203,7 +203,7 @@ static void send_reset(struct sk_buff *oldskb, int hook) sizeof(struct tcphdr), 0)); /* Adjust IP TTL, DF */ - nskb->nh.iph->ttl = dst_metric(nskb->dst, RTAX_HOPLIMIT); + nskb->nh.iph->ttl = MAXTTL; /* Set DF, id = 0 */ nskb->nh.iph->frag_off = htons(IP_DF); nskb->nh.iph->id = 0; diff --git a/trunk/net/ipv4/netfilter/ipt_ULOG.c b/trunk/net/ipv4/netfilter/ipt_ULOG.c index 38641cd06123..2883ccd8a91d 100644 --- a/trunk/net/ipv4/netfilter/ipt_ULOG.c +++ b/trunk/net/ipv4/netfilter/ipt_ULOG.c @@ -77,15 +77,15 @@ MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_NFLOG); #define PRINTR(format, args...) do { if (net_ratelimit()) printk(format , ## args); } while (0) static unsigned int nlbufsiz = 4096; -module_param(nlbufsiz, uint, 0400); +module_param(nlbufsiz, uint, 0600); /* FIXME: Check size < 128k --RR */ MODULE_PARM_DESC(nlbufsiz, "netlink buffer size"); static unsigned int flushtimeout = 10; -module_param(flushtimeout, uint, 0600); +module_param(flushtimeout, int, 0600); MODULE_PARM_DESC(flushtimeout, "buffer flush timeout (hundredths of a second)"); -static int nflog = 1; -module_param(nflog, bool, 0400); +static unsigned int nflog = 1; +module_param(nflog, int, 0400); MODULE_PARM_DESC(nflog, "register as internal netfilter logging module"); /* global data structures */ @@ -376,7 +376,7 @@ static int __init init(void) DEBUGP("ipt_ULOG: init module\n"); - if (nlbufsiz > 128*1024) { + if (nlbufsiz >= 128*1024) { printk("Netlink buffer has to be <= 128kB\n"); return -EINVAL; } diff --git a/trunk/net/ipv4/netfilter/ipt_physdev.c b/trunk/net/ipv4/netfilter/ipt_physdev.c index 03f554857a4d..1a53924041fc 100644 --- a/trunk/net/ipv4/netfilter/ipt_physdev.c +++ b/trunk/net/ipv4/netfilter/ipt_physdev.c @@ -9,7 +9,6 @@ */ #include -#include #include #include #include diff --git a/trunk/net/ipv4/netfilter/ipt_recent.c b/trunk/net/ipv4/netfilter/ipt_recent.c index 5ddccb18c65e..261cbb4d4c49 100644 --- a/trunk/net/ipv4/netfilter/ipt_recent.c +++ b/trunk/net/ipv4/netfilter/ipt_recent.c @@ -24,10 +24,10 @@ #define HASH_LOG 9 /* Defaults, these can be overridden on the module command-line. */ -static unsigned int ip_list_tot = 100; -static unsigned int ip_pkt_list_tot = 20; -static unsigned int ip_list_hash_size = 0; -static unsigned int ip_list_perms = 0644; +static int ip_list_tot = 100; +static int ip_pkt_list_tot = 20; +static int ip_list_hash_size = 0; +static int ip_list_perms = 0644; #ifdef DEBUG static int debug = 1; #endif @@ -38,13 +38,13 @@ KERN_INFO RECENT_NAME " " RECENT_VER ": Stephen Frost . htt MODULE_AUTHOR("Stephen Frost "); MODULE_DESCRIPTION("IP tables recently seen matching module " RECENT_VER); MODULE_LICENSE("GPL"); -module_param(ip_list_tot, uint, 0400); -module_param(ip_pkt_list_tot, uint, 0400); -module_param(ip_list_hash_size, uint, 0400); -module_param(ip_list_perms, uint, 0400); +module_param(ip_list_tot, int, 0400); +module_param(ip_pkt_list_tot, int, 0400); +module_param(ip_list_hash_size, int, 0400); +module_param(ip_list_perms, int, 0400); #ifdef DEBUG -module_param(debug, bool, 0600); -MODULE_PARM_DESC(debug,"enable debugging output"); +module_param(debug, int, 0600); +MODULE_PARM_DESC(debug,"debugging level, defaults to 1"); #endif MODULE_PARM_DESC(ip_list_tot,"number of IPs to remember per list"); MODULE_PARM_DESC(ip_pkt_list_tot,"number of packets per IP to remember"); diff --git a/trunk/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c b/trunk/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c index 9bdbb7793971..8202c1c0afad 100644 --- a/trunk/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c +++ b/trunk/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c @@ -22,7 +22,6 @@ #include #include #include -#include #include #include @@ -181,6 +180,30 @@ static unsigned int ipv4_conntrack_defrag(unsigned int hooknum, return NF_ACCEPT; } +static unsigned int ipv4_refrag(unsigned int hooknum, + struct sk_buff **pskb, + const struct net_device *in, + const struct net_device *out, + int (*okfn)(struct sk_buff *)) +{ + struct rtable *rt = (struct rtable *)(*pskb)->dst; + + /* We've seen it coming out the other side: confirm */ + if (ipv4_confirm(hooknum, pskb, in, out, okfn) != NF_ACCEPT) + return NF_DROP; + + /* Local packets are never produced too large for their + interface. We degfragment them at LOCAL_OUT, however, + so we have to refragment them here. */ + if ((*pskb)->len > dst_mtu(&rt->u.dst) && + !skb_shinfo(*pskb)->tso_size) { + /* No hook can be after us, so this should be OK. */ + ip_fragment(*pskb, okfn); + return NF_STOLEN; + } + return NF_ACCEPT; +} + static unsigned int ipv4_conntrack_in(unsigned int hooknum, struct sk_buff **pskb, const struct net_device *in, @@ -260,7 +283,7 @@ static struct nf_hook_ops ipv4_conntrack_helper_in_ops = { /* Refragmenter; last chance. */ static struct nf_hook_ops ipv4_conntrack_out_ops = { - .hook = ipv4_confirm, + .hook = ipv4_refrag, .owner = THIS_MODULE, .pf = PF_INET, .hooknum = NF_IP_POST_ROUTING, @@ -369,48 +392,6 @@ getorigdst(struct sock *sk, int optval, void __user *user, int *len) return -ENOENT; } -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - -#include -#include - -static int ipv4_tuple_to_nfattr(struct sk_buff *skb, - const struct nf_conntrack_tuple *tuple) -{ - NFA_PUT(skb, CTA_IP_V4_SRC, sizeof(u_int32_t), - &tuple->src.u3.ip); - NFA_PUT(skb, CTA_IP_V4_DST, sizeof(u_int32_t), - &tuple->dst.u3.ip); - return 0; - -nfattr_failure: - return -1; -} - -static const size_t cta_min_ip[CTA_IP_MAX] = { - [CTA_IP_V4_SRC-1] = sizeof(u_int32_t), - [CTA_IP_V4_DST-1] = sizeof(u_int32_t), -}; - -static int ipv4_nfattr_to_tuple(struct nfattr *tb[], - struct nf_conntrack_tuple *t) -{ - if (!tb[CTA_IP_V4_SRC-1] || !tb[CTA_IP_V4_DST-1]) - return -EINVAL; - - if (nfattr_bad_size(tb, CTA_IP_MAX, cta_min_ip)) - return -EINVAL; - - t->src.u3.ip = - *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_SRC-1]); - t->dst.u3.ip = - *(u_int32_t *)NFA_DATA(tb[CTA_IP_V4_DST-1]); - - return 0; -} -#endif - static struct nf_sockopt_ops so_getorigdst = { .pf = PF_INET, .get_optmin = SO_ORIGINAL_DST, @@ -427,11 +408,6 @@ struct nf_conntrack_l3proto nf_conntrack_l3proto_ipv4 = { .print_conntrack = ipv4_print_conntrack, .prepare = ipv4_prepare, .get_features = ipv4_get_features, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .tuple_to_nfattr = ipv4_tuple_to_nfattr, - .nfattr_to_tuple = ipv4_nfattr_to_tuple, -#endif .me = THIS_MODULE, }; diff --git a/trunk/net/ipv4/netfilter/nf_conntrack_proto_icmp.c b/trunk/net/ipv4/netfilter/nf_conntrack_proto_icmp.c index 52dc175be39a..7ddb5c08f7b8 100644 --- a/trunk/net/ipv4/netfilter/nf_conntrack_proto_icmp.c +++ b/trunk/net/ipv4/netfilter/nf_conntrack_proto_icmp.c @@ -50,21 +50,20 @@ static int icmp_pkt_to_tuple(const struct sk_buff *skb, return 1; } -/* Add 1; spaces filled with 0. */ -static const u_int8_t invmap[] = { - [ICMP_ECHO] = ICMP_ECHOREPLY + 1, - [ICMP_ECHOREPLY] = ICMP_ECHO + 1, - [ICMP_TIMESTAMP] = ICMP_TIMESTAMPREPLY + 1, - [ICMP_TIMESTAMPREPLY] = ICMP_TIMESTAMP + 1, - [ICMP_INFO_REQUEST] = ICMP_INFO_REPLY + 1, - [ICMP_INFO_REPLY] = ICMP_INFO_REQUEST + 1, - [ICMP_ADDRESS] = ICMP_ADDRESSREPLY + 1, - [ICMP_ADDRESSREPLY] = ICMP_ADDRESS + 1 -}; - static int icmp_invert_tuple(struct nf_conntrack_tuple *tuple, const struct nf_conntrack_tuple *orig) { + /* Add 1; spaces filled with 0. */ + static u_int8_t invmap[] + = { [ICMP_ECHO] = ICMP_ECHOREPLY + 1, + [ICMP_ECHOREPLY] = ICMP_ECHO + 1, + [ICMP_TIMESTAMP] = ICMP_TIMESTAMPREPLY + 1, + [ICMP_TIMESTAMPREPLY] = ICMP_TIMESTAMP + 1, + [ICMP_INFO_REQUEST] = ICMP_INFO_REPLY + 1, + [ICMP_INFO_REPLY] = ICMP_INFO_REQUEST + 1, + [ICMP_ADDRESS] = ICMP_ADDRESSREPLY + 1, + [ICMP_ADDRESSREPLY] = ICMP_ADDRESS + 1}; + if (orig->dst.u.icmp.type >= sizeof(invmap) || !invmap[orig->dst.u.icmp.type]) return 0; @@ -121,12 +120,11 @@ static int icmp_packet(struct nf_conn *ct, static int icmp_new(struct nf_conn *conntrack, const struct sk_buff *skb, unsigned int dataoff) { - static const u_int8_t valid_new[] = { - [ICMP_ECHO] = 1, - [ICMP_TIMESTAMP] = 1, - [ICMP_INFO_REQUEST] = 1, - [ICMP_ADDRESS] = 1 - }; + static u_int8_t valid_new[] + = { [ICMP_ECHO] = 1, + [ICMP_TIMESTAMP] = 1, + [ICMP_INFO_REQUEST] = 1, + [ICMP_ADDRESS] = 1 }; if (conntrack->tuplehash[0].tuple.dst.u.icmp.type >= sizeof(valid_new) || !valid_new[conntrack->tuplehash[0].tuple.dst.u.icmp.type]) { @@ -170,7 +168,7 @@ icmp_error_message(struct sk_buff *skb, return -NF_ACCEPT; } - innerproto = __nf_ct_proto_find(PF_INET, inside->ip.protocol); + innerproto = nf_ct_find_proto(PF_INET, inside->ip.protocol); dataoff = skb->nh.iph->ihl*4 + sizeof(inside->icmp); /* Are they talking about one of our connections? */ if (!nf_ct_get_tuple(skb, dataoff, dataoff + inside->ip.ihl*4, PF_INET, @@ -283,60 +281,6 @@ icmp_error(struct sk_buff *skb, unsigned int dataoff, return icmp_error_message(skb, ctinfo, hooknum); } -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - -#include -#include - -static int icmp_tuple_to_nfattr(struct sk_buff *skb, - const struct nf_conntrack_tuple *t) -{ - NFA_PUT(skb, CTA_PROTO_ICMP_ID, sizeof(u_int16_t), - &t->src.u.icmp.id); - NFA_PUT(skb, CTA_PROTO_ICMP_TYPE, sizeof(u_int8_t), - &t->dst.u.icmp.type); - NFA_PUT(skb, CTA_PROTO_ICMP_CODE, sizeof(u_int8_t), - &t->dst.u.icmp.code); - - return 0; - -nfattr_failure: - return -1; -} - -static const size_t cta_min_proto[CTA_PROTO_MAX] = { - [CTA_PROTO_ICMP_TYPE-1] = sizeof(u_int8_t), - [CTA_PROTO_ICMP_CODE-1] = sizeof(u_int8_t), - [CTA_PROTO_ICMP_ID-1] = sizeof(u_int16_t) -}; - -static int icmp_nfattr_to_tuple(struct nfattr *tb[], - struct nf_conntrack_tuple *tuple) -{ - if (!tb[CTA_PROTO_ICMP_TYPE-1] - || !tb[CTA_PROTO_ICMP_CODE-1] - || !tb[CTA_PROTO_ICMP_ID-1]) - return -EINVAL; - - if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto)) - return -EINVAL; - - tuple->dst.u.icmp.type = - *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_TYPE-1]); - tuple->dst.u.icmp.code = - *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMP_CODE-1]); - tuple->src.u.icmp.id = - *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_ICMP_ID-1]); - - if (tuple->dst.u.icmp.type >= sizeof(invmap) - || !invmap[tuple->dst.u.icmp.type]) - return -EINVAL; - - return 0; -} -#endif - struct nf_conntrack_protocol nf_conntrack_protocol_icmp = { .list = { NULL, NULL }, @@ -351,12 +295,7 @@ struct nf_conntrack_protocol nf_conntrack_protocol_icmp = .new = icmp_new, .error = icmp_error, .destroy = NULL, - .me = NULL, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .tuple_to_nfattr = icmp_tuple_to_nfattr, - .nfattr_to_tuple = icmp_nfattr_to_tuple, -#endif + .me = NULL }; EXPORT_SYMBOL(nf_conntrack_protocol_icmp); diff --git a/trunk/net/ipv4/proc.c b/trunk/net/ipv4/proc.c index 39d49dc333a7..0d7dc668db46 100644 --- a/trunk/net/ipv4/proc.c +++ b/trunk/net/ipv4/proc.c @@ -38,7 +38,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv4/syncookies.c b/trunk/net/ipv4/syncookies.c index e20be3331f67..a34e60ea48a1 100644 --- a/trunk/net/ipv4/syncookies.c +++ b/trunk/net/ipv4/syncookies.c @@ -173,10 +173,10 @@ static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb, struct request_sock *req, struct dst_entry *dst) { - struct inet_connection_sock *icsk = inet_csk(sk); + struct tcp_sock *tp = tcp_sk(sk); struct sock *child; - child = icsk->icsk_af_ops->syn_recv_sock(sk, skb, req, dst); + child = tp->af_specific->syn_recv_sock(sk, skb, req, dst); if (child) inet_csk_reqsk_queue_add(sk, req, child); else diff --git a/trunk/net/ipv4/sysctl_net_ipv4.c b/trunk/net/ipv4/sysctl_net_ipv4.c index 16984d4a8a06..01444a02b48b 100644 --- a/trunk/net/ipv4/sysctl_net_ipv4.c +++ b/trunk/net/ipv4/sysctl_net_ipv4.c @@ -12,7 +12,6 @@ #include #include #include -#include #include #include #include @@ -23,7 +22,6 @@ extern int sysctl_ip_nonlocal_bind; #ifdef CONFIG_SYSCTL -static int zero; static int tcp_retr1_max = 255; static int ip_local_port_range_min[] = { 1, 1 }; static int ip_local_port_range_max[] = { 65535, 65535 }; @@ -615,15 +613,6 @@ ctl_table ipv4_table[] = { .proc_handler = &proc_dointvec_jiffies, .strategy = &sysctl_jiffies }, - { - .ctl_name = NET_IPV4_IPFRAG_MAX_DIST, - .procname = "ipfrag_max_dist", - .data = &sysctl_ipfrag_max_dist, - .maxlen = sizeof(int), - .mode = 0644, - .proc_handler = &proc_dointvec_minmax, - .extra1 = &zero - }, { .ctl_name = NET_TCP_NO_METRICS_SAVE, .procname = "tcp_no_metrics_save", diff --git a/trunk/net/ipv4/tcp.c b/trunk/net/ipv4/tcp.c index 00aa80e93243..ef98b14ac56d 100644 --- a/trunk/net/ipv4/tcp.c +++ b/trunk/net/ipv4/tcp.c @@ -1696,8 +1696,8 @@ int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval, int err = 0; if (level != SOL_TCP) - return icsk->icsk_af_ops->setsockopt(sk, level, optname, - optval, optlen); + return tp->af_specific->setsockopt(sk, level, optname, + optval, optlen); /* This is a string value all the others are int's */ if (optname == TCP_CONGESTION) { @@ -1914,7 +1914,7 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info) info->tcpi_last_data_recv = jiffies_to_msecs(now - icsk->icsk_ack.lrcvtime); info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp); - info->tcpi_pmtu = icsk->icsk_pmtu_cookie; + info->tcpi_pmtu = tp->pmtu_cookie; info->tcpi_rcv_ssthresh = tp->rcv_ssthresh; info->tcpi_rtt = jiffies_to_usecs(tp->srtt)>>3; info->tcpi_rttvar = jiffies_to_usecs(tp->mdev)>>2; @@ -1939,8 +1939,8 @@ int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval, int val, len; if (level != SOL_TCP) - return icsk->icsk_af_ops->getsockopt(sk, level, optname, - optval, optlen); + return tp->af_specific->getsockopt(sk, level, optname, + optval, optlen); if (get_user(len, optlen)) return -EFAULT; diff --git a/trunk/net/ipv4/tcp_bic.c b/trunk/net/ipv4/tcp_bic.c index 035f2092d73a..1d0cd86621b1 100644 --- a/trunk/net/ipv4/tcp_bic.c +++ b/trunk/net/ipv4/tcp_bic.c @@ -30,6 +30,8 @@ static int fast_convergence = 1; static int max_increment = 16; static int low_window = 14; static int beta = 819; /* = 819/1024 (BICTCP_BETA_SCALE) */ +static int low_utilization_threshold = 153; +static int low_utilization_period = 2; static int initial_ssthresh = 100; static int smooth_part = 20; @@ -41,6 +43,10 @@ module_param(low_window, int, 0644); MODULE_PARM_DESC(low_window, "lower bound on congestion window (for TCP friendliness)"); module_param(beta, int, 0644); MODULE_PARM_DESC(beta, "beta for multiplicative increase"); +module_param(low_utilization_threshold, int, 0644); +MODULE_PARM_DESC(low_utilization_threshold, "percent (scaled by 1024) for low utilization mode"); +module_param(low_utilization_period, int, 0644); +MODULE_PARM_DESC(low_utilization_period, "if average delay exceeds then goto to low utilization mode (seconds)"); module_param(initial_ssthresh, int, 0644); MODULE_PARM_DESC(initial_ssthresh, "initial value of slow start threshold"); module_param(smooth_part, int, 0644); @@ -54,6 +60,11 @@ struct bictcp { u32 loss_cwnd; /* congestion window at last loss */ u32 last_cwnd; /* the last snd_cwnd */ u32 last_time; /* time when updated last_cwnd */ + u32 delay_min; /* min delay */ + u32 delay_max; /* max delay */ + u32 last_delay; + u8 low_utilization;/* 0: high; 1: low */ + u32 low_utilization_start; /* starting time of low utilization detection*/ u32 epoch_start; /* beginning of an epoch */ #define ACK_RATIO_SHIFT 4 u32 delayed_ack; /* estimate the ratio of Packets/ACKs << 4 */ @@ -66,6 +77,11 @@ static inline void bictcp_reset(struct bictcp *ca) ca->loss_cwnd = 0; ca->last_cwnd = 0; ca->last_time = 0; + ca->delay_min = 0; + ca->delay_max = 0; + ca->last_delay = 0; + ca->low_utilization = 0; + ca->low_utilization_start = 0; ca->epoch_start = 0; ca->delayed_ack = 2 << ACK_RATIO_SHIFT; } @@ -127,7 +143,8 @@ static inline void bictcp_update(struct bictcp *ca, u32 cwnd) } /* if in slow start or link utilization is very low */ - if (ca->loss_cwnd == 0) { + if ( ca->loss_cwnd == 0 || + (cwnd > ca->loss_cwnd && ca->low_utilization)) { if (ca->cnt > 20) /* increase cwnd 5% per RTT */ ca->cnt = 20; } @@ -137,12 +154,69 @@ static inline void bictcp_update(struct bictcp *ca, u32 cwnd) ca->cnt = 1; } + +/* Detect low utilization in congestion avoidance */ +static inline void bictcp_low_utilization(struct sock *sk, int flag) +{ + const struct tcp_sock *tp = tcp_sk(sk); + struct bictcp *ca = inet_csk_ca(sk); + u32 dist, delay; + + /* No time stamp */ + if (!(tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr) || + /* Discard delay samples right after fast recovery */ + tcp_time_stamp < ca->epoch_start + HZ || + /* this delay samples may not be accurate */ + flag == 0) { + ca->last_delay = 0; + goto notlow; + } + + delay = ca->last_delay<<3; /* use the same scale as tp->srtt*/ + ca->last_delay = tcp_time_stamp - tp->rx_opt.rcv_tsecr; + if (delay == 0) /* no previous delay sample */ + goto notlow; + + /* first time call or link delay decreases */ + if (ca->delay_min == 0 || ca->delay_min > delay) { + ca->delay_min = ca->delay_max = delay; + goto notlow; + } + + if (ca->delay_max < delay) + ca->delay_max = delay; + + /* utilization is low, if avg delay < dist*threshold + for checking_period time */ + dist = ca->delay_max - ca->delay_min; + if (dist <= ca->delay_min>>6 || + tp->srtt - ca->delay_min >= (dist*low_utilization_threshold)>>10) + goto notlow; + + if (ca->low_utilization_start == 0) { + ca->low_utilization = 0; + ca->low_utilization_start = tcp_time_stamp; + } else if ((s32)(tcp_time_stamp - ca->low_utilization_start) + > low_utilization_period*HZ) { + ca->low_utilization = 1; + } + + return; + + notlow: + ca->low_utilization = 0; + ca->low_utilization_start = 0; + +} + static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 seq_rtt, u32 in_flight, int data_acked) { struct tcp_sock *tp = tcp_sk(sk); struct bictcp *ca = inet_csk_ca(sk); + bictcp_low_utilization(sk, data_acked); + if (!tcp_is_cwnd_limited(sk, in_flight)) return; @@ -175,6 +249,11 @@ static u32 bictcp_recalc_ssthresh(struct sock *sk) ca->epoch_start = 0; /* end of epoch */ + /* in case of wrong delay_max*/ + if (ca->delay_min > 0 && ca->delay_max > ca->delay_min) + ca->delay_max = ca->delay_min + + ((ca->delay_max - ca->delay_min)* 90) / 100; + /* Wmax and fast convergence */ if (tp->snd_cwnd < ca->last_max_cwnd && fast_convergence) ca->last_max_cwnd = (tp->snd_cwnd * (BICTCP_BETA_SCALE + beta)) @@ -210,14 +289,14 @@ static void bictcp_state(struct sock *sk, u8 new_state) bictcp_reset(inet_csk_ca(sk)); } -/* Track delayed acknowledgment ratio using sliding window +/* Track delayed acknowledgement ratio using sliding window * ratio = (15*ratio + sample) / 16 */ static void bictcp_acked(struct sock *sk, u32 cnt) { const struct inet_connection_sock *icsk = inet_csk(sk); - if (cnt > 0 && icsk->icsk_ca_state == TCP_CA_Open) { + if (cnt > 0 && icsk->icsk_ca_state == TCP_CA_Open) { struct bictcp *ca = inet_csk_ca(sk); cnt -= ca->delayed_ack >> ACK_RATIO_SHIFT; ca->delayed_ack += cnt; diff --git a/trunk/net/ipv4/tcp_cong.c b/trunk/net/ipv4/tcp_cong.c index e688c687d62d..c7cc62c8dc12 100644 --- a/trunk/net/ipv4/tcp_cong.c +++ b/trunk/net/ipv4/tcp_cong.c @@ -174,34 +174,6 @@ int tcp_set_congestion_control(struct sock *sk, const char *name) return err; } - -/* - * Linear increase during slow start - */ -void tcp_slow_start(struct tcp_sock *tp) -{ - if (sysctl_tcp_abc) { - /* RFC3465: Slow Start - * TCP sender SHOULD increase cwnd by the number of - * previously unacknowledged bytes ACKed by each incoming - * acknowledgment, provided the increase is not more than L - */ - if (tp->bytes_acked < tp->mss_cache) - return; - - /* We MAY increase by 2 if discovered delayed ack */ - if (sysctl_tcp_abc > 1 && tp->bytes_acked > 2*tp->mss_cache) { - if (tp->snd_cwnd < tp->snd_cwnd_clamp) - tp->snd_cwnd++; - } - } - tp->bytes_acked = 0; - - if (tp->snd_cwnd < tp->snd_cwnd_clamp) - tp->snd_cwnd++; -} -EXPORT_SYMBOL_GPL(tcp_slow_start); - /* * TCP Reno congestion control * This is special case used for fallback as well. diff --git a/trunk/net/ipv4/tcp_cubic.c b/trunk/net/ipv4/tcp_cubic.c deleted file mode 100644 index 31a4986dfbf7..000000000000 --- a/trunk/net/ipv4/tcp_cubic.c +++ /dev/null @@ -1,411 +0,0 @@ -/* - * TCP CUBIC: Binary Increase Congestion control for TCP v2.0 - * - * This is from the implementation of CUBIC TCP in - * Injong Rhee, Lisong Xu. - * "CUBIC: A New TCP-Friendly High-Speed TCP Variant - * in PFLDnet 2005 - * Available from: - * http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/cubic-paper.pdf - * - * Unless CUBIC is enabled and congestion window is large - * this behaves the same as the original Reno. - */ - -#include -#include -#include -#include -#include - -#define BICTCP_BETA_SCALE 1024 /* Scale factor beta calculation - * max_cwnd = snd_cwnd * beta - */ -#define BICTCP_B 4 /* - * In binary search, - * go to point (max+min)/N - */ -#define BICTCP_HZ 10 /* BIC HZ 2^10 = 1024 */ - -static int fast_convergence = 1; -static int max_increment = 16; -static int beta = 819; /* = 819/1024 (BICTCP_BETA_SCALE) */ -static int initial_ssthresh = 100; -static int bic_scale = 41; -static int tcp_friendliness = 1; - -static u32 cube_rtt_scale; -static u32 beta_scale; -static u64 cube_factor; - -/* Note parameters that are used for precomputing scale factors are read-only */ -module_param(fast_convergence, int, 0644); -MODULE_PARM_DESC(fast_convergence, "turn on/off fast convergence"); -module_param(max_increment, int, 0644); -MODULE_PARM_DESC(max_increment, "Limit on increment allowed during binary search"); -module_param(beta, int, 0444); -MODULE_PARM_DESC(beta, "beta for multiplicative increase"); -module_param(initial_ssthresh, int, 0644); -MODULE_PARM_DESC(initial_ssthresh, "initial value of slow start threshold"); -module_param(bic_scale, int, 0444); -MODULE_PARM_DESC(bic_scale, "scale (scaled by 1024) value for bic function (bic_scale/1024)"); -module_param(tcp_friendliness, int, 0644); -MODULE_PARM_DESC(tcp_friendliness, "turn on/off tcp friendliness"); - -#include - -/* BIC TCP Parameters */ -struct bictcp { - u32 cnt; /* increase cwnd by 1 after ACKs */ - u32 last_max_cwnd; /* last maximum snd_cwnd */ - u32 loss_cwnd; /* congestion window at last loss */ - u32 last_cwnd; /* the last snd_cwnd */ - u32 last_time; /* time when updated last_cwnd */ - u32 bic_origin_point;/* origin point of bic function */ - u32 bic_K; /* time to origin point from the beginning of the current epoch */ - u32 delay_min; /* min delay */ - u32 epoch_start; /* beginning of an epoch */ - u32 ack_cnt; /* number of acks */ - u32 tcp_cwnd; /* estimated tcp cwnd */ -#define ACK_RATIO_SHIFT 4 - u32 delayed_ack; /* estimate the ratio of Packets/ACKs << 4 */ -}; - -static inline void bictcp_reset(struct bictcp *ca) -{ - ca->cnt = 0; - ca->last_max_cwnd = 0; - ca->loss_cwnd = 0; - ca->last_cwnd = 0; - ca->last_time = 0; - ca->bic_origin_point = 0; - ca->bic_K = 0; - ca->delay_min = 0; - ca->epoch_start = 0; - ca->delayed_ack = 2 << ACK_RATIO_SHIFT; - ca->ack_cnt = 0; - ca->tcp_cwnd = 0; -} - -static void bictcp_init(struct sock *sk) -{ - bictcp_reset(inet_csk_ca(sk)); - if (initial_ssthresh) - tcp_sk(sk)->snd_ssthresh = initial_ssthresh; -} - -/* 64bit divisor, dividend and result. dynamic precision */ -static inline u_int64_t div64_64(u_int64_t dividend, u_int64_t divisor) -{ - u_int32_t d = divisor; - - if (divisor > 0xffffffffULL) { - unsigned int shift = fls(divisor >> 32); - - d = divisor >> shift; - dividend >>= shift; - } - - /* avoid 64 bit division if possible */ - if (dividend >> 32) - do_div(dividend, d); - else - dividend = (uint32_t) dividend / d; - - return dividend; -} - -/* - * calculate the cubic root of x using Newton-Raphson - */ -static u32 cubic_root(u64 a) -{ - u32 x, x1; - - /* Initial estimate is based on: - * cbrt(x) = exp(log(x) / 3) - */ - x = 1u << (fls64(a)/3); - - /* - * Iteration based on: - * 2 - * x = ( 2 * x + a / x ) / 3 - * k+1 k k - */ - do { - x1 = x; - x = (2 * x + (uint32_t) div64_64(a, x*x)) / 3; - } while (abs(x1 - x) > 1); - - return x; -} - -/* - * Compute congestion window to use. - */ -static inline void bictcp_update(struct bictcp *ca, u32 cwnd) -{ - u64 offs; - u32 delta, t, bic_target, min_cnt, max_cnt; - - ca->ack_cnt++; /* count the number of ACKs */ - - if (ca->last_cwnd == cwnd && - (s32)(tcp_time_stamp - ca->last_time) <= HZ / 32) - return; - - ca->last_cwnd = cwnd; - ca->last_time = tcp_time_stamp; - - if (ca->epoch_start == 0) { - ca->epoch_start = tcp_time_stamp; /* record the beginning of an epoch */ - ca->ack_cnt = 1; /* start counting */ - ca->tcp_cwnd = cwnd; /* syn with cubic */ - - if (ca->last_max_cwnd <= cwnd) { - ca->bic_K = 0; - ca->bic_origin_point = cwnd; - } else { - /* Compute new K based on - * (wmax-cwnd) * (srtt>>3 / HZ) / c * 2^(3*bictcp_HZ) - */ - ca->bic_K = cubic_root(cube_factor - * (ca->last_max_cwnd - cwnd)); - ca->bic_origin_point = ca->last_max_cwnd; - } - } - - /* cubic function - calc*/ - /* calculate c * time^3 / rtt, - * while considering overflow in calculation of time^3 - * (so time^3 is done by using 64 bit) - * and without the support of division of 64bit numbers - * (so all divisions are done by using 32 bit) - * also NOTE the unit of those veriables - * time = (t - K) / 2^bictcp_HZ - * c = bic_scale >> 10 - * rtt = (srtt >> 3) / HZ - * !!! The following code does not have overflow problems, - * if the cwnd < 1 million packets !!! - */ - - /* change the unit from HZ to bictcp_HZ */ - t = ((tcp_time_stamp + ca->delay_min - ca->epoch_start) - << BICTCP_HZ) / HZ; - - if (t < ca->bic_K) /* t - K */ - offs = ca->bic_K - t; - else - offs = t - ca->bic_K; - - /* c/rtt * (t-K)^3 */ - delta = (cube_rtt_scale * offs * offs * offs) >> (10+3*BICTCP_HZ); - if (t < ca->bic_K) /* below origin*/ - bic_target = ca->bic_origin_point - delta; - else /* above origin*/ - bic_target = ca->bic_origin_point + delta; - - /* cubic function - calc bictcp_cnt*/ - if (bic_target > cwnd) { - ca->cnt = cwnd / (bic_target - cwnd); - } else { - ca->cnt = 100 * cwnd; /* very small increment*/ - } - - if (ca->delay_min > 0) { - /* max increment = Smax * rtt / 0.1 */ - min_cnt = (cwnd * HZ * 8)/(10 * max_increment * ca->delay_min); - if (ca->cnt < min_cnt) - ca->cnt = min_cnt; - } - - /* slow start and low utilization */ - if (ca->loss_cwnd == 0) /* could be aggressive in slow start */ - ca->cnt = 50; - - /* TCP Friendly */ - if (tcp_friendliness) { - u32 scale = beta_scale; - delta = (cwnd * scale) >> 3; - while (ca->ack_cnt > delta) { /* update tcp cwnd */ - ca->ack_cnt -= delta; - ca->tcp_cwnd++; - } - - if (ca->tcp_cwnd > cwnd){ /* if bic is slower than tcp */ - delta = ca->tcp_cwnd - cwnd; - max_cnt = cwnd / delta; - if (ca->cnt > max_cnt) - ca->cnt = max_cnt; - } - } - - ca->cnt = (ca->cnt << ACK_RATIO_SHIFT) / ca->delayed_ack; - if (ca->cnt == 0) /* cannot be zero */ - ca->cnt = 1; -} - - -/* Keep track of minimum rtt */ -static inline void measure_delay(struct sock *sk) -{ - const struct tcp_sock *tp = tcp_sk(sk); - struct bictcp *ca = inet_csk_ca(sk); - u32 delay; - - /* No time stamp */ - if (!(tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr) || - /* Discard delay samples right after fast recovery */ - (s32)(tcp_time_stamp - ca->epoch_start) < HZ) - return; - - delay = tcp_time_stamp - tp->rx_opt.rcv_tsecr; - if (delay == 0) - delay = 1; - - /* first time call or link delay decreases */ - if (ca->delay_min == 0 || ca->delay_min > delay) - ca->delay_min = delay; -} - -static void bictcp_cong_avoid(struct sock *sk, u32 ack, - u32 seq_rtt, u32 in_flight, int data_acked) -{ - struct tcp_sock *tp = tcp_sk(sk); - struct bictcp *ca = inet_csk_ca(sk); - - if (data_acked) - measure_delay(sk); - - if (!tcp_is_cwnd_limited(sk, in_flight)) - return; - - if (tp->snd_cwnd <= tp->snd_ssthresh) - tcp_slow_start(tp); - else { - bictcp_update(ca, tp->snd_cwnd); - - /* In dangerous area, increase slowly. - * In theory this is tp->snd_cwnd += 1 / tp->snd_cwnd - */ - if (tp->snd_cwnd_cnt >= ca->cnt) { - if (tp->snd_cwnd < tp->snd_cwnd_clamp) - tp->snd_cwnd++; - tp->snd_cwnd_cnt = 0; - } else - tp->snd_cwnd_cnt++; - } - -} - -static u32 bictcp_recalc_ssthresh(struct sock *sk) -{ - const struct tcp_sock *tp = tcp_sk(sk); - struct bictcp *ca = inet_csk_ca(sk); - - ca->epoch_start = 0; /* end of epoch */ - - /* Wmax and fast convergence */ - if (tp->snd_cwnd < ca->last_max_cwnd && fast_convergence) - ca->last_max_cwnd = (tp->snd_cwnd * (BICTCP_BETA_SCALE + beta)) - / (2 * BICTCP_BETA_SCALE); - else - ca->last_max_cwnd = tp->snd_cwnd; - - ca->loss_cwnd = tp->snd_cwnd; - - return max((tp->snd_cwnd * beta) / BICTCP_BETA_SCALE, 2U); -} - -static u32 bictcp_undo_cwnd(struct sock *sk) -{ - struct bictcp *ca = inet_csk_ca(sk); - - return max(tcp_sk(sk)->snd_cwnd, ca->last_max_cwnd); -} - -static u32 bictcp_min_cwnd(struct sock *sk) -{ - return tcp_sk(sk)->snd_ssthresh; -} - -static void bictcp_state(struct sock *sk, u8 new_state) -{ - if (new_state == TCP_CA_Loss) - bictcp_reset(inet_csk_ca(sk)); -} - -/* Track delayed acknowledgment ratio using sliding window - * ratio = (15*ratio + sample) / 16 - */ -static void bictcp_acked(struct sock *sk, u32 cnt) -{ - const struct inet_connection_sock *icsk = inet_csk(sk); - - if (cnt > 0 && icsk->icsk_ca_state == TCP_CA_Open) { - struct bictcp *ca = inet_csk_ca(sk); - cnt -= ca->delayed_ack >> ACK_RATIO_SHIFT; - ca->delayed_ack += cnt; - } -} - - -static struct tcp_congestion_ops cubictcp = { - .init = bictcp_init, - .ssthresh = bictcp_recalc_ssthresh, - .cong_avoid = bictcp_cong_avoid, - .set_state = bictcp_state, - .undo_cwnd = bictcp_undo_cwnd, - .min_cwnd = bictcp_min_cwnd, - .pkts_acked = bictcp_acked, - .owner = THIS_MODULE, - .name = "cubic", -}; - -static int __init cubictcp_register(void) -{ - BUG_ON(sizeof(struct bictcp) > ICSK_CA_PRIV_SIZE); - - /* Precompute a bunch of the scaling factors that are used per-packet - * based on SRTT of 100ms - */ - - beta_scale = 8*(BICTCP_BETA_SCALE+beta)/ 3 / (BICTCP_BETA_SCALE - beta); - - cube_rtt_scale = (bic_scale << 3) / 10; /* 1024*c/rtt */ - - /* calculate the "K" for (wmax-cwnd) = c/rtt * K^3 - * so K = cubic_root( (wmax-cwnd)*rtt/c ) - * the unit of K is bictcp_HZ=2^10, not HZ - * - * c = bic_scale >> 10 - * rtt = 100ms - * - * the following code has been designed and tested for - * cwnd < 1 million packets - * RTT < 100 seconds - * HZ < 1,000,00 (corresponding to 10 nano-second) - */ - - /* 1/c * 2^2*bictcp_HZ * srtt */ - cube_factor = 1ull << (10+3*BICTCP_HZ); /* 2^40 */ - - /* divide by bic_scale and by constant Srtt (100ms) */ - do_div(cube_factor, bic_scale * 10); - - return tcp_register_congestion_control(&cubictcp); -} - -static void __exit cubictcp_unregister(void) -{ - tcp_unregister_congestion_control(&cubictcp); -} - -module_init(cubictcp_register); -module_exit(cubictcp_unregister); - -MODULE_AUTHOR("Sangtae Ha, Stephen Hemminger"); -MODULE_LICENSE("GPL"); -MODULE_DESCRIPTION("CUBIC TCP"); -MODULE_VERSION("2.0"); diff --git a/trunk/net/ipv4/tcp_input.c b/trunk/net/ipv4/tcp_input.c index 0a461232329f..bf2e23086bce 100644 --- a/trunk/net/ipv4/tcp_input.c +++ b/trunk/net/ipv4/tcp_input.c @@ -115,8 +115,8 @@ int sysctl_tcp_abc = 1; /* Adapt the MSS value used to make delayed ack decision to the * real world. */ -static void tcp_measure_rcv_mss(struct sock *sk, - const struct sk_buff *skb) +static inline void tcp_measure_rcv_mss(struct sock *sk, + const struct sk_buff *skb) { struct inet_connection_sock *icsk = inet_csk(sk); const unsigned int lss = icsk->icsk_ack.last_seg_size; @@ -246,8 +246,8 @@ static int __tcp_grow_window(const struct sock *sk, struct tcp_sock *tp, return 0; } -static void tcp_grow_window(struct sock *sk, struct tcp_sock *tp, - struct sk_buff *skb) +static inline void tcp_grow_window(struct sock *sk, struct tcp_sock *tp, + struct sk_buff *skb) { /* Check #1 */ if (tp->rcv_ssthresh < tp->window_clamp && @@ -341,26 +341,6 @@ static void tcp_clamp_window(struct sock *sk, struct tcp_sock *tp) tp->rcv_ssthresh = min(tp->window_clamp, 2U*tp->advmss); } - -/* Initialize RCV_MSS value. - * RCV_MSS is an our guess about MSS used by the peer. - * We haven't any direct information about the MSS. - * It's better to underestimate the RCV_MSS rather than overestimate. - * Overestimations make us ACKing less frequently than needed. - * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss(). - */ -void tcp_initialize_rcv_mss(struct sock *sk) -{ - struct tcp_sock *tp = tcp_sk(sk); - unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache); - - hint = min(hint, tp->rcv_wnd/2); - hint = min(hint, TCP_MIN_RCVMSS); - hint = max(hint, TCP_MIN_MSS); - - inet_csk(sk)->icsk_ack.rcv_mss = hint; -} - /* Receiver "autotuning" code. * * The algorithm for RTT estimation w/o timestamps is based on @@ -755,27 +735,6 @@ __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst) return min_t(__u32, cwnd, tp->snd_cwnd_clamp); } -/* Set slow start threshold and cwnd not falling to slow start */ -void tcp_enter_cwr(struct sock *sk) -{ - struct tcp_sock *tp = tcp_sk(sk); - - tp->prior_ssthresh = 0; - tp->bytes_acked = 0; - if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) { - tp->undo_marker = 0; - tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk); - tp->snd_cwnd = min(tp->snd_cwnd, - tcp_packets_in_flight(tp) + 1U); - tp->snd_cwnd_cnt = 0; - tp->high_seq = tp->snd_nxt; - tp->snd_cwnd_stamp = tcp_time_stamp; - TCP_ECN_queue_cwr(tp); - - tcp_set_ca_state(sk, TCP_CA_CWR); - } -} - /* Initialize metrics on socket. */ static void tcp_init_metrics(struct sock *sk) @@ -2111,8 +2070,8 @@ static inline void tcp_ack_update_rtt(struct sock *sk, const int flag, tcp_ack_no_tstamp(sk, seq_rtt, flag); } -static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 rtt, - u32 in_flight, int good) +static inline void tcp_cong_avoid(struct sock *sk, u32 ack, u32 rtt, + u32 in_flight, int good) { const struct inet_connection_sock *icsk = inet_csk(sk); icsk->icsk_ca_ops->cong_avoid(sk, ack, rtt, in_flight, good); @@ -2123,7 +2082,7 @@ static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 rtt, * RFC2988 recommends to restart timer to now+rto. */ -static void tcp_ack_packets_out(struct sock *sk, struct tcp_sock *tp) +static inline void tcp_ack_packets_out(struct sock *sk, struct tcp_sock *tp) { if (!tp->packets_out) { inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS); @@ -2188,7 +2147,7 @@ static int tcp_tso_acked(struct sock *sk, struct sk_buff *skb, return acked; } -static u32 tcp_usrtt(const struct sk_buff *skb) +static inline u32 tcp_usrtt(const struct sk_buff *skb) { struct timeval tv, now; @@ -2383,7 +2342,7 @@ static int tcp_ack_update_window(struct sock *sk, struct tcp_sock *tp, if (nwin > tp->max_window) { tp->max_window = nwin; - tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie); + tcp_sync_mss(sk, tp->pmtu_cookie); } } } @@ -2624,8 +2583,8 @@ void tcp_parse_options(struct sk_buff *skb, struct tcp_options_received *opt_rx, /* Fast parse options. This hopes to only see timestamps. * If it is wrong it falls back on tcp_parse_options(). */ -static int tcp_fast_parse_options(struct sk_buff *skb, struct tcphdr *th, - struct tcp_sock *tp) +static inline int tcp_fast_parse_options(struct sk_buff *skb, struct tcphdr *th, + struct tcp_sock *tp) { if (th->doff == sizeof(struct tcphdr)>>2) { tp->rx_opt.saw_tstamp = 0; @@ -2845,7 +2804,8 @@ static void tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th) } } -static inline int tcp_sack_extend(struct tcp_sack_block *sp, u32 seq, u32 end_seq) +static __inline__ int +tcp_sack_extend(struct tcp_sack_block *sp, u32 seq, u32 end_seq) { if (!after(seq, sp->end_seq) && !after(sp->start_seq, end_seq)) { if (before(seq, sp->start_seq)) @@ -2857,7 +2817,7 @@ static inline int tcp_sack_extend(struct tcp_sack_block *sp, u32 seq, u32 end_se return 0; } -static void tcp_dsack_set(struct tcp_sock *tp, u32 seq, u32 end_seq) +static inline void tcp_dsack_set(struct tcp_sock *tp, u32 seq, u32 end_seq) { if (tp->rx_opt.sack_ok && sysctl_tcp_dsack) { if (before(seq, tp->rcv_nxt)) @@ -2872,7 +2832,7 @@ static void tcp_dsack_set(struct tcp_sock *tp, u32 seq, u32 end_seq) } } -static void tcp_dsack_extend(struct tcp_sock *tp, u32 seq, u32 end_seq) +static inline void tcp_dsack_extend(struct tcp_sock *tp, u32 seq, u32 end_seq) { if (!tp->rx_opt.dsack) tcp_dsack_set(tp, seq, end_seq); @@ -2930,7 +2890,7 @@ static void tcp_sack_maybe_coalesce(struct tcp_sock *tp) } } -static inline void tcp_sack_swap(struct tcp_sack_block *sack1, struct tcp_sack_block *sack2) +static __inline__ void tcp_sack_swap(struct tcp_sack_block *sack1, struct tcp_sack_block *sack2) { __u32 tmp; @@ -3495,7 +3455,7 @@ void tcp_cwnd_application_limited(struct sock *sk) tp->snd_cwnd_stamp = tcp_time_stamp; } -static int tcp_should_expand_sndbuf(struct sock *sk, struct tcp_sock *tp) +static inline int tcp_should_expand_sndbuf(struct sock *sk, struct tcp_sock *tp) { /* If the user specified a specific send buffer setting, do * not modify it. @@ -3542,7 +3502,7 @@ static void tcp_new_space(struct sock *sk) sk->sk_write_space(sk); } -static void tcp_check_space(struct sock *sk) +static inline void tcp_check_space(struct sock *sk) { if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) { sock_reset_flag(sk, SOCK_QUEUE_SHRUNK); @@ -3552,7 +3512,7 @@ static void tcp_check_space(struct sock *sk) } } -static inline void tcp_data_snd_check(struct sock *sk, struct tcp_sock *tp) +static __inline__ void tcp_data_snd_check(struct sock *sk, struct tcp_sock *tp) { tcp_push_pending_frames(sk, tp); tcp_check_space(sk); @@ -3584,7 +3544,7 @@ static void __tcp_ack_snd_check(struct sock *sk, int ofo_possible) } } -static inline void tcp_ack_snd_check(struct sock *sk) +static __inline__ void tcp_ack_snd_check(struct sock *sk) { if (!inet_csk_ack_scheduled(sk)) { /* We sent a data segment already. */ @@ -3732,7 +3692,8 @@ static int __tcp_checksum_complete_user(struct sock *sk, struct sk_buff *skb) return result; } -static inline int tcp_checksum_complete_user(struct sock *sk, struct sk_buff *skb) +static __inline__ int +tcp_checksum_complete_user(struct sock *sk, struct sk_buff *skb) { return skb->ip_summed != CHECKSUM_UNNECESSARY && __tcp_checksum_complete_user(sk, skb); @@ -4006,12 +3967,12 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, struct tcphdr *th, unsigned len) { struct tcp_sock *tp = tcp_sk(sk); - struct inet_connection_sock *icsk = inet_csk(sk); int saved_clamp = tp->rx_opt.mss_clamp; tcp_parse_options(skb, &tp->rx_opt, 0); if (th->ack) { + struct inet_connection_sock *icsk; /* rfc793: * "If the state is SYN-SENT then * first check the ACK bit @@ -4100,7 +4061,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, if (tp->rx_opt.sack_ok && sysctl_tcp_fack) tp->rx_opt.sack_ok |= 2; - tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); + tcp_sync_mss(sk, tp->pmtu_cookie); tcp_initialize_rcv_mss(sk); /* Remember, tcp_poll() does not lock socket! @@ -4111,7 +4072,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, tcp_set_state(sk, TCP_ESTABLISHED); /* Make sure socket is routed, for correct metrics. */ - icsk->icsk_af_ops->rebuild_header(sk); + tp->af_specific->rebuild_header(sk); tcp_init_metrics(sk); @@ -4137,6 +4098,8 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, sk_wake_async(sk, 0, POLL_OUT); } + icsk = inet_csk(sk); + if (sk->sk_write_pending || icsk->icsk_accept_queue.rskq_defer_accept || icsk->icsk_ack.pingpong) { @@ -4210,7 +4173,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb, if (tp->ecn_flags&TCP_ECN_OK) sock_set_flag(sk, SOCK_NO_LARGESEND); - tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); + tcp_sync_mss(sk, tp->pmtu_cookie); tcp_initialize_rcv_mss(sk); @@ -4257,7 +4220,6 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, struct tcphdr *th, unsigned len) { struct tcp_sock *tp = tcp_sk(sk); - struct inet_connection_sock *icsk = inet_csk(sk); int queued = 0; tp->rx_opt.saw_tstamp = 0; @@ -4274,7 +4236,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, goto discard; if(th->syn) { - if (icsk->icsk_af_ops->conn_request(sk, skb) < 0) + if(tp->af_specific->conn_request(sk, skb) < 0) return 1; /* Now we have several options: In theory there is @@ -4387,7 +4349,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, /* Make sure socket is routed, for * correct metrics. */ - icsk->icsk_af_ops->rebuild_header(sk); + tp->af_specific->rebuild_header(sk); tcp_init_metrics(sk); @@ -4513,4 +4475,3 @@ EXPORT_SYMBOL(sysctl_tcp_abc); EXPORT_SYMBOL(tcp_parse_options); EXPORT_SYMBOL(tcp_rcv_established); EXPORT_SYMBOL(tcp_rcv_state_process); -EXPORT_SYMBOL(tcp_initialize_rcv_mss); diff --git a/trunk/net/ipv4/tcp_ipv4.c b/trunk/net/ipv4/tcp_ipv4.c index e9f83e5b28ce..4d5021e1929b 100644 --- a/trunk/net/ipv4/tcp_ipv4.c +++ b/trunk/net/ipv4/tcp_ipv4.c @@ -69,7 +69,6 @@ #include #include #include -#include #include #include @@ -87,7 +86,8 @@ int sysctl_tcp_low_latency; /* Socket used for sending RSTs */ static struct socket *tcp_socket; -void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb); +void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len, + struct sk_buff *skb); struct inet_hashinfo __cacheline_aligned tcp_hashinfo = { .lhash_lock = RW_LOCK_UNLOCKED, @@ -97,8 +97,7 @@ struct inet_hashinfo __cacheline_aligned tcp_hashinfo = { static int tcp_v4_get_port(struct sock *sk, unsigned short snum) { - return inet_csk_get_port(&tcp_hashinfo, sk, snum, - inet_csk_bind_conflict); + return inet_csk_get_port(&tcp_hashinfo, sk, snum); } static void tcp_v4_hash(struct sock *sk) @@ -119,38 +118,202 @@ static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb) skb->h.th->source); } -int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp) +/* called with local bh disabled */ +static int __tcp_v4_check_established(struct sock *sk, __u16 lport, + struct inet_timewait_sock **twp) { - const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw); - struct tcp_sock *tp = tcp_sk(sk); + struct inet_sock *inet = inet_sk(sk); + u32 daddr = inet->rcv_saddr; + u32 saddr = inet->daddr; + int dif = sk->sk_bound_dev_if; + INET_ADDR_COOKIE(acookie, saddr, daddr) + const __u32 ports = INET_COMBINED_PORTS(inet->dport, lport); + unsigned int hash = inet_ehashfn(daddr, lport, saddr, inet->dport); + struct inet_ehash_bucket *head = inet_ehash_bucket(&tcp_hashinfo, hash); + struct sock *sk2; + const struct hlist_node *node; + struct inet_timewait_sock *tw; - /* With PAWS, it is safe from the viewpoint - of data integrity. Even without PAWS it is safe provided sequence - spaces do not overlap i.e. at data rates <= 80Mbit/sec. + prefetch(head->chain.first); + write_lock(&head->lock); - Actually, the idea is close to VJ's one, only timestamp cache is - held not per host, but per port pair and TW bucket is used as state - holder. + /* Check TIME-WAIT sockets first. */ + sk_for_each(sk2, node, &(head + tcp_hashinfo.ehash_size)->chain) { + tw = inet_twsk(sk2); - If TW bucket has been already destroyed we fall back to VJ's scheme - and use initial timestamp retrieved from peer table. - */ - if (tcptw->tw_ts_recent_stamp && - (twp == NULL || (sysctl_tcp_tw_reuse && - xtime.tv_sec - tcptw->tw_ts_recent_stamp > 1))) { - tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2; - if (tp->write_seq == 0) - tp->write_seq = 1; - tp->rx_opt.ts_recent = tcptw->tw_ts_recent; - tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp; - sock_hold(sktw); - return 1; + if (INET_TW_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif)) { + const struct tcp_timewait_sock *tcptw = tcp_twsk(sk2); + struct tcp_sock *tp = tcp_sk(sk); + + /* With PAWS, it is safe from the viewpoint + of data integrity. Even without PAWS it + is safe provided sequence spaces do not + overlap i.e. at data rates <= 80Mbit/sec. + + Actually, the idea is close to VJ's one, + only timestamp cache is held not per host, + but per port pair and TW bucket is used + as state holder. + + If TW bucket has been already destroyed we + fall back to VJ's scheme and use initial + timestamp retrieved from peer table. + */ + if (tcptw->tw_ts_recent_stamp && + (!twp || (sysctl_tcp_tw_reuse && + xtime.tv_sec - + tcptw->tw_ts_recent_stamp > 1))) { + tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2; + if (tp->write_seq == 0) + tp->write_seq = 1; + tp->rx_opt.ts_recent = tcptw->tw_ts_recent; + tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp; + sock_hold(sk2); + goto unique; + } else + goto not_unique; + } + } + tw = NULL; + + /* And established part... */ + sk_for_each(sk2, node, &head->chain) { + if (INET_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif)) + goto not_unique; + } + +unique: + /* Must record num and sport now. Otherwise we will see + * in hash table socket with a funny identity. */ + inet->num = lport; + inet->sport = htons(lport); + sk->sk_hash = hash; + BUG_TRAP(sk_unhashed(sk)); + __sk_add_node(sk, &head->chain); + sock_prot_inc_use(sk->sk_prot); + write_unlock(&head->lock); + + if (twp) { + *twp = tw; + NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); + } else if (tw) { + /* Silly. Should hash-dance instead... */ + inet_twsk_deschedule(tw, &tcp_death_row); + NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); + + inet_twsk_put(tw); } return 0; + +not_unique: + write_unlock(&head->lock); + return -EADDRNOTAVAIL; } -EXPORT_SYMBOL_GPL(tcp_twsk_unique); +static inline u32 connect_port_offset(const struct sock *sk) +{ + const struct inet_sock *inet = inet_sk(sk); + + return secure_tcp_port_ephemeral(inet->rcv_saddr, inet->daddr, + inet->dport); +} + +/* + * Bind a port for a connect operation and hash it. + */ +static inline int tcp_v4_hash_connect(struct sock *sk) +{ + const unsigned short snum = inet_sk(sk)->num; + struct inet_bind_hashbucket *head; + struct inet_bind_bucket *tb; + int ret; + + if (!snum) { + int low = sysctl_local_port_range[0]; + int high = sysctl_local_port_range[1]; + int range = high - low; + int i; + int port; + static u32 hint; + u32 offset = hint + connect_port_offset(sk); + struct hlist_node *node; + struct inet_timewait_sock *tw = NULL; + + local_bh_disable(); + for (i = 1; i <= range; i++) { + port = low + (i + offset) % range; + head = &tcp_hashinfo.bhash[inet_bhashfn(port, tcp_hashinfo.bhash_size)]; + spin_lock(&head->lock); + + /* Does not bother with rcv_saddr checks, + * because the established check is already + * unique enough. + */ + inet_bind_bucket_for_each(tb, node, &head->chain) { + if (tb->port == port) { + BUG_TRAP(!hlist_empty(&tb->owners)); + if (tb->fastreuse >= 0) + goto next_port; + if (!__tcp_v4_check_established(sk, + port, + &tw)) + goto ok; + goto next_port; + } + } + + tb = inet_bind_bucket_create(tcp_hashinfo.bind_bucket_cachep, head, port); + if (!tb) { + spin_unlock(&head->lock); + break; + } + tb->fastreuse = -1; + goto ok; + + next_port: + spin_unlock(&head->lock); + } + local_bh_enable(); + + return -EADDRNOTAVAIL; + +ok: + hint += i; + + /* Head lock still held and bh's disabled */ + inet_bind_hash(sk, tb, port); + if (sk_unhashed(sk)) { + inet_sk(sk)->sport = htons(port); + __inet_hash(&tcp_hashinfo, sk, 0); + } + spin_unlock(&head->lock); + + if (tw) { + inet_twsk_deschedule(tw, &tcp_death_row);; + inet_twsk_put(tw); + } + + ret = 0; + goto out; + } + + head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)]; + tb = inet_csk(sk)->icsk_bind_hash; + spin_lock_bh(&head->lock); + if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) { + __inet_hash(&tcp_hashinfo, sk, 0); + spin_unlock_bh(&head->lock); + return 0; + } else { + spin_unlock(&head->lock); + /* No definite answer... Walk to established hash table */ + ret = __tcp_v4_check_established(sk, snum, NULL); +out: + local_bh_enable(); + return ret; + } +} /* This will initiate an outgoing connection. */ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) @@ -220,9 +383,9 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) inet->dport = usin->sin_port; inet->daddr = daddr; - inet_csk(sk)->icsk_ext_hdr_len = 0; + tp->ext_header_len = 0; if (inet->opt) - inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen; + tp->ext_header_len = inet->opt->optlen; tp->rx_opt.mss_clamp = 536; @@ -232,7 +395,7 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) * complete initialization after this. */ tcp_set_state(sk, TCP_SYN_SENT); - err = inet_hash_connect(&tcp_death_row, sk); + err = tcp_v4_hash_connect(sk); if (err) goto failure; @@ -270,10 +433,12 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) /* * This routine does path mtu discovery as defined in RFC1191. */ -static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu) +static inline void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, + u32 mtu) { struct dst_entry *dst; struct inet_sock *inet = inet_sk(sk); + struct tcp_sock *tp = tcp_sk(sk); /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs * send out by Linux are always <576bytes so they should go through @@ -302,7 +467,7 @@ static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu) mtu = dst_mtu(dst); if (inet->pmtudisc != IP_PMTUDISC_DONT && - inet_csk(sk)->icsk_pmtu_cookie > mtu) { + tp->pmtu_cookie > mtu) { tcp_sync_mss(sk, mtu); /* Resend the TCP packet because it's @@ -479,10 +644,10 @@ void tcp_v4_err(struct sk_buff *skb, u32 info) } /* This routine computes an IPv4 TCP checksum. */ -void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb) +void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len, + struct sk_buff *skb) { struct inet_sock *inet = inet_sk(sk); - struct tcphdr *th = skb->h.th; if (skb->ip_summed == CHECKSUM_HW) { th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0); @@ -661,8 +826,7 @@ static void tcp_v4_reqsk_destructor(struct request_sock *req) kfree(inet_rsk(req)->opt); } -#ifdef CONFIG_SYN_COOKIES -static void syn_flood_warning(struct sk_buff *skb) +static inline void syn_flood_warning(struct sk_buff *skb) { static unsigned long warntime; @@ -673,13 +837,12 @@ static void syn_flood_warning(struct sk_buff *skb) ntohs(skb->h.th->dest)); } } -#endif /* * Save and compile IPv4 options into the request_sock if needed. */ -static struct ip_options *tcp_v4_save_options(struct sock *sk, - struct sk_buff *skb) +static inline struct ip_options *tcp_v4_save_options(struct sock *sk, + struct sk_buff *skb) { struct ip_options *opt = &(IPCB(skb)->opt); struct ip_options *dopt = NULL; @@ -706,11 +869,6 @@ struct request_sock_ops tcp_request_sock_ops = { .send_reset = tcp_v4_send_reset, }; -static struct timewait_sock_ops tcp_timewait_sock_ops = { - .twsk_obj_size = sizeof(struct tcp_timewait_sock), - .twsk_unique = tcp_twsk_unique, -}; - int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb) { struct inet_request_sock *ireq; @@ -895,9 +1053,9 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb, ireq->opt = NULL; newinet->mc_index = inet_iif(skb); newinet->mc_ttl = skb->nh.iph->ttl; - inet_csk(newsk)->icsk_ext_hdr_len = 0; + newtp->ext_header_len = 0; if (newinet->opt) - inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen; + newtp->ext_header_len = newinet->opt->optlen; newinet->id = newtp->write_seq ^ jiffies; tcp_sync_mss(newsk, dst_mtu(dst)); @@ -1156,6 +1314,16 @@ int tcp_v4_rcv(struct sk_buff *skb) goto discard_it; } +static void v4_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr) +{ + struct sockaddr_in *sin = (struct sockaddr_in *) uaddr; + struct inet_sock *inet = inet_sk(sk); + + sin->sin_family = AF_INET; + sin->sin_addr.s_addr = inet->daddr; + sin->sin_port = inet->dport; +} + /* VJ's idea. Save last timestamp seen from this destination * and hold it at least for normal timewait interval to use for duplicate * segment detection in subsequent connections, before they enter synchronized @@ -1214,7 +1382,7 @@ int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw) return 0; } -struct inet_connection_sock_af_ops ipv4_specific = { +struct tcp_func ipv4_specific = { .queue_xmit = ip_queue_xmit, .send_check = tcp_v4_send_check, .rebuild_header = inet_sk_rebuild_header, @@ -1224,7 +1392,7 @@ struct inet_connection_sock_af_ops ipv4_specific = { .net_header_len = sizeof(struct iphdr), .setsockopt = ip_setsockopt, .getsockopt = ip_getsockopt, - .addr2sockaddr = inet_csk_addr2sockaddr, + .addr2sockaddr = v4_addr2sockaddr, .sockaddr_len = sizeof(struct sockaddr_in), }; @@ -1265,8 +1433,7 @@ static int tcp_v4_init_sock(struct sock *sk) sk->sk_write_space = sk_stream_write_space; sock_set_flag(sk, SOCK_USE_WRITE_QUEUE); - icsk->icsk_af_ops = &ipv4_specific; - icsk->icsk_sync_mss = tcp_sync_mss; + tp->af_specific = &ipv4_specific; sk->sk_sndbuf = sysctl_tcp_wmem[1]; sk->sk_rcvbuf = sysctl_tcp_rmem[1]; @@ -1822,7 +1989,7 @@ struct proto tcp_prot = { .sysctl_rmem = sysctl_tcp_rmem, .max_header = MAX_TCP_HEADER, .obj_size = sizeof(struct tcp_sock), - .twsk_prot = &tcp_timewait_sock_ops, + .twsk_obj_size = sizeof(struct tcp_timewait_sock), .rsk_prot = &tcp_request_sock_ops, }; diff --git a/trunk/net/ipv4/tcp_minisocks.c b/trunk/net/ipv4/tcp_minisocks.c index 2b9b7f6c7f7c..1b66a2ac4321 100644 --- a/trunk/net/ipv4/tcp_minisocks.c +++ b/trunk/net/ipv4/tcp_minisocks.c @@ -274,18 +274,18 @@ tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb, void tcp_time_wait(struct sock *sk, int state, int timeo) { struct inet_timewait_sock *tw = NULL; - const struct inet_connection_sock *icsk = inet_csk(sk); const struct tcp_sock *tp = tcp_sk(sk); int recycle_ok = 0; if (tcp_death_row.sysctl_tw_recycle && tp->rx_opt.ts_recent_stamp) - recycle_ok = icsk->icsk_af_ops->remember_stamp(sk); + recycle_ok = tp->af_specific->remember_stamp(sk); if (tcp_death_row.tw_count < tcp_death_row.sysctl_max_tw_buckets) tw = inet_twsk_alloc(sk, state); if (tw != NULL) { struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw); + const struct inet_connection_sock *icsk = inet_csk(sk); const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1); tw->tw_rcv_wscale = tp->rx_opt.rcv_wscale; @@ -298,12 +298,10 @@ void tcp_time_wait(struct sock *sk, int state, int timeo) #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) if (tw->tw_family == PF_INET6) { struct ipv6_pinfo *np = inet6_sk(sk); - struct inet6_timewait_sock *tw6; + struct tcp6_timewait_sock *tcp6tw = tcp6_twsk((struct sock *)tw); - tw->tw_ipv6_offset = inet6_tw_offset(sk->sk_prot); - tw6 = inet6_twsk((struct sock *)tw); - ipv6_addr_copy(&tw6->tw_v6_daddr, &np->daddr); - ipv6_addr_copy(&tw6->tw_v6_rcv_saddr, &np->rcv_saddr); + ipv6_addr_copy(&tcp6tw->tw_v6_daddr, &np->daddr); + ipv6_addr_copy(&tcp6tw->tw_v6_rcv_saddr, &np->rcv_saddr); tw->tw_ipv6only = np->ipv6only; } #endif @@ -458,6 +456,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb, struct request_sock **prev) { struct tcphdr *th = skb->h.th; + struct tcp_sock *tp = tcp_sk(sk); u32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK); int paws_reject = 0; struct tcp_options_received tmp_opt; @@ -614,8 +613,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb, * ESTABLISHED STATE. If it will be dropped after * socket is created, wait for troubles. */ - child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, - req, NULL); + child = tp->af_specific->syn_recv_sock(sk, skb, req, NULL); if (child == NULL) goto listen_overflow; diff --git a/trunk/net/ipv4/tcp_output.c b/trunk/net/ipv4/tcp_output.c index a7623ead39a8..b7325e0b406a 100644 --- a/trunk/net/ipv4/tcp_output.c +++ b/trunk/net/ipv4/tcp_output.c @@ -51,8 +51,8 @@ int sysctl_tcp_retrans_collapse = 1; */ int sysctl_tcp_tso_win_divisor = 3; -static void update_send_head(struct sock *sk, struct tcp_sock *tp, - struct sk_buff *skb) +static inline void update_send_head(struct sock *sk, struct tcp_sock *tp, + struct sk_buff *skb) { sk->sk_send_head = skb->next; if (sk->sk_send_head == (struct sk_buff *)&sk->sk_write_queue) @@ -124,8 +124,8 @@ static void tcp_cwnd_restart(struct sock *sk, struct dst_entry *dst) tp->snd_cwnd_used = 0; } -static void tcp_event_data_sent(struct tcp_sock *tp, - struct sk_buff *skb, struct sock *sk) +static inline void tcp_event_data_sent(struct tcp_sock *tp, + struct sk_buff *skb, struct sock *sk) { struct inet_connection_sock *icsk = inet_csk(sk); const u32 now = tcp_time_stamp; @@ -142,7 +142,7 @@ static void tcp_event_data_sent(struct tcp_sock *tp, icsk->icsk_ack.pingpong = 1; } -static inline void tcp_event_ack_sent(struct sock *sk, unsigned int pkts) +static __inline__ void tcp_event_ack_sent(struct sock *sk, unsigned int pkts) { tcp_dec_quickack_mode(sk, pkts); inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK); @@ -212,7 +212,7 @@ void tcp_select_initial_window(int __space, __u32 mss, * value can be stuffed directly into th->window for an outgoing * frame. */ -static u16 tcp_select_window(struct sock *sk) +static __inline__ u16 tcp_select_window(struct sock *sk) { struct tcp_sock *tp = tcp_sk(sk); u32 cur_win = tcp_receive_window(tp); @@ -250,75 +250,6 @@ static u16 tcp_select_window(struct sock *sk) return new_win; } -static void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp, - __u32 tstamp) -{ - if (tp->rx_opt.tstamp_ok) { - *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | - (TCPOPT_NOP << 16) | - (TCPOPT_TIMESTAMP << 8) | - TCPOLEN_TIMESTAMP); - *ptr++ = htonl(tstamp); - *ptr++ = htonl(tp->rx_opt.ts_recent); - } - if (tp->rx_opt.eff_sacks) { - struct tcp_sack_block *sp = tp->rx_opt.dsack ? tp->duplicate_sack : tp->selective_acks; - int this_sack; - - *ptr++ = htonl((TCPOPT_NOP << 24) | - (TCPOPT_NOP << 16) | - (TCPOPT_SACK << 8) | - (TCPOLEN_SACK_BASE + (tp->rx_opt.eff_sacks * - TCPOLEN_SACK_PERBLOCK))); - for(this_sack = 0; this_sack < tp->rx_opt.eff_sacks; this_sack++) { - *ptr++ = htonl(sp[this_sack].start_seq); - *ptr++ = htonl(sp[this_sack].end_seq); - } - if (tp->rx_opt.dsack) { - tp->rx_opt.dsack = 0; - tp->rx_opt.eff_sacks--; - } - } -} - -/* Construct a tcp options header for a SYN or SYN_ACK packet. - * If this is every changed make sure to change the definition of - * MAX_SYN_SIZE to match the new maximum number of options that you - * can generate. - */ -static void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack, - int offer_wscale, int wscale, __u32 tstamp, - __u32 ts_recent) -{ - /* We always get an MSS option. - * The option bytes which will be seen in normal data - * packets should timestamps be used, must be in the MSS - * advertised. But we subtract them from tp->mss_cache so - * that calculations in tcp_sendmsg are simpler etc. - * So account for this fact here if necessary. If we - * don't do this correctly, as a receiver we won't - * recognize data packets as being full sized when we - * should, and thus we won't abide by the delayed ACK - * rules correctly. - * SACKs don't matter, we never delay an ACK when we - * have any of those going out. - */ - *ptr++ = htonl((TCPOPT_MSS << 24) | (TCPOLEN_MSS << 16) | mss); - if (ts) { - if(sack) - *ptr++ = __constant_htonl((TCPOPT_SACK_PERM << 24) | (TCPOLEN_SACK_PERM << 16) | - (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP); - else - *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | - (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP); - *ptr++ = htonl(tstamp); /* TSVAL */ - *ptr++ = htonl(ts_recent); /* TSECR */ - } else if(sack) - *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | - (TCPOPT_SACK_PERM << 8) | TCPOLEN_SACK_PERM); - if (offer_wscale) - *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_WINDOW << 16) | (TCPOLEN_WINDOW << 8) | (wscale)); -} /* This routine actually transmits TCP packets queued in by * tcp_do_sendmsg(). This is used by both the initial @@ -440,7 +371,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, TCP_ECN_send(sk, tp, skb, tcp_header_size); } - icsk->icsk_af_ops->send_check(sk, skb->len, skb); + tp->af_specific->send_check(sk, th, skb->len, skb); if (likely(tcb->flags & TCPCB_FLAG_ACK)) tcp_event_ack_sent(sk, tcp_skb_pcount(skb)); @@ -450,7 +381,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, TCP_INC_STATS(TCP_MIB_OUTSEGS); - err = icsk->icsk_af_ops->queue_xmit(skb, 0); + err = tp->af_specific->queue_xmit(skb, 0); if (unlikely(err <= 0)) return err; @@ -690,7 +621,7 @@ int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len) It is minimum of user_mss and mss received with SYN. It also does not include TCP options. - inet_csk(sk)->icsk_pmtu_cookie is last pmtu, seen by this function. + tp->pmtu_cookie is last pmtu, seen by this function. tp->mss_cache is current effective sending mss, including all tcp options except for SACKs. It is evaluated, @@ -700,26 +631,26 @@ int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len) NOTE1. rfc1122 clearly states that advertised MSS DOES NOT include either tcp or ip options. - NOTE2. inet_csk(sk)->icsk_pmtu_cookie and tp->mss_cache - are READ ONLY outside this function. --ANK (980731) + NOTE2. tp->pmtu_cookie and tp->mss_cache are READ ONLY outside + this function. --ANK (980731) */ unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu) { struct tcp_sock *tp = tcp_sk(sk); - struct inet_connection_sock *icsk = inet_csk(sk); + int mss_now; + /* Calculate base mss without TCP options: It is MMS_S - sizeof(tcphdr) of rfc1122 */ - int mss_now = (pmtu - icsk->icsk_af_ops->net_header_len - - sizeof(struct tcphdr)); + mss_now = pmtu - tp->af_specific->net_header_len - sizeof(struct tcphdr); /* Clamp it (mss_clamp does not include tcp options) */ if (mss_now > tp->rx_opt.mss_clamp) mss_now = tp->rx_opt.mss_clamp; /* Now subtract optional transport overhead */ - mss_now -= icsk->icsk_ext_hdr_len; + mss_now -= tp->ext_header_len; /* Then reserve room for full set of TCP options and 8 bytes of data */ if (mss_now < 48) @@ -733,7 +664,7 @@ unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu) mss_now = max((tp->max_window>>1), 68U - tp->tcp_header_len); /* And store cached results */ - icsk->icsk_pmtu_cookie = pmtu; + tp->pmtu_cookie = pmtu; tp->mss_cache = mss_now; return mss_now; @@ -763,7 +694,7 @@ unsigned int tcp_current_mss(struct sock *sk, int large_allowed) if (dst) { u32 mtu = dst_mtu(dst); - if (mtu != inet_csk(sk)->icsk_pmtu_cookie) + if (mtu != tp->pmtu_cookie) mss_now = tcp_sync_mss(sk, mtu); } @@ -774,10 +705,9 @@ unsigned int tcp_current_mss(struct sock *sk, int large_allowed) xmit_size_goal = mss_now; if (doing_tso) { - xmit_size_goal = (65535 - - inet_csk(sk)->icsk_af_ops->net_header_len - - inet_csk(sk)->icsk_ext_hdr_len - - tp->tcp_header_len); + xmit_size_goal = 65535 - + tp->af_specific->net_header_len - + tp->ext_header_len - tp->tcp_header_len; if (tp->max_window && (xmit_size_goal > (tp->max_window >> 1))) @@ -793,7 +723,7 @@ unsigned int tcp_current_mss(struct sock *sk, int large_allowed) /* Congestion window validation. (RFC2861) */ -static void tcp_cwnd_validate(struct sock *sk, struct tcp_sock *tp) +static inline void tcp_cwnd_validate(struct sock *sk, struct tcp_sock *tp) { __u32 packets_out = tp->packets_out; @@ -842,7 +772,7 @@ static inline unsigned int tcp_cwnd_test(struct tcp_sock *tp, struct sk_buff *sk /* This must be invoked the first time we consider transmitting * SKB onto the wire. */ -static int tcp_init_tso_segs(struct sock *sk, struct sk_buff *skb, unsigned int mss_now) +static inline int tcp_init_tso_segs(struct sock *sk, struct sk_buff *skb, unsigned int mss_now) { int tso_segs = tcp_skb_pcount(skb); @@ -1492,7 +1422,7 @@ int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb) (sysctl_tcp_retrans_collapse != 0)) tcp_retrans_try_collapse(sk, skb, cur_mss); - if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk)) + if(tp->af_specific->rebuild_header(sk)) return -EHOSTUNREACH; /* Routing failure or similar. */ /* Some Solaris stacks overoptimize and ignore the FIN on a @@ -1863,7 +1793,7 @@ struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst, /* * Do all connect socket setups that can be done AF independent. */ -static void tcp_connect_init(struct sock *sk) +static inline void tcp_connect_init(struct sock *sk) { struct dst_entry *dst = __sk_dst_get(sk); struct tcp_sock *tp = tcp_sk(sk); diff --git a/trunk/net/ipv4/tcp_vegas.c b/trunk/net/ipv4/tcp_vegas.c index 3b7403495052..13e7e6e8df16 100644 --- a/trunk/net/ipv4/tcp_vegas.c +++ b/trunk/net/ipv4/tcp_vegas.c @@ -330,10 +330,6 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, vegas->cntRTT = 0; vegas->minRTT = 0x7fffffff; } - /* Use normal slow start */ - else if (tp->snd_cwnd <= tp->snd_ssthresh) - tcp_slow_start(tp); - } /* Extract info for Tcp socket info provided via netlink. */ diff --git a/trunk/net/ipv4/udp.c b/trunk/net/ipv4/udp.c index 223abaa72bc5..2422a5f7195d 100644 --- a/trunk/net/ipv4/udp.c +++ b/trunk/net/ipv4/udp.c @@ -86,7 +86,6 @@ #include #include #include -#include #include #include #include @@ -847,7 +846,20 @@ static int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, csum_copy_err: UDP_INC_STATS_BH(UDP_MIB_INERRORS); - skb_kill_datagram(sk, skb, flags); + /* Clear queue. */ + if (flags&MSG_PEEK) { + int clear = 0; + spin_lock_bh(&sk->sk_receive_queue.lock); + if (skb == skb_peek(&sk->sk_receive_queue)) { + __skb_unlink(skb, &sk->sk_receive_queue); + clear = 1; + } + spin_unlock_bh(&sk->sk_receive_queue.lock); + if (clear) + kfree_skb(skb); + } + + skb_free_datagram(sk, skb); if (noblock) return -EAGAIN; @@ -1082,7 +1094,7 @@ static int udp_v4_mcast_deliver(struct sk_buff *skb, struct udphdr *uh, * Otherwise, csum completion requires chacksumming packet body, * including udp header and folding it to skb->csum. */ -static void udp_checksum_init(struct sk_buff *skb, struct udphdr *uh, +static int udp_checksum_init(struct sk_buff *skb, struct udphdr *uh, unsigned short ulen, u32 saddr, u32 daddr) { if (uh->check == 0) { @@ -1096,6 +1108,7 @@ static void udp_checksum_init(struct sk_buff *skb, struct udphdr *uh, /* Probably, we should checksum udp header (it should be in cache * in any case) and data in tiny packets (< rx copybreak). */ + return 0; } /* @@ -1128,7 +1141,8 @@ int udp_rcv(struct sk_buff *skb) if (pskb_trim_rcsum(skb, ulen)) goto short_packet; - udp_checksum_init(skb, uh, ulen, saddr, daddr); + if (udp_checksum_init(skb, uh, ulen, saddr, daddr) < 0) + goto csum_error; if(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST)) return udp_v4_mcast_deliver(skb, uh, saddr, daddr); diff --git a/trunk/net/ipv6/Makefile b/trunk/net/ipv6/Makefile index 9601fd7f9d66..6460eec834b7 100644 --- a/trunk/net/ipv6/Makefile +++ b/trunk/net/ipv6/Makefile @@ -8,8 +8,7 @@ ipv6-objs := af_inet6.o anycast.o ip6_output.o ip6_input.o addrconf.o sit.o \ route.o ip6_fib.o ipv6_sockglue.o ndisc.o udp.o raw.o \ protocol.o icmp.o mcast.o reassembly.o tcp_ipv6.o \ exthdrs.o sysctl_net_ipv6.o datagram.o proc.o \ - ip6_flowlabel.o ipv6_syms.o netfilter.o \ - inet6_connection_sock.o + ip6_flowlabel.o ipv6_syms.o netfilter.o ipv6-$(CONFIG_XFRM) += xfrm6_policy.o xfrm6_state.o xfrm6_input.o \ xfrm6_output.o diff --git a/trunk/net/ipv6/addrconf.c b/trunk/net/ipv6/addrconf.c index 704fb73e6c5f..a60585fd85ad 100644 --- a/trunk/net/ipv6/addrconf.c +++ b/trunk/net/ipv6/addrconf.c @@ -1195,7 +1195,7 @@ struct inet6_ifaddr * ipv6_get_ifaddr(struct in6_addr *addr, struct net_device * int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2) { const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr; - const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2); + const struct in6_addr *sk2_rcv_saddr6 = tcp_v6_rcv_saddr(sk2); u32 sk_rcv_saddr = inet_sk(sk)->rcv_saddr; u32 sk2_rcv_saddr = inet_rcv_saddr(sk2); int sk_ipv6only = ipv6_only_sock(sk); diff --git a/trunk/net/ipv6/af_inet6.c b/trunk/net/ipv6/af_inet6.c index 68afc53be662..d9546380fa04 100644 --- a/trunk/net/ipv6/af_inet6.c +++ b/trunk/net/ipv6/af_inet6.c @@ -167,7 +167,6 @@ static int inet6_create(struct socket *sock, int protocol) sk->sk_reuse = 1; inet = inet_sk(sk); - inet->is_icsk = INET_PROTOSW_ICSK & answer_flags; if (SOCK_RAW == sock->type) { inet->num = protocol; @@ -390,8 +389,6 @@ int inet6_destroy_sock(struct sock *sk) return 0; } -EXPORT_SYMBOL_GPL(inet6_destroy_sock); - /* * This does both peername and sockname. */ @@ -434,6 +431,7 @@ int inet6_getname(struct socket *sock, struct sockaddr *uaddr, int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) { struct sock *sk = sock->sk; + int err = -EINVAL; switch(cmd) { @@ -452,15 +450,16 @@ int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) case SIOCSIFDSTADDR: return addrconf_set_dstaddr((void __user *) arg); default: - if (!sk->sk_prot->ioctl) - return -ENOIOCTLCMD; - return sk->sk_prot->ioctl(sk, cmd, arg); + if (!sk->sk_prot->ioctl || + (err = sk->sk_prot->ioctl(sk, cmd, arg)) == -ENOIOCTLCMD) + return(dev_ioctl(cmd,(void __user *) arg)); + return err; } /*NOTREACHED*/ return(0); } -const struct proto_ops inet6_stream_ops = { +struct proto_ops inet6_stream_ops = { .family = PF_INET6, .owner = THIS_MODULE, .release = inet6_release, @@ -481,7 +480,7 @@ const struct proto_ops inet6_stream_ops = { .sendpage = tcp_sendpage }; -const struct proto_ops inet6_dgram_ops = { +struct proto_ops inet6_dgram_ops = { .family = PF_INET6, .owner = THIS_MODULE, .release = inet6_release, @@ -509,7 +508,7 @@ static struct net_proto_family inet6_family_ops = { }; /* Same as inet6_dgram_ops, sans udp_poll. */ -static const struct proto_ops inet6_sockraw_ops = { +static struct proto_ops inet6_sockraw_ops = { .family = PF_INET6, .owner = THIS_MODULE, .release = inet6_release, @@ -610,79 +609,6 @@ inet6_unregister_protosw(struct inet_protosw *p) } } -int inet6_sk_rebuild_header(struct sock *sk) -{ - int err; - struct dst_entry *dst; - struct ipv6_pinfo *np = inet6_sk(sk); - - dst = __sk_dst_check(sk, np->dst_cookie); - - if (dst == NULL) { - struct inet_sock *inet = inet_sk(sk); - struct in6_addr *final_p = NULL, final; - struct flowi fl; - - memset(&fl, 0, sizeof(fl)); - fl.proto = sk->sk_protocol; - ipv6_addr_copy(&fl.fl6_dst, &np->daddr); - ipv6_addr_copy(&fl.fl6_src, &np->saddr); - fl.fl6_flowlabel = np->flow_label; - fl.oif = sk->sk_bound_dev_if; - fl.fl_ip_dport = inet->dport; - fl.fl_ip_sport = inet->sport; - - if (np->opt && np->opt->srcrt) { - struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt; - ipv6_addr_copy(&final, &fl.fl6_dst); - ipv6_addr_copy(&fl.fl6_dst, rt0->addr); - final_p = &final; - } - - err = ip6_dst_lookup(sk, &dst, &fl); - if (err) { - sk->sk_route_caps = 0; - return err; - } - if (final_p) - ipv6_addr_copy(&fl.fl6_dst, final_p); - - if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) { - sk->sk_err_soft = -err; - return err; - } - - ip6_dst_store(sk, dst, NULL); - sk->sk_route_caps = dst->dev->features & - ~(NETIF_F_IP_CSUM | NETIF_F_TSO); - } - - return 0; -} - -EXPORT_SYMBOL_GPL(inet6_sk_rebuild_header); - -int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb) -{ - struct ipv6_pinfo *np = inet6_sk(sk); - struct inet6_skb_parm *opt = IP6CB(skb); - - if (np->rxopt.all) { - if ((opt->hop && (np->rxopt.bits.hopopts || - np->rxopt.bits.ohopopts)) || - ((IPV6_FLOWINFO_MASK & *(u32*)skb->nh.raw) && - np->rxopt.bits.rxflow) || - (opt->srcrt && (np->rxopt.bits.srcrt || - np->rxopt.bits.osrcrt)) || - ((opt->dst1 || opt->dst0) && - (np->rxopt.bits.dstopts || np->rxopt.bits.odstopts))) - return 1; - } - return 0; -} - -EXPORT_SYMBOL_GPL(ipv6_opt_accepted); - int snmp6_mib_init(void *ptr[2], size_t mibsize, size_t mibalign) { diff --git a/trunk/net/ipv6/ah6.c b/trunk/net/ipv6/ah6.c index 13cc7f895583..f3629730eb15 100644 --- a/trunk/net/ipv6/ah6.c +++ b/trunk/net/ipv6/ah6.c @@ -33,7 +33,6 @@ #include #include #include -#include #include #include diff --git a/trunk/net/ipv6/esp6.c b/trunk/net/ipv6/esp6.c index 6de8ee1a5ad9..8bfbe9970793 100644 --- a/trunk/net/ipv6/esp6.c +++ b/trunk/net/ipv6/esp6.c @@ -36,7 +36,6 @@ #include #include #include -#include #include static int esp6_output(struct xfrm_state *x, struct sk_buff *skb) diff --git a/trunk/net/ipv6/exthdrs.c b/trunk/net/ipv6/exthdrs.c index 113374dc342c..be6faf311387 100644 --- a/trunk/net/ipv6/exthdrs.c +++ b/trunk/net/ipv6/exthdrs.c @@ -413,8 +413,6 @@ ipv6_invert_rthdr(struct sock *sk, struct ipv6_rt_hdr *hdr) return opt; } -EXPORT_SYMBOL_GPL(ipv6_invert_rthdr); - /********************************** Hop-by-hop options. **********************************/ @@ -581,8 +579,6 @@ ipv6_dup_options(struct sock *sk, struct ipv6_txoptions *opt) return opt2; } -EXPORT_SYMBOL_GPL(ipv6_dup_options); - static int ipv6_renew_option(void *ohdr, struct ipv6_opt_hdr __user *newopt, int newoptlen, int inherit, diff --git a/trunk/net/ipv6/inet6_connection_sock.c b/trunk/net/ipv6/inet6_connection_sock.c deleted file mode 100644 index 792f90f0f9ec..000000000000 --- a/trunk/net/ipv6/inet6_connection_sock.c +++ /dev/null @@ -1,199 +0,0 @@ -/* - * INET An implementation of the TCP/IP protocol suite for the LINUX - * operating system. INET is implemented using the BSD Socket - * interface as the means of communication with the user level. - * - * Support for INET6 connection oriented protocols. - * - * Authors: See the TCPv6 sources - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version - * 2 of the License, or(at your option) any later version. - */ - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -int inet6_csk_bind_conflict(const struct sock *sk, - const struct inet_bind_bucket *tb) -{ - const struct sock *sk2; - const struct hlist_node *node; - - /* We must walk the whole port owner list in this case. -DaveM */ - sk_for_each_bound(sk2, node, &tb->owners) { - if (sk != sk2 && - (!sk->sk_bound_dev_if || - !sk2->sk_bound_dev_if || - sk->sk_bound_dev_if == sk2->sk_bound_dev_if) && - (!sk->sk_reuse || !sk2->sk_reuse || - sk2->sk_state == TCP_LISTEN) && - ipv6_rcv_saddr_equal(sk, sk2)) - break; - } - - return node != NULL; -} - -EXPORT_SYMBOL_GPL(inet6_csk_bind_conflict); - -/* - * request_sock (formerly open request) hash tables. - */ -static u32 inet6_synq_hash(const struct in6_addr *raddr, const u16 rport, - const u32 rnd, const u16 synq_hsize) -{ - u32 a = raddr->s6_addr32[0]; - u32 b = raddr->s6_addr32[1]; - u32 c = raddr->s6_addr32[2]; - - a += JHASH_GOLDEN_RATIO; - b += JHASH_GOLDEN_RATIO; - c += rnd; - __jhash_mix(a, b, c); - - a += raddr->s6_addr32[3]; - b += (u32)rport; - __jhash_mix(a, b, c); - - return c & (synq_hsize - 1); -} - -struct request_sock *inet6_csk_search_req(const struct sock *sk, - struct request_sock ***prevp, - const __u16 rport, - const struct in6_addr *raddr, - const struct in6_addr *laddr, - const int iif) -{ - const struct inet_connection_sock *icsk = inet_csk(sk); - struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt; - struct request_sock *req, **prev; - - for (prev = &lopt->syn_table[inet6_synq_hash(raddr, rport, - lopt->hash_rnd, - lopt->nr_table_entries)]; - (req = *prev) != NULL; - prev = &req->dl_next) { - const struct inet6_request_sock *treq = inet6_rsk(req); - - if (inet_rsk(req)->rmt_port == rport && - req->rsk_ops->family == AF_INET6 && - ipv6_addr_equal(&treq->rmt_addr, raddr) && - ipv6_addr_equal(&treq->loc_addr, laddr) && - (!treq->iif || treq->iif == iif)) { - BUG_TRAP(req->sk == NULL); - *prevp = prev; - return req; - } - } - - return NULL; -} - -EXPORT_SYMBOL_GPL(inet6_csk_search_req); - -void inet6_csk_reqsk_queue_hash_add(struct sock *sk, - struct request_sock *req, - const unsigned long timeout) -{ - struct inet_connection_sock *icsk = inet_csk(sk); - struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt; - const u32 h = inet6_synq_hash(&inet6_rsk(req)->rmt_addr, - inet_rsk(req)->rmt_port, - lopt->hash_rnd, lopt->nr_table_entries); - - reqsk_queue_hash_req(&icsk->icsk_accept_queue, h, req, timeout); - inet_csk_reqsk_queue_added(sk, timeout); -} - -EXPORT_SYMBOL_GPL(inet6_csk_reqsk_queue_hash_add); - -void inet6_csk_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr) -{ - struct ipv6_pinfo *np = inet6_sk(sk); - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) uaddr; - - sin6->sin6_family = AF_INET6; - ipv6_addr_copy(&sin6->sin6_addr, &np->daddr); - sin6->sin6_port = inet_sk(sk)->dport; - /* We do not store received flowlabel for TCP */ - sin6->sin6_flowinfo = 0; - sin6->sin6_scope_id = 0; - if (sk->sk_bound_dev_if && - ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) - sin6->sin6_scope_id = sk->sk_bound_dev_if; -} - -EXPORT_SYMBOL_GPL(inet6_csk_addr2sockaddr); - -int inet6_csk_xmit(struct sk_buff *skb, int ipfragok) -{ - struct sock *sk = skb->sk; - struct inet_sock *inet = inet_sk(sk); - struct ipv6_pinfo *np = inet6_sk(sk); - struct flowi fl; - struct dst_entry *dst; - struct in6_addr *final_p = NULL, final; - - memset(&fl, 0, sizeof(fl)); - fl.proto = sk->sk_protocol; - ipv6_addr_copy(&fl.fl6_dst, &np->daddr); - ipv6_addr_copy(&fl.fl6_src, &np->saddr); - fl.fl6_flowlabel = np->flow_label; - IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel); - fl.oif = sk->sk_bound_dev_if; - fl.fl_ip_sport = inet->sport; - fl.fl_ip_dport = inet->dport; - - if (np->opt && np->opt->srcrt) { - struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt; - ipv6_addr_copy(&final, &fl.fl6_dst); - ipv6_addr_copy(&fl.fl6_dst, rt0->addr); - final_p = &final; - } - - dst = __sk_dst_check(sk, np->dst_cookie); - - if (dst == NULL) { - int err = ip6_dst_lookup(sk, &dst, &fl); - - if (err) { - sk->sk_err_soft = -err; - return err; - } - - if (final_p) - ipv6_addr_copy(&fl.fl6_dst, final_p); - - if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) { - sk->sk_route_caps = 0; - return err; - } - - ip6_dst_store(sk, dst, NULL); - sk->sk_route_caps = dst->dev->features & - ~(NETIF_F_IP_CSUM | NETIF_F_TSO); - } - - skb->dst = dst_clone(dst); - - /* Restore final destination back after routing done */ - ipv6_addr_copy(&fl.fl6_dst, &np->daddr); - - return ip6_xmit(sk, skb, &fl, np->opt, 0); -} - -EXPORT_SYMBOL_GPL(inet6_csk_xmit); diff --git a/trunk/net/ipv6/inet6_hashtables.c b/trunk/net/ipv6/inet6_hashtables.c index 4154f3a8b6cf..01d5f46d4e40 100644 --- a/trunk/net/ipv6/inet6_hashtables.c +++ b/trunk/net/ipv6/inet6_hashtables.c @@ -5,8 +5,7 @@ * * Generic INET6 transport hashtables * - * Authors: Lotsa people, from code originally in tcp, generalised here - * by Arnaldo Carvalho de Melo + * Authors: Lotsa people, from code originally in tcp * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License @@ -15,13 +14,12 @@ */ #include + #include -#include #include #include #include -#include struct sock *inet6_lookup_listener(struct inet_hashinfo *hashinfo, const struct in6_addr *daddr, @@ -81,180 +79,3 @@ struct sock *inet6_lookup(struct inet_hashinfo *hashinfo, } EXPORT_SYMBOL_GPL(inet6_lookup); - -static int __inet6_check_established(struct inet_timewait_death_row *death_row, - struct sock *sk, const __u16 lport, - struct inet_timewait_sock **twp) -{ - struct inet_hashinfo *hinfo = death_row->hashinfo; - const struct inet_sock *inet = inet_sk(sk); - const struct ipv6_pinfo *np = inet6_sk(sk); - const struct in6_addr *daddr = &np->rcv_saddr; - const struct in6_addr *saddr = &np->daddr; - const int dif = sk->sk_bound_dev_if; - const u32 ports = INET_COMBINED_PORTS(inet->dport, lport); - const unsigned int hash = inet6_ehashfn(daddr, inet->num, saddr, - inet->dport); - struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash); - struct sock *sk2; - const struct hlist_node *node; - struct inet_timewait_sock *tw; - - prefetch(head->chain.first); - write_lock(&head->lock); - - /* Check TIME-WAIT sockets first. */ - sk_for_each(sk2, node, &(head + hinfo->ehash_size)->chain) { - const struct inet6_timewait_sock *tw6 = inet6_twsk(sk2); - - tw = inet_twsk(sk2); - - if(*((__u32 *)&(tw->tw_dport)) == ports && - sk2->sk_family == PF_INET6 && - ipv6_addr_equal(&tw6->tw_v6_daddr, saddr) && - ipv6_addr_equal(&tw6->tw_v6_rcv_saddr, daddr) && - sk2->sk_bound_dev_if == sk->sk_bound_dev_if) { - if (twsk_unique(sk, sk2, twp)) - goto unique; - else - goto not_unique; - } - } - tw = NULL; - - /* And established part... */ - sk_for_each(sk2, node, &head->chain) { - if (INET6_MATCH(sk2, hash, saddr, daddr, ports, dif)) - goto not_unique; - } - -unique: - BUG_TRAP(sk_unhashed(sk)); - __sk_add_node(sk, &head->chain); - sk->sk_hash = hash; - sock_prot_inc_use(sk->sk_prot); - write_unlock(&head->lock); - - if (twp != NULL) { - *twp = tw; - NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); - } else if (tw != NULL) { - /* Silly. Should hash-dance instead... */ - inet_twsk_deschedule(tw, death_row); - NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); - - inet_twsk_put(tw); - } - return 0; - -not_unique: - write_unlock(&head->lock); - return -EADDRNOTAVAIL; -} - -static inline u32 inet6_sk_port_offset(const struct sock *sk) -{ - const struct inet_sock *inet = inet_sk(sk); - const struct ipv6_pinfo *np = inet6_sk(sk); - return secure_ipv6_port_ephemeral(np->rcv_saddr.s6_addr32, - np->daddr.s6_addr32, - inet->dport); -} - -int inet6_hash_connect(struct inet_timewait_death_row *death_row, - struct sock *sk) -{ - struct inet_hashinfo *hinfo = death_row->hashinfo; - const unsigned short snum = inet_sk(sk)->num; - struct inet_bind_hashbucket *head; - struct inet_bind_bucket *tb; - int ret; - - if (snum == 0) { - const int low = sysctl_local_port_range[0]; - const int high = sysctl_local_port_range[1]; - const int range = high - low; - int i, port; - static u32 hint; - const u32 offset = hint + inet6_sk_port_offset(sk); - struct hlist_node *node; - struct inet_timewait_sock *tw = NULL; - - local_bh_disable(); - for (i = 1; i <= range; i++) { - port = low + (i + offset) % range; - head = &hinfo->bhash[inet_bhashfn(port, hinfo->bhash_size)]; - spin_lock(&head->lock); - - /* Does not bother with rcv_saddr checks, - * because the established check is already - * unique enough. - */ - inet_bind_bucket_for_each(tb, node, &head->chain) { - if (tb->port == port) { - BUG_TRAP(!hlist_empty(&tb->owners)); - if (tb->fastreuse >= 0) - goto next_port; - if (!__inet6_check_established(death_row, - sk, port, - &tw)) - goto ok; - goto next_port; - } - } - - tb = inet_bind_bucket_create(hinfo->bind_bucket_cachep, - head, port); - if (!tb) { - spin_unlock(&head->lock); - break; - } - tb->fastreuse = -1; - goto ok; - - next_port: - spin_unlock(&head->lock); - } - local_bh_enable(); - - return -EADDRNOTAVAIL; - -ok: - hint += i; - - /* Head lock still held and bh's disabled */ - inet_bind_hash(sk, tb, port); - if (sk_unhashed(sk)) { - inet_sk(sk)->sport = htons(port); - __inet6_hash(hinfo, sk); - } - spin_unlock(&head->lock); - - if (tw) { - inet_twsk_deschedule(tw, death_row); - inet_twsk_put(tw); - } - - ret = 0; - goto out; - } - - head = &hinfo->bhash[inet_bhashfn(snum, hinfo->bhash_size)]; - tb = inet_csk(sk)->icsk_bind_hash; - spin_lock_bh(&head->lock); - - if (sk_head(&tb->owners) == sk && sk->sk_bind_node.next == NULL) { - __inet6_hash(hinfo, sk); - spin_unlock_bh(&head->lock); - return 0; - } else { - spin_unlock(&head->lock); - /* No definite answer... Walk to established hash table */ - ret = __inet6_check_established(death_row, sk, snum, NULL); -out: - local_bh_enable(); - return ret; - } -} - -EXPORT_SYMBOL_GPL(inet6_hash_connect); diff --git a/trunk/net/ipv6/ip6_flowlabel.c b/trunk/net/ipv6/ip6_flowlabel.c index 89d12b4817a9..1cf02765fb5c 100644 --- a/trunk/net/ipv6/ip6_flowlabel.c +++ b/trunk/net/ipv6/ip6_flowlabel.c @@ -200,8 +200,6 @@ struct ip6_flowlabel * fl6_sock_lookup(struct sock *sk, u32 label) return NULL; } -EXPORT_SYMBOL_GPL(fl6_sock_lookup); - void fl6_free_socklist(struct sock *sk) { struct ipv6_pinfo *np = inet6_sk(sk); diff --git a/trunk/net/ipv6/ip6_output.c b/trunk/net/ipv6/ip6_output.c index b4c4beba0ede..8523c76ebf76 100644 --- a/trunk/net/ipv6/ip6_output.c +++ b/trunk/net/ipv6/ip6_output.c @@ -775,8 +775,6 @@ int ip6_dst_lookup(struct sock *sk, struct dst_entry **dst, struct flowi *fl) return err; } -EXPORT_SYMBOL_GPL(ip6_dst_lookup); - static inline int ip6_ufo_append_data(struct sock *sk, int getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb), diff --git a/trunk/net/ipv6/ipcomp6.c b/trunk/net/ipv6/ipcomp6.c index 626dd39685f2..55917fb17094 100644 --- a/trunk/net/ipv6/ipcomp6.c +++ b/trunk/net/ipv6/ipcomp6.c @@ -47,7 +47,6 @@ #include #include #include -#include #include #include diff --git a/trunk/net/ipv6/ipv6_sockglue.c b/trunk/net/ipv6/ipv6_sockglue.c index c63868dd2ca2..3620718defe6 100644 --- a/trunk/net/ipv6/ipv6_sockglue.c +++ b/trunk/net/ipv6/ipv6_sockglue.c @@ -163,17 +163,17 @@ int ipv6_setsockopt(struct sock *sk, int level, int optname, sk_refcnt_debug_dec(sk); if (sk->sk_protocol == IPPROTO_TCP) { - struct inet_connection_sock *icsk = inet_csk(sk); + struct tcp_sock *tp = tcp_sk(sk); local_bh_disable(); sock_prot_dec_use(sk->sk_prot); sock_prot_inc_use(&tcp_prot); local_bh_enable(); sk->sk_prot = &tcp_prot; - icsk->icsk_af_ops = &ipv4_specific; + tp->af_specific = &ipv4_specific; sk->sk_socket->ops = &inet_stream_ops; sk->sk_family = PF_INET; - tcp_sync_mss(sk, icsk->icsk_pmtu_cookie); + tcp_sync_mss(sk, tp->pmtu_cookie); } else { local_bh_disable(); sock_prot_dec_use(sk->sk_prot); @@ -317,15 +317,14 @@ int ipv6_setsockopt(struct sock *sk, int level, int optname, } retv = 0; - if (inet_sk(sk)->is_icsk) { + if (sk->sk_type == SOCK_STREAM) { if (opt) { - struct inet_connection_sock *icsk = inet_csk(sk); + struct tcp_sock *tp = tcp_sk(sk); if (!((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) && inet_sk(sk)->daddr != LOOPBACK4_IPV6) { - icsk->icsk_ext_hdr_len = - opt->opt_flen + opt->opt_nflen; - icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie); + tp->ext_header_len = opt->opt_flen + opt->opt_nflen; + tcp_sync_mss(sk, tp->pmtu_cookie); } } opt = xchg(&np->opt, opt); @@ -381,15 +380,14 @@ int ipv6_setsockopt(struct sock *sk, int level, int optname, goto done; update: retv = 0; - if (inet_sk(sk)->is_icsk) { + if (sk->sk_type == SOCK_STREAM) { if (opt) { - struct inet_connection_sock *icsk = inet_csk(sk); + struct tcp_sock *tp = tcp_sk(sk); if (!((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) && inet_sk(sk)->daddr != LOOPBACK4_IPV6) { - icsk->icsk_ext_hdr_len = - opt->opt_flen + opt->opt_nflen; - icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie); + tp->ext_header_len = opt->opt_flen + opt->opt_nflen; + tcp_sync_mss(sk, tp->pmtu_cookie); } } opt = xchg(&np->opt, opt); diff --git a/trunk/net/ipv6/mcast.c b/trunk/net/ipv6/mcast.c index 1cf305a9f8dd..f829a4ad3ccc 100644 --- a/trunk/net/ipv6/mcast.c +++ b/trunk/net/ipv6/mcast.c @@ -224,7 +224,7 @@ int ipv6_sock_mc_join(struct sock *sk, int ifindex, struct in6_addr *addr) mc_lst->ifindex = dev->ifindex; mc_lst->sfmode = MCAST_EXCLUDE; - rwlock_init(&mc_lst->sflock); + mc_lst->sflock = RW_LOCK_UNLOCKED; mc_lst->sflist = NULL; /* diff --git a/trunk/net/ipv6/netfilter/ip6_tables.c b/trunk/net/ipv6/netfilter/ip6_tables.c index 925b42d48347..95d469271c4d 100644 --- a/trunk/net/ipv6/netfilter/ip6_tables.c +++ b/trunk/net/ipv6/netfilter/ip6_tables.c @@ -15,7 +15,6 @@ * - new extension header parser code */ #include -#include #include #include #include @@ -87,6 +86,11 @@ static DECLARE_MUTEX(ip6t_mutex); context stops packets coming through and allows user context to read the counters or update the rules. + To be cache friendly on SMP, we arrange them like so: + [ n-entries ] + ... cache-align padding ... + [ n-entries ] + Hence the start of any table is given by get_table() below. */ /* The table itself */ @@ -104,29 +108,33 @@ struct ip6t_table_info unsigned int underflow[NF_IP6_NUMHOOKS]; /* ip6t_entry tables: one per CPU */ - void *entries[NR_CPUS]; + char entries[0] ____cacheline_aligned; }; static LIST_HEAD(ip6t_target); static LIST_HEAD(ip6t_match); static LIST_HEAD(ip6t_tables); -#define SET_COUNTER(c,b,p) do { (c).bcnt = (b); (c).pcnt = (p); } while(0) #define ADD_COUNTER(c,b,p) do { (c).bcnt += (b); (c).pcnt += (p); } while(0) +#ifdef CONFIG_SMP +#define TABLE_OFFSET(t,p) (SMP_ALIGN((t)->size)*(p)) +#else +#define TABLE_OFFSET(t,p) 0 +#endif + #if 0 #define down(x) do { printk("DOWN:%u:" #x "\n", __LINE__); down(x); } while(0) #define down_interruptible(x) ({ int __r; printk("DOWNi:%u:" #x "\n", __LINE__); __r = down_interruptible(x); if (__r != 0) printk("ABORT-DOWNi:%u\n", __LINE__); __r; }) #define up(x) do { printk("UP:%u:" #x "\n", __LINE__); up(x); } while(0) #endif -int -ip6_masked_addrcmp(const struct in6_addr *addr1, const struct in6_addr *mask, - const struct in6_addr *addr2) +static int ip6_masked_addrcmp(struct in6_addr addr1, struct in6_addr mask, + struct in6_addr addr2) { int i; for( i = 0; i < 16; i++){ - if((addr1->s6_addr[i] & mask->s6_addr[i]) != - (addr2->s6_addr[i] & mask->s6_addr[i])) + if((addr1.s6_addr[i] & mask.s6_addr[i]) != + (addr2.s6_addr[i] & mask.s6_addr[i])) return 1; } return 0; @@ -160,10 +168,10 @@ ip6_packet_match(const struct sk_buff *skb, #define FWINV(bool,invflg) ((bool) ^ !!(ip6info->invflags & invflg)) - if (FWINV(ip6_masked_addrcmp(&ipv6->saddr, &ip6info->smsk, - &ip6info->src), IP6T_INV_SRCIP) - || FWINV(ip6_masked_addrcmp(&ipv6->daddr, &ip6info->dmsk, - &ip6info->dst), IP6T_INV_DSTIP)) { + if (FWINV(ip6_masked_addrcmp(ipv6->saddr,ip6info->smsk,ip6info->src), + IP6T_INV_SRCIP) + || FWINV(ip6_masked_addrcmp(ipv6->daddr,ip6info->dmsk,ip6info->dst), + IP6T_INV_DSTIP)) { dprintf("Source or dest mismatch.\n"); /* dprintf("SRC: %u. Mask: %u. Target: %u.%s\n", ip->saddr, @@ -206,21 +214,69 @@ ip6_packet_match(const struct sk_buff *skb, /* look for the desired protocol header */ if((ip6info->flags & IP6T_F_PROTO)) { - int protohdr; - unsigned short _frag_off; + u_int8_t currenthdr = ipv6->nexthdr; + struct ipv6_opt_hdr _hdr, *hp; + u_int16_t ptr; /* Header offset in skb */ + u_int16_t hdrlen; /* Header */ + u_int16_t _fragoff = 0, *fp = NULL; + + ptr = IPV6_HDR_LEN; + + while (ip6t_ext_hdr(currenthdr)) { + /* Is there enough space for the next ext header? */ + if (skb->len - ptr < IPV6_OPTHDR_LEN) + return 0; + + /* NONE or ESP: there isn't protocol part */ + /* If we want to count these packets in '-p all', + * we will change the return 0 to 1*/ + if ((currenthdr == IPPROTO_NONE) || + (currenthdr == IPPROTO_ESP)) + break; - protohdr = ipv6_find_hdr(skb, protoff, -1, &_frag_off); - if (protohdr < 0) - return 0; + hp = skb_header_pointer(skb, ptr, sizeof(_hdr), &_hdr); + BUG_ON(hp == NULL); + + /* Size calculation */ + if (currenthdr == IPPROTO_FRAGMENT) { + fp = skb_header_pointer(skb, + ptr+offsetof(struct frag_hdr, + frag_off), + sizeof(_fragoff), + &_fragoff); + if (fp == NULL) + return 0; + + _fragoff = ntohs(*fp) & ~0x7; + hdrlen = 8; + } else if (currenthdr == IPPROTO_AH) + hdrlen = (hp->hdrlen+2)<<2; + else + hdrlen = ipv6_optlen(hp); + + currenthdr = hp->nexthdr; + ptr += hdrlen; + /* ptr is too large */ + if ( ptr > skb->len ) + return 0; + if (_fragoff) { + if (ip6t_ext_hdr(currenthdr)) + return 0; + break; + } + } - *fragoff = _frag_off; + *protoff = ptr; + *fragoff = _fragoff; + + /* currenthdr contains the protocol header */ dprintf("Packet protocol %hi ?= %s%hi.\n", - protohdr, + currenthdr, ip6info->invflags & IP6T_INV_PROTO ? "!":"", ip6info->proto); - if (ip6info->proto == protohdr) { + if (ip6info->proto == currenthdr) { if(ip6info->invflags & IP6T_INV_PROTO) { return 0; } @@ -320,7 +376,8 @@ ip6t_do_table(struct sk_buff **pskb, read_lock_bh(&table->lock); IP_NF_ASSERT(table->valid_hooks & (1 << hook)); - table_base = (void *)table->private->entries[smp_processor_id()]; + table_base = (void *)table->private->entries + + TABLE_OFFSET(table->private, smp_processor_id()); e = get_entry(table_base, table->private->hook_entry[hook]); #ifdef CONFIG_NETFILTER_DEBUG @@ -592,8 +649,7 @@ unconditional(const struct ip6t_ip6 *ipv6) /* Figures out from what hook each rule can be called: returns 0 if there are loops. Puts hook bitmask in comefrom. */ static int -mark_source_chains(struct ip6t_table_info *newinfo, - unsigned int valid_hooks, void *entry0) +mark_source_chains(struct ip6t_table_info *newinfo, unsigned int valid_hooks) { unsigned int hook; @@ -602,7 +658,7 @@ mark_source_chains(struct ip6t_table_info *newinfo, for (hook = 0; hook < NF_IP6_NUMHOOKS; hook++) { unsigned int pos = newinfo->hook_entry[hook]; struct ip6t_entry *e - = (struct ip6t_entry *)(entry0 + pos); + = (struct ip6t_entry *)(newinfo->entries + pos); if (!(valid_hooks & (1 << hook))) continue; @@ -652,13 +708,13 @@ mark_source_chains(struct ip6t_table_info *newinfo, goto next; e = (struct ip6t_entry *) - (entry0 + pos); + (newinfo->entries + pos); } while (oldpos == pos + e->next_offset); /* Move along one */ size = e->next_offset; e = (struct ip6t_entry *) - (entry0 + pos + size); + (newinfo->entries + pos + size); e->counters.pcnt = pos; pos += size; } else { @@ -675,7 +731,7 @@ mark_source_chains(struct ip6t_table_info *newinfo, newpos = pos + e->next_offset; } e = (struct ip6t_entry *) - (entry0 + newpos); + (newinfo->entries + newpos); e->counters.pcnt = pos; pos = newpos; } @@ -885,7 +941,6 @@ static int translate_table(const char *name, unsigned int valid_hooks, struct ip6t_table_info *newinfo, - void *entry0, unsigned int size, unsigned int number, const unsigned int *hook_entries, @@ -906,11 +961,11 @@ translate_table(const char *name, duprintf("translate_table: size %u\n", newinfo->size); i = 0; /* Walk through entries, checking offsets. */ - ret = IP6T_ENTRY_ITERATE(entry0, newinfo->size, + ret = IP6T_ENTRY_ITERATE(newinfo->entries, newinfo->size, check_entry_size_and_hooks, newinfo, - entry0, - entry0 + size, + newinfo->entries, + newinfo->entries + size, hook_entries, underflows, &i); if (ret != 0) return ret; @@ -938,24 +993,27 @@ translate_table(const char *name, } } - if (!mark_source_chains(newinfo, valid_hooks, entry0)) + if (!mark_source_chains(newinfo, valid_hooks)) return -ELOOP; /* Finally, each sanity check must pass */ i = 0; - ret = IP6T_ENTRY_ITERATE(entry0, newinfo->size, + ret = IP6T_ENTRY_ITERATE(newinfo->entries, newinfo->size, check_entry, name, size, &i); if (ret != 0) { - IP6T_ENTRY_ITERATE(entry0, newinfo->size, + IP6T_ENTRY_ITERATE(newinfo->entries, newinfo->size, cleanup_entry, &i); return ret; } /* And one copy for every other CPU */ for_each_cpu(i) { - if (newinfo->entries[i] && newinfo->entries[i] != entry0) - memcpy(newinfo->entries[i], entry0, newinfo->size); + if (i == 0) + continue; + memcpy(newinfo->entries + SMP_ALIGN(newinfo->size) * i, + newinfo->entries, + SMP_ALIGN(newinfo->size)); } return ret; @@ -971,12 +1029,15 @@ replace_table(struct ip6t_table *table, #ifdef CONFIG_NETFILTER_DEBUG { - int cpu; + struct ip6t_entry *table_base; + unsigned int i; - for_each_cpu(cpu) { - struct ip6t_entry *table_base = newinfo->entries[cpu]; - if (table_base) - table_base->comefrom = 0xdead57ac; + for_each_cpu(i) { + table_base = + (void *)newinfo->entries + + TABLE_OFFSET(newinfo, i); + + table_base->comefrom = 0xdead57ac; } } #endif @@ -1011,44 +1072,16 @@ add_entry_to_counter(const struct ip6t_entry *e, return 0; } -static inline int -set_entry_to_counter(const struct ip6t_entry *e, - struct ip6t_counters total[], - unsigned int *i) -{ - SET_COUNTER(total[*i], e->counters.bcnt, e->counters.pcnt); - - (*i)++; - return 0; -} - static void get_counters(const struct ip6t_table_info *t, struct ip6t_counters counters[]) { unsigned int cpu; unsigned int i; - unsigned int curcpu; - - /* Instead of clearing (by a previous call to memset()) - * the counters and using adds, we set the counters - * with data used by 'current' CPU - * We dont care about preemption here. - */ - curcpu = raw_smp_processor_id(); - - i = 0; - IP6T_ENTRY_ITERATE(t->entries[curcpu], - t->size, - set_entry_to_counter, - counters, - &i); for_each_cpu(cpu) { - if (cpu == curcpu) - continue; i = 0; - IP6T_ENTRY_ITERATE(t->entries[cpu], + IP6T_ENTRY_ITERATE(t->entries + TABLE_OFFSET(t, cpu), t->size, add_entry_to_counter, counters, @@ -1065,7 +1098,6 @@ copy_entries_to_user(unsigned int total_size, struct ip6t_entry *e; struct ip6t_counters *counters; int ret = 0; - void *loc_cpu_entry; /* We need atomic snapshot of counters: rest doesn't change (other than comefrom, which userspace doesn't care @@ -1077,13 +1109,13 @@ copy_entries_to_user(unsigned int total_size, return -ENOMEM; /* First, sum counters... */ + memset(counters, 0, countersize); write_lock_bh(&table->lock); get_counters(table->private, counters); write_unlock_bh(&table->lock); - /* choose the copy that is on ourc node/cpu */ - loc_cpu_entry = table->private->entries[raw_smp_processor_id()]; - if (copy_to_user(userptr, loc_cpu_entry, total_size) != 0) { + /* ... then copy entire thing from CPU 0... */ + if (copy_to_user(userptr, table->private->entries, total_size) != 0) { ret = -EFAULT; goto free_counters; } @@ -1095,7 +1127,7 @@ copy_entries_to_user(unsigned int total_size, struct ip6t_entry_match *m; struct ip6t_entry_target *t; - e = (struct ip6t_entry *)(loc_cpu_entry + off); + e = (struct ip6t_entry *)(table->private->entries + off); if (copy_to_user(userptr + off + offsetof(struct ip6t_entry, counters), &counters[num], @@ -1164,46 +1196,6 @@ get_entries(const struct ip6t_get_entries *entries, return ret; } -static void free_table_info(struct ip6t_table_info *info) -{ - int cpu; - for_each_cpu(cpu) { - if (info->size <= PAGE_SIZE) - kfree(info->entries[cpu]); - else - vfree(info->entries[cpu]); - } - kfree(info); -} - -static struct ip6t_table_info *alloc_table_info(unsigned int size) -{ - struct ip6t_table_info *newinfo; - int cpu; - - newinfo = kzalloc(sizeof(struct ip6t_table_info), GFP_KERNEL); - if (!newinfo) - return NULL; - - newinfo->size = size; - - for_each_cpu(cpu) { - if (size <= PAGE_SIZE) - newinfo->entries[cpu] = kmalloc_node(size, - GFP_KERNEL, - cpu_to_node(cpu)); - else - newinfo->entries[cpu] = vmalloc_node(size, - cpu_to_node(cpu)); - if (newinfo->entries[cpu] == NULL) { - free_table_info(newinfo); - return NULL; - } - } - - return newinfo; -} - static int do_replace(void __user *user, unsigned int len) { @@ -1212,7 +1204,6 @@ do_replace(void __user *user, unsigned int len) struct ip6t_table *t; struct ip6t_table_info *newinfo, *oldinfo; struct ip6t_counters *counters; - void *loc_cpu_entry, *loc_cpu_old_entry; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; @@ -1221,13 +1212,13 @@ do_replace(void __user *user, unsigned int len) if ((SMP_ALIGN(tmp.size) >> PAGE_SHIFT) + 2 > num_physpages) return -ENOMEM; - newinfo = alloc_table_info(tmp.size); + newinfo = vmalloc(sizeof(struct ip6t_table_info) + + SMP_ALIGN(tmp.size) * + (highest_possible_processor_id()+1)); if (!newinfo) return -ENOMEM; - /* choose the copy that is on our node/cpu */ - loc_cpu_entry = newinfo->entries[raw_smp_processor_id()]; - if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + if (copy_from_user(newinfo->entries, user + sizeof(tmp), tmp.size) != 0) { ret = -EFAULT; goto free_newinfo; @@ -1238,9 +1229,10 @@ do_replace(void __user *user, unsigned int len) ret = -ENOMEM; goto free_newinfo; } + memset(counters, 0, tmp.num_counters * sizeof(struct ip6t_counters)); ret = translate_table(tmp.name, tmp.valid_hooks, - newinfo, loc_cpu_entry, tmp.size, tmp.num_entries, + newinfo, tmp.size, tmp.num_entries, tmp.hook_entry, tmp.underflow); if (ret != 0) goto free_newinfo_counters; @@ -1279,9 +1271,8 @@ do_replace(void __user *user, unsigned int len) /* Get the old counters. */ get_counters(oldinfo, counters); /* Decrease module usage counts and free resource */ - loc_cpu_old_entry = oldinfo->entries[raw_smp_processor_id()]; - IP6T_ENTRY_ITERATE(loc_cpu_old_entry, oldinfo->size, cleanup_entry,NULL); - free_table_info(oldinfo); + IP6T_ENTRY_ITERATE(oldinfo->entries, oldinfo->size, cleanup_entry,NULL); + vfree(oldinfo); if (copy_to_user(tmp.counters, counters, sizeof(struct ip6t_counters) * tmp.num_counters) != 0) ret = -EFAULT; @@ -1293,11 +1284,11 @@ do_replace(void __user *user, unsigned int len) module_put(t->me); up(&ip6t_mutex); free_newinfo_counters_untrans: - IP6T_ENTRY_ITERATE(loc_cpu_entry, newinfo->size, cleanup_entry,NULL); + IP6T_ENTRY_ITERATE(newinfo->entries, newinfo->size, cleanup_entry,NULL); free_newinfo_counters: vfree(counters); free_newinfo: - free_table_info(newinfo); + vfree(newinfo); return ret; } @@ -1330,7 +1321,6 @@ do_add_counters(void __user *user, unsigned int len) struct ip6t_counters_info tmp, *paddc; struct ip6t_table *t; int ret = 0; - void *loc_cpu_entry; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; @@ -1360,9 +1350,7 @@ do_add_counters(void __user *user, unsigned int len) } i = 0; - /* Choose the copy that is on our node */ - loc_cpu_entry = t->private->entries[smp_processor_id()]; - IP6T_ENTRY_ITERATE(loc_cpu_entry, + IP6T_ENTRY_ITERATE(t->private->entries, t->private->size, add_counter_to_entry, paddc->counters, @@ -1555,29 +1543,28 @@ int ip6t_register_table(struct ip6t_table *table, struct ip6t_table_info *newinfo; static struct ip6t_table_info bootstrap = { 0, 0, 0, { 0 }, { 0 }, { } }; - void *loc_cpu_entry; - newinfo = alloc_table_info(repl->size); + newinfo = vmalloc(sizeof(struct ip6t_table_info) + + SMP_ALIGN(repl->size) * + (highest_possible_processor_id()+1)); if (!newinfo) return -ENOMEM; - /* choose the copy on our node/cpu */ - loc_cpu_entry = newinfo->entries[raw_smp_processor_id()]; - memcpy(loc_cpu_entry, repl->entries, repl->size); + memcpy(newinfo->entries, repl->entries, repl->size); ret = translate_table(table->name, table->valid_hooks, - newinfo, loc_cpu_entry, repl->size, + newinfo, repl->size, repl->num_entries, repl->hook_entry, repl->underflow); if (ret != 0) { - free_table_info(newinfo); + vfree(newinfo); return ret; } ret = down_interruptible(&ip6t_mutex); if (ret != 0) { - free_table_info(newinfo); + vfree(newinfo); return ret; } @@ -1606,23 +1593,20 @@ int ip6t_register_table(struct ip6t_table *table, return ret; free_unlock: - free_table_info(newinfo); + vfree(newinfo); goto unlock; } void ip6t_unregister_table(struct ip6t_table *table) { - void *loc_cpu_entry; - down(&ip6t_mutex); LIST_DELETE(&ip6t_tables, table); up(&ip6t_mutex); /* Decrease module usage counts and free resources */ - loc_cpu_entry = table->private->entries[raw_smp_processor_id()]; - IP6T_ENTRY_ITERATE(loc_cpu_entry, table->private->size, + IP6T_ENTRY_ITERATE(table->private->entries, table->private->size, cleanup_entry, NULL); - free_table_info(table->private); + vfree(table->private); } /* Returns 1 if the port is matched by the range, 0 otherwise */ @@ -2051,39 +2035,26 @@ static void __exit fini(void) } /* - * find the offset to specified header or the protocol number of last header - * if target < 0. "last header" is transport protocol header, ESP, or - * "No next header". - * - * If target header is found, its offset is set in *offset and return protocol - * number. Otherwise, return -1. - * - * Note that non-1st fragment is special case that "the protocol number - * of last header" is "next header" field in Fragment header. In this case, - * *offset is meaningless and fragment offset is stored in *fragoff if fragoff - * isn't NULL. + * find specified header up to transport protocol header. + * If found target header, the offset to the header is set to *offset + * and return 0. otherwise, return -1. * + * Notes: - non-1st Fragment Header isn't skipped. + * - ESP header isn't skipped. + * - The target header may be trancated. */ -int ipv6_find_hdr(const struct sk_buff *skb, unsigned int *offset, - int target, unsigned short *fragoff) +int ipv6_find_hdr(const struct sk_buff *skb, unsigned int *offset, u8 target) { unsigned int start = (u8*)(skb->nh.ipv6h + 1) - skb->data; u8 nexthdr = skb->nh.ipv6h->nexthdr; unsigned int len = skb->len - start; - if (fragoff) - *fragoff = 0; - while (nexthdr != target) { struct ipv6_opt_hdr _hdr, *hp; unsigned int hdrlen; - if ((!ipv6_ext_hdr(nexthdr)) || nexthdr == NEXTHDR_NONE) { - if (target < 0) - break; + if ((!ipv6_ext_hdr(nexthdr)) || nexthdr == NEXTHDR_NONE) return -1; - } - hp = skb_header_pointer(skb, start, sizeof(_hdr), &_hdr); if (hp == NULL) return -1; @@ -2097,17 +2068,8 @@ int ipv6_find_hdr(const struct sk_buff *skb, unsigned int *offset, if (fp == NULL) return -1; - _frag_off = ntohs(*fp) & ~0x7; - if (_frag_off) { - if (target < 0 && - ((!ipv6_ext_hdr(hp->nexthdr)) || - nexthdr == NEXTHDR_NONE)) { - if (fragoff) - *fragoff = _frag_off; - return hp->nexthdr; - } + if (ntohs(*fp) & ~0x7) return -1; - } hdrlen = 8; } else if (nexthdr == NEXTHDR_AUTH) hdrlen = (hp->hdrlen + 2) << 2; @@ -2120,7 +2082,7 @@ int ipv6_find_hdr(const struct sk_buff *skb, unsigned int *offset, } *offset = start; - return nexthdr; + return 0; } EXPORT_SYMBOL(ip6t_register_table); @@ -2132,7 +2094,6 @@ EXPORT_SYMBOL(ip6t_register_target); EXPORT_SYMBOL(ip6t_unregister_target); EXPORT_SYMBOL(ip6t_ext_hdr); EXPORT_SYMBOL(ipv6_find_hdr); -EXPORT_SYMBOL(ip6_masked_addrcmp); module_init(init); module_exit(fini); diff --git a/trunk/net/ipv6/netfilter/ip6t_LOG.c b/trunk/net/ipv6/netfilter/ip6t_LOG.c index ae4653bfd654..0cd1d1bd9033 100644 --- a/trunk/net/ipv6/netfilter/ip6t_LOG.c +++ b/trunk/net/ipv6/netfilter/ip6t_LOG.c @@ -13,7 +13,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/ipv6/netfilter/ip6t_ah.c b/trunk/net/ipv6/netfilter/ip6t_ah.c index f5c1a7ff4a1f..dde37793d20b 100644 --- a/trunk/net/ipv6/netfilter/ip6t_ah.c +++ b/trunk/net/ipv6/netfilter/ip6t_ah.c @@ -9,7 +9,6 @@ #include #include -#include #include #include #include @@ -54,7 +53,7 @@ match(const struct sk_buff *skb, unsigned int ptr; unsigned int hdrlen = 0; - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_AUTH, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_AUTH) < 0) return 0; ah = skb_header_pointer(skb, ptr, sizeof(_ah), &_ah); diff --git a/trunk/net/ipv6/netfilter/ip6t_dst.c b/trunk/net/ipv6/netfilter/ip6t_dst.c index 48cf5f9efc95..c450a635e54b 100644 --- a/trunk/net/ipv6/netfilter/ip6t_dst.c +++ b/trunk/net/ipv6/netfilter/ip6t_dst.c @@ -71,9 +71,9 @@ match(const struct sk_buff *skb, unsigned int optlen; #if HOPBYHOP - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_HOP, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_HOP) < 0) #else - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_DEST, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_DEST) < 0) #endif return 0; diff --git a/trunk/net/ipv6/netfilter/ip6t_esp.c b/trunk/net/ipv6/netfilter/ip6t_esp.c index e1828f6d0a40..24bc0cde43a1 100644 --- a/trunk/net/ipv6/netfilter/ip6t_esp.c +++ b/trunk/net/ipv6/netfilter/ip6t_esp.c @@ -9,7 +9,6 @@ #include #include -#include #include #include #include @@ -56,7 +55,7 @@ match(const struct sk_buff *skb, /* Make sure this isn't an evil packet */ /*DEBUGP("ipv6_esp entered \n");*/ - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_ESP, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_ESP) < 0) return 0; eh = skb_header_pointer(skb, ptr, sizeof(_esp), &_esp); diff --git a/trunk/net/ipv6/netfilter/ip6t_frag.c b/trunk/net/ipv6/netfilter/ip6t_frag.c index d1549b268669..085d5f8eea29 100644 --- a/trunk/net/ipv6/netfilter/ip6t_frag.c +++ b/trunk/net/ipv6/netfilter/ip6t_frag.c @@ -52,7 +52,7 @@ match(const struct sk_buff *skb, const struct ip6t_frag *fraginfo = matchinfo; unsigned int ptr; - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_FRAGMENT, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_FRAGMENT) < 0) return 0; fh = skb_header_pointer(skb, ptr, sizeof(_frag), &_frag); diff --git a/trunk/net/ipv6/netfilter/ip6t_hbh.c b/trunk/net/ipv6/netfilter/ip6t_hbh.c index e3bc8e2700e7..1d09485111d0 100644 --- a/trunk/net/ipv6/netfilter/ip6t_hbh.c +++ b/trunk/net/ipv6/netfilter/ip6t_hbh.c @@ -71,9 +71,9 @@ match(const struct sk_buff *skb, unsigned int optlen; #if HOPBYHOP - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_HOP, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_HOP) < 0) #else - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_DEST, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_DEST) < 0) #endif return 0; diff --git a/trunk/net/ipv6/netfilter/ip6t_rt.c b/trunk/net/ipv6/netfilter/ip6t_rt.c index c1e770e45543..beb2fd5cebbb 100644 --- a/trunk/net/ipv6/netfilter/ip6t_rt.c +++ b/trunk/net/ipv6/netfilter/ip6t_rt.c @@ -58,7 +58,7 @@ match(const struct sk_buff *skb, unsigned int ret = 0; struct in6_addr *ap, _addr; - if (ipv6_find_hdr(skb, &ptr, NEXTHDR_ROUTING, NULL) < 0) + if (ipv6_find_hdr(skb, &ptr, NEXTHDR_ROUTING) < 0) return 0; rh = skb_header_pointer(skb, ptr, sizeof(_route), &_route); diff --git a/trunk/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c b/trunk/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c index 704fbbe74874..753a3ae8502b 100644 --- a/trunk/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c +++ b/trunk/net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c @@ -401,48 +401,6 @@ static ctl_table nf_ct_net_table[] = { }; #endif -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - -#include -#include - -static int ipv6_tuple_to_nfattr(struct sk_buff *skb, - const struct nf_conntrack_tuple *tuple) -{ - NFA_PUT(skb, CTA_IP_V6_SRC, sizeof(u_int32_t) * 4, - &tuple->src.u3.ip6); - NFA_PUT(skb, CTA_IP_V6_DST, sizeof(u_int32_t) * 4, - &tuple->dst.u3.ip6); - return 0; - -nfattr_failure: - return -1; -} - -static const size_t cta_min_ip[CTA_IP_MAX] = { - [CTA_IP_V6_SRC-1] = sizeof(u_int32_t)*4, - [CTA_IP_V6_DST-1] = sizeof(u_int32_t)*4, -}; - -static int ipv6_nfattr_to_tuple(struct nfattr *tb[], - struct nf_conntrack_tuple *t) -{ - if (!tb[CTA_IP_V6_SRC-1] || !tb[CTA_IP_V6_DST-1]) - return -EINVAL; - - if (nfattr_bad_size(tb, CTA_IP_MAX, cta_min_ip)) - return -EINVAL; - - memcpy(&t->src.u3.ip6, NFA_DATA(tb[CTA_IP_V6_SRC-1]), - sizeof(u_int32_t) * 4); - memcpy(&t->dst.u3.ip6, NFA_DATA(tb[CTA_IP_V6_DST-1]), - sizeof(u_int32_t) * 4); - - return 0; -} -#endif - struct nf_conntrack_l3proto nf_conntrack_l3proto_ipv6 = { .l3proto = PF_INET6, .name = "ipv6", @@ -451,11 +409,6 @@ struct nf_conntrack_l3proto nf_conntrack_l3proto_ipv6 = { .print_tuple = ipv6_print_tuple, .print_conntrack = ipv6_print_conntrack, .prepare = ipv6_prepare, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .tuple_to_nfattr = ipv6_tuple_to_nfattr, - .nfattr_to_tuple = ipv6_nfattr_to_tuple, -#endif .get_features = ipv6_get_features, .me = THIS_MODULE, }; diff --git a/trunk/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c b/trunk/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c index 09945c333055..a7e03cfacd06 100644 --- a/trunk/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c +++ b/trunk/net/ipv6/netfilter/nf_conntrack_proto_icmpv6.c @@ -57,17 +57,17 @@ static int icmpv6_pkt_to_tuple(const struct sk_buff *skb, return 1; } -/* Add 1; spaces filled with 0. */ -static u_int8_t invmap[] = { - [ICMPV6_ECHO_REQUEST - 128] = ICMPV6_ECHO_REPLY + 1, - [ICMPV6_ECHO_REPLY - 128] = ICMPV6_ECHO_REQUEST + 1, - [ICMPV6_NI_QUERY - 128] = ICMPV6_NI_QUERY + 1, - [ICMPV6_NI_REPLY - 128] = ICMPV6_NI_REPLY +1 -}; - static int icmpv6_invert_tuple(struct nf_conntrack_tuple *tuple, const struct nf_conntrack_tuple *orig) { + /* Add 1; spaces filled with 0. */ + static u_int8_t invmap[] = { + [ICMPV6_ECHO_REQUEST - 128] = ICMPV6_ECHO_REPLY + 1, + [ICMPV6_ECHO_REPLY - 128] = ICMPV6_ECHO_REQUEST + 1, + [ICMPV6_NI_QUERY - 128] = ICMPV6_NI_QUERY + 1, + [ICMPV6_NI_REPLY - 128] = ICMPV6_NI_REPLY +1 + }; + int type = orig->dst.u.icmp.type - 128; if (type < 0 || type >= sizeof(invmap) || !invmap[type]) return 0; @@ -185,7 +185,7 @@ icmpv6_error_message(struct sk_buff *skb, return -NF_ACCEPT; } - inproto = __nf_ct_proto_find(PF_INET6, inprotonum); + inproto = nf_ct_find_proto(PF_INET6, inprotonum); /* Are they talking about one of our connections? */ if (!nf_ct_get_tuple(skb, inip6off, inprotoff, PF_INET6, inprotonum, @@ -255,60 +255,6 @@ icmpv6_error(struct sk_buff *skb, unsigned int dataoff, return icmpv6_error_message(skb, dataoff, ctinfo, hooknum); } -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - -#include -#include -static int icmpv6_tuple_to_nfattr(struct sk_buff *skb, - const struct nf_conntrack_tuple *t) -{ - NFA_PUT(skb, CTA_PROTO_ICMPV6_ID, sizeof(u_int16_t), - &t->src.u.icmp.id); - NFA_PUT(skb, CTA_PROTO_ICMPV6_TYPE, sizeof(u_int8_t), - &t->dst.u.icmp.type); - NFA_PUT(skb, CTA_PROTO_ICMPV6_CODE, sizeof(u_int8_t), - &t->dst.u.icmp.code); - - return 0; - -nfattr_failure: - return -1; -} - -static const size_t cta_min_proto[CTA_PROTO_MAX] = { - [CTA_PROTO_ICMPV6_TYPE-1] = sizeof(u_int8_t), - [CTA_PROTO_ICMPV6_CODE-1] = sizeof(u_int8_t), - [CTA_PROTO_ICMPV6_ID-1] = sizeof(u_int16_t) -}; - -static int icmpv6_nfattr_to_tuple(struct nfattr *tb[], - struct nf_conntrack_tuple *tuple) -{ - if (!tb[CTA_PROTO_ICMPV6_TYPE-1] - || !tb[CTA_PROTO_ICMPV6_CODE-1] - || !tb[CTA_PROTO_ICMPV6_ID-1]) - return -EINVAL; - - if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto)) - return -EINVAL; - - tuple->dst.u.icmp.type = - *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_TYPE-1]); - tuple->dst.u.icmp.code = - *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_CODE-1]); - tuple->src.u.icmp.id = - *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_ICMPV6_ID-1]); - - if (tuple->dst.u.icmp.type < 128 - || tuple->dst.u.icmp.type - 128 >= sizeof(invmap) - || !invmap[tuple->dst.u.icmp.type - 128]) - return -EINVAL; - - return 0; -} -#endif - struct nf_conntrack_protocol nf_conntrack_protocol_icmpv6 = { .l3proto = PF_INET6, @@ -321,11 +267,6 @@ struct nf_conntrack_protocol nf_conntrack_protocol_icmpv6 = .packet = icmpv6_packet, .new = icmpv6_new, .error = icmpv6_error, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .tuple_to_nfattr = icmpv6_tuple_to_nfattr, - .nfattr_to_tuple = icmpv6_nfattr_to_tuple, -#endif }; EXPORT_SYMBOL(nf_conntrack_protocol_icmpv6); diff --git a/trunk/net/ipv6/netfilter/nf_conntrack_reasm.c b/trunk/net/ipv6/netfilter/nf_conntrack_reasm.c index f3e5ffbd592f..c2c52af9e560 100644 --- a/trunk/net/ipv6/netfilter/nf_conntrack_reasm.c +++ b/trunk/net/ipv6/netfilter/nf_conntrack_reasm.c @@ -98,7 +98,7 @@ struct nf_ct_frag6_queue #define FRAG6Q_HASHSZ 64 static struct nf_ct_frag6_queue *nf_ct_frag6_hash[FRAG6Q_HASHSZ]; -static DEFINE_RWLOCK(nf_ct_frag6_lock); +static rwlock_t nf_ct_frag6_lock = RW_LOCK_UNLOCKED; static u32 nf_ct_frag6_hash_rnd; static LIST_HEAD(nf_ct_frag6_lru_list); int nf_ct_frag6_nqueues = 0; @@ -371,7 +371,7 @@ nf_ct_frag6_create(unsigned int hash, u32 id, struct in6_addr *src, struct init_timer(&fq->timer); fq->timer.function = nf_ct_frag6_expire; fq->timer.data = (long) fq; - spin_lock_init(&fq->lock); + fq->lock = SPIN_LOCK_UNLOCKED; atomic_set(&fq->refcnt, 1); return nf_ct_frag6_intern(hash, fq); diff --git a/trunk/net/ipv6/raw.c b/trunk/net/ipv6/raw.c index 66f1d12ea578..a66900cda2af 100644 --- a/trunk/net/ipv6/raw.c +++ b/trunk/net/ipv6/raw.c @@ -32,7 +32,6 @@ #include #include #include -#include #include #include #include @@ -434,14 +433,25 @@ static int rawv6_recvmsg(struct kiocb *iocb, struct sock *sk, return err; csum_copy_err: - skb_kill_datagram(sk, skb, flags); + /* Clear queue. */ + if (flags&MSG_PEEK) { + int clear = 0; + spin_lock_bh(&sk->sk_receive_queue.lock); + if (skb == skb_peek(&sk->sk_receive_queue)) { + __skb_unlink(skb, &sk->sk_receive_queue); + clear = 1; + } + spin_unlock_bh(&sk->sk_receive_queue.lock); + if (clear) + kfree_skb(skb); + } /* Error for blocking case is chosen to masquerade as some normal condition. */ err = (flags&MSG_DONTWAIT) ? -EAGAIN : -EHOSTUNREACH; /* FIXME: increment a raw6 drops counter here */ - goto out; + goto out_free; } static int rawv6_push_pending_frames(struct sock *sk, struct flowi *fl, diff --git a/trunk/net/ipv6/sit.c b/trunk/net/ipv6/sit.c index 577d49732b0f..c3123c9e1a8e 100644 --- a/trunk/net/ipv6/sit.c +++ b/trunk/net/ipv6/sit.c @@ -33,7 +33,6 @@ #include #include #include -#include #include #include @@ -721,7 +720,7 @@ static void ipip6_tunnel_setup(struct net_device *dev) dev->type = ARPHRD_SIT; dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr); - dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr); + dev->mtu = 1500 - sizeof(struct iphdr); dev->flags = IFF_NOARP; dev->iflink = 0; dev->addr_len = 4; diff --git a/trunk/net/ipv6/tcp_ipv6.c b/trunk/net/ipv6/tcp_ipv6.c index 2947bc56d8a0..8827389abaf7 100644 --- a/trunk/net/ipv6/tcp_ipv6.c +++ b/trunk/net/ipv6/tcp_ipv6.c @@ -48,7 +48,6 @@ #include #include #include -#include #include #include #include @@ -60,7 +59,6 @@ #include #include #include -#include #include @@ -69,33 +67,224 @@ static void tcp_v6_send_reset(struct sk_buff *skb); static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req); -static void tcp_v6_send_check(struct sock *sk, int len, +static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len, struct sk_buff *skb); static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb); +static int tcp_v6_xmit(struct sk_buff *skb, int ipfragok); -static struct inet_connection_sock_af_ops ipv6_mapped; -static struct inet_connection_sock_af_ops ipv6_specific; +static struct tcp_func ipv6_mapped; +static struct tcp_func ipv6_specific; +static inline int tcp_v6_bind_conflict(const struct sock *sk, + const struct inet_bind_bucket *tb) +{ + const struct sock *sk2; + const struct hlist_node *node; + + /* We must walk the whole port owner list in this case. -DaveM */ + sk_for_each_bound(sk2, node, &tb->owners) { + if (sk != sk2 && + (!sk->sk_bound_dev_if || + !sk2->sk_bound_dev_if || + sk->sk_bound_dev_if == sk2->sk_bound_dev_if) && + (!sk->sk_reuse || !sk2->sk_reuse || + sk2->sk_state == TCP_LISTEN) && + ipv6_rcv_saddr_equal(sk, sk2)) + break; + } + + return node != NULL; +} + +/* Grrr, addr_type already calculated by caller, but I don't want + * to add some silly "cookie" argument to this method just for that. + * But it doesn't matter, the recalculation is in the rarest path + * this function ever takes. + */ static int tcp_v6_get_port(struct sock *sk, unsigned short snum) { - return inet_csk_get_port(&tcp_hashinfo, sk, snum, - inet6_csk_bind_conflict); + struct inet_bind_hashbucket *head; + struct inet_bind_bucket *tb; + struct hlist_node *node; + int ret; + + local_bh_disable(); + if (snum == 0) { + int low = sysctl_local_port_range[0]; + int high = sysctl_local_port_range[1]; + int remaining = (high - low) + 1; + int rover = net_random() % (high - low) + low; + + do { + head = &tcp_hashinfo.bhash[inet_bhashfn(rover, tcp_hashinfo.bhash_size)]; + spin_lock(&head->lock); + inet_bind_bucket_for_each(tb, node, &head->chain) + if (tb->port == rover) + goto next; + break; + next: + spin_unlock(&head->lock); + if (++rover > high) + rover = low; + } while (--remaining > 0); + + /* Exhausted local port range during search? It is not + * possible for us to be holding one of the bind hash + * locks if this test triggers, because if 'remaining' + * drops to zero, we broke out of the do/while loop at + * the top level, not from the 'break;' statement. + */ + ret = 1; + if (unlikely(remaining <= 0)) + goto fail; + + /* OK, here is the one we will use. */ + snum = rover; + } else { + head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)]; + spin_lock(&head->lock); + inet_bind_bucket_for_each(tb, node, &head->chain) + if (tb->port == snum) + goto tb_found; + } + tb = NULL; + goto tb_not_found; +tb_found: + if (tb && !hlist_empty(&tb->owners)) { + if (tb->fastreuse > 0 && sk->sk_reuse && + sk->sk_state != TCP_LISTEN) { + goto success; + } else { + ret = 1; + if (tcp_v6_bind_conflict(sk, tb)) + goto fail_unlock; + } + } +tb_not_found: + ret = 1; + if (tb == NULL) { + tb = inet_bind_bucket_create(tcp_hashinfo.bind_bucket_cachep, head, snum); + if (tb == NULL) + goto fail_unlock; + } + if (hlist_empty(&tb->owners)) { + if (sk->sk_reuse && sk->sk_state != TCP_LISTEN) + tb->fastreuse = 1; + else + tb->fastreuse = 0; + } else if (tb->fastreuse && + (!sk->sk_reuse || sk->sk_state == TCP_LISTEN)) + tb->fastreuse = 0; + +success: + if (!inet_csk(sk)->icsk_bind_hash) + inet_bind_hash(sk, tb, snum); + BUG_TRAP(inet_csk(sk)->icsk_bind_hash == tb); + ret = 0; + +fail_unlock: + spin_unlock(&head->lock); +fail: + local_bh_enable(); + return ret; +} + +static __inline__ void __tcp_v6_hash(struct sock *sk) +{ + struct hlist_head *list; + rwlock_t *lock; + + BUG_TRAP(sk_unhashed(sk)); + + if (sk->sk_state == TCP_LISTEN) { + list = &tcp_hashinfo.listening_hash[inet_sk_listen_hashfn(sk)]; + lock = &tcp_hashinfo.lhash_lock; + inet_listen_wlock(&tcp_hashinfo); + } else { + unsigned int hash; + sk->sk_hash = hash = inet6_sk_ehashfn(sk); + hash &= (tcp_hashinfo.ehash_size - 1); + list = &tcp_hashinfo.ehash[hash].chain; + lock = &tcp_hashinfo.ehash[hash].lock; + write_lock(lock); + } + + __sk_add_node(sk, list); + sock_prot_inc_use(sk->sk_prot); + write_unlock(lock); } + static void tcp_v6_hash(struct sock *sk) { if (sk->sk_state != TCP_CLOSE) { - if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) { + struct tcp_sock *tp = tcp_sk(sk); + + if (tp->af_specific == &ipv6_mapped) { tcp_prot.hash(sk); return; } local_bh_disable(); - __inet6_hash(&tcp_hashinfo, sk); + __tcp_v6_hash(sk); local_bh_enable(); } } +/* + * Open request hash tables. + */ + +static u32 tcp_v6_synq_hash(const struct in6_addr *raddr, const u16 rport, const u32 rnd) +{ + u32 a, b, c; + + a = raddr->s6_addr32[0]; + b = raddr->s6_addr32[1]; + c = raddr->s6_addr32[2]; + + a += JHASH_GOLDEN_RATIO; + b += JHASH_GOLDEN_RATIO; + c += rnd; + __jhash_mix(a, b, c); + + a += raddr->s6_addr32[3]; + b += (u32) rport; + __jhash_mix(a, b, c); + + return c & (TCP_SYNQ_HSIZE - 1); +} + +static struct request_sock *tcp_v6_search_req(const struct sock *sk, + struct request_sock ***prevp, + __u16 rport, + struct in6_addr *raddr, + struct in6_addr *laddr, + int iif) +{ + const struct inet_connection_sock *icsk = inet_csk(sk); + struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt; + struct request_sock *req, **prev; + + for (prev = &lopt->syn_table[tcp_v6_synq_hash(raddr, rport, lopt->hash_rnd)]; + (req = *prev) != NULL; + prev = &req->dl_next) { + const struct tcp6_request_sock *treq = tcp6_rsk(req); + + if (inet_rsk(req)->rmt_port == rport && + req->rsk_ops->family == AF_INET6 && + ipv6_addr_equal(&treq->rmt_addr, raddr) && + ipv6_addr_equal(&treq->loc_addr, laddr) && + (!treq->iif || treq->iif == iif)) { + BUG_TRAP(req->sk == NULL); + *prevp = prev; + return req; + } + } + + return NULL; +} + static __inline__ u16 tcp_v6_check(struct tcphdr *th, int len, struct in6_addr *saddr, struct in6_addr *daddr, @@ -119,12 +308,195 @@ static __u32 tcp_v6_init_sequence(struct sock *sk, struct sk_buff *skb) } } +static int __tcp_v6_check_established(struct sock *sk, const __u16 lport, + struct inet_timewait_sock **twp) +{ + struct inet_sock *inet = inet_sk(sk); + const struct ipv6_pinfo *np = inet6_sk(sk); + const struct in6_addr *daddr = &np->rcv_saddr; + const struct in6_addr *saddr = &np->daddr; + const int dif = sk->sk_bound_dev_if; + const u32 ports = INET_COMBINED_PORTS(inet->dport, lport); + unsigned int hash = inet6_ehashfn(daddr, inet->num, saddr, inet->dport); + struct inet_ehash_bucket *head = inet_ehash_bucket(&tcp_hashinfo, hash); + struct sock *sk2; + const struct hlist_node *node; + struct inet_timewait_sock *tw; + + prefetch(head->chain.first); + write_lock(&head->lock); + + /* Check TIME-WAIT sockets first. */ + sk_for_each(sk2, node, &(head + tcp_hashinfo.ehash_size)->chain) { + const struct tcp6_timewait_sock *tcp6tw = tcp6_twsk(sk2); + + tw = inet_twsk(sk2); + + if(*((__u32 *)&(tw->tw_dport)) == ports && + sk2->sk_family == PF_INET6 && + ipv6_addr_equal(&tcp6tw->tw_v6_daddr, saddr) && + ipv6_addr_equal(&tcp6tw->tw_v6_rcv_saddr, daddr) && + sk2->sk_bound_dev_if == sk->sk_bound_dev_if) { + const struct tcp_timewait_sock *tcptw = tcp_twsk(sk2); + struct tcp_sock *tp = tcp_sk(sk); + + if (tcptw->tw_ts_recent_stamp && + (!twp || + (sysctl_tcp_tw_reuse && + xtime.tv_sec - tcptw->tw_ts_recent_stamp > 1))) { + /* See comment in tcp_ipv4.c */ + tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2; + if (!tp->write_seq) + tp->write_seq = 1; + tp->rx_opt.ts_recent = tcptw->tw_ts_recent; + tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp; + sock_hold(sk2); + goto unique; + } else + goto not_unique; + } + } + tw = NULL; + + /* And established part... */ + sk_for_each(sk2, node, &head->chain) { + if (INET6_MATCH(sk2, hash, saddr, daddr, ports, dif)) + goto not_unique; + } + +unique: + BUG_TRAP(sk_unhashed(sk)); + __sk_add_node(sk, &head->chain); + sk->sk_hash = hash; + sock_prot_inc_use(sk->sk_prot); + write_unlock(&head->lock); + + if (twp) { + *twp = tw; + NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); + } else if (tw) { + /* Silly. Should hash-dance instead... */ + inet_twsk_deschedule(tw, &tcp_death_row); + NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED); + + inet_twsk_put(tw); + } + return 0; + +not_unique: + write_unlock(&head->lock); + return -EADDRNOTAVAIL; +} + +static inline u32 tcpv6_port_offset(const struct sock *sk) +{ + const struct inet_sock *inet = inet_sk(sk); + const struct ipv6_pinfo *np = inet6_sk(sk); + + return secure_tcpv6_port_ephemeral(np->rcv_saddr.s6_addr32, + np->daddr.s6_addr32, + inet->dport); +} + +static int tcp_v6_hash_connect(struct sock *sk) +{ + unsigned short snum = inet_sk(sk)->num; + struct inet_bind_hashbucket *head; + struct inet_bind_bucket *tb; + int ret; + + if (!snum) { + int low = sysctl_local_port_range[0]; + int high = sysctl_local_port_range[1]; + int range = high - low; + int i; + int port; + static u32 hint; + u32 offset = hint + tcpv6_port_offset(sk); + struct hlist_node *node; + struct inet_timewait_sock *tw = NULL; + + local_bh_disable(); + for (i = 1; i <= range; i++) { + port = low + (i + offset) % range; + head = &tcp_hashinfo.bhash[inet_bhashfn(port, tcp_hashinfo.bhash_size)]; + spin_lock(&head->lock); + + /* Does not bother with rcv_saddr checks, + * because the established check is already + * unique enough. + */ + inet_bind_bucket_for_each(tb, node, &head->chain) { + if (tb->port == port) { + BUG_TRAP(!hlist_empty(&tb->owners)); + if (tb->fastreuse >= 0) + goto next_port; + if (!__tcp_v6_check_established(sk, + port, + &tw)) + goto ok; + goto next_port; + } + } + + tb = inet_bind_bucket_create(tcp_hashinfo.bind_bucket_cachep, head, port); + if (!tb) { + spin_unlock(&head->lock); + break; + } + tb->fastreuse = -1; + goto ok; + + next_port: + spin_unlock(&head->lock); + } + local_bh_enable(); + + return -EADDRNOTAVAIL; + +ok: + hint += i; + + /* Head lock still held and bh's disabled */ + inet_bind_hash(sk, tb, port); + if (sk_unhashed(sk)) { + inet_sk(sk)->sport = htons(port); + __tcp_v6_hash(sk); + } + spin_unlock(&head->lock); + + if (tw) { + inet_twsk_deschedule(tw, &tcp_death_row); + inet_twsk_put(tw); + } + + ret = 0; + goto out; + } + + head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)]; + tb = inet_csk(sk)->icsk_bind_hash; + spin_lock_bh(&head->lock); + + if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) { + __tcp_v6_hash(sk); + spin_unlock_bh(&head->lock); + return 0; + } else { + spin_unlock(&head->lock); + /* No definite answer... Walk to established hash table */ + ret = __tcp_v6_check_established(sk, snum, NULL); +out: + local_bh_enable(); + return ret; + } +} + static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) { struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr; - struct inet_sock *inet = inet_sk(sk); - struct inet_connection_sock *icsk = inet_csk(sk); + struct inet_sock *inet = inet_sk(sk); struct ipv6_pinfo *np = inet6_sk(sk); struct tcp_sock *tp = tcp_sk(sk); struct in6_addr *saddr = NULL, *final_p = NULL, final; @@ -199,7 +571,7 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, */ if (addr_type == IPV6_ADDR_MAPPED) { - u32 exthdrlen = icsk->icsk_ext_hdr_len; + u32 exthdrlen = tp->ext_header_len; struct sockaddr_in sin; SOCK_DEBUG(sk, "connect: ipv4 mapped\n"); @@ -211,14 +583,14 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, sin.sin_port = usin->sin6_port; sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3]; - icsk->icsk_af_ops = &ipv6_mapped; + tp->af_specific = &ipv6_mapped; sk->sk_backlog_rcv = tcp_v4_do_rcv; err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin)); if (err) { - icsk->icsk_ext_hdr_len = exthdrlen; - icsk->icsk_af_ops = &ipv6_specific; + tp->ext_header_len = exthdrlen; + tp->af_specific = &ipv6_specific; sk->sk_backlog_rcv = tcp_v6_do_rcv; goto failure; } else { @@ -271,17 +643,16 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, sk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM | NETIF_F_TSO); - icsk->icsk_ext_hdr_len = 0; + tp->ext_header_len = 0; if (np->opt) - icsk->icsk_ext_hdr_len = (np->opt->opt_flen + - np->opt->opt_nflen); + tp->ext_header_len = np->opt->opt_flen + np->opt->opt_nflen; tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr); inet->dport = usin->sin6_port; tcp_set_state(sk, TCP_SYN_SENT); - err = inet6_hash_connect(&tcp_death_row, sk); + err = tcp_v6_hash_connect(sk); if (err) goto late_failure; @@ -387,7 +758,7 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, } else dst_hold(dst); - if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) { + if (tp->pmtu_cookie > dst_mtu(dst)) { tcp_sync_mss(sk, dst_mtu(dst)); tcp_simple_retransmit(sk); } /* else let the usual retransmit timer handle it */ @@ -404,8 +775,8 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, if (sock_owned_by_user(sk)) goto out; - req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr, - &hdr->saddr, inet6_iif(skb)); + req = tcp_v6_search_req(sk, &prev, th->dest, &hdr->daddr, + &hdr->saddr, inet6_iif(skb)); if (!req) goto out; @@ -451,7 +822,7 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt, static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req, struct dst_entry *dst) { - struct inet6_request_sock *treq = inet6_rsk(req); + struct tcp6_request_sock *treq = tcp6_rsk(req); struct ipv6_pinfo *np = inet6_sk(sk); struct sk_buff * skb; struct ipv6_txoptions *opt = NULL; @@ -517,8 +888,8 @@ static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req, static void tcp_v6_reqsk_destructor(struct request_sock *req) { - if (inet6_rsk(req)->pktopts) - kfree_skb(inet6_rsk(req)->pktopts); + if (tcp6_rsk(req)->pktopts) + kfree_skb(tcp6_rsk(req)->pktopts); } static struct request_sock_ops tcp6_request_sock_ops = { @@ -530,15 +901,26 @@ static struct request_sock_ops tcp6_request_sock_ops = { .send_reset = tcp_v6_send_reset }; -static struct timewait_sock_ops tcp6_timewait_sock_ops = { - .twsk_obj_size = sizeof(struct tcp6_timewait_sock), - .twsk_unique = tcp_twsk_unique, -}; +static int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb) +{ + struct ipv6_pinfo *np = inet6_sk(sk); + struct inet6_skb_parm *opt = IP6CB(skb); + + if (np->rxopt.all) { + if ((opt->hop && (np->rxopt.bits.hopopts || np->rxopt.bits.ohopopts)) || + ((IPV6_FLOWINFO_MASK & *(u32*)skb->nh.raw) && np->rxopt.bits.rxflow) || + (opt->srcrt && (np->rxopt.bits.srcrt || np->rxopt.bits.osrcrt)) || + ((opt->dst1 || opt->dst0) && (np->rxopt.bits.dstopts || np->rxopt.bits.odstopts))) + return 1; + } + return 0; +} -static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb) + +static void tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len, + struct sk_buff *skb) { struct ipv6_pinfo *np = inet6_sk(sk); - struct tcphdr *th = skb->h.th; if (skb->ip_summed == CHECKSUM_HW) { th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0); @@ -709,9 +1091,8 @@ static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb) struct sock *nsk; /* Find possible connection requests. */ - req = inet6_csk_search_req(sk, &prev, th->source, - &skb->nh.ipv6h->saddr, - &skb->nh.ipv6h->daddr, inet6_iif(skb)); + req = tcp_v6_search_req(sk, &prev, th->source, &skb->nh.ipv6h->saddr, + &skb->nh.ipv6h->daddr, inet6_iif(skb)); if (req) return tcp_check_req(sk, skb, req, prev); @@ -735,12 +1116,23 @@ static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb) return sk; } +static void tcp_v6_synq_add(struct sock *sk, struct request_sock *req) +{ + struct inet_connection_sock *icsk = inet_csk(sk); + struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt; + const u32 h = tcp_v6_synq_hash(&tcp6_rsk(req)->rmt_addr, inet_rsk(req)->rmt_port, lopt->hash_rnd); + + reqsk_queue_hash_req(&icsk->icsk_accept_queue, h, req, TCP_TIMEOUT_INIT); + inet_csk_reqsk_queue_added(sk, TCP_TIMEOUT_INIT); +} + + /* FIXME: this is substantially similar to the ipv4 code. * Can some kind of merge be done? -- erics */ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) { - struct inet6_request_sock *treq; + struct tcp6_request_sock *treq; struct ipv6_pinfo *np = inet6_sk(sk); struct tcp_options_received tmp_opt; struct tcp_sock *tp = tcp_sk(sk); @@ -765,7 +1157,7 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) goto drop; - req = inet6_reqsk_alloc(&tcp6_request_sock_ops); + req = reqsk_alloc(&tcp6_request_sock_ops); if (req == NULL) goto drop; @@ -778,7 +1170,7 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) tmp_opt.tstamp_ok = tmp_opt.saw_tstamp; tcp_openreq_init(req, &tmp_opt, skb); - treq = inet6_rsk(req); + treq = tcp6_rsk(req); ipv6_addr_copy(&treq->rmt_addr, &skb->nh.ipv6h->saddr); ipv6_addr_copy(&treq->loc_addr, &skb->nh.ipv6h->daddr); TCP_ECN_create_request(req, skb->h.th); @@ -804,7 +1196,8 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb) if (tcp_v6_send_synack(sk, req, NULL)) goto drop; - inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT); + tcp_v6_synq_add(sk, req); + return 0; drop: @@ -819,7 +1212,7 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb, struct request_sock *req, struct dst_entry *dst) { - struct inet6_request_sock *treq = inet6_rsk(req); + struct tcp6_request_sock *treq = tcp6_rsk(req); struct ipv6_pinfo *newnp, *np = inet6_sk(sk); struct tcp6_sock *newtcp6sk; struct inet_sock *newinet; @@ -854,7 +1247,7 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb, ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr); - inet_csk(newsk)->icsk_af_ops = &ipv6_mapped; + newtp->af_specific = &ipv6_mapped; newsk->sk_backlog_rcv = tcp_v4_do_rcv; newnp->pktoptions = NULL; newnp->opt = NULL; @@ -868,10 +1261,10 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb, */ /* It is tricky place. Until this moment IPv4 tcp - worked with IPv6 icsk.icsk_af_ops. + worked with IPv6 af_tcp.af_specific. Sync it now. */ - tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie); + tcp_sync_mss(newsk, newtp->pmtu_cookie); return newsk; } @@ -978,10 +1371,10 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb, sock_kfree_s(sk, opt, opt->tot_len); } - inet_csk(newsk)->icsk_ext_hdr_len = 0; + newtp->ext_header_len = 0; if (newnp->opt) - inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen + - newnp->opt->opt_flen); + newtp->ext_header_len = newnp->opt->opt_nflen + + newnp->opt->opt_flen; tcp_sync_mss(newsk, dst_mtu(dst)); newtp->advmss = dst_metric(dst, RTAX_ADVMSS); @@ -989,7 +1382,7 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb, newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6; - __inet6_hash(&tcp_hashinfo, newsk); + __tcp_v6_hash(newsk); inet_inherit_port(&tcp_hashinfo, sk, newsk); return newsk; @@ -1286,16 +1679,139 @@ static int tcp_v6_rcv(struct sk_buff **pskb, unsigned int *nhoffp) goto discard_it; } +static int tcp_v6_rebuild_header(struct sock *sk) +{ + int err; + struct dst_entry *dst; + struct ipv6_pinfo *np = inet6_sk(sk); + + dst = __sk_dst_check(sk, np->dst_cookie); + + if (dst == NULL) { + struct inet_sock *inet = inet_sk(sk); + struct in6_addr *final_p = NULL, final; + struct flowi fl; + + memset(&fl, 0, sizeof(fl)); + fl.proto = IPPROTO_TCP; + ipv6_addr_copy(&fl.fl6_dst, &np->daddr); + ipv6_addr_copy(&fl.fl6_src, &np->saddr); + fl.fl6_flowlabel = np->flow_label; + fl.oif = sk->sk_bound_dev_if; + fl.fl_ip_dport = inet->dport; + fl.fl_ip_sport = inet->sport; + + if (np->opt && np->opt->srcrt) { + struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt; + ipv6_addr_copy(&final, &fl.fl6_dst); + ipv6_addr_copy(&fl.fl6_dst, rt0->addr); + final_p = &final; + } + + err = ip6_dst_lookup(sk, &dst, &fl); + if (err) { + sk->sk_route_caps = 0; + return err; + } + if (final_p) + ipv6_addr_copy(&fl.fl6_dst, final_p); + + if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) { + sk->sk_err_soft = -err; + return err; + } + + ip6_dst_store(sk, dst, NULL); + sk->sk_route_caps = dst->dev->features & + ~(NETIF_F_IP_CSUM | NETIF_F_TSO); + } + + return 0; +} + +static int tcp_v6_xmit(struct sk_buff *skb, int ipfragok) +{ + struct sock *sk = skb->sk; + struct inet_sock *inet = inet_sk(sk); + struct ipv6_pinfo *np = inet6_sk(sk); + struct flowi fl; + struct dst_entry *dst; + struct in6_addr *final_p = NULL, final; + + memset(&fl, 0, sizeof(fl)); + fl.proto = IPPROTO_TCP; + ipv6_addr_copy(&fl.fl6_dst, &np->daddr); + ipv6_addr_copy(&fl.fl6_src, &np->saddr); + fl.fl6_flowlabel = np->flow_label; + IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel); + fl.oif = sk->sk_bound_dev_if; + fl.fl_ip_sport = inet->sport; + fl.fl_ip_dport = inet->dport; + + if (np->opt && np->opt->srcrt) { + struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt; + ipv6_addr_copy(&final, &fl.fl6_dst); + ipv6_addr_copy(&fl.fl6_dst, rt0->addr); + final_p = &final; + } + + dst = __sk_dst_check(sk, np->dst_cookie); + + if (dst == NULL) { + int err = ip6_dst_lookup(sk, &dst, &fl); + + if (err) { + sk->sk_err_soft = -err; + return err; + } + + if (final_p) + ipv6_addr_copy(&fl.fl6_dst, final_p); + + if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) { + sk->sk_route_caps = 0; + return err; + } + + ip6_dst_store(sk, dst, NULL); + sk->sk_route_caps = dst->dev->features & + ~(NETIF_F_IP_CSUM | NETIF_F_TSO); + } + + skb->dst = dst_clone(dst); + + /* Restore final destination back after routing done */ + ipv6_addr_copy(&fl.fl6_dst, &np->daddr); + + return ip6_xmit(sk, skb, &fl, np->opt, 0); +} + +static void v6_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr) +{ + struct ipv6_pinfo *np = inet6_sk(sk); + struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) uaddr; + + sin6->sin6_family = AF_INET6; + ipv6_addr_copy(&sin6->sin6_addr, &np->daddr); + sin6->sin6_port = inet_sk(sk)->dport; + /* We do not store received flowlabel for TCP */ + sin6->sin6_flowinfo = 0; + sin6->sin6_scope_id = 0; + if (sk->sk_bound_dev_if && + ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) + sin6->sin6_scope_id = sk->sk_bound_dev_if; +} + static int tcp_v6_remember_stamp(struct sock *sk) { /* Alas, not yet... */ return 0; } -static struct inet_connection_sock_af_ops ipv6_specific = { - .queue_xmit = inet6_csk_xmit, +static struct tcp_func ipv6_specific = { + .queue_xmit = tcp_v6_xmit, .send_check = tcp_v6_send_check, - .rebuild_header = inet6_sk_rebuild_header, + .rebuild_header = tcp_v6_rebuild_header, .conn_request = tcp_v6_conn_request, .syn_recv_sock = tcp_v6_syn_recv_sock, .remember_stamp = tcp_v6_remember_stamp, @@ -1303,7 +1819,7 @@ static struct inet_connection_sock_af_ops ipv6_specific = { .setsockopt = ipv6_setsockopt, .getsockopt = ipv6_getsockopt, - .addr2sockaddr = inet6_csk_addr2sockaddr, + .addr2sockaddr = v6_addr2sockaddr, .sockaddr_len = sizeof(struct sockaddr_in6) }; @@ -1311,7 +1827,7 @@ static struct inet_connection_sock_af_ops ipv6_specific = { * TCP over IPv4 via INET6 API */ -static struct inet_connection_sock_af_ops ipv6_mapped = { +static struct tcp_func ipv6_mapped = { .queue_xmit = ip_queue_xmit, .send_check = tcp_v4_send_check, .rebuild_header = inet_sk_rebuild_header, @@ -1322,7 +1838,7 @@ static struct inet_connection_sock_af_ops ipv6_mapped = { .setsockopt = ipv6_setsockopt, .getsockopt = ipv6_getsockopt, - .addr2sockaddr = inet6_csk_addr2sockaddr, + .addr2sockaddr = v6_addr2sockaddr, .sockaddr_len = sizeof(struct sockaddr_in6) }; @@ -1361,9 +1877,8 @@ static int tcp_v6_init_sock(struct sock *sk) sk->sk_state = TCP_CLOSE; - icsk->icsk_af_ops = &ipv6_specific; + tp->af_specific = &ipv6_specific; icsk->icsk_ca_ops = &tcp_init_congestion_ops; - icsk->icsk_sync_mss = tcp_sync_mss; sk->sk_write_space = sk_stream_write_space; sock_set_flag(sk, SOCK_USE_WRITE_QUEUE); @@ -1385,13 +1900,14 @@ static int tcp_v6_destroy_sock(struct sock *sk) static void get_openreq6(struct seq_file *seq, struct sock *sk, struct request_sock *req, int i, int uid) { + struct in6_addr *dest, *src; int ttd = req->expires - jiffies; - struct in6_addr *src = &inet6_rsk(req)->loc_addr; - struct in6_addr *dest = &inet6_rsk(req)->rmt_addr; if (ttd < 0) ttd = 0; + src = &tcp6_rsk(req)->loc_addr; + dest = &tcp6_rsk(req)->rmt_addr; seq_printf(seq, "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X " "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n", @@ -1472,14 +1988,14 @@ static void get_timewait6_sock(struct seq_file *seq, { struct in6_addr *dest, *src; __u16 destp, srcp; - struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw); + struct tcp6_timewait_sock *tcp6tw = tcp6_twsk((struct sock *)tw); int ttd = tw->tw_ttd - jiffies; if (ttd < 0) ttd = 0; - dest = &tw6->tw_v6_daddr; - src = &tw6->tw_v6_rcv_saddr; + dest = &tcp6tw->tw_v6_daddr; + src = &tcp6tw->tw_v6_rcv_saddr; destp = ntohs(tw->tw_dport); srcp = ntohs(tw->tw_sport); @@ -1577,7 +2093,7 @@ struct proto tcpv6_prot = { .sysctl_rmem = sysctl_tcp_rmem, .max_header = MAX_TCP_HEADER, .obj_size = sizeof(struct tcp6_sock), - .twsk_prot = &tcp6_timewait_sock_ops, + .twsk_obj_size = sizeof(struct tcp6_timewait_sock), .rsk_prot = &tcp6_request_sock_ops, }; @@ -1594,8 +2110,7 @@ static struct inet_protosw tcpv6_protosw = { .ops = &inet6_stream_ops, .capability = -1, .no_check = 0, - .flags = INET_PROTOSW_PERMANENT | - INET_PROTOSW_ICSK, + .flags = INET_PROTOSW_PERMANENT, }; void __init tcpv6_init(void) diff --git a/trunk/net/ipv6/udp.c b/trunk/net/ipv6/udp.c index d8538dcea813..5cc8731eb55b 100644 --- a/trunk/net/ipv6/udp.c +++ b/trunk/net/ipv6/udp.c @@ -36,7 +36,6 @@ #include #include #include -#include #include #include @@ -301,7 +300,20 @@ static int udpv6_recvmsg(struct kiocb *iocb, struct sock *sk, return err; csum_copy_err: - skb_kill_datagram(sk, skb, flags); + /* Clear queue. */ + if (flags&MSG_PEEK) { + int clear = 0; + spin_lock_bh(&sk->sk_receive_queue.lock); + if (skb == skb_peek(&sk->sk_receive_queue)) { + __skb_unlink(skb, &sk->sk_receive_queue); + clear = 1; + } + spin_unlock_bh(&sk->sk_receive_queue.lock); + if (clear) + kfree_skb(skb); + } + + skb_free_datagram(sk, skb); if (flags & MSG_DONTWAIT) { UDP6_INC_STATS_USER(UDP_MIB_INERRORS); diff --git a/trunk/net/ipx/af_ipx.c b/trunk/net/ipx/af_ipx.c index 0dc519b40404..34b3bb868409 100644 --- a/trunk/net/ipx/af_ipx.c +++ b/trunk/net/ipx/af_ipx.c @@ -75,7 +75,7 @@ static struct datalink_proto *pEII_datalink; static struct datalink_proto *p8023_datalink; static struct datalink_proto *pSNAP_datalink; -static const struct proto_ops ipx_dgram_ops; +static struct proto_ops ipx_dgram_ops; LIST_HEAD(ipx_interfaces); DEFINE_SPINLOCK(ipx_interfaces_lock); @@ -1884,7 +1884,7 @@ static int ipx_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) rc = -EINVAL; break; default: - rc = -ENOIOCTLCMD; + rc = dev_ioctl(cmd, argp); break; } @@ -1901,7 +1901,7 @@ static struct net_proto_family ipx_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops SOCKOPS_WRAPPED(ipx_dgram_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(ipx_dgram_ops) = { .family = PF_IPX, .owner = THIS_MODULE, .release = ipx_release, diff --git a/trunk/net/irda/af_irda.c b/trunk/net/irda/af_irda.c index fbfa96754417..6f92f9c62990 100644 --- a/trunk/net/irda/af_irda.c +++ b/trunk/net/irda/af_irda.c @@ -62,12 +62,12 @@ static int irda_create(struct socket *sock, int protocol); -static const struct proto_ops irda_stream_ops; -static const struct proto_ops irda_seqpacket_ops; -static const struct proto_ops irda_dgram_ops; +static struct proto_ops irda_stream_ops; +static struct proto_ops irda_seqpacket_ops; +static struct proto_ops irda_dgram_ops; #ifdef CONFIG_IRDA_ULTRA -static const struct proto_ops irda_ultra_ops; +static struct proto_ops irda_ultra_ops; #define ULTRA_MAX_DATA 382 #endif /* CONFIG_IRDA_ULTRA */ @@ -1438,9 +1438,8 @@ static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock, /* * POSIX 1003.1g mandates this order. */ - ret = sock_error(sk); - if (ret) - break; + if (sk->sk_err) + ret = sock_error(sk); else if (sk->sk_shutdown & RCV_SHUTDOWN) ; else if (noblock) @@ -1822,7 +1821,7 @@ static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) return -EINVAL; default: IRDA_DEBUG(1, "%s(), doing device ioctl!\n", __FUNCTION__); - return -ENOIOCTLCMD; + return dev_ioctl(cmd, (void __user *) arg); } /*NOTREACHED*/ @@ -2464,7 +2463,7 @@ static struct net_proto_family irda_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops SOCKOPS_WRAPPED(irda_stream_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(irda_stream_ops) = { .family = PF_IRDA, .owner = THIS_MODULE, .release = irda_release, @@ -2485,7 +2484,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_stream_ops) = { .sendpage = sock_no_sendpage, }; -static const struct proto_ops SOCKOPS_WRAPPED(irda_seqpacket_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(irda_seqpacket_ops) = { .family = PF_IRDA, .owner = THIS_MODULE, .release = irda_release, @@ -2506,7 +2505,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_seqpacket_ops) = { .sendpage = sock_no_sendpage, }; -static const struct proto_ops SOCKOPS_WRAPPED(irda_dgram_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(irda_dgram_ops) = { .family = PF_IRDA, .owner = THIS_MODULE, .release = irda_release, @@ -2528,7 +2527,7 @@ static const struct proto_ops SOCKOPS_WRAPPED(irda_dgram_ops) = { }; #ifdef CONFIG_IRDA_ULTRA -static const struct proto_ops SOCKOPS_WRAPPED(irda_ultra_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(irda_ultra_ops) = { .family = PF_IRDA, .owner = THIS_MODULE, .release = irda_release, diff --git a/trunk/net/irda/iriap.c b/trunk/net/irda/iriap.c index 254f90746900..b8bb78af8b8a 100644 --- a/trunk/net/irda/iriap.c +++ b/trunk/net/irda/iriap.c @@ -364,7 +364,7 @@ static void iriap_disconnect_request(struct iriap_cb *self) /* * Function iriap_getvaluebyclass (addr, name, attr) * - * Retrieve all values from attribute in all objects with given class + * Retreive all values from attribute in all objects with given class * name */ int iriap_getvaluebyclass_request(struct iriap_cb *self, diff --git a/trunk/net/key/af_key.c b/trunk/net/key/af_key.c index 52efd04cbedb..39031684b65c 100644 --- a/trunk/net/key/af_key.c +++ b/trunk/net/key/af_key.c @@ -113,7 +113,7 @@ static __inline__ void pfkey_unlock_table(void) } -static const struct proto_ops pfkey_ops; +static struct proto_ops pfkey_ops; static void pfkey_insert(struct sock *sk) { @@ -336,7 +336,6 @@ static u8 sadb_ext_min_len[] = { [SADB_X_EXT_NAT_T_SPORT] = (u8) sizeof(struct sadb_x_nat_t_port), [SADB_X_EXT_NAT_T_DPORT] = (u8) sizeof(struct sadb_x_nat_t_port), [SADB_X_EXT_NAT_T_OA] = (u8) sizeof(struct sadb_address), - [SADB_X_EXT_SEC_CTX] = (u8) sizeof(struct sadb_x_sec_ctx), }; /* Verify sadb_address_{len,prefixlen} against sa_family. */ @@ -384,55 +383,6 @@ static int verify_address_len(void *p) return 0; } -static inline int pfkey_sec_ctx_len(struct sadb_x_sec_ctx *sec_ctx) -{ - int len = 0; - - len += sizeof(struct sadb_x_sec_ctx); - len += sec_ctx->sadb_x_ctx_len; - len += sizeof(uint64_t) - 1; - len /= sizeof(uint64_t); - - return len; -} - -static inline int verify_sec_ctx_len(void *p) -{ - struct sadb_x_sec_ctx *sec_ctx = (struct sadb_x_sec_ctx *)p; - int len; - - if (sec_ctx->sadb_x_ctx_len > PAGE_SIZE) - return -EINVAL; - - len = pfkey_sec_ctx_len(sec_ctx); - - if (sec_ctx->sadb_x_sec_len != len) - return -EINVAL; - - return 0; -} - -static inline struct xfrm_user_sec_ctx *pfkey_sadb2xfrm_user_sec_ctx(struct sadb_x_sec_ctx *sec_ctx) -{ - struct xfrm_user_sec_ctx *uctx = NULL; - int ctx_size = sec_ctx->sadb_x_ctx_len; - - uctx = kmalloc((sizeof(*uctx)+ctx_size), GFP_KERNEL); - - if (!uctx) - return NULL; - - uctx->len = pfkey_sec_ctx_len(sec_ctx); - uctx->exttype = sec_ctx->sadb_x_sec_exttype; - uctx->ctx_doi = sec_ctx->sadb_x_ctx_doi; - uctx->ctx_alg = sec_ctx->sadb_x_ctx_alg; - uctx->ctx_len = sec_ctx->sadb_x_ctx_len; - memcpy(uctx + 1, sec_ctx + 1, - uctx->ctx_len); - - return uctx; -} - static int present_and_same_family(struct sadb_address *src, struct sadb_address *dst) { @@ -488,10 +438,6 @@ static int parse_exthdrs(struct sk_buff *skb, struct sadb_msg *hdr, void **ext_h if (verify_address_len(p)) return -EINVAL; } - if (ext_type == SADB_X_EXT_SEC_CTX) { - if (verify_sec_ctx_len(p)) - return -EINVAL; - } ext_hdrs[ext_type-1] = p; } p += ext_len; @@ -640,9 +586,6 @@ static struct sk_buff * pfkey_xfrm_state2msg(struct xfrm_state *x, int add_keys, struct sadb_key *key; struct sadb_x_sa2 *sa2; struct sockaddr_in *sin; - struct sadb_x_sec_ctx *sec_ctx; - struct xfrm_sec_ctx *xfrm_ctx; - int ctx_size = 0; #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) struct sockaddr_in6 *sin6; #endif @@ -666,12 +609,6 @@ static struct sk_buff * pfkey_xfrm_state2msg(struct xfrm_state *x, int add_keys, sizeof(struct sadb_address)*2 + sockaddr_size*2 + sizeof(struct sadb_x_sa2); - - if ((xfrm_ctx = x->security)) { - ctx_size = PFKEY_ALIGN8(xfrm_ctx->ctx_len); - size += sizeof(struct sadb_x_sec_ctx) + ctx_size; - } - /* identity & sensitivity */ if ((x->props.family == AF_INET && @@ -962,20 +899,6 @@ static struct sk_buff * pfkey_xfrm_state2msg(struct xfrm_state *x, int add_keys, n_port->sadb_x_nat_t_port_reserved = 0; } - /* security context */ - if (xfrm_ctx) { - sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb, - sizeof(struct sadb_x_sec_ctx) + ctx_size); - sec_ctx->sadb_x_sec_len = - (sizeof(struct sadb_x_sec_ctx) + ctx_size) / sizeof(uint64_t); - sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX; - sec_ctx->sadb_x_ctx_doi = xfrm_ctx->ctx_doi; - sec_ctx->sadb_x_ctx_alg = xfrm_ctx->ctx_alg; - sec_ctx->sadb_x_ctx_len = xfrm_ctx->ctx_len; - memcpy(sec_ctx + 1, xfrm_ctx->ctx_str, - xfrm_ctx->ctx_len); - } - return skb; } @@ -986,7 +909,6 @@ static struct xfrm_state * pfkey_msg2xfrm_state(struct sadb_msg *hdr, struct sadb_lifetime *lifetime; struct sadb_sa *sa; struct sadb_key *key; - struct sadb_x_sec_ctx *sec_ctx; uint16_t proto; int err; @@ -1071,21 +993,6 @@ static struct xfrm_state * pfkey_msg2xfrm_state(struct sadb_msg *hdr, x->lft.soft_add_expires_seconds = lifetime->sadb_lifetime_addtime; x->lft.soft_use_expires_seconds = lifetime->sadb_lifetime_usetime; } - - sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1]; - if (sec_ctx != NULL) { - struct xfrm_user_sec_ctx *uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx); - - if (!uctx) - goto out; - - err = security_xfrm_state_alloc(x, uctx); - kfree(uctx); - - if (err) - goto out; - } - key = (struct sadb_key*) ext_hdrs[SADB_EXT_KEY_AUTH-1]; if (sa->sadb_sa_auth) { int keysize = 0; @@ -1813,18 +1720,6 @@ parse_ipsecrequests(struct xfrm_policy *xp, struct sadb_x_policy *pol) return 0; } -static inline int pfkey_xfrm_policy2sec_ctx_size(struct xfrm_policy *xp) -{ - struct xfrm_sec_ctx *xfrm_ctx = xp->security; - - if (xfrm_ctx) { - int len = sizeof(struct sadb_x_sec_ctx); - len += xfrm_ctx->ctx_len; - return PFKEY_ALIGN8(len); - } - return 0; -} - static int pfkey_xfrm_policy2msg_size(struct xfrm_policy *xp) { int sockaddr_size = pfkey_sockaddr_size(xp->family); @@ -1838,8 +1733,7 @@ static int pfkey_xfrm_policy2msg_size(struct xfrm_policy *xp) (sockaddr_size * 2) + sizeof(struct sadb_x_policy) + (xp->xfrm_nr * (sizeof(struct sadb_x_ipsecrequest) + - (socklen * 2))) + - pfkey_xfrm_policy2sec_ctx_size(xp); + (socklen * 2))); } static struct sk_buff * pfkey_xfrm_policy2msg_prep(struct xfrm_policy *xp) @@ -1863,8 +1757,6 @@ static void pfkey_xfrm_policy2msg(struct sk_buff *skb, struct xfrm_policy *xp, i struct sadb_lifetime *lifetime; struct sadb_x_policy *pol; struct sockaddr_in *sin; - struct sadb_x_sec_ctx *sec_ctx; - struct xfrm_sec_ctx *xfrm_ctx; #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) struct sockaddr_in6 *sin6; #endif @@ -2049,21 +1941,6 @@ static void pfkey_xfrm_policy2msg(struct sk_buff *skb, struct xfrm_policy *xp, i } } } - - /* security context */ - if ((xfrm_ctx = xp->security)) { - int ctx_size = pfkey_xfrm_policy2sec_ctx_size(xp); - - sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb, ctx_size); - sec_ctx->sadb_x_sec_len = ctx_size / sizeof(uint64_t); - sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX; - sec_ctx->sadb_x_ctx_doi = xfrm_ctx->ctx_doi; - sec_ctx->sadb_x_ctx_alg = xfrm_ctx->ctx_alg; - sec_ctx->sadb_x_ctx_len = xfrm_ctx->ctx_len; - memcpy(sec_ctx + 1, xfrm_ctx->ctx_str, - xfrm_ctx->ctx_len); - } - hdr->sadb_msg_len = size / sizeof(uint64_t); hdr->sadb_msg_reserved = atomic_read(&xp->refcnt); } @@ -2099,13 +1976,12 @@ static int key_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs) { - int err = 0; + int err; struct sadb_lifetime *lifetime; struct sadb_address *sa; struct sadb_x_policy *pol; struct xfrm_policy *xp; struct km_event c; - struct sadb_x_sec_ctx *sec_ctx; if (!present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1], ext_hdrs[SADB_EXT_ADDRESS_DST-1]) || @@ -2152,22 +2028,6 @@ static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h if (xp->selector.dport) xp->selector.dport_mask = ~0; - sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1]; - if (sec_ctx != NULL) { - struct xfrm_user_sec_ctx *uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx); - - if (!uctx) { - err = -ENOBUFS; - goto out; - } - - err = security_xfrm_policy_alloc(xp, uctx); - kfree(uctx); - - if (err) - goto out; - } - xp->lft.soft_byte_limit = XFRM_INF; xp->lft.hard_byte_limit = XFRM_INF; xp->lft.soft_packet_limit = XFRM_INF; @@ -2191,9 +2051,10 @@ static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h err = xfrm_policy_insert(pol->sadb_x_policy_dir-1, xp, hdr->sadb_msg_type != SADB_X_SPDUPDATE); - - if (err) - goto out; + if (err) { + kfree(xp); + return err; + } if (hdr->sadb_msg_type == SADB_X_SPDUPDATE) c.event = XFRM_MSG_UPDPOLICY; @@ -2208,7 +2069,6 @@ static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *h return 0; out: - security_xfrm_policy_free(xp); kfree(xp); return err; } @@ -2218,10 +2078,9 @@ static int pfkey_spddelete(struct sock *sk, struct sk_buff *skb, struct sadb_msg int err; struct sadb_address *sa; struct sadb_x_policy *pol; - struct xfrm_policy *xp, tmp; + struct xfrm_policy *xp; struct xfrm_selector sel; struct km_event c; - struct sadb_x_sec_ctx *sec_ctx; if (!present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1], ext_hdrs[SADB_EXT_ADDRESS_DST-1]) || @@ -2250,24 +2109,7 @@ static int pfkey_spddelete(struct sock *sk, struct sk_buff *skb, struct sadb_msg if (sel.dport) sel.dport_mask = ~0; - sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1]; - memset(&tmp, 0, sizeof(struct xfrm_policy)); - - if (sec_ctx != NULL) { - struct xfrm_user_sec_ctx *uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx); - - if (!uctx) - return -ENOMEM; - - err = security_xfrm_policy_alloc(&tmp, uctx); - kfree(uctx); - - if (err) - return err; - } - - xp = xfrm_policy_bysel_ctx(pol->sadb_x_policy_dir-1, &sel, tmp.security, 1); - security_xfrm_policy_free(&tmp); + xp = xfrm_policy_bysel(pol->sadb_x_policy_dir-1, &sel, 1); if (xp == NULL) return -ENOENT; @@ -2818,7 +2660,6 @@ static struct xfrm_policy *pfkey_compile_policy(u16 family, int opt, { struct xfrm_policy *xp; struct sadb_x_policy *pol = (struct sadb_x_policy*)data; - struct sadb_x_sec_ctx *sec_ctx; switch (family) { case AF_INET: @@ -2868,32 +2709,10 @@ static struct xfrm_policy *pfkey_compile_policy(u16 family, int opt, (*dir = parse_ipsecrequests(xp, pol)) < 0) goto out; - /* security context too */ - if (len >= (pol->sadb_x_policy_len*8 + - sizeof(struct sadb_x_sec_ctx))) { - char *p = (char *)pol; - struct xfrm_user_sec_ctx *uctx; - - p += pol->sadb_x_policy_len*8; - sec_ctx = (struct sadb_x_sec_ctx *)p; - if (len < pol->sadb_x_policy_len*8 + - sec_ctx->sadb_x_sec_len) - goto out; - if ((*dir = verify_sec_ctx_len(p))) - goto out; - uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx); - *dir = security_xfrm_policy_alloc(xp, uctx); - kfree(uctx); - - if (*dir) - goto out; - } - *dir = pol->sadb_x_policy_dir-1; return xp; out: - security_xfrm_policy_free(xp); kfree(xp); return NULL; } @@ -3127,7 +2946,7 @@ static int pfkey_recvmsg(struct kiocb *kiocb, return err; } -static const struct proto_ops pfkey_ops = { +static struct proto_ops pfkey_ops = { .family = PF_KEY, .owner = THIS_MODULE, /* Operations that make no sense on pfkey sockets. */ diff --git a/trunk/net/llc/af_llc.c b/trunk/net/llc/af_llc.c index 8171c53bc0ed..c3f0b0783453 100644 --- a/trunk/net/llc/af_llc.c +++ b/trunk/net/llc/af_llc.c @@ -36,7 +36,7 @@ static u16 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; static u16 llc_ui_sap_link_no_max[256]; static struct sockaddr_llc llc_ui_addrnull; -static const struct proto_ops llc_ui_ops; +static struct proto_ops llc_ui_ops; static int llc_ui_wait_for_conn(struct sock *sk, long timeout); static int llc_ui_wait_for_disc(struct sock *sk, long timeout); @@ -566,9 +566,10 @@ static int llc_wait_data(struct sock *sk, long timeo) /* * POSIX 1003.1g mandates this order. */ - rc = sock_error(sk); - if (rc) + if (sk->sk_err) { + rc = sock_error(sk); break; + } rc = 0; if (sk->sk_shutdown & RCV_SHUTDOWN) break; @@ -959,7 +960,7 @@ static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr, static int llc_ui_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) { - return -ENOIOCTLCMD; + return dev_ioctl(cmd, (void __user *)arg); } /** @@ -1098,7 +1099,7 @@ static struct net_proto_family llc_ui_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops llc_ui_ops = { +static struct proto_ops llc_ui_ops = { .family = PF_LLC, .owner = THIS_MODULE, .release = llc_ui_release, diff --git a/trunk/net/netfilter/Kconfig b/trunk/net/netfilter/Kconfig index 7d55f9cbd853..794c41d19b28 100644 --- a/trunk/net/netfilter/Kconfig +++ b/trunk/net/netfilter/Kconfig @@ -95,11 +95,4 @@ config NF_CONNTRACK_FTP To compile it as a module, choose M here. If unsure, say N. -config NF_CT_NETLINK - tristate 'Connection tracking netlink interface (EXPERIMENTAL)' - depends on EXPERIMENTAL && NF_CONNTRACK && NETFILTER_NETLINK - depends on NF_CONNTRACK!=y || NETFILTER_NETLINK!=m - help - This option enables support for a netlink-based userspace interface - endmenu diff --git a/trunk/net/netfilter/Makefile b/trunk/net/netfilter/Makefile index cb2183145c37..55f019ad2c08 100644 --- a/trunk/net/netfilter/Makefile +++ b/trunk/net/netfilter/Makefile @@ -13,6 +13,3 @@ obj-$(CONFIG_NF_CONNTRACK_FTP) += nf_conntrack_ftp.o # SCTP protocol connection tracking obj-$(CONFIG_NF_CT_PROTO_SCTP) += nf_conntrack_proto_sctp.o - -# netlink interface for nf_conntrack -obj-$(CONFIG_NF_CT_NETLINK) += nf_conntrack_netlink.o diff --git a/trunk/net/netfilter/nf_conntrack_core.c b/trunk/net/netfilter/nf_conntrack_core.c index 62bb509f05d4..a7c7b490cf22 100644 --- a/trunk/net/netfilter/nf_conntrack_core.c +++ b/trunk/net/netfilter/nf_conntrack_core.c @@ -82,8 +82,6 @@ unsigned int nf_ct_log_invalid; static LIST_HEAD(unconfirmed); static int nf_conntrack_vmalloc; -static unsigned int nf_conntrack_next_id = 1; -static unsigned int nf_conntrack_expect_next_id = 1; #ifdef CONFIG_NF_CONNTRACK_EVENTS struct notifier_block *nf_conntrack_chain; struct notifier_block *nf_conntrack_expect_chain; @@ -186,7 +184,7 @@ DECLARE_MUTEX(nf_ct_cache_mutex); extern struct nf_conntrack_protocol nf_conntrack_generic_protocol; struct nf_conntrack_protocol * -__nf_ct_proto_find(u_int16_t l3proto, u_int8_t protocol) +nf_ct_find_proto(u_int16_t l3proto, u_int8_t protocol) { if (unlikely(nf_ct_protos[l3proto] == NULL)) return &nf_conntrack_generic_protocol; @@ -194,50 +192,6 @@ __nf_ct_proto_find(u_int16_t l3proto, u_int8_t protocol) return nf_ct_protos[l3proto][protocol]; } -/* this is guaranteed to always return a valid protocol helper, since - * it falls back to generic_protocol */ -struct nf_conntrack_protocol * -nf_ct_proto_find_get(u_int16_t l3proto, u_int8_t protocol) -{ - struct nf_conntrack_protocol *p; - - preempt_disable(); - p = __nf_ct_proto_find(l3proto, protocol); - if (p) { - if (!try_module_get(p->me)) - p = &nf_conntrack_generic_protocol; - } - preempt_enable(); - - return p; -} - -void nf_ct_proto_put(struct nf_conntrack_protocol *p) -{ - module_put(p->me); -} - -struct nf_conntrack_l3proto * -nf_ct_l3proto_find_get(u_int16_t l3proto) -{ - struct nf_conntrack_l3proto *p; - - preempt_disable(); - p = __nf_ct_l3proto_find(l3proto); - if (p) { - if (!try_module_get(p->me)) - p = &nf_conntrack_generic_l3proto; - } - preempt_enable(); - - return p; -} - -void nf_ct_l3proto_put(struct nf_conntrack_l3proto *p) -{ - module_put(p->me); -} - static int nf_conntrack_hash_rnd_initted; static unsigned int nf_conntrack_hash_rnd; @@ -430,7 +384,7 @@ nf_ct_invert_tuple(struct nf_conntrack_tuple *inverse, } /* nf_conntrack_expect helper functions */ -void nf_ct_unlink_expect(struct nf_conntrack_expect *exp) +static void nf_ct_unlink_expect(struct nf_conntrack_expect *exp) { ASSERT_WRITE_LOCK(&nf_conntrack_lock); NF_CT_ASSERT(!timer_pending(&exp->timeout)); @@ -450,33 +404,6 @@ static void expectation_timed_out(unsigned long ul_expect) nf_conntrack_expect_put(exp); } -struct nf_conntrack_expect * -__nf_conntrack_expect_find(const struct nf_conntrack_tuple *tuple) -{ - struct nf_conntrack_expect *i; - - list_for_each_entry(i, &nf_conntrack_expect_list, list) { - if (nf_ct_tuple_mask_cmp(tuple, &i->tuple, &i->mask)) { - atomic_inc(&i->use); - return i; - } - } - return NULL; -} - -/* Just find a expectation corresponding to a tuple. */ -struct nf_conntrack_expect * -nf_conntrack_expect_find(const struct nf_conntrack_tuple *tuple) -{ - struct nf_conntrack_expect *i; - - read_lock_bh(&nf_conntrack_lock); - i = __nf_conntrack_expect_find(tuple); - read_unlock_bh(&nf_conntrack_lock); - - return i; -} - /* If an expectation for this connection is found, it gets delete from * global list then returned. */ static struct nf_conntrack_expect * @@ -505,7 +432,7 @@ find_expectation(const struct nf_conntrack_tuple *tuple) } /* delete all expectations for this conntrack */ -void nf_ct_remove_expectations(struct nf_conn *ct) +static void remove_expectations(struct nf_conn *ct) { struct nf_conntrack_expect *i, *tmp; @@ -535,7 +462,7 @@ clean_from_lists(struct nf_conn *ct) LIST_DELETE(&nf_conntrack_hash[hr], &ct->tuplehash[IP_CT_DIR_REPLY]); /* Destroy all pending expectations */ - nf_ct_remove_expectations(ct); + remove_expectations(ct); } static void @@ -555,11 +482,12 @@ destroy_conntrack(struct nf_conntrack *nfct) /* To make sure we don't get any weird locking issues here: * destroy_conntrack() MUST NOT be called with a write lock * to nf_conntrack_lock!!! -HW */ - l3proto = __nf_ct_l3proto_find(ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.l3num); + l3proto = nf_ct_find_l3proto(ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.l3num); if (l3proto && l3proto->destroy) l3proto->destroy(ct); - proto = __nf_ct_proto_find(ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.l3num, ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.protonum); + proto = nf_ct_find_proto(ct->tuplehash[IP_CT_DIR_REPLY].tuple.src.l3num, + ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.protonum); if (proto && proto->destroy) proto->destroy(ct); @@ -571,7 +499,7 @@ destroy_conntrack(struct nf_conntrack *nfct) * except TFTP can create an expectation on the first packet, * before connection is in the list, so we need to clean here, * too. */ - nf_ct_remove_expectations(ct); + remove_expectations(ct); /* We overload first tuple to link into unconfirmed list. */ if (!nf_ct_is_confirmed(ct)) { @@ -612,7 +540,7 @@ conntrack_tuple_cmp(const struct nf_conntrack_tuple_hash *i, && nf_ct_tuple_equal(tuple, &i->tuple); } -struct nf_conntrack_tuple_hash * +static struct nf_conntrack_tuple_hash * __nf_conntrack_find(const struct nf_conntrack_tuple *tuple, const struct nf_conn *ignored_conntrack) { @@ -647,29 +575,6 @@ nf_conntrack_find_get(const struct nf_conntrack_tuple *tuple, return h; } -static void __nf_conntrack_hash_insert(struct nf_conn *ct, - unsigned int hash, - unsigned int repl_hash) -{ - ct->id = ++nf_conntrack_next_id; - list_prepend(&nf_conntrack_hash[hash], - &ct->tuplehash[IP_CT_DIR_ORIGINAL].list); - list_prepend(&nf_conntrack_hash[repl_hash], - &ct->tuplehash[IP_CT_DIR_REPLY].list); -} - -void nf_conntrack_hash_insert(struct nf_conn *ct) -{ - unsigned int hash, repl_hash; - - hash = hash_conntrack(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple); - repl_hash = hash_conntrack(&ct->tuplehash[IP_CT_DIR_REPLY].tuple); - - write_lock_bh(&nf_conntrack_lock); - __nf_conntrack_hash_insert(ct, hash, repl_hash); - write_unlock_bh(&nf_conntrack_lock); -} - /* Confirm a connection given skb; places it in hash table */ int __nf_conntrack_confirm(struct sk_buff **pskb) @@ -716,7 +621,10 @@ __nf_conntrack_confirm(struct sk_buff **pskb) /* Remove from unconfirmed list */ list_del(&ct->tuplehash[IP_CT_DIR_ORIGINAL].list); - __nf_conntrack_hash_insert(ct, hash, repl_hash); + list_prepend(&nf_conntrack_hash[hash], + &ct->tuplehash[IP_CT_DIR_ORIGINAL]); + list_prepend(&nf_conntrack_hash[repl_hash], + &ct->tuplehash[IP_CT_DIR_REPLY]); /* Timer relative to confirmation time, not original setting time, otherwise we'd get timer wrap in weird delay cases. */ @@ -800,41 +708,13 @@ static inline int helper_cmp(const struct nf_conntrack_helper *i, } static struct nf_conntrack_helper * -__nf_ct_helper_find(const struct nf_conntrack_tuple *tuple) +nf_ct_find_helper(const struct nf_conntrack_tuple *tuple) { return LIST_FIND(&helpers, helper_cmp, struct nf_conntrack_helper *, tuple); } -struct nf_conntrack_helper * -nf_ct_helper_find_get( const struct nf_conntrack_tuple *tuple) -{ - struct nf_conntrack_helper *helper; - - /* need nf_conntrack_lock to assure that helper exists until - * try_module_get() is called */ - read_lock_bh(&nf_conntrack_lock); - - helper = __nf_ct_helper_find(tuple); - if (helper) { - /* need to increase module usage count to assure helper will - * not go away while the caller is e.g. busy putting a - * conntrack in the hash that uses the helper */ - if (!try_module_get(helper->me)) - helper = NULL; - } - - read_unlock_bh(&nf_conntrack_lock); - - return helper; -} - -void nf_ct_helper_put(struct nf_conntrack_helper *helper) -{ - module_put(helper->me); -} - static struct nf_conn * __nf_conntrack_alloc(const struct nf_conntrack_tuple *orig, const struct nf_conntrack_tuple *repl, @@ -864,7 +744,7 @@ __nf_conntrack_alloc(const struct nf_conntrack_tuple *orig, /* find features needed by this conntrack. */ features = l3proto->get_features(orig); read_lock_bh(&nf_conntrack_lock); - if (__nf_ct_helper_find(repl) != NULL) + if (nf_ct_find_helper(repl) != NULL) features |= NF_CT_F_HELP; read_unlock_bh(&nf_conntrack_lock); @@ -914,7 +794,7 @@ struct nf_conn *nf_conntrack_alloc(const struct nf_conntrack_tuple *orig, { struct nf_conntrack_l3proto *l3proto; - l3proto = __nf_ct_l3proto_find(orig->src.l3num); + l3proto = nf_ct_find_l3proto(orig->src.l3num); return __nf_conntrack_alloc(orig, repl, l3proto); } @@ -973,7 +853,7 @@ init_conntrack(const struct nf_conntrack_tuple *tuple, nf_conntrack_get(&conntrack->master->ct_general); NF_CT_STAT_INC(expect_new); } else { - conntrack->helper = __nf_ct_helper_find(&repl_tuple); + conntrack->helper = nf_ct_find_helper(&repl_tuple); NF_CT_STAT_INC(new); } @@ -1067,13 +947,13 @@ nf_conntrack_in(int pf, unsigned int hooknum, struct sk_buff **pskb) return NF_ACCEPT; } - l3proto = __nf_ct_l3proto_find((u_int16_t)pf); + l3proto = nf_ct_find_l3proto((u_int16_t)pf); if ((ret = l3proto->prepare(pskb, hooknum, &dataoff, &protonum)) <= 0) { DEBUGP("not prepared to track yet or error occured\n"); return -ret; } - proto = __nf_ct_proto_find((u_int16_t)pf, protonum); + proto = nf_ct_find_proto((u_int16_t)pf, protonum); /* It may be an special packet, error, unclean... * inverse of the return code tells to the netfilter @@ -1122,9 +1002,9 @@ int nf_ct_invert_tuplepr(struct nf_conntrack_tuple *inverse, const struct nf_conntrack_tuple *orig) { return nf_ct_invert_tuple(inverse, orig, - __nf_ct_l3proto_find(orig->src.l3num), - __nf_ct_proto_find(orig->src.l3num, - orig->dst.protonum)); + nf_ct_find_l3proto(orig->src.l3num), + nf_ct_find_proto(orig->src.l3num, + orig->dst.protonum)); } /* Would two expected things clash? */ @@ -1216,7 +1096,6 @@ static void nf_conntrack_expect_insert(struct nf_conntrack_expect *exp) exp->timeout.expires = jiffies + exp->master->helper->timeout * HZ; add_timer(&exp->timeout); - exp->id = ++nf_conntrack_expect_next_id; atomic_inc(&exp->use); NF_CT_STAT_INC(expect_create); } @@ -1250,7 +1129,6 @@ static inline int refresh_timer(struct nf_conntrack_expect *i) int nf_conntrack_expect_related(struct nf_conntrack_expect *expect) { struct nf_conntrack_expect *i; - struct nf_conn *master = expect->master; int ret; DEBUGP("nf_conntrack_expect_related %p\n", related_to); @@ -1271,9 +1149,9 @@ int nf_conntrack_expect_related(struct nf_conntrack_expect *expect) } } /* Will be over limit? */ - if (master->helper->max_expected && - master->expecting >= master->helper->max_expected) - evict_oldest_expect(master); + if (expect->master->helper->max_expected && + expect->master->expecting >= expect->master->helper->max_expected) + evict_oldest_expect(expect->master); nf_conntrack_expect_insert(expect); nf_conntrack_expect_event(IPEXP_NEW, expect); @@ -1297,7 +1175,7 @@ void nf_conntrack_alter_reply(struct nf_conn *conntrack, conntrack->tuplehash[IP_CT_DIR_REPLY].tuple = *newreply; if (!conntrack->master && conntrack->expecting == 0) - conntrack->helper = __nf_ct_helper_find(newreply); + conntrack->helper = nf_ct_find_helper(newreply); write_unlock_bh(&nf_conntrack_lock); } @@ -1322,19 +1200,6 @@ int nf_conntrack_helper_register(struct nf_conntrack_helper *me) return 0; } -struct nf_conntrack_helper * -__nf_conntrack_helper_find_byname(const char *name) -{ - struct nf_conntrack_helper *h; - - list_for_each_entry(h, &helpers, list) { - if (!strcmp(h->name, name)) - return h; - } - - return NULL; -} - static inline int unhelp(struct nf_conntrack_tuple_hash *i, const struct nf_conntrack_helper *me) { @@ -1418,51 +1283,6 @@ void __nf_ct_refresh_acct(struct nf_conn *ct, nf_conntrack_event_cache(event, skb); } -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - -#include -#include - -/* Generic function for tcp/udp/sctp/dccp and alike. This needs to be - * in ip_conntrack_core, since we don't want the protocols to autoload - * or depend on ctnetlink */ -int nf_ct_port_tuple_to_nfattr(struct sk_buff *skb, - const struct nf_conntrack_tuple *tuple) -{ - NFA_PUT(skb, CTA_PROTO_SRC_PORT, sizeof(u_int16_t), - &tuple->src.u.tcp.port); - NFA_PUT(skb, CTA_PROTO_DST_PORT, sizeof(u_int16_t), - &tuple->dst.u.tcp.port); - return 0; - -nfattr_failure: - return -1; -} - -static const size_t cta_min_proto[CTA_PROTO_MAX] = { - [CTA_PROTO_SRC_PORT-1] = sizeof(u_int16_t), - [CTA_PROTO_DST_PORT-1] = sizeof(u_int16_t) -}; - -int nf_ct_port_nfattr_to_tuple(struct nfattr *tb[], - struct nf_conntrack_tuple *t) -{ - if (!tb[CTA_PROTO_SRC_PORT-1] || !tb[CTA_PROTO_DST_PORT-1]) - return -EINVAL; - - if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto)) - return -EINVAL; - - t->src.u.tcp.port = - *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_SRC_PORT-1]); - t->dst.u.tcp.port = - *(u_int16_t *)NFA_DATA(tb[CTA_PROTO_DST_PORT-1]); - - return 0; -} -#endif - /* Used by ipt_REJECT and ip6t_REJECT. */ void __nf_conntrack_attach(struct sk_buff *nskb, struct sk_buff *skb) { @@ -1545,11 +1365,6 @@ static void free_conntrack_hash(struct list_head *hash, int vmalloced, int size) get_order(sizeof(struct list_head) * size)); } -void nf_conntrack_flush() -{ - nf_ct_iterate_cleanup(kill_all, NULL); -} - /* Mishearing the voices in his head, our hero wonders how he's supposed to kill the mall. */ void nf_conntrack_cleanup(void) @@ -1563,7 +1378,7 @@ void nf_conntrack_cleanup(void) nf_ct_event_cache_flush(); i_see_dead_people: - nf_conntrack_flush(); + nf_ct_iterate_cleanup(kill_all, NULL); if (atomic_read(&nf_conntrack_count) != 0) { schedule(); goto i_see_dead_people; diff --git a/trunk/net/netfilter/nf_conntrack_ftp.c b/trunk/net/netfilter/nf_conntrack_ftp.c index d5a6eaf4a1de..65080e269f27 100644 --- a/trunk/net/netfilter/nf_conntrack_ftp.c +++ b/trunk/net/netfilter/nf_conntrack_ftp.c @@ -44,7 +44,7 @@ static unsigned int ports_c; module_param_array(ports, ushort, &ports_c, 0400); static int loose; -module_param(loose, bool, 0600); +module_param(loose, int, 0600); unsigned int (*nf_nat_ftp_hook)(struct sk_buff **pskb, enum ip_conntrack_info ctinfo, diff --git a/trunk/net/netfilter/nf_conntrack_netlink.c b/trunk/net/netfilter/nf_conntrack_netlink.c deleted file mode 100644 index 73ab16bc7d40..000000000000 --- a/trunk/net/netfilter/nf_conntrack_netlink.c +++ /dev/null @@ -1,1653 +0,0 @@ -/* Connection tracking via netlink socket. Allows for user space - * protocol helpers and general trouble making from userspace. - * - * (C) 2001 by Jay Schulist - * (C) 2002-2005 by Harald Welte - * (C) 2003 by Patrick Mchardy - * (C) 2005 by Pablo Neira Ayuso - * - * I've reworked this stuff to use attributes instead of conntrack - * structures. 5.44 am. I need more tea. --pablo 05/07/11. - * - * Initial connection tracking via netlink development funded and - * generally made possible by Network Robots, Inc. (www.networkrobots.com) - * - * Further development of this code funded by Astaro AG (http://www.astaro.com) - * - * This software may be used and distributed according to the terms - * of the GNU General Public License, incorporated herein by reference. - * - * Derived from ip_conntrack_netlink.c: Port by Pablo Neira Ayuso (05/11/14) - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -MODULE_LICENSE("GPL"); - -static char __initdata version[] = "0.92"; - -#if 0 -#define DEBUGP printk -#else -#define DEBUGP(format, args...) -#endif - - -static inline int -ctnetlink_dump_tuples_proto(struct sk_buff *skb, - const struct nf_conntrack_tuple *tuple) -{ - struct nf_conntrack_protocol *proto; - int ret = 0; - - NFA_PUT(skb, CTA_PROTO_NUM, sizeof(u_int8_t), &tuple->dst.protonum); - - /* If no protocol helper is found, this function will return the - * generic protocol helper, so proto won't *ever* be NULL */ - proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum); - if (likely(proto->tuple_to_nfattr)) - ret = proto->tuple_to_nfattr(skb, tuple); - - nf_ct_proto_put(proto); - - return ret; - -nfattr_failure: - return -1; -} - -static inline int -ctnetlink_dump_tuples(struct sk_buff *skb, - const struct nf_conntrack_tuple *tuple) -{ - struct nfattr *nest_parms; - struct nf_conntrack_l3proto *l3proto; - int ret = 0; - - l3proto = nf_ct_l3proto_find_get(tuple->src.l3num); - - nest_parms = NFA_NEST(skb, CTA_TUPLE_IP); - if (likely(l3proto->tuple_to_nfattr)) - ret = l3proto->tuple_to_nfattr(skb, tuple); - NFA_NEST_END(skb, nest_parms); - - nf_ct_l3proto_put(l3proto); - - if (unlikely(ret < 0)) - return ret; - - nest_parms = NFA_NEST(skb, CTA_TUPLE_PROTO); - ret = ctnetlink_dump_tuples_proto(skb, tuple); - NFA_NEST_END(skb, nest_parms); - - return ret; - -nfattr_failure: - return -1; -} - -static inline int -ctnetlink_dump_status(struct sk_buff *skb, const struct nf_conn *ct) -{ - u_int32_t status = htonl((u_int32_t) ct->status); - NFA_PUT(skb, CTA_STATUS, sizeof(status), &status); - return 0; - -nfattr_failure: - return -1; -} - -static inline int -ctnetlink_dump_timeout(struct sk_buff *skb, const struct nf_conn *ct) -{ - long timeout_l = ct->timeout.expires - jiffies; - u_int32_t timeout; - - if (timeout_l < 0) - timeout = 0; - else - timeout = htonl(timeout_l / HZ); - - NFA_PUT(skb, CTA_TIMEOUT, sizeof(timeout), &timeout); - return 0; - -nfattr_failure: - return -1; -} - -static inline int -ctnetlink_dump_protoinfo(struct sk_buff *skb, const struct nf_conn *ct) -{ - struct nf_conntrack_protocol *proto = nf_ct_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num, ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum); - struct nfattr *nest_proto; - int ret; - - if (!proto->to_nfattr) { - nf_ct_proto_put(proto); - return 0; - } - - nest_proto = NFA_NEST(skb, CTA_PROTOINFO); - - ret = proto->to_nfattr(skb, nest_proto, ct); - - nf_ct_proto_put(proto); - - NFA_NEST_END(skb, nest_proto); - - return ret; - -nfattr_failure: - return -1; -} - -static inline int -ctnetlink_dump_helpinfo(struct sk_buff *skb, const struct nf_conn *ct) -{ - struct nfattr *nest_helper; - - if (!ct->helper) - return 0; - - nest_helper = NFA_NEST(skb, CTA_HELP); - NFA_PUT(skb, CTA_HELP_NAME, strlen(ct->helper->name), ct->helper->name); - - if (ct->helper->to_nfattr) - ct->helper->to_nfattr(skb, ct); - - NFA_NEST_END(skb, nest_helper); - - return 0; - -nfattr_failure: - return -1; -} - -#ifdef CONFIG_NF_CT_ACCT -static inline int -ctnetlink_dump_counters(struct sk_buff *skb, const struct nf_conn *ct, - enum ip_conntrack_dir dir) -{ - enum ctattr_type type = dir ? CTA_COUNTERS_REPLY: CTA_COUNTERS_ORIG; - struct nfattr *nest_count = NFA_NEST(skb, type); - u_int32_t tmp; - - tmp = htonl(ct->counters[dir].packets); - NFA_PUT(skb, CTA_COUNTERS32_PACKETS, sizeof(u_int32_t), &tmp); - - tmp = htonl(ct->counters[dir].bytes); - NFA_PUT(skb, CTA_COUNTERS32_BYTES, sizeof(u_int32_t), &tmp); - - NFA_NEST_END(skb, nest_count); - - return 0; - -nfattr_failure: - return -1; -} -#else -#define ctnetlink_dump_counters(a, b, c) (0) -#endif - -#ifdef CONFIG_NF_CONNTRACK_MARK -static inline int -ctnetlink_dump_mark(struct sk_buff *skb, const struct nf_conn *ct) -{ - u_int32_t mark = htonl(ct->mark); - - NFA_PUT(skb, CTA_MARK, sizeof(u_int32_t), &mark); - return 0; - -nfattr_failure: - return -1; -} -#else -#define ctnetlink_dump_mark(a, b) (0) -#endif - -static inline int -ctnetlink_dump_id(struct sk_buff *skb, const struct nf_conn *ct) -{ - u_int32_t id = htonl(ct->id); - NFA_PUT(skb, CTA_ID, sizeof(u_int32_t), &id); - return 0; - -nfattr_failure: - return -1; -} - -static inline int -ctnetlink_dump_use(struct sk_buff *skb, const struct nf_conn *ct) -{ - u_int32_t use = htonl(atomic_read(&ct->ct_general.use)); - - NFA_PUT(skb, CTA_USE, sizeof(u_int32_t), &use); - return 0; - -nfattr_failure: - return -1; -} - -#define tuple(ct, dir) (&(ct)->tuplehash[dir].tuple) - -static int -ctnetlink_fill_info(struct sk_buff *skb, u32 pid, u32 seq, - int event, int nowait, - const struct nf_conn *ct) -{ - struct nlmsghdr *nlh; - struct nfgenmsg *nfmsg; - struct nfattr *nest_parms; - unsigned char *b; - - b = skb->tail; - - event |= NFNL_SUBSYS_CTNETLINK << 8; - nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg)); - nfmsg = NLMSG_DATA(nlh); - - nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0; - nfmsg->nfgen_family = - ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num; - nfmsg->version = NFNETLINK_V0; - nfmsg->res_id = 0; - - nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG); - if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0) - goto nfattr_failure; - NFA_NEST_END(skb, nest_parms); - - nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY); - if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0) - goto nfattr_failure; - NFA_NEST_END(skb, nest_parms); - - if (ctnetlink_dump_status(skb, ct) < 0 || - ctnetlink_dump_timeout(skb, ct) < 0 || - ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 || - ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0 || - ctnetlink_dump_protoinfo(skb, ct) < 0 || - ctnetlink_dump_helpinfo(skb, ct) < 0 || - ctnetlink_dump_mark(skb, ct) < 0 || - ctnetlink_dump_id(skb, ct) < 0 || - ctnetlink_dump_use(skb, ct) < 0) - goto nfattr_failure; - - nlh->nlmsg_len = skb->tail - b; - return skb->len; - -nlmsg_failure: -nfattr_failure: - skb_trim(skb, b - skb->data); - return -1; -} - -#ifdef CONFIG_NF_CONNTRACK_EVENTS -static int ctnetlink_conntrack_event(struct notifier_block *this, - unsigned long events, void *ptr) -{ - struct nlmsghdr *nlh; - struct nfgenmsg *nfmsg; - struct nfattr *nest_parms; - struct nf_conn *ct = (struct nf_conn *)ptr; - struct sk_buff *skb; - unsigned int type; - unsigned char *b; - unsigned int flags = 0, group; - - /* ignore our fake conntrack entry */ - if (ct == &nf_conntrack_untracked) - return NOTIFY_DONE; - - if (events & IPCT_DESTROY) { - type = IPCTNL_MSG_CT_DELETE; - group = NFNLGRP_CONNTRACK_DESTROY; - } else if (events & (IPCT_NEW | IPCT_RELATED)) { - type = IPCTNL_MSG_CT_NEW; - flags = NLM_F_CREATE|NLM_F_EXCL; - /* dump everything */ - events = ~0UL; - group = NFNLGRP_CONNTRACK_NEW; - } else if (events & (IPCT_STATUS | - IPCT_PROTOINFO | - IPCT_HELPER | - IPCT_HELPINFO | - IPCT_NATINFO)) { - type = IPCTNL_MSG_CT_NEW; - group = NFNLGRP_CONNTRACK_UPDATE; - } else - return NOTIFY_DONE; - - /* FIXME: Check if there are any listeners before, don't hurt performance */ - - skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC); - if (!skb) - return NOTIFY_DONE; - - b = skb->tail; - - type |= NFNL_SUBSYS_CTNETLINK << 8; - nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg)); - nfmsg = NLMSG_DATA(nlh); - - nlh->nlmsg_flags = flags; - nfmsg->nfgen_family = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num; - nfmsg->version = NFNETLINK_V0; - nfmsg->res_id = 0; - - nest_parms = NFA_NEST(skb, CTA_TUPLE_ORIG); - if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_ORIGINAL)) < 0) - goto nfattr_failure; - NFA_NEST_END(skb, nest_parms); - - nest_parms = NFA_NEST(skb, CTA_TUPLE_REPLY); - if (ctnetlink_dump_tuples(skb, tuple(ct, IP_CT_DIR_REPLY)) < 0) - goto nfattr_failure; - NFA_NEST_END(skb, nest_parms); - - /* NAT stuff is now a status flag */ - if ((events & IPCT_STATUS || events & IPCT_NATINFO) - && ctnetlink_dump_status(skb, ct) < 0) - goto nfattr_failure; - if (events & IPCT_REFRESH - && ctnetlink_dump_timeout(skb, ct) < 0) - goto nfattr_failure; - if (events & IPCT_PROTOINFO - && ctnetlink_dump_protoinfo(skb, ct) < 0) - goto nfattr_failure; - if (events & IPCT_HELPINFO - && ctnetlink_dump_helpinfo(skb, ct) < 0) - goto nfattr_failure; - - if (ctnetlink_dump_counters(skb, ct, IP_CT_DIR_ORIGINAL) < 0 || - ctnetlink_dump_counters(skb, ct, IP_CT_DIR_REPLY) < 0) - goto nfattr_failure; - - nlh->nlmsg_len = skb->tail - b; - nfnetlink_send(skb, 0, group, 0); - return NOTIFY_DONE; - -nlmsg_failure: -nfattr_failure: - kfree_skb(skb); - return NOTIFY_DONE; -} -#endif /* CONFIG_NF_CONNTRACK_EVENTS */ - -static int ctnetlink_done(struct netlink_callback *cb) -{ - DEBUGP("entered %s\n", __FUNCTION__); - return 0; -} - -#define L3PROTO(ct) ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num - -static int -ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) -{ - struct nf_conn *ct = NULL; - struct nf_conntrack_tuple_hash *h; - struct list_head *i; - u_int32_t *id = (u_int32_t *) &cb->args[1]; - struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh); - u_int8_t l3proto = nfmsg->nfgen_family; - - DEBUGP("entered %s, last bucket=%lu id=%u\n", __FUNCTION__, - cb->args[0], *id); - - read_lock_bh(&nf_conntrack_lock); - for (; cb->args[0] < nf_conntrack_htable_size; cb->args[0]++, *id = 0) { - list_for_each_prev(i, &nf_conntrack_hash[cb->args[0]]) { - h = (struct nf_conntrack_tuple_hash *) i; - if (DIRECTION(h) != IP_CT_DIR_ORIGINAL) - continue; - ct = nf_ct_tuplehash_to_ctrack(h); - /* Dump entries of a given L3 protocol number. - * If it is not specified, ie. l3proto == 0, - * then dump everything. */ - if (l3proto && L3PROTO(ct) != l3proto) - continue; - if (ct->id <= *id) - continue; - if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid, - cb->nlh->nlmsg_seq, - IPCTNL_MSG_CT_NEW, - 1, ct) < 0) - goto out; - *id = ct->id; - } - } -out: - read_unlock_bh(&nf_conntrack_lock); - - DEBUGP("leaving, last bucket=%lu id=%u\n", cb->args[0], *id); - - return skb->len; -} - -#ifdef CONFIG_NF_CT_ACCT -static int -ctnetlink_dump_table_w(struct sk_buff *skb, struct netlink_callback *cb) -{ - struct nf_conn *ct = NULL; - struct nf_conntrack_tuple_hash *h; - struct list_head *i; - u_int32_t *id = (u_int32_t *) &cb->args[1]; - struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh); - u_int8_t l3proto = nfmsg->nfgen_family; - - DEBUGP("entered %s, last bucket=%u id=%u\n", __FUNCTION__, - cb->args[0], *id); - - write_lock_bh(&nf_conntrack_lock); - for (; cb->args[0] < nf_conntrack_htable_size; cb->args[0]++, *id = 0) { - list_for_each_prev(i, &nf_conntrack_hash[cb->args[0]]) { - h = (struct nf_conntrack_tuple_hash *) i; - if (DIRECTION(h) != IP_CT_DIR_ORIGINAL) - continue; - ct = nf_ct_tuplehash_to_ctrack(h); - if (l3proto && L3PROTO(ct) != l3proto) - continue; - if (ct->id <= *id) - continue; - if (ctnetlink_fill_info(skb, NETLINK_CB(cb->skb).pid, - cb->nlh->nlmsg_seq, - IPCTNL_MSG_CT_NEW, - 1, ct) < 0) - goto out; - *id = ct->id; - - memset(&ct->counters, 0, sizeof(ct->counters)); - } - } -out: - write_unlock_bh(&nf_conntrack_lock); - - DEBUGP("leaving, last bucket=%lu id=%u\n", cb->args[0], *id); - - return skb->len; -} -#endif - -static inline int -ctnetlink_parse_tuple_ip(struct nfattr *attr, struct nf_conntrack_tuple *tuple) -{ - struct nfattr *tb[CTA_IP_MAX]; - struct nf_conntrack_l3proto *l3proto; - int ret = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - nfattr_parse_nested(tb, CTA_IP_MAX, attr); - - l3proto = nf_ct_l3proto_find_get(tuple->src.l3num); - - if (likely(l3proto->nfattr_to_tuple)) - ret = l3proto->nfattr_to_tuple(tb, tuple); - - nf_ct_l3proto_put(l3proto); - - DEBUGP("leaving\n"); - - return ret; -} - -static const size_t cta_min_proto[CTA_PROTO_MAX] = { - [CTA_PROTO_NUM-1] = sizeof(u_int8_t), -}; - -static inline int -ctnetlink_parse_tuple_proto(struct nfattr *attr, - struct nf_conntrack_tuple *tuple) -{ - struct nfattr *tb[CTA_PROTO_MAX]; - struct nf_conntrack_protocol *proto; - int ret = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - nfattr_parse_nested(tb, CTA_PROTO_MAX, attr); - - if (nfattr_bad_size(tb, CTA_PROTO_MAX, cta_min_proto)) - return -EINVAL; - - if (!tb[CTA_PROTO_NUM-1]) - return -EINVAL; - tuple->dst.protonum = *(u_int8_t *)NFA_DATA(tb[CTA_PROTO_NUM-1]); - - proto = nf_ct_proto_find_get(tuple->src.l3num, tuple->dst.protonum); - - if (likely(proto->nfattr_to_tuple)) - ret = proto->nfattr_to_tuple(tb, tuple); - - nf_ct_proto_put(proto); - - return ret; -} - -static inline int -ctnetlink_parse_tuple(struct nfattr *cda[], struct nf_conntrack_tuple *tuple, - enum ctattr_tuple type, u_int8_t l3num) -{ - struct nfattr *tb[CTA_TUPLE_MAX]; - int err; - - DEBUGP("entered %s\n", __FUNCTION__); - - memset(tuple, 0, sizeof(*tuple)); - - nfattr_parse_nested(tb, CTA_TUPLE_MAX, cda[type-1]); - - if (!tb[CTA_TUPLE_IP-1]) - return -EINVAL; - - tuple->src.l3num = l3num; - - err = ctnetlink_parse_tuple_ip(tb[CTA_TUPLE_IP-1], tuple); - if (err < 0) - return err; - - if (!tb[CTA_TUPLE_PROTO-1]) - return -EINVAL; - - err = ctnetlink_parse_tuple_proto(tb[CTA_TUPLE_PROTO-1], tuple); - if (err < 0) - return err; - - /* orig and expect tuples get DIR_ORIGINAL */ - if (type == CTA_TUPLE_REPLY) - tuple->dst.dir = IP_CT_DIR_REPLY; - else - tuple->dst.dir = IP_CT_DIR_ORIGINAL; - - NF_CT_DUMP_TUPLE(tuple); - - DEBUGP("leaving\n"); - - return 0; -} - -#ifdef CONFIG_IP_NF_NAT_NEEDED -static const size_t cta_min_protonat[CTA_PROTONAT_MAX] = { - [CTA_PROTONAT_PORT_MIN-1] = sizeof(u_int16_t), - [CTA_PROTONAT_PORT_MAX-1] = sizeof(u_int16_t), -}; - -static int ctnetlink_parse_nat_proto(struct nfattr *attr, - const struct nf_conn *ct, - struct ip_nat_range *range) -{ - struct nfattr *tb[CTA_PROTONAT_MAX]; - struct ip_nat_protocol *npt; - - DEBUGP("entered %s\n", __FUNCTION__); - - nfattr_parse_nested(tb, CTA_PROTONAT_MAX, attr); - - if (nfattr_bad_size(tb, CTA_PROTONAT_MAX, cta_min_protonat)) - return -EINVAL; - - npt = ip_nat_proto_find_get(ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum); - - if (!npt->nfattr_to_range) { - ip_nat_proto_put(npt); - return 0; - } - - /* nfattr_to_range returns 1 if it parsed, 0 if not, neg. on error */ - if (npt->nfattr_to_range(tb, range) > 0) - range->flags |= IP_NAT_RANGE_PROTO_SPECIFIED; - - ip_nat_proto_put(npt); - - DEBUGP("leaving\n"); - return 0; -} - -static const size_t cta_min_nat[CTA_NAT_MAX] = { - [CTA_NAT_MINIP-1] = sizeof(u_int32_t), - [CTA_NAT_MAXIP-1] = sizeof(u_int32_t), -}; - -static inline int -ctnetlink_parse_nat(struct nfattr *cda[], - const struct nf_conn *ct, struct ip_nat_range *range) -{ - struct nfattr *tb[CTA_NAT_MAX]; - int err; - - DEBUGP("entered %s\n", __FUNCTION__); - - memset(range, 0, sizeof(*range)); - - nfattr_parse_nested(tb, CTA_NAT_MAX, cda[CTA_NAT-1]); - - if (nfattr_bad_size(tb, CTA_NAT_MAX, cta_min_nat)) - return -EINVAL; - - if (tb[CTA_NAT_MINIP-1]) - range->min_ip = *(u_int32_t *)NFA_DATA(tb[CTA_NAT_MINIP-1]); - - if (!tb[CTA_NAT_MAXIP-1]) - range->max_ip = range->min_ip; - else - range->max_ip = *(u_int32_t *)NFA_DATA(tb[CTA_NAT_MAXIP-1]); - - if (range->min_ip) - range->flags |= IP_NAT_RANGE_MAP_IPS; - - if (!tb[CTA_NAT_PROTO-1]) - return 0; - - err = ctnetlink_parse_nat_proto(tb[CTA_NAT_PROTO-1], ct, range); - if (err < 0) - return err; - - DEBUGP("leaving\n"); - return 0; -} -#endif - -static inline int -ctnetlink_parse_help(struct nfattr *attr, char **helper_name) -{ - struct nfattr *tb[CTA_HELP_MAX]; - - DEBUGP("entered %s\n", __FUNCTION__); - - nfattr_parse_nested(tb, CTA_HELP_MAX, attr); - - if (!tb[CTA_HELP_NAME-1]) - return -EINVAL; - - *helper_name = NFA_DATA(tb[CTA_HELP_NAME-1]); - - return 0; -} - -static const size_t cta_min[CTA_MAX] = { - [CTA_STATUS-1] = sizeof(u_int32_t), - [CTA_TIMEOUT-1] = sizeof(u_int32_t), - [CTA_MARK-1] = sizeof(u_int32_t), - [CTA_USE-1] = sizeof(u_int32_t), - [CTA_ID-1] = sizeof(u_int32_t) -}; - -static int -ctnetlink_del_conntrack(struct sock *ctnl, struct sk_buff *skb, - struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) -{ - struct nf_conntrack_tuple_hash *h; - struct nf_conntrack_tuple tuple; - struct nf_conn *ct; - struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); - u_int8_t u3 = nfmsg->nfgen_family; - int err = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - if (nfattr_bad_size(cda, CTA_MAX, cta_min)) - return -EINVAL; - - if (cda[CTA_TUPLE_ORIG-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3); - else if (cda[CTA_TUPLE_REPLY-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3); - else { - /* Flush the whole table */ - nf_conntrack_flush(); - return 0; - } - - if (err < 0) - return err; - - h = nf_conntrack_find_get(&tuple, NULL); - if (!h) { - DEBUGP("tuple not found in conntrack hash\n"); - return -ENOENT; - } - - ct = nf_ct_tuplehash_to_ctrack(h); - - if (cda[CTA_ID-1]) { - u_int32_t id = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_ID-1])); - if (ct->id != id) { - nf_ct_put(ct); - return -ENOENT; - } - } - if (del_timer(&ct->timeout)) - ct->timeout.function((unsigned long)ct); - - nf_ct_put(ct); - DEBUGP("leaving\n"); - - return 0; -} - -static int -ctnetlink_get_conntrack(struct sock *ctnl, struct sk_buff *skb, - struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) -{ - struct nf_conntrack_tuple_hash *h; - struct nf_conntrack_tuple tuple; - struct nf_conn *ct; - struct sk_buff *skb2 = NULL; - struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); - u_int8_t u3 = nfmsg->nfgen_family; - int err = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - if (nlh->nlmsg_flags & NLM_F_DUMP) { - u32 rlen; - - if (NFNL_MSG_TYPE(nlh->nlmsg_type) == - IPCTNL_MSG_CT_GET_CTRZERO) { -#ifdef CONFIG_NF_CT_ACCT - if ((*errp = netlink_dump_start(ctnl, skb, nlh, - ctnetlink_dump_table_w, - ctnetlink_done)) != 0) - return -EINVAL; -#else - return -ENOTSUPP; -#endif - } else { - if ((*errp = netlink_dump_start(ctnl, skb, nlh, - ctnetlink_dump_table, - ctnetlink_done)) != 0) - return -EINVAL; - } - - rlen = NLMSG_ALIGN(nlh->nlmsg_len); - if (rlen > skb->len) - rlen = skb->len; - skb_pull(skb, rlen); - return 0; - } - - if (nfattr_bad_size(cda, CTA_MAX, cta_min)) - return -EINVAL; - - if (cda[CTA_TUPLE_ORIG-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_ORIG, u3); - else if (cda[CTA_TUPLE_REPLY-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_TUPLE_REPLY, u3); - else - return -EINVAL; - - if (err < 0) - return err; - - h = nf_conntrack_find_get(&tuple, NULL); - if (!h) { - DEBUGP("tuple not found in conntrack hash"); - return -ENOENT; - } - DEBUGP("tuple found\n"); - ct = nf_ct_tuplehash_to_ctrack(h); - - err = -ENOMEM; - skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); - if (!skb2) { - nf_ct_put(ct); - return -ENOMEM; - } - NETLINK_CB(skb2).dst_pid = NETLINK_CB(skb).pid; - - err = ctnetlink_fill_info(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, - IPCTNL_MSG_CT_NEW, 1, ct); - nf_ct_put(ct); - if (err <= 0) - goto free; - - err = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT); - if (err < 0) - goto out; - - DEBUGP("leaving\n"); - return 0; - -free: - kfree_skb(skb2); -out: - return err; -} - -static inline int -ctnetlink_change_status(struct nf_conn *ct, struct nfattr *cda[]) -{ - unsigned long d; - unsigned status = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_STATUS-1])); - d = ct->status ^ status; - - if (d & (IPS_EXPECTED|IPS_CONFIRMED|IPS_DYING)) - /* unchangeable */ - return -EINVAL; - - if (d & IPS_SEEN_REPLY && !(status & IPS_SEEN_REPLY)) - /* SEEN_REPLY bit can only be set */ - return -EINVAL; - - - if (d & IPS_ASSURED && !(status & IPS_ASSURED)) - /* ASSURED bit can only be set */ - return -EINVAL; - - if (cda[CTA_NAT-1]) { -#ifndef CONFIG_IP_NF_NAT_NEEDED - return -EINVAL; -#else - unsigned int hooknum; - struct ip_nat_range range; - - if (ctnetlink_parse_nat(cda, ct, &range) < 0) - return -EINVAL; - - DEBUGP("NAT: %u.%u.%u.%u-%u.%u.%u.%u:%u-%u\n", - NIPQUAD(range.min_ip), NIPQUAD(range.max_ip), - htons(range.min.all), htons(range.max.all)); - - /* This is tricky but it works. ip_nat_setup_info needs the - * hook number as parameter, so let's do the correct - * conversion and run away */ - if (status & IPS_SRC_NAT_DONE) - hooknum = NF_IP_POST_ROUTING; /* IP_NAT_MANIP_SRC */ - else if (status & IPS_DST_NAT_DONE) - hooknum = NF_IP_PRE_ROUTING; /* IP_NAT_MANIP_DST */ - else - return -EINVAL; /* Missing NAT flags */ - - DEBUGP("NAT status: %lu\n", - status & (IPS_NAT_MASK | IPS_NAT_DONE_MASK)); - - if (ip_nat_initialized(ct, HOOK2MANIP(hooknum))) - return -EEXIST; - ip_nat_setup_info(ct, &range, hooknum); - - DEBUGP("NAT status after setup_info: %lu\n", - ct->status & (IPS_NAT_MASK | IPS_NAT_DONE_MASK)); -#endif - } - - /* Be careful here, modifying NAT bits can screw up things, - * so don't let users modify them directly if they don't pass - * ip_nat_range. */ - ct->status |= status & ~(IPS_NAT_DONE_MASK | IPS_NAT_MASK); - return 0; -} - - -static inline int -ctnetlink_change_helper(struct nf_conn *ct, struct nfattr *cda[]) -{ - struct nf_conntrack_helper *helper; - char *helpname; - int err; - - DEBUGP("entered %s\n", __FUNCTION__); - - /* don't change helper of sibling connections */ - if (ct->master) - return -EINVAL; - - err = ctnetlink_parse_help(cda[CTA_HELP-1], &helpname); - if (err < 0) - return err; - - helper = __nf_conntrack_helper_find_byname(helpname); - if (!helper) { - if (!strcmp(helpname, "")) - helper = NULL; - else - return -EINVAL; - } - - if (ct->helper) { - if (!helper) { - /* we had a helper before ... */ - nf_ct_remove_expectations(ct); - ct->helper = NULL; - } else { - /* need to zero data of old helper */ - memset(&ct->help, 0, sizeof(ct->help)); - } - } - - ct->helper = helper; - - return 0; -} - -static inline int -ctnetlink_change_timeout(struct nf_conn *ct, struct nfattr *cda[]) -{ - u_int32_t timeout = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_TIMEOUT-1])); - - if (!del_timer(&ct->timeout)) - return -ETIME; - - ct->timeout.expires = jiffies + timeout * HZ; - add_timer(&ct->timeout); - - return 0; -} - -static inline int -ctnetlink_change_protoinfo(struct nf_conn *ct, struct nfattr *cda[]) -{ - struct nfattr *tb[CTA_PROTOINFO_MAX], *attr = cda[CTA_PROTOINFO-1]; - struct nf_conntrack_protocol *proto; - u_int16_t npt = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum; - u_int16_t l3num = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.l3num; - int err = 0; - - nfattr_parse_nested(tb, CTA_PROTOINFO_MAX, attr); - - proto = nf_ct_proto_find_get(l3num, npt); - - if (proto->from_nfattr) - err = proto->from_nfattr(tb, ct); - nf_ct_proto_put(proto); - - return err; -} - -static int -ctnetlink_change_conntrack(struct nf_conn *ct, struct nfattr *cda[]) -{ - int err; - - DEBUGP("entered %s\n", __FUNCTION__); - - if (cda[CTA_HELP-1]) { - err = ctnetlink_change_helper(ct, cda); - if (err < 0) - return err; - } - - if (cda[CTA_TIMEOUT-1]) { - err = ctnetlink_change_timeout(ct, cda); - if (err < 0) - return err; - } - - if (cda[CTA_STATUS-1]) { - err = ctnetlink_change_status(ct, cda); - if (err < 0) - return err; - } - - if (cda[CTA_PROTOINFO-1]) { - err = ctnetlink_change_protoinfo(ct, cda); - if (err < 0) - return err; - } - -#if defined(CONFIG_IP_NF_CONNTRACK_MARK) - if (cda[CTA_MARK-1]) - ct->mark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_MARK-1])); -#endif - - DEBUGP("all done\n"); - return 0; -} - -static int -ctnetlink_create_conntrack(struct nfattr *cda[], - struct nf_conntrack_tuple *otuple, - struct nf_conntrack_tuple *rtuple) -{ - struct nf_conn *ct; - int err = -EINVAL; - - DEBUGP("entered %s\n", __FUNCTION__); - - ct = nf_conntrack_alloc(otuple, rtuple); - if (ct == NULL || IS_ERR(ct)) - return -ENOMEM; - - if (!cda[CTA_TIMEOUT-1]) - goto err; - ct->timeout.expires = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_TIMEOUT-1])); - - ct->timeout.expires = jiffies + ct->timeout.expires * HZ; - ct->status |= IPS_CONFIRMED; - - err = ctnetlink_change_status(ct, cda); - if (err < 0) - goto err; - - if (cda[CTA_PROTOINFO-1]) { - err = ctnetlink_change_protoinfo(ct, cda); - if (err < 0) - return err; - } - -#if defined(CONFIG_IP_NF_CONNTRACK_MARK) - if (cda[CTA_MARK-1]) - ct->mark = ntohl(*(u_int32_t *)NFA_DATA(cda[CTA_MARK-1])); -#endif - - ct->helper = nf_ct_helper_find_get(rtuple); - - add_timer(&ct->timeout); - nf_conntrack_hash_insert(ct); - - if (ct->helper) - nf_ct_helper_put(ct->helper); - - DEBUGP("conntrack with id %u inserted\n", ct->id); - return 0; - -err: - nf_conntrack_free(ct); - return err; -} - -static int -ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb, - struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) -{ - struct nf_conntrack_tuple otuple, rtuple; - struct nf_conntrack_tuple_hash *h = NULL; - struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); - u_int8_t u3 = nfmsg->nfgen_family; - int err = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - if (nfattr_bad_size(cda, CTA_MAX, cta_min)) - return -EINVAL; - - if (cda[CTA_TUPLE_ORIG-1]) { - err = ctnetlink_parse_tuple(cda, &otuple, CTA_TUPLE_ORIG, u3); - if (err < 0) - return err; - } - - if (cda[CTA_TUPLE_REPLY-1]) { - err = ctnetlink_parse_tuple(cda, &rtuple, CTA_TUPLE_REPLY, u3); - if (err < 0) - return err; - } - - write_lock_bh(&nf_conntrack_lock); - if (cda[CTA_TUPLE_ORIG-1]) - h = __nf_conntrack_find(&otuple, NULL); - else if (cda[CTA_TUPLE_REPLY-1]) - h = __nf_conntrack_find(&rtuple, NULL); - - if (h == NULL) { - write_unlock_bh(&nf_conntrack_lock); - DEBUGP("no such conntrack, create new\n"); - err = -ENOENT; - if (nlh->nlmsg_flags & NLM_F_CREATE) - err = ctnetlink_create_conntrack(cda, &otuple, &rtuple); - return err; - } - /* implicit 'else' */ - - /* we only allow nat config for new conntracks */ - if (cda[CTA_NAT-1]) { - err = -EINVAL; - goto out_unlock; - } - - /* We manipulate the conntrack inside the global conntrack table lock, - * so there's no need to increase the refcount */ - DEBUGP("conntrack found\n"); - err = -EEXIST; - if (!(nlh->nlmsg_flags & NLM_F_EXCL)) - err = ctnetlink_change_conntrack(nf_ct_tuplehash_to_ctrack(h), cda); - -out_unlock: - write_unlock_bh(&nf_conntrack_lock); - return err; -} - -/*********************************************************************** - * EXPECT - ***********************************************************************/ - -static inline int -ctnetlink_exp_dump_tuple(struct sk_buff *skb, - const struct nf_conntrack_tuple *tuple, - enum ctattr_expect type) -{ - struct nfattr *nest_parms = NFA_NEST(skb, type); - - if (ctnetlink_dump_tuples(skb, tuple) < 0) - goto nfattr_failure; - - NFA_NEST_END(skb, nest_parms); - - return 0; - -nfattr_failure: - return -1; -} - -static inline int -ctnetlink_exp_dump_expect(struct sk_buff *skb, - const struct nf_conntrack_expect *exp) -{ - struct nf_conn *master = exp->master; - u_int32_t timeout = htonl((exp->timeout.expires - jiffies) / HZ); - u_int32_t id = htonl(exp->id); - - if (ctnetlink_exp_dump_tuple(skb, &exp->tuple, CTA_EXPECT_TUPLE) < 0) - goto nfattr_failure; - if (ctnetlink_exp_dump_tuple(skb, &exp->mask, CTA_EXPECT_MASK) < 0) - goto nfattr_failure; - if (ctnetlink_exp_dump_tuple(skb, - &master->tuplehash[IP_CT_DIR_ORIGINAL].tuple, - CTA_EXPECT_MASTER) < 0) - goto nfattr_failure; - - NFA_PUT(skb, CTA_EXPECT_TIMEOUT, sizeof(timeout), &timeout); - NFA_PUT(skb, CTA_EXPECT_ID, sizeof(u_int32_t), &id); - - return 0; - -nfattr_failure: - return -1; -} - -static int -ctnetlink_exp_fill_info(struct sk_buff *skb, u32 pid, u32 seq, - int event, - int nowait, - const struct nf_conntrack_expect *exp) -{ - struct nlmsghdr *nlh; - struct nfgenmsg *nfmsg; - unsigned char *b; - - b = skb->tail; - - event |= NFNL_SUBSYS_CTNETLINK_EXP << 8; - nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(struct nfgenmsg)); - nfmsg = NLMSG_DATA(nlh); - - nlh->nlmsg_flags = (nowait && pid) ? NLM_F_MULTI : 0; - nfmsg->nfgen_family = exp->tuple.src.l3num; - nfmsg->version = NFNETLINK_V0; - nfmsg->res_id = 0; - - if (ctnetlink_exp_dump_expect(skb, exp) < 0) - goto nfattr_failure; - - nlh->nlmsg_len = skb->tail - b; - return skb->len; - -nlmsg_failure: -nfattr_failure: - skb_trim(skb, b - skb->data); - return -1; -} - -#ifdef CONFIG_NF_CONNTRACK_EVENTS -static int ctnetlink_expect_event(struct notifier_block *this, - unsigned long events, void *ptr) -{ - struct nlmsghdr *nlh; - struct nfgenmsg *nfmsg; - struct nf_conntrack_expect *exp = (struct nf_conntrack_expect *)ptr; - struct sk_buff *skb; - unsigned int type; - unsigned char *b; - int flags = 0; - - if (events & IPEXP_NEW) { - type = IPCTNL_MSG_EXP_NEW; - flags = NLM_F_CREATE|NLM_F_EXCL; - } else - return NOTIFY_DONE; - - skb = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC); - if (!skb) - return NOTIFY_DONE; - - b = skb->tail; - - type |= NFNL_SUBSYS_CTNETLINK << 8; - nlh = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg)); - nfmsg = NLMSG_DATA(nlh); - - nlh->nlmsg_flags = flags; - nfmsg->nfgen_family = exp->tuple.src.l3num; - nfmsg->version = NFNETLINK_V0; - nfmsg->res_id = 0; - - if (ctnetlink_exp_dump_expect(skb, exp) < 0) - goto nfattr_failure; - - nlh->nlmsg_len = skb->tail - b; - nfnetlink_send(skb, 0, NFNLGRP_CONNTRACK_EXP_NEW, 0); - return NOTIFY_DONE; - -nlmsg_failure: -nfattr_failure: - kfree_skb(skb); - return NOTIFY_DONE; -} -#endif - -static int -ctnetlink_exp_dump_table(struct sk_buff *skb, struct netlink_callback *cb) -{ - struct nf_conntrack_expect *exp = NULL; - struct list_head *i; - u_int32_t *id = (u_int32_t *) &cb->args[0]; - struct nfgenmsg *nfmsg = NLMSG_DATA(cb->nlh); - u_int8_t l3proto = nfmsg->nfgen_family; - - DEBUGP("entered %s, last id=%llu\n", __FUNCTION__, *id); - - read_lock_bh(&nf_conntrack_lock); - list_for_each_prev(i, &nf_conntrack_expect_list) { - exp = (struct nf_conntrack_expect *) i; - if (l3proto && exp->tuple.src.l3num != l3proto) - continue; - if (exp->id <= *id) - continue; - if (ctnetlink_exp_fill_info(skb, NETLINK_CB(cb->skb).pid, - cb->nlh->nlmsg_seq, - IPCTNL_MSG_EXP_NEW, - 1, exp) < 0) - goto out; - *id = exp->id; - } -out: - read_unlock_bh(&nf_conntrack_lock); - - DEBUGP("leaving, last id=%llu\n", *id); - - return skb->len; -} - -static const size_t cta_min_exp[CTA_EXPECT_MAX] = { - [CTA_EXPECT_TIMEOUT-1] = sizeof(u_int32_t), - [CTA_EXPECT_ID-1] = sizeof(u_int32_t) -}; - -static int -ctnetlink_get_expect(struct sock *ctnl, struct sk_buff *skb, - struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) -{ - struct nf_conntrack_tuple tuple; - struct nf_conntrack_expect *exp; - struct sk_buff *skb2; - struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); - u_int8_t u3 = nfmsg->nfgen_family; - int err = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp)) - return -EINVAL; - - if (nlh->nlmsg_flags & NLM_F_DUMP) { - u32 rlen; - - if ((*errp = netlink_dump_start(ctnl, skb, nlh, - ctnetlink_exp_dump_table, - ctnetlink_done)) != 0) - return -EINVAL; - rlen = NLMSG_ALIGN(nlh->nlmsg_len); - if (rlen > skb->len) - rlen = skb->len; - skb_pull(skb, rlen); - return 0; - } - - if (cda[CTA_EXPECT_MASTER-1]) - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_MASTER, u3); - else - return -EINVAL; - - if (err < 0) - return err; - - exp = nf_conntrack_expect_find(&tuple); - if (!exp) - return -ENOENT; - - if (cda[CTA_EXPECT_ID-1]) { - u_int32_t id = *(u_int32_t *)NFA_DATA(cda[CTA_EXPECT_ID-1]); - if (exp->id != ntohl(id)) { - nf_conntrack_expect_put(exp); - return -ENOENT; - } - } - - err = -ENOMEM; - skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); - if (!skb2) - goto out; - NETLINK_CB(skb2).dst_pid = NETLINK_CB(skb).pid; - - err = ctnetlink_exp_fill_info(skb2, NETLINK_CB(skb).pid, - nlh->nlmsg_seq, IPCTNL_MSG_EXP_NEW, - 1, exp); - if (err <= 0) - goto free; - - nf_conntrack_expect_put(exp); - - return netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT); - -free: - kfree_skb(skb2); -out: - nf_conntrack_expect_put(exp); - return err; -} - -static int -ctnetlink_del_expect(struct sock *ctnl, struct sk_buff *skb, - struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) -{ - struct nf_conntrack_expect *exp, *tmp; - struct nf_conntrack_tuple tuple; - struct nf_conntrack_helper *h; - struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); - u_int8_t u3 = nfmsg->nfgen_family; - int err; - - if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp)) - return -EINVAL; - - if (cda[CTA_EXPECT_TUPLE-1]) { - /* delete a single expect by tuple */ - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3); - if (err < 0) - return err; - - /* bump usage count to 2 */ - exp = nf_conntrack_expect_find(&tuple); - if (!exp) - return -ENOENT; - - if (cda[CTA_EXPECT_ID-1]) { - u_int32_t id = - *(u_int32_t *)NFA_DATA(cda[CTA_EXPECT_ID-1]); - if (exp->id != ntohl(id)) { - nf_conntrack_expect_put(exp); - return -ENOENT; - } - } - - /* after list removal, usage count == 1 */ - nf_conntrack_unexpect_related(exp); - /* have to put what we 'get' above. - * after this line usage count == 0 */ - nf_conntrack_expect_put(exp); - } else if (cda[CTA_EXPECT_HELP_NAME-1]) { - char *name = NFA_DATA(cda[CTA_EXPECT_HELP_NAME-1]); - - /* delete all expectations for this helper */ - write_lock_bh(&nf_conntrack_lock); - h = __nf_conntrack_helper_find_byname(name); - if (!h) { - write_unlock_bh(&nf_conntrack_lock); - return -EINVAL; - } - list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list, - list) { - if (exp->master->helper == h - && del_timer(&exp->timeout)) { - nf_ct_unlink_expect(exp); - nf_conntrack_expect_put(exp); - } - } - write_unlock_bh(&nf_conntrack_lock); - } else { - /* This basically means we have to flush everything*/ - write_lock_bh(&nf_conntrack_lock); - list_for_each_entry_safe(exp, tmp, &nf_conntrack_expect_list, - list) { - if (del_timer(&exp->timeout)) { - nf_ct_unlink_expect(exp); - nf_conntrack_expect_put(exp); - } - } - write_unlock_bh(&nf_conntrack_lock); - } - - return 0; -} -static int -ctnetlink_change_expect(struct nf_conntrack_expect *x, struct nfattr *cda[]) -{ - return -EOPNOTSUPP; -} - -static int -ctnetlink_create_expect(struct nfattr *cda[], u_int8_t u3) -{ - struct nf_conntrack_tuple tuple, mask, master_tuple; - struct nf_conntrack_tuple_hash *h = NULL; - struct nf_conntrack_expect *exp; - struct nf_conn *ct; - int err = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - /* caller guarantees that those three CTA_EXPECT_* exist */ - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3); - if (err < 0) - return err; - err = ctnetlink_parse_tuple(cda, &mask, CTA_EXPECT_MASK, u3); - if (err < 0) - return err; - err = ctnetlink_parse_tuple(cda, &master_tuple, CTA_EXPECT_MASTER, u3); - if (err < 0) - return err; - - /* Look for master conntrack of this expectation */ - h = nf_conntrack_find_get(&master_tuple, NULL); - if (!h) - return -ENOENT; - ct = nf_ct_tuplehash_to_ctrack(h); - - if (!ct->helper) { - /* such conntrack hasn't got any helper, abort */ - err = -EINVAL; - goto out; - } - - exp = nf_conntrack_expect_alloc(ct); - if (!exp) { - err = -ENOMEM; - goto out; - } - - exp->expectfn = NULL; - exp->flags = 0; - exp->master = ct; - memcpy(&exp->tuple, &tuple, sizeof(struct nf_conntrack_tuple)); - memcpy(&exp->mask, &mask, sizeof(struct nf_conntrack_tuple)); - - err = nf_conntrack_expect_related(exp); - nf_conntrack_expect_put(exp); - -out: - nf_ct_put(nf_ct_tuplehash_to_ctrack(h)); - return err; -} - -static int -ctnetlink_new_expect(struct sock *ctnl, struct sk_buff *skb, - struct nlmsghdr *nlh, struct nfattr *cda[], int *errp) -{ - struct nf_conntrack_tuple tuple; - struct nf_conntrack_expect *exp; - struct nfgenmsg *nfmsg = NLMSG_DATA(nlh); - u_int8_t u3 = nfmsg->nfgen_family; - int err = 0; - - DEBUGP("entered %s\n", __FUNCTION__); - - if (nfattr_bad_size(cda, CTA_EXPECT_MAX, cta_min_exp)) - return -EINVAL; - - if (!cda[CTA_EXPECT_TUPLE-1] - || !cda[CTA_EXPECT_MASK-1] - || !cda[CTA_EXPECT_MASTER-1]) - return -EINVAL; - - err = ctnetlink_parse_tuple(cda, &tuple, CTA_EXPECT_TUPLE, u3); - if (err < 0) - return err; - - write_lock_bh(&nf_conntrack_lock); - exp = __nf_conntrack_expect_find(&tuple); - - if (!exp) { - write_unlock_bh(&nf_conntrack_lock); - err = -ENOENT; - if (nlh->nlmsg_flags & NLM_F_CREATE) - err = ctnetlink_create_expect(cda, u3); - return err; - } - - err = -EEXIST; - if (!(nlh->nlmsg_flags & NLM_F_EXCL)) - err = ctnetlink_change_expect(exp, cda); - write_unlock_bh(&nf_conntrack_lock); - - DEBUGP("leaving\n"); - - return err; -} - -#ifdef CONFIG_NF_CONNTRACK_EVENTS -static struct notifier_block ctnl_notifier = { - .notifier_call = ctnetlink_conntrack_event, -}; - -static struct notifier_block ctnl_notifier_exp = { - .notifier_call = ctnetlink_expect_event, -}; -#endif - -static struct nfnl_callback ctnl_cb[IPCTNL_MSG_MAX] = { - [IPCTNL_MSG_CT_NEW] = { .call = ctnetlink_new_conntrack, - .attr_count = CTA_MAX, }, - [IPCTNL_MSG_CT_GET] = { .call = ctnetlink_get_conntrack, - .attr_count = CTA_MAX, }, - [IPCTNL_MSG_CT_DELETE] = { .call = ctnetlink_del_conntrack, - .attr_count = CTA_MAX, }, - [IPCTNL_MSG_CT_GET_CTRZERO] = { .call = ctnetlink_get_conntrack, - .attr_count = CTA_MAX, }, -}; - -static struct nfnl_callback ctnl_exp_cb[IPCTNL_MSG_EXP_MAX] = { - [IPCTNL_MSG_EXP_GET] = { .call = ctnetlink_get_expect, - .attr_count = CTA_EXPECT_MAX, }, - [IPCTNL_MSG_EXP_NEW] = { .call = ctnetlink_new_expect, - .attr_count = CTA_EXPECT_MAX, }, - [IPCTNL_MSG_EXP_DELETE] = { .call = ctnetlink_del_expect, - .attr_count = CTA_EXPECT_MAX, }, -}; - -static struct nfnetlink_subsystem ctnl_subsys = { - .name = "conntrack", - .subsys_id = NFNL_SUBSYS_CTNETLINK, - .cb_count = IPCTNL_MSG_MAX, - .cb = ctnl_cb, -}; - -static struct nfnetlink_subsystem ctnl_exp_subsys = { - .name = "conntrack_expect", - .subsys_id = NFNL_SUBSYS_CTNETLINK_EXP, - .cb_count = IPCTNL_MSG_EXP_MAX, - .cb = ctnl_exp_cb, -}; - -MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK); - -static int __init ctnetlink_init(void) -{ - int ret; - - printk("ctnetlink v%s: registering with nfnetlink.\n", version); - ret = nfnetlink_subsys_register(&ctnl_subsys); - if (ret < 0) { - printk("ctnetlink_init: cannot register with nfnetlink.\n"); - goto err_out; - } - - ret = nfnetlink_subsys_register(&ctnl_exp_subsys); - if (ret < 0) { - printk("ctnetlink_init: cannot register exp with nfnetlink.\n"); - goto err_unreg_subsys; - } - -#ifdef CONFIG_NF_CONNTRACK_EVENTS - ret = nf_conntrack_register_notifier(&ctnl_notifier); - if (ret < 0) { - printk("ctnetlink_init: cannot register notifier.\n"); - goto err_unreg_exp_subsys; - } - - ret = nf_conntrack_expect_register_notifier(&ctnl_notifier_exp); - if (ret < 0) { - printk("ctnetlink_init: cannot expect register notifier.\n"); - goto err_unreg_notifier; - } -#endif - - return 0; - -#ifdef CONFIG_NF_CONNTRACK_EVENTS -err_unreg_notifier: - nf_conntrack_unregister_notifier(&ctnl_notifier); -err_unreg_exp_subsys: - nfnetlink_subsys_unregister(&ctnl_exp_subsys); -#endif -err_unreg_subsys: - nfnetlink_subsys_unregister(&ctnl_subsys); -err_out: - return ret; -} - -static void __exit ctnetlink_exit(void) -{ - printk("ctnetlink: unregistering from nfnetlink.\n"); - -#ifdef CONFIG_NF_CONNTRACK_EVENTS - nf_conntrack_unregister_notifier(&ctnl_notifier_exp); - nf_conntrack_unregister_notifier(&ctnl_notifier); -#endif - - nfnetlink_subsys_unregister(&ctnl_exp_subsys); - nfnetlink_subsys_unregister(&ctnl_subsys); - return; -} - -module_init(ctnetlink_init); -module_exit(ctnetlink_exit); diff --git a/trunk/net/netfilter/nf_conntrack_proto_tcp.c b/trunk/net/netfilter/nf_conntrack_proto_tcp.c index 6167137a5cb5..6035633d8225 100644 --- a/trunk/net/netfilter/nf_conntrack_proto_tcp.c +++ b/trunk/net/netfilter/nf_conntrack_proto_tcp.c @@ -1147,63 +1147,6 @@ static int tcp_new(struct nf_conn *conntrack, receiver->td_scale); return 1; } - -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - -#include -#include - -static int tcp_to_nfattr(struct sk_buff *skb, struct nfattr *nfa, - const struct nf_conn *ct) -{ - struct nfattr *nest_parms; - - read_lock_bh(&tcp_lock); - nest_parms = NFA_NEST(skb, CTA_PROTOINFO_TCP); - NFA_PUT(skb, CTA_PROTOINFO_TCP_STATE, sizeof(u_int8_t), - &ct->proto.tcp.state); - read_unlock_bh(&tcp_lock); - - NFA_NEST_END(skb, nest_parms); - - return 0; - -nfattr_failure: - read_unlock_bh(&tcp_lock); - return -1; -} - -static const size_t cta_min_tcp[CTA_PROTOINFO_TCP_MAX] = { - [CTA_PROTOINFO_TCP_STATE-1] = sizeof(u_int8_t), -}; - -static int nfattr_to_tcp(struct nfattr *cda[], struct nf_conn *ct) -{ - struct nfattr *attr = cda[CTA_PROTOINFO_TCP-1]; - struct nfattr *tb[CTA_PROTOINFO_TCP_MAX]; - - /* updates could not contain anything about the private - * protocol info, in that case skip the parsing */ - if (!attr) - return 0; - - nfattr_parse_nested(tb, CTA_PROTOINFO_TCP_MAX, attr); - - if (nfattr_bad_size(tb, CTA_PROTOINFO_TCP_MAX, cta_min_tcp)) - return -EINVAL; - - if (!tb[CTA_PROTOINFO_TCP_STATE-1]) - return -EINVAL; - - write_lock_bh(&tcp_lock); - ct->proto.tcp.state = - *(u_int8_t *)NFA_DATA(tb[CTA_PROTOINFO_TCP_STATE-1]); - write_unlock_bh(&tcp_lock); - - return 0; -} -#endif struct nf_conntrack_protocol nf_conntrack_protocol_tcp4 = { @@ -1217,13 +1160,6 @@ struct nf_conntrack_protocol nf_conntrack_protocol_tcp4 = .packet = tcp_packet, .new = tcp_new, .error = tcp_error4, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .to_nfattr = tcp_to_nfattr, - .from_nfattr = nfattr_to_tcp, - .tuple_to_nfattr = nf_ct_port_tuple_to_nfattr, - .nfattr_to_tuple = nf_ct_port_nfattr_to_tuple, -#endif }; struct nf_conntrack_protocol nf_conntrack_protocol_tcp6 = @@ -1238,13 +1174,6 @@ struct nf_conntrack_protocol nf_conntrack_protocol_tcp6 = .packet = tcp_packet, .new = tcp_new, .error = tcp_error6, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .to_nfattr = tcp_to_nfattr, - .from_nfattr = nfattr_to_tcp, - .tuple_to_nfattr = nf_ct_port_tuple_to_nfattr, - .nfattr_to_tuple = nf_ct_port_nfattr_to_tuple, -#endif }; EXPORT_SYMBOL(nf_conntrack_protocol_tcp4); diff --git a/trunk/net/netfilter/nf_conntrack_proto_udp.c b/trunk/net/netfilter/nf_conntrack_proto_udp.c index 1a592a556182..3cae7ce420dd 100644 --- a/trunk/net/netfilter/nf_conntrack_proto_udp.c +++ b/trunk/net/netfilter/nf_conntrack_proto_udp.c @@ -196,11 +196,6 @@ struct nf_conntrack_protocol nf_conntrack_protocol_udp4 = .packet = udp_packet, .new = udp_new, .error = udp_error4, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .tuple_to_nfattr = nf_ct_port_tuple_to_nfattr, - .nfattr_to_tuple = nf_ct_port_nfattr_to_tuple, -#endif }; struct nf_conntrack_protocol nf_conntrack_protocol_udp6 = @@ -215,11 +210,6 @@ struct nf_conntrack_protocol nf_conntrack_protocol_udp6 = .packet = udp_packet, .new = udp_new, .error = udp_error6, -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) - .tuple_to_nfattr = nf_ct_port_tuple_to_nfattr, - .nfattr_to_tuple = nf_ct_port_nfattr_to_tuple, -#endif }; EXPORT_SYMBOL(nf_conntrack_protocol_udp4); diff --git a/trunk/net/netfilter/nf_conntrack_standalone.c b/trunk/net/netfilter/nf_conntrack_standalone.c index d17e42b28c79..5af381f9fe3d 100644 --- a/trunk/net/netfilter/nf_conntrack_standalone.c +++ b/trunk/net/netfilter/nf_conntrack_standalone.c @@ -161,14 +161,14 @@ static int ct_seq_show(struct seq_file *s, void *v) if (NF_CT_DIRECTION(hash)) return 0; - l3proto = __nf_ct_l3proto_find(conntrack->tuplehash[IP_CT_DIR_ORIGINAL] - .tuple.src.l3num); + l3proto = nf_ct_find_l3proto(conntrack->tuplehash[IP_CT_DIR_ORIGINAL] + .tuple.src.l3num); NF_CT_ASSERT(l3proto); - proto = __nf_ct_proto_find(conntrack->tuplehash[IP_CT_DIR_ORIGINAL] - .tuple.src.l3num, - conntrack->tuplehash[IP_CT_DIR_ORIGINAL] - .tuple.dst.protonum); + proto = nf_ct_find_proto(conntrack->tuplehash[IP_CT_DIR_ORIGINAL] + .tuple.src.l3num, + conntrack->tuplehash[IP_CT_DIR_ORIGINAL] + .tuple.dst.protonum); NF_CT_ASSERT(proto); if (seq_printf(s, "%-8s %u %-8s %u %ld ", @@ -307,9 +307,9 @@ static int exp_seq_show(struct seq_file *s, void *v) expect->tuple.src.l3num, expect->tuple.dst.protonum); print_tuple(s, &expect->tuple, - __nf_ct_l3proto_find(expect->tuple.src.l3num), - __nf_ct_proto_find(expect->tuple.src.l3num, - expect->tuple.dst.protonum)); + nf_ct_find_l3proto(expect->tuple.src.l3num), + nf_ct_find_proto(expect->tuple.src.l3num, + expect->tuple.dst.protonum)); return seq_putc(s, '\n'); } @@ -847,11 +847,7 @@ EXPORT_SYMBOL(nf_conntrack_helper_unregister); EXPORT_SYMBOL(nf_ct_iterate_cleanup); EXPORT_SYMBOL(__nf_ct_refresh_acct); EXPORT_SYMBOL(nf_ct_protos); -EXPORT_SYMBOL(__nf_ct_proto_find); -EXPORT_SYMBOL(nf_ct_proto_find_get); -EXPORT_SYMBOL(nf_ct_proto_put); -EXPORT_SYMBOL(nf_ct_l3proto_find_get); -EXPORT_SYMBOL(nf_ct_l3proto_put); +EXPORT_SYMBOL(nf_ct_find_proto); EXPORT_SYMBOL(nf_ct_l3protos); EXPORT_SYMBOL(nf_conntrack_expect_alloc); EXPORT_SYMBOL(nf_conntrack_expect_put); @@ -871,21 +867,3 @@ EXPORT_SYMBOL(nf_ct_get_tuple); EXPORT_SYMBOL(nf_ct_invert_tuple); EXPORT_SYMBOL(nf_conntrack_in); EXPORT_SYMBOL(__nf_conntrack_attach); -EXPORT_SYMBOL(nf_conntrack_alloc); -EXPORT_SYMBOL(nf_conntrack_free); -EXPORT_SYMBOL(nf_conntrack_flush); -EXPORT_SYMBOL(nf_ct_remove_expectations); -EXPORT_SYMBOL(nf_ct_helper_find_get); -EXPORT_SYMBOL(nf_ct_helper_put); -EXPORT_SYMBOL(__nf_conntrack_helper_find_byname); -EXPORT_SYMBOL(__nf_conntrack_find); -EXPORT_SYMBOL(nf_ct_unlink_expect); -EXPORT_SYMBOL(nf_conntrack_hash_insert); -EXPORT_SYMBOL(__nf_conntrack_expect_find); -EXPORT_SYMBOL(nf_conntrack_expect_find); -EXPORT_SYMBOL(nf_conntrack_expect_list); -#if defined(CONFIG_NF_CT_NETLINK) || \ - defined(CONFIG_NF_CT_NETLINK_MODULE) -EXPORT_SYMBOL(nf_ct_port_tuple_to_nfattr); -EXPORT_SYMBOL(nf_ct_port_nfattr_to_tuple); -#endif diff --git a/trunk/net/netfilter/nfnetlink_log.c b/trunk/net/netfilter/nfnetlink_log.c index e10512e229b6..cba63729313d 100644 --- a/trunk/net/netfilter/nfnetlink_log.c +++ b/trunk/net/netfilter/nfnetlink_log.c @@ -151,7 +151,7 @@ instance_create(u_int16_t group_num, int pid) goto out_unlock; INIT_HLIST_NODE(&inst->hlist); - spin_lock_init(&inst->lock); + inst->lock = SPIN_LOCK_UNLOCKED; /* needs to be two, since we _put() after creation */ atomic_set(&inst->use, 2); diff --git a/trunk/net/netfilter/nfnetlink_queue.c b/trunk/net/netfilter/nfnetlink_queue.c index 18ed9c5d209c..f28460b61e47 100644 --- a/trunk/net/netfilter/nfnetlink_queue.c +++ b/trunk/net/netfilter/nfnetlink_queue.c @@ -148,7 +148,7 @@ instance_create(u_int16_t queue_num, int pid) atomic_set(&inst->id_sequence, 0); /* needs to be two, since we _put() after creation */ atomic_set(&inst->use, 2); - spin_lock_init(&inst->lock); + inst->lock = SPIN_LOCK_UNLOCKED; INIT_LIST_HEAD(&inst->queue_list); if (!try_module_get(THIS_MODULE)) @@ -345,10 +345,6 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, struct nfqnl_msg_packet_hdr pmsg; struct nlmsghdr *nlh; struct nfgenmsg *nfmsg; - struct nf_info *entinf = entry->info; - struct sk_buff *entskb = entry->skb; - struct net_device *indev; - struct net_device *outdev; unsigned int tmp_uint; QDEBUG("entered\n"); @@ -365,8 +361,6 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, + NLMSG_SPACE(sizeof(struct nfqnl_msg_packet_hw)) + NLMSG_SPACE(sizeof(struct nfqnl_msg_packet_timestamp)); - outdev = entinf->outdev; - spin_lock_bh(&queue->lock); switch (queue->copy_mode) { @@ -376,15 +370,15 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, break; case NFQNL_COPY_PACKET: - if (entskb->ip_summed == CHECKSUM_HW && - (*errp = skb_checksum_help(entskb, - outdev == NULL))) { + if (entry->skb->ip_summed == CHECKSUM_HW && + (*errp = skb_checksum_help(entry->skb, + entry->info->outdev == NULL))) { spin_unlock_bh(&queue->lock); return NULL; } if (queue->copy_range == 0 - || queue->copy_range > entskb->len) - data_len = entskb->len; + || queue->copy_range > entry->skb->len) + data_len = entry->skb->len; else data_len = queue->copy_range; @@ -408,30 +402,29 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, NFNL_SUBSYS_QUEUE << 8 | NFQNL_MSG_PACKET, sizeof(struct nfgenmsg)); nfmsg = NLMSG_DATA(nlh); - nfmsg->nfgen_family = entinf->pf; + nfmsg->nfgen_family = entry->info->pf; nfmsg->version = NFNETLINK_V0; nfmsg->res_id = htons(queue->queue_num); pmsg.packet_id = htonl(entry->id); - pmsg.hw_protocol = htons(entskb->protocol); - pmsg.hook = entinf->hook; + pmsg.hw_protocol = htons(entry->skb->protocol); + pmsg.hook = entry->info->hook; NFA_PUT(skb, NFQA_PACKET_HDR, sizeof(pmsg), &pmsg); - indev = entinf->indev; - if (indev) { - tmp_uint = htonl(indev->ifindex); + if (entry->info->indev) { + tmp_uint = htonl(entry->info->indev->ifindex); #ifndef CONFIG_BRIDGE_NETFILTER NFA_PUT(skb, NFQA_IFINDEX_INDEV, sizeof(tmp_uint), &tmp_uint); #else - if (entinf->pf == PF_BRIDGE) { + if (entry->info->pf == PF_BRIDGE) { /* Case 1: indev is physical input device, we need to * look for bridge group (when called from * netfilter_bridge) */ NFA_PUT(skb, NFQA_IFINDEX_PHYSINDEV, sizeof(tmp_uint), &tmp_uint); /* this is the bridge group "brX" */ - tmp_uint = htonl(indev->br_port->br->dev->ifindex); + tmp_uint = htonl(entry->info->indev->br_port->br->dev->ifindex); NFA_PUT(skb, NFQA_IFINDEX_INDEV, sizeof(tmp_uint), &tmp_uint); } else { @@ -439,9 +432,9 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, * physical device (when called from ipv4) */ NFA_PUT(skb, NFQA_IFINDEX_INDEV, sizeof(tmp_uint), &tmp_uint); - if (entskb->nf_bridge - && entskb->nf_bridge->physindev) { - tmp_uint = htonl(entskb->nf_bridge->physindev->ifindex); + if (entry->skb->nf_bridge + && entry->skb->nf_bridge->physindev) { + tmp_uint = htonl(entry->skb->nf_bridge->physindev->ifindex); NFA_PUT(skb, NFQA_IFINDEX_PHYSINDEV, sizeof(tmp_uint), &tmp_uint); } @@ -449,19 +442,19 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, #endif } - if (outdev) { - tmp_uint = htonl(outdev->ifindex); + if (entry->info->outdev) { + tmp_uint = htonl(entry->info->outdev->ifindex); #ifndef CONFIG_BRIDGE_NETFILTER NFA_PUT(skb, NFQA_IFINDEX_OUTDEV, sizeof(tmp_uint), &tmp_uint); #else - if (entinf->pf == PF_BRIDGE) { + if (entry->info->pf == PF_BRIDGE) { /* Case 1: outdev is physical output device, we need to * look for bridge group (when called from * netfilter_bridge) */ NFA_PUT(skb, NFQA_IFINDEX_PHYSOUTDEV, sizeof(tmp_uint), &tmp_uint); /* this is the bridge group "brX" */ - tmp_uint = htonl(outdev->br_port->br->dev->ifindex); + tmp_uint = htonl(entry->info->outdev->br_port->br->dev->ifindex); NFA_PUT(skb, NFQA_IFINDEX_OUTDEV, sizeof(tmp_uint), &tmp_uint); } else { @@ -469,9 +462,9 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, * physical output device (when called from ipv4) */ NFA_PUT(skb, NFQA_IFINDEX_OUTDEV, sizeof(tmp_uint), &tmp_uint); - if (entskb->nf_bridge - && entskb->nf_bridge->physoutdev) { - tmp_uint = htonl(entskb->nf_bridge->physoutdev->ifindex); + if (entry->skb->nf_bridge + && entry->skb->nf_bridge->physoutdev) { + tmp_uint = htonl(entry->skb->nf_bridge->physoutdev->ifindex); NFA_PUT(skb, NFQA_IFINDEX_PHYSOUTDEV, sizeof(tmp_uint), &tmp_uint); } @@ -479,27 +472,27 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, #endif } - if (entskb->nfmark) { - tmp_uint = htonl(entskb->nfmark); + if (entry->skb->nfmark) { + tmp_uint = htonl(entry->skb->nfmark); NFA_PUT(skb, NFQA_MARK, sizeof(u_int32_t), &tmp_uint); } - if (indev && entskb->dev - && entskb->dev->hard_header_parse) { + if (entry->info->indev && entry->skb->dev + && entry->skb->dev->hard_header_parse) { struct nfqnl_msg_packet_hw phw; phw.hw_addrlen = - entskb->dev->hard_header_parse(entskb, + entry->skb->dev->hard_header_parse(entry->skb, phw.hw_addr); phw.hw_addrlen = htons(phw.hw_addrlen); NFA_PUT(skb, NFQA_HWADDR, sizeof(phw), &phw); } - if (entskb->tstamp.off_sec) { + if (entry->skb->tstamp.off_sec) { struct nfqnl_msg_packet_timestamp ts; - ts.sec = cpu_to_be64(entskb->tstamp.off_sec); - ts.usec = cpu_to_be64(entskb->tstamp.off_usec); + ts.sec = cpu_to_be64(entry->skb->tstamp.off_sec); + ts.usec = cpu_to_be64(entry->skb->tstamp.off_usec); NFA_PUT(skb, NFQA_TIMESTAMP, sizeof(ts), &ts); } @@ -517,7 +510,7 @@ nfqnl_build_packet_message(struct nfqnl_instance *queue, nfa->nfa_type = NFQA_PAYLOAD; nfa->nfa_len = size; - if (skb_copy_bits(entskb, 0, NFA_DATA(nfa), data_len)) + if (skb_copy_bits(entry->skb, 0, NFA_DATA(nfa), data_len)) BUG(); } @@ -674,14 +667,12 @@ nfqnl_set_mode(struct nfqnl_instance *queue, static int dev_cmp(struct nfqnl_queue_entry *entry, unsigned long ifindex) { - struct nf_info *entinf = entry->info; - - if (entinf->indev) - if (entinf->indev->ifindex == ifindex) + if (entry->info->indev) + if (entry->info->indev->ifindex == ifindex) return 1; - if (entinf->outdev) - if (entinf->outdev->ifindex == ifindex) + if (entry->info->outdev) + if (entry->info->outdev->ifindex == ifindex) return 1; return 0; diff --git a/trunk/net/netlink/af_netlink.c b/trunk/net/netlink/af_netlink.c index 7849cac14d3a..96020d7087e8 100644 --- a/trunk/net/netlink/af_netlink.c +++ b/trunk/net/netlink/af_netlink.c @@ -293,7 +293,7 @@ static inline int nl_pid_hash_dilute(struct nl_pid_hash *hash, int len) return 0; } -static const struct proto_ops netlink_ops; +static struct proto_ops netlink_ops; static int netlink_insert(struct sock *sk, u32 pid) { @@ -1656,7 +1656,7 @@ int netlink_unregister_notifier(struct notifier_block *nb) return notifier_chain_unregister(&netlink_chain, nb); } -static const struct proto_ops netlink_ops = { +static struct proto_ops netlink_ops = { .family = PF_NETLINK, .owner = THIS_MODULE, .release = netlink_release, diff --git a/trunk/net/netlink/genetlink.c b/trunk/net/netlink/genetlink.c index 3b1378498d50..287cfcc56951 100644 --- a/trunk/net/netlink/genetlink.c +++ b/trunk/net/netlink/genetlink.c @@ -441,7 +441,7 @@ static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb) } static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid, - int seq, u8 cmd) + int seq, int cmd) { struct sk_buff *skb; int err; diff --git a/trunk/net/netrom/af_netrom.c b/trunk/net/netrom/af_netrom.c index 63b0e4afeb33..e5d82d711cae 100644 --- a/trunk/net/netrom/af_netrom.c +++ b/trunk/net/netrom/af_netrom.c @@ -63,7 +63,7 @@ static unsigned short circuit = 0x101; static HLIST_HEAD(nr_list); static DEFINE_SPINLOCK(nr_list_lock); -static const struct proto_ops nr_proto_ops; +static struct proto_ops nr_proto_ops; /* * Socket removal during an interrupt is now safe. @@ -1166,11 +1166,10 @@ static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) void __user *argp = (void __user *)arg; int ret; + lock_sock(sk); switch (cmd) { case TIOCOUTQ: { long amount; - - lock_sock(sk); amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc); if (amount < 0) amount = 0; @@ -1181,8 +1180,6 @@ static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) case TIOCINQ: { struct sk_buff *skb; long amount = 0L; - - lock_sock(sk); /* These two are safe on a single CPU system as only user tasks fiddle here */ if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) amount = skb->len; @@ -1191,7 +1188,6 @@ static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) } case SIOCGSTAMP: - lock_sock(sk); ret = sock_get_timestamp(sk, argp); release_sock(sk); return ret; @@ -1206,17 +1202,21 @@ static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) case SIOCSIFNETMASK: case SIOCGIFMETRIC: case SIOCSIFMETRIC: + release_sock(sk); return -EINVAL; case SIOCADDRT: case SIOCDELRT: case SIOCNRDECOBS: + release_sock(sk); if (!capable(CAP_NET_ADMIN)) return -EPERM; return nr_rt_ioctl(cmd, argp); default: - return -ENOIOCTLCMD; + release_sock(sk); + return dev_ioctl(cmd, argp); } + release_sock(sk); return 0; } @@ -1337,7 +1337,7 @@ static struct net_proto_family nr_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops nr_proto_ops = { +static struct proto_ops nr_proto_ops = { .family = PF_NETROM, .owner = THIS_MODULE, .release = nr_release, diff --git a/trunk/net/nonet.c b/trunk/net/nonet.c index 1230f0ae832e..e5241dceaa57 100644 --- a/trunk/net/nonet.c +++ b/trunk/net/nonet.c @@ -14,6 +14,11 @@ #include #include +void __init sock_init(void) +{ + printk(KERN_INFO "Linux NoNET1.0 for Linux 2.6\n"); +} + static int sock_no_open(struct inode *irrelevant, struct file *dontcare) { return -ENXIO; diff --git a/trunk/net/packet/af_packet.c b/trunk/net/packet/af_packet.c index f69e5ed9bd06..3e2462760413 100644 --- a/trunk/net/packet/af_packet.c +++ b/trunk/net/packet/af_packet.c @@ -251,10 +251,10 @@ static void packet_sock_destruct(struct sock *sk) } -static const struct proto_ops packet_ops; +static struct proto_ops packet_ops; #ifdef CONFIG_SOCK_PACKET -static const struct proto_ops packet_ops_spkt; +static struct proto_ops packet_ops_spkt; static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev) { @@ -1521,7 +1521,7 @@ static int packet_ioctl(struct socket *sock, unsigned int cmd, #endif default: - return -ENOIOCTLCMD; + return dev_ioctl(cmd, (void __user *)arg); } return 0; } @@ -1784,7 +1784,7 @@ static int packet_mmap(struct file *file, struct socket *sock, struct vm_area_st #ifdef CONFIG_SOCK_PACKET -static const struct proto_ops packet_ops_spkt = { +static struct proto_ops packet_ops_spkt = { .family = PF_PACKET, .owner = THIS_MODULE, .release = packet_release, @@ -1806,7 +1806,7 @@ static const struct proto_ops packet_ops_spkt = { }; #endif -static const struct proto_ops packet_ops = { +static struct proto_ops packet_ops = { .family = PF_PACKET, .owner = THIS_MODULE, .release = packet_release, diff --git a/trunk/net/rose/af_rose.c b/trunk/net/rose/af_rose.c index 63090be2315a..829fdbc4400b 100644 --- a/trunk/net/rose/af_rose.c +++ b/trunk/net/rose/af_rose.c @@ -1320,7 +1320,7 @@ static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) return 0; default: - return -ENOIOCTLCMD; + return dev_ioctl(cmd, argp); } return 0; diff --git a/trunk/net/sched/sch_netem.c b/trunk/net/sched/sch_netem.c index ba5283204837..82fb07aa06a5 100644 --- a/trunk/net/sched/sch_netem.c +++ b/trunk/net/sched/sch_netem.c @@ -25,7 +25,7 @@ #include -#define VERSION "1.2" +#define VERSION "1.1" /* Network Emulation Queuing algorithm. ==================================== @@ -65,12 +65,11 @@ struct netem_sched_data { u32 jitter; u32 duplicate; u32 reorder; - u32 corrupt; struct crndstate { unsigned long last; unsigned long rho; - } delay_cor, loss_cor, dup_cor, reorder_cor, corrupt_cor; + } delay_cor, loss_cor, dup_cor, reorder_cor; struct disttable { u32 size; @@ -184,23 +183,6 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch) q->duplicate = dupsave; } - /* - * Randomized packet corruption. - * Make copy if needed since we are modifying - * If packet is going to be hardware checksummed, then - * do it now in software before we mangle it. - */ - if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) { - if (!(skb = skb_unshare(skb, GFP_ATOMIC)) - || (skb->ip_summed == CHECKSUM_HW - && skb_checksum_help(skb, 0))) { - sch->qstats.drops++; - return NET_XMIT_DROP; - } - - skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8); - } - if (q->gap == 0 /* not doing reordering */ || q->counter < q->gap /* inside last reordering gap */ || q->reorder < get_crandom(&q->reorder_cor)) { @@ -400,20 +382,6 @@ static int get_reorder(struct Qdisc *sch, const struct rtattr *attr) return 0; } -static int get_corrupt(struct Qdisc *sch, const struct rtattr *attr) -{ - struct netem_sched_data *q = qdisc_priv(sch); - const struct tc_netem_corrupt *r = RTA_DATA(attr); - - if (RTA_PAYLOAD(attr) != sizeof(*r)) - return -EINVAL; - - q->corrupt = r->probability; - init_crandom(&q->corrupt_cor, r->correlation); - return 0; -} - -/* Parse netlink message to set options */ static int netem_change(struct Qdisc *sch, struct rtattr *opt) { struct netem_sched_data *q = qdisc_priv(sch); @@ -464,20 +432,14 @@ static int netem_change(struct Qdisc *sch, struct rtattr *opt) if (ret) return ret; } - if (tb[TCA_NETEM_REORDER-1]) { ret = get_reorder(sch, tb[TCA_NETEM_REORDER-1]); if (ret) return ret; } - - if (tb[TCA_NETEM_CORRUPT-1]) { - ret = get_corrupt(sch, tb[TCA_NETEM_CORRUPT-1]); - if (ret) - return ret; - } } + return 0; } @@ -602,7 +564,6 @@ static int netem_dump(struct Qdisc *sch, struct sk_buff *skb) struct tc_netem_qopt qopt; struct tc_netem_corr cor; struct tc_netem_reorder reorder; - struct tc_netem_corrupt corrupt; qopt.latency = q->latency; qopt.jitter = q->jitter; @@ -621,10 +582,6 @@ static int netem_dump(struct Qdisc *sch, struct sk_buff *skb) reorder.correlation = q->reorder_cor.rho; RTA_PUT(skb, TCA_NETEM_REORDER, sizeof(reorder), &reorder); - corrupt.probability = q->corrupt; - corrupt.correlation = q->corrupt_cor.rho; - RTA_PUT(skb, TCA_NETEM_CORRUPT, sizeof(corrupt), &corrupt); - rta->rta_len = skb->tail - b; return skb->len; diff --git a/trunk/net/sched/sch_teql.c b/trunk/net/sched/sch_teql.c index c4a2a8c4c339..6cf0342706b5 100644 --- a/trunk/net/sched/sch_teql.c +++ b/trunk/net/sched/sch_teql.c @@ -22,7 +22,6 @@ #include #include #include -#include #include #include #include diff --git a/trunk/net/sctp/associola.c b/trunk/net/sctp/associola.c index 9d05e13e92f6..dec68a604773 100644 --- a/trunk/net/sctp/associola.c +++ b/trunk/net/sctp/associola.c @@ -110,6 +110,7 @@ static struct sctp_association *sctp_association_init(struct sctp_association *a asoc->cookie_life.tv_sec = sp->assocparams.sasoc_cookie_life / 1000; asoc->cookie_life.tv_usec = (sp->assocparams.sasoc_cookie_life % 1000) * 1000; + asoc->pmtu = 0; asoc->frag_point = 0; /* Set the association max_retrans and RTO values from the @@ -122,25 +123,6 @@ static struct sctp_association *sctp_association_init(struct sctp_association *a asoc->overall_error_count = 0; - /* Initialize the association's heartbeat interval based on the - * sock configured value. - */ - asoc->hbinterval = msecs_to_jiffies(sp->hbinterval); - - /* Initialize path max retrans value. */ - asoc->pathmaxrxt = sp->pathmaxrxt; - - /* Initialize default path MTU. */ - asoc->pathmtu = sp->pathmtu; - - /* Set association default SACK delay */ - asoc->sackdelay = msecs_to_jiffies(sp->sackdelay); - - /* Set the association default flags controlling - * Heartbeat, SACK delay, and Path MTU Discovery. - */ - asoc->param_flags = sp->param_flags; - /* Initialize the maximum mumber of new data packets that can be sent * in a burst. */ @@ -162,7 +144,8 @@ static struct sctp_association *sctp_association_init(struct sctp_association *a = 5 * asoc->rto_max; asoc->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] = 0; - asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay; + asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = + SCTP_DEFAULT_TIMEOUT_SACK; asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] = sp->autoclose * HZ; @@ -557,46 +540,23 @@ struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc, sctp_transport_set_owner(peer, asoc); - /* Initialize the peer's heartbeat interval based on the - * association configured value. - */ - peer->hbinterval = asoc->hbinterval; - - /* Set the path max_retrans. */ - peer->pathmaxrxt = asoc->pathmaxrxt; - - /* Initialize the peer's SACK delay timeout based on the - * association configured value. - */ - peer->sackdelay = asoc->sackdelay; - - /* Enable/disable heartbeat, SACK delay, and path MTU discovery - * based on association setting. - */ - peer->param_flags = asoc->param_flags; - /* Initialize the pmtu of the transport. */ - if (peer->param_flags & SPP_PMTUD_ENABLE) - sctp_transport_pmtu(peer); - else if (asoc->pathmtu) - peer->pathmtu = asoc->pathmtu; - else - peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT; + sctp_transport_pmtu(peer); /* If this is the first transport addr on this association, * initialize the association PMTU to the peer's PMTU. * If not and the current association PMTU is higher than the new * peer's PMTU, reset the association PMTU to the new peer's PMTU. */ - if (asoc->pathmtu) - asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu); + if (asoc->pmtu) + asoc->pmtu = min_t(int, peer->pmtu, asoc->pmtu); else - asoc->pathmtu = peer->pathmtu; + asoc->pmtu = peer->pmtu; SCTP_DEBUG_PRINTK("sctp_assoc_add_peer:association %p PMTU set to " - "%d\n", asoc, asoc->pathmtu); + "%d\n", asoc, asoc->pmtu); - asoc->frag_point = sctp_frag_point(sp, asoc->pathmtu); + asoc->frag_point = sctp_frag_point(sp, asoc->pmtu); /* The asoc->peer.port might not be meaningful yet, but * initialize the packet structure anyway. @@ -614,7 +574,7 @@ struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc, * (for example, implementations MAY use the size of the * receiver advertised window). */ - peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380)); + peer->cwnd = min(4*asoc->pmtu, max_t(__u32, 2*asoc->pmtu, 4380)); /* At this point, we may not have the receiver's advertised window, * so initialize ssthresh to the default value and it will be set @@ -625,6 +585,17 @@ struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc, peer->partial_bytes_acked = 0; peer->flight_size = 0; + /* By default, enable heartbeat for peer address. */ + peer->hb_allowed = 1; + + /* Initialize the peer's heartbeat interval based on the + * sock configured value. + */ + peer->hb_interval = msecs_to_jiffies(sp->paddrparam.spp_hbinterval); + + /* Set the path max_retrans. */ + peer->max_retrans = sp->paddrparam.spp_pathmaxrxt; + /* Set the transport's RTO.initial value */ peer->rto = asoc->rto_initial; @@ -1184,18 +1155,18 @@ void sctp_assoc_sync_pmtu(struct sctp_association *asoc) /* Get the lowest pmtu of all the transports. */ list_for_each(pos, &asoc->peer.transport_addr_list) { t = list_entry(pos, struct sctp_transport, transports); - if (!pmtu || (t->pathmtu < pmtu)) - pmtu = t->pathmtu; + if (!pmtu || (t->pmtu < pmtu)) + pmtu = t->pmtu; } if (pmtu) { struct sctp_sock *sp = sctp_sk(asoc->base.sk); - asoc->pathmtu = pmtu; + asoc->pmtu = pmtu; asoc->frag_point = sctp_frag_point(sp, pmtu); } SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n", - __FUNCTION__, asoc, asoc->pathmtu, asoc->frag_point); + __FUNCTION__, asoc, asoc->pmtu, asoc->frag_point); } /* Should we send a SACK to update our peer? */ @@ -1208,7 +1179,7 @@ static inline int sctp_peer_needs_update(struct sctp_association *asoc) case SCTP_STATE_SHUTDOWN_SENT: if ((asoc->rwnd > asoc->a_rwnd) && ((asoc->rwnd - asoc->a_rwnd) >= - min_t(__u32, (asoc->base.sk->sk_rcvbuf >> 1), asoc->pathmtu))) + min_t(__u32, (asoc->base.sk->sk_rcvbuf >> 1), asoc->pmtu))) return 1; break; default: diff --git a/trunk/net/sctp/input.c b/trunk/net/sctp/input.c index 238f1bffa684..b24ff2c1aef5 100644 --- a/trunk/net/sctp/input.c +++ b/trunk/net/sctp/input.c @@ -305,36 +305,18 @@ int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb) void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc, struct sctp_transport *t, __u32 pmtu) { - if (sock_owned_by_user(sk) || !t || (t->pathmtu == pmtu)) - return; - - if (t->param_flags & SPP_PMTUD_ENABLE) { - if (unlikely(pmtu < SCTP_DEFAULT_MINSEGMENT)) { - printk(KERN_WARNING "%s: Reported pmtu %d too low, " - "using default minimum of %d\n", - __FUNCTION__, pmtu, - SCTP_DEFAULT_MINSEGMENT); - /* Use default minimum segment size and disable - * pmtu discovery on this transport. - */ - t->pathmtu = SCTP_DEFAULT_MINSEGMENT; - t->param_flags = (t->param_flags & ~SPP_HB) | - SPP_PMTUD_DISABLE; - } else { - t->pathmtu = pmtu; - } + if (unlikely(pmtu < SCTP_DEFAULT_MINSEGMENT)) { + printk(KERN_WARNING "%s: Reported pmtu %d too low, " + "using default minimum of %d\n", __FUNCTION__, pmtu, + SCTP_DEFAULT_MINSEGMENT); + pmtu = SCTP_DEFAULT_MINSEGMENT; + } - /* Update association pmtu. */ + if (!sock_owned_by_user(sk) && t && (t->pmtu != pmtu)) { + t->pmtu = pmtu; sctp_assoc_sync_pmtu(asoc); + sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD); } - - /* Retransmit with the new pmtu setting. - * Normally, if PMTU discovery is disabled, an ICMP Fragmentation - * Needed will never be sent, but if a message was sent before - * PMTU discovery was disabled that was larger than the PMTU, it - * would not be fragmented, so it must be re-transmitted fragmented. - */ - sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD); } /* diff --git a/trunk/net/sctp/ipv6.c b/trunk/net/sctp/ipv6.c index 15c05165c905..fa3be2b8fb5f 100644 --- a/trunk/net/sctp/ipv6.c +++ b/trunk/net/sctp/ipv6.c @@ -866,7 +866,7 @@ static int sctp_inet6_supported_addrs(const struct sctp_sock *opt, return 2; } -static const struct proto_ops inet6_seqpacket_ops = { +static struct proto_ops inet6_seqpacket_ops = { .family = PF_INET6, .owner = THIS_MODULE, .release = inet6_release, diff --git a/trunk/net/sctp/output.c b/trunk/net/sctp/output.c index a40991ef72c9..931371633464 100644 --- a/trunk/net/sctp/output.c +++ b/trunk/net/sctp/output.c @@ -234,8 +234,8 @@ sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet, goto finish; pmtu = ((packet->transport->asoc) ? - (packet->transport->asoc->pathmtu) : - (packet->transport->pathmtu)); + (packet->transport->asoc->pmtu) : + (packet->transport->pmtu)); too_big = (psize + chunk_len > pmtu); @@ -482,9 +482,7 @@ int sctp_packet_transmit(struct sctp_packet *packet) if (!dst || (dst->obsolete > 1)) { dst_release(dst); sctp_transport_route(tp, NULL, sctp_sk(sk)); - if (asoc->param_flags & SPP_PMTUD_ENABLE) { - sctp_assoc_sync_pmtu(asoc); - } + sctp_assoc_sync_pmtu(asoc); } nskb->dst = dst_clone(tp->dst); @@ -494,10 +492,7 @@ int sctp_packet_transmit(struct sctp_packet *packet) SCTP_DEBUG_PRINTK("***sctp_transmit_packet*** skb len %d\n", nskb->len); - if (tp->param_flags & SPP_PMTUD_ENABLE) - (*tp->af_specific->sctp_xmit)(nskb, tp, packet->ipfragok); - else - (*tp->af_specific->sctp_xmit)(nskb, tp, 1); + (*tp->af_specific->sctp_xmit)(nskb, tp, packet->ipfragok); out: packet->size = packet->overhead; @@ -582,7 +577,7 @@ static sctp_xmit_t sctp_packet_append_data(struct sctp_packet *packet, * if ((flightsize + Max.Burst * MTU) < cwnd) * cwnd = flightsize + Max.Burst * MTU */ - max_burst_bytes = asoc->max_burst * asoc->pathmtu; + max_burst_bytes = asoc->max_burst * asoc->pmtu; if ((transport->flight_size + max_burst_bytes) < transport->cwnd) { transport->cwnd = transport->flight_size + max_burst_bytes; SCTP_DEBUG_PRINTK("%s: cwnd limited by max_burst: " @@ -627,7 +622,7 @@ static sctp_xmit_t sctp_packet_append_data(struct sctp_packet *packet, * data will fit or delay in hopes of bundling a full * sized packet. */ - if (len < asoc->pathmtu - packet->overhead) { + if (len < asoc->pmtu - packet->overhead) { retval = SCTP_XMIT_NAGLE_DELAY; goto finish; } diff --git a/trunk/net/sctp/protocol.c b/trunk/net/sctp/protocol.c index de693b43c8ea..f775d78aa59d 100644 --- a/trunk/net/sctp/protocol.c +++ b/trunk/net/sctp/protocol.c @@ -54,7 +54,6 @@ #include #include #include -#include #include #include #include @@ -830,7 +829,7 @@ static struct notifier_block sctp_inetaddr_notifier = { }; /* Socket operations. */ -static const struct proto_ops inet_seqpacket_ops = { +static struct proto_ops inet_seqpacket_ops = { .family = PF_INET, .owner = THIS_MODULE, .release = inet_release, /* Needs to be wrapped... */ diff --git a/trunk/net/sctp/sm_sideeffect.c b/trunk/net/sctp/sm_sideeffect.c index 2d7d8a5db2ac..823947170a33 100644 --- a/trunk/net/sctp/sm_sideeffect.c +++ b/trunk/net/sctp/sm_sideeffect.c @@ -157,12 +157,9 @@ static int sctp_gen_sack(struct sctp_association *asoc, int force, { __u32 ctsn, max_tsn_seen; struct sctp_chunk *sack; - struct sctp_transport *trans = asoc->peer.last_data_from; int error = 0; - if (force || - (!trans && (asoc->param_flags & SPP_SACKDELAY_DISABLE)) || - (trans && (trans->param_flags & SPP_SACKDELAY_DISABLE))) + if (force) asoc->peer.sack_needed = 1; ctsn = sctp_tsnmap_get_ctsn(&asoc->peer.tsn_map); @@ -192,22 +189,7 @@ static int sctp_gen_sack(struct sctp_association *asoc, int force, if (!asoc->peer.sack_needed) { /* We will need a SACK for the next packet. */ asoc->peer.sack_needed = 1; - - /* Set the SACK delay timeout based on the - * SACK delay for the last transport - * data was received from, or the default - * for the association. - */ - if (trans) - asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = - trans->sackdelay; - else - asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = - asoc->sackdelay; - - /* Restart the SACK timer. */ - sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART, - SCTP_TO(SCTP_EVENT_TIMEOUT_SACK)); + goto out; } else { if (asoc->a_rwnd > asoc->rwnd) asoc->a_rwnd = asoc->rwnd; @@ -223,7 +205,7 @@ static int sctp_gen_sack(struct sctp_association *asoc, int force, sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP, SCTP_TO(SCTP_EVENT_TIMEOUT_SACK)); } - +out: return error; nomem: error = -ENOMEM; @@ -433,7 +415,7 @@ static void sctp_do_8_2_transport_strike(struct sctp_association *asoc, asoc->overall_error_count++; if (transport->state != SCTP_INACTIVE && - (transport->error_count++ >= transport->pathmaxrxt)) { + (transport->error_count++ >= transport->max_retrans)) { SCTP_DEBUG_PRINTK_IPADDR("transport_strike:association %p", " transport IP: port:%d failed.\n", asoc, diff --git a/trunk/net/sctp/sm_statefuns.c b/trunk/net/sctp/sm_statefuns.c index 557a7d90b92a..475bfb4972d9 100644 --- a/trunk/net/sctp/sm_statefuns.c +++ b/trunk/net/sctp/sm_statefuns.c @@ -900,7 +900,7 @@ sctp_disposition_t sctp_sf_sendbeat_8_3(const struct sctp_endpoint *ep, * HEARTBEAT is sent (see Section 8.3). */ - if (transport->param_flags & SPP_HB_ENABLE) { + if (transport->hb_allowed) { if (SCTP_DISPOSITION_NOMEM == sctp_sf_heartbeat(ep, asoc, type, arg, commands)) @@ -1051,7 +1051,7 @@ sctp_disposition_t sctp_sf_backbeat_8_3(const struct sctp_endpoint *ep, return SCTP_DISPOSITION_DISCARD; } - max_interval = link->hbinterval + link->rto; + max_interval = link->hb_interval + link->rto; /* Check if the timestamp looks valid. */ if (time_after(hbinfo->sent_at, jiffies) || @@ -2691,9 +2691,14 @@ sctp_disposition_t sctp_sf_eat_data_6_2(const struct sctp_endpoint *ep, * document allow. However, an SCTP transmitter MUST NOT be * more aggressive than the following algorithms allow. */ - if (chunk->end_of_packet) + if (chunk->end_of_packet) { sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE()); + /* Start the SACK timer. */ + sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART, + SCTP_TO(SCTP_EVENT_TIMEOUT_SACK)); + } + return SCTP_DISPOSITION_CONSUME; discard_force: @@ -2716,9 +2721,13 @@ sctp_disposition_t sctp_sf_eat_data_6_2(const struct sctp_endpoint *ep, return SCTP_DISPOSITION_DISCARD; discard_noforce: - if (chunk->end_of_packet) + if (chunk->end_of_packet) { sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE()); + /* Start the SACK timer. */ + sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART, + SCTP_TO(SCTP_EVENT_TIMEOUT_SACK)); + } return SCTP_DISPOSITION_DISCARD; consume: return SCTP_DISPOSITION_CONSUME; @@ -3433,6 +3442,9 @@ sctp_disposition_t sctp_sf_eat_fwd_tsn(const struct sctp_endpoint *ep, * send another. */ sctp_add_cmd_sf(commands, SCTP_CMD_GEN_SACK, SCTP_NOFORCE()); + /* Start the SACK timer. */ + sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_RESTART, + SCTP_TO(SCTP_EVENT_TIMEOUT_SACK)); return SCTP_DISPOSITION_CONSUME; diff --git a/trunk/net/sctp/socket.c b/trunk/net/sctp/socket.c index fc04d185fa33..9df888e932c5 100644 --- a/trunk/net/sctp/socket.c +++ b/trunk/net/sctp/socket.c @@ -1941,379 +1941,107 @@ static int sctp_setsockopt_autoclose(struct sock *sk, char __user *optval, * address's parameters: * * struct sctp_paddrparams { - * sctp_assoc_t spp_assoc_id; - * struct sockaddr_storage spp_address; - * uint32_t spp_hbinterval; - * uint16_t spp_pathmaxrxt; - * uint32_t spp_pathmtu; - * uint32_t spp_sackdelay; - * uint32_t spp_flags; - * }; - * - * spp_assoc_id - (one-to-many style socket) This is filled in the - * application, and identifies the association for - * this query. + * sctp_assoc_t spp_assoc_id; + * struct sockaddr_storage spp_address; + * uint32_t spp_hbinterval; + * uint16_t spp_pathmaxrxt; + * }; + * + * spp_assoc_id - (UDP style socket) This is filled in the application, + * and identifies the association for this query. * spp_address - This specifies which address is of interest. * spp_hbinterval - This contains the value of the heartbeat interval, - * in milliseconds. If a value of zero - * is present in this field then no changes are to - * be made to this parameter. + * in milliseconds. A value of 0, when modifying the + * parameter, specifies that the heartbeat on this + * address should be disabled. A value of UINT32_MAX + * (4294967295), when modifying the parameter, + * specifies that a heartbeat should be sent + * immediately to the peer address, and the current + * interval should remain unchanged. * spp_pathmaxrxt - This contains the maximum number of * retransmissions before this address shall be - * considered unreachable. If a value of zero - * is present in this field then no changes are to - * be made to this parameter. - * spp_pathmtu - When Path MTU discovery is disabled the value - * specified here will be the "fixed" path mtu. - * Note that if the spp_address field is empty - * then all associations on this address will - * have this fixed path mtu set upon them. - * - * spp_sackdelay - When delayed sack is enabled, this value specifies - * the number of milliseconds that sacks will be delayed - * for. This value will apply to all addresses of an - * association if the spp_address field is empty. Note - * also, that if delayed sack is enabled and this - * value is set to 0, no change is made to the last - * recorded delayed sack timer value. - * - * spp_flags - These flags are used to control various features - * on an association. The flag field may contain - * zero or more of the following options. - * - * SPP_HB_ENABLE - Enable heartbeats on the - * specified address. Note that if the address - * field is empty all addresses for the association - * have heartbeats enabled upon them. - * - * SPP_HB_DISABLE - Disable heartbeats on the - * speicifed address. Note that if the address - * field is empty all addresses for the association - * will have their heartbeats disabled. Note also - * that SPP_HB_ENABLE and SPP_HB_DISABLE are - * mutually exclusive, only one of these two should - * be specified. Enabling both fields will have - * undetermined results. - * - * SPP_HB_DEMAND - Request a user initiated heartbeat - * to be made immediately. - * - * SPP_PMTUD_ENABLE - This field will enable PMTU - * discovery upon the specified address. Note that - * if the address feild is empty then all addresses - * on the association are effected. - * - * SPP_PMTUD_DISABLE - This field will disable PMTU - * discovery upon the specified address. Note that - * if the address feild is empty then all addresses - * on the association are effected. Not also that - * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually - * exclusive. Enabling both will have undetermined - * results. - * - * SPP_SACKDELAY_ENABLE - Setting this flag turns - * on delayed sack. The time specified in spp_sackdelay - * is used to specify the sack delay for this address. Note - * that if spp_address is empty then all addresses will - * enable delayed sack and take on the sack delay - * value specified in spp_sackdelay. - * SPP_SACKDELAY_DISABLE - Setting this flag turns - * off delayed sack. If the spp_address field is blank then - * delayed sack is disabled for the entire association. Note - * also that this field is mutually exclusive to - * SPP_SACKDELAY_ENABLE, setting both will have undefined - * results. + * considered unreachable. */ -int sctp_apply_peer_addr_params(struct sctp_paddrparams *params, - struct sctp_transport *trans, - struct sctp_association *asoc, - struct sctp_sock *sp, - int hb_change, - int pmtud_change, - int sackdelay_change) -{ - int error; - - if (params->spp_flags & SPP_HB_DEMAND && trans) { - error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans); - if (error) - return error; - } - - if (params->spp_hbinterval) { - if (trans) { - trans->hbinterval = msecs_to_jiffies(params->spp_hbinterval); - } else if (asoc) { - asoc->hbinterval = msecs_to_jiffies(params->spp_hbinterval); - } else { - sp->hbinterval = params->spp_hbinterval; - } - } - - if (hb_change) { - if (trans) { - trans->param_flags = - (trans->param_flags & ~SPP_HB) | hb_change; - } else if (asoc) { - asoc->param_flags = - (asoc->param_flags & ~SPP_HB) | hb_change; - } else { - sp->param_flags = - (sp->param_flags & ~SPP_HB) | hb_change; - } - } - - if (params->spp_pathmtu) { - if (trans) { - trans->pathmtu = params->spp_pathmtu; - sctp_assoc_sync_pmtu(asoc); - } else if (asoc) { - asoc->pathmtu = params->spp_pathmtu; - sctp_frag_point(sp, params->spp_pathmtu); - } else { - sp->pathmtu = params->spp_pathmtu; - } - } - - if (pmtud_change) { - if (trans) { - int update = (trans->param_flags & SPP_PMTUD_DISABLE) && - (params->spp_flags & SPP_PMTUD_ENABLE); - trans->param_flags = - (trans->param_flags & ~SPP_PMTUD) | pmtud_change; - if (update) { - sctp_transport_pmtu(trans); - sctp_assoc_sync_pmtu(asoc); - } - } else if (asoc) { - asoc->param_flags = - (asoc->param_flags & ~SPP_PMTUD) | pmtud_change; - } else { - sp->param_flags = - (sp->param_flags & ~SPP_PMTUD) | pmtud_change; - } - } - - if (params->spp_sackdelay) { - if (trans) { - trans->sackdelay = - msecs_to_jiffies(params->spp_sackdelay); - } else if (asoc) { - asoc->sackdelay = - msecs_to_jiffies(params->spp_sackdelay); - } else { - sp->sackdelay = params->spp_sackdelay; - } - } - - if (sackdelay_change) { - if (trans) { - trans->param_flags = - (trans->param_flags & ~SPP_SACKDELAY) | - sackdelay_change; - } else if (asoc) { - asoc->param_flags = - (asoc->param_flags & ~SPP_SACKDELAY) | - sackdelay_change; - } else { - sp->param_flags = - (sp->param_flags & ~SPP_SACKDELAY) | - sackdelay_change; - } - } - - if (params->spp_pathmaxrxt) { - if (trans) { - trans->pathmaxrxt = params->spp_pathmaxrxt; - } else if (asoc) { - asoc->pathmaxrxt = params->spp_pathmaxrxt; - } else { - sp->pathmaxrxt = params->spp_pathmaxrxt; - } - } - - return 0; -} - static int sctp_setsockopt_peer_addr_params(struct sock *sk, char __user *optval, int optlen) { - struct sctp_paddrparams params; - struct sctp_transport *trans = NULL; - struct sctp_association *asoc = NULL; - struct sctp_sock *sp = sctp_sk(sk); + struct sctp_paddrparams params; + struct sctp_transport *trans; int error; - int hb_change, pmtud_change, sackdelay_change; if (optlen != sizeof(struct sctp_paddrparams)) - return - EINVAL; - + return -EINVAL; if (copy_from_user(¶ms, optval, optlen)) return -EFAULT; - /* Validate flags and value parameters. */ - hb_change = params.spp_flags & SPP_HB; - pmtud_change = params.spp_flags & SPP_PMTUD; - sackdelay_change = params.spp_flags & SPP_SACKDELAY; - - if (hb_change == SPP_HB || - pmtud_change == SPP_PMTUD || - sackdelay_change == SPP_SACKDELAY || - params.spp_sackdelay > 500 || - (params.spp_pathmtu - && params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT)) - return -EINVAL; - - /* If an address other than INADDR_ANY is specified, and - * no transport is found, then the request is invalid. + /* + * API 7. Socket Options (setting the default value for the endpoint) + * All options that support specific settings on an association by + * filling in either an association id variable or a sockaddr_storage + * SHOULD also support setting of the same value for the entire endpoint + * (i.e. future associations). To accomplish this the following logic is + * used when setting one of these options: + + * c) If neither the sockaddr_storage or association identification is + * set i.e. the sockaddr_storage is set to all 0's (INADDR_ANY) and + * the association identification is 0, the settings are a default + * and to be applied to the endpoint (all future associations). */ - if (!sctp_is_any(( union sctp_addr *)¶ms.spp_address)) { - trans = sctp_addr_id2transport(sk, ¶ms.spp_address, - params.spp_assoc_id); - if (!trans) + + /* update default value for endpoint (all future associations) */ + if (!params.spp_assoc_id && + sctp_is_any(( union sctp_addr *)¶ms.spp_address)) { + /* Manual heartbeat on an endpoint is invalid. */ + if (0xffffffff == params.spp_hbinterval) return -EINVAL; + else if (params.spp_hbinterval) + sctp_sk(sk)->paddrparam.spp_hbinterval = + params.spp_hbinterval; + if (params.spp_pathmaxrxt) + sctp_sk(sk)->paddrparam.spp_pathmaxrxt = + params.spp_pathmaxrxt; + return 0; } - /* Get association, if assoc_id != 0 and the socket is a one - * to many style socket, and an association was not found, then - * the id was invalid. - */ - asoc = sctp_id2assoc(sk, params.spp_assoc_id); - if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) - return -EINVAL; - - /* Heartbeat demand can only be sent on a transport or - * association, but not a socket. - */ - if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc) + trans = sctp_addr_id2transport(sk, ¶ms.spp_address, + params.spp_assoc_id); + if (!trans) return -EINVAL; - /* Process parameters. */ - error = sctp_apply_peer_addr_params(¶ms, trans, asoc, sp, - hb_change, pmtud_change, - sackdelay_change); - - if (error) - return error; - - /* If changes are for association, also apply parameters to each - * transport. + /* Applications can enable or disable heartbeats for any peer address + * of an association, modify an address's heartbeat interval, force a + * heartbeat to be sent immediately, and adjust the address's maximum + * number of retransmissions sent before an address is considered + * unreachable. + * + * The value of the heartbeat interval, in milliseconds. A value of + * UINT32_MAX (4294967295), when modifying the parameter, specifies + * that a heartbeat should be sent immediately to the peer address, + * and the current interval should remain unchanged. */ - if (!trans && asoc) { - struct list_head *pos; - - list_for_each(pos, &asoc->peer.transport_addr_list) { - trans = list_entry(pos, struct sctp_transport, - transports); - sctp_apply_peer_addr_params(¶ms, trans, asoc, sp, - hb_change, pmtud_change, - sackdelay_change); - } - } - - return 0; -} - -/* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME) - * - * This options will get or set the delayed ack timer. The time is set - * in milliseconds. If the assoc_id is 0, then this sets or gets the - * endpoints default delayed ack timer value. If the assoc_id field is - * non-zero, then the set or get effects the specified association. - * - * struct sctp_assoc_value { - * sctp_assoc_t assoc_id; - * uint32_t assoc_value; - * }; - * - * assoc_id - This parameter, indicates which association the - * user is preforming an action upon. Note that if - * this field's value is zero then the endpoints - * default value is changed (effecting future - * associations only). - * - * assoc_value - This parameter contains the number of milliseconds - * that the user is requesting the delayed ACK timer - * be set to. Note that this value is defined in - * the standard to be between 200 and 500 milliseconds. - * - * Note: a value of zero will leave the value alone, - * but disable SACK delay. A non-zero value will also - * enable SACK delay. - */ - -static int sctp_setsockopt_delayed_ack_time(struct sock *sk, - char __user *optval, int optlen) -{ - struct sctp_assoc_value params; - struct sctp_transport *trans = NULL; - struct sctp_association *asoc = NULL; - struct sctp_sock *sp = sctp_sk(sk); - - if (optlen != sizeof(struct sctp_assoc_value)) - return - EINVAL; - - if (copy_from_user(¶ms, optval, optlen)) - return -EFAULT; - - /* Validate value parameter. */ - if (params.assoc_value > 500) - return -EINVAL; - - /* Get association, if assoc_id != 0 and the socket is a one - * to many style socket, and an association was not found, then - * the id was invalid. - */ - asoc = sctp_id2assoc(sk, params.assoc_id); - if (!asoc && params.assoc_id && sctp_style(sk, UDP)) - return -EINVAL; - - if (params.assoc_value) { - if (asoc) { - asoc->sackdelay = - msecs_to_jiffies(params.assoc_value); - asoc->param_flags = - (asoc->param_flags & ~SPP_SACKDELAY) | - SPP_SACKDELAY_ENABLE; - } else { - sp->sackdelay = params.assoc_value; - sp->param_flags = - (sp->param_flags & ~SPP_SACKDELAY) | - SPP_SACKDELAY_ENABLE; - } + if (0xffffffff == params.spp_hbinterval) { + error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans); + if (error) + return error; } else { - if (asoc) { - asoc->param_flags = - (asoc->param_flags & ~SPP_SACKDELAY) | - SPP_SACKDELAY_DISABLE; - } else { - sp->param_flags = - (sp->param_flags & ~SPP_SACKDELAY) | - SPP_SACKDELAY_DISABLE; - } + /* The value of the heartbeat interval, in milliseconds. A value of 0, + * when modifying the parameter, specifies that the heartbeat on this + * address should be disabled. + */ + if (params.spp_hbinterval) { + trans->hb_allowed = 1; + trans->hb_interval = + msecs_to_jiffies(params.spp_hbinterval); + } else + trans->hb_allowed = 0; } - /* If change is for association, also apply to each transport. */ - if (asoc) { - struct list_head *pos; + /* spp_pathmaxrxt contains the maximum number of retransmissions + * before this address shall be considered unreachable. + */ + if (params.spp_pathmaxrxt) + trans->max_retrans = params.spp_pathmaxrxt; - list_for_each(pos, &asoc->peer.transport_addr_list) { - trans = list_entry(pos, struct sctp_transport, - transports); - if (params.assoc_value) { - trans->sackdelay = - msecs_to_jiffies(params.assoc_value); - trans->param_flags = - (trans->param_flags & ~SPP_SACKDELAY) | - SPP_SACKDELAY_ENABLE; - } else { - trans->param_flags = - (trans->param_flags & ~SPP_SACKDELAY) | - SPP_SACKDELAY_DISABLE; - } - } - } - return 0; } @@ -2606,7 +2334,7 @@ static int sctp_setsockopt_maxseg(struct sock *sk, char __user *optval, int optl /* Update the frag_point of the existing associations. */ list_for_each(pos, &(sp->ep->asocs)) { asoc = list_entry(pos, struct sctp_association, asocs); - asoc->frag_point = sctp_frag_point(sp, asoc->pathmtu); + asoc->frag_point = sctp_frag_point(sp, asoc->pmtu); } return 0; @@ -2763,10 +2491,6 @@ SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname, retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen); break; - case SCTP_DELAYED_ACK_TIME: - retval = sctp_setsockopt_delayed_ack_time(sk, optval, optlen); - break; - case SCTP_INITMSG: retval = sctp_setsockopt_initmsg(sk, optval, optlen); break; @@ -2991,13 +2715,8 @@ SCTP_STATIC int sctp_init_sock(struct sock *sk) /* Default Peer Address Parameters. These defaults can * be modified via SCTP_PEER_ADDR_PARAMS */ - sp->hbinterval = jiffies_to_msecs(sctp_hb_interval); - sp->pathmaxrxt = sctp_max_retrans_path; - sp->pathmtu = 0; // allow default discovery - sp->sackdelay = sctp_sack_timeout; - sp->param_flags = SPP_HB_ENABLE | - SPP_PMTUD_ENABLE | - SPP_SACKDELAY_ENABLE; + sp->paddrparam.spp_hbinterval = jiffies_to_msecs(sctp_hb_interval); + sp->paddrparam.spp_pathmaxrxt = sctp_max_retrans_path; /* If enabled no SCTP message fragmentation will be performed. * Configure through SCTP_DISABLE_FRAGMENTS socket option. @@ -3146,7 +2865,7 @@ static int sctp_getsockopt_sctp_status(struct sock *sk, int len, status.sstat_primary.spinfo_cwnd = transport->cwnd; status.sstat_primary.spinfo_srtt = transport->srtt; status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto); - status.sstat_primary.spinfo_mtu = transport->pathmtu; + status.sstat_primary.spinfo_mtu = transport->pmtu; if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN) status.sstat_primary.spinfo_state = SCTP_ACTIVE; @@ -3205,7 +2924,7 @@ static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len, pinfo.spinfo_cwnd = transport->cwnd; pinfo.spinfo_srtt = transport->srtt; pinfo.spinfo_rto = jiffies_to_msecs(transport->rto); - pinfo.spinfo_mtu = transport->pathmtu; + pinfo.spinfo_mtu = transport->pmtu; if (pinfo.spinfo_state == SCTP_UNKNOWN) pinfo.spinfo_state = SCTP_ACTIVE; @@ -3367,227 +3086,69 @@ static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval * address's parameters: * * struct sctp_paddrparams { - * sctp_assoc_t spp_assoc_id; - * struct sockaddr_storage spp_address; - * uint32_t spp_hbinterval; - * uint16_t spp_pathmaxrxt; - * uint32_t spp_pathmtu; - * uint32_t spp_sackdelay; - * uint32_t spp_flags; - * }; - * - * spp_assoc_id - (one-to-many style socket) This is filled in the - * application, and identifies the association for - * this query. + * sctp_assoc_t spp_assoc_id; + * struct sockaddr_storage spp_address; + * uint32_t spp_hbinterval; + * uint16_t spp_pathmaxrxt; + * }; + * + * spp_assoc_id - (UDP style socket) This is filled in the application, + * and identifies the association for this query. * spp_address - This specifies which address is of interest. * spp_hbinterval - This contains the value of the heartbeat interval, - * in milliseconds. If a value of zero - * is present in this field then no changes are to - * be made to this parameter. + * in milliseconds. A value of 0, when modifying the + * parameter, specifies that the heartbeat on this + * address should be disabled. A value of UINT32_MAX + * (4294967295), when modifying the parameter, + * specifies that a heartbeat should be sent + * immediately to the peer address, and the current + * interval should remain unchanged. * spp_pathmaxrxt - This contains the maximum number of * retransmissions before this address shall be - * considered unreachable. If a value of zero - * is present in this field then no changes are to - * be made to this parameter. - * spp_pathmtu - When Path MTU discovery is disabled the value - * specified here will be the "fixed" path mtu. - * Note that if the spp_address field is empty - * then all associations on this address will - * have this fixed path mtu set upon them. - * - * spp_sackdelay - When delayed sack is enabled, this value specifies - * the number of milliseconds that sacks will be delayed - * for. This value will apply to all addresses of an - * association if the spp_address field is empty. Note - * also, that if delayed sack is enabled and this - * value is set to 0, no change is made to the last - * recorded delayed sack timer value. - * - * spp_flags - These flags are used to control various features - * on an association. The flag field may contain - * zero or more of the following options. - * - * SPP_HB_ENABLE - Enable heartbeats on the - * specified address. Note that if the address - * field is empty all addresses for the association - * have heartbeats enabled upon them. - * - * SPP_HB_DISABLE - Disable heartbeats on the - * speicifed address. Note that if the address - * field is empty all addresses for the association - * will have their heartbeats disabled. Note also - * that SPP_HB_ENABLE and SPP_HB_DISABLE are - * mutually exclusive, only one of these two should - * be specified. Enabling both fields will have - * undetermined results. - * - * SPP_HB_DEMAND - Request a user initiated heartbeat - * to be made immediately. - * - * SPP_PMTUD_ENABLE - This field will enable PMTU - * discovery upon the specified address. Note that - * if the address feild is empty then all addresses - * on the association are effected. - * - * SPP_PMTUD_DISABLE - This field will disable PMTU - * discovery upon the specified address. Note that - * if the address feild is empty then all addresses - * on the association are effected. Not also that - * SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually - * exclusive. Enabling both will have undetermined - * results. - * - * SPP_SACKDELAY_ENABLE - Setting this flag turns - * on delayed sack. The time specified in spp_sackdelay - * is used to specify the sack delay for this address. Note - * that if spp_address is empty then all addresses will - * enable delayed sack and take on the sack delay - * value specified in spp_sackdelay. - * SPP_SACKDELAY_DISABLE - Setting this flag turns - * off delayed sack. If the spp_address field is blank then - * delayed sack is disabled for the entire association. Note - * also that this field is mutually exclusive to - * SPP_SACKDELAY_ENABLE, setting both will have undefined - * results. + * considered unreachable. */ static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len, - char __user *optval, int __user *optlen) + char __user *optval, int __user *optlen) { - struct sctp_paddrparams params; - struct sctp_transport *trans = NULL; - struct sctp_association *asoc = NULL; - struct sctp_sock *sp = sctp_sk(sk); + struct sctp_paddrparams params; + struct sctp_transport *trans; if (len != sizeof(struct sctp_paddrparams)) return -EINVAL; - if (copy_from_user(¶ms, optval, len)) return -EFAULT; - /* If an address other than INADDR_ANY is specified, and - * no transport is found, then the request is invalid. + /* If no association id is specified retrieve the default value + * for the endpoint that will be used for all future associations */ - if (!sctp_is_any(( union sctp_addr *)¶ms.spp_address)) { - trans = sctp_addr_id2transport(sk, ¶ms.spp_address, - params.spp_assoc_id); - if (!trans) { - SCTP_DEBUG_PRINTK("Failed no transport\n"); - return -EINVAL; - } - } + if (!params.spp_assoc_id && + sctp_is_any(( union sctp_addr *)¶ms.spp_address)) { + params.spp_hbinterval = sctp_sk(sk)->paddrparam.spp_hbinterval; + params.spp_pathmaxrxt = sctp_sk(sk)->paddrparam.spp_pathmaxrxt; - /* Get association, if assoc_id != 0 and the socket is a one - * to many style socket, and an association was not found, then - * the id was invalid. - */ - asoc = sctp_id2assoc(sk, params.spp_assoc_id); - if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) { - SCTP_DEBUG_PRINTK("Failed no association\n"); - return -EINVAL; - } - - if (trans) { - /* Fetch transport values. */ - params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval); - params.spp_pathmtu = trans->pathmtu; - params.spp_pathmaxrxt = trans->pathmaxrxt; - params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay); - - /*draft-11 doesn't say what to return in spp_flags*/ - params.spp_flags = trans->param_flags; - } else if (asoc) { - /* Fetch association values. */ - params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval); - params.spp_pathmtu = asoc->pathmtu; - params.spp_pathmaxrxt = asoc->pathmaxrxt; - params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay); - - /*draft-11 doesn't say what to return in spp_flags*/ - params.spp_flags = asoc->param_flags; - } else { - /* Fetch socket values. */ - params.spp_hbinterval = sp->hbinterval; - params.spp_pathmtu = sp->pathmtu; - params.spp_sackdelay = sp->sackdelay; - params.spp_pathmaxrxt = sp->pathmaxrxt; - - /*draft-11 doesn't say what to return in spp_flags*/ - params.spp_flags = sp->param_flags; + goto done; } - if (copy_to_user(optval, ¶ms, len)) - return -EFAULT; - - if (put_user(len, optlen)) - return -EFAULT; - - return 0; -} - -/* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME) - * - * This options will get or set the delayed ack timer. The time is set - * in milliseconds. If the assoc_id is 0, then this sets or gets the - * endpoints default delayed ack timer value. If the assoc_id field is - * non-zero, then the set or get effects the specified association. - * - * struct sctp_assoc_value { - * sctp_assoc_t assoc_id; - * uint32_t assoc_value; - * }; - * - * assoc_id - This parameter, indicates which association the - * user is preforming an action upon. Note that if - * this field's value is zero then the endpoints - * default value is changed (effecting future - * associations only). - * - * assoc_value - This parameter contains the number of milliseconds - * that the user is requesting the delayed ACK timer - * be set to. Note that this value is defined in - * the standard to be between 200 and 500 milliseconds. - * - * Note: a value of zero will leave the value alone, - * but disable SACK delay. A non-zero value will also - * enable SACK delay. - */ -static int sctp_getsockopt_delayed_ack_time(struct sock *sk, int len, - char __user *optval, - int __user *optlen) -{ - struct sctp_assoc_value params; - struct sctp_association *asoc = NULL; - struct sctp_sock *sp = sctp_sk(sk); - - if (len != sizeof(struct sctp_assoc_value)) - return - EINVAL; - - if (copy_from_user(¶ms, optval, len)) - return -EFAULT; - - /* Get association, if assoc_id != 0 and the socket is a one - * to many style socket, and an association was not found, then - * the id was invalid. - */ - asoc = sctp_id2assoc(sk, params.assoc_id); - if (!asoc && params.assoc_id && sctp_style(sk, UDP)) + trans = sctp_addr_id2transport(sk, ¶ms.spp_address, + params.spp_assoc_id); + if (!trans) return -EINVAL; - if (asoc) { - /* Fetch association values. */ - if (asoc->param_flags & SPP_SACKDELAY_ENABLE) - params.assoc_value = jiffies_to_msecs( - asoc->sackdelay); - else - params.assoc_value = 0; - } else { - /* Fetch socket values. */ - if (sp->param_flags & SPP_SACKDELAY_ENABLE) - params.assoc_value = sp->sackdelay; - else - params.assoc_value = 0; - } + /* The value of the heartbeat interval, in milliseconds. A value of 0, + * when modifying the parameter, specifies that the heartbeat on this + * address should be disabled. + */ + if (!trans->hb_allowed) + params.spp_hbinterval = 0; + else + params.spp_hbinterval = jiffies_to_msecs(trans->hb_interval); + /* spp_pathmaxrxt contains the maximum number of retransmissions + * before this address shall be considered unreachable. + */ + params.spp_pathmaxrxt = trans->max_retrans; + +done: if (copy_to_user(optval, ¶ms, len)) return -EFAULT; @@ -4454,10 +4015,6 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname, retval = sctp_getsockopt_peer_addr_params(sk, len, optval, optlen); break; - case SCTP_DELAYED_ACK_TIME: - retval = sctp_getsockopt_delayed_ack_time(sk, len, optval, - optlen); - break; case SCTP_INITMSG: retval = sctp_getsockopt_initmsg(sk, len, optval, optlen); break; diff --git a/trunk/net/sctp/transport.c b/trunk/net/sctp/transport.c index 68d73e2dd155..268ddaf2dc0f 100644 --- a/trunk/net/sctp/transport.c +++ b/trunk/net/sctp/transport.c @@ -86,13 +86,10 @@ static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer, peer->init_sent_count = 0; peer->state = SCTP_ACTIVE; - peer->param_flags = SPP_HB_DISABLE | - SPP_PMTUD_ENABLE | - SPP_SACKDELAY_ENABLE; - peer->hbinterval = 0; + peer->hb_allowed = 0; /* Initialize the default path max_retrans. */ - peer->pathmaxrxt = sctp_max_retrans_path; + peer->max_retrans = sctp_max_retrans_path; peer->error_count = 0; INIT_LIST_HEAD(&peer->transmitted); @@ -232,10 +229,10 @@ void sctp_transport_pmtu(struct sctp_transport *transport) dst = transport->af_specific->get_dst(NULL, &transport->ipaddr, NULL); if (dst) { - transport->pathmtu = dst_mtu(dst); + transport->pmtu = dst_mtu(dst); dst_release(dst); } else - transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT; + transport->pmtu = SCTP_DEFAULT_MAXSEGMENT; } /* Caches the dst entry and source address for a transport's destination @@ -257,11 +254,8 @@ void sctp_transport_route(struct sctp_transport *transport, af->get_saddr(asoc, dst, daddr, &transport->saddr); transport->dst = dst; - if ((transport->param_flags & SPP_PMTUD_DISABLE) && transport->pathmtu) { - return; - } if (dst) { - transport->pathmtu = dst_mtu(dst); + transport->pmtu = dst_mtu(dst); /* Initialize sk->sk_rcv_saddr, if the transport is the * association's active path for getsockname(). @@ -270,7 +264,7 @@ void sctp_transport_route(struct sctp_transport *transport, opt->pf->af->to_sk_saddr(&transport->saddr, asoc->base.sk); } else - transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT; + transport->pmtu = SCTP_DEFAULT_MAXSEGMENT; } /* Hold a reference to a transport. */ @@ -375,7 +369,7 @@ void sctp_transport_raise_cwnd(struct sctp_transport *transport, ssthresh = transport->ssthresh; pba = transport->partial_bytes_acked; - pmtu = transport->asoc->pathmtu; + pmtu = transport->asoc->pmtu; if (cwnd <= ssthresh) { /* RFC 2960 7.2.1, sctpimpguide-05 2.14.2 When cwnd is less @@ -447,8 +441,8 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport, * partial_bytes_acked = 0 */ transport->ssthresh = max(transport->cwnd/2, - 4*transport->asoc->pathmtu); - transport->cwnd = transport->asoc->pathmtu; + 4*transport->asoc->pmtu); + transport->cwnd = transport->asoc->pmtu; break; case SCTP_LOWER_CWND_FAST_RTX: @@ -465,7 +459,7 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport, * partial_bytes_acked = 0 */ transport->ssthresh = max(transport->cwnd/2, - 4*transport->asoc->pathmtu); + 4*transport->asoc->pmtu); transport->cwnd = transport->ssthresh; break; @@ -485,7 +479,7 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport, if ((jiffies - transport->last_time_ecne_reduced) > transport->rtt) { transport->ssthresh = max(transport->cwnd/2, - 4*transport->asoc->pathmtu); + 4*transport->asoc->pmtu); transport->cwnd = transport->ssthresh; transport->last_time_ecne_reduced = jiffies; } @@ -502,7 +496,7 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport, */ if ((jiffies - transport->last_time_used) > transport->rto) transport->cwnd = max(transport->cwnd/2, - 4*transport->asoc->pathmtu); + 4*transport->asoc->pmtu); break; }; @@ -517,7 +511,7 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport, unsigned long sctp_transport_timeout(struct sctp_transport *t) { unsigned long timeout; - timeout = t->hbinterval + t->rto + sctp_jitter(t->rto); + timeout = t->hb_interval + t->rto + sctp_jitter(t->rto); timeout += jiffies; return timeout; } diff --git a/trunk/net/socket.c b/trunk/net/socket.c index 06fa217f58a9..3145103cdf54 100644 --- a/trunk/net/socket.c +++ b/trunk/net/socket.c @@ -640,150 +640,154 @@ static void sock_aio_dtor(struct kiocb *iocb) kfree(iocb->private); } -static ssize_t sock_sendpage(struct file *file, struct page *page, - int offset, size_t size, loff_t *ppos, int more) +/* + * Read data from a socket. ubuf is a user mode pointer. We make sure the user + * area ubuf...ubuf+size-1 is writable before asking the protocol. + */ + +static ssize_t sock_aio_read(struct kiocb *iocb, char __user *ubuf, + size_t size, loff_t pos) { + struct sock_iocb *x, siocb; struct socket *sock; int flags; - sock = file->private_data; - - flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; - if (more) - flags |= MSG_MORE; - - return sock->ops->sendpage(sock, page, offset, size, flags); -} + if (pos != 0) + return -ESPIPE; + if (size==0) /* Match SYS5 behaviour */ + return 0; -static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, - char __user *ubuf, size_t size, struct sock_iocb *siocb) -{ - if (!is_sync_kiocb(iocb)) { - siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); - if (!siocb) - return NULL; + if (is_sync_kiocb(iocb)) + x = &siocb; + else { + x = kmalloc(sizeof(struct sock_iocb), GFP_KERNEL); + if (!x) + return -ENOMEM; iocb->ki_dtor = sock_aio_dtor; } + iocb->private = x; + x->kiocb = iocb; + sock = iocb->ki_filp->private_data; - siocb->kiocb = iocb; - siocb->async_iov.iov_base = ubuf; - siocb->async_iov.iov_len = size; + x->async_msg.msg_name = NULL; + x->async_msg.msg_namelen = 0; + x->async_msg.msg_iov = &x->async_iov; + x->async_msg.msg_iovlen = 1; + x->async_msg.msg_control = NULL; + x->async_msg.msg_controllen = 0; + x->async_iov.iov_base = ubuf; + x->async_iov.iov_len = size; + flags = !(iocb->ki_filp->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; - iocb->private = siocb; - return siocb; + return __sock_recvmsg(iocb, sock, &x->async_msg, size, flags); } -static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, - struct file *file, struct iovec *iov, unsigned long nr_segs) -{ - struct socket *sock = file->private_data; - size_t size = 0; - int i; - for (i = 0 ; i < nr_segs ; i++) - size += iov[i].iov_len; - - msg->msg_name = NULL; - msg->msg_namelen = 0; - msg->msg_control = NULL; - msg->msg_controllen = 0; - msg->msg_iov = (struct iovec *) iov; - msg->msg_iovlen = nr_segs; - msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; - - return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); -} - -static ssize_t sock_readv(struct file *file, const struct iovec *iov, - unsigned long nr_segs, loff_t *ppos) -{ - struct kiocb iocb; - struct sock_iocb siocb; - struct msghdr msg; - int ret; - - init_sync_kiocb(&iocb, NULL); - iocb.private = &siocb; - - ret = do_sock_read(&msg, &iocb, file, (struct iovec *)iov, nr_segs); - if (-EIOCBQUEUED == ret) - ret = wait_on_sync_kiocb(&iocb); - return ret; -} +/* + * Write data to a socket. We verify that the user area ubuf..ubuf+size-1 + * is readable by the user process. + */ -static ssize_t sock_aio_read(struct kiocb *iocb, char __user *ubuf, - size_t count, loff_t pos) +static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf, + size_t size, loff_t pos) { - struct sock_iocb siocb, *x; - + struct sock_iocb *x, siocb; + struct socket *sock; + if (pos != 0) return -ESPIPE; - if (count == 0) /* Match SYS5 behaviour */ + if(size==0) /* Match SYS5 behaviour */ return 0; - x = alloc_sock_iocb(iocb, ubuf, count, &siocb); - if (!x) - return -ENOMEM; - return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, - &x->async_iov, 1); + if (is_sync_kiocb(iocb)) + x = &siocb; + else { + x = kmalloc(sizeof(struct sock_iocb), GFP_KERNEL); + if (!x) + return -ENOMEM; + iocb->ki_dtor = sock_aio_dtor; + } + iocb->private = x; + x->kiocb = iocb; + sock = iocb->ki_filp->private_data; + + x->async_msg.msg_name = NULL; + x->async_msg.msg_namelen = 0; + x->async_msg.msg_iov = &x->async_iov; + x->async_msg.msg_iovlen = 1; + x->async_msg.msg_control = NULL; + x->async_msg.msg_controllen = 0; + x->async_msg.msg_flags = !(iocb->ki_filp->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; + if (sock->type == SOCK_SEQPACKET) + x->async_msg.msg_flags |= MSG_EOR; + x->async_iov.iov_base = (void __user *)ubuf; + x->async_iov.iov_len = size; + + return __sock_sendmsg(iocb, sock, &x->async_msg, size); } -static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, - struct file *file, struct iovec *iov, unsigned long nr_segs) +static ssize_t sock_sendpage(struct file *file, struct page *page, + int offset, size_t size, loff_t *ppos, int more) { - struct socket *sock = file->private_data; - size_t size = 0; - int i; + struct socket *sock; + int flags; - for (i = 0 ; i < nr_segs ; i++) - size += iov[i].iov_len; + sock = file->private_data; - msg->msg_name = NULL; - msg->msg_namelen = 0; - msg->msg_control = NULL; - msg->msg_controllen = 0; - msg->msg_iov = (struct iovec *) iov; - msg->msg_iovlen = nr_segs; - msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; - if (sock->type == SOCK_SEQPACKET) - msg->msg_flags |= MSG_EOR; + flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; + if (more) + flags |= MSG_MORE; - return __sock_sendmsg(iocb, sock, msg, size); + return sock->ops->sendpage(sock, page, offset, size, flags); } -static ssize_t sock_writev(struct file *file, const struct iovec *iov, - unsigned long nr_segs, loff_t *ppos) +static int sock_readv_writev(int type, + struct file * file, const struct iovec * iov, + long count, size_t size) { struct msghdr msg; - struct kiocb iocb; - struct sock_iocb siocb; - int ret; + struct socket *sock; - init_sync_kiocb(&iocb, NULL); - iocb.private = &siocb; + sock = file->private_data; - ret = do_sock_write(&msg, &iocb, file, (struct iovec *)iov, nr_segs); - if (-EIOCBQUEUED == ret) - ret = wait_on_sync_kiocb(&iocb); - return ret; -} + msg.msg_name = NULL; + msg.msg_namelen = 0; + msg.msg_control = NULL; + msg.msg_controllen = 0; + msg.msg_iov = (struct iovec *) iov; + msg.msg_iovlen = count; + msg.msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; -static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf, - size_t count, loff_t pos) -{ - struct sock_iocb siocb, *x; + /* read() does a VERIFY_WRITE */ + if (type == VERIFY_WRITE) + return sock_recvmsg(sock, &msg, size, msg.msg_flags); - if (pos != 0) - return -ESPIPE; - if (count == 0) /* Match SYS5 behaviour */ - return 0; + if (sock->type == SOCK_SEQPACKET) + msg.msg_flags |= MSG_EOR; - x = alloc_sock_iocb(iocb, (void __user *)ubuf, count, &siocb); - if (!x) - return -ENOMEM; + return sock_sendmsg(sock, &msg, size); +} - return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, - &x->async_iov, 1); +static ssize_t sock_readv(struct file *file, const struct iovec *vector, + unsigned long count, loff_t *ppos) +{ + size_t tot_len = 0; + int i; + for (i = 0 ; i < count ; i++) + tot_len += vector[i].iov_len; + return sock_readv_writev(VERIFY_WRITE, + file, vector, count, tot_len); +} + +static ssize_t sock_writev(struct file *file, const struct iovec *vector, + unsigned long count, loff_t *ppos) +{ + size_t tot_len = 0; + int i; + for (i = 0 ; i < count ; i++) + tot_len += vector[i].iov_len; + return sock_readv_writev(VERIFY_READ, + file, vector, count, tot_len); } @@ -900,13 +904,6 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) break; default: err = sock->ops->ioctl(sock, cmd, arg); - - /* - * If this ioctl is unknown try to hand it down - * to the NIC driver. - */ - if (err == -ENOIOCTLCMD) - err = dev_ioctl(cmd, argp); break; } return err; @@ -2039,7 +2036,7 @@ int sock_unregister(int family) return 0; } -static int __init sock_init(void) +void __init sock_init(void) { /* * Initialize sock SLAB cache. @@ -2047,10 +2044,12 @@ static int __init sock_init(void) sk_init(); +#ifdef SLAB_SKB /* * Initialize skbuff SLAB cache */ skb_init(); +#endif /* * Initialize the protocols module. @@ -2059,19 +2058,15 @@ static int __init sock_init(void) init_inodecache(); register_filesystem(&sock_fs_type); sock_mnt = kern_mount(&sock_fs_type); - - /* The real protocol initialization is performed in later initcalls. + /* The real protocol initialization is performed when + * do_initcalls is run. */ #ifdef CONFIG_NETFILTER netfilter_init(); #endif - - return 0; } -core_initcall(sock_init); /* early initcall */ - #ifdef CONFIG_PROC_FS void socket_seq_show(struct seq_file *seq) { diff --git a/trunk/net/sunrpc/svcsock.c b/trunk/net/sunrpc/svcsock.c index d68eba481291..c6a51911e71e 100644 --- a/trunk/net/sunrpc/svcsock.c +++ b/trunk/net/sunrpc/svcsock.c @@ -758,7 +758,7 @@ svc_tcp_accept(struct svc_sock *svsk) struct svc_serv *serv = svsk->sk_server; struct socket *sock = svsk->sk_sock; struct socket *newsock; - const struct proto_ops *ops; + struct proto_ops *ops; struct svc_sock *newsvsk; int err, slen; diff --git a/trunk/net/unix/af_unix.c b/trunk/net/unix/af_unix.c index 5f6ae79b8b16..acc73ba8bade 100644 --- a/trunk/net/unix/af_unix.c +++ b/trunk/net/unix/af_unix.c @@ -121,7 +121,7 @@ int sysctl_unix_max_dgram_qlen = 10; struct hlist_head unix_socket_table[UNIX_HASH_SIZE + 1]; -DEFINE_SPINLOCK(unix_table_lock); +DEFINE_RWLOCK(unix_table_lock); static atomic_t unix_nr_socks = ATOMIC_INIT(0); #define unix_sockets_unbound (&unix_socket_table[UNIX_HASH_SIZE]) @@ -130,7 +130,7 @@ static atomic_t unix_nr_socks = ATOMIC_INIT(0); /* * SMP locking strategy: - * hash table is protected with spinlock unix_table_lock + * hash table is protected with rwlock unix_table_lock * each socket state is protected by separate rwlock. */ @@ -214,16 +214,16 @@ static void __unix_insert_socket(struct hlist_head *list, struct sock *sk) static inline void unix_remove_socket(struct sock *sk) { - spin_lock(&unix_table_lock); + write_lock(&unix_table_lock); __unix_remove_socket(sk); - spin_unlock(&unix_table_lock); + write_unlock(&unix_table_lock); } static inline void unix_insert_socket(struct hlist_head *list, struct sock *sk) { - spin_lock(&unix_table_lock); + write_lock(&unix_table_lock); __unix_insert_socket(list, sk); - spin_unlock(&unix_table_lock); + write_unlock(&unix_table_lock); } static struct sock *__unix_find_socket_byname(struct sockaddr_un *sunname, @@ -250,11 +250,11 @@ static inline struct sock *unix_find_socket_byname(struct sockaddr_un *sunname, { struct sock *s; - spin_lock(&unix_table_lock); + read_lock(&unix_table_lock); s = __unix_find_socket_byname(sunname, len, type, hash); if (s) sock_hold(s); - spin_unlock(&unix_table_lock); + read_unlock(&unix_table_lock); return s; } @@ -263,7 +263,7 @@ static struct sock *unix_find_socket_byinode(struct inode *i) struct sock *s; struct hlist_node *node; - spin_lock(&unix_table_lock); + read_lock(&unix_table_lock); sk_for_each(s, node, &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) { struct dentry *dentry = unix_sk(s)->dentry; @@ -276,7 +276,7 @@ static struct sock *unix_find_socket_byinode(struct inode *i) } s = NULL; found: - spin_unlock(&unix_table_lock); + read_unlock(&unix_table_lock); return s; } @@ -473,7 +473,7 @@ static int unix_dgram_connect(struct socket *, struct sockaddr *, static int unix_seqpacket_sendmsg(struct kiocb *, struct socket *, struct msghdr *, size_t); -static const struct proto_ops unix_stream_ops = { +static struct proto_ops unix_stream_ops = { .family = PF_UNIX, .owner = THIS_MODULE, .release = unix_release, @@ -494,7 +494,7 @@ static const struct proto_ops unix_stream_ops = { .sendpage = sock_no_sendpage, }; -static const struct proto_ops unix_dgram_ops = { +static struct proto_ops unix_dgram_ops = { .family = PF_UNIX, .owner = THIS_MODULE, .release = unix_release, @@ -515,7 +515,7 @@ static const struct proto_ops unix_dgram_ops = { .sendpage = sock_no_sendpage, }; -static const struct proto_ops unix_seqpacket_ops = { +static struct proto_ops unix_seqpacket_ops = { .family = PF_UNIX, .owner = THIS_MODULE, .release = unix_release, @@ -564,7 +564,7 @@ static struct sock * unix_create1(struct socket *sock) u = unix_sk(sk); u->dentry = NULL; u->mnt = NULL; - spin_lock_init(&u->lock); + rwlock_init(&u->lock); atomic_set(&u->inflight, sock ? 0 : -1); init_MUTEX(&u->readsem); /* single task reading lock */ init_waitqueue_head(&u->peer_wait); @@ -642,12 +642,12 @@ static int unix_autobind(struct socket *sock) addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short); addr->hash = unix_hash_fold(csum_partial((void*)addr->name, addr->len, 0)); - spin_lock(&unix_table_lock); + write_lock(&unix_table_lock); ordernum = (ordernum+1)&0xFFFFF; if (__unix_find_socket_byname(addr->name, addr->len, sock->type, addr->hash)) { - spin_unlock(&unix_table_lock); + write_unlock(&unix_table_lock); /* Sanity yield. It is unusual case, but yet... */ if (!(ordernum&0xFF)) yield(); @@ -658,7 +658,7 @@ static int unix_autobind(struct socket *sock) __unix_remove_socket(sk); u->addr = addr; __unix_insert_socket(&unix_socket_table[addr->hash], sk); - spin_unlock(&unix_table_lock); + write_unlock(&unix_table_lock); err = 0; out: up(&u->readsem); @@ -791,7 +791,7 @@ static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) addr->hash = UNIX_HASH_SIZE; } - spin_lock(&unix_table_lock); + write_lock(&unix_table_lock); if (!sunaddr->sun_path[0]) { err = -EADDRINUSE; @@ -814,7 +814,7 @@ static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) __unix_insert_socket(list, sk); out_unlock: - spin_unlock(&unix_table_lock); + write_unlock(&unix_table_lock); out_up: up(&u->readsem); out: @@ -1063,12 +1063,10 @@ static int unix_stream_connect(struct socket *sock, struct sockaddr *uaddr, /* Set credentials */ sk->sk_peercred = other->sk_peercred; - sock->state = SS_CONNECTED; - sk->sk_state = TCP_ESTABLISHED; sock_hold(newsk); - - smp_mb__after_atomic_inc(); /* sock_hold() does an atomic_inc() */ unix_peer(sk) = newsk; + sock->state = SS_CONNECTED; + sk->sk_state = TCP_ESTABLISHED; unix_state_wunlock(sk); @@ -1416,7 +1414,7 @@ static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock, } else { sunaddr = NULL; err = -ENOTCONN; - other = unix_peer(sk); + other = unix_peer_get(sk); if (!other) goto out_err; } @@ -1478,6 +1476,7 @@ static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock, other->sk_data_ready(other, size); sent+=size; } + sock_put(other); scm_destroy(siocb->scm); siocb->scm = NULL; @@ -1492,6 +1491,8 @@ static int unix_stream_sendmsg(struct kiocb *kiocb, struct socket *sock, send_sig(SIGPIPE,current,0); err = -EPIPE; out_err: + if (other) + sock_put(other); scm_destroy(siocb->scm); siocb->scm = NULL; return sent ? : err; @@ -1859,7 +1860,7 @@ static int unix_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) } default: - err = -ENOIOCTLCMD; + err = dev_ioctl(cmd, (void __user *)arg); break; } return err; @@ -1916,7 +1917,7 @@ static struct sock *unix_seq_idx(int *iter, loff_t pos) static void *unix_seq_start(struct seq_file *seq, loff_t *pos) { - spin_lock(&unix_table_lock); + read_lock(&unix_table_lock); return *pos ? unix_seq_idx(seq->private, *pos - 1) : ((void *) 1); } @@ -1931,7 +1932,7 @@ static void *unix_seq_next(struct seq_file *seq, void *v, loff_t *pos) static void unix_seq_stop(struct seq_file *seq, void *v) { - spin_unlock(&unix_table_lock); + read_unlock(&unix_table_lock); } static int unix_seq_show(struct seq_file *seq, void *v) diff --git a/trunk/net/unix/garbage.c b/trunk/net/unix/garbage.c index 411802bd4d37..6ffc64e1712d 100644 --- a/trunk/net/unix/garbage.c +++ b/trunk/net/unix/garbage.c @@ -182,7 +182,7 @@ void unix_gc(void) if (down_trylock(&unix_gc_sem)) return; - spin_lock(&unix_table_lock); + read_lock(&unix_table_lock); forall_unix_sockets(i, s) { @@ -301,7 +301,7 @@ void unix_gc(void) } u->gc_tree = GC_ORPHAN; } - spin_unlock(&unix_table_lock); + read_unlock(&unix_table_lock); /* * Here we are. Hitlist is filled. Die. diff --git a/trunk/net/wanrouter/af_wanpipe.c b/trunk/net/wanrouter/af_wanpipe.c index 7a43ae4721ed..59fec59b2132 100644 --- a/trunk/net/wanrouter/af_wanpipe.c +++ b/trunk/net/wanrouter/af_wanpipe.c @@ -181,7 +181,7 @@ struct wanpipe_opt #endif static int sk_count; -extern const struct proto_ops wanpipe_ops; +extern struct proto_ops wanpipe_ops; static unsigned long find_free_critical; static void wanpipe_unlink_driver(struct sock *sk); @@ -1839,7 +1839,7 @@ static int wanpipe_ioctl(struct socket *sock, unsigned int cmd, unsigned long ar #endif default: - return -ENOIOCTLCMD; + return dev_ioctl(cmd,(void __user *) arg); } /*NOTREACHED*/ } @@ -2546,7 +2546,7 @@ static int wanpipe_connect(struct socket *sock, struct sockaddr *uaddr, int addr return 0; } -const struct proto_ops wanpipe_ops = { +struct proto_ops wanpipe_ops = { .family = PF_WANPIPE, .owner = THIS_MODULE, .release = wanpipe_release, diff --git a/trunk/net/x25/af_x25.c b/trunk/net/x25/af_x25.c index 16459c7f54b2..020d73cc8414 100644 --- a/trunk/net/x25/af_x25.c +++ b/trunk/net/x25/af_x25.c @@ -64,7 +64,7 @@ int sysctl_x25_ack_holdback_timeout = X25_DEFAULT_T2; HLIST_HEAD(x25_list); DEFINE_RWLOCK(x25_list_lock); -static const struct proto_ops x25_proto_ops; +static struct proto_ops x25_proto_ops; static struct x25_address null_x25_address = {" "}; @@ -1378,7 +1378,7 @@ static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) } default: - rc = -ENOIOCTLCMD; + rc = dev_ioctl(cmd, argp); break; } @@ -1391,7 +1391,7 @@ static struct net_proto_family x25_family_ops = { .owner = THIS_MODULE, }; -static const struct proto_ops SOCKOPS_WRAPPED(x25_proto_ops) = { +static struct proto_ops SOCKOPS_WRAPPED(x25_proto_ops) = { .family = AF_X25, .owner = THIS_MODULE, .release = x25_release, diff --git a/trunk/net/xfrm/xfrm_policy.c b/trunk/net/xfrm/xfrm_policy.c index 64a447375fdb..d19e274b9c4a 100644 --- a/trunk/net/xfrm/xfrm_policy.c +++ b/trunk/net/xfrm/xfrm_policy.c @@ -10,7 +10,7 @@ * YOSHIFUJI Hideaki * Split up af-specific portion * Derek Atkins Add the post_input processor - * + * */ #include @@ -256,7 +256,6 @@ void __xfrm_policy_destroy(struct xfrm_policy *policy) if (del_timer(&policy->timer)) BUG(); - security_xfrm_policy_free(policy); kfree(policy); } EXPORT_SYMBOL(__xfrm_policy_destroy); @@ -351,8 +350,7 @@ int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl) write_lock_bh(&xfrm_policy_lock); for (p = &xfrm_policy_list[dir]; (pol=*p)!=NULL;) { - if (!delpol && memcmp(&policy->selector, &pol->selector, sizeof(pol->selector)) == 0 && - xfrm_sec_ctx_match(pol->security, policy->security)) { + if (!delpol && memcmp(&policy->selector, &pol->selector, sizeof(pol->selector)) == 0) { if (excl) { write_unlock_bh(&xfrm_policy_lock); return -EEXIST; @@ -418,15 +416,14 @@ int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl) } EXPORT_SYMBOL(xfrm_policy_insert); -struct xfrm_policy *xfrm_policy_bysel_ctx(int dir, struct xfrm_selector *sel, - struct xfrm_sec_ctx *ctx, int delete) +struct xfrm_policy *xfrm_policy_bysel(int dir, struct xfrm_selector *sel, + int delete) { struct xfrm_policy *pol, **p; write_lock_bh(&xfrm_policy_lock); for (p = &xfrm_policy_list[dir]; (pol=*p)!=NULL; p = &pol->next) { - if ((memcmp(sel, &pol->selector, sizeof(*sel)) == 0) && - (xfrm_sec_ctx_match(ctx, pol->security))) { + if (memcmp(sel, &pol->selector, sizeof(*sel)) == 0) { xfrm_pol_hold(pol); if (delete) *p = pol->next; @@ -441,7 +438,7 @@ struct xfrm_policy *xfrm_policy_bysel_ctx(int dir, struct xfrm_selector *sel, } return pol; } -EXPORT_SYMBOL(xfrm_policy_bysel_ctx); +EXPORT_SYMBOL(xfrm_policy_bysel); struct xfrm_policy *xfrm_policy_byid(int dir, u32 id, int delete) { @@ -522,7 +519,7 @@ EXPORT_SYMBOL(xfrm_policy_walk); /* Find policy to apply to this flow. */ -static void xfrm_policy_lookup(struct flowi *fl, u32 sk_sid, u16 family, u8 dir, +static void xfrm_policy_lookup(struct flowi *fl, u16 family, u8 dir, void **objp, atomic_t **obj_refp) { struct xfrm_policy *pol; @@ -536,12 +533,9 @@ static void xfrm_policy_lookup(struct flowi *fl, u32 sk_sid, u16 family, u8 dir, continue; match = xfrm_selector_match(sel, fl, family); - if (match) { - if (!security_xfrm_policy_lookup(pol, sk_sid, dir)) { - xfrm_pol_hold(pol); - break; - } + xfrm_pol_hold(pol); + break; } } read_unlock_bh(&xfrm_policy_lock); @@ -549,37 +543,15 @@ static void xfrm_policy_lookup(struct flowi *fl, u32 sk_sid, u16 family, u8 dir, *obj_refp = &pol->refcnt; } -static inline int policy_to_flow_dir(int dir) -{ - if (XFRM_POLICY_IN == FLOW_DIR_IN && - XFRM_POLICY_OUT == FLOW_DIR_OUT && - XFRM_POLICY_FWD == FLOW_DIR_FWD) - return dir; - switch (dir) { - default: - case XFRM_POLICY_IN: - return FLOW_DIR_IN; - case XFRM_POLICY_OUT: - return FLOW_DIR_OUT; - case XFRM_POLICY_FWD: - return FLOW_DIR_FWD; - }; -} - -static struct xfrm_policy *xfrm_sk_policy_lookup(struct sock *sk, int dir, struct flowi *fl, u32 sk_sid) +static struct xfrm_policy *xfrm_sk_policy_lookup(struct sock *sk, int dir, struct flowi *fl) { struct xfrm_policy *pol; read_lock_bh(&xfrm_policy_lock); if ((pol = sk->sk_policy[dir]) != NULL) { - int match = xfrm_selector_match(&pol->selector, fl, + int match = xfrm_selector_match(&pol->selector, fl, sk->sk_family); - int err = 0; - if (match) - err = security_xfrm_policy_lookup(pol, sk_sid, policy_to_flow_dir(dir)); - - if (match && !err) xfrm_pol_hold(pol); else pol = NULL; @@ -652,10 +624,6 @@ static struct xfrm_policy *clone_policy(struct xfrm_policy *old, int dir) if (newp) { newp->selector = old->selector; - if (security_xfrm_policy_clone(old, newp)) { - kfree(newp); - return NULL; /* ENOMEM */ - } newp->lft = old->lft; newp->curlft = old->curlft; newp->action = old->action; @@ -767,6 +735,22 @@ xfrm_bundle_create(struct xfrm_policy *policy, struct xfrm_state **xfrm, int nx, return err; } +static inline int policy_to_flow_dir(int dir) +{ + if (XFRM_POLICY_IN == FLOW_DIR_IN && + XFRM_POLICY_OUT == FLOW_DIR_OUT && + XFRM_POLICY_FWD == FLOW_DIR_FWD) + return dir; + switch (dir) { + default: + case XFRM_POLICY_IN: + return FLOW_DIR_IN; + case XFRM_POLICY_OUT: + return FLOW_DIR_OUT; + case XFRM_POLICY_FWD: + return FLOW_DIR_FWD; + }; +} static int stale_bundle(struct dst_entry *dst); @@ -785,20 +769,19 @@ int xfrm_lookup(struct dst_entry **dst_p, struct flowi *fl, int err; u32 genid; u16 family = dst_orig->ops->family; - u8 dir = policy_to_flow_dir(XFRM_POLICY_OUT); - u32 sk_sid = security_sk_sid(sk, fl, dir); restart: genid = atomic_read(&flow_cache_genid); policy = NULL; if (sk && sk->sk_policy[1]) - policy = xfrm_sk_policy_lookup(sk, XFRM_POLICY_OUT, fl, sk_sid); + policy = xfrm_sk_policy_lookup(sk, XFRM_POLICY_OUT, fl); if (!policy) { /* To accelerate a bit... */ if ((dst_orig->flags & DST_NOXFRM) || !xfrm_policy_list[XFRM_POLICY_OUT]) return 0; - policy = flow_cache_lookup(fl, sk_sid, family, dir, + policy = flow_cache_lookup(fl, family, + policy_to_flow_dir(XFRM_POLICY_OUT), xfrm_policy_lookup); } @@ -979,20 +962,16 @@ int __xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, { struct xfrm_policy *pol; struct flowi fl; - u8 fl_dir = policy_to_flow_dir(dir); - u32 sk_sid; if (_decode_session(skb, &fl, family) < 0) return 0; - sk_sid = security_sk_sid(sk, &fl, fl_dir); - /* First, check used SA against their selectors. */ if (skb->sp) { int i; for (i=skb->sp->len-1; i>=0; i--) { - struct sec_decap_state *xvec = &(skb->sp->x[i]); + struct sec_decap_state *xvec = &(skb->sp->x[i]); if (!xfrm_selector_match(&xvec->xvec->sel, &fl, family)) return 0; @@ -1007,10 +986,11 @@ int __xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, pol = NULL; if (sk && sk->sk_policy[dir]) - pol = xfrm_sk_policy_lookup(sk, dir, &fl, sk_sid); + pol = xfrm_sk_policy_lookup(sk, dir, &fl); if (!pol) - pol = flow_cache_lookup(&fl, sk_sid, family, fl_dir, + pol = flow_cache_lookup(&fl, family, + policy_to_flow_dir(dir), xfrm_policy_lookup); if (!pol) diff --git a/trunk/net/xfrm/xfrm_state.c b/trunk/net/xfrm/xfrm_state.c index e12d0be5f976..479effc97666 100644 --- a/trunk/net/xfrm/xfrm_state.c +++ b/trunk/net/xfrm/xfrm_state.c @@ -10,7 +10,7 @@ * Split up af-specific functions * Derek Atkins * Add UDP Encapsulation - * + * */ #include @@ -70,7 +70,6 @@ static void xfrm_state_gc_destroy(struct xfrm_state *x) x->type->destructor(x); xfrm_put_type(x->type); } - security_xfrm_state_free(x); kfree(x); } @@ -344,8 +343,7 @@ xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr, selector. */ if (x->km.state == XFRM_STATE_VALID) { - if (!xfrm_selector_match(&x->sel, fl, family) || - !xfrm_sec_ctx_match(pol->security, x->security)) + if (!xfrm_selector_match(&x->sel, fl, family)) continue; if (!best || best->km.dying > x->km.dying || @@ -356,8 +354,7 @@ xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr, acquire_in_progress = 1; } else if (x->km.state == XFRM_STATE_ERROR || x->km.state == XFRM_STATE_EXPIRED) { - if (xfrm_selector_match(&x->sel, fl, family) && - xfrm_sec_ctx_match(pol->security, x->security)) + if (xfrm_selector_match(&x->sel, fl, family)) error = -ESRCH; } } diff --git a/trunk/net/xfrm/xfrm_user.c b/trunk/net/xfrm/xfrm_user.c index 92e2b804c606..0cdd9a07e043 100644 --- a/trunk/net/xfrm/xfrm_user.c +++ b/trunk/net/xfrm/xfrm_user.c @@ -7,7 +7,7 @@ * Kazunori MIYAZAWA @USAGI * Kunihiro Ishiguro * IPv6 support - * + * */ #include @@ -88,34 +88,6 @@ static int verify_encap_tmpl(struct rtattr **xfrma) return 0; } - -static inline int verify_sec_ctx_len(struct rtattr **xfrma) -{ - struct rtattr *rt = xfrma[XFRMA_SEC_CTX - 1]; - struct xfrm_user_sec_ctx *uctx; - int len = 0; - - if (!rt) - return 0; - - if (rt->rta_len < sizeof(*uctx)) - return -EINVAL; - - uctx = RTA_DATA(rt); - - if (uctx->ctx_len > PAGE_SIZE) - return -EINVAL; - - len += sizeof(struct xfrm_user_sec_ctx); - len += uctx->ctx_len; - - if (uctx->len != len) - return -EINVAL; - - return 0; -} - - static int verify_newsa_info(struct xfrm_usersa_info *p, struct rtattr **xfrma) { @@ -173,8 +145,6 @@ static int verify_newsa_info(struct xfrm_usersa_info *p, goto out; if ((err = verify_encap_tmpl(xfrma))) goto out; - if ((err = verify_sec_ctx_len(xfrma))) - goto out; err = -EINVAL; switch (p->mode) { @@ -239,30 +209,6 @@ static int attach_encap_tmpl(struct xfrm_encap_tmpl **encapp, struct rtattr *u_a return 0; } - -static inline int xfrm_user_sec_ctx_size(struct xfrm_policy *xp) -{ - struct xfrm_sec_ctx *xfrm_ctx = xp->security; - int len = 0; - - if (xfrm_ctx) { - len += sizeof(struct xfrm_user_sec_ctx); - len += xfrm_ctx->ctx_len; - } - return len; -} - -static int attach_sec_ctx(struct xfrm_state *x, struct rtattr *u_arg) -{ - struct xfrm_user_sec_ctx *uctx; - - if (!u_arg) - return 0; - - uctx = RTA_DATA(u_arg); - return security_xfrm_state_alloc(x, uctx); -} - static void copy_from_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p) { memcpy(&x->id, &p->id, sizeof(x->id)); @@ -307,9 +253,6 @@ static struct xfrm_state *xfrm_state_construct(struct xfrm_usersa_info *p, if (err) goto error; - if ((err = attach_sec_ctx(x, xfrma[XFRMA_SEC_CTX-1]))) - goto error; - x->km.seq = p->seq; return x; @@ -329,11 +272,11 @@ static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfrma) int err; struct km_event c; - err = verify_newsa_info(p, (struct rtattr **)xfrma); + err = verify_newsa_info(p, (struct rtattr **) xfrma); if (err) return err; - x = xfrm_state_construct(p, (struct rtattr **)xfrma, &err); + x = xfrm_state_construct(p, (struct rtattr **) xfrma, &err); if (!x) return err; @@ -447,19 +390,6 @@ static int dump_one_state(struct xfrm_state *x, int count, void *ptr) if (x->encap) RTA_PUT(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap); - if (x->security) { - int ctx_size = sizeof(struct xfrm_sec_ctx) + - x->security->ctx_len; - struct rtattr *rt = __RTA_PUT(skb, XFRMA_SEC_CTX, ctx_size); - struct xfrm_user_sec_ctx *uctx = RTA_DATA(rt); - - uctx->exttype = XFRMA_SEC_CTX; - uctx->len = ctx_size; - uctx->ctx_doi = x->security->ctx_doi; - uctx->ctx_alg = x->security->ctx_alg; - uctx->ctx_len = x->security->ctx_len; - memcpy(uctx + 1, x->security->ctx_str, x->security->ctx_len); - } nlh->nlmsg_len = skb->tail - b; out: sp->this_idx++; @@ -673,18 +603,6 @@ static int verify_newpolicy_info(struct xfrm_userpolicy_info *p) return verify_policy_dir(p->dir); } -static int copy_from_user_sec_ctx(struct xfrm_policy *pol, struct rtattr **xfrma) -{ - struct rtattr *rt = xfrma[XFRMA_SEC_CTX-1]; - struct xfrm_user_sec_ctx *uctx; - - if (!rt) - return 0; - - uctx = RTA_DATA(rt); - return security_xfrm_policy_alloc(pol, uctx); -} - static void copy_templates(struct xfrm_policy *xp, struct xfrm_user_tmpl *ut, int nr) { @@ -763,10 +681,7 @@ static struct xfrm_policy *xfrm_policy_construct(struct xfrm_userpolicy_info *p, } copy_from_user_policy(xp, p); - - if (!(err = copy_from_user_tmpl(xp, xfrma))) - err = copy_from_user_sec_ctx(xp, xfrma); - + err = copy_from_user_tmpl(xp, xfrma); if (err) { *errp = err; kfree(xp); @@ -785,13 +700,10 @@ static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfr int excl; err = verify_newpolicy_info(p); - if (err) - return err; - err = verify_sec_ctx_len((struct rtattr **)xfrma); if (err) return err; - xp = xfrm_policy_construct(p, (struct rtattr **)xfrma, &err); + xp = xfrm_policy_construct(p, (struct rtattr **) xfrma, &err); if (!xp) return err; @@ -849,27 +761,6 @@ static int copy_to_user_tmpl(struct xfrm_policy *xp, struct sk_buff *skb) return -1; } -static int copy_to_user_sec_ctx(struct xfrm_policy *xp, struct sk_buff *skb) -{ - if (xp->security) { - int ctx_size = sizeof(struct xfrm_sec_ctx) + - xp->security->ctx_len; - struct rtattr *rt = __RTA_PUT(skb, XFRMA_SEC_CTX, ctx_size); - struct xfrm_user_sec_ctx *uctx = RTA_DATA(rt); - - uctx->exttype = XFRMA_SEC_CTX; - uctx->len = ctx_size; - uctx->ctx_doi = xp->security->ctx_doi; - uctx->ctx_alg = xp->security->ctx_alg; - uctx->ctx_len = xp->security->ctx_len; - memcpy(uctx + 1, xp->security->ctx_str, xp->security->ctx_len); - } - return 0; - - rtattr_failure: - return -1; -} - static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptr) { struct xfrm_dump_info *sp = ptr; @@ -891,8 +782,6 @@ static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptr copy_to_user_policy(xp, p, dir); if (copy_to_user_tmpl(xp, skb) < 0) goto nlmsg_failure; - if (copy_to_user_sec_ctx(xp, skb)) - goto nlmsg_failure; nlh->nlmsg_len = skb->tail - b; out: @@ -963,25 +852,8 @@ static int xfrm_get_policy(struct sk_buff *skb, struct nlmsghdr *nlh, void **xfr if (p->index) xp = xfrm_policy_byid(p->dir, p->index, delete); - else { - struct rtattr **rtattrs = (struct rtattr **)xfrma; - struct rtattr *rt = rtattrs[XFRMA_SEC_CTX-1]; - struct xfrm_policy tmp; - - err = verify_sec_ctx_len(rtattrs); - if (err) - return err; - - memset(&tmp, 0, sizeof(struct xfrm_policy)); - if (rt) { - struct xfrm_user_sec_ctx *uctx = RTA_DATA(rt); - - if ((err = security_xfrm_policy_alloc(&tmp, uctx))) - return err; - } - xp = xfrm_policy_bysel_ctx(p->dir, &p->sel, tmp.security, delete); - security_xfrm_policy_free(&tmp); - } + else + xp = xfrm_policy_bysel(p->dir, &p->sel, delete); if (xp == NULL) return -ENOENT; @@ -1352,8 +1224,6 @@ static int build_acquire(struct sk_buff *skb, struct xfrm_state *x, if (copy_to_user_tmpl(xp, skb) < 0) goto nlmsg_failure; - if (copy_to_user_sec_ctx(xp, skb)) - goto nlmsg_failure; nlh->nlmsg_len = skb->tail - b; return skb->len; @@ -1371,7 +1241,6 @@ static int xfrm_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *xt, len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr); len += NLMSG_SPACE(sizeof(struct xfrm_user_acquire)); - len += RTA_SPACE(xfrm_user_sec_ctx_size(xp)); skb = alloc_skb(len, GFP_ATOMIC); if (skb == NULL) return -ENOMEM; @@ -1455,8 +1324,6 @@ static int build_polexpire(struct sk_buff *skb, struct xfrm_policy *xp, copy_to_user_policy(xp, &upe->pol, dir); if (copy_to_user_tmpl(xp, skb) < 0) goto nlmsg_failure; - if (copy_to_user_sec_ctx(xp, skb)) - goto nlmsg_failure; upe->hard = !!hard; nlh->nlmsg_len = skb->tail - b; @@ -1474,7 +1341,6 @@ static int xfrm_exp_policy_notify(struct xfrm_policy *xp, int dir, struct km_eve len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr); len += NLMSG_SPACE(sizeof(struct xfrm_user_polexpire)); - len += RTA_SPACE(xfrm_user_sec_ctx_size(xp)); skb = alloc_skb(len, GFP_ATOMIC); if (skb == NULL) return -ENOMEM; diff --git a/trunk/scripts/.gitignore b/trunk/scripts/.gitignore index a234e524a490..b46d68bb9e17 100644 --- a/trunk/scripts/.gitignore +++ b/trunk/scripts/.gitignore @@ -1,7 +1,4 @@ -# -# Generated files -# conmakehash kallsyms pnmtologo -bin2c + diff --git a/trunk/scripts/Makefile b/trunk/scripts/Makefile index 6f6b48f39f0a..67763eeb8a3e 100644 --- a/trunk/scripts/Makefile +++ b/trunk/scripts/Makefile @@ -19,4 +19,4 @@ subdir-$(CONFIG_MODVERSIONS) += genksyms subdir-$(CONFIG_MODULES) += mod # Let clean descend into subdirs -subdir- += basic kconfig package +subdir- += basic lxdialog kconfig package diff --git a/trunk/scripts/Makefile.lib b/trunk/scripts/Makefile.lib index 550798f57da5..0f81dcfd6909 100644 --- a/trunk/scripts/Makefile.lib +++ b/trunk/scripts/Makefile.lib @@ -81,10 +81,8 @@ obj-dirs := $(addprefix $(obj)/,$(obj-dirs)) # Note: It's possible that one object gets potentially linked into more # than one module. In that case KBUILD_MODNAME will be set to foo_bar, # where foo and bar are the name of the modules. -name-fix = $(subst $(comma),_,$(subst -,_,$1)) -basename_flags = -D"KBUILD_BASENAME=KBUILD_STR($(call name-fix,$(*F)))" -modname_flags = $(if $(filter 1,$(words $(modname))),\ - -D"KBUILD_MODNAME=KBUILD_STR($(call name-fix,$(modname)))") +basename_flags = -DKBUILD_BASENAME=$(subst $(comma),_,$(subst -,_,$(*F))) +modname_flags = $(if $(filter 1,$(words $(modname))),-DKBUILD_MODNAME=$(subst $(comma),_,$(subst -,_,$(modname)))) _c_flags = $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$(*F).o) _a_flags = $(AFLAGS) $(EXTRA_AFLAGS) $(AFLAGS_$(*F).o) @@ -115,7 +113,7 @@ endif c_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(CPPFLAGS) \ $(__c_flags) $(modkern_cflags) \ - -D"KBUILD_STR(s)=\#s" $(basename_flags) $(modname_flags) + $(basename_flags) $(modname_flags) a_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(CPPFLAGS) \ $(__a_flags) $(modkern_aflags) diff --git a/trunk/scripts/basic/fixdep.c b/trunk/scripts/basic/fixdep.c index 679124b11e12..0b61bea869f7 100644 --- a/trunk/scripts/basic/fixdep.c +++ b/trunk/scripts/basic/fixdep.c @@ -130,22 +130,9 @@ void usage(void) exit(1); } -/* - * Print out the commandline prefixed with cmd_ := - * If commandline contains '#' escape with '\' so make to not see - * the '#' as a start-of-comment symbol - **/ void print_cmdline(void) { - char *p = cmdline; - - printf("cmd_%s := ", target); - for (; *p; p++) { - if (*p == '#') - printf("\\"); - printf("%c", *p); - } - printf("\n\n"); + printf("cmd_%s := %s\n\n", target, cmdline); } char * str_config = NULL; diff --git a/trunk/scripts/binoffset.c b/trunk/scripts/binoffset.c index 1a2e39b8e3e5..591309d85518 100644 --- a/trunk/scripts/binoffset.c +++ b/trunk/scripts/binoffset.c @@ -1,6 +1,6 @@ /*************************************************************************** * binoffset.c - * (C) 2002 Randy Dunlap + * (C) 2002 Randy Dunlap # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by diff --git a/trunk/scripts/checkversion.pl b/trunk/scripts/checkversion.pl index 9f84e562318d..df10db662eb1 100755 --- a/trunk/scripts/checkversion.pl +++ b/trunk/scripts/checkversion.pl @@ -3,7 +3,7 @@ # checkversion find uses of LINUX_VERSION_CODE, KERNEL_VERSION, or # UTS_RELEASE without including , or cases of # including that don't need it. -# Copyright (C) 2003, Randy Dunlap +# Copyright (C) 2003, Randy Dunlap $| = 1; diff --git a/trunk/scripts/genksyms/.gitignore b/trunk/scripts/genksyms/.gitignore deleted file mode 100644 index be5cadb1b907..000000000000 --- a/trunk/scripts/genksyms/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -keywords.c -lex.c -parse.[ch] -genksyms diff --git a/trunk/scripts/genksyms/keywords.c_shipped b/trunk/scripts/genksyms/keywords.c_shipped index ee4647805c58..eabaf7401cd6 100644 --- a/trunk/scripts/genksyms/keywords.c_shipped +++ b/trunk/scripts/genksyms/keywords.c_shipped @@ -1,38 +1,7 @@ -/* ANSI-C code produced by gperf version 3.0.1 */ +/* ANSI-C code produced by gperf version 2.7.2 */ /* Command-line: gperf -L ANSI-C -a -C -E -g -H is_reserved_hash -k '1,3,$' -N is_reserved_word -p -t scripts/genksyms/keywords.gperf */ - -#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ - && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ - && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ - && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ - && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ - && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ - && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ - && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ - && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ - && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ - && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ - && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ - && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ - && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ - && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ - && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ - && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ - && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ - && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ - && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ - && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ - && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ - && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) -/* The character set is not based on ISO-646. */ -#error "gperf generated tables don't work with this execution character set. Please report a bug to ." -#endif - -#line 1 "scripts/genksyms/keywords.gperf" - -#line 3 "scripts/genksyms/keywords.gperf" struct resword { const char *name; int token; }; -/* maximum key range = 68, duplicates = 0 */ +/* maximum key range = 109, duplicates = 0 */ #ifdef __GNUC__ __inline @@ -46,32 +15,32 @@ is_reserved_hash (register const char *str, register unsigned int len) { static const unsigned char asso_values[] = { - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 15, - 71, 71, 71, 71, 71, 71, 15, 71, 71, 71, - 10, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 0, 71, 0, 71, 5, - 5, 0, 10, 20, 71, 25, 71, 71, 20, 0, - 20, 30, 25, 71, 10, 5, 0, 20, 15, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, - 71, 71, 71, 71, 71, 71 + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 5, + 113, 113, 113, 113, 113, 113, 0, 113, 113, 113, + 0, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 0, 113, 0, 113, 20, + 25, 0, 35, 30, 113, 20, 113, 113, 40, 30, + 30, 0, 0, 113, 0, 51, 0, 15, 5, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, + 113, 113, 113, 113, 113, 113 }; return len + asso_values[(unsigned char)str[2]] + asso_values[(unsigned char)str[0]] + asso_values[(unsigned char)str[len - 1]]; } @@ -87,112 +56,77 @@ is_reserved_word (register const char *str, register unsigned int len) TOTAL_KEYWORDS = 41, MIN_WORD_LENGTH = 3, MAX_WORD_LENGTH = 17, - MIN_HASH_VALUE = 3, - MAX_HASH_VALUE = 70 + MIN_HASH_VALUE = 4, + MAX_HASH_VALUE = 112 }; static const struct resword wordlist[] = { - {""}, {""}, {""}, -#line 24 "scripts/genksyms/keywords.gperf" - {"asm", ASM_KEYW}, - {""}, -#line 7 "scripts/genksyms/keywords.gperf" - {"__asm", ASM_KEYW}, - {""}, -#line 8 "scripts/genksyms/keywords.gperf" + {""}, {""}, {""}, {""}, + {"auto", AUTO_KEYW}, + {""}, {""}, {"__asm__", ASM_KEYW}, {""}, -#line 21 "scripts/genksyms/keywords.gperf" {"_restrict", RESTRICT_KEYW}, -#line 50 "scripts/genksyms/keywords.gperf" {"__typeof__", TYPEOF_KEYW}, -#line 9 "scripts/genksyms/keywords.gperf" {"__attribute", ATTRIBUTE_KEYW}, -#line 11 "scripts/genksyms/keywords.gperf" - {"__const", CONST_KEYW}, -#line 10 "scripts/genksyms/keywords.gperf" + {"__restrict__", RESTRICT_KEYW}, {"__attribute__", ATTRIBUTE_KEYW}, -#line 12 "scripts/genksyms/keywords.gperf" - {"__const__", CONST_KEYW}, -#line 16 "scripts/genksyms/keywords.gperf" - {"__signed__", SIGNED_KEYW}, -#line 42 "scripts/genksyms/keywords.gperf" - {"static", STATIC_KEYW}, - {""}, -#line 15 "scripts/genksyms/keywords.gperf" - {"__signed", SIGNED_KEYW}, -#line 30 "scripts/genksyms/keywords.gperf" - {"char", CHAR_KEYW}, {""}, -#line 43 "scripts/genksyms/keywords.gperf" - {"struct", STRUCT_KEYW}, -#line 22 "scripts/genksyms/keywords.gperf" - {"__restrict__", RESTRICT_KEYW}, -#line 23 "scripts/genksyms/keywords.gperf" - {"restrict", RESTRICT_KEYW}, -#line 33 "scripts/genksyms/keywords.gperf" - {"enum", ENUM_KEYW}, -#line 17 "scripts/genksyms/keywords.gperf" {"__volatile", VOLATILE_KEYW}, -#line 34 "scripts/genksyms/keywords.gperf" - {"extern", EXTERN_KEYW}, -#line 18 "scripts/genksyms/keywords.gperf" + {""}, {"__volatile__", VOLATILE_KEYW}, -#line 37 "scripts/genksyms/keywords.gperf" + {"EXPORT_SYMBOL", EXPORT_SYMBOL_KEYW}, + {""}, {""}, {""}, + {"EXPORT_SYMBOL_GPL", EXPORT_SYMBOL_KEYW}, {"int", INT_KEYW}, - {""}, -#line 31 "scripts/genksyms/keywords.gperf" - {"const", CONST_KEYW}, -#line 32 "scripts/genksyms/keywords.gperf" - {"double", DOUBLE_KEYW}, - {""}, -#line 13 "scripts/genksyms/keywords.gperf" + {"char", CHAR_KEYW}, + {""}, {""}, + {"__const", CONST_KEYW}, {"__inline", INLINE_KEYW}, -#line 29 "scripts/genksyms/keywords.gperf" - {"auto", AUTO_KEYW}, -#line 14 "scripts/genksyms/keywords.gperf" + {"__const__", CONST_KEYW}, {"__inline__", INLINE_KEYW}, -#line 41 "scripts/genksyms/keywords.gperf" - {"signed", SIGNED_KEYW}, + {""}, {""}, {""}, {""}, + {"__asm", ASM_KEYW}, + {"extern", EXTERN_KEYW}, {""}, -#line 46 "scripts/genksyms/keywords.gperf" - {"unsigned", UNSIGNED_KEYW}, + {"register", REGISTER_KEYW}, {""}, -#line 40 "scripts/genksyms/keywords.gperf" - {"short", SHORT_KEYW}, -#line 49 "scripts/genksyms/keywords.gperf" + {"float", FLOAT_KEYW}, {"typeof", TYPEOF_KEYW}, -#line 44 "scripts/genksyms/keywords.gperf" {"typedef", TYPEDEF_KEYW}, -#line 48 "scripts/genksyms/keywords.gperf" - {"volatile", VOLATILE_KEYW}, - {""}, -#line 35 "scripts/genksyms/keywords.gperf" - {"float", FLOAT_KEYW}, {""}, {""}, -#line 39 "scripts/genksyms/keywords.gperf" - {"register", REGISTER_KEYW}, -#line 47 "scripts/genksyms/keywords.gperf" + {"_Bool", BOOL_KEYW}, + {"double", DOUBLE_KEYW}, + {""}, {""}, + {"enum", ENUM_KEYW}, + {""}, {""}, {""}, + {"volatile", VOLATILE_KEYW}, {"void", VOID_KEYW}, + {"const", CONST_KEYW}, + {"short", SHORT_KEYW}, + {"struct", STRUCT_KEYW}, {""}, -#line 36 "scripts/genksyms/keywords.gperf" - {"inline", INLINE_KEYW}, - {""}, -#line 5 "scripts/genksyms/keywords.gperf" - {"EXPORT_SYMBOL", EXPORT_SYMBOL_KEYW}, + {"restrict", RESTRICT_KEYW}, {""}, -#line 20 "scripts/genksyms/keywords.gperf" - {"_Bool", BOOL_KEYW}, + {"__signed__", SIGNED_KEYW}, {""}, -#line 6 "scripts/genksyms/keywords.gperf" - {"EXPORT_SYMBOL_GPL", EXPORT_SYMBOL_KEYW}, + {"asm", ASM_KEYW}, + {""}, {""}, + {"inline", INLINE_KEYW}, + {""}, {""}, {""}, + {"union", UNION_KEYW}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 38 "scripts/genksyms/keywords.gperf" - {"long", LONG_KEYW}, + {"static", STATIC_KEYW}, + {""}, {""}, {""}, {""}, {""}, {""}, + {"__signed", SIGNED_KEYW}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, -#line 45 "scripts/genksyms/keywords.gperf" - {"union", UNION_KEYW} + {"unsigned", UNSIGNED_KEYW}, + {""}, {""}, {""}, {""}, + {"long", LONG_KEYW}, + {""}, {""}, {""}, {""}, {""}, {""}, {""}, + {"signed", SIGNED_KEYW} }; if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) diff --git a/trunk/scripts/genksyms/lex.c_shipped b/trunk/scripts/genksyms/lex.c_shipped index 1218053ee960..d9bfbb5948f2 100644 --- a/trunk/scripts/genksyms/lex.c_shipped +++ b/trunk/scripts/genksyms/lex.c_shipped @@ -2036,131 +2036,49 @@ fini: return token; } -/* A Bison parser, made by GNU Bison 2.0. */ +#ifndef YYSTYPE +#define YYSTYPE int +#endif +#define ASM_KEYW 257 +#define ATTRIBUTE_KEYW 258 +#define AUTO_KEYW 259 +#define BOOL_KEYW 260 +#define CHAR_KEYW 261 +#define CONST_KEYW 262 +#define DOUBLE_KEYW 263 +#define ENUM_KEYW 264 +#define EXTERN_KEYW 265 +#define FLOAT_KEYW 266 +#define INLINE_KEYW 267 +#define INT_KEYW 268 +#define LONG_KEYW 269 +#define REGISTER_KEYW 270 +#define RESTRICT_KEYW 271 +#define SHORT_KEYW 272 +#define SIGNED_KEYW 273 +#define STATIC_KEYW 274 +#define STRUCT_KEYW 275 +#define TYPEDEF_KEYW 276 +#define UNION_KEYW 277 +#define UNSIGNED_KEYW 278 +#define VOID_KEYW 279 +#define VOLATILE_KEYW 280 +#define TYPEOF_KEYW 281 +#define EXPORT_SYMBOL_KEYW 282 +#define ASM_PHRASE 283 +#define ATTRIBUTE_PHRASE 284 +#define BRACE_PHRASE 285 +#define BRACKET_PHRASE 286 +#define EXPRESSION_PHRASE 287 +#define CHAR 288 +#define DOTS 289 +#define IDENT 290 +#define INT 291 +#define REAL 292 +#define STRING 293 +#define TYPE 294 +#define OTHER 295 +#define FILENAME 296 -/* Skeleton parser for Yacc-like parsing with Bison, - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - ASM_KEYW = 258, - ATTRIBUTE_KEYW = 259, - AUTO_KEYW = 260, - BOOL_KEYW = 261, - CHAR_KEYW = 262, - CONST_KEYW = 263, - DOUBLE_KEYW = 264, - ENUM_KEYW = 265, - EXTERN_KEYW = 266, - FLOAT_KEYW = 267, - INLINE_KEYW = 268, - INT_KEYW = 269, - LONG_KEYW = 270, - REGISTER_KEYW = 271, - RESTRICT_KEYW = 272, - SHORT_KEYW = 273, - SIGNED_KEYW = 274, - STATIC_KEYW = 275, - STRUCT_KEYW = 276, - TYPEDEF_KEYW = 277, - UNION_KEYW = 278, - UNSIGNED_KEYW = 279, - VOID_KEYW = 280, - VOLATILE_KEYW = 281, - TYPEOF_KEYW = 282, - EXPORT_SYMBOL_KEYW = 283, - ASM_PHRASE = 284, - ATTRIBUTE_PHRASE = 285, - BRACE_PHRASE = 286, - BRACKET_PHRASE = 287, - EXPRESSION_PHRASE = 288, - CHAR = 289, - DOTS = 290, - IDENT = 291, - INT = 292, - REAL = 293, - STRING = 294, - TYPE = 295, - OTHER = 296, - FILENAME = 297 - }; -#endif -#define ASM_KEYW 258 -#define ATTRIBUTE_KEYW 259 -#define AUTO_KEYW 260 -#define BOOL_KEYW 261 -#define CHAR_KEYW 262 -#define CONST_KEYW 263 -#define DOUBLE_KEYW 264 -#define ENUM_KEYW 265 -#define EXTERN_KEYW 266 -#define FLOAT_KEYW 267 -#define INLINE_KEYW 268 -#define INT_KEYW 269 -#define LONG_KEYW 270 -#define REGISTER_KEYW 271 -#define RESTRICT_KEYW 272 -#define SHORT_KEYW 273 -#define SIGNED_KEYW 274 -#define STATIC_KEYW 275 -#define STRUCT_KEYW 276 -#define TYPEDEF_KEYW 277 -#define UNION_KEYW 278 -#define UNSIGNED_KEYW 279 -#define VOID_KEYW 280 -#define VOLATILE_KEYW 281 -#define TYPEOF_KEYW 282 -#define EXPORT_SYMBOL_KEYW 283 -#define ASM_PHRASE 284 -#define ATTRIBUTE_PHRASE 285 -#define BRACE_PHRASE 286 -#define BRACKET_PHRASE 287 -#define EXPRESSION_PHRASE 288 -#define CHAR 289 -#define DOTS 290 -#define IDENT 291 -#define INT 292 -#define REAL 293 -#define STRING 294 -#define TYPE 295 -#define OTHER 296 -#define FILENAME 297 - - - - -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) -typedef int YYSTYPE; -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 -#endif extern YYSTYPE yylval; - - - diff --git a/trunk/scripts/genksyms/parse.c_shipped b/trunk/scripts/genksyms/parse.c_shipped index 99d7c258696d..2c6b1286b638 100644 --- a/trunk/scripts/genksyms/parse.c_shipped +++ b/trunk/scripts/genksyms/parse.c_shipped @@ -1,145 +1,50 @@ -/* A Bison parser, made by GNU Bison 2.0. */ -/* Skeleton parser for Yacc-like parsing with Bison, - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. +/* A Bison parser, made from scripts/genksyms/parse.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define ASM_KEYW 257 +#define ATTRIBUTE_KEYW 258 +#define AUTO_KEYW 259 +#define BOOL_KEYW 260 +#define CHAR_KEYW 261 +#define CONST_KEYW 262 +#define DOUBLE_KEYW 263 +#define ENUM_KEYW 264 +#define EXTERN_KEYW 265 +#define FLOAT_KEYW 266 +#define INLINE_KEYW 267 +#define INT_KEYW 268 +#define LONG_KEYW 269 +#define REGISTER_KEYW 270 +#define RESTRICT_KEYW 271 +#define SHORT_KEYW 272 +#define SIGNED_KEYW 273 +#define STATIC_KEYW 274 +#define STRUCT_KEYW 275 +#define TYPEDEF_KEYW 276 +#define UNION_KEYW 277 +#define UNSIGNED_KEYW 278 +#define VOID_KEYW 279 +#define VOLATILE_KEYW 280 +#define TYPEOF_KEYW 281 +#define EXPORT_SYMBOL_KEYW 282 +#define ASM_PHRASE 283 +#define ATTRIBUTE_PHRASE 284 +#define BRACE_PHRASE 285 +#define BRACKET_PHRASE 286 +#define EXPRESSION_PHRASE 287 +#define CHAR 288 +#define DOTS 289 +#define IDENT 290 +#define INT 291 +#define REAL 292 +#define STRING 293 +#define TYPE 294 +#define OTHER 295 +#define FILENAME 296 - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* Written by Richard Stallman by simplifying the original so called - ``semantic'' parser. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - - - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - ASM_KEYW = 258, - ATTRIBUTE_KEYW = 259, - AUTO_KEYW = 260, - BOOL_KEYW = 261, - CHAR_KEYW = 262, - CONST_KEYW = 263, - DOUBLE_KEYW = 264, - ENUM_KEYW = 265, - EXTERN_KEYW = 266, - FLOAT_KEYW = 267, - INLINE_KEYW = 268, - INT_KEYW = 269, - LONG_KEYW = 270, - REGISTER_KEYW = 271, - RESTRICT_KEYW = 272, - SHORT_KEYW = 273, - SIGNED_KEYW = 274, - STATIC_KEYW = 275, - STRUCT_KEYW = 276, - TYPEDEF_KEYW = 277, - UNION_KEYW = 278, - UNSIGNED_KEYW = 279, - VOID_KEYW = 280, - VOLATILE_KEYW = 281, - TYPEOF_KEYW = 282, - EXPORT_SYMBOL_KEYW = 283, - ASM_PHRASE = 284, - ATTRIBUTE_PHRASE = 285, - BRACE_PHRASE = 286, - BRACKET_PHRASE = 287, - EXPRESSION_PHRASE = 288, - CHAR = 289, - DOTS = 290, - IDENT = 291, - INT = 292, - REAL = 293, - STRING = 294, - TYPE = 295, - OTHER = 296, - FILENAME = 297 - }; -#endif -#define ASM_KEYW 258 -#define ATTRIBUTE_KEYW 259 -#define AUTO_KEYW 260 -#define BOOL_KEYW 261 -#define CHAR_KEYW 262 -#define CONST_KEYW 263 -#define DOUBLE_KEYW 264 -#define ENUM_KEYW 265 -#define EXTERN_KEYW 266 -#define FLOAT_KEYW 267 -#define INLINE_KEYW 268 -#define INT_KEYW 269 -#define LONG_KEYW 270 -#define REGISTER_KEYW 271 -#define RESTRICT_KEYW 272 -#define SHORT_KEYW 273 -#define SIGNED_KEYW 274 -#define STATIC_KEYW 275 -#define STRUCT_KEYW 276 -#define TYPEDEF_KEYW 277 -#define UNION_KEYW 278 -#define UNSIGNED_KEYW 279 -#define VOID_KEYW 280 -#define VOLATILE_KEYW 281 -#define TYPEOF_KEYW 282 -#define EXPORT_SYMBOL_KEYW 283 -#define ASM_PHRASE 284 -#define ATTRIBUTE_PHRASE 285 -#define BRACE_PHRASE 286 -#define BRACKET_PHRASE 287 -#define EXPRESSION_PHRASE 288 -#define CHAR 289 -#define DOTS 290 -#define IDENT 291 -#define INT 292 -#define REAL 293 -#define STRING 294 -#define TYPE 295 -#define OTHER 296 -#define FILENAME 297 - - - - -/* Copy the first part of user declarations. */ #line 24 "scripts/genksyms/parse.y" @@ -170,1000 +75,661 @@ remove_list(struct string_list **pb, struct string_list **pe) free_list(b, e); } - - -/* Enabling traces. */ +#ifndef YYSTYPE +#define YYSTYPE int +#endif #ifndef YYDEBUG -# define YYDEBUG 1 +#define YYDEBUG 1 #endif -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 -#endif +#include -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) -typedef int YYSTYPE; -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif #endif -/* Copy the second part of user declarations. */ - - -/* Line 213 of yacc.c. */ -#line 202 "scripts/genksyms/parse.c" - -#if ! defined (yyoverflow) || YYERROR_VERBOSE - -# ifndef YYFREE -# define YYFREE free -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# endif - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# ifdef YYSTACK_USE_ALLOCA -# if YYSTACK_USE_ALLOCA -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# else -# define YYSTACK_ALLOC alloca -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# else -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -# define YYSTACK_ALLOC YYMALLOC -# define YYSTACK_FREE YYFREE -# endif -#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ - +#define YYFINAL 172 +#define YYFLAG -32768 +#define YYNTBASE 52 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 96) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 46, + 47, 48, 2, 45, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 51, 43, 2, + 49, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 50, 2, 44, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42 +}; -#if (! defined (yyoverflow) \ - && (! defined (__cplusplus) \ - || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 5, 6, 9, 10, 14, 16, 18, 20, + 22, 25, 28, 32, 33, 35, 37, 41, 46, 47, + 49, 51, 54, 56, 58, 60, 62, 64, 66, 68, + 70, 72, 77, 80, 83, 86, 90, 94, 98, 101, + 104, 107, 109, 111, 113, 115, 117, 119, 121, 123, + 125, 127, 129, 132, 133, 135, 137, 140, 142, 144, + 146, 148, 151, 153, 155, 160, 165, 168, 172, 176, + 179, 181, 183, 185, 190, 195, 198, 202, 206, 209, + 211, 215, 216, 218, 220, 224, 227, 230, 232, 233, + 235, 237, 242, 247, 250, 254, 258, 262, 263, 265, + 268, 272, 276, 277, 279, 281, 284, 288, 291, 292, + 294, 296, 300, 303, 306, 308, 311, 312, 314, 317, + 318, 320 +}; -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - short int yyss; - YYSTYPE yyvs; - }; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined (__GNUC__) && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - register YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (0) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (0) +static const short yyrhs[] = { 53, + 0, 52, 53, 0, 0, 54, 55, 0, 0, 22, + 56, 57, 0, 57, 0, 81, 0, 93, 0, 95, + 0, 1, 43, 0, 1, 44, 0, 61, 58, 43, + 0, 0, 59, 0, 60, 0, 59, 45, 60, 0, + 71, 94, 92, 82, 0, 0, 62, 0, 63, 0, + 62, 63, 0, 64, 0, 65, 0, 5, 0, 16, + 0, 20, 0, 11, 0, 13, 0, 66, 0, 70, + 0, 27, 46, 62, 47, 0, 21, 36, 0, 23, + 36, 0, 10, 36, 0, 21, 36, 84, 0, 23, + 36, 84, 0, 10, 36, 31, 0, 10, 31, 0, + 21, 84, 0, 23, 84, 0, 7, 0, 18, 0, + 14, 0, 15, 0, 19, 0, 24, 0, 12, 0, + 9, 0, 25, 0, 6, 0, 40, 0, 48, 68, + 0, 0, 69, 0, 70, 0, 69, 70, 0, 8, + 0, 26, 0, 30, 0, 17, 0, 67, 71, 0, + 72, 0, 36, 0, 72, 46, 75, 47, 0, 72, + 46, 1, 47, 0, 72, 32, 0, 46, 71, 47, + 0, 46, 1, 47, 0, 67, 73, 0, 74, 0, + 36, 0, 40, 0, 74, 46, 75, 47, 0, 74, + 46, 1, 47, 0, 74, 32, 0, 46, 73, 47, + 0, 46, 1, 47, 0, 76, 35, 0, 76, 0, + 77, 45, 35, 0, 0, 77, 0, 78, 0, 77, + 45, 78, 0, 62, 79, 0, 67, 79, 0, 80, + 0, 0, 36, 0, 40, 0, 80, 46, 75, 47, + 0, 80, 46, 1, 47, 0, 80, 32, 0, 46, + 79, 47, 0, 46, 1, 47, 0, 61, 71, 31, + 0, 0, 83, 0, 49, 33, 0, 50, 85, 44, + 0, 50, 1, 44, 0, 0, 86, 0, 87, 0, + 86, 87, 0, 61, 88, 43, 0, 1, 43, 0, + 0, 89, 0, 90, 0, 89, 45, 90, 0, 73, + 92, 0, 36, 91, 0, 91, 0, 51, 33, 0, + 0, 30, 0, 29, 43, 0, 0, 29, 0, 28, + 46, 36, 47, 43, 0 +}; #endif -#if defined (__STDC__) || defined (__cplusplus) - typedef signed char yysigned_char; -#else - typedef short int yysigned_char; +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 101, 103, 106, 109, 112, 114, 115, 116, 117, 118, + 119, 120, 123, 137, 139, 142, 151, 163, 169, 171, + 174, 176, 179, 186, 189, 191, 192, 193, 194, 197, + 199, 200, 204, 206, 208, 212, 219, 226, 235, 236, + 237, 240, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 254, 259, 261, 264, 266, 269, 270, 270, + 271, 278, 280, 283, 293, 295, 297, 299, 301, 307, + 309, 312, 314, 315, 317, 319, 321, 323, 327, 329, + 330, 333, 335, 338, 340, 344, 349, 352, 355, 357, + 365, 369, 371, 373, 375, 377, 381, 390, 392, 396, + 401, 403, 406, 408, 411, 413, 416, 419, 423, 425, + 428, 430, 433, 435, 436, 439, 443, 445, 448, 452, + 454, 457 +}; #endif -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 4 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 535 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 52 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 45 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 124 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 174 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 297 - -#define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const unsigned char yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 46, 48, 47, 2, 45, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 51, 43, - 2, 49, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 50, 2, 44, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42 -}; -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const unsigned short int yyprhs[] = -{ - 0, 0, 3, 5, 8, 9, 12, 13, 17, 19, - 21, 23, 25, 28, 31, 35, 36, 38, 40, 44, - 49, 50, 52, 54, 57, 59, 61, 63, 65, 67, - 69, 71, 73, 75, 81, 86, 89, 92, 95, 99, - 103, 107, 110, 113, 116, 118, 120, 122, 124, 126, - 128, 130, 132, 134, 136, 138, 141, 142, 144, 146, - 149, 151, 153, 155, 157, 160, 162, 164, 169, 174, - 177, 181, 185, 188, 190, 192, 194, 199, 204, 207, - 211, 215, 218, 220, 224, 225, 227, 229, 233, 236, - 239, 241, 242, 244, 246, 251, 256, 259, 263, 267, - 271, 272, 274, 277, 281, 285, 286, 288, 290, 293, - 297, 300, 301, 303, 305, 309, 312, 315, 317, 320, - 321, 323, 326, 327, 329 +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","ASM_KEYW", +"ATTRIBUTE_KEYW","AUTO_KEYW","BOOL_KEYW","CHAR_KEYW","CONST_KEYW","DOUBLE_KEYW", +"ENUM_KEYW","EXTERN_KEYW","FLOAT_KEYW","INLINE_KEYW","INT_KEYW","LONG_KEYW", +"REGISTER_KEYW","RESTRICT_KEYW","SHORT_KEYW","SIGNED_KEYW","STATIC_KEYW","STRUCT_KEYW", +"TYPEDEF_KEYW","UNION_KEYW","UNSIGNED_KEYW","VOID_KEYW","VOLATILE_KEYW","TYPEOF_KEYW", +"EXPORT_SYMBOL_KEYW","ASM_PHRASE","ATTRIBUTE_PHRASE","BRACE_PHRASE","BRACKET_PHRASE", +"EXPRESSION_PHRASE","CHAR","DOTS","IDENT","INT","REAL","STRING","TYPE","OTHER", +"FILENAME","';'","'}'","','","'('","')'","'*'","'='","'{'","':'","declaration_seq", +"declaration","@1","declaration1","@2","simple_declaration","init_declarator_list_opt", +"init_declarator_list","init_declarator","decl_specifier_seq_opt","decl_specifier_seq", +"decl_specifier","storage_class_specifier","type_specifier","simple_type_specifier", +"ptr_operator","cvar_qualifier_seq_opt","cvar_qualifier_seq","cvar_qualifier", +"declarator","direct_declarator","nested_declarator","direct_nested_declarator", +"parameter_declaration_clause","parameter_declaration_list_opt","parameter_declaration_list", +"parameter_declaration","m_abstract_declarator","direct_m_abstract_declarator", +"function_definition","initializer_opt","initializer","class_body","member_specification_opt", +"member_specification","member_declaration","member_declarator_list_opt","member_declarator_list", +"member_declarator","member_bitfield_declarator","attribute_opt","asm_definition", +"asm_phrase_opt","export_definition", NULL }; +#endif -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yysigned_char yyrhs[] = -{ - 53, 0, -1, 54, -1, 53, 54, -1, -1, 55, - 56, -1, -1, 22, 57, 58, -1, 58, -1, 82, - -1, 94, -1, 96, -1, 1, 43, -1, 1, 44, - -1, 62, 59, 43, -1, -1, 60, -1, 61, -1, - 60, 45, 61, -1, 72, 95, 93, 83, -1, -1, - 63, -1, 64, -1, 63, 64, -1, 65, -1, 66, - -1, 5, -1, 16, -1, 20, -1, 11, -1, 13, - -1, 67, -1, 71, -1, 27, 46, 63, 47, 48, - -1, 27, 46, 63, 48, -1, 21, 36, -1, 23, - 36, -1, 10, 36, -1, 21, 36, 85, -1, 23, - 36, 85, -1, 10, 36, 31, -1, 10, 31, -1, - 21, 85, -1, 23, 85, -1, 7, -1, 18, -1, - 14, -1, 15, -1, 19, -1, 24, -1, 12, -1, - 9, -1, 25, -1, 6, -1, 40, -1, 47, 69, - -1, -1, 70, -1, 71, -1, 70, 71, -1, 8, - -1, 26, -1, 30, -1, 17, -1, 68, 72, -1, - 73, -1, 36, -1, 73, 46, 76, 48, -1, 73, - 46, 1, 48, -1, 73, 32, -1, 46, 72, 48, - -1, 46, 1, 48, -1, 68, 74, -1, 75, -1, - 36, -1, 40, -1, 75, 46, 76, 48, -1, 75, - 46, 1, 48, -1, 75, 32, -1, 46, 74, 48, - -1, 46, 1, 48, -1, 77, 35, -1, 77, -1, - 78, 45, 35, -1, -1, 78, -1, 79, -1, 78, - 45, 79, -1, 63, 80, -1, 68, 80, -1, 81, - -1, -1, 36, -1, 40, -1, 81, 46, 76, 48, - -1, 81, 46, 1, 48, -1, 81, 32, -1, 46, - 80, 48, -1, 46, 1, 48, -1, 62, 72, 31, - -1, -1, 84, -1, 49, 33, -1, 50, 86, 44, - -1, 50, 1, 44, -1, -1, 87, -1, 88, -1, - 87, 88, -1, 62, 89, 43, -1, 1, 43, -1, - -1, 90, -1, 91, -1, 90, 45, 91, -1, 74, - 93, -1, 36, 92, -1, 92, -1, 51, 33, -1, - -1, 30, -1, 29, 43, -1, -1, 29, -1, 28, - 46, 36, 48, 43, -1 +static const short yyr1[] = { 0, + 52, 52, 54, 53, 56, 55, 55, 55, 55, 55, + 55, 55, 57, 58, 58, 59, 59, 60, 61, 61, + 62, 62, 63, 63, 64, 64, 64, 64, 64, 65, + 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, + 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, + 66, 66, 67, 68, 68, 69, 69, 70, 70, 70, + 70, 71, 71, 72, 72, 72, 72, 72, 72, 73, + 73, 74, 74, 74, 74, 74, 74, 74, 75, 75, + 75, 76, 76, 77, 77, 78, 79, 79, 80, 80, + 80, 80, 80, 80, 80, 80, 81, 82, 82, 83, + 84, 84, 85, 85, 86, 86, 87, 87, 88, 88, + 89, 89, 90, 90, 90, 91, 92, 92, 93, 94, + 94, 95 }; -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const unsigned short int yyrline[] = -{ - 0, 102, 102, 103, 107, 107, 113, 113, 115, 116, - 117, 118, 119, 120, 124, 138, 139, 143, 151, 164, - 170, 171, 175, 176, 180, 186, 190, 191, 192, 193, - 194, 198, 199, 200, 201, 205, 207, 209, 213, 220, - 227, 236, 237, 238, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 256, 261, 262, 266, 267, - 271, 271, 271, 272, 280, 281, 285, 294, 296, 298, - 300, 302, 309, 310, 314, 315, 316, 318, 320, 322, - 324, 329, 330, 331, 335, 336, 340, 341, 346, 351, - 353, 357, 358, 366, 370, 372, 374, 376, 378, 383, - 392, 393, 398, 403, 404, 408, 409, 413, 414, 418, - 420, 425, 426, 430, 431, 435, 436, 437, 441, 445, - 446, 450, 454, 455, 459 +static const short yyr2[] = { 0, + 1, 2, 0, 2, 0, 3, 1, 1, 1, 1, + 2, 2, 3, 0, 1, 1, 3, 4, 0, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 2, 2, 2, 3, 3, 3, 2, 2, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 0, 1, 1, 2, 1, 1, 1, + 1, 2, 1, 1, 4, 4, 2, 3, 3, 2, + 1, 1, 1, 4, 4, 2, 3, 3, 2, 1, + 3, 0, 1, 1, 3, 2, 2, 1, 0, 1, + 1, 4, 4, 2, 3, 3, 3, 0, 1, 2, + 3, 3, 0, 1, 1, 2, 3, 2, 0, 1, + 1, 3, 2, 2, 1, 2, 0, 1, 2, 0, + 1, 5 }; -#endif -#if YYDEBUG || YYERROR_VERBOSE -/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = -{ - "$end", "error", "$undefined", "ASM_KEYW", "ATTRIBUTE_KEYW", - "AUTO_KEYW", "BOOL_KEYW", "CHAR_KEYW", "CONST_KEYW", "DOUBLE_KEYW", - "ENUM_KEYW", "EXTERN_KEYW", "FLOAT_KEYW", "INLINE_KEYW", "INT_KEYW", - "LONG_KEYW", "REGISTER_KEYW", "RESTRICT_KEYW", "SHORT_KEYW", - "SIGNED_KEYW", "STATIC_KEYW", "STRUCT_KEYW", "TYPEDEF_KEYW", - "UNION_KEYW", "UNSIGNED_KEYW", "VOID_KEYW", "VOLATILE_KEYW", - "TYPEOF_KEYW", "EXPORT_SYMBOL_KEYW", "ASM_PHRASE", "ATTRIBUTE_PHRASE", - "BRACE_PHRASE", "BRACKET_PHRASE", "EXPRESSION_PHRASE", "CHAR", "DOTS", - "IDENT", "INT", "REAL", "STRING", "TYPE", "OTHER", "FILENAME", "';'", - "'}'", "','", "'('", "'*'", "')'", "'='", "'{'", "':'", "$accept", - "declaration_seq", "declaration", "@1", "declaration1", "@2", - "simple_declaration", "init_declarator_list_opt", "init_declarator_list", - "init_declarator", "decl_specifier_seq_opt", "decl_specifier_seq", - "decl_specifier", "storage_class_specifier", "type_specifier", - "simple_type_specifier", "ptr_operator", "cvar_qualifier_seq_opt", - "cvar_qualifier_seq", "cvar_qualifier", "declarator", - "direct_declarator", "nested_declarator", "direct_nested_declarator", - "parameter_declaration_clause", "parameter_declaration_list_opt", - "parameter_declaration_list", "parameter_declaration", - "m_abstract_declarator", "direct_m_abstract_declarator", - "function_definition", "initializer_opt", "initializer", "class_body", - "member_specification_opt", "member_specification", "member_declaration", - "member_declarator_list_opt", "member_declarator_list", - "member_declarator", "member_bitfield_declarator", "attribute_opt", - "asm_definition", "asm_phrase_opt", "export_definition", 0 +static const short yydefact[] = { 3, + 3, 1, 0, 2, 0, 25, 51, 42, 58, 49, + 0, 28, 48, 29, 44, 45, 26, 61, 43, 46, + 27, 0, 5, 0, 47, 50, 59, 0, 0, 0, + 60, 52, 4, 7, 14, 20, 21, 23, 24, 30, + 31, 8, 9, 10, 11, 12, 39, 35, 33, 0, + 40, 19, 34, 41, 0, 0, 119, 64, 0, 54, + 0, 15, 16, 0, 120, 63, 22, 38, 36, 0, + 109, 0, 0, 105, 6, 14, 37, 0, 0, 0, + 0, 53, 55, 56, 13, 0, 62, 121, 97, 117, + 67, 0, 108, 102, 72, 73, 0, 0, 0, 117, + 71, 0, 110, 111, 115, 101, 0, 106, 120, 32, + 0, 69, 68, 57, 17, 118, 98, 0, 89, 0, + 80, 83, 84, 114, 0, 72, 0, 116, 70, 113, + 76, 0, 107, 0, 122, 0, 18, 99, 66, 90, + 52, 0, 89, 86, 88, 65, 79, 0, 78, 77, + 0, 0, 112, 100, 0, 91, 0, 87, 94, 0, + 81, 85, 75, 74, 96, 95, 0, 0, 93, 92, + 0, 0 }; -#endif -# ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const unsigned short int yytoknum[] = -{ - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 59, 125, 44, 40, 42, 41, 61, - 123, 58 +static const short yydefgoto[] = { 1, + 2, 3, 33, 52, 34, 61, 62, 63, 71, 36, + 37, 38, 39, 40, 64, 82, 83, 41, 109, 66, + 100, 101, 120, 121, 122, 123, 144, 145, 42, 137, + 138, 51, 72, 73, 74, 102, 103, 104, 105, 117, + 43, 90, 44 }; -# endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const unsigned char yyr1[] = -{ - 0, 52, 53, 53, 55, 54, 57, 56, 56, 56, - 56, 56, 56, 56, 58, 59, 59, 60, 60, 61, - 62, 62, 63, 63, 64, 64, 65, 65, 65, 65, - 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, - 66, 66, 66, 66, 67, 67, 67, 67, 67, 67, - 67, 67, 67, 67, 67, 68, 69, 69, 70, 70, - 71, 71, 71, 71, 72, 72, 73, 73, 73, 73, - 73, 73, 74, 74, 75, 75, 75, 75, 75, 75, - 75, 76, 76, 76, 77, 77, 78, 78, 79, 80, - 80, 81, 81, 81, 81, 81, 81, 81, 81, 82, - 83, 83, 84, 85, 85, 86, 86, 87, 87, 88, - 88, 89, 89, 90, 90, 91, 91, 91, 92, 93, - 93, 94, 95, 95, 96 +static const short yypact[] = {-32768, + 15,-32768, 197,-32768, 23,-32768,-32768,-32768,-32768,-32768, + -18,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, -28,-32768, -25,-32768,-32768,-32768, -26, -22, -12, +-32768,-32768,-32768,-32768, 49, 493,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768, 27, -8, 101, +-32768, 493, -8,-32768, 493, 10,-32768,-32768, 11, 9, + 18, 26,-32768, 49, -15, -13,-32768,-32768,-32768, 25, + 24, 48, 149,-32768,-32768, 49,-32768, 414, 39, 40, + 47,-32768, 9,-32768,-32768, 49,-32768,-32768,-32768, 66, +-32768, 241,-32768,-32768, 50,-32768, 5, 65, 42, 66, + 17, 56, 55,-32768,-32768,-32768, 60,-32768, 75,-32768, + 80,-32768,-32768,-32768,-32768,-32768, 81, 82, 370, 85, + 98, 89,-32768,-32768, 88,-32768, 91,-32768,-32768,-32768, +-32768, 284,-32768, 24,-32768, 103,-32768,-32768,-32768,-32768, +-32768, 8, 43,-32768, 30,-32768,-32768, 457,-32768,-32768, + 92, 93,-32768,-32768, 95,-32768, 96,-32768,-32768, 327, +-32768,-32768,-32768,-32768,-32768,-32768, 99, 104,-32768,-32768, + 148,-32768 }; -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const unsigned char yyr2[] = -{ - 0, 2, 1, 2, 0, 2, 0, 3, 1, 1, - 1, 1, 2, 2, 3, 0, 1, 1, 3, 4, - 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 5, 4, 2, 2, 2, 3, 3, - 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 2, 0, 1, 1, 2, - 1, 1, 1, 1, 2, 1, 1, 4, 4, 2, - 3, 3, 2, 1, 1, 1, 4, 4, 2, 3, - 3, 2, 1, 3, 0, 1, 1, 3, 2, 2, - 1, 0, 1, 1, 4, 4, 2, 3, 3, 3, - 0, 1, 2, 3, 3, 0, 1, 1, 2, 3, - 2, 0, 1, 1, 3, 2, 2, 1, 2, 0, - 1, 2, 0, 1, 5 +static const short yypgoto[] = {-32768, + 152,-32768,-32768,-32768, 119,-32768,-32768, 94, 0, -55, + -35,-32768,-32768,-32768, -69,-32768,-32768, -56, -30,-32768, + -76,-32768, -122,-32768,-32768, 29, -62,-32768,-32768,-32768, +-32768, -17,-32768,-32768, 105,-32768,-32768, 52, 86, 83, +-32768,-32768,-32768 }; -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const unsigned char yydefact[] = -{ - 4, 4, 2, 0, 1, 3, 0, 26, 53, 44, - 60, 51, 0, 29, 50, 30, 46, 47, 27, 63, - 45, 48, 28, 0, 6, 0, 49, 52, 61, 0, - 0, 0, 62, 54, 5, 8, 15, 21, 22, 24, - 25, 31, 32, 9, 10, 11, 12, 13, 41, 37, - 35, 0, 42, 20, 36, 43, 0, 0, 121, 66, - 0, 56, 0, 16, 17, 0, 122, 65, 23, 40, - 38, 0, 111, 0, 0, 107, 7, 15, 39, 0, - 0, 0, 0, 55, 57, 58, 14, 0, 64, 123, - 99, 119, 69, 0, 110, 104, 74, 75, 0, 0, - 0, 119, 73, 0, 112, 113, 117, 103, 0, 108, - 122, 0, 34, 0, 71, 70, 59, 18, 120, 100, - 0, 91, 0, 82, 85, 86, 116, 0, 74, 0, - 118, 72, 115, 78, 0, 109, 0, 33, 124, 0, - 19, 101, 68, 92, 54, 0, 91, 88, 90, 67, - 81, 0, 80, 79, 0, 0, 114, 102, 0, 93, - 0, 89, 96, 0, 83, 87, 77, 76, 98, 97, - 0, 0, 95, 94 -}; -/* YYDEFGOTO[NTERM-NUM]. */ -static const short int yydefgoto[] = -{ - -1, 1, 2, 3, 34, 53, 35, 62, 63, 64, - 72, 37, 38, 39, 40, 41, 65, 83, 84, 42, - 110, 67, 101, 102, 122, 123, 124, 125, 147, 148, - 43, 140, 141, 52, 73, 74, 75, 103, 104, 105, - 106, 119, 44, 91, 45 +#define YYLAST 533 + + +static const short yytable[] = { 78, + 67, 99, 35, 84, 65, 125, 54, 49, 155, 152, + 53, 80, 47, 88, 171, 89, 9, 48, 91, 55, + 127, 50, 129, 56, 50, 18, 114, 99, 81, 99, + 57, 69, 92, 87, 27, 77, 119, 168, 31, -89, + 126, 50, 67, 140, 96, 79, 58, 156, 131, 143, + 97, 76, 60, 142, -89, 60, 59, 68, 60, 95, + 85, 159, 132, 96, 99, 45, 46, 93, 94, 97, + 86, 60, 143, 143, 98, 160, 119, 126, 140, 157, + 158, 96, 156, 67, 58, 111, 112, 97, 142, 60, + 60, 106, 119, 113, 59, 116, 60, 128, 133, 134, + 98, 70, 93, 88, 119, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 135, 24, 25, 26, 27, 28, 139, 136, + 31, 146, 147, 148, 149, 154, -19, 150, 163, 164, + 32, 165, 166, -19, -103, 169, -19, 172, -19, 107, + 170, -19, 4, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 75, 24, 25, 26, 27, 28, 162, 108, 31, 115, + 124, 0, 130, 0, -19, 153, 0, 0, 32, 0, + 0, -19, -104, 0, -19, 0, -19, 5, 0, -19, + 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 0, 0, 0, + 0, 0, -19, 0, 0, 0, 32, 0, 0, -19, + 0, 118, -19, 0, -19, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 0, 24, 25, 26, 27, 28, 0, 0, + 31, 0, 0, 0, 0, -82, 0, 0, 0, 0, + 32, 0, 0, 0, 151, 0, 0, -82, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 0, 24, 25, 26, 27, + 28, 0, 0, 31, 0, 0, 0, 0, -82, 0, + 0, 0, 0, 32, 0, 0, 0, 167, 0, 0, + -82, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 0, 24, + 25, 26, 27, 28, 0, 0, 31, 0, 0, 0, + 0, -82, 0, 0, 0, 0, 32, 0, 0, 0, + 0, 0, 0, -82, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 0, 24, 25, 26, 27, 28, 0, 0, 31, + 0, 0, 0, 0, 0, 140, 0, 0, 0, 141, + 0, 0, 0, 0, 0, 142, 0, 60, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 0, 24, 25, 26, 27, + 28, 0, 0, 31, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, + 110, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 0, 24, + 25, 26, 27, 28, 0, 0, 31, 0, 0, 0, + 0, 161, 0, 0, 0, 0, 32, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 0, 24, 25, 26, 27, 28, + 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 32 }; -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -128 -static const short int yypact[] = -{ - -128, 13, -128, 329, -128, -128, 36, -128, -128, -128, - -128, -128, -16, -128, -128, -128, -128, -128, -128, -128, - -128, -128, -128, -25, -128, -24, -128, -128, -128, -29, - -4, -22, -128, -128, -128, -128, -28, 495, -128, -128, - -128, -128, -128, -128, -128, -128, -128, -128, -128, 16, - -23, 103, -128, 495, -23, -128, 495, 35, -128, -128, - 3, 15, 9, 17, -128, -28, -15, -8, -128, -128, - -128, 47, 23, 44, 150, -128, -128, -28, -128, 372, - 33, 48, 49, -128, 15, -128, -128, -28, -128, -128, - -128, 64, -128, 197, -128, -128, 50, -128, 21, 65, - 37, 64, 14, 56, 55, -128, -128, -128, 59, -128, - 74, 57, -128, 63, -128, -128, -128, -128, -128, 76, - 83, 416, 84, 99, 90, -128, -128, 88, -128, 89, - -128, -128, -128, -128, 241, -128, 23, -128, -128, 105, - -128, -128, -128, -128, -128, 8, 46, -128, 26, -128, - -128, 459, -128, -128, 92, 93, -128, -128, 94, -128, - 96, -128, -128, 285, -128, -128, -128, -128, -128, -128, - 97, 100, -128, -128 +static const short yycheck[] = { 55, + 36, 71, 3, 60, 35, 1, 24, 36, 1, 132, + 36, 1, 31, 29, 0, 31, 8, 36, 32, 46, + 97, 50, 99, 46, 50, 17, 83, 97, 59, 99, + 43, 49, 46, 64, 26, 53, 92, 160, 30, 32, + 36, 50, 78, 36, 40, 36, 36, 40, 32, 119, + 46, 52, 48, 46, 47, 48, 46, 31, 48, 36, + 43, 32, 46, 40, 134, 43, 44, 43, 44, 46, + 45, 48, 142, 143, 51, 46, 132, 36, 36, 142, + 143, 40, 40, 119, 36, 47, 47, 46, 46, 48, + 48, 44, 148, 47, 46, 30, 48, 33, 43, 45, + 51, 1, 43, 29, 160, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 43, 23, 24, 25, 26, 27, 47, 49, + 30, 47, 35, 45, 47, 33, 36, 47, 47, 47, + 40, 47, 47, 43, 44, 47, 46, 0, 48, 1, + 47, 51, 1, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 52, 23, 24, 25, 26, 27, 148, 73, 30, 86, + 95, -1, 100, -1, 36, 134, -1, -1, 40, -1, + -1, 43, 44, -1, 46, -1, 48, 1, -1, 51, + -1, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, -1, -1, -1, + -1, -1, 36, -1, -1, -1, 40, -1, -1, 43, + -1, 1, 46, -1, 48, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, -1, 23, 24, 25, 26, 27, -1, -1, + 30, -1, -1, -1, -1, 35, -1, -1, -1, -1, + 40, -1, -1, -1, 1, -1, -1, 47, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, -1, 23, 24, 25, 26, + 27, -1, -1, 30, -1, -1, -1, -1, 35, -1, + -1, -1, -1, 40, -1, -1, -1, 1, -1, -1, + 47, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, -1, 23, + 24, 25, 26, 27, -1, -1, 30, -1, -1, -1, + -1, 35, -1, -1, -1, -1, 40, -1, -1, -1, + -1, -1, -1, 47, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, -1, 23, 24, 25, 26, 27, -1, -1, 30, + -1, -1, -1, -1, -1, 36, -1, -1, -1, 40, + -1, -1, -1, -1, -1, 46, -1, 48, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, -1, 23, 24, 25, 26, + 27, -1, -1, 30, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 40, -1, -1, -1, -1, -1, -1, + 47, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, -1, 23, + 24, 25, 26, 27, -1, -1, 30, -1, -1, -1, + -1, 35, -1, -1, -1, -1, 40, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, -1, 23, 24, 25, 26, 27, + -1, -1, 30, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 40 }; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/lib/bison.simple" +/* This file comes from bison-1.28. */ -/* YYPGOTO[NTERM-NUM]. */ -static const short int yypgoto[] = -{ - -128, -128, 151, -128, -128, -128, 119, -128, -128, 66, - 0, -56, -36, -128, -128, -128, -70, -128, -128, -51, - -31, -128, -11, -128, -127, -128, -128, 27, -81, -128, - -128, -128, -128, -19, -128, -128, 107, -128, -128, 43, - 86, 82, -128, -128, -128 -}; +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -107 -static const short int yytable[] = -{ - 79, 68, 100, 36, 81, 66, 55, 155, 59, 158, - 85, 50, 54, 4, 89, 48, 90, 56, 60, 61, - 49, 58, 127, 10, 92, 51, 51, 51, 100, 82, - 100, 70, 19, 116, 88, 78, 171, 121, 93, 59, - -91, 28, 57, 68, 143, 32, 133, 69, 159, 60, - 61, 146, 86, 77, 145, 61, -91, 128, 162, 96, - 134, 97, 87, 97, 160, 161, 100, 98, 61, 98, - 61, 80, 163, 128, 99, 146, 146, 97, 121, 46, - 47, 113, 143, 98, 61, 68, 159, 129, 107, 131, - 94, 95, 145, 61, 118, 121, 114, 115, 130, 135, - 136, 99, 94, 89, 71, 137, 138, 121, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 139, 25, 26, 27, 28, - 29, 142, 149, 32, 150, 151, 152, 153, 157, -20, - 166, 167, 168, 33, 169, 172, -20, -105, 173, -20, - -20, 108, 5, 117, -20, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 76, 25, 26, 27, 28, 29, 165, 156, - 32, 109, 126, 132, 0, 0, -20, 0, 0, 0, - 33, 0, 0, -20, -106, 0, -20, -20, 120, 0, - 0, -20, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 0, - 25, 26, 27, 28, 29, 0, 0, 32, 0, 0, - 0, 0, -84, 0, 0, 0, 0, 33, 0, 0, - 0, 0, 154, 0, 0, -84, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 0, 25, 26, 27, 28, 29, 0, - 0, 32, 0, 0, 0, 0, -84, 0, 0, 0, - 0, 33, 0, 0, 0, 0, 170, 0, 0, -84, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 0, 25, 26, - 27, 28, 29, 0, 0, 32, 0, 0, 0, 0, - -84, 0, 0, 0, 0, 33, 0, 0, 0, 0, - 6, 0, 0, -84, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 0, 0, 0, 0, 0, -20, 0, 0, 0, 33, - 0, 0, -20, 0, 0, -20, -20, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 0, 25, 26, 27, 28, 29, - 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 33, 0, 0, 0, 0, 0, 0, 111, - 112, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 0, 25, - 26, 27, 28, 29, 0, 0, 32, 0, 0, 0, - 0, 0, 143, 0, 0, 0, 144, 0, 0, 0, - 0, 0, 145, 61, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 0, 25, 26, 27, 28, 29, 0, 0, 32, - 0, 0, 0, 0, 164, 0, 0, 0, 0, 33, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 0, 25, 26, - 27, 28, 29, 0, 0, 32, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 33 -}; + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. -static const short int yycheck[] = -{ - 56, 37, 72, 3, 1, 36, 25, 134, 36, 1, - 61, 36, 36, 0, 29, 31, 31, 46, 46, 47, - 36, 43, 1, 8, 32, 50, 50, 50, 98, 60, - 100, 50, 17, 84, 65, 54, 163, 93, 46, 36, - 32, 26, 46, 79, 36, 30, 32, 31, 40, 46, - 47, 121, 43, 53, 46, 47, 48, 36, 32, 36, - 46, 40, 45, 40, 145, 146, 136, 46, 47, 46, - 47, 36, 46, 36, 51, 145, 146, 40, 134, 43, - 44, 48, 36, 46, 47, 121, 40, 98, 44, 100, - 43, 44, 46, 47, 30, 151, 48, 48, 33, 43, - 45, 51, 43, 29, 1, 48, 43, 163, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 49, 23, 24, 25, 26, - 27, 48, 48, 30, 35, 45, 48, 48, 33, 36, - 48, 48, 48, 40, 48, 48, 43, 44, 48, 46, - 47, 1, 1, 87, 51, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 53, 23, 24, 25, 26, 27, 151, 136, - 30, 74, 96, 101, -1, -1, 36, -1, -1, -1, - 40, -1, -1, 43, 44, -1, 46, 47, 1, -1, - -1, 51, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, -1, - 23, 24, 25, 26, 27, -1, -1, 30, -1, -1, - -1, -1, 35, -1, -1, -1, -1, 40, -1, -1, - -1, -1, 1, -1, -1, 48, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, -1, 23, 24, 25, 26, 27, -1, - -1, 30, -1, -1, -1, -1, 35, -1, -1, -1, - -1, 40, -1, -1, -1, -1, 1, -1, -1, 48, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, -1, 23, 24, - 25, 26, 27, -1, -1, 30, -1, -1, -1, -1, - 35, -1, -1, -1, -1, 40, -1, -1, -1, -1, - 1, -1, -1, 48, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - -1, -1, -1, -1, -1, 36, -1, -1, -1, 40, - -1, -1, 43, -1, -1, 46, 47, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, -1, 23, 24, 25, 26, 27, - -1, -1, 30, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 40, -1, -1, -1, -1, -1, -1, 47, - 48, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, -1, 23, - 24, 25, 26, 27, -1, -1, 30, -1, -1, -1, - -1, -1, 36, -1, -1, -1, 40, -1, -1, -1, - -1, -1, 46, 47, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, -1, 23, 24, 25, 26, 27, -1, -1, 30, - -1, -1, -1, -1, 35, -1, -1, -1, -1, 40, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, -1, 23, 24, - 25, 26, 27, -1, -1, 30, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 40 -}; + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const unsigned char yystos[] = -{ - 0, 53, 54, 55, 0, 54, 1, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 40, 56, 58, 62, 63, 64, 65, - 66, 67, 71, 82, 94, 96, 43, 44, 31, 36, - 36, 50, 85, 57, 36, 85, 46, 46, 43, 36, - 46, 47, 59, 60, 61, 68, 72, 73, 64, 31, - 85, 1, 62, 86, 87, 88, 58, 62, 85, 63, - 36, 1, 72, 69, 70, 71, 43, 45, 72, 29, - 31, 95, 32, 46, 43, 44, 36, 40, 46, 51, - 68, 74, 75, 89, 90, 91, 92, 44, 1, 88, - 72, 47, 48, 48, 48, 48, 71, 61, 30, 93, - 1, 63, 76, 77, 78, 79, 92, 1, 36, 74, - 33, 74, 93, 32, 46, 43, 45, 48, 43, 49, - 83, 84, 48, 36, 40, 46, 68, 80, 81, 48, - 35, 45, 48, 48, 1, 76, 91, 33, 1, 40, - 80, 80, 32, 46, 35, 79, 48, 48, 48, 48, - 1, 76, 48, 48 -}; + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ -#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) -# define YYSIZE_T __SIZE_TYPE__ -#endif -#if ! defined (YYSIZE_T) && defined (size_t) -# define YYSIZE_T size_t +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include #endif -#if ! defined (YYSIZE_T) -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ #endif -#if ! defined (YYSIZE_T) -# define YYSIZE_T unsigned int +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc #endif +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) +#define YYEMPTY -2 #define YYEOF 0 - #define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab - - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ - #define YYFAIL goto yyerrlab - #define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ +#define YYBACKUP(token, value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yytoken = YYTRANSLATE (yychar); \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ - { \ - yyerror ("syntax error: cannot back up");\ - YYERROR; \ - } \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ while (0) - #define YYTERROR 1 #define YYERRCODE 256 - -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (N) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ - while (0) -#endif - - -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -#ifndef YY_LOCATION_PRINT -# if YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif +#ifndef YYPURE +#define YYLEX yylex() #endif - -/* YYLEX -- calling `yylex' with the right arguments. */ - +#ifdef YYPURE +#ifdef YYLSP_NEEDED #ifdef YYLEX_PARAM -# define YYLEX yylex (YYLEX_PARAM) +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) #else -# define YYLEX yylex () +#define YYLEX yylex(&yylval, &yylloc) #endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (0) - -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yysymprint (stderr, \ - Type, Value); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (0) - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -#if defined (__STDC__) || defined (__cplusplus) -static void -yy_stack_print (short int *bottom, short int *top) +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) #else -static void -yy_stack_print (bottom, top) - short int *bottom; - short int *top; +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ #endif -{ - YYFPRINTF (stderr, "Stack now"); - for (/* Nothing. */; bottom <= top; ++bottom) - YYFPRINTF (stderr, " %d", *bottom); - YYFPRINTF (stderr, "\n"); -} -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ -} while (0) +/* If nonreentrant, generate the variables here */ +#ifndef YYPURE -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ -#if defined (__STDC__) || defined (__cplusplus) -static void -yy_reduce_print (int yyrule) -#else -static void -yy_reduce_print (yyrule) - int yyrule; +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ #endif -{ - int yyi; - unsigned int yylno = yyrline[yyrule]; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", - yyrule - 1, yylno); - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) - YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); - YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); -} -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ - yy_reduce_print (Rule); \ -} while (0) +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) -# define YY_STACK_PRINT(Bottom, Top) -# define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif +/* YYINITDEPTH indicates the initial size of the parser's stacks */ -/* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH -# define YYINITDEPTH 200 +#define YYINITDEPTH 200 #endif -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ - Do not make this value too large; the results are undefined if - SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif #ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 +#define YYMAXDEPTH 10000 #endif - - -#if YYERROR_VERBOSE - -# ifndef yystrlen -# if defined (__GLIBC__) && defined (_STRING_H) -# define yystrlen strlen -# else -/* Return the length of YYSTR. */ -static YYSIZE_T -# if defined (__STDC__) || defined (__cplusplus) -yystrlen (const char *yystr) -# else -yystrlen (yystr) - const char *yystr; -# endif -{ - register const char *yys = yystr; - - while (*yys++ != '\0') - continue; - - return yys - yystr - 1; -} -# endif -# endif - -# ifndef yystpcpy -# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) -# define yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -static char * -# if defined (__STDC__) || defined (__cplusplus) -yystpcpy (char *yydest, const char *yysrc) -# else -yystpcpy (yydest, yysrc) - char *yydest; - const char *yysrc; -# endif +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; { - register char *yyd = yydest; - register const char *yys = yysrc; + register char *f = from; + register char *t = to; + register int i = count; - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; + while (i-- > 0) + *t++ = *f++; } -# endif -# endif - -#endif /* !YYERROR_VERBOSE */ - - -#if YYDEBUG -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ +#else /* __cplusplus */ -#if defined (__STDC__) || defined (__cplusplus) +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ static void -yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) -#else -static void -yysymprint (yyoutput, yytype, yyvaluep) - FILE *yyoutput; - int yytype; - YYSTYPE *yyvaluep; -#endif +__yy_memcpy (char *to, char *from, unsigned int count) { - /* Pacify ``unused variable'' warnings. */ - (void) yyvaluep; + register char *t = to; + register char *f = from; + register int i = count; - if (yytype < YYNTOKENS) - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); - - -# ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); -# endif - switch (yytype) - { - default: - break; - } - YYFPRINTF (yyoutput, ")"); + while (i-- > 0) + *t++ = *f++; } -#endif /* ! YYDEBUG */ -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -#if defined (__STDC__) || defined (__cplusplus) -static void -yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) -#else -static void -yydestruct (yymsg, yytype, yyvaluep) - const char *yymsg; - int yytype; - YYSTYPE *yyvaluep; #endif -{ - /* Pacify ``unused variable'' warnings. */ - (void) yyvaluep; - - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) - { - - default: - break; - } -} +#endif +#line 217 "/usr/lib/bison.simple" -/* Prevent warnings from -Wmissing-prototypes. */ +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ #ifdef YYPARSE_PARAM -# if defined (__STDC__) || defined (__cplusplus) -int yyparse (void *YYPARSE_PARAM); -# else -int yyparse (); -# endif -#else /* ! YYPARSE_PARAM */ -#if defined (__STDC__) || defined (__cplusplus) -int yyparse (void); -#else -int yyparse (); -#endif -#endif /* ! YYPARSE_PARAM */ - - - -/* The look-ahead symbol. */ -int yychar; - -/* The semantic value of the look-ahead symbol. */ -YYSTYPE yylval; - -/* Number of syntax errors so far. */ -int yynerrs; - - - -/*----------. -| yyparse. | -`----------*/ - +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ #ifdef YYPARSE_PARAM -# if defined (__STDC__) || defined (__cplusplus) -int yyparse (void *YYPARSE_PARAM) -# else -int yyparse (YYPARSE_PARAM) - void *YYPARSE_PARAM; -# endif -#else /* ! YYPARSE_PARAM */ -#if defined (__STDC__) || defined (__cplusplus) -int -yyparse (void) +int yyparse (void *); #else -int -yyparse () - +int yyparse (void); #endif #endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL { - register int yystate; register int yyn; - int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Look-ahead token as an internal (translated) token number. */ - int yytoken = 0; - - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - short int yyssa[YYINITDEPTH]; - short int *yyss = yyssa; - register short int *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; + register short *yyssp; register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else #define YYPOPSTACK (yyvsp--, yyssp--) +#endif - YYSIZE_T yystacksize = YYINITDEPTH; + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ - /* When reducing, the number of symbols on the RHS of the reduced - rule. */ int yylen; - YYDPRINTF ((stderr, "Starting parse\n")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif yystate = 0; yyerrstatus = 0; @@ -1175,872 +741,833 @@ yyparse () so that they stay on the same level as the state stack. The wasted elements are never initialized. */ - yyssp = yyss; + yyssp = yyss - 1; yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: - yyvsp[0] = yylval; - - goto yysetstate; - -/*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | -`------------------------------------------------------------*/ - yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. so pushing a state here evens the stacks. - */ - yyssp++; - - yysetstate: - *yyssp = yystate; + *++yyssp = yystate; - if (yyss + yystacksize - 1 <= yyssp) + if (yyssp >= yyss + yystacksize - 1) { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + int size = yyssp - yyss + 1; #ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - short int *yyss1 = yyss; - - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - - &yystacksize); - - yyss = yyss1; - yyvs = yyvs1; - } + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif #else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyoverflowlab; -# else /* Extend the stack our own way. */ - if (YYMAXDEPTH <= yystacksize) - goto yyoverflowlab; + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } yystacksize *= 2; - if (YYMAXDEPTH < yystacksize) + if (yystacksize > YYMAXDEPTH) yystacksize = YYMAXDEPTH; - - { - short int *yyss1 = yyss; - union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); - if (! yyptr) - goto yyoverflowlab; - YYSTACK_RELOCATE (yyss); - YYSTACK_RELOCATE (yyvs); - -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif #endif /* no yyoverflow */ - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif - if (yyss + yystacksize - 1 <= yyssp) + if (yyssp >= yyss + yystacksize - 1) YYABORT; } - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif goto yybackup; - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: + yybackup: /* Do appropriate processing given the current state. */ -/* Read a look-ahead token if we need one and don't already have one. */ +/* Read a lookahead token if we need one and don't already have one. */ /* yyresume: */ - /* First try to decide what to do without reference to look-ahead token. */ + /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) + if (yyn == YYFLAG) goto yydefault; - /* Not known => get a look-ahead token if don't already have one. */ + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ - /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { - YYDPRINTF ((stderr, "Reading a token: ")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif yychar = YYLEX; } - if (yychar <= YYEOF) + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ { - yychar = yytoken = YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif } else { - yytoken = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif } - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; + yyn = yytable[yyn]; - if (yyn <= 0) + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) { - if (yyn == 0 || yyn == YYTABLE_NINF) + if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } + else if (yyn == 0) + goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; - /* Shift the look-ahead token. */ - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; yystate = yyn; goto yynewstate; - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ +/* Do the default action for the current state. */ yydefault: + yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; - goto yyreduce; - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ +/* Do a reduction. yyn is the number of a rule to reduce with. */ yyreduce: - /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. +#if YYDEBUG != 0 + if (yydebug) + { + int i; - Otherwise, the following line sets YYVAL to garbage. - This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1-yylen]; + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif - YY_REDUCE_PRINT (yyn); - switch (yyn) - { - case 4: -#line 107 "scripts/genksyms/parse.y" - { is_typedef = 0; is_extern = 0; current_name = NULL; decl_spec = NULL; ;} - break; - case 5: -#line 109 "scripts/genksyms/parse.y" - { free_list(*(yyvsp[0]), NULL); *(yyvsp[0]) = NULL; ;} - break; + switch (yyn) { - case 6: +case 3: +#line 107 "scripts/genksyms/parse.y" +{ is_typedef = 0; is_extern = 0; current_name = NULL; decl_spec = NULL; ; + break;} +case 4: +#line 109 "scripts/genksyms/parse.y" +{ free_list(*yyvsp[0], NULL); *yyvsp[0] = NULL; ; + break;} +case 5: #line 113 "scripts/genksyms/parse.y" - { is_typedef = 1; ;} - break; - - case 7: +{ is_typedef = 1; ; + break;} +case 6: #line 114 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 12: +{ yyval = yyvsp[0]; ; + break;} +case 11: #line 119 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 13: +{ yyval = yyvsp[0]; ; + break;} +case 12: #line 120 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 14: +{ yyval = yyvsp[0]; ; + break;} +case 13: #line 125 "scripts/genksyms/parse.y" - { if (current_name) { - struct string_list *decl = (*(yyvsp[0]))->next; - (*(yyvsp[0]))->next = NULL; +{ if (current_name) { + struct string_list *decl = (*yyvsp[0])->next; + (*yyvsp[0])->next = NULL; add_symbol(current_name, is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern); current_name = NULL; } - (yyval) = (yyvsp[0]); - ;} - break; - - case 15: + yyval = yyvsp[0]; + ; + break;} +case 14: #line 138 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 17: +{ yyval = NULL; ; + break;} +case 16: #line 144 "scripts/genksyms/parse.y" - { struct string_list *decl = *(yyvsp[0]); - *(yyvsp[0]) = NULL; +{ struct string_list *decl = *yyvsp[0]; + *yyvsp[0] = NULL; add_symbol(current_name, is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern); current_name = NULL; - (yyval) = (yyvsp[0]); - ;} - break; - - case 18: + yyval = yyvsp[0]; + ; + break;} +case 17: #line 152 "scripts/genksyms/parse.y" - { struct string_list *decl = *(yyvsp[0]); - *(yyvsp[0]) = NULL; - free_list(*(yyvsp[-1]), NULL); - *(yyvsp[-1]) = decl_spec; +{ struct string_list *decl = *yyvsp[0]; + *yyvsp[0] = NULL; + free_list(*yyvsp[-1], NULL); + *yyvsp[-1] = decl_spec; add_symbol(current_name, is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern); current_name = NULL; - (yyval) = (yyvsp[0]); - ;} - break; - - case 19: + yyval = yyvsp[0]; + ; + break;} +case 18: #line 165 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]) ? (yyvsp[-1]) : (yyvsp[-2]) ? (yyvsp[-2]) : (yyvsp[-3]); ;} - break; - - case 20: +{ yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1] ? yyvsp[-1] : yyvsp[-2] ? yyvsp[-2] : yyvsp[-3]; ; + break;} +case 19: #line 170 "scripts/genksyms/parse.y" - { decl_spec = NULL; ;} - break; - - case 22: +{ decl_spec = NULL; ; + break;} +case 21: #line 175 "scripts/genksyms/parse.y" - { decl_spec = *(yyvsp[0]); ;} - break; - - case 23: +{ decl_spec = *yyvsp[0]; ; + break;} +case 22: #line 176 "scripts/genksyms/parse.y" - { decl_spec = *(yyvsp[0]); ;} - break; - - case 24: +{ decl_spec = *yyvsp[0]; ; + break;} +case 23: #line 181 "scripts/genksyms/parse.y" - { /* Version 2 checksumming ignores storage class, as that +{ /* Version 2 checksumming ignores storage class, as that is really irrelevant to the linkage. */ - remove_node((yyvsp[0])); - (yyval) = (yyvsp[0]); - ;} - break; - - case 29: + remove_node(yyvsp[0]); + yyval = yyvsp[0]; + ; + break;} +case 28: #line 193 "scripts/genksyms/parse.y" - { is_extern = 1; (yyval) = (yyvsp[0]); ;} - break; - - case 30: +{ is_extern = 1; yyval = yyvsp[0]; ; + break;} +case 29: #line 194 "scripts/genksyms/parse.y" - { is_extern = 0; (yyval) = (yyvsp[0]); ;} - break; - - case 35: -#line 206 "scripts/genksyms/parse.y" - { remove_node((yyvsp[-1])); (*(yyvsp[0]))->tag = SYM_STRUCT; (yyval) = (yyvsp[0]); ;} - break; - - case 36: -#line 208 "scripts/genksyms/parse.y" - { remove_node((yyvsp[-1])); (*(yyvsp[0]))->tag = SYM_UNION; (yyval) = (yyvsp[0]); ;} - break; - - case 37: -#line 210 "scripts/genksyms/parse.y" - { remove_node((yyvsp[-1])); (*(yyvsp[0]))->tag = SYM_ENUM; (yyval) = (yyvsp[0]); ;} - break; - - case 38: -#line 214 "scripts/genksyms/parse.y" - { struct string_list *s = *(yyvsp[0]), *i = *(yyvsp[-1]), *r; +{ is_extern = 0; yyval = yyvsp[0]; ; + break;} +case 33: +#line 205 "scripts/genksyms/parse.y" +{ remove_node(yyvsp[-1]); (*yyvsp[0])->tag = SYM_STRUCT; yyval = yyvsp[0]; ; + break;} +case 34: +#line 207 "scripts/genksyms/parse.y" +{ remove_node(yyvsp[-1]); (*yyvsp[0])->tag = SYM_UNION; yyval = yyvsp[0]; ; + break;} +case 35: +#line 209 "scripts/genksyms/parse.y" +{ remove_node(yyvsp[-1]); (*yyvsp[0])->tag = SYM_ENUM; yyval = yyvsp[0]; ; + break;} +case 36: +#line 213 "scripts/genksyms/parse.y" +{ struct string_list *s = *yyvsp[0], *i = *yyvsp[-1], *r; r = copy_node(i); r->tag = SYM_STRUCT; - r->next = (*(yyvsp[-2]))->next; *(yyvsp[0]) = r; (*(yyvsp[-2]))->next = NULL; + r->next = (*yyvsp[-2])->next; *yyvsp[0] = r; (*yyvsp[-2])->next = NULL; add_symbol(i->string, SYM_STRUCT, s, is_extern); - (yyval) = (yyvsp[0]); - ;} - break; - - case 39: -#line 221 "scripts/genksyms/parse.y" - { struct string_list *s = *(yyvsp[0]), *i = *(yyvsp[-1]), *r; + yyval = yyvsp[0]; + ; + break;} +case 37: +#line 220 "scripts/genksyms/parse.y" +{ struct string_list *s = *yyvsp[0], *i = *yyvsp[-1], *r; r = copy_node(i); r->tag = SYM_UNION; - r->next = (*(yyvsp[-2]))->next; *(yyvsp[0]) = r; (*(yyvsp[-2]))->next = NULL; + r->next = (*yyvsp[-2])->next; *yyvsp[0] = r; (*yyvsp[-2])->next = NULL; add_symbol(i->string, SYM_UNION, s, is_extern); - (yyval) = (yyvsp[0]); - ;} - break; - - case 40: -#line 228 "scripts/genksyms/parse.y" - { struct string_list *s = *(yyvsp[0]), *i = *(yyvsp[-1]), *r; + yyval = yyvsp[0]; + ; + break;} +case 38: +#line 227 "scripts/genksyms/parse.y" +{ struct string_list *s = *yyvsp[0], *i = *yyvsp[-1], *r; r = copy_node(i); r->tag = SYM_ENUM; - r->next = (*(yyvsp[-2]))->next; *(yyvsp[0]) = r; (*(yyvsp[-2]))->next = NULL; + r->next = (*yyvsp[-2])->next; *yyvsp[0] = r; (*yyvsp[-2])->next = NULL; add_symbol(i->string, SYM_ENUM, s, is_extern); - (yyval) = (yyvsp[0]); - ;} - break; - - case 41: + yyval = yyvsp[0]; + ; + break;} +case 39: +#line 235 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 40: #line 236 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 42: +{ yyval = yyvsp[0]; ; + break;} +case 41: #line 237 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 43: -#line 238 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 54: -#line 252 "scripts/genksyms/parse.y" - { (*(yyvsp[0]))->tag = SYM_TYPEDEF; (yyval) = (yyvsp[0]); ;} - break; - - case 55: -#line 257 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); ;} - break; - - case 56: -#line 261 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 59: -#line 267 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 63: -#line 273 "scripts/genksyms/parse.y" - { /* restrict has no effect in prototypes so ignore it */ - remove_node((yyvsp[0])); - (yyval) = (yyvsp[0]); - ;} - break; - - case 64: -#line 280 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 66: -#line 286 "scripts/genksyms/parse.y" - { if (current_name != NULL) { +{ yyval = yyvsp[0]; ; + break;} +case 52: +#line 251 "scripts/genksyms/parse.y" +{ (*yyvsp[0])->tag = SYM_TYPEDEF; yyval = yyvsp[0]; ; + break;} +case 53: +#line 256 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ; + break;} +case 54: +#line 260 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 57: +#line 266 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 61: +#line 272 "scripts/genksyms/parse.y" +{ /* restrict has no effect in prototypes so ignore it */ + remove_node(yyvsp[0]); + yyval = yyvsp[0]; + ; + break;} +case 62: +#line 279 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 64: +#line 285 "scripts/genksyms/parse.y" +{ if (current_name != NULL) { error_with_pos("unexpected second declaration name"); YYERROR; } else { - current_name = (*(yyvsp[0]))->string; - (yyval) = (yyvsp[0]); + current_name = (*yyvsp[0])->string; + yyval = yyvsp[0]; } - ;} - break; - - case 67: -#line 295 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 68: -#line 297 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 69: -#line 299 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 70: -#line 301 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 71: -#line 303 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 72: -#line 309 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 76: -#line 317 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 77: -#line 319 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 78: -#line 321 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 79: -#line 323 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 80: -#line 325 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 81: -#line 329 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 83: -#line 331 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 84: -#line 335 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 87: -#line 342 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 88: -#line 347 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); ;} - break; - - case 89: -#line 352 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); ;} - break; - - case 91: -#line 357 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 92: -#line 359 "scripts/genksyms/parse.y" - { /* For version 2 checksums, we don't want to remember + ; + break;} +case 65: +#line 294 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 66: +#line 296 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 67: +#line 298 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 68: +#line 300 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 69: +#line 302 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 70: +#line 308 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 74: +#line 316 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 75: +#line 318 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 76: +#line 320 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 77: +#line 322 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 78: +#line 324 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 79: +#line 328 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 81: +#line 330 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 82: +#line 334 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 85: +#line 341 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 86: +#line 346 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ; + break;} +case 87: +#line 351 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ; + break;} +case 89: +#line 356 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 90: +#line 358 "scripts/genksyms/parse.y" +{ /* For version 2 checksums, we don't want to remember private parameter names. */ - remove_node((yyvsp[0])); - (yyval) = (yyvsp[0]); - ;} - break; - - case 93: -#line 367 "scripts/genksyms/parse.y" - { remove_node((yyvsp[0])); - (yyval) = (yyvsp[0]); - ;} - break; - - case 94: -#line 371 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 95: -#line 373 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 96: -#line 375 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 97: -#line 377 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 98: -#line 379 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 99: -#line 384 "scripts/genksyms/parse.y" - { struct string_list *decl = *(yyvsp[-1]); - *(yyvsp[-1]) = NULL; + remove_node(yyvsp[0]); + yyval = yyvsp[0]; + ; + break;} +case 91: +#line 366 "scripts/genksyms/parse.y" +{ remove_node(yyvsp[0]); + yyval = yyvsp[0]; + ; + break;} +case 92: +#line 370 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 93: +#line 372 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 94: +#line 374 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 95: +#line 376 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 96: +#line 378 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 97: +#line 383 "scripts/genksyms/parse.y" +{ struct string_list *decl = *yyvsp[-1]; + *yyvsp[-1] = NULL; add_symbol(current_name, SYM_NORMAL, decl, is_extern); - (yyval) = (yyvsp[0]); - ;} - break; - - case 100: -#line 392 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 102: -#line 399 "scripts/genksyms/parse.y" - { remove_list((yyvsp[0]), &(*(yyvsp[-1]))->next); (yyval) = (yyvsp[0]); ;} - break; - - case 103: + yyval = yyvsp[0]; + ; + break;} +case 98: +#line 391 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 100: +#line 398 "scripts/genksyms/parse.y" +{ remove_list(yyvsp[0], &(*yyvsp[-1])->next); yyval = yyvsp[0]; ; + break;} +case 101: +#line 402 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 102: #line 403 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 104: -#line 404 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 105: -#line 408 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 108: -#line 414 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 109: -#line 419 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 110: -#line 421 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 111: -#line 425 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 114: -#line 431 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 115: +{ yyval = yyvsp[0]; ; + break;} +case 103: +#line 407 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 106: +#line 413 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 107: +#line 418 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 108: +#line 420 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 109: +#line 424 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 112: +#line 430 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 113: +#line 434 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0] ? yyvsp[0] : yyvsp[-1]; ; + break;} +case 114: #line 435 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]) ? (yyvsp[0]) : (yyvsp[-1]); ;} - break; - - case 116: -#line 436 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 118: -#line 441 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 119: -#line 445 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 121: -#line 450 "scripts/genksyms/parse.y" - { (yyval) = (yyvsp[0]); ;} - break; - - case 122: -#line 454 "scripts/genksyms/parse.y" - { (yyval) = NULL; ;} - break; - - case 124: -#line 460 "scripts/genksyms/parse.y" - { export_symbol((*(yyvsp[-2]))->string); (yyval) = (yyvsp[0]); ;} - break; - - - } - -/* Line 1037 of yacc.c. */ -#line 1816 "scripts/genksyms/parse.c" +{ yyval = yyvsp[0]; ; + break;} +case 116: +#line 440 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 117: +#line 444 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 119: +#line 449 "scripts/genksyms/parse.y" +{ yyval = yyvsp[0]; ; + break;} +case 120: +#line 453 "scripts/genksyms/parse.y" +{ yyval = NULL; ; + break;} +case 122: +#line 459 "scripts/genksyms/parse.y" +{ export_symbol((*yyvsp[-2])->string); yyval = yyvsp[0]; ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/lib/bison.simple" yyvsp -= yylen; yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif - - YY_STACK_PRINT (yyss, yyssp); +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif *++yyvsp = yyval; +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ yyn = yyr1[yyn]; - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else - yystate = yydefgoto[yyn - YYNTOKENS]; + yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; +yyerrlab: /* here on detecting error */ -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ { ++yynerrs; -#if YYERROR_VERBOSE + +#ifdef YYERROR_VERBOSE yyn = yypact[yystate]; - if (YYPACT_NINF < yyn && yyn < YYLAST) + if (yyn > YYFLAG && yyn < YYLAST) { - YYSIZE_T yysize = 0; - int yytype = YYTRANSLATE (yychar); - const char* yyprefix; - char *yymsg; - int yyx; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 0; - - yyprefix = ", expecting "; - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); - yycount += 1; - if (yycount == 5) - { - yysize = 0; - break; - } - } - yysize += (sizeof ("syntax error, unexpected ") - + yystrlen (yytname[yytype])); - yymsg = (char *) YYSTACK_ALLOC (yysize); - if (yymsg != 0) + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) { - char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); - yyp = yystpcpy (yyp, yytname[yytype]); + strcpy(msg, "parse error"); - if (yycount < 5) + if (count < 5) { - yyprefix = ", expecting "; - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) { - yyp = yystpcpy (yyp, yyprefix); - yyp = yystpcpy (yyp, yytname[yyx]); - yyprefix = " or "; + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; } } - yyerror (yymsg); - YYSTACK_FREE (yymsg); + yyerror(msg); + free(msg); } else - yyerror ("syntax error; also virtual memory exhausted"); + yyerror ("parse error; also virtual memory exceeded"); } else #endif /* YYERROR_VERBOSE */ - yyerror ("syntax error"); + yyerror("parse error"); } - + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ if (yyerrstatus == 3) { - /* If just tried and failed to reuse look-ahead token after an - error, discard it. */ - - if (yychar <= YYEOF) - { - /* If at end of input, pop the error token, - then the rest of the stack, then return failure. */ - if (yychar == YYEOF) - for (;;) - { - - YYPOPSTACK; - if (yyssp == yyss) - YYABORT; - yydestruct ("Error: popping", - yystos[*yyssp], yyvsp); - } - } - else - { - yydestruct ("Error: discarding", yytoken, &yylval); - yychar = YYEMPTY; - } + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; } - /* Else will try to reuse look-ahead token after shifting the error - token. */ - goto yyerrlab1; + /* Else will try to reuse lookahead token + after shifting the error token. */ + yyerrstatus = 3; /* Each real token shifted decrements this */ -/*---------------------------------------------------. -| yyerrorlab -- error raised explicitly by YYERROR. | -`---------------------------------------------------*/ -yyerrorlab: + goto yyerrhandle; -#ifdef __GNUC__ - /* Pacify GCC when the user code never invokes YYERROR and the label - yyerrorlab therefore never appears in user code. */ - if (0) - goto yyerrorlab; -#endif +yyerrdefault: /* current state does not do anything special for the error token. */ -yyvsp -= yylen; - yyssp -= yylen; - yystate = *yyssp; - goto yyerrlab1; +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif +yyerrpop: /* pop the current state because it cannot handle the error token */ -/*-------------------------------------------------------------. -| yyerrlab1 -- common code for both syntax error and YYERROR. | -`-------------------------------------------------------------*/ -yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif - for (;;) +#if YYDEBUG != 0 + if (yydebug) { - yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) - { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; +yyerrhandle: + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; - yydestruct ("Error: popping", yystos[yystate], yyvsp); - YYPOPSTACK; - yystate = *yyssp; - YY_STACK_PRINT (yyss, yyssp); + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; } + else if (yyn == 0) + goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; - *++yyvsp = yylval; - +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif - /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif yystate = yyn; goto yynewstate; - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yydestruct ("Error: discarding lookahead", - yytoken, &yylval); - yychar = YYEMPTY; - yyresult = 1; - goto yyreturn; - -#ifndef yyoverflow -/*----------------------------------------------. -| yyoverflowlab -- parser overflow comes here. | -`----------------------------------------------*/ -yyoverflowlab: - yyerror ("parser stack overflow"); - yyresult = 2; - /* Fall through. */ + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); #endif + } + return 0; -yyreturn: -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); #endif - return yyresult; + } + return 1; } - - -#line 464 "scripts/genksyms/parse.y" +#line 463 "scripts/genksyms/parse.y" static void @@ -2048,4 +1575,3 @@ yyerror(const char *e) { error_with_pos("%s", e); } - diff --git a/trunk/scripts/genksyms/parse.h_shipped b/trunk/scripts/genksyms/parse.h_shipped index f3fb2bb058e1..d5b27e3b20c4 100644 --- a/trunk/scripts/genksyms/parse.h_shipped +++ b/trunk/scripts/genksyms/parse.h_shipped @@ -1,128 +1,46 @@ -/* A Bison parser, made by GNU Bison 2.0. */ - -/* Skeleton parser for Yacc-like parsing with Bison, - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - ASM_KEYW = 258, - ATTRIBUTE_KEYW = 259, - AUTO_KEYW = 260, - BOOL_KEYW = 261, - CHAR_KEYW = 262, - CONST_KEYW = 263, - DOUBLE_KEYW = 264, - ENUM_KEYW = 265, - EXTERN_KEYW = 266, - FLOAT_KEYW = 267, - INLINE_KEYW = 268, - INT_KEYW = 269, - LONG_KEYW = 270, - REGISTER_KEYW = 271, - RESTRICT_KEYW = 272, - SHORT_KEYW = 273, - SIGNED_KEYW = 274, - STATIC_KEYW = 275, - STRUCT_KEYW = 276, - TYPEDEF_KEYW = 277, - UNION_KEYW = 278, - UNSIGNED_KEYW = 279, - VOID_KEYW = 280, - VOLATILE_KEYW = 281, - TYPEOF_KEYW = 282, - EXPORT_SYMBOL_KEYW = 283, - ASM_PHRASE = 284, - ATTRIBUTE_PHRASE = 285, - BRACE_PHRASE = 286, - BRACKET_PHRASE = 287, - EXPRESSION_PHRASE = 288, - CHAR = 289, - DOTS = 290, - IDENT = 291, - INT = 292, - REAL = 293, - STRING = 294, - TYPE = 295, - OTHER = 296, - FILENAME = 297 - }; +#ifndef YYSTYPE +#define YYSTYPE int #endif -#define ASM_KEYW 258 -#define ATTRIBUTE_KEYW 259 -#define AUTO_KEYW 260 -#define BOOL_KEYW 261 -#define CHAR_KEYW 262 -#define CONST_KEYW 263 -#define DOUBLE_KEYW 264 -#define ENUM_KEYW 265 -#define EXTERN_KEYW 266 -#define FLOAT_KEYW 267 -#define INLINE_KEYW 268 -#define INT_KEYW 269 -#define LONG_KEYW 270 -#define REGISTER_KEYW 271 -#define RESTRICT_KEYW 272 -#define SHORT_KEYW 273 -#define SIGNED_KEYW 274 -#define STATIC_KEYW 275 -#define STRUCT_KEYW 276 -#define TYPEDEF_KEYW 277 -#define UNION_KEYW 278 -#define UNSIGNED_KEYW 279 -#define VOID_KEYW 280 -#define VOLATILE_KEYW 281 -#define TYPEOF_KEYW 282 -#define EXPORT_SYMBOL_KEYW 283 -#define ASM_PHRASE 284 -#define ATTRIBUTE_PHRASE 285 -#define BRACE_PHRASE 286 -#define BRACKET_PHRASE 287 -#define EXPRESSION_PHRASE 288 -#define CHAR 289 -#define DOTS 290 -#define IDENT 291 -#define INT 292 -#define REAL 293 -#define STRING 294 -#define TYPE 295 -#define OTHER 296 -#define FILENAME 297 - +#define ASM_KEYW 257 +#define ATTRIBUTE_KEYW 258 +#define AUTO_KEYW 259 +#define BOOL_KEYW 260 +#define CHAR_KEYW 261 +#define CONST_KEYW 262 +#define DOUBLE_KEYW 263 +#define ENUM_KEYW 264 +#define EXTERN_KEYW 265 +#define FLOAT_KEYW 266 +#define INLINE_KEYW 267 +#define INT_KEYW 268 +#define LONG_KEYW 269 +#define REGISTER_KEYW 270 +#define RESTRICT_KEYW 271 +#define SHORT_KEYW 272 +#define SIGNED_KEYW 273 +#define STATIC_KEYW 274 +#define STRUCT_KEYW 275 +#define TYPEDEF_KEYW 276 +#define UNION_KEYW 277 +#define UNSIGNED_KEYW 278 +#define VOID_KEYW 279 +#define VOLATILE_KEYW 280 +#define TYPEOF_KEYW 281 +#define EXPORT_SYMBOL_KEYW 282 +#define ASM_PHRASE 283 +#define ATTRIBUTE_PHRASE 284 +#define BRACE_PHRASE 285 +#define BRACKET_PHRASE 286 +#define EXPRESSION_PHRASE 287 +#define CHAR 288 +#define DOTS 289 +#define IDENT 290 +#define INT 291 +#define REAL 292 +#define STRING 293 +#define TYPE 294 +#define OTHER 295 +#define FILENAME 296 - -#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) -typedef int YYSTYPE; -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 -#endif - extern YYSTYPE yylval; - - - diff --git a/trunk/scripts/genksyms/parse.y b/trunk/scripts/genksyms/parse.y index ca04c944b7c3..099043713db4 100644 --- a/trunk/scripts/genksyms/parse.y +++ b/trunk/scripts/genksyms/parse.y @@ -197,7 +197,6 @@ storage_class_specifier: type_specifier: simple_type_specifier | cvar_qualifier - | TYPEOF_KEYW '(' decl_specifier_seq '*' ')' | TYPEOF_KEYW '(' decl_specifier_seq ')' /* References to s/u/e's defined elsewhere. Rearrange things diff --git a/trunk/scripts/kconfig/.gitignore b/trunk/scripts/kconfig/.gitignore index e8ad1f6b3da4..2dac3442e0ac 100644 --- a/trunk/scripts/kconfig/.gitignore +++ b/trunk/scripts/kconfig/.gitignore @@ -5,7 +5,6 @@ config* lex.*.c *.tab.c *.tab.h -zconf.hash.c # # configuration programs diff --git a/trunk/scripts/kconfig/Makefile b/trunk/scripts/kconfig/Makefile index 3d7f1ac9e00c..a96153fc793f 100644 --- a/trunk/scripts/kconfig/Makefile +++ b/trunk/scripts/kconfig/Makefile @@ -11,7 +11,7 @@ gconfig: $(obj)/gconf $< arch/$(ARCH)/Kconfig menuconfig: $(obj)/mconf - $(Q)$(MAKE) $(build)=scripts/kconfig/lxdialog + $(Q)$(MAKE) $(build)=scripts/lxdialog $< arch/$(ARCH)/Kconfig config: $(obj)/conf @@ -115,7 +115,6 @@ endif clean-files := lkc_defs.h qconf.moc .tmp_qtcheck \ .tmp_gtkcheck zconf.tab.c lex.zconf.c zconf.hash.c -subdir- += lxdialog # Needed for systems without gettext KBUILD_HAVE_NLS := $(shell \ diff --git a/trunk/scripts/kconfig/lxdialog/.gitignore b/trunk/scripts/kconfig/lxdialog/.gitignore deleted file mode 100644 index 90b08ff025a6..000000000000 --- a/trunk/scripts/kconfig/lxdialog/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -# -# Generated files -# -lxdialog diff --git a/trunk/scripts/kconfig/lxdialog/checklist.c b/trunk/scripts/kconfig/lxdialog/checklist.c deleted file mode 100644 index db07ae73e051..000000000000 --- a/trunk/scripts/kconfig/lxdialog/checklist.c +++ /dev/null @@ -1,334 +0,0 @@ -/* - * checklist.c -- implements the checklist box - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * Stuart Herbert - S.Herbert@sheffield.ac.uk: radiolist extension - * Alessandro Rubini - rubini@ipvvis.unipv.it: merged the two - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include "dialog.h" - -static int list_width, check_x, item_x; - -/* - * Print list item - */ -static void print_item(WINDOW * win, const char *item, int status, int choice, - int selected) -{ - int i; - - /* Clear 'residue' of last item */ - wattrset(win, menubox_attr); - wmove(win, choice, 0); - for (i = 0; i < list_width; i++) - waddch(win, ' '); - - wmove(win, choice, check_x); - wattrset(win, selected ? check_selected_attr : check_attr); - wprintw(win, "(%c)", status ? 'X' : ' '); - - wattrset(win, selected ? tag_selected_attr : tag_attr); - mvwaddch(win, choice, item_x, item[0]); - wattrset(win, selected ? item_selected_attr : item_attr); - waddstr(win, (char *)item + 1); - if (selected) { - wmove(win, choice, check_x + 1); - wrefresh(win); - } -} - -/* - * Print the scroll indicators. - */ -static void print_arrows(WINDOW * win, int choice, int item_no, int scroll, - int y, int x, int height) -{ - wmove(win, y, x); - - if (scroll > 0) { - wattrset(win, uarrow_attr); - waddch(win, ACS_UARROW); - waddstr(win, "(-)"); - } else { - wattrset(win, menubox_attr); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - } - - y = y + height + 1; - wmove(win, y, x); - - if ((height < item_no) && (scroll + choice < item_no - 1)) { - wattrset(win, darrow_attr); - waddch(win, ACS_DARROW); - waddstr(win, "(+)"); - } else { - wattrset(win, menubox_border_attr); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - } -} - -/* - * Display the termination buttons - */ -static void print_buttons(WINDOW * dialog, int height, int width, int selected) -{ - int x = width / 2 - 11; - int y = height - 2; - - print_button(dialog, "Select", y, x, selected == 0); - print_button(dialog, " Help ", y, x + 14, selected == 1); - - wmove(dialog, y, x + 1 + 14 * selected); - wrefresh(dialog); -} - -/* - * Display a dialog box with a list of options that can be turned on or off - * in the style of radiolist (only one option turned on at a time). - */ -int dialog_checklist(const char *title, const char *prompt, int height, - int width, int list_height, int item_no, - const char *const *items) -{ - int i, x, y, box_x, box_y; - int key = 0, button = 0, choice = 0, scroll = 0, max_choice, *status; - WINDOW *dialog, *list; - - /* Allocate space for storing item on/off status */ - if ((status = malloc(sizeof(int) * item_no)) == NULL) { - endwin(); - fprintf(stderr, - "\nCan't allocate memory in dialog_checklist().\n"); - exit(-1); - } - - /* Initializes status */ - for (i = 0; i < item_no; i++) { - status[i] = !strcasecmp(items[i * 3 + 2], "on"); - if ((!choice && status[i]) - || !strcasecmp(items[i * 3 + 2], "selected")) - choice = i + 1; - } - if (choice) - choice--; - - max_choice = MIN(list_height, item_no); - - /* center dialog box on screen */ - x = (COLS - width) / 2; - y = (LINES - height) / 2; - - draw_shadow(stdscr, y, x, height, width); - - dialog = newwin(height, width, y, x); - keypad(dialog, TRUE); - - draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr); - wattrset(dialog, border_attr); - mvwaddch(dialog, height - 3, 0, ACS_LTEE); - for (i = 0; i < width - 2; i++) - waddch(dialog, ACS_HLINE); - wattrset(dialog, dialog_attr); - waddch(dialog, ACS_RTEE); - - print_title(dialog, title, width); - - wattrset(dialog, dialog_attr); - print_autowrap(dialog, prompt, width - 2, 1, 3); - - list_width = width - 6; - box_y = height - list_height - 5; - box_x = (width - list_width) / 2 - 1; - - /* create new window for the list */ - list = subwin(dialog, list_height, list_width, y + box_y + 1, - x + box_x + 1); - - keypad(list, TRUE); - - /* draw a box around the list items */ - draw_box(dialog, box_y, box_x, list_height + 2, list_width + 2, - menubox_border_attr, menubox_attr); - - /* Find length of longest item in order to center checklist */ - check_x = 0; - for (i = 0; i < item_no; i++) - check_x = MAX(check_x, +strlen(items[i * 3 + 1]) + 4); - - check_x = (list_width - check_x) / 2; - item_x = check_x + 4; - - if (choice >= list_height) { - scroll = choice - list_height + 1; - choice -= scroll; - } - - /* Print the list */ - for (i = 0; i < max_choice; i++) { - print_item(list, items[(scroll + i) * 3 + 1], - status[i + scroll], i, i == choice); - } - - print_arrows(dialog, choice, item_no, scroll, - box_y, box_x + check_x + 5, list_height); - - print_buttons(dialog, height, width, 0); - - wnoutrefresh(list); - wnoutrefresh(dialog); - doupdate(); - - while (key != ESC) { - key = wgetch(dialog); - - for (i = 0; i < max_choice; i++) - if (toupper(key) == - toupper(items[(scroll + i) * 3 + 1][0])) - break; - - if (i < max_choice || key == KEY_UP || key == KEY_DOWN || - key == '+' || key == '-') { - if (key == KEY_UP || key == '-') { - if (!choice) { - if (!scroll) - continue; - /* Scroll list down */ - if (list_height > 1) { - /* De-highlight current first item */ - print_item(list, items[scroll * 3 + 1], - status[scroll], 0, FALSE); - scrollok(list, TRUE); - wscrl(list, -1); - scrollok(list, FALSE); - } - scroll--; - print_item(list, items[scroll * 3 + 1], status[scroll], 0, TRUE); - wnoutrefresh(list); - - print_arrows(dialog, choice, item_no, - scroll, box_y, box_x + check_x + 5, list_height); - - wrefresh(dialog); - - continue; /* wait for another key press */ - } else - i = choice - 1; - } else if (key == KEY_DOWN || key == '+') { - if (choice == max_choice - 1) { - if (scroll + choice >= item_no - 1) - continue; - /* Scroll list up */ - if (list_height > 1) { - /* De-highlight current last item before scrolling up */ - print_item(list, items[(scroll + max_choice - 1) * 3 + 1], - status[scroll + max_choice - 1], - max_choice - 1, FALSE); - scrollok(list, TRUE); - wscrl(list, 1); - scrollok(list, FALSE); - } - scroll++; - print_item(list, items[(scroll + max_choice - 1) * 3 + 1], - status[scroll + max_choice - 1], max_choice - 1, TRUE); - wnoutrefresh(list); - - print_arrows(dialog, choice, item_no, - scroll, box_y, box_x + check_x + 5, list_height); - - wrefresh(dialog); - - continue; /* wait for another key press */ - } else - i = choice + 1; - } - if (i != choice) { - /* De-highlight current item */ - print_item(list, items[(scroll + choice) * 3 + 1], - status[scroll + choice], choice, FALSE); - /* Highlight new item */ - choice = i; - print_item(list, items[(scroll + choice) * 3 + 1], - status[scroll + choice], choice, TRUE); - wnoutrefresh(list); - wrefresh(dialog); - } - continue; /* wait for another key press */ - } - switch (key) { - case 'H': - case 'h': - case '?': - fprintf(stderr, "%s", items[(scroll + choice) * 3]); - delwin(dialog); - free(status); - return 1; - case TAB: - case KEY_LEFT: - case KEY_RIGHT: - button = ((key == KEY_LEFT ? --button : ++button) < 0) - ? 1 : (button > 1 ? 0 : button); - - print_buttons(dialog, height, width, button); - wrefresh(dialog); - break; - case 'S': - case 's': - case ' ': - case '\n': - if (!button) { - if (!status[scroll + choice]) { - for (i = 0; i < item_no; i++) - status[i] = 0; - status[scroll + choice] = 1; - for (i = 0; i < max_choice; i++) - print_item(list, items[(scroll + i) * 3 + 1], - status[scroll + i], i, i == choice); - } - wnoutrefresh(list); - wrefresh(dialog); - - for (i = 0; i < item_no; i++) - if (status[i]) - fprintf(stderr, "%s", items[i * 3]); - } else - fprintf(stderr, "%s", items[(scroll + choice) * 3]); - delwin(dialog); - free(status); - return button; - case 'X': - case 'x': - key = ESC; - case ESC: - break; - } - - /* Now, update everything... */ - doupdate(); - } - - delwin(dialog); - free(status); - return -1; /* ESC pressed */ -} diff --git a/trunk/scripts/kconfig/lxdialog/inputbox.c b/trunk/scripts/kconfig/lxdialog/inputbox.c deleted file mode 100644 index 779503726b0a..000000000000 --- a/trunk/scripts/kconfig/lxdialog/inputbox.c +++ /dev/null @@ -1,224 +0,0 @@ -/* - * inputbox.c -- implements the input box - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include "dialog.h" - -char dialog_input_result[MAX_LEN + 1]; - -/* - * Print the termination buttons - */ -static void print_buttons(WINDOW * dialog, int height, int width, int selected) -{ - int x = width / 2 - 11; - int y = height - 2; - - print_button(dialog, " Ok ", y, x, selected == 0); - print_button(dialog, " Help ", y, x + 14, selected == 1); - - wmove(dialog, y, x + 1 + 14 * selected); - wrefresh(dialog); -} - -/* - * Display a dialog box for inputing a string - */ -int dialog_inputbox(const char *title, const char *prompt, int height, int width, - const char *init) -{ - int i, x, y, box_y, box_x, box_width; - int input_x = 0, scroll = 0, key = 0, button = -1; - char *instr = dialog_input_result; - WINDOW *dialog; - - /* center dialog box on screen */ - x = (COLS - width) / 2; - y = (LINES - height) / 2; - - draw_shadow(stdscr, y, x, height, width); - - dialog = newwin(height, width, y, x); - keypad(dialog, TRUE); - - draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr); - wattrset(dialog, border_attr); - mvwaddch(dialog, height - 3, 0, ACS_LTEE); - for (i = 0; i < width - 2; i++) - waddch(dialog, ACS_HLINE); - wattrset(dialog, dialog_attr); - waddch(dialog, ACS_RTEE); - - print_title(dialog, title, width); - - wattrset(dialog, dialog_attr); - print_autowrap(dialog, prompt, width - 2, 1, 3); - - /* Draw the input field box */ - box_width = width - 6; - getyx(dialog, y, x); - box_y = y + 2; - box_x = (width - box_width) / 2; - draw_box(dialog, y + 1, box_x - 1, 3, box_width + 2, border_attr, dialog_attr); - - print_buttons(dialog, height, width, 0); - - /* Set up the initial value */ - wmove(dialog, box_y, box_x); - wattrset(dialog, inputbox_attr); - - if (!init) - instr[0] = '\0'; - else - strcpy(instr, init); - - input_x = strlen(instr); - - if (input_x >= box_width) { - scroll = input_x - box_width + 1; - input_x = box_width - 1; - for (i = 0; i < box_width - 1; i++) - waddch(dialog, instr[scroll + i]); - } else { - waddstr(dialog, instr); - } - - wmove(dialog, box_y, box_x + input_x); - - wrefresh(dialog); - - while (key != ESC) { - key = wgetch(dialog); - - if (button == -1) { /* Input box selected */ - switch (key) { - case TAB: - case KEY_UP: - case KEY_DOWN: - break; - case KEY_LEFT: - continue; - case KEY_RIGHT: - continue; - case KEY_BACKSPACE: - case 127: - if (input_x || scroll) { - wattrset(dialog, inputbox_attr); - if (!input_x) { - scroll = scroll < box_width - 1 ? 0 : scroll - (box_width - 1); - wmove(dialog, box_y, box_x); - for (i = 0; i < box_width; i++) - waddch(dialog, - instr[scroll + input_x + i] ? - instr[scroll + input_x + i] : ' '); - input_x = strlen(instr) - scroll; - } else - input_x--; - instr[scroll + input_x] = '\0'; - mvwaddch(dialog, box_y, input_x + box_x, ' '); - wmove(dialog, box_y, input_x + box_x); - wrefresh(dialog); - } - continue; - default: - if (key < 0x100 && isprint(key)) { - if (scroll + input_x < MAX_LEN) { - wattrset(dialog, inputbox_attr); - instr[scroll + input_x] = key; - instr[scroll + input_x + 1] = '\0'; - if (input_x == box_width - 1) { - scroll++; - wmove(dialog, box_y, box_x); - for (i = 0; i < box_width - 1; i++) - waddch(dialog, instr [scroll + i]); - } else { - wmove(dialog, box_y, input_x++ + box_x); - waddch(dialog, key); - } - wrefresh(dialog); - } else - flash(); /* Alarm user about overflow */ - continue; - } - } - } - switch (key) { - case 'O': - case 'o': - delwin(dialog); - return 0; - case 'H': - case 'h': - delwin(dialog); - return 1; - case KEY_UP: - case KEY_LEFT: - switch (button) { - case -1: - button = 1; /* Indicates "Cancel" button is selected */ - print_buttons(dialog, height, width, 1); - break; - case 0: - button = -1; /* Indicates input box is selected */ - print_buttons(dialog, height, width, 0); - wmove(dialog, box_y, box_x + input_x); - wrefresh(dialog); - break; - case 1: - button = 0; /* Indicates "OK" button is selected */ - print_buttons(dialog, height, width, 0); - break; - } - break; - case TAB: - case KEY_DOWN: - case KEY_RIGHT: - switch (button) { - case -1: - button = 0; /* Indicates "OK" button is selected */ - print_buttons(dialog, height, width, 0); - break; - case 0: - button = 1; /* Indicates "Cancel" button is selected */ - print_buttons(dialog, height, width, 1); - break; - case 1: - button = -1; /* Indicates input box is selected */ - print_buttons(dialog, height, width, 0); - wmove(dialog, box_y, box_x + input_x); - wrefresh(dialog); - break; - } - break; - case ' ': - case '\n': - delwin(dialog); - return (button == -1 ? 0 : button); - case 'X': - case 'x': - key = ESC; - case ESC: - break; - } - } - - delwin(dialog); - return -1; /* ESC pressed */ -} diff --git a/trunk/scripts/kconfig/lxdialog/lxdialog.c b/trunk/scripts/kconfig/lxdialog/lxdialog.c deleted file mode 100644 index 79f6c5fb5cef..000000000000 --- a/trunk/scripts/kconfig/lxdialog/lxdialog.c +++ /dev/null @@ -1,204 +0,0 @@ -/* - * dialog - Display simple dialog boxes from shell scripts - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include "dialog.h" - -static void Usage(const char *name); - -typedef int (jumperFn) (const char *title, int argc, const char *const *argv); - -struct Mode { - char *name; - int argmin, argmax, argmod; - jumperFn *jumper; -}; - -jumperFn j_menu, j_radiolist, j_yesno, j_textbox, j_inputbox; -jumperFn j_msgbox, j_infobox; - -static struct Mode modes[] = { - {"--menu", 9, 0, 3, j_menu}, - {"--radiolist", 9, 0, 3, j_radiolist}, - {"--yesno", 5, 5, 1, j_yesno}, - {"--textbox", 5, 5, 1, j_textbox}, - {"--inputbox", 5, 6, 1, j_inputbox}, - {"--msgbox", 5, 5, 1, j_msgbox}, - {"--infobox", 5, 5, 1, j_infobox}, - {NULL, 0, 0, 0, NULL} -}; - -static struct Mode *modePtr; - -#ifdef LOCALE -#include -#endif - -int main(int argc, const char *const *argv) -{ - int offset = 0, opt_clear = 0, end_common_opts = 0, retval; - const char *title = NULL; - -#ifdef LOCALE - (void)setlocale(LC_ALL, ""); -#endif - -#ifdef TRACE - trace(TRACE_CALLS | TRACE_UPDATE); -#endif - if (argc < 2) { - Usage(argv[0]); - exit(-1); - } - - while (offset < argc - 1 && !end_common_opts) { /* Common options */ - if (!strcmp(argv[offset + 1], "--title")) { - if (argc - offset < 3 || title != NULL) { - Usage(argv[0]); - exit(-1); - } else { - title = argv[offset + 2]; - offset += 2; - } - } else if (!strcmp(argv[offset + 1], "--backtitle")) { - if (backtitle != NULL) { - Usage(argv[0]); - exit(-1); - } else { - backtitle = argv[offset + 2]; - offset += 2; - } - } else if (!strcmp(argv[offset + 1], "--clear")) { - if (opt_clear) { /* Hey, "--clear" can't appear twice! */ - Usage(argv[0]); - exit(-1); - } else if (argc == 2) { /* we only want to clear the screen */ - init_dialog(); - refresh(); /* init_dialog() will clear the screen for us */ - end_dialog(); - return 0; - } else { - opt_clear = 1; - offset++; - } - } else /* no more common options */ - end_common_opts = 1; - } - - if (argc - 1 == offset) { /* no more options */ - Usage(argv[0]); - exit(-1); - } - /* use a table to look for the requested mode, to avoid code duplication */ - - for (modePtr = modes; modePtr->name; modePtr++) /* look for the mode */ - if (!strcmp(argv[offset + 1], modePtr->name)) - break; - - if (!modePtr->name) - Usage(argv[0]); - if (argc - offset < modePtr->argmin) - Usage(argv[0]); - if (modePtr->argmax && argc - offset > modePtr->argmax) - Usage(argv[0]); - - init_dialog(); - retval = (*(modePtr->jumper)) (title, argc - offset, argv + offset); - - if (opt_clear) { /* clear screen before exit */ - attr_clear(stdscr, LINES, COLS, screen_attr); - refresh(); - } - end_dialog(); - - exit(retval); -} - -/* - * Print program usage - */ -static void Usage(const char *name) -{ - fprintf(stderr, "\ -\ndialog, by Savio Lam (lam836@cs.cuhk.hk).\ -\n patched by Stuart Herbert (S.Herbert@shef.ac.uk)\ -\n modified/gutted for use as a Linux kernel config tool by \ -\n William Roadcap (roadcapw@cfw.com)\ -\n\ -\n* Display dialog boxes from shell scripts *\ -\n\ -\nUsage: %s --clear\ -\n %s [--title ] [--backtitle <backtitle>] --clear <Box options>\ -\n\ -\nBox options:\ -\n\ -\n --menu <text> <height> <width> <menu height> <tag1> <item1>...\ -\n --radiolist <text> <height> <width> <list height> <tag1> <item1> <status1>...\ -\n --textbox <file> <height> <width>\ -\n --inputbox <text> <height> <width> [<init>]\ -\n --yesno <text> <height> <width>\ -\n", name, name); - exit(-1); -} - -/* - * These are the program jumpers - */ - -int j_menu(const char *t, int ac, const char *const *av) -{ - return dialog_menu(t, av[2], atoi(av[3]), atoi(av[4]), - atoi(av[5]), av[6], (ac - 6) / 2, av + 7); -} - -int j_radiolist(const char *t, int ac, const char *const *av) -{ - return dialog_checklist(t, av[2], atoi(av[3]), atoi(av[4]), - atoi(av[5]), (ac - 6) / 3, av + 6); -} - -int j_textbox(const char *t, int ac, const char *const *av) -{ - return dialog_textbox(t, av[2], atoi(av[3]), atoi(av[4])); -} - -int j_yesno(const char *t, int ac, const char *const *av) -{ - return dialog_yesno(t, av[2], atoi(av[3]), atoi(av[4])); -} - -int j_inputbox(const char *t, int ac, const char *const *av) -{ - int ret = dialog_inputbox(t, av[2], atoi(av[3]), atoi(av[4]), - ac == 6 ? av[5] : (char *)NULL); - if (ret == 0) - fprintf(stderr, dialog_input_result); - return ret; -} - -int j_msgbox(const char *t, int ac, const char *const *av) -{ - return dialog_msgbox(t, av[2], atoi(av[3]), atoi(av[4]), 1); -} - -int j_infobox(const char *t, int ac, const char *const *av) -{ - return dialog_msgbox(t, av[2], atoi(av[3]), atoi(av[4]), 0); -} diff --git a/trunk/scripts/kconfig/lxdialog/menubox.c b/trunk/scripts/kconfig/lxdialog/menubox.c deleted file mode 100644 index 09512b544375..000000000000 --- a/trunk/scripts/kconfig/lxdialog/menubox.c +++ /dev/null @@ -1,425 +0,0 @@ -/* - * menubox.c -- implements the menu box - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcapw@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -/* - * Changes by Clifford Wolf (god@clifford.at) - * - * [ 1998-06-13 ] - * - * *) A bugfix for the Page-Down problem - * - * *) Formerly when I used Page Down and Page Up, the cursor would be set - * to the first position in the menu box. Now lxdialog is a bit - * smarter and works more like other menu systems (just have a look at - * it). - * - * *) Formerly if I selected something my scrolling would be broken because - * lxdialog is re-invoked by the Menuconfig shell script, can't - * remember the last scrolling position, and just sets it so that the - * cursor is at the bottom of the box. Now it writes the temporary file - * lxdialog.scrltmp which contains this information. The file is - * deleted by lxdialog if the user leaves a submenu or enters a new - * one, but it would be nice if Menuconfig could make another "rm -f" - * just to be sure. Just try it out - you will recognise a difference! - * - * [ 1998-06-14 ] - * - * *) Now lxdialog is crash-safe against broken "lxdialog.scrltmp" files - * and menus change their size on the fly. - * - * *) If for some reason the last scrolling position is not saved by - * lxdialog, it sets the scrolling so that the selected item is in the - * middle of the menu box, not at the bottom. - * - * 02 January 1999, Michael Elizabeth Chastain (mec@shout.net) - * Reset 'scroll' to 0 if the value from lxdialog.scrltmp is bogus. - * This fixes a bug in Menuconfig where using ' ' to descend into menus - * would leave mis-synchronized lxdialog.scrltmp files lying around, - * fscanf would read in 'scroll', and eventually that value would get used. - */ - -#include "dialog.h" - -#define ITEM_IDENT 1 /* Indent of menu entries. Fixed for all menus */ -static int menu_width; - -/* - * Print menu item - */ -static void do_print_item(WINDOW * win, const char *item, int choice, - int selected, int hotkey) -{ - int j; - char *menu_item = malloc(menu_width + 1); - - strncpy(menu_item, item, menu_width - ITEM_IDENT); - menu_item[menu_width] = 0; - j = first_alpha(menu_item, "YyNnMmHh"); - - /* Clear 'residue' of last item */ - wattrset(win, menubox_attr); - wmove(win, choice, 0); -#if OLD_NCURSES - { - int i; - for (i = 0; i < menu_width; i++) - waddch(win, ' '); - } -#else - wclrtoeol(win); -#endif - wattrset(win, selected ? item_selected_attr : item_attr); - mvwaddstr(win, choice, ITEM_IDENT, menu_item); - if (hotkey) { - wattrset(win, selected ? tag_key_selected_attr : tag_key_attr); - mvwaddch(win, choice, ITEM_IDENT + j, menu_item[j]); - } - if (selected) { - wmove(win, choice, ITEM_IDENT + 1); - } - free(menu_item); - wrefresh(win); -} - -#define print_item(index, choice, selected) \ -do {\ - int hotkey = (items[(index) * 2][0] != ':'); \ - do_print_item(menu, items[(index) * 2 + 1], choice, selected, hotkey); \ -} while (0) - -/* - * Print the scroll indicators. - */ -static void print_arrows(WINDOW * win, int item_no, int scroll, int y, int x, - int height) -{ - int cur_y, cur_x; - - getyx(win, cur_y, cur_x); - - wmove(win, y, x); - - if (scroll > 0) { - wattrset(win, uarrow_attr); - waddch(win, ACS_UARROW); - waddstr(win, "(-)"); - } else { - wattrset(win, menubox_attr); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - } - - y = y + height + 1; - wmove(win, y, x); - wrefresh(win); - - if ((height < item_no) && (scroll + height < item_no)) { - wattrset(win, darrow_attr); - waddch(win, ACS_DARROW); - waddstr(win, "(+)"); - } else { - wattrset(win, menubox_border_attr); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - waddch(win, ACS_HLINE); - } - - wmove(win, cur_y, cur_x); - wrefresh(win); -} - -/* - * Display the termination buttons. - */ -static void print_buttons(WINDOW * win, int height, int width, int selected) -{ - int x = width / 2 - 16; - int y = height - 2; - - print_button(win, "Select", y, x, selected == 0); - print_button(win, " Exit ", y, x + 12, selected == 1); - print_button(win, " Help ", y, x + 24, selected == 2); - - wmove(win, y, x + 1 + 12 * selected); - wrefresh(win); -} - -/* scroll up n lines (n may be negative) */ -static void do_scroll(WINDOW *win, int *scroll, int n) -{ - /* Scroll menu up */ - scrollok(win, TRUE); - wscrl(win, n); - scrollok(win, FALSE); - *scroll = *scroll + n; - wrefresh(win); -} - -/* - * Display a menu for choosing among a number of options - */ -int dialog_menu(const char *title, const char *prompt, int height, int width, - int menu_height, const char *current, int item_no, - const char *const *items) -{ - int i, j, x, y, box_x, box_y; - int key = 0, button = 0, scroll = 0, choice = 0; - int first_item = 0, max_choice; - WINDOW *dialog, *menu; - FILE *f; - - max_choice = MIN(menu_height, item_no); - - /* center dialog box on screen */ - x = (COLS - width) / 2; - y = (LINES - height) / 2; - - draw_shadow(stdscr, y, x, height, width); - - dialog = newwin(height, width, y, x); - keypad(dialog, TRUE); - - draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr); - wattrset(dialog, border_attr); - mvwaddch(dialog, height - 3, 0, ACS_LTEE); - for (i = 0; i < width - 2; i++) - waddch(dialog, ACS_HLINE); - wattrset(dialog, dialog_attr); - wbkgdset(dialog, dialog_attr & A_COLOR); - waddch(dialog, ACS_RTEE); - - print_title(dialog, title, width); - - wattrset(dialog, dialog_attr); - print_autowrap(dialog, prompt, width - 2, 1, 3); - - menu_width = width - 6; - box_y = height - menu_height - 5; - box_x = (width - menu_width) / 2 - 1; - - /* create new window for the menu */ - menu = subwin(dialog, menu_height, menu_width, - y + box_y + 1, x + box_x + 1); - keypad(menu, TRUE); - - /* draw a box around the menu items */ - draw_box(dialog, box_y, box_x, menu_height + 2, menu_width + 2, - menubox_border_attr, menubox_attr); - - /* Set choice to default item */ - for (i = 0; i < item_no; i++) - if (strcmp(current, items[i * 2]) == 0) - choice = i; - - /* get the scroll info from the temp file */ - if ((f = fopen("lxdialog.scrltmp", "r")) != NULL) { - if ((fscanf(f, "%d\n", &scroll) == 1) && (scroll <= choice) && - (scroll + max_choice > choice) && (scroll >= 0) && - (scroll + max_choice <= item_no)) { - first_item = scroll; - choice = choice - scroll; - fclose(f); - } else { - scroll = 0; - remove("lxdialog.scrltmp"); - fclose(f); - f = NULL; - } - } - if ((choice >= max_choice) || (f == NULL && choice >= max_choice / 2)) { - if (choice >= item_no - max_choice / 2) - scroll = first_item = item_no - max_choice; - else - scroll = first_item = choice - max_choice / 2; - choice = choice - scroll; - } - - /* Print the menu */ - for (i = 0; i < max_choice; i++) { - print_item(first_item + i, i, i == choice); - } - - wnoutrefresh(menu); - - print_arrows(dialog, item_no, scroll, - box_y, box_x + ITEM_IDENT + 1, menu_height); - - print_buttons(dialog, height, width, 0); - wmove(menu, choice, ITEM_IDENT + 1); - wrefresh(menu); - - while (key != ESC) { - key = wgetch(menu); - - if (key < 256 && isalpha(key)) - key = tolower(key); - - if (strchr("ynmh", key)) - i = max_choice; - else { - for (i = choice + 1; i < max_choice; i++) { - j = first_alpha(items[(scroll + i) * 2 + 1], "YyNnMmHh"); - if (key == tolower(items[(scroll + i) * 2 + 1][j])) - break; - } - if (i == max_choice) - for (i = 0; i < max_choice; i++) { - j = first_alpha(items [(scroll + i) * 2 + 1], "YyNnMmHh"); - if (key == tolower(items[(scroll + i) * 2 + 1][j])) - break; - } - } - - if (i < max_choice || - key == KEY_UP || key == KEY_DOWN || - key == '-' || key == '+' || - key == KEY_PPAGE || key == KEY_NPAGE) { - /* Remove highligt of current item */ - print_item(scroll + choice, choice, FALSE); - - if (key == KEY_UP || key == '-') { - if (choice < 2 && scroll) { - /* Scroll menu down */ - do_scroll(menu, &scroll, -1); - - print_item(scroll, 0, FALSE); - } else - choice = MAX(choice - 1, 0); - - } else if (key == KEY_DOWN || key == '+') { - print_item(scroll+choice, choice, FALSE); - - if ((choice > max_choice - 3) && - (scroll + max_choice < item_no)) { - /* Scroll menu up */ - do_scroll(menu, &scroll, 1); - - print_item(scroll+max_choice - 1, - max_choice - 1, FALSE); - } else - choice = MIN(choice + 1, max_choice - 1); - - } else if (key == KEY_PPAGE) { - scrollok(menu, TRUE); - for (i = 0; (i < max_choice); i++) { - if (scroll > 0) { - do_scroll(menu, &scroll, -1); - print_item(scroll, 0, FALSE); - } else { - if (choice > 0) - choice--; - } - } - - } else if (key == KEY_NPAGE) { - for (i = 0; (i < max_choice); i++) { - if (scroll + max_choice < item_no) { - do_scroll(menu, &scroll, 1); - print_item(scroll+max_choice-1, - max_choice - 1, FALSE); - } else { - if (choice + 1 < max_choice) - choice++; - } - } - } else - choice = i; - - print_item(scroll + choice, choice, TRUE); - - print_arrows(dialog, item_no, scroll, - box_y, box_x + ITEM_IDENT + 1, menu_height); - - wnoutrefresh(dialog); - wrefresh(menu); - - continue; /* wait for another key press */ - } - - switch (key) { - case KEY_LEFT: - case TAB: - case KEY_RIGHT: - button = ((key == KEY_LEFT ? --button : ++button) < 0) - ? 2 : (button > 2 ? 0 : button); - - print_buttons(dialog, height, width, button); - wrefresh(menu); - break; - case ' ': - case 's': - case 'y': - case 'n': - case 'm': - case '/': - /* save scroll info */ - if ((f = fopen("lxdialog.scrltmp", "w")) != NULL) { - fprintf(f, "%d\n", scroll); - fclose(f); - } - delwin(dialog); - fprintf(stderr, "%s\n", items[(scroll + choice) * 2]); - switch (key) { - case 's': - return 3; - case 'y': - return 3; - case 'n': - return 4; - case 'm': - return 5; - case ' ': - return 6; - case '/': - return 7; - } - return 0; - case 'h': - case '?': - button = 2; - case '\n': - delwin(dialog); - if (button == 2) - fprintf(stderr, "%s \"%s\"\n", - items[(scroll + choice) * 2], - items[(scroll + choice) * 2 + 1] + - first_alpha(items [(scroll + choice) * 2 + 1], "")); - else - fprintf(stderr, "%s\n", - items[(scroll + choice) * 2]); - - remove("lxdialog.scrltmp"); - return button; - case 'e': - case 'x': - key = ESC; - case ESC: - break; - } - } - - delwin(dialog); - remove("lxdialog.scrltmp"); - return -1; /* ESC pressed */ -} diff --git a/trunk/scripts/kconfig/lxdialog/msgbox.c b/trunk/scripts/kconfig/lxdialog/msgbox.c deleted file mode 100644 index 7323f5471f69..000000000000 --- a/trunk/scripts/kconfig/lxdialog/msgbox.c +++ /dev/null @@ -1,71 +0,0 @@ -/* - * msgbox.c -- implements the message box and info box - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcapw@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include "dialog.h" - -/* - * Display a message box. Program will pause and display an "OK" button - * if the parameter 'pause' is non-zero. - */ -int dialog_msgbox(const char *title, const char *prompt, int height, int width, - int pause) -{ - int i, x, y, key = 0; - WINDOW *dialog; - - /* center dialog box on screen */ - x = (COLS - width) / 2; - y = (LINES - height) / 2; - - draw_shadow(stdscr, y, x, height, width); - - dialog = newwin(height, width, y, x); - keypad(dialog, TRUE); - - draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr); - - print_title(dialog, title, width); - - wattrset(dialog, dialog_attr); - print_autowrap(dialog, prompt, width - 2, 1, 2); - - if (pause) { - wattrset(dialog, border_attr); - mvwaddch(dialog, height - 3, 0, ACS_LTEE); - for (i = 0; i < width - 2; i++) - waddch(dialog, ACS_HLINE); - wattrset(dialog, dialog_attr); - waddch(dialog, ACS_RTEE); - - print_button(dialog, " Ok ", height - 2, width / 2 - 4, TRUE); - - wrefresh(dialog); - while (key != ESC && key != '\n' && key != ' ' && - key != 'O' && key != 'o' && key != 'X' && key != 'x') - key = wgetch(dialog); - } else { - key = '\n'; - wrefresh(dialog); - } - - delwin(dialog); - return key == ESC ? -1 : 0; -} diff --git a/trunk/scripts/kconfig/lxdialog/textbox.c b/trunk/scripts/kconfig/lxdialog/textbox.c deleted file mode 100644 index 77848bb8e07f..000000000000 --- a/trunk/scripts/kconfig/lxdialog/textbox.c +++ /dev/null @@ -1,533 +0,0 @@ -/* - * textbox.c -- implements the text box - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include "dialog.h" - -static void back_lines(int n); -static void print_page(WINDOW * win, int height, int width); -static void print_line(WINDOW * win, int row, int width); -static char *get_line(void); -static void print_position(WINDOW * win, int height, int width); - -static int hscroll, fd, file_size, bytes_read; -static int begin_reached = 1, end_reached, page_length; -static char *buf, *page; - -/* - * Display text from a file in a dialog box. - */ -int dialog_textbox(const char *title, const char *file, int height, int width) -{ - int i, x, y, cur_x, cur_y, fpos, key = 0; - int passed_end; - char search_term[MAX_LEN + 1]; - WINDOW *dialog, *text; - - search_term[0] = '\0'; /* no search term entered yet */ - - /* Open input file for reading */ - if ((fd = open(file, O_RDONLY)) == -1) { - endwin(); - fprintf(stderr, "\nCan't open input file in dialog_textbox().\n"); - exit(-1); - } - /* Get file size. Actually, 'file_size' is the real file size - 1, - since it's only the last byte offset from the beginning */ - if ((file_size = lseek(fd, 0, SEEK_END)) == -1) { - endwin(); - fprintf(stderr, "\nError getting file size in dialog_textbox().\n"); - exit(-1); - } - /* Restore file pointer to beginning of file after getting file size */ - if (lseek(fd, 0, SEEK_SET) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in dialog_textbox().\n"); - exit(-1); - } - /* Allocate space for read buffer */ - if ((buf = malloc(BUF_SIZE + 1)) == NULL) { - endwin(); - fprintf(stderr, "\nCan't allocate memory in dialog_textbox().\n"); - exit(-1); - } - if ((bytes_read = read(fd, buf, BUF_SIZE)) == -1) { - endwin(); - fprintf(stderr, "\nError reading file in dialog_textbox().\n"); - exit(-1); - } - buf[bytes_read] = '\0'; /* mark end of valid data */ - page = buf; /* page is pointer to start of page to be displayed */ - - /* center dialog box on screen */ - x = (COLS - width) / 2; - y = (LINES - height) / 2; - - draw_shadow(stdscr, y, x, height, width); - - dialog = newwin(height, width, y, x); - keypad(dialog, TRUE); - - /* Create window for text region, used for scrolling text */ - text = subwin(dialog, height - 4, width - 2, y + 1, x + 1); - wattrset(text, dialog_attr); - wbkgdset(text, dialog_attr & A_COLOR); - - keypad(text, TRUE); - - /* register the new window, along with its borders */ - draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr); - - wattrset(dialog, border_attr); - mvwaddch(dialog, height - 3, 0, ACS_LTEE); - for (i = 0; i < width - 2; i++) - waddch(dialog, ACS_HLINE); - wattrset(dialog, dialog_attr); - wbkgdset(dialog, dialog_attr & A_COLOR); - waddch(dialog, ACS_RTEE); - - print_title(dialog, title, width); - - print_button(dialog, " Exit ", height - 2, width / 2 - 4, TRUE); - wnoutrefresh(dialog); - getyx(dialog, cur_y, cur_x); /* Save cursor position */ - - /* Print first page of text */ - attr_clear(text, height - 4, width - 2, dialog_attr); - print_page(text, height - 4, width - 2); - print_position(dialog, height, width); - wmove(dialog, cur_y, cur_x); /* Restore cursor position */ - wrefresh(dialog); - - while ((key != ESC) && (key != '\n')) { - key = wgetch(dialog); - switch (key) { - case 'E': /* Exit */ - case 'e': - case 'X': - case 'x': - delwin(dialog); - free(buf); - close(fd); - return 0; - case 'g': /* First page */ - case KEY_HOME: - if (!begin_reached) { - begin_reached = 1; - /* First page not in buffer? */ - if ((fpos = lseek(fd, 0, SEEK_CUR)) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in dialog_textbox().\n"); - exit(-1); - } - if (fpos > bytes_read) { /* Yes, we have to read it in */ - if (lseek(fd, 0, SEEK_SET) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in " - "dialog_textbox().\n"); - exit(-1); - } - if ((bytes_read = - read(fd, buf, BUF_SIZE)) == -1) { - endwin(); - fprintf(stderr, "\nError reading file in dialog_textbox().\n"); - exit(-1); - } - buf[bytes_read] = '\0'; - } - page = buf; - print_page(text, height - 4, width - 2); - print_position(dialog, height, width); - wmove(dialog, cur_y, cur_x); /* Restore cursor position */ - wrefresh(dialog); - } - break; - case 'G': /* Last page */ - case KEY_END: - - end_reached = 1; - /* Last page not in buffer? */ - if ((fpos = lseek(fd, 0, SEEK_CUR)) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in dialog_textbox().\n"); - exit(-1); - } - if (fpos < file_size) { /* Yes, we have to read it in */ - if (lseek(fd, -BUF_SIZE, SEEK_END) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in dialog_textbox().\n"); - exit(-1); - } - if ((bytes_read = - read(fd, buf, BUF_SIZE)) == -1) { - endwin(); - fprintf(stderr, "\nError reading file in dialog_textbox().\n"); - exit(-1); - } - buf[bytes_read] = '\0'; - } - page = buf + bytes_read; - back_lines(height - 4); - print_page(text, height - 4, width - 2); - print_position(dialog, height, width); - wmove(dialog, cur_y, cur_x); /* Restore cursor position */ - wrefresh(dialog); - break; - case 'K': /* Previous line */ - case 'k': - case KEY_UP: - if (!begin_reached) { - back_lines(page_length + 1); - - /* We don't call print_page() here but use scrolling to ensure - faster screen update. However, 'end_reached' and - 'page_length' should still be updated, and 'page' should - point to start of next page. This is done by calling - get_line() in the following 'for' loop. */ - scrollok(text, TRUE); - wscrl(text, -1); /* Scroll text region down one line */ - scrollok(text, FALSE); - page_length = 0; - passed_end = 0; - for (i = 0; i < height - 4; i++) { - if (!i) { - /* print first line of page */ - print_line(text, 0, width - 2); - wnoutrefresh(text); - } else - /* Called to update 'end_reached' and 'page' */ - get_line(); - if (!passed_end) - page_length++; - if (end_reached && !passed_end) - passed_end = 1; - } - - print_position(dialog, height, width); - wmove(dialog, cur_y, cur_x); /* Restore cursor position */ - wrefresh(dialog); - } - break; - case 'B': /* Previous page */ - case 'b': - case KEY_PPAGE: - if (begin_reached) - break; - back_lines(page_length + height - 4); - print_page(text, height - 4, width - 2); - print_position(dialog, height, width); - wmove(dialog, cur_y, cur_x); - wrefresh(dialog); - break; - case 'J': /* Next line */ - case 'j': - case KEY_DOWN: - if (!end_reached) { - begin_reached = 0; - scrollok(text, TRUE); - scroll(text); /* Scroll text region up one line */ - scrollok(text, FALSE); - print_line(text, height - 5, width - 2); - wnoutrefresh(text); - print_position(dialog, height, width); - wmove(dialog, cur_y, cur_x); /* Restore cursor position */ - wrefresh(dialog); - } - break; - case KEY_NPAGE: /* Next page */ - case ' ': - if (end_reached) - break; - - begin_reached = 0; - print_page(text, height - 4, width - 2); - print_position(dialog, height, width); - wmove(dialog, cur_y, cur_x); - wrefresh(dialog); - break; - case '0': /* Beginning of line */ - case 'H': /* Scroll left */ - case 'h': - case KEY_LEFT: - if (hscroll <= 0) - break; - - if (key == '0') - hscroll = 0; - else - hscroll--; - /* Reprint current page to scroll horizontally */ - back_lines(page_length); - print_page(text, height - 4, width - 2); - wmove(dialog, cur_y, cur_x); - wrefresh(dialog); - break; - case 'L': /* Scroll right */ - case 'l': - case KEY_RIGHT: - if (hscroll >= MAX_LEN) - break; - hscroll++; - /* Reprint current page to scroll horizontally */ - back_lines(page_length); - print_page(text, height - 4, width - 2); - wmove(dialog, cur_y, cur_x); - wrefresh(dialog); - break; - case ESC: - break; - } - } - - delwin(dialog); - free(buf); - close(fd); - return -1; /* ESC pressed */ -} - -/* - * Go back 'n' lines in text file. Called by dialog_textbox(). - * 'page' will be updated to point to the desired line in 'buf'. - */ -static void back_lines(int n) -{ - int i, fpos; - - begin_reached = 0; - /* We have to distinguish between end_reached and !end_reached - since at end of file, the line is not ended by a '\n'. - The code inside 'if' basically does a '--page' to move one - character backward so as to skip '\n' of the previous line */ - if (!end_reached) { - /* Either beginning of buffer or beginning of file reached? */ - if (page == buf) { - if ((fpos = lseek(fd, 0, SEEK_CUR)) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in " - "back_lines().\n"); - exit(-1); - } - if (fpos > bytes_read) { /* Not beginning of file yet */ - /* We've reached beginning of buffer, but not beginning of - file yet, so read previous part of file into buffer. - Note that we only move backward for BUF_SIZE/2 bytes, - but not BUF_SIZE bytes to avoid re-reading again in - print_page() later */ - /* Really possible to move backward BUF_SIZE/2 bytes? */ - if (fpos < BUF_SIZE / 2 + bytes_read) { - /* No, move less then */ - if (lseek(fd, 0, SEEK_SET) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in " - "back_lines().\n"); - exit(-1); - } - page = buf + fpos - bytes_read; - } else { /* Move backward BUF_SIZE/2 bytes */ - if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), SEEK_CUR) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer " - "in back_lines().\n"); - exit(-1); - } - page = buf + BUF_SIZE / 2; - } - if ((bytes_read = - read(fd, buf, BUF_SIZE)) == -1) { - endwin(); - fprintf(stderr, "\nError reading file in back_lines().\n"); - exit(-1); - } - buf[bytes_read] = '\0'; - } else { /* Beginning of file reached */ - begin_reached = 1; - return; - } - } - if (*(--page) != '\n') { /* '--page' here */ - /* Something's wrong... */ - endwin(); - fprintf(stderr, "\nInternal error in back_lines().\n"); - exit(-1); - } - } - /* Go back 'n' lines */ - for (i = 0; i < n; i++) - do { - if (page == buf) { - if ((fpos = lseek(fd, 0, SEEK_CUR)) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in back_lines().\n"); - exit(-1); - } - if (fpos > bytes_read) { - /* Really possible to move backward BUF_SIZE/2 bytes? */ - if (fpos < BUF_SIZE / 2 + bytes_read) { - /* No, move less then */ - if (lseek(fd, 0, SEEK_SET) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer " - "in back_lines().\n"); - exit(-1); - } - page = buf + fpos - bytes_read; - } else { /* Move backward BUF_SIZE/2 bytes */ - if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), SEEK_CUR) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer" - " in back_lines().\n"); - exit(-1); - } - page = buf + BUF_SIZE / 2; - } - if ((bytes_read = - read(fd, buf, BUF_SIZE)) == -1) { - endwin(); - fprintf(stderr, "\nError reading file in " - "back_lines().\n"); - exit(-1); - } - buf[bytes_read] = '\0'; - } else { /* Beginning of file reached */ - begin_reached = 1; - return; - } - } - } while (*(--page) != '\n'); - page++; -} - -/* - * Print a new page of text. Called by dialog_textbox(). - */ -static void print_page(WINDOW * win, int height, int width) -{ - int i, passed_end = 0; - - page_length = 0; - for (i = 0; i < height; i++) { - print_line(win, i, width); - if (!passed_end) - page_length++; - if (end_reached && !passed_end) - passed_end = 1; - } - wnoutrefresh(win); -} - -/* - * Print a new line of text. Called by dialog_textbox() and print_page(). - */ -static void print_line(WINDOW * win, int row, int width) -{ - int y, x; - char *line; - - line = get_line(); - line += MIN(strlen(line), hscroll); /* Scroll horizontally */ - wmove(win, row, 0); /* move cursor to correct line */ - waddch(win, ' '); - waddnstr(win, line, MIN(strlen(line), width - 2)); - - getyx(win, y, x); - /* Clear 'residue' of previous line */ -#if OLD_NCURSES - { - int i; - for (i = 0; i < width - x; i++) - waddch(win, ' '); - } -#else - wclrtoeol(win); -#endif -} - -/* - * Return current line of text. Called by dialog_textbox() and print_line(). - * 'page' should point to start of current line before calling, and will be - * updated to point to start of next line. - */ -static char *get_line(void) -{ - int i = 0, fpos; - static char line[MAX_LEN + 1]; - - end_reached = 0; - while (*page != '\n') { - if (*page == '\0') { - /* Either end of file or end of buffer reached */ - if ((fpos = lseek(fd, 0, SEEK_CUR)) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in " - "get_line().\n"); - exit(-1); - } - if (fpos < file_size) { /* Not end of file yet */ - /* We've reached end of buffer, but not end of file yet, - so read next part of file into buffer */ - if ((bytes_read = - read(fd, buf, BUF_SIZE)) == -1) { - endwin(); - fprintf(stderr, "\nError reading file in get_line().\n"); - exit(-1); - } - buf[bytes_read] = '\0'; - page = buf; - } else { - if (!end_reached) - end_reached = 1; - break; - } - } else if (i < MAX_LEN) - line[i++] = *(page++); - else { - /* Truncate lines longer than MAX_LEN characters */ - if (i == MAX_LEN) - line[i++] = '\0'; - page++; - } - } - if (i <= MAX_LEN) - line[i] = '\0'; - if (!end_reached) - page++; /* move pass '\n' */ - - return line; -} - -/* - * Print current position - */ -static void print_position(WINDOW * win, int height, int width) -{ - int fpos, percent; - - if ((fpos = lseek(fd, 0, SEEK_CUR)) == -1) { - endwin(); - fprintf(stderr, "\nError moving file pointer in print_position().\n"); - exit(-1); - } - wattrset(win, position_indicator_attr); - wbkgdset(win, position_indicator_attr & A_COLOR); - percent = !file_size ? - 100 : ((fpos - bytes_read + page - buf) * 100) / file_size; - wmove(win, height - 3, width - 9); - wprintw(win, "(%3d%%)", percent); -} diff --git a/trunk/scripts/kconfig/lxdialog/util.c b/trunk/scripts/kconfig/lxdialog/util.c deleted file mode 100644 index f82cebb9ff06..000000000000 --- a/trunk/scripts/kconfig/lxdialog/util.c +++ /dev/null @@ -1,362 +0,0 @@ -/* - * util.c - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include "dialog.h" - -/* use colors by default? */ -bool use_colors = 1; - -const char *backtitle = NULL; - -/* - * Attribute values, default is for mono display - */ -chtype attributes[] = { - A_NORMAL, /* screen_attr */ - A_NORMAL, /* shadow_attr */ - A_NORMAL, /* dialog_attr */ - A_BOLD, /* title_attr */ - A_NORMAL, /* border_attr */ - A_REVERSE, /* button_active_attr */ - A_DIM, /* button_inactive_attr */ - A_REVERSE, /* button_key_active_attr */ - A_BOLD, /* button_key_inactive_attr */ - A_REVERSE, /* button_label_active_attr */ - A_NORMAL, /* button_label_inactive_attr */ - A_NORMAL, /* inputbox_attr */ - A_NORMAL, /* inputbox_border_attr */ - A_NORMAL, /* searchbox_attr */ - A_BOLD, /* searchbox_title_attr */ - A_NORMAL, /* searchbox_border_attr */ - A_BOLD, /* position_indicator_attr */ - A_NORMAL, /* menubox_attr */ - A_NORMAL, /* menubox_border_attr */ - A_NORMAL, /* item_attr */ - A_REVERSE, /* item_selected_attr */ - A_BOLD, /* tag_attr */ - A_REVERSE, /* tag_selected_attr */ - A_BOLD, /* tag_key_attr */ - A_REVERSE, /* tag_key_selected_attr */ - A_BOLD, /* check_attr */ - A_REVERSE, /* check_selected_attr */ - A_BOLD, /* uarrow_attr */ - A_BOLD /* darrow_attr */ -}; - -#include "colors.h" - -/* - * Table of color values - */ -int color_table[][3] = { - {SCREEN_FG, SCREEN_BG, SCREEN_HL}, - {SHADOW_FG, SHADOW_BG, SHADOW_HL}, - {DIALOG_FG, DIALOG_BG, DIALOG_HL}, - {TITLE_FG, TITLE_BG, TITLE_HL}, - {BORDER_FG, BORDER_BG, BORDER_HL}, - {BUTTON_ACTIVE_FG, BUTTON_ACTIVE_BG, BUTTON_ACTIVE_HL}, - {BUTTON_INACTIVE_FG, BUTTON_INACTIVE_BG, BUTTON_INACTIVE_HL}, - {BUTTON_KEY_ACTIVE_FG, BUTTON_KEY_ACTIVE_BG, BUTTON_KEY_ACTIVE_HL}, - {BUTTON_KEY_INACTIVE_FG, BUTTON_KEY_INACTIVE_BG, - BUTTON_KEY_INACTIVE_HL}, - {BUTTON_LABEL_ACTIVE_FG, BUTTON_LABEL_ACTIVE_BG, - BUTTON_LABEL_ACTIVE_HL}, - {BUTTON_LABEL_INACTIVE_FG, BUTTON_LABEL_INACTIVE_BG, - BUTTON_LABEL_INACTIVE_HL}, - {INPUTBOX_FG, INPUTBOX_BG, INPUTBOX_HL}, - {INPUTBOX_BORDER_FG, INPUTBOX_BORDER_BG, INPUTBOX_BORDER_HL}, - {SEARCHBOX_FG, SEARCHBOX_BG, SEARCHBOX_HL}, - {SEARCHBOX_TITLE_FG, SEARCHBOX_TITLE_BG, SEARCHBOX_TITLE_HL}, - {SEARCHBOX_BORDER_FG, SEARCHBOX_BORDER_BG, SEARCHBOX_BORDER_HL}, - {POSITION_INDICATOR_FG, POSITION_INDICATOR_BG, POSITION_INDICATOR_HL}, - {MENUBOX_FG, MENUBOX_BG, MENUBOX_HL}, - {MENUBOX_BORDER_FG, MENUBOX_BORDER_BG, MENUBOX_BORDER_HL}, - {ITEM_FG, ITEM_BG, ITEM_HL}, - {ITEM_SELECTED_FG, ITEM_SELECTED_BG, ITEM_SELECTED_HL}, - {TAG_FG, TAG_BG, TAG_HL}, - {TAG_SELECTED_FG, TAG_SELECTED_BG, TAG_SELECTED_HL}, - {TAG_KEY_FG, TAG_KEY_BG, TAG_KEY_HL}, - {TAG_KEY_SELECTED_FG, TAG_KEY_SELECTED_BG, TAG_KEY_SELECTED_HL}, - {CHECK_FG, CHECK_BG, CHECK_HL}, - {CHECK_SELECTED_FG, CHECK_SELECTED_BG, CHECK_SELECTED_HL}, - {UARROW_FG, UARROW_BG, UARROW_HL}, - {DARROW_FG, DARROW_BG, DARROW_HL}, -}; /* color_table */ - -/* - * Set window to attribute 'attr' - */ -void attr_clear(WINDOW * win, int height, int width, chtype attr) -{ - int i, j; - - wattrset(win, attr); - for (i = 0; i < height; i++) { - wmove(win, i, 0); - for (j = 0; j < width; j++) - waddch(win, ' '); - } - touchwin(win); -} - -void dialog_clear(void) -{ - attr_clear(stdscr, LINES, COLS, screen_attr); - /* Display background title if it exists ... - SLH */ - if (backtitle != NULL) { - int i; - - wattrset(stdscr, screen_attr); - mvwaddstr(stdscr, 0, 1, (char *)backtitle); - wmove(stdscr, 1, 1); - for (i = 1; i < COLS - 1; i++) - waddch(stdscr, ACS_HLINE); - } - wnoutrefresh(stdscr); -} - -/* - * Do some initialization for dialog - */ -void init_dialog(void) -{ - initscr(); /* Init curses */ - keypad(stdscr, TRUE); - cbreak(); - noecho(); - - if (use_colors) /* Set up colors */ - color_setup(); - - dialog_clear(); -} - -/* - * Setup for color display - */ -void color_setup(void) -{ - int i; - - if (has_colors()) { /* Terminal supports color? */ - start_color(); - - /* Initialize color pairs */ - for (i = 0; i < ATTRIBUTE_COUNT; i++) - init_pair(i + 1, color_table[i][0], color_table[i][1]); - - /* Setup color attributes */ - for (i = 0; i < ATTRIBUTE_COUNT; i++) - attributes[i] = C_ATTR(color_table[i][2], i + 1); - } -} - -/* - * End using dialog functions. - */ -void end_dialog(void) -{ - endwin(); -} - -/* Print the title of the dialog. Center the title and truncate - * tile if wider than dialog (- 2 chars). - **/ -void print_title(WINDOW *dialog, const char *title, int width) -{ - if (title) { - int tlen = MIN(width - 2, strlen(title)); - wattrset(dialog, title_attr); - mvwaddch(dialog, 0, (width - tlen) / 2 - 1, ' '); - mvwaddnstr(dialog, 0, (width - tlen)/2, title, tlen); - waddch(dialog, ' '); - } -} - -/* - * Print a string of text in a window, automatically wrap around to the - * next line if the string is too long to fit on one line. Newline - * characters '\n' are replaced by spaces. We start on a new line - * if there is no room for at least 4 nonblanks following a double-space. - */ -void print_autowrap(WINDOW * win, const char *prompt, int width, int y, int x) -{ - int newl, cur_x, cur_y; - int i, prompt_len, room, wlen; - char tempstr[MAX_LEN + 1], *word, *sp, *sp2; - - strcpy(tempstr, prompt); - - prompt_len = strlen(tempstr); - - /* - * Remove newlines - */ - for (i = 0; i < prompt_len; i++) { - if (tempstr[i] == '\n') - tempstr[i] = ' '; - } - - if (prompt_len <= width - x * 2) { /* If prompt is short */ - wmove(win, y, (width - prompt_len) / 2); - waddstr(win, tempstr); - } else { - cur_x = x; - cur_y = y; - newl = 1; - word = tempstr; - while (word && *word) { - sp = index(word, ' '); - if (sp) - *sp++ = 0; - - /* Wrap to next line if either the word does not fit, - or it is the first word of a new sentence, and it is - short, and the next word does not fit. */ - room = width - cur_x; - wlen = strlen(word); - if (wlen > room || - (newl && wlen < 4 && sp - && wlen + 1 + strlen(sp) > room - && (!(sp2 = index(sp, ' ')) - || wlen + 1 + (sp2 - sp) > room))) { - cur_y++; - cur_x = x; - } - wmove(win, cur_y, cur_x); - waddstr(win, word); - getyx(win, cur_y, cur_x); - cur_x++; - if (sp && *sp == ' ') { - cur_x++; /* double space */ - while (*++sp == ' ') ; - newl = 1; - } else - newl = 0; - word = sp; - } - } -} - -/* - * Print a button - */ -void print_button(WINDOW * win, const char *label, int y, int x, int selected) -{ - int i, temp; - - wmove(win, y, x); - wattrset(win, selected ? button_active_attr : button_inactive_attr); - waddstr(win, "<"); - temp = strspn(label, " "); - label += temp; - wattrset(win, selected ? button_label_active_attr - : button_label_inactive_attr); - for (i = 0; i < temp; i++) - waddch(win, ' '); - wattrset(win, selected ? button_key_active_attr - : button_key_inactive_attr); - waddch(win, label[0]); - wattrset(win, selected ? button_label_active_attr - : button_label_inactive_attr); - waddstr(win, (char *)label + 1); - wattrset(win, selected ? button_active_attr : button_inactive_attr); - waddstr(win, ">"); - wmove(win, y, x + temp + 1); -} - -/* - * Draw a rectangular box with line drawing characters - */ -void -draw_box(WINDOW * win, int y, int x, int height, int width, - chtype box, chtype border) -{ - int i, j; - - wattrset(win, 0); - for (i = 0; i < height; i++) { - wmove(win, y + i, x); - for (j = 0; j < width; j++) - if (!i && !j) - waddch(win, border | ACS_ULCORNER); - else if (i == height - 1 && !j) - waddch(win, border | ACS_LLCORNER); - else if (!i && j == width - 1) - waddch(win, box | ACS_URCORNER); - else if (i == height - 1 && j == width - 1) - waddch(win, box | ACS_LRCORNER); - else if (!i) - waddch(win, border | ACS_HLINE); - else if (i == height - 1) - waddch(win, box | ACS_HLINE); - else if (!j) - waddch(win, border | ACS_VLINE); - else if (j == width - 1) - waddch(win, box | ACS_VLINE); - else - waddch(win, box | ' '); - } -} - -/* - * Draw shadows along the right and bottom edge to give a more 3D look - * to the boxes - */ -void draw_shadow(WINDOW * win, int y, int x, int height, int width) -{ - int i; - - if (has_colors()) { /* Whether terminal supports color? */ - wattrset(win, shadow_attr); - wmove(win, y + height, x + 2); - for (i = 0; i < width; i++) - waddch(win, winch(win) & A_CHARTEXT); - for (i = y + 1; i < y + height + 1; i++) { - wmove(win, i, x + width); - waddch(win, winch(win) & A_CHARTEXT); - waddch(win, winch(win) & A_CHARTEXT); - } - wnoutrefresh(win); - } -} - -/* - * Return the position of the first alphabetic character in a string. - */ -int first_alpha(const char *string, const char *exempt) -{ - int i, in_paren = 0, c; - - for (i = 0; i < strlen(string); i++) { - c = tolower(string[i]); - - if (strchr("<[(", c)) - ++in_paren; - if (strchr(">])", c) && in_paren > 0) - --in_paren; - - if ((!in_paren) && isalpha(c) && strchr(exempt, c) == 0) - return i; - } - - return 0; -} diff --git a/trunk/scripts/kconfig/lxdialog/yesno.c b/trunk/scripts/kconfig/lxdialog/yesno.c deleted file mode 100644 index cb2568aae3ed..000000000000 --- a/trunk/scripts/kconfig/lxdialog/yesno.c +++ /dev/null @@ -1,102 +0,0 @@ -/* - * yesno.c -- implements the yes/no box - * - * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) - * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -#include "dialog.h" - -/* - * Display termination buttons - */ -static void print_buttons(WINDOW * dialog, int height, int width, int selected) -{ - int x = width / 2 - 10; - int y = height - 2; - - print_button(dialog, " Yes ", y, x, selected == 0); - print_button(dialog, " No ", y, x + 13, selected == 1); - - wmove(dialog, y, x + 1 + 13 * selected); - wrefresh(dialog); -} - -/* - * Display a dialog box with two buttons - Yes and No - */ -int dialog_yesno(const char *title, const char *prompt, int height, int width) -{ - int i, x, y, key = 0, button = 0; - WINDOW *dialog; - - /* center dialog box on screen */ - x = (COLS - width) / 2; - y = (LINES - height) / 2; - - draw_shadow(stdscr, y, x, height, width); - - dialog = newwin(height, width, y, x); - keypad(dialog, TRUE); - - draw_box(dialog, 0, 0, height, width, dialog_attr, border_attr); - wattrset(dialog, border_attr); - mvwaddch(dialog, height - 3, 0, ACS_LTEE); - for (i = 0; i < width - 2; i++) - waddch(dialog, ACS_HLINE); - wattrset(dialog, dialog_attr); - waddch(dialog, ACS_RTEE); - - print_title(dialog, title, width); - - wattrset(dialog, dialog_attr); - print_autowrap(dialog, prompt, width - 2, 1, 3); - - print_buttons(dialog, height, width, 0); - - while (key != ESC) { - key = wgetch(dialog); - switch (key) { - case 'Y': - case 'y': - delwin(dialog); - return 0; - case 'N': - case 'n': - delwin(dialog); - return 1; - - case TAB: - case KEY_LEFT: - case KEY_RIGHT: - button = ((key == KEY_LEFT ? --button : ++button) < 0) ? 1 : (button > 1 ? 0 : button); - - print_buttons(dialog, height, width, button); - wrefresh(dialog); - break; - case ' ': - case '\n': - delwin(dialog); - return button; - case ESC: - break; - } - } - - delwin(dialog); - return -1; /* ESC pressed */ -} diff --git a/trunk/scripts/kconfig/mconf.c b/trunk/scripts/kconfig/mconf.c index d63d7fb677e4..d1ad40531ee5 100644 --- a/trunk/scripts/kconfig/mconf.c +++ b/trunk/scripts/kconfig/mconf.c @@ -325,7 +325,7 @@ static void cprint_init(void) memset(args, 0, sizeof(args)); indent = 0; child_count = 0; - cprint("./scripts/kconfig/lxdialog/lxdialog"); + cprint("./scripts/lxdialog/lxdialog"); cprint("--backtitle"); cprint(menu_backtitle); } diff --git a/trunk/scripts/kconfig/util.c b/trunk/scripts/kconfig/util.c index 656d2c87d661..1fa4c0b801b3 100644 --- a/trunk/scripts/kconfig/util.c +++ b/trunk/scripts/kconfig/util.c @@ -33,7 +33,7 @@ int file_write_dep(const char *name) FILE *out; if (!name) - name = ".kconfig.d"; + name = ".config.cmd"; out = fopen("..config.tmp", "w"); if (!out) return 1; @@ -101,7 +101,7 @@ void str_printf(struct gstr *gs, const char *fmt, ...) va_end(ap); } -/* Retrieve value of growable string */ +/* Retreive value of growable string */ const char *str_get(struct gstr *gs) { return gs->s; diff --git a/trunk/scripts/kconfig/lxdialog/BIG.FAT.WARNING b/trunk/scripts/lxdialog/BIG.FAT.WARNING similarity index 100% rename from trunk/scripts/kconfig/lxdialog/BIG.FAT.WARNING rename to trunk/scripts/lxdialog/BIG.FAT.WARNING diff --git a/trunk/scripts/kconfig/lxdialog/Makefile b/trunk/scripts/lxdialog/Makefile similarity index 100% rename from trunk/scripts/kconfig/lxdialog/Makefile rename to trunk/scripts/lxdialog/Makefile diff --git a/trunk/scripts/lxdialog/checklist.c b/trunk/scripts/lxdialog/checklist.c new file mode 100644 index 000000000000..7aba17c72e64 --- /dev/null +++ b/trunk/scripts/lxdialog/checklist.c @@ -0,0 +1,373 @@ +/* + * checklist.c -- implements the checklist box + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * Stuart Herbert - S.Herbert@sheffield.ac.uk: radiolist extension + * Alessandro Rubini - rubini@ipvvis.unipv.it: merged the two + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "dialog.h" + +static int list_width, check_x, item_x, checkflag; + +/* + * Print list item + */ +static void +print_item (WINDOW * win, const char *item, int status, + int choice, int selected) +{ + int i; + + /* Clear 'residue' of last item */ + wattrset (win, menubox_attr); + wmove (win, choice, 0); + for (i = 0; i < list_width; i++) + waddch (win, ' '); + + wmove (win, choice, check_x); + wattrset (win, selected ? check_selected_attr : check_attr); + if (checkflag == FLAG_CHECK) + wprintw (win, "[%c]", status ? 'X' : ' '); + else + wprintw (win, "(%c)", status ? 'X' : ' '); + + wattrset (win, selected ? tag_selected_attr : tag_attr); + mvwaddch(win, choice, item_x, item[0]); + wattrset (win, selected ? item_selected_attr : item_attr); + waddstr (win, (char *)item+1); + if (selected) { + wmove (win, choice, check_x+1); + wrefresh (win); + } +} + +/* + * Print the scroll indicators. + */ +static void +print_arrows (WINDOW * win, int choice, int item_no, int scroll, + int y, int x, int height) +{ + wmove(win, y, x); + + if (scroll > 0) { + wattrset (win, uarrow_attr); + waddch (win, ACS_UARROW); + waddstr (win, "(-)"); + } + else { + wattrset (win, menubox_attr); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + } + + y = y + height + 1; + wmove(win, y, x); + + if ((height < item_no) && (scroll + choice < item_no - 1)) { + wattrset (win, darrow_attr); + waddch (win, ACS_DARROW); + waddstr (win, "(+)"); + } + else { + wattrset (win, menubox_border_attr); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + } +} + +/* + * Display the termination buttons + */ +static void +print_buttons( WINDOW *dialog, int height, int width, int selected) +{ + int x = width / 2 - 11; + int y = height - 2; + + print_button (dialog, "Select", y, x, selected == 0); + print_button (dialog, " Help ", y, x + 14, selected == 1); + + wmove(dialog, y, x+1 + 14*selected); + wrefresh (dialog); +} + +/* + * Display a dialog box with a list of options that can be turned on or off + * The `flag' parameter is used to select between radiolist and checklist. + */ +int +dialog_checklist (const char *title, const char *prompt, int height, int width, + int list_height, int item_no, const char * const * items, int flag) + +{ + int i, x, y, box_x, box_y; + int key = 0, button = 0, choice = 0, scroll = 0, max_choice, *status; + WINDOW *dialog, *list; + + checkflag = flag; + + /* Allocate space for storing item on/off status */ + if ((status = malloc (sizeof (int) * item_no)) == NULL) { + endwin (); + fprintf (stderr, + "\nCan't allocate memory in dialog_checklist().\n"); + exit (-1); + } + + /* Initializes status */ + for (i = 0; i < item_no; i++) { + status[i] = !strcasecmp (items[i * 3 + 2], "on"); + if ((!choice && status[i]) || !strcasecmp (items[i * 3 + 2], "selected")) + choice = i + 1; + } + if (choice) + choice--; + + max_choice = MIN (list_height, item_no); + + /* center dialog box on screen */ + x = (COLS - width) / 2; + y = (LINES - height) / 2; + + draw_shadow (stdscr, y, x, height, width); + + dialog = newwin (height, width, y, x); + keypad (dialog, TRUE); + + draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); + wattrset (dialog, border_attr); + mvwaddch (dialog, height-3, 0, ACS_LTEE); + for (i = 0; i < width - 2; i++) + waddch (dialog, ACS_HLINE); + wattrset (dialog, dialog_attr); + waddch (dialog, ACS_RTEE); + + if (title != NULL && strlen(title) >= width-2 ) { + /* truncate long title -- mec */ + char * title2 = malloc(width-2+1); + memcpy( title2, title, width-2 ); + title2[width-2] = '\0'; + title = title2; + } + + if (title != NULL) { + wattrset (dialog, title_attr); + mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); + waddstr (dialog, (char *)title); + waddch (dialog, ' '); + } + + wattrset (dialog, dialog_attr); + print_autowrap (dialog, prompt, width - 2, 1, 3); + + list_width = width - 6; + box_y = height - list_height - 5; + box_x = (width - list_width) / 2 - 1; + + /* create new window for the list */ + list = subwin (dialog, list_height, list_width, y+box_y+1, x+box_x+1); + + keypad (list, TRUE); + + /* draw a box around the list items */ + draw_box (dialog, box_y, box_x, list_height + 2, list_width + 2, + menubox_border_attr, menubox_attr); + + /* Find length of longest item in order to center checklist */ + check_x = 0; + for (i = 0; i < item_no; i++) + check_x = MAX (check_x, + strlen (items[i * 3 + 1]) + 4); + + check_x = (list_width - check_x) / 2; + item_x = check_x + 4; + + if (choice >= list_height) { + scroll = choice - list_height + 1; + choice -= scroll; + } + + /* Print the list */ + for (i = 0; i < max_choice; i++) { + print_item (list, items[(scroll+i) * 3 + 1], + status[i+scroll], i, i == choice); + } + + print_arrows(dialog, choice, item_no, scroll, + box_y, box_x + check_x + 5, list_height); + + print_buttons(dialog, height, width, 0); + + wnoutrefresh (list); + wnoutrefresh (dialog); + doupdate (); + + while (key != ESC) { + key = wgetch (dialog); + + for (i = 0; i < max_choice; i++) + if (toupper(key) == toupper(items[(scroll+i)*3+1][0])) + break; + + + if ( i < max_choice || key == KEY_UP || key == KEY_DOWN || + key == '+' || key == '-' ) { + if (key == KEY_UP || key == '-') { + if (!choice) { + if (!scroll) + continue; + /* Scroll list down */ + if (list_height > 1) { + /* De-highlight current first item */ + print_item (list, items[scroll * 3 + 1], + status[scroll], 0, FALSE); + scrollok (list, TRUE); + wscrl (list, -1); + scrollok (list, FALSE); + } + scroll--; + print_item (list, items[scroll * 3 + 1], + status[scroll], 0, TRUE); + wnoutrefresh (list); + + print_arrows(dialog, choice, item_no, scroll, + box_y, box_x + check_x + 5, list_height); + + wrefresh (dialog); + + continue; /* wait for another key press */ + } else + i = choice - 1; + } else if (key == KEY_DOWN || key == '+') { + if (choice == max_choice - 1) { + if (scroll + choice >= item_no - 1) + continue; + /* Scroll list up */ + if (list_height > 1) { + /* De-highlight current last item before scrolling up */ + print_item (list, items[(scroll + max_choice - 1) * 3 + 1], + status[scroll + max_choice - 1], + max_choice - 1, FALSE); + scrollok (list, TRUE); + wscrl (list, 1); + scrollok (list, FALSE); + } + scroll++; + print_item (list, items[(scroll + max_choice - 1) * 3 + 1], + status[scroll + max_choice - 1], + max_choice - 1, TRUE); + wnoutrefresh (list); + + print_arrows(dialog, choice, item_no, scroll, + box_y, box_x + check_x + 5, list_height); + + wrefresh (dialog); + + continue; /* wait for another key press */ + } else + i = choice + 1; + } + if (i != choice) { + /* De-highlight current item */ + print_item (list, items[(scroll + choice) * 3 + 1], + status[scroll + choice], choice, FALSE); + /* Highlight new item */ + choice = i; + print_item (list, items[(scroll + choice) * 3 + 1], + status[scroll + choice], choice, TRUE); + wnoutrefresh (list); + wrefresh (dialog); + } + continue; /* wait for another key press */ + } + switch (key) { + case 'H': + case 'h': + case '?': + fprintf (stderr, "%s", items[(scroll + choice) * 3]); + delwin (dialog); + free (status); + return 1; + case TAB: + case KEY_LEFT: + case KEY_RIGHT: + button = ((key == KEY_LEFT ? --button : ++button) < 0) + ? 1 : (button > 1 ? 0 : button); + + print_buttons(dialog, height, width, button); + wrefresh (dialog); + break; + case 'S': + case 's': + case ' ': + case '\n': + if (!button) { + if (flag == FLAG_CHECK) { + status[scroll + choice] = !status[scroll + choice]; + wmove (list, choice, check_x); + wattrset (list, check_selected_attr); + wprintw (list, "[%c]", status[scroll + choice] ? 'X' : ' '); + } else { + if (!status[scroll + choice]) { + for (i = 0; i < item_no; i++) + status[i] = 0; + status[scroll + choice] = 1; + for (i = 0; i < max_choice; i++) + print_item (list, items[(scroll + i) * 3 + 1], + status[scroll + i], i, i == choice); + } + } + wnoutrefresh (list); + wrefresh (dialog); + + for (i = 0; i < item_no; i++) { + if (status[i]) { + if (flag == FLAG_CHECK) { + fprintf (stderr, "\"%s\" ", items[i * 3]); + } else { + fprintf (stderr, "%s", items[i * 3]); + } + + } + } + } else + fprintf (stderr, "%s", items[(scroll + choice) * 3]); + delwin (dialog); + free (status); + return button; + case 'X': + case 'x': + key = ESC; + case ESC: + break; + } + + /* Now, update everything... */ + doupdate (); + } + + + delwin (dialog); + free (status); + return -1; /* ESC pressed */ +} diff --git a/trunk/scripts/kconfig/lxdialog/colors.h b/trunk/scripts/lxdialog/colors.h similarity index 99% rename from trunk/scripts/kconfig/lxdialog/colors.h rename to trunk/scripts/lxdialog/colors.h index db071df12bbb..25c59528a251 100644 --- a/trunk/scripts/kconfig/lxdialog/colors.h +++ b/trunk/scripts/lxdialog/colors.h @@ -18,6 +18,7 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + /* * Default color definitions * diff --git a/trunk/scripts/kconfig/lxdialog/dialog.h b/trunk/scripts/lxdialog/dialog.h similarity index 75% rename from trunk/scripts/kconfig/lxdialog/dialog.h rename to trunk/scripts/lxdialog/dialog.h index af3cf716e215..eb63e1bb63a3 100644 --- a/trunk/scripts/kconfig/lxdialog/dialog.h +++ b/trunk/scripts/lxdialog/dialog.h @@ -1,3 +1,4 @@ + /* * dialog.h -- common declarations for all dialog modules * @@ -41,7 +42,7 @@ #if defined(NCURSES_VERSION) && defined(_NEED_WRAP) && !defined(GCC_PRINTFLIKE) #define OLD_NCURSES 1 #undef wbkgdset -#define wbkgdset(w,p) /*nothing */ +#define wbkgdset(w,p) /*nothing*/ #else #define OLD_NCURSES 0 #endif @@ -55,6 +56,7 @@ #define MIN(x,y) (x < y ? x : y) #define MAX(x,y) (x > y ? x : y) + #ifndef ACS_ULCORNER #define ACS_ULCORNER '+' #endif @@ -86,7 +88,7 @@ #define ACS_DARROW 'v' #endif -/* +/* * Attribute names */ #define screen_attr attributes[0] @@ -135,35 +137,35 @@ extern const char *backtitle; /* * Function prototypes */ -extern void create_rc(const char *filename); -extern int parse_rc(void); - -void init_dialog(void); -void end_dialog(void); -void attr_clear(WINDOW * win, int height, int width, chtype attr); -void dialog_clear(void); -void color_setup(void); -void print_autowrap(WINDOW * win, const char *prompt, int width, int y, int x); -void print_button(WINDOW * win, const char *label, int y, int x, int selected); -void print_title(WINDOW *dialog, const char *title, int width); -void draw_box(WINDOW * win, int y, int x, int height, int width, chtype box, - chtype border); -void draw_shadow(WINDOW * win, int y, int x, int height, int width); - -int first_alpha(const char *string, const char *exempt); -int dialog_yesno(const char *title, const char *prompt, int height, int width); -int dialog_msgbox(const char *title, const char *prompt, int height, - int width, int pause); -int dialog_textbox(const char *title, const char *file, int height, int width); -int dialog_menu(const char *title, const char *prompt, int height, int width, - int menu_height, const char *choice, int item_no, - const char *const *items); -int dialog_checklist(const char *title, const char *prompt, int height, - int width, int list_height, int item_no, - const char *const *items); +extern void create_rc (const char *filename); +extern int parse_rc (void); + + +void init_dialog (void); +void end_dialog (void); +void attr_clear (WINDOW * win, int height, int width, chtype attr); +void dialog_clear (void); +void color_setup (void); +void print_autowrap (WINDOW * win, const char *prompt, int width, int y, int x); +void print_button (WINDOW * win, const char *label, int y, int x, int selected); +void draw_box (WINDOW * win, int y, int x, int height, int width, chtype box, + chtype border); +void draw_shadow (WINDOW * win, int y, int x, int height, int width); + +int first_alpha (const char *string, const char *exempt); +int dialog_yesno (const char *title, const char *prompt, int height, int width); +int dialog_msgbox (const char *title, const char *prompt, int height, + int width, int pause); +int dialog_textbox (const char *title, const char *file, int height, int width); +int dialog_menu (const char *title, const char *prompt, int height, int width, + int menu_height, const char *choice, int item_no, + const char * const * items); +int dialog_checklist (const char *title, const char *prompt, int height, + int width, int list_height, int item_no, + const char * const * items, int flag); extern char dialog_input_result[]; -int dialog_inputbox(const char *title, const char *prompt, int height, - int width, const char *init); +int dialog_inputbox (const char *title, const char *prompt, int height, + int width, const char *init); /* * This is the base for fictitious keys, which activate @@ -175,3 +177,11 @@ int dialog_inputbox(const char *title, const char *prompt, int height, * -- uppercase chars are used to invoke the button (M_EVENT + 'O') */ #define M_EVENT (KEY_MAX+1) + + +/* + * The `flag' parameter in checklist is used to select between + * radiolist and checklist + */ +#define FLAG_CHECK 1 +#define FLAG_RADIO 0 diff --git a/trunk/scripts/lxdialog/inputbox.c b/trunk/scripts/lxdialog/inputbox.c new file mode 100644 index 000000000000..074d2d68bd31 --- /dev/null +++ b/trunk/scripts/lxdialog/inputbox.c @@ -0,0 +1,240 @@ +/* + * inputbox.c -- implements the input box + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "dialog.h" + +char dialog_input_result[MAX_LEN + 1]; + +/* + * Print the termination buttons + */ +static void +print_buttons(WINDOW *dialog, int height, int width, int selected) +{ + int x = width / 2 - 11; + int y = height - 2; + + print_button (dialog, " Ok ", y, x, selected==0); + print_button (dialog, " Help ", y, x + 14, selected==1); + + wmove(dialog, y, x+1+14*selected); + wrefresh(dialog); +} + +/* + * Display a dialog box for inputing a string + */ +int +dialog_inputbox (const char *title, const char *prompt, int height, int width, + const char *init) +{ + int i, x, y, box_y, box_x, box_width; + int input_x = 0, scroll = 0, key = 0, button = -1; + char *instr = dialog_input_result; + WINDOW *dialog; + + /* center dialog box on screen */ + x = (COLS - width) / 2; + y = (LINES - height) / 2; + + + draw_shadow (stdscr, y, x, height, width); + + dialog = newwin (height, width, y, x); + keypad (dialog, TRUE); + + draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); + wattrset (dialog, border_attr); + mvwaddch (dialog, height-3, 0, ACS_LTEE); + for (i = 0; i < width - 2; i++) + waddch (dialog, ACS_HLINE); + wattrset (dialog, dialog_attr); + waddch (dialog, ACS_RTEE); + + if (title != NULL && strlen(title) >= width-2 ) { + /* truncate long title -- mec */ + char * title2 = malloc(width-2+1); + memcpy( title2, title, width-2 ); + title2[width-2] = '\0'; + title = title2; + } + + if (title != NULL) { + wattrset (dialog, title_attr); + mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); + waddstr (dialog, (char *)title); + waddch (dialog, ' '); + } + + wattrset (dialog, dialog_attr); + print_autowrap (dialog, prompt, width - 2, 1, 3); + + /* Draw the input field box */ + box_width = width - 6; + getyx (dialog, y, x); + box_y = y + 2; + box_x = (width - box_width) / 2; + draw_box (dialog, y + 1, box_x - 1, 3, box_width + 2, + border_attr, dialog_attr); + + print_buttons(dialog, height, width, 0); + + /* Set up the initial value */ + wmove (dialog, box_y, box_x); + wattrset (dialog, inputbox_attr); + + if (!init) + instr[0] = '\0'; + else + strcpy (instr, init); + + input_x = strlen (instr); + + if (input_x >= box_width) { + scroll = input_x - box_width + 1; + input_x = box_width - 1; + for (i = 0; i < box_width - 1; i++) + waddch (dialog, instr[scroll + i]); + } else + waddstr (dialog, instr); + + wmove (dialog, box_y, box_x + input_x); + + wrefresh (dialog); + + while (key != ESC) { + key = wgetch (dialog); + + if (button == -1) { /* Input box selected */ + switch (key) { + case TAB: + case KEY_UP: + case KEY_DOWN: + break; + case KEY_LEFT: + continue; + case KEY_RIGHT: + continue; + case KEY_BACKSPACE: + case 127: + if (input_x || scroll) { + wattrset (dialog, inputbox_attr); + if (!input_x) { + scroll = scroll < box_width - 1 ? + 0 : scroll - (box_width - 1); + wmove (dialog, box_y, box_x); + for (i = 0; i < box_width; i++) + waddch (dialog, instr[scroll + input_x + i] ? + instr[scroll + input_x + i] : ' '); + input_x = strlen (instr) - scroll; + } else + input_x--; + instr[scroll + input_x] = '\0'; + mvwaddch (dialog, box_y, input_x + box_x, ' '); + wmove (dialog, box_y, input_x + box_x); + wrefresh (dialog); + } + continue; + default: + if (key < 0x100 && isprint (key)) { + if (scroll + input_x < MAX_LEN) { + wattrset (dialog, inputbox_attr); + instr[scroll + input_x] = key; + instr[scroll + input_x + 1] = '\0'; + if (input_x == box_width - 1) { + scroll++; + wmove (dialog, box_y, box_x); + for (i = 0; i < box_width - 1; i++) + waddch (dialog, instr[scroll + i]); + } else { + wmove (dialog, box_y, input_x++ + box_x); + waddch (dialog, key); + } + wrefresh (dialog); + } else + flash (); /* Alarm user about overflow */ + continue; + } + } + } + switch (key) { + case 'O': + case 'o': + delwin (dialog); + return 0; + case 'H': + case 'h': + delwin (dialog); + return 1; + case KEY_UP: + case KEY_LEFT: + switch (button) { + case -1: + button = 1; /* Indicates "Cancel" button is selected */ + print_buttons(dialog, height, width, 1); + break; + case 0: + button = -1; /* Indicates input box is selected */ + print_buttons(dialog, height, width, 0); + wmove (dialog, box_y, box_x + input_x); + wrefresh (dialog); + break; + case 1: + button = 0; /* Indicates "OK" button is selected */ + print_buttons(dialog, height, width, 0); + break; + } + break; + case TAB: + case KEY_DOWN: + case KEY_RIGHT: + switch (button) { + case -1: + button = 0; /* Indicates "OK" button is selected */ + print_buttons(dialog, height, width, 0); + break; + case 0: + button = 1; /* Indicates "Cancel" button is selected */ + print_buttons(dialog, height, width, 1); + break; + case 1: + button = -1; /* Indicates input box is selected */ + print_buttons(dialog, height, width, 0); + wmove (dialog, box_y, box_x + input_x); + wrefresh (dialog); + break; + } + break; + case ' ': + case '\n': + delwin (dialog); + return (button == -1 ? 0 : button); + case 'X': + case 'x': + key = ESC; + case ESC: + break; + } + } + + delwin (dialog); + return -1; /* ESC pressed */ +} diff --git a/trunk/scripts/lxdialog/lxdialog.c b/trunk/scripts/lxdialog/lxdialog.c new file mode 100644 index 000000000000..f283a8545426 --- /dev/null +++ b/trunk/scripts/lxdialog/lxdialog.c @@ -0,0 +1,226 @@ +/* + * dialog - Display simple dialog boxes from shell scripts + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "dialog.h" + +static void Usage (const char *name); + +typedef int (jumperFn) (const char *title, int argc, const char * const * argv); + +struct Mode { + char *name; + int argmin, argmax, argmod; + jumperFn *jumper; +}; + +jumperFn j_menu, j_checklist, j_radiolist, j_yesno, j_textbox, j_inputbox; +jumperFn j_msgbox, j_infobox; + +static struct Mode modes[] = +{ + {"--menu", 9, 0, 3, j_menu}, + {"--checklist", 9, 0, 3, j_checklist}, + {"--radiolist", 9, 0, 3, j_radiolist}, + {"--yesno", 5,5,1, j_yesno}, + {"--textbox", 5,5,1, j_textbox}, + {"--inputbox", 5, 6, 1, j_inputbox}, + {"--msgbox", 5, 5, 1, j_msgbox}, + {"--infobox", 5, 5, 1, j_infobox}, + {NULL, 0, 0, 0, NULL} +}; + +static struct Mode *modePtr; + +#ifdef LOCALE +#include <locale.h> +#endif + +int +main (int argc, const char * const * argv) +{ + int offset = 0, opt_clear = 0, end_common_opts = 0, retval; + const char *title = NULL; + +#ifdef LOCALE + (void) setlocale (LC_ALL, ""); +#endif + +#ifdef TRACE + trace(TRACE_CALLS|TRACE_UPDATE); +#endif + if (argc < 2) { + Usage (argv[0]); + exit (-1); + } + + while (offset < argc - 1 && !end_common_opts) { /* Common options */ + if (!strcmp (argv[offset + 1], "--title")) { + if (argc - offset < 3 || title != NULL) { + Usage (argv[0]); + exit (-1); + } else { + title = argv[offset + 2]; + offset += 2; + } + } else if (!strcmp (argv[offset + 1], "--backtitle")) { + if (backtitle != NULL) { + Usage (argv[0]); + exit (-1); + } else { + backtitle = argv[offset + 2]; + offset += 2; + } + } else if (!strcmp (argv[offset + 1], "--clear")) { + if (opt_clear) { /* Hey, "--clear" can't appear twice! */ + Usage (argv[0]); + exit (-1); + } else if (argc == 2) { /* we only want to clear the screen */ + init_dialog (); + refresh (); /* init_dialog() will clear the screen for us */ + end_dialog (); + return 0; + } else { + opt_clear = 1; + offset++; + } + } else /* no more common options */ + end_common_opts = 1; + } + + if (argc - 1 == offset) { /* no more options */ + Usage (argv[0]); + exit (-1); + } + /* use a table to look for the requested mode, to avoid code duplication */ + + for (modePtr = modes; modePtr->name; modePtr++) /* look for the mode */ + if (!strcmp (argv[offset + 1], modePtr->name)) + break; + + if (!modePtr->name) + Usage (argv[0]); + if (argc - offset < modePtr->argmin) + Usage (argv[0]); + if (modePtr->argmax && argc - offset > modePtr->argmax) + Usage (argv[0]); + + + + init_dialog (); + retval = (*(modePtr->jumper)) (title, argc - offset, argv + offset); + + if (opt_clear) { /* clear screen before exit */ + attr_clear (stdscr, LINES, COLS, screen_attr); + refresh (); + } + end_dialog(); + + exit (retval); +} + +/* + * Print program usage + */ +static void +Usage (const char *name) +{ + fprintf (stderr, "\ +\ndialog, by Savio Lam (lam836@cs.cuhk.hk).\ +\n patched by Stuart Herbert (S.Herbert@shef.ac.uk)\ +\n modified/gutted for use as a Linux kernel config tool by \ +\n William Roadcap (roadcapw@cfw.com)\ +\n\ +\n* Display dialog boxes from shell scripts *\ +\n\ +\nUsage: %s --clear\ +\n %s [--title <title>] [--backtitle <backtitle>] --clear <Box options>\ +\n\ +\nBox options:\ +\n\ +\n --menu <text> <height> <width> <menu height> <tag1> <item1>...\ +\n --checklist <text> <height> <width> <list height> <tag1> <item1> <status1>...\ +\n --radiolist <text> <height> <width> <list height> <tag1> <item1> <status1>...\ +\n --textbox <file> <height> <width>\ +\n --inputbox <text> <height> <width> [<init>]\ +\n --yesno <text> <height> <width>\ +\n", name, name); + exit (-1); +} + +/* + * These are the program jumpers + */ + +int +j_menu (const char *t, int ac, const char * const * av) +{ + return dialog_menu (t, av[2], atoi (av[3]), atoi (av[4]), + atoi (av[5]), av[6], (ac - 6) / 2, av + 7); +} + +int +j_checklist (const char *t, int ac, const char * const * av) +{ + return dialog_checklist (t, av[2], atoi (av[3]), atoi (av[4]), + atoi (av[5]), (ac - 6) / 3, av + 6, FLAG_CHECK); +} + +int +j_radiolist (const char *t, int ac, const char * const * av) +{ + return dialog_checklist (t, av[2], atoi (av[3]), atoi (av[4]), + atoi (av[5]), (ac - 6) / 3, av + 6, FLAG_RADIO); +} + +int +j_textbox (const char *t, int ac, const char * const * av) +{ + return dialog_textbox (t, av[2], atoi (av[3]), atoi (av[4])); +} + +int +j_yesno (const char *t, int ac, const char * const * av) +{ + return dialog_yesno (t, av[2], atoi (av[3]), atoi (av[4])); +} + +int +j_inputbox (const char *t, int ac, const char * const * av) +{ + int ret = dialog_inputbox (t, av[2], atoi (av[3]), atoi (av[4]), + ac == 6 ? av[5] : (char *) NULL); + if (ret == 0) + fprintf(stderr, dialog_input_result); + return ret; +} + +int +j_msgbox (const char *t, int ac, const char * const * av) +{ + return dialog_msgbox (t, av[2], atoi (av[3]), atoi (av[4]), 1); +} + +int +j_infobox (const char *t, int ac, const char * const * av) +{ + return dialog_msgbox (t, av[2], atoi (av[3]), atoi (av[4]), 0); +} + diff --git a/trunk/scripts/lxdialog/menubox.c b/trunk/scripts/lxdialog/menubox.c new file mode 100644 index 000000000000..91d82ba17f8d --- /dev/null +++ b/trunk/scripts/lxdialog/menubox.c @@ -0,0 +1,445 @@ +/* + * menubox.c -- implements the menu box + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcapw@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * Changes by Clifford Wolf (god@clifford.at) + * + * [ 1998-06-13 ] + * + * *) A bugfix for the Page-Down problem + * + * *) Formerly when I used Page Down and Page Up, the cursor would be set + * to the first position in the menu box. Now lxdialog is a bit + * smarter and works more like other menu systems (just have a look at + * it). + * + * *) Formerly if I selected something my scrolling would be broken because + * lxdialog is re-invoked by the Menuconfig shell script, can't + * remember the last scrolling position, and just sets it so that the + * cursor is at the bottom of the box. Now it writes the temporary file + * lxdialog.scrltmp which contains this information. The file is + * deleted by lxdialog if the user leaves a submenu or enters a new + * one, but it would be nice if Menuconfig could make another "rm -f" + * just to be sure. Just try it out - you will recognise a difference! + * + * [ 1998-06-14 ] + * + * *) Now lxdialog is crash-safe against broken "lxdialog.scrltmp" files + * and menus change their size on the fly. + * + * *) If for some reason the last scrolling position is not saved by + * lxdialog, it sets the scrolling so that the selected item is in the + * middle of the menu box, not at the bottom. + * + * 02 January 1999, Michael Elizabeth Chastain (mec@shout.net) + * Reset 'scroll' to 0 if the value from lxdialog.scrltmp is bogus. + * This fixes a bug in Menuconfig where using ' ' to descend into menus + * would leave mis-synchronized lxdialog.scrltmp files lying around, + * fscanf would read in 'scroll', and eventually that value would get used. + */ + +#include "dialog.h" + +static int menu_width, item_x; + +/* + * Print menu item + */ +static void +print_item (WINDOW * win, const char *item, int choice, int selected, int hotkey) +{ + int j; + char menu_item[menu_width+1]; + + strncpy(menu_item, item, menu_width); + menu_item[menu_width] = 0; + j = first_alpha(menu_item, "YyNnMmHh"); + + /* Clear 'residue' of last item */ + wattrset (win, menubox_attr); + wmove (win, choice, 0); +#if OLD_NCURSES + { + int i; + for (i = 0; i < menu_width; i++) + waddch (win, ' '); + } +#else + wclrtoeol(win); +#endif + wattrset (win, selected ? item_selected_attr : item_attr); + mvwaddstr (win, choice, item_x, menu_item); + if (hotkey) { + wattrset (win, selected ? tag_key_selected_attr : tag_key_attr); + mvwaddch(win, choice, item_x+j, menu_item[j]); + } + if (selected) { + wmove (win, choice, item_x+1); + wrefresh (win); + } +} + +/* + * Print the scroll indicators. + */ +static void +print_arrows (WINDOW * win, int item_no, int scroll, + int y, int x, int height) +{ + int cur_y, cur_x; + + getyx(win, cur_y, cur_x); + + wmove(win, y, x); + + if (scroll > 0) { + wattrset (win, uarrow_attr); + waddch (win, ACS_UARROW); + waddstr (win, "(-)"); + } + else { + wattrset (win, menubox_attr); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + } + + y = y + height + 1; + wmove(win, y, x); + + if ((height < item_no) && (scroll + height < item_no)) { + wattrset (win, darrow_attr); + waddch (win, ACS_DARROW); + waddstr (win, "(+)"); + } + else { + wattrset (win, menubox_border_attr); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + waddch (win, ACS_HLINE); + } + + wmove(win, cur_y, cur_x); +} + +/* + * Display the termination buttons. + */ +static void +print_buttons (WINDOW *win, int height, int width, int selected) +{ + int x = width / 2 - 16; + int y = height - 2; + + print_button (win, "Select", y, x, selected == 0); + print_button (win, " Exit ", y, x + 12, selected == 1); + print_button (win, " Help ", y, x + 24, selected == 2); + + wmove(win, y, x+1+12*selected); + wrefresh (win); +} + +/* + * Display a menu for choosing among a number of options + */ +int +dialog_menu (const char *title, const char *prompt, int height, int width, + int menu_height, const char *current, int item_no, + const char * const * items) + +{ + int i, j, x, y, box_x, box_y; + int key = 0, button = 0, scroll = 0, choice = 0, first_item = 0, max_choice; + WINDOW *dialog, *menu; + FILE *f; + + max_choice = MIN (menu_height, item_no); + + /* center dialog box on screen */ + x = (COLS - width) / 2; + y = (LINES - height) / 2; + + draw_shadow (stdscr, y, x, height, width); + + dialog = newwin (height, width, y, x); + keypad (dialog, TRUE); + + draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); + wattrset (dialog, border_attr); + mvwaddch (dialog, height - 3, 0, ACS_LTEE); + for (i = 0; i < width - 2; i++) + waddch (dialog, ACS_HLINE); + wattrset (dialog, dialog_attr); + wbkgdset (dialog, dialog_attr & A_COLOR); + waddch (dialog, ACS_RTEE); + + if (title != NULL && strlen(title) >= width-2 ) { + /* truncate long title -- mec */ + char * title2 = malloc(width-2+1); + memcpy( title2, title, width-2 ); + title2[width-2] = '\0'; + title = title2; + } + + if (title != NULL) { + wattrset (dialog, title_attr); + mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); + waddstr (dialog, (char *)title); + waddch (dialog, ' '); + } + + wattrset (dialog, dialog_attr); + print_autowrap (dialog, prompt, width - 2, 1, 3); + + menu_width = width - 6; + box_y = height - menu_height - 5; + box_x = (width - menu_width) / 2 - 1; + + /* create new window for the menu */ + menu = subwin (dialog, menu_height, menu_width, + y + box_y + 1, x + box_x + 1); + keypad (menu, TRUE); + + /* draw a box around the menu items */ + draw_box (dialog, box_y, box_x, menu_height + 2, menu_width + 2, + menubox_border_attr, menubox_attr); + + /* + * Find length of longest item in order to center menu. + * Set 'choice' to default item. + */ + item_x = 0; + for (i = 0; i < item_no; i++) { + item_x = MAX (item_x, MIN(menu_width, strlen (items[i * 2 + 1]) + 2)); + if (strcmp(current, items[i*2]) == 0) choice = i; + } + + item_x = (menu_width - item_x) / 2; + + /* get the scroll info from the temp file */ + if ( (f=fopen("lxdialog.scrltmp","r")) != NULL ) { + if ( (fscanf(f,"%d\n",&scroll) == 1) && (scroll <= choice) && + (scroll+max_choice > choice) && (scroll >= 0) && + (scroll+max_choice <= item_no) ) { + first_item = scroll; + choice = choice - scroll; + fclose(f); + } else { + scroll=0; + remove("lxdialog.scrltmp"); + fclose(f); + f=NULL; + } + } + if ( (choice >= max_choice) || (f==NULL && choice >= max_choice/2) ) { + if (choice >= item_no-max_choice/2) + scroll = first_item = item_no-max_choice; + else + scroll = first_item = choice - max_choice/2; + choice = choice - scroll; + } + + /* Print the menu */ + for (i=0; i < max_choice; i++) { + print_item (menu, items[(first_item + i) * 2 + 1], i, i == choice, + (items[(first_item + i)*2][0] != ':')); + } + + wnoutrefresh (menu); + + print_arrows(dialog, item_no, scroll, + box_y, box_x+item_x+1, menu_height); + + print_buttons (dialog, height, width, 0); + wmove (menu, choice, item_x+1); + wrefresh (menu); + + while (key != ESC) { + key = wgetch(menu); + + if (key < 256 && isalpha(key)) key = tolower(key); + + if (strchr("ynmh", key)) + i = max_choice; + else { + for (i = choice+1; i < max_choice; i++) { + j = first_alpha(items[(scroll+i)*2+1], "YyNnMmHh"); + if (key == tolower(items[(scroll+i)*2+1][j])) + break; + } + if (i == max_choice) + for (i = 0; i < max_choice; i++) { + j = first_alpha(items[(scroll+i)*2+1], "YyNnMmHh"); + if (key == tolower(items[(scroll+i)*2+1][j])) + break; + } + } + + if (i < max_choice || + key == KEY_UP || key == KEY_DOWN || + key == '-' || key == '+' || + key == KEY_PPAGE || key == KEY_NPAGE) { + + print_item (menu, items[(scroll+choice)*2+1], choice, FALSE, + (items[(scroll+choice)*2][0] != ':')); + + if (key == KEY_UP || key == '-') { + if (choice < 2 && scroll) { + /* Scroll menu down */ + scrollok (menu, TRUE); + wscrl (menu, -1); + scrollok (menu, FALSE); + + scroll--; + + print_item (menu, items[scroll * 2 + 1], 0, FALSE, + (items[scroll*2][0] != ':')); + } else + choice = MAX(choice - 1, 0); + + } else if (key == KEY_DOWN || key == '+') { + + print_item (menu, items[(scroll+choice)*2+1], choice, FALSE, + (items[(scroll+choice)*2][0] != ':')); + + if ((choice > max_choice-3) && + (scroll + max_choice < item_no) + ) { + /* Scroll menu up */ + scrollok (menu, TRUE); + wscrl (menu, 1); + scrollok (menu, FALSE); + + scroll++; + + print_item (menu, items[(scroll+max_choice-1)*2+1], + max_choice-1, FALSE, + (items[(scroll+max_choice-1)*2][0] != ':')); + } else + choice = MIN(choice+1, max_choice-1); + + } else if (key == KEY_PPAGE) { + scrollok (menu, TRUE); + for (i=0; (i < max_choice); i++) { + if (scroll > 0) { + wscrl (menu, -1); + scroll--; + print_item (menu, items[scroll * 2 + 1], 0, FALSE, + (items[scroll*2][0] != ':')); + } else { + if (choice > 0) + choice--; + } + } + scrollok (menu, FALSE); + + } else if (key == KEY_NPAGE) { + for (i=0; (i < max_choice); i++) { + if (scroll+max_choice < item_no) { + scrollok (menu, TRUE); + wscrl (menu, 1); + scrollok (menu, FALSE); + scroll++; + print_item (menu, items[(scroll+max_choice-1)*2+1], + max_choice-1, FALSE, + (items[(scroll+max_choice-1)*2][0] != ':')); + } else { + if (choice+1 < max_choice) + choice++; + } + } + + } else + choice = i; + + print_item (menu, items[(scroll+choice)*2+1], choice, TRUE, + (items[(scroll+choice)*2][0] != ':')); + + print_arrows(dialog, item_no, scroll, + box_y, box_x+item_x+1, menu_height); + + wnoutrefresh (dialog); + wrefresh (menu); + + continue; /* wait for another key press */ + } + + switch (key) { + case KEY_LEFT: + case TAB: + case KEY_RIGHT: + button = ((key == KEY_LEFT ? --button : ++button) < 0) + ? 2 : (button > 2 ? 0 : button); + + print_buttons(dialog, height, width, button); + wrefresh (menu); + break; + case ' ': + case 's': + case 'y': + case 'n': + case 'm': + case '/': + /* save scroll info */ + if ( (f=fopen("lxdialog.scrltmp","w")) != NULL ) { + fprintf(f,"%d\n",scroll); + fclose(f); + } + delwin (dialog); + fprintf(stderr, "%s\n", items[(scroll + choice) * 2]); + switch (key) { + case 's': return 3; + case 'y': return 3; + case 'n': return 4; + case 'm': return 5; + case ' ': return 6; + case '/': return 7; + } + return 0; + case 'h': + case '?': + button = 2; + case '\n': + delwin (dialog); + if (button == 2) + fprintf(stderr, "%s \"%s\"\n", + items[(scroll + choice) * 2], + items[(scroll + choice) * 2 + 1] + + first_alpha(items[(scroll + choice) * 2 + 1],"")); + else + fprintf(stderr, "%s\n", items[(scroll + choice) * 2]); + + remove("lxdialog.scrltmp"); + return button; + case 'e': + case 'x': + key = ESC; + case ESC: + break; + } + } + + delwin (dialog); + remove("lxdialog.scrltmp"); + return -1; /* ESC pressed */ +} diff --git a/trunk/scripts/lxdialog/msgbox.c b/trunk/scripts/lxdialog/msgbox.c new file mode 100644 index 000000000000..93692e1fbcc2 --- /dev/null +++ b/trunk/scripts/lxdialog/msgbox.c @@ -0,0 +1,85 @@ +/* + * msgbox.c -- implements the message box and info box + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcapw@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "dialog.h" + +/* + * Display a message box. Program will pause and display an "OK" button + * if the parameter 'pause' is non-zero. + */ +int +dialog_msgbox (const char *title, const char *prompt, int height, int width, + int pause) +{ + int i, x, y, key = 0; + WINDOW *dialog; + + /* center dialog box on screen */ + x = (COLS - width) / 2; + y = (LINES - height) / 2; + + draw_shadow (stdscr, y, x, height, width); + + dialog = newwin (height, width, y, x); + keypad (dialog, TRUE); + + draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); + + if (title != NULL && strlen(title) >= width-2 ) { + /* truncate long title -- mec */ + char * title2 = malloc(width-2+1); + memcpy( title2, title, width-2 ); + title2[width-2] = '\0'; + title = title2; + } + + if (title != NULL) { + wattrset (dialog, title_attr); + mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); + waddstr (dialog, (char *)title); + waddch (dialog, ' '); + } + wattrset (dialog, dialog_attr); + print_autowrap (dialog, prompt, width - 2, 1, 2); + + if (pause) { + wattrset (dialog, border_attr); + mvwaddch (dialog, height - 3, 0, ACS_LTEE); + for (i = 0; i < width - 2; i++) + waddch (dialog, ACS_HLINE); + wattrset (dialog, dialog_attr); + waddch (dialog, ACS_RTEE); + + print_button (dialog, " Ok ", + height - 2, width / 2 - 4, TRUE); + + wrefresh (dialog); + while (key != ESC && key != '\n' && key != ' ' && + key != 'O' && key != 'o' && key != 'X' && key != 'x') + key = wgetch (dialog); + } else { + key = '\n'; + wrefresh (dialog); + } + + delwin (dialog); + return key == ESC ? -1 : 0; +} diff --git a/trunk/scripts/lxdialog/textbox.c b/trunk/scripts/lxdialog/textbox.c new file mode 100644 index 000000000000..ed23df2d096a --- /dev/null +++ b/trunk/scripts/lxdialog/textbox.c @@ -0,0 +1,556 @@ +/* + * textbox.c -- implements the text box + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "dialog.h" + +static void back_lines (int n); +static void print_page (WINDOW * win, int height, int width); +static void print_line (WINDOW * win, int row, int width); +static char *get_line (void); +static void print_position (WINDOW * win, int height, int width); + +static int hscroll, fd, file_size, bytes_read; +static int begin_reached = 1, end_reached, page_length; +static char *buf, *page; + +/* + * Display text from a file in a dialog box. + */ +int +dialog_textbox (const char *title, const char *file, int height, int width) +{ + int i, x, y, cur_x, cur_y, fpos, key = 0; + int passed_end; + char search_term[MAX_LEN + 1]; + WINDOW *dialog, *text; + + search_term[0] = '\0'; /* no search term entered yet */ + + /* Open input file for reading */ + if ((fd = open (file, O_RDONLY)) == -1) { + endwin (); + fprintf (stderr, + "\nCan't open input file in dialog_textbox().\n"); + exit (-1); + } + /* Get file size. Actually, 'file_size' is the real file size - 1, + since it's only the last byte offset from the beginning */ + if ((file_size = lseek (fd, 0, SEEK_END)) == -1) { + endwin (); + fprintf (stderr, "\nError getting file size in dialog_textbox().\n"); + exit (-1); + } + /* Restore file pointer to beginning of file after getting file size */ + if (lseek (fd, 0, SEEK_SET) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer in dialog_textbox().\n"); + exit (-1); + } + /* Allocate space for read buffer */ + if ((buf = malloc (BUF_SIZE + 1)) == NULL) { + endwin (); + fprintf (stderr, "\nCan't allocate memory in dialog_textbox().\n"); + exit (-1); + } + if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { + endwin (); + fprintf (stderr, "\nError reading file in dialog_textbox().\n"); + exit (-1); + } + buf[bytes_read] = '\0'; /* mark end of valid data */ + page = buf; /* page is pointer to start of page to be displayed */ + + /* center dialog box on screen */ + x = (COLS - width) / 2; + y = (LINES - height) / 2; + + + draw_shadow (stdscr, y, x, height, width); + + dialog = newwin (height, width, y, x); + keypad (dialog, TRUE); + + /* Create window for text region, used for scrolling text */ + text = subwin (dialog, height - 4, width - 2, y + 1, x + 1); + wattrset (text, dialog_attr); + wbkgdset (text, dialog_attr & A_COLOR); + + keypad (text, TRUE); + + /* register the new window, along with its borders */ + draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); + + wattrset (dialog, border_attr); + mvwaddch (dialog, height-3, 0, ACS_LTEE); + for (i = 0; i < width - 2; i++) + waddch (dialog, ACS_HLINE); + wattrset (dialog, dialog_attr); + wbkgdset (dialog, dialog_attr & A_COLOR); + waddch (dialog, ACS_RTEE); + + if (title != NULL && strlen(title) >= width-2 ) { + /* truncate long title -- mec */ + char * title2 = malloc(width-2+1); + memcpy( title2, title, width-2 ); + title2[width-2] = '\0'; + title = title2; + } + + if (title != NULL) { + wattrset (dialog, title_attr); + mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); + waddstr (dialog, (char *)title); + waddch (dialog, ' '); + } + print_button (dialog, " Exit ", height - 2, width / 2 - 4, TRUE); + wnoutrefresh (dialog); + getyx (dialog, cur_y, cur_x); /* Save cursor position */ + + /* Print first page of text */ + attr_clear (text, height - 4, width - 2, dialog_attr); + print_page (text, height - 4, width - 2); + print_position (dialog, height, width); + wmove (dialog, cur_y, cur_x); /* Restore cursor position */ + wrefresh (dialog); + + while ((key != ESC) && (key != '\n')) { + key = wgetch (dialog); + switch (key) { + case 'E': /* Exit */ + case 'e': + case 'X': + case 'x': + delwin (dialog); + free (buf); + close (fd); + return 0; + case 'g': /* First page */ + case KEY_HOME: + if (!begin_reached) { + begin_reached = 1; + /* First page not in buffer? */ + if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { + endwin (); + fprintf (stderr, + "\nError moving file pointer in dialog_textbox().\n"); + exit (-1); + } + if (fpos > bytes_read) { /* Yes, we have to read it in */ + if (lseek (fd, 0, SEEK_SET) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer in " + "dialog_textbox().\n"); + exit (-1); + } + if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { + endwin (); + fprintf (stderr, + "\nError reading file in dialog_textbox().\n"); + exit (-1); + } + buf[bytes_read] = '\0'; + } + page = buf; + print_page (text, height - 4, width - 2); + print_position (dialog, height, width); + wmove (dialog, cur_y, cur_x); /* Restore cursor position */ + wrefresh (dialog); + } + break; + case 'G': /* Last page */ + case KEY_END: + + end_reached = 1; + /* Last page not in buffer? */ + if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { + endwin (); + fprintf (stderr, + "\nError moving file pointer in dialog_textbox().\n"); + exit (-1); + } + if (fpos < file_size) { /* Yes, we have to read it in */ + if (lseek (fd, -BUF_SIZE, SEEK_END) == -1) { + endwin (); + fprintf (stderr, + "\nError moving file pointer in dialog_textbox().\n"); + exit (-1); + } + if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { + endwin (); + fprintf (stderr, + "\nError reading file in dialog_textbox().\n"); + exit (-1); + } + buf[bytes_read] = '\0'; + } + page = buf + bytes_read; + back_lines (height - 4); + print_page (text, height - 4, width - 2); + print_position (dialog, height, width); + wmove (dialog, cur_y, cur_x); /* Restore cursor position */ + wrefresh (dialog); + break; + case 'K': /* Previous line */ + case 'k': + case KEY_UP: + if (!begin_reached) { + back_lines (page_length + 1); + + /* We don't call print_page() here but use scrolling to ensure + faster screen update. However, 'end_reached' and + 'page_length' should still be updated, and 'page' should + point to start of next page. This is done by calling + get_line() in the following 'for' loop. */ + scrollok (text, TRUE); + wscrl (text, -1); /* Scroll text region down one line */ + scrollok (text, FALSE); + page_length = 0; + passed_end = 0; + for (i = 0; i < height - 4; i++) { + if (!i) { + /* print first line of page */ + print_line (text, 0, width - 2); + wnoutrefresh (text); + } else + /* Called to update 'end_reached' and 'page' */ + get_line (); + if (!passed_end) + page_length++; + if (end_reached && !passed_end) + passed_end = 1; + } + + print_position (dialog, height, width); + wmove (dialog, cur_y, cur_x); /* Restore cursor position */ + wrefresh (dialog); + } + break; + case 'B': /* Previous page */ + case 'b': + case KEY_PPAGE: + if (begin_reached) + break; + back_lines (page_length + height - 4); + print_page (text, height - 4, width - 2); + print_position (dialog, height, width); + wmove (dialog, cur_y, cur_x); + wrefresh (dialog); + break; + case 'J': /* Next line */ + case 'j': + case KEY_DOWN: + if (!end_reached) { + begin_reached = 0; + scrollok (text, TRUE); + scroll (text); /* Scroll text region up one line */ + scrollok (text, FALSE); + print_line (text, height - 5, width - 2); + wnoutrefresh (text); + print_position (dialog, height, width); + wmove (dialog, cur_y, cur_x); /* Restore cursor position */ + wrefresh (dialog); + } + break; + case KEY_NPAGE: /* Next page */ + case ' ': + if (end_reached) + break; + + begin_reached = 0; + print_page (text, height - 4, width - 2); + print_position (dialog, height, width); + wmove (dialog, cur_y, cur_x); + wrefresh (dialog); + break; + case '0': /* Beginning of line */ + case 'H': /* Scroll left */ + case 'h': + case KEY_LEFT: + if (hscroll <= 0) + break; + + if (key == '0') + hscroll = 0; + else + hscroll--; + /* Reprint current page to scroll horizontally */ + back_lines (page_length); + print_page (text, height - 4, width - 2); + wmove (dialog, cur_y, cur_x); + wrefresh (dialog); + break; + case 'L': /* Scroll right */ + case 'l': + case KEY_RIGHT: + if (hscroll >= MAX_LEN) + break; + hscroll++; + /* Reprint current page to scroll horizontally */ + back_lines (page_length); + print_page (text, height - 4, width - 2); + wmove (dialog, cur_y, cur_x); + wrefresh (dialog); + break; + case ESC: + break; + } + } + + delwin (dialog); + free (buf); + close (fd); + return -1; /* ESC pressed */ +} + +/* + * Go back 'n' lines in text file. Called by dialog_textbox(). + * 'page' will be updated to point to the desired line in 'buf'. + */ +static void +back_lines (int n) +{ + int i, fpos; + + begin_reached = 0; + /* We have to distinguish between end_reached and !end_reached + since at end of file, the line is not ended by a '\n'. + The code inside 'if' basically does a '--page' to move one + character backward so as to skip '\n' of the previous line */ + if (!end_reached) { + /* Either beginning of buffer or beginning of file reached? */ + if (page == buf) { + if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer in " + "back_lines().\n"); + exit (-1); + } + if (fpos > bytes_read) { /* Not beginning of file yet */ + /* We've reached beginning of buffer, but not beginning of + file yet, so read previous part of file into buffer. + Note that we only move backward for BUF_SIZE/2 bytes, + but not BUF_SIZE bytes to avoid re-reading again in + print_page() later */ + /* Really possible to move backward BUF_SIZE/2 bytes? */ + if (fpos < BUF_SIZE / 2 + bytes_read) { + /* No, move less then */ + if (lseek (fd, 0, SEEK_SET) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer in " + "back_lines().\n"); + exit (-1); + } + page = buf + fpos - bytes_read; + } else { /* Move backward BUF_SIZE/2 bytes */ + if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), SEEK_CUR) + == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer " + "in back_lines().\n"); + exit (-1); + } + page = buf + BUF_SIZE / 2; + } + if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { + endwin (); + fprintf (stderr, "\nError reading file in back_lines().\n"); + exit (-1); + } + buf[bytes_read] = '\0'; + } else { /* Beginning of file reached */ + begin_reached = 1; + return; + } + } + if (*(--page) != '\n') { /* '--page' here */ + /* Something's wrong... */ + endwin (); + fprintf (stderr, "\nInternal error in back_lines().\n"); + exit (-1); + } + } + /* Go back 'n' lines */ + for (i = 0; i < n; i++) + do { + if (page == buf) { + if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { + endwin (); + fprintf (stderr, + "\nError moving file pointer in back_lines().\n"); + exit (-1); + } + if (fpos > bytes_read) { + /* Really possible to move backward BUF_SIZE/2 bytes? */ + if (fpos < BUF_SIZE / 2 + bytes_read) { + /* No, move less then */ + if (lseek (fd, 0, SEEK_SET) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer " + "in back_lines().\n"); + exit (-1); + } + page = buf + fpos - bytes_read; + } else { /* Move backward BUF_SIZE/2 bytes */ + if (lseek (fd, -(BUF_SIZE / 2 + bytes_read), + SEEK_CUR) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer" + " in back_lines().\n"); + exit (-1); + } + page = buf + BUF_SIZE / 2; + } + if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { + endwin (); + fprintf (stderr, "\nError reading file in " + "back_lines().\n"); + exit (-1); + } + buf[bytes_read] = '\0'; + } else { /* Beginning of file reached */ + begin_reached = 1; + return; + } + } + } while (*(--page) != '\n'); + page++; +} + +/* + * Print a new page of text. Called by dialog_textbox(). + */ +static void +print_page (WINDOW * win, int height, int width) +{ + int i, passed_end = 0; + + page_length = 0; + for (i = 0; i < height; i++) { + print_line (win, i, width); + if (!passed_end) + page_length++; + if (end_reached && !passed_end) + passed_end = 1; + } + wnoutrefresh (win); +} + +/* + * Print a new line of text. Called by dialog_textbox() and print_page(). + */ +static void +print_line (WINDOW * win, int row, int width) +{ + int y, x; + char *line; + + line = get_line (); + line += MIN (strlen (line), hscroll); /* Scroll horizontally */ + wmove (win, row, 0); /* move cursor to correct line */ + waddch (win, ' '); + waddnstr (win, line, MIN (strlen (line), width - 2)); + + getyx (win, y, x); + /* Clear 'residue' of previous line */ +#if OLD_NCURSES + { + int i; + for (i = 0; i < width - x; i++) + waddch (win, ' '); + } +#else + wclrtoeol(win); +#endif +} + +/* + * Return current line of text. Called by dialog_textbox() and print_line(). + * 'page' should point to start of current line before calling, and will be + * updated to point to start of next line. + */ +static char * +get_line (void) +{ + int i = 0, fpos; + static char line[MAX_LEN + 1]; + + end_reached = 0; + while (*page != '\n') { + if (*page == '\0') { + /* Either end of file or end of buffer reached */ + if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer in " + "get_line().\n"); + exit (-1); + } + if (fpos < file_size) { /* Not end of file yet */ + /* We've reached end of buffer, but not end of file yet, + so read next part of file into buffer */ + if ((bytes_read = read (fd, buf, BUF_SIZE)) == -1) { + endwin (); + fprintf (stderr, "\nError reading file in get_line().\n"); + exit (-1); + } + buf[bytes_read] = '\0'; + page = buf; + } else { + if (!end_reached) + end_reached = 1; + break; + } + } else if (i < MAX_LEN) + line[i++] = *(page++); + else { + /* Truncate lines longer than MAX_LEN characters */ + if (i == MAX_LEN) + line[i++] = '\0'; + page++; + } + } + if (i <= MAX_LEN) + line[i] = '\0'; + if (!end_reached) + page++; /* move pass '\n' */ + + return line; +} + +/* + * Print current position + */ +static void +print_position (WINDOW * win, int height, int width) +{ + int fpos, percent; + + if ((fpos = lseek (fd, 0, SEEK_CUR)) == -1) { + endwin (); + fprintf (stderr, "\nError moving file pointer in print_position().\n"); + exit (-1); + } + wattrset (win, position_indicator_attr); + wbkgdset (win, position_indicator_attr & A_COLOR); + percent = !file_size ? + 100 : ((fpos - bytes_read + page - buf) * 100) / file_size; + wmove (win, height - 3, width - 9); + wprintw (win, "(%3d%%)", percent); +} diff --git a/trunk/scripts/lxdialog/util.c b/trunk/scripts/lxdialog/util.c new file mode 100644 index 000000000000..e7bce9be69c3 --- /dev/null +++ b/trunk/scripts/lxdialog/util.c @@ -0,0 +1,359 @@ +/* + * util.c + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "dialog.h" + + +/* use colors by default? */ +bool use_colors = 1; + +const char *backtitle = NULL; + +const char *dialog_result; + +/* + * Attribute values, default is for mono display + */ +chtype attributes[] = +{ + A_NORMAL, /* screen_attr */ + A_NORMAL, /* shadow_attr */ + A_NORMAL, /* dialog_attr */ + A_BOLD, /* title_attr */ + A_NORMAL, /* border_attr */ + A_REVERSE, /* button_active_attr */ + A_DIM, /* button_inactive_attr */ + A_REVERSE, /* button_key_active_attr */ + A_BOLD, /* button_key_inactive_attr */ + A_REVERSE, /* button_label_active_attr */ + A_NORMAL, /* button_label_inactive_attr */ + A_NORMAL, /* inputbox_attr */ + A_NORMAL, /* inputbox_border_attr */ + A_NORMAL, /* searchbox_attr */ + A_BOLD, /* searchbox_title_attr */ + A_NORMAL, /* searchbox_border_attr */ + A_BOLD, /* position_indicator_attr */ + A_NORMAL, /* menubox_attr */ + A_NORMAL, /* menubox_border_attr */ + A_NORMAL, /* item_attr */ + A_REVERSE, /* item_selected_attr */ + A_BOLD, /* tag_attr */ + A_REVERSE, /* tag_selected_attr */ + A_BOLD, /* tag_key_attr */ + A_REVERSE, /* tag_key_selected_attr */ + A_BOLD, /* check_attr */ + A_REVERSE, /* check_selected_attr */ + A_BOLD, /* uarrow_attr */ + A_BOLD /* darrow_attr */ +}; + + +#include "colors.h" + +/* + * Table of color values + */ +int color_table[][3] = +{ + {SCREEN_FG, SCREEN_BG, SCREEN_HL}, + {SHADOW_FG, SHADOW_BG, SHADOW_HL}, + {DIALOG_FG, DIALOG_BG, DIALOG_HL}, + {TITLE_FG, TITLE_BG, TITLE_HL}, + {BORDER_FG, BORDER_BG, BORDER_HL}, + {BUTTON_ACTIVE_FG, BUTTON_ACTIVE_BG, BUTTON_ACTIVE_HL}, + {BUTTON_INACTIVE_FG, BUTTON_INACTIVE_BG, BUTTON_INACTIVE_HL}, + {BUTTON_KEY_ACTIVE_FG, BUTTON_KEY_ACTIVE_BG, BUTTON_KEY_ACTIVE_HL}, + {BUTTON_KEY_INACTIVE_FG, BUTTON_KEY_INACTIVE_BG, BUTTON_KEY_INACTIVE_HL}, + {BUTTON_LABEL_ACTIVE_FG, BUTTON_LABEL_ACTIVE_BG, BUTTON_LABEL_ACTIVE_HL}, + {BUTTON_LABEL_INACTIVE_FG, BUTTON_LABEL_INACTIVE_BG, + BUTTON_LABEL_INACTIVE_HL}, + {INPUTBOX_FG, INPUTBOX_BG, INPUTBOX_HL}, + {INPUTBOX_BORDER_FG, INPUTBOX_BORDER_BG, INPUTBOX_BORDER_HL}, + {SEARCHBOX_FG, SEARCHBOX_BG, SEARCHBOX_HL}, + {SEARCHBOX_TITLE_FG, SEARCHBOX_TITLE_BG, SEARCHBOX_TITLE_HL}, + {SEARCHBOX_BORDER_FG, SEARCHBOX_BORDER_BG, SEARCHBOX_BORDER_HL}, + {POSITION_INDICATOR_FG, POSITION_INDICATOR_BG, POSITION_INDICATOR_HL}, + {MENUBOX_FG, MENUBOX_BG, MENUBOX_HL}, + {MENUBOX_BORDER_FG, MENUBOX_BORDER_BG, MENUBOX_BORDER_HL}, + {ITEM_FG, ITEM_BG, ITEM_HL}, + {ITEM_SELECTED_FG, ITEM_SELECTED_BG, ITEM_SELECTED_HL}, + {TAG_FG, TAG_BG, TAG_HL}, + {TAG_SELECTED_FG, TAG_SELECTED_BG, TAG_SELECTED_HL}, + {TAG_KEY_FG, TAG_KEY_BG, TAG_KEY_HL}, + {TAG_KEY_SELECTED_FG, TAG_KEY_SELECTED_BG, TAG_KEY_SELECTED_HL}, + {CHECK_FG, CHECK_BG, CHECK_HL}, + {CHECK_SELECTED_FG, CHECK_SELECTED_BG, CHECK_SELECTED_HL}, + {UARROW_FG, UARROW_BG, UARROW_HL}, + {DARROW_FG, DARROW_BG, DARROW_HL}, +}; /* color_table */ + +/* + * Set window to attribute 'attr' + */ +void +attr_clear (WINDOW * win, int height, int width, chtype attr) +{ + int i, j; + + wattrset (win, attr); + for (i = 0; i < height; i++) { + wmove (win, i, 0); + for (j = 0; j < width; j++) + waddch (win, ' '); + } + touchwin (win); +} + +void dialog_clear (void) +{ + attr_clear (stdscr, LINES, COLS, screen_attr); + /* Display background title if it exists ... - SLH */ + if (backtitle != NULL) { + int i; + + wattrset (stdscr, screen_attr); + mvwaddstr (stdscr, 0, 1, (char *)backtitle); + wmove (stdscr, 1, 1); + for (i = 1; i < COLS - 1; i++) + waddch (stdscr, ACS_HLINE); + } + wnoutrefresh (stdscr); +} + +/* + * Do some initialization for dialog + */ +void +init_dialog (void) +{ + initscr (); /* Init curses */ + keypad (stdscr, TRUE); + cbreak (); + noecho (); + + + if (use_colors) /* Set up colors */ + color_setup (); + + + dialog_clear (); +} + +/* + * Setup for color display + */ +void +color_setup (void) +{ + int i; + + if (has_colors ()) { /* Terminal supports color? */ + start_color (); + + /* Initialize color pairs */ + for (i = 0; i < ATTRIBUTE_COUNT; i++) + init_pair (i + 1, color_table[i][0], color_table[i][1]); + + /* Setup color attributes */ + for (i = 0; i < ATTRIBUTE_COUNT; i++) + attributes[i] = C_ATTR (color_table[i][2], i + 1); + } +} + +/* + * End using dialog functions. + */ +void +end_dialog (void) +{ + endwin (); +} + + +/* + * Print a string of text in a window, automatically wrap around to the + * next line if the string is too long to fit on one line. Newline + * characters '\n' are replaced by spaces. We start on a new line + * if there is no room for at least 4 nonblanks following a double-space. + */ +void +print_autowrap (WINDOW * win, const char *prompt, int width, int y, int x) +{ + int newl, cur_x, cur_y; + int i, prompt_len, room, wlen; + char tempstr[MAX_LEN + 1], *word, *sp, *sp2; + + strcpy (tempstr, prompt); + + prompt_len = strlen(tempstr); + + /* + * Remove newlines + */ + for(i=0; i<prompt_len; i++) { + if(tempstr[i] == '\n') tempstr[i] = ' '; + } + + if (prompt_len <= width - x * 2) { /* If prompt is short */ + wmove (win, y, (width - prompt_len) / 2); + waddstr (win, tempstr); + } else { + cur_x = x; + cur_y = y; + newl = 1; + word = tempstr; + while (word && *word) { + sp = index(word, ' '); + if (sp) + *sp++ = 0; + + /* Wrap to next line if either the word does not fit, + or it is the first word of a new sentence, and it is + short, and the next word does not fit. */ + room = width - cur_x; + wlen = strlen(word); + if (wlen > room || + (newl && wlen < 4 && sp && wlen+1+strlen(sp) > room + && (!(sp2 = index(sp, ' ')) || wlen+1+(sp2-sp) > room))) { + cur_y++; + cur_x = x; + } + wmove (win, cur_y, cur_x); + waddstr (win, word); + getyx (win, cur_y, cur_x); + cur_x++; + if (sp && *sp == ' ') { + cur_x++; /* double space */ + while (*++sp == ' '); + newl = 1; + } else + newl = 0; + word = sp; + } + } +} + +/* + * Print a button + */ +void +print_button (WINDOW * win, const char *label, int y, int x, int selected) +{ + int i, temp; + + wmove (win, y, x); + wattrset (win, selected ? button_active_attr : button_inactive_attr); + waddstr (win, "<"); + temp = strspn (label, " "); + label += temp; + wattrset (win, selected ? button_label_active_attr + : button_label_inactive_attr); + for (i = 0; i < temp; i++) + waddch (win, ' '); + wattrset (win, selected ? button_key_active_attr + : button_key_inactive_attr); + waddch (win, label[0]); + wattrset (win, selected ? button_label_active_attr + : button_label_inactive_attr); + waddstr (win, (char *)label + 1); + wattrset (win, selected ? button_active_attr : button_inactive_attr); + waddstr (win, ">"); + wmove (win, y, x + temp + 1); +} + +/* + * Draw a rectangular box with line drawing characters + */ +void +draw_box (WINDOW * win, int y, int x, int height, int width, + chtype box, chtype border) +{ + int i, j; + + wattrset (win, 0); + for (i = 0; i < height; i++) { + wmove (win, y + i, x); + for (j = 0; j < width; j++) + if (!i && !j) + waddch (win, border | ACS_ULCORNER); + else if (i == height - 1 && !j) + waddch (win, border | ACS_LLCORNER); + else if (!i && j == width - 1) + waddch (win, box | ACS_URCORNER); + else if (i == height - 1 && j == width - 1) + waddch (win, box | ACS_LRCORNER); + else if (!i) + waddch (win, border | ACS_HLINE); + else if (i == height - 1) + waddch (win, box | ACS_HLINE); + else if (!j) + waddch (win, border | ACS_VLINE); + else if (j == width - 1) + waddch (win, box | ACS_VLINE); + else + waddch (win, box | ' '); + } +} + +/* + * Draw shadows along the right and bottom edge to give a more 3D look + * to the boxes + */ +void +draw_shadow (WINDOW * win, int y, int x, int height, int width) +{ + int i; + + if (has_colors ()) { /* Whether terminal supports color? */ + wattrset (win, shadow_attr); + wmove (win, y + height, x + 2); + for (i = 0; i < width; i++) + waddch (win, winch (win) & A_CHARTEXT); + for (i = y + 1; i < y + height + 1; i++) { + wmove (win, i, x + width); + waddch (win, winch (win) & A_CHARTEXT); + waddch (win, winch (win) & A_CHARTEXT); + } + wnoutrefresh (win); + } +} + +/* + * Return the position of the first alphabetic character in a string. + */ +int +first_alpha(const char *string, const char *exempt) +{ + int i, in_paren=0, c; + + for (i = 0; i < strlen(string); i++) { + c = tolower(string[i]); + + if (strchr("<[(", c)) ++in_paren; + if (strchr(">])", c) && in_paren > 0) --in_paren; + + if ((! in_paren) && isalpha(c) && + strchr(exempt, c) == 0) + return i; + } + + return 0; +} diff --git a/trunk/scripts/lxdialog/yesno.c b/trunk/scripts/lxdialog/yesno.c new file mode 100644 index 000000000000..11fcc25f5159 --- /dev/null +++ b/trunk/scripts/lxdialog/yesno.c @@ -0,0 +1,118 @@ +/* + * yesno.c -- implements the yes/no box + * + * ORIGINAL AUTHOR: Savio Lam (lam836@cs.cuhk.hk) + * MODIFIED FOR LINUX KERNEL CONFIG BY: William Roadcap (roadcap@cfw.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "dialog.h" + +/* + * Display termination buttons + */ +static void +print_buttons(WINDOW *dialog, int height, int width, int selected) +{ + int x = width / 2 - 10; + int y = height - 2; + + print_button (dialog, " Yes ", y, x, selected == 0); + print_button (dialog, " No ", y, x + 13, selected == 1); + + wmove(dialog, y, x+1 + 13*selected ); + wrefresh (dialog); +} + +/* + * Display a dialog box with two buttons - Yes and No + */ +int +dialog_yesno (const char *title, const char *prompt, int height, int width) +{ + int i, x, y, key = 0, button = 0; + WINDOW *dialog; + + /* center dialog box on screen */ + x = (COLS - width) / 2; + y = (LINES - height) / 2; + + draw_shadow (stdscr, y, x, height, width); + + dialog = newwin (height, width, y, x); + keypad (dialog, TRUE); + + draw_box (dialog, 0, 0, height, width, dialog_attr, border_attr); + wattrset (dialog, border_attr); + mvwaddch (dialog, height-3, 0, ACS_LTEE); + for (i = 0; i < width - 2; i++) + waddch (dialog, ACS_HLINE); + wattrset (dialog, dialog_attr); + waddch (dialog, ACS_RTEE); + + if (title != NULL && strlen(title) >= width-2 ) { + /* truncate long title -- mec */ + char * title2 = malloc(width-2+1); + memcpy( title2, title, width-2 ); + title2[width-2] = '\0'; + title = title2; + } + + if (title != NULL) { + wattrset (dialog, title_attr); + mvwaddch (dialog, 0, (width - strlen(title))/2 - 1, ' '); + waddstr (dialog, (char *)title); + waddch (dialog, ' '); + } + + wattrset (dialog, dialog_attr); + print_autowrap (dialog, prompt, width - 2, 1, 3); + + print_buttons(dialog, height, width, 0); + + while (key != ESC) { + key = wgetch (dialog); + switch (key) { + case 'Y': + case 'y': + delwin (dialog); + return 0; + case 'N': + case 'n': + delwin (dialog); + return 1; + + case TAB: + case KEY_LEFT: + case KEY_RIGHT: + button = ((key == KEY_LEFT ? --button : ++button) < 0) + ? 1 : (button > 1 ? 0 : button); + + print_buttons(dialog, height, width, button); + wrefresh (dialog); + break; + case ' ': + case '\n': + delwin (dialog); + return button; + case ESC: + break; + } + } + + delwin (dialog); + return -1; /* ESC pressed */ +} diff --git a/trunk/scripts/mod/file2alias.c b/trunk/scripts/mod/file2alias.c index e0eedffe565b..e3d144a3f10b 100644 --- a/trunk/scripts/mod/file2alias.c +++ b/trunk/scripts/mod/file2alias.c @@ -16,10 +16,8 @@ * use either stdint.h or inttypes.h for the rest. */ #if KERNEL_ELFCLASS == ELFCLASS32 typedef Elf32_Addr kernel_ulong_t; -#define BITS_PER_LONG 32 #else typedef Elf64_Addr kernel_ulong_t; -#define BITS_PER_LONG 64 #endif #ifdef __sun__ #include <inttypes.h> @@ -37,7 +35,6 @@ typedef unsigned char __u8; * even potentially has different endianness and word sizes, since * we handle those differences explicitly below */ #include "../../include/linux/mod_devicetable.h" -#include "../../include/linux/input.h" #define ADD(str, sep, cond, field) \ do { \ @@ -369,61 +366,6 @@ static int do_i2c_entry(const char *filename, struct i2c_device_id *i2c, char *a return 1; } -#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) - -static void do_input(char *alias, - kernel_ulong_t *arr, unsigned int min, unsigned int max) -{ - unsigned int i; - for (i = min; i < max; i++) { - if (arr[i/BITS_PER_LONG] & (1 << (i%BITS_PER_LONG))) - sprintf(alias+strlen(alias), "%X,*", i); - } -} - -/* input:b0v0p0e0-eXkXrXaXmXlXsXfXwX where X is comma-separated %02X. */ -static int do_input_entry(const char *filename, struct input_device_id *id, - char *alias) -{ - sprintf(alias, "input:"); - - ADD(alias, "b", id->flags&INPUT_DEVICE_ID_MATCH_BUS, id->id.bustype); - ADD(alias, "v", id->flags&INPUT_DEVICE_ID_MATCH_VENDOR, id->id.vendor); - ADD(alias, "p", id->flags&INPUT_DEVICE_ID_MATCH_PRODUCT, - id->id.product); - ADD(alias, "e", id->flags&INPUT_DEVICE_ID_MATCH_VERSION, - id->id.version); - - sprintf(alias + strlen(alias), "-e*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_EVBIT) - do_input(alias, id->evbit, 0, EV_MAX); - sprintf(alias + strlen(alias), "k*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_KEYBIT) - do_input(alias, id->keybit, KEY_MIN_INTERESTING, KEY_MAX); - sprintf(alias + strlen(alias), "r*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_RELBIT) - do_input(alias, id->relbit, 0, REL_MAX); - sprintf(alias + strlen(alias), "a*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_ABSBIT) - do_input(alias, id->absbit, 0, ABS_MAX); - sprintf(alias + strlen(alias), "m*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_MSCIT) - do_input(alias, id->mscbit, 0, MSC_MAX); - sprintf(alias + strlen(alias), "l*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_LEDBIT) - do_input(alias, id->ledbit, 0, LED_MAX); - sprintf(alias + strlen(alias), "s*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_SNDBIT) - do_input(alias, id->sndbit, 0, SND_MAX); - sprintf(alias + strlen(alias), "f*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_FFBIT) - do_input(alias, id->ffbit, 0, SND_MAX); - sprintf(alias + strlen(alias), "w*"); - if (id->flags&INPUT_DEVICE_ID_MATCH_SWBIT) - do_input(alias, id->swbit, 0, SW_MAX); - return 1; -} - /* Ignore any prefix, eg. v850 prepends _ */ static inline int sym_is(const char *symbol, const char *name) { @@ -511,9 +453,7 @@ void handle_moddevtable(struct module *mod, struct elf_info *info, else if (sym_is(symname, "__mod_i2c_device_table")) do_table(symval, sym->st_size, sizeof(struct i2c_device_id), do_i2c_entry, mod); - else if (sym_is(symname, "__mod_input_device_table")) - do_table(symval, sym->st_size, sizeof(struct input_device_id), - do_input_entry, mod); + } /* Now add out buffered information to the generated C source */ diff --git a/trunk/scripts/mod/modpost.c b/trunk/scripts/mod/modpost.c index f70ff13d4818..3bed09e625c0 100644 --- a/trunk/scripts/mod/modpost.c +++ b/trunk/scripts/mod/modpost.c @@ -326,8 +326,8 @@ parse_elf_finish(struct elf_info *info) release_file(info->hdr, info->size); } -#define CRC_PFX "__crc_" -#define KSYMTAB_PFX "__ksymtab_" +#define CRC_PFX MODULE_SYMBOL_PREFIX "__crc_" +#define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_" void handle_modversions(struct module *mod, struct elf_info *info, @@ -539,9 +539,10 @@ add_header(struct buffer *b, struct module *mod) buf_printf(b, "\n"); buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n"); buf_printf(b, "\n"); + buf_printf(b, "#undef unix\n"); /* We have a module called "unix" */ buf_printf(b, "struct module __this_module\n"); buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n"); - buf_printf(b, " .name = KBUILD_MODNAME,\n"); + buf_printf(b, " .name = __stringify(KBUILD_MODNAME),\n"); if (mod->has_init) buf_printf(b, " .init = init_module,\n"); if (mod->has_cleanup) diff --git a/trunk/scripts/package/Makefile b/trunk/scripts/package/Makefile index c201ef001f09..f3e7e8e4a500 100644 --- a/trunk/scripts/package/Makefile +++ b/trunk/scripts/package/Makefile @@ -84,7 +84,7 @@ clean-dirs += $(objtree)/debian/ # --------------------------------------------------------------------------- .PHONY: tar%pkg tar%pkg: - $(MAKE) KBUILD_SRC= + $(MAKE) $(CONFIG_SHELL) $(srctree)/scripts/package/buildtar $@ clean-dirs += $(objtree)/tar-install/ diff --git a/trunk/scripts/package/buildtar b/trunk/scripts/package/buildtar index 88b5281ac41e..d8fffe6f8906 100644 --- a/trunk/scripts/package/buildtar +++ b/trunk/scripts/package/buildtar @@ -1,9 +1,9 @@ #!/bin/sh # -# buildtar 0.0.4 +# buildtar 0.0.3 # -# (C) 2004-2006 by Jan-Benedict Glaw <jbglaw@lug-owl.de> +# (C) 2004-2005 by Jan-Benedict Glaw <jbglaw@lug-owl.de> # # This script is used to compile a tarball from the currently # prepared kernel. Based upon the builddeb script from @@ -15,8 +15,9 @@ set -e # # Some variables and settings used throughout the script # +version="${VERSION}.${PATCHLEVEL}.${SUBLEVEL}${EXTRAVERSION}${EXTRANAME}" tmpdir="${objtree}/tar-install" -tarball="${objtree}/linux-${KERNELRELEASE}.tar" +tarball="${objtree}/linux-${version}.tar" # @@ -52,17 +53,21 @@ mkdir -p -- "${tmpdir}/boot" # # Try to install modules # -if grep -q '^CONFIG_MODULES=y' "${objtree}/.config"; then - make ARCH="${ARCH}" O="${objtree}" KBUILD_SRC= INSTALL_MOD_PATH="${tmpdir}" modules_install +if ! make INSTALL_MOD_PATH="${tmpdir}" modules_install; then + echo "" >&2 + echo "Ignoring error at module_install time, since that could be" >&2 + echo "a result of missing local modutils/module-init-tools," >&2 + echo "or you just didn't compile in module support at all..." >&2 + echo "" >&2 fi # # Install basic kernel files # -cp -v -- "${objtree}/System.map" "${tmpdir}/boot/System.map-${KERNELRELEASE}" -cp -v -- "${objtree}/.config" "${tmpdir}/boot/config-${KERNELRELEASE}" -cp -v -- "${objtree}/vmlinux" "${tmpdir}/boot/vmlinux-${KERNELRELEASE}" +cp -v -- System.map "${tmpdir}/boot/System.map-${version}" +cp -v -- .config "${tmpdir}/boot/config-${version}" +cp -v -- vmlinux "${tmpdir}/boot/vmlinux-${version}" # @@ -70,17 +75,17 @@ cp -v -- "${objtree}/vmlinux" "${tmpdir}/boot/vmlinux-${KERNELRELEASE}" # case "${ARCH}" in i386) - [ -f "${objtree}/arch/i386/boot/bzImage" ] && cp -v -- "${objtree}/arch/i386/boot/bzImage" "${tmpdir}/boot/vmlinuz-${KERNELRELEASE}" + [ -f arch/i386/boot/bzImage ] && cp -v -- arch/i386/boot/bzImage "${tmpdir}/boot/vmlinuz-${version}" ;; alpha) - [ -f "${objtree}/arch/alpha/boot/vmlinux.gz" ] && cp -v -- "${objtree}/arch/alpha/boot/vmlinux.gz" "${tmpdir}/boot/vmlinuz-${KERNELRELEASE}" + [ -f arch/alpha/boot/vmlinux.gz ] && cp -v -- arch/alpha/boot/vmlinux.gz "${tmpdir}/boot/vmlinuz-${version}" ;; vax) - [ -f "${objtree}/vmlinux.SYS" ] && cp -v -- "${objtree}/vmlinux.SYS" "${tmpdir}/boot/vmlinux-${KERNELRELEASE}.SYS" - [ -f "${objtree}/vmlinux.dsk" ] && cp -v -- "${objtree}/vmlinux.dsk" "${tmpdir}/boot/vmlinux-${KERNELRELEASE}.dsk" + [ -f vmlinux.SYS ] && cp -v -- vmlinux.SYS "${tmpdir}/boot/vmlinux-${version}.SYS" + [ -f vmlinux.dsk ] && cp -v -- vmlinux.dsk "${tmpdir}/boot/vmlinux-${version}.dsk" ;; *) - [ -f "${KBUILD_IMAGE}" ] && cp -v -- "${KBUILD_IMAGE}" "${tmpdir}/boot/vmlinux-kbuild-${KERNELRELEASE}" + [ -f "${KBUILD_IMAGE}" ] && cp -v -- "${KBUILD_IMAGE}" "${tmpdir}/boot/vmlinux-kbuild-${version}" echo "" >&2 echo '** ** ** WARNING ** ** **' >&2 echo "" >&2 diff --git a/trunk/scripts/patch-kernel b/trunk/scripts/patch-kernel index 67e4b1868e50..f2d47ca9c8fa 100755 --- a/trunk/scripts/patch-kernel +++ b/trunk/scripts/patch-kernel @@ -45,7 +45,7 @@ # update usage message; # fix some whitespace damage; # be smarter about stopping when current version is larger than requested; -# Randy Dunlap <rdunlap@xenotime.net>, 2004-AUG-18. +# Randy Dunlap <rddunlap@osdl.org>, 2004-AUG-18. # # Add better support for (non-incremental) 2.6.x.y patches; # If an ending version number if not specified, the script automatically @@ -56,7 +56,7 @@ # patch-kernel does not normally support reverse patching, but does so when # applying EXTRAVERSION (x.y) patches, so that moving from 2.6.11.y to 2.6.11.z # is easy and handled by the script (reverse 2.6.11.y and apply 2.6.11.z). -# Randy Dunlap <rdunlap@xenotime.net>, 2005-APR-08. +# Randy Dunlap <rddunlap@osdl.org>, 2005-APR-08. PNAME=patch-kernel diff --git a/trunk/security/Kconfig b/trunk/security/Kconfig index 34f593410d57..64d3f1e9ca85 100644 --- a/trunk/security/Kconfig +++ b/trunk/security/Kconfig @@ -54,19 +54,6 @@ config SECURITY_NETWORK implement socket and networking access controls. If you are unsure how to answer this question, answer N. -config SECURITY_NETWORK_XFRM - bool "XFRM (IPSec) Networking Security Hooks" - depends on XFRM && SECURITY_NETWORK - help - This enables the XFRM (IPSec) networking security hooks. - If enabled, a security module can use these hooks to - implement per-packet access controls based on labels - derived from IPSec policy. Non-IPSec communications are - designated as unlabelled, and only sockets authorized - to communicate unlabelled data can send without using - IPSec. - If you are unsure how to answer this question, answer N. - config SECURITY_CAPABILITIES tristate "Default Linux Capabilities" depends on SECURITY diff --git a/trunk/security/dummy.c b/trunk/security/dummy.c index a15c54709fde..3ca5f2b828a0 100644 --- a/trunk/security/dummy.c +++ b/trunk/security/dummy.c @@ -776,42 +776,8 @@ static inline int dummy_sk_alloc_security (struct sock *sk, int family, gfp_t pr static inline void dummy_sk_free_security (struct sock *sk) { } - -static unsigned int dummy_sk_getsid(struct sock *sk, struct flowi *fl, u8 dir) -{ - return 0; -} #endif /* CONFIG_SECURITY_NETWORK */ -#ifdef CONFIG_SECURITY_NETWORK_XFRM -static int dummy_xfrm_policy_alloc_security(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx) -{ - return 0; -} - -static inline int dummy_xfrm_policy_clone_security(struct xfrm_policy *old, struct xfrm_policy *new) -{ - return 0; -} - -static void dummy_xfrm_policy_free_security(struct xfrm_policy *xp) -{ -} - -static int dummy_xfrm_state_alloc_security(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx) -{ - return 0; -} - -static void dummy_xfrm_state_free_security(struct xfrm_state *x) -{ -} - -static int dummy_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir) -{ - return 0; -} -#endif /* CONFIG_SECURITY_NETWORK_XFRM */ static int dummy_register_security (const char *name, struct security_operations *ops) { return -EINVAL; @@ -1004,16 +970,7 @@ void security_fixup_ops (struct security_operations *ops) set_to_dummy_if_null(ops, socket_getpeersec); set_to_dummy_if_null(ops, sk_alloc_security); set_to_dummy_if_null(ops, sk_free_security); - set_to_dummy_if_null(ops, sk_getsid); - #endif /* CONFIG_SECURITY_NETWORK */ -#ifdef CONFIG_SECURITY_NETWORK_XFRM - set_to_dummy_if_null(ops, xfrm_policy_alloc_security); - set_to_dummy_if_null(ops, xfrm_policy_clone_security); - set_to_dummy_if_null(ops, xfrm_policy_free_security); - set_to_dummy_if_null(ops, xfrm_state_alloc_security); - set_to_dummy_if_null(ops, xfrm_state_free_security); - set_to_dummy_if_null(ops, xfrm_policy_lookup); -#endif /* CONFIG_SECURITY_NETWORK_XFRM */ +#endif /* CONFIG_SECURITY_NETWORK */ #ifdef CONFIG_KEYS set_to_dummy_if_null(ops, key_alloc); set_to_dummy_if_null(ops, key_free); diff --git a/trunk/security/selinux/Makefile b/trunk/security/selinux/Makefile index 06d54d9d20a5..b038cd0fae2e 100644 --- a/trunk/security/selinux/Makefile +++ b/trunk/security/selinux/Makefile @@ -8,7 +8,5 @@ selinux-y := avc.o hooks.o selinuxfs.o netlink.o nlmsgtab.o selinux-$(CONFIG_SECURITY_NETWORK) += netif.o -selinux-$(CONFIG_SECURITY_NETWORK_XFRM) += xfrm.o - EXTRA_CFLAGS += -Isecurity/selinux/include diff --git a/trunk/security/selinux/hooks.c b/trunk/security/selinux/hooks.c index 3d496eae1b47..fc774436a264 100644 --- a/trunk/security/selinux/hooks.c +++ b/trunk/security/selinux/hooks.c @@ -73,7 +73,6 @@ #include "avc.h" #include "objsec.h" #include "netif.h" -#include "xfrm.h" #define XATTR_SELINUX_SUFFIX "selinux" #define XATTR_NAME_SELINUX XATTR_SECURITY_PREFIX XATTR_SELINUX_SUFFIX @@ -3350,10 +3349,6 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb) err = avc_has_perm(sock_sid, port_sid, sock_class, recv_perm, &ad); } - - if (!err) - err = selinux_xfrm_sock_rcv_skb(sock_sid, skb); - out: return err; } @@ -3406,24 +3401,6 @@ static void selinux_sk_free_security(struct sock *sk) sk_free_security(sk); } -static unsigned int selinux_sk_getsid_security(struct sock *sk, struct flowi *fl, u8 dir) -{ - struct inode_security_struct *isec; - u32 sock_sid = SECINITSID_ANY_SOCKET; - - if (!sk) - return selinux_no_sk_sid(fl); - - read_lock_bh(&sk->sk_callback_lock); - isec = get_sock_isec(sk); - - if (isec) - sock_sid = isec->sid; - - read_unlock_bh(&sk->sk_callback_lock); - return sock_sid; -} - static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb) { int err = 0; @@ -3559,11 +3536,6 @@ static unsigned int selinux_ip_postroute_last(unsigned int hooknum, send_perm, &ad) ? NF_DROP : NF_ACCEPT; } - if (err != NF_ACCEPT) - goto out; - - err = selinux_xfrm_postroute_last(isec->sid, skb); - out: return err; } @@ -4408,16 +4380,6 @@ static struct security_operations selinux_ops = { .socket_getpeersec = selinux_socket_getpeersec, .sk_alloc_security = selinux_sk_alloc_security, .sk_free_security = selinux_sk_free_security, - .sk_getsid = selinux_sk_getsid_security, -#endif - -#ifdef CONFIG_SECURITY_NETWORK_XFRM - .xfrm_policy_alloc_security = selinux_xfrm_policy_alloc, - .xfrm_policy_clone_security = selinux_xfrm_policy_clone, - .xfrm_policy_free_security = selinux_xfrm_policy_free, - .xfrm_state_alloc_security = selinux_xfrm_state_alloc, - .xfrm_state_free_security = selinux_xfrm_state_free, - .xfrm_policy_lookup = selinux_xfrm_policy_lookup, #endif }; @@ -4529,7 +4491,6 @@ static int __init selinux_nf_ip_init(void) panic("SELinux: nf_register_hook for IPv6: error %d\n", err); #endif /* IPV6 */ - out: return err; } diff --git a/trunk/security/selinux/include/av_perm_to_string.h b/trunk/security/selinux/include/av_perm_to_string.h index 71aeb12f07c8..1deb59e1b762 100644 --- a/trunk/security/selinux/include/av_perm_to_string.h +++ b/trunk/security/selinux/include/av_perm_to_string.h @@ -238,5 +238,3 @@ S_(SECCLASS_NSCD, NSCD__SHMEMHOST, "shmemhost") S_(SECCLASS_ASSOCIATION, ASSOCIATION__SENDTO, "sendto") S_(SECCLASS_ASSOCIATION, ASSOCIATION__RECVFROM, "recvfrom") - S_(SECCLASS_ASSOCIATION, ASSOCIATION__RELABELFROM, "relabelfrom") - S_(SECCLASS_ASSOCIATION, ASSOCIATION__RELABELTO, "relabelto") diff --git a/trunk/security/selinux/include/av_permissions.h b/trunk/security/selinux/include/av_permissions.h index d1d0996049e3..a78b5d59c9fc 100644 --- a/trunk/security/selinux/include/av_permissions.h +++ b/trunk/security/selinux/include/av_permissions.h @@ -908,8 +908,6 @@ #define ASSOCIATION__SENDTO 0x00000001UL #define ASSOCIATION__RECVFROM 0x00000002UL -#define ASSOCIATION__RELABELFROM 0x00000004UL -#define ASSOCIATION__RELABELTO 0x00000008UL #define NETLINK_KOBJECT_UEVENT_SOCKET__IOCTL 0x00000001UL #define NETLINK_KOBJECT_UEVENT_SOCKET__READ 0x00000002UL diff --git a/trunk/security/selinux/include/xfrm.h b/trunk/security/selinux/include/xfrm.h deleted file mode 100644 index 8e87996c6dd5..000000000000 --- a/trunk/security/selinux/include/xfrm.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * SELinux support for the XFRM LSM hooks - * - * Author : Trent Jaeger, <jaegert@us.ibm.com> - */ -#ifndef _SELINUX_XFRM_H_ -#define _SELINUX_XFRM_H_ - -int selinux_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *sec_ctx); -int selinux_xfrm_policy_clone(struct xfrm_policy *old, struct xfrm_policy *new); -void selinux_xfrm_policy_free(struct xfrm_policy *xp); -int selinux_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx); -void selinux_xfrm_state_free(struct xfrm_state *x); -int selinux_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir); - -/* - * Extract the security blob from the sock (it's actually on the socket) - */ -static inline struct inode_security_struct *get_sock_isec(struct sock *sk) -{ - if (!sk->sk_socket) - return NULL; - - return SOCK_INODE(sk->sk_socket)->i_security; -} - - -static inline u32 selinux_no_sk_sid(struct flowi *fl) -{ - /* NOTE: no sock occurs on ICMP reply, forwards, ... */ - /* icmp_reply: authorize as kernel packet */ - if (fl && fl->proto == IPPROTO_ICMP) { - return SECINITSID_KERNEL; - } - - return SECINITSID_ANY_SOCKET; -} - -#ifdef CONFIG_SECURITY_NETWORK_XFRM -int selinux_xfrm_sock_rcv_skb(u32 sid, struct sk_buff *skb); -int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb); -#else -static inline int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb) -{ - return 0; -} - -static inline int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb) -{ - return NF_ACCEPT; -} -#endif - -#endif /* _SELINUX_XFRM_H_ */ diff --git a/trunk/security/selinux/xfrm.c b/trunk/security/selinux/xfrm.c deleted file mode 100644 index c4d87d4dca7b..000000000000 --- a/trunk/security/selinux/xfrm.c +++ /dev/null @@ -1,311 +0,0 @@ -/* - * NSA Security-Enhanced Linux (SELinux) security module - * - * This file contains the SELinux XFRM hook function implementations. - * - * Authors: Serge Hallyn <sergeh@us.ibm.com> - * Trent Jaeger <jaegert@us.ibm.com> - * - * Copyright (C) 2005 International Business Machines Corporation - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2, - * as published by the Free Software Foundation. - */ - -/* - * USAGE: - * NOTES: - * 1. Make sure to enable the following options in your kernel config: - * CONFIG_SECURITY=y - * CONFIG_SECURITY_NETWORK=y - * CONFIG_SECURITY_NETWORK_XFRM=y - * CONFIG_SECURITY_SELINUX=m/y - * ISSUES: - * 1. Caching packets, so they are not dropped during negotiation - * 2. Emulating a reasonable SO_PEERSEC across machines - * 3. Testing addition of sk_policy's with security context via setsockopt - */ -#include <linux/config.h> -#include <linux/module.h> -#include <linux/kernel.h> -#include <linux/init.h> -#include <linux/security.h> -#include <linux/types.h> -#include <linux/netfilter.h> -#include <linux/netfilter_ipv4.h> -#include <linux/netfilter_ipv6.h> -#include <linux/ip.h> -#include <linux/tcp.h> -#include <linux/skbuff.h> -#include <linux/xfrm.h> -#include <net/xfrm.h> -#include <net/checksum.h> -#include <net/udp.h> -#include <asm/semaphore.h> - -#include "avc.h" -#include "objsec.h" -#include "xfrm.h" - - -/* - * Returns true if an LSM/SELinux context - */ -static inline int selinux_authorizable_ctx(struct xfrm_sec_ctx *ctx) -{ - return (ctx && - (ctx->ctx_doi == XFRM_SC_DOI_LSM) && - (ctx->ctx_alg == XFRM_SC_ALG_SELINUX)); -} - -/* - * Returns true if the xfrm contains a security blob for SELinux - */ -static inline int selinux_authorizable_xfrm(struct xfrm_state *x) -{ - return selinux_authorizable_ctx(x->security); -} - -/* - * LSM hook implementation that authorizes that a socket can be used - * with the corresponding xfrm_sec_ctx and direction. - */ -int selinux_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid, u8 dir) -{ - int rc = 0; - u32 sel_sid = SECINITSID_UNLABELED; - struct xfrm_sec_ctx *ctx; - - /* Context sid is either set to label or ANY_ASSOC */ - if ((ctx = xp->security)) { - if (!selinux_authorizable_ctx(ctx)) - return -EINVAL; - - sel_sid = ctx->ctx_sid; - } - - rc = avc_has_perm(sk_sid, sel_sid, SECCLASS_ASSOCIATION, - ((dir == FLOW_DIR_IN) ? ASSOCIATION__RECVFROM : - ((dir == FLOW_DIR_OUT) ? ASSOCIATION__SENDTO : - (ASSOCIATION__SENDTO | ASSOCIATION__RECVFROM))), - NULL); - - return rc; -} - -/* - * Security blob allocation for xfrm_policy and xfrm_state - * CTX does not have a meaningful value on input - */ -static int selinux_xfrm_sec_ctx_alloc(struct xfrm_sec_ctx **ctxp, struct xfrm_user_sec_ctx *uctx) -{ - int rc = 0; - struct task_security_struct *tsec = current->security; - struct xfrm_sec_ctx *ctx; - - BUG_ON(!uctx); - BUG_ON(uctx->ctx_doi != XFRM_SC_ALG_SELINUX); - - if (uctx->ctx_len >= PAGE_SIZE) - return -ENOMEM; - - *ctxp = ctx = kmalloc(sizeof(*ctx) + - uctx->ctx_len, - GFP_KERNEL); - - if (!ctx) - return -ENOMEM; - - ctx->ctx_doi = uctx->ctx_doi; - ctx->ctx_len = uctx->ctx_len; - ctx->ctx_alg = uctx->ctx_alg; - - memcpy(ctx->ctx_str, - uctx+1, - ctx->ctx_len); - rc = security_context_to_sid(ctx->ctx_str, - ctx->ctx_len, - &ctx->ctx_sid); - - if (rc) - goto out; - - /* - * Does the subject have permission to set security or permission to - * do the relabel? - * Must be permitted to relabel from default socket type (process type) - * to specified context - */ - rc = avc_has_perm(tsec->sid, tsec->sid, - SECCLASS_ASSOCIATION, - ASSOCIATION__RELABELFROM, NULL); - if (rc) - goto out; - - rc = avc_has_perm(tsec->sid, ctx->ctx_sid, - SECCLASS_ASSOCIATION, - ASSOCIATION__RELABELTO, NULL); - if (rc) - goto out; - - return rc; - -out: - *ctxp = 0; - kfree(ctx); - return rc; -} - -/* - * LSM hook implementation that allocs and transfers uctx spec to - * xfrm_policy. - */ -int selinux_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *uctx) -{ - int err; - - BUG_ON(!xp); - - err = selinux_xfrm_sec_ctx_alloc(&xp->security, uctx); - return err; -} - - -/* - * LSM hook implementation that copies security data structure from old to - * new for policy cloning. - */ -int selinux_xfrm_policy_clone(struct xfrm_policy *old, struct xfrm_policy *new) -{ - struct xfrm_sec_ctx *old_ctx, *new_ctx; - - old_ctx = old->security; - - if (old_ctx) { - new_ctx = new->security = kmalloc(sizeof(*new_ctx) + - old_ctx->ctx_len, - GFP_KERNEL); - - if (!new_ctx) - return -ENOMEM; - - memcpy(new_ctx, old_ctx, sizeof(*new_ctx)); - memcpy(new_ctx->ctx_str, old_ctx->ctx_str, new_ctx->ctx_len); - } - return 0; -} - -/* - * LSM hook implementation that frees xfrm_policy security information. - */ -void selinux_xfrm_policy_free(struct xfrm_policy *xp) -{ - struct xfrm_sec_ctx *ctx = xp->security; - if (ctx) - kfree(ctx); -} - -/* - * LSM hook implementation that allocs and transfers sec_ctx spec to - * xfrm_state. - */ -int selinux_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *uctx) -{ - int err; - - BUG_ON(!x); - - err = selinux_xfrm_sec_ctx_alloc(&x->security, uctx); - return err; -} - -/* - * LSM hook implementation that frees xfrm_state security information. - */ -void selinux_xfrm_state_free(struct xfrm_state *x) -{ - struct xfrm_sec_ctx *ctx = x->security; - if (ctx) - kfree(ctx); -} - -/* - * LSM hook that controls access to unlabelled packets. If - * a xfrm_state is authorizable (defined by macro) then it was - * already authorized by the IPSec process. If not, then - * we need to check for unlabelled access since this may not have - * gone thru the IPSec process. - */ -int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb) -{ - int i, rc = 0; - struct sec_path *sp; - - sp = skb->sp; - - if (sp) { - /* - * __xfrm_policy_check does not approve unless xfrm_policy_ok - * says that spi's match for policy and the socket. - * - * Only need to verify the existence of an authorizable sp. - */ - for (i = 0; i < sp->len; i++) { - struct xfrm_state *x = sp->x[i].xvec; - - if (x && selinux_authorizable_xfrm(x)) - goto accept; - } - } - - /* check SELinux sock for unlabelled access */ - rc = avc_has_perm(isec_sid, SECINITSID_UNLABELED, SECCLASS_ASSOCIATION, - ASSOCIATION__RECVFROM, NULL); - if (rc) - goto drop; - -accept: - return 0; - -drop: - return rc; -} - -/* - * POSTROUTE_LAST hook's XFRM processing: - * If we have no security association, then we need to determine - * whether the socket is allowed to send to an unlabelled destination. - * If we do have a authorizable security association, then it has already been - * checked in xfrm_policy_lookup hook. - */ -int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb) -{ - struct dst_entry *dst; - int rc = 0; - - dst = skb->dst; - - if (dst) { - struct dst_entry *dst_test; - - for (dst_test = dst; dst_test != 0; - dst_test = dst_test->child) { - struct xfrm_state *x = dst_test->xfrm; - - if (x && selinux_authorizable_xfrm(x)) - goto accept; - } - } - - rc = avc_has_perm(isec_sid, SECINITSID_UNLABELED, SECCLASS_ASSOCIATION, - ASSOCIATION__SENDTO, NULL); - if (rc) - goto drop; - -accept: - return NF_ACCEPT; - -drop: - return NF_DROP; -} diff --git a/trunk/sound/Kconfig b/trunk/sound/Kconfig index b65ee4701f98..d8f11408ce27 100644 --- a/trunk/sound/Kconfig +++ b/trunk/sound/Kconfig @@ -48,6 +48,14 @@ config SND For more information, see <http://www.alsa-project.org/> +config SND_AC97_CODEC + tristate + select SND_PCM + select SND_AC97_BUS + +config SND_AC97_BUS + tristate + source "sound/core/Kconfig" source "sound/drivers/Kconfig" diff --git a/trunk/sound/arm/Kconfig b/trunk/sound/arm/Kconfig index 2e4a5e0d16db..0864a7ce414d 100644 --- a/trunk/sound/arm/Kconfig +++ b/trunk/sound/arm/Kconfig @@ -7,6 +7,7 @@ config SND_SA11XX_UDA1341 tristate "SA11xx UDA1341TS driver (iPaq H3600)" depends on ARCH_SA1100 && SND && L3 select SND_PCM + select SND_GENERIC_DRIVER help Say Y here if you have a Compaq iPaq H3x00 handheld computer and want to use its Philips UDA 1341 audio chip. diff --git a/trunk/sound/arm/aaci.c b/trunk/sound/arm/aaci.c index 5e9a81ab990b..559ead6367da 100644 --- a/trunk/sound/arm/aaci.c +++ b/trunk/sound/arm/aaci.c @@ -40,7 +40,7 @@ */ #undef CONFIG_PM -static void aaci_ac97_select_codec(struct aaci *aaci, struct snd_ac97 *ac97) +static void aaci_ac97_select_codec(struct aaci *aaci, ac97_t *ac97) { u32 v, maincr = aaci->maincr | MAINCR_SCRA(ac97->num); @@ -65,7 +65,7 @@ static void aaci_ac97_select_codec(struct aaci *aaci, struct snd_ac97 *ac97) * SI1TxEn, SI2TxEn and SI12TxEn bits are set in the AACI_MAINCR * register. */ -static void aaci_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) +static void aaci_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { struct aaci *aaci = ac97->private_data; u32 v; @@ -97,7 +97,7 @@ static void aaci_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned /* * Read an AC'97 register. */ -static unsigned short aaci_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short aaci_ac97_read(ac97_t *ac97, unsigned short reg) { struct aaci *aaci = ac97->private_data; u32 v; @@ -284,11 +284,11 @@ static unsigned int rate_list[] = { * (unimplemented) */ static int -aaci_rule_rate_by_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule *rule) +aaci_rule_rate_by_channels(snd_pcm_hw_params_t *p, snd_pcm_hw_rule_t *rule) { struct aaci *aaci = rule->private; unsigned int rate_mask = SNDRV_PCM_RATE_8000_48000|SNDRV_PCM_RATE_5512; - struct snd_interval *c = hw_param_interval(p, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *c = hw_param_interval(p, SNDRV_PCM_HW_PARAM_CHANNELS); switch (c->max) { case 6: @@ -304,7 +304,7 @@ aaci_rule_rate_by_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule * rate_mask); } -static struct snd_pcm_hardware aaci_hw_info = { +static snd_pcm_hardware_t aaci_hw_info = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | @@ -330,10 +330,10 @@ static struct snd_pcm_hardware aaci_hw_info = { .periods_max = PAGE_SIZE / 16, }; -static int aaci_pcm_open(struct aaci *aaci, struct snd_pcm_substream *substream, +static int aaci_pcm_open(struct aaci *aaci, snd_pcm_substream_t *substream, struct aaci_runtime *aacirun) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int ret; aacirun->substream = substream; @@ -375,7 +375,7 @@ static int aaci_pcm_open(struct aaci *aaci, struct snd_pcm_substream *substream, /* * Common ALSA stuff */ -static int aaci_pcm_close(struct snd_pcm_substream *substream) +static int aaci_pcm_close(snd_pcm_substream_t *substream) { struct aaci *aaci = substream->private_data; struct aaci_runtime *aacirun = substream->runtime->private_data; @@ -388,7 +388,7 @@ static int aaci_pcm_close(struct snd_pcm_substream *substream) return 0; } -static int aaci_pcm_hw_free(struct snd_pcm_substream *substream) +static int aaci_pcm_hw_free(snd_pcm_substream_t *substream) { struct aaci_runtime *aacirun = substream->runtime->private_data; @@ -409,9 +409,9 @@ static int aaci_pcm_hw_free(struct snd_pcm_substream *substream) return 0; } -static int aaci_pcm_hw_params(struct snd_pcm_substream *substream, +static int aaci_pcm_hw_params(snd_pcm_substream_t *substream, struct aaci_runtime *aacirun, - struct snd_pcm_hw_params *params) + snd_pcm_hw_params_t *params) { int err; @@ -434,9 +434,9 @@ static int aaci_pcm_hw_params(struct snd_pcm_substream *substream, return err; } -static int aaci_pcm_prepare(struct snd_pcm_substream *substream) +static int aaci_pcm_prepare(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; struct aaci_runtime *aacirun = runtime->private_data; aacirun->start = (void *)runtime->dma_area; @@ -448,16 +448,16 @@ static int aaci_pcm_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t aaci_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t aaci_pcm_pointer(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; struct aaci_runtime *aacirun = runtime->private_data; ssize_t bytes = aacirun->ptr - aacirun->start; return bytes_to_frames(runtime, bytes); } -static int aaci_pcm_mmap(struct snd_pcm_substream *substream, struct vm_area_struct *vma) +static int aaci_pcm_mmap(snd_pcm_substream_t *substream, struct vm_area_struct *vma) { return devdma_mmap(NULL, substream, vma); } @@ -484,7 +484,7 @@ static const u32 channels_to_txmask[] = { static unsigned int channel_list[] = { 2, 4, 6 }; static int -aaci_rule_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule *rule) +aaci_rule_channels(snd_pcm_hw_params_t *p, snd_pcm_hw_rule_t *rule) { struct aaci *aaci = rule->private; unsigned int chan_mask = 1 << 0, slots; @@ -504,7 +504,7 @@ aaci_rule_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule *rule) chan_mask); } -static int aaci_pcm_playback_open(struct snd_pcm_substream *substream) +static int aaci_pcm_playback_open(snd_pcm_substream_t *substream) { struct aaci *aaci = substream->private_data; int ret; @@ -522,8 +522,8 @@ static int aaci_pcm_playback_open(struct snd_pcm_substream *substream) return aaci_pcm_open(aaci, substream, &aaci->playback); } -static int aaci_pcm_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +static int aaci_pcm_playback_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { struct aaci *aaci = substream->private_data; struct aaci_runtime *aacirun = substream->runtime->private_data; @@ -575,7 +575,7 @@ static void aaci_pcm_playback_start(struct aaci_runtime *aacirun) writel(aacirun->cr, aacirun->base + AACI_TXCR); } -static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd) +static int aaci_pcm_playback_trigger(snd_pcm_substream_t *substream, int cmd) { struct aaci *aaci = substream->private_data; struct aaci_runtime *aacirun = substream->runtime->private_data; @@ -614,7 +614,7 @@ static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cm return ret; } -static struct snd_pcm_ops aaci_playback_ops = { +static snd_pcm_ops_t aaci_playback_ops = { .open = aaci_pcm_playback_open, .close = aaci_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -632,29 +632,34 @@ static struct snd_pcm_ops aaci_playback_ops = { * Power Management. */ #ifdef CONFIG_PM -static int aaci_do_suspend(struct snd_card *card, unsigned int state) +static int aaci_do_suspend(snd_card_t *card, unsigned int state) { struct aaci *aaci = card->private_data; - snd_power_change_state(card, SNDRV_CTL_POWER_D3cold); - snd_pcm_suspend_all(aaci->pcm); + if (aaci->card->power_state != SNDRV_CTL_POWER_D3cold) { + snd_pcm_suspend_all(aaci->pcm); + snd_power_change_state(aaci->card, SNDRV_CTL_POWER_D3cold); + } return 0; } -static int aaci_do_resume(struct snd_card *card, unsigned int state) +static int aaci_do_resume(snd_card_t *card, unsigned int state) { - snd_power_change_state(card, SNDRV_CTL_POWER_D0); + struct aaci *aaci = card->private_data; + if (aaci->card->power_state != SNDRV_CTL_POWER_D0) { + snd_power_change_state(aaci->card, SNDRV_CTL_POWER_D0); + } return 0; } static int aaci_suspend(struct amba_device *dev, pm_message_t state) { - struct snd_card *card = amba_get_drvdata(dev); + snd_card_t *card = amba_get_drvdata(dev); return card ? aaci_do_suspend(card) : 0; } static int aaci_resume(struct amba_device *dev) { - struct snd_card *card = amba_get_drvdata(dev); + snd_card_t *card = amba_get_drvdata(dev); return card ? aaci_do_resume(card) : 0; } #else @@ -700,16 +705,16 @@ static struct ac97_pcm ac97_defs[] __devinitdata = { } }; -static struct snd_ac97_bus_ops aaci_bus_ops = { +static ac97_bus_ops_t aaci_bus_ops = { .write = aaci_ac97_write, .read = aaci_ac97_read, }; static int __devinit aaci_probe_ac97(struct aaci *aaci) { - struct snd_ac97_template ac97_template; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; + ac97_template_t ac97_template; + ac97_bus_t *ac97_bus; + ac97_t *ac97; int ret; /* @@ -732,7 +737,7 @@ static int __devinit aaci_probe_ac97(struct aaci *aaci) ac97_bus->clock = 48000; aaci->ac97_bus = ac97_bus; - memset(&ac97_template, 0, sizeof(struct snd_ac97_template)); + memset(&ac97_template, 0, sizeof(ac97_template_t)); ac97_template.private_data = aaci; ac97_template.num = 0; ac97_template.scaps = AC97_SCAP_SKIP_MODEM; @@ -757,7 +762,7 @@ static int __devinit aaci_probe_ac97(struct aaci *aaci) return ret; } -static void aaci_free_card(struct snd_card *card) +static void aaci_free_card(snd_card_t *card) { struct aaci *aaci = card->private_data; if (aaci->base) @@ -767,7 +772,7 @@ static void aaci_free_card(struct snd_card *card) static struct aaci * __devinit aaci_init_card(struct amba_device *dev) { struct aaci *aaci; - struct snd_card *card; + snd_card_t *card; card = snd_card_new(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, THIS_MODULE, sizeof(struct aaci)); @@ -775,6 +780,7 @@ static struct aaci * __devinit aaci_init_card(struct amba_device *dev) return ERR_PTR(-ENOMEM); card->private_free = aaci_free_card; + snd_card_set_pm_callback(card, aaci_do_suspend, aaci_do_resume, NULL); strlcpy(card->driver, DRIVER_NAME, sizeof(card->driver)); strlcpy(card->shortname, "ARM AC'97 Interface", sizeof(card->shortname)); @@ -797,7 +803,7 @@ static struct aaci * __devinit aaci_init_card(struct amba_device *dev) static int __devinit aaci_init_pcm(struct aaci *aaci) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int ret; ret = snd_pcm_new(aaci->card, "AACI AC'97", 0, 1, 0, &pcm); @@ -914,7 +920,7 @@ static int __devinit aaci_probe(struct amba_device *dev, void *id) static int __devexit aaci_remove(struct amba_device *dev) { - struct snd_card *card = amba_get_drvdata(dev); + snd_card_t *card = amba_get_drvdata(dev); amba_set_drvdata(dev, NULL); diff --git a/trunk/sound/arm/aaci.h b/trunk/sound/arm/aaci.h index 83f73c2505c6..b2f969bc7845 100644 --- a/trunk/sound/arm/aaci.h +++ b/trunk/sound/arm/aaci.h @@ -207,7 +207,7 @@ struct aaci_runtime { int pcm_open; u32 cr; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; /* * PIO support @@ -222,7 +222,7 @@ struct aaci_runtime { struct aaci { struct amba_device *dev; - struct snd_card *card; + snd_card_t *card; void __iomem *base; unsigned int fifosize; @@ -236,7 +236,7 @@ struct aaci { struct aaci_runtime playback; struct aaci_runtime capture; - struct snd_pcm *pcm; + snd_pcm_t *pcm; }; #define ACSTREAM_FRONT 0 diff --git a/trunk/sound/arm/devdma.c b/trunk/sound/arm/devdma.c index ca3bf4ee05a3..60826a5324b4 100644 --- a/trunk/sound/arm/devdma.c +++ b/trunk/sound/arm/devdma.c @@ -18,9 +18,9 @@ #include "devdma.h" -void devdma_hw_free(struct device *dev, struct snd_pcm_substream *substream) +void devdma_hw_free(struct device *dev, snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; struct snd_dma_buffer *buf = runtime->dma_buffer_p; if (runtime->dma_area == NULL) @@ -34,9 +34,9 @@ void devdma_hw_free(struct device *dev, struct snd_pcm_substream *substream) snd_pcm_set_runtime_buffer(substream, NULL); } -int devdma_hw_alloc(struct device *dev, struct snd_pcm_substream *substream, size_t size) +int devdma_hw_alloc(struct device *dev, snd_pcm_substream_t *substream, size_t size) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; struct snd_dma_buffer *buf = runtime->dma_buffer_p; int ret = 0; @@ -74,8 +74,8 @@ int devdma_hw_alloc(struct device *dev, struct snd_pcm_substream *substream, siz return -ENOMEM; } -int devdma_mmap(struct device *dev, struct snd_pcm_substream *substream, struct vm_area_struct *vma) +int devdma_mmap(struct device *dev, snd_pcm_substream_t *substream, struct vm_area_struct *vma) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return dma_mmap_coherent(dev, vma, runtime->dma_area, runtime->dma_addr, runtime->dma_bytes); } diff --git a/trunk/sound/arm/devdma.h b/trunk/sound/arm/devdma.h index d025329c8a0f..5a33b6bacc34 100644 --- a/trunk/sound/arm/devdma.h +++ b/trunk/sound/arm/devdma.h @@ -1,3 +1,3 @@ -void devdma_hw_free(struct device *dev, struct snd_pcm_substream *substream); -int devdma_hw_alloc(struct device *dev, struct snd_pcm_substream *substream, size_t size); -int devdma_mmap(struct device *dev, struct snd_pcm_substream *substream, struct vm_area_struct *vma); +void devdma_hw_free(struct device *dev, snd_pcm_substream_t *substream); +int devdma_hw_alloc(struct device *dev, snd_pcm_substream_t *substream, size_t size); +int devdma_mmap(struct device *dev, snd_pcm_substream_t *substream, struct vm_area_struct *vma); diff --git a/trunk/sound/arm/pxa2xx-ac97.c b/trunk/sound/arm/pxa2xx-ac97.c index 3acbc6023d19..c96c8a2aa1c2 100644 --- a/trunk/sound/arm/pxa2xx-ac97.c +++ b/trunk/sound/arm/pxa2xx-ac97.c @@ -37,74 +37,69 @@ static DECLARE_MUTEX(car_mutex); static DECLARE_WAIT_QUEUE_HEAD(gsr_wq); static volatile long gsr_bits; -/* - * Beware PXA27x bugs: - * - * o Slot 12 read from modem space will hang controller. - * o CDONE, SDONE interrupt fails after any slot 12 IO. - * - * We therefore have an hybrid approach for waiting on SDONE (interrupt or - * 1 jiffy timeout if interrupt never comes). - */ - -static unsigned short pxa2xx_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short pxa2xx_ac97_read(ac97_t *ac97, unsigned short reg) { unsigned short val = -1; volatile u32 *reg_addr; down(&car_mutex); + if (CAR & CAR_CAIP) { + printk(KERN_CRIT"%s: CAR_CAIP already set\n", __FUNCTION__); + goto out; + } /* set up primary or secondary codec space */ reg_addr = (ac97->num & 1) ? &SAC_REG_BASE : &PAC_REG_BASE; reg_addr += (reg >> 1); /* start read access across the ac97 link */ - GSR = GSR_CDONE | GSR_SDONE; gsr_bits = 0; val = *reg_addr; if (reg == AC97_GPIO_STATUS) goto out; - if (wait_event_timeout(gsr_wq, (GSR | gsr_bits) & GSR_SDONE, 1) <= 0 && - !((GSR | gsr_bits) & GSR_SDONE)) { + wait_event_timeout(gsr_wq, gsr_bits & GSR_SDONE, 1); + if (!gsr_bits & GSR_SDONE) { printk(KERN_ERR "%s: read error (ac97_reg=%d GSR=%#lx)\n", - __FUNCTION__, reg, GSR | gsr_bits); + __FUNCTION__, reg, gsr_bits); val = -1; goto out; } /* valid data now */ - GSR = GSR_CDONE | GSR_SDONE; gsr_bits = 0; val = *reg_addr; /* but we've just started another cycle... */ - wait_event_timeout(gsr_wq, (GSR | gsr_bits) & GSR_SDONE, 1); + wait_event_timeout(gsr_wq, gsr_bits & GSR_SDONE, 1); out: up(&car_mutex); return val; } -static void pxa2xx_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) +static void pxa2xx_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { volatile u32 *reg_addr; down(&car_mutex); + if (CAR & CAR_CAIP) { + printk(KERN_CRIT "%s: CAR_CAIP already set\n", __FUNCTION__); + goto out; + } + /* set up primary or secondary codec space */ reg_addr = (ac97->num & 1) ? &SAC_REG_BASE : &PAC_REG_BASE; reg_addr += (reg >> 1); - - GSR = GSR_CDONE | GSR_SDONE; gsr_bits = 0; *reg_addr = val; - if (wait_event_timeout(gsr_wq, (GSR | gsr_bits) & GSR_CDONE, 1) <= 0 && - !((GSR | gsr_bits) & GSR_CDONE)) + wait_event_timeout(gsr_wq, gsr_bits & GSR_CDONE, 1); + if (!gsr_bits & GSR_SDONE) printk(KERN_ERR "%s: write error (ac97_reg=%d GSR=%#lx)\n", - __FUNCTION__, reg, GSR | gsr_bits); + __FUNCTION__, reg, gsr_bits); - up(&car_mutex); +out: up(&car_mutex); } -static void pxa2xx_ac97_reset(struct snd_ac97 *ac97) +static void pxa2xx_ac97_reset(ac97_t *ac97) { /* First, try cold reset */ GCR &= GCR_COLD_RST; /* clear everything but nCRST */ @@ -177,13 +172,13 @@ static irqreturn_t pxa2xx_ac97_irq(int irq, void *dev_id, struct pt_regs *regs) return IRQ_NONE; } -static struct snd_ac97_bus_ops pxa2xx_ac97_ops = { +static ac97_bus_ops_t pxa2xx_ac97_ops = { .read = pxa2xx_ac97_read, .write = pxa2xx_ac97_write, .reset = pxa2xx_ac97_reset, }; -static struct pxa2xx_pcm_dma_params pxa2xx_ac97_pcm_out = { +static pxa2xx_pcm_dma_params_t pxa2xx_ac97_pcm_out = { .name = "AC97 PCM out", .dev_addr = __PREG(PCDR), .drcmr = &DRCMRTXPCDR, @@ -191,7 +186,7 @@ static struct pxa2xx_pcm_dma_params pxa2xx_ac97_pcm_out = { DCMD_BURST32 | DCMD_WIDTH4, }; -static struct pxa2xx_pcm_dma_params pxa2xx_ac97_pcm_in = { +static pxa2xx_pcm_dma_params_t pxa2xx_ac97_pcm_in = { .name = "AC97 PCM in", .dev_addr = __PREG(PCDR), .drcmr = &DRCMRRXPCDR, @@ -199,12 +194,12 @@ static struct pxa2xx_pcm_dma_params pxa2xx_ac97_pcm_in = { DCMD_BURST32 | DCMD_WIDTH4, }; -static struct snd_pcm *pxa2xx_ac97_pcm; -static struct snd_ac97 *pxa2xx_ac97_ac97; +static snd_pcm_t *pxa2xx_ac97_pcm; +static ac97_t *pxa2xx_ac97_ac97; -static int pxa2xx_ac97_pcm_startup(struct snd_pcm_substream *substream) +static int pxa2xx_ac97_pcm_startup(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; pxa2xx_audio_ops_t *platform_ops; int r; @@ -223,7 +218,7 @@ static int pxa2xx_ac97_pcm_startup(struct snd_pcm_substream *substream) return 0; } -static void pxa2xx_ac97_pcm_shutdown(struct snd_pcm_substream *substream) +static void pxa2xx_ac97_pcm_shutdown(snd_pcm_substream_t *substream) { pxa2xx_audio_ops_t *platform_ops; @@ -232,15 +227,15 @@ static void pxa2xx_ac97_pcm_shutdown(struct snd_pcm_substream *substream) platform_ops->shutdown(substream, platform_ops->priv); } -static int pxa2xx_ac97_pcm_prepare(struct snd_pcm_substream *substream) +static int pxa2xx_ac97_pcm_prepare(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int reg = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? AC97_PCM_FRONT_DAC_RATE : AC97_PCM_LR_ADC_RATE; return snd_ac97_set_rate(pxa2xx_ac97_ac97, reg, runtime->rate); } -static struct pxa2xx_pcm_client pxa2xx_ac97_pcm_client = { +static pxa2xx_pcm_client_t pxa2xx_ac97_pcm_client = { .playback_params = &pxa2xx_ac97_pcm_out, .capture_params = &pxa2xx_ac97_pcm_in, .startup = pxa2xx_ac97_pcm_startup, @@ -250,37 +245,39 @@ static struct pxa2xx_pcm_client pxa2xx_ac97_pcm_client = { #ifdef CONFIG_PM -static int pxa2xx_ac97_do_suspend(struct snd_card *card, pm_message_t state) +static int pxa2xx_ac97_do_suspend(snd_card_t *card, pm_message_t state) { - pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3cold); - snd_pcm_suspend_all(pxa2xx_ac97_pcm); - snd_ac97_suspend(pxa2xx_ac97_ac97); - if (platform_ops && platform_ops->suspend) - platform_ops->suspend(platform_ops->priv); - GCR |= GCR_ACLINK_OFF; - pxa_set_cken(CKEN2_AC97, 0); + if (card->power_state != SNDRV_CTL_POWER_D3cold) { + pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data; + snd_pcm_suspend_all(pxa2xx_ac97_pcm); + snd_ac97_suspend(pxa2xx_ac97_ac97); + snd_power_change_state(card, SNDRV_CTL_POWER_D3cold); + if (platform_ops && platform_ops->suspend) + platform_ops->suspend(platform_ops->priv); + GCR |= GCR_ACLINK_OFF; + pxa_set_cken(CKEN2_AC97, 0); + } return 0; } -static int pxa2xx_ac97_do_resume(struct snd_card *card) +static int pxa2xx_ac97_do_resume(snd_card_t *card) { - pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data; - - pxa_set_cken(CKEN2_AC97, 1); - if (platform_ops && platform_ops->resume) - platform_ops->resume(platform_ops->priv); - snd_ac97_resume(pxa2xx_ac97_ac97); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); + if (card->power_state != SNDRV_CTL_POWER_D0) { + pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data; + pxa_set_cken(CKEN2_AC97, 1); + if (platform_ops && platform_ops->resume) + platform_ops->resume(platform_ops->priv); + snd_ac97_resume(pxa2xx_ac97_ac97); + snd_power_change_state(card, SNDRV_CTL_POWER_D0); + } return 0; } static int pxa2xx_ac97_suspend(struct platform_device *dev, pm_message_t state) { - struct snd_card *card = platform_get_drvdata(dev); + snd_card_t *card = platform_get_drvdata(dev); int ret = 0; if (card) @@ -291,7 +288,7 @@ static int pxa2xx_ac97_suspend(struct platform_device *dev, pm_message_t state) static int pxa2xx_ac97_resume(struct platform_device *dev) { - struct snd_card *card = platform_get_drvdata(dev); + snd_card_t *card = platform_get_drvdata(dev); int ret = 0; if (card) @@ -307,9 +304,9 @@ static int pxa2xx_ac97_resume(struct platform_device *dev) static int pxa2xx_ac97_probe(struct platform_device *dev) { - struct snd_card *card; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97_template ac97_template; + snd_card_t *card; + ac97_bus_t *ac97_bus; + ac97_template_t ac97_template; int ret; ret = -ENOMEM; @@ -352,6 +349,8 @@ static int pxa2xx_ac97_probe(struct platform_device *dev) snprintf(card->longname, sizeof(card->longname), "%s (%s)", dev->dev.driver->name, card->mixername); + snd_card_set_pm_callback(card, pxa2xx_ac97_do_suspend, + pxa2xx_ac97_do_resume, NULL); ret = snd_card_register(card); if (ret == 0) { platform_set_drvdata(dev, card); @@ -371,7 +370,7 @@ static int pxa2xx_ac97_probe(struct platform_device *dev) static int pxa2xx_ac97_remove(struct platform_device *dev) { - struct snd_card *card = platform_get_drvdata(dev); + snd_card_t *card = platform_get_drvdata(dev); if (card) { snd_card_free(card); diff --git a/trunk/sound/arm/pxa2xx-pcm.c b/trunk/sound/arm/pxa2xx-pcm.c index 4938ef10b813..b1eb53b02eae 100644 --- a/trunk/sound/arm/pxa2xx-pcm.c +++ b/trunk/sound/arm/pxa2xx-pcm.c @@ -28,7 +28,7 @@ #include "pxa2xx-pcm.h" -static const struct snd_pcm_hardware pxa2xx_pcm_hardware = { +static const snd_pcm_hardware_t pxa2xx_pcm_hardware = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | @@ -44,15 +44,15 @@ static const struct snd_pcm_hardware pxa2xx_pcm_hardware = { struct pxa2xx_runtime_data { int dma_ch; - struct pxa2xx_pcm_dma_params *params; + pxa2xx_pcm_dma_params_t *params; pxa_dma_desc *dma_desc_array; dma_addr_t dma_desc_array_phys; }; -static int pxa2xx_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +static int pxa2xx_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; struct pxa2xx_runtime_data *rtd = runtime->private_data; size_t totsize = params_buffer_bytes(params); size_t period = params_period_bytes(params); @@ -86,7 +86,7 @@ static int pxa2xx_pcm_hw_params(struct snd_pcm_substream *substream, return 0; } -static int pxa2xx_pcm_hw_free(struct snd_pcm_substream *substream) +static int pxa2xx_pcm_hw_free(snd_pcm_substream_t *substream) { struct pxa2xx_runtime_data *rtd = substream->runtime->private_data; @@ -95,10 +95,10 @@ static int pxa2xx_pcm_hw_free(struct snd_pcm_substream *substream) return 0; } -static int pxa2xx_pcm_prepare(struct snd_pcm_substream *substream) +static int pxa2xx_pcm_prepare(snd_pcm_substream_t *substream) { - struct pxa2xx_pcm_client *client = substream->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + pxa2xx_pcm_client_t *client = substream->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; struct pxa2xx_runtime_data *rtd = runtime->private_data; DCSR(rtd->dma_ch) &= ~DCSR_RUN; @@ -109,7 +109,7 @@ static int pxa2xx_pcm_prepare(struct snd_pcm_substream *substream) return client->prepare(substream); } -static int pxa2xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int pxa2xx_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { struct pxa2xx_runtime_data *rtd = substream->runtime->private_data; int ret = 0; @@ -139,7 +139,7 @@ static int pxa2xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) static void pxa2xx_pcm_dma_irq(int dma_ch, void *dev_id, struct pt_regs *regs) { - struct snd_pcm_substream *substream = dev_id; + snd_pcm_substream_t *substream = dev_id; struct pxa2xx_runtime_data *rtd = substream->runtime->private_data; int dcsr; @@ -155,9 +155,9 @@ static void pxa2xx_pcm_dma_irq(int dma_ch, void *dev_id, struct pt_regs *regs) } } -static snd_pcm_uframes_t pxa2xx_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t pxa2xx_pcm_pointer(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; struct pxa2xx_runtime_data *rtd = runtime->private_data; dma_addr_t ptr = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? DSADR(rtd->dma_ch) : DTADR(rtd->dma_ch); @@ -168,9 +168,9 @@ static snd_pcm_uframes_t pxa2xx_pcm_pointer(struct snd_pcm_substream *substream) } static int -pxa2xx_pcm_hw_rule_mult32(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) +pxa2xx_pcm_hw_rule_mult32(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) { - struct snd_interval *i = hw_param_interval(params, rule->var); + snd_interval_t *i = hw_param_interval(params, rule->var); int changed = 0; if (i->min & 31) { @@ -188,10 +188,10 @@ pxa2xx_pcm_hw_rule_mult32(struct snd_pcm_hw_params *params, struct snd_pcm_hw_ru return changed; } -static int pxa2xx_pcm_open(struct snd_pcm_substream *substream) +static int pxa2xx_pcm_open(snd_pcm_substream_t *substream) { - struct pxa2xx_pcm_client *client = substream->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + pxa2xx_pcm_client_t *client = substream->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; struct pxa2xx_runtime_data *rtd; int ret; @@ -246,9 +246,9 @@ static int pxa2xx_pcm_open(struct snd_pcm_substream *substream) return ret; } -static int pxa2xx_pcm_close(struct snd_pcm_substream *substream) +static int pxa2xx_pcm_close(snd_pcm_substream_t *substream) { - struct pxa2xx_pcm_client *client = substream->private_data; + pxa2xx_pcm_client_t *client = substream->private_data; struct pxa2xx_runtime_data *rtd = substream->runtime->private_data; pxa_free_dma(rtd->dma_ch); @@ -260,16 +260,16 @@ static int pxa2xx_pcm_close(struct snd_pcm_substream *substream) } static int -pxa2xx_pcm_mmap(struct snd_pcm_substream *substream, struct vm_area_struct *vma) +pxa2xx_pcm_mmap(snd_pcm_substream_t *substream, struct vm_area_struct *vma) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; return dma_mmap_writecombine(substream->pcm->card->dev, vma, runtime->dma_area, runtime->dma_addr, runtime->dma_bytes); } -static struct snd_pcm_ops pxa2xx_pcm_ops = { +static snd_pcm_ops_t pxa2xx_pcm_ops = { .open = pxa2xx_pcm_open, .close = pxa2xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -281,9 +281,9 @@ static struct snd_pcm_ops pxa2xx_pcm_ops = { .mmap = pxa2xx_pcm_mmap, }; -static int pxa2xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream) +static int pxa2xx_pcm_preallocate_dma_buffer(snd_pcm_t *pcm, int stream) { - struct snd_pcm_substream *substream = pcm->streams[stream].substream; + snd_pcm_substream_t *substream = pcm->streams[stream].substream; struct snd_dma_buffer *buf = &substream->dma_buffer; size_t size = pxa2xx_pcm_hardware.buffer_bytes_max; buf->dev.type = SNDRV_DMA_TYPE_DEV; @@ -297,9 +297,9 @@ static int pxa2xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream) return 0; } -static void pxa2xx_pcm_free_dma_buffers(struct snd_pcm *pcm) +static void pxa2xx_pcm_free_dma_buffers(snd_pcm_t *pcm) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; struct snd_dma_buffer *buf; int stream; @@ -318,10 +318,9 @@ static void pxa2xx_pcm_free_dma_buffers(struct snd_pcm *pcm) static u64 pxa2xx_pcm_dmamask = 0xffffffff; -int pxa2xx_pcm_new(struct snd_card *card, struct pxa2xx_pcm_client *client, - struct snd_pcm **rpcm) +int pxa2xx_pcm_new(snd_card_t *card, pxa2xx_pcm_client_t *client, snd_pcm_t **rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int play = client->playback_params ? 1 : 0; int capt = client->capture_params ? 1 : 0; int ret; diff --git a/trunk/sound/arm/pxa2xx-pcm.h b/trunk/sound/arm/pxa2xx-pcm.h index b79f1e803780..43517597cab9 100644 --- a/trunk/sound/arm/pxa2xx-pcm.h +++ b/trunk/sound/arm/pxa2xx-pcm.h @@ -10,20 +10,20 @@ * published by the Free Software Foundation. */ -struct pxa2xx_pcm_dma_params { +typedef struct { char *name; /* stream identifier */ u32 dcmd; /* DMA descriptor dcmd field */ volatile u32 *drcmr; /* the DMA request channel to use */ u32 dev_addr; /* device physical address for DMA */ -}; +} pxa2xx_pcm_dma_params_t; -struct pxa2xx_pcm_client { - struct pxa2xx_pcm_dma_params *playback_params; - struct pxa2xx_pcm_dma_params *capture_params; - int (*startup)(struct snd_pcm_substream *); - void (*shutdown)(struct snd_pcm_substream *); - int (*prepare)(struct snd_pcm_substream *); -}; +typedef struct { + pxa2xx_pcm_dma_params_t *playback_params; + pxa2xx_pcm_dma_params_t *capture_params; + int (*startup)(snd_pcm_substream_t *); + void (*shutdown)(snd_pcm_substream_t *); + int (*prepare)(snd_pcm_substream_t *); +} pxa2xx_pcm_client_t; -extern int pxa2xx_pcm_new(struct snd_card *, struct pxa2xx_pcm_client *, struct snd_pcm **); +extern int pxa2xx_pcm_new(snd_card_t *, pxa2xx_pcm_client_t *, snd_pcm_t **); diff --git a/trunk/sound/arm/sa11xx-uda1341.c b/trunk/sound/arm/sa11xx-uda1341.c index 13057d92f08a..6ee912259cc5 100644 --- a/trunk/sound/arm/sa11xx-uda1341.c +++ b/trunk/sound/arm/sa11xx-uda1341.c @@ -21,7 +21,7 @@ * merged HAL layer (patches from Brian) */ -/* $Id: sa11xx-uda1341.c,v 1.27 2005/12/07 09:13:42 cladisch Exp $ */ +/* $Id: sa11xx-uda1341.c,v 1.23 2005/09/09 13:22:34 tiwai Exp $ */ /*************************************************************************************************** * @@ -64,8 +64,6 @@ #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/errno.h> #include <linux/ioctl.h> #include <linux/delay.h> @@ -117,7 +115,7 @@ static char *id = NULL; /* ID for this card */ module_param(id, charp, 0444); MODULE_PARM_DESC(id, "ID string for SA1100/SA1111 + UDA1341TS soundcard."); -struct audio_stream { +typedef struct audio_stream { char *id; /* identification string */ int stream_id; /* numeric identification */ dma_device_t dma_dev; /* device identifier for DMA */ @@ -132,16 +130,18 @@ struct audio_stream { int tx_spin; /* are we recoding - flag used to do DMA trans. for sync */ unsigned int old_offset; spinlock_t dma_lock; /* for locking in DMA operations (see dma-sa1100.c in the kernel) */ - struct snd_pcm_substream *stream; -}; + snd_pcm_substream_t *stream; +}audio_stream_t; -struct sa11xx_uda1341 { - struct snd_card *card; +typedef struct snd_card_sa11xx_uda1341 { + snd_card_t *card; struct l3_client *uda1341; - struct snd_pcm *pcm; + snd_pcm_t *pcm; long samplerate; - struct audio_stream s[2]; /* playback & capture */ -}; + audio_stream_t s[2]; /* playback & capture */ +} sa11xx_uda1341_t; + +static struct snd_card_sa11xx_uda1341 *sa11xx_uda1341 = NULL; static unsigned int rates[] = { 8000, 10666, 10985, 14647, @@ -149,14 +149,12 @@ static unsigned int rates[] = { 29400, 32000, 44100, 48000, }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, }; -static struct platform_device *device; - /* }}} */ /* {{{ Clock and sample rate stuff */ @@ -197,7 +195,7 @@ static void sa11xx_uda1341_set_audio_clock(long val) } } -static void sa11xx_uda1341_set_samplerate(struct sa11xx_uda1341 *sa11xx_uda1341, long rate) +static void sa11xx_uda1341_set_samplerate(sa11xx_uda1341_t *sa11xx_uda1341, long rate) { int clk_div = 0; int clk=0; @@ -282,7 +280,7 @@ static void sa11xx_uda1341_set_samplerate(struct sa11xx_uda1341 *sa11xx_uda1341, /* {{{ HW init and shutdown */ -static void sa11xx_uda1341_audio_init(struct sa11xx_uda1341 *sa11xx_uda1341) +static void sa11xx_uda1341_audio_init(sa11xx_uda1341_t *sa11xx_uda1341) { unsigned long flags; @@ -339,7 +337,7 @@ static void sa11xx_uda1341_audio_init(struct sa11xx_uda1341 *sa11xx_uda1341) #endif } -static void sa11xx_uda1341_audio_shutdown(struct sa11xx_uda1341 *sa11xx_uda1341) +static void sa11xx_uda1341_audio_shutdown(sa11xx_uda1341_t *sa11xx_uda1341) { /* mute on */ #ifdef CONFIG_H3600_HAL @@ -380,7 +378,7 @@ static void sa11xx_uda1341_audio_shutdown(struct sa11xx_uda1341 *sa11xx_uda1341) #ifdef HH_VERSION -static int audio_dma_request(struct audio_stream *s, void (*callback)(void *, int)) +static int audio_dma_request(audio_stream_t *s, void (*callback)(void *, int)) { int ret; @@ -393,7 +391,7 @@ static int audio_dma_request(struct audio_stream *s, void (*callback)(void *, in return 0; } -static inline void audio_dma_free(struct audio_stream *s) +static inline void audio_dma_free(audio_stream_t *s) { sa1100_free_dma(s->dmach); s->dmach = -1; @@ -401,7 +399,7 @@ static inline void audio_dma_free(struct audio_stream *s) #else -static int audio_dma_request(struct audio_stream *s, void (*callback)(void *)) +static int audio_dma_request(audio_stream_t *s, void (*callback)(void *)) { int ret; @@ -411,18 +409,18 @@ static int audio_dma_request(struct audio_stream *s, void (*callback)(void *)) return ret; } -static void audio_dma_free(struct audio_stream *s) +static void audio_dma_free(audio_stream_t *s) { - sa1100_free_dma(s->dma_regs); - s->dma_regs = 0; + sa1100_free_dma((s)->dma_regs); + (s)->dma_regs = 0; } #endif -static u_int audio_get_dma_pos(struct audio_stream *s) +static u_int audio_get_dma_pos(audio_stream_t *s) { - struct snd_pcm_substream *substream = s->stream; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_substream_t * substream = s->stream; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int offset; unsigned long flags; dma_addr_t addr; @@ -447,7 +445,7 @@ static u_int audio_get_dma_pos(struct audio_stream *s) /* * this stops the dma and clears the dma ptrs */ -static void audio_stop_dma(struct audio_stream *s) +static void audio_stop_dma(audio_stream_t *s) { unsigned long flags; @@ -463,10 +461,10 @@ static void audio_stop_dma(struct audio_stream *s) spin_unlock_irqrestore(&s->dma_lock, flags); } -static void audio_process_dma(struct audio_stream *s) +static void audio_process_dma(audio_stream_t *s) { - struct snd_pcm_substream *substream = s->stream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = s->stream; + snd_pcm_runtime_t *runtime; unsigned int dma_size; unsigned int offset; int ret; @@ -529,7 +527,7 @@ static void audio_dma_callback(void *data, int size) static void audio_dma_callback(void *data) #endif { - struct audio_stream *s = data; + audio_stream_t *s = data; /* * If we are getting a callback for an active stream then we inform @@ -551,12 +549,12 @@ static void audio_dma_callback(void *data) /* {{{ trigger & timer */ -static int snd_sa11xx_uda1341_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_sa11xx_uda1341_trigger(snd_pcm_substream_t * substream, int cmd) { - struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); + sa11xx_uda1341_t *chip = snd_pcm_substream_chip(substream); int stream_id = substream->pstr->stream; - struct audio_stream *s = &chip->s[stream_id]; - struct audio_stream *s1 = &chip->s[stream_id ^ 1]; + audio_stream_t *s = &chip->s[stream_id]; + audio_stream_t *s1 = &chip->s[stream_id ^ 1]; int err = 0; /* note local interrupts are already disabled in the midlevel code */ @@ -685,11 +683,11 @@ static int snd_sa11xx_uda1341_trigger(struct snd_pcm_substream *substream, int c return err; } -static int snd_sa11xx_uda1341_prepare(struct snd_pcm_substream *substream) +static int snd_sa11xx_uda1341_prepare(snd_pcm_substream_t * substream) { - struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct audio_stream *s = &chip->s[substream->pstr->stream]; + sa11xx_uda1341_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + audio_stream_t *s = &chip->s[substream->pstr->stream]; /* set requested samplerate */ sa11xx_uda1341_set_samplerate(chip, runtime->rate); @@ -703,15 +701,15 @@ static int snd_sa11xx_uda1341_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_sa11xx_uda1341_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_sa11xx_uda1341_pointer(snd_pcm_substream_t * substream) { - struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); + sa11xx_uda1341_t *chip = snd_pcm_substream_chip(substream); return audio_get_dma_pos(&chip->s[substream->pstr->stream]); } /* }}} */ -static struct snd_pcm_hardware snd_sa11xx_uda1341_capture = +static snd_pcm_hardware_t snd_sa11xx_uda1341_capture = { .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -734,7 +732,7 @@ static struct snd_pcm_hardware snd_sa11xx_uda1341_capture = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_sa11xx_uda1341_playback = +static snd_pcm_hardware_t snd_sa11xx_uda1341_playback = { .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -757,10 +755,10 @@ static struct snd_pcm_hardware snd_sa11xx_uda1341_playback = .fifo_size = 0, }; -static int snd_card_sa11xx_uda1341_open(struct snd_pcm_substream *substream) +static int snd_card_sa11xx_uda1341_open(snd_pcm_substream_t * substream) { - struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sa11xx_uda1341_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int stream_id = substream->pstr->stream; int err; @@ -778,9 +776,9 @@ static int snd_card_sa11xx_uda1341_open(struct snd_pcm_substream *substream) return 0; } -static int snd_card_sa11xx_uda1341_close(struct snd_pcm_substream *substream) +static int snd_card_sa11xx_uda1341_close(snd_pcm_substream_t * substream) { - struct sa11xx_uda1341 *chip = snd_pcm_substream_chip(substream); + sa11xx_uda1341_t *chip = snd_pcm_substream_chip(substream); chip->s[substream->pstr->stream].stream = NULL; return 0; @@ -788,21 +786,21 @@ static int snd_card_sa11xx_uda1341_close(struct snd_pcm_substream *substream) /* {{{ HW params & free */ -static int snd_sa11xx_uda1341_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_sa11xx_uda1341_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_sa11xx_uda1341_hw_free(struct snd_pcm_substream *substream) +static int snd_sa11xx_uda1341_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } /* }}} */ -static struct snd_pcm_ops snd_card_sa11xx_uda1341_playback_ops = { +static snd_pcm_ops_t snd_card_sa11xx_uda1341_playback_ops = { .open = snd_card_sa11xx_uda1341_open, .close = snd_card_sa11xx_uda1341_close, .ioctl = snd_pcm_lib_ioctl, @@ -813,7 +811,7 @@ static struct snd_pcm_ops snd_card_sa11xx_uda1341_playback_ops = { .pointer = snd_sa11xx_uda1341_pointer, }; -static struct snd_pcm_ops snd_card_sa11xx_uda1341_capture_ops = { +static snd_pcm_ops_t snd_card_sa11xx_uda1341_capture_ops = { .open = snd_card_sa11xx_uda1341_open, .close = snd_card_sa11xx_uda1341_close, .ioctl = snd_pcm_lib_ioctl, @@ -824,9 +822,9 @@ static struct snd_pcm_ops snd_card_sa11xx_uda1341_capture_ops = { .pointer = snd_sa11xx_uda1341_pointer, }; -static int __init snd_card_sa11xx_uda1341_pcm(struct sa11xx_uda1341 *sa11xx_uda1341, int device) +static int __init snd_card_sa11xx_uda1341_pcm(sa11xx_uda1341_t *sa11xx_uda1341, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(sa11xx_uda1341->card, "UDA1341 PCM", device, 1, 1, &pcm)) < 0) @@ -837,8 +835,8 @@ static int __init snd_card_sa11xx_uda1341_pcm(struct sa11xx_uda1341 *sa11xx_uda1 * isa works but I'm not sure why (or if) it's the right choice * this may be too large, trying it for now */ - snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_isa_data(), + snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_ISA, + snd_pcm_dma_flags(0), 64*1024, 64*1024); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_sa11xx_uda1341_playback_ops); @@ -864,15 +862,12 @@ static int __init snd_card_sa11xx_uda1341_pcm(struct sa11xx_uda1341 *sa11xx_uda1 #ifdef CONFIG_PM -static int snd_sa11xx_uda1341_suspend(struct platform_device *devptr, - pm_message_t state) +static int snd_sa11xx_uda1341_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = platform_get_drvdata(devptr); - struct sa11xx_uda1341 *chip = card->private_data; + sa11xx_uda1341_t *chip = card->pm_private_data; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); -#ifdef HH_VERSION +#ifdef HH_VERSION sa1100_dma_sleep(chip->s[SNDRV_PCM_STREAM_PLAYBACK].dmach); sa1100_dma_sleep(chip->s[SNDRV_PCM_STREAM_CAPTURE].dmach); #else @@ -880,14 +875,12 @@ static int snd_sa11xx_uda1341_suspend(struct platform_device *devptr, #endif l3_command(chip->uda1341, CMD_SUSPEND, NULL); sa11xx_uda1341_audio_shutdown(chip); - return 0; } -static int snd_sa11xx_uda1341_resume(struct platform_device *devptr) +static int snd_sa11xx_uda1341_resume(snd_card_t *card) { - struct snd_card *card = platform_get_drvdata(devptr); - struct sa11xx_uda1341 *chip = card->private_data; + sa11xx_uda1341_t *chip = card->pm_private_data; sa11xx_uda1341_audio_init(chip); l3_command(chip->uda1341, CMD_RESUME, NULL); @@ -897,55 +890,67 @@ static int snd_sa11xx_uda1341_resume(struct platform_device *devptr) #else //FIXME #endif - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* COMFIG_PM */ -void snd_sa11xx_uda1341_free(struct snd_card *card) +void snd_sa11xx_uda1341_free(snd_card_t *card) { - struct sa11xx_uda1341 *chip = card->private_data; + sa11xx_uda1341_t *chip = card->private_data; audio_dma_free(&chip->s[SNDRV_PCM_STREAM_PLAYBACK]); audio_dma_free(&chip->s[SNDRV_PCM_STREAM_CAPTURE]); + sa11xx_uda1341 = NULL; + card->private_data = NULL; + kfree(chip); } -static int __init sa11xx_uda1341_probe(struct platform_device *devptr) +static int __init sa11xx_uda1341_init(void) { int err; - struct snd_card *card; - struct sa11xx_uda1341 *chip; + snd_card_t *card; + + if (!machine_is_h3xxx()) + return -ENODEV; /* register the soundcard */ - card = snd_card_new(-1, id, THIS_MODULE, sizeof(struct sa11xx_uda1341)); + card = snd_card_new(-1, id, THIS_MODULE, sizeof(sa11xx_uda1341_t)); if (card == NULL) return -ENOMEM; - chip = card->private_data; + sa11xx_uda1341 = kzalloc(sizeof(*sa11xx_uda1341), GFP_KERNEL); + if (sa11xx_uda1341 == NULL) + return -ENOMEM; spin_lock_init(&chip->s[0].dma_lock); spin_lock_init(&chip->s[1].dma_lock); - + + card->private_data = (void *)sa11xx_uda1341; card->private_free = snd_sa11xx_uda1341_free; - chip->card = card; - chip->samplerate = AUDIO_RATE_DEFAULT; + + sa11xx_uda1341->card = card; + sa11xx_uda1341->samplerate = AUDIO_RATE_DEFAULT; // mixer - if ((err = snd_chip_uda1341_mixer_new(card, &chip->uda1341))) + if ((err = snd_chip_uda1341_mixer_new(sa11xx_uda1341->card, &sa11xx_uda1341->uda1341))) goto nodev; // PCM - if ((err = snd_card_sa11xx_uda1341_pcm(chip, 0)) < 0) + if ((err = snd_card_sa11xx_uda1341_pcm(sa11xx_uda1341, 0)) < 0) goto nodev; + snd_card_set_generic_pm_callback(card, + snd_sa11xx_uda1341_suspend, snd_sa11_uda1341_resume, + sa11xx_uda1341); + strcpy(card->driver, "UDA1341"); strcpy(card->shortname, "H3600 UDA1341TS"); sprintf(card->longname, "Compaq iPAQ H3600 with Philips UDA1341TS"); - snd_card_set_dev(card, &devptr->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto nodev; if ((err = snd_card_register(card)) == 0) { printk( KERN_INFO "iPAQ audio support initialized\n" ); - platform_set_drvdata(devptr, card); return 0; } @@ -954,47 +959,9 @@ static int __init sa11xx_uda1341_probe(struct platform_device *devptr) return err; } -static int __devexit sa11xx_uda1341_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define SA11XX_UDA1341_DRIVER "sa11xx_uda1341" - -static struct platform_driver sa11xx_uda1341_driver = { - .probe = sa11xx_uda1341_probe, - .remove = __devexit_p(sa11xx_uda1341_remove), -#ifdef CONFIG_PM - .suspend = snd_sa11xx_uda1341_suspend, - .resume = snd_sa11xx_uda1341_resume, -#endif - .driver = { - .name = SA11XX_UDA1341_DRIVER, - }, -}; - -static int __init sa11xx_uda1341_init(void) -{ - int err; - - if (!machine_is_h3xxx()) - return -ENODEV; - if ((err = platform_driver_register(&sa11xx_uda1341_driver)) < 0) - return err; - device = platform_device_register_simple(SA11XX_UDA1341_DRIVER, -1, NULL, 0); - if (IS_ERR(device)) { - platform_driver_unregister(&sa11xx_uda1341_driver); - return PTR_ERR(device); - } - return 0; -} - static void __exit sa11xx_uda1341_exit(void) { - platform_device_unregister(device); - platform_driver_unregister(&sa11xx_uda1341_driver); + snd_card_free(sa11xx_uda1341->card); } module_init(sa11xx_uda1341_init); diff --git a/trunk/sound/core/Kconfig b/trunk/sound/core/Kconfig index f79755f77a81..82718836f937 100644 --- a/trunk/sound/core/Kconfig +++ b/trunk/sound/core/Kconfig @@ -111,25 +111,6 @@ config SND_SEQ_RTCTIMER_DEFAULT If in doubt, say Y. -config SND_DYNAMIC_MINORS - bool "Dynamic device file minor numbers (EXPERIMENTAL)" - depends on SND && EXPERIMENTAL - help - If you say Y here, the minor numbers of ALSA device files in - /dev/snd/ are allocated dynamically. This allows you to have - more than 8 sound cards, but requires a dynamic device file - system like udev. - - If you are unsure about this, say N here. - -config SND_SUPPORT_OLD_API - bool "Support old ALSA API" - depends on SND - default y - help - Say Y here to support the obsolete ALSA PCM API (ver.0.9.0 rc3 - or older). - config SND_VERBOSE_PRINTK bool "Verbose printk" depends on SND @@ -152,3 +133,7 @@ config SND_DEBUG_DETECT help Say Y here to enable extra-verbose log messages printed when detecting devices. + +config SND_GENERIC_DRIVER + bool + depends on SND diff --git a/trunk/sound/core/control.c b/trunk/sound/core/control.c index abd62f943726..212c46a94376 100644 --- a/trunk/sound/core/control.c +++ b/trunk/sound/core/control.c @@ -34,10 +34,12 @@ /* max number of user-defined controls */ #define MAX_USER_CONTROLS 32 -struct snd_kctl_ioctl { +typedef struct _snd_kctl_ioctl { struct list_head list; /* list of all ioctls */ snd_kctl_ioctl_func_t fioctl; -}; +} snd_kctl_ioctl_t; + +#define snd_kctl_ioctl(n) list_entry(n, snd_kctl_ioctl_t, list) static DECLARE_RWSEM(snd_ioctl_rwsem); static LIST_HEAD(snd_control_ioctls); @@ -47,12 +49,13 @@ static LIST_HEAD(snd_control_compat_ioctls); static int snd_ctl_open(struct inode *inode, struct file *file) { + int cardnum = SNDRV_MINOR_CARD(iminor(inode)); unsigned long flags; - struct snd_card *card; - struct snd_ctl_file *ctl; + snd_card_t *card; + snd_ctl_file_t *ctl; int err; - card = snd_lookup_minor_data(iminor(inode), SNDRV_DEVICE_TYPE_CONTROL); + card = snd_cards[cardnum]; if (!card) { err = -ENODEV; goto __error1; @@ -90,9 +93,9 @@ static int snd_ctl_open(struct inode *inode, struct file *file) return err; } -static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl) +static void snd_ctl_empty_read_queue(snd_ctl_file_t * ctl) { - struct snd_kctl_event *cread; + snd_kctl_event_t *cread; spin_lock(&ctl->read_lock); while (!list_empty(&ctl->events)) { @@ -107,9 +110,9 @@ static int snd_ctl_release(struct inode *inode, struct file *file) { unsigned long flags; struct list_head *list; - struct snd_card *card; - struct snd_ctl_file *ctl; - struct snd_kcontrol *control; + snd_card_t *card; + snd_ctl_file_t *ctl; + snd_kcontrol_t *control; unsigned int idx; ctl = file->private_data; @@ -134,13 +137,12 @@ static int snd_ctl_release(struct inode *inode, struct file *file) return 0; } -void snd_ctl_notify(struct snd_card *card, unsigned int mask, - struct snd_ctl_elem_id *id) +void snd_ctl_notify(snd_card_t *card, unsigned int mask, snd_ctl_elem_id_t *id) { unsigned long flags; struct list_head *flist; - struct snd_ctl_file *ctl; - struct snd_kctl_event *ev; + snd_ctl_file_t *ctl; + snd_kctl_event_t *ev; snd_assert(card != NULL && id != NULL, return); read_lock(&card->ctl_files_rwlock); @@ -181,23 +183,21 @@ void snd_ctl_notify(struct snd_card *card, unsigned int mask, * @control: the control template * @access: the default control access * - * Allocates a new struct snd_kcontrol instance and copies the given template + * Allocates a new snd_kcontrol_t instance and copies the given template * to the new instance. It does not copy volatile data (access). * * Returns the pointer of the new instance, or NULL on failure. */ -struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, unsigned int access) +snd_kcontrol_t *snd_ctl_new(snd_kcontrol_t * control, unsigned int access) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; unsigned int idx; snd_assert(control != NULL, return NULL); snd_assert(control->count > 0, return NULL); - kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL); - if (kctl == NULL) { - snd_printk(KERN_ERR "Cannot allocate control instance\n"); + kctl = kzalloc(sizeof(*kctl) + sizeof(snd_kcontrol_volatile_t) * control->count, GFP_KERNEL); + if (kctl == NULL) return NULL; - } *kctl = *control; for (idx = 0; idx < kctl->count; idx++) kctl->vd[idx].access = access; @@ -209,16 +209,15 @@ struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, unsigned int acce * @ncontrol: the initialization record * @private_data: the private data to set * - * Allocates a new struct snd_kcontrol instance and initialize from the given + * Allocates a new snd_kcontrol_t instance and initialize from the given * template. When the access field of ncontrol is 0, it's assumed as * READWRITE access. When the count field is 0, it's assumes as one. * * Returns the pointer of the newly generated instance, or NULL on failure. */ -struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol, - void *private_data) +snd_kcontrol_t *snd_ctl_new1(const snd_kcontrol_new_t * ncontrol, void *private_data) { - struct snd_kcontrol kctl; + snd_kcontrol_t kctl; unsigned int access; snd_assert(ncontrol != NULL, return NULL); @@ -250,7 +249,7 @@ struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol, * or snd_ctl_new1(). * Don't call this after the control was added to the card. */ -void snd_ctl_free_one(struct snd_kcontrol *kcontrol) +void snd_ctl_free_one(snd_kcontrol_t * kcontrol) { if (kcontrol) { if (kcontrol->private_free) @@ -259,11 +258,11 @@ void snd_ctl_free_one(struct snd_kcontrol *kcontrol) } } -static unsigned int snd_ctl_hole_check(struct snd_card *card, +static unsigned int snd_ctl_hole_check(snd_card_t * card, unsigned int count) { struct list_head *list; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; list_for_each(list, &card->controls) { kctl = snd_kcontrol(list); @@ -276,7 +275,7 @@ static unsigned int snd_ctl_hole_check(struct snd_card *card, return card->last_numid; } -static int snd_ctl_find_hole(struct snd_card *card, unsigned int count) +static int snd_ctl_find_hole(snd_card_t * card, unsigned int count) { unsigned int last_numid, iter = 100000; @@ -305,14 +304,12 @@ static int snd_ctl_find_hole(struct snd_card *card, unsigned int count) * * It frees automatically the control which cannot be added. */ -int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol) +int snd_ctl_add(snd_card_t * card, snd_kcontrol_t * kcontrol) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; unsigned int idx; - snd_assert(card != NULL, return -EINVAL); - if (! kcontrol) - return -EINVAL; + snd_assert(card != NULL && kcontrol != NULL, return -EINVAL); snd_assert(kcontrol->info != NULL, return -EINVAL); id = kcontrol->id; down_write(&card->controls_rwsem); @@ -353,9 +350,9 @@ int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol) * * Returns 0 if successful, or a negative error code on failure. */ -int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol) +int snd_ctl_remove(snd_card_t * card, snd_kcontrol_t * kcontrol) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; unsigned int idx; snd_assert(card != NULL && kcontrol != NULL, return -EINVAL); @@ -378,9 +375,9 @@ int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol) * * Returns 0 if successful, or a negative error code on failure. */ -int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id) +int snd_ctl_remove_id(snd_card_t * card, snd_ctl_elem_id_t *id) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; int ret; down_write(&card->controls_rwsem); @@ -404,11 +401,10 @@ int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id) * * Returns 0 if successful, or a negative error code on failure. */ -static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file, - struct snd_ctl_elem_id *id) +static int snd_ctl_remove_unlocked_id(snd_ctl_file_t * file, snd_ctl_elem_id_t *id) { - struct snd_card *card = file->card; - struct snd_kcontrol *kctl; + snd_card_t *card = file->card; + snd_kcontrol_t *kctl; int idx, ret; down_write(&card->controls_rwsem); @@ -438,10 +434,9 @@ static int snd_ctl_remove_unlocked_id(struct snd_ctl_file * file, * * Returns zero if successful, or a negative error code on failure. */ -int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id, - struct snd_ctl_elem_id *dst_id) +int snd_ctl_rename_id(snd_card_t * card, snd_ctl_elem_id_t *src_id, snd_ctl_elem_id_t *dst_id) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; down_write(&card->controls_rwsem); kctl = snd_ctl_find_id(card, src_id); @@ -468,10 +463,10 @@ int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id, * The caller must down card->controls_rwsem before calling this function * (if the race condition can happen). */ -struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid) +snd_kcontrol_t *snd_ctl_find_numid(snd_card_t * card, unsigned int numid) { struct list_head *list; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; snd_assert(card != NULL && numid != 0, return NULL); list_for_each(list, &card->controls) { @@ -494,11 +489,10 @@ struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numi * The caller must down card->controls_rwsem before calling this function * (if the race condition can happen). */ -struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card, - struct snd_ctl_elem_id *id) +snd_kcontrol_t *snd_ctl_find_id(snd_card_t * card, snd_ctl_elem_id_t *id) { struct list_head *list; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; snd_assert(card != NULL && id != NULL, return NULL); if (id->numid != 0) @@ -522,10 +516,10 @@ struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card, return NULL; } -static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl, +static int snd_ctl_card_info(snd_card_t * card, snd_ctl_file_t * ctl, unsigned int cmd, void __user *arg) { - struct snd_ctl_card_info *info; + snd_ctl_card_info_t *info; info = kzalloc(sizeof(*info), GFP_KERNEL); if (! info) @@ -539,7 +533,7 @@ static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl, strlcpy(info->mixername, card->mixername, sizeof(info->mixername)); strlcpy(info->components, card->components, sizeof(info->components)); up_read(&snd_ioctl_rwsem); - if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) { + if (copy_to_user(arg, info, sizeof(snd_ctl_card_info_t))) { kfree(info); return -EFAULT; } @@ -547,13 +541,12 @@ static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl, return 0; } -static int snd_ctl_elem_list(struct snd_card *card, - struct snd_ctl_elem_list __user *_list) +static int snd_ctl_elem_list(snd_card_t *card, snd_ctl_elem_list_t __user *_list) { struct list_head *plist; - struct snd_ctl_elem_list list; - struct snd_kcontrol *kctl; - struct snd_ctl_elem_id *dst, *id; + snd_ctl_elem_list_t list; + snd_kcontrol_t *kctl; + snd_ctl_elem_id_t *dst, *id; unsigned int offset, space, first, jidx; if (copy_from_user(&list, _list, sizeof(list))) @@ -566,7 +559,7 @@ static int snd_ctl_elem_list(struct snd_card *card, return -ENOMEM; if (space > 0) { /* allocate temporary buffer for atomic operation */ - dst = vmalloc(space * sizeof(struct snd_ctl_elem_id)); + dst = vmalloc(space * sizeof(snd_ctl_elem_id_t)); if (dst == NULL) return -ENOMEM; down_read(&card->controls_rwsem); @@ -595,9 +588,7 @@ static int snd_ctl_elem_list(struct snd_card *card, offset = 0; } up_read(&card->controls_rwsem); - if (list.used > 0 && - copy_to_user(list.pids, dst, - list.used * sizeof(struct snd_ctl_elem_id))) { + if (list.used > 0 && copy_to_user(list.pids, dst, list.used * sizeof(snd_ctl_elem_id_t))) { vfree(dst); return -EFAULT; } @@ -612,12 +603,11 @@ static int snd_ctl_elem_list(struct snd_card *card, return 0; } -static int snd_ctl_elem_info(struct snd_ctl_file *ctl, - struct snd_ctl_elem_info *info) +static int snd_ctl_elem_info(snd_ctl_file_t *ctl, snd_ctl_elem_info_t *info) { - struct snd_card *card = ctl->card; - struct snd_kcontrol *kctl; - struct snd_kcontrol_volatile *vd; + snd_card_t *card = ctl->card; + snd_kcontrol_t *kctl; + snd_kcontrol_volatile_t *vd; unsigned int index_offset; int result; @@ -650,10 +640,9 @@ static int snd_ctl_elem_info(struct snd_ctl_file *ctl, return result; } -static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl, - struct snd_ctl_elem_info __user *_info) +static int snd_ctl_elem_info_user(snd_ctl_file_t *ctl, snd_ctl_elem_info_t __user *_info) { - struct snd_ctl_elem_info info; + snd_ctl_elem_info_t info; int result; if (copy_from_user(&info, _info, sizeof(info))) @@ -665,10 +654,10 @@ static int snd_ctl_elem_info_user(struct snd_ctl_file *ctl, return result; } -int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control) +int snd_ctl_elem_read(snd_card_t *card, snd_ctl_elem_value_t *control) { - struct snd_kcontrol *kctl; - struct snd_kcontrol_volatile *vd; + snd_kcontrol_t *kctl; + snd_kcontrol_volatile_t *vd; unsigned int index_offset; int result, indirect; @@ -695,10 +684,9 @@ int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control) return result; } -static int snd_ctl_elem_read_user(struct snd_card *card, - struct snd_ctl_elem_value __user *_control) +static int snd_ctl_elem_read_user(snd_card_t *card, snd_ctl_elem_value_t __user *_control) { - struct snd_ctl_elem_value *control; + snd_ctl_elem_value_t *control; int result; control = kmalloc(sizeof(*control), GFP_KERNEL); @@ -716,11 +704,10 @@ static int snd_ctl_elem_read_user(struct snd_card *card, return result; } -int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file, - struct snd_ctl_elem_value *control) +int snd_ctl_elem_write(snd_card_t *card, snd_ctl_file_t *file, snd_ctl_elem_value_t *control) { - struct snd_kcontrol *kctl; - struct snd_kcontrol_volatile *vd; + snd_kcontrol_t *kctl; + snd_kcontrol_volatile_t *vd; unsigned int index_offset; int result, indirect; @@ -754,10 +741,9 @@ int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file, return result; } -static int snd_ctl_elem_write_user(struct snd_ctl_file *file, - struct snd_ctl_elem_value __user *_control) +static int snd_ctl_elem_write_user(snd_ctl_file_t *file, snd_ctl_elem_value_t __user *_control) { - struct snd_ctl_elem_value *control; + snd_ctl_elem_value_t *control; int result; control = kmalloc(sizeof(*control), GFP_KERNEL); @@ -775,13 +761,12 @@ static int snd_ctl_elem_write_user(struct snd_ctl_file *file, return result; } -static int snd_ctl_elem_lock(struct snd_ctl_file *file, - struct snd_ctl_elem_id __user *_id) +static int snd_ctl_elem_lock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id) { - struct snd_card *card = file->card; - struct snd_ctl_elem_id id; - struct snd_kcontrol *kctl; - struct snd_kcontrol_volatile *vd; + snd_card_t *card = file->card; + snd_ctl_elem_id_t id; + snd_kcontrol_t *kctl; + snd_kcontrol_volatile_t *vd; int result; if (copy_from_user(&id, _id, sizeof(id))) @@ -804,13 +789,12 @@ static int snd_ctl_elem_lock(struct snd_ctl_file *file, return result; } -static int snd_ctl_elem_unlock(struct snd_ctl_file *file, - struct snd_ctl_elem_id __user *_id) +static int snd_ctl_elem_unlock(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id) { - struct snd_card *card = file->card; - struct snd_ctl_elem_id id; - struct snd_kcontrol *kctl; - struct snd_kcontrol_volatile *vd; + snd_card_t *card = file->card; + snd_ctl_elem_id_t id; + snd_kcontrol_t *kctl; + snd_kcontrol_volatile_t *vd; int result; if (copy_from_user(&id, _id, sizeof(id))) @@ -836,15 +820,14 @@ static int snd_ctl_elem_unlock(struct snd_ctl_file *file, } struct user_element { - struct snd_ctl_elem_info info; + snd_ctl_elem_info_t info; void *elem_data; /* element data */ unsigned long elem_data_size; /* size of element data in bytes */ void *priv_data; /* private data (like strings for enumerated type) */ unsigned long priv_data_size; /* size of private data in bytes */ }; -static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ctl_elem_user_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct user_element *ue = kcontrol->private_data; @@ -852,8 +835,7 @@ static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ctl_elem_user_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { struct user_element *ue = kcontrol->private_data; @@ -861,8 +843,7 @@ static int snd_ctl_elem_user_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ctl_elem_user_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { int change; struct user_element *ue = kcontrol->private_data; @@ -873,16 +854,15 @@ static int snd_ctl_elem_user_put(struct snd_kcontrol *kcontrol, return change; } -static void snd_ctl_elem_user_free(struct snd_kcontrol *kcontrol) +static void snd_ctl_elem_user_free(snd_kcontrol_t * kcontrol) { kfree(kcontrol->private_data); } -static int snd_ctl_elem_add(struct snd_ctl_file *file, - struct snd_ctl_elem_info *info, int replace) +static int snd_ctl_elem_add(snd_ctl_file_t *file, snd_ctl_elem_info_t *info, int replace) { - struct snd_card *card = file->card; - struct snd_kcontrol kctl, *_kctl; + snd_card_t *card = file->card; + snd_kcontrol_t kctl, *_kctl; unsigned int access; long private_size; struct user_element *ue; @@ -893,8 +873,7 @@ static int snd_ctl_elem_add(struct snd_ctl_file *file, if (info->count > 1024) return -EINVAL; access = info->access == 0 ? SNDRV_CTL_ELEM_ACCESS_READWRITE : - (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE| - SNDRV_CTL_ELEM_ACCESS_INACTIVE)); + (info->access & (SNDRV_CTL_ELEM_ACCESS_READWRITE|SNDRV_CTL_ELEM_ACCESS_INACTIVE)); info->id.numid = 0; memset(&kctl, 0, sizeof(kctl)); down_write(&card->controls_rwsem); @@ -942,7 +921,7 @@ static int snd_ctl_elem_add(struct snd_ctl_file *file, return -EINVAL; break; case SNDRV_CTL_ELEM_TYPE_IEC958: - private_size = sizeof(struct snd_aes_iec958); + private_size = sizeof(struct sndrv_aes_iec958); if (info->count != 1) return -EINVAL; break; @@ -978,26 +957,24 @@ static int snd_ctl_elem_add(struct snd_ctl_file *file, return 0; } -static int snd_ctl_elem_add_user(struct snd_ctl_file *file, - struct snd_ctl_elem_info __user *_info, int replace) +static int snd_ctl_elem_add_user(snd_ctl_file_t *file, snd_ctl_elem_info_t __user *_info, int replace) { - struct snd_ctl_elem_info info; + snd_ctl_elem_info_t info; if (copy_from_user(&info, _info, sizeof(info))) return -EFAULT; return snd_ctl_elem_add(file, &info, replace); } -static int snd_ctl_elem_remove(struct snd_ctl_file *file, - struct snd_ctl_elem_id __user *_id) +static int snd_ctl_elem_remove(snd_ctl_file_t *file, snd_ctl_elem_id_t __user *_id) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; int err; if (copy_from_user(&id, _id, sizeof(id))) return -EFAULT; err = snd_ctl_remove_unlocked_id(file, &id); if (! err) { - struct snd_card *card = file->card; + snd_card_t *card = file->card; down_write(&card->controls_rwsem); card->user_ctl_count--; up_write(&card->controls_rwsem); @@ -1005,7 +982,7 @@ static int snd_ctl_elem_remove(struct snd_ctl_file *file, return err; } -static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr) +static int snd_ctl_subscribe_events(snd_ctl_file_t *file, int __user *ptr) { int subscribe; if (get_user(subscribe, ptr)) @@ -1026,12 +1003,42 @@ static int snd_ctl_subscribe_events(struct snd_ctl_file *file, int __user *ptr) return 0; } +#ifdef CONFIG_PM +/* + * change the power state + */ +static int snd_ctl_set_power_state(snd_card_t *card, unsigned int power_state) +{ + switch (power_state) { + case SNDRV_CTL_POWER_D0: + if (card->power_state != power_state) { + card->pm_resume(card); + snd_power_change_state(card, power_state); + } + break; + case SNDRV_CTL_POWER_D3hot: + if (card->power_state != power_state) { + card->pm_suspend(card, PMSG_SUSPEND); + snd_power_change_state(card, power_state); + } + break; + case SNDRV_CTL_POWER_D1: + case SNDRV_CTL_POWER_D2: + case SNDRV_CTL_POWER_D3cold: + /* not supported yet */ + default: + return -EINVAL; + } + return 0; +} +#endif + static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_ctl_file *ctl; - struct snd_card *card; + snd_ctl_file_t *ctl; + snd_card_t *card; struct list_head *list; - struct snd_kctl_ioctl *p; + snd_kctl_ioctl_t *p; void __user *argp = (void __user *)arg; int __user *ip = argp; int err; @@ -1065,7 +1072,19 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS: return snd_ctl_subscribe_events(ctl, ip); case SNDRV_CTL_IOCTL_POWER: - return -ENOPROTOOPT; + if (get_user(err, ip)) + return -EFAULT; + if (!capable(CAP_SYS_ADMIN)) + return -EPERM; +#ifdef CONFIG_PM + if (card->pm_suspend && card->pm_resume) { + snd_power_lock(card); + err = snd_ctl_set_power_state(card, err); + snd_power_unlock(card); + } else +#endif + err = -ENOPROTOOPT; + return err; case SNDRV_CTL_IOCTL_POWER_STATE: #ifdef CONFIG_PM return put_user(card->power_state, ip) ? -EFAULT : 0; @@ -1075,7 +1094,7 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg } down_read(&snd_ioctl_rwsem); list_for_each(list, &snd_control_ioctls) { - p = list_entry(list, struct snd_kctl_ioctl, list); + p = list_entry(list, snd_kctl_ioctl_t, list); err = p->fioctl(card, ctl, cmd, arg); if (err != -ENOIOCTLCMD) { up_read(&snd_ioctl_rwsem); @@ -1087,10 +1106,9 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg return -ENOTTY; } -static ssize_t snd_ctl_read(struct file *file, char __user *buffer, - size_t count, loff_t * offset) +static ssize_t snd_ctl_read(struct file *file, char __user *buffer, size_t count, loff_t * offset) { - struct snd_ctl_file *ctl; + snd_ctl_file_t *ctl; int err = 0; ssize_t result = 0; @@ -1098,12 +1116,12 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO); if (!ctl->subscribed) return -EBADFD; - if (count < sizeof(struct snd_ctl_event)) + if (count < sizeof(snd_ctl_event_t)) return -EINVAL; spin_lock_irq(&ctl->read_lock); - while (count >= sizeof(struct snd_ctl_event)) { - struct snd_ctl_event ev; - struct snd_kctl_event *kev; + while (count >= sizeof(snd_ctl_event_t)) { + snd_ctl_event_t ev; + snd_kctl_event_t *kev; while (list_empty(&ctl->events)) { wait_queue_t wait; if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { @@ -1127,14 +1145,14 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, list_del(&kev->list); spin_unlock_irq(&ctl->read_lock); kfree(kev); - if (copy_to_user(buffer, &ev, sizeof(struct snd_ctl_event))) { + if (copy_to_user(buffer, &ev, sizeof(snd_ctl_event_t))) { err = -EFAULT; goto __end; } spin_lock_irq(&ctl->read_lock); - buffer += sizeof(struct snd_ctl_event); - count -= sizeof(struct snd_ctl_event); - result += sizeof(struct snd_ctl_event); + buffer += sizeof(snd_ctl_event_t); + count -= sizeof(snd_ctl_event_t); + result += sizeof(snd_ctl_event_t); } __end_lock: spin_unlock_irq(&ctl->read_lock); @@ -1145,7 +1163,7 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer, static unsigned int snd_ctl_poll(struct file *file, poll_table * wait) { unsigned int mask; - struct snd_ctl_file *ctl; + snd_ctl_file_t *ctl; ctl = file->private_data; if (!ctl->subscribed) @@ -1165,9 +1183,9 @@ static unsigned int snd_ctl_poll(struct file *file, poll_table * wait) */ static int _snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists) { - struct snd_kctl_ioctl *pn; + snd_kctl_ioctl_t *pn; - pn = kzalloc(sizeof(struct snd_kctl_ioctl), GFP_KERNEL); + pn = kzalloc(sizeof(snd_kctl_ioctl_t), GFP_KERNEL); if (pn == NULL) return -ENOMEM; pn->fioctl = fcn; @@ -1192,16 +1210,15 @@ int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn) /* * de-register the device-specific control-ioctls. */ -static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn, - struct list_head *lists) +static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn, struct list_head *lists) { struct list_head *list; - struct snd_kctl_ioctl *p; + snd_kctl_ioctl_t *p; snd_assert(fcn != NULL, return -EINVAL); down_write(&snd_ioctl_rwsem); list_for_each(list, lists) { - p = list_entry(list, struct snd_kctl_ioctl, list); + p = list_entry(list, snd_kctl_ioctl_t, list); if (p->fioctl == fcn) { list_del(&p->list); up_write(&snd_ioctl_rwsem); @@ -1229,7 +1246,7 @@ int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn) static int snd_ctl_fasync(int fd, struct file * file, int on) { - struct snd_ctl_file *ctl; + snd_ctl_file_t *ctl; int err; ctl = file->private_data; err = fasync_helper(fd, file, on, &ctl->fasync); @@ -1263,12 +1280,18 @@ static struct file_operations snd_ctl_f_ops = .fasync = snd_ctl_fasync, }; +static snd_minor_t snd_ctl_reg = +{ + .comment = "ctl", + .f_ops = &snd_ctl_f_ops, +}; + /* * registration of the control device */ -static int snd_ctl_dev_register(struct snd_device *device) +static int snd_ctl_dev_register(snd_device_t *device) { - struct snd_card *card = device->device_data; + snd_card_t *card = device->device_data; int err, cardnum; char name[16]; @@ -1276,8 +1299,8 @@ static int snd_ctl_dev_register(struct snd_device *device) cardnum = card->number; snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); sprintf(name, "controlC%i", cardnum); - if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1, - &snd_ctl_f_ops, card, name)) < 0) + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, + card, 0, &snd_ctl_reg, name)) < 0) return err; return 0; } @@ -1285,11 +1308,11 @@ static int snd_ctl_dev_register(struct snd_device *device) /* * disconnection of the control device */ -static int snd_ctl_dev_disconnect(struct snd_device *device) +static int snd_ctl_dev_disconnect(snd_device_t *device) { - struct snd_card *card = device->device_data; + snd_card_t *card = device->device_data; struct list_head *flist; - struct snd_ctl_file *ctl; + snd_ctl_file_t *ctl; down_read(&card->controls_rwsem); list_for_each(flist, &card->ctl_files) { @@ -1304,10 +1327,10 @@ static int snd_ctl_dev_disconnect(struct snd_device *device) /* * free all controls */ -static int snd_ctl_dev_free(struct snd_device *device) +static int snd_ctl_dev_free(snd_device_t *device) { - struct snd_card *card = device->device_data; - struct snd_kcontrol *control; + snd_card_t *card = device->device_data; + snd_kcontrol_t *control; down_write(&card->controls_rwsem); while (!list_empty(&card->controls)) { @@ -1321,16 +1344,15 @@ static int snd_ctl_dev_free(struct snd_device *device) /* * de-registration of the control device */ -static int snd_ctl_dev_unregister(struct snd_device *device) +static int snd_ctl_dev_unregister(snd_device_t *device) { - struct snd_card *card = device->device_data; + snd_card_t *card = device->device_data; int err, cardnum; snd_assert(card != NULL, return -ENXIO); cardnum = card->number; snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); - if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, - card, -1)) < 0) + if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL, card, 0)) < 0) return err; return snd_ctl_dev_free(device); } @@ -1339,9 +1361,9 @@ static int snd_ctl_dev_unregister(struct snd_device *device) * create control core: * called from init.c */ -int snd_ctl_create(struct snd_card *card) +int snd_ctl_create(snd_card_t *card) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ctl_dev_free, .dev_register = snd_ctl_dev_register, .dev_disconnect = snd_ctl_dev_disconnect, diff --git a/trunk/sound/core/control_compat.c b/trunk/sound/core/control_compat.c index 418c6d4e5daf..207c7de5129c 100644 --- a/trunk/sound/core/control_compat.c +++ b/trunk/sound/core/control_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct snd_ctl_elem_list32 { +struct sndrv_ctl_elem_list32 { u32 offset; u32 space; u32 used; @@ -31,10 +31,9 @@ struct snd_ctl_elem_list32 { unsigned char reserved[50]; } /* don't set packed attribute here */; -static int snd_ctl_elem_list_compat(struct snd_card *card, - struct snd_ctl_elem_list32 __user *data32) +static int snd_ctl_elem_list_compat(snd_card_t *card, struct sndrv_ctl_elem_list32 __user *data32) { - struct snd_ctl_elem_list __user *data; + struct sndrv_ctl_elem_list __user *data; compat_caddr_t ptr; int err; @@ -61,8 +60,8 @@ static int snd_ctl_elem_list_compat(struct snd_card *card, * it uses union, so the things are not easy.. */ -struct snd_ctl_elem_info32 { - struct snd_ctl_elem_id id; // the size of struct is same +struct sndrv_ctl_elem_info32 { + struct sndrv_ctl_elem_id id; // the size of struct is same s32 type; u32 access; u32 count; @@ -88,10 +87,9 @@ struct snd_ctl_elem_info32 { unsigned char reserved[64]; } __attribute__((packed)); -static int snd_ctl_elem_info_compat(struct snd_ctl_file *ctl, - struct snd_ctl_elem_info32 __user *data32) +static int snd_ctl_elem_info_compat(snd_ctl_file_t *ctl, struct sndrv_ctl_elem_info32 __user *data32) { - struct snd_ctl_elem_info *data; + struct sndrv_ctl_elem_info *data; int err; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -148,8 +146,8 @@ static int snd_ctl_elem_info_compat(struct snd_ctl_file *ctl, } /* read / write */ -struct snd_ctl_elem_value32 { - struct snd_ctl_elem_id id; +struct sndrv_ctl_elem_value32 { + struct sndrv_ctl_elem_id id; unsigned int indirect; /* bit-field causes misalignment */ union { s32 integer[128]; @@ -163,11 +161,10 @@ struct snd_ctl_elem_value32 { /* get the value type and count of the control */ -static int get_ctl_type(struct snd_card *card, struct snd_ctl_elem_id *id, - int *countp) +static int get_ctl_type(snd_card_t *card, snd_ctl_elem_id_t *id, int *countp) { - struct snd_kcontrol *kctl; - struct snd_ctl_elem_info info; + snd_kcontrol_t *kctl; + snd_ctl_elem_info_t info; int err; down_read(&card->controls_rwsem); @@ -196,15 +193,15 @@ static int get_elem_size(int type, int count) case SNDRV_CTL_ELEM_TYPE_BYTES: return 512; case SNDRV_CTL_ELEM_TYPE_IEC958: - return sizeof(struct snd_aes_iec958); + return sizeof(struct sndrv_aes_iec958); default: return -1; } } -static int copy_ctl_value_from_user(struct snd_card *card, - struct snd_ctl_elem_value *data, - struct snd_ctl_elem_value32 __user *data32, +static int copy_ctl_value_from_user(snd_card_t *card, + struct sndrv_ctl_elem_value *data, + struct sndrv_ctl_elem_value32 __user *data32, int *typep, int *countp) { int i, type, count, size; @@ -245,8 +242,8 @@ static int copy_ctl_value_from_user(struct snd_card *card, } /* restore the value to 32bit */ -static int copy_ctl_value_to_user(struct snd_ctl_elem_value32 __user *data32, - struct snd_ctl_elem_value *data, +static int copy_ctl_value_to_user(struct sndrv_ctl_elem_value32 __user *data32, + struct sndrv_ctl_elem_value *data, int type, int count) { int i, size; @@ -268,10 +265,10 @@ static int copy_ctl_value_to_user(struct snd_ctl_elem_value32 __user *data32, return 0; } -static int snd_ctl_elem_read_user_compat(struct snd_card *card, - struct snd_ctl_elem_value32 __user *data32) +static int snd_ctl_elem_read_user_compat(snd_card_t *card, + struct sndrv_ctl_elem_value32 __user *data32) { - struct snd_ctl_elem_value *data; + struct sndrv_ctl_elem_value *data; int err, type, count; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -288,10 +285,10 @@ static int snd_ctl_elem_read_user_compat(struct snd_card *card, return err; } -static int snd_ctl_elem_write_user_compat(struct snd_ctl_file *file, - struct snd_ctl_elem_value32 __user *data32) +static int snd_ctl_elem_write_user_compat(snd_ctl_file_t *file, + struct sndrv_ctl_elem_value32 __user *data32) { - struct snd_ctl_elem_value *data; + struct sndrv_ctl_elem_value *data; int err, type, count; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -309,11 +306,11 @@ static int snd_ctl_elem_write_user_compat(struct snd_ctl_file *file, } /* add or replace a user control */ -static int snd_ctl_elem_add_compat(struct snd_ctl_file *file, - struct snd_ctl_elem_info32 __user *data32, +static int snd_ctl_elem_add_compat(snd_ctl_file_t *file, + struct sndrv_ctl_elem_info32 __user *data32, int replace) { - struct snd_ctl_elem_info *data; + struct sndrv_ctl_elem_info *data; int err; data = kzalloc(sizeof(*data), GFP_KERNEL); @@ -358,17 +355,17 @@ static int snd_ctl_elem_add_compat(struct snd_ctl_file *file, } enum { - SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct snd_ctl_elem_list32), - SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct snd_ctl_elem_info32), - SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct snd_ctl_elem_value32), - SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct snd_ctl_elem_value32), - SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct snd_ctl_elem_info32), - SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct snd_ctl_elem_info32), + SNDRV_CTL_IOCTL_ELEM_LIST32 = _IOWR('U', 0x10, struct sndrv_ctl_elem_list32), + SNDRV_CTL_IOCTL_ELEM_INFO32 = _IOWR('U', 0x11, struct sndrv_ctl_elem_info32), + SNDRV_CTL_IOCTL_ELEM_READ32 = _IOWR('U', 0x12, struct sndrv_ctl_elem_value32), + SNDRV_CTL_IOCTL_ELEM_WRITE32 = _IOWR('U', 0x13, struct sndrv_ctl_elem_value32), + SNDRV_CTL_IOCTL_ELEM_ADD32 = _IOWR('U', 0x17, struct sndrv_ctl_elem_info32), + SNDRV_CTL_IOCTL_ELEM_REPLACE32 = _IOWR('U', 0x18, struct sndrv_ctl_elem_info32), }; static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_ctl_file *ctl; + snd_ctl_file_t *ctl; struct list_head *list; void __user *argp = compat_ptr(arg); int err; @@ -401,7 +398,7 @@ static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, uns down_read(&snd_ioctl_rwsem); list_for_each(list, &snd_control_compat_ioctls) { - struct snd_kctl_ioctl *p = list_entry(list, struct snd_kctl_ioctl, list); + snd_kctl_ioctl_t *p = list_entry(list, snd_kctl_ioctl_t, list); if (p->fioctl) { err = p->fioctl(ctl->card, ctl, cmd, arg); if (err != -ENOIOCTLCMD) { diff --git a/trunk/sound/core/device.c b/trunk/sound/core/device.c index b1cf6ec56784..1f509f56e60c 100644 --- a/trunk/sound/core/device.c +++ b/trunk/sound/core/device.c @@ -41,19 +41,17 @@ * * Returns zero if successful, or a negative error code on failure. */ -int snd_device_new(struct snd_card *card, snd_device_type_t type, - void *device_data, struct snd_device_ops *ops) +int snd_device_new(snd_card_t *card, snd_device_type_t type, + void *device_data, snd_device_ops_t *ops) { - struct snd_device *dev; + snd_device_t *dev; snd_assert(card != NULL, return -ENXIO); snd_assert(device_data != NULL, return -ENXIO); snd_assert(ops != NULL, return -ENXIO); dev = kzalloc(sizeof(*dev), GFP_KERNEL); - if (dev == NULL) { - snd_printk(KERN_ERR "Cannot allocate device\n"); + if (dev == NULL) return -ENOMEM; - } dev->card = card; dev->type = type; dev->state = SNDRV_DEV_BUILD; @@ -75,10 +73,10 @@ int snd_device_new(struct snd_card *card, snd_device_type_t type, * Returns zero if successful, or a negative error code on failure or if the * device not found. */ -int snd_device_free(struct snd_card *card, void *device_data) +int snd_device_free(snd_card_t *card, void *device_data) { struct list_head *list; - struct snd_device *dev; + snd_device_t *dev; snd_assert(card != NULL, return -ENXIO); snd_assert(device_data != NULL, return -ENXIO); @@ -88,8 +86,7 @@ int snd_device_free(struct snd_card *card, void *device_data) continue; /* unlink */ list_del(&dev->list); - if ((dev->state == SNDRV_DEV_REGISTERED || - dev->state == SNDRV_DEV_DISCONNECTED) && + if ((dev->state == SNDRV_DEV_REGISTERED || dev->state == SNDRV_DEV_DISCONNECTED) && dev->ops->dev_unregister) { if (dev->ops->dev_unregister(dev)) snd_printk(KERN_ERR "device unregister failure\n"); @@ -102,8 +99,7 @@ int snd_device_free(struct snd_card *card, void *device_data) kfree(dev); return 0; } - snd_printd("device free %p (from %p), not found\n", device_data, - __builtin_return_address(0)); + snd_printd("device free %p (from %p), not found\n", device_data, __builtin_return_address(0)); return -ENXIO; } @@ -120,10 +116,10 @@ int snd_device_free(struct snd_card *card, void *device_data) * Returns zero if successful, or a negative error code on failure or if the * device not found. */ -int snd_device_disconnect(struct snd_card *card, void *device_data) +int snd_device_disconnect(snd_card_t *card, void *device_data) { struct list_head *list; - struct snd_device *dev; + snd_device_t *dev; snd_assert(card != NULL, return -ENXIO); snd_assert(device_data != NULL, return -ENXIO); @@ -131,16 +127,14 @@ int snd_device_disconnect(struct snd_card *card, void *device_data) dev = snd_device(list); if (dev->device_data != device_data) continue; - if (dev->state == SNDRV_DEV_REGISTERED && - dev->ops->dev_disconnect) { + if (dev->state == SNDRV_DEV_REGISTERED && dev->ops->dev_disconnect) { if (dev->ops->dev_disconnect(dev)) snd_printk(KERN_ERR "device disconnect failure\n"); dev->state = SNDRV_DEV_DISCONNECTED; } return 0; } - snd_printd("device disconnect %p (from %p), not found\n", device_data, - __builtin_return_address(0)); + snd_printd("device disconnect %p (from %p), not found\n", device_data, __builtin_return_address(0)); return -ENXIO; } @@ -157,10 +151,10 @@ int snd_device_disconnect(struct snd_card *card, void *device_data) * Returns zero if successful, or a negative error code on failure or if the * device not found. */ -int snd_device_register(struct snd_card *card, void *device_data) +int snd_device_register(snd_card_t *card, void *device_data) { struct list_head *list; - struct snd_device *dev; + snd_device_t *dev; int err; snd_assert(card != NULL, return -ENXIO); @@ -175,7 +169,6 @@ int snd_device_register(struct snd_card *card, void *device_data) dev->state = SNDRV_DEV_REGISTERED; return 0; } - snd_printd("snd_device_register busy\n"); return -EBUSY; } snd_BUG(); @@ -186,10 +179,10 @@ int snd_device_register(struct snd_card *card, void *device_data) * register all the devices on the card. * called from init.c */ -int snd_device_register_all(struct snd_card *card) +int snd_device_register_all(snd_card_t *card) { struct list_head *list; - struct snd_device *dev; + snd_device_t *dev; int err; snd_assert(card != NULL, return -ENXIO); @@ -208,9 +201,9 @@ int snd_device_register_all(struct snd_card *card) * disconnect all the devices on the card. * called from init.c */ -int snd_device_disconnect_all(struct snd_card *card) +int snd_device_disconnect_all(snd_card_t *card) { - struct snd_device *dev; + snd_device_t *dev; struct list_head *list; int err = 0; @@ -227,9 +220,9 @@ int snd_device_disconnect_all(struct snd_card *card) * release all the devices on the card. * called from init.c */ -int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd) +int snd_device_free_all(snd_card_t *card, snd_device_cmd_t cmd) { - struct snd_device *dev; + snd_device_t *dev; struct list_head *list; int err; unsigned int range_low, range_high; diff --git a/trunk/sound/core/hwdep.c b/trunk/sound/core/hwdep.c index 618c43be0bc3..e91cee35a4b9 100644 --- a/trunk/sound/core/hwdep.c +++ b/trunk/sound/core/hwdep.c @@ -35,49 +35,38 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("Hardware dependent layer"); MODULE_LICENSE("GPL"); -static LIST_HEAD(snd_hwdep_devices); -static DECLARE_MUTEX(register_mutex); +static snd_hwdep_t *snd_hwdep_devices[SNDRV_CARDS * SNDRV_MINOR_HWDEPS]; -static int snd_hwdep_free(struct snd_hwdep *hwdep); -static int snd_hwdep_dev_free(struct snd_device *device); -static int snd_hwdep_dev_register(struct snd_device *device); -static int snd_hwdep_dev_unregister(struct snd_device *device); +static DECLARE_MUTEX(register_mutex); +static int snd_hwdep_free(snd_hwdep_t *hwdep); +static int snd_hwdep_dev_free(snd_device_t *device); +static int snd_hwdep_dev_register(snd_device_t *device); +static int snd_hwdep_dev_unregister(snd_device_t *device); -static struct snd_hwdep *snd_hwdep_search(struct snd_card *card, int device) -{ - struct list_head *p; - struct snd_hwdep *hwdep; +/* - list_for_each(p, &snd_hwdep_devices) { - hwdep = list_entry(p, struct snd_hwdep, list); - if (hwdep->card == card && hwdep->device == device) - return hwdep; - } - return NULL; -} + */ static loff_t snd_hwdep_llseek(struct file * file, loff_t offset, int orig) { - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; if (hw->ops.llseek) return hw->ops.llseek(hw, file, offset, orig); return -ENXIO; } -static ssize_t snd_hwdep_read(struct file * file, char __user *buf, - size_t count, loff_t *offset) +static ssize_t snd_hwdep_read(struct file * file, char __user *buf, size_t count, loff_t *offset) { - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; if (hw->ops.read) return hw->ops.read(hw, buf, count, offset); return -ENXIO; } -static ssize_t snd_hwdep_write(struct file * file, const char __user *buf, - size_t count, loff_t *offset) +static ssize_t snd_hwdep_write(struct file * file, const char __user *buf, size_t count, loff_t *offset) { - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; if (hw->ops.write) return hw->ops.write(hw, buf, count, offset); return -ENXIO; @@ -86,25 +75,34 @@ static ssize_t snd_hwdep_write(struct file * file, const char __user *buf, static int snd_hwdep_open(struct inode *inode, struct file * file) { int major = imajor(inode); - struct snd_hwdep *hw; + int cardnum; + int device; + snd_hwdep_t *hw; int err; wait_queue_t wait; if (major == snd_major) { - hw = snd_lookup_minor_data(iminor(inode), - SNDRV_DEVICE_TYPE_HWDEP); + cardnum = SNDRV_MINOR_CARD(iminor(inode)); + device = SNDRV_MINOR_DEVICE(iminor(inode)) - SNDRV_MINOR_HWDEP; #ifdef CONFIG_SND_OSSEMUL } else if (major == SOUND_MAJOR) { - hw = snd_lookup_oss_minor_data(iminor(inode), - SNDRV_OSS_DEVICE_TYPE_DMFM); + cardnum = SNDRV_MINOR_OSS_CARD(iminor(inode)); + device = 0; #endif } else return -ENXIO; + cardnum %= SNDRV_CARDS; + device %= SNDRV_MINOR_HWDEPS; + hw = snd_hwdep_devices[(cardnum * SNDRV_MINOR_HWDEPS) + device]; if (hw == NULL) return -ENODEV; if (!hw->ops.open) return -ENXIO; +#ifdef CONFIG_SND_OSSEMUL + if (major == SOUND_MAJOR && hw->oss_type < 0) + return -ENXIO; +#endif if (!try_module_get(hw->card->module)) return -EFAULT; @@ -156,7 +154,7 @@ static int snd_hwdep_open(struct inode *inode, struct file * file) static int snd_hwdep_release(struct inode *inode, struct file * file) { int err = -ENXIO; - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; down(&hw->open_mutex); if (hw->ops.release) { err = hw->ops.release(hw, file); @@ -172,16 +170,15 @@ static int snd_hwdep_release(struct inode *inode, struct file * file) static unsigned int snd_hwdep_poll(struct file * file, poll_table * wait) { - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; if (hw->ops.poll) return hw->ops.poll(hw, file, wait); return 0; } -static int snd_hwdep_info(struct snd_hwdep *hw, - struct snd_hwdep_info __user *_info) +static int snd_hwdep_info(snd_hwdep_t *hw, snd_hwdep_info_t __user *_info) { - struct snd_hwdep_info info; + snd_hwdep_info_t info; memset(&info, 0, sizeof(info)); info.card = hw->card->number; @@ -193,10 +190,9 @@ static int snd_hwdep_info(struct snd_hwdep *hw, return 0; } -static int snd_hwdep_dsp_status(struct snd_hwdep *hw, - struct snd_hwdep_dsp_status __user *_info) +static int snd_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t __user *_info) { - struct snd_hwdep_dsp_status info; + snd_hwdep_dsp_status_t info; int err; if (! hw->ops.dsp_status) @@ -210,10 +206,9 @@ static int snd_hwdep_dsp_status(struct snd_hwdep *hw, return 0; } -static int snd_hwdep_dsp_load(struct snd_hwdep *hw, - struct snd_hwdep_dsp_image __user *_info) +static int snd_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t __user *_info) { - struct snd_hwdep_dsp_image info; + snd_hwdep_dsp_image_t info; int err; if (! hw->ops.dsp_load) @@ -233,10 +228,9 @@ static int snd_hwdep_dsp_load(struct snd_hwdep *hw, return 0; } -static long snd_hwdep_ioctl(struct file * file, unsigned int cmd, - unsigned long arg) +static long snd_hwdep_ioctl(struct file * file, unsigned int cmd, unsigned long arg) { - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; void __user *argp = (void __user *)arg; switch (cmd) { case SNDRV_HWDEP_IOCTL_PVERSION: @@ -255,16 +249,18 @@ static long snd_hwdep_ioctl(struct file * file, unsigned int cmd, static int snd_hwdep_mmap(struct file * file, struct vm_area_struct * vma) { - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; if (hw->ops.mmap) return hw->ops.mmap(hw, file, vma); return -ENXIO; } -static int snd_hwdep_control_ioctl(struct snd_card *card, - struct snd_ctl_file * control, +static int snd_hwdep_control_ioctl(snd_card_t * card, snd_ctl_file_t * control, unsigned int cmd, unsigned long arg) { + unsigned int tmp; + + tmp = card->number * SNDRV_MINOR_HWDEPS; switch (cmd) { case SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE: { @@ -272,36 +268,32 @@ static int snd_hwdep_control_ioctl(struct snd_card *card, if (get_user(device, (int __user *)arg)) return -EFAULT; - down(®ister_mutex); device = device < 0 ? 0 : device + 1; while (device < SNDRV_MINOR_HWDEPS) { - if (snd_hwdep_search(card, device)) + if (snd_hwdep_devices[tmp + device]) break; device++; } if (device >= SNDRV_MINOR_HWDEPS) device = -1; - up(®ister_mutex); if (put_user(device, (int __user *)arg)) return -EFAULT; return 0; } case SNDRV_CTL_IOCTL_HWDEP_INFO: { - struct snd_hwdep_info __user *info = (struct snd_hwdep_info __user *)arg; - int device, err; - struct snd_hwdep *hwdep; + snd_hwdep_info_t __user *info = (snd_hwdep_info_t __user *)arg; + int device; + snd_hwdep_t *hwdep; if (get_user(device, &info->device)) return -EFAULT; - down(®ister_mutex); - hwdep = snd_hwdep_search(card, device); - if (hwdep) - err = snd_hwdep_info(hwdep, info); - else - err = -ENXIO; - up(®ister_mutex); - return err; + if (device < 0 || device >= SNDRV_MINOR_HWDEPS) + return -ENXIO; + hwdep = snd_hwdep_devices[tmp + device]; + if (hwdep == NULL) + return -ENXIO; + return snd_hwdep_info(hwdep, info); } } return -ENOIOCTLCMD; @@ -331,6 +323,12 @@ static struct file_operations snd_hwdep_f_ops = .mmap = snd_hwdep_mmap, }; +static snd_minor_t snd_hwdep_reg = +{ + .comment = "hardware dependent", + .f_ops = &snd_hwdep_f_ops, +}; + /** * snd_hwdep_new - create a new hwdep instance * @card: the card instance @@ -344,12 +342,11 @@ static struct file_operations snd_hwdep_f_ops = * * Returns zero if successful, or a negative error code on failure. */ -int snd_hwdep_new(struct snd_card *card, char *id, int device, - struct snd_hwdep **rhwdep) +int snd_hwdep_new(snd_card_t * card, char *id, int device, snd_hwdep_t ** rhwdep) { - struct snd_hwdep *hwdep; + snd_hwdep_t *hwdep; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_hwdep_dev_free, .dev_register = snd_hwdep_dev_register, .dev_unregister = snd_hwdep_dev_unregister @@ -359,14 +356,13 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device, *rhwdep = NULL; snd_assert(card != NULL, return -ENXIO); hwdep = kzalloc(sizeof(*hwdep), GFP_KERNEL); - if (hwdep == NULL) { - snd_printk(KERN_ERR "hwdep: cannot allocate\n"); + if (hwdep == NULL) return -ENOMEM; - } hwdep->card = card; hwdep->device = device; - if (id) + if (id) { strlcpy(hwdep->id, id, sizeof(hwdep->id)); + } #ifdef CONFIG_SND_OSSEMUL hwdep->oss_type = -1; #endif @@ -380,7 +376,7 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device, return 0; } -static int snd_hwdep_free(struct snd_hwdep *hwdep) +static int snd_hwdep_free(snd_hwdep_t *hwdep) { snd_assert(hwdep != NULL, return -ENXIO); if (hwdep->private_free) @@ -389,31 +385,32 @@ static int snd_hwdep_free(struct snd_hwdep *hwdep) return 0; } -static int snd_hwdep_dev_free(struct snd_device *device) +static int snd_hwdep_dev_free(snd_device_t *device) { - struct snd_hwdep *hwdep = device->device_data; + snd_hwdep_t *hwdep = device->device_data; return snd_hwdep_free(hwdep); } -static int snd_hwdep_dev_register(struct snd_device *device) +static int snd_hwdep_dev_register(snd_device_t *device) { - struct snd_hwdep *hwdep = device->device_data; - int err; + snd_hwdep_t *hwdep = device->device_data; + int idx, err; char name[32]; down(®ister_mutex); - if (snd_hwdep_search(hwdep->card, hwdep->device)) { + idx = (hwdep->card->number * SNDRV_MINOR_HWDEPS) + hwdep->device; + if (snd_hwdep_devices[idx]) { up(®ister_mutex); return -EBUSY; } - list_add_tail(&hwdep->list, &snd_hwdep_devices); + snd_hwdep_devices[idx] = hwdep; sprintf(name, "hwC%iD%i", hwdep->card->number, hwdep->device); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, hwdep->device, - &snd_hwdep_f_ops, hwdep, name)) < 0) { + &snd_hwdep_reg, name)) < 0) { snd_printk(KERN_ERR "unable to register hardware dependent device %i:%i\n", hwdep->card->number, hwdep->device); - list_del(&hwdep->list); + snd_hwdep_devices[idx] = NULL; up(®ister_mutex); return err; } @@ -425,8 +422,7 @@ static int snd_hwdep_dev_register(struct snd_device *device) } else { if (snd_register_oss_device(hwdep->oss_type, hwdep->card, hwdep->device, - &snd_hwdep_f_ops, hwdep, - hwdep->oss_dev) < 0) { + &snd_hwdep_reg, hwdep->oss_dev) < 0) { snd_printk(KERN_ERR "unable to register OSS compatibility device %i:%i\n", hwdep->card->number, hwdep->device); } else @@ -438,13 +434,15 @@ static int snd_hwdep_dev_register(struct snd_device *device) return 0; } -static int snd_hwdep_dev_unregister(struct snd_device *device) +static int snd_hwdep_dev_unregister(snd_device_t *device) { - struct snd_hwdep *hwdep = device->device_data; + snd_hwdep_t *hwdep = device->device_data; + int idx; snd_assert(hwdep != NULL, return -ENXIO); down(®ister_mutex); - if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep) { + idx = (hwdep->card->number * SNDRV_MINOR_HWDEPS) + hwdep->device; + if (snd_hwdep_devices[idx] != hwdep) { up(®ister_mutex); return -EINVAL; } @@ -453,39 +451,47 @@ static int snd_hwdep_dev_unregister(struct snd_device *device) snd_unregister_oss_device(hwdep->oss_type, hwdep->card, hwdep->device); #endif snd_unregister_device(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, hwdep->device); - list_del(&hwdep->list); + snd_hwdep_devices[idx] = NULL; up(®ister_mutex); return snd_hwdep_free(hwdep); } -#ifdef CONFIG_PROC_FS /* * Info interface */ -static void snd_hwdep_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_hwdep_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct list_head *p; - struct snd_hwdep *hwdep; + int idx; + snd_hwdep_t *hwdep; down(®ister_mutex); - list_for_each(p, &snd_hwdep_devices) { - hwdep = list_entry(p, struct snd_hwdep, list); + for (idx = 0; idx < SNDRV_CARDS * SNDRV_MINOR_HWDEPS; idx++) { + hwdep = snd_hwdep_devices[idx]; + if (hwdep == NULL) + continue; snd_iprintf(buffer, "%02i-%02i: %s\n", - hwdep->card->number, hwdep->device, hwdep->name); + idx / SNDRV_MINOR_HWDEPS, + idx % SNDRV_MINOR_HWDEPS, + hwdep->name); } up(®ister_mutex); } -static struct snd_info_entry *snd_hwdep_proc_entry; +/* + * ENTRY functions + */ -static void __init snd_hwdep_proc_init(void) +static snd_info_entry_t *snd_hwdep_proc_entry = NULL; + +static int __init alsa_hwdep_init(void) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; + memset(snd_hwdep_devices, 0, sizeof(snd_hwdep_devices)); if ((entry = snd_info_create_module_entry(THIS_MODULE, "hwdep", NULL)) != NULL) { - entry->c.text.read_size = PAGE_SIZE; + entry->c.text.read_size = 512; entry->c.text.read = snd_hwdep_proc_read; if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); @@ -493,25 +499,6 @@ static void __init snd_hwdep_proc_init(void) } } snd_hwdep_proc_entry = entry; -} - -static void __exit snd_hwdep_proc_done(void) -{ - snd_info_unregister(snd_hwdep_proc_entry); -} -#else /* !CONFIG_PROC_FS */ -#define snd_hwdep_proc_init() -#define snd_hwdep_proc_done() -#endif /* CONFIG_PROC_FS */ - - -/* - * ENTRY functions - */ - -static int __init alsa_hwdep_init(void) -{ - snd_hwdep_proc_init(); snd_ctl_register_ioctl(snd_hwdep_control_ioctl); snd_ctl_register_ioctl_compat(snd_hwdep_control_ioctl); return 0; @@ -521,7 +508,10 @@ static void __exit alsa_hwdep_exit(void) { snd_ctl_unregister_ioctl(snd_hwdep_control_ioctl); snd_ctl_unregister_ioctl_compat(snd_hwdep_control_ioctl); - snd_hwdep_proc_done(); + if (snd_hwdep_proc_entry) { + snd_info_unregister(snd_hwdep_proc_entry); + snd_hwdep_proc_entry = NULL; + } } module_init(alsa_hwdep_init) diff --git a/trunk/sound/core/hwdep_compat.c b/trunk/sound/core/hwdep_compat.c index 938f77580966..6866f423d4b9 100644 --- a/trunk/sound/core/hwdep_compat.c +++ b/trunk/sound/core/hwdep_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct snd_hwdep_dsp_image32 { +struct sndrv_hwdep_dsp_image32 { u32 index; unsigned char name[64]; u32 image; /* pointer */ @@ -30,10 +30,10 @@ struct snd_hwdep_dsp_image32 { u32 driver_data; } /* don't set packed attribute here */; -static int snd_hwdep_dsp_load_compat(struct snd_hwdep *hw, - struct snd_hwdep_dsp_image32 __user *src) +static int snd_hwdep_dsp_load_compat(snd_hwdep_t *hw, + struct sndrv_hwdep_dsp_image32 __user *src) { - struct snd_hwdep_dsp_image *dst; + struct sndrv_hwdep_dsp_image *dst; compat_caddr_t ptr; u32 val; @@ -56,13 +56,12 @@ static int snd_hwdep_dsp_load_compat(struct snd_hwdep *hw, } enum { - SNDRV_HWDEP_IOCTL_DSP_LOAD32 = _IOW('H', 0x03, struct snd_hwdep_dsp_image32) + SNDRV_HWDEP_IOCTL_DSP_LOAD32 = _IOW('H', 0x03, struct sndrv_hwdep_dsp_image32) }; -static long snd_hwdep_ioctl_compat(struct file * file, unsigned int cmd, - unsigned long arg) +static long snd_hwdep_ioctl_compat(struct file * file, unsigned int cmd, unsigned long arg) { - struct snd_hwdep *hw = file->private_data; + snd_hwdep_t *hw = file->private_data; void __user *argp = compat_ptr(arg); switch (cmd) { case SNDRV_HWDEP_IOCTL_PVERSION: diff --git a/trunk/sound/core/info.c b/trunk/sound/core/info.c index ae8853921464..39f9b97d9219 100644 --- a/trunk/sound/core/info.c +++ b/trunk/sound/core/info.c @@ -37,8 +37,6 @@ * */ -#ifdef CONFIG_PROC_FS - int snd_info_check_reserved_words(const char *str) { static char *reserved[] = @@ -68,14 +66,16 @@ int snd_info_check_reserved_words(const char *str) return 1; } +#ifdef CONFIG_PROC_FS + static DECLARE_MUTEX(info_mutex); -struct snd_info_private_data { - struct snd_info_buffer *rbuffer; - struct snd_info_buffer *wbuffer; - struct snd_info_entry *entry; +typedef struct _snd_info_private_data { + snd_info_buffer_t *rbuffer; + snd_info_buffer_t *wbuffer; + snd_info_entry_t *entry; void *file_private_data; -}; +} snd_info_private_data_t; static int snd_info_version_init(void); static int snd_info_version_done(void); @@ -90,7 +90,7 @@ static int snd_info_version_done(void); * * Returns the size of output string. */ -int snd_iprintf(struct snd_info_buffer *buffer, char *fmt,...) +int snd_iprintf(snd_info_buffer_t * buffer, char *fmt,...) { va_list args; int len, res; @@ -115,9 +115,9 @@ int snd_iprintf(struct snd_info_buffer *buffer, char *fmt,...) */ static struct proc_dir_entry *snd_proc_root = NULL; -struct snd_info_entry *snd_seq_root = NULL; +snd_info_entry_t *snd_seq_root = NULL; #ifdef CONFIG_SND_OSSEMUL -struct snd_info_entry *snd_oss_root = NULL; +snd_info_entry_t *snd_oss_root = NULL; #endif static inline void snd_info_entry_prepare(struct proc_dir_entry *de) @@ -134,7 +134,7 @@ static void snd_remove_proc_entry(struct proc_dir_entry *parent, static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig) { - struct snd_info_private_data *data; + snd_info_private_data_t *data; struct snd_info_entry *entry; loff_t ret; @@ -176,9 +176,9 @@ static loff_t snd_info_entry_llseek(struct file *file, loff_t offset, int orig) static ssize_t snd_info_entry_read(struct file *file, char __user *buffer, size_t count, loff_t * offset) { - struct snd_info_private_data *data; + snd_info_private_data_t *data; struct snd_info_entry *entry; - struct snd_info_buffer *buf; + snd_info_buffer_t *buf; size_t size = 0; loff_t pos; @@ -217,9 +217,9 @@ static ssize_t snd_info_entry_read(struct file *file, char __user *buffer, static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer, size_t count, loff_t * offset) { - struct snd_info_private_data *data; + snd_info_private_data_t *data; struct snd_info_entry *entry; - struct snd_info_buffer *buf; + snd_info_buffer_t *buf; size_t size = 0; loff_t pos; @@ -259,15 +259,15 @@ static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer static int snd_info_entry_open(struct inode *inode, struct file *file) { - struct snd_info_entry *entry; - struct snd_info_private_data *data; - struct snd_info_buffer *buffer; + snd_info_entry_t *entry; + snd_info_private_data_t *data; + snd_info_buffer_t *buffer; struct proc_dir_entry *p; int mode, err; down(&info_mutex); p = PDE(inode); - entry = p == NULL ? NULL : (struct snd_info_entry *)p->data; + entry = p == NULL ? NULL : (snd_info_entry_t *)p->data; if (entry == NULL || entry->disconnected) { up(&info_mutex); return -ENODEV; @@ -381,8 +381,8 @@ static int snd_info_entry_open(struct inode *inode, struct file *file) static int snd_info_entry_release(struct inode *inode, struct file *file) { - struct snd_info_entry *entry; - struct snd_info_private_data *data; + snd_info_entry_t *entry; + snd_info_private_data_t *data; int mode; mode = file->f_flags & O_ACCMODE; @@ -420,7 +420,7 @@ static int snd_info_entry_release(struct inode *inode, struct file *file) static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait) { - struct snd_info_private_data *data; + snd_info_private_data_t *data; struct snd_info_entry *entry; unsigned int mask; @@ -447,7 +447,7 @@ static unsigned int snd_info_entry_poll(struct file *file, poll_table * wait) static inline int _snd_info_entry_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_info_private_data *data; + snd_info_private_data_t *data; struct snd_info_entry *entry; data = file->private_data; @@ -479,7 +479,7 @@ static int snd_info_entry_ioctl(struct inode *inode, struct file *file, static int snd_info_entry_mmap(struct file *file, struct vm_area_struct *vma) { struct inode *inode = file->f_dentry->d_inode; - struct snd_info_private_data *data; + snd_info_private_data_t *data; struct snd_info_entry *entry; data = file->private_data; @@ -541,7 +541,7 @@ int __init snd_info_init(void) snd_proc_root = p; #ifdef CONFIG_SND_OSSEMUL { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if ((entry = snd_info_create_module_entry(THIS_MODULE, "oss", NULL)) == NULL) return -ENOMEM; entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; @@ -554,7 +554,7 @@ int __init snd_info_init(void) #endif #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if ((entry = snd_info_create_module_entry(THIS_MODULE, "seq", NULL)) == NULL) return -ENOMEM; entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; @@ -580,10 +580,12 @@ int __exit snd_info_done(void) snd_info_version_done(); if (snd_proc_root) { #if defined(CONFIG_SND_SEQUENCER) || defined(CONFIG_SND_SEQUENCER_MODULE) - snd_info_unregister(snd_seq_root); + if (snd_seq_root) + snd_info_unregister(snd_seq_root); #endif #ifdef CONFIG_SND_OSSEMUL - snd_info_unregister(snd_oss_root); + if (snd_oss_root) + snd_info_unregister(snd_oss_root); #endif snd_remove_proc_entry(&proc_root, snd_proc_root); } @@ -599,10 +601,10 @@ int __exit snd_info_done(void) * create a card proc file * called from init.c */ -int snd_info_card_create(struct snd_card *card) +int snd_info_card_create(snd_card_t * card) { char str[8]; - struct snd_info_entry *entry; + snd_info_entry_t *entry; snd_assert(card != NULL, return -ENXIO); @@ -622,7 +624,7 @@ int snd_info_card_create(struct snd_card *card) * register the card proc file * called from init.c */ -int snd_info_card_register(struct snd_card *card) +int snd_info_card_register(snd_card_t * card) { struct proc_dir_entry *p; @@ -642,7 +644,7 @@ int snd_info_card_register(struct snd_card *card) * de-register the card proc file * called from init.c */ -int snd_info_card_free(struct snd_card *card) +int snd_info_card_free(snd_card_t * card) { snd_assert(card != NULL, return -ENXIO); if (card->proc_root_link) { @@ -667,7 +669,7 @@ int snd_info_card_free(struct snd_card *card) * * Returns zero if successful, or 1 if error or EOF. */ -int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) +int snd_info_get_line(snd_info_buffer_t * buffer, char *line, int len) { int c = -1; @@ -745,9 +747,9 @@ char *snd_info_get_str(char *dest, char *src, int len) * * Returns the pointer of the new instance, or NULL on failure. */ -static struct snd_info_entry *snd_info_create_entry(const char *name) +static snd_info_entry_t *snd_info_create_entry(const char *name) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; entry = kzalloc(sizeof(*entry), GFP_KERNEL); if (entry == NULL) return NULL; @@ -772,11 +774,11 @@ static struct snd_info_entry *snd_info_create_entry(const char *name) * * Returns the pointer of the new instance, or NULL on failure. */ -struct snd_info_entry *snd_info_create_module_entry(struct module * module, +snd_info_entry_t *snd_info_create_module_entry(struct module * module, const char *name, - struct snd_info_entry *parent) + snd_info_entry_t *parent) { - struct snd_info_entry *entry = snd_info_create_entry(name); + snd_info_entry_t *entry = snd_info_create_entry(name); if (entry) { entry->module = module; entry->parent = parent; @@ -794,11 +796,11 @@ struct snd_info_entry *snd_info_create_module_entry(struct module * module, * * Returns the pointer of the new instance, or NULL on failure. */ -struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card, +snd_info_entry_t *snd_info_create_card_entry(snd_card_t * card, const char *name, - struct snd_info_entry * parent) + snd_info_entry_t * parent) { - struct snd_info_entry *entry = snd_info_create_entry(name); + snd_info_entry_t *entry = snd_info_create_entry(name); if (entry) { entry->module = card->module; entry->card = card; @@ -807,29 +809,29 @@ struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card, return entry; } -static int snd_info_dev_free_entry(struct snd_device *device) +static int snd_info_dev_free_entry(snd_device_t *device) { - struct snd_info_entry *entry = device->device_data; + snd_info_entry_t *entry = device->device_data; snd_info_free_entry(entry); return 0; } -static int snd_info_dev_register_entry(struct snd_device *device) +static int snd_info_dev_register_entry(snd_device_t *device) { - struct snd_info_entry *entry = device->device_data; + snd_info_entry_t *entry = device->device_data; return snd_info_register(entry); } -static int snd_info_dev_disconnect_entry(struct snd_device *device) +static int snd_info_dev_disconnect_entry(snd_device_t *device) { - struct snd_info_entry *entry = device->device_data; + snd_info_entry_t *entry = device->device_data; entry->disconnected = 1; return 0; } -static int snd_info_dev_unregister_entry(struct snd_device *device) +static int snd_info_dev_unregister_entry(snd_device_t *device) { - struct snd_info_entry *entry = device->device_data; + snd_info_entry_t *entry = device->device_data; return snd_info_unregister(entry); } @@ -853,16 +855,16 @@ static int snd_info_dev_unregister_entry(struct snd_device *device) * * Returns zero if successful, or a negative error code on failure. */ -int snd_card_proc_new(struct snd_card *card, const char *name, - struct snd_info_entry **entryp) +int snd_card_proc_new(snd_card_t *card, const char *name, + snd_info_entry_t **entryp) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_info_dev_free_entry, .dev_register = snd_info_dev_register_entry, .dev_disconnect = snd_info_dev_disconnect_entry, .dev_unregister = snd_info_dev_unregister_entry }; - struct snd_info_entry *entry; + snd_info_entry_t *entry; int err; entry = snd_info_create_card_entry(card, name, card->proc_root); @@ -883,7 +885,7 @@ int snd_card_proc_new(struct snd_card *card, const char *name, * * Releases the info entry. Don't call this after registered. */ -void snd_info_free_entry(struct snd_info_entry * entry) +void snd_info_free_entry(snd_info_entry_t * entry) { if (entry == NULL) return; @@ -901,7 +903,7 @@ void snd_info_free_entry(struct snd_info_entry * entry) * * Returns zero if successful, or a negative error code on failure. */ -int snd_info_register(struct snd_info_entry * entry) +int snd_info_register(snd_info_entry_t * entry) { struct proc_dir_entry *root, *p = NULL; @@ -931,12 +933,11 @@ int snd_info_register(struct snd_info_entry * entry) * * Returns zero if successful, or a negative error code on failure. */ -int snd_info_unregister(struct snd_info_entry * entry) +int snd_info_unregister(snd_info_entry_t * entry) { struct proc_dir_entry *root; - if (! entry) - return 0; + snd_assert(entry != NULL, return -ENXIO); snd_assert(entry->p != NULL, return -ENXIO); root = entry->parent == NULL ? snd_proc_root : entry->parent->p; snd_assert(root, return -ENXIO); @@ -951,9 +952,9 @@ int snd_info_unregister(struct snd_info_entry * entry) */ -static struct snd_info_entry *snd_info_version_entry = NULL; +static snd_info_entry_t *snd_info_version_entry = NULL; -static void snd_info_version_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void snd_info_version_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { snd_iprintf(buffer, "Advanced Linux Sound Architecture Driver Version " @@ -963,7 +964,7 @@ static void snd_info_version_read(struct snd_info_entry *entry, struct snd_info_ static int __init snd_info_version_init(void) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL); if (entry == NULL) diff --git a/trunk/sound/core/info_oss.c b/trunk/sound/core/info_oss.c index 820f4772e44a..12107968d402 100644 --- a/trunk/sound/core/info_oss.c +++ b/trunk/sound/core/info_oss.c @@ -37,7 +37,7 @@ static DECLARE_MUTEX(strings); static char *snd_sndstat_strings[SNDRV_CARDS][SNDRV_OSS_INFO_DEV_COUNT]; -static struct snd_info_entry *snd_sndstat_proc_entry; +static snd_info_entry_t *snd_sndstat_proc_entry; int snd_oss_info_register(int dev, int num, char *string) { @@ -63,9 +63,9 @@ int snd_oss_info_register(int dev, int num, char *string) return 0; } -extern void snd_card_info_read_oss(struct snd_info_buffer *buffer); +extern void snd_card_info_read_oss(snd_info_buffer_t * buffer); -static int snd_sndstat_show_strings(struct snd_info_buffer *buf, char *id, int dev) +static int snd_sndstat_show_strings(snd_info_buffer_t * buf, char *id, int dev) { int idx, ok = -1; char *str; @@ -88,8 +88,7 @@ static int snd_sndstat_show_strings(struct snd_info_buffer *buf, char *id, int d return ok; } -static void snd_sndstat_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_sndstat_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { snd_iprintf(buffer, "Sound Driver:3.8.1a-980706 (ALSA v" CONFIG_SND_VERSION " emulation code)\n"); snd_iprintf(buffer, "Kernel: %s %s %s %s %s\n", @@ -112,7 +111,7 @@ static void snd_sndstat_proc_read(struct snd_info_entry *entry, int snd_info_minor_register(void) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; memset(snd_sndstat_strings, 0, sizeof(snd_sndstat_strings)); if ((entry = snd_info_create_module_entry(THIS_MODULE, "sndstat", snd_oss_root)) != NULL) { diff --git a/trunk/sound/core/init.c b/trunk/sound/core/init.c index 75816688607c..33813f92ab52 100644 --- a/trunk/sound/core/init.c +++ b/trunk/sound/core/init.c @@ -28,6 +28,7 @@ #include <linux/ctype.h> #include <linux/pci.h> #include <linux/pm.h> +#include <linux/platform_device.h> #include <sound/core.h> #include <sound/control.h> @@ -39,46 +40,18 @@ struct snd_shutdown_f_ops { }; unsigned int snd_cards_lock = 0; /* locked for registering/using */ -struct snd_card *snd_cards[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = NULL}; +snd_card_t *snd_cards[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = NULL}; DEFINE_RWLOCK(snd_card_rwlock); #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) -int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag); +int (*snd_mixer_oss_notify_callback)(snd_card_t *card, int free_flag); #endif -#ifdef CONFIG_PROC_FS -static void snd_card_id_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_card_id_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { snd_iprintf(buffer, "%s\n", entry->card->id); } -static inline int init_info_for_card(struct snd_card *card) -{ - int err; - struct snd_info_entry *entry; - - if ((err = snd_info_card_register(card)) < 0) { - snd_printd("unable to create card info\n"); - return err; - } - if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) { - snd_printd("unable to create card entry\n"); - return err; - } - entry->c.text.read_size = PAGE_SIZE; - entry->c.text.read = snd_card_id_read; - if (snd_info_register(entry) < 0) { - snd_info_free_entry(entry); - entry = NULL; - } - card->proc_id = entry; - return 0; -} -#else /* !CONFIG_PROC_FS */ -#define init_info_for_card(card) -#endif - static void snd_card_free_thread(void * __card); /** @@ -90,13 +63,13 @@ static void snd_card_free_thread(void * __card); * * Creates and initializes a soundcard structure. * - * Returns kmallocated snd_card structure. Creates the ALSA control interface + * Returns kmallocated snd_card_t structure. Creates the ALSA control interface * (which is blocked until snd_card_register function is called). */ -struct snd_card *snd_card_new(int idx, const char *xid, +snd_card_t *snd_card_new(int idx, const char *xid, struct module *module, int extra_size) { - struct snd_card *card; + snd_card_t *card; int err; if (extra_size < 0) @@ -159,7 +132,7 @@ struct snd_card *snd_card_new(int idx, const char *xid, goto __error_ctl; } if (extra_size > 0) - card->private_data = (char *)card + sizeof(struct snd_card); + card->private_data = (char *)card + sizeof(snd_card_t); return card; __error_ctl: @@ -185,7 +158,7 @@ static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait) * Note: The current implementation replaces all active file->f_op with special * dummy file operations (they do nothing except release). */ -int snd_card_disconnect(struct snd_card *card) +int snd_card_disconnect(snd_card_t * card) { struct snd_monitor_file *mfile; struct file *file; @@ -255,6 +228,12 @@ int snd_card_disconnect(struct snd_card *card) return 0; } +#ifdef CONFIG_SND_GENERIC_DRIVER +static void snd_generic_device_unregister(snd_card_t *card); +#else +#define snd_generic_device_unregister(x) /*NOP*/ +#endif + /** * snd_card_free - frees given soundcard structure * @card: soundcard structure @@ -266,7 +245,7 @@ int snd_card_disconnect(struct snd_card *card) * Returns zero. Frees all associated devices and frees the control * interface associated to given soundcard. */ -int snd_card_free(struct snd_card *card) +int snd_card_free(snd_card_t * card) { struct snd_shutdown_f_ops *s_f_ops; @@ -300,11 +279,13 @@ int snd_card_free(struct snd_card *card) } if (card->private_free) card->private_free(card); - snd_info_unregister(card->proc_id); + if (card->proc_id) + snd_info_unregister(card->proc_id); if (snd_info_card_free(card) < 0) { snd_printk(KERN_WARNING "unable to free card info\n"); /* Not fatal error */ } + snd_generic_device_unregister(card); while (card->s_f_ops) { s_f_ops = card->s_f_ops; card->s_f_ops = s_f_ops->next; @@ -319,7 +300,7 @@ int snd_card_free(struct snd_card *card) static void snd_card_free_thread(void * __card) { - struct snd_card *card = __card; + snd_card_t *card = __card; struct module * module = card->module; if (!try_module_get(module)) { @@ -346,7 +327,7 @@ static void snd_card_free_thread(void * __card) * * Returns - zero otherwise a negative error code if the start of thread failed. */ -int snd_card_free_in_thread(struct snd_card *card) +int snd_card_free_in_thread(snd_card_t * card) { if (card->files == NULL) { snd_card_free(card); @@ -362,9 +343,9 @@ int snd_card_free_in_thread(struct snd_card *card) return -EFAULT; } -static void choose_default_id(struct snd_card *card) +static void choose_default_id(snd_card_t * card) { - int i, len, idx_flag = 0, loops = SNDRV_CARDS; + int i, len, idx_flag = 0, loops = 8; char *id, *spos; id = spos = card->shortname; @@ -406,12 +387,9 @@ static void choose_default_id(struct snd_card *card) __change: len = strlen(id); - if (idx_flag) { - if (id[len-1] != '9') - id[len-1]++; - else - id[len-1] = 'A'; - } else if ((size_t)len <= sizeof(card->id) - 3) { + if (idx_flag) + id[len-1]++; + else if ((size_t)len <= sizeof(card->id) - 3) { strcat(id, "_1"); idx_flag++; } else { @@ -437,9 +415,10 @@ static void choose_default_id(struct snd_card *card) * * Returns zero otherwise a negative error code if the registrain failed. */ -int snd_card_register(struct snd_card *card) +int snd_card_register(snd_card_t * card) { int err; + snd_info_entry_t *entry; snd_assert(card != NULL, return -EINVAL); if ((err = snd_device_register_all(card)) < 0) @@ -454,7 +433,22 @@ int snd_card_register(struct snd_card *card) choose_default_id(card); snd_cards[card->number] = card; write_unlock(&snd_card_rwlock); - init_info_for_card(card); + if ((err = snd_info_card_register(card)) < 0) { + snd_printd("unable to create card info\n"); + goto __skip_info; + } + if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) { + snd_printd("unable to create card entry\n"); + goto __skip_info; + } + entry->c.text.read_size = PAGE_SIZE; + entry->c.text.read = snd_card_id_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + card->proc_id = entry; + __skip_info: #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) if (snd_mixer_oss_notify_callback) snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER); @@ -462,25 +456,23 @@ int snd_card_register(struct snd_card *card) return 0; } -#ifdef CONFIG_PROC_FS -static struct snd_info_entry *snd_card_info_entry = NULL; +static snd_info_entry_t *snd_card_info_entry = NULL; -static void snd_card_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_card_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { int idx, count; - struct snd_card *card; + snd_card_t *card; for (idx = count = 0; idx < SNDRV_CARDS; idx++) { read_lock(&snd_card_rwlock); if ((card = snd_cards[idx]) != NULL) { count++; - snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n", + snd_iprintf(buffer, "%i [%-15s]: %s - %s\n", idx, card->id, card->driver, card->shortname); - snd_iprintf(buffer, " %s\n", + snd_iprintf(buffer, " %s\n", card->longname); } read_unlock(&snd_card_rwlock); @@ -489,12 +481,12 @@ static void snd_card_info_read(struct snd_info_entry *entry, snd_iprintf(buffer, "--- no soundcards ---\n"); } -#ifdef CONFIG_SND_OSSEMUL +#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS) -void snd_card_info_read_oss(struct snd_info_buffer *buffer) +void snd_card_info_read_oss(snd_info_buffer_t * buffer) { int idx, count; - struct snd_card *card; + snd_card_t *card; for (idx = count = 0; idx < SNDRV_CARDS; idx++) { read_lock(&snd_card_rwlock); @@ -512,18 +504,16 @@ void snd_card_info_read_oss(struct snd_info_buffer *buffer) #endif #ifdef MODULE -static struct snd_info_entry *snd_card_module_info_entry; -static void snd_card_module_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static snd_info_entry_t *snd_card_module_info_entry; +static void snd_card_module_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { int idx; - struct snd_card *card; + snd_card_t *card; for (idx = 0; idx < SNDRV_CARDS; idx++) { read_lock(&snd_card_rwlock); if ((card = snd_cards[idx]) != NULL) - snd_iprintf(buffer, "%2i %s\n", - idx, card->module->name); + snd_iprintf(buffer, "%i %s\n", idx, card->module->name); read_unlock(&snd_card_rwlock); } } @@ -531,7 +521,7 @@ static void snd_card_module_info_read(struct snd_info_entry *entry, int __init snd_card_info_init(void) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL); if (! entry) @@ -561,15 +551,15 @@ int __init snd_card_info_init(void) int __exit snd_card_info_done(void) { - snd_info_unregister(snd_card_info_entry); + if (snd_card_info_entry) + snd_info_unregister(snd_card_info_entry); #ifdef MODULE - snd_info_unregister(snd_card_module_info_entry); + if (snd_card_module_info_entry) + snd_info_unregister(snd_card_module_info_entry); #endif return 0; } -#endif /* CONFIG_PROC_FS */ - /** * snd_component_add - add a component string * @card: soundcard structure @@ -581,7 +571,7 @@ int __exit snd_card_info_done(void) * Returns zero otherwise a negative error code. */ -int snd_component_add(struct snd_card *card, const char *component) +int snd_component_add(snd_card_t *card, const char *component) { char *ptr; int len = strlen(component); @@ -612,7 +602,7 @@ int snd_component_add(struct snd_card *card, const char *component) * * Returns zero or a negative error code. */ -int snd_card_file_add(struct snd_card *card, struct file *file) +int snd_card_file_add(snd_card_t *card, struct file *file) { struct snd_monitor_file *mfile; @@ -646,7 +636,7 @@ int snd_card_file_add(struct snd_card *card, struct file *file) * * Returns zero or a negative error code. */ -int snd_card_file_remove(struct snd_card *card, struct file *file) +int snd_card_file_remove(snd_card_t *card, struct file *file) { struct snd_monitor_file *mfile, *pfile = NULL; @@ -674,6 +664,97 @@ int snd_card_file_remove(struct snd_card *card, struct file *file) return 0; } +#ifdef CONFIG_SND_GENERIC_DRIVER +/* + * generic device without a proper bus using platform_device + * (e.g. ISA) + */ +struct snd_generic_device { + struct platform_device pdev; + snd_card_t *card; +}; + +#define get_snd_generic_card(dev) container_of(dev, struct snd_generic_device, pdev)->card + +#define SND_GENERIC_NAME "snd_generic" + +#ifdef CONFIG_PM +static int snd_generic_suspend(struct platform_device *dev, pm_message_t state); +static int snd_generic_resume(struct platform_device *dev); +#endif + +/* initialized in sound.c */ +struct platform_driver snd_generic_driver = { +#ifdef CONFIG_PM + .suspend = snd_generic_suspend, + .resume = snd_generic_resume, +#endif + .driver = { + .name = SND_GENERIC_NAME, + }, +}; + +void snd_generic_device_release(struct device *dev) +{ +} + +static int snd_generic_device_register(snd_card_t *card) +{ + struct snd_generic_device *dev; + int err; + + if (card->generic_dev) + return 0; /* already registered */ + + dev = kzalloc(sizeof(*dev), GFP_KERNEL); + if (! dev) { + snd_printk(KERN_ERR "can't allocate generic_device\n"); + return -ENOMEM; + } + + dev->pdev.name = SND_GENERIC_NAME; + dev->pdev.id = card->number; + dev->pdev.dev.release = snd_generic_device_release; + dev->card = card; + if ((err = platform_device_register(&dev->pdev)) < 0) { + kfree(dev); + return err; + } + card->generic_dev = dev; + return 0; +} + +static void snd_generic_device_unregister(snd_card_t *card) +{ + struct snd_generic_device *dev = card->generic_dev; + if (dev) { + platform_device_unregister(&dev->pdev); + kfree(dev); + card->generic_dev = NULL; + } +} + +/** + * snd_card_set_generic_dev - assign the generic device to the card + * @card: soundcard structure + * + * Assigns a generic device to the card. This function is provided as the + * last resort, for devices without any proper bus. Thus this won't override + * the device already assigned to the card. + * + * Returns zero if successful, or a negative error code. + */ +int snd_card_set_generic_dev(snd_card_t *card) +{ + int err; + if ((err = snd_generic_device_register(card)) < 0) + return err; + if (! card->dev) + snd_card_set_dev(card, &card->generic_dev->pdev.dev); + return 0; +} +#endif /* CONFIG_SND_GENERIC_DRIVER */ + #ifdef CONFIG_PM /** * snd_power_wait - wait until the power-state is changed. @@ -685,7 +766,7 @@ int snd_card_file_remove(struct snd_card *card, struct file *file) * * Note: the power lock must be active before call. */ -int snd_power_wait(struct snd_card *card, unsigned int power_state, struct file *file) +int snd_power_wait(snd_card_t *card, unsigned int power_state, struct file *file) { wait_queue_t wait; int result = 0; @@ -717,4 +798,107 @@ int snd_power_wait(struct snd_card *card, unsigned int power_state, struct file return result; } +/** + * snd_card_set_pm_callback - set the PCI power-management callbacks + * @card: soundcard structure + * @suspend: suspend callback function + * @resume: resume callback function + * @private_data: private data to pass to the callback functions + * + * Sets the power-management callback functions of the card. + * These callbacks are called from ALSA's common PCI suspend/resume + * handler and from the control API. + */ +int snd_card_set_pm_callback(snd_card_t *card, + int (*suspend)(snd_card_t *, pm_message_t), + int (*resume)(snd_card_t *), + void *private_data) +{ + card->pm_suspend = suspend; + card->pm_resume = resume; + card->pm_private_data = private_data; + return 0; +} + +#ifdef CONFIG_SND_GENERIC_DRIVER +/* suspend/resume callbacks for snd_generic platform device */ +static int snd_generic_suspend(struct platform_device *dev, pm_message_t state) +{ + snd_card_t *card; + + card = get_snd_generic_card(dev); + if (card->power_state == SNDRV_CTL_POWER_D3hot) + return 0; + if (card->pm_suspend) + card->pm_suspend(card, PMSG_SUSPEND); + snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); + return 0; +} + +static int snd_generic_resume(struct platform_device *dev) +{ + snd_card_t *card; + + card = get_snd_generic_card(dev); + if (card->power_state == SNDRV_CTL_POWER_D0) + return 0; + if (card->pm_resume) + card->pm_resume(card); + snd_power_change_state(card, SNDRV_CTL_POWER_D0); + return 0; +} + +/** + * snd_card_set_generic_pm_callback - set the generic power-management callbacks + * @card: soundcard structure + * @suspend: suspend callback function + * @resume: resume callback function + * @private_data: private data to pass to the callback functions + * + * Registers the power-management and sets the lowlevel callbacks for + * the given card. These callbacks are called from the ALSA's common + * PM handler and from the control API. + */ +int snd_card_set_generic_pm_callback(snd_card_t *card, + int (*suspend)(snd_card_t *, pm_message_t), + int (*resume)(snd_card_t *), + void *private_data) +{ + int err; + if ((err = snd_generic_device_register(card)) < 0) + return err; + return snd_card_set_pm_callback(card, suspend, resume, private_data); +} +#endif /* CONFIG_SND_GENERIC_DRIVER */ + +#ifdef CONFIG_PCI +int snd_card_pci_suspend(struct pci_dev *dev, pm_message_t state) +{ + snd_card_t *card = pci_get_drvdata(dev); + int err; + if (! card || ! card->pm_suspend) + return 0; + if (card->power_state == SNDRV_CTL_POWER_D3hot) + return 0; + err = card->pm_suspend(card, PMSG_SUSPEND); + pci_save_state(dev); + snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); + return err; +} + +int snd_card_pci_resume(struct pci_dev *dev) +{ + snd_card_t *card = pci_get_drvdata(dev); + if (! card || ! card->pm_resume) + return 0; + if (card->power_state == SNDRV_CTL_POWER_D0) + return 0; + /* restore the PCI config space */ + pci_restore_state(dev); + card->pm_resume(card); + snd_power_change_state(card, SNDRV_CTL_POWER_D0); + return 0; +} +#endif + #endif /* CONFIG_PM */ diff --git a/trunk/sound/core/memalloc.c b/trunk/sound/core/memalloc.c index 19b3dcbb09c2..e4b8959dd4bb 100644 --- a/trunk/sound/core/memalloc.c +++ b/trunk/sound/core/memalloc.c @@ -43,6 +43,10 @@ MODULE_DESCRIPTION("Memory allocator for ALSA system."); MODULE_LICENSE("GPL"); +#ifndef SNDRV_CARDS +#define SNDRV_CARDS 8 +#endif + /* */ diff --git a/trunk/sound/core/oss/copy.c b/trunk/sound/core/oss/copy.c index d6a04c2d5a75..edecbe7417bd 100644 --- a/trunk/sound/core/oss/copy.c +++ b/trunk/sound/core/oss/copy.c @@ -25,9 +25,9 @@ #include <sound/pcm.h> #include "pcm_plugin.h" -static snd_pcm_sframes_t copy_transfer(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static snd_pcm_sframes_t copy_transfer(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { unsigned int channel; @@ -58,13 +58,13 @@ static snd_pcm_sframes_t copy_transfer(struct snd_pcm_plugin *plugin, return frames; } -int snd_pcm_plugin_build_copy(struct snd_pcm_substream *plug, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin) +int snd_pcm_plugin_build_copy(snd_pcm_plug_t *plug, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin) { int err; - struct snd_pcm_plugin *plugin; + snd_pcm_plugin_t *plugin; int width; snd_assert(r_plugin != NULL, return -ENXIO); diff --git a/trunk/sound/core/oss/io.c b/trunk/sound/core/oss/io.c index 322702e05f3e..bb1c99a5b734 100644 --- a/trunk/sound/core/oss/io.c +++ b/trunk/sound/core/oss/io.c @@ -35,9 +35,9 @@ * Basic io plugin */ -static snd_pcm_sframes_t io_playback_transfer(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static snd_pcm_sframes_t io_playback_transfer(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels ATTRIBUTE_UNUSED, snd_pcm_uframes_t frames) { snd_assert(plugin != NULL, return -ENXIO); @@ -58,9 +58,9 @@ static snd_pcm_sframes_t io_playback_transfer(struct snd_pcm_plugin *plugin, } } -static snd_pcm_sframes_t io_capture_transfer(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static snd_pcm_sframes_t io_capture_transfer(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels ATTRIBUTE_UNUSED, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { snd_assert(plugin != NULL, return -ENXIO); @@ -82,13 +82,13 @@ static snd_pcm_sframes_t io_capture_transfer(struct snd_pcm_plugin *plugin, return 0; } -static snd_pcm_sframes_t io_src_channels(struct snd_pcm_plugin *plugin, +static snd_pcm_sframes_t io_src_channels(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames, - struct snd_pcm_plugin_channel **channels) + snd_pcm_plugin_channel_t **channels) { int err; unsigned int channel; - struct snd_pcm_plugin_channel *v; + snd_pcm_plugin_channel_t *v; err = snd_pcm_plugin_client_channels(plugin, frames, &v); if (err < 0) return err; @@ -100,13 +100,13 @@ static snd_pcm_sframes_t io_src_channels(struct snd_pcm_plugin *plugin, return frames; } -int snd_pcm_plugin_build_io(struct snd_pcm_substream *plug, - struct snd_pcm_hw_params *params, - struct snd_pcm_plugin **r_plugin) +int snd_pcm_plugin_build_io(snd_pcm_plug_t *plug, + snd_pcm_hw_params_t *params, + snd_pcm_plugin_t **r_plugin) { int err; - struct snd_pcm_plugin_format format; - struct snd_pcm_plugin *plugin; + snd_pcm_plugin_format_t format; + snd_pcm_plugin_t *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; diff --git a/trunk/sound/core/oss/linear.c b/trunk/sound/core/oss/linear.c index 8cbfa415ce40..12ed27a57b27 100644 --- a/trunk/sound/core/oss/linear.c +++ b/trunk/sound/core/oss/linear.c @@ -30,19 +30,19 @@ * Basic linear conversion plugin */ -struct linear_priv { +typedef struct linear_private_data { int conv; -}; +} linear_t; -static void convert(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static void convert(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { #define CONV_LABELS #include "plugin_ops.h" #undef CONV_LABELS - struct linear_priv *data = (struct linear_priv *)plugin->extra_data; + linear_t *data = (linear_t *)plugin->extra_data; void *conv = conv_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -75,15 +75,15 @@ static void convert(struct snd_pcm_plugin *plugin, } } -static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static snd_pcm_sframes_t linear_transfer(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { - struct linear_priv *data; + linear_t *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); - data = (struct linear_priv *)plugin->extra_data; + data = (linear_t *)plugin->extra_data; if (frames == 0) return 0; #ifdef CONFIG_SND_DEBUG @@ -128,14 +128,14 @@ int conv_index(int src_format, int dst_format) return src_width * 32 + src_endian * 16 + sign * 8 + dst_width * 2 + dst_endian; } -int snd_pcm_plugin_build_linear(struct snd_pcm_substream *plug, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin) +int snd_pcm_plugin_build_linear(snd_pcm_plug_t *plug, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin) { int err; - struct linear_priv *data; - struct snd_pcm_plugin *plugin; + struct linear_private_data *data; + snd_pcm_plugin_t *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; @@ -147,10 +147,10 @@ int snd_pcm_plugin_build_linear(struct snd_pcm_substream *plug, err = snd_pcm_plugin_build(plug, "linear format conversion", src_format, dst_format, - sizeof(struct linear_priv), &plugin); + sizeof(linear_t), &plugin); if (err < 0) return err; - data = (struct linear_priv *)plugin->extra_data; + data = (linear_t *)plugin->extra_data; data->conv = conv_index(src_format->format, dst_format->format); plugin->transfer = linear_transfer; *r_plugin = plugin; diff --git a/trunk/sound/core/oss/mixer_oss.c b/trunk/sound/core/oss/mixer_oss.c index f08e65a2bffe..214933cf5d49 100644 --- a/trunk/sound/core/oss/mixer_oss.c +++ b/trunk/sound/core/oss/mixer_oss.c @@ -41,13 +41,12 @@ MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MIXER); static int snd_mixer_oss_open(struct inode *inode, struct file *file) { - struct snd_card *card; - struct snd_mixer_oss_file *fmixer; + int cardnum = SNDRV_MINOR_OSS_CARD(iminor(inode)); + snd_card_t *card; + snd_mixer_oss_file_t *fmixer; int err; - card = snd_lookup_oss_minor_data(iminor(inode), - SNDRV_OSS_DEVICE_TYPE_MIXER); - if (card == NULL) + if ((card = snd_cards[cardnum]) == NULL) return -ENODEV; if (card->mixer_oss == NULL) return -ENODEV; @@ -72,10 +71,10 @@ static int snd_mixer_oss_open(struct inode *inode, struct file *file) static int snd_mixer_oss_release(struct inode *inode, struct file *file) { - struct snd_mixer_oss_file *fmixer; + snd_mixer_oss_file_t *fmixer; if (file->private_data) { - fmixer = (struct snd_mixer_oss_file *) file->private_data; + fmixer = (snd_mixer_oss_file_t *) file->private_data; module_put(fmixer->card->module); snd_card_file_remove(fmixer->card, file); kfree(fmixer); @@ -83,11 +82,11 @@ static int snd_mixer_oss_release(struct inode *inode, struct file *file) return 0; } -static int snd_mixer_oss_info(struct snd_mixer_oss_file *fmixer, +static int snd_mixer_oss_info(snd_mixer_oss_file_t *fmixer, mixer_info __user *_info) { - struct snd_card *card = fmixer->card; - struct snd_mixer_oss *mixer = fmixer->mixer; + snd_card_t *card = fmixer->card; + snd_mixer_oss_t *mixer = fmixer->mixer; struct mixer_info info; memset(&info, 0, sizeof(info)); @@ -99,11 +98,11 @@ static int snd_mixer_oss_info(struct snd_mixer_oss_file *fmixer, return 0; } -static int snd_mixer_oss_info_obsolete(struct snd_mixer_oss_file *fmixer, +static int snd_mixer_oss_info_obsolete(snd_mixer_oss_file_t *fmixer, _old_mixer_info __user *_info) { - struct snd_card *card = fmixer->card; - struct snd_mixer_oss *mixer = fmixer->mixer; + snd_card_t *card = fmixer->card; + snd_mixer_oss_t *mixer = fmixer->mixer; _old_mixer_info info; memset(&info, 0, sizeof(info)); @@ -114,9 +113,9 @@ static int snd_mixer_oss_info_obsolete(struct snd_mixer_oss_file *fmixer, return 0; } -static int snd_mixer_oss_caps(struct snd_mixer_oss_file *fmixer) +static int snd_mixer_oss_caps(snd_mixer_oss_file_t *fmixer) { - struct snd_mixer_oss *mixer = fmixer->mixer; + snd_mixer_oss_t *mixer = fmixer->mixer; int result = 0; if (mixer == NULL) @@ -126,10 +125,10 @@ static int snd_mixer_oss_caps(struct snd_mixer_oss_file *fmixer) return result; } -static int snd_mixer_oss_devmask(struct snd_mixer_oss_file *fmixer) +static int snd_mixer_oss_devmask(snd_mixer_oss_file_t *fmixer) { - struct snd_mixer_oss *mixer = fmixer->mixer; - struct snd_mixer_oss_slot *pslot; + snd_mixer_oss_t *mixer = fmixer->mixer; + snd_mixer_oss_slot_t *pslot; int result = 0, chn; if (mixer == NULL) @@ -142,10 +141,10 @@ static int snd_mixer_oss_devmask(struct snd_mixer_oss_file *fmixer) return result; } -static int snd_mixer_oss_stereodevs(struct snd_mixer_oss_file *fmixer) +static int snd_mixer_oss_stereodevs(snd_mixer_oss_file_t *fmixer) { - struct snd_mixer_oss *mixer = fmixer->mixer; - struct snd_mixer_oss_slot *pslot; + snd_mixer_oss_t *mixer = fmixer->mixer; + snd_mixer_oss_slot_t *pslot; int result = 0, chn; if (mixer == NULL) @@ -158,9 +157,9 @@ static int snd_mixer_oss_stereodevs(struct snd_mixer_oss_file *fmixer) return result; } -static int snd_mixer_oss_recmask(struct snd_mixer_oss_file *fmixer) +static int snd_mixer_oss_recmask(snd_mixer_oss_file_t *fmixer) { - struct snd_mixer_oss *mixer = fmixer->mixer; + snd_mixer_oss_t *mixer = fmixer->mixer; int result = 0; if (mixer == NULL) @@ -168,7 +167,7 @@ static int snd_mixer_oss_recmask(struct snd_mixer_oss_file *fmixer) if (mixer->put_recsrc && mixer->get_recsrc) { /* exclusive */ result = mixer->mask_recsrc; } else { - struct snd_mixer_oss_slot *pslot; + snd_mixer_oss_slot_t *pslot; int chn; for (chn = 0; chn < 31; chn++) { pslot = &mixer->slots[chn]; @@ -179,9 +178,9 @@ static int snd_mixer_oss_recmask(struct snd_mixer_oss_file *fmixer) return result; } -static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file *fmixer) +static int snd_mixer_oss_get_recsrc(snd_mixer_oss_file_t *fmixer) { - struct snd_mixer_oss *mixer = fmixer->mixer; + snd_mixer_oss_t *mixer = fmixer->mixer; int result = 0; if (mixer == NULL) @@ -192,7 +191,7 @@ static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file *fmixer) return err; result = 1 << result; } else { - struct snd_mixer_oss_slot *pslot; + snd_mixer_oss_slot_t *pslot; int chn; for (chn = 0; chn < 31; chn++) { pslot = &mixer->slots[chn]; @@ -207,10 +206,10 @@ static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file *fmixer) return mixer->oss_recsrc = result; } -static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file *fmixer, int recsrc) +static int snd_mixer_oss_set_recsrc(snd_mixer_oss_file_t *fmixer, int recsrc) { - struct snd_mixer_oss *mixer = fmixer->mixer; - struct snd_mixer_oss_slot *pslot; + snd_mixer_oss_t *mixer = fmixer->mixer; + snd_mixer_oss_slot_t *pslot; int chn, active; int result = 0; @@ -244,10 +243,10 @@ static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file *fmixer, int recsr return result; } -static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file *fmixer, int slot) +static int snd_mixer_oss_get_volume(snd_mixer_oss_file_t *fmixer, int slot) { - struct snd_mixer_oss *mixer = fmixer->mixer; - struct snd_mixer_oss_slot *pslot; + snd_mixer_oss_t *mixer = fmixer->mixer; + snd_mixer_oss_slot_t *pslot; int result = 0, left, right; if (mixer == NULL || slot > 30) @@ -269,11 +268,11 @@ static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file *fmixer, int slot) return result; } -static int snd_mixer_oss_set_volume(struct snd_mixer_oss_file *fmixer, +static int snd_mixer_oss_set_volume(snd_mixer_oss_file_t *fmixer, int slot, int volume) { - struct snd_mixer_oss *mixer = fmixer->mixer; - struct snd_mixer_oss_slot *pslot; + snd_mixer_oss_t *mixer = fmixer->mixer; + snd_mixer_oss_slot_t *pslot; int result = 0, left = volume & 0xff, right = (volume >> 8) & 0xff; if (mixer == NULL || slot > 30) @@ -294,7 +293,7 @@ static int snd_mixer_oss_set_volume(struct snd_mixer_oss_file *fmixer, return (left & 0xff) | ((right & 0xff) << 8); } -static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int cmd, unsigned long arg) +static int snd_mixer_oss_ioctl1(snd_mixer_oss_file_t *fmixer, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int __user *p = argp; @@ -363,12 +362,12 @@ static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int static long snd_mixer_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - return snd_mixer_oss_ioctl1((struct snd_mixer_oss_file *) file->private_data, cmd, arg); + return snd_mixer_oss_ioctl1((snd_mixer_oss_file_t *) file->private_data, cmd, arg); } -int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg) +int snd_mixer_oss_ioctl_card(snd_card_t *card, unsigned int cmd, unsigned long arg) { - struct snd_mixer_oss_file fmixer; + snd_mixer_oss_file_t fmixer; snd_assert(card != NULL, return -ENXIO); if (card->mixer_oss == NULL) @@ -399,6 +398,12 @@ static struct file_operations snd_mixer_oss_f_ops = .compat_ioctl = snd_mixer_oss_ioctl_compat, }; +static snd_minor_t snd_mixer_oss_reg = +{ + .comment = "mixer", + .f_ops = &snd_mixer_oss_f_ops, +}; + /* * utilities */ @@ -427,16 +432,16 @@ static long snd_mixer_oss_conv2(long val, long min, long max) } #if 0 -static void snd_mixer_oss_recsrce_set(struct snd_card *card, int slot) +static void snd_mixer_oss_recsrce_set(snd_card_t *card, int slot) { - struct snd_mixer_oss *mixer = card->mixer_oss; + snd_mixer_oss_t *mixer = card->mixer_oss; if (mixer) mixer->mask_recsrc |= 1 << slot; } -static int snd_mixer_oss_recsrce_get(struct snd_card *card, int slot) +static int snd_mixer_oss_recsrce_get(snd_card_t *card, int slot) { - struct snd_mixer_oss *mixer = card->mixer_oss; + snd_mixer_oss_t *mixer = card->mixer_oss; if (mixer && (mixer->mask_recsrc & (1 << slot))) return 1; return 0; @@ -483,10 +488,10 @@ struct slot { #define ID_UNKNOWN ((unsigned int)-1) -static struct snd_kcontrol *snd_mixer_oss_test_id(struct snd_mixer_oss *mixer, const char *name, int index) +static snd_kcontrol_t *snd_mixer_oss_test_id(snd_mixer_oss_t *mixer, const char *name, int index) { - struct snd_card *card = mixer->card; - struct snd_ctl_elem_id id; + snd_card_t * card = mixer->card; + snd_ctl_elem_id_t id; memset(&id, 0, sizeof(id)); id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; @@ -495,15 +500,15 @@ static struct snd_kcontrol *snd_mixer_oss_test_id(struct snd_mixer_oss *mixer, c return snd_ctl_find_id(card, &id); } -static void snd_mixer_oss_get_volume1_vol(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static void snd_mixer_oss_get_volume1_vol(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, unsigned int numid, int *left, int *right) { - struct snd_ctl_elem_info *uinfo; - struct snd_ctl_elem_value *uctl; - struct snd_kcontrol *kctl; - struct snd_card *card = fmixer->card; + snd_ctl_elem_info_t *uinfo; + snd_ctl_elem_value_t *uctl; + snd_kcontrol_t *kctl; + snd_card_t *card = fmixer->card; if (numid == ID_UNKNOWN) return; @@ -532,16 +537,16 @@ static void snd_mixer_oss_get_volume1_vol(struct snd_mixer_oss_file *fmixer, kfree(uinfo); } -static void snd_mixer_oss_get_volume1_sw(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static void snd_mixer_oss_get_volume1_sw(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, unsigned int numid, int *left, int *right, int route) { - struct snd_ctl_elem_info *uinfo; - struct snd_ctl_elem_value *uctl; - struct snd_kcontrol *kctl; - struct snd_card *card = fmixer->card; + snd_ctl_elem_info_t *uinfo; + snd_ctl_elem_value_t *uctl; + snd_kcontrol_t *kctl; + snd_card_t *card = fmixer->card; if (numid == ID_UNKNOWN) return; @@ -571,8 +576,8 @@ static void snd_mixer_oss_get_volume1_sw(struct snd_mixer_oss_file *fmixer, kfree(uinfo); } -static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static int snd_mixer_oss_get_volume1(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, int *left, int *right) { struct slot *slot = (struct slot *)pslot->private_data; @@ -597,15 +602,15 @@ static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer, return 0; } -static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static void snd_mixer_oss_put_volume1_vol(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, unsigned int numid, int left, int right) { - struct snd_ctl_elem_info *uinfo; - struct snd_ctl_elem_value *uctl; - struct snd_kcontrol *kctl; - struct snd_card *card = fmixer->card; + snd_ctl_elem_info_t *uinfo; + snd_ctl_elem_value_t *uctl; + snd_kcontrol_t *kctl; + snd_card_t *card = fmixer->card; int res; if (numid == ID_UNKNOWN) @@ -635,16 +640,16 @@ static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer, kfree(uinfo); } -static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static void snd_mixer_oss_put_volume1_sw(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, unsigned int numid, int left, int right, int route) { - struct snd_ctl_elem_info *uinfo; - struct snd_ctl_elem_value *uctl; - struct snd_kcontrol *kctl; - struct snd_card *card = fmixer->card; + snd_ctl_elem_info_t *uinfo; + snd_ctl_elem_value_t *uctl; + snd_kcontrol_t *kctl; + snd_card_t *card = fmixer->card; int res; if (numid == ID_UNKNOWN) @@ -680,8 +685,8 @@ static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer, kfree(uinfo); } -static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static int snd_mixer_oss_put_volume1(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, int left, int right) { struct slot *slot = (struct slot *)pslot->private_data; @@ -718,8 +723,8 @@ static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer, return 0; } -static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static int snd_mixer_oss_get_recsrc1_sw(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, int *active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -731,8 +736,8 @@ static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer, return 0; } -static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static int snd_mixer_oss_get_recsrc1_route(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, int *active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -744,8 +749,8 @@ static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer, return 0; } -static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static int snd_mixer_oss_put_recsrc1_sw(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, int active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -754,8 +759,8 @@ static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer, return 0; } -static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer, - struct snd_mixer_oss_slot *pslot, +static int snd_mixer_oss_put_recsrc1_route(snd_mixer_oss_file_t *fmixer, + snd_mixer_oss_slot_t *pslot, int active) { struct slot *slot = (struct slot *)pslot->private_data; @@ -764,15 +769,15 @@ static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer, return 0; } -static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int *active_index) +static int snd_mixer_oss_get_recsrc2(snd_mixer_oss_file_t *fmixer, unsigned int *active_index) { - struct snd_card *card = fmixer->card; - struct snd_mixer_oss *mixer = fmixer->mixer; - struct snd_kcontrol *kctl; - struct snd_mixer_oss_slot *pslot; + snd_card_t *card = fmixer->card; + snd_mixer_oss_t *mixer = fmixer->mixer; + snd_kcontrol_t *kctl; + snd_mixer_oss_slot_t *pslot; struct slot *slot; - struct snd_ctl_elem_info *uinfo; - struct snd_ctl_elem_value *uctl; + snd_ctl_elem_info_t *uinfo; + snd_ctl_elem_value_t *uctl; int err, idx; uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL); @@ -813,15 +818,15 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned return err; } -static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned int active_index) +static int snd_mixer_oss_put_recsrc2(snd_mixer_oss_file_t *fmixer, unsigned int active_index) { - struct snd_card *card = fmixer->card; - struct snd_mixer_oss *mixer = fmixer->mixer; - struct snd_kcontrol *kctl; - struct snd_mixer_oss_slot *pslot; + snd_card_t *card = fmixer->card; + snd_mixer_oss_t *mixer = fmixer->mixer; + snd_kcontrol_t *kctl; + snd_mixer_oss_slot_t *pslot; struct slot *slot = NULL; - struct snd_ctl_elem_info *uinfo; - struct snd_ctl_elem_value *uctl; + snd_ctl_elem_info_t *uinfo; + snd_ctl_elem_value_t *uctl; int err; unsigned int idx; @@ -873,11 +878,11 @@ struct snd_mixer_oss_assign_table { int index; }; -static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *slot, const char *name, int index, int item) +static int snd_mixer_oss_build_test(snd_mixer_oss_t *mixer, struct slot *slot, const char *name, int index, int item) { - struct snd_ctl_elem_info *info; - struct snd_kcontrol *kcontrol; - struct snd_card *card = mixer->card; + snd_ctl_elem_info_t *info; + snd_kcontrol_t *kcontrol; + snd_card_t *card = mixer->card; int err; down_read(&card->controls_rwsem); @@ -905,7 +910,7 @@ static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *sl return 0; } -static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn) +static void snd_mixer_oss_slot_free(snd_mixer_oss_slot_t *chn) { struct slot *p = (struct slot *)chn->private_data; if (p) { @@ -917,7 +922,7 @@ static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn) } } -static void mixer_slot_clear(struct snd_mixer_oss_slot *rslot) +static void mixer_slot_clear(snd_mixer_oss_slot_t *rslot) { int idx = rslot->number; /* remember this */ if (rslot->private_free) @@ -931,12 +936,12 @@ static void mixer_slot_clear(struct snd_mixer_oss_slot *rslot) * ptr_allocated means the entry is dynamically allocated (change via proc file). * when replace_old = 1, the old entry is replaced with the new one. */ -static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer, struct snd_mixer_oss_assign_table *ptr, int ptr_allocated, int replace_old) +static int snd_mixer_oss_build_input(snd_mixer_oss_t *mixer, struct snd_mixer_oss_assign_table *ptr, int ptr_allocated, int replace_old) { struct slot slot; struct slot *pslot; - struct snd_kcontrol *kctl; - struct snd_mixer_oss_slot *rslot; + snd_kcontrol_t *kctl; + snd_mixer_oss_slot_t *rslot; char str[64]; /* check if already assigned */ @@ -986,7 +991,7 @@ static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer, struct snd_mix return 0; down_read(&mixer->card->controls_rwsem); if (ptr->index == 0 && (kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0)) != NULL) { - struct snd_ctl_elem_info *uinfo; + snd_ctl_elem_info_t *uinfo; uinfo = kmalloc(sizeof(*uinfo), GFP_KERNEL); if (! uinfo) { @@ -1053,7 +1058,6 @@ static int snd_mixer_oss_build_input(struct snd_mixer_oss *mixer, struct snd_mix return 0; } -#ifdef CONFIG_PROC_FS /* */ #define MIXER_VOL(name) [SOUND_MIXER_##name] = #name @@ -1089,10 +1093,10 @@ static char *oss_mixer_names[SNDRV_OSS_MAX_MIXERS] = { * /proc interface */ -static void snd_mixer_oss_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_mixer_oss_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_mixer_oss *mixer = entry->private_data; + snd_mixer_oss_t *mixer = entry->private_data; int i; down(&mixer->reg_mutex); @@ -1113,10 +1117,10 @@ static void snd_mixer_oss_proc_read(struct snd_info_entry *entry, up(&mixer->reg_mutex); } -static void snd_mixer_oss_proc_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_mixer_oss_proc_write(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_mixer_oss *mixer = entry->private_data; + snd_mixer_oss_t *mixer = entry->private_data; char line[128], str[32], idxstr[16], *cptr; int ch, idx; struct snd_mixer_oss_assign_table *tbl; @@ -1172,9 +1176,9 @@ static void snd_mixer_oss_proc_write(struct snd_info_entry *entry, } } -static void snd_mixer_oss_proc_init(struct snd_mixer_oss *mixer) +static void snd_mixer_oss_proc_init(snd_mixer_oss_t *mixer) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; entry = snd_info_create_card_entry(mixer->card, "oss_mixer", mixer->card->proc_root); @@ -1194,19 +1198,15 @@ static void snd_mixer_oss_proc_init(struct snd_mixer_oss *mixer) mixer->proc_entry = entry; } -static void snd_mixer_oss_proc_done(struct snd_mixer_oss *mixer) +static void snd_mixer_oss_proc_done(snd_mixer_oss_t *mixer) { if (mixer->proc_entry) { snd_info_unregister(mixer->proc_entry); mixer->proc_entry = NULL; } } -#else /* !CONFIG_PROC_FS */ -#define snd_mixer_oss_proc_init(mix) -#define snd_mixer_oss_proc_done(mix) -#endif /* CONFIG_PROC_FS */ -static void snd_mixer_oss_build(struct snd_mixer_oss *mixer) +static void snd_mixer_oss_build(snd_mixer_oss_t *mixer) { static struct snd_mixer_oss_assign_table table[] = { { SOUND_MIXER_VOLUME, "Master", 0 }, @@ -1260,8 +1260,8 @@ static void snd_mixer_oss_build(struct snd_mixer_oss *mixer) static int snd_mixer_oss_free1(void *private) { - struct snd_mixer_oss *mixer = private; - struct snd_card *card; + snd_mixer_oss_t *mixer = private; + snd_card_t * card; int idx; snd_assert(mixer != NULL, return -ENXIO); @@ -1269,7 +1269,7 @@ static int snd_mixer_oss_free1(void *private) snd_assert(mixer == card->mixer_oss, return -ENXIO); card->mixer_oss = NULL; for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++) { - struct snd_mixer_oss_slot *chn = &mixer->slots[idx]; + snd_mixer_oss_slot_t *chn = &mixer->slots[idx]; if (chn->private_free) chn->private_free(chn); } @@ -1277,9 +1277,9 @@ static int snd_mixer_oss_free1(void *private) return 0; } -static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd) +static int snd_mixer_oss_notify_handler(snd_card_t * card, int cmd) { - struct snd_mixer_oss *mixer; + snd_mixer_oss_t *mixer; if (cmd == SND_MIXER_OSS_NOTIFY_REGISTER) { char name[128]; @@ -1292,7 +1292,7 @@ static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd) sprintf(name, "mixer%i%i", card->number, 0); if ((err = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, card, 0, - &snd_mixer_oss_f_ops, card, + &snd_mixer_oss_reg, name)) < 0) { snd_printk(KERN_ERR "unable to register OSS mixer device %i:%i\n", card->number, 0); diff --git a/trunk/sound/core/oss/mulaw.c b/trunk/sound/core/oss/mulaw.c index 14f5578ec7a7..44ec4c66eb19 100644 --- a/trunk/sound/core/oss/mulaw.c +++ b/trunk/sound/core/oss/mulaw.c @@ -139,25 +139,25 @@ static int ulaw2linear(unsigned char u_val) * Basic Mu-Law plugin */ -typedef void (*mulaw_f)(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +typedef void (*mulaw_f)(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames); -struct mulaw_priv { +typedef struct mulaw_private_data { mulaw_f func; int conv; -}; +} mulaw_t; -static void mulaw_decode(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static void mulaw_decode(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { #define PUT_S16_LABELS #include "plugin_ops.h" #undef PUT_S16_LABELS - struct mulaw_priv *data = (struct mulaw_priv *)plugin->extra_data; + mulaw_t *data = (mulaw_t *)plugin->extra_data; void *put = put_s16_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -191,15 +191,15 @@ static void mulaw_decode(struct snd_pcm_plugin *plugin, } } -static void mulaw_encode(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static void mulaw_encode(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { #define GET_S16_LABELS #include "plugin_ops.h" #undef GET_S16_LABELS - struct mulaw_priv *data = (struct mulaw_priv *)plugin->extra_data; + mulaw_t *data = (mulaw_t *)plugin->extra_data; void *get = get_s16_labels[data->conv]; int channel; int nchannels = plugin->src_format.channels; @@ -234,12 +234,12 @@ static void mulaw_encode(struct snd_pcm_plugin *plugin, } } -static snd_pcm_sframes_t mulaw_transfer(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static snd_pcm_sframes_t mulaw_transfer(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { - struct mulaw_priv *data; + mulaw_t *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) @@ -257,20 +257,20 @@ static snd_pcm_sframes_t mulaw_transfer(struct snd_pcm_plugin *plugin, } } #endif - data = (struct mulaw_priv *)plugin->extra_data; + data = (mulaw_t *)plugin->extra_data; data->func(plugin, src_channels, dst_channels, frames); return frames; } -int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin) +int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *plug, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin) { int err; - struct mulaw_priv *data; - struct snd_pcm_plugin *plugin; - struct snd_pcm_plugin_format *format; + mulaw_t *data; + snd_pcm_plugin_t *plugin; + snd_pcm_plugin_format_t *format; mulaw_f func; snd_assert(r_plugin != NULL, return -ENXIO); @@ -295,10 +295,10 @@ int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug, err = snd_pcm_plugin_build(plug, "Mu-Law<->linear conversion", src_format, dst_format, - sizeof(struct mulaw_priv), &plugin); + sizeof(mulaw_t), &plugin); if (err < 0) return err; - data = (struct mulaw_priv *)plugin->extra_data; + data = (mulaw_t*)plugin->extra_data; data->func = func; data->conv = getput_index(format->format); snd_assert(data->conv >= 0 && data->conv < 4*2*2, return -EINVAL); diff --git a/trunk/sound/core/oss/pcm_oss.c b/trunk/sound/core/oss/pcm_oss.c index 16df1246a131..bcc970759134 100644 --- a/trunk/sound/core/oss/pcm_oss.c +++ b/trunk/sound/core/oss/pcm_oss.c @@ -61,10 +61,10 @@ MODULE_PARM_DESC(nonblock_open, "Don't block opening busy PCM devices."); MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM); MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_PCM1); -extern int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg); -static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file); -static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file); -static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file); +extern int snd_mixer_oss_ioctl_card(snd_card_t *card, unsigned int cmd, unsigned long arg); +static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file); +static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file); +static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file); static inline mm_segment_t snd_enter_user(void) { @@ -78,10 +78,10 @@ static inline void snd_leave_user(mm_segment_t fs) set_fs(fs); } -static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream) +static int snd_pcm_oss_plugin_clear(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_pcm_plugin *plugin, *next; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_pcm_plugin_t *plugin, *next; plugin = runtime->oss.plugin_first; while (plugin) { @@ -93,9 +93,9 @@ static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream) return 0; } -static int snd_pcm_plugin_insert(struct snd_pcm_plugin *plugin) +static int snd_pcm_plugin_insert(snd_pcm_plugin_t *plugin) { - struct snd_pcm_runtime *runtime = plugin->plug->runtime; + snd_pcm_runtime_t *runtime = plugin->plug->runtime; plugin->next = runtime->oss.plugin_first; plugin->prev = NULL; if (runtime->oss.plugin_first) { @@ -108,9 +108,9 @@ static int snd_pcm_plugin_insert(struct snd_pcm_plugin *plugin) return 0; } -int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin) +int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin) { - struct snd_pcm_runtime *runtime = plugin->plug->runtime; + snd_pcm_runtime_t *runtime = plugin->plug->runtime; plugin->next = NULL; plugin->prev = runtime->oss.plugin_last; if (runtime->oss.plugin_last) { @@ -123,9 +123,9 @@ int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin) return 0; } -static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames) +static long snd_pcm_oss_bytes(snd_pcm_substream_t *substream, long frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; long buffer_size = snd_pcm_lib_buffer_bytes(substream); long bytes = frames_to_bytes(runtime, frames); if (buffer_size == runtime->oss.buffer_bytes) @@ -142,9 +142,9 @@ static long snd_pcm_oss_bytes(struct snd_pcm_substream *substream, long frames) #endif } -static long snd_pcm_alsa_frames(struct snd_pcm_substream *substream, long bytes) +static long snd_pcm_alsa_frames(snd_pcm_substream_t *substream, long bytes) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; long buffer_size = snd_pcm_lib_buffer_bytes(substream); if (buffer_size == runtime->oss.buffer_bytes) return bytes_to_frames(runtime, bytes); @@ -185,14 +185,14 @@ static int snd_pcm_oss_format_to(int format) } } -static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *oss_params, - struct snd_pcm_hw_params *slave_params) +static int snd_pcm_oss_period_size(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *oss_params, + snd_pcm_hw_params_t *slave_params) { size_t s; size_t oss_buffer_size, oss_period_size, oss_periods; size_t min_period_size, max_period_size; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; size_t oss_frame_size; oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) * @@ -277,11 +277,11 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, return 0; } -static int choose_rate(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params, unsigned int best_rate) +static int choose_rate(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params, unsigned int best_rate) { - struct snd_interval *it; - struct snd_pcm_hw_params *save; + snd_interval_t *it; + snd_pcm_hw_params_t *save; unsigned int rate, prev; save = kmalloc(sizeof(*save), GFP_KERNEL); @@ -317,18 +317,18 @@ static int choose_rate(struct snd_pcm_substream *substream, return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL); } -static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) +static int snd_pcm_oss_change_params(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_pcm_hw_params *params, *sparams; - struct snd_pcm_sw_params *sw_params; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_pcm_hw_params_t *params, *sparams; + snd_pcm_sw_params_t *sw_params; ssize_t oss_buffer_size, oss_period_size; size_t oss_frame_size; int err; int direct; int format, sformat, n; - struct snd_mask sformat_mask; - struct snd_mask mask; + snd_mask_t sformat_mask; + snd_mask_t mask; sw_params = kmalloc(sizeof(*sw_params), GFP_KERNEL); params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -342,7 +342,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) if (atomic_read(&runtime->mmap_count)) { direct = 1; } else { - struct snd_pcm_oss_setup *setup = substream->oss.setup; + snd_pcm_oss_setup_t *setup = substream->oss.setup; direct = (setup != NULL && setup->direct); } @@ -424,7 +424,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) goto failure; } if (runtime->oss.plugin_first) { - struct snd_pcm_plugin *plugin; + snd_pcm_plugin_t *plugin; if ((err = snd_pcm_plugin_build_io(substream, sparams, &plugin)) < 0) { snd_printd("snd_pcm_plugin_build_io failed: %i\n", err); snd_pcm_oss_plugin_clear(substream); @@ -540,10 +540,10 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream) return err; } -static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_file, struct snd_pcm_substream **r_substream) +static int snd_pcm_oss_get_active_substream(snd_pcm_oss_file_t *pcm_oss_file, snd_pcm_substream_t **r_substream) { int idx, err; - struct snd_pcm_substream *asubstream = NULL, *substream; + snd_pcm_substream_t *asubstream = NULL, *substream; for (idx = 0; idx < 2; idx++) { substream = pcm_oss_file->streams[idx]; @@ -563,10 +563,10 @@ static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_fil return 0; } -static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream) +static int snd_pcm_oss_prepare(snd_pcm_substream_t *substream) { int err; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL); if (err < 0) { @@ -581,9 +581,9 @@ static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream) +static int snd_pcm_oss_make_ready(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; int err; if (substream == NULL) @@ -602,9 +602,9 @@ static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream) return 0; } -static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream *substream, snd_pcm_sframes_t *delay) +static int snd_pcm_oss_capture_position_fixup(snd_pcm_substream_t *substream, snd_pcm_sframes_t *delay) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; snd_pcm_uframes_t frames; int err = 0; @@ -627,9 +627,9 @@ static int snd_pcm_oss_capture_position_fixup(struct snd_pcm_substream *substrea return err; } -snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char *ptr, snd_pcm_uframes_t frames, int in_kernel) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -662,9 +662,9 @@ snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, const return ret; } -snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, snd_pcm_uframes_t frames, int in_kernel) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t delay; int ret; while (1) { @@ -709,9 +709,9 @@ snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, char *p return ret; } -snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -745,9 +745,9 @@ snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, void return ret; } -snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) +snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int ret; while (1) { if (runtime->status->state == SNDRV_PCM_STATE_XRUN || @@ -780,12 +780,12 @@ snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, void * return ret; } -static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const char *buf, size_t bytes, int in_kernel) +static ssize_t snd_pcm_oss_write2(snd_pcm_substream_t *substream, const char *buf, size_t bytes, int in_kernel) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t frames, frames1; if (runtime->oss.plugin_first) { - struct snd_pcm_plugin_channel *channels; + snd_pcm_plugin_channel_t *channels; size_t oss_frame_bytes = (runtime->oss.plugin_first->src_width * runtime->oss.plugin_first->src_format.channels) / 8; if (!in_kernel) { if (copy_from_user(runtime->oss.buffer, (const char __user *)buf, bytes)) @@ -810,11 +810,11 @@ static ssize_t snd_pcm_oss_write2(struct snd_pcm_substream *substream, const cha return bytes; } -static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const char __user *buf, size_t bytes) +static ssize_t snd_pcm_oss_write1(snd_pcm_substream_t *substream, const char __user *buf, size_t bytes) { size_t xfer = 0; ssize_t tmp; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return -ENXIO; @@ -867,13 +867,13 @@ static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const cha return xfer; } -static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf, size_t bytes, int in_kernel) +static ssize_t snd_pcm_oss_read2(snd_pcm_substream_t *substream, char *buf, size_t bytes, int in_kernel) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t frames, frames1; char __user *final_dst = (char __user *)buf; if (runtime->oss.plugin_first) { - struct snd_pcm_plugin_channel *channels; + snd_pcm_plugin_channel_t *channels; size_t oss_frame_bytes = (runtime->oss.plugin_last->dst_width * runtime->oss.plugin_last->dst_format.channels) / 8; if (!in_kernel) buf = runtime->oss.buffer; @@ -897,11 +897,11 @@ static ssize_t snd_pcm_oss_read2(struct snd_pcm_substream *substream, char *buf, return bytes; } -static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __user *buf, size_t bytes) +static ssize_t snd_pcm_oss_read1(snd_pcm_substream_t *substream, char __user *buf, size_t bytes) { size_t xfer = 0; ssize_t tmp; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return -ENXIO; @@ -941,9 +941,9 @@ static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __use return xfer; } -static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_reset(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; if (substream != NULL) { @@ -958,9 +958,9 @@ static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file) return 0; } -static int snd_pcm_oss_post(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_post(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int err; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -974,9 +974,9 @@ static int snd_pcm_oss_post(struct snd_pcm_oss_file *pcm_oss_file) return 0; } -static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size) +static int snd_pcm_oss_sync1(snd_pcm_substream_t *substream, size_t size) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; ssize_t result = 0; long res; wait_queue_t wait; @@ -1020,12 +1020,12 @@ static int snd_pcm_oss_sync1(struct snd_pcm_substream *substream, size_t size) return result; } -static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_sync(snd_pcm_oss_file_t *pcm_oss_file) { int err = 0; unsigned int saved_f_flags; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_format_t format; unsigned long width; size_t size; @@ -1117,13 +1117,13 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file) return 0; } -static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate) +static int snd_pcm_oss_set_rate(snd_pcm_oss_file_t *pcm_oss_file, int rate) { int idx; for (idx = 1; idx >= 0; --idx) { - struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + snd_pcm_runtime_t *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1139,9 +1139,9 @@ static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate) return snd_pcm_oss_get_rate(pcm_oss_file); } -static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_rate(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1149,7 +1149,7 @@ static int snd_pcm_oss_get_rate(struct snd_pcm_oss_file *pcm_oss_file) return substream->runtime->oss.rate; } -static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsigned int channels) +static int snd_pcm_oss_set_channels(snd_pcm_oss_file_t *pcm_oss_file, unsigned int channels) { int idx; if (channels < 1) @@ -1157,8 +1157,8 @@ static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsig if (channels > 128) return -EINVAL; for (idx = 1; idx >= 0; --idx) { - struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + snd_pcm_runtime_t *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1170,9 +1170,9 @@ static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsig return snd_pcm_oss_get_channels(pcm_oss_file); } -static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_channels(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1180,9 +1180,9 @@ static int snd_pcm_oss_get_channels(struct snd_pcm_oss_file *pcm_oss_file) return substream->runtime->oss.channels; } -static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_block_size(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1190,14 +1190,14 @@ static int snd_pcm_oss_get_block_size(struct snd_pcm_oss_file *pcm_oss_file) return substream->runtime->oss.period_bytes; } -static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_formats(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int err; int direct; - struct snd_pcm_hw_params *params; + snd_pcm_hw_params_t *params; unsigned int formats = 0; - struct snd_mask format_mask; + snd_mask_t format_mask; int fmt; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1205,7 +1205,7 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file) if (atomic_read(&substream->runtime->mmap_count)) { direct = 1; } else { - struct snd_pcm_oss_setup *setup = substream->oss.setup; + snd_pcm_oss_setup_t *setup = substream->oss.setup; direct = (setup != NULL && setup->direct); } if (!direct) @@ -1231,7 +1231,7 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file) return formats; } -static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int format) +static int snd_pcm_oss_set_format(snd_pcm_oss_file_t *pcm_oss_file, int format) { int formats, idx; @@ -1240,8 +1240,8 @@ static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int for if (!(formats & format)) format = AFMT_U8; for (idx = 1; idx >= 0; --idx) { - struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; + snd_pcm_runtime_t *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1254,9 +1254,9 @@ static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int for return snd_pcm_oss_get_format(pcm_oss_file); } -static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_format(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int err; if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0) @@ -1264,9 +1264,9 @@ static int snd_pcm_oss_get_format(struct snd_pcm_oss_file *pcm_oss_file) return substream->runtime->oss.format; } -static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int subdivide) +static int snd_pcm_oss_set_subdivide1(snd_pcm_substream_t *substream, int subdivide) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; if (substream == NULL) return 0; @@ -1287,12 +1287,12 @@ static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int s return subdivide; } -static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int subdivide) +static int snd_pcm_oss_set_subdivide(snd_pcm_oss_file_t *pcm_oss_file, int subdivide) { int err = -EINVAL, idx; for (idx = 1; idx >= 0; --idx) { - struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; if (substream == NULL) continue; if ((err = snd_pcm_oss_set_subdivide1(substream, subdivide)) < 0) @@ -1301,9 +1301,9 @@ static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int return err; } -static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsigned int val) +static int snd_pcm_oss_set_fragment1(snd_pcm_substream_t *substream, unsigned int val) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; if (substream == NULL) return 0; @@ -1320,12 +1320,12 @@ static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsign return 0; } -static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsigned int val) +static int snd_pcm_oss_set_fragment(snd_pcm_oss_file_t *pcm_oss_file, unsigned int val) { int err = -EINVAL, idx; for (idx = 1; idx >= 0; --idx) { - struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; if (substream == NULL) continue; if ((err = snd_pcm_oss_set_fragment1(substream, val)) < 0) @@ -1340,7 +1340,7 @@ static int snd_pcm_oss_nonblock(struct file * file) return 0; } -static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res) +static int snd_pcm_oss_get_caps1(snd_pcm_substream_t *substream, int res) { if (substream == NULL) { @@ -1356,7 +1356,7 @@ static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res) /* all ALSA drivers can return actual pointer in ring buffer */ #if defined(DSP_CAP_REALTIME) && 0 { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->info & (SNDRV_PCM_INFO_BLOCK_TRANSFER|SNDRV_PCM_INFO_BATCH)) res &= ~DSP_CAP_REALTIME; } @@ -1364,32 +1364,32 @@ static int snd_pcm_oss_get_caps1(struct snd_pcm_substream *substream, int res) return res; } -static int snd_pcm_oss_get_caps(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_caps(snd_pcm_oss_file_t *pcm_oss_file) { int result, idx; result = DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_DUPLEX | DSP_CAP_REALTIME; for (idx = 0; idx < 2; idx++) { - struct snd_pcm_substream *substream = pcm_oss_file->streams[idx]; + snd_pcm_substream_t *substream = pcm_oss_file->streams[idx]; result = snd_pcm_oss_get_caps1(substream, result); } result |= 0x0001; /* revision - same as SB AWE 64 */ return result; } -static void snd_pcm_oss_simulate_fill(struct snd_pcm_substream *substream, snd_pcm_uframes_t hw_ptr) +static void snd_pcm_oss_simulate_fill(snd_pcm_substream_t *substream, snd_pcm_uframes_t hw_ptr) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t appl_ptr; appl_ptr = hw_ptr + runtime->buffer_size; appl_ptr %= runtime->boundary; runtime->control->appl_ptr = appl_ptr; } -static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int trigger) +static int snd_pcm_oss_set_trigger(snd_pcm_oss_file_t *pcm_oss_file, int trigger) { - struct snd_pcm_runtime *runtime; - struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; + snd_pcm_runtime_t *runtime; + snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; int err, cmd; #ifdef OSS_DEBUG @@ -1454,9 +1454,9 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr return 0; } -static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_trigger(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; + snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; int result = 0; psubstream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -1468,10 +1468,10 @@ static int snd_pcm_oss_get_trigger(struct snd_pcm_oss_file *pcm_oss_file) return result; } -static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_get_odelay(snd_pcm_oss_file_t *pcm_oss_file) { - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_sframes_t delay; int err; @@ -1491,10 +1491,10 @@ static int snd_pcm_oss_get_odelay(struct snd_pcm_oss_file *pcm_oss_file) return snd_pcm_oss_bytes(substream, delay); } -static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct count_info __user * _info) +static int snd_pcm_oss_get_ptr(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct count_info __user * _info) { - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_sframes_t delay; int fixup; struct count_info info; @@ -1543,7 +1543,7 @@ static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream } else { delay = snd_pcm_oss_bytes(substream, delay); if (stream == SNDRV_PCM_STREAM_PLAYBACK) { - struct snd_pcm_oss_setup *setup = substream->oss.setup; + snd_pcm_oss_setup_t *setup = substream->oss.setup; if (setup && setup->buggyptr) info.blocks = (runtime->oss.buffer_bytes - delay - fixup) / runtime->oss.period_bytes; else @@ -1560,10 +1560,10 @@ static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream return 0; } -static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct audio_buf_info __user *_info) +static int snd_pcm_oss_get_space(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct audio_buf_info __user *_info) { - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_sframes_t avail; int fixup; struct audio_buf_info info; @@ -1619,17 +1619,17 @@ static int snd_pcm_oss_get_space(struct snd_pcm_oss_file *pcm_oss_file, int stre return 0; } -static int snd_pcm_oss_get_mapbuf(struct snd_pcm_oss_file *pcm_oss_file, int stream, struct buffmem_desc __user * _info) +static int snd_pcm_oss_get_mapbuf(snd_pcm_oss_file_t *pcm_oss_file, int stream, struct buffmem_desc __user * _info) { // it won't be probably implemented // snd_printd("TODO: snd_pcm_oss_get_mapbuf\n"); return -EINVAL; } -static struct snd_pcm_oss_setup *snd_pcm_oss_look_for_setup(struct snd_pcm *pcm, int stream, const char *task_name) +static snd_pcm_oss_setup_t *snd_pcm_oss_look_for_setup(snd_pcm_t *pcm, int stream, const char *task_name) { const char *ptr, *ptrl; - struct snd_pcm_oss_setup *setup; + snd_pcm_oss_setup_t *setup; down(&pcm->streams[stream].oss.setup_mutex); for (setup = pcm->streams[stream].oss.setup_list; setup; setup = setup->next) { @@ -1659,11 +1659,11 @@ static struct snd_pcm_oss_setup *snd_pcm_oss_look_for_setup(struct snd_pcm *pcm, return NULL; } -static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream, - struct snd_pcm_oss_setup *setup, +static void snd_pcm_oss_init_substream(snd_pcm_substream_t *substream, + snd_pcm_oss_setup_t *setup, int minor) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; substream->oss.oss = 1; substream->oss.setup = setup; @@ -1687,9 +1687,9 @@ static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream, runtime->oss.subdivision = 0; } -static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream) +static void snd_pcm_oss_release_substream(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; runtime = substream->runtime; vfree(runtime->oss.buffer); snd_pcm_oss_plugin_clear(substream); @@ -1697,13 +1697,13 @@ static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream) substream->oss.oss = 0; } -static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file) +static int snd_pcm_oss_release_file(snd_pcm_oss_file_t *pcm_oss_file) { int cidx; snd_assert(pcm_oss_file != NULL, return -ENXIO); for (cidx = 0; cidx < 2; ++cidx) { - struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx]; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = pcm_oss_file->streams[cidx]; + snd_pcm_runtime_t *runtime; if (substream == NULL) continue; runtime = substream->runtime; @@ -1726,15 +1726,15 @@ static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file) } static int snd_pcm_oss_open_file(struct file *file, - struct snd_pcm *pcm, - struct snd_pcm_oss_file **rpcm_oss_file, + snd_pcm_t *pcm, + snd_pcm_oss_file_t **rpcm_oss_file, int minor, - struct snd_pcm_oss_setup *psetup, - struct snd_pcm_oss_setup *csetup) + snd_pcm_oss_setup_t *psetup, + snd_pcm_oss_setup_t *csetup) { int err = 0; - struct snd_pcm_oss_file *pcm_oss_file; - struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; + snd_pcm_oss_file_t *pcm_oss_file; + snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; unsigned int f_mode = file->f_mode; snd_assert(rpcm_oss_file != NULL, return -EINVAL); @@ -1834,16 +1834,22 @@ static int snd_task_name(struct task_struct *task, char *name, size_t size) static int snd_pcm_oss_open(struct inode *inode, struct file *file) { + int minor = iminor(inode); + int cardnum = SNDRV_MINOR_OSS_CARD(minor); + int device; int err; char task_name[32]; - struct snd_pcm *pcm; - struct snd_pcm_oss_file *pcm_oss_file; - struct snd_pcm_oss_setup *psetup = NULL, *csetup = NULL; + snd_pcm_t *pcm; + snd_pcm_oss_file_t *pcm_oss_file; + snd_pcm_oss_setup_t *psetup = NULL, *csetup = NULL; int nonblock; wait_queue_t wait; - pcm = snd_lookup_oss_minor_data(iminor(inode), - SNDRV_OSS_DEVICE_TYPE_PCM); + snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); + device = SNDRV_MINOR_OSS_DEVICE(minor) == SNDRV_MINOR_OSS_PCM1 ? + adsp_map[cardnum] : dsp_map[cardnum]; + + pcm = snd_pcm_devices[(cardnum * SNDRV_PCM_DEVICES) + device]; if (pcm == NULL) { err = -ENODEV; goto __error1; @@ -1884,7 +1890,7 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file) down(&pcm->open_mutex); while (1) { err = snd_pcm_oss_open_file(file, pcm, &pcm_oss_file, - iminor(inode), psetup, csetup); + minor, psetup, csetup); if (err >= 0) break; if (err == -EAGAIN) { @@ -1919,9 +1925,9 @@ static int snd_pcm_oss_open(struct inode *inode, struct file *file) static int snd_pcm_oss_release(struct inode *inode, struct file *file) { - struct snd_pcm *pcm; - struct snd_pcm_substream *substream; - struct snd_pcm_oss_file *pcm_oss_file; + snd_pcm_t *pcm; + snd_pcm_substream_t *substream; + snd_pcm_oss_file_t *pcm_oss_file; pcm_oss_file = file->private_data; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; @@ -1941,7 +1947,7 @@ static int snd_pcm_oss_release(struct inode *inode, struct file *file) static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_pcm_oss_file *pcm_oss_file; + snd_pcm_oss_file_t *pcm_oss_file; int __user *p = (int __user *)arg; int res; @@ -1952,7 +1958,7 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long return put_user(1, p); #if defined(CONFIG_SND_MIXER_OSS) || (defined(MODULE) && defined(CONFIG_SND_MIXER_OSS_MODULE)) if (((cmd >> 8) & 0xff) == 'M') { /* mixer ioctl - for OSS compatibility */ - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int idx; for (idx = 0; idx < 2; ++idx) { substream = pcm_oss_file->streams[idx]; @@ -2107,8 +2113,8 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { - struct snd_pcm_oss_file *pcm_oss_file; - struct snd_pcm_substream *substream; + snd_pcm_oss_file_t *pcm_oss_file; + snd_pcm_substream_t *substream; pcm_oss_file = file->private_data; substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE]; @@ -2127,8 +2133,8 @@ static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t coun static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { - struct snd_pcm_oss_file *pcm_oss_file; - struct snd_pcm_substream *substream; + snd_pcm_oss_file_t *pcm_oss_file; + snd_pcm_substream_t *substream; long result; pcm_oss_file = file->private_data; @@ -2144,18 +2150,18 @@ static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size return result; } -static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream) +static int snd_pcm_oss_playback_ready(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt; else return snd_pcm_playback_avail(runtime) >= runtime->oss.period_frames; } -static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream) +static int snd_pcm_oss_capture_ready(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (atomic_read(&runtime->mmap_count)) return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt; else @@ -2164,9 +2170,9 @@ static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream) static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) { - struct snd_pcm_oss_file *pcm_oss_file; + snd_pcm_oss_file_t *pcm_oss_file; unsigned int mask; - struct snd_pcm_substream *psubstream = NULL, *csubstream = NULL; + snd_pcm_substream_t *psubstream = NULL, *csubstream = NULL; pcm_oss_file = file->private_data; @@ -2175,7 +2181,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) mask = 0; if (psubstream != NULL) { - struct snd_pcm_runtime *runtime = psubstream->runtime; + snd_pcm_runtime_t *runtime = psubstream->runtime; poll_wait(file, &runtime->sleep, wait); snd_pcm_stream_lock_irq(psubstream); if (runtime->status->state != SNDRV_PCM_STATE_DRAINING && @@ -2185,8 +2191,8 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) snd_pcm_stream_unlock_irq(psubstream); } if (csubstream != NULL) { - struct snd_pcm_runtime *runtime = csubstream->runtime; - snd_pcm_state_t ostate; + snd_pcm_runtime_t *runtime = csubstream->runtime; + enum sndrv_pcm_state ostate; poll_wait(file, &runtime->sleep, wait); snd_pcm_stream_lock_irq(csubstream); if ((ostate = runtime->status->state) != SNDRV_PCM_STATE_RUNNING || @@ -2194,7 +2200,7 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) mask |= POLLIN | POLLRDNORM; snd_pcm_stream_unlock_irq(csubstream); if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) { - struct snd_pcm_oss_file ofile; + snd_pcm_oss_file_t ofile; memset(&ofile, 0, sizeof(ofile)); ofile.streams[SNDRV_PCM_STREAM_CAPTURE] = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE]; runtime->oss.trigger = 0; @@ -2207,9 +2213,9 @@ static unsigned int snd_pcm_oss_poll(struct file *file, poll_table * wait) static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) { - struct snd_pcm_oss_file *pcm_oss_file; - struct snd_pcm_substream *substream = NULL; - struct snd_pcm_runtime *runtime; + snd_pcm_oss_file_t *pcm_oss_file; + snd_pcm_substream_t *substream = NULL; + snd_pcm_runtime_t *runtime; int err; #ifdef OSS_DEBUG @@ -2269,16 +2275,15 @@ static int snd_pcm_oss_mmap(struct file *file, struct vm_area_struct *area) return 0; } -#ifdef CONFIG_PROC_FS /* * /proc interface */ -static void snd_pcm_oss_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_oss_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_pcm_str *pstr = entry->private_data; - struct snd_pcm_oss_setup *setup = pstr->oss.setup_list; + snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; + snd_pcm_oss_setup_t *setup = pstr->oss.setup_list; down(&pstr->oss.setup_mutex); while (setup) { snd_iprintf(buffer, "%s %u %u%s%s%s%s%s%s\n", @@ -2296,11 +2301,11 @@ static void snd_pcm_oss_proc_read(struct snd_info_entry *entry, up(&pstr->oss.setup_mutex); } -static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str * pstr) +static void snd_pcm_oss_proc_free_setup_list(snd_pcm_str_t * pstr) { unsigned int idx; - struct snd_pcm_substream *substream; - struct snd_pcm_oss_setup *setup, *setupn; + snd_pcm_substream_t *substream; + snd_pcm_oss_setup_t *setup, *setupn; for (idx = 0, substream = pstr->substream; idx < pstr->substream_count; idx++, substream = substream->next) @@ -2314,13 +2319,13 @@ static void snd_pcm_oss_proc_free_setup_list(struct snd_pcm_str * pstr) pstr->oss.setup_list = NULL; } -static void snd_pcm_oss_proc_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_oss_proc_write(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_pcm_str *pstr = entry->private_data; + snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; char line[128], str[32], task_name[32], *ptr; int idx1; - struct snd_pcm_oss_setup *setup, *setup1, template; + snd_pcm_oss_setup_t *setup, *setup1, template; while (!snd_info_get_line(buffer, line, sizeof(line))) { down(&pstr->oss.setup_mutex); @@ -2365,7 +2370,7 @@ static void snd_pcm_oss_proc_write(struct snd_info_entry *entry, } } while (*str); if (setup == NULL) { - setup = kmalloc(sizeof(struct snd_pcm_oss_setup), GFP_KERNEL); + setup = (snd_pcm_oss_setup_t *) kmalloc(sizeof(snd_pcm_oss_setup_t), GFP_KERNEL); if (setup) { if (pstr->oss.setup_list == NULL) { pstr->oss.setup_list = setup; @@ -2384,12 +2389,12 @@ static void snd_pcm_oss_proc_write(struct snd_info_entry *entry, } } -static void snd_pcm_oss_proc_init(struct snd_pcm *pcm) +static void snd_pcm_oss_proc_init(snd_pcm_t *pcm) { int stream; for (stream = 0; stream < 2; ++stream) { - struct snd_info_entry *entry; - struct snd_pcm_str *pstr = &pcm->streams[stream]; + snd_info_entry_t *entry; + snd_pcm_str_t *pstr = &pcm->streams[stream]; if (pstr->substream_count == 0) continue; if ((entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root)) != NULL) { @@ -2409,11 +2414,11 @@ static void snd_pcm_oss_proc_init(struct snd_pcm *pcm) } } -static void snd_pcm_oss_proc_done(struct snd_pcm *pcm) +static void snd_pcm_oss_proc_done(snd_pcm_t *pcm) { int stream; for (stream = 0; stream < 2; ++stream) { - struct snd_pcm_str *pstr = &pcm->streams[stream]; + snd_pcm_str_t *pstr = &pcm->streams[stream]; if (pstr->oss.proc_entry) { snd_info_unregister(pstr->oss.proc_entry); pstr->oss.proc_entry = NULL; @@ -2421,10 +2426,6 @@ static void snd_pcm_oss_proc_done(struct snd_pcm *pcm) } } } -#else /* !CONFIG_PROC_FS */ -#define snd_pcm_oss_proc_init(pcm) -#define snd_pcm_oss_proc_done(pcm) -#endif /* CONFIG_PROC_FS */ /* * ENTRY functions @@ -2443,19 +2444,25 @@ static struct file_operations snd_pcm_oss_f_reg = .mmap = snd_pcm_oss_mmap, }; -static void register_oss_dsp(struct snd_pcm *pcm, int index) +static snd_minor_t snd_pcm_oss_reg = +{ + .comment = "digital audio", + .f_ops = &snd_pcm_oss_f_reg, +}; + +static void register_oss_dsp(snd_pcm_t *pcm, int index) { char name[128]; sprintf(name, "dsp%i%i", pcm->card->number, pcm->device); if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM, - pcm->card, index, &snd_pcm_oss_f_reg, - pcm, name) < 0) { + pcm->card, index, &snd_pcm_oss_reg, + name) < 0) { snd_printk(KERN_ERR "unable to register OSS PCM device %i:%i\n", pcm->card->number, pcm->device); } } -static int snd_pcm_oss_register_minor(struct snd_pcm *pcm) +static int snd_pcm_oss_register_minor(snd_pcm_t * pcm) { pcm->oss.reg = 0; if (dsp_map[pcm->card->number] == (int)pcm->device) { @@ -2486,7 +2493,7 @@ static int snd_pcm_oss_register_minor(struct snd_pcm *pcm) return 0; } -static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm) +static int snd_pcm_oss_disconnect_minor(snd_pcm_t * pcm) { if (pcm->oss.reg) { if (pcm->oss.reg_mask & 1) { @@ -2503,7 +2510,7 @@ static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm) return 0; } -static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm) +static int snd_pcm_oss_unregister_minor(snd_pcm_t * pcm) { snd_pcm_oss_disconnect_minor(pcm); if (pcm->oss.reg) { @@ -2518,7 +2525,7 @@ static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm) return 0; } -static struct snd_pcm_notify snd_pcm_oss_notify = +static snd_pcm_notify_t snd_pcm_oss_notify = { .n_register = snd_pcm_oss_register_minor, .n_disconnect = snd_pcm_oss_disconnect_minor, diff --git a/trunk/sound/core/oss/pcm_plugin.c b/trunk/sound/core/oss/pcm_plugin.c index 7e8676880dde..fc23373c000d 100644 --- a/trunk/sound/core/oss/pcm_plugin.c +++ b/trunk/sound/core/oss/pcm_plugin.c @@ -36,22 +36,22 @@ #define snd_pcm_plug_first(plug) ((plug)->runtime->oss.plugin_first) #define snd_pcm_plug_last(plug) ((plug)->runtime->oss.plugin_last) -static int snd_pcm_plugin_src_channels_mask(struct snd_pcm_plugin *plugin, - unsigned long *dst_vmask, - unsigned long **src_vmask) +static int snd_pcm_plugin_src_channels_mask(snd_pcm_plugin_t *plugin, + bitset_t *dst_vmask, + bitset_t **src_vmask) { - unsigned long *vmask = plugin->src_vmask; - bitmap_copy(vmask, dst_vmask, plugin->src_format.channels); + bitset_t *vmask = plugin->src_vmask; + bitset_copy(vmask, dst_vmask, plugin->src_format.channels); *src_vmask = vmask; return 0; } -static int snd_pcm_plugin_dst_channels_mask(struct snd_pcm_plugin *plugin, - unsigned long *src_vmask, - unsigned long **dst_vmask) +static int snd_pcm_plugin_dst_channels_mask(snd_pcm_plugin_t *plugin, + bitset_t *src_vmask, + bitset_t **dst_vmask) { - unsigned long *vmask = plugin->dst_vmask; - bitmap_copy(vmask, src_vmask, plugin->dst_format.channels); + bitset_t *vmask = plugin->dst_vmask; + bitset_copy(vmask, src_vmask, plugin->dst_format.channels); *dst_vmask = vmask; return 0; } @@ -67,13 +67,13 @@ static int rate_match(unsigned int src_rate, unsigned int dst_rate) return dst_rate >= low && dst_rate <= high; } -static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) +static int snd_pcm_plugin_alloc(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) { - struct snd_pcm_plugin_format *format; + snd_pcm_plugin_format_t *format; ssize_t width; size_t size; unsigned int channel; - struct snd_pcm_plugin_channel *c; + snd_pcm_plugin_channel_t *c; if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK) { format = &plugin->src_format; @@ -120,12 +120,12 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t return 0; } -int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames) +int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames) { int err; snd_assert(snd_pcm_plug_first(plug) != NULL, return -ENXIO); if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) { - struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); + snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug); while (plugin->next) { if (plugin->dst_frames) frames = plugin->dst_frames(plugin, frames); @@ -136,7 +136,7 @@ int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames) return err; } } else { - struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); + snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); while (plugin->prev) { if (plugin->src_frames) frames = plugin->src_frames(plugin, frames); @@ -151,22 +151,22 @@ int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames) } -snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin, +snd_pcm_sframes_t snd_pcm_plugin_client_channels(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames, - struct snd_pcm_plugin_channel **channels) + snd_pcm_plugin_channel_t **channels) { *channels = plugin->buf_channels; return frames; } -int snd_pcm_plugin_build(struct snd_pcm_substream *plug, +int snd_pcm_plugin_build(snd_pcm_plug_t *plug, const char *name, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, size_t extra, - struct snd_pcm_plugin **ret) + snd_pcm_plugin_t **ret) { - struct snd_pcm_plugin *plugin; + snd_pcm_plugin_t *plugin; unsigned int channels; snd_assert(plug != NULL, return -ENXIO); @@ -193,12 +193,12 @@ int snd_pcm_plugin_build(struct snd_pcm_substream *plug, snd_pcm_plugin_free(plugin); return -ENOMEM; } - plugin->src_vmask = bitmap_alloc(src_format->channels); + plugin->src_vmask = bitset_alloc(src_format->channels); if (plugin->src_vmask == NULL) { snd_pcm_plugin_free(plugin); return -ENOMEM; } - plugin->dst_vmask = bitmap_alloc(dst_format->channels); + plugin->dst_vmask = bitset_alloc(dst_format->channels); if (plugin->dst_vmask == NULL) { snd_pcm_plugin_free(plugin); return -ENOMEM; @@ -210,7 +210,7 @@ int snd_pcm_plugin_build(struct snd_pcm_substream *plug, return 0; } -int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin) +int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin) { if (! plugin) return 0; @@ -224,9 +224,9 @@ int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin) return 0; } -snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t drv_frames) +snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t drv_frames) { - struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; + snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next; int stream = snd_pcm_plug_stream(plug); snd_assert(plug != NULL, return -ENXIO); @@ -253,9 +253,9 @@ snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *plug, snd_p return drv_frames; } -snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t clt_frames) +snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *plug, snd_pcm_uframes_t clt_frames) { - struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; + snd_pcm_plugin_t *plugin, *plugin_prev, *plugin_next; snd_pcm_sframes_t frames; int stream = snd_pcm_plug_stream(plug); @@ -290,9 +290,9 @@ snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pc return frames; } -static int snd_pcm_plug_formats(struct snd_mask *mask, int format) +static int snd_pcm_plug_formats(snd_mask_t *mask, int format) { - struct snd_mask formats = *mask; + snd_mask_t formats = *mask; u64 linfmts = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_BE | SNDRV_PCM_FMTBIT_S16_BE | @@ -326,7 +326,7 @@ static int preferred_formats[] = { SNDRV_PCM_FORMAT_U8 }; -int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask) +int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask) { if (snd_mask_test(format_mask, format)) return format; @@ -376,15 +376,15 @@ int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask) } } -int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug, - struct snd_pcm_hw_params *params, - struct snd_pcm_hw_params *slave_params) +int snd_pcm_plug_format_plugins(snd_pcm_plug_t *plug, + snd_pcm_hw_params_t *params, + snd_pcm_hw_params_t *slave_params) { - struct snd_pcm_plugin_format tmpformat; - struct snd_pcm_plugin_format dstformat; - struct snd_pcm_plugin_format srcformat; + snd_pcm_plugin_format_t tmpformat; + snd_pcm_plugin_format_t dstformat; + snd_pcm_plugin_format_t srcformat; int src_access, dst_access; - struct snd_pcm_plugin *plugin = NULL; + snd_pcm_plugin_t *plugin = NULL; int err; int stream = snd_pcm_plug_stream(plug); int slave_interleaved = (params_channels(slave_params) == 1 || @@ -462,7 +462,7 @@ int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug, if (srcformat.channels > dstformat.channels) { int sv = srcformat.channels; int dv = dstformat.channels; - int *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); + route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); if (ttable == NULL) return -ENOMEM; #if 1 @@ -525,7 +525,7 @@ int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug, if (srcformat.channels < dstformat.channels) { int sv = srcformat.channels; int dv = dstformat.channels; - int *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); + route_ttable_entry_t *ttable = kcalloc(dv * sv, sizeof(*ttable), GFP_KERNEL); if (ttable == NULL) return -ENOMEM; #if 0 @@ -614,14 +614,14 @@ int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug, return 0; } -snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plug, +snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *plug, char *buf, snd_pcm_uframes_t count, - struct snd_pcm_plugin_channel **channels) + snd_pcm_plugin_channel_t **channels) { - struct snd_pcm_plugin *plugin; - struct snd_pcm_plugin_channel *v; - struct snd_pcm_plugin_format *format; + snd_pcm_plugin_t *plugin; + snd_pcm_plugin_channel_t *v; + snd_pcm_plugin_format_t *format; int width, nchannels, channel; int stream = snd_pcm_plug_stream(plug); @@ -650,19 +650,19 @@ snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plu return count; } -static int snd_pcm_plug_playback_channels_mask(struct snd_pcm_substream *plug, - unsigned long *client_vmask) +static int snd_pcm_plug_playback_channels_mask(snd_pcm_plug_t *plug, + bitset_t *client_vmask) { - struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); + snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); if (plugin == NULL) { return 0; } else { int schannels = plugin->dst_format.channels; - DECLARE_BITMAP(bs, schannels); - unsigned long *srcmask; - unsigned long *dstmask = bs; + bitset_t bs[bitset_size(schannels)]; + bitset_t *srcmask; + bitset_t *dstmask = bs; int err; - bitmap_fill(dstmask, schannels); + bitset_one(dstmask, schannels); while (1) { err = plugin->src_channels_mask(plugin, dstmask, &srcmask); @@ -673,52 +673,52 @@ static int snd_pcm_plug_playback_channels_mask(struct snd_pcm_substream *plug, break; plugin = plugin->prev; } - bitmap_and(client_vmask, client_vmask, dstmask, plugin->src_format.channels); + bitset_and(client_vmask, dstmask, plugin->src_format.channels); return 0; } } -static int snd_pcm_plug_playback_disable_useless_channels(struct snd_pcm_substream *plug, - struct snd_pcm_plugin_channel *src_channels) +static int snd_pcm_plug_playback_disable_useless_channels(snd_pcm_plug_t *plug, + snd_pcm_plugin_channel_t *src_channels) { - struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); + snd_pcm_plugin_t *plugin = snd_pcm_plug_first(plug); unsigned int nchannels = plugin->src_format.channels; - DECLARE_BITMAP(bs, nchannels); - unsigned long *srcmask = bs; + bitset_t bs[bitset_size(nchannels)]; + bitset_t *srcmask = bs; int err; unsigned int channel; for (channel = 0; channel < nchannels; channel++) { if (src_channels[channel].enabled) - set_bit(channel, srcmask); + bitset_set(srcmask, channel); else - clear_bit(channel, srcmask); + bitset_reset(srcmask, channel); } err = snd_pcm_plug_playback_channels_mask(plug, srcmask); if (err < 0) return err; for (channel = 0; channel < nchannels; channel++) { - if (!test_bit(channel, srcmask)) + if (!bitset_get(srcmask, channel)) src_channels[channel].enabled = 0; } return 0; } -static int snd_pcm_plug_capture_disable_useless_channels(struct snd_pcm_substream *plug, - struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *client_channels) +static int snd_pcm_plug_capture_disable_useless_channels(snd_pcm_plug_t *plug, + snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *client_channels) { - struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); + snd_pcm_plugin_t *plugin = snd_pcm_plug_last(plug); unsigned int nchannels = plugin->dst_format.channels; - DECLARE_BITMAP(bs, nchannels); - unsigned long *dstmask = bs; - unsigned long *srcmask; + bitset_t bs[bitset_size(nchannels)]; + bitset_t *dstmask = bs; + bitset_t *srcmask; int err; unsigned int channel; for (channel = 0; channel < nchannels; channel++) { if (client_channels[channel].enabled) - set_bit(channel, dstmask); + bitset_set(dstmask, channel); else - clear_bit(channel, dstmask); + bitset_reset(dstmask, channel); } while (plugin) { err = plugin->src_channels_mask(plugin, dstmask, &srcmask); @@ -730,16 +730,16 @@ static int snd_pcm_plug_capture_disable_useless_channels(struct snd_pcm_substrea plugin = snd_pcm_plug_first(plug); nchannels = plugin->src_format.channels; for (channel = 0; channel < nchannels; channel++) { - if (!test_bit(channel, dstmask)) + if (!bitset_get(dstmask, channel)) src_channels[channel].enabled = 0; } return 0; } -snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *src_channels, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *src_channels, snd_pcm_uframes_t size) { - struct snd_pcm_plugin *plugin, *next; - struct snd_pcm_plugin_channel *dst_channels; + snd_pcm_plugin_t *plugin, *next; + snd_pcm_plugin_channel_t *dst_channels; int err; snd_pcm_sframes_t frames = size; @@ -771,10 +771,10 @@ snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *plug, st return snd_pcm_plug_client_size(plug, frames); } -snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *dst_channels_final, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *plug, snd_pcm_plugin_channel_t *dst_channels_final, snd_pcm_uframes_t size) { - struct snd_pcm_plugin *plugin, *next; - struct snd_pcm_plugin_channel *src_channels, *dst_channels; + snd_pcm_plugin_t *plugin, *next; + snd_pcm_plugin_channel_t *src_channels, *dst_channels; snd_pcm_sframes_t frames = size; int err; @@ -806,7 +806,7 @@ snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *plug, str return frames; } -int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_area, size_t dst_offset, +int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, size_t dst_offset, size_t samples, int format) { /* FIXME: sub byte resolution and odd dst_offset */ @@ -852,8 +852,8 @@ int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_area, size_t dst return 0; } -int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_area, size_t src_offset, - const struct snd_pcm_channel_area *dst_area, size_t dst_offset, +int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_area, size_t src_offset, + const snd_pcm_channel_area_t *dst_area, size_t dst_offset, size_t samples, int format) { /* FIXME: sub byte resolution and odd dst_offset */ diff --git a/trunk/sound/core/oss/pcm_plugin.h b/trunk/sound/core/oss/pcm_plugin.h index 29198da615cd..0f86ce477490 100644 --- a/trunk/sound/core/oss/pcm_plugin.h +++ b/trunk/sound/core/oss/pcm_plugin.h @@ -22,164 +22,214 @@ * */ -#include <linux/bitmap.h> +#ifndef ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +#endif + +typedef unsigned int bitset_t; + +static inline size_t bitset_size(int nbits) +{ + return (nbits + sizeof(bitset_t) * 8 - 1) / (sizeof(bitset_t) * 8); +} + +static inline bitset_t *bitset_alloc(int nbits) +{ + return kcalloc(bitset_size(nbits), sizeof(bitset_t), GFP_KERNEL); +} + +static inline void bitset_set(bitset_t *bitmap, unsigned int pos) +{ + size_t bits = sizeof(*bitmap) * 8; + bitmap[pos / bits] |= 1 << (pos % bits); +} -static inline unsigned long *bitmap_alloc(unsigned int nbits) +static inline void bitset_reset(bitset_t *bitmap, unsigned int pos) { - return kmalloc(BITS_TO_LONGS(nbits), GFP_KERNEL); + size_t bits = sizeof(*bitmap) * 8; + bitmap[pos / bits] &= ~(1 << (pos % bits)); } +static inline int bitset_get(bitset_t *bitmap, unsigned int pos) +{ + size_t bits = sizeof(*bitmap) * 8; + return !!(bitmap[pos / bits] & (1 << (pos % bits))); +} + +static inline void bitset_copy(bitset_t *dst, bitset_t *src, unsigned int nbits) +{ + memcpy(dst, src, bitset_size(nbits) * sizeof(bitset_t)); +} + +static inline void bitset_and(bitset_t *dst, bitset_t *bs, unsigned int nbits) +{ + bitset_t *end = dst + bitset_size(nbits); + while (dst < end) + *dst++ &= *bs++; +} + +static inline void bitset_or(bitset_t *dst, bitset_t *bs, unsigned int nbits) +{ + bitset_t *end = dst + bitset_size(nbits); + while (dst < end) + *dst++ |= *bs++; +} + +static inline void bitset_zero(bitset_t *dst, unsigned int nbits) +{ + bitset_t *end = dst + bitset_size(nbits); + while (dst < end) + *dst++ = 0; +} + +static inline void bitset_one(bitset_t *dst, unsigned int nbits) +{ + bitset_t *end = dst + bitset_size(nbits); + while (dst < end) + *dst++ = ~(bitset_t)0; +} + +#define snd_pcm_plug_t snd_pcm_substream_t #define snd_pcm_plug_stream(plug) ((plug)->stream) -enum snd_pcm_plugin_action { +typedef enum { INIT = 0, PREPARE = 1, -}; +} snd_pcm_plugin_action_t; -struct snd_pcm_channel_area { +typedef struct _snd_pcm_channel_area { void *addr; /* base address of channel samples */ unsigned int first; /* offset to first sample in bits */ unsigned int step; /* samples distance in bits */ -}; +} snd_pcm_channel_area_t; -struct snd_pcm_plugin_channel { +typedef struct _snd_pcm_plugin_channel { void *aptr; /* pointer to the allocated area */ - struct snd_pcm_channel_area area; + snd_pcm_channel_area_t area; snd_pcm_uframes_t frames; /* allocated frames */ unsigned int enabled:1; /* channel need to be processed */ unsigned int wanted:1; /* channel is wanted */ -}; +} snd_pcm_plugin_channel_t; -struct snd_pcm_plugin_format { +typedef struct _snd_pcm_plugin_format { int format; unsigned int rate; unsigned int channels; -}; +} snd_pcm_plugin_format_t; -struct snd_pcm_plugin { +struct _snd_pcm_plugin { const char *name; /* plug-in name */ int stream; - struct snd_pcm_plugin_format src_format; /* source format */ - struct snd_pcm_plugin_format dst_format; /* destination format */ + snd_pcm_plugin_format_t src_format; /* source format */ + snd_pcm_plugin_format_t dst_format; /* destination format */ int src_width; /* sample width in bits */ int dst_width; /* sample width in bits */ int access; - snd_pcm_sframes_t (*src_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t dst_frames); - snd_pcm_sframes_t (*dst_frames)(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t src_frames); - snd_pcm_sframes_t (*client_channels)(struct snd_pcm_plugin *plugin, - snd_pcm_uframes_t frames, - struct snd_pcm_plugin_channel **channels); - int (*src_channels_mask)(struct snd_pcm_plugin *plugin, - unsigned long *dst_vmask, - unsigned long **src_vmask); - int (*dst_channels_mask)(struct snd_pcm_plugin *plugin, - unsigned long *src_vmask, - unsigned long **dst_vmask); - snd_pcm_sframes_t (*transfer)(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, - snd_pcm_uframes_t frames); - int (*action)(struct snd_pcm_plugin *plugin, - enum snd_pcm_plugin_action action, + snd_pcm_sframes_t (*src_frames)(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t dst_frames); + snd_pcm_sframes_t (*dst_frames)(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t src_frames); + snd_pcm_sframes_t (*client_channels)(snd_pcm_plugin_t *plugin, + snd_pcm_uframes_t frames, + snd_pcm_plugin_channel_t **channels); + int (*src_channels_mask)(snd_pcm_plugin_t *plugin, + bitset_t *dst_vmask, + bitset_t **src_vmask); + int (*dst_channels_mask)(snd_pcm_plugin_t *plugin, + bitset_t *src_vmask, + bitset_t **dst_vmask); + snd_pcm_sframes_t (*transfer)(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, + snd_pcm_uframes_t frames); + int (*action)(snd_pcm_plugin_t *plugin, + snd_pcm_plugin_action_t action, unsigned long data); - struct snd_pcm_plugin *prev; - struct snd_pcm_plugin *next; - struct snd_pcm_substream *plug; + snd_pcm_plugin_t *prev; + snd_pcm_plugin_t *next; + snd_pcm_plug_t *plug; void *private_data; - void (*private_free)(struct snd_pcm_plugin *plugin); + void (*private_free)(snd_pcm_plugin_t *plugin); char *buf; snd_pcm_uframes_t buf_frames; - struct snd_pcm_plugin_channel *buf_channels; - unsigned long *src_vmask; - unsigned long *dst_vmask; + snd_pcm_plugin_channel_t *buf_channels; + bitset_t *src_vmask; + bitset_t *dst_vmask; char extra_data[0]; }; -int snd_pcm_plugin_build(struct snd_pcm_substream *handle, +int snd_pcm_plugin_build(snd_pcm_plug_t *handle, const char *name, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, size_t extra, - struct snd_pcm_plugin **ret); -int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin); -int snd_pcm_plugin_clear(struct snd_pcm_plugin **first); -int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames); -snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *handle, snd_pcm_uframes_t drv_size); -snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *handle, snd_pcm_uframes_t clt_size); + snd_pcm_plugin_t **ret); +int snd_pcm_plugin_free(snd_pcm_plugin_t *plugin); +int snd_pcm_plugin_clear(snd_pcm_plugin_t **first); +int snd_pcm_plug_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t frames); +snd_pcm_sframes_t snd_pcm_plug_client_size(snd_pcm_plug_t *handle, snd_pcm_uframes_t drv_size); +snd_pcm_sframes_t snd_pcm_plug_slave_size(snd_pcm_plug_t *handle, snd_pcm_uframes_t clt_size); #define FULL ROUTE_PLUGIN_RESOLUTION #define HALF ROUTE_PLUGIN_RESOLUTION / 2 - -int snd_pcm_plugin_build_io(struct snd_pcm_substream *handle, - struct snd_pcm_hw_params *params, - struct snd_pcm_plugin **r_plugin); -int snd_pcm_plugin_build_linear(struct snd_pcm_substream *handle, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin); -int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *handle, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin); -int snd_pcm_plugin_build_rate(struct snd_pcm_substream *handle, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin); -int snd_pcm_plugin_build_route(struct snd_pcm_substream *handle, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - int *ttable, - struct snd_pcm_plugin **r_plugin); -int snd_pcm_plugin_build_copy(struct snd_pcm_substream *handle, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin); - -int snd_pcm_plug_format_plugins(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params, - struct snd_pcm_hw_params *slave_params); - -int snd_pcm_plug_slave_format(int format, struct snd_mask *format_mask); - -int snd_pcm_plugin_append(struct snd_pcm_plugin *plugin); - -snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *handle, - struct snd_pcm_plugin_channel *src_channels, - snd_pcm_uframes_t size); -snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *handle, - struct snd_pcm_plugin_channel *dst_channels_final, - snd_pcm_uframes_t size); - -snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *handle, - char *buf, snd_pcm_uframes_t count, - struct snd_pcm_plugin_channel **channels); - -snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin, - snd_pcm_uframes_t frames, - struct snd_pcm_plugin_channel **channels); - -int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_channel, - size_t dst_offset, +typedef int route_ttable_entry_t; + +int snd_pcm_plugin_build_io(snd_pcm_plug_t *handle, + snd_pcm_hw_params_t *params, + snd_pcm_plugin_t **r_plugin); +int snd_pcm_plugin_build_linear(snd_pcm_plug_t *handle, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin); +int snd_pcm_plugin_build_mulaw(snd_pcm_plug_t *handle, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin); +int snd_pcm_plugin_build_rate(snd_pcm_plug_t *handle, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin); +int snd_pcm_plugin_build_route(snd_pcm_plug_t *handle, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + route_ttable_entry_t *ttable, + snd_pcm_plugin_t **r_plugin); +int snd_pcm_plugin_build_copy(snd_pcm_plug_t *handle, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin); + +int snd_pcm_plug_format_plugins(snd_pcm_plug_t *substream, + snd_pcm_hw_params_t *params, + snd_pcm_hw_params_t *slave_params); + +int snd_pcm_plug_slave_format(int format, snd_mask_t *format_mask); + +int snd_pcm_plugin_append(snd_pcm_plugin_t *plugin); + +snd_pcm_sframes_t snd_pcm_plug_write_transfer(snd_pcm_plug_t *handle, snd_pcm_plugin_channel_t *src_channels, snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_plug_read_transfer(snd_pcm_plug_t *handle, snd_pcm_plugin_channel_t *dst_channels_final, snd_pcm_uframes_t size); + +snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(snd_pcm_plug_t *handle, + char *buf, snd_pcm_uframes_t count, + snd_pcm_plugin_channel_t **channels); + +snd_pcm_sframes_t snd_pcm_plugin_client_channels(snd_pcm_plugin_t *plugin, + snd_pcm_uframes_t frames, + snd_pcm_plugin_channel_t **channels); + +int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_channel, size_t dst_offset, size_t samples, int format); -int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_channel, - size_t src_offset, - const struct snd_pcm_channel_area *dst_channel, - size_t dst_offset, +int snd_pcm_area_copy(const snd_pcm_channel_area_t *src_channel, size_t src_offset, + const snd_pcm_channel_area_t *dst_channel, size_t dst_offset, size_t samples, int format); -void *snd_pcm_plug_buf_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t size); -void snd_pcm_plug_buf_unlock(struct snd_pcm_substream *plug, void *ptr); -snd_pcm_sframes_t snd_pcm_oss_write3(struct snd_pcm_substream *substream, - const char *ptr, snd_pcm_uframes_t size, - int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_read3(struct snd_pcm_substream *substream, - char *ptr, snd_pcm_uframes_t size, int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_writev3(struct snd_pcm_substream *substream, - void **bufs, snd_pcm_uframes_t frames, - int in_kernel); -snd_pcm_sframes_t snd_pcm_oss_readv3(struct snd_pcm_substream *substream, - void **bufs, snd_pcm_uframes_t frames, - int in_kernel); +void *snd_pcm_plug_buf_alloc(snd_pcm_plug_t *plug, snd_pcm_uframes_t size); +void snd_pcm_plug_buf_unlock(snd_pcm_plug_t *plug, void *ptr); +snd_pcm_sframes_t snd_pcm_oss_write3(snd_pcm_substream_t *substream, const char *ptr, snd_pcm_uframes_t size, int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_read3(snd_pcm_substream_t *substream, char *ptr, snd_pcm_uframes_t size, int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_writev3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel); +snd_pcm_sframes_t snd_pcm_oss_readv3(snd_pcm_substream_t *substream, void **bufs, snd_pcm_uframes_t frames, int in_kernel); + + #define ROUTE_PLUGIN_RESOLUTION 16 @@ -187,8 +237,8 @@ int getput_index(int format); int copy_index(int format); int conv_index(int src_format, int dst_format); -void zero_channel(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *dst_channel, +void zero_channel(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *dst_channel, size_t samples); #ifdef PLUGIN_DEBUG diff --git a/trunk/sound/core/oss/rate.c b/trunk/sound/core/oss/rate.c index 4854cef6fb4f..1096ec186714 100644 --- a/trunk/sound/core/oss/rate.c +++ b/trunk/sound/core/oss/rate.c @@ -33,29 +33,29 @@ * Basic rate conversion plugin */ -struct rate_channel { +typedef struct { signed short last_S1; signed short last_S2; -}; +} rate_channel_t; -typedef void (*rate_f)(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +typedef void (*rate_f)(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, int src_frames, int dst_frames); -struct rate_priv { +typedef struct rate_private_data { unsigned int pitch; unsigned int pos; rate_f func; int get, put; snd_pcm_sframes_t old_src_frames, old_dst_frames; - struct rate_channel channels[0]; -}; + rate_channel_t channels[0]; +} rate_t; -static void rate_init(struct snd_pcm_plugin *plugin) +static void rate_init(snd_pcm_plugin_t *plugin) { unsigned int channel; - struct rate_priv *data = (struct rate_priv *)plugin->extra_data; + rate_t *data = (rate_t *)plugin->extra_data; data->pos = 0; for (channel = 0; channel < plugin->src_format.channels; channel++) { data->channels[channel].last_S1 = 0; @@ -63,9 +63,9 @@ static void rate_init(struct snd_pcm_plugin *plugin) } } -static void resample_expand(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static void resample_expand(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, int src_frames, int dst_frames) { unsigned int pos = 0; @@ -75,8 +75,8 @@ static void resample_expand(struct snd_pcm_plugin *plugin, unsigned int channel; int src_step, dst_step; int src_frames1, dst_frames1; - struct rate_priv *data = (struct rate_priv *)plugin->extra_data; - struct rate_channel *rchannels = data->channels; + rate_t *data = (rate_t *)plugin->extra_data; + rate_channel_t *rchannels = data->channels; #define GET_S16_LABELS #define PUT_S16_LABELS @@ -139,9 +139,9 @@ static void resample_expand(struct snd_pcm_plugin *plugin, data->pos = pos; } -static void resample_shrink(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static void resample_shrink(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, int src_frames, int dst_frames) { unsigned int pos = 0; @@ -151,8 +151,8 @@ static void resample_shrink(struct snd_pcm_plugin *plugin, unsigned int channel; int src_step, dst_step; int src_frames1, dst_frames1; - struct rate_priv *data = (struct rate_priv *)plugin->extra_data; - struct rate_channel *rchannels = data->channels; + rate_t *data = (rate_t *)plugin->extra_data; + rate_channel_t *rchannels = data->channels; #define GET_S16_LABELS #define PUT_S16_LABELS @@ -216,15 +216,15 @@ static void resample_shrink(struct snd_pcm_plugin *plugin, data->pos = pos; } -static snd_pcm_sframes_t rate_src_frames(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t rate_src_frames(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) { - struct rate_priv *data; + rate_t *data; snd_pcm_sframes_t res; snd_assert(plugin != NULL, return -ENXIO); if (frames == 0) return 0; - data = (struct rate_priv *)plugin->extra_data; + data = (rate_t *)plugin->extra_data; if (plugin->src_format.rate < plugin->dst_format.rate) { res = (((frames * data->pitch) + (BITS/2)) >> SHIFT); } else { @@ -248,15 +248,15 @@ static snd_pcm_sframes_t rate_src_frames(struct snd_pcm_plugin *plugin, snd_pcm_ return res; } -static snd_pcm_sframes_t rate_dst_frames(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) +static snd_pcm_sframes_t rate_dst_frames(snd_pcm_plugin_t *plugin, snd_pcm_uframes_t frames) { - struct rate_priv *data; + rate_t *data; snd_pcm_sframes_t res; snd_assert(plugin != NULL, return -ENXIO); if (frames == 0) return 0; - data = (struct rate_priv *)plugin->extra_data; + data = (rate_t *)plugin->extra_data; if (plugin->src_format.rate < plugin->dst_format.rate) { res = (((frames << SHIFT) + (data->pitch / 2)) / data->pitch); } else { @@ -280,13 +280,13 @@ static snd_pcm_sframes_t rate_dst_frames(struct snd_pcm_plugin *plugin, snd_pcm_ return res; } -static snd_pcm_sframes_t rate_transfer(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static snd_pcm_sframes_t rate_transfer(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { snd_pcm_uframes_t dst_frames; - struct rate_priv *data; + rate_t *data; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) @@ -308,14 +308,14 @@ static snd_pcm_sframes_t rate_transfer(struct snd_pcm_plugin *plugin, dst_frames = rate_dst_frames(plugin, frames); if (dst_frames > dst_channels[0].frames) dst_frames = dst_channels[0].frames; - data = (struct rate_priv *)plugin->extra_data; + data = (rate_t *)plugin->extra_data; data->func(plugin, src_channels, dst_channels, frames, dst_frames); return dst_frames; } -static int rate_action(struct snd_pcm_plugin *plugin, - enum snd_pcm_plugin_action action, - unsigned long udata) +static int rate_action(snd_pcm_plugin_t *plugin, + snd_pcm_plugin_action_t action, + unsigned long udata ATTRIBUTE_UNUSED) { snd_assert(plugin != NULL, return -ENXIO); switch (action) { @@ -329,14 +329,14 @@ static int rate_action(struct snd_pcm_plugin *plugin, return 0; /* silenty ignore other actions */ } -int snd_pcm_plugin_build_rate(struct snd_pcm_substream *plug, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - struct snd_pcm_plugin **r_plugin) +int snd_pcm_plugin_build_rate(snd_pcm_plug_t *plug, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + snd_pcm_plugin_t **r_plugin) { int err; - struct rate_priv *data; - struct snd_pcm_plugin *plugin; + rate_t *data; + snd_pcm_plugin_t *plugin; snd_assert(r_plugin != NULL, return -ENXIO); *r_plugin = NULL; @@ -349,12 +349,11 @@ int snd_pcm_plugin_build_rate(struct snd_pcm_substream *plug, err = snd_pcm_plugin_build(plug, "rate conversion", src_format, dst_format, - sizeof(struct rate_priv) + - src_format->channels * sizeof(struct rate_channel), + sizeof(rate_t) + src_format->channels * sizeof(rate_channel_t), &plugin); if (err < 0) return err; - data = (struct rate_priv *)plugin->extra_data; + data = (rate_t *)plugin->extra_data; data->get = getput_index(src_format->format); snd_assert(data->get >= 0 && data->get < 4*2*2, return -EINVAL); data->put = getput_index(dst_format->format); diff --git a/trunk/sound/core/oss/route.c b/trunk/sound/core/oss/route.c index 726c5caa3fdb..c955b7dfdb30 100644 --- a/trunk/sound/core/oss/route.c +++ b/trunk/sound/core/oss/route.c @@ -35,62 +35,61 @@ #error "Add some code here" #endif -struct ttable_dst; +typedef struct ttable_dst ttable_dst_t; +typedef struct route_private_data route_t; -typedef void (*route_channel_f)(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channel, - struct ttable_dst *ttable, snd_pcm_uframes_t frames); +typedef void (*route_channel_f)(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channel, + ttable_dst_t* ttable, snd_pcm_uframes_t frames); -struct ttable_src { +typedef struct { int channel; int as_int; -}; +} ttable_src_t; struct ttable_dst { int att; /* Attenuated */ unsigned int nsrcs; - struct ttable_src *srcs; + ttable_src_t* srcs; route_channel_f func; }; -struct route_priv { +struct route_private_data { enum {R_UINT32=0, R_UINT64=1} sum_type; int get, put; int conv; int src_sample_size; - struct ttable_dst ttable[0]; + ttable_dst_t ttable[0]; }; -union sum { +typedef union { u_int32_t as_uint32; u_int64_t as_uint64; -}; +} sum_t; -static void route_to_channel_from_zero(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channel, - struct ttable_dst *ttable, - snd_pcm_uframes_t frames) +static void route_to_channel_from_zero(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels ATTRIBUTE_UNUSED, + snd_pcm_plugin_channel_t *dst_channel, + ttable_dst_t* ttable ATTRIBUTE_UNUSED, snd_pcm_uframes_t frames) { if (dst_channel->wanted) snd_pcm_area_silence(&dst_channel->area, 0, frames, plugin->dst_format.format); dst_channel->enabled = 0; } -static void route_to_channel_from_one(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channel, - struct ttable_dst *ttable, - snd_pcm_uframes_t frames) +static void route_to_channel_from_one(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channel, + ttable_dst_t* ttable, snd_pcm_uframes_t frames) { #define CONV_LABELS #include "plugin_ops.h" #undef CONV_LABELS - struct route_priv *data = (struct route_priv *)plugin->extra_data; + route_t *data = (route_t *)plugin->extra_data; void *conv; - const struct snd_pcm_plugin_channel *src_channel = NULL; + const snd_pcm_plugin_channel_t *src_channel = NULL; unsigned int srcidx; char *src, *dst; int src_step, dst_step; @@ -121,10 +120,10 @@ static void route_to_channel_from_one(struct snd_pcm_plugin *plugin, } } -static void route_to_channel(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channel, - struct ttable_dst *ttable, snd_pcm_uframes_t frames) +static void route_to_channel(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channel, + ttable_dst_t* ttable, snd_pcm_uframes_t frames) { #define GET_U_LABELS #define PUT_U32_LABELS @@ -154,18 +153,18 @@ static void route_to_channel(struct snd_pcm_plugin *plugin, &&norm_int64_16_att, &&norm_int64_24_att, }; - struct route_priv *data = (struct route_priv *)plugin->extra_data; + route_t *data = (route_t *)plugin->extra_data; void *zero, *get, *add, *norm, *put_u32; int nsrcs = ttable->nsrcs; char *dst; int dst_step; char *srcs[nsrcs]; int src_steps[nsrcs]; - struct ttable_src src_tt[nsrcs]; + ttable_src_t src_tt[nsrcs]; u_int32_t sample = 0; int srcidx, srcidx1 = 0; for (srcidx = 0; srcidx < nsrcs; ++srcidx) { - const struct snd_pcm_plugin_channel *src_channel = &src_channels[ttable->srcs[srcidx].channel]; + const snd_pcm_plugin_channel_t *src_channel = &src_channels[ttable->srcs[srcidx].channel]; if (!src_channel->enabled) continue; srcs[srcidx1] = src_channel->area.addr + src_channel->area.first / 8; @@ -192,8 +191,8 @@ static void route_to_channel(struct snd_pcm_plugin *plugin, dst_step = dst_channel->area.step / 8; while (frames-- > 0) { - struct ttable_src *ttp = src_tt; - union sum sum; + ttable_src_t *ttp = src_tt; + sum_t sum; /* Zero sum */ goto *zero; @@ -298,47 +297,47 @@ static void route_to_channel(struct snd_pcm_plugin *plugin, } } -static int route_src_channels_mask(struct snd_pcm_plugin *plugin, - unsigned long *dst_vmask, - unsigned long **src_vmask) +static int route_src_channels_mask(snd_pcm_plugin_t *plugin, + bitset_t *dst_vmask, + bitset_t **src_vmask) { - struct route_priv *data = (struct route_priv *)plugin->extra_data; + route_t *data = (route_t *)plugin->extra_data; int schannels = plugin->src_format.channels; int dchannels = plugin->dst_format.channels; - unsigned long *vmask = plugin->src_vmask; + bitset_t *vmask = plugin->src_vmask; int channel; - struct ttable_dst *dp = data->ttable; - bitmap_zero(vmask, schannels); + ttable_dst_t *dp = data->ttable; + bitset_zero(vmask, schannels); for (channel = 0; channel < dchannels; channel++, dp++) { unsigned int src; - struct ttable_src *sp; - if (!test_bit(channel, dst_vmask)) + ttable_src_t *sp; + if (!bitset_get(dst_vmask, channel)) continue; sp = dp->srcs; for (src = 0; src < dp->nsrcs; src++, sp++) - set_bit(sp->channel, vmask); + bitset_set(vmask, sp->channel); } *src_vmask = vmask; return 0; } -static int route_dst_channels_mask(struct snd_pcm_plugin *plugin, - unsigned long *src_vmask, - unsigned long **dst_vmask) +static int route_dst_channels_mask(snd_pcm_plugin_t *plugin, + bitset_t *src_vmask, + bitset_t **dst_vmask) { - struct route_priv *data = (struct route_priv *)plugin->extra_data; + route_t *data = (route_t *)plugin->extra_data; int dchannels = plugin->dst_format.channels; - unsigned long *vmask = plugin->dst_vmask; + bitset_t *vmask = plugin->dst_vmask; int channel; - struct ttable_dst *dp = data->ttable; - bitmap_zero(vmask, dchannels); + ttable_dst_t *dp = data->ttable; + bitset_zero(vmask, dchannels); for (channel = 0; channel < dchannels; channel++, dp++) { unsigned int src; - struct ttable_src *sp; + ttable_src_t *sp; sp = dp->srcs; for (src = 0; src < dp->nsrcs; src++, sp++) { - if (test_bit(sp->channel, src_vmask)) { - set_bit(channel, vmask); + if (bitset_get(src_vmask, sp->channel)) { + bitset_set(vmask, channel); break; } } @@ -347,33 +346,33 @@ static int route_dst_channels_mask(struct snd_pcm_plugin *plugin, return 0; } -static void route_free(struct snd_pcm_plugin *plugin) +static void route_free(snd_pcm_plugin_t *plugin) { - struct route_priv *data = (struct route_priv *)plugin->extra_data; + route_t *data = (route_t *)plugin->extra_data; unsigned int dst_channel; for (dst_channel = 0; dst_channel < plugin->dst_format.channels; ++dst_channel) { kfree(data->ttable[dst_channel].srcs); } } -static int route_load_ttable(struct snd_pcm_plugin *plugin, - const int *src_ttable) +static int route_load_ttable(snd_pcm_plugin_t *plugin, + const route_ttable_entry_t* src_ttable) { - struct route_priv *data; + route_t *data; unsigned int src_channel, dst_channel; - const int *sptr; - struct ttable_dst *dptr; + const route_ttable_entry_t *sptr; + ttable_dst_t *dptr; if (src_ttable == NULL) return 0; - data = (struct route_priv *)plugin->extra_data; + data = (route_t *)plugin->extra_data; dptr = data->ttable; sptr = src_ttable; plugin->private_free = route_free; for (dst_channel = 0; dst_channel < plugin->dst_format.channels; ++dst_channel) { - int t = 0; + route_ttable_entry_t t = 0; int att = 0; int nsrcs = 0; - struct ttable_src srcs[plugin->src_format.channels]; + ttable_src_t srcs[plugin->src_format.channels]; for (src_channel = 0; src_channel < plugin->src_format.channels; ++src_channel) { snd_assert(*sptr >= 0 || *sptr <= FULL, return -ENXIO); if (*sptr != 0) { @@ -406,21 +405,21 @@ static int route_load_ttable(struct snd_pcm_plugin *plugin, return 0; } -static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin, - const struct snd_pcm_plugin_channel *src_channels, - struct snd_pcm_plugin_channel *dst_channels, +static snd_pcm_sframes_t route_transfer(snd_pcm_plugin_t *plugin, + const snd_pcm_plugin_channel_t *src_channels, + snd_pcm_plugin_channel_t *dst_channels, snd_pcm_uframes_t frames) { - struct route_priv *data; + route_t *data; int src_nchannels, dst_nchannels; int dst_channel; - struct ttable_dst *ttp; - struct snd_pcm_plugin_channel *dvp; + ttable_dst_t *ttp; + snd_pcm_plugin_channel_t *dvp; snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); if (frames == 0) return 0; - data = (struct route_priv *)plugin->extra_data; + data = (route_t *)plugin->extra_data; src_nchannels = plugin->src_format.channels; dst_nchannels = plugin->dst_format.channels; @@ -470,14 +469,14 @@ int getput_index(int format) return width * 4 + endian * 2 + sign; } -int snd_pcm_plugin_build_route(struct snd_pcm_substream *plug, - struct snd_pcm_plugin_format *src_format, - struct snd_pcm_plugin_format *dst_format, - int *ttable, - struct snd_pcm_plugin **r_plugin) +int snd_pcm_plugin_build_route(snd_pcm_plug_t *plug, + snd_pcm_plugin_format_t *src_format, + snd_pcm_plugin_format_t *dst_format, + route_ttable_entry_t *ttable, + snd_pcm_plugin_t **r_plugin) { - struct route_priv *data; - struct snd_pcm_plugin *plugin; + route_t *data; + snd_pcm_plugin_t *plugin; int err; snd_assert(r_plugin != NULL, return -ENXIO); @@ -489,13 +488,12 @@ int snd_pcm_plugin_build_route(struct snd_pcm_substream *plug, err = snd_pcm_plugin_build(plug, "attenuated route conversion", src_format, dst_format, - sizeof(struct route_priv) + - sizeof(data->ttable[0]) * dst_format->channels, + sizeof(route_t) + sizeof(data->ttable[0]) * dst_format->channels, &plugin); if (err < 0) return err; - data = (struct route_priv *)plugin->extra_data; + data = (route_t *) plugin->extra_data; data->get = getput_index(src_format->format); snd_assert(data->get >= 0 && data->get < 4*2*2, return -EINVAL); diff --git a/trunk/sound/core/pcm.c b/trunk/sound/core/pcm.c index 28ca61eb0b0d..184e74b75ba9 100644 --- a/trunk/sound/core/pcm.c +++ b/trunk/sound/core/pcm.c @@ -33,33 +33,23 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Abramo Bagnara <abramo@alsa-proj MODULE_DESCRIPTION("Midlevel PCM code for ALSA."); MODULE_LICENSE("GPL"); -static LIST_HEAD(snd_pcm_devices); +snd_pcm_t *snd_pcm_devices[SNDRV_CARDS * SNDRV_PCM_DEVICES]; static LIST_HEAD(snd_pcm_notify_list); static DECLARE_MUTEX(register_mutex); -static int snd_pcm_free(struct snd_pcm *pcm); -static int snd_pcm_dev_free(struct snd_device *device); -static int snd_pcm_dev_register(struct snd_device *device); -static int snd_pcm_dev_disconnect(struct snd_device *device); -static int snd_pcm_dev_unregister(struct snd_device *device); +static int snd_pcm_free(snd_pcm_t *pcm); +static int snd_pcm_dev_free(snd_device_t *device); +static int snd_pcm_dev_register(snd_device_t *device); +static int snd_pcm_dev_disconnect(snd_device_t *device); +static int snd_pcm_dev_unregister(snd_device_t *device); -static struct snd_pcm *snd_pcm_search(struct snd_card *card, int device) -{ - struct list_head *p; - struct snd_pcm *pcm; - - list_for_each(p, &snd_pcm_devices) { - pcm = list_entry(p, struct snd_pcm, list); - if (pcm->card == card && pcm->device == device) - return pcm; - } - return NULL; -} - -static int snd_pcm_control_ioctl(struct snd_card *card, - struct snd_ctl_file *control, +static int snd_pcm_control_ioctl(snd_card_t * card, + snd_ctl_file_t * control, unsigned int cmd, unsigned long arg) { + unsigned int tmp; + + tmp = card->number * SNDRV_PCM_DEVICES; switch (cmd) { case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE: { @@ -67,66 +57,51 @@ static int snd_pcm_control_ioctl(struct snd_card *card, if (get_user(device, (int __user *)arg)) return -EFAULT; - down(®ister_mutex); device = device < 0 ? 0 : device + 1; while (device < SNDRV_PCM_DEVICES) { - if (snd_pcm_search(card, device)) + if (snd_pcm_devices[tmp + device]) break; device++; } if (device == SNDRV_PCM_DEVICES) device = -1; - up(®ister_mutex); if (put_user(device, (int __user *)arg)) return -EFAULT; return 0; } case SNDRV_CTL_IOCTL_PCM_INFO: { - struct snd_pcm_info __user *info; + snd_pcm_info_t __user *info; unsigned int device, subdevice; - int stream; - struct snd_pcm *pcm; - struct snd_pcm_str *pstr; - struct snd_pcm_substream *substream; - int err; - - info = (struct snd_pcm_info __user *)arg; + snd_pcm_stream_t stream; + snd_pcm_t *pcm; + snd_pcm_str_t *pstr; + snd_pcm_substream_t *substream; + info = (snd_pcm_info_t __user *)arg; if (get_user(device, &info->device)) return -EFAULT; + if (device >= SNDRV_PCM_DEVICES) + return -ENXIO; + pcm = snd_pcm_devices[tmp + device]; + if (pcm == NULL) + return -ENXIO; if (get_user(stream, &info->stream)) return -EFAULT; if (stream < 0 || stream > 1) return -EINVAL; + pstr = &pcm->streams[stream]; + if (pstr->substream_count == 0) + return -ENOENT; if (get_user(subdevice, &info->subdevice)) return -EFAULT; - down(®ister_mutex); - pcm = snd_pcm_search(card, device); - if (pcm == NULL) { - err = -ENXIO; - goto _error; - } - pstr = &pcm->streams[stream]; - if (pstr->substream_count == 0) { - err = -ENOENT; - goto _error; - } - if (subdevice >= pstr->substream_count) { - err = -ENXIO; - goto _error; - } - for (substream = pstr->substream; substream; - substream = substream->next) + if (subdevice >= pstr->substream_count) + return -ENXIO; + for (substream = pstr->substream; substream; substream = substream->next) if (substream->number == (int)subdevice) break; - if (substream == NULL) { - err = -ENXIO; - goto _error; - } - err = snd_pcm_info_user(substream, info); - _error: - up(®ister_mutex); - return err; + if (substream == NULL) + return -ENXIO; + return snd_pcm_info_user(substream, info); } case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE: { @@ -151,6 +126,30 @@ static int snd_pcm_control_ioctl(struct snd_card *card, #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v +static char *snd_pcm_stream_names[] = { + STREAM(PLAYBACK), + STREAM(CAPTURE), +}; + +static char *snd_pcm_state_names[] = { + STATE(OPEN), + STATE(SETUP), + STATE(PREPARED), + STATE(RUNNING), + STATE(XRUN), + STATE(DRAINING), + STATE(PAUSED), + STATE(SUSPENDED), +}; + +static char *snd_pcm_access_names[] = { + ACCESS(MMAP_INTERLEAVED), + ACCESS(MMAP_NONINTERLEAVED), + ACCESS(MMAP_COMPLEX), + ACCESS(RW_INTERLEAVED), + ACCESS(RW_NONINTERLEAVED), +}; + static char *snd_pcm_format_names[] = { FORMAT(S8), FORMAT(U8), @@ -192,36 +191,6 @@ static char *snd_pcm_format_names[] = { FORMAT(U18_3BE), }; -const char *snd_pcm_format_name(snd_pcm_format_t format) -{ - return snd_pcm_format_names[format]; -} - -#ifdef CONFIG_PROC_FS -static char *snd_pcm_stream_names[] = { - STREAM(PLAYBACK), - STREAM(CAPTURE), -}; - -static char *snd_pcm_state_names[] = { - STATE(OPEN), - STATE(SETUP), - STATE(PREPARED), - STATE(RUNNING), - STATE(XRUN), - STATE(DRAINING), - STATE(PAUSED), - STATE(SUSPENDED), -}; - -static char *snd_pcm_access_names[] = { - ACCESS(MMAP_INTERLEAVED), - ACCESS(MMAP_NONINTERLEAVED), - ACCESS(MMAP_COMPLEX), - ACCESS(RW_INTERLEAVED), - ACCESS(RW_NONINTERLEAVED), -}; - static char *snd_pcm_subformat_names[] = { SUBFORMAT(STD), }; @@ -231,7 +200,7 @@ static char *snd_pcm_tstamp_mode_names[] = { TSTAMP(MMAP), }; -static const char *snd_pcm_stream_name(int stream) +static const char *snd_pcm_stream_name(snd_pcm_stream_t stream) { snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL); return snd_pcm_stream_names[stream]; @@ -239,15 +208,23 @@ static const char *snd_pcm_stream_name(int stream) static const char *snd_pcm_access_name(snd_pcm_access_t access) { + snd_assert(access <= SNDRV_PCM_ACCESS_LAST, return NULL); return snd_pcm_access_names[access]; } +const char *snd_pcm_format_name(snd_pcm_format_t format) +{ + snd_assert(format <= SNDRV_PCM_FORMAT_LAST, return NULL); + return snd_pcm_format_names[format]; +} + static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat) { + snd_assert(subformat <= SNDRV_PCM_SUBFORMAT_LAST, return NULL); return snd_pcm_subformat_names[subformat]; } -static const char *snd_pcm_tstamp_mode_name(int mode) +static const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode) { snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL); return snd_pcm_tstamp_mode_names[mode]; @@ -255,6 +232,7 @@ static const char *snd_pcm_tstamp_mode_name(int mode) static const char *snd_pcm_state_name(snd_pcm_state_t state) { + snd_assert(state <= SNDRV_PCM_STATE_LAST, return NULL); return snd_pcm_state_names[state]; } @@ -289,10 +267,10 @@ static const char *snd_pcm_oss_format_name(int format) } #endif -static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream, - struct snd_info_buffer *buffer) +#ifdef CONFIG_PROC_FS +static void snd_pcm_proc_info_read(snd_pcm_substream_t *substream, snd_info_buffer_t *buffer) { - struct snd_pcm_info *info; + snd_pcm_info_t *info; int err; if (! substream) @@ -324,25 +302,20 @@ static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream, kfree(info); } -static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_stream_proc_info_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream, - buffer); + snd_pcm_proc_info_read(((snd_pcm_str_t *)entry->private_data)->substream, buffer); } -static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_substream_proc_info_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data, - buffer); + snd_pcm_proc_info_read((snd_pcm_substream_t *)entry->private_data, buffer); } -static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_substream_proc_hw_params_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_pcm_substream *substream = entry->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); return; @@ -374,11 +347,10 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry, snd_pcm_stream_unlock_irq(substream); } -static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_substream_proc_sw_params_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_pcm_substream *substream = entry->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); return; @@ -402,12 +374,11 @@ static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry, snd_pcm_stream_unlock_irq(substream); } -static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_substream_proc_status_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_pcm_substream *substream = entry->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_pcm_status status; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_pcm_status_t status; int err; if (!runtime) { snd_iprintf(buffer, "closed\n"); @@ -431,29 +402,28 @@ static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry, snd_iprintf(buffer, "hw_ptr : %ld\n", runtime->status->hw_ptr); snd_iprintf(buffer, "appl_ptr : %ld\n", runtime->control->appl_ptr); } +#endif #ifdef CONFIG_SND_DEBUG -static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_xrun_debug_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_pcm_str *pstr = entry->private_data; + snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; snd_iprintf(buffer, "%d\n", pstr->xrun_debug); } -static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_xrun_debug_write(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_pcm_str *pstr = entry->private_data; + snd_pcm_str_t *pstr = (snd_pcm_str_t *)entry->private_data; char line[64]; if (!snd_info_get_line(buffer, line, sizeof(line))) pstr->xrun_debug = simple_strtoul(line, NULL, 10); } #endif -static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) +static int snd_pcm_stream_proc_init(snd_pcm_str_t *pstr) { - struct snd_pcm *pcm = pstr->pcm; - struct snd_info_entry *entry; + snd_pcm_t *pcm = pstr->pcm; + snd_info_entry_t *entry; char name[16]; sprintf(name, "pcm%i%c", pcm->device, @@ -477,8 +447,7 @@ static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) pstr->proc_info_entry = entry; #ifdef CONFIG_SND_DEBUG - if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug", - pstr->proc_root)) != NULL) { + if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug", pstr->proc_root)) != NULL) { entry->c.text.read_size = 64; entry->c.text.read = snd_pcm_xrun_debug_read; entry->c.text.write_size = 64; @@ -495,7 +464,7 @@ static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) return 0; } -static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) +static int snd_pcm_stream_proc_done(snd_pcm_str_t *pstr) { #ifdef CONFIG_SND_DEBUG if (pstr->proc_xrun_debug_entry) { @@ -514,10 +483,10 @@ static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) return 0; } -static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) +static int snd_pcm_substream_proc_init(snd_pcm_substream_t *substream) { - struct snd_info_entry *entry; - struct snd_card *card; + snd_info_entry_t *entry; + snd_card_t *card; char name[16]; card = substream->pcm->card; @@ -571,7 +540,7 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) return 0; } -static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) +static int snd_pcm_substream_proc_done(snd_pcm_substream_t *substream) { if (substream->proc_info_entry) { snd_info_unregister(substream->proc_info_entry); @@ -595,12 +564,6 @@ static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) } return 0; } -#else /* !CONFIG_PROC_FS */ -static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; } -static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; } -static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; } -static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; } -#endif /* CONFIG_PROC_FS */ /** * snd_pcm_new_stream - create a new PCM stream @@ -615,11 +578,11 @@ static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substrea * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) +int snd_pcm_new_stream(snd_pcm_t *pcm, int stream, int substream_count) { int idx, err; - struct snd_pcm_str *pstr = &pcm->streams[stream]; - struct snd_pcm_substream *substream, *prev; + snd_pcm_str_t *pstr = &pcm->streams[stream]; + snd_pcm_substream_t *substream, *prev; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) init_MUTEX(&pstr->oss.setup_mutex); @@ -627,20 +590,17 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) pstr->stream = stream; pstr->pcm = pcm; pstr->substream_count = substream_count; + pstr->reg = &snd_pcm_reg[stream]; if (substream_count > 0) { err = snd_pcm_stream_proc_init(pstr); - if (err < 0) { - snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n"); + if (err < 0) return err; - } } prev = NULL; for (idx = 0, prev = NULL; idx < substream_count; idx++) { substream = kzalloc(sizeof(*substream), GFP_KERNEL); - if (substream == NULL) { - snd_printk(KERN_ERR "Cannot allocate PCM substream\n"); + if (substream == NULL) return -ENOMEM; - } substream->pcm = pcm; substream->pstr = pstr; substream->number = idx; @@ -653,7 +613,6 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) prev->next = substream; err = snd_pcm_substream_proc_init(substream); if (err < 0) { - snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n"); kfree(substream); return err; } @@ -683,13 +642,13 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_new(struct snd_card *card, char *id, int device, +int snd_pcm_new(snd_card_t * card, char *id, int device, int playback_count, int capture_count, - struct snd_pcm ** rpcm) + snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_pcm_dev_free, .dev_register = snd_pcm_dev_register, .dev_disconnect = snd_pcm_dev_disconnect, @@ -700,14 +659,13 @@ int snd_pcm_new(struct snd_card *card, char *id, int device, *rpcm = NULL; snd_assert(card != NULL, return -ENXIO); pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); - if (pcm == NULL) { - snd_printk(KERN_ERR "Cannot allocate PCM\n"); + if (pcm == NULL) return -ENOMEM; - } pcm->card = card; pcm->device = device; - if (id) + if (id) { strlcpy(pcm->id, id, sizeof(pcm->id)); + } if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) { snd_pcm_free(pcm); return err; @@ -726,11 +684,11 @@ int snd_pcm_new(struct snd_card *card, char *id, int device, return 0; } -static void snd_pcm_free_stream(struct snd_pcm_str * pstr) +static void snd_pcm_free_stream(snd_pcm_str_t * pstr) { - struct snd_pcm_substream *substream, *substream_next; + snd_pcm_substream_t *substream, *substream_next; #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) - struct snd_pcm_oss_setup *setup, *setupn; + snd_pcm_oss_setup_t *setup, *setupn; #endif substream = pstr->substream; while (substream) { @@ -749,7 +707,7 @@ static void snd_pcm_free_stream(struct snd_pcm_str * pstr) #endif } -static int snd_pcm_free(struct snd_pcm *pcm) +static int snd_pcm_free(snd_pcm_t *pcm) { snd_assert(pcm != NULL, return -ENXIO); if (pcm->private_free) @@ -761,26 +719,26 @@ static int snd_pcm_free(struct snd_pcm *pcm) return 0; } -static int snd_pcm_dev_free(struct snd_device *device) +static int snd_pcm_dev_free(snd_device_t *device) { - struct snd_pcm *pcm = device->device_data; + snd_pcm_t *pcm = device->device_data; return snd_pcm_free(pcm); } static void snd_pcm_tick_timer_func(unsigned long data) { - struct snd_pcm_substream *substream = (struct snd_pcm_substream *) data; + snd_pcm_substream_t *substream = (snd_pcm_substream_t*) data; snd_pcm_tick_elapsed(substream); } -int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, - struct snd_pcm_substream **rsubstream) +int snd_pcm_open_substream(snd_pcm_t *pcm, int stream, + snd_pcm_substream_t **rsubstream) { - struct snd_pcm_str * pstr; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; - struct snd_ctl_file *kctl; - struct snd_card *card; + snd_pcm_str_t * pstr; + snd_pcm_substream_t * substream; + snd_pcm_runtime_t * runtime; + snd_ctl_file_t *kctl; + snd_card_t *card; struct list_head *list; int prefer_subdevice = -1; size_t size; @@ -842,7 +800,7 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, if (runtime == NULL) return -ENOMEM; - size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)); + size = PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t)); runtime->status = snd_malloc_pages(size, GFP_KERNEL); if (runtime->status == NULL) { kfree(runtime); @@ -850,11 +808,10 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, } memset((void*)runtime->status, 0, size); - size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)); + size = PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t)); runtime->control = snd_malloc_pages(size, GFP_KERNEL); if (runtime->control == NULL) { - snd_free_pages((void*)runtime->status, - PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); + snd_free_pages((void*)runtime->status, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))); kfree(runtime); return -ENOMEM; } @@ -875,39 +832,39 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream, return 0; } -void snd_pcm_release_substream(struct snd_pcm_substream *substream) +void snd_pcm_release_substream(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t * runtime; substream->file = NULL; runtime = substream->runtime; snd_assert(runtime != NULL, return); if (runtime->private_free != NULL) runtime->private_free(runtime); - snd_free_pages((void*)runtime->status, - PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))); - snd_free_pages((void*)runtime->control, - PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))); + snd_free_pages((void*)runtime->status, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))); + snd_free_pages((void*)runtime->control, PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t))); kfree(runtime->hw_constraints.rules); kfree(runtime); substream->runtime = NULL; substream->pstr->substream_opened--; } -static int snd_pcm_dev_register(struct snd_device *device) +static int snd_pcm_dev_register(snd_device_t *device) { - int cidx, err; - struct snd_pcm_substream *substream; + int idx, cidx, err; + unsigned short minor; + snd_pcm_substream_t *substream; struct list_head *list; char str[16]; - struct snd_pcm *pcm = device->device_data; + snd_pcm_t *pcm = device->device_data; snd_assert(pcm != NULL && device != NULL, return -ENXIO); down(®ister_mutex); - if (snd_pcm_search(pcm->card, pcm->device)) { + idx = (pcm->card->number * SNDRV_PCM_DEVICES) + pcm->device; + if (snd_pcm_devices[idx]) { up(®ister_mutex); return -EBUSY; } - list_add_tail(&pcm->list, &snd_pcm_devices); + snd_pcm_devices[idx] = pcm; for (cidx = 0; cidx < 2; cidx++) { int devtype = -1; if (pcm->streams[cidx].substream == NULL) @@ -915,19 +872,17 @@ static int snd_pcm_dev_register(struct snd_device *device) switch (cidx) { case SNDRV_PCM_STREAM_PLAYBACK: sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device); + minor = SNDRV_MINOR_PCM_PLAYBACK + idx; devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK; break; case SNDRV_PCM_STREAM_CAPTURE: sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device); + minor = SNDRV_MINOR_PCM_CAPTURE + idx; devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE; break; } - if ((err = snd_register_device(devtype, pcm->card, - pcm->device, - &snd_pcm_f_ops[cidx], - pcm, str)) < 0) - { - list_del(&pcm->list); + if ((err = snd_register_device(devtype, pcm->card, pcm->device, pcm->streams[cidx].reg, str)) < 0) { + snd_pcm_devices[idx] = NULL; up(®ister_mutex); return err; } @@ -935,46 +890,48 @@ static int snd_pcm_dev_register(struct snd_device *device) snd_pcm_timer_init(substream); } list_for_each(list, &snd_pcm_notify_list) { - struct snd_pcm_notify *notify; - notify = list_entry(list, struct snd_pcm_notify, list); + snd_pcm_notify_t *notify; + notify = list_entry(list, snd_pcm_notify_t, list); notify->n_register(pcm); } up(®ister_mutex); return 0; } -static int snd_pcm_dev_disconnect(struct snd_device *device) +static int snd_pcm_dev_disconnect(snd_device_t *device) { - struct snd_pcm *pcm = device->device_data; + snd_pcm_t *pcm = device->device_data; struct list_head *list; - struct snd_pcm_substream *substream; - int cidx; + snd_pcm_substream_t *substream; + int idx, cidx; down(®ister_mutex); - list_del_init(&pcm->list); + idx = (pcm->card->number * SNDRV_PCM_DEVICES) + pcm->device; + snd_pcm_devices[idx] = NULL; for (cidx = 0; cidx < 2; cidx++) for (substream = pcm->streams[cidx].substream; substream; substream = substream->next) if (substream->runtime) substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED; list_for_each(list, &snd_pcm_notify_list) { - struct snd_pcm_notify *notify; - notify = list_entry(list, struct snd_pcm_notify, list); + snd_pcm_notify_t *notify; + notify = list_entry(list, snd_pcm_notify_t, list); notify->n_disconnect(pcm); } up(®ister_mutex); return 0; } -static int snd_pcm_dev_unregister(struct snd_device *device) +static int snd_pcm_dev_unregister(snd_device_t *device) { - int cidx, devtype; - struct snd_pcm_substream *substream; + int idx, cidx, devtype; + snd_pcm_substream_t *substream; struct list_head *list; - struct snd_pcm *pcm = device->device_data; + snd_pcm_t *pcm = device->device_data; snd_assert(pcm != NULL, return -ENXIO); down(®ister_mutex); - list_del(&pcm->list); + idx = (pcm->card->number * SNDRV_PCM_DEVICES) + pcm->device; + snd_pcm_devices[idx] = NULL; for (cidx = 0; cidx < 2; cidx++) { devtype = -1; switch (cidx) { @@ -990,99 +947,84 @@ static int snd_pcm_dev_unregister(struct snd_device *device) snd_pcm_timer_done(substream); } list_for_each(list, &snd_pcm_notify_list) { - struct snd_pcm_notify *notify; - notify = list_entry(list, struct snd_pcm_notify, list); + snd_pcm_notify_t *notify; + notify = list_entry(list, snd_pcm_notify_t, list); notify->n_unregister(pcm); } up(®ister_mutex); return snd_pcm_free(pcm); } -int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree) +int snd_pcm_notify(snd_pcm_notify_t *notify, int nfree) { - struct list_head *p; + int idx; snd_assert(notify != NULL && notify->n_register != NULL && notify->n_unregister != NULL, return -EINVAL); down(®ister_mutex); if (nfree) { list_del(¬ify->list); - list_for_each(p, &snd_pcm_devices) - notify->n_unregister(list_entry(p, - struct snd_pcm, list)); + for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) { + if (snd_pcm_devices[idx] == NULL) + continue; + notify->n_unregister(snd_pcm_devices[idx]); + } } else { list_add_tail(¬ify->list, &snd_pcm_notify_list); - list_for_each(p, &snd_pcm_devices) - notify->n_register(list_entry(p, struct snd_pcm, list)); + for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) { + if (snd_pcm_devices[idx] == NULL) + continue; + notify->n_register(snd_pcm_devices[idx]); + } } up(®ister_mutex); return 0; } -#ifdef CONFIG_PROC_FS /* * Info interface */ -static void snd_pcm_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct list_head *p; - struct snd_pcm *pcm; + int idx; + snd_pcm_t *pcm; down(®ister_mutex); - list_for_each(p, &snd_pcm_devices) { - pcm = list_entry(p, struct snd_pcm, list); - snd_iprintf(buffer, "%02i-%02i: %s : %s", - pcm->card->number, pcm->device, pcm->id, pcm->name); + for (idx = 0; idx < SNDRV_CARDS * SNDRV_PCM_DEVICES; idx++) { + pcm = snd_pcm_devices[idx]; + if (pcm == NULL) + continue; + snd_iprintf(buffer, "%02i-%02i: %s : %s", idx / SNDRV_PCM_DEVICES, + idx % SNDRV_PCM_DEVICES, pcm->id, pcm->name); if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) - snd_iprintf(buffer, " : playback %i", - pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); + snd_iprintf(buffer, " : playback %i", pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count); if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) - snd_iprintf(buffer, " : capture %i", - pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); + snd_iprintf(buffer, " : capture %i", pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count); snd_iprintf(buffer, "\n"); } up(®ister_mutex); } -static struct snd_info_entry *snd_pcm_proc_entry = NULL; +/* + * ENTRY functions + */ + +static snd_info_entry_t *snd_pcm_proc_entry = NULL; -static void snd_pcm_proc_init(void) +static int __init alsa_pcm_init(void) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; + snd_ctl_register_ioctl(snd_pcm_control_ioctl); + snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) { - snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128, - snd_pcm_proc_read); + snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128, snd_pcm_proc_read); if (snd_info_register(entry) < 0) { snd_info_free_entry(entry); entry = NULL; } } snd_pcm_proc_entry = entry; -} - -static void snd_pcm_proc_done(void) -{ - if (snd_pcm_proc_entry) - snd_info_unregister(snd_pcm_proc_entry); -} - -#else /* !CONFIG_PROC_FS */ -#define snd_pcm_proc_init() -#define snd_pcm_proc_done() -#endif /* CONFIG_PROC_FS */ - - -/* - * ENTRY functions - */ - -static int __init alsa_pcm_init(void) -{ - snd_ctl_register_ioctl(snd_pcm_control_ioctl); - snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl); - snd_pcm_proc_init(); return 0; } @@ -1090,12 +1032,16 @@ static void __exit alsa_pcm_exit(void) { snd_ctl_unregister_ioctl(snd_pcm_control_ioctl); snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl); - snd_pcm_proc_done(); + if (snd_pcm_proc_entry) { + snd_info_unregister(snd_pcm_proc_entry); + snd_pcm_proc_entry = NULL; + } } module_init(alsa_pcm_init) module_exit(alsa_pcm_exit) +EXPORT_SYMBOL(snd_pcm_devices); EXPORT_SYMBOL(snd_pcm_new); EXPORT_SYMBOL(snd_pcm_new_stream); EXPORT_SYMBOL(snd_pcm_notify); diff --git a/trunk/sound/core/pcm_compat.c b/trunk/sound/core/pcm_compat.c index e5133033de5e..4b6307df846d 100644 --- a/trunk/sound/core/pcm_compat.c +++ b/trunk/sound/core/pcm_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream, +static int snd_pcm_ioctl_delay_compat(snd_pcm_substream_t *substream, s32 __user *src) { snd_pcm_sframes_t delay; @@ -39,7 +39,7 @@ static int snd_pcm_ioctl_delay_compat(struct snd_pcm_substream *substream, return err; } -static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream, +static int snd_pcm_ioctl_rewind_compat(snd_pcm_substream_t *substream, u32 __user *src) { snd_pcm_uframes_t frames; @@ -56,7 +56,7 @@ static int snd_pcm_ioctl_rewind_compat(struct snd_pcm_substream *substream, return err < 0 ? err : 0; } -static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream, +static int snd_pcm_ioctl_forward_compat(snd_pcm_substream_t *substream, u32 __user *src) { snd_pcm_uframes_t frames; @@ -73,12 +73,12 @@ static int snd_pcm_ioctl_forward_compat(struct snd_pcm_substream *substream, return err < 0 ? err : 0; } -struct snd_pcm_hw_params32 { +struct sndrv_pcm_hw_params32 { u32 flags; - struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */ - struct snd_mask mres[5]; /* reserved masks */ - struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; - struct snd_interval ires[9]; /* reserved intervals */ + struct sndrv_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; /* this must be identical */ + struct sndrv_mask mres[5]; /* reserved masks */ + struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; + struct sndrv_interval ires[9]; /* reserved intervals */ u32 rmask; u32 cmask; u32 info; @@ -89,7 +89,7 @@ struct snd_pcm_hw_params32 { unsigned char reserved[64]; }; -struct snd_pcm_sw_params32 { +struct sndrv_pcm_sw_params32 { s32 tstamp_mode; u32 period_step; u32 sleep_min; @@ -104,7 +104,7 @@ struct snd_pcm_sw_params32 { }; /* recalcuate the boundary within 32bit */ -static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime) +static snd_pcm_uframes_t recalculate_boundary(snd_pcm_runtime_t *runtime) { snd_pcm_uframes_t boundary; @@ -116,10 +116,10 @@ static snd_pcm_uframes_t recalculate_boundary(struct snd_pcm_runtime *runtime) return boundary; } -static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream, - struct snd_pcm_sw_params32 __user *src) +static int snd_pcm_ioctl_sw_params_compat(snd_pcm_substream_t *substream, + struct sndrv_pcm_sw_params32 __user *src) { - struct snd_pcm_sw_params params; + snd_pcm_sw_params_t params; snd_pcm_uframes_t boundary; int err; @@ -149,17 +149,17 @@ static int snd_pcm_ioctl_sw_params_compat(struct snd_pcm_substream *substream, return err; } -struct snd_pcm_channel_info32 { +struct sndrv_pcm_channel_info32 { u32 channel; u32 offset; u32 first; u32 step; }; -static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream, - struct snd_pcm_channel_info32 __user *src) +static int snd_pcm_ioctl_channel_info_compat(snd_pcm_substream_t *substream, + struct sndrv_pcm_channel_info32 __user *src) { - struct snd_pcm_channel_info info; + snd_pcm_channel_info_t info; int err; if (get_user(info.channel, &src->channel) || @@ -178,7 +178,7 @@ static int snd_pcm_ioctl_channel_info_compat(struct snd_pcm_substream *substream return err; } -struct snd_pcm_status32 { +struct sndrv_pcm_status32 { s32 state; struct compat_timespec trigger_tstamp; struct compat_timespec tstamp; @@ -193,10 +193,10 @@ struct snd_pcm_status32 { } __attribute__((packed)); -static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream, - struct snd_pcm_status32 __user *src) +static int snd_pcm_status_user_compat(snd_pcm_substream_t *substream, + struct sndrv_pcm_status32 __user *src) { - struct snd_pcm_status status; + snd_pcm_status_t status; int err; err = snd_pcm_status(substream, &status); @@ -221,12 +221,12 @@ static int snd_pcm_status_user_compat(struct snd_pcm_substream *substream, } /* both for HW_PARAMS and HW_REFINE */ -static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream, +static int snd_pcm_ioctl_hw_params_compat(snd_pcm_substream_t *substream, int refine, - struct snd_pcm_hw_params32 __user *data32) + struct sndrv_pcm_hw_params32 __user *data32) { - struct snd_pcm_hw_params *data; - struct snd_pcm_runtime *runtime; + struct sndrv_pcm_hw_params *data; + snd_pcm_runtime_t *runtime; int err; if (! (runtime = substream->runtime)) @@ -265,14 +265,14 @@ static int snd_pcm_ioctl_hw_params_compat(struct snd_pcm_substream *substream, /* */ -struct snd_xferi32 { +struct sndrv_xferi32 { s32 result; u32 buf; u32 frames; }; -static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream, - int dir, struct snd_xferi32 __user *data32) +static int snd_pcm_ioctl_xferi_compat(snd_pcm_substream_t *substream, + int dir, struct sndrv_xferi32 __user *data32) { compat_caddr_t buf; u32 frames; @@ -303,7 +303,7 @@ static int snd_pcm_ioctl_xferi_compat(struct snd_pcm_substream *substream, /* snd_xfern needs remapping of bufs */ -struct snd_xfern32 { +struct sndrv_xfern32 { s32 result; u32 bufs; /* this is void **; */ u32 frames; @@ -315,8 +315,8 @@ struct snd_xfern32 { * handler there expands again the same 128 pointers on stack, so it is better * to handle the function (calling pcm_readv/writev) directly in this handler. */ -static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream, - int dir, struct snd_xfern32 __user *data32) +static int snd_pcm_ioctl_xfern_compat(snd_pcm_substream_t *substream, + int dir, struct sndrv_xfern32 __user *data32) { compat_caddr_t buf; compat_caddr_t __user *bufptr; @@ -360,7 +360,7 @@ static int snd_pcm_ioctl_xfern_compat(struct snd_pcm_substream *substream, } -struct snd_pcm_mmap_status32 { +struct sndrv_pcm_mmap_status32 { s32 state; s32 pad1; u32 hw_ptr; @@ -368,32 +368,32 @@ struct snd_pcm_mmap_status32 { s32 suspended_state; } __attribute__((packed)); -struct snd_pcm_mmap_control32 { +struct sndrv_pcm_mmap_control32 { u32 appl_ptr; u32 avail_min; }; -struct snd_pcm_sync_ptr32 { +struct sndrv_pcm_sync_ptr32 { u32 flags; union { - struct snd_pcm_mmap_status32 status; + struct sndrv_pcm_mmap_status32 status; unsigned char reserved[64]; } s; union { - struct snd_pcm_mmap_control32 control; + struct sndrv_pcm_mmap_control32 control; unsigned char reserved[64]; } c; } __attribute__((packed)); -static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream, - struct snd_pcm_sync_ptr32 __user *src) +static int snd_pcm_ioctl_sync_ptr_compat(snd_pcm_substream_t *substream, + struct sndrv_pcm_sync_ptr32 __user *src) { - struct snd_pcm_runtime *runtime = substream->runtime; - volatile struct snd_pcm_mmap_status *status; - volatile struct snd_pcm_mmap_control *control; + snd_pcm_runtime_t *runtime = substream->runtime; + volatile struct sndrv_pcm_mmap_status *status; + volatile struct sndrv_pcm_mmap_control *control; u32 sflags; - struct snd_pcm_mmap_control scontrol; - struct snd_pcm_mmap_status sstatus; + struct sndrv_pcm_mmap_control scontrol; + struct sndrv_pcm_mmap_status sstatus; snd_pcm_uframes_t boundary; int err; @@ -444,26 +444,26 @@ static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream, /* */ enum { - SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct snd_pcm_hw_params32), - SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct snd_pcm_hw_params32), - SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct snd_pcm_sw_params32), - SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct snd_pcm_status32), + SNDRV_PCM_IOCTL_HW_REFINE32 = _IOWR('A', 0x10, struct sndrv_pcm_hw_params32), + SNDRV_PCM_IOCTL_HW_PARAMS32 = _IOWR('A', 0x11, struct sndrv_pcm_hw_params32), + SNDRV_PCM_IOCTL_SW_PARAMS32 = _IOWR('A', 0x13, struct sndrv_pcm_sw_params32), + SNDRV_PCM_IOCTL_STATUS32 = _IOR('A', 0x20, struct sndrv_pcm_status32), SNDRV_PCM_IOCTL_DELAY32 = _IOR('A', 0x21, s32), - SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct snd_pcm_channel_info32), + SNDRV_PCM_IOCTL_CHANNEL_INFO32 = _IOR('A', 0x32, struct sndrv_pcm_channel_info32), SNDRV_PCM_IOCTL_REWIND32 = _IOW('A', 0x46, u32), SNDRV_PCM_IOCTL_FORWARD32 = _IOW('A', 0x49, u32), - SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct snd_xferi32), - SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct snd_xferi32), - SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct snd_xfern32), - SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct snd_xfern32), - SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct snd_pcm_sync_ptr32), + SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = _IOW('A', 0x50, struct sndrv_xferi32), + SNDRV_PCM_IOCTL_READI_FRAMES32 = _IOR('A', 0x51, struct sndrv_xferi32), + SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = _IOW('A', 0x52, struct sndrv_xfern32), + SNDRV_PCM_IOCTL_READN_FRAMES32 = _IOR('A', 0x53, struct sndrv_xfern32), + SNDRV_PCM_IOCTL_SYNC_PTR32 = _IOWR('A', 0x23, struct sndrv_pcm_sync_ptr32), }; static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; void __user *argp = compat_ptr(arg); pcm_file = file->private_data; diff --git a/trunk/sound/core/pcm_lib.c b/trunk/sound/core/pcm_lib.c index eeba2f060955..3dbf9bf2ac16 100644 --- a/trunk/sound/core/pcm_lib.c +++ b/trunk/sound/core/pcm_lib.c @@ -39,9 +39,9 @@ * * when runtime->silence_size >= runtime->boundary - fill processed area with silence immediately */ -void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_uframes_t new_hw_ptr) +void snd_pcm_playback_silence(snd_pcm_substream_t *substream, snd_pcm_uframes_t new_hw_ptr) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t frames, ofs, transfer; if (runtime->silence_size < runtime->boundary) { @@ -56,8 +56,9 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram runtime->silence_filled = 0; runtime->silence_start = runtime->control->appl_ptr; } - if (runtime->silence_filled >= runtime->buffer_size) + if (runtime->silence_filled == runtime->buffer_size) return; + snd_assert(runtime->silence_filled <= runtime->buffer_size, return); noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; if (noise_dist >= (snd_pcm_sframes_t) runtime->silence_threshold) return; @@ -127,7 +128,7 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram } } -static void xrun(struct snd_pcm_substream *substream) +static void xrun(snd_pcm_substream_t *substream) { snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN); #ifdef CONFIG_SND_DEBUG @@ -142,8 +143,8 @@ static void xrun(struct snd_pcm_substream *substream) #endif } -static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substream *substream, - struct snd_pcm_runtime *runtime) +static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(snd_pcm_substream_t *substream, + snd_pcm_runtime_t *runtime) { snd_pcm_uframes_t pos; @@ -161,8 +162,8 @@ static inline snd_pcm_uframes_t snd_pcm_update_hw_ptr_pos(struct snd_pcm_substre return pos; } -static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream, - struct snd_pcm_runtime *runtime) +static inline int snd_pcm_update_hw_ptr_post(snd_pcm_substream_t *substream, + snd_pcm_runtime_t *runtime) { snd_pcm_uframes_t avail; @@ -184,9 +185,9 @@ static inline int snd_pcm_update_hw_ptr_post(struct snd_pcm_substream *substream return 0; } -static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *substream) +static inline int snd_pcm_update_hw_ptr_interrupt(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t new_hw_ptr, hw_ptr_interrupt; snd_pcm_sframes_t delta; @@ -231,9 +232,9 @@ static inline int snd_pcm_update_hw_ptr_interrupt(struct snd_pcm_substream *subs } /* CAUTION: call it with irq disabled */ -int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream) +int snd_pcm_update_hw_ptr(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t pos; snd_pcm_uframes_t old_hw_ptr, new_hw_ptr; snd_pcm_sframes_t delta; @@ -280,10 +281,10 @@ int snd_pcm_update_hw_ptr(struct snd_pcm_substream *substream) * * Sets the given PCM operators to the pcm instance. */ -void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops) +void snd_pcm_set_ops(snd_pcm_t *pcm, int direction, snd_pcm_ops_t *ops) { - struct snd_pcm_str *stream = &pcm->streams[direction]; - struct snd_pcm_substream *substream; + snd_pcm_str_t *stream = &pcm->streams[direction]; + snd_pcm_substream_t *substream; for (substream = stream->substream; substream != NULL; substream = substream->next) substream->ops = ops; @@ -296,9 +297,9 @@ void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops * * Sets the PCM sync identifier for the card. */ -void snd_pcm_set_sync(struct snd_pcm_substream *substream) +void snd_pcm_set_sync(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; runtime->sync.id32[0] = substream->pcm->card->number; runtime->sync.id32[1] = -1; @@ -369,7 +370,7 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b, return n; } -static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin) +static int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin) { int changed = 0; assert(!snd_interval_empty(i)); @@ -394,7 +395,7 @@ static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int return changed; } -static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax) +static int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax) { int changed = 0; assert(!snd_interval_empty(i)); @@ -430,7 +431,7 @@ static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v) +int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) { int changed = 0; assert(!snd_interval_empty(i)); @@ -472,7 +473,7 @@ int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v) return changed; } -static int snd_interval_refine_first(struct snd_interval *i) +static int snd_interval_refine_first(snd_interval_t *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -484,7 +485,7 @@ static int snd_interval_refine_first(struct snd_interval *i) return 1; } -static int snd_interval_refine_last(struct snd_interval *i) +static int snd_interval_refine_last(snd_interval_t *i) { assert(!snd_interval_empty(i)); if (snd_interval_single(i)) @@ -496,9 +497,9 @@ static int snd_interval_refine_last(struct snd_interval *i) return 1; } -static int snd_interval_refine_set(struct snd_interval *i, unsigned int val) +static int snd_interval_refine_set(snd_interval_t *i, unsigned int val) { - struct snd_interval t; + snd_interval_t t; t.empty = 0; t.min = t.max = val; t.openmin = t.openmax = 0; @@ -506,7 +507,7 @@ static int snd_interval_refine_set(struct snd_interval *i, unsigned int val) return snd_interval_refine(i, &t); } -void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) +void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) { if (a->empty || b->empty) { snd_interval_none(c); @@ -530,7 +531,7 @@ void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c) +void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) { unsigned int r; if (a->empty || b->empty) { @@ -565,8 +566,8 @@ void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, - unsigned int k, struct snd_interval *c) +void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, + unsigned int k, snd_interval_t *c) { unsigned int r; if (a->empty || b->empty) { @@ -596,8 +597,8 @@ void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interva * * Returns non-zero if the value is changed, zero if not changed. */ -void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, - const struct snd_interval *b, struct snd_interval *c) +void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, + const snd_interval_t *b, snd_interval_t *c) { unsigned int r; if (a->empty || b->empty) { @@ -635,13 +636,13 @@ void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_ratnum(struct snd_interval *i, - unsigned int rats_count, struct snd_ratnum *rats, - unsigned int *nump, unsigned int *denp) +int snd_interval_ratnum(snd_interval_t *i, + unsigned int rats_count, ratnum_t *rats, + unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - struct snd_interval t; + snd_interval_t t; int err; best_num = best_den = best_diff = 0; @@ -730,20 +731,20 @@ int snd_interval_ratnum(struct snd_interval *i, /** * snd_interval_ratden - refine the interval value * @i: interval to refine - * @rats_count: number of struct ratden - * @rats: struct ratden array + * @rats_count: number of ratden_t + * @rats: ratden_t array * @nump: pointer to store the resultant numerator * @denp: pointer to store the resultant denominator * * Returns non-zero if the value is changed, zero if not changed. */ -static int snd_interval_ratden(struct snd_interval *i, - unsigned int rats_count, struct snd_ratden *rats, +static int snd_interval_ratden(snd_interval_t *i, + unsigned int rats_count, ratden_t *rats, unsigned int *nump, unsigned int *denp) { unsigned int best_num, best_diff, best_den; unsigned int k; - struct snd_interval t; + snd_interval_t t; int err; best_num = best_den = best_diff = 0; @@ -836,7 +837,7 @@ static int snd_interval_ratden(struct snd_interval *i, * * Returns non-zero if the value is changed, zero if not changed. */ -int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *list, unsigned int mask) +int snd_interval_list(snd_interval_t *i, unsigned int count, unsigned int *list, unsigned int mask) { unsigned int k; int changed = 0; @@ -877,7 +878,7 @@ int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int * return changed; } -static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step) +static int snd_interval_step(snd_interval_t *i, unsigned int min, unsigned int step) { unsigned int n; int changed = 0; @@ -911,18 +912,18 @@ static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, +int snd_pcm_hw_rule_add(snd_pcm_runtime_t *runtime, unsigned int cond, int var, snd_pcm_hw_rule_func_t func, void *private, int dep, ...) { - struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; - struct snd_pcm_hw_rule *c; + snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + snd_pcm_hw_rule_t *c; unsigned int k; va_list args; va_start(args, dep); if (constrs->rules_num >= constrs->rules_all) { - struct snd_pcm_hw_rule *new; + snd_pcm_hw_rule_t *new; unsigned int new_rules = constrs->rules_all + 16; new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL); if (!new) @@ -961,11 +962,11 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, * * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, u_int32_t mask) { - struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; - struct snd_mask *maskp = constrs_mask(constrs, var); + snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + snd_mask_t *maskp = constrs_mask(constrs, var); *maskp->bits &= mask; memset(maskp->bits + 1, 0, (SNDRV_MASK_MAX-32) / 8); /* clear rest */ if (*maskp->bits == 0) @@ -981,11 +982,11 @@ int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param * * Apply the constraint of the given bitmap mask to a mask parameter. */ -int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_mask64(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, u_int64_t mask) { - struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; - struct snd_mask *maskp = constrs_mask(constrs, var); + snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + snd_mask_t *maskp = constrs_mask(constrs, var); maskp->bits[0] &= (u_int32_t)mask; maskp->bits[1] &= (u_int32_t)(mask >> 32); memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ @@ -1001,9 +1002,9 @@ int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_par * * Apply the constraint of integer to an interval parameter. */ -int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var) +int snd_pcm_hw_constraint_integer(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var) { - struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; return snd_interval_setinteger(constrs_interval(constrs, var)); } @@ -1016,11 +1017,11 @@ int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_pa * * Apply the min/max range constraint to an interval parameter. */ -int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, +int snd_pcm_hw_constraint_minmax(snd_pcm_runtime_t *runtime, snd_pcm_hw_param_t var, unsigned int min, unsigned int max) { - struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; - struct snd_interval t; + snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; + snd_interval_t t; t.min = min; t.max = max; t.openmin = t.openmax = 0; @@ -1028,10 +1029,10 @@ int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_par return snd_interval_refine(constrs_interval(constrs, var), &t); } -static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_list(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_pcm_hw_constraint_list *list = rule->private; + snd_pcm_hw_constraint_list_t *list = rule->private; return snd_interval_list(hw_param_interval(params, rule->var), list->count, list->list, list->mask); } @@ -1045,20 +1046,20 @@ static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params, * * Apply the list of constraints to an interval parameter. */ -int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_list(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, - struct snd_pcm_hw_constraint_list *l) + snd_pcm_hw_constraint_list_t *l) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_list, l, var, -1); } -static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_ratnums(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_pcm_hw_constraint_ratnums *r = rule->private; + snd_pcm_hw_constraint_ratnums_t *r = rule->private; unsigned int num = 0, den = 0; int err; err = snd_interval_ratnum(hw_param_interval(params, rule->var), @@ -1075,22 +1076,22 @@ static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params, * @runtime: PCM runtime instance * @cond: condition bits * @var: hw_params variable to apply the ratnums constraint - * @r: struct snd_ratnums constriants + * @r: ratnums_t constriants */ -int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_ratnums(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, - struct snd_pcm_hw_constraint_ratnums *r) + snd_pcm_hw_constraint_ratnums_t *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratnums, r, var, -1); } -static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_ratdens(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_pcm_hw_constraint_ratdens *r = rule->private; + snd_pcm_hw_constraint_ratdens_t *r = rule->private; unsigned int num = 0, den = 0; int err = snd_interval_ratden(hw_param_interval(params, rule->var), r->nrats, r->rats, &num, &den); @@ -1106,25 +1107,25 @@ static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params, * @runtime: PCM runtime instance * @cond: condition bits * @var: hw_params variable to apply the ratdens constraint - * @r: struct snd_ratdens constriants + * @r: ratdens_t constriants */ -int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_ratdens(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, - struct snd_pcm_hw_constraint_ratdens *r) + snd_pcm_hw_constraint_ratdens_t *r) { return snd_pcm_hw_rule_add(runtime, cond, var, snd_pcm_hw_rule_ratdens, r, var, -1); } -static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_msbits(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { unsigned int l = (unsigned long) rule->private; int width = l & 0xffff; unsigned int msbits = l >> 16; - struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); + snd_interval_t *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS); if (snd_interval_single(i) && snd_interval_value(i) == width) params->msbits = msbits; return 0; @@ -1137,7 +1138,7 @@ static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params, * @width: sample bits width * @msbits: msbits width */ -int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_msbits(snd_pcm_runtime_t *runtime, unsigned int cond, unsigned int width, unsigned int msbits) @@ -1149,8 +1150,8 @@ int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1); } -static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_step(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { unsigned long step = (unsigned long) rule->private; return snd_interval_step(hw_param_interval(params, rule->var), 0, step); @@ -1163,7 +1164,7 @@ static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params, * @var: hw_params variable to apply the step constraint * @step: step size */ -int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_step(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var, unsigned long step) @@ -1173,7 +1174,7 @@ int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, var, -1); } -static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_pow2(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) { static int pow2_sizes[] = { 1<<0, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1<<7, @@ -1191,7 +1192,7 @@ static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm * @cond: condition bits * @var: hw_params variable to apply the power-of-2 constraint */ -int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, +int snd_pcm_hw_constraint_pow2(snd_pcm_runtime_t *runtime, unsigned int cond, snd_pcm_hw_param_t var) { @@ -1201,12 +1202,13 @@ int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, } /* To use the same code we have in alsa-lib */ +#define snd_pcm_t snd_pcm_substream_t #define assert(i) snd_assert((i), return -EINVAL) #ifndef INT_MIN #define INT_MIN ((int)((unsigned int)INT_MAX+1)) #endif -static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params, +static void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { @@ -1228,7 +1230,7 @@ static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params, /* * snd_pcm_hw_param_any */ -int snd_pcm_hw_param_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, +int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { _snd_pcm_hw_param_any(params, var); @@ -1236,7 +1238,7 @@ int snd_pcm_hw_param_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params } #endif /* 0 */ -void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params) +void _snd_pcm_hw_params_any(snd_pcm_hw_params_t *params) { unsigned int k; memset(params, 0, sizeof(*params)); @@ -1253,7 +1255,7 @@ void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params) * * Fill PARAMS with full configuration space boundaries */ -int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) +int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) { _snd_pcm_hw_params_any(params); return snd_pcm_hw_refine(pcm, params); @@ -1269,11 +1271,11 @@ int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_param * Return the value for field PAR if it's fixed in configuration space * defined by PARAMS. Return -EINVAL otherwise */ -static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, +static int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { - const struct snd_mask *mask = hw_param_mask_c(params, var); + const snd_mask_t *mask = hw_param_mask_c(params, var); if (!snd_mask_single(mask)) return -EINVAL; if (dir) @@ -1281,7 +1283,7 @@ static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, return snd_mask_value(mask); } if (hw_is_interval(var)) { - const struct snd_interval *i = hw_param_interval_c(params, var); + const snd_interval_t *i = hw_param_interval_c(params, var); if (!snd_interval_single(i)) return -EINVAL; if (dir) @@ -1300,7 +1302,7 @@ static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, * * Return the minimum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, +unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1309,7 +1311,7 @@ unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, return snd_mask_min(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const struct snd_interval *i = hw_param_interval_c(params, var); + const snd_interval_t *i = hw_param_interval_c(params, var); if (dir) *dir = i->openmin; return snd_interval_min(i); @@ -1326,7 +1328,7 @@ unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, * * Return the maximum value for field PAR. */ -unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params, +unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { @@ -1335,7 +1337,7 @@ unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params, return snd_mask_max(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const struct snd_interval *i = hw_param_interval_c(params, var); + const snd_interval_t *i = hw_param_interval_c(params, var); if (dir) *dir = - (int) i->openmax; return snd_interval_max(i); @@ -1344,7 +1346,7 @@ unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params, return -EINVAL; } -void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, +void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { @@ -1360,7 +1362,7 @@ void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, } } -int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params, +int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { int changed; @@ -1381,8 +1383,8 @@ int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params, * non integer values. Reduce configuration space accordingly. * Return -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_setinteger(struct snd_pcm_substream *pcm, - struct snd_pcm_hw_params *params, +int snd_pcm_hw_param_setinteger(snd_pcm_t *pcm, + snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { int changed = _snd_pcm_hw_param_setinteger(params, var); @@ -1397,7 +1399,7 @@ int snd_pcm_hw_param_setinteger(struct snd_pcm_substream *pcm, } #endif /* 0 */ -static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params, +static int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { int changed; @@ -1428,8 +1430,8 @@ static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params, * values > minimum. Reduce configuration space accordingly. * Return the minimum. */ -static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, - struct snd_pcm_hw_params *params, +static int snd_pcm_hw_param_first(snd_pcm_t *pcm, + snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_first(params, var); @@ -1442,7 +1444,7 @@ static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, return snd_pcm_hw_param_value(params, var, dir); } -static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params, +static int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { int changed; @@ -1473,8 +1475,8 @@ static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params, * values < maximum. Reduce configuration space accordingly. * Return the maximum. */ -static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, - struct snd_pcm_hw_params *params, +static int snd_pcm_hw_param_last(snd_pcm_t *pcm, + snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir) { int changed = _snd_pcm_hw_param_last(params, var); @@ -1487,7 +1489,7 @@ static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, return snd_pcm_hw_param_value(params, var, dir); } -int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params, +int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; @@ -1529,7 +1531,7 @@ int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params, * values < VAL. Reduce configuration space accordingly. * Return new minimum or -EINVAL if the configuration space is empty */ -static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, +static int snd_pcm_hw_param_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int *dir) { @@ -1544,7 +1546,7 @@ static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm, struct snd_pcm_hw return snd_pcm_hw_param_value_min(params, var, dir); } -static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params, +static int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { @@ -1589,7 +1591,7 @@ static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params, * values >= VAL + 1. Reduce configuration space accordingly. * Return new maximum or -EINVAL if the configuration space is empty */ -static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, +static int snd_pcm_hw_param_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int *dir) { @@ -1604,12 +1606,12 @@ static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm, struct snd_pcm_hw return snd_pcm_hw_param_value_max(params, var, dir); } -int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, +int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed; if (hw_is_mask(var)) { - struct snd_mask *m = hw_param_mask(params, var); + snd_mask_t *m = hw_param_mask(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_mask_none(m); @@ -1621,14 +1623,14 @@ int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, changed = snd_mask_refine_set(hw_param_mask(params, var), val); } } else if (hw_is_interval(var)) { - struct snd_interval *i = hw_param_interval(params, var); + snd_interval_t *i = hw_param_interval(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; snd_interval_none(i); } else if (dir == 0) changed = snd_interval_refine_set(i, val); else { - struct snd_interval t; + snd_interval_t t; t.openmin = 1; t.openmax = 1; t.empty = 0; @@ -1665,7 +1667,7 @@ int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, * values != VAL. Reduce configuration space accordingly. * Return VAL or -EINVAL if the configuration space is empty */ -int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, +int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir) { int changed = _snd_pcm_hw_param_set(params, var, val, dir); @@ -1679,8 +1681,8 @@ int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params return snd_pcm_hw_param_value(params, var, NULL); } -static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params, - snd_pcm_hw_param_t var, const struct snd_mask *val) +static int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, + snd_pcm_hw_param_t var, const snd_mask_t *val) { int changed; assert(hw_is_mask(var)); @@ -1706,8 +1708,8 @@ static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params, * Return 0 on success or -EINVAL * if the configuration space is empty */ -int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, - snd_pcm_hw_param_t var, const struct snd_mask *val) +int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, + snd_pcm_hw_param_t var, const snd_mask_t *val) { int changed = _snd_pcm_hw_param_mask(params, var, val); if (changed < 0) @@ -1782,10 +1784,10 @@ static int boundary_nearer(int min, int mindir, * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT. * Return the value found. */ -int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, +int snd_pcm_hw_param_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int best, int *dir) { - struct snd_pcm_hw_params *save = NULL; + snd_pcm_hw_params_t *save = NULL; int v; unsigned int saved_min; int last = 0; @@ -1812,7 +1814,7 @@ int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_param saved_min = min; min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir); if (min >= 0) { - struct snd_pcm_hw_params *params1; + snd_pcm_hw_params_t *params1; if (max < 0) goto _end; if ((unsigned int)min == saved_min && mindir == valdir) @@ -1859,7 +1861,7 @@ int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_param * first access, first format, first subformat, min channels, * min rate, min period time, max buffer size, min tick time */ -int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params) +int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) { int err; @@ -1890,12 +1892,13 @@ int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_pa return 0; } +#undef snd_pcm_t #undef assert -static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream, +static int snd_pcm_lib_ioctl_reset(snd_pcm_substream_t *substream, void *arg) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; snd_pcm_stream_lock_irqsave(substream, flags); if (snd_pcm_running(substream) && @@ -1907,11 +1910,11 @@ static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream, return 0; } -static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream, +static int snd_pcm_lib_ioctl_channel_info(snd_pcm_substream_t *substream, void *arg) { - struct snd_pcm_channel_info *info = arg; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_channel_info_t *info = arg; + snd_pcm_runtime_t *runtime = substream->runtime; int width; if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) { info->offset = -1; @@ -1953,7 +1956,7 @@ static int snd_pcm_lib_ioctl_channel_info(struct snd_pcm_substream *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, +int snd_pcm_lib_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg) { switch (cmd) { @@ -1971,10 +1974,10 @@ int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, * Conditions */ -static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, +static void snd_pcm_system_tick_set(snd_pcm_substream_t *substream, unsigned long ticks) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (ticks == 0) del_timer(&runtime->tick_timer); else { @@ -1985,14 +1988,14 @@ static void snd_pcm_system_tick_set(struct snd_pcm_substream *substream, } /* Temporary alias */ -void snd_pcm_tick_set(struct snd_pcm_substream *substream, unsigned long ticks) +void snd_pcm_tick_set(snd_pcm_substream_t *substream, unsigned long ticks) { snd_pcm_system_tick_set(substream, ticks); } -void snd_pcm_tick_prepare(struct snd_pcm_substream *substream) +void snd_pcm_tick_prepare(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t frames = ULONG_MAX; snd_pcm_uframes_t avail, dist; unsigned int ticks; @@ -2005,8 +2008,8 @@ void snd_pcm_tick_prepare(struct snd_pcm_substream *substream) runtime->silence_filled < runtime->buffer_size) { snd_pcm_sframes_t noise_dist; noise_dist = snd_pcm_playback_hw_avail(runtime) + runtime->silence_filled; - if (noise_dist > (snd_pcm_sframes_t)runtime->silence_threshold) - frames = noise_dist - runtime->silence_threshold; + snd_assert(noise_dist <= (snd_pcm_sframes_t)runtime->silence_threshold, ); + frames = noise_dist - runtime->silence_threshold; } avail = snd_pcm_playback_avail(runtime); } else { @@ -2043,9 +2046,9 @@ void snd_pcm_tick_prepare(struct snd_pcm_substream *substream) snd_pcm_tick_set(substream, (unsigned long) ticks); } -void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream) +void snd_pcm_tick_elapsed(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -2073,9 +2076,9 @@ void snd_pcm_tick_elapsed(struct snd_pcm_substream *substream) * Even if more than one periods have elapsed since the last call, you * have to call this only once. */ -void snd_pcm_period_elapsed(struct snd_pcm_substream *substream) +void snd_pcm_period_elapsed(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; unsigned long flags; snd_assert(substream != NULL, return); @@ -2101,12 +2104,12 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream) kill_fasync(&runtime->fasync, SIGIO, POLL_IN); } -static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, +static int snd_pcm_lib_write_transfer(snd_pcm_substream_t *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2121,17 +2124,17 @@ static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream, return 0; } -typedef int (*transfer_f)(struct snd_pcm_substream *substream, unsigned int hwoff, +typedef int (*transfer_f)(snd_pcm_substream_t *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t size); -static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, +static snd_pcm_sframes_t snd_pcm_lib_write1(snd_pcm_substream_t *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2287,9 +2290,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_write(snd_pcm_substream_t *substream, const void __user *buf, snd_pcm_uframes_t size) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2303,7 +2306,7 @@ snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const v nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - struct snd_pcm_oss_setup *setup = substream->oss.setup; + snd_pcm_oss_setup_t *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2320,12 +2323,12 @@ snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const v snd_pcm_lib_write_transfer); } -static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, +static int snd_pcm_lib_writev_transfer(snd_pcm_substream_t *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2360,11 +2363,11 @@ static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, +snd_pcm_sframes_t snd_pcm_lib_writev(snd_pcm_substream_t *substream, void __user **bufs, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2378,7 +2381,7 @@ snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - struct snd_pcm_oss_setup *setup = substream->oss.setup; + snd_pcm_oss_setup_t *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2394,12 +2397,12 @@ snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream, nonblock, snd_pcm_lib_writev_transfer); } -static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, +static int snd_pcm_lib_read_transfer(snd_pcm_substream_t *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; char __user *buf = (char __user *) data + frames_to_bytes(runtime, off); if (substream->ops->copy) { @@ -2414,13 +2417,13 @@ static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, return 0; } -static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, +static snd_pcm_sframes_t snd_pcm_lib_read1(snd_pcm_substream_t *substream, unsigned long data, snd_pcm_uframes_t size, int nonblock, transfer_f transfer) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_uframes_t xfer = 0; snd_pcm_uframes_t offset = 0; int err = 0; @@ -2584,9 +2587,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream, return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; } -snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __user *buf, snd_pcm_uframes_t size) +snd_pcm_sframes_t snd_pcm_lib_read(snd_pcm_substream_t *substream, void __user *buf, snd_pcm_uframes_t size) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2600,7 +2603,7 @@ snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __u nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - struct snd_pcm_oss_setup *setup = substream->oss.setup; + snd_pcm_oss_setup_t *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; @@ -2614,12 +2617,12 @@ snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __u return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer); } -static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, +static int snd_pcm_lib_readv_transfer(snd_pcm_substream_t *substream, unsigned int hwoff, unsigned long data, unsigned int off, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; void __user **bufs = (void __user **)data; int channels = runtime->channels; @@ -2651,11 +2654,11 @@ static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream, return 0; } -snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, +snd_pcm_sframes_t snd_pcm_lib_readv(snd_pcm_substream_t *substream, void __user **bufs, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; int nonblock; snd_assert(substream != NULL, return -ENXIO); @@ -2669,7 +2672,7 @@ snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream, nonblock = !!(substream->ffile->f_flags & O_NONBLOCK); #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE) if (substream->oss.oss) { - struct snd_pcm_oss_setup *setup = substream->oss.setup; + snd_pcm_oss_setup_t *setup = substream->oss.setup; if (setup != NULL) { if (setup->nonblock) nonblock = 1; diff --git a/trunk/sound/core/pcm_memory.c b/trunk/sound/core/pcm_memory.c index a0119ae67dcd..b3f5344f60be 100644 --- a/trunk/sound/core/pcm_memory.c +++ b/trunk/sound/core/pcm_memory.c @@ -46,7 +46,7 @@ static const size_t snd_minimum_buffer = 16384; * * the minimum size is snd_minimum_buffer. it should be power of 2. */ -static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size) +static int preallocate_pcm_pages(snd_pcm_substream_t *substream, size_t size) { struct snd_dma_buffer *dmab = &substream->dma_buffer; int err; @@ -78,7 +78,7 @@ static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t siz /* * release the preallocated buffer if not yet done. */ -static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream) +static void snd_pcm_lib_preallocate_dma_free(snd_pcm_substream_t *substream) { if (substream->dma_buffer.area == NULL) return; @@ -97,11 +97,13 @@ static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream) +int snd_pcm_lib_preallocate_free(snd_pcm_substream_t *substream) { snd_pcm_lib_preallocate_dma_free(substream); - snd_info_unregister(substream->proc_prealloc_entry); - substream->proc_prealloc_entry = NULL; + if (substream->proc_prealloc_entry) { + snd_info_unregister(substream->proc_prealloc_entry); + substream->proc_prealloc_entry = NULL; + } return 0; } @@ -113,9 +115,9 @@ int snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm) +int snd_pcm_lib_preallocate_free_for_all(snd_pcm_t *pcm) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int stream; for (stream = 0; stream < 2; stream++) @@ -124,16 +126,15 @@ int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm) return 0; } -#ifdef CONFIG_PROC_FS /* * read callback for prealloc proc file * * prints the current allocated size in kB. */ -static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_lib_preallocate_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t *buffer) { - struct snd_pcm_substream *substream = entry->private_data; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; snd_iprintf(buffer, "%lu\n", (unsigned long) substream->dma_buffer.bytes / 1024); } @@ -142,10 +143,10 @@ static void snd_pcm_lib_preallocate_proc_read(struct snd_info_entry *entry, * * accepts the preallocation size in kB. */ -static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_pcm_lib_preallocate_proc_write(snd_info_entry_t *entry, + snd_info_buffer_t *buffer) { - struct snd_pcm_substream *substream = entry->private_data; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)entry->private_data; char line[64], str[64]; size_t size; struct snd_dma_buffer new_dmab; @@ -184,10 +185,20 @@ static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry, } } -static inline void preallocate_info_init(struct snd_pcm_substream *substream) +/* + * pre-allocate the buffer and create a proc file for the substream + */ +static int snd_pcm_lib_preallocate_pages1(snd_pcm_substream_t *substream, + size_t size, size_t max) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; + if (size > 0 && preallocate_dma && substream->number < maximum_substreams) + preallocate_pcm_pages(substream, size); + + if (substream->dma_buffer.bytes > 0) + substream->buffer_bytes_max = substream->dma_buffer.bytes; + substream->dma_max = max; if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) { entry->c.text.read_size = 64; entry->c.text.read = snd_pcm_lib_preallocate_proc_read; @@ -201,26 +212,6 @@ static inline void preallocate_info_init(struct snd_pcm_substream *substream) } } substream->proc_prealloc_entry = entry; -} - -#else /* !CONFIG_PROC_FS */ -#define preallocate_info_init(s) -#endif - -/* - * pre-allocate the buffer and create a proc file for the substream - */ -static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream, - size_t size, size_t max) -{ - - if (size > 0 && preallocate_dma && substream->number < maximum_substreams) - preallocate_pcm_pages(substream, size); - - if (substream->dma_buffer.bytes > 0) - substream->buffer_bytes_max = substream->dma_buffer.bytes; - substream->dma_max = max; - preallocate_info_init(substream); return 0; } @@ -242,7 +233,7 @@ static int snd_pcm_lib_preallocate_pages1(struct snd_pcm_substream *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, +int snd_pcm_lib_preallocate_pages(snd_pcm_substream_t *substream, int type, struct device *data, size_t size, size_t max) { @@ -264,11 +255,11 @@ int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, +int snd_pcm_lib_preallocate_pages_for_all(snd_pcm_t *pcm, int type, void *data, size_t size, size_t max) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int stream, err; for (stream = 0; stream < 2; stream++) @@ -286,7 +277,7 @@ int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, * Returns the page struct at the given buffer offset. * Used as the page callback of PCM ops. */ -struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset) +struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset) { struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); @@ -307,9 +298,9 @@ struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigne * Returns 1 if the buffer is changed, 0 if not changed, or a negative * code on failure. */ -int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size) +int snd_pcm_lib_malloc_pages(snd_pcm_substream_t *substream, size_t size) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; struct snd_dma_buffer *dmab = NULL; snd_assert(substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_UNKNOWN, return -EINVAL); @@ -327,8 +318,7 @@ int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size) } snd_pcm_lib_free_pages(substream); } - if (substream->dma_buffer.area != NULL && - substream->dma_buffer.bytes >= size) { + if (substream->dma_buffer.area != NULL && substream->dma_buffer.bytes >= size) { dmab = &substream->dma_buffer; /* use the pre-allocated buffer */ } else { dmab = kzalloc(sizeof(*dmab), GFP_KERNEL); @@ -355,9 +345,9 @@ int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size) * * Returns zero if successful, or a negative error code on failure. */ -int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream) +int snd_pcm_lib_free_pages(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; snd_assert(substream != NULL, return -EINVAL); runtime = substream->runtime; diff --git a/trunk/sound/core/pcm_misc.c b/trunk/sound/core/pcm_misc.c index 593c77f4d181..1453743e4da0 100644 --- a/trunk/sound/core/pcm_misc.c +++ b/trunk/sound/core/pcm_misc.c @@ -441,7 +441,7 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end * * Returns zero if successful. */ -int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime) +int snd_pcm_limit_hw_rates(snd_pcm_runtime_t *runtime) { static unsigned rates[] = { /* ATTENTION: these values depend on the definition in pcm.h! */ diff --git a/trunk/sound/core/pcm_native.c b/trunk/sound/core/pcm_native.c index f3d5de7b55ac..16e252f54954 100644 --- a/trunk/sound/core/pcm_native.c +++ b/trunk/sound/core/pcm_native.c @@ -39,11 +39,11 @@ * Compatibility */ -struct snd_pcm_hw_params_old { +struct sndrv_pcm_hw_params_old { unsigned int flags; unsigned int masks[SNDRV_PCM_HW_PARAM_SUBFORMAT - SNDRV_PCM_HW_PARAM_ACCESS + 1]; - struct snd_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME - + struct sndrv_interval intervals[SNDRV_PCM_HW_PARAM_TICK_TIME - SNDRV_PCM_HW_PARAM_SAMPLE_BITS + 1]; unsigned int rmask; unsigned int cmask; @@ -51,20 +51,15 @@ struct snd_pcm_hw_params_old { unsigned int msbits; unsigned int rate_num; unsigned int rate_den; - snd_pcm_uframes_t fifo_size; + sndrv_pcm_uframes_t fifo_size; unsigned char reserved[64]; }; -#ifdef CONFIG_SND_SUPPORT_OLD_API -#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct snd_pcm_hw_params_old) -#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct snd_pcm_hw_params_old) +#define SNDRV_PCM_IOCTL_HW_REFINE_OLD _IOWR('A', 0x10, struct sndrv_pcm_hw_params_old) +#define SNDRV_PCM_IOCTL_HW_PARAMS_OLD _IOWR('A', 0x11, struct sndrv_pcm_hw_params_old) -static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params_old __user * _oparams); -static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params_old __user * _oparams); -#endif -static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream); +static int snd_pcm_hw_refine_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams); +static int snd_pcm_hw_params_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams); /* * @@ -88,11 +83,11 @@ static inline void snd_leave_user(mm_segment_t fs) -int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info) +int snd_pcm_info(snd_pcm_substream_t * substream, snd_pcm_info_t *info) { - struct snd_pcm_runtime *runtime; - struct snd_pcm *pcm = substream->pcm; - struct snd_pcm_str *pstr = substream->pstr; + snd_pcm_runtime_t * runtime; + snd_pcm_t *pcm = substream->pcm; + snd_pcm_str_t *pstr = substream->pstr; snd_assert(substream != NULL, return -ENXIO); memset(info, 0, sizeof(*info)); @@ -116,10 +111,9 @@ int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info) return 0; } -int snd_pcm_info_user(struct snd_pcm_substream *substream, - struct snd_pcm_info __user * _info) +int snd_pcm_info_user(snd_pcm_substream_t * substream, snd_pcm_info_t __user * _info) { - struct snd_pcm_info *info; + snd_pcm_info_t *info; int err; info = kmalloc(sizeof(*info), GFP_KERNEL); @@ -157,14 +151,14 @@ char *snd_pcm_hw_param_names[] = { }; #endif -int snd_pcm_hw_refine(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +int snd_pcm_hw_refine(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { unsigned int k; - struct snd_pcm_hardware *hw; - struct snd_interval *i = NULL; - struct snd_mask *m = NULL; - struct snd_pcm_hw_constraints *constrs = &substream->runtime->hw_constraints; + snd_pcm_hardware_t *hw; + snd_interval_t *i = NULL; + snd_mask_t *m = NULL; + snd_pcm_hw_constraints_t *constrs = &substream->runtime->hw_constraints; unsigned int rstamps[constrs->rules_num]; unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1]; unsigned int stamp = 2; @@ -237,7 +231,7 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream, do { again = 0; for (k = 0; k < constrs->rules_num; k++) { - struct snd_pcm_hw_rule *r = &constrs->rules[k]; + snd_pcm_hw_rule_t *r = &constrs->rules[k]; unsigned int d; int doit = 0; if (r->cond && !(r->cond & params->flags)) @@ -319,10 +313,9 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream, return 0; } -static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params __user * _params) +static int snd_pcm_hw_refine_user(snd_pcm_substream_t * substream, snd_pcm_hw_params_t __user * _params) { - struct snd_pcm_hw_params *params; + snd_pcm_hw_params_t *params; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -344,10 +337,10 @@ static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream, return err; } -static int snd_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +static int snd_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; int err; unsigned int bits; snd_pcm_uframes_t frames; @@ -439,10 +432,9 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream, return err; } -static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params __user * _params) +static int snd_pcm_hw_params_user(snd_pcm_substream_t * substream, snd_pcm_hw_params_t __user * _params) { - struct snd_pcm_hw_params *params; + snd_pcm_hw_params_t *params; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -464,9 +456,9 @@ static int snd_pcm_hw_params_user(struct snd_pcm_substream *substream, return err; } -static int snd_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_pcm_hw_free(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; int result = 0; snd_assert(substream != NULL, return -ENXIO); @@ -490,10 +482,9 @@ static int snd_pcm_hw_free(struct snd_pcm_substream *substream) return result; } -static int snd_pcm_sw_params(struct snd_pcm_substream *substream, - struct snd_pcm_sw_params *params) +static int snd_pcm_sw_params(snd_pcm_substream_t * substream, snd_pcm_sw_params_t *params) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; snd_assert(substream != NULL, return -ENXIO); runtime = substream->runtime; @@ -546,10 +537,9 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream, - struct snd_pcm_sw_params __user * _params) +static int snd_pcm_sw_params_user(snd_pcm_substream_t * substream, snd_pcm_sw_params_t __user * _params) { - struct snd_pcm_sw_params params; + snd_pcm_sw_params_t params; int err; if (copy_from_user(¶ms, _params, sizeof(params))) return -EFAULT; @@ -559,10 +549,10 @@ static int snd_pcm_sw_params_user(struct snd_pcm_substream *substream, return err; } -int snd_pcm_status(struct snd_pcm_substream *substream, - struct snd_pcm_status *status) +int snd_pcm_status(snd_pcm_substream_t *substream, + snd_pcm_status_t *status) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_stream_lock_irq(substream); status->state = runtime->status->state; @@ -603,11 +593,10 @@ int snd_pcm_status(struct snd_pcm_substream *substream, return 0; } -static int snd_pcm_status_user(struct snd_pcm_substream *substream, - struct snd_pcm_status __user * _status) +static int snd_pcm_status_user(snd_pcm_substream_t * substream, snd_pcm_status_t __user * _status) { - struct snd_pcm_status status; - struct snd_pcm_runtime *runtime; + snd_pcm_status_t status; + snd_pcm_runtime_t *runtime; int res; snd_assert(substream != NULL, return -ENXIO); @@ -621,10 +610,9 @@ static int snd_pcm_status_user(struct snd_pcm_substream *substream, return 0; } -static int snd_pcm_channel_info(struct snd_pcm_substream *substream, - struct snd_pcm_channel_info * info) +static int snd_pcm_channel_info(snd_pcm_substream_t * substream, snd_pcm_channel_info_t * info) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; unsigned int channel; snd_assert(substream != NULL, return -ENXIO); @@ -643,10 +631,9 @@ static int snd_pcm_channel_info(struct snd_pcm_substream *substream, return substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_CHANNEL_INFO, info); } -static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream, - struct snd_pcm_channel_info __user * _info) +static int snd_pcm_channel_info_user(snd_pcm_substream_t * substream, snd_pcm_channel_info_t __user * _info) { - struct snd_pcm_channel_info info; + snd_pcm_channel_info_t info; int res; if (copy_from_user(&info, _info, sizeof(info))) @@ -659,9 +646,9 @@ static int snd_pcm_channel_info_user(struct snd_pcm_substream *substream, return 0; } -static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream) +static void snd_pcm_trigger_tstamp(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->trigger_master == NULL) return; if (runtime->trigger_master == substream) { @@ -674,10 +661,10 @@ static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream) } struct action_ops { - int (*pre_action)(struct snd_pcm_substream *substream, int state); - int (*do_action)(struct snd_pcm_substream *substream, int state); - void (*undo_action)(struct snd_pcm_substream *substream, int state); - void (*post_action)(struct snd_pcm_substream *substream, int state); + int (*pre_action)(snd_pcm_substream_t *substream, int state); + int (*do_action)(snd_pcm_substream_t *substream, int state); + void (*undo_action)(snd_pcm_substream_t *substream, int state); + void (*post_action)(snd_pcm_substream_t *substream, int state); }; /* @@ -686,12 +673,12 @@ struct action_ops { * Note2: call with calling stream lock + link lock */ static int snd_pcm_action_group(struct action_ops *ops, - struct snd_pcm_substream *substream, + snd_pcm_substream_t *substream, int state, int do_lock) { struct list_head *pos; - struct snd_pcm_substream *s = NULL; - struct snd_pcm_substream *s1; + snd_pcm_substream_t *s = NULL; + snd_pcm_substream_t *s1; int res = 0; snd_pcm_group_for_each(pos, substream) { @@ -740,7 +727,7 @@ static int snd_pcm_action_group(struct action_ops *ops, * Note: call with stream lock */ static int snd_pcm_action_single(struct action_ops *ops, - struct snd_pcm_substream *substream, + snd_pcm_substream_t *substream, int state) { int res; @@ -760,7 +747,7 @@ static int snd_pcm_action_single(struct action_ops *ops, * Note: call with stream lock */ static int snd_pcm_action(struct action_ops *ops, - struct snd_pcm_substream *substream, + snd_pcm_substream_t *substream, int state) { int res; @@ -783,7 +770,7 @@ static int snd_pcm_action(struct action_ops *ops, * Note: don't use any locks before */ static int snd_pcm_action_lock_irq(struct action_ops *ops, - struct snd_pcm_substream *substream, + snd_pcm_substream_t *substream, int state) { int res; @@ -807,7 +794,7 @@ static int snd_pcm_action_lock_irq(struct action_ops *ops, /* */ static int snd_pcm_action_nonatomic(struct action_ops *ops, - struct snd_pcm_substream *substream, + snd_pcm_substream_t *substream, int state) { int res; @@ -824,9 +811,9 @@ static int snd_pcm_action_nonatomic(struct action_ops *ops, /* * start callbacks */ -static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state) +static int snd_pcm_pre_start(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->status->state != SNDRV_PCM_STATE_PREPARED) return -EBADFD; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && @@ -836,22 +823,22 @@ static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state) return 0; } -static int snd_pcm_do_start(struct snd_pcm_substream *substream, int state) +static int snd_pcm_do_start(snd_pcm_substream_t *substream, int state) { if (substream->runtime->trigger_master != substream) return 0; return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START); } -static void snd_pcm_undo_start(struct snd_pcm_substream *substream, int state) +static void snd_pcm_undo_start(snd_pcm_substream_t *substream, int state) { if (substream->runtime->trigger_master == substream) substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP); } -static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state) +static void snd_pcm_post_start(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); runtime->status->state = state; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && @@ -860,8 +847,7 @@ static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state) if (runtime->sleep_min) snd_pcm_tick_prepare(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART, - &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTART, &runtime->trigger_tstamp); } static struct action_ops snd_pcm_action_start = { @@ -877,25 +863,24 @@ static struct action_ops snd_pcm_action_start = { * * Start all linked streams. */ -int snd_pcm_start(struct snd_pcm_substream *substream) +int snd_pcm_start(snd_pcm_substream_t *substream) { - return snd_pcm_action(&snd_pcm_action_start, substream, - SNDRV_PCM_STATE_RUNNING); + return snd_pcm_action(&snd_pcm_action_start, substream, SNDRV_PCM_STATE_RUNNING); } /* * stop callbacks */ -static int snd_pcm_pre_stop(struct snd_pcm_substream *substream, int state) +static int snd_pcm_pre_stop(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state) +static int snd_pcm_do_stop(snd_pcm_substream_t *substream, int state) { if (substream->runtime->trigger_master == substream && snd_pcm_running(substream)) @@ -903,14 +888,13 @@ static int snd_pcm_do_stop(struct snd_pcm_substream *substream, int state) return 0; /* unconditonally stop all substreams */ } -static void snd_pcm_post_stop(struct snd_pcm_substream *substream, int state) +static void snd_pcm_post_stop(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->status->state != state) { snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP, - &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSTOP, &runtime->trigger_tstamp); runtime->status->state = state; snd_pcm_tick_set(substream, 0); } @@ -931,7 +915,7 @@ static struct action_ops snd_pcm_action_stop = { * Try to stop all running streams in the substream group. * The state of each stream is changed to the given value after that unconditionally. */ -int snd_pcm_stop(struct snd_pcm_substream *substream, int state) +int snd_pcm_stop(snd_pcm_substream_t *substream, int state) { return snd_pcm_action(&snd_pcm_action_stop, substream, state); } @@ -944,18 +928,17 @@ int snd_pcm_stop(struct snd_pcm_substream *substream, int state) * The state is changed to SETUP. * Unlike snd_pcm_stop(), this affects only the given stream. */ -int snd_pcm_drain_done(struct snd_pcm_substream *substream) +int snd_pcm_drain_done(snd_pcm_substream_t *substream) { - return snd_pcm_action_single(&snd_pcm_action_stop, substream, - SNDRV_PCM_STATE_SETUP); + return snd_pcm_action_single(&snd_pcm_action_stop, substream, SNDRV_PCM_STATE_SETUP); } /* * pause callbacks */ -static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push) +static int snd_pcm_pre_pause(snd_pcm_substream_t *substream, int push) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (!(runtime->info & SNDRV_PCM_INFO_PAUSE)) return -ENOSYS; if (push) { @@ -967,7 +950,7 @@ static int snd_pcm_pre_pause(struct snd_pcm_substream *substream, int push) return 0; } -static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push) +static int snd_pcm_do_pause(snd_pcm_substream_t *substream, int push) { if (substream->runtime->trigger_master != substream) return 0; @@ -976,7 +959,7 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push) SNDRV_PCM_TRIGGER_PAUSE_RELEASE); } -static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push) +static void snd_pcm_undo_pause(snd_pcm_substream_t *substream, int push) { if (substream->runtime->trigger_master == substream) substream->ops->trigger(substream, @@ -984,16 +967,14 @@ static void snd_pcm_undo_pause(struct snd_pcm_substream *substream, int push) SNDRV_PCM_TRIGGER_PAUSE_PUSH); } -static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push) +static void snd_pcm_post_pause(snd_pcm_substream_t *substream, int push) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (push) { runtime->status->state = SNDRV_PCM_STATE_PAUSED; if (substream->timer) - snd_timer_notify(substream->timer, - SNDRV_TIMER_EVENT_MPAUSE, - &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MPAUSE, &runtime->trigger_tstamp); snd_pcm_tick_set(substream, 0); wake_up(&runtime->sleep); } else { @@ -1001,9 +982,7 @@ static void snd_pcm_post_pause(struct snd_pcm_substream *substream, int push) if (runtime->sleep_min) snd_pcm_tick_prepare(substream); if (substream->timer) - snd_timer_notify(substream->timer, - SNDRV_TIMER_EVENT_MCONTINUE, - &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MCONTINUE, &runtime->trigger_tstamp); } } @@ -1017,7 +996,7 @@ static struct action_ops snd_pcm_action_pause = { /* * Push/release the pause for all linked streams. */ -static int snd_pcm_pause(struct snd_pcm_substream *substream, int push) +static int snd_pcm_pause(snd_pcm_substream_t *substream, int push) { return snd_pcm_action(&snd_pcm_action_pause, substream, push); } @@ -1025,18 +1004,18 @@ static int snd_pcm_pause(struct snd_pcm_substream *substream, int push) #ifdef CONFIG_PM /* suspend */ -static int snd_pcm_pre_suspend(struct snd_pcm_substream *substream, int state) +static int snd_pcm_pre_suspend(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) return -EBUSY; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state) +static int snd_pcm_do_suspend(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->trigger_master != substream) return 0; if (! snd_pcm_running(substream)) @@ -1045,13 +1024,12 @@ static int snd_pcm_do_suspend(struct snd_pcm_substream *substream, int state) return 0; /* suspend unconditionally */ } -static void snd_pcm_post_suspend(struct snd_pcm_substream *substream, int state) +static void snd_pcm_post_suspend(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND, - &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MSUSPEND, &runtime->trigger_tstamp); runtime->status->suspended_state = runtime->status->state; runtime->status->state = SNDRV_PCM_STATE_SUSPENDED; snd_pcm_tick_set(substream, 0); @@ -1071,14 +1049,11 @@ static struct action_ops snd_pcm_action_suspend = { * Trigger SUSPEND to all linked streams. * After this call, all streams are changed to SUSPENDED state. */ -int snd_pcm_suspend(struct snd_pcm_substream *substream) +int snd_pcm_suspend(snd_pcm_substream_t *substream) { int err; unsigned long flags; - if (! substream) - return 0; - snd_pcm_stream_lock_irqsave(substream, flags); err = snd_pcm_action(&snd_pcm_action_suspend, substream, 0); snd_pcm_stream_unlock_irqrestore(substream, flags); @@ -1092,17 +1067,13 @@ int snd_pcm_suspend(struct snd_pcm_substream *substream) * Trigger SUSPEND to all substreams in the given pcm. * After this call, all streams are changed to SUSPENDED state. */ -int snd_pcm_suspend_all(struct snd_pcm *pcm) +int snd_pcm_suspend_all(snd_pcm_t *pcm) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int stream, err = 0; - if (! pcm) - return 0; - for (stream = 0; stream < 2; stream++) { - for (substream = pcm->streams[stream].substream; - substream; substream = substream->next) { + for (substream = pcm->streams[stream].substream; substream; substream = substream->next) { /* FIXME: the open/close code should lock this as well */ if (substream->runtime == NULL) continue; @@ -1116,18 +1087,18 @@ int snd_pcm_suspend_all(struct snd_pcm *pcm) /* resume */ -static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state) +static int snd_pcm_pre_resume(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (!(runtime->info & SNDRV_PCM_INFO_RESUME)) return -ENOSYS; runtime->trigger_master = substream; return 0; } -static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state) +static int snd_pcm_do_resume(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->trigger_master != substream) return 0; /* DMA not running previously? */ @@ -1138,20 +1109,19 @@ static int snd_pcm_do_resume(struct snd_pcm_substream *substream, int state) return substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_RESUME); } -static void snd_pcm_undo_resume(struct snd_pcm_substream *substream, int state) +static void snd_pcm_undo_resume(snd_pcm_substream_t *substream, int state) { if (substream->runtime->trigger_master == substream && snd_pcm_running(substream)) substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_SUSPEND); } -static void snd_pcm_post_resume(struct snd_pcm_substream *substream, int state) +static void snd_pcm_post_resume(snd_pcm_substream_t *substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); if (substream->timer) - snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME, - &runtime->trigger_tstamp); + snd_timer_notify(substream->timer, SNDRV_TIMER_EVENT_MRESUME, &runtime->trigger_tstamp); runtime->status->state = runtime->status->suspended_state; if (runtime->sleep_min) snd_pcm_tick_prepare(substream); @@ -1164,9 +1134,9 @@ static struct action_ops snd_pcm_action_resume = { .post_action = snd_pcm_post_resume }; -static int snd_pcm_resume(struct snd_pcm_substream *substream) +static int snd_pcm_resume(snd_pcm_substream_t *substream) { - struct snd_card *card = substream->pcm->card; + snd_card_t *card = substream->pcm->card; int res; snd_power_lock(card); @@ -1178,7 +1148,7 @@ static int snd_pcm_resume(struct snd_pcm_substream *substream) #else -static int snd_pcm_resume(struct snd_pcm_substream *substream) +static int snd_pcm_resume(snd_pcm_substream_t *substream) { return -ENOSYS; } @@ -1190,10 +1160,10 @@ static int snd_pcm_resume(struct snd_pcm_substream *substream) * * Change the RUNNING stream(s) to XRUN state. */ -static int snd_pcm_xrun(struct snd_pcm_substream *substream) +static int snd_pcm_xrun(snd_pcm_substream_t *substream) { - struct snd_card *card = substream->pcm->card; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_card_t *card = substream->pcm->card; + snd_pcm_runtime_t *runtime = substream->runtime; int result; snd_power_lock(card); @@ -1223,9 +1193,9 @@ static int snd_pcm_xrun(struct snd_pcm_substream *substream) /* * reset ioctl */ -static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state) +static int snd_pcm_pre_reset(snd_pcm_substream_t * substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; switch (runtime->status->state) { case SNDRV_PCM_STATE_RUNNING: case SNDRV_PCM_STATE_PREPARED: @@ -1237,24 +1207,23 @@ static int snd_pcm_pre_reset(struct snd_pcm_substream *substream, int state) } } -static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state) +static int snd_pcm_do_reset(snd_pcm_substream_t * substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL); if (err < 0) return err; // snd_assert(runtime->status->hw_ptr < runtime->buffer_size, ); runtime->hw_ptr_base = 0; - runtime->hw_ptr_interrupt = runtime->status->hw_ptr - - runtime->status->hw_ptr % runtime->period_size; + runtime->hw_ptr_interrupt = runtime->status->hw_ptr - runtime->status->hw_ptr % runtime->period_size; runtime->silence_start = runtime->status->hw_ptr; runtime->silence_filled = 0; return 0; } -static void snd_pcm_post_reset(struct snd_pcm_substream *substream, int state) +static void snd_pcm_post_reset(snd_pcm_substream_t * substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; runtime->control->appl_ptr = runtime->status->hw_ptr; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0) @@ -1267,7 +1236,7 @@ static struct action_ops snd_pcm_action_reset = { .post_action = snd_pcm_post_reset }; -static int snd_pcm_reset(struct snd_pcm_substream *substream) +static int snd_pcm_reset(snd_pcm_substream_t *substream) { return snd_pcm_action_nonatomic(&snd_pcm_action_reset, substream, 0); } @@ -1275,9 +1244,9 @@ static int snd_pcm_reset(struct snd_pcm_substream *substream) /* * prepare ioctl */ -static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, int state) +static int snd_pcm_pre_prepare(snd_pcm_substream_t * substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; if (snd_pcm_running(substream)) @@ -1285,7 +1254,7 @@ static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, int state) return 0; } -static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state) +static int snd_pcm_do_prepare(snd_pcm_substream_t * substream, int state) { int err; err = substream->ops->prepare(substream); @@ -1294,9 +1263,9 @@ static int snd_pcm_do_prepare(struct snd_pcm_substream *substream, int state) return snd_pcm_do_reset(substream, 0); } -static void snd_pcm_post_prepare(struct snd_pcm_substream *substream, int state) +static void snd_pcm_post_prepare(snd_pcm_substream_t * substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; runtime->control->appl_ptr = runtime->status->hw_ptr; runtime->status->state = SNDRV_PCM_STATE_PREPARED; } @@ -1313,10 +1282,10 @@ static struct action_ops snd_pcm_action_prepare = { * * Prepare the PCM substream to be triggerable. */ -int snd_pcm_prepare(struct snd_pcm_substream *substream) +int snd_pcm_prepare(snd_pcm_substream_t *substream) { int res; - struct snd_card *card = substream->pcm->card; + snd_card_t *card = substream->pcm->card; snd_power_lock(card); if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0, substream->ffile)) >= 0) @@ -1329,7 +1298,7 @@ int snd_pcm_prepare(struct snd_pcm_substream *substream) * drain ioctl */ -static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state) +static int snd_pcm_pre_drain_init(snd_pcm_substream_t * substream, int state) { if (substream->ffile->f_flags & O_NONBLOCK) return -EAGAIN; @@ -1337,9 +1306,9 @@ static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state return 0; } -static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state) +static int snd_pcm_do_drain_init(snd_pcm_substream_t * substream, int state) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { switch (runtime->status->state) { case SNDRV_PCM_STATE_PREPARED: @@ -1367,7 +1336,7 @@ static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state) return 0; } -static void snd_pcm_post_drain_init(struct snd_pcm_substream *substream, int state) +static void snd_pcm_post_drain_init(snd_pcm_substream_t * substream, int state) { } @@ -1378,12 +1347,12 @@ static struct action_ops snd_pcm_action_drain_init = { }; struct drain_rec { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; wait_queue_t wait; snd_pcm_uframes_t stop_threshold; }; -static int snd_pcm_drop(struct snd_pcm_substream *substream); +static int snd_pcm_drop(snd_pcm_substream_t *substream); /* * Drain the stream(s). @@ -1392,10 +1361,10 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream); * After this call, all streams are supposed to be either SETUP or DRAINING * (capture only) state. */ -static int snd_pcm_drain(struct snd_pcm_substream *substream) +static int snd_pcm_drain(snd_pcm_substream_t *substream) { - struct snd_card *card; - struct snd_pcm_runtime *runtime; + snd_card_t *card; + snd_pcm_runtime_t *runtime; struct list_head *pos; int result = 0; int i, num_drecs; @@ -1432,7 +1401,7 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream) /* count only playback streams */ num_drecs = 0; snd_pcm_group_for_each(pos, substream) { - struct snd_pcm_substream *s = snd_pcm_group_substream_entry(pos); + snd_pcm_substream_t *s = snd_pcm_group_substream_entry(pos); runtime = s->runtime; if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) { d = &drec[num_drecs++]; @@ -1518,10 +1487,10 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream) * * Immediately put all linked substreams into SETUP state. */ -static int snd_pcm_drop(struct snd_pcm_substream *substream) +static int snd_pcm_drop(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime; - struct snd_card *card; + snd_pcm_runtime_t *runtime; + snd_card_t *card; int result = 0; snd_assert(substream != NULL, return -ENXIO); @@ -1557,8 +1526,7 @@ static struct file *snd_pcm_file_fd(int fd) { struct file *file; struct inode *inode; - unsigned int minor; - + unsigned short minor; file = fget(fd); if (!file) return NULL; @@ -1569,8 +1537,8 @@ static struct file *snd_pcm_file_fd(int fd) return NULL; } minor = iminor(inode); - if (!snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_PLAYBACK) && - !snd_lookup_minor_data(minor, SNDRV_DEVICE_TYPE_PCM_CAPTURE)) { + if (minor >= 256 || + minor % SNDRV_MINOR_DEVICES < SNDRV_MINOR_PCM_PLAYBACK) { fput(file); return NULL; } @@ -1580,12 +1548,12 @@ static struct file *snd_pcm_file_fd(int fd) /* * PCM link handling */ -static int snd_pcm_link(struct snd_pcm_substream *substream, int fd) +static int snd_pcm_link(snd_pcm_substream_t *substream, int fd) { int res = 0; struct file *file; - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream1; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream1; file = snd_pcm_file_fd(fd); if (!file) @@ -1604,7 +1572,7 @@ static int snd_pcm_link(struct snd_pcm_substream *substream, int fd) goto _end; } if (!snd_pcm_stream_linked(substream)) { - substream->group = kmalloc(sizeof(struct snd_pcm_group), GFP_ATOMIC); + substream->group = kmalloc(sizeof(snd_pcm_group_t), GFP_ATOMIC); if (substream->group == NULL) { res = -ENOMEM; goto _end; @@ -1624,14 +1592,14 @@ static int snd_pcm_link(struct snd_pcm_substream *substream, int fd) return res; } -static void relink_to_local(struct snd_pcm_substream *substream) +static void relink_to_local(snd_pcm_substream_t *substream) { substream->group = &substream->self_group; INIT_LIST_HEAD(&substream->self_group.substreams); list_add_tail(&substream->link_list, &substream->self_group.substreams); } -static int snd_pcm_unlink(struct snd_pcm_substream *substream) +static int snd_pcm_unlink(snd_pcm_substream_t *substream) { struct list_head *pos; int res = 0; @@ -1661,51 +1629,51 @@ static int snd_pcm_unlink(struct snd_pcm_substream *substream) /* * hw configurator */ -static int snd_pcm_hw_rule_mul(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_mul(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval t; + snd_interval_t t; snd_interval_mul(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_div(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_div(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval t; + snd_interval_t t; snd_interval_div(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_muldivk(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_muldivk(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval t; + snd_interval_t t; snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), (unsigned long) rule->private, &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_mulkdiv(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_mulkdiv(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval t; + snd_interval_t t; snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]), (unsigned long) rule->private, hw_param_interval_c(params, rule->deps[1]), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { unsigned int k; - struct snd_interval *i = hw_param_interval(params, rule->deps[0]); - struct snd_mask m; - struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); + snd_interval_t *i = hw_param_interval(params, rule->deps[0]); + snd_mask_t m; + snd_mask_t *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); snd_mask_any(&m); for (k = 0; k <= SNDRV_PCM_FORMAT_LAST; ++k) { int bits; @@ -1720,10 +1688,10 @@ static int snd_pcm_hw_rule_format(struct snd_pcm_hw_params *params, return snd_mask_refine(mask, &m); } -static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval t; + snd_interval_t t; unsigned int k; t.min = UINT_MAX; t.max = 0; @@ -1752,19 +1720,19 @@ static int snd_pcm_hw_rule_sample_bits(struct snd_pcm_hw_params *params, static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000 }; -static int snd_pcm_hw_rule_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_pcm_hardware *hw = rule->private; + snd_pcm_hardware_t *hw = rule->private; return snd_interval_list(hw_param_interval(params, rule->var), ARRAY_SIZE(rates), rates, hw->rates); } -static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pcm_hw_rule_buffer_bytes_max(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval t; - struct snd_pcm_substream *substream = rule->private; + snd_interval_t t; + snd_pcm_substream_t *substream = rule->private; t.min = 0; t.max = substream->buffer_bytes_max; t.openmin = 0; @@ -1773,10 +1741,10 @@ static int snd_pcm_hw_rule_buffer_bytes_max(struct snd_pcm_hw_params *params, return snd_interval_refine(hw_param_interval(params, rule->var), &t); } -int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream) +int snd_pcm_hw_constraints_init(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_pcm_hw_constraints *constrs = &runtime->hw_constraints; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_pcm_hw_constraints_t *constrs = &runtime->hw_constraints; int k, err; for (k = SNDRV_PCM_HW_PARAM_FIRST_MASK; k <= SNDRV_PCM_HW_PARAM_LAST_MASK; k++) { @@ -1897,10 +1865,10 @@ int snd_pcm_hw_constraints_init(struct snd_pcm_substream *substream) return 0; } -int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream) +int snd_pcm_hw_constraints_complete(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_pcm_hardware *hw = &runtime->hw; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_pcm_hardware_t *hw = &runtime->hw; int err; unsigned int mask = 0; @@ -1973,17 +1941,17 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream) return 0; } -static void snd_pcm_add_file(struct snd_pcm_str *str, - struct snd_pcm_file *pcm_file) +static void snd_pcm_add_file(snd_pcm_str_t *str, + snd_pcm_file_t *pcm_file) { pcm_file->next = str->files; str->files = pcm_file; } -static void snd_pcm_remove_file(struct snd_pcm_str *str, - struct snd_pcm_file *pcm_file) +static void snd_pcm_remove_file(snd_pcm_str_t *str, + snd_pcm_file_t *pcm_file) { - struct snd_pcm_file * pcm_file1; + snd_pcm_file_t * pcm_file1; if (str->files == pcm_file) { str->files = pcm_file->next; } else { @@ -1995,11 +1963,11 @@ static void snd_pcm_remove_file(struct snd_pcm_str *str, } } -static int snd_pcm_release_file(struct snd_pcm_file * pcm_file) +static int snd_pcm_release_file(snd_pcm_file_t * pcm_file) { - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; - struct snd_pcm_str * str; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; + snd_pcm_str_t * str; snd_assert(pcm_file != NULL, return -ENXIO); substream = pcm_file->substream; @@ -2020,14 +1988,14 @@ static int snd_pcm_release_file(struct snd_pcm_file * pcm_file) } static int snd_pcm_open_file(struct file *file, - struct snd_pcm *pcm, + snd_pcm_t *pcm, int stream, - struct snd_pcm_file **rpcm_file) + snd_pcm_file_t **rpcm_file) { int err = 0; - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_str *str; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_str_t *str; snd_assert(rpcm_file != NULL, return -EINVAL); *rpcm_file = NULL; @@ -2075,30 +2043,18 @@ static int snd_pcm_open_file(struct file *file, return 0; } -static int snd_pcm_playback_open(struct inode *inode, struct file *file) -{ - struct snd_pcm *pcm; - - pcm = snd_lookup_minor_data(iminor(inode), - SNDRV_DEVICE_TYPE_PCM_PLAYBACK); - return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK); -} - -static int snd_pcm_capture_open(struct inode *inode, struct file *file) -{ - struct snd_pcm *pcm; - - pcm = snd_lookup_minor_data(iminor(inode), - SNDRV_DEVICE_TYPE_PCM_CAPTURE); - return snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_CAPTURE); -} - -static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream) +static int snd_pcm_open(struct inode *inode, struct file *file) { + int cardnum = SNDRV_MINOR_CARD(iminor(inode)); + int device = SNDRV_MINOR_DEVICE(iminor(inode)); int err; - struct snd_pcm_file *pcm_file; + snd_pcm_t *pcm; + snd_pcm_file_t *pcm_file; wait_queue_t wait; + if (device < SNDRV_MINOR_PCM_PLAYBACK || device >= SNDRV_MINOR_DEVICES) + return -ENXIO; + pcm = snd_pcm_devices[(cardnum * SNDRV_PCM_DEVICES) + (device % SNDRV_MINOR_PCMS)]; if (pcm == NULL) { err = -ENODEV; goto __error1; @@ -2114,7 +2070,7 @@ static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream) add_wait_queue(&pcm->open_wait, &wait); down(&pcm->open_mutex); while (1) { - err = snd_pcm_open_file(file, pcm, stream, &pcm_file); + err = snd_pcm_open_file(file, pcm, device >= SNDRV_MINOR_PCM_CAPTURE ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK, &pcm_file); if (err >= 0) break; if (err == -EAGAIN) { @@ -2149,9 +2105,9 @@ static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream) static int snd_pcm_release(struct inode *inode, struct file *file) { - struct snd_pcm *pcm; - struct snd_pcm_substream *substream; - struct snd_pcm_file *pcm_file; + snd_pcm_t *pcm; + snd_pcm_substream_t *substream; + snd_pcm_file_t *pcm_file; pcm_file = file->private_data; substream = pcm_file->substream; @@ -2169,10 +2125,9 @@ static int snd_pcm_release(struct inode *inode, struct file *file) return 0; } -static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *substream, - snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_playback_rewind(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t hw_avail; @@ -2219,10 +2174,9 @@ static snd_pcm_sframes_t snd_pcm_playback_rewind(struct snd_pcm_substream *subst return ret; } -static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substream, - snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_capture_rewind(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t hw_avail; @@ -2269,10 +2223,9 @@ static snd_pcm_sframes_t snd_pcm_capture_rewind(struct snd_pcm_substream *substr return ret; } -static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *substream, - snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_playback_forward(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t avail; @@ -2320,10 +2273,9 @@ static snd_pcm_sframes_t snd_pcm_playback_forward(struct snd_pcm_substream *subs return ret; } -static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *substream, - snd_pcm_uframes_t frames) +static snd_pcm_sframes_t snd_pcm_capture_forward(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t appl_ptr; snd_pcm_sframes_t ret; snd_pcm_sframes_t avail; @@ -2371,9 +2323,9 @@ static snd_pcm_sframes_t snd_pcm_capture_forward(struct snd_pcm_substream *subst return ret; } -static int snd_pcm_hwsync(struct snd_pcm_substream *substream) +static int snd_pcm_hwsync(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; snd_pcm_stream_lock_irq(substream); @@ -2401,10 +2353,9 @@ static int snd_pcm_hwsync(struct snd_pcm_substream *substream) return err; } -static int snd_pcm_delay(struct snd_pcm_substream *substream, - snd_pcm_sframes_t __user *res) +static int snd_pcm_delay(snd_pcm_substream_t *substream, snd_pcm_sframes_t __user *res) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; snd_pcm_sframes_t n = 0; @@ -2440,19 +2391,18 @@ static int snd_pcm_delay(struct snd_pcm_substream *substream, return err; } -static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream, - struct snd_pcm_sync_ptr __user *_sync_ptr) +static int snd_pcm_sync_ptr(snd_pcm_substream_t *substream, struct sndrv_pcm_sync_ptr __user *_sync_ptr) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_pcm_sync_ptr sync_ptr; - volatile struct snd_pcm_mmap_status *status; - volatile struct snd_pcm_mmap_control *control; + snd_pcm_runtime_t *runtime = substream->runtime; + struct sndrv_pcm_sync_ptr sync_ptr; + volatile struct sndrv_pcm_mmap_status *status; + volatile struct sndrv_pcm_mmap_control *control; int err; memset(&sync_ptr, 0, sizeof(sync_ptr)); if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags))) return -EFAULT; - if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct snd_pcm_mmap_control))) + if (copy_from_user(&sync_ptr.c.control, &(_sync_ptr->c.control), sizeof(struct sndrv_pcm_mmap_control))) return -EFAULT; status = runtime->status; control = runtime->control; @@ -2480,12 +2430,12 @@ static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream, return 0; } -static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, +static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, unsigned int cmd, void __user *arg); -static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, +static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, unsigned int cmd, void __user *arg); -static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream, +static int snd_pcm_common_ioctl1(snd_pcm_substream_t *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2529,12 +2479,10 @@ static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream, return snd_pcm_delay(substream, arg); case SNDRV_PCM_IOCTL_SYNC_PTR: return snd_pcm_sync_ptr(substream, arg); -#ifdef CONFIG_SND_SUPPORT_OLD_API case SNDRV_PCM_IOCTL_HW_REFINE_OLD: return snd_pcm_hw_refine_old_user(substream, arg); case SNDRV_PCM_IOCTL_HW_PARAMS_OLD: return snd_pcm_hw_params_old_user(substream, arg); -#endif case SNDRV_PCM_IOCTL_DRAIN: return snd_pcm_drain(substream); case SNDRV_PCM_IOCTL_DROP: @@ -2544,7 +2492,7 @@ static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream, return -ENOTTY; } -static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, +static int snd_pcm_playback_ioctl1(snd_pcm_substream_t *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2552,9 +2500,9 @@ static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, switch (cmd) { case SNDRV_PCM_IOCTL_WRITEI_FRAMES: { - struct snd_xferi xferi; - struct snd_xferi __user *_xferi = arg; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_xferi_t xferi; + snd_xferi_t __user *_xferi = arg; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; @@ -2568,9 +2516,9 @@ static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, } case SNDRV_PCM_IOCTL_WRITEN_FRAMES: { - struct snd_xfern xfern; - struct snd_xfern __user *_xfern = arg; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_xfern_t xfern; + snd_xfern_t __user *_xfern = arg; + snd_pcm_runtime_t *runtime = substream->runtime; void __user **bufs; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) @@ -2631,7 +2579,7 @@ static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream, return snd_pcm_common_ioctl1(substream, cmd, arg); } -static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, +static int snd_pcm_capture_ioctl1(snd_pcm_substream_t *substream, unsigned int cmd, void __user *arg) { snd_assert(substream != NULL, return -ENXIO); @@ -2639,9 +2587,9 @@ static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, switch (cmd) { case SNDRV_PCM_IOCTL_READI_FRAMES: { - struct snd_xferi xferi; - struct snd_xferi __user *_xferi = arg; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_xferi_t xferi; + snd_xferi_t __user *_xferi = arg; + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) return -EBADFD; @@ -2655,9 +2603,9 @@ static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, } case SNDRV_PCM_IOCTL_READN_FRAMES: { - struct snd_xfern xfern; - struct snd_xfern __user *_xfern = arg; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_xfern_t xfern; + snd_xfern_t __user *_xfern = arg; + snd_pcm_runtime_t *runtime = substream->runtime; void *bufs; snd_pcm_sframes_t result; if (runtime->status->state == SNDRV_PCM_STATE_OPEN) @@ -2710,10 +2658,9 @@ static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream, return snd_pcm_common_ioctl1(substream, cmd, arg); } -static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, - unsigned long arg) +static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_pcm_file *pcm_file; + snd_pcm_file_t *pcm_file; pcm_file = file->private_data; @@ -2723,10 +2670,9 @@ static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd, return snd_pcm_playback_ioctl1(pcm_file->substream, cmd, (void __user *)arg); } -static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, - unsigned long arg) +static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_pcm_file *pcm_file; + snd_pcm_file_t *pcm_file; pcm_file = file->private_data; @@ -2736,7 +2682,7 @@ static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd, return snd_pcm_capture_ioctl1(pcm_file->substream, cmd, (void __user *)arg); } -int snd_pcm_kernel_playback_ioctl(struct snd_pcm_substream *substream, +int snd_pcm_kernel_playback_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg) { mm_segment_t fs; @@ -2748,7 +2694,7 @@ int snd_pcm_kernel_playback_ioctl(struct snd_pcm_substream *substream, return result; } -int snd_pcm_kernel_capture_ioctl(struct snd_pcm_substream *substream, +int snd_pcm_kernel_capture_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg) { mm_segment_t fs; @@ -2760,7 +2706,7 @@ int snd_pcm_kernel_capture_ioctl(struct snd_pcm_substream *substream, return result; } -int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, +int snd_pcm_kernel_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg) { switch (substream->stream) { @@ -2773,12 +2719,11 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, } } -static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, - loff_t * offset) +static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, loff_t * offset) { - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_sframes_t result; pcm_file = file->private_data; @@ -2796,12 +2741,11 @@ static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count, return result; } -static ssize_t snd_pcm_write(struct file *file, const char __user *buf, - size_t count, loff_t * offset) +static ssize_t snd_pcm_write(struct file *file, const char __user *buf, size_t count, loff_t * offset) { - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_sframes_t result; pcm_file = file->private_data; @@ -2828,9 +2772,9 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector, unsigned long count, loff_t * offset) { - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_sframes_t result; unsigned long i; void __user **bufs; @@ -2862,9 +2806,9 @@ static ssize_t snd_pcm_readv(struct file *file, const struct iovec *_vector, static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector, unsigned long count, loff_t * offset) { - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_pcm_sframes_t result; unsigned long i; void __user **bufs; @@ -2899,9 +2843,9 @@ static ssize_t snd_pcm_writev(struct file *file, const struct iovec *_vector, static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait) { - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; unsigned int mask; snd_pcm_uframes_t avail; @@ -2937,9 +2881,9 @@ static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait) static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait) { - struct snd_pcm_file *pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_file_t *pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; unsigned int mask; snd_pcm_uframes_t avail; @@ -2989,11 +2933,10 @@ static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait) /* * mmap status record */ -static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area, - unsigned long address, int *type) +static struct page * snd_pcm_mmap_status_nopage(struct vm_area_struct *area, unsigned long address, int *type) { - struct snd_pcm_substream *substream = area->vm_private_data; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; + snd_pcm_runtime_t *runtime; struct page * page; if (substream == NULL) @@ -3011,17 +2954,17 @@ static struct vm_operations_struct snd_pcm_vm_ops_status = .nopage = snd_pcm_mmap_status_nopage, }; -static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, +static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file, struct vm_area_struct *area) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; long size; if (!(area->vm_flags & VM_READ)) return -EINVAL; runtime = substream->runtime; snd_assert(runtime != NULL, return -EAGAIN); size = area->vm_end - area->vm_start; - if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))) + if (size != PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t))) return -EINVAL; area->vm_ops = &snd_pcm_vm_ops_status; area->vm_private_data = substream; @@ -3032,11 +2975,10 @@ static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file /* * mmap control record */ -static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area, - unsigned long address, int *type) +static struct page * snd_pcm_mmap_control_nopage(struct vm_area_struct *area, unsigned long address, int *type) { - struct snd_pcm_substream *substream = area->vm_private_data; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; + snd_pcm_runtime_t *runtime; struct page * page; if (substream == NULL) @@ -3054,17 +2996,17 @@ static struct vm_operations_struct snd_pcm_vm_ops_control = .nopage = snd_pcm_mmap_control_nopage, }; -static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, +static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *file, struct vm_area_struct *area) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; long size; if (!(area->vm_flags & VM_READ)) return -EINVAL; runtime = substream->runtime; snd_assert(runtime != NULL, return -EAGAIN); size = area->vm_end - area->vm_start; - if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))) + if (size != PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t))) return -EINVAL; area->vm_ops = &snd_pcm_vm_ops_control; area->vm_private_data = substream; @@ -3075,12 +3017,12 @@ static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file /* * don't support mmap for status and control records. */ -static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file *file, +static int snd_pcm_mmap_status(snd_pcm_substream_t *substream, struct file *file, struct vm_area_struct *area) { return -ENXIO; } -static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file *file, +static int snd_pcm_mmap_control(snd_pcm_substream_t *substream, struct file *file, struct vm_area_struct *area) { return -ENXIO; @@ -3090,11 +3032,10 @@ static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file /* * nopage callback for mmapping a RAM page */ -static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area, - unsigned long address, int *type) +static struct page *snd_pcm_mmap_data_nopage(struct vm_area_struct *area, unsigned long address, int *type) { - struct snd_pcm_substream *substream = area->vm_private_data; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream = (snd_pcm_substream_t *)area->vm_private_data; + snd_pcm_runtime_t *runtime; unsigned long offset; struct page * page; void *vaddr; @@ -3133,8 +3074,7 @@ static struct vm_operations_struct snd_pcm_vm_ops_data = /* * mmap the DMA buffer on RAM */ -static int snd_pcm_default_mmap(struct snd_pcm_substream *substream, - struct vm_area_struct *area) +static int snd_pcm_default_mmap(snd_pcm_substream_t *substream, struct vm_area_struct *area) { area->vm_ops = &snd_pcm_vm_ops_data; area->vm_private_data = substream; @@ -3153,8 +3093,7 @@ static struct vm_operations_struct snd_pcm_vm_ops_data_mmio = .close = snd_pcm_mmap_data_close, }; -int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, - struct vm_area_struct *area) +int snd_pcm_lib_mmap_iomem(snd_pcm_substream_t *substream, struct vm_area_struct *area) { long size; unsigned long offset; @@ -3179,10 +3118,10 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, /* * mmap DMA buffer */ -int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, +int snd_pcm_mmap_data(snd_pcm_substream_t *substream, struct file *file, struct vm_area_struct *area) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; long size; unsigned long offset; size_t dma_bytes; @@ -3219,8 +3158,8 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) { - struct snd_pcm_file * pcm_file; - struct snd_pcm_substream *substream; + snd_pcm_file_t * pcm_file; + snd_pcm_substream_t *substream; unsigned long offset; pcm_file = file->private_data; @@ -3245,9 +3184,9 @@ static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area) static int snd_pcm_fasync(int fd, struct file * file, int on) { - struct snd_pcm_file * pcm_file; - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_file_t * pcm_file; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; int err; pcm_file = file->private_data; @@ -3274,12 +3213,10 @@ static int snd_pcm_fasync(int fd, struct file * file, int on) * To be removed helpers to keep binary compatibility */ -#ifdef CONFIG_SND_SUPPORT_OLD_API #define __OLD_TO_NEW_MASK(x) ((x&7)|((x&0x07fffff8)<<5)) #define __NEW_TO_OLD_MASK(x) ((x&7)|((x&0xffffff00)>>5)) -static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_params_old *oparams) +static void snd_pcm_hw_convert_from_old_params(snd_pcm_hw_params_t *params, struct sndrv_pcm_hw_params_old *oparams) { unsigned int i; @@ -3297,8 +3234,7 @@ static void snd_pcm_hw_convert_from_old_params(struct snd_pcm_hw_params *params, params->fifo_size = oparams->fifo_size; } -static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *oparams, - struct snd_pcm_hw_params *params) +static void snd_pcm_hw_convert_to_old_params(struct sndrv_pcm_hw_params_old *oparams, snd_pcm_hw_params_t *params) { unsigned int i; @@ -3316,11 +3252,10 @@ static void snd_pcm_hw_convert_to_old_params(struct snd_pcm_hw_params_old *opara oparams->fifo_size = params->fifo_size; } -static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params_old __user * _oparams) +static int snd_pcm_hw_refine_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams) { - struct snd_pcm_hw_params *params; - struct snd_pcm_hw_params_old *oparams = NULL; + snd_pcm_hw_params_t *params; + struct sndrv_pcm_hw_params_old *oparams = NULL; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -3351,11 +3286,10 @@ static int snd_pcm_hw_refine_old_user(struct snd_pcm_substream *substream, return err; } -static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params_old __user * _oparams) +static int snd_pcm_hw_params_old_user(snd_pcm_substream_t * substream, struct sndrv_pcm_hw_params_old __user * _oparams) { - struct snd_pcm_hw_params *params; - struct snd_pcm_hw_params_old *oparams = NULL; + snd_pcm_hw_params_t *params; + struct sndrv_pcm_hw_params_old *oparams = NULL; int err; params = kmalloc(sizeof(*params), GFP_KERNEL); @@ -3384,35 +3318,45 @@ static int snd_pcm_hw_params_old_user(struct snd_pcm_substream *substream, kfree(oparams); return err; } -#endif /* CONFIG_SND_SUPPORT_OLD_API */ /* * Register section */ -struct file_operations snd_pcm_f_ops[2] = { +static struct file_operations snd_pcm_f_ops_playback = { + .owner = THIS_MODULE, + .write = snd_pcm_write, + .writev = snd_pcm_writev, + .open = snd_pcm_open, + .release = snd_pcm_release, + .poll = snd_pcm_playback_poll, + .unlocked_ioctl = snd_pcm_playback_ioctl, + .compat_ioctl = snd_pcm_ioctl_compat, + .mmap = snd_pcm_mmap, + .fasync = snd_pcm_fasync, +}; + +static struct file_operations snd_pcm_f_ops_capture = { + .owner = THIS_MODULE, + .read = snd_pcm_read, + .readv = snd_pcm_readv, + .open = snd_pcm_open, + .release = snd_pcm_release, + .poll = snd_pcm_capture_poll, + .unlocked_ioctl = snd_pcm_capture_ioctl, + .compat_ioctl = snd_pcm_ioctl_compat, + .mmap = snd_pcm_mmap, + .fasync = snd_pcm_fasync, +}; + +snd_minor_t snd_pcm_reg[2] = +{ { - .owner = THIS_MODULE, - .write = snd_pcm_write, - .writev = snd_pcm_writev, - .open = snd_pcm_playback_open, - .release = snd_pcm_release, - .poll = snd_pcm_playback_poll, - .unlocked_ioctl = snd_pcm_playback_ioctl, - .compat_ioctl = snd_pcm_ioctl_compat, - .mmap = snd_pcm_mmap, - .fasync = snd_pcm_fasync, + .comment = "digital audio playback", + .f_ops = &snd_pcm_f_ops_playback, }, { - .owner = THIS_MODULE, - .read = snd_pcm_read, - .readv = snd_pcm_readv, - .open = snd_pcm_capture_open, - .release = snd_pcm_release, - .poll = snd_pcm_capture_poll, - .unlocked_ioctl = snd_pcm_capture_ioctl, - .compat_ioctl = snd_pcm_ioctl_compat, - .mmap = snd_pcm_mmap, - .fasync = snd_pcm_fasync, + .comment = "digital audio capture", + .f_ops = &snd_pcm_f_ops_capture, } }; diff --git a/trunk/sound/core/pcm_timer.c b/trunk/sound/core/pcm_timer.c index d94ed16d21ea..884eaea31fec 100644 --- a/trunk/sound/core/pcm_timer.c +++ b/trunk/sound/core/pcm_timer.c @@ -45,10 +45,10 @@ static unsigned long gcd(unsigned long a, unsigned long b) return b; } -void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream) +void snd_pcm_timer_resolution_change(snd_pcm_substream_t *substream) { unsigned long rate, mult, fsize, l, post; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; mult = 1000000000; rate = runtime->rate; @@ -74,18 +74,18 @@ void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream) runtime->timer_resolution = (mult * fsize / rate) * post; } -static unsigned long snd_pcm_timer_resolution(struct snd_timer * timer) +static unsigned long snd_pcm_timer_resolution(snd_timer_t * timer) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t * substream; substream = timer->private_data; return substream->runtime ? substream->runtime->timer_resolution : 0; } -static int snd_pcm_timer_start(struct snd_timer * timer) +static int snd_pcm_timer_start(snd_timer_t * timer) { unsigned long flags; - struct snd_pcm_substream *substream; + snd_pcm_substream_t * substream; substream = snd_timer_chip(timer); spin_lock_irqsave(&substream->timer_lock, flags); @@ -94,10 +94,10 @@ static int snd_pcm_timer_start(struct snd_timer * timer) return 0; } -static int snd_pcm_timer_stop(struct snd_timer * timer) +static int snd_pcm_timer_stop(snd_timer_t * timer) { unsigned long flags; - struct snd_pcm_substream *substream; + snd_pcm_substream_t * substream; substream = snd_timer_chip(timer); spin_lock_irqsave(&substream->timer_lock, flags); @@ -106,7 +106,7 @@ static int snd_pcm_timer_stop(struct snd_timer * timer) return 0; } -static struct snd_timer_hardware snd_pcm_timer = +static struct _snd_timer_hardware snd_pcm_timer = { .flags = SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_SLAVE, .resolution = 0, @@ -120,16 +120,16 @@ static struct snd_timer_hardware snd_pcm_timer = * Init functions */ -static void snd_pcm_timer_free(struct snd_timer *timer) +static void snd_pcm_timer_free(snd_timer_t *timer) { - struct snd_pcm_substream *substream = timer->private_data; + snd_pcm_substream_t *substream = timer->private_data; substream->timer = NULL; } -void snd_pcm_timer_init(struct snd_pcm_substream *substream) +void snd_pcm_timer_init(snd_pcm_substream_t *substream) { - struct snd_timer_id tid; - struct snd_timer *timer; + snd_timer_id_t tid; + snd_timer_t *timer; tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE; tid.dev_class = SNDRV_TIMER_CLASS_PCM; @@ -152,7 +152,7 @@ void snd_pcm_timer_init(struct snd_pcm_substream *substream) substream->timer = timer; } -void snd_pcm_timer_done(struct snd_pcm_substream *substream) +void snd_pcm_timer_done(snd_pcm_substream_t *substream) { if (substream->timer) { snd_device_free(substream->pcm->card, substream->timer); diff --git a/trunk/sound/core/rawmidi.c b/trunk/sound/core/rawmidi.c index d4d124e21924..d033e61c05c7 100644 --- a/trunk/sound/core/rawmidi.c +++ b/trunk/sound/core/rawmidi.c @@ -50,27 +50,15 @@ module_param_array(amidi_map, int, NULL, 0444); MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device."); #endif /* CONFIG_SND_OSSEMUL */ -static int snd_rawmidi_free(struct snd_rawmidi *rawmidi); -static int snd_rawmidi_dev_free(struct snd_device *device); -static int snd_rawmidi_dev_register(struct snd_device *device); -static int snd_rawmidi_dev_disconnect(struct snd_device *device); -static int snd_rawmidi_dev_unregister(struct snd_device *device); +static int snd_rawmidi_free(snd_rawmidi_t *rawmidi); +static int snd_rawmidi_dev_free(snd_device_t *device); +static int snd_rawmidi_dev_register(snd_device_t *device); +static int snd_rawmidi_dev_disconnect(snd_device_t *device); +static int snd_rawmidi_dev_unregister(snd_device_t *device); -static LIST_HEAD(snd_rawmidi_devices); -static DECLARE_MUTEX(register_mutex); - -static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device) -{ - struct list_head *p; - struct snd_rawmidi *rawmidi; +static snd_rawmidi_t *snd_rawmidi_devices[SNDRV_CARDS * SNDRV_RAWMIDI_DEVICES]; - list_for_each(p, &snd_rawmidi_devices) { - rawmidi = list_entry(p, struct snd_rawmidi, list); - if (rawmidi->card == card && rawmidi->device == device) - return rawmidi; - } - return NULL; -} +static DECLARE_MUTEX(register_mutex); static inline unsigned short snd_rawmidi_file_flags(struct file *file) { @@ -84,35 +72,34 @@ static inline unsigned short snd_rawmidi_file_flags(struct file *file) } } -static inline int snd_rawmidi_ready(struct snd_rawmidi_substream *substream) +static inline int snd_rawmidi_ready(snd_rawmidi_substream_t * substream) { - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; return runtime->avail >= runtime->avail_min; } -static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream, - size_t count) +static inline int snd_rawmidi_ready_append(snd_rawmidi_substream_t * substream, size_t count) { - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; return runtime->avail >= runtime->avail_min && (!substream->append || runtime->avail >= count); } static void snd_rawmidi_input_event_tasklet(unsigned long data) { - struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *)data; + snd_rawmidi_substream_t *substream = (snd_rawmidi_substream_t *)data; substream->runtime->event(substream); } static void snd_rawmidi_output_trigger_tasklet(unsigned long data) { - struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *)data; + snd_rawmidi_substream_t *substream = (snd_rawmidi_substream_t *)data; substream->ops->trigger(substream, 1); } -static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream) +static int snd_rawmidi_runtime_create(snd_rawmidi_substream_t * substream) { - struct snd_rawmidi_runtime *runtime; + snd_rawmidi_runtime_t *runtime; if ((runtime = kzalloc(sizeof(*runtime), GFP_KERNEL)) == NULL) return -ENOMEM; @@ -142,9 +129,9 @@ static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream) return 0; } -static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream) +static int snd_rawmidi_runtime_free(snd_rawmidi_substream_t * substream) { - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; kfree(runtime->buffer); kfree(runtime); @@ -152,7 +139,7 @@ static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream) return 0; } -static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream,int up) +static inline void snd_rawmidi_output_trigger(snd_rawmidi_substream_t * substream, int up) { if (up) { tasklet_hi_schedule(&substream->runtime->tasklet); @@ -162,17 +149,17 @@ static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *subs } } -static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_rawmidi_input_trigger(snd_rawmidi_substream_t * substream, int up) { substream->ops->trigger(substream, up); if (!up && substream->runtime->event) tasklet_kill(&substream->runtime->tasklet); } -int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream) +int snd_rawmidi_drop_output(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; snd_rawmidi_output_trigger(substream, 0); runtime->drain = 0; @@ -183,11 +170,11 @@ int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream) return 0; } -int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream) +int snd_rawmidi_drain_output(snd_rawmidi_substream_t * substream) { int err; long timeout; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; err = 0; runtime->drain = 1; @@ -212,10 +199,10 @@ int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream) return err; } -int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream) +int snd_rawmidi_drain_input(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; snd_rawmidi_input_trigger(substream, 0); runtime->drain = 0; @@ -226,20 +213,18 @@ int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream) return 0; } -int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, - int mode, struct snd_rawmidi_file * rfile) +int snd_rawmidi_kernel_open(int cardnum, int device, int subdevice, + int mode, snd_rawmidi_file_t * rfile) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; struct list_head *list1, *list2; - struct snd_rawmidi_substream *sinput = NULL, *soutput = NULL; - struct snd_rawmidi_runtime *input = NULL, *output = NULL; + snd_rawmidi_substream_t *sinput = NULL, *soutput = NULL; + snd_rawmidi_runtime_t *input = NULL, *output = NULL; int err; if (rfile) rfile->input = rfile->output = NULL; - down(®ister_mutex); - rmidi = snd_rawmidi_search(card, device); - up(®ister_mutex); + rmidi = snd_rawmidi_devices[(cardnum * SNDRV_RAWMIDI_DEVICES) + device]; if (rmidi == NULL) { err = -ENODEV; goto __error1; @@ -290,7 +275,7 @@ int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, } break; } - sinput = list_entry(list1, struct snd_rawmidi_substream, list); + sinput = list_entry(list1, snd_rawmidi_substream_t, list); if ((mode & SNDRV_RAWMIDI_LFLG_INPUT) && sinput->opened) goto __nexti; if (subdevice < 0 || (subdevice >= 0 && subdevice == sinput->number)) @@ -308,7 +293,7 @@ int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, } break; } - soutput = list_entry(list2, struct snd_rawmidi_substream, list); + soutput = list_entry(list2, snd_rawmidi_substream_t, list); if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) { if (mode & SNDRV_RAWMIDI_LFLG_APPEND) { if (soutput->opened && !soutput->append) @@ -382,29 +367,39 @@ int snd_rawmidi_kernel_open(struct snd_card *card, int device, int subdevice, static int snd_rawmidi_open(struct inode *inode, struct file *file) { int maj = imajor(inode); - struct snd_card *card; - int subdevice; + int cardnum; + snd_card_t *card; + int device, subdevice; unsigned short fflags; int err; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_file *rawmidi_file; + snd_rawmidi_t *rmidi; + snd_rawmidi_file_t *rawmidi_file; wait_queue_t wait; struct list_head *list; - struct snd_ctl_file *kctl; + snd_ctl_file_t *kctl; if (maj == snd_major) { - rmidi = snd_lookup_minor_data(iminor(inode), - SNDRV_DEVICE_TYPE_RAWMIDI); + cardnum = SNDRV_MINOR_CARD(iminor(inode)); + cardnum %= SNDRV_CARDS; + device = SNDRV_MINOR_DEVICE(iminor(inode)) - SNDRV_MINOR_RAWMIDI; + device %= SNDRV_MINOR_RAWMIDIS; #ifdef CONFIG_SND_OSSEMUL } else if (maj == SOUND_MAJOR) { - rmidi = snd_lookup_oss_minor_data(iminor(inode), - SNDRV_OSS_DEVICE_TYPE_MIDI); + cardnum = SNDRV_MINOR_OSS_CARD(iminor(inode)); + cardnum %= SNDRV_CARDS; + device = SNDRV_MINOR_OSS_DEVICE(iminor(inode)) == SNDRV_MINOR_OSS_MIDI ? + midi_map[cardnum] : amidi_map[cardnum]; #endif } else return -ENXIO; + rmidi = snd_rawmidi_devices[(cardnum * SNDRV_RAWMIDI_DEVICES) + device]; if (rmidi == NULL) return -ENODEV; +#ifdef CONFIG_SND_OSSEMUL + if (maj == SOUND_MAJOR && !rmidi->ossreg) + return -ENXIO; +#endif if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) return -EINVAL; /* invalid combination */ card = rmidi->card; @@ -434,8 +429,7 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file) } } up_read(&card->controls_rwsem); - err = snd_rawmidi_kernel_open(rmidi->card, rmidi->device, - subdevice, fflags, rawmidi_file); + err = snd_rawmidi_kernel_open(cardnum, device, subdevice, fflags, rawmidi_file); if (err >= 0) break; if (err == -EAGAIN) { @@ -471,11 +465,11 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file) return err; } -int snd_rawmidi_kernel_release(struct snd_rawmidi_file * rfile) +int snd_rawmidi_kernel_release(snd_rawmidi_file_t * rfile) { - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *substream; - struct snd_rawmidi_runtime *runtime; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *substream; + snd_rawmidi_runtime_t *runtime; snd_assert(rfile != NULL, return -ENXIO); snd_assert(rfile->input != NULL || rfile->output != NULL, return -ENXIO); @@ -521,8 +515,8 @@ int snd_rawmidi_kernel_release(struct snd_rawmidi_file * rfile) static int snd_rawmidi_release(struct inode *inode, struct file *file) { - struct snd_rawmidi_file *rfile; - struct snd_rawmidi *rmidi; + snd_rawmidi_file_t *rfile; + snd_rawmidi_t *rmidi; int err; rfile = file->private_data; @@ -534,10 +528,9 @@ static int snd_rawmidi_release(struct inode *inode, struct file *file) return err; } -static int snd_rawmidi_info(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_info *info) +int snd_rawmidi_info(snd_rawmidi_substream_t *substream, snd_rawmidi_info_t *info) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; if (substream == NULL) return -ENODEV; @@ -557,30 +550,26 @@ static int snd_rawmidi_info(struct snd_rawmidi_substream *substream, return 0; } -static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_info __user * _info) +static int snd_rawmidi_info_user(snd_rawmidi_substream_t *substream, snd_rawmidi_info_t __user * _info) { - struct snd_rawmidi_info info; + snd_rawmidi_info_t info; int err; if ((err = snd_rawmidi_info(substream, &info)) < 0) return err; - if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) + if (copy_to_user(_info, &info, sizeof(snd_rawmidi_info_t))) return -EFAULT; return 0; } -int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info) +int snd_rawmidi_info_select(snd_card_t *card, snd_rawmidi_info_t *info) { - struct snd_rawmidi *rmidi; - struct snd_rawmidi_str *pstr; - struct snd_rawmidi_substream *substream; + snd_rawmidi_t *rmidi; + snd_rawmidi_str_t *pstr; + snd_rawmidi_substream_t *substream; struct list_head *list; - - down(®ister_mutex); - rmidi = snd_rawmidi_search(card, info->device); - up(®ister_mutex); - if (!rmidi) + if (info->device >= SNDRV_RAWMIDI_DEVICES) return -ENXIO; + rmidi = snd_rawmidi_devices[card->number * SNDRV_RAWMIDI_DEVICES + info->device]; if (info->stream < 0 || info->stream > 1) return -EINVAL; pstr = &rmidi->streams[info->stream]; @@ -589,18 +578,18 @@ int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info if (info->subdevice >= pstr->substream_count) return -ENXIO; list_for_each(list, &pstr->substreams) { - substream = list_entry(list, struct snd_rawmidi_substream, list); + substream = list_entry(list, snd_rawmidi_substream_t, list); if ((unsigned int)substream->number == info->subdevice) return snd_rawmidi_info(substream, info); } return -ENXIO; } -static int snd_rawmidi_info_select_user(struct snd_card *card, - struct snd_rawmidi_info __user *_info) +static int snd_rawmidi_info_select_user(snd_card_t *card, + snd_rawmidi_info_t __user *_info) { int err; - struct snd_rawmidi_info info; + snd_rawmidi_info_t info; if (get_user(info.device, &_info->device)) return -EFAULT; if (get_user(info.stream, &_info->stream)) @@ -609,16 +598,16 @@ static int snd_rawmidi_info_select_user(struct snd_card *card, return -EFAULT; if ((err = snd_rawmidi_info_select(card, &info)) < 0) return err; - if (copy_to_user(_info, &info, sizeof(struct snd_rawmidi_info))) + if (copy_to_user(_info, &info, sizeof(snd_rawmidi_info_t))) return -EFAULT; return 0; } -int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_params * params) +int snd_rawmidi_output_params(snd_rawmidi_substream_t * substream, + snd_rawmidi_params_t * params) { char *newbuf; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; if (substream->append && substream->use_count > 1) return -EBUSY; @@ -635,18 +624,17 @@ int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream, kfree(runtime->buffer); runtime->buffer = newbuf; runtime->buffer_size = params->buffer_size; - runtime->avail = runtime->buffer_size; } runtime->avail_min = params->avail_min; substream->active_sensing = !params->no_active_sensing; return 0; } -int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_params * params) +int snd_rawmidi_input_params(snd_rawmidi_substream_t * substream, + snd_rawmidi_params_t * params) { char *newbuf; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; snd_rawmidi_drain_input(substream); if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L) { @@ -666,10 +654,10 @@ int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream, return 0; } -static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_status * status) +static int snd_rawmidi_output_status(snd_rawmidi_substream_t * substream, + snd_rawmidi_status_t * status) { - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; memset(status, 0, sizeof(*status)); status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT; @@ -679,10 +667,10 @@ static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream, return 0; } -static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream, - struct snd_rawmidi_status * status) +static int snd_rawmidi_input_status(snd_rawmidi_substream_t * substream, + snd_rawmidi_status_t * status) { - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; memset(status, 0, sizeof(*status)); status->stream = SNDRV_RAWMIDI_STREAM_INPUT; @@ -696,7 +684,7 @@ static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream, static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_rawmidi_file *rfile; + snd_rawmidi_file_t *rfile; void __user *argp = (void __user *)arg; rfile = file->private_data; @@ -707,8 +695,8 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long return put_user(SNDRV_RAWMIDI_VERSION, (int __user *)argp) ? -EFAULT : 0; case SNDRV_RAWMIDI_IOCTL_INFO: { - int stream; - struct snd_rawmidi_info __user *info = argp; + snd_rawmidi_stream_t stream; + snd_rawmidi_info_t __user *info = argp; if (get_user(stream, &info->stream)) return -EFAULT; switch (stream) { @@ -722,8 +710,8 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long } case SNDRV_RAWMIDI_IOCTL_PARAMS: { - struct snd_rawmidi_params params; - if (copy_from_user(¶ms, argp, sizeof(struct snd_rawmidi_params))) + snd_rawmidi_params_t params; + if (copy_from_user(¶ms, argp, sizeof(snd_rawmidi_params_t))) return -EFAULT; switch (params.stream) { case SNDRV_RAWMIDI_STREAM_OUTPUT: @@ -741,8 +729,8 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long case SNDRV_RAWMIDI_IOCTL_STATUS: { int err = 0; - struct snd_rawmidi_status status; - if (copy_from_user(&status, argp, sizeof(struct snd_rawmidi_status))) + snd_rawmidi_status_t status; + if (copy_from_user(&status, argp, sizeof(snd_rawmidi_status_t))) return -EFAULT; switch (status.stream) { case SNDRV_RAWMIDI_STREAM_OUTPUT: @@ -760,7 +748,7 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long } if (err < 0) return err; - if (copy_to_user(argp, &status, sizeof(struct snd_rawmidi_status))) + if (copy_to_user(argp, &status, sizeof(snd_rawmidi_status_t))) return -EFAULT; return 0; } @@ -804,13 +792,15 @@ static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long return -ENOTTY; } -static int snd_rawmidi_control_ioctl(struct snd_card *card, - struct snd_ctl_file *control, +static int snd_rawmidi_control_ioctl(snd_card_t * card, + snd_ctl_file_t * control, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; + unsigned int tmp; + tmp = card->number * SNDRV_RAWMIDI_DEVICES; switch (cmd) { case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE: { @@ -818,16 +808,14 @@ static int snd_rawmidi_control_ioctl(struct snd_card *card, if (get_user(device, (int __user *)argp)) return -EFAULT; - down(®ister_mutex); device = device < 0 ? 0 : device + 1; while (device < SNDRV_RAWMIDI_DEVICES) { - if (snd_rawmidi_search(card, device)) + if (snd_rawmidi_devices[tmp + device]) break; device++; } if (device == SNDRV_RAWMIDI_DEVICES) device = -1; - up(®ister_mutex); if (put_user(device, (int __user *)argp)) return -EFAULT; return 0; @@ -857,12 +845,11 @@ static int snd_rawmidi_control_ioctl(struct snd_card *card, * * Returns the size of read data, or a negative error code on failure. */ -int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, - const unsigned char *buffer, int count) +int snd_rawmidi_receive(snd_rawmidi_substream_t * substream, const unsigned char *buffer, int count) { unsigned long flags; int result = 0, count1; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; if (runtime->buffer == NULL) { snd_printd("snd_rawmidi_receive: input is not active!!!\n"); @@ -917,12 +904,12 @@ int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, return result; } -static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream, +static long snd_rawmidi_kernel_read1(snd_rawmidi_substream_t *substream, unsigned char *buf, long count, int kernel) { unsigned long flags; long result = 0, count1; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; while (count > 0 && runtime->avail) { count1 = runtime->buffer_size - runtime->appl_ptr; @@ -951,21 +938,19 @@ static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream, return result; } -long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream, - unsigned char *buf, long count) +long snd_rawmidi_kernel_read(snd_rawmidi_substream_t *substream, unsigned char *buf, long count) { snd_rawmidi_input_trigger(substream, 1); return snd_rawmidi_kernel_read1(substream, buf, count, 1); } -static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count, - loff_t *offset) +static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { long result; int count1; - struct snd_rawmidi_file *rfile; - struct snd_rawmidi_substream *substream; - struct snd_rawmidi_runtime *runtime; + snd_rawmidi_file_t *rfile; + snd_rawmidi_substream_t *substream; + snd_rawmidi_runtime_t *runtime; rfile = file->private_data; substream = rfile->input; @@ -1013,9 +998,9 @@ static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t coun * * Returns 1 if the internal output buffer is empty, 0 if not. */ -int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream) +int snd_rawmidi_transmit_empty(snd_rawmidi_substream_t * substream) { - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; int result; unsigned long flags; @@ -1043,12 +1028,11 @@ int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream) * * Returns the size of copied data, or a negative error code on failure. */ -int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, - unsigned char *buffer, int count) +int snd_rawmidi_transmit_peek(snd_rawmidi_substream_t * substream, unsigned char *buffer, int count) { unsigned long flags; int result, count1; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; if (runtime->buffer == NULL) { snd_printd("snd_rawmidi_transmit_peek: output is not active!!!\n"); @@ -1095,10 +1079,10 @@ int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, * * Returns the advanced size if successful, or a negative error code on failure. */ -int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) +int snd_rawmidi_transmit_ack(snd_rawmidi_substream_t * substream, int count) { unsigned long flags; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; if (runtime->buffer == NULL) { snd_printd("snd_rawmidi_transmit_ack: output is not active!!!\n"); @@ -1128,8 +1112,7 @@ int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count) * * Returns the copied size if successful, or a negative error code on failure. */ -int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, - unsigned char *buffer, int count) +int snd_rawmidi_transmit(snd_rawmidi_substream_t * substream, unsigned char *buffer, int count) { count = snd_rawmidi_transmit_peek(substream, buffer, count); if (count < 0) @@ -1137,12 +1120,11 @@ int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, return snd_rawmidi_transmit_ack(substream, count); } -static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, - const unsigned char *buf, long count, int kernel) +static long snd_rawmidi_kernel_write1(snd_rawmidi_substream_t * substream, const unsigned char *buf, long count, int kernel) { unsigned long flags; long count1, result; - struct snd_rawmidi_runtime *runtime = substream->runtime; + snd_rawmidi_runtime_t *runtime = substream->runtime; snd_assert(buf != NULL, return -EINVAL); snd_assert(runtime->buffer != NULL, return -EINVAL); @@ -1188,20 +1170,18 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream, return result; } -long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream, - const unsigned char *buf, long count) +long snd_rawmidi_kernel_write(snd_rawmidi_substream_t * substream, const unsigned char *buf, long count) { return snd_rawmidi_kernel_write1(substream, buf, count, 1); } -static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, - size_t count, loff_t *offset) +static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { long result, timeout; int count1; - struct snd_rawmidi_file *rfile; - struct snd_rawmidi_runtime *runtime; - struct snd_rawmidi_substream *substream; + snd_rawmidi_file_t *rfile; + snd_rawmidi_runtime_t *runtime; + snd_rawmidi_substream_t *substream; rfile = file->private_data; substream = rfile->output; @@ -1266,8 +1246,8 @@ static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf, static unsigned int snd_rawmidi_poll(struct file *file, poll_table * wait) { - struct snd_rawmidi_file *rfile; - struct snd_rawmidi_runtime *runtime; + snd_rawmidi_file_t *rfile; + snd_rawmidi_runtime_t *runtime; unsigned int mask; rfile = file->private_data; @@ -1304,12 +1284,12 @@ static unsigned int snd_rawmidi_poll(struct file *file, poll_table * wait) */ -static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_rawmidi_proc_info_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *substream; - struct snd_rawmidi_runtime *runtime; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *substream; + snd_rawmidi_runtime_t *runtime; struct list_head *list; rmidi = entry->private_data; @@ -1317,7 +1297,7 @@ static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, down(&rmidi->open_mutex); if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) { list_for_each(list, &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { - substream = list_entry(list, struct snd_rawmidi_substream, list); + substream = list_entry(list, snd_rawmidi_substream_t, list); snd_iprintf(buffer, "Output %d\n" " Tx bytes : %lu\n", @@ -1337,7 +1317,7 @@ static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry, } if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT) { list_for_each(list, &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { - substream = list_entry(list, struct snd_rawmidi_substream, list); + substream = list_entry(list, snd_rawmidi_substream_t, list); snd_iprintf(buffer, "Input %d\n" " Rx bytes : %lu\n", @@ -1374,21 +1354,25 @@ static struct file_operations snd_rawmidi_f_ops = .compat_ioctl = snd_rawmidi_ioctl_compat, }; -static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi, - struct snd_rawmidi_str *stream, +static snd_minor_t snd_rawmidi_reg = +{ + .comment = "raw midi", + .f_ops = &snd_rawmidi_f_ops, +}; + +static int snd_rawmidi_alloc_substreams(snd_rawmidi_t *rmidi, + snd_rawmidi_str_t *stream, int direction, int count) { - struct snd_rawmidi_substream *substream; + snd_rawmidi_substream_t *substream; int idx; INIT_LIST_HEAD(&stream->substreams); for (idx = 0; idx < count; idx++) { substream = kzalloc(sizeof(*substream), GFP_KERNEL); - if (substream == NULL) { - snd_printk(KERN_ERR "rawmidi: cannot allocate substream\n"); + if (substream == NULL) return -ENOMEM; - } substream->stream = direction; substream->number = idx; substream->rmidi = rmidi; @@ -1413,13 +1397,13 @@ static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi, * * Returns zero if successful, or a negative error code on failure. */ -int snd_rawmidi_new(struct snd_card *card, char *id, int device, +int snd_rawmidi_new(snd_card_t * card, char *id, int device, int output_count, int input_count, - struct snd_rawmidi ** rrawmidi) + snd_rawmidi_t ** rrawmidi) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_rawmidi_dev_free, .dev_register = snd_rawmidi_dev_register, .dev_disconnect = snd_rawmidi_dev_disconnect, @@ -1430,27 +1414,19 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device, *rrawmidi = NULL; snd_assert(card != NULL, return -ENXIO); rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL); - if (rmidi == NULL) { - snd_printk(KERN_ERR "rawmidi: cannot allocate\n"); + if (rmidi == NULL) return -ENOMEM; - } rmidi->card = card; rmidi->device = device; init_MUTEX(&rmidi->open_mutex); init_waitqueue_head(&rmidi->open_wait); if (id != NULL) strlcpy(rmidi->id, id, sizeof(rmidi->id)); - if ((err = snd_rawmidi_alloc_substreams(rmidi, - &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT], - SNDRV_RAWMIDI_STREAM_INPUT, - input_count)) < 0) { + if ((err = snd_rawmidi_alloc_substreams(rmidi, &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT], SNDRV_RAWMIDI_STREAM_INPUT, input_count)) < 0) { snd_rawmidi_free(rmidi); return err; } - if ((err = snd_rawmidi_alloc_substreams(rmidi, - &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT], - SNDRV_RAWMIDI_STREAM_OUTPUT, - output_count)) < 0) { + if ((err = snd_rawmidi_alloc_substreams(rmidi, &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT], SNDRV_RAWMIDI_STREAM_OUTPUT, output_count)) < 0) { snd_rawmidi_free(rmidi); return err; } @@ -1462,18 +1438,18 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device, return 0; } -static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream) +static void snd_rawmidi_free_substreams(snd_rawmidi_str_t *stream) { - struct snd_rawmidi_substream *substream; + snd_rawmidi_substream_t *substream; while (!list_empty(&stream->substreams)) { - substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list); + substream = list_entry(stream->substreams.next, snd_rawmidi_substream_t, list); list_del(&substream->list); kfree(substream); } } -static int snd_rawmidi_free(struct snd_rawmidi *rmidi) +static int snd_rawmidi_free(snd_rawmidi_t *rmidi) { snd_assert(rmidi != NULL, return -ENXIO); snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]); @@ -1484,48 +1460,49 @@ static int snd_rawmidi_free(struct snd_rawmidi *rmidi) return 0; } -static int snd_rawmidi_dev_free(struct snd_device *device) +static int snd_rawmidi_dev_free(snd_device_t *device) { - struct snd_rawmidi *rmidi = device->device_data; + snd_rawmidi_t *rmidi = device->device_data; return snd_rawmidi_free(rmidi); } #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) -static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device) +static void snd_rawmidi_dev_seq_free(snd_seq_device_t *device) { - struct snd_rawmidi *rmidi = device->private_data; + snd_rawmidi_t *rmidi = device->private_data; rmidi->seq_dev = NULL; } #endif -static int snd_rawmidi_dev_register(struct snd_device *device) +static int snd_rawmidi_dev_register(snd_device_t *device) { - int err; - struct snd_info_entry *entry; + int idx, err; + snd_info_entry_t *entry; char name[16]; - struct snd_rawmidi *rmidi = device->device_data; + snd_rawmidi_t *rmidi = device->device_data; if (rmidi->device >= SNDRV_RAWMIDI_DEVICES) return -ENOMEM; down(®ister_mutex); - if (snd_rawmidi_search(rmidi->card, rmidi->device)) { + idx = (rmidi->card->number * SNDRV_RAWMIDI_DEVICES) + rmidi->device; + if (snd_rawmidi_devices[idx] != NULL) { up(®ister_mutex); return -EBUSY; } - list_add_tail(&rmidi->list, &snd_rawmidi_devices); + snd_rawmidi_devices[idx] = rmidi; sprintf(name, "midiC%iD%i", rmidi->card->number, rmidi->device); if ((err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device, - &snd_rawmidi_f_ops, rmidi, name)) < 0) { + &snd_rawmidi_reg, name)) < 0) { snd_printk(KERN_ERR "unable to register rawmidi device %i:%i\n", rmidi->card->number, rmidi->device); - list_del(&rmidi->list); + snd_rawmidi_devices[idx] = NULL; up(®ister_mutex); return err; } if (rmidi->ops && rmidi->ops->dev_register && (err = rmidi->ops->dev_register(rmidi)) < 0) { snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device); - list_del(&rmidi->list); + snd_rawmidi_devices[idx] = NULL; up(®ister_mutex); return err; } @@ -1533,8 +1510,7 @@ static int snd_rawmidi_dev_register(struct snd_device *device) rmidi->ossreg = 0; if ((int)rmidi->device == midi_map[rmidi->card->number]) { if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, - rmidi->card, 0, &snd_rawmidi_f_ops, - rmidi, name) < 0) { + rmidi->card, 0, &snd_rawmidi_reg, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 0); } else { rmidi->ossreg++; @@ -1545,8 +1521,7 @@ static int snd_rawmidi_dev_register(struct snd_device *device) } if ((int)rmidi->device == amidi_map[rmidi->card->number]) { if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, - rmidi->card, 1, &snd_rawmidi_f_ops, - rmidi, name) < 0) { + rmidi->card, 1, &snd_rawmidi_reg, name) < 0) { snd_printk(KERN_ERR "unable to register OSS rawmidi device %i:%i\n", rmidi->card->number, 1); } else { rmidi->ossreg++; @@ -1579,23 +1554,27 @@ static int snd_rawmidi_dev_register(struct snd_device *device) return 0; } -static int snd_rawmidi_dev_disconnect(struct snd_device *device) +static int snd_rawmidi_dev_disconnect(snd_device_t *device) { - struct snd_rawmidi *rmidi = device->device_data; + snd_rawmidi_t *rmidi = device->device_data; + int idx; down(®ister_mutex); - list_del_init(&rmidi->list); + idx = (rmidi->card->number * SNDRV_RAWMIDI_DEVICES) + rmidi->device; + snd_rawmidi_devices[idx] = NULL; up(®ister_mutex); return 0; } -static int snd_rawmidi_dev_unregister(struct snd_device *device) +static int snd_rawmidi_dev_unregister(snd_device_t *device) { - struct snd_rawmidi *rmidi = device->device_data; + int idx; + snd_rawmidi_t *rmidi = device->device_data; snd_assert(rmidi != NULL, return -ENXIO); down(®ister_mutex); - list_del(&rmidi->list); + idx = (rmidi->card->number * SNDRV_RAWMIDI_DEVICES) + rmidi->device; + snd_rawmidi_devices[idx] = NULL; if (rmidi->proc_entry) { snd_info_unregister(rmidi->proc_entry); rmidi->proc_entry = NULL; @@ -1634,14 +1613,13 @@ static int snd_rawmidi_dev_unregister(struct snd_device *device) * * Sets the rawmidi operators for the given stream direction. */ -void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream, - struct snd_rawmidi_ops *ops) +void snd_rawmidi_set_ops(snd_rawmidi_t *rmidi, int stream, snd_rawmidi_ops_t *ops) { struct list_head *list; - struct snd_rawmidi_substream *substream; + snd_rawmidi_substream_t *substream; list_for_each(list, &rmidi->streams[stream].substreams) { - substream = list_entry(list, struct snd_rawmidi_substream, list); + substream = list_entry(list, snd_rawmidi_substream_t, list); substream->ops = ops; } } @@ -1694,6 +1672,7 @@ EXPORT_SYMBOL(snd_rawmidi_transmit_ack); EXPORT_SYMBOL(snd_rawmidi_transmit); EXPORT_SYMBOL(snd_rawmidi_new); EXPORT_SYMBOL(snd_rawmidi_set_ops); +EXPORT_SYMBOL(snd_rawmidi_info); EXPORT_SYMBOL(snd_rawmidi_info_select); EXPORT_SYMBOL(snd_rawmidi_kernel_open); EXPORT_SYMBOL(snd_rawmidi_kernel_release); diff --git a/trunk/sound/core/rawmidi_compat.c b/trunk/sound/core/rawmidi_compat.c index 5268c1f58c25..d97631c3f3ad 100644 --- a/trunk/sound/core/rawmidi_compat.c +++ b/trunk/sound/core/rawmidi_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct snd_rawmidi_params32 { +struct sndrv_rawmidi_params32 { s32 stream; u32 buffer_size; u32 avail_min; @@ -30,10 +30,10 @@ struct snd_rawmidi_params32 { unsigned char reserved[16]; } __attribute__((packed)); -static int snd_rawmidi_ioctl_params_compat(struct snd_rawmidi_file *rfile, - struct snd_rawmidi_params32 __user *src) +static int snd_rawmidi_ioctl_params_compat(snd_rawmidi_file_t *rfile, + struct sndrv_rawmidi_params32 __user *src) { - struct snd_rawmidi_params params; + snd_rawmidi_params_t params; unsigned int val; if (rfile->output == NULL) @@ -53,7 +53,7 @@ static int snd_rawmidi_ioctl_params_compat(struct snd_rawmidi_file *rfile, return -EINVAL; } -struct snd_rawmidi_status32 { +struct sndrv_rawmidi_status32 { s32 stream; struct compat_timespec tstamp; u32 avail; @@ -61,11 +61,11 @@ struct snd_rawmidi_status32 { unsigned char reserved[16]; } __attribute__((packed)); -static int snd_rawmidi_ioctl_status_compat(struct snd_rawmidi_file *rfile, - struct snd_rawmidi_status32 __user *src) +static int snd_rawmidi_ioctl_status_compat(snd_rawmidi_file_t *rfile, + struct sndrv_rawmidi_status32 __user *src) { int err; - struct snd_rawmidi_status status; + snd_rawmidi_status_t status; if (rfile->output == NULL) return -EINVAL; @@ -95,13 +95,13 @@ static int snd_rawmidi_ioctl_status_compat(struct snd_rawmidi_file *rfile, } enum { - SNDRV_RAWMIDI_IOCTL_PARAMS32 = _IOWR('W', 0x10, struct snd_rawmidi_params32), - SNDRV_RAWMIDI_IOCTL_STATUS32 = _IOWR('W', 0x20, struct snd_rawmidi_status32), + SNDRV_RAWMIDI_IOCTL_PARAMS32 = _IOWR('W', 0x10, struct sndrv_rawmidi_params32), + SNDRV_RAWMIDI_IOCTL_STATUS32 = _IOWR('W', 0x20, struct sndrv_rawmidi_status32), }; static long snd_rawmidi_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_rawmidi_file *rfile; + snd_rawmidi_file_t *rfile; void __user *argp = compat_ptr(arg); rfile = file->private_data; diff --git a/trunk/sound/core/rtctimer.c b/trunk/sound/core/rtctimer.c index 84704ccb1829..c3c18568207e 100644 --- a/trunk/sound/core/rtctimer.c +++ b/trunk/sound/core/rtctimer.c @@ -40,16 +40,16 @@ /* * prototypes */ -static int rtctimer_open(struct snd_timer *t); -static int rtctimer_close(struct snd_timer *t); -static int rtctimer_start(struct snd_timer *t); -static int rtctimer_stop(struct snd_timer *t); +static int rtctimer_open(snd_timer_t *t); +static int rtctimer_close(snd_timer_t *t); +static int rtctimer_start(snd_timer_t *t); +static int rtctimer_stop(snd_timer_t *t); /* * The hardware dependent description for this timer. */ -static struct snd_timer_hardware rtc_hw = { +static struct _snd_timer_hardware rtc_hw = { .flags = SNDRV_TIMER_HW_FIRST|SNDRV_TIMER_HW_AUTO, .ticks = 100000000L, /* FIXME: XXX */ .open = rtctimer_open, @@ -59,12 +59,12 @@ static struct snd_timer_hardware rtc_hw = { }; static int rtctimer_freq = RTC_FREQ; /* frequency */ -static struct snd_timer *rtctimer; +static snd_timer_t *rtctimer; static rtc_task_t rtc_task; static int -rtctimer_open(struct snd_timer *t) +rtctimer_open(snd_timer_t *t) { int err; @@ -76,7 +76,7 @@ rtctimer_open(struct snd_timer *t) } static int -rtctimer_close(struct snd_timer *t) +rtctimer_close(snd_timer_t *t) { rtc_task_t *rtc = t->private_data; if (rtc) { @@ -87,7 +87,7 @@ rtctimer_close(struct snd_timer *t) } static int -rtctimer_start(struct snd_timer *timer) +rtctimer_start(snd_timer_t *timer) { rtc_task_t *rtc = timer->private_data; snd_assert(rtc != NULL, return -EINVAL); @@ -97,7 +97,7 @@ rtctimer_start(struct snd_timer *timer) } static int -rtctimer_stop(struct snd_timer *timer) +rtctimer_stop(snd_timer_t *timer) { rtc_task_t *rtc = timer->private_data; snd_assert(rtc != NULL, return -EINVAL); @@ -120,7 +120,7 @@ static void rtctimer_interrupt(void *private_data) static int __init rtctimer_init(void) { int err; - struct snd_timer *timer; + snd_timer_t *timer; if (rtctimer_freq < 2 || rtctimer_freq > 8192 || (rtctimer_freq & (rtctimer_freq - 1)) != 0) { diff --git a/trunk/sound/core/seq/instr/ainstr_fm.c b/trunk/sound/core/seq/instr/ainstr_fm.c index b09babf272cd..5c671e69884f 100644 --- a/trunk/sound/core/seq/instr/ainstr_fm.c +++ b/trunk/sound/core/seq/instr/ainstr_fm.c @@ -30,11 +30,11 @@ MODULE_AUTHOR("Uros Bizjak <uros@kss-loka.si>"); MODULE_DESCRIPTION("Advanced Linux Sound Architecture FM Instrument support."); MODULE_LICENSE("GPL"); -static int snd_seq_fm_put(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_fm_put(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct fm_instrument *ip; - struct fm_xinstrument ix; + fm_instrument_t *ip; + fm_xinstrument_t ix; int idx; if (cmd != SNDRV_SEQ_INSTR_PUT_CMD_CREATE) @@ -46,7 +46,7 @@ static int snd_seq_fm_put(void *private_data, struct snd_seq_kinstr *instr, return -EFAULT; if (ix.stype != FM_STRU_INSTR) return -EINVAL; - ip = (struct fm_instrument *)KINSTR_DATA(instr); + ip = (fm_instrument_t *)KINSTR_DATA(instr); ip->share_id[0] = le32_to_cpu(ix.share_id[0]); ip->share_id[1] = le32_to_cpu(ix.share_id[1]); ip->share_id[2] = le32_to_cpu(ix.share_id[2]); @@ -72,12 +72,12 @@ static int snd_seq_fm_put(void *private_data, struct snd_seq_kinstr *instr, return 0; } -static int snd_seq_fm_get(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_fm_get(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct fm_instrument *ip; - struct fm_xinstrument ix; + fm_instrument_t *ip; + fm_xinstrument_t ix; int idx; if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL) @@ -85,7 +85,7 @@ static int snd_seq_fm_get(void *private_data, struct snd_seq_kinstr *instr, if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (struct fm_instrument *)KINSTR_DATA(instr); + ip = (fm_instrument_t *)KINSTR_DATA(instr); ix.stype = FM_STRU_INSTR; ix.share_id[0] = cpu_to_le32(ip->share_id[0]); ix.share_id[1] = cpu_to_le32(ip->share_id[1]); @@ -114,19 +114,19 @@ static int snd_seq_fm_get(void *private_data, struct snd_seq_kinstr *instr, return 0; } -static int snd_seq_fm_get_size(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_fm_get_size(void *private_data, snd_seq_kinstr_t *instr, long *size) { - *size = sizeof(struct fm_xinstrument); + *size = sizeof(fm_xinstrument_t); return 0; } -int snd_seq_fm_init(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_ops *next) +int snd_seq_fm_init(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_ops_t *next) { memset(ops, 0, sizeof(*ops)); // ops->private_data = private_data; - ops->add_len = sizeof(struct fm_instrument); + ops->add_len = sizeof(fm_instrument_t); ops->instr_type = SNDRV_SEQ_INSTR_ID_OPL2_3; ops->put = snd_seq_fm_put; ops->get = snd_seq_fm_get; diff --git a/trunk/sound/core/seq/instr/ainstr_gf1.c b/trunk/sound/core/seq/instr/ainstr_gf1.c index 3c31038a74ba..0e4df8826eed 100644 --- a/trunk/sound/core/seq/instr/ainstr_gf1.c +++ b/trunk/sound/core/seq/instr/ainstr_gf1.c @@ -42,14 +42,14 @@ static unsigned int snd_seq_gf1_size(unsigned int size, unsigned int format) return format; } -static int snd_seq_gf1_copy_wave_from_stream(struct snd_gf1_ops *ops, - struct gf1_instrument *ip, +static int snd_seq_gf1_copy_wave_from_stream(snd_gf1_ops_t *ops, + gf1_instrument_t *ip, char __user **data, long *len, int atomic) { - struct gf1_wave *wp, *prev; - struct gf1_xwave xp; + gf1_wave_t *wp, *prev; + gf1_xwave_t xp; int err; gfp_t gfp_mask; unsigned int real_size; @@ -116,8 +116,8 @@ static int snd_seq_gf1_copy_wave_from_stream(struct snd_gf1_ops *ops, return 0; } -static void snd_seq_gf1_wave_free(struct snd_gf1_ops *ops, - struct gf1_wave *wave, +static void snd_seq_gf1_wave_free(snd_gf1_ops_t *ops, + gf1_wave_t *wave, int atomic) { if (ops->remove_sample) @@ -125,11 +125,11 @@ static void snd_seq_gf1_wave_free(struct snd_gf1_ops *ops, kfree(wave); } -static void snd_seq_gf1_instr_free(struct snd_gf1_ops *ops, - struct gf1_instrument *ip, +static void snd_seq_gf1_instr_free(snd_gf1_ops_t *ops, + gf1_instrument_t *ip, int atomic) { - struct gf1_wave *wave; + gf1_wave_t *wave; while ((wave = ip->wave) != NULL) { ip->wave = wave->next; @@ -137,13 +137,13 @@ static void snd_seq_gf1_instr_free(struct snd_gf1_ops *ops, } } -static int snd_seq_gf1_put(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_gf1_put(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct snd_gf1_ops *ops = private_data; - struct gf1_instrument *ip; - struct gf1_xinstrument ix; + snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; + gf1_instrument_t *ip; + gf1_xinstrument_t ix; int err; gfp_t gfp_mask; @@ -159,7 +159,7 @@ static int snd_seq_gf1_put(void *private_data, struct snd_seq_kinstr *instr, return -EINVAL; instr_data += sizeof(ix); len -= sizeof(ix); - ip = (struct gf1_instrument *)KINSTR_DATA(instr); + ip = (gf1_instrument_t *)KINSTR_DATA(instr); ip->exclusion = le16_to_cpu(ix.exclusion); ip->exclusion_group = le16_to_cpu(ix.exclusion_group); ip->effect1 = ix.effect1; @@ -189,14 +189,14 @@ static int snd_seq_gf1_put(void *private_data, struct snd_seq_kinstr *instr, return 0; } -static int snd_seq_gf1_copy_wave_to_stream(struct snd_gf1_ops *ops, - struct gf1_instrument *ip, +static int snd_seq_gf1_copy_wave_to_stream(snd_gf1_ops_t *ops, + gf1_instrument_t *ip, char __user **data, long *len, int atomic) { - struct gf1_wave *wp; - struct gf1_xwave xp; + gf1_wave_t *wp; + gf1_xwave_t xp; int err; unsigned int real_size; @@ -251,20 +251,20 @@ static int snd_seq_gf1_copy_wave_to_stream(struct snd_gf1_ops *ops, return 0; } -static int snd_seq_gf1_get(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_gf1_get(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct snd_gf1_ops *ops = private_data; - struct gf1_instrument *ip; - struct gf1_xinstrument ix; + snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; + gf1_instrument_t *ip; + gf1_xinstrument_t ix; if (cmd != SNDRV_SEQ_INSTR_GET_CMD_FULL) return -EINVAL; if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (struct gf1_instrument *)KINSTR_DATA(instr); + ip = (gf1_instrument_t *)KINSTR_DATA(instr); ix.stype = GF1_STRU_INSTR; ix.exclusion = cpu_to_le16(ip->exclusion); ix.exclusion_group = cpu_to_le16(ip->exclusion_group); @@ -283,18 +283,18 @@ static int snd_seq_gf1_get(void *private_data, struct snd_seq_kinstr *instr, atomic); } -static int snd_seq_gf1_get_size(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_gf1_get_size(void *private_data, snd_seq_kinstr_t *instr, long *size) { long result; - struct gf1_instrument *ip; - struct gf1_wave *wp; + gf1_instrument_t *ip; + gf1_wave_t *wp; *size = 0; - ip = (struct gf1_instrument *)KINSTR_DATA(instr); - result = sizeof(struct gf1_xinstrument); + ip = (gf1_instrument_t *)KINSTR_DATA(instr); + result = sizeof(gf1_xinstrument_t); for (wp = ip->wave; wp; wp = wp->next) { - result += sizeof(struct gf1_xwave); + result += sizeof(gf1_xwave_t); result += wp->size; } *size = result; @@ -302,35 +302,35 @@ static int snd_seq_gf1_get_size(void *private_data, struct snd_seq_kinstr *instr } static int snd_seq_gf1_remove(void *private_data, - struct snd_seq_kinstr *instr, + snd_seq_kinstr_t *instr, int atomic) { - struct snd_gf1_ops *ops = private_data; - struct gf1_instrument *ip; + snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; + gf1_instrument_t *ip; - ip = (struct gf1_instrument *)KINSTR_DATA(instr); + ip = (gf1_instrument_t *)KINSTR_DATA(instr); snd_seq_gf1_instr_free(ops, ip, atomic); return 0; } static void snd_seq_gf1_notify(void *private_data, - struct snd_seq_kinstr *instr, + snd_seq_kinstr_t *instr, int what) { - struct snd_gf1_ops *ops = private_data; + snd_gf1_ops_t *ops = (snd_gf1_ops_t *)private_data; if (ops->notify) ops->notify(ops->private_data, instr, what); } -int snd_seq_gf1_init(struct snd_gf1_ops *ops, +int snd_seq_gf1_init(snd_gf1_ops_t *ops, void *private_data, - struct snd_seq_kinstr_ops *next) + snd_seq_kinstr_ops_t *next) { memset(ops, 0, sizeof(*ops)); ops->private_data = private_data; ops->kops.private_data = ops; - ops->kops.add_len = sizeof(struct gf1_instrument); + ops->kops.add_len = sizeof(gf1_instrument_t); ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_GUS_PATCH; ops->kops.put = snd_seq_gf1_put; ops->kops.get = snd_seq_gf1_get; diff --git a/trunk/sound/core/seq/instr/ainstr_iw.c b/trunk/sound/core/seq/instr/ainstr_iw.c index 7f8df19ba563..7c19fbbc5d0f 100644 --- a/trunk/sound/core/seq/instr/ainstr_iw.c +++ b/trunk/sound/core/seq/instr/ainstr_iw.c @@ -42,8 +42,8 @@ static unsigned int snd_seq_iwffff_size(unsigned int size, unsigned int format) return result; } -static void snd_seq_iwffff_copy_lfo_from_stream(struct iwffff_lfo *fp, - struct iwffff_xlfo *fx) +static void snd_seq_iwffff_copy_lfo_from_stream(iwffff_lfo_t *fp, + iwffff_xlfo_t *fx) { fp->freq = le16_to_cpu(fx->freq); fp->depth = le16_to_cpu(fx->depth); @@ -53,18 +53,18 @@ static void snd_seq_iwffff_copy_lfo_from_stream(struct iwffff_lfo *fp, } static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype, - struct iwffff_layer *lp, - struct iwffff_env *ep, - struct iwffff_xenv *ex, + iwffff_layer_t *lp, + iwffff_env_t *ep, + iwffff_xenv_t *ex, char __user **data, long *len, gfp_t gfp_mask) { __u32 stype; - struct iwffff_env_record *rp, *rp_last; - struct iwffff_xenv_record rx; - struct iwffff_env_point *pp; - struct iwffff_xenv_point px; + iwffff_env_record_t *rp, *rp_last; + iwffff_xenv_record_t rx; + iwffff_env_point_t *pp; + iwffff_xenv_point_t px; int points_size, idx; ep->flags = ex->flags; @@ -101,7 +101,7 @@ static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype, rp->sustain_rate = le16_to_cpu(rx.sustain_rate); rp->release_rate = le16_to_cpu(rx.release_rate); rp->hirange = rx.hirange; - pp = (struct iwffff_env_point *)(rp + 1); + pp = (iwffff_env_point_t *)(rp + 1); for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) { if (copy_from_user(&px, *data, sizeof(px))) return -EFAULT; @@ -120,14 +120,14 @@ static int snd_seq_iwffff_copy_env_from_stream(__u32 req_stype, return 0; } -static int snd_seq_iwffff_copy_wave_from_stream(struct snd_iwffff_ops *ops, - struct iwffff_layer *lp, +static int snd_seq_iwffff_copy_wave_from_stream(snd_iwffff_ops_t *ops, + iwffff_layer_t *lp, char __user **data, long *len, int atomic) { - struct iwffff_wave *wp, *prev; - struct iwffff_xwave xp; + iwffff_wave_t *wp, *prev; + iwffff_xwave_t xp; int err; gfp_t gfp_mask; unsigned int real_size; @@ -186,11 +186,11 @@ static int snd_seq_iwffff_copy_wave_from_stream(struct snd_iwffff_ops *ops, return 0; } -static void snd_seq_iwffff_env_free(struct snd_iwffff_ops *ops, - struct iwffff_env *env, +static void snd_seq_iwffff_env_free(snd_iwffff_ops_t *ops, + iwffff_env_t *env, int atomic) { - struct iwffff_env_record *rec; + iwffff_env_record_t *rec; while ((rec = env->record) != NULL) { env->record = rec->next; @@ -198,8 +198,8 @@ static void snd_seq_iwffff_env_free(struct snd_iwffff_ops *ops, } } -static void snd_seq_iwffff_wave_free(struct snd_iwffff_ops *ops, - struct iwffff_wave *wave, +static void snd_seq_iwffff_wave_free(snd_iwffff_ops_t *ops, + iwffff_wave_t *wave, int atomic) { if (ops->remove_sample) @@ -207,12 +207,12 @@ static void snd_seq_iwffff_wave_free(struct snd_iwffff_ops *ops, kfree(wave); } -static void snd_seq_iwffff_instr_free(struct snd_iwffff_ops *ops, - struct iwffff_instrument *ip, +static void snd_seq_iwffff_instr_free(snd_iwffff_ops_t *ops, + iwffff_instrument_t *ip, int atomic) { - struct iwffff_layer *layer; - struct iwffff_wave *wave; + iwffff_layer_t *layer; + iwffff_wave_t *wave; while ((layer = ip->layer) != NULL) { ip->layer = layer->next; @@ -226,15 +226,15 @@ static void snd_seq_iwffff_instr_free(struct snd_iwffff_ops *ops, } } -static int snd_seq_iwffff_put(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_iwffff_put(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct snd_iwffff_ops *ops = private_data; - struct iwffff_instrument *ip; - struct iwffff_xinstrument ix; - struct iwffff_layer *lp, *prev_lp; - struct iwffff_xlayer lx; + snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; + iwffff_instrument_t *ip; + iwffff_xinstrument_t ix; + iwffff_layer_t *lp, *prev_lp; + iwffff_xlayer_t lx; int err; gfp_t gfp_mask; @@ -250,7 +250,7 @@ static int snd_seq_iwffff_put(void *private_data, struct snd_seq_kinstr *instr, return -EINVAL; instr_data += sizeof(ix); len -= sizeof(ix); - ip = (struct iwffff_instrument *)KINSTR_DATA(instr); + ip = (iwffff_instrument_t *)KINSTR_DATA(instr); ip->exclusion = le16_to_cpu(ix.exclusion); ip->layer_type = le16_to_cpu(ix.layer_type); ip->exclusion_group = le16_to_cpu(ix.exclusion_group); @@ -261,7 +261,7 @@ static int snd_seq_iwffff_put(void *private_data, struct snd_seq_kinstr *instr, /* copy layers */ prev_lp = NULL; while (len > 0) { - if (len < (long)sizeof(struct iwffff_xlayer)) { + if (len < (long)sizeof(iwffff_xlayer_t)) { snd_seq_iwffff_instr_free(ops, ip, atomic); return -EINVAL; } @@ -335,8 +335,8 @@ static int snd_seq_iwffff_put(void *private_data, struct snd_seq_kinstr *instr, return 0; } -static void snd_seq_iwffff_copy_lfo_to_stream(struct iwffff_xlfo *fx, - struct iwffff_lfo *fp) +static void snd_seq_iwffff_copy_lfo_to_stream(iwffff_xlfo_t *fx, + iwffff_lfo_t *fp) { fx->freq = cpu_to_le16(fp->freq); fx->depth = cpu_to_le16(fp->depth); @@ -346,16 +346,16 @@ static void snd_seq_iwffff_copy_lfo_to_stream(struct iwffff_xlfo *fx, } static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype, - struct iwffff_layer *lp, - struct iwffff_xenv *ex, - struct iwffff_env *ep, + iwffff_layer_t *lp, + iwffff_xenv_t *ex, + iwffff_env_t *ep, char __user **data, long *len) { - struct iwffff_env_record *rp; - struct iwffff_xenv_record rx; - struct iwffff_env_point *pp; - struct iwffff_xenv_point px; + iwffff_env_record_t *rp; + iwffff_xenv_record_t rx; + iwffff_env_point_t *pp; + iwffff_xenv_point_t px; int points_size, idx; ex->flags = ep->flags; @@ -379,7 +379,7 @@ static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype, points_size = (rp->nattack + rp->nrelease) * 2 * sizeof(__u16); if (*len < points_size) return -ENOMEM; - pp = (struct iwffff_env_point *)(rp + 1); + pp = (iwffff_env_point_t *)(rp + 1); for (idx = 0; idx < rp->nattack + rp->nrelease; idx++) { px.offset = cpu_to_le16(pp->offset); px.rate = cpu_to_le16(pp->rate); @@ -392,14 +392,14 @@ static int snd_seq_iwffff_copy_env_to_stream(__u32 req_stype, return 0; } -static int snd_seq_iwffff_copy_wave_to_stream(struct snd_iwffff_ops *ops, - struct iwffff_layer *lp, +static int snd_seq_iwffff_copy_wave_to_stream(snd_iwffff_ops_t *ops, + iwffff_layer_t *lp, char __user **data, long *len, int atomic) { - struct iwffff_wave *wp; - struct iwffff_xwave xp; + iwffff_wave_t *wp; + iwffff_xwave_t xp; int err; unsigned int real_size; @@ -447,14 +447,14 @@ static int snd_seq_iwffff_copy_wave_to_stream(struct snd_iwffff_ops *ops, return 0; } -static int snd_seq_iwffff_get(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_iwffff_get(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct snd_iwffff_ops *ops = private_data; - struct iwffff_instrument *ip; - struct iwffff_xinstrument ix; - struct iwffff_layer *lp; - struct iwffff_xlayer lx; + snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; + iwffff_instrument_t *ip; + iwffff_xinstrument_t ix; + iwffff_layer_t *lp; + iwffff_xlayer_t lx; char __user *layer_instr_data; int err; @@ -463,7 +463,7 @@ static int snd_seq_iwffff_get(void *private_data, struct snd_seq_kinstr *instr, if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (struct iwffff_instrument *)KINSTR_DATA(instr); + ip = (iwffff_instrument_t *)KINSTR_DATA(instr); ix.stype = IWFFFF_STRU_INSTR; ix.exclusion = cpu_to_le16(ip->exclusion); ix.layer_type = cpu_to_le16(ip->layer_type); @@ -520,43 +520,43 @@ static int snd_seq_iwffff_get(void *private_data, struct snd_seq_kinstr *instr, return 0; } -static long snd_seq_iwffff_env_size_in_stream(struct iwffff_env *ep) +static long snd_seq_iwffff_env_size_in_stream(iwffff_env_t *ep) { long result = 0; - struct iwffff_env_record *rp; + iwffff_env_record_t *rp; for (rp = ep->record; rp; rp = rp->next) { - result += sizeof(struct iwffff_xenv_record); + result += sizeof(iwffff_xenv_record_t); result += (rp->nattack + rp->nrelease) * 2 * sizeof(__u16); } return 0; } -static long snd_seq_iwffff_wave_size_in_stream(struct iwffff_layer *lp) +static long snd_seq_iwffff_wave_size_in_stream(iwffff_layer_t *lp) { long result = 0; - struct iwffff_wave *wp; + iwffff_wave_t *wp; for (wp = lp->wave; wp; wp = wp->next) { - result += sizeof(struct iwffff_xwave); + result += sizeof(iwffff_xwave_t); if (!(wp->format & IWFFFF_WAVE_ROM)) result += wp->size; } return result; } -static int snd_seq_iwffff_get_size(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_iwffff_get_size(void *private_data, snd_seq_kinstr_t *instr, long *size) { long result; - struct iwffff_instrument *ip; - struct iwffff_layer *lp; + iwffff_instrument_t *ip; + iwffff_layer_t *lp; *size = 0; - ip = (struct iwffff_instrument *)KINSTR_DATA(instr); - result = sizeof(struct iwffff_xinstrument); + ip = (iwffff_instrument_t *)KINSTR_DATA(instr); + result = sizeof(iwffff_xinstrument_t); for (lp = ip->layer; lp; lp = lp->next) { - result += sizeof(struct iwffff_xlayer); + result += sizeof(iwffff_xlayer_t); result += snd_seq_iwffff_env_size_in_stream(&lp->penv); result += snd_seq_iwffff_env_size_in_stream(&lp->venv); result += snd_seq_iwffff_wave_size_in_stream(lp); @@ -566,35 +566,35 @@ static int snd_seq_iwffff_get_size(void *private_data, struct snd_seq_kinstr *in } static int snd_seq_iwffff_remove(void *private_data, - struct snd_seq_kinstr *instr, + snd_seq_kinstr_t *instr, int atomic) { - struct snd_iwffff_ops *ops = private_data; - struct iwffff_instrument *ip; + snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; + iwffff_instrument_t *ip; - ip = (struct iwffff_instrument *)KINSTR_DATA(instr); + ip = (iwffff_instrument_t *)KINSTR_DATA(instr); snd_seq_iwffff_instr_free(ops, ip, atomic); return 0; } static void snd_seq_iwffff_notify(void *private_data, - struct snd_seq_kinstr *instr, + snd_seq_kinstr_t *instr, int what) { - struct snd_iwffff_ops *ops = private_data; + snd_iwffff_ops_t *ops = (snd_iwffff_ops_t *)private_data; if (ops->notify) ops->notify(ops->private_data, instr, what); } -int snd_seq_iwffff_init(struct snd_iwffff_ops *ops, +int snd_seq_iwffff_init(snd_iwffff_ops_t *ops, void *private_data, - struct snd_seq_kinstr_ops *next) + snd_seq_kinstr_ops_t *next) { memset(ops, 0, sizeof(*ops)); ops->private_data = private_data; ops->kops.private_data = ops; - ops->kops.add_len = sizeof(struct iwffff_instrument); + ops->kops.add_len = sizeof(iwffff_instrument_t); ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_INTERWAVE; ops->kops.put = snd_seq_iwffff_put; ops->kops.get = snd_seq_iwffff_get; diff --git a/trunk/sound/core/seq/instr/ainstr_simple.c b/trunk/sound/core/seq/instr/ainstr_simple.c index 6d6ffece7cbe..17ab94e76073 100644 --- a/trunk/sound/core/seq/instr/ainstr_simple.c +++ b/trunk/sound/core/seq/instr/ainstr_simple.c @@ -42,21 +42,21 @@ static unsigned int snd_seq_simple_size(unsigned int size, unsigned int format) return result; } -static void snd_seq_simple_instr_free(struct snd_simple_ops *ops, - struct simple_instrument *ip, +static void snd_seq_simple_instr_free(snd_simple_ops_t *ops, + simple_instrument_t *ip, int atomic) { if (ops->remove_sample) ops->remove_sample(ops->private_data, ip, atomic); } -static int snd_seq_simple_put(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_simple_put(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct snd_simple_ops *ops = private_data; - struct simple_instrument *ip; - struct simple_xinstrument ix; + snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; + simple_instrument_t *ip; + simple_xinstrument_t ix; int err; gfp_t gfp_mask; unsigned int real_size; @@ -73,7 +73,7 @@ static int snd_seq_simple_put(void *private_data, struct snd_seq_kinstr *instr, return -EINVAL; instr_data += sizeof(ix); len -= sizeof(ix); - ip = (struct simple_instrument *)KINSTR_DATA(instr); + ip = (simple_instrument_t *)KINSTR_DATA(instr); ip->share_id[0] = le32_to_cpu(ix.share_id[0]); ip->share_id[1] = le32_to_cpu(ix.share_id[1]); ip->share_id[2] = le32_to_cpu(ix.share_id[2]); @@ -100,13 +100,13 @@ static int snd_seq_simple_put(void *private_data, struct snd_seq_kinstr *instr, return 0; } -static int snd_seq_simple_get(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_simple_get(void *private_data, snd_seq_kinstr_t *instr, char __user *instr_data, long len, int atomic, int cmd) { - struct snd_simple_ops *ops = private_data; - struct simple_instrument *ip; - struct simple_xinstrument ix; + snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; + simple_instrument_t *ip; + simple_xinstrument_t ix; int err; unsigned int real_size; @@ -115,7 +115,7 @@ static int snd_seq_simple_get(void *private_data, struct snd_seq_kinstr *instr, if (len < (long)sizeof(ix)) return -ENOMEM; memset(&ix, 0, sizeof(ix)); - ip = (struct simple_instrument *)KINSTR_DATA(instr); + ip = (simple_instrument_t *)KINSTR_DATA(instr); ix.stype = SIMPLE_STRU_INSTR; ix.share_id[0] = cpu_to_le32(ip->share_id[0]); ix.share_id[1] = cpu_to_le32(ip->share_id[1]); @@ -147,46 +147,46 @@ static int snd_seq_simple_get(void *private_data, struct snd_seq_kinstr *instr, return 0; } -static int snd_seq_simple_get_size(void *private_data, struct snd_seq_kinstr *instr, +static int snd_seq_simple_get_size(void *private_data, snd_seq_kinstr_t *instr, long *size) { - struct simple_instrument *ip; + simple_instrument_t *ip; - ip = (struct simple_instrument *)KINSTR_DATA(instr); - *size = sizeof(struct simple_xinstrument) + snd_seq_simple_size(ip->size, ip->format); + ip = (simple_instrument_t *)KINSTR_DATA(instr); + *size = sizeof(simple_xinstrument_t) + snd_seq_simple_size(ip->size, ip->format); return 0; } static int snd_seq_simple_remove(void *private_data, - struct snd_seq_kinstr *instr, + snd_seq_kinstr_t *instr, int atomic) { - struct snd_simple_ops *ops = private_data; - struct simple_instrument *ip; + snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; + simple_instrument_t *ip; - ip = (struct simple_instrument *)KINSTR_DATA(instr); + ip = (simple_instrument_t *)KINSTR_DATA(instr); snd_seq_simple_instr_free(ops, ip, atomic); return 0; } static void snd_seq_simple_notify(void *private_data, - struct snd_seq_kinstr *instr, + snd_seq_kinstr_t *instr, int what) { - struct snd_simple_ops *ops = private_data; + snd_simple_ops_t *ops = (snd_simple_ops_t *)private_data; if (ops->notify) ops->notify(ops->private_data, instr, what); } -int snd_seq_simple_init(struct snd_simple_ops *ops, +int snd_seq_simple_init(snd_simple_ops_t *ops, void *private_data, - struct snd_seq_kinstr_ops *next) + snd_seq_kinstr_ops_t *next) { memset(ops, 0, sizeof(*ops)); ops->private_data = private_data; ops->kops.private_data = ops; - ops->kops.add_len = sizeof(struct simple_instrument); + ops->kops.add_len = sizeof(simple_instrument_t); ops->kops.instr_type = SNDRV_SEQ_INSTR_ID_SIMPLE; ops->kops.put = snd_seq_simple_put; ops->kops.get = snd_seq_simple_get; diff --git a/trunk/sound/core/seq/oss/seq_oss.c b/trunk/sound/core/seq/oss/seq_oss.c index c98f0ba13810..4c0558c0a8b4 100644 --- a/trunk/sound/core/seq/oss/seq_oss.c +++ b/trunk/sound/core/seq/oss/seq_oss.c @@ -52,13 +52,8 @@ int seq_oss_debug = 0; */ static int register_device(void); static void unregister_device(void); -#ifdef CONFIG_PROC_FS static int register_proc(void); static void unregister_proc(void); -#else -static inline int register_proc(void) { return 0; } -static inline void unregister_proc(void) {} -#endif static int odev_open(struct inode *inode, struct file *file); static int odev_release(struct inode *inode, struct file *file); @@ -66,6 +61,9 @@ static ssize_t odev_read(struct file *file, char __user *buf, size_t count, loff static ssize_t odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset); static long odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg); static unsigned int odev_poll(struct file *file, poll_table * wait); +#ifdef CONFIG_PROC_FS +static void info_read(snd_info_entry_t *entry, snd_info_buffer_t *buf); +#endif /* @@ -75,7 +73,7 @@ static unsigned int odev_poll(struct file *file, poll_table * wait); static int __init alsa_seq_oss_init(void) { int rc; - static struct snd_seq_dev_ops ops = { + static snd_seq_dev_ops_t ops = { snd_seq_oss_synth_register, snd_seq_oss_synth_unregister, }; @@ -94,7 +92,7 @@ static int __init alsa_seq_oss_init(void) } if ((rc = snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OSS, &ops, - sizeof(struct snd_seq_oss_reg))) < 0) { + sizeof(snd_seq_oss_reg_t))) < 0) { snd_seq_oss_delete_client(); unregister_proc(); unregister_device(); @@ -146,7 +144,7 @@ odev_open(struct inode *inode, struct file *file) static int odev_release(struct inode *inode, struct file *file) { - struct seq_oss_devinfo *dp; + seq_oss_devinfo_t *dp; if ((dp = file->private_data) == NULL) return 0; @@ -163,7 +161,7 @@ odev_release(struct inode *inode, struct file *file) static ssize_t odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { - struct seq_oss_devinfo *dp; + seq_oss_devinfo_t *dp; dp = file->private_data; snd_assert(dp != NULL, return -EIO); return snd_seq_oss_read(dp, buf, count); @@ -173,7 +171,7 @@ odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset) static ssize_t odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { - struct seq_oss_devinfo *dp; + seq_oss_devinfo_t *dp; dp = file->private_data; snd_assert(dp != NULL, return -EIO); return snd_seq_oss_write(dp, buf, count, file); @@ -182,7 +180,7 @@ odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offs static long odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct seq_oss_devinfo *dp; + seq_oss_devinfo_t *dp; dp = file->private_data; snd_assert(dp != NULL, return -EIO); return snd_seq_oss_ioctl(dp, cmd, arg); @@ -197,7 +195,7 @@ odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) static unsigned int odev_poll(struct file *file, poll_table * wait) { - struct seq_oss_devinfo *dp; + seq_oss_devinfo_t *dp; dp = file->private_data; snd_assert(dp != NULL, return 0); return snd_seq_oss_poll(dp, file, wait); @@ -219,6 +217,11 @@ static struct file_operations seq_oss_f_ops = .compat_ioctl = odev_ioctl_compat, }; +static snd_minor_t seq_oss_reg = { + .comment = "sequencer", + .f_ops = &seq_oss_f_ops, +}; + static int __init register_device(void) { @@ -227,7 +230,7 @@ register_device(void) down(®ister_mutex); if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0, - &seq_oss_f_ops, NULL, + &seq_oss_reg, SNDRV_SEQ_OSS_DEVNAME)) < 0) { snd_printk(KERN_ERR "can't register device seq\n"); up(®ister_mutex); @@ -235,7 +238,7 @@ register_device(void) } if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, NULL, 0, - &seq_oss_f_ops, NULL, + &seq_oss_reg, SNDRV_SEQ_OSS_DEVNAME)) < 0) { snd_printk(KERN_ERR "can't register device music\n"); snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0); @@ -265,10 +268,10 @@ unregister_device(void) #ifdef CONFIG_PROC_FS -static struct snd_info_entry *info_entry; +static snd_info_entry_t *info_entry; static void -info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) +info_read(snd_info_entry_t *entry, snd_info_buffer_t *buf) { down(®ister_mutex); snd_iprintf(buf, "OSS sequencer emulation version %s\n", SNDRV_SEQ_OSS_VERSION_STR); @@ -278,11 +281,13 @@ info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) up(®ister_mutex); } +#endif /* CONFIG_PROC_FS */ static int __init register_proc(void) { - struct snd_info_entry *entry; +#ifdef CONFIG_PROC_FS + snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, SNDRV_SEQ_OSS_PROCNAME, snd_seq_root); if (entry == NULL) @@ -297,14 +302,16 @@ register_proc(void) return -ENOMEM; } info_entry = entry; +#endif return 0; } static void unregister_proc(void) { +#ifdef CONFIG_PROC_FS if (info_entry) snd_info_unregister(info_entry); info_entry = NULL; +#endif } -#endif /* CONFIG_PROC_FS */ diff --git a/trunk/sound/core/seq/oss/seq_oss_device.h b/trunk/sound/core/seq/oss/seq_oss_device.h index 9a8567c928ec..973786758c55 100644 --- a/trunk/sound/core/seq/oss/seq_oss_device.h +++ b/trunk/sound/core/seq/oss/seq_oss_device.h @@ -55,24 +55,32 @@ * type definitions */ +typedef struct seq_oss_devinfo_t seq_oss_devinfo_t; +typedef struct seq_oss_writeq_t seq_oss_writeq_t; +typedef struct seq_oss_readq_t seq_oss_readq_t; +typedef struct seq_oss_timer_t seq_oss_timer_t; +typedef struct seq_oss_synthinfo_t seq_oss_synthinfo_t; +typedef struct seq_oss_synth_sysex_t seq_oss_synth_sysex_t; +typedef struct seq_oss_chinfo_t seq_oss_chinfo_t; typedef unsigned int reltime_t; typedef unsigned int abstime_t; +typedef union evrec_t evrec_t; /* * synthesizer channel information */ -struct seq_oss_chinfo { +struct seq_oss_chinfo_t { int note, vel; }; /* * synthesizer information */ -struct seq_oss_synthinfo { - struct snd_seq_oss_arg arg; - struct seq_oss_chinfo *ch; - struct seq_oss_synth_sysex *sysex; +struct seq_oss_synthinfo_t { + snd_seq_oss_arg_t arg; + seq_oss_chinfo_t *ch; + seq_oss_synth_sysex_t *sysex; int nr_voices; int opened; int is_midi; @@ -84,14 +92,14 @@ struct seq_oss_synthinfo { * sequencer client information */ -struct seq_oss_devinfo { +struct seq_oss_devinfo_t { int index; /* application index */ int cseq; /* sequencer client number */ int port; /* sequencer port number */ int queue; /* sequencer queue number */ - struct snd_seq_addr addr; /* address of this device */ + snd_seq_addr_t addr; /* address of this device */ int seq_mode; /* sequencer mode */ int file_mode; /* file access */ @@ -101,17 +109,17 @@ struct seq_oss_devinfo { /* synth device table */ int max_synthdev; - struct seq_oss_synthinfo synths[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; + seq_oss_synthinfo_t synths[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; int synth_opened; /* output queue */ - struct seq_oss_writeq *writeq; + seq_oss_writeq_t *writeq; /* midi input queue */ - struct seq_oss_readq *readq; + seq_oss_readq_t *readq; /* timer */ - struct seq_oss_timer *timer; + seq_oss_timer_t *timer; }; @@ -125,24 +133,24 @@ int snd_seq_oss_delete_client(void); /* device file interface */ int snd_seq_oss_open(struct file *file, int level); -void snd_seq_oss_release(struct seq_oss_devinfo *dp); -int snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long arg); -int snd_seq_oss_read(struct seq_oss_devinfo *dev, char __user *buf, int count); -int snd_seq_oss_write(struct seq_oss_devinfo *dp, const char __user *buf, int count, struct file *opt); -unsigned int snd_seq_oss_poll(struct seq_oss_devinfo *dp, struct file *file, poll_table * wait); +void snd_seq_oss_release(seq_oss_devinfo_t *dp); +int snd_seq_oss_ioctl(seq_oss_devinfo_t *dp, unsigned int cmd, unsigned long arg); +int snd_seq_oss_read(seq_oss_devinfo_t *dev, char __user *buf, int count); +int snd_seq_oss_write(seq_oss_devinfo_t *dp, const char __user *buf, int count, struct file *opt); +unsigned int snd_seq_oss_poll(seq_oss_devinfo_t *dp, struct file *file, poll_table * wait); -void snd_seq_oss_reset(struct seq_oss_devinfo *dp); -void snd_seq_oss_drain_write(struct seq_oss_devinfo *dp); +void snd_seq_oss_reset(seq_oss_devinfo_t *dp); +void snd_seq_oss_drain_write(seq_oss_devinfo_t *dp); /* */ -void snd_seq_oss_process_queue(struct seq_oss_devinfo *dp, abstime_t time); +void snd_seq_oss_process_queue(seq_oss_devinfo_t *dp, abstime_t time); /* proc interface */ -void snd_seq_oss_system_info_read(struct snd_info_buffer *buf); -void snd_seq_oss_midi_info_read(struct snd_info_buffer *buf); -void snd_seq_oss_synth_info_read(struct snd_info_buffer *buf); -void snd_seq_oss_readq_info_read(struct seq_oss_readq *q, struct snd_info_buffer *buf); +void snd_seq_oss_system_info_read(snd_info_buffer_t *buf); +void snd_seq_oss_midi_info_read(snd_info_buffer_t *buf); +void snd_seq_oss_synth_info_read(snd_info_buffer_t *buf); +void snd_seq_oss_readq_info_read(seq_oss_readq_t *q, snd_info_buffer_t *buf); /* file mode macros */ #define is_read_mode(mode) ((mode) & SNDRV_SEQ_OSS_FILE_READ) @@ -151,21 +159,21 @@ void snd_seq_oss_readq_info_read(struct seq_oss_readq *q, struct snd_info_buffer /* dispatch event */ static inline int -snd_seq_oss_dispatch(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int atomic, int hop) +snd_seq_oss_dispatch(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int atomic, int hop) { return snd_seq_kernel_client_dispatch(dp->cseq, ev, atomic, hop); } /* ioctl */ static inline int -snd_seq_oss_control(struct seq_oss_devinfo *dp, unsigned int type, void *arg) +snd_seq_oss_control(seq_oss_devinfo_t *dp, unsigned int type, void *arg) { return snd_seq_kernel_client_ctl(dp->cseq, type, arg); } /* fill the addresses in header */ static inline void -snd_seq_oss_fill_addr(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, +snd_seq_oss_fill_addr(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dest_client, int dest_port) { ev->queue = dp->queue; diff --git a/trunk/sound/core/seq/oss/seq_oss_event.c b/trunk/sound/core/seq/oss/seq_oss_event.c index 066f5f3e3f4c..58e52ddd2927 100644 --- a/trunk/sound/core/seq/oss/seq_oss_event.c +++ b/trunk/sound/core/seq/oss/seq_oss_event.c @@ -31,17 +31,17 @@ /* * prototypes */ -static int extended_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev); -static int chn_voice_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); -static int chn_common_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); -static int timing_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); -static int local_event(struct seq_oss_devinfo *dp, union evrec *event_rec, struct snd_seq_event *ev); -static int old_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev); -static int note_on_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev); -static int note_off_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev); -static int set_note_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int note, int vel, struct snd_seq_event *ev); -static int set_control_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int param, int val, struct snd_seq_event *ev); -static int set_echo_event(struct seq_oss_devinfo *dp, union evrec *rec, struct snd_seq_event *ev); +static int extended_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev); +static int chn_voice_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); +static int chn_common_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); +static int timing_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); +static int local_event(seq_oss_devinfo_t *dp, evrec_t *event_rec, snd_seq_event_t *ev); +static int old_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev); +static int note_on_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev); +static int note_off_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev); +static int set_note_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int note, int vel, snd_seq_event_t *ev); +static int set_control_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int param, int val, snd_seq_event_t *ev); +static int set_echo_event(seq_oss_devinfo_t *dp, evrec_t *rec, snd_seq_event_t *ev); /* @@ -51,7 +51,7 @@ static int set_echo_event(struct seq_oss_devinfo *dp, union evrec *rec, struct s */ int -snd_seq_oss_process_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) +snd_seq_oss_process_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) { switch (q->s.code) { case SEQ_EXTENDED: @@ -104,7 +104,7 @@ snd_seq_oss_process_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd /* old type events: mode1 only */ static int -old_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) +old_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) { switch (q->s.code) { case SEQ_NOTEOFF: @@ -130,7 +130,7 @@ old_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) /* 8bytes extended event: mode1 only */ static int -extended_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) +extended_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) { int val; @@ -184,7 +184,7 @@ extended_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event /* channel voice events: mode1 and 2 */ static int -chn_voice_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) +chn_voice_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) { if (q->v.chn >= 32) return -EINVAL; @@ -205,7 +205,7 @@ chn_voice_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event /* channel common events: mode1 and 2 */ static int -chn_common_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) +chn_common_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) { if (q->l.chn >= 32) return -EINVAL; @@ -232,14 +232,14 @@ chn_common_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_even /* timer events: mode1 and mode2 */ static int -timing_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) +timing_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) { switch (q->t.cmd) { case TMR_ECHO: if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) return set_echo_event(dp, q, ev); else { - union evrec tmp; + evrec_t tmp; memset(&tmp, 0, sizeof(tmp)); /* XXX: only for little-endian! */ tmp.echo = (q->t.time << 8) | SEQ_ECHO; @@ -267,7 +267,7 @@ timing_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *e /* local events: mode1 and 2 */ static int -local_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev) +local_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev) { return -EINVAL; } @@ -283,9 +283,9 @@ local_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev * Use key-pressure if note >= 128 */ static int -note_on_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev) +note_on_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev) { - struct seq_oss_synthinfo *info = &dp->synths[dev]; + seq_oss_synthinfo_t *info = &dp->synths[dev]; switch (info->arg.event_passing) { case SNDRV_SEQ_OSS_PROCESS_EVENTS: if (! info->ch || ch < 0 || ch >= info->nr_voices) { @@ -338,9 +338,9 @@ note_on_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, st * process note-off event for OSS synth */ static int -note_off_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, struct snd_seq_event *ev) +note_off_event(seq_oss_devinfo_t *dp, int dev, int ch, int note, int vel, snd_seq_event_t *ev) { - struct seq_oss_synthinfo *info = &dp->synths[dev]; + seq_oss_synthinfo_t *info = &dp->synths[dev]; switch (info->arg.event_passing) { case SNDRV_SEQ_OSS_PROCESS_EVENTS: if (! info->ch || ch < 0 || ch >= info->nr_voices) { @@ -369,7 +369,7 @@ note_off_event(struct seq_oss_devinfo *dp, int dev, int ch, int note, int vel, s * create a note event */ static int -set_note_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int note, int vel, struct snd_seq_event *ev) +set_note_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int note, int vel, snd_seq_event_t *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev)) return -ENXIO; @@ -387,7 +387,7 @@ set_note_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int note, * create a control event */ static int -set_control_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int param, int val, struct snd_seq_event *ev) +set_control_event(seq_oss_devinfo_t *dp, int dev, int type, int ch, int param, int val, snd_seq_event_t *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev)) return -ENXIO; @@ -405,7 +405,7 @@ set_control_event(struct seq_oss_devinfo *dp, int dev, int type, int ch, int par * create an echo event */ static int -set_echo_event(struct seq_oss_devinfo *dp, union evrec *rec, struct snd_seq_event *ev) +set_echo_event(seq_oss_devinfo_t *dp, evrec_t *rec, snd_seq_event_t *ev) { ev->type = SNDRV_SEQ_EVENT_ECHO; /* echo back to itself */ @@ -419,11 +419,11 @@ set_echo_event(struct seq_oss_devinfo *dp, union evrec *rec, struct snd_seq_even * the echo event is processed here. */ int -snd_seq_oss_event_input(struct snd_seq_event *ev, int direct, void *private_data, +snd_seq_oss_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private_data; - union evrec *rec; + seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private_data; + evrec_t *rec; if (ev->type != SNDRV_SEQ_EVENT_ECHO) return snd_seq_oss_midi_input(ev, direct, private_data); @@ -431,7 +431,7 @@ snd_seq_oss_event_input(struct snd_seq_event *ev, int direct, void *private_data if (ev->source.client != dp->cseq) return 0; /* ignored */ - rec = (union evrec*)&ev->data; + rec = (evrec_t*)&ev->data; if (rec->s.code == SEQ_SYNCTIMER) { /* sync echo back */ snd_seq_oss_writeq_wakeup(dp->writeq, rec->t.time); diff --git a/trunk/sound/core/seq/oss/seq_oss_event.h b/trunk/sound/core/seq/oss/seq_oss_event.h index 9a4d9adb7b8c..bf1d4d3f53c9 100644 --- a/trunk/sound/core/seq/oss/seq_oss_event.h +++ b/trunk/sound/core/seq/oss/seq_oss_event.h @@ -29,74 +29,74 @@ #define LONG_EVENT_SIZE 8 /* short event (4bytes) */ -struct evrec_short { +typedef struct evrec_short_t { unsigned char code; unsigned char parm1; unsigned char dev; unsigned char parm2; -}; +} evrec_short_t; /* short note events (4bytes) */ -struct evrec_note { +typedef struct evrec_note_t { unsigned char code; unsigned char chn; unsigned char note; unsigned char vel; -}; +} evrec_note_t; /* long timer events (8bytes) */ -struct evrec_timer { +typedef struct evrec_timer_t { unsigned char code; unsigned char cmd; unsigned char dummy1, dummy2; unsigned int time; -}; +} evrec_timer_t; /* long extended events (8bytes) */ -struct evrec_extended { +typedef struct evrec_extended_t { unsigned char code; unsigned char cmd; unsigned char dev; unsigned char chn; unsigned char p1, p2, p3, p4; -}; +} evrec_extended_t; /* long channel events (8bytes) */ -struct evrec_long { +typedef struct evrec_long_t { unsigned char code; unsigned char dev; unsigned char cmd; unsigned char chn; unsigned char p1, p2; unsigned short val; -}; +} evrec_long_t; /* channel voice events (8bytes) */ -struct evrec_voice { +typedef struct evrec_voice_t { unsigned char code; unsigned char dev; unsigned char cmd; unsigned char chn; unsigned char note, parm; unsigned short dummy; -}; +} evrec_voice_t; /* sysex events (8bytes) */ -struct evrec_sysex { +typedef struct evrec_sysex_t { unsigned char code; unsigned char dev; unsigned char buf[6]; -}; +} evrec_sysex_t; /* event record */ -union evrec { - struct evrec_short s; - struct evrec_note n; - struct evrec_long l; - struct evrec_voice v; - struct evrec_timer t; - struct evrec_extended e; - struct evrec_sysex x; +union evrec_t { + evrec_short_t s; + evrec_note_t n; + evrec_long_t l; + evrec_voice_t v; + evrec_timer_t t; + evrec_extended_t e; + evrec_sysex_t x; unsigned int echo; unsigned char c[LONG_EVENT_SIZE]; }; @@ -104,9 +104,9 @@ union evrec { #define ev_is_long(ev) ((ev)->s.code >= 128) #define ev_length(ev) ((ev)->s.code >= 128 ? LONG_EVENT_SIZE : SHORT_EVENT_SIZE) -int snd_seq_oss_process_event(struct seq_oss_devinfo *dp, union evrec *q, struct snd_seq_event *ev); -int snd_seq_oss_process_timer_event(struct seq_oss_timer *rec, union evrec *q); -int snd_seq_oss_event_input(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop); +int snd_seq_oss_process_event(seq_oss_devinfo_t *dp, evrec_t *q, snd_seq_event_t *ev); +int snd_seq_oss_process_timer_event(seq_oss_timer_t *rec, evrec_t *q); +int snd_seq_oss_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop); #endif /* __SEQ_OSS_EVENT_H */ diff --git a/trunk/sound/core/seq/oss/seq_oss_init.c b/trunk/sound/core/seq/oss/seq_oss_init.c index ca5a2ed4d7c3..1ab1cf8158c8 100644 --- a/trunk/sound/core/seq/oss/seq_oss_init.c +++ b/trunk/sound/core/seq/oss/seq_oss_init.c @@ -41,17 +41,17 @@ static int system_client = -1; /* ALSA sequencer client number */ static int system_port = -1; static int num_clients; -static struct seq_oss_devinfo *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS]; +static seq_oss_devinfo_t *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS]; /* * prototypes */ -static int receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop); +static int receive_announce(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop); static int translate_mode(struct file *file); -static int create_port(struct seq_oss_devinfo *dp); -static int delete_port(struct seq_oss_devinfo *dp); -static int alloc_seq_queue(struct seq_oss_devinfo *dp); +static int create_port(seq_oss_devinfo_t *dp); +static int delete_port(seq_oss_devinfo_t *dp); +static int alloc_seq_queue(seq_oss_devinfo_t *dp); static int delete_seq_queue(int queue); static void free_devinfo(void *private); @@ -65,24 +65,40 @@ int __init snd_seq_oss_create_client(void) { int rc; - struct snd_seq_port_info *port; - struct snd_seq_port_callback port_callback; + snd_seq_client_callback_t callback; + snd_seq_client_info_t *info; + snd_seq_port_info_t *port; + snd_seq_port_callback_t port_callback; + info = kmalloc(sizeof(*info), GFP_KERNEL); port = kmalloc(sizeof(*port), GFP_KERNEL); - if (!port) { + if (!info || !port) { rc = -ENOMEM; goto __error; } /* create ALSA client */ - rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS, - "OSS sequencer"); + memset(&callback, 0, sizeof(callback)); + + callback.private_data = NULL; + callback.allow_input = 1; + callback.allow_output = 1; + + rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS, &callback); if (rc < 0) goto __error; system_client = rc; debug_printk(("new client = %d\n", rc)); + /* set client information */ + memset(info, 0, sizeof(*info)); + info->client = system_client; + info->type = KERNEL_CLIENT; + strcpy(info->name, "OSS sequencer"); + + rc = call_ctl(SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, info); + /* look up midi devices */ snd_seq_oss_midi_lookup_ports(system_client); @@ -102,7 +118,7 @@ snd_seq_oss_create_client(void) call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, port); if ((system_port = port->addr.port) >= 0) { - struct snd_seq_port_subscribe subs; + snd_seq_port_subscribe_t subs; memset(&subs, 0, sizeof(subs)); subs.sender.client = SNDRV_SEQ_CLIENT_SYSTEM; @@ -115,6 +131,7 @@ snd_seq_oss_create_client(void) __error: kfree(port); + kfree(info); return rc; } @@ -123,9 +140,9 @@ snd_seq_oss_create_client(void) * receive annoucement from system port, and check the midi device */ static int -receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop) +receive_announce(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop) { - struct snd_seq_port_info pinfo; + snd_seq_port_info_t pinfo; if (atomic) return 0; /* it must not happen */ @@ -174,7 +191,7 @@ int snd_seq_oss_open(struct file *file, int level) { int i, rc; - struct seq_oss_devinfo *dp; + seq_oss_devinfo_t *dp; if ((dp = kzalloc(sizeof(*dp), GFP_KERNEL)) == NULL) { snd_printk(KERN_ERR "can't malloc device info\n"); @@ -306,11 +323,11 @@ translate_mode(struct file *file) * create sequencer port */ static int -create_port(struct seq_oss_devinfo *dp) +create_port(seq_oss_devinfo_t *dp) { int rc; - struct snd_seq_port_info port; - struct snd_seq_port_callback callback; + snd_seq_port_info_t port; + snd_seq_port_callback_t callback; memset(&port, 0, sizeof(port)); port.addr.client = dp->cseq; @@ -341,7 +358,7 @@ create_port(struct seq_oss_devinfo *dp) * delete ALSA port */ static int -delete_port(struct seq_oss_devinfo *dp) +delete_port(seq_oss_devinfo_t *dp) { if (dp->port < 0) return 0; @@ -354,9 +371,9 @@ delete_port(struct seq_oss_devinfo *dp) * allocate a queue */ static int -alloc_seq_queue(struct seq_oss_devinfo *dp) +alloc_seq_queue(seq_oss_devinfo_t *dp) { - struct snd_seq_queue_info qinfo; + snd_seq_queue_info_t qinfo; int rc; memset(&qinfo, 0, sizeof(qinfo)); @@ -375,7 +392,7 @@ alloc_seq_queue(struct seq_oss_devinfo *dp) static int delete_seq_queue(int queue) { - struct snd_seq_queue_info qinfo; + snd_seq_queue_info_t qinfo; int rc; if (queue < 0) @@ -395,7 +412,7 @@ delete_seq_queue(int queue) static void free_devinfo(void *private) { - struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private; + seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private; if (dp->timer) snd_seq_oss_timer_delete(dp->timer); @@ -414,7 +431,7 @@ free_devinfo(void *private) * close sequencer device */ void -snd_seq_oss_release(struct seq_oss_devinfo *dp) +snd_seq_oss_release(seq_oss_devinfo_t *dp) { int queue; @@ -443,7 +460,7 @@ snd_seq_oss_release(struct seq_oss_devinfo *dp) * Wait until the queue is empty (if we don't have nonblock) */ void -snd_seq_oss_drain_write(struct seq_oss_devinfo *dp) +snd_seq_oss_drain_write(seq_oss_devinfo_t *dp) { if (! dp->timer->running) return; @@ -460,7 +477,7 @@ snd_seq_oss_drain_write(struct seq_oss_devinfo *dp) * reset sequencer devices */ void -snd_seq_oss_reset(struct seq_oss_devinfo *dp) +snd_seq_oss_reset(seq_oss_devinfo_t *dp) { int i; @@ -485,7 +502,6 @@ snd_seq_oss_reset(struct seq_oss_devinfo *dp) } -#ifdef CONFIG_PROC_FS /* * misc. functions for proc interface */ @@ -509,10 +525,10 @@ filemode_str(int val) * proc interface */ void -snd_seq_oss_system_info_read(struct snd_info_buffer *buf) +snd_seq_oss_system_info_read(snd_info_buffer_t *buf) { int i; - struct seq_oss_devinfo *dp; + seq_oss_devinfo_t *dp; snd_iprintf(buf, "ALSA client number %d\n", system_client); snd_iprintf(buf, "ALSA receiver port %d\n", system_port); @@ -536,4 +552,4 @@ snd_seq_oss_system_info_read(struct snd_info_buffer *buf) snd_seq_oss_readq_info_read(dp->readq, buf); } } -#endif /* CONFIG_PROC_FS */ + diff --git a/trunk/sound/core/seq/oss/seq_oss_ioctl.c b/trunk/sound/core/seq/oss/seq_oss_ioctl.c index 5ac701c903c1..e86f18d00f39 100644 --- a/trunk/sound/core/seq/oss/seq_oss_ioctl.c +++ b/trunk/sound/core/seq/oss/seq_oss_ioctl.c @@ -28,7 +28,7 @@ #include "seq_oss_midi.h" #include "seq_oss_event.h" -static int snd_seq_oss_synth_info_user(struct seq_oss_devinfo *dp, void __user *arg) +static int snd_seq_oss_synth_info_user(seq_oss_devinfo_t *dp, void __user *arg) { struct synth_info info; @@ -41,7 +41,7 @@ static int snd_seq_oss_synth_info_user(struct seq_oss_devinfo *dp, void __user * return 0; } -static int snd_seq_oss_midi_info_user(struct seq_oss_devinfo *dp, void __user *arg) +static int snd_seq_oss_midi_info_user(seq_oss_devinfo_t *dp, void __user *arg) { struct midi_info info; @@ -54,24 +54,24 @@ static int snd_seq_oss_midi_info_user(struct seq_oss_devinfo *dp, void __user *a return 0; } -static int snd_seq_oss_oob_user(struct seq_oss_devinfo *dp, void __user *arg) +static int snd_seq_oss_oob_user(seq_oss_devinfo_t *dp, void __user *arg) { unsigned char ev[8]; - struct snd_seq_event tmpev; + snd_seq_event_t tmpev; if (copy_from_user(ev, arg, 8)) return -EFAULT; memset(&tmpev, 0, sizeof(tmpev)); snd_seq_oss_fill_addr(dp, &tmpev, dp->addr.port, dp->addr.client); tmpev.time.tick = 0; - if (! snd_seq_oss_process_event(dp, (union evrec *)ev, &tmpev)) { + if (! snd_seq_oss_process_event(dp, (evrec_t*)ev, &tmpev)) { snd_seq_oss_dispatch(dp, &tmpev, 0, 0); } return 0; } int -snd_seq_oss_ioctl(struct seq_oss_devinfo *dp, unsigned int cmd, unsigned long carg) +snd_seq_oss_ioctl(seq_oss_devinfo_t *dp, unsigned int cmd, unsigned long carg) { int dev, val; void __user *arg = (void __user *)carg; diff --git a/trunk/sound/core/seq/oss/seq_oss_midi.c b/trunk/sound/core/seq/oss/seq_oss_midi.c index 0a711d2d04f0..f0e95c8f2eef 100644 --- a/trunk/sound/core/seq/oss/seq_oss_midi.c +++ b/trunk/sound/core/seq/oss/seq_oss_midi.c @@ -37,15 +37,15 @@ /* * definition of midi device record */ -struct seq_oss_midi { +struct seq_oss_midi_t { int seq_device; /* device number */ int client; /* sequencer client number */ int port; /* sequencer port number */ unsigned int flags; /* port capability */ int opened; /* flag for opening */ unsigned char name[SNDRV_SEQ_OSS_MAX_MIDI_NAME]; - struct snd_midi_event *coder; /* MIDI event coder */ - struct seq_oss_devinfo *devinfo; /* assigned OSSseq device */ + snd_midi_event_t *coder; /* MIDI event coder */ + seq_oss_devinfo_t *devinfo; /* assigned OSSseq device */ snd_use_lock_t use_lock; }; @@ -54,17 +54,17 @@ struct seq_oss_midi { * midi device table */ static int max_midi_devs; -static struct seq_oss_midi *midi_devs[SNDRV_SEQ_OSS_MAX_MIDI_DEVS]; +static seq_oss_midi_t *midi_devs[SNDRV_SEQ_OSS_MAX_MIDI_DEVS]; static DEFINE_SPINLOCK(register_lock); /* * prototypes */ -static struct seq_oss_midi *get_mdev(int dev); -static struct seq_oss_midi *get_mididev(struct seq_oss_devinfo *dp, int dev); -static int send_synth_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dev); -static int send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, struct seq_oss_midi *mdev); +static seq_oss_midi_t *get_mdev(int dev); +static seq_oss_midi_t *get_mididev(seq_oss_devinfo_t *dp, int dev); +static int send_synth_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dev); +static int send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_midi_t *mdev); /* * look up the existing ports @@ -73,8 +73,8 @@ static int send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int __init snd_seq_oss_midi_lookup_ports(int client) { - struct snd_seq_client_info *clinfo; - struct snd_seq_port_info *pinfo; + snd_seq_client_info_t *clinfo; + snd_seq_port_info_t *pinfo; clinfo = kzalloc(sizeof(*clinfo), GFP_KERNEL); pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL); @@ -100,10 +100,10 @@ snd_seq_oss_midi_lookup_ports(int client) /* */ -static struct seq_oss_midi * +static seq_oss_midi_t * get_mdev(int dev) { - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -117,11 +117,11 @@ get_mdev(int dev) /* * look for the identical slot */ -static struct seq_oss_midi * +static seq_oss_midi_t * find_slot(int client, int port) { int i; - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -145,10 +145,10 @@ find_slot(int client, int port) * register a new port if it doesn't exist yet */ int -snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo) +snd_seq_oss_midi_check_new_port(snd_seq_port_info_t *pinfo) { int i; - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; unsigned long flags; debug_printk(("check for MIDI client %d port %d\n", pinfo->addr.client, pinfo->addr.port)); @@ -226,7 +226,7 @@ snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo) int snd_seq_oss_midi_check_exit_port(int client, int port) { - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; unsigned long flags; int index; @@ -258,7 +258,7 @@ void snd_seq_oss_midi_clear_all(void) { int i; - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -279,7 +279,7 @@ snd_seq_oss_midi_clear_all(void) * set up midi tables */ void -snd_seq_oss_midi_setup(struct seq_oss_devinfo *dp) +snd_seq_oss_midi_setup(seq_oss_devinfo_t *dp) { dp->max_mididev = max_midi_devs; } @@ -288,7 +288,7 @@ snd_seq_oss_midi_setup(struct seq_oss_devinfo *dp) * clean up midi tables */ void -snd_seq_oss_midi_cleanup(struct seq_oss_devinfo *dp) +snd_seq_oss_midi_cleanup(seq_oss_devinfo_t *dp) { int i; for (i = 0; i < dp->max_mididev; i++) @@ -301,7 +301,7 @@ snd_seq_oss_midi_cleanup(struct seq_oss_devinfo *dp) * open all midi devices. ignore errors. */ void -snd_seq_oss_midi_open_all(struct seq_oss_devinfo *dp, int file_mode) +snd_seq_oss_midi_open_all(seq_oss_devinfo_t *dp, int file_mode) { int i; for (i = 0; i < dp->max_mididev; i++) @@ -312,8 +312,8 @@ snd_seq_oss_midi_open_all(struct seq_oss_devinfo *dp, int file_mode) /* * get the midi device information */ -static struct seq_oss_midi * -get_mididev(struct seq_oss_devinfo *dp, int dev) +static seq_oss_midi_t * +get_mididev(seq_oss_devinfo_t *dp, int dev) { if (dev < 0 || dev >= dp->max_mididev) return NULL; @@ -325,11 +325,11 @@ get_mididev(struct seq_oss_devinfo *dp, int dev) * open the midi device if not opened yet */ int -snd_seq_oss_midi_open(struct seq_oss_devinfo *dp, int dev, int fmode) +snd_seq_oss_midi_open(seq_oss_devinfo_t *dp, int dev, int fmode) { int perm; - struct seq_oss_midi *mdev; - struct snd_seq_port_subscribe subs; + seq_oss_midi_t *mdev; + snd_seq_port_subscribe_t subs; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENODEV; @@ -392,10 +392,10 @@ snd_seq_oss_midi_open(struct seq_oss_devinfo *dp, int dev, int fmode) * close the midi device if already opened */ int -snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev) +snd_seq_oss_midi_close(seq_oss_devinfo_t *dp, int dev) { - struct seq_oss_midi *mdev; - struct snd_seq_port_subscribe subs; + seq_oss_midi_t *mdev; + snd_seq_port_subscribe_t subs; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENODEV; @@ -430,9 +430,9 @@ snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev) * change seq capability flags to file mode flags */ int -snd_seq_oss_midi_filemode(struct seq_oss_devinfo *dp, int dev) +snd_seq_oss_midi_filemode(seq_oss_devinfo_t *dp, int dev) { - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; int mode; if ((mdev = get_mididev(dp, dev)) == NULL) @@ -453,9 +453,9 @@ snd_seq_oss_midi_filemode(struct seq_oss_devinfo *dp, int dev) * so far, only close the device. */ void -snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev) +snd_seq_oss_midi_reset(seq_oss_devinfo_t *dp, int dev) { - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return; @@ -465,7 +465,7 @@ snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev) } if (mdev->opened & PERM_WRITE) { - struct snd_seq_event ev; + snd_seq_event_t ev; int c; debug_printk(("resetting client %d port %d\n", mdev->client, mdev->port)); @@ -501,9 +501,9 @@ snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev) * get client/port of the specified MIDI device */ void -snd_seq_oss_midi_get_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_addr *addr) +snd_seq_oss_midi_get_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_addr_t *addr) { - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return; @@ -517,10 +517,10 @@ snd_seq_oss_midi_get_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_ad * input callback - this can be atomic */ int -snd_seq_oss_midi_input(struct snd_seq_event *ev, int direct, void *private_data) +snd_seq_oss_midi_input(snd_seq_event_t *ev, int direct, void *private_data) { - struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private_data; - struct seq_oss_midi *mdev; + seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private_data; + seq_oss_midi_t *mdev; int rc; if (dp->readq == NULL) @@ -545,9 +545,9 @@ snd_seq_oss_midi_input(struct snd_seq_event *ev, int direct, void *private_data) * convert ALSA sequencer event to OSS synth event */ static int -send_synth_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dev) +send_synth_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dev) { - union evrec ossev; + evrec_t ossev; memset(&ossev, 0, sizeof(ossev)); @@ -606,7 +606,7 @@ send_synth_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, int dev) * decode event and send MIDI bytes to read queue */ static int -send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, struct seq_oss_midi *mdev) +send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_midi_t *mdev) { char msg[32]; int len; @@ -634,9 +634,9 @@ send_midi_event(struct seq_oss_devinfo *dp, struct snd_seq_event *ev, struct seq * non-zero : invalid - ignored */ int -snd_seq_oss_midi_putc(struct seq_oss_devinfo *dp, int dev, unsigned char c, struct snd_seq_event *ev) +snd_seq_oss_midi_putc(seq_oss_devinfo_t *dp, int dev, unsigned char c, snd_seq_event_t *ev) { - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENODEV; @@ -653,9 +653,9 @@ snd_seq_oss_midi_putc(struct seq_oss_devinfo *dp, int dev, unsigned char c, stru * create OSS compatible midi_info record */ int -snd_seq_oss_midi_make_info(struct seq_oss_devinfo *dp, int dev, struct midi_info *inf) +snd_seq_oss_midi_make_info(seq_oss_devinfo_t *dp, int dev, struct midi_info *inf) { - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; if ((mdev = get_mididev(dp, dev)) == NULL) return -ENXIO; @@ -668,7 +668,6 @@ snd_seq_oss_midi_make_info(struct seq_oss_devinfo *dp, int dev, struct midi_info } -#ifdef CONFIG_PROC_FS /* * proc interface */ @@ -687,10 +686,10 @@ capmode_str(int val) } void -snd_seq_oss_midi_info_read(struct snd_info_buffer *buf) +snd_seq_oss_midi_info_read(snd_info_buffer_t *buf) { int i; - struct seq_oss_midi *mdev; + seq_oss_midi_t *mdev; snd_iprintf(buf, "\nNumber of MIDI devices: %d\n", max_midi_devs); for (i = 0; i < max_midi_devs; i++) { @@ -708,4 +707,4 @@ snd_seq_oss_midi_info_read(struct snd_info_buffer *buf) snd_use_lock_free(&mdev->use_lock); } } -#endif /* CONFIG_PROC_FS */ + diff --git a/trunk/sound/core/seq/oss/seq_oss_midi.h b/trunk/sound/core/seq/oss/seq_oss_midi.h index 84eb866ba58e..462484b2b6fe 100644 --- a/trunk/sound/core/seq/oss/seq_oss_midi.h +++ b/trunk/sound/core/seq/oss/seq_oss_midi.h @@ -26,23 +26,24 @@ #include "seq_oss_device.h" #include <sound/seq_oss_legacy.h> +typedef struct seq_oss_midi_t seq_oss_midi_t; + int snd_seq_oss_midi_lookup_ports(int client); -int snd_seq_oss_midi_check_new_port(struct snd_seq_port_info *pinfo); +int snd_seq_oss_midi_check_new_port(snd_seq_port_info_t *pinfo); int snd_seq_oss_midi_check_exit_port(int client, int port); void snd_seq_oss_midi_clear_all(void); -void snd_seq_oss_midi_setup(struct seq_oss_devinfo *dp); -void snd_seq_oss_midi_cleanup(struct seq_oss_devinfo *dp); +void snd_seq_oss_midi_setup(seq_oss_devinfo_t *dp); +void snd_seq_oss_midi_cleanup(seq_oss_devinfo_t *dp); -int snd_seq_oss_midi_open(struct seq_oss_devinfo *dp, int dev, int file_mode); -void snd_seq_oss_midi_open_all(struct seq_oss_devinfo *dp, int file_mode); -int snd_seq_oss_midi_close(struct seq_oss_devinfo *dp, int dev); -void snd_seq_oss_midi_reset(struct seq_oss_devinfo *dp, int dev); -int snd_seq_oss_midi_putc(struct seq_oss_devinfo *dp, int dev, unsigned char c, - struct snd_seq_event *ev); -int snd_seq_oss_midi_input(struct snd_seq_event *ev, int direct, void *private); -int snd_seq_oss_midi_filemode(struct seq_oss_devinfo *dp, int dev); -int snd_seq_oss_midi_make_info(struct seq_oss_devinfo *dp, int dev, struct midi_info *inf); -void snd_seq_oss_midi_get_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_addr *addr); +int snd_seq_oss_midi_open(seq_oss_devinfo_t *dp, int dev, int file_mode); +void snd_seq_oss_midi_open_all(seq_oss_devinfo_t *dp, int file_mode); +int snd_seq_oss_midi_close(seq_oss_devinfo_t *dp, int dev); +void snd_seq_oss_midi_reset(seq_oss_devinfo_t *dp, int dev); +int snd_seq_oss_midi_putc(seq_oss_devinfo_t *dp, int dev, unsigned char c, snd_seq_event_t *ev); +int snd_seq_oss_midi_input(snd_seq_event_t *ev, int direct, void *private); +int snd_seq_oss_midi_filemode(seq_oss_devinfo_t *dp, int dev); +int snd_seq_oss_midi_make_info(seq_oss_devinfo_t *dp, int dev, struct midi_info *inf); +void snd_seq_oss_midi_get_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_addr_t *addr); #endif diff --git a/trunk/sound/core/seq/oss/seq_oss_readq.c b/trunk/sound/core/seq/oss/seq_oss_readq.c index f5de79f29f1e..55571e15cd38 100644 --- a/trunk/sound/core/seq/oss/seq_oss_readq.c +++ b/trunk/sound/core/seq/oss/seq_oss_readq.c @@ -41,17 +41,17 @@ /* * create a read queue */ -struct seq_oss_readq * -snd_seq_oss_readq_new(struct seq_oss_devinfo *dp, int maxlen) +seq_oss_readq_t * +snd_seq_oss_readq_new(seq_oss_devinfo_t *dp, int maxlen) { - struct seq_oss_readq *q; + seq_oss_readq_t *q; if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) { snd_printk(KERN_ERR "can't malloc read queue\n"); return NULL; } - if ((q->q = kcalloc(maxlen, sizeof(union evrec), GFP_KERNEL)) == NULL) { + if ((q->q = kcalloc(maxlen, sizeof(evrec_t), GFP_KERNEL)) == NULL) { snd_printk(KERN_ERR "can't malloc read queue buffer\n"); kfree(q); return NULL; @@ -72,7 +72,7 @@ snd_seq_oss_readq_new(struct seq_oss_devinfo *dp, int maxlen) * delete the read queue */ void -snd_seq_oss_readq_delete(struct seq_oss_readq *q) +snd_seq_oss_readq_delete(seq_oss_readq_t *q) { if (q) { kfree(q->q); @@ -84,7 +84,7 @@ snd_seq_oss_readq_delete(struct seq_oss_readq *q) * reset the read queue */ void -snd_seq_oss_readq_clear(struct seq_oss_readq *q) +snd_seq_oss_readq_clear(seq_oss_readq_t *q) { if (q->qlen) { q->qlen = 0; @@ -100,9 +100,9 @@ snd_seq_oss_readq_clear(struct seq_oss_readq *q) * put a midi byte */ int -snd_seq_oss_readq_puts(struct seq_oss_readq *q, int dev, unsigned char *data, int len) +snd_seq_oss_readq_puts(seq_oss_readq_t *q, int dev, unsigned char *data, int len) { - union evrec rec; + evrec_t rec; int result; memset(&rec, 0, sizeof(rec)); @@ -123,7 +123,7 @@ snd_seq_oss_readq_puts(struct seq_oss_readq *q, int dev, unsigned char *data, in * return zero if enqueued */ int -snd_seq_oss_readq_put_event(struct seq_oss_readq *q, union evrec *ev) +snd_seq_oss_readq_put_event(seq_oss_readq_t *q, evrec_t *ev) { unsigned long flags; @@ -152,7 +152,7 @@ snd_seq_oss_readq_put_event(struct seq_oss_readq *q, union evrec *ev) * caller must hold lock */ int -snd_seq_oss_readq_pick(struct seq_oss_readq *q, union evrec *rec) +snd_seq_oss_readq_pick(seq_oss_readq_t *q, evrec_t *rec) { if (q->qlen == 0) return -EAGAIN; @@ -164,7 +164,7 @@ snd_seq_oss_readq_pick(struct seq_oss_readq *q, union evrec *rec) * sleep until ready */ void -snd_seq_oss_readq_wait(struct seq_oss_readq *q) +snd_seq_oss_readq_wait(seq_oss_readq_t *q) { wait_event_interruptible_timeout(q->midi_sleep, (q->qlen > 0 || q->head == q->tail), @@ -176,7 +176,7 @@ snd_seq_oss_readq_wait(struct seq_oss_readq *q) * caller must hold lock */ void -snd_seq_oss_readq_free(struct seq_oss_readq *q) +snd_seq_oss_readq_free(seq_oss_readq_t *q) { if (q->qlen > 0) { q->head = (q->head + 1) % q->maxlen; @@ -189,7 +189,7 @@ snd_seq_oss_readq_free(struct seq_oss_readq *q) * return non-zero if readq is not empty. */ unsigned int -snd_seq_oss_readq_poll(struct seq_oss_readq *q, struct file *file, poll_table *wait) +snd_seq_oss_readq_poll(seq_oss_readq_t *q, struct file *file, poll_table *wait) { poll_wait(file, &q->midi_sleep, wait); return q->qlen; @@ -199,10 +199,10 @@ snd_seq_oss_readq_poll(struct seq_oss_readq *q, struct file *file, poll_table *w * put a timestamp */ int -snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *q, unsigned long curt, int seq_mode) +snd_seq_oss_readq_put_timestamp(seq_oss_readq_t *q, unsigned long curt, int seq_mode) { if (curt != q->input_time) { - union evrec rec; + evrec_t rec; memset(&rec, 0, sizeof(rec)); switch (seq_mode) { case SNDRV_SEQ_OSS_MODE_SYNTH: @@ -222,15 +222,13 @@ snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *q, unsigned long curt, int } -#ifdef CONFIG_PROC_FS /* * proc interface */ void -snd_seq_oss_readq_info_read(struct seq_oss_readq *q, struct snd_info_buffer *buf) +snd_seq_oss_readq_info_read(seq_oss_readq_t *q, snd_info_buffer_t *buf) { snd_iprintf(buf, " read queue [%s] length = %d : tick = %ld\n", (waitqueue_active(&q->midi_sleep) ? "sleeping":"running"), q->qlen, q->input_time); } -#endif /* CONFIG_PROC_FS */ diff --git a/trunk/sound/core/seq/oss/seq_oss_readq.h b/trunk/sound/core/seq/oss/seq_oss_readq.h index f1463f1f449e..303b9298f206 100644 --- a/trunk/sound/core/seq/oss/seq_oss_readq.h +++ b/trunk/sound/core/seq/oss/seq_oss_readq.h @@ -28,8 +28,8 @@ /* * definition of read queue */ -struct seq_oss_readq { - union evrec *q; +struct seq_oss_readq_t { + evrec_t *q; int qlen; int maxlen; int head, tail; @@ -39,16 +39,16 @@ struct seq_oss_readq { spinlock_t lock; }; -struct seq_oss_readq *snd_seq_oss_readq_new(struct seq_oss_devinfo *dp, int maxlen); -void snd_seq_oss_readq_delete(struct seq_oss_readq *q); -void snd_seq_oss_readq_clear(struct seq_oss_readq *readq); -unsigned int snd_seq_oss_readq_poll(struct seq_oss_readq *readq, struct file *file, poll_table *wait); -int snd_seq_oss_readq_puts(struct seq_oss_readq *readq, int dev, unsigned char *data, int len); -int snd_seq_oss_readq_put_event(struct seq_oss_readq *readq, union evrec *ev); -int snd_seq_oss_readq_put_timestamp(struct seq_oss_readq *readq, unsigned long curt, int seq_mode); -int snd_seq_oss_readq_pick(struct seq_oss_readq *q, union evrec *rec); -void snd_seq_oss_readq_wait(struct seq_oss_readq *q); -void snd_seq_oss_readq_free(struct seq_oss_readq *q); +seq_oss_readq_t *snd_seq_oss_readq_new(seq_oss_devinfo_t *dp, int maxlen); +void snd_seq_oss_readq_delete(seq_oss_readq_t *q); +void snd_seq_oss_readq_clear(seq_oss_readq_t *readq); +unsigned int snd_seq_oss_readq_poll(seq_oss_readq_t *readq, struct file *file, poll_table *wait); +int snd_seq_oss_readq_puts(seq_oss_readq_t *readq, int dev, unsigned char *data, int len); +int snd_seq_oss_readq_put_event(seq_oss_readq_t *readq, evrec_t *ev); +int snd_seq_oss_readq_put_timestamp(seq_oss_readq_t *readq, unsigned long curt, int seq_mode); +int snd_seq_oss_readq_pick(seq_oss_readq_t *q, evrec_t *rec); +void snd_seq_oss_readq_wait(seq_oss_readq_t *q); +void snd_seq_oss_readq_free(seq_oss_readq_t *q); #define snd_seq_oss_readq_lock(q, flags) spin_lock_irqsave(&(q)->lock, flags) #define snd_seq_oss_readq_unlock(q, flags) spin_unlock_irqrestore(&(q)->lock, flags) diff --git a/trunk/sound/core/seq/oss/seq_oss_rw.c b/trunk/sound/core/seq/oss/seq_oss_rw.c index 6a7b6aceeca9..1d8fbd22e3e3 100644 --- a/trunk/sound/core/seq/oss/seq_oss_rw.c +++ b/trunk/sound/core/seq/oss/seq_oss_rw.c @@ -33,7 +33,7 @@ /* * protoypes */ -static int insert_queue(struct seq_oss_devinfo *dp, union evrec *rec, struct file *opt); +static int insert_queue(seq_oss_devinfo_t *dp, evrec_t *rec, struct file *opt); /* @@ -41,12 +41,12 @@ static int insert_queue(struct seq_oss_devinfo *dp, union evrec *rec, struct fil */ int -snd_seq_oss_read(struct seq_oss_devinfo *dp, char __user *buf, int count) +snd_seq_oss_read(seq_oss_devinfo_t *dp, char __user *buf, int count) { - struct seq_oss_readq *readq = dp->readq; + seq_oss_readq_t *readq = dp->readq; int result = 0, err = 0; int ev_len; - union evrec rec; + evrec_t rec; unsigned long flags; if (readq == NULL || ! is_read_mode(dp->file_mode)) @@ -93,11 +93,11 @@ snd_seq_oss_read(struct seq_oss_devinfo *dp, char __user *buf, int count) */ int -snd_seq_oss_write(struct seq_oss_devinfo *dp, const char __user *buf, int count, struct file *opt) +snd_seq_oss_write(seq_oss_devinfo_t *dp, const char __user *buf, int count, struct file *opt) { int result = 0, err = 0; int ev_size, fmt; - union evrec rec; + evrec_t rec; if (! is_write_mode(dp->file_mode) || dp->writeq == NULL) return -ENXIO; @@ -161,10 +161,10 @@ snd_seq_oss_write(struct seq_oss_devinfo *dp, const char __user *buf, int count, * return: 0 = OK, non-zero = NG */ static int -insert_queue(struct seq_oss_devinfo *dp, union evrec *rec, struct file *opt) +insert_queue(seq_oss_devinfo_t *dp, evrec_t *rec, struct file *opt) { int rc = 0; - struct snd_seq_event event; + snd_seq_event_t event; /* if this is a timing event, process the current time */ if (snd_seq_oss_process_timer_event(dp->timer, rec)) @@ -197,7 +197,7 @@ insert_queue(struct seq_oss_devinfo *dp, union evrec *rec, struct file *opt) */ unsigned int -snd_seq_oss_poll(struct seq_oss_devinfo *dp, struct file *file, poll_table * wait) +snd_seq_oss_poll(seq_oss_devinfo_t *dp, struct file *file, poll_table * wait) { unsigned int mask = 0; diff --git a/trunk/sound/core/seq/oss/seq_oss_synth.c b/trunk/sound/core/seq/oss/seq_oss_synth.c index ab570a0a6183..8257fce2ca1b 100644 --- a/trunk/sound/core/seq/oss/seq_oss_synth.c +++ b/trunk/sound/core/seq/oss/seq_oss_synth.c @@ -37,14 +37,14 @@ */ /* sysex buffer */ -struct seq_oss_synth_sysex { +struct seq_oss_synth_sysex_t { int len; int skip; unsigned char buf[MAX_SYSEX_BUFLEN]; }; /* synth info */ -struct seq_oss_synth { +struct seq_oss_synth_t { int seq_device; /* for synth_info */ @@ -53,7 +53,7 @@ struct seq_oss_synth { int nr_voices; char name[SNDRV_SEQ_OSS_MAX_SYNTH_NAME]; - struct snd_seq_oss_callback oper; + snd_seq_oss_callback_t oper; int opened; @@ -66,8 +66,8 @@ struct seq_oss_synth { * device table */ static int max_synth_devs; -static struct seq_oss_synth *synth_devs[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; -static struct seq_oss_synth midi_synth_dev = { +static seq_oss_synth_t *synth_devs[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS]; +static seq_oss_synth_t midi_synth_dev = { -1, /* seq_device */ SYNTH_TYPE_MIDI, /* synth_type */ 0, /* synth_subtype */ @@ -80,8 +80,8 @@ static DEFINE_SPINLOCK(register_lock); /* * prototypes */ -static struct seq_oss_synth *get_synthdev(struct seq_oss_devinfo *dp, int dev); -static void reset_channels(struct seq_oss_synthinfo *info); +static seq_oss_synth_t *get_synthdev(seq_oss_devinfo_t *dp, int dev); +static void reset_channels(seq_oss_synthinfo_t *info); /* * global initialization @@ -96,11 +96,11 @@ snd_seq_oss_synth_init(void) * registration of the synth device */ int -snd_seq_oss_synth_register(struct snd_seq_device *dev) +snd_seq_oss_synth_register(snd_seq_device_t *dev) { int i; - struct seq_oss_synth *rec; - struct snd_seq_oss_reg *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev); + seq_oss_synth_t *rec; + snd_seq_oss_reg_t *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev); unsigned long flags; if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) { @@ -148,10 +148,10 @@ snd_seq_oss_synth_register(struct snd_seq_device *dev) int -snd_seq_oss_synth_unregister(struct snd_seq_device *dev) +snd_seq_oss_synth_unregister(snd_seq_device_t *dev) { int index; - struct seq_oss_synth *rec = dev->driver_data; + seq_oss_synth_t *rec = dev->driver_data; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -187,10 +187,10 @@ snd_seq_oss_synth_unregister(struct snd_seq_device *dev) /* */ -static struct seq_oss_synth * +static seq_oss_synth_t * get_sdev(int dev) { - struct seq_oss_synth *rec; + seq_oss_synth_t *rec; unsigned long flags; spin_lock_irqsave(®ister_lock, flags); @@ -207,11 +207,11 @@ get_sdev(int dev) */ void -snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp) +snd_seq_oss_synth_setup(seq_oss_devinfo_t *dp) { int i; - struct seq_oss_synth *rec; - struct seq_oss_synthinfo *info; + seq_oss_synth_t *rec; + seq_oss_synthinfo_t *info; dp->max_synthdev = max_synth_devs; dp->synth_opened = 0; @@ -244,7 +244,7 @@ snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp) } info->nr_voices = rec->nr_voices; if (info->nr_voices > 0) { - info->ch = kcalloc(info->nr_voices, sizeof(struct seq_oss_chinfo), GFP_KERNEL); + info->ch = kcalloc(info->nr_voices, sizeof(seq_oss_chinfo_t), GFP_KERNEL); if (!info->ch) BUG(); reset_channels(info); @@ -263,7 +263,7 @@ snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp) */ void -snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp) +snd_seq_oss_synth_setup_midi(seq_oss_devinfo_t *dp) { int i; @@ -271,7 +271,7 @@ snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp) return; for (i = 0; i < dp->max_mididev; i++) { - struct seq_oss_synthinfo *info; + seq_oss_synthinfo_t *info; info = &dp->synths[dp->max_synthdev]; if (snd_seq_oss_midi_open(dp, i, dp->file_mode) < 0) continue; @@ -297,11 +297,11 @@ snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp) */ void -snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp) +snd_seq_oss_synth_cleanup(seq_oss_devinfo_t *dp) { int i; - struct seq_oss_synth *rec; - struct seq_oss_synthinfo *info; + seq_oss_synth_t *rec; + seq_oss_synthinfo_t *info; snd_assert(dp->max_synthdev <= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS, return); for (i = 0; i < dp->max_synthdev; i++) { @@ -338,7 +338,7 @@ snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp) * check if the specified device is MIDI mapped device */ static int -is_midi_dev(struct seq_oss_devinfo *dp, int dev) +is_midi_dev(seq_oss_devinfo_t *dp, int dev) { if (dev < 0 || dev >= dp->max_synthdev) return 0; @@ -350,10 +350,10 @@ is_midi_dev(struct seq_oss_devinfo *dp, int dev) /* * return synth device information pointer */ -static struct seq_oss_synth * -get_synthdev(struct seq_oss_devinfo *dp, int dev) +static seq_oss_synth_t * +get_synthdev(seq_oss_devinfo_t *dp, int dev) { - struct seq_oss_synth *rec; + seq_oss_synth_t *rec; if (dev < 0 || dev >= dp->max_synthdev) return NULL; if (! dp->synths[dev].opened) @@ -374,7 +374,7 @@ get_synthdev(struct seq_oss_devinfo *dp, int dev) * reset note and velocity on each channel. */ static void -reset_channels(struct seq_oss_synthinfo *info) +reset_channels(seq_oss_synthinfo_t *info) { int i; if (info->ch == NULL || ! info->nr_voices) @@ -392,10 +392,10 @@ reset_channels(struct seq_oss_synthinfo *info) * event to the corresponding port. */ void -snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev) +snd_seq_oss_synth_reset(seq_oss_devinfo_t *dp, int dev) { - struct seq_oss_synth *rec; - struct seq_oss_synthinfo *info; + seq_oss_synth_t *rec; + seq_oss_synthinfo_t *info; snd_assert(dev >= 0 && dev < dp->max_synthdev, return); info = &dp->synths[dev]; @@ -428,7 +428,7 @@ snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev) if (rec->oper.reset) { rec->oper.reset(&info->arg); } else { - struct snd_seq_event ev; + snd_seq_event_t ev; memset(&ev, 0, sizeof(ev)); snd_seq_oss_fill_addr(dp, &ev, info->arg.addr.client, info->arg.addr.port); @@ -444,10 +444,10 @@ snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev) * call load_patch callback function */ int -snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt, +snd_seq_oss_synth_load_patch(seq_oss_devinfo_t *dp, int dev, int fmt, const char __user *buf, int p, int c) { - struct seq_oss_synth *rec; + seq_oss_synth_t *rec; int rc; if (dev < 0 || dev >= dp->max_synthdev) @@ -470,9 +470,9 @@ snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt, * check if the device is valid synth device */ int -snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev) +snd_seq_oss_synth_is_valid(seq_oss_devinfo_t *dp, int dev) { - struct seq_oss_synth *rec; + seq_oss_synth_t *rec; rec = get_synthdev(dp, dev); if (rec) { snd_use_lock_free(&rec->use_lock); @@ -488,11 +488,11 @@ snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev) * (0xff). */ int -snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, struct snd_seq_event *ev) +snd_seq_oss_synth_sysex(seq_oss_devinfo_t *dp, int dev, unsigned char *buf, snd_seq_event_t *ev) { int i, send; unsigned char *dest; - struct seq_oss_synth_sysex *sysex; + seq_oss_synth_sysex_t *sysex; if (! snd_seq_oss_synth_is_valid(dp, dev)) return -ENXIO; @@ -545,7 +545,7 @@ snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, * fill the event source/destination addresses */ int -snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event *ev) +snd_seq_oss_synth_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_event_t *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev)) return -EINVAL; @@ -559,9 +559,9 @@ snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event * OSS compatible ioctl */ int -snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, unsigned long addr) +snd_seq_oss_synth_ioctl(seq_oss_devinfo_t *dp, int dev, unsigned int cmd, unsigned long addr) { - struct seq_oss_synth *rec; + seq_oss_synth_t *rec; int rc; if (is_midi_dev(dp, dev)) @@ -581,7 +581,7 @@ snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, u * send OSS raw events - SEQ_PRIVATE and SEQ_VOLUME */ int -snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, unsigned char *data, struct snd_seq_event *ev) +snd_seq_oss_synth_raw_event(seq_oss_devinfo_t *dp, int dev, unsigned char *data, snd_seq_event_t *ev) { if (! snd_seq_oss_synth_is_valid(dp, dev) || is_midi_dev(dp, dev)) return -ENXIO; @@ -595,9 +595,9 @@ snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, unsigned char * * create OSS compatible synth_info record */ int -snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_info *inf) +snd_seq_oss_synth_make_info(seq_oss_devinfo_t *dp, int dev, struct synth_info *inf) { - struct seq_oss_synth *rec; + seq_oss_synth_t *rec; if (dp->synths[dev].is_midi) { struct midi_info minf; @@ -621,15 +621,14 @@ snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_in } -#ifdef CONFIG_PROC_FS /* * proc interface */ void -snd_seq_oss_synth_info_read(struct snd_info_buffer *buf) +snd_seq_oss_synth_info_read(snd_info_buffer_t *buf) { int i; - struct seq_oss_synth *rec; + seq_oss_synth_t *rec; snd_iprintf(buf, "\nNumber of synth devices: %d\n", max_synth_devs); for (i = 0; i < max_synth_devs; i++) { @@ -649,4 +648,4 @@ snd_seq_oss_synth_info_read(struct snd_info_buffer *buf) snd_use_lock_free(&rec->use_lock); } } -#endif /* CONFIG_PROC_FS */ + diff --git a/trunk/sound/core/seq/oss/seq_oss_synth.h b/trunk/sound/core/seq/oss/seq_oss_synth.h index dbdfcbb80eaa..07bc0e2cfb82 100644 --- a/trunk/sound/core/seq/oss/seq_oss_synth.h +++ b/trunk/sound/core/seq/oss/seq_oss_synth.h @@ -27,25 +27,23 @@ #include <sound/seq_oss_legacy.h> #include <sound/seq_device.h> +typedef struct seq_oss_synth_t seq_oss_synth_t; + void snd_seq_oss_synth_init(void); -int snd_seq_oss_synth_register(struct snd_seq_device *dev); -int snd_seq_oss_synth_unregister(struct snd_seq_device *dev); -void snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp); -void snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp); -void snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp); +int snd_seq_oss_synth_register(snd_seq_device_t *dev); +int snd_seq_oss_synth_unregister(snd_seq_device_t *dev); +void snd_seq_oss_synth_setup(seq_oss_devinfo_t *dp); +void snd_seq_oss_synth_setup_midi(seq_oss_devinfo_t *dp); +void snd_seq_oss_synth_cleanup(seq_oss_devinfo_t *dp); -void snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev); -int snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt, - const char __user *buf, int p, int c); -int snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev); -int snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, - struct snd_seq_event *ev); -int snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event *ev); -int snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, - unsigned long addr); -int snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, - unsigned char *data, struct snd_seq_event *ev); +void snd_seq_oss_synth_reset(seq_oss_devinfo_t *dp, int dev); +int snd_seq_oss_synth_load_patch(seq_oss_devinfo_t *dp, int dev, int fmt, const char __user *buf, int p, int c); +int snd_seq_oss_synth_is_valid(seq_oss_devinfo_t *dp, int dev); +int snd_seq_oss_synth_sysex(seq_oss_devinfo_t *dp, int dev, unsigned char *buf, snd_seq_event_t *ev); +int snd_seq_oss_synth_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_event_t *ev); +int snd_seq_oss_synth_ioctl(seq_oss_devinfo_t *dp, int dev, unsigned int cmd, unsigned long addr); +int snd_seq_oss_synth_raw_event(seq_oss_devinfo_t *dp, int dev, unsigned char *data, snd_seq_event_t *ev); -int snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_info *inf); +int snd_seq_oss_synth_make_info(seq_oss_devinfo_t *dp, int dev, struct synth_info *inf); #endif diff --git a/trunk/sound/core/seq/oss/seq_oss_timer.c b/trunk/sound/core/seq/oss/seq_oss_timer.c index c440fdacec93..64d594b3170f 100644 --- a/trunk/sound/core/seq/oss/seq_oss_timer.c +++ b/trunk/sound/core/seq/oss/seq_oss_timer.c @@ -33,18 +33,18 @@ /* */ -static void calc_alsa_tempo(struct seq_oss_timer *timer); -static int send_timer_event(struct seq_oss_devinfo *dp, int type, int value); +static void calc_alsa_tempo(seq_oss_timer_t *timer); +static int send_timer_event(seq_oss_devinfo_t *dp, int type, int value); /* * create and register a new timer. * if queue is not started yet, start it. */ -struct seq_oss_timer * -snd_seq_oss_timer_new(struct seq_oss_devinfo *dp) +seq_oss_timer_t * +snd_seq_oss_timer_new(seq_oss_devinfo_t *dp) { - struct seq_oss_timer *rec; + seq_oss_timer_t *rec; rec = kzalloc(sizeof(*rec), GFP_KERNEL); if (rec == NULL) @@ -67,7 +67,7 @@ snd_seq_oss_timer_new(struct seq_oss_devinfo *dp) * if no more timer exists, stop the queue. */ void -snd_seq_oss_timer_delete(struct seq_oss_timer *rec) +snd_seq_oss_timer_delete(seq_oss_timer_t *rec) { if (rec) { snd_seq_oss_timer_stop(rec); @@ -82,7 +82,7 @@ snd_seq_oss_timer_delete(struct seq_oss_timer *rec) * 0 : not a timer event -- enqueue this event */ int -snd_seq_oss_process_timer_event(struct seq_oss_timer *rec, union evrec *ev) +snd_seq_oss_process_timer_event(seq_oss_timer_t *rec, evrec_t *ev) { abstime_t parm = ev->t.time; @@ -125,7 +125,7 @@ snd_seq_oss_process_timer_event(struct seq_oss_timer *rec, union evrec *ev) * convert tempo units */ static void -calc_alsa_tempo(struct seq_oss_timer *timer) +calc_alsa_tempo(seq_oss_timer_t *timer) { timer->tempo = (60 * 1000000) / timer->oss_tempo; timer->ppq = timer->oss_timebase; @@ -136,9 +136,9 @@ calc_alsa_tempo(struct seq_oss_timer *timer) * dispatch a timer event */ static int -send_timer_event(struct seq_oss_devinfo *dp, int type, int value) +send_timer_event(seq_oss_devinfo_t *dp, int type, int value) { - struct snd_seq_event ev; + snd_seq_event_t ev; memset(&ev, 0, sizeof(ev)); ev.type = type; @@ -156,10 +156,10 @@ send_timer_event(struct seq_oss_devinfo *dp, int type, int value) * set queue tempo and start queue */ int -snd_seq_oss_timer_start(struct seq_oss_timer *timer) +snd_seq_oss_timer_start(seq_oss_timer_t *timer) { - struct seq_oss_devinfo *dp = timer->dp; - struct snd_seq_queue_tempo tmprec; + seq_oss_devinfo_t *dp = timer->dp; + snd_seq_queue_tempo_t tmprec; if (timer->running) snd_seq_oss_timer_stop(timer); @@ -181,7 +181,7 @@ snd_seq_oss_timer_start(struct seq_oss_timer *timer) * stop queue */ int -snd_seq_oss_timer_stop(struct seq_oss_timer *timer) +snd_seq_oss_timer_stop(seq_oss_timer_t *timer) { if (! timer->running) return 0; @@ -195,7 +195,7 @@ snd_seq_oss_timer_stop(struct seq_oss_timer *timer) * continue queue */ int -snd_seq_oss_timer_continue(struct seq_oss_timer *timer) +snd_seq_oss_timer_continue(seq_oss_timer_t *timer) { if (timer->running) return 0; @@ -209,7 +209,7 @@ snd_seq_oss_timer_continue(struct seq_oss_timer *timer) * change queue tempo */ int -snd_seq_oss_timer_tempo(struct seq_oss_timer *timer, int value) +snd_seq_oss_timer_tempo(seq_oss_timer_t *timer, int value) { if (value < MIN_OSS_TEMPO) value = MIN_OSS_TEMPO; @@ -227,7 +227,7 @@ snd_seq_oss_timer_tempo(struct seq_oss_timer *timer, int value) * ioctls */ int -snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __user *arg) +snd_seq_oss_timer_ioctl(seq_oss_timer_t *timer, unsigned int cmd, int __user *arg) { int value; diff --git a/trunk/sound/core/seq/oss/seq_oss_timer.h b/trunk/sound/core/seq/oss/seq_oss_timer.h index b995bd68ad1f..6e4dbd8504c1 100644 --- a/trunk/sound/core/seq/oss/seq_oss_timer.h +++ b/trunk/sound/core/seq/oss/seq_oss_timer.h @@ -27,8 +27,8 @@ /* * timer information definition */ -struct seq_oss_timer { - struct seq_oss_devinfo *dp; +struct seq_oss_timer_t { + seq_oss_devinfo_t *dp; reltime_t cur_tick; int realtime; int running; @@ -37,22 +37,22 @@ struct seq_oss_timer { }; -struct seq_oss_timer *snd_seq_oss_timer_new(struct seq_oss_devinfo *dp); -void snd_seq_oss_timer_delete(struct seq_oss_timer *dp); +seq_oss_timer_t *snd_seq_oss_timer_new(seq_oss_devinfo_t *dp); +void snd_seq_oss_timer_delete(seq_oss_timer_t *dp); -int snd_seq_oss_timer_start(struct seq_oss_timer *timer); -int snd_seq_oss_timer_stop(struct seq_oss_timer *timer); -int snd_seq_oss_timer_continue(struct seq_oss_timer *timer); -int snd_seq_oss_timer_tempo(struct seq_oss_timer *timer, int value); +int snd_seq_oss_timer_start(seq_oss_timer_t *timer); +int snd_seq_oss_timer_stop(seq_oss_timer_t *timer); +int snd_seq_oss_timer_continue(seq_oss_timer_t *timer); +int snd_seq_oss_timer_tempo(seq_oss_timer_t *timer, int value); #define snd_seq_oss_timer_reset snd_seq_oss_timer_start -int snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __user *arg); +int snd_seq_oss_timer_ioctl(seq_oss_timer_t *timer, unsigned int cmd, int __user *arg); /* * get current processed time */ static inline abstime_t -snd_seq_oss_timer_cur_tick(struct seq_oss_timer *timer) +snd_seq_oss_timer_cur_tick(seq_oss_timer_t *timer) { return timer->cur_tick; } @@ -62,7 +62,7 @@ snd_seq_oss_timer_cur_tick(struct seq_oss_timer *timer) * is realtime event? */ static inline int -snd_seq_oss_timer_is_realtime(struct seq_oss_timer *timer) +snd_seq_oss_timer_is_realtime(seq_oss_timer_t *timer) { return timer->realtime; } diff --git a/trunk/sound/core/seq/oss/seq_oss_writeq.c b/trunk/sound/core/seq/oss/seq_oss_writeq.c index 5c8495601a38..b20378024547 100644 --- a/trunk/sound/core/seq/oss/seq_oss_writeq.c +++ b/trunk/sound/core/seq/oss/seq_oss_writeq.c @@ -32,11 +32,11 @@ /* * create a write queue record */ -struct seq_oss_writeq * -snd_seq_oss_writeq_new(struct seq_oss_devinfo *dp, int maxlen) +seq_oss_writeq_t * +snd_seq_oss_writeq_new(seq_oss_devinfo_t *dp, int maxlen) { - struct seq_oss_writeq *q; - struct snd_seq_client_pool pool; + seq_oss_writeq_t *q; + snd_seq_client_pool_t pool; if ((q = kzalloc(sizeof(*q), GFP_KERNEL)) == NULL) return NULL; @@ -61,7 +61,7 @@ snd_seq_oss_writeq_new(struct seq_oss_devinfo *dp, int maxlen) * delete the write queue */ void -snd_seq_oss_writeq_delete(struct seq_oss_writeq *q) +snd_seq_oss_writeq_delete(seq_oss_writeq_t *q) { snd_seq_oss_writeq_clear(q); /* to be sure */ kfree(q); @@ -72,9 +72,9 @@ snd_seq_oss_writeq_delete(struct seq_oss_writeq *q) * reset the write queue */ void -snd_seq_oss_writeq_clear(struct seq_oss_writeq *q) +snd_seq_oss_writeq_clear(seq_oss_writeq_t *q) { - struct snd_seq_remove_events reset; + snd_seq_remove_events_t reset; memset(&reset, 0, sizeof(reset)); reset.remove_mode = SNDRV_SEQ_REMOVE_OUTPUT; /* remove all */ @@ -88,9 +88,9 @@ snd_seq_oss_writeq_clear(struct seq_oss_writeq *q) * wait until the write buffer has enough room */ int -snd_seq_oss_writeq_sync(struct seq_oss_writeq *q) +snd_seq_oss_writeq_sync(seq_oss_writeq_t *q) { - struct seq_oss_devinfo *dp = q->dp; + seq_oss_devinfo_t *dp = q->dp; abstime_t time; time = snd_seq_oss_timer_cur_tick(dp->timer); @@ -98,8 +98,8 @@ snd_seq_oss_writeq_sync(struct seq_oss_writeq *q) return 0; /* already finished */ if (! q->sync_event_put) { - struct snd_seq_event ev; - union evrec *rec; + snd_seq_event_t ev; + evrec_t *rec; /* put echoback event */ memset(&ev, 0, sizeof(ev)); @@ -108,7 +108,7 @@ snd_seq_oss_writeq_sync(struct seq_oss_writeq *q) ev.time.tick = time; /* echo back to itself */ snd_seq_oss_fill_addr(dp, &ev, dp->addr.client, dp->addr.port); - rec = (union evrec *)&ev.data; + rec = (evrec_t*)&ev.data; rec->t.code = SEQ_SYNCTIMER; rec->t.time = time; q->sync_event_put = 1; @@ -128,7 +128,7 @@ snd_seq_oss_writeq_sync(struct seq_oss_writeq *q) * wake up sync - echo event was catched */ void -snd_seq_oss_writeq_wakeup(struct seq_oss_writeq *q, abstime_t time) +snd_seq_oss_writeq_wakeup(seq_oss_writeq_t *q, abstime_t time) { unsigned long flags; @@ -146,9 +146,9 @@ snd_seq_oss_writeq_wakeup(struct seq_oss_writeq *q, abstime_t time) * return the unused pool size */ int -snd_seq_oss_writeq_get_free_size(struct seq_oss_writeq *q) +snd_seq_oss_writeq_get_free_size(seq_oss_writeq_t *q) { - struct snd_seq_client_pool pool; + snd_seq_client_pool_t pool; pool.client = q->dp->cseq; snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, &pool); return pool.output_free; @@ -159,9 +159,9 @@ snd_seq_oss_writeq_get_free_size(struct seq_oss_writeq *q) * set output threshold size from ioctl */ void -snd_seq_oss_writeq_set_output(struct seq_oss_writeq *q, int val) +snd_seq_oss_writeq_set_output(seq_oss_writeq_t *q, int val) { - struct snd_seq_client_pool pool; + snd_seq_client_pool_t pool; pool.client = q->dp->cseq; snd_seq_oss_control(q->dp, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, &pool); pool.output_room = val; diff --git a/trunk/sound/core/seq/oss/seq_oss_writeq.h b/trunk/sound/core/seq/oss/seq_oss_writeq.h index c469d2967566..6a13c85e2399 100644 --- a/trunk/sound/core/seq/oss/seq_oss_writeq.h +++ b/trunk/sound/core/seq/oss/seq_oss_writeq.h @@ -25,8 +25,8 @@ #include "seq_oss_device.h" -struct seq_oss_writeq { - struct seq_oss_devinfo *dp; +struct seq_oss_writeq_t { + seq_oss_devinfo_t *dp; int maxlen; abstime_t sync_time; int sync_event_put; @@ -38,13 +38,13 @@ struct seq_oss_writeq { /* * seq_oss_writeq.c */ -struct seq_oss_writeq *snd_seq_oss_writeq_new(struct seq_oss_devinfo *dp, int maxlen); -void snd_seq_oss_writeq_delete(struct seq_oss_writeq *q); -void snd_seq_oss_writeq_clear(struct seq_oss_writeq *q); -int snd_seq_oss_writeq_sync(struct seq_oss_writeq *q); -void snd_seq_oss_writeq_wakeup(struct seq_oss_writeq *q, abstime_t time); -int snd_seq_oss_writeq_get_free_size(struct seq_oss_writeq *q); -void snd_seq_oss_writeq_set_output(struct seq_oss_writeq *q, int size); +seq_oss_writeq_t *snd_seq_oss_writeq_new(seq_oss_devinfo_t *dp, int maxlen); +void snd_seq_oss_writeq_delete(seq_oss_writeq_t *q); +void snd_seq_oss_writeq_clear(seq_oss_writeq_t *q); +int snd_seq_oss_writeq_sync(seq_oss_writeq_t *q); +void snd_seq_oss_writeq_wakeup(seq_oss_writeq_t *q, abstime_t time); +int snd_seq_oss_writeq_get_free_size(seq_oss_writeq_t *q); +void snd_seq_oss_writeq_set_output(seq_oss_writeq_t *q, int size); #endif diff --git a/trunk/sound/core/seq/seq.c b/trunk/sound/core/seq/seq.c index 20f954bc7aa0..24644150f24b 100644 --- a/trunk/sound/core/seq/seq.c +++ b/trunk/sound/core/seq/seq.c @@ -36,9 +36,9 @@ #include <sound/seq_device.h> #if defined(CONFIG_SND_SEQ_DUMMY_MODULE) -int seq_client_load[15] = {[0] = SNDRV_SEQ_CLIENT_DUMMY, [1 ... 14] = -1}; +int seq_client_load[64] = {[0] = SNDRV_SEQ_CLIENT_DUMMY, [1 ... 63] = -1}; #else -int seq_client_load[15] = {[0 ... 14] = -1}; +int seq_client_load[64] = {[0 ... 63] = -1}; #endif int seq_default_timer_class = SNDRV_TIMER_CLASS_GLOBAL; int seq_default_timer_sclass = SNDRV_TIMER_SCLASS_NONE; diff --git a/trunk/sound/core/seq/seq_clientmgr.c b/trunk/sound/core/seq/seq_clientmgr.c index fd2032eae214..a886db94b1fa 100644 --- a/trunk/sound/core/seq/seq_clientmgr.c +++ b/trunk/sound/core/seq/seq_clientmgr.c @@ -47,21 +47,6 @@ * */ -/* - * There are four ranges of client numbers (last two shared): - * 0..15: global clients - * 16..127: statically allocated client numbers for cards 0..27 - * 128..191: dynamically allocated client numbers for cards 28..31 - * 128..191: dynamically allocated client numbers for applications - */ - -/* number of kernel non-card clients */ -#define SNDRV_SEQ_GLOBAL_CLIENTS 16 -/* clients per cards, for static clients */ -#define SNDRV_SEQ_CLIENTS_PER_CARD 4 -/* dynamically allocated client numbers (both kernel drivers and user space) */ -#define SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN 128 - #define SNDRV_SEQ_LFLG_INPUT 0x0001 #define SNDRV_SEQ_LFLG_OUTPUT 0x0002 #define SNDRV_SEQ_LFLG_OPEN (SNDRV_SEQ_LFLG_INPUT|SNDRV_SEQ_LFLG_OUTPUT) @@ -73,18 +58,14 @@ static DECLARE_MUTEX(register_mutex); * client table */ static char clienttablock[SNDRV_SEQ_MAX_CLIENTS]; -static struct snd_seq_client *clienttab[SNDRV_SEQ_MAX_CLIENTS]; -static struct snd_seq_usage client_usage; +static client_t *clienttab[SNDRV_SEQ_MAX_CLIENTS]; +static usage_t client_usage; /* * prototypes */ -static int bounce_error_event(struct snd_seq_client *client, - struct snd_seq_event *event, - int err, int atomic, int hop); -static int snd_seq_deliver_single_event(struct snd_seq_client *client, - struct snd_seq_event *event, - int filter, int atomic, int hop); +static int bounce_error_event(client_t *client, snd_seq_event_t *event, int err, int atomic, int hop); +static int snd_seq_deliver_single_event(client_t *client, snd_seq_event_t *event, int filter, int atomic, int hop); /* */ @@ -115,17 +96,16 @@ static inline unsigned short snd_seq_file_flags(struct file *file) } } -static inline int snd_seq_write_pool_allocated(struct snd_seq_client *client) +static inline int snd_seq_write_pool_allocated(client_t *client) { return snd_seq_total_cells(client->pool) > 0; } /* return pointer to client structure for specified id */ -static struct snd_seq_client *clientptr(int clientid) +static client_t *clientptr(int clientid) { if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) { - snd_printd("Seq: oops. Trying to get pointer to client %d\n", - clientid); + snd_printd("Seq: oops. Trying to get pointer to client %d\n", clientid); return NULL; } return clienttab[clientid]; @@ -133,14 +113,13 @@ static struct snd_seq_client *clientptr(int clientid) extern int seq_client_load[]; -struct snd_seq_client *snd_seq_client_use_ptr(int clientid) +client_t *snd_seq_client_use_ptr(int clientid) { unsigned long flags; - struct snd_seq_client *client; + client_t *client; if (clientid < 0 || clientid >= SNDRV_SEQ_MAX_CLIENTS) { - snd_printd("Seq: oops. Trying to get pointer to client %d\n", - clientid); + snd_printd("Seq: oops. Trying to get pointer to client %d\n", clientid); return NULL; } spin_lock_irqsave(&clients_lock, flags); @@ -154,26 +133,24 @@ struct snd_seq_client *snd_seq_client_use_ptr(int clientid) spin_unlock_irqrestore(&clients_lock, flags); #ifdef CONFIG_KMOD if (!in_interrupt() && current->fs->root) { - static char client_requested[SNDRV_SEQ_GLOBAL_CLIENTS]; + static char client_requested[64]; static char card_requested[SNDRV_CARDS]; - if (clientid < SNDRV_SEQ_GLOBAL_CLIENTS) { + if (clientid < 64) { int idx; if (! client_requested[clientid] && current->fs->root) { client_requested[clientid] = 1; - for (idx = 0; idx < 15; idx++) { + for (idx = 0; idx < 64; idx++) { if (seq_client_load[idx] < 0) break; if (seq_client_load[idx] == clientid) { - request_module("snd-seq-client-%i", - clientid); + request_module("snd-seq-client-%i", clientid); break; } } } - } else if (clientid < SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN) { - int card = (clientid - SNDRV_SEQ_GLOBAL_CLIENTS) / - SNDRV_SEQ_CLIENTS_PER_CARD; + } else if (clientid >= 64 && clientid < 128) { + int card = (clientid - 64) / 8; if (card < snd_ecards_limit) { if (! card_requested[card]) { card_requested[card] = 1; @@ -197,14 +174,14 @@ struct snd_seq_client *snd_seq_client_use_ptr(int clientid) return client; } -static void usage_alloc(struct snd_seq_usage *res, int num) +static void usage_alloc(usage_t * res, int num) { res->cur += num; if (res->cur > res->peak) res->peak = res->cur; } -static void usage_free(struct snd_seq_usage *res, int num) +static void usage_free(usage_t * res, int num) { res->cur -= num; } @@ -219,11 +196,11 @@ int __init client_init_data(void) } -static struct snd_seq_client *seq_create_client1(int client_index, int poolsize) +static client_t *seq_create_client1(int client_index, int poolsize) { unsigned long flags; int c; - struct snd_seq_client *client; + client_t *client; /* init client data */ client = kzalloc(sizeof(*client), GFP_KERNEL); @@ -243,9 +220,7 @@ static struct snd_seq_client *seq_create_client1(int client_index, int poolsize) /* find free slot in the client table */ spin_lock_irqsave(&clients_lock, flags); if (client_index < 0) { - for (c = SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN; - c < SNDRV_SEQ_MAX_CLIENTS; - c++) { + for (c = 128; c < SNDRV_SEQ_MAX_CLIENTS; c++) { if (clienttab[c] || clienttablock[c]) continue; clienttab[client->number = c] = client; @@ -266,7 +241,7 @@ static struct snd_seq_client *seq_create_client1(int client_index, int poolsize) } -static int seq_free_client1(struct snd_seq_client *client) +static int seq_free_client1(client_t *client) { unsigned long flags; @@ -288,13 +263,12 @@ static int seq_free_client1(struct snd_seq_client *client) } -static void seq_free_client(struct snd_seq_client * client) +static void seq_free_client(client_t * client) { down(®ister_mutex); switch (client->type) { case NO_CLIENT: - snd_printk(KERN_WARNING "Seq: Trying to free unused client %d\n", - client->number); + snd_printk(KERN_WARNING "Seq: Trying to free unused client %d\n", client->number); break; case USER_CLIENT: case KERNEL_CLIENT: @@ -303,8 +277,7 @@ static void seq_free_client(struct snd_seq_client * client) break; default: - snd_printk(KERN_ERR "Seq: Trying to free client %d with undefined type = %d\n", - client->number, client->type); + snd_printk(KERN_ERR "Seq: Trying to free client %d with undefined type = %d\n", client->number, client->type); } up(®ister_mutex); @@ -319,8 +292,8 @@ static void seq_free_client(struct snd_seq_client * client) static int snd_seq_open(struct inode *inode, struct file *file) { int c, mode; /* client id */ - struct snd_seq_client *client; - struct snd_seq_user_client *user; + client_t *client; + user_client_t *user; if (down_interruptible(®ister_mutex)) return -ERESTARTSYS; @@ -371,7 +344,7 @@ static int snd_seq_open(struct inode *inode, struct file *file) /* delete a user client */ static int snd_seq_release(struct inode *inode, struct file *file) { - struct snd_seq_client *client = file->private_data; + client_t *client = (client_t *) file->private_data; if (client) { seq_free_client(client); @@ -391,14 +364,13 @@ static int snd_seq_release(struct inode *inode, struct file *file) * -EINVAL no enough user-space buffer to write the whole event * -EFAULT seg. fault during copy to user space */ -static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, - loff_t *offset) +static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { - struct snd_seq_client *client = file->private_data; - struct snd_seq_fifo *fifo; + client_t *client = (client_t *) file->private_data; + fifo_t *fifo; int err; long result = 0; - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; if (!(snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_INPUT)) return -ENXIO; @@ -424,7 +396,7 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, snd_seq_fifo_lock(fifo); /* while data available in queue */ - while (count >= sizeof(struct snd_seq_event)) { + while (count >= sizeof(snd_seq_event_t)) { int nonblock; nonblock = (file->f_flags & O_NONBLOCK) || result > 0; @@ -432,34 +404,34 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, break; } if (snd_seq_ev_is_variable(&cell->event)) { - struct snd_seq_event tmpev; + snd_seq_event_t tmpev; tmpev = cell->event; tmpev.data.ext.len &= ~SNDRV_SEQ_EXT_MASK; - if (copy_to_user(buf, &tmpev, sizeof(struct snd_seq_event))) { + if (copy_to_user(buf, &tmpev, sizeof(snd_seq_event_t))) { err = -EFAULT; break; } - count -= sizeof(struct snd_seq_event); - buf += sizeof(struct snd_seq_event); + count -= sizeof(snd_seq_event_t); + buf += sizeof(snd_seq_event_t); err = snd_seq_expand_var_event(&cell->event, count, (char __force *)buf, 0, - sizeof(struct snd_seq_event)); + sizeof(snd_seq_event_t)); if (err < 0) break; result += err; count -= err; buf += err; } else { - if (copy_to_user(buf, &cell->event, sizeof(struct snd_seq_event))) { + if (copy_to_user(buf, &cell->event, sizeof(snd_seq_event_t))) { err = -EFAULT; break; } - count -= sizeof(struct snd_seq_event); - buf += sizeof(struct snd_seq_event); + count -= sizeof(snd_seq_event_t); + buf += sizeof(snd_seq_event_t); } snd_seq_cell_free(cell); cell = NULL; /* to be sure */ - result += sizeof(struct snd_seq_event); + result += sizeof(snd_seq_event_t); } if (err < 0) { @@ -477,7 +449,7 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count, /* * check access permission to the port */ -static int check_port_perm(struct snd_seq_client_port *port, unsigned int flags) +static int check_port_perm(client_port_t *port, unsigned int flags) { if ((port->capability & flags) != flags) return 0; @@ -488,10 +460,9 @@ static int check_port_perm(struct snd_seq_client_port *port, unsigned int flags) * check if the destination client is available, and return the pointer * if filter is non-zero, client filter bitmap is tested. */ -static struct snd_seq_client *get_event_dest_client(struct snd_seq_event *event, - int filter) +static client_t *get_event_dest_client(snd_seq_event_t *event, int filter) { - struct snd_seq_client *dest; + client_t *dest; dest = snd_seq_client_use_ptr(event->dest.client); if (dest == NULL) @@ -522,11 +493,10 @@ static struct snd_seq_client *get_event_dest_client(struct snd_seq_event *event, * quoted in SNDRV_SEQ_EVENT_KERNEL_ERROR, since this requires no extra * kmalloc. */ -static int bounce_error_event(struct snd_seq_client *client, - struct snd_seq_event *event, +static int bounce_error_event(client_t *client, snd_seq_event_t *event, int err, int atomic, int hop) { - struct snd_seq_event bounce_ev; + snd_seq_event_t bounce_ev; int result; if (client == NULL || @@ -561,10 +531,9 @@ static int bounce_error_event(struct snd_seq_client *client, * of the given queue. * return non-zero if updated. */ -static int update_timestamp_of_queue(struct snd_seq_event *event, - int queue, int real_time) +static int update_timestamp_of_queue(snd_seq_event_t *event, int queue, int real_time) { - struct snd_seq_queue *q; + queue_t *q; q = queueptr(queue); if (! q) @@ -590,12 +559,12 @@ static int update_timestamp_of_queue(struct snd_seq_event *event, * RETURN VALUE: 0 : if succeeded * <0 : error */ -static int snd_seq_deliver_single_event(struct snd_seq_client *client, - struct snd_seq_event *event, +static int snd_seq_deliver_single_event(client_t *client, + snd_seq_event_t *event, int filter, int atomic, int hop) { - struct snd_seq_client *dest = NULL; - struct snd_seq_client_port *dest_port = NULL; + client_t *dest = NULL; + client_port_t *dest_port = NULL; int result = -ENOENT; int direct; @@ -627,9 +596,7 @@ static int snd_seq_deliver_single_event(struct snd_seq_client *client, case KERNEL_CLIENT: if (dest_port->event_input == NULL) break; - result = dest_port->event_input(event, direct, - dest_port->private_data, - atomic, hop); + result = dest_port->event_input(event, direct, dest_port->private_data, atomic, hop); break; default: break; @@ -651,16 +618,16 @@ static int snd_seq_deliver_single_event(struct snd_seq_client *client, /* * send the event to all subscribers: */ -static int deliver_to_subscribers(struct snd_seq_client *client, - struct snd_seq_event *event, +static int deliver_to_subscribers(client_t *client, + snd_seq_event_t *event, int atomic, int hop) { - struct snd_seq_subscribers *subs; + subscribers_t *subs; int err = 0, num_ev = 0; - struct snd_seq_event event_saved; - struct snd_seq_client_port *src_port; + snd_seq_event_t event_saved; + client_port_t *src_port; struct list_head *p; - struct snd_seq_port_subs_info *grp; + port_subs_info_t *grp; src_port = snd_seq_port_use_ptr(client, event->source.port); if (src_port == NULL) @@ -675,7 +642,7 @@ static int deliver_to_subscribers(struct snd_seq_client *client, else down_read(&grp->list_mutex); list_for_each(p, &grp->list_head) { - subs = list_entry(p, struct snd_seq_subscribers, src_list); + subs = list_entry(p, subscribers_t, src_list); event->dest = subs->info.dest; if (subs->info.flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) /* convert time according to flag with subscription */ @@ -703,12 +670,12 @@ static int deliver_to_subscribers(struct snd_seq_client *client, /* * broadcast to all ports: */ -static int port_broadcast_event(struct snd_seq_client *client, - struct snd_seq_event *event, +static int port_broadcast_event(client_t *client, + snd_seq_event_t *event, int atomic, int hop) { int num_ev = 0, err = 0; - struct snd_seq_client *dest_client; + client_t *dest_client; struct list_head *p; dest_client = get_event_dest_client(event, SNDRV_SEQ_FILTER_BROADCAST); @@ -717,7 +684,7 @@ static int port_broadcast_event(struct snd_seq_client *client, read_lock(&dest_client->ports_lock); list_for_each(p, &dest_client->ports_list_head) { - struct snd_seq_client_port *port = list_entry(p, struct snd_seq_client_port, list); + client_port_t *port = list_entry(p, client_port_t, list); event->dest.port = port->addr.port; /* pass NULL as source client to avoid error bounce */ err = snd_seq_deliver_single_event(NULL, event, @@ -737,12 +704,12 @@ static int port_broadcast_event(struct snd_seq_client *client, * send the event to all clients: * if destination port is also ADDRESS_BROADCAST, deliver to all ports. */ -static int broadcast_event(struct snd_seq_client *client, - struct snd_seq_event *event, int atomic, int hop) +static int broadcast_event(client_t *client, + snd_seq_event_t *event, int atomic, int hop) { int err = 0, num_ev = 0; int dest; - struct snd_seq_addr addr; + snd_seq_addr_t addr; addr = event->dest; /* save */ @@ -769,7 +736,7 @@ static int broadcast_event(struct snd_seq_client *client, /* multicast - not supported yet */ -static int multicast_event(struct snd_seq_client *client, struct snd_seq_event *event, +static int multicast_event(client_t *client, snd_seq_event_t *event, int atomic, int hop) { snd_printd("seq: multicast not supported yet.\n"); @@ -786,7 +753,7 @@ static int multicast_event(struct snd_seq_client *client, struct snd_seq_event * * n == 0 : the event was not passed to any client. * n < 0 : error - event was not processed. */ -static int snd_seq_deliver_event(struct snd_seq_client *client, struct snd_seq_event *event, +static int snd_seq_deliver_event(client_t *client, snd_seq_event_t *event, int atomic, int hop) { int result; @@ -827,9 +794,9 @@ static int snd_seq_deliver_event(struct snd_seq_client *client, struct snd_seq_e * n == 0 : the event was not passed to any client. * n < 0 : error - event was not processed. */ -int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop) +int snd_seq_dispatch_event(snd_seq_event_cell_t *cell, int atomic, int hop) { - struct snd_seq_client *client; + client_t *client; int result; snd_assert(cell != NULL, return -EINVAL); @@ -845,7 +812,7 @@ int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop) * the event cell is re-used as a NOTE-OFF event and * enqueued again. */ - struct snd_seq_event tmpev, *ev; + snd_seq_event_t tmpev, *ev; /* reserve this event to enqueue note-off later */ tmpev = cell->event; @@ -898,12 +865,12 @@ int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop) * if pool is empty and blocking is TRUE, sleep until a new cell is * available. */ -static int snd_seq_client_enqueue_event(struct snd_seq_client *client, - struct snd_seq_event *event, +static int snd_seq_client_enqueue_event(client_t *client, + snd_seq_event_t *event, struct file *file, int blocking, int atomic, int hop) { - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; int err; /* special queue values - force direct passing */ @@ -919,7 +886,7 @@ static int snd_seq_client_enqueue_event(struct snd_seq_client *client, #endif if (event->dest.client == SNDRV_SEQ_ADDRESS_SUBSCRIBERS) { /* check presence of source port */ - struct snd_seq_client_port *src_port = snd_seq_port_use_ptr(client, event->source.port); + client_port_t *src_port = snd_seq_port_use_ptr(client, event->source.port); if (src_port == NULL) return -EINVAL; snd_seq_port_unlock(src_port); @@ -957,7 +924,7 @@ static int snd_seq_client_enqueue_event(struct snd_seq_client *client, * check validity of event type and data length. * return non-zero if invalid. */ -static int check_event_type_and_length(struct snd_seq_event *ev) +static int check_event_type_and_length(snd_seq_event_t *ev) { switch (snd_seq_ev_length_type(ev)) { case SNDRV_SEQ_EVENT_LENGTH_FIXED: @@ -990,13 +957,12 @@ static int check_event_type_and_length(struct snd_seq_event *ev) * -EMLINK too many hops * others depends on return value from driver callback */ -static ssize_t snd_seq_write(struct file *file, const char __user *buf, - size_t count, loff_t *offset) +static ssize_t snd_seq_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) { - struct snd_seq_client *client = file->private_data; + client_t *client = (client_t *) file->private_data; int written = 0, len; int err = -EINVAL; - struct snd_seq_event event; + snd_seq_event_t event; if (!(snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_OUTPUT)) return -ENXIO; @@ -1014,7 +980,7 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf, } /* only process whole events */ - while (count >= sizeof(struct snd_seq_event)) { + while (count >= sizeof(snd_seq_event_t)) { /* Read in the event header from the user */ len = sizeof(event); if (copy_from_user(&event, buf, len)) { @@ -1046,7 +1012,7 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf, /* set user space pointer */ event.data.ext.len = extlen | SNDRV_SEQ_EXT_USRPTR; event.data.ext.ptr = (char __force *)buf - + sizeof(struct snd_seq_event); + + sizeof(snd_seq_event_t); len += extlen; /* increment data length */ } else { #ifdef CONFIG_COMPAT @@ -1080,7 +1046,7 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf, */ static unsigned int snd_seq_poll(struct file *file, poll_table * wait) { - struct snd_seq_client *client = file->private_data; + client_t *client = (client_t *) file->private_data; unsigned int mask = 0; /* check client structures are in place */ @@ -1110,9 +1076,9 @@ static unsigned int snd_seq_poll(struct file *file, poll_table * wait) /* SYSTEM_INFO ioctl() */ -static int snd_seq_ioctl_system_info(struct snd_seq_client *client, void __user *arg) +static int snd_seq_ioctl_system_info(client_t *client, void __user *arg) { - struct snd_seq_system_info info; + snd_seq_system_info_t info; memset(&info, 0, sizeof(info)); /* fill the info fields */ @@ -1130,10 +1096,10 @@ static int snd_seq_ioctl_system_info(struct snd_seq_client *client, void __user /* RUNNING_MODE ioctl() */ -static int snd_seq_ioctl_running_mode(struct snd_seq_client *client, void __user *arg) +static int snd_seq_ioctl_running_mode(client_t *client, void __user *arg) { - struct snd_seq_running_info info; - struct snd_seq_client *cptr; + struct sndrv_seq_running_info info; + client_t *cptr; int err = 0; if (copy_from_user(&info, arg, sizeof(info))) @@ -1167,8 +1133,7 @@ static int snd_seq_ioctl_running_mode(struct snd_seq_client *client, void __user } /* CLIENT_INFO ioctl() */ -static void get_client_info(struct snd_seq_client *cptr, - struct snd_seq_client_info *info) +static void get_client_info(client_t *cptr, snd_seq_client_info_t *info) { info->client = cptr->number; @@ -1182,11 +1147,10 @@ static void get_client_info(struct snd_seq_client *cptr, memset(info->reserved, 0, sizeof(info->reserved)); } -static int snd_seq_ioctl_get_client_info(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_client_info(client_t * client, void __user *arg) { - struct snd_seq_client *cptr; - struct snd_seq_client_info client_info; + client_t *cptr; + snd_seq_client_info_t client_info; if (copy_from_user(&client_info, arg, sizeof(client_info))) return -EFAULT; @@ -1206,10 +1170,9 @@ static int snd_seq_ioctl_get_client_info(struct snd_seq_client *client, /* CLIENT_INFO ioctl() */ -static int snd_seq_ioctl_set_client_info(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_set_client_info(client_t * client, void __user *arg) { - struct snd_seq_client_info client_info; + snd_seq_client_info_t client_info; if (copy_from_user(&client_info, arg, sizeof(client_info))) return -EFAULT; @@ -1236,12 +1199,11 @@ static int snd_seq_ioctl_set_client_info(struct snd_seq_client *client, /* * CREATE PORT ioctl() */ -static int snd_seq_ioctl_create_port(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_create_port(client_t * client, void __user *arg) { - struct snd_seq_client_port *port; - struct snd_seq_port_info info; - struct snd_seq_port_callback *callback; + client_port_t *port; + snd_seq_port_info_t info; + snd_seq_port_callback_t *callback; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1287,10 +1249,9 @@ static int snd_seq_ioctl_create_port(struct snd_seq_client *client, /* * DELETE PORT ioctl() */ -static int snd_seq_ioctl_delete_port(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_delete_port(client_t * client, void __user *arg) { - struct snd_seq_port_info info; + snd_seq_port_info_t info; int err; /* set passed parameters */ @@ -1311,12 +1272,11 @@ static int snd_seq_ioctl_delete_port(struct snd_seq_client *client, /* * GET_PORT_INFO ioctl() (on any client) */ -static int snd_seq_ioctl_get_port_info(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_port_info(client_t *client, void __user *arg) { - struct snd_seq_client *cptr; - struct snd_seq_client_port *port; - struct snd_seq_port_info info; + client_t *cptr; + client_port_t *port; + snd_seq_port_info_t info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1344,11 +1304,10 @@ static int snd_seq_ioctl_get_port_info(struct snd_seq_client *client, /* * SET_PORT_INFO ioctl() (only ports on this/own client) */ -static int snd_seq_ioctl_set_port_info(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_set_port_info(client_t * client, void __user *arg) { - struct snd_seq_client_port *port; - struct snd_seq_port_info info; + client_port_t *port; + snd_seq_port_info_t info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1370,10 +1329,9 @@ static int snd_seq_ioctl_set_port_info(struct snd_seq_client *client, #define PERM_RD (SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_SUBS_READ) #define PERM_WR (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_SUBS_WRITE) -static int check_subscription_permission(struct snd_seq_client *client, - struct snd_seq_client_port *sport, - struct snd_seq_client_port *dport, - struct snd_seq_port_subscribe *subs) +static int check_subscription_permission(client_t *client, client_port_t *sport, + client_port_t *dport, + snd_seq_port_subscribe_t *subs) { if (client->number != subs->sender.client && client->number != subs->dest.client) { @@ -1405,10 +1363,9 @@ static int check_subscription_permission(struct snd_seq_client *client, * client must be user client. */ int snd_seq_client_notify_subscription(int client, int port, - struct snd_seq_port_subscribe *info, - int evtype) + snd_seq_port_subscribe_t *info, int evtype) { - struct snd_seq_event event; + snd_seq_event_t event; memset(&event, 0, sizeof(event)); event.type = evtype; @@ -1422,13 +1379,12 @@ int snd_seq_client_notify_subscription(int client, int port, /* * add to port's subscription list IOCTL interface */ -static int snd_seq_ioctl_subscribe_port(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_subscribe_port(client_t * client, void __user *arg) { int result = -EINVAL; - struct snd_seq_client *receiver = NULL, *sender = NULL; - struct snd_seq_client_port *sport = NULL, *dport = NULL; - struct snd_seq_port_subscribe subs; + client_t *receiver = NULL, *sender = NULL; + client_port_t *sport = NULL, *dport = NULL; + snd_seq_port_subscribe_t subs; if (copy_from_user(&subs, arg, sizeof(subs))) return -EFAULT; @@ -1467,13 +1423,12 @@ static int snd_seq_ioctl_subscribe_port(struct snd_seq_client *client, /* * remove from port's subscription list */ -static int snd_seq_ioctl_unsubscribe_port(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_unsubscribe_port(client_t * client, void __user *arg) { int result = -ENXIO; - struct snd_seq_client *receiver = NULL, *sender = NULL; - struct snd_seq_client_port *sport = NULL, *dport = NULL; - struct snd_seq_port_subscribe subs; + client_t *receiver = NULL, *sender = NULL; + client_port_t *sport = NULL, *dport = NULL; + snd_seq_port_subscribe_t subs; if (copy_from_user(&subs, arg, sizeof(subs))) return -EFAULT; @@ -1509,12 +1464,11 @@ static int snd_seq_ioctl_unsubscribe_port(struct snd_seq_client *client, /* CREATE_QUEUE ioctl() */ -static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_create_queue(client_t *client, void __user *arg) { - struct snd_seq_queue_info info; + snd_seq_queue_info_t info; int result; - struct snd_seq_queue *q; + queue_t *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1544,10 +1498,9 @@ static int snd_seq_ioctl_create_queue(struct snd_seq_client *client, } /* DELETE_QUEUE ioctl() */ -static int snd_seq_ioctl_delete_queue(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_delete_queue(client_t *client, void __user *arg) { - struct snd_seq_queue_info info; + snd_seq_queue_info_t info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1556,11 +1509,10 @@ static int snd_seq_ioctl_delete_queue(struct snd_seq_client *client, } /* GET_QUEUE_INFO ioctl() */ -static int snd_seq_ioctl_get_queue_info(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_queue_info(client_t *client, void __user *arg) { - struct snd_seq_queue_info info; - struct snd_seq_queue *q; + snd_seq_queue_info_t info; + queue_t *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1583,11 +1535,10 @@ static int snd_seq_ioctl_get_queue_info(struct snd_seq_client *client, } /* SET_QUEUE_INFO ioctl() */ -static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_set_queue_info(client_t *client, void __user *arg) { - struct snd_seq_queue_info info; - struct snd_seq_queue *q; + snd_seq_queue_info_t info; + queue_t *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1619,10 +1570,10 @@ static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client, } /* GET_NAMED_QUEUE ioctl() */ -static int snd_seq_ioctl_get_named_queue(struct snd_seq_client *client, void __user *arg) +static int snd_seq_ioctl_get_named_queue(client_t *client, void __user *arg) { - struct snd_seq_queue_info info; - struct snd_seq_queue *q; + snd_seq_queue_info_t info; + queue_t *q; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1642,12 +1593,11 @@ static int snd_seq_ioctl_get_named_queue(struct snd_seq_client *client, void __u } /* GET_QUEUE_STATUS ioctl() */ -static int snd_seq_ioctl_get_queue_status(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_queue_status(client_t * client, void __user *arg) { - struct snd_seq_queue_status status; - struct snd_seq_queue *queue; - struct snd_seq_timer *tmr; + snd_seq_queue_status_t status; + queue_t *queue; + seq_timer_t *tmr; if (copy_from_user(&status, arg, sizeof(status))) return -EFAULT; @@ -1676,12 +1626,11 @@ static int snd_seq_ioctl_get_queue_status(struct snd_seq_client *client, /* GET_QUEUE_TEMPO ioctl() */ -static int snd_seq_ioctl_get_queue_tempo(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_queue_tempo(client_t * client, void __user *arg) { - struct snd_seq_queue_tempo tempo; - struct snd_seq_queue *queue; - struct snd_seq_timer *tmr; + snd_seq_queue_tempo_t tempo; + queue_t *queue; + seq_timer_t *tmr; if (copy_from_user(&tempo, arg, sizeof(tempo))) return -EFAULT; @@ -1707,18 +1656,17 @@ static int snd_seq_ioctl_get_queue_tempo(struct snd_seq_client *client, /* SET_QUEUE_TEMPO ioctl() */ -int snd_seq_set_queue_tempo(int client, struct snd_seq_queue_tempo *tempo) +int snd_seq_set_queue_tempo(int client, snd_seq_queue_tempo_t *tempo) { if (!snd_seq_queue_check_access(tempo->queue, client)) return -EPERM; return snd_seq_queue_timer_set_tempo(tempo->queue, client, tempo); } -static int snd_seq_ioctl_set_queue_tempo(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_set_queue_tempo(client_t * client, void __user *arg) { int result; - struct snd_seq_queue_tempo tempo; + snd_seq_queue_tempo_t tempo; if (copy_from_user(&tempo, arg, sizeof(tempo))) return -EFAULT; @@ -1729,12 +1677,11 @@ static int snd_seq_ioctl_set_queue_tempo(struct snd_seq_client *client, /* GET_QUEUE_TIMER ioctl() */ -static int snd_seq_ioctl_get_queue_timer(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_queue_timer(client_t * client, void __user *arg) { - struct snd_seq_queue_timer timer; - struct snd_seq_queue *queue; - struct snd_seq_timer *tmr; + snd_seq_queue_timer_t timer; + queue_t *queue; + seq_timer_t *tmr; if (copy_from_user(&timer, arg, sizeof(timer))) return -EFAULT; @@ -1766,11 +1713,10 @@ static int snd_seq_ioctl_get_queue_timer(struct snd_seq_client *client, /* SET_QUEUE_TIMER ioctl() */ -static int snd_seq_ioctl_set_queue_timer(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_set_queue_timer(client_t * client, void __user *arg) { int result = 0; - struct snd_seq_queue_timer timer; + snd_seq_queue_timer_t timer; if (copy_from_user(&timer, arg, sizeof(timer))) return -EFAULT; @@ -1779,8 +1725,8 @@ static int snd_seq_ioctl_set_queue_timer(struct snd_seq_client *client, return -EINVAL; if (snd_seq_queue_check_access(timer.queue, client->number)) { - struct snd_seq_queue *q; - struct snd_seq_timer *tmr; + queue_t *q; + seq_timer_t *tmr; q = queueptr(timer.queue); if (q == NULL) @@ -1808,10 +1754,9 @@ static int snd_seq_ioctl_set_queue_timer(struct snd_seq_client *client, /* GET_QUEUE_CLIENT ioctl() */ -static int snd_seq_ioctl_get_queue_client(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_queue_client(client_t * client, void __user *arg) { - struct snd_seq_queue_client info; + snd_seq_queue_client_t info; int used; if (copy_from_user(&info, arg, sizeof(info))) @@ -1830,11 +1775,10 @@ static int snd_seq_ioctl_get_queue_client(struct snd_seq_client *client, /* SET_QUEUE_CLIENT ioctl() */ -static int snd_seq_ioctl_set_queue_client(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_set_queue_client(client_t * client, void __user *arg) { int err; - struct snd_seq_queue_client info; + snd_seq_queue_client_t info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1850,11 +1794,10 @@ static int snd_seq_ioctl_set_queue_client(struct snd_seq_client *client, /* GET_CLIENT_POOL ioctl() */ -static int snd_seq_ioctl_get_client_pool(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_client_pool(client_t * client, void __user *arg) { - struct snd_seq_client_pool info; - struct snd_seq_client *cptr; + snd_seq_client_pool_t info; + client_t *cptr; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1885,10 +1828,9 @@ static int snd_seq_ioctl_get_client_pool(struct snd_seq_client *client, } /* SET_CLIENT_POOL ioctl() */ -static int snd_seq_ioctl_set_client_pool(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_set_client_pool(client_t * client, void __user *arg) { - struct snd_seq_client_pool info; + snd_seq_client_pool_t info; int rc; if (copy_from_user(&info, arg, sizeof(info))) @@ -1930,10 +1872,9 @@ static int snd_seq_ioctl_set_client_pool(struct snd_seq_client *client, /* REMOVE_EVENTS ioctl() */ -static int snd_seq_ioctl_remove_events(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_remove_events(client_t * client, void __user *arg) { - struct snd_seq_remove_events info; + snd_seq_remove_events_t info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -1960,14 +1901,13 @@ static int snd_seq_ioctl_remove_events(struct snd_seq_client *client, /* * get subscription info */ -static int snd_seq_ioctl_get_subscription(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_get_subscription(client_t *client, void __user *arg) { int result; - struct snd_seq_client *sender = NULL; - struct snd_seq_client_port *sport = NULL; - struct snd_seq_port_subscribe subs; - struct snd_seq_subscribers *p; + client_t *sender = NULL; + client_port_t *sport = NULL; + snd_seq_port_subscribe_t subs; + subscribers_t *p; if (copy_from_user(&subs, arg, sizeof(subs))) return -EFAULT; @@ -2000,14 +1940,13 @@ static int snd_seq_ioctl_get_subscription(struct snd_seq_client *client, /* * get subscription info - check only its presence */ -static int snd_seq_ioctl_query_subs(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_query_subs(client_t *client, void __user *arg) { int result = -ENXIO; - struct snd_seq_client *cptr = NULL; - struct snd_seq_client_port *port = NULL; - struct snd_seq_query_subs subs; - struct snd_seq_port_subs_info *group; + client_t *cptr = NULL; + client_port_t *port = NULL; + snd_seq_query_subs_t subs; + port_subs_info_t *group; struct list_head *p; int i; @@ -2038,12 +1977,12 @@ static int snd_seq_ioctl_query_subs(struct snd_seq_client *client, list_for_each(p, &group->list_head) { if (i++ == subs.index) { /* found! */ - struct snd_seq_subscribers *s; + subscribers_t *s; if (subs.type == SNDRV_SEQ_QUERY_SUBS_READ) { - s = list_entry(p, struct snd_seq_subscribers, src_list); + s = list_entry(p, subscribers_t, src_list); subs.addr = s->info.dest; } else { - s = list_entry(p, struct snd_seq_subscribers, dest_list); + s = list_entry(p, subscribers_t, dest_list); subs.addr = s->info.sender; } subs.flags = s->info.flags; @@ -2070,11 +2009,10 @@ static int snd_seq_ioctl_query_subs(struct snd_seq_client *client, /* * query next client */ -static int snd_seq_ioctl_query_next_client(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_query_next_client(client_t *client, void __user *arg) { - struct snd_seq_client *cptr = NULL; - struct snd_seq_client_info info; + client_t *cptr = NULL; + snd_seq_client_info_t info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -2102,12 +2040,11 @@ static int snd_seq_ioctl_query_next_client(struct snd_seq_client *client, /* * query next port */ -static int snd_seq_ioctl_query_next_port(struct snd_seq_client *client, - void __user *arg) +static int snd_seq_ioctl_query_next_port(client_t *client, void __user *arg) { - struct snd_seq_client *cptr; - struct snd_seq_client_port *port = NULL; - struct snd_seq_port_info info; + client_t *cptr; + client_port_t *port = NULL; + snd_seq_port_info_t info; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; @@ -2138,7 +2075,7 @@ static int snd_seq_ioctl_query_next_port(struct snd_seq_client *client, static struct seq_ioctl_table { unsigned int cmd; - int (*func)(struct snd_seq_client *client, void __user * arg); + int (*func)(client_t *client, void __user * arg); } ioctl_tables[] = { { SNDRV_SEQ_IOCTL_SYSTEM_INFO, snd_seq_ioctl_system_info }, { SNDRV_SEQ_IOCTL_RUNNING_MODE, snd_seq_ioctl_running_mode }, @@ -2172,8 +2109,7 @@ static struct seq_ioctl_table { { 0, NULL }, }; -static int snd_seq_do_ioctl(struct snd_seq_client *client, unsigned int cmd, - void __user *arg) +static int snd_seq_do_ioctl(client_t *client, unsigned int cmd, void __user *arg) { struct seq_ioctl_table *p; @@ -2200,7 +2136,7 @@ static int snd_seq_do_ioctl(struct snd_seq_client *client, unsigned int cmd, static long snd_seq_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_seq_client *client = file->private_data; + client_t *client = (client_t *) file->private_data; snd_assert(client != NULL, return -ENXIO); @@ -2217,29 +2153,23 @@ static long snd_seq_ioctl(struct file *file, unsigned int cmd, unsigned long arg /* exported to kernel modules */ -int snd_seq_create_kernel_client(struct snd_card *card, int client_index, - const char *name_fmt, ...) +int snd_seq_create_kernel_client(snd_card_t *card, int client_index, snd_seq_client_callback_t * callback) { - struct snd_seq_client *client; - va_list args; + client_t *client; snd_assert(! in_interrupt(), return -EBUSY); - if (card && client_index >= SNDRV_SEQ_CLIENTS_PER_CARD) + if (callback == NULL) return -EINVAL; - if (card == NULL && client_index >= SNDRV_SEQ_GLOBAL_CLIENTS) + if (card && client_index > 7) return -EINVAL; + if (card == NULL && client_index > 63) + return -EINVAL; + if (card) + client_index += 64 + (card->number << 3); if (down_interruptible(®ister_mutex)) return -ERESTARTSYS; - - if (card) { - client_index += SNDRV_SEQ_GLOBAL_CLIENTS - + card->number * SNDRV_SEQ_CLIENTS_PER_CARD; - if (client_index >= SNDRV_SEQ_DYNAMIC_CLIENTS_BEGIN) - client_index = -1; - } - /* empty write queue as default */ client = seq_create_client1(client_index, 0); if (client == NULL) { @@ -2248,12 +2178,13 @@ int snd_seq_create_kernel_client(struct snd_card *card, int client_index, } usage_alloc(&client_usage, 1); - client->accept_input = 1; - client->accept_output = 1; + client->accept_input = callback->allow_output; + client->accept_output = callback->allow_input; - va_start(args, name_fmt); - vsnprintf(client->name, sizeof(client->name), name_fmt, args); - va_end(args); + /* fill client data */ + client->data.kernel.card = card; + client->data.kernel.private_data = callback->private_data; + sprintf(client->name, "Client-%d", client->number); client->type = KERNEL_CLIENT; up(®ister_mutex); @@ -2268,7 +2199,7 @@ int snd_seq_create_kernel_client(struct snd_card *card, int client_index, /* exported to kernel modules */ int snd_seq_delete_kernel_client(int client) { - struct snd_seq_client *ptr; + client_t *ptr; snd_assert(! in_interrupt(), return -EBUSY); @@ -2285,11 +2216,11 @@ int snd_seq_delete_kernel_client(int client) /* skeleton to enqueue event, called from snd_seq_kernel_client_enqueue * and snd_seq_kernel_client_enqueue_blocking */ -static int kernel_client_enqueue(int client, struct snd_seq_event *ev, +static int kernel_client_enqueue(int client, snd_seq_event_t *ev, struct file *file, int blocking, int atomic, int hop) { - struct snd_seq_client *cptr; + client_t *cptr; int result; snd_assert(ev != NULL, return -EINVAL); @@ -2323,7 +2254,7 @@ static int kernel_client_enqueue(int client, struct snd_seq_event *ev, * * RETURN VALUE: zero if succeed, negative if error */ -int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event * ev, +int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t * ev, int atomic, int hop) { return kernel_client_enqueue(client, ev, NULL, 0, atomic, hop); @@ -2334,7 +2265,7 @@ int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event * ev, * * RETURN VALUE: zero if succeed, negative if error */ -int snd_seq_kernel_client_enqueue_blocking(int client, struct snd_seq_event * ev, +int snd_seq_kernel_client_enqueue_blocking(int client, snd_seq_event_t * ev, struct file *file, int atomic, int hop) { @@ -2349,10 +2280,10 @@ int snd_seq_kernel_client_enqueue_blocking(int client, struct snd_seq_event * ev * RETURN VALUE: negative = delivery failed, * zero, or positive: the number of delivered events */ -int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev, +int snd_seq_kernel_client_dispatch(int client, snd_seq_event_t * ev, int atomic, int hop) { - struct snd_seq_client *cptr; + client_t *cptr; int result; snd_assert(ev != NULL, return -EINVAL); @@ -2384,7 +2315,7 @@ int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev, */ int snd_seq_kernel_client_ctl(int clientid, unsigned int cmd, void *arg) { - struct snd_seq_client *client; + client_t *client; mm_segment_t fs; int result; @@ -2401,7 +2332,7 @@ int snd_seq_kernel_client_ctl(int clientid, unsigned int cmd, void *arg) /* exported (for OSS emulator) */ int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table *wait) { - struct snd_seq_client *client; + client_t *client; client = clientptr(clientid); if (client == NULL) @@ -2416,16 +2347,13 @@ int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table /*---------------------------------------------------------------------------*/ -#ifdef CONFIG_PROC_FS /* * /proc interface */ -static void snd_seq_info_dump_subscribers(struct snd_info_buffer *buffer, - struct snd_seq_port_subs_info *group, - int is_src, char *msg) +static void snd_seq_info_dump_subscribers(snd_info_buffer_t *buffer, port_subs_info_t *group, int is_src, char *msg) { struct list_head *p; - struct snd_seq_subscribers *s; + subscribers_t *s; int count = 0; down_read(&group->list_mutex); @@ -2436,9 +2364,9 @@ static void snd_seq_info_dump_subscribers(struct snd_info_buffer *buffer, snd_iprintf(buffer, msg); list_for_each(p, &group->list_head) { if (is_src) - s = list_entry(p, struct snd_seq_subscribers, src_list); + s = list_entry(p, subscribers_t, src_list); else - s = list_entry(p, struct snd_seq_subscribers, dest_list); + s = list_entry(p, subscribers_t, dest_list); if (count++) snd_iprintf(buffer, ", "); snd_iprintf(buffer, "%d:%d", @@ -2459,14 +2387,13 @@ static void snd_seq_info_dump_subscribers(struct snd_info_buffer *buffer, #define FLAG_PERM_DUPLEX(perm) ((perm) & SNDRV_SEQ_PORT_CAP_DUPLEX ? 'X' : '-') -static void snd_seq_info_dump_ports(struct snd_info_buffer *buffer, - struct snd_seq_client *client) +static void snd_seq_info_dump_ports(snd_info_buffer_t *buffer, client_t *client) { struct list_head *l; down(&client->ports_mutex); list_for_each(l, &client->ports_list_head) { - struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list); + client_port_t *p = list_entry(l, client_port_t, list); snd_iprintf(buffer, " Port %3d : \"%s\" (%c%c%c%c)\n", p->addr.port, p->name, FLAG_PERM_RD(p->capability), @@ -2480,15 +2407,13 @@ static void snd_seq_info_dump_ports(struct snd_info_buffer *buffer, } -void snd_seq_info_pool(struct snd_info_buffer *buffer, - struct snd_seq_pool *pool, char *space); - /* exported to seq_info.c */ -void snd_seq_info_clients_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +void snd_seq_info_clients_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { + extern void snd_seq_info_pool(snd_info_buffer_t * buffer, pool_t * pool, char *space); int c; - struct snd_seq_client *client; + client_t *client; snd_iprintf(buffer, "Client info\n"); snd_iprintf(buffer, " cur clients : %d\n", client_usage.cur); @@ -2522,7 +2447,7 @@ void snd_seq_info_clients_read(struct snd_info_entry *entry, snd_seq_client_unlock(client); } } -#endif /* CONFIG_PROC_FS */ + /*---------------------------------------------------------------------------*/ @@ -2543,6 +2468,13 @@ static struct file_operations snd_seq_f_ops = .compat_ioctl = snd_seq_ioctl_compat, }; +static snd_minor_t snd_seq_reg = +{ + .comment = "sequencer", + .f_ops = &snd_seq_f_ops, +}; + + /* * register sequencer device */ @@ -2553,8 +2485,7 @@ int __init snd_sequencer_device_init(void) if (down_interruptible(®ister_mutex)) return -ERESTARTSYS; - if ((err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0, - &snd_seq_f_ops, NULL, "seq")) < 0) { + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0, &snd_seq_reg, "seq")) < 0) { up(®ister_mutex); return err; } diff --git a/trunk/sound/core/seq/seq_clientmgr.h b/trunk/sound/core/seq/seq_clientmgr.h index 450091ca153d..3715c36183d3 100644 --- a/trunk/sound/core/seq/seq_clientmgr.h +++ b/trunk/sound/core/seq/seq_clientmgr.h @@ -30,21 +30,24 @@ /* client manager */ -struct snd_seq_user_client { +struct _snd_seq_user_client { struct file *file; /* file struct of client */ /* ... */ /* fifo */ - struct snd_seq_fifo *fifo; /* queue for incoming events */ + fifo_t *fifo; /* queue for incoming events */ int fifo_pool_size; }; -struct snd_seq_kernel_client { +struct _snd_seq_kernel_client { + snd_card_t *card; + /* pointer to client functions */ + void *private_data; /* private data for client */ /* ... */ }; -struct snd_seq_client { +struct _snd_seq_client { snd_seq_client_type_t type; unsigned int accept_input: 1, accept_output: 1; @@ -62,40 +65,40 @@ struct snd_seq_client { int convert32; /* convert 32->64bit */ /* output pool */ - struct snd_seq_pool *pool; /* memory pool for this client */ + pool_t *pool; /* memory pool for this client */ union { - struct snd_seq_user_client user; - struct snd_seq_kernel_client kernel; + user_client_t user; + kernel_client_t kernel; } data; }; /* usage statistics */ -struct snd_seq_usage { +typedef struct { int cur; int peak; -}; +} usage_t; -int client_init_data(void); -int snd_sequencer_device_init(void); -void snd_sequencer_device_done(void); +extern int client_init_data(void); +extern int snd_sequencer_device_init(void); +extern void snd_sequencer_device_done(void); /* get locked pointer to client */ -struct snd_seq_client *snd_seq_client_use_ptr(int clientid); +extern client_t *snd_seq_client_use_ptr(int clientid); /* unlock pointer to client */ #define snd_seq_client_unlock(client) snd_use_lock_free(&(client)->use_lock) /* dispatch event to client(s) */ -int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop); +extern int snd_seq_dispatch_event(snd_seq_event_cell_t *cell, int atomic, int hop); /* exported to other modules */ -int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event *ev, int atomic, int hop); -int snd_seq_kernel_client_enqueue_blocking(int client, struct snd_seq_event * ev, - struct file *file, int atomic, int hop); +extern int snd_seq_register_kernel_client(snd_seq_client_callback_t *callback, void *private_data); +extern int snd_seq_unregister_kernel_client(int client); +extern int snd_seq_kernel_client_enqueue(int client, snd_seq_event_t *ev, int atomic, int hop); +int snd_seq_kernel_client_enqueue_blocking(int client, snd_seq_event_t * ev, struct file *file, int atomic, int hop); int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table *wait); -int snd_seq_client_notify_subscription(int client, int port, - struct snd_seq_port_subscribe *info, int evtype); +int snd_seq_client_notify_subscription(int client, int port, snd_seq_port_subscribe_t *info, int evtype); #endif diff --git a/trunk/sound/core/seq/seq_compat.c b/trunk/sound/core/seq/seq_compat.c index 9628c06e4eab..902ad8b0c355 100644 --- a/trunk/sound/core/seq/seq_compat.c +++ b/trunk/sound/core/seq/seq_compat.c @@ -22,8 +22,8 @@ #include <linux/compat.h> -struct snd_seq_port_info32 { - struct snd_seq_addr addr; /* client/port numbers */ +struct sndrv_seq_port_info32 { + struct sndrv_seq_addr addr; /* client/port numbers */ char name[64]; /* port name */ u32 capability; /* port capability bits */ @@ -41,11 +41,11 @@ struct snd_seq_port_info32 { char reserved[59]; /* for future use */ }; -static int snd_seq_call_port_info_ioctl(struct snd_seq_client *client, unsigned int cmd, - struct snd_seq_port_info32 __user *data32) +static int snd_seq_call_port_info_ioctl(client_t *client, unsigned int cmd, + struct sndrv_seq_port_info32 __user *data32) { int err = -EFAULT; - struct snd_seq_port_info *data; + snd_seq_port_info_t *data; mm_segment_t fs; data = kmalloc(sizeof(*data), GFP_KERNEL); @@ -80,16 +80,16 @@ static int snd_seq_call_port_info_ioctl(struct snd_seq_client *client, unsigned */ enum { - SNDRV_SEQ_IOCTL_CREATE_PORT32 = _IOWR('S', 0x20, struct snd_seq_port_info32), - SNDRV_SEQ_IOCTL_DELETE_PORT32 = _IOW ('S', 0x21, struct snd_seq_port_info32), - SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = _IOWR('S', 0x22, struct snd_seq_port_info32), - SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = _IOW ('S', 0x23, struct snd_seq_port_info32), - SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = _IOWR('S', 0x52, struct snd_seq_port_info32), + SNDRV_SEQ_IOCTL_CREATE_PORT32 = _IOWR('S', 0x20, struct sndrv_seq_port_info32), + SNDRV_SEQ_IOCTL_DELETE_PORT32 = _IOW ('S', 0x21, struct sndrv_seq_port_info32), + SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = _IOWR('S', 0x22, struct sndrv_seq_port_info32), + SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = _IOW ('S', 0x23, struct sndrv_seq_port_info32), + SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = _IOWR('S', 0x52, struct sndrv_seq_port_info32), }; static long snd_seq_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_seq_client *client = file->private_data; + client_t *client = (client_t *) file->private_data; void __user *argp = compat_ptr(arg); snd_assert(client != NULL, return -ENXIO); diff --git a/trunk/sound/core/seq/seq_device.c b/trunk/sound/core/seq/seq_device.c index 9ece443fba55..252b52731003 100644 --- a/trunk/sound/core/seq/seq_device.c +++ b/trunk/sound/core/seq/seq_device.c @@ -50,6 +50,11 @@ MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); MODULE_DESCRIPTION("ALSA sequencer device management"); MODULE_LICENSE("GPL"); +/* + * driver list + */ +typedef struct ops_list ops_list_t; + /* driver state */ #define DRIVER_EMPTY 0 #define DRIVER_LOADED (1<<0) @@ -63,7 +68,7 @@ struct ops_list { int argsize; /* argument size */ /* operators */ - struct snd_seq_dev_ops ops; + snd_seq_dev_ops_t ops; /* registred devices */ struct list_head dev_list; /* list of devices */ @@ -78,39 +83,35 @@ struct ops_list { static LIST_HEAD(opslist); static int num_ops; static DECLARE_MUTEX(ops_mutex); -#ifdef CONFIG_PROC_FS -static struct snd_info_entry *info_entry = NULL; -#endif +static snd_info_entry_t *info_entry = NULL; /* * prototypes */ -static int snd_seq_device_free(struct snd_seq_device *dev); -static int snd_seq_device_dev_free(struct snd_device *device); -static int snd_seq_device_dev_register(struct snd_device *device); -static int snd_seq_device_dev_disconnect(struct snd_device *device); -static int snd_seq_device_dev_unregister(struct snd_device *device); - -static int init_device(struct snd_seq_device *dev, struct ops_list *ops); -static int free_device(struct snd_seq_device *dev, struct ops_list *ops); -static struct ops_list *find_driver(char *id, int create_if_empty); -static struct ops_list *create_driver(char *id); -static void unlock_driver(struct ops_list *ops); +static int snd_seq_device_free(snd_seq_device_t *dev); +static int snd_seq_device_dev_free(snd_device_t *device); +static int snd_seq_device_dev_register(snd_device_t *device); +static int snd_seq_device_dev_disconnect(snd_device_t *device); +static int snd_seq_device_dev_unregister(snd_device_t *device); + +static int init_device(snd_seq_device_t *dev, ops_list_t *ops); +static int free_device(snd_seq_device_t *dev, ops_list_t *ops); +static ops_list_t *find_driver(char *id, int create_if_empty); +static ops_list_t *create_driver(char *id); +static void unlock_driver(ops_list_t *ops); static void remove_drivers(void); /* * show all drivers and their status */ -#ifdef CONFIG_PROC_FS -static void snd_seq_device_info(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_seq_device_info(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { struct list_head *head; down(&ops_mutex); list_for_each(head, &opslist) { - struct ops_list *ops = list_entry(head, struct ops_list, list); + ops_list_t *ops = list_entry(head, ops_list_t, list); snd_iprintf(buffer, "snd-%s%s%s%s,%d\n", ops->id, ops->driver & DRIVER_LOADED ? ",loaded" : (ops->driver == DRIVER_EMPTY ? ",empty" : ""), @@ -120,7 +121,6 @@ static void snd_seq_device_info(struct snd_info_entry *entry, } up(&ops_mutex); } -#endif /* * load all registered drivers (called from seq_clientmgr.c) @@ -156,7 +156,7 @@ void snd_seq_device_load_drivers(void) down(&ops_mutex); list_for_each(head, &opslist) { - struct ops_list *ops = list_entry(head, struct ops_list, list); + ops_list_t *ops = list_entry(head, ops_list_t, list); if (! (ops->driver & DRIVER_LOADED) && ! (ops->driver & DRIVER_REQUESTED)) { ops->used++; @@ -178,13 +178,13 @@ void snd_seq_device_load_drivers(void) * id = id of driver * result = return pointer (NULL allowed if unnecessary) */ -int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize, - struct snd_seq_device **result) +int snd_seq_device_new(snd_card_t *card, int device, char *id, int argsize, + snd_seq_device_t **result) { - struct snd_seq_device *dev; - struct ops_list *ops; + snd_seq_device_t *dev; + ops_list_t *ops; int err; - static struct snd_device_ops dops = { + static snd_device_ops_t dops = { .dev_free = snd_seq_device_dev_free, .dev_register = snd_seq_device_dev_register, .dev_disconnect = snd_seq_device_dev_disconnect, @@ -235,9 +235,9 @@ int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize, /* * free the existing device */ -static int snd_seq_device_free(struct snd_seq_device *dev) +static int snd_seq_device_free(snd_seq_device_t *dev) { - struct ops_list *ops; + ops_list_t *ops; snd_assert(dev != NULL, return -EINVAL); @@ -261,19 +261,19 @@ static int snd_seq_device_free(struct snd_seq_device *dev) return 0; } -static int snd_seq_device_dev_free(struct snd_device *device) +static int snd_seq_device_dev_free(snd_device_t *device) { - struct snd_seq_device *dev = device->device_data; + snd_seq_device_t *dev = device->device_data; return snd_seq_device_free(dev); } /* * register the device */ -static int snd_seq_device_dev_register(struct snd_device *device) +static int snd_seq_device_dev_register(snd_device_t *device) { - struct snd_seq_device *dev = device->device_data; - struct ops_list *ops; + snd_seq_device_t *dev = device->device_data; + ops_list_t *ops; ops = find_driver(dev->id, 0); if (ops == NULL) @@ -292,10 +292,10 @@ static int snd_seq_device_dev_register(struct snd_device *device) /* * disconnect the device */ -static int snd_seq_device_dev_disconnect(struct snd_device *device) +static int snd_seq_device_dev_disconnect(snd_device_t *device) { - struct snd_seq_device *dev = device->device_data; - struct ops_list *ops; + snd_seq_device_t *dev = device->device_data; + ops_list_t *ops; ops = find_driver(dev->id, 0); if (ops == NULL) @@ -310,9 +310,9 @@ static int snd_seq_device_dev_disconnect(struct snd_device *device) /* * unregister the existing device */ -static int snd_seq_device_dev_unregister(struct snd_device *device) +static int snd_seq_device_dev_unregister(snd_device_t *device) { - struct snd_seq_device *dev = device->device_data; + snd_seq_device_t *dev = device->device_data; return snd_seq_device_free(dev); } @@ -321,11 +321,10 @@ static int snd_seq_device_dev_unregister(struct snd_device *device) * id = driver id * entry = driver operators - duplicated to each instance */ -int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, - int argsize) +int snd_seq_device_register_driver(char *id, snd_seq_dev_ops_t *entry, int argsize) { struct list_head *head; - struct ops_list *ops; + ops_list_t *ops; if (id == NULL || entry == NULL || entry->init_device == NULL || entry->free_device == NULL) @@ -352,7 +351,7 @@ int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, /* initialize existing devices if necessary */ list_for_each(head, &ops->dev_list) { - struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list); + snd_seq_device_t *dev = list_entry(head, snd_seq_device_t, list); init_device(dev, ops); } up(&ops->reg_mutex); @@ -367,9 +366,9 @@ int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry, /* * create driver record */ -static struct ops_list * create_driver(char *id) +static ops_list_t * create_driver(char *id) { - struct ops_list *ops; + ops_list_t *ops; ops = kmalloc(sizeof(*ops), GFP_KERNEL); if (ops == NULL) @@ -400,15 +399,14 @@ static struct ops_list * create_driver(char *id) int snd_seq_device_unregister_driver(char *id) { struct list_head *head; - struct ops_list *ops; + ops_list_t *ops; ops = find_driver(id, 0); if (ops == NULL) return -ENXIO; if (! (ops->driver & DRIVER_LOADED) || (ops->driver & DRIVER_LOCKED)) { - snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n", - id, ops->driver); + snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n", id, ops->driver); unlock_driver(ops); return -EBUSY; } @@ -417,14 +415,13 @@ int snd_seq_device_unregister_driver(char *id) down(&ops->reg_mutex); ops->driver |= DRIVER_LOCKED; /* do not remove this driver recursively */ list_for_each(head, &ops->dev_list) { - struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list); + snd_seq_device_t *dev = list_entry(head, snd_seq_device_t, list); free_device(dev, ops); } ops->driver = 0; if (ops->num_init_devices > 0) - snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n", - ops->num_init_devices); + snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n", ops->num_init_devices); up(&ops->reg_mutex); unlock_driver(ops); @@ -446,7 +443,7 @@ static void remove_drivers(void) down(&ops_mutex); head = opslist.next; while (head != &opslist) { - struct ops_list *ops = list_entry(head, struct ops_list, list); + ops_list_t *ops = list_entry(head, ops_list_t, list); if (! (ops->driver & DRIVER_LOADED) && ops->used == 0 && ops->num_devices == 0) { head = head->next; @@ -462,23 +459,21 @@ static void remove_drivers(void) /* * initialize the device - call init_device operator */ -static int init_device(struct snd_seq_device *dev, struct ops_list *ops) +static int init_device(snd_seq_device_t *dev, ops_list_t *ops) { if (! (ops->driver & DRIVER_LOADED)) return 0; /* driver is not loaded yet */ if (dev->status != SNDRV_SEQ_DEVICE_FREE) return 0; /* already initialized */ if (ops->argsize != dev->argsize) { - snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", - dev->name, ops->id, ops->argsize, dev->argsize); + snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", dev->name, ops->id, ops->argsize, dev->argsize); return -EINVAL; } if (ops->ops.init_device(dev) >= 0) { dev->status = SNDRV_SEQ_DEVICE_REGISTERED; ops->num_init_devices++; } else { - snd_printk(KERN_ERR "init_device failed: %s: %s\n", - dev->name, dev->id); + snd_printk(KERN_ERR "init_device failed: %s: %s\n", dev->name, dev->id); } return 0; @@ -487,7 +482,7 @@ static int init_device(struct snd_seq_device *dev, struct ops_list *ops) /* * release the device - call free_device operator */ -static int free_device(struct snd_seq_device *dev, struct ops_list *ops) +static int free_device(snd_seq_device_t *dev, ops_list_t *ops) { int result; @@ -496,8 +491,7 @@ static int free_device(struct snd_seq_device *dev, struct ops_list *ops) if (dev->status != SNDRV_SEQ_DEVICE_REGISTERED) return 0; /* not registered */ if (ops->argsize != dev->argsize) { - snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", - dev->name, ops->id, ops->argsize, dev->argsize); + snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n", dev->name, ops->id, ops->argsize, dev->argsize); return -EINVAL; } if ((result = ops->ops.free_device(dev)) >= 0 || result == -ENXIO) { @@ -505,8 +499,7 @@ static int free_device(struct snd_seq_device *dev, struct ops_list *ops) dev->driver_data = NULL; ops->num_init_devices--; } else { - snd_printk(KERN_ERR "free_device failed: %s: %s\n", - dev->name, dev->id); + snd_printk(KERN_ERR "free_device failed: %s: %s\n", dev->name, dev->id); } return 0; @@ -515,13 +508,13 @@ static int free_device(struct snd_seq_device *dev, struct ops_list *ops) /* * find the matching driver with given id */ -static struct ops_list * find_driver(char *id, int create_if_empty) +static ops_list_t * find_driver(char *id, int create_if_empty) { struct list_head *head; down(&ops_mutex); list_for_each(head, &opslist) { - struct ops_list *ops = list_entry(head, struct ops_list, list); + ops_list_t *ops = list_entry(head, ops_list_t, list); if (strcmp(ops->id, id) == 0) { ops->used++; up(&ops_mutex); @@ -534,7 +527,7 @@ static struct ops_list * find_driver(char *id, int create_if_empty) return NULL; } -static void unlock_driver(struct ops_list *ops) +static void unlock_driver(ops_list_t *ops) { down(&ops_mutex); ops->used--; @@ -548,9 +541,7 @@ static void unlock_driver(struct ops_list *ops) static int __init alsa_seq_device_init(void) { -#ifdef CONFIG_PROC_FS - info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers", - snd_seq_root); + info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers", snd_seq_root); if (info_entry == NULL) return -ENOMEM; info_entry->content = SNDRV_INFO_CONTENT_TEXT; @@ -560,16 +551,13 @@ static int __init alsa_seq_device_init(void) snd_info_free_entry(info_entry); return -ENOMEM; } -#endif return 0; } static void __exit alsa_seq_device_exit(void) { remove_drivers(); -#ifdef CONFIG_PROC_FS snd_info_unregister(info_entry); -#endif if (num_ops) snd_printk(KERN_ERR "drivers not released (%d)\n", num_ops); } diff --git a/trunk/sound/core/seq/seq_dummy.c b/trunk/sound/core/seq/seq_dummy.c index 2a283a59ea4d..5dd0e6a19e50 100644 --- a/trunk/sound/core/seq/seq_dummy.c +++ b/trunk/sound/core/seq/seq_dummy.c @@ -73,12 +73,12 @@ MODULE_PARM_DESC(ports, "number of ports to be created"); module_param(duplex, bool, 0444); MODULE_PARM_DESC(duplex, "create DUPLEX ports"); -struct snd_seq_dummy_port { +typedef struct snd_seq_dummy_port { int client; int port; int duplex; int connect; -}; +} snd_seq_dummy_port_t; static int my_client = -1; @@ -88,11 +88,11 @@ static int my_client = -1; * Note: this callback is called only after all subscribers are removed. */ static int -dummy_unuse(void *private_data, struct snd_seq_port_subscribe *info) +dummy_unuse(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_seq_dummy_port *p; + snd_seq_dummy_port_t *p; int i; - struct snd_seq_event ev; + snd_seq_event_t ev; p = private_data; memset(&ev, 0, sizeof(ev)); @@ -116,11 +116,10 @@ dummy_unuse(void *private_data, struct snd_seq_port_subscribe *info) * event input callback - just redirect events to subscribers */ static int -dummy_input(struct snd_seq_event *ev, int direct, void *private_data, - int atomic, int hop) +dummy_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct snd_seq_dummy_port *p; - struct snd_seq_event tmpev; + snd_seq_dummy_port_t *p; + snd_seq_event_t tmpev; p = private_data; if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM || @@ -147,12 +146,12 @@ dummy_free(void *private_data) /* * create a port */ -static struct snd_seq_dummy_port __init * +static snd_seq_dummy_port_t __init * create_port(int idx, int type) { - struct snd_seq_port_info pinfo; - struct snd_seq_port_callback pcb; - struct snd_seq_dummy_port *rec; + snd_seq_port_info_t pinfo; + snd_seq_port_callback_t pcb; + snd_seq_dummy_port_t *rec; if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL) return NULL; @@ -193,7 +192,9 @@ create_port(int idx, int type) static int __init register_client(void) { - struct snd_seq_dummy_port *rec1, *rec2; + snd_seq_client_callback_t cb; + snd_seq_client_info_t cinfo; + snd_seq_dummy_port_t *rec1, *rec2; int i; if (ports < 1) { @@ -202,11 +203,20 @@ register_client(void) } /* create client */ - my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, - "Midi Through"); + memset(&cb, 0, sizeof(cb)); + cb.allow_input = 1; + cb.allow_output = 1; + my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY, &cb); if (my_client < 0) return my_client; + /* set client name */ + memset(&cinfo, 0, sizeof(cinfo)); + cinfo.client = my_client; + cinfo.type = KERNEL_CLIENT; + strcpy(cinfo.name, "Midi Through"); + snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); + /* create ports */ for (i = 0; i < ports; i++) { rec1 = create_port(i, 0); diff --git a/trunk/sound/core/seq/seq_fifo.c b/trunk/sound/core/seq/seq_fifo.c index 6b055aed7a4b..4767cfdc361f 100644 --- a/trunk/sound/core/seq/seq_fifo.c +++ b/trunk/sound/core/seq/seq_fifo.c @@ -29,9 +29,9 @@ /* FIFO */ /* create new fifo */ -struct snd_seq_fifo *snd_seq_fifo_new(int poolsize) +fifo_t *snd_seq_fifo_new(int poolsize) { - struct snd_seq_fifo *f; + fifo_t *f; f = kzalloc(sizeof(*f), GFP_KERNEL); if (f == NULL) { @@ -62,9 +62,9 @@ struct snd_seq_fifo *snd_seq_fifo_new(int poolsize) return f; } -void snd_seq_fifo_delete(struct snd_seq_fifo **fifo) +void snd_seq_fifo_delete(fifo_t **fifo) { - struct snd_seq_fifo *f; + fifo_t *f; snd_assert(fifo != NULL, return); f = *fifo; @@ -88,12 +88,12 @@ void snd_seq_fifo_delete(struct snd_seq_fifo **fifo) kfree(f); } -static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f); +static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f); /* clear queue */ -void snd_seq_fifo_clear(struct snd_seq_fifo *f) +void snd_seq_fifo_clear(fifo_t *f) { - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; unsigned long flags; /* clear overflow flag */ @@ -110,10 +110,9 @@ void snd_seq_fifo_clear(struct snd_seq_fifo *f) /* enqueue event to fifo */ -int snd_seq_fifo_event_in(struct snd_seq_fifo *f, - struct snd_seq_event *event) +int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event) { - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; unsigned long flags; int err; @@ -149,9 +148,9 @@ int snd_seq_fifo_event_in(struct snd_seq_fifo *f, } /* dequeue cell from fifo */ -static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f) +static snd_seq_event_cell_t *fifo_cell_out(fifo_t *f) { - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; if ((cell = f->head) != NULL) { f->head = cell->next; @@ -168,10 +167,9 @@ static struct snd_seq_event_cell *fifo_cell_out(struct snd_seq_fifo *f) } /* dequeue cell from fifo and copy on user space */ -int snd_seq_fifo_cell_out(struct snd_seq_fifo *f, - struct snd_seq_event_cell **cellp, int nonblock) +int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock) { - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; unsigned long flags; wait_queue_t wait; @@ -204,8 +202,7 @@ int snd_seq_fifo_cell_out(struct snd_seq_fifo *f, } -void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f, - struct snd_seq_event_cell *cell) +void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell) { unsigned long flags; @@ -220,19 +217,18 @@ void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f, /* polling; return non-zero if queue is available */ -int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file, - poll_table *wait) +int snd_seq_fifo_poll_wait(fifo_t *f, struct file *file, poll_table *wait) { poll_wait(file, &f->input_sleep, wait); return (f->cells > 0); } /* change the size of pool; all old events are removed */ -int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize) +int snd_seq_fifo_resize(fifo_t *f, int poolsize) { unsigned long flags; - struct snd_seq_pool *newpool, *oldpool; - struct snd_seq_event_cell *cell, *next, *oldhead; + pool_t *newpool, *oldpool; + snd_seq_event_cell_t *cell, *next, *oldhead; snd_assert(f != NULL && f->pool != NULL, return -EINVAL); diff --git a/trunk/sound/core/seq/seq_fifo.h b/trunk/sound/core/seq/seq_fifo.h index 062c446e7867..d677c261b0a4 100644 --- a/trunk/sound/core/seq/seq_fifo.h +++ b/trunk/sound/core/seq/seq_fifo.h @@ -27,46 +27,46 @@ /* === FIFO === */ -struct snd_seq_fifo { - struct snd_seq_pool *pool; /* FIFO pool */ - struct snd_seq_event_cell *head; /* pointer to head of fifo */ - struct snd_seq_event_cell *tail; /* pointer to tail of fifo */ +typedef struct { + pool_t *pool; /* FIFO pool */ + snd_seq_event_cell_t* head; /* pointer to head of fifo */ + snd_seq_event_cell_t* tail; /* pointer to tail of fifo */ int cells; spinlock_t lock; snd_use_lock_t use_lock; wait_queue_head_t input_sleep; atomic_t overflow; -}; +} fifo_t; /* create new fifo (constructor) */ -struct snd_seq_fifo *snd_seq_fifo_new(int poolsize); +extern fifo_t *snd_seq_fifo_new(int poolsize); /* delete fifo (destructor) */ -void snd_seq_fifo_delete(struct snd_seq_fifo **f); +extern void snd_seq_fifo_delete(fifo_t **f); /* enqueue event to fifo */ -int snd_seq_fifo_event_in(struct snd_seq_fifo *f, struct snd_seq_event *event); +extern int snd_seq_fifo_event_in(fifo_t *f, snd_seq_event_t *event); /* lock fifo from release */ #define snd_seq_fifo_lock(fifo) snd_use_lock_use(&(fifo)->use_lock) #define snd_seq_fifo_unlock(fifo) snd_use_lock_free(&(fifo)->use_lock) /* get a cell from fifo - fifo should be locked */ -int snd_seq_fifo_cell_out(struct snd_seq_fifo *f, struct snd_seq_event_cell **cellp, int nonblock); +int snd_seq_fifo_cell_out(fifo_t *f, snd_seq_event_cell_t **cellp, int nonblock); /* free dequeued cell - fifo should be locked */ -void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f, struct snd_seq_event_cell *cell); +extern void snd_seq_fifo_cell_putback(fifo_t *f, snd_seq_event_cell_t *cell); /* clean up queue */ -void snd_seq_fifo_clear(struct snd_seq_fifo *f); +extern void snd_seq_fifo_clear(fifo_t *f); /* polling */ -int snd_seq_fifo_poll_wait(struct snd_seq_fifo *f, struct file *file, poll_table *wait); +extern int snd_seq_fifo_poll_wait(fifo_t *f, struct file *file, poll_table *wait); /* resize pool in fifo */ -int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize); +int snd_seq_fifo_resize(fifo_t *f, int poolsize); #endif diff --git a/trunk/sound/core/seq/seq_info.c b/trunk/sound/core/seq/seq_info.c index acce21afdaa4..b50b695c41c4 100644 --- a/trunk/sound/core/seq/seq_info.c +++ b/trunk/sound/core/seq/seq_info.c @@ -27,17 +27,16 @@ #include "seq_clientmgr.h" #include "seq_timer.h" -#ifdef CONFIG_PROC_FS -static struct snd_info_entry *queues_entry; -static struct snd_info_entry *clients_entry; -static struct snd_info_entry *timer_entry; +static snd_info_entry_t *queues_entry; +static snd_info_entry_t *clients_entry; +static snd_info_entry_t *timer_entry; -static struct snd_info_entry * __init -create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *, - struct snd_info_buffer *)) + +static snd_info_entry_t * __init +create_info_entry(char *name, int size, void (*read)(snd_info_entry_t *, snd_info_buffer_t *)) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, name, snd_seq_root); if (entry == NULL) @@ -52,6 +51,7 @@ create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *, return entry; } + /* create all our /proc entries */ int __init snd_seq_info_init(void) { @@ -65,9 +65,11 @@ int __init snd_seq_info_init(void) int __exit snd_seq_info_done(void) { - snd_info_unregister(queues_entry); - snd_info_unregister(clients_entry); - snd_info_unregister(timer_entry); + if (queues_entry) + snd_info_unregister(queues_entry); + if (clients_entry) + snd_info_unregister(clients_entry); + if (timer_entry) + snd_info_unregister(timer_entry); return 0; } -#endif diff --git a/trunk/sound/core/seq/seq_info.h b/trunk/sound/core/seq/seq_info.h index 4892a7f35c08..efd099a858e4 100644 --- a/trunk/sound/core/seq/seq_info.h +++ b/trunk/sound/core/seq/seq_info.h @@ -24,17 +24,13 @@ #include <sound/info.h> #include <sound/seq_kernel.h> -void snd_seq_info_clients_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); -void snd_seq_info_timer_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); -void snd_seq_info_queues_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); +void snd_seq_info_clients_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer); +void snd_seq_info_timer_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer); +void snd_seq_info_queues_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer); -#ifdef CONFIG_PROC_FS int snd_seq_info_init( void ); int snd_seq_info_done( void ); -#else -static inline int snd_seq_info_init(void) { return 0; } -static inline int snd_seq_info_done(void) { return 0; } -#endif + #endif diff --git a/trunk/sound/core/seq/seq_instr.c b/trunk/sound/core/seq/seq_instr.c index 487452063965..1d525b13ebb6 100644 --- a/trunk/sound/core/seq/seq_instr.c +++ b/trunk/sound/core/seq/seq_instr.c @@ -31,7 +31,7 @@ MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer instrument libra MODULE_LICENSE("GPL"); -static void snd_instr_lock_ops(struct snd_seq_kinstr_list *list) +static void snd_instr_lock_ops(snd_seq_kinstr_list_t *list) { if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) { spin_lock_irqsave(&list->ops_lock, list->ops_flags); @@ -40,7 +40,7 @@ static void snd_instr_lock_ops(struct snd_seq_kinstr_list *list) } } -static void snd_instr_unlock_ops(struct snd_seq_kinstr_list *list) +static void snd_instr_unlock_ops(snd_seq_kinstr_list_t *list) { if (!(list->flags & SNDRV_SEQ_INSTR_FLG_DIRECT)) { spin_unlock_irqrestore(&list->ops_lock, list->ops_flags); @@ -49,18 +49,18 @@ static void snd_instr_unlock_ops(struct snd_seq_kinstr_list *list) } } -static struct snd_seq_kinstr *snd_seq_instr_new(int add_len, int atomic) +static snd_seq_kinstr_t *snd_seq_instr_new(int add_len, int atomic) { - struct snd_seq_kinstr *instr; + snd_seq_kinstr_t *instr; - instr = kzalloc(sizeof(struct snd_seq_kinstr) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL); + instr = kzalloc(sizeof(snd_seq_kinstr_t) + add_len, atomic ? GFP_ATOMIC : GFP_KERNEL); if (instr == NULL) return NULL; instr->add_len = add_len; return instr; } -static int snd_seq_instr_free(struct snd_seq_kinstr *instr, int atomic) +static int snd_seq_instr_free(snd_seq_kinstr_t *instr, int atomic) { int result = 0; @@ -73,11 +73,11 @@ static int snd_seq_instr_free(struct snd_seq_kinstr *instr, int atomic) return result; } -struct snd_seq_kinstr_list *snd_seq_instr_list_new(void) +snd_seq_kinstr_list_t *snd_seq_instr_list_new(void) { - struct snd_seq_kinstr_list *list; + snd_seq_kinstr_list_t *list; - list = kzalloc(sizeof(struct snd_seq_kinstr_list), GFP_KERNEL); + list = kzalloc(sizeof(snd_seq_kinstr_list_t), GFP_KERNEL); if (list == NULL) return NULL; spin_lock_init(&list->lock); @@ -87,11 +87,11 @@ struct snd_seq_kinstr_list *snd_seq_instr_list_new(void) return list; } -void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list_ptr) +void snd_seq_instr_list_free(snd_seq_kinstr_list_t **list_ptr) { - struct snd_seq_kinstr_list *list; - struct snd_seq_kinstr *instr; - struct snd_seq_kcluster *cluster; + snd_seq_kinstr_list_t *list; + snd_seq_kinstr_t *instr; + snd_seq_kcluster_t *cluster; int idx; unsigned long flags; @@ -125,8 +125,8 @@ void snd_seq_instr_list_free(struct snd_seq_kinstr_list **list_ptr) kfree(list); } -static int instr_free_compare(struct snd_seq_kinstr *instr, - struct snd_seq_instr_header *ifree, +static int instr_free_compare(snd_seq_kinstr_t *instr, + snd_seq_instr_header_t *ifree, unsigned int client) { switch (ifree->cmd) { @@ -160,12 +160,12 @@ static int instr_free_compare(struct snd_seq_kinstr *instr, return 1; } -int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list, - struct snd_seq_instr_header *ifree, +int snd_seq_instr_list_free_cond(snd_seq_kinstr_list_t *list, + snd_seq_instr_header_t *ifree, int client, int atomic) { - struct snd_seq_kinstr *instr, *prev, *next, *flist; + snd_seq_kinstr_t *instr, *prev, *next, *flist; int idx; unsigned long flags; @@ -209,7 +209,7 @@ int snd_seq_instr_list_free_cond(struct snd_seq_kinstr_list *list, return 0; } -static int compute_hash_instr_key(struct snd_seq_instr *instr) +static int compute_hash_instr_key(snd_seq_instr_t *instr) { int result; @@ -233,7 +233,7 @@ static int compute_hash_cluster_key(snd_seq_instr_cluster_t cluster) } #endif -static int compare_instr(struct snd_seq_instr *i1, struct snd_seq_instr *i2, int exact) +static int compare_instr(snd_seq_instr_t *i1, snd_seq_instr_t *i2, int exact) { if (exact) { if (i1->cluster != i2->cluster || @@ -262,14 +262,14 @@ static int compare_instr(struct snd_seq_instr *i1, struct snd_seq_instr *i2, int } } -struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list, - struct snd_seq_instr *instr, - int exact, - int follow_alias) +snd_seq_kinstr_t *snd_seq_instr_find(snd_seq_kinstr_list_t *list, + snd_seq_instr_t *instr, + int exact, + int follow_alias) { unsigned long flags; int depth = 0; - struct snd_seq_kinstr *result; + snd_seq_kinstr_t *result; if (list == NULL || instr == NULL) return NULL; @@ -279,7 +279,7 @@ struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list, while (result) { if (!compare_instr(&result->instr, instr, exact)) { if (follow_alias && (result->type == SNDRV_SEQ_INSTR_ATYPE_ALIAS)) { - instr = (struct snd_seq_instr *)KINSTR_DATA(result); + instr = (snd_seq_instr_t *)KINSTR_DATA(result); if (++depth > 10) goto __not_found; goto __again; @@ -295,8 +295,8 @@ struct snd_seq_kinstr *snd_seq_instr_find(struct snd_seq_kinstr_list *list, return NULL; } -void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list, - struct snd_seq_kinstr *instr) +void snd_seq_instr_free_use(snd_seq_kinstr_list_t *list, + snd_seq_kinstr_t *instr) { unsigned long flags; @@ -311,8 +311,7 @@ void snd_seq_instr_free_use(struct snd_seq_kinstr_list *list, spin_unlock_irqrestore(&list->lock, flags); } -static struct snd_seq_kinstr_ops *instr_ops(struct snd_seq_kinstr_ops *ops, - char *instr_type) +static snd_seq_kinstr_ops_t *instr_ops(snd_seq_kinstr_ops_t *ops, char *instr_type) { while (ops) { if (!strcmp(ops->instr_type, instr_type)) @@ -322,11 +321,11 @@ static struct snd_seq_kinstr_ops *instr_ops(struct snd_seq_kinstr_ops *ops, return NULL; } -static int instr_result(struct snd_seq_event *ev, +static int instr_result(snd_seq_event_t *ev, int type, int result, int atomic) { - struct snd_seq_event sev; + snd_seq_event_t sev; memset(&sev, 0, sizeof(sev)); sev.type = SNDRV_SEQ_EVENT_RESULT; @@ -346,9 +345,9 @@ static int instr_result(struct snd_seq_event *ev, return snd_seq_kernel_client_dispatch(sev.source.client, &sev, atomic, 0); } -static int instr_begin(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_begin(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { unsigned long flags; @@ -363,9 +362,9 @@ static int instr_begin(struct snd_seq_kinstr_ops *ops, return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_BEGIN, 0, atomic); } -static int instr_end(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_end(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { unsigned long flags; @@ -381,55 +380,54 @@ static int instr_end(struct snd_seq_kinstr_ops *ops, return instr_result(ev, SNDRV_SEQ_EVENT_INSTR_END, -EINVAL, atomic); } -static int instr_info(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_info(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { return -ENXIO; } -static int instr_format_info(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_format_info(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { return -ENXIO; } -static int instr_reset(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_reset(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { return -ENXIO; } -static int instr_status(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_status(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { return -ENXIO; } -static int instr_put(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_put(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { unsigned long flags; - struct snd_seq_instr_header put; - struct snd_seq_kinstr *instr; + snd_seq_instr_header_t put; + snd_seq_kinstr_t *instr; int result = -EINVAL, len, key; if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR) goto __return; - if (ev->data.ext.len < sizeof(struct snd_seq_instr_header)) + if (ev->data.ext.len < sizeof(snd_seq_instr_header_t)) goto __return; - if (copy_from_user(&put, (void __user *)ev->data.ext.ptr, - sizeof(struct snd_seq_instr_header))) { + if (copy_from_user(&put, (void __user *)ev->data.ext.ptr, sizeof(snd_seq_instr_header_t))) { result = -EFAULT; goto __return; } @@ -451,7 +449,7 @@ static int instr_put(struct snd_seq_kinstr_ops *ops, } len = ops->add_len; if (put.data.type == SNDRV_SEQ_INSTR_ATYPE_ALIAS) - len = sizeof(struct snd_seq_instr); + len = sizeof(snd_seq_instr_t); instr = snd_seq_instr_new(len, atomic); if (instr == NULL) { snd_instr_unlock_ops(list); @@ -465,8 +463,8 @@ static int instr_put(struct snd_seq_kinstr_ops *ops, if (instr->type == SNDRV_SEQ_INSTR_ATYPE_DATA) { result = ops->put(ops->private_data, instr, - (void __user *)ev->data.ext.ptr + sizeof(struct snd_seq_instr_header), - ev->data.ext.len - sizeof(struct snd_seq_instr_header), + (void __user *)ev->data.ext.ptr + sizeof(snd_seq_instr_header_t), + ev->data.ext.len - sizeof(snd_seq_instr_header_t), atomic, put.cmd); if (result < 0) { @@ -488,21 +486,21 @@ static int instr_put(struct snd_seq_kinstr_ops *ops, return result; } -static int instr_get(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_get(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { return -ENXIO; } -static int instr_free(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_free(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { - struct snd_seq_instr_header ifree; - struct snd_seq_kinstr *instr, *prev; + snd_seq_instr_header_t ifree; + snd_seq_kinstr_t *instr, *prev; int result = -EINVAL; unsigned long flags; unsigned int hash; @@ -510,10 +508,9 @@ static int instr_free(struct snd_seq_kinstr_ops *ops, if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARUSR) goto __return; - if (ev->data.ext.len < sizeof(struct snd_seq_instr_header)) + if (ev->data.ext.len < sizeof(snd_seq_instr_header_t)) goto __return; - if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr, - sizeof(struct snd_seq_instr_header))) { + if (copy_from_user(&ifree, (void __user *)ev->data.ext.ptr, sizeof(snd_seq_instr_header_t))) { result = -EFAULT; goto __return; } @@ -551,8 +548,7 @@ static int instr_free(struct snd_seq_kinstr_ops *ops, list->hash[hash] = instr->next; } if (instr->ops && instr->ops->notify) - instr->ops->notify(instr->ops->private_data, instr, - SNDRV_SEQ_INSTR_NOTIFY_REMOVE); + instr->ops->notify(instr->ops->private_data, instr, SNDRV_SEQ_INSTR_NOTIFY_REMOVE); while (instr->use) { spin_unlock_irqrestore(&list->lock, flags); schedule_timeout_interruptible(1); @@ -569,25 +565,25 @@ static int instr_free(struct snd_seq_kinstr_ops *ops, return result; } -static int instr_list(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_list(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { return -ENXIO; } -static int instr_cluster(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +static int instr_cluster(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int atomic, int hop) { return -ENXIO; } -int snd_seq_instr_event(struct snd_seq_kinstr_ops *ops, - struct snd_seq_kinstr_list *list, - struct snd_seq_event *ev, +int snd_seq_instr_event(snd_seq_kinstr_ops_t *ops, + snd_seq_kinstr_list_t *list, + snd_seq_event_t *ev, int client, int atomic, int hop) diff --git a/trunk/sound/core/seq/seq_memory.c b/trunk/sound/core/seq/seq_memory.c index 9ee6c177db0c..8416bcffa091 100644 --- a/trunk/sound/core/seq/seq_memory.c +++ b/trunk/sound/core/seq/seq_memory.c @@ -36,12 +36,12 @@ #define semaphore_of(fp) ((fp)->f_dentry->d_inode->i_sem) -static inline int snd_seq_pool_available(struct snd_seq_pool *pool) +static inline int snd_seq_pool_available(pool_t *pool) { return pool->total_elements - atomic_read(&pool->counter); } -static inline int snd_seq_output_ok(struct snd_seq_pool *pool) +static inline int snd_seq_output_ok(pool_t *pool) { return snd_seq_pool_available(pool) >= pool->room; } @@ -72,7 +72,7 @@ static inline int snd_seq_output_ok(struct snd_seq_pool *pool) * call dump function to expand external data. */ -static int get_var_len(const struct snd_seq_event *event) +static int get_var_len(const snd_seq_event_t *event) { if ((event->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE) return -EINVAL; @@ -80,11 +80,10 @@ static int get_var_len(const struct snd_seq_event *event) return event->data.ext.len & ~SNDRV_SEQ_EXT_MASK; } -int snd_seq_dump_var_event(const struct snd_seq_event *event, - snd_seq_dump_func_t func, void *private_data) +int snd_seq_dump_var_event(const snd_seq_event_t *event, snd_seq_dump_func_t func, void *private_data) { int len, err; - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; if ((len = get_var_len(event)) <= 0) return len; @@ -109,9 +108,9 @@ int snd_seq_dump_var_event(const struct snd_seq_event *event, return func(private_data, event->data.ext.ptr, len); } - cell = (struct snd_seq_event_cell *)event->data.ext.ptr; + cell = (snd_seq_event_cell_t*)event->data.ext.ptr; for (; len > 0 && cell; cell = cell->next) { - int size = sizeof(struct snd_seq_event); + int size = sizeof(snd_seq_event_t); if (len < size) size = len; err = func(private_data, &cell->event, size); @@ -143,8 +142,7 @@ static int seq_copy_in_user(char __user **bufptr, const void *src, int size) return 0; } -int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char *buf, - int in_kernel, int size_aligned) +int snd_seq_expand_var_event(const snd_seq_event_t *event, int count, char *buf, int in_kernel, int size_aligned) { int len, newlen; int err; @@ -176,18 +174,17 @@ int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char * release this cell, free extended data if available */ -static inline void free_cell(struct snd_seq_pool *pool, - struct snd_seq_event_cell *cell) +static inline void free_cell(pool_t *pool, snd_seq_event_cell_t *cell) { cell->next = pool->free; pool->free = cell; atomic_dec(&pool->counter); } -void snd_seq_cell_free(struct snd_seq_event_cell * cell) +void snd_seq_cell_free(snd_seq_event_cell_t * cell) { unsigned long flags; - struct snd_seq_pool *pool; + pool_t *pool; snd_assert(cell != NULL, return); pool = cell->pool; @@ -197,7 +194,7 @@ void snd_seq_cell_free(struct snd_seq_event_cell * cell) free_cell(pool, cell); if (snd_seq_ev_is_variable(&cell->event)) { if (cell->event.data.ext.len & SNDRV_SEQ_EXT_CHAINED) { - struct snd_seq_event_cell *curp, *nextptr; + snd_seq_event_cell_t *curp, *nextptr; curp = cell->event.data.ext.ptr; for (; curp; curp = nextptr) { nextptr = curp->next; @@ -218,11 +215,9 @@ void snd_seq_cell_free(struct snd_seq_event_cell * cell) /* * allocate an event cell. */ -static int snd_seq_cell_alloc(struct snd_seq_pool *pool, - struct snd_seq_event_cell **cellp, - int nonblock, struct file *file) +static int snd_seq_cell_alloc(pool_t *pool, snd_seq_event_cell_t **cellp, int nonblock, struct file *file) { - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; unsigned long flags; int err = -EAGAIN; wait_queue_t wait; @@ -285,13 +280,11 @@ static int snd_seq_cell_alloc(struct snd_seq_pool *pool, * if the event has external data, the data is decomposed to additional * cells. */ -int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event, - struct snd_seq_event_cell **cellp, int nonblock, - struct file *file) +int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t **cellp, int nonblock, struct file *file) { int ncells, err; unsigned int extlen; - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; *cellp = NULL; @@ -299,7 +292,7 @@ int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event, extlen = 0; if (snd_seq_ev_is_variable(event)) { extlen = event->data.ext.len & ~SNDRV_SEQ_EXT_MASK; - ncells = (extlen + sizeof(struct snd_seq_event) - 1) / sizeof(struct snd_seq_event); + ncells = (extlen + sizeof(snd_seq_event_t) - 1) / sizeof(snd_seq_event_t); } if (ncells >= pool->total_elements) return -ENOMEM; @@ -316,18 +309,18 @@ int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event, int len = extlen; int is_chained = event->data.ext.len & SNDRV_SEQ_EXT_CHAINED; int is_usrptr = event->data.ext.len & SNDRV_SEQ_EXT_USRPTR; - struct snd_seq_event_cell *src, *tmp, *tail; + snd_seq_event_cell_t *src, *tmp, *tail; char *buf; cell->event.data.ext.len = extlen | SNDRV_SEQ_EXT_CHAINED; cell->event.data.ext.ptr = NULL; - src = (struct snd_seq_event_cell *)event->data.ext.ptr; + src = (snd_seq_event_cell_t*)event->data.ext.ptr; buf = (char *)event->data.ext.ptr; tail = NULL; while (ncells-- > 0) { - int size = sizeof(struct snd_seq_event); + int size = sizeof(snd_seq_event_t); if (len < size) size = len; err = snd_seq_cell_alloc(pool, &tmp, nonblock, file); @@ -365,8 +358,7 @@ int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event, /* poll wait */ -int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file, - poll_table *wait) +int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait) { poll_wait(file, &pool->output_sleep, wait); return snd_seq_output_ok(pool); @@ -374,17 +366,17 @@ int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file, /* allocate room specified number of events */ -int snd_seq_pool_init(struct snd_seq_pool *pool) +int snd_seq_pool_init(pool_t *pool) { int cell; - struct snd_seq_event_cell *cellptr; + snd_seq_event_cell_t *cellptr; unsigned long flags; snd_assert(pool != NULL, return -EINVAL); if (pool->ptr) /* should be atomic? */ return 0; - pool->ptr = vmalloc(sizeof(struct snd_seq_event_cell) * pool->size); + pool->ptr = vmalloc(sizeof(snd_seq_event_cell_t) * pool->size); if (pool->ptr == NULL) { snd_printd("seq: malloc for sequencer events failed\n"); return -ENOMEM; @@ -410,10 +402,10 @@ int snd_seq_pool_init(struct snd_seq_pool *pool) } /* remove events */ -int snd_seq_pool_done(struct snd_seq_pool *pool) +int snd_seq_pool_done(pool_t *pool) { unsigned long flags; - struct snd_seq_event_cell *ptr; + snd_seq_event_cell_t *ptr; int max_count = 5 * HZ; snd_assert(pool != NULL, return -EINVAL); @@ -454,9 +446,9 @@ int snd_seq_pool_done(struct snd_seq_pool *pool) /* init new memory pool */ -struct snd_seq_pool *snd_seq_pool_new(int poolsize) +pool_t *snd_seq_pool_new(int poolsize) { - struct snd_seq_pool *pool; + pool_t *pool; /* create pool block */ pool = kzalloc(sizeof(*pool), GFP_KERNEL); @@ -480,9 +472,9 @@ struct snd_seq_pool *snd_seq_pool_new(int poolsize) } /* remove memory pool */ -int snd_seq_pool_delete(struct snd_seq_pool **ppool) +int snd_seq_pool_delete(pool_t **ppool) { - struct snd_seq_pool *pool = *ppool; + pool_t *pool = *ppool; *ppool = NULL; if (pool == NULL) @@ -505,8 +497,7 @@ void __exit snd_sequencer_memory_done(void) /* exported to seq_clientmgr.c */ -void snd_seq_info_pool(struct snd_info_buffer *buffer, - struct snd_seq_pool *pool, char *space) +void snd_seq_info_pool(snd_info_buffer_t * buffer, pool_t *pool, char *space) { if (pool == NULL) return; diff --git a/trunk/sound/core/seq/seq_memory.h b/trunk/sound/core/seq/seq_memory.h index 39c60d9e1efc..6c4dde5d3d6f 100644 --- a/trunk/sound/core/seq/seq_memory.h +++ b/trunk/sound/core/seq/seq_memory.h @@ -24,21 +24,23 @@ #include <sound/seq_kernel.h> #include <linux/poll.h> +typedef struct pool pool_t; + /* container for sequencer event (internal use) */ -struct snd_seq_event_cell { - struct snd_seq_event event; - struct snd_seq_pool *pool; /* used pool */ - struct snd_seq_event_cell *next; /* next cell */ -}; +typedef struct snd_seq_event_cell_t { + snd_seq_event_t event; + pool_t *pool; /* used pool */ + struct snd_seq_event_cell_t *next; /* next cell */ +} snd_seq_event_cell_t; /* design note: the pool is a contigious block of memory, if we dynamicly want to add additional cells to the pool be better store this in another pool as we need to know the base address of the pool when releasing memory. */ -struct snd_seq_pool { - struct snd_seq_event_cell *ptr; /* pointer to first event chunk */ - struct snd_seq_event_cell *free; /* pointer to the head of the free list */ +struct pool { + snd_seq_event_cell_t *ptr; /* pointer to first event chunk */ + snd_seq_event_cell_t *free; /* pointer to the head of the free list */ int total_elements; /* pool size actually allocated */ atomic_t counter; /* cells free */ @@ -61,34 +63,33 @@ struct snd_seq_pool { spinlock_t lock; }; -void snd_seq_cell_free(struct snd_seq_event_cell *cell); +extern void snd_seq_cell_free(snd_seq_event_cell_t* cell); -int snd_seq_event_dup(struct snd_seq_pool *pool, struct snd_seq_event *event, - struct snd_seq_event_cell **cellp, int nonblock, struct file *file); +int snd_seq_event_dup(pool_t *pool, snd_seq_event_t *event, snd_seq_event_cell_t **cellp, int nonblock, struct file *file); /* return number of unused (free) cells */ -static inline int snd_seq_unused_cells(struct snd_seq_pool *pool) +static inline int snd_seq_unused_cells(pool_t *pool) { return pool ? pool->total_elements - atomic_read(&pool->counter) : 0; } /* return total number of allocated cells */ -static inline int snd_seq_total_cells(struct snd_seq_pool *pool) +static inline int snd_seq_total_cells(pool_t *pool) { return pool ? pool->total_elements : 0; } /* init pool - allocate events */ -int snd_seq_pool_init(struct snd_seq_pool *pool); +int snd_seq_pool_init(pool_t *pool); /* done pool - free events */ -int snd_seq_pool_done(struct snd_seq_pool *pool); +int snd_seq_pool_done(pool_t *pool); /* create pool */ -struct snd_seq_pool *snd_seq_pool_new(int poolsize); +pool_t *snd_seq_pool_new(int poolsize); /* remove pool */ -int snd_seq_pool_delete(struct snd_seq_pool **pool); +int snd_seq_pool_delete(pool_t **pool); /* init memory */ int snd_sequencer_memory_init(void); @@ -97,7 +98,7 @@ int snd_sequencer_memory_init(void); void snd_sequencer_memory_done(void); /* polling */ -int snd_seq_pool_poll_wait(struct snd_seq_pool *pool, struct file *file, poll_table *wait); +int snd_seq_pool_poll_wait(pool_t *pool, struct file *file, poll_table *wait); #endif diff --git a/trunk/sound/core/seq/seq_midi.c b/trunk/sound/core/seq/seq_midi.c index ce0df86157de..f89f40f44876 100644 --- a/trunk/sound/core/seq/seq_midi.c +++ b/trunk/sound/core/seq/seq_midi.c @@ -51,40 +51,40 @@ module_param(input_buffer_size, int, 0644); MODULE_PARM_DESC(input_buffer_size, "Input buffer size in bytes."); /* data for this midi synth driver */ -struct seq_midisynth { - struct snd_card *card; +typedef struct { + snd_card_t *card; int device; int subdevice; - struct snd_rawmidi_file input_rfile; - struct snd_rawmidi_file output_rfile; + snd_rawmidi_file_t input_rfile; + snd_rawmidi_file_t output_rfile; int seq_client; int seq_port; - struct snd_midi_event *parser; -}; + snd_midi_event_t *parser; +} seq_midisynth_t; -struct seq_midisynth_client { +typedef struct { int seq_client; int num_ports; int ports_per_device[SNDRV_RAWMIDI_DEVICES]; - struct seq_midisynth *ports[SNDRV_RAWMIDI_DEVICES]; -}; + seq_midisynth_t *ports[SNDRV_RAWMIDI_DEVICES]; +} seq_midisynth_client_t; -static struct seq_midisynth_client *synths[SNDRV_CARDS]; +static seq_midisynth_client_t *synths[SNDRV_CARDS]; static DECLARE_MUTEX(register_mutex); /* handle rawmidi input event (MIDI v1.0 stream) */ -static void snd_midi_input_event(struct snd_rawmidi_substream *substream) +static void snd_midi_input_event(snd_rawmidi_substream_t * substream) { - struct snd_rawmidi_runtime *runtime; - struct seq_midisynth *msynth; - struct snd_seq_event ev; + snd_rawmidi_runtime_t *runtime; + seq_midisynth_t *msynth; + snd_seq_event_t ev; char buf[16], *pbuf; long res, count; if (substream == NULL) return; runtime = substream->runtime; - msynth = runtime->private_data; + msynth = (seq_midisynth_t *) runtime->private_data; if (msynth == NULL) return; memset(&ev, 0, sizeof(ev)); @@ -112,9 +112,9 @@ static void snd_midi_input_event(struct snd_rawmidi_substream *substream) } } -static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, int count) +static int dump_midi(snd_rawmidi_substream_t *substream, const char *buf, int count) { - struct snd_rawmidi_runtime *runtime; + snd_rawmidi_runtime_t *runtime; int tmp; snd_assert(substream != NULL || buf != NULL, return -EINVAL); @@ -128,12 +128,12 @@ static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, i return 0; } -static int event_process_midi(struct snd_seq_event *ev, int direct, +static int event_process_midi(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop) { - struct seq_midisynth *msynth = private_data; + seq_midisynth_t *msynth = (seq_midisynth_t *) private_data; unsigned char msg[10]; /* buffer for constructing midi messages */ - struct snd_rawmidi_substream *substream; + snd_rawmidi_substream_t *substream; int len; snd_assert(msynth != NULL, return -EINVAL); @@ -161,8 +161,8 @@ static int event_process_midi(struct snd_seq_event *ev, int direct, } -static int snd_seq_midisynth_new(struct seq_midisynth *msynth, - struct snd_card *card, +static int snd_seq_midisynth_new(seq_midisynth_t *msynth, + snd_card_t *card, int device, int subdevice) { @@ -175,18 +175,15 @@ static int snd_seq_midisynth_new(struct seq_midisynth *msynth, } /* open associated midi device for input */ -static int midisynth_subscribe(void *private_data, struct snd_seq_port_subscribe *info) +static int midisynth_subscribe(void *private_data, snd_seq_port_subscribe_t *info) { int err; - struct seq_midisynth *msynth = private_data; - struct snd_rawmidi_runtime *runtime; - struct snd_rawmidi_params params; + seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; + snd_rawmidi_runtime_t *runtime; + snd_rawmidi_params_t params; /* open midi port */ - if ((err = snd_rawmidi_kernel_open(msynth->card, msynth->device, - msynth->subdevice, - SNDRV_RAWMIDI_LFLG_INPUT, - &msynth->input_rfile)) < 0) { + if ((err = snd_rawmidi_kernel_open(msynth->card->number, msynth->device, msynth->subdevice, SNDRV_RAWMIDI_LFLG_INPUT, &msynth->input_rfile)) < 0) { snd_printd("midi input open failed!!!\n"); return err; } @@ -206,10 +203,10 @@ static int midisynth_subscribe(void *private_data, struct snd_seq_port_subscribe } /* close associated midi device for input */ -static int midisynth_unsubscribe(void *private_data, struct snd_seq_port_subscribe *info) +static int midisynth_unsubscribe(void *private_data, snd_seq_port_subscribe_t *info) { int err; - struct seq_midisynth *msynth = private_data; + seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; snd_assert(msynth->input_rfile.input != NULL, return -EINVAL); err = snd_rawmidi_kernel_release(&msynth->input_rfile); @@ -217,17 +214,14 @@ static int midisynth_unsubscribe(void *private_data, struct snd_seq_port_subscri } /* open associated midi device for output */ -static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info) +static int midisynth_use(void *private_data, snd_seq_port_subscribe_t *info) { int err; - struct seq_midisynth *msynth = private_data; - struct snd_rawmidi_params params; + seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; + snd_rawmidi_params_t params; /* open midi port */ - if ((err = snd_rawmidi_kernel_open(msynth->card, msynth->device, - msynth->subdevice, - SNDRV_RAWMIDI_LFLG_OUTPUT, - &msynth->output_rfile)) < 0) { + if ((err = snd_rawmidi_kernel_open(msynth->card->number, msynth->device, msynth->subdevice, SNDRV_RAWMIDI_LFLG_OUTPUT, &msynth->output_rfile)) < 0) { snd_printd("midi output open failed!!!\n"); return err; } @@ -243,9 +237,9 @@ static int midisynth_use(void *private_data, struct snd_seq_port_subscribe *info } /* close associated midi device for output */ -static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *info) +static int midisynth_unuse(void *private_data, snd_seq_port_subscribe_t *info) { - struct seq_midisynth *msynth = private_data; + seq_midisynth_t *msynth = (seq_midisynth_t *)private_data; unsigned char buf = 0xff; /* MIDI reset */ snd_assert(msynth->output_rfile.output != NULL, return -EINVAL); @@ -256,7 +250,7 @@ static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *in } /* delete given midi synth port */ -static void snd_seq_midisynth_delete(struct seq_midisynth *msynth) +static void snd_seq_midisynth_delete(seq_midisynth_t *msynth) { if (msynth == NULL) return; @@ -270,18 +264,34 @@ static void snd_seq_midisynth_delete(struct seq_midisynth *msynth) snd_midi_event_free(msynth->parser); } +/* set our client name */ +static int set_client_name(seq_midisynth_client_t *client, snd_card_t *card, + snd_rawmidi_info_t *rmidi) +{ + snd_seq_client_info_t cinfo; + const char *name; + + memset(&cinfo, 0, sizeof(cinfo)); + cinfo.client = client->seq_client; + cinfo.type = KERNEL_CLIENT; + name = rmidi->name[0] ? (const char *)rmidi->name : "External MIDI"; + strlcpy(cinfo.name, name, sizeof(cinfo.name)); + return snd_seq_kernel_client_ctl(client->seq_client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); +} + /* register new midi synth port */ static int -snd_seq_midisynth_register_port(struct snd_seq_device *dev) +snd_seq_midisynth_register_port(snd_seq_device_t *dev) { - struct seq_midisynth_client *client; - struct seq_midisynth *msynth, *ms; - struct snd_seq_port_info *port; - struct snd_rawmidi_info *info; + seq_midisynth_client_t *client; + seq_midisynth_t *msynth, *ms; + snd_seq_port_info_t *port; + snd_rawmidi_info_t *info; int newclient = 0; unsigned int p, ports; - struct snd_seq_port_callback pcallbacks; - struct snd_card *card = dev->card; + snd_seq_client_callback_t callbacks; + snd_seq_port_callback_t pcallbacks; + snd_card_t *card = dev->card; int device = dev->device; unsigned int input_count = 0, output_count = 0; @@ -318,19 +328,21 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev) kfree(info); return -ENOMEM; } - client->seq_client = - snd_seq_create_kernel_client( - card, 0, "%s", info->name[0] ? - (const char *)info->name : "External MIDI"); + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.private_data = client; + callbacks.allow_input = callbacks.allow_output = 1; + client->seq_client = snd_seq_create_kernel_client(card, 0, &callbacks); if (client->seq_client < 0) { kfree(client); up(®ister_mutex); kfree(info); return -ENOMEM; } - } + set_client_name(client, card, info); + } else if (device == 0) + set_client_name(client, card, info); /* use the first device's name */ - msynth = kcalloc(ports, sizeof(struct seq_midisynth), GFP_KERNEL); + msynth = kcalloc(ports, sizeof(seq_midisynth_t), GFP_KERNEL); port = kmalloc(sizeof(*port), GFP_KERNEL); if (msynth == NULL || port == NULL) goto __nomem; @@ -420,11 +432,11 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev) /* release midi synth port */ static int -snd_seq_midisynth_unregister_port(struct snd_seq_device *dev) +snd_seq_midisynth_unregister_port(snd_seq_device_t *dev) { - struct seq_midisynth_client *client; - struct seq_midisynth *msynth; - struct snd_card *card = dev->card; + seq_midisynth_client_t *client; + seq_midisynth_t *msynth; + snd_card_t *card = dev->card; int device = dev->device, p, ports; down(®ister_mutex); @@ -453,7 +465,7 @@ snd_seq_midisynth_unregister_port(struct snd_seq_device *dev) static int __init alsa_seq_midi_init(void) { - static struct snd_seq_dev_ops ops = { + static snd_seq_dev_ops_t ops = { snd_seq_midisynth_register_port, snd_seq_midisynth_unregister_port, }; diff --git a/trunk/sound/core/seq/seq_midi_emul.c b/trunk/sound/core/seq/seq_midi_emul.c index d7c4fb86b9eb..35fe8a7e34bf 100644 --- a/trunk/sound/core/seq/seq_midi_emul.c +++ b/trunk/sound/core/seq/seq_midi_emul.c @@ -44,25 +44,17 @@ MODULE_DESCRIPTION("Advanced Linux Sound Architecture sequencer MIDI emulation." MODULE_LICENSE("GPL"); /* Prototypes for static functions */ -static void note_off(struct snd_midi_op *ops, void *drv, - struct snd_midi_channel *chan, - int note, int vel); -static void do_control(struct snd_midi_op *ops, void *private, - struct snd_midi_channel_set *chset, - struct snd_midi_channel *chan, +static void note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int vel); +static void do_control(snd_midi_op_t *ops, void *private, + snd_midi_channel_set_t *chset, snd_midi_channel_t *chan, int control, int value); -static void rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset); -static void nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset); -static void sysex(struct snd_midi_op *ops, void *private, unsigned char *sysex, - int len, struct snd_midi_channel_set *chset); -static void all_sounds_off(struct snd_midi_op *ops, void *private, - struct snd_midi_channel *chan); -static void all_notes_off(struct snd_midi_op *ops, void *private, - struct snd_midi_channel *chan); -static void snd_midi_reset_controllers(struct snd_midi_channel *chan); -static void reset_all_channels(struct snd_midi_channel_set *chset); +static void rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset); +static void nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset); +static void sysex(snd_midi_op_t *ops, void *private, unsigned char *sysex, int len, snd_midi_channel_set_t *chset); +static void all_sounds_off(snd_midi_op_t *ops, void *private, snd_midi_channel_t *chan); +static void all_notes_off(snd_midi_op_t *ops, void *private, snd_midi_channel_t *chan); +static void snd_midi_reset_controllers(snd_midi_channel_t *chan); +static void reset_all_channels(snd_midi_channel_set_t *chset); /* @@ -80,11 +72,10 @@ static void reset_all_channels(struct snd_midi_channel_set *chset); * be interpreted. */ void -snd_midi_process_event(struct snd_midi_op *ops, - struct snd_seq_event *ev, - struct snd_midi_channel_set *chanset) +snd_midi_process_event(snd_midi_op_t *ops, + snd_seq_event_t *ev, snd_midi_channel_set_t *chanset) { - struct snd_midi_channel *chan; + snd_midi_channel_t *chan; void *drv; int dest_channel = 0; @@ -98,8 +89,7 @@ snd_midi_process_event(struct snd_midi_op *ops, if (snd_seq_ev_is_channel_type(ev)) { dest_channel = ev->data.note.channel; if (dest_channel >= chanset->max_channels) { - snd_printd("dest channel is %d, max is %d\n", - dest_channel, chanset->max_channels); + snd_printd("dest channel is %d, max is %d\n", dest_channel, chanset->max_channels); return; } } @@ -249,8 +239,7 @@ snd_midi_process_event(struct snd_midi_op *ops, * release note */ static void -note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, - int note, int vel) +note_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, int note, int vel) { if (chan->gm_hold) { /* Hold this note until pedal is turned off */ @@ -271,8 +260,8 @@ note_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, * events that need to take place immediately to the driver. */ static void -do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chset, - struct snd_midi_channel *chan, int control, int value) +do_control(snd_midi_op_t *ops, void *drv, snd_midi_channel_set_t *chset, + snd_midi_channel_t *chan, int control, int value) { int i; @@ -387,7 +376,7 @@ do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chse * initialize the MIDI status */ void -snd_midi_channel_set_clear(struct snd_midi_channel_set *chset) +snd_midi_channel_set_clear(snd_midi_channel_set_t *chset) { int i; @@ -395,7 +384,7 @@ snd_midi_channel_set_clear(struct snd_midi_channel_set *chset) chset->gs_master_volume = 127; for (i = 0; i < chset->max_channels; i++) { - struct snd_midi_channel *chan = chset->channels + i; + snd_midi_channel_t *chan = chset->channels + i; memset(chan->note, 0, sizeof(chan->note)); chan->midi_aftertouch = 0; @@ -418,8 +407,8 @@ snd_midi_channel_set_clear(struct snd_midi_channel_set *chset) * Process a rpn message. */ static void -rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset) +rpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, + snd_midi_channel_set_t *chset) { int type; int val; @@ -458,8 +447,8 @@ rpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, * Process an nrpn message. */ static void -nrpn(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset) +nrpn(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan, + snd_midi_channel_set_t *chset) { /* parse XG NRPNs here if possible */ if (ops->nrpn) @@ -486,8 +475,7 @@ get_channel(unsigned char cmd) * Process a sysex message. */ static void -sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len, - struct snd_midi_channel_set *chset) +sysex(snd_midi_op_t *ops, void *private, unsigned char *buf, int len, snd_midi_channel_set_t *chset) { /* GM on */ static unsigned char gm_on_macro[] = { @@ -600,7 +588,7 @@ sysex(struct snd_midi_op *ops, void *private, unsigned char *buf, int len, * all sound off */ static void -all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan) +all_sounds_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) { int n; @@ -618,7 +606,7 @@ all_sounds_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan * all notes off */ static void -all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan) +all_notes_off(snd_midi_op_t *ops, void *drv, snd_midi_channel_t *chan) { int n; @@ -633,12 +621,12 @@ all_notes_off(struct snd_midi_op *ops, void *drv, struct snd_midi_channel *chan) /* * Initialise a single midi channel control block. */ -static void snd_midi_channel_init(struct snd_midi_channel *p, int n) +static void snd_midi_channel_init(snd_midi_channel_t *p, int n) { if (p == NULL) return; - memset(p, 0, sizeof(struct snd_midi_channel)); + memset(p, 0, sizeof(snd_midi_channel_t)); p->private = NULL; p->number = n; @@ -654,12 +642,12 @@ static void snd_midi_channel_init(struct snd_midi_channel *p, int n) /* * Allocate and initialise a set of midi channel control blocks. */ -static struct snd_midi_channel *snd_midi_channel_init_set(int n) +static snd_midi_channel_t *snd_midi_channel_init_set(int n) { - struct snd_midi_channel *chan; + snd_midi_channel_t *chan; int i; - chan = kmalloc(n * sizeof(struct snd_midi_channel), GFP_KERNEL); + chan = kmalloc(n * sizeof(snd_midi_channel_t), GFP_KERNEL); if (chan) { for (i = 0; i < n; i++) snd_midi_channel_init(chan+i, i); @@ -672,11 +660,11 @@ static struct snd_midi_channel *snd_midi_channel_init_set(int n) * reset all midi channels */ static void -reset_all_channels(struct snd_midi_channel_set *chset) +reset_all_channels(snd_midi_channel_set_t *chset) { int ch; for (ch = 0; ch < chset->max_channels; ch++) { - struct snd_midi_channel *chan = chset->channels + ch; + snd_midi_channel_t *chan = chset->channels + ch; snd_midi_reset_controllers(chan); chan->gm_rpn_pitch_bend_range = 256; /* 2 semitones */ chan->gm_rpn_fine_tuning = 0; @@ -693,9 +681,9 @@ reset_all_channels(struct snd_midi_channel_set *chset) /* * Allocate and initialise a midi channel set. */ -struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n) +snd_midi_channel_set_t *snd_midi_channel_alloc_set(int n) { - struct snd_midi_channel_set *chset; + snd_midi_channel_set_t *chset; chset = kmalloc(sizeof(*chset), GFP_KERNEL); if (chset) { @@ -709,7 +697,7 @@ struct snd_midi_channel_set *snd_midi_channel_alloc_set(int n) /* * Reset the midi controllers on a particular channel to default values. */ -static void snd_midi_reset_controllers(struct snd_midi_channel *chan) +static void snd_midi_reset_controllers(snd_midi_channel_t *chan) { memset(chan->control, 0, sizeof(chan->control)); chan->gm_volume = 127; @@ -721,7 +709,7 @@ static void snd_midi_reset_controllers(struct snd_midi_channel *chan) /* * Free a midi channel set. */ -void snd_midi_channel_free_set(struct snd_midi_channel_set *chset) +void snd_midi_channel_free_set(snd_midi_channel_set_t *chset) { if (chset == NULL) return; diff --git a/trunk/sound/core/seq/seq_midi_event.c b/trunk/sound/core/seq/seq_midi_event.c index 5ff80b776906..2dc1aecfb426 100644 --- a/trunk/sound/core/seq/seq_midi_event.c +++ b/trunk/sound/core/seq/seq_midi_event.c @@ -41,29 +41,33 @@ MODULE_LICENSE("GPL"); /* from 8 to 15 are events for 0xf0-0xf7 */ +/* status event types */ +typedef void (*event_encode_t)(snd_midi_event_t *dev, snd_seq_event_t *ev); +typedef void (*event_decode_t)(snd_seq_event_t *ev, unsigned char *buf); + /* * prototypes */ -static void note_event(struct snd_midi_event *dev, struct snd_seq_event *ev); -static void one_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev); -static void pitchbend_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev); -static void two_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev); -static void one_param_event(struct snd_midi_event *dev, struct snd_seq_event *ev); -static void songpos_event(struct snd_midi_event *dev, struct snd_seq_event *ev); -static void note_decode(struct snd_seq_event *ev, unsigned char *buf); -static void one_param_decode(struct snd_seq_event *ev, unsigned char *buf); -static void pitchbend_decode(struct snd_seq_event *ev, unsigned char *buf); -static void two_param_decode(struct snd_seq_event *ev, unsigned char *buf); -static void songpos_decode(struct snd_seq_event *ev, unsigned char *buf); +static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev); +static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev); +static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev); +static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev); +static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev); +static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev); +static void note_decode(snd_seq_event_t *ev, unsigned char *buf); +static void one_param_decode(snd_seq_event_t *ev, unsigned char *buf); +static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf); +static void two_param_decode(snd_seq_event_t *ev, unsigned char *buf); +static void songpos_decode(snd_seq_event_t *ev, unsigned char *buf); /* * event list */ -static struct status_event_list { +static struct status_event_list_t { int event; int qlen; - void (*encode)(struct snd_midi_event *dev, struct snd_seq_event *ev); - void (*decode)(struct snd_seq_event *ev, unsigned char *buf); + event_encode_t encode; + event_decode_t decode; } status_event[] = { /* 0x80 - 0xf0 */ {SNDRV_SEQ_EVENT_NOTEOFF, 2, note_event, note_decode}, @@ -93,15 +97,12 @@ static struct status_event_list { {SNDRV_SEQ_EVENT_RESET, 0, NULL, NULL}, /* 0xff */ }; -static int extra_decode_ctrl14(struct snd_midi_event *dev, unsigned char *buf, int len, - struct snd_seq_event *ev); -static int extra_decode_xrpn(struct snd_midi_event *dev, unsigned char *buf, int count, - struct snd_seq_event *ev); +static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev); +static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev); -static struct extra_event_list { +static struct extra_event_list_t { int event; - int (*decode)(struct snd_midi_event *dev, unsigned char *buf, int len, - struct snd_seq_event *ev); + int (*decode)(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev); } extra_event[] = { {SNDRV_SEQ_EVENT_CONTROL14, extra_decode_ctrl14}, {SNDRV_SEQ_EVENT_NONREGPARAM, extra_decode_xrpn}, @@ -112,9 +113,9 @@ static struct extra_event_list { * new/delete record */ -int snd_midi_event_new(int bufsize, struct snd_midi_event **rdev) +int snd_midi_event_new(int bufsize, snd_midi_event_t **rdev) { - struct snd_midi_event *dev; + snd_midi_event_t *dev; *rdev = NULL; dev = kzalloc(sizeof(*dev), GFP_KERNEL); @@ -134,7 +135,7 @@ int snd_midi_event_new(int bufsize, struct snd_midi_event **rdev) return 0; } -void snd_midi_event_free(struct snd_midi_event *dev) +void snd_midi_event_free(snd_midi_event_t *dev) { if (dev != NULL) { kfree(dev->buf); @@ -145,14 +146,14 @@ void snd_midi_event_free(struct snd_midi_event *dev) /* * initialize record */ -static inline void reset_encode(struct snd_midi_event *dev) +static inline void reset_encode(snd_midi_event_t *dev) { dev->read = 0; dev->qlen = 0; dev->type = 0; } -void snd_midi_event_reset_encode(struct snd_midi_event *dev) +void snd_midi_event_reset_encode(snd_midi_event_t *dev) { unsigned long flags; @@ -161,7 +162,7 @@ void snd_midi_event_reset_encode(struct snd_midi_event *dev) spin_unlock_irqrestore(&dev->lock, flags); } -void snd_midi_event_reset_decode(struct snd_midi_event *dev) +void snd_midi_event_reset_decode(snd_midi_event_t *dev) { unsigned long flags; @@ -171,14 +172,14 @@ void snd_midi_event_reset_decode(struct snd_midi_event *dev) } #if 0 -void snd_midi_event_init(struct snd_midi_event *dev) +void snd_midi_event_init(snd_midi_event_t *dev) { snd_midi_event_reset_encode(dev); snd_midi_event_reset_decode(dev); } #endif /* 0 */ -void snd_midi_event_no_status(struct snd_midi_event *dev, int on) +void snd_midi_event_no_status(snd_midi_event_t *dev, int on) { dev->nostat = on ? 1 : 0; } @@ -187,7 +188,7 @@ void snd_midi_event_no_status(struct snd_midi_event *dev, int on) * resize buffer */ #if 0 -int snd_midi_event_resize_buffer(struct snd_midi_event *dev, int bufsize) +int snd_midi_event_resize_buffer(snd_midi_event_t *dev, int bufsize) { unsigned char *new_buf, *old_buf; unsigned long flags; @@ -212,8 +213,7 @@ int snd_midi_event_resize_buffer(struct snd_midi_event *dev, int bufsize) * read bytes and encode to sequencer event if finished * return the size of encoded bytes */ -long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long count, - struct snd_seq_event *ev) +long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) { long result = 0; int rc; @@ -238,8 +238,7 @@ long snd_midi_event_encode(struct snd_midi_event *dev, unsigned char *buf, long * 0 data is not finished * negative for error */ -int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c, - struct snd_seq_event *ev) +int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev) { int rc = 0; unsigned long flags; @@ -304,7 +303,7 @@ int snd_midi_event_encode_byte(struct snd_midi_event *dev, int c, } /* encode note event */ -static void note_event(struct snd_midi_event *dev, struct snd_seq_event *ev) +static void note_event(snd_midi_event_t *dev, snd_seq_event_t *ev) { ev->data.note.channel = dev->buf[0] & 0x0f; ev->data.note.note = dev->buf[1]; @@ -312,21 +311,21 @@ static void note_event(struct snd_midi_event *dev, struct snd_seq_event *ev) } /* encode one parameter controls */ -static void one_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev) +static void one_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) { ev->data.control.channel = dev->buf[0] & 0x0f; ev->data.control.value = dev->buf[1]; } /* encode pitch wheel change */ -static void pitchbend_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev) +static void pitchbend_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) { ev->data.control.channel = dev->buf[0] & 0x0f; ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1] - 8192; } /* encode midi control change */ -static void two_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_event *ev) +static void two_param_ctrl_event(snd_midi_event_t *dev, snd_seq_event_t *ev) { ev->data.control.channel = dev->buf[0] & 0x0f; ev->data.control.param = dev->buf[1]; @@ -334,13 +333,13 @@ static void two_param_ctrl_event(struct snd_midi_event *dev, struct snd_seq_even } /* encode one parameter value*/ -static void one_param_event(struct snd_midi_event *dev, struct snd_seq_event *ev) +static void one_param_event(snd_midi_event_t *dev, snd_seq_event_t *ev) { ev->data.control.value = dev->buf[1]; } /* encode song position */ -static void songpos_event(struct snd_midi_event *dev, struct snd_seq_event *ev) +static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev) { ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1]; } @@ -349,8 +348,7 @@ static void songpos_event(struct snd_midi_event *dev, struct snd_seq_event *ev) * decode from a sequencer event to midi bytes * return the size of decoded midi events */ -long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long count, - struct snd_seq_event *ev) +long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) { unsigned int cmd, type; @@ -406,20 +404,20 @@ long snd_midi_event_decode(struct snd_midi_event *dev, unsigned char *buf, long /* decode note event */ -static void note_decode(struct snd_seq_event *ev, unsigned char *buf) +static void note_decode(snd_seq_event_t *ev, unsigned char *buf) { buf[0] = ev->data.note.note & 0x7f; buf[1] = ev->data.note.velocity & 0x7f; } /* decode one parameter controls */ -static void one_param_decode(struct snd_seq_event *ev, unsigned char *buf) +static void one_param_decode(snd_seq_event_t *ev, unsigned char *buf) { buf[0] = ev->data.control.value & 0x7f; } /* decode pitch wheel change */ -static void pitchbend_decode(struct snd_seq_event *ev, unsigned char *buf) +static void pitchbend_decode(snd_seq_event_t *ev, unsigned char *buf) { int value = ev->data.control.value + 8192; buf[0] = value & 0x7f; @@ -427,22 +425,21 @@ static void pitchbend_decode(struct snd_seq_event *ev, unsigned char *buf) } /* decode midi control change */ -static void two_param_decode(struct snd_seq_event *ev, unsigned char *buf) +static void two_param_decode(snd_seq_event_t *ev, unsigned char *buf) { buf[0] = ev->data.control.param & 0x7f; buf[1] = ev->data.control.value & 0x7f; } /* decode song position */ -static void songpos_decode(struct snd_seq_event *ev, unsigned char *buf) +static void songpos_decode(snd_seq_event_t *ev, unsigned char *buf) { buf[0] = ev->data.control.value & 0x7f; buf[1] = (ev->data.control.value >> 7) & 0x7f; } /* decode 14bit control */ -static int extra_decode_ctrl14(struct snd_midi_event *dev, unsigned char *buf, - int count, struct snd_seq_event *ev) +static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev) { unsigned char cmd; int idx = 0; @@ -479,8 +476,7 @@ static int extra_decode_ctrl14(struct snd_midi_event *dev, unsigned char *buf, } /* decode reg/nonreg param */ -static int extra_decode_xrpn(struct snd_midi_event *dev, unsigned char *buf, - int count, struct snd_seq_event *ev) +static int extra_decode_xrpn(snd_midi_event_t *dev, unsigned char *buf, int count, snd_seq_event_t *ev) { unsigned char cmd; char *cbytes; diff --git a/trunk/sound/core/seq/seq_ports.c b/trunk/sound/core/seq/seq_ports.c index 2b384fd7967f..57ec31df0d15 100644 --- a/trunk/sound/core/seq/seq_ports.c +++ b/trunk/sound/core/seq/seq_ports.c @@ -56,17 +56,16 @@ much elements are in array. */ /* return pointer to port structure - port is locked if found */ -struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client, - int num) +client_port_t *snd_seq_port_use_ptr(client_t *client, int num) { struct list_head *p; - struct snd_seq_client_port *port; + client_port_t *port; if (client == NULL) return NULL; read_lock(&client->ports_lock); list_for_each(p, &client->ports_list_head) { - port = list_entry(p, struct snd_seq_client_port, list); + port = list_entry(p, client_port_t, list); if (port->addr.port == num) { if (port->closing) break; /* deleting now */ @@ -81,18 +80,17 @@ struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client, /* search for the next port - port is locked if found */ -struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client, - struct snd_seq_port_info *pinfo) +client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t *pinfo) { int num; struct list_head *p; - struct snd_seq_client_port *port, *found; + client_port_t *port, *found; num = pinfo->addr.port; found = NULL; read_lock(&client->ports_lock); list_for_each(p, &client->ports_list_head) { - port = list_entry(p, struct snd_seq_client_port, list); + port = list_entry(p, client_port_t, list); if (port->addr.port < num) continue; if (port->addr.port == num) { @@ -113,8 +111,8 @@ struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *cl } -/* initialize snd_seq_port_subs_info */ -static void port_subs_info_init(struct snd_seq_port_subs_info *grp) +/* initialize port_subs_info_t */ +static void port_subs_info_init(port_subs_info_t *grp) { INIT_LIST_HEAD(&grp->list_head); grp->count = 0; @@ -127,11 +125,10 @@ static void port_subs_info_init(struct snd_seq_port_subs_info *grp) /* create a port, port number is returned (-1 on failure) */ -struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, - int port) +client_port_t *snd_seq_create_port(client_t *client, int port) { unsigned long flags; - struct snd_seq_client_port *new_port; + client_port_t *new_port; struct list_head *l; int num = -1; @@ -162,7 +159,7 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, down(&client->ports_mutex); write_lock_irqsave(&client->ports_lock, flags); list_for_each(l, &client->ports_list_head) { - struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list); + client_port_t *p = list_entry(l, client_port_t, list); if (p->addr.port > num) break; if (port < 0) /* auto-probe mode */ @@ -180,24 +177,17 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, } /* */ -enum group_type { +enum group_type_t { SRC_LIST, DEST_LIST }; -static int subscribe_port(struct snd_seq_client *client, - struct snd_seq_client_port *port, - struct snd_seq_port_subs_info *grp, - struct snd_seq_port_subscribe *info, int send_ack); -static int unsubscribe_port(struct snd_seq_client *client, - struct snd_seq_client_port *port, - struct snd_seq_port_subs_info *grp, - struct snd_seq_port_subscribe *info, int send_ack); +static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, snd_seq_port_subscribe_t *info, int send_ack); +static int unsubscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, snd_seq_port_subscribe_t *info, int send_ack); -static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr, - struct snd_seq_client **cp) +static client_port_t *get_client_port(snd_seq_addr_t *addr, client_t **cp) { - struct snd_seq_client_port *p; + client_port_t *p; *cp = snd_seq_client_use_ptr(addr->client); if (*cp) { p = snd_seq_port_use_ptr(*cp, addr->port); @@ -214,24 +204,22 @@ static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr, * remove all subscribers on the list * this is called from port_delete, for each src and dest list. */ -static void clear_subscriber_list(struct snd_seq_client *client, - struct snd_seq_client_port *port, - struct snd_seq_port_subs_info *grp, - int grptype) +static void clear_subscriber_list(client_t *client, client_port_t *port, + port_subs_info_t *grp, int grptype) { struct list_head *p, *n; down_write(&grp->list_mutex); list_for_each_safe(p, n, &grp->list_head) { - struct snd_seq_subscribers *subs; - struct snd_seq_client *c; - struct snd_seq_client_port *aport; + subscribers_t *subs; + client_t *c; + client_port_t *aport; if (grptype == SRC_LIST) { - subs = list_entry(p, struct snd_seq_subscribers, src_list); + subs = list_entry(p, subscribers_t, src_list); aport = get_client_port(&subs->info.dest, &c); } else { - subs = list_entry(p, struct snd_seq_subscribers, dest_list); + subs = list_entry(p, subscribers_t, dest_list); aport = get_client_port(&subs->info.sender, &c); } list_del(p); @@ -245,7 +233,7 @@ static void clear_subscriber_list(struct snd_seq_client *client, kfree(subs); } else { /* ok we got the connected port */ - struct snd_seq_port_subs_info *agrp; + port_subs_info_t *agrp; agrp = (grptype == SRC_LIST) ? &aport->c_dest : &aport->c_src; down_write(&agrp->list_mutex); if (grptype == SRC_LIST) @@ -263,8 +251,7 @@ static void clear_subscriber_list(struct snd_seq_client *client, } /* delete port data */ -static int port_delete(struct snd_seq_client *client, - struct snd_seq_client_port *port) +static int port_delete(client_t *client, client_port_t *port) { /* set closing flag and wait for all port access are gone */ port->closing = 1; @@ -286,16 +273,16 @@ static int port_delete(struct snd_seq_client *client, /* delete a port with the given port id */ -int snd_seq_delete_port(struct snd_seq_client *client, int port) +int snd_seq_delete_port(client_t *client, int port) { unsigned long flags; struct list_head *l; - struct snd_seq_client_port *found = NULL; + client_port_t *found = NULL; down(&client->ports_mutex); write_lock_irqsave(&client->ports_lock, flags); list_for_each(l, &client->ports_list_head) { - struct snd_seq_client_port *p = list_entry(l, struct snd_seq_client_port, list); + client_port_t *p = list_entry(l, client_port_t, list); if (p->addr.port == port) { /* ok found. delete from the list at first */ list_del(l); @@ -313,7 +300,7 @@ int snd_seq_delete_port(struct snd_seq_client *client, int port) } /* delete the all ports belonging to the given client */ -int snd_seq_delete_all_ports(struct snd_seq_client *client) +int snd_seq_delete_all_ports(client_t *client) { unsigned long flags; struct list_head deleted_list, *p, *n; @@ -336,7 +323,7 @@ int snd_seq_delete_all_ports(struct snd_seq_client *client) /* remove each port in deleted_list */ list_for_each_safe(p, n, &deleted_list) { - struct snd_seq_client_port *port = list_entry(p, struct snd_seq_client_port, list); + client_port_t *port = list_entry(p, client_port_t, list); list_del(p); snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port); port_delete(client, port); @@ -346,8 +333,7 @@ int snd_seq_delete_all_ports(struct snd_seq_client *client) } /* set port info fields */ -int snd_seq_set_port_info(struct snd_seq_client_port * port, - struct snd_seq_port_info * info) +int snd_seq_set_port_info(client_port_t * port, snd_seq_port_info_t * info) { snd_assert(port && info, return -EINVAL); @@ -375,8 +361,7 @@ int snd_seq_set_port_info(struct snd_seq_client_port * port, } /* get port info fields */ -int snd_seq_get_port_info(struct snd_seq_client_port * port, - struct snd_seq_port_info * info) +int snd_seq_get_port_info(client_port_t * port, snd_seq_port_info_t * info) { snd_assert(port && info, return -EINVAL); @@ -425,11 +410,8 @@ int snd_seq_get_port_info(struct snd_seq_client_port * port, * at each connnection/disconnection. */ -static int subscribe_port(struct snd_seq_client *client, - struct snd_seq_client_port *port, - struct snd_seq_port_subs_info *grp, - struct snd_seq_port_subscribe *info, - int send_ack) +static int subscribe_port(client_t *client, client_port_t *port, port_subs_info_t *grp, + snd_seq_port_subscribe_t *info, int send_ack) { int err = 0; @@ -450,11 +432,9 @@ static int subscribe_port(struct snd_seq_client *client, return err; } -static int unsubscribe_port(struct snd_seq_client *client, - struct snd_seq_client_port *port, - struct snd_seq_port_subs_info *grp, - struct snd_seq_port_subscribe *info, - int send_ack) +static int unsubscribe_port(client_t *client, client_port_t *port, + port_subs_info_t *grp, + snd_seq_port_subscribe_t *info, int send_ack) { int err = 0; @@ -473,15 +453,15 @@ static int unsubscribe_port(struct snd_seq_client *client, /* check if both addresses are identical */ -static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s) +static inline int addr_match(snd_seq_addr_t *r, snd_seq_addr_t *s) { return (r->client == s->client) && (r->port == s->port); } /* check the two subscribe info match */ /* if flags is zero, checks only sender and destination addresses */ -static int match_subs_info(struct snd_seq_port_subscribe *r, - struct snd_seq_port_subscribe *s) +static int match_subs_info(snd_seq_port_subscribe_t *r, + snd_seq_port_subscribe_t *s) { if (addr_match(&r->sender, &s->sender) && addr_match(&r->dest, &s->dest)) { @@ -495,16 +475,14 @@ static int match_subs_info(struct snd_seq_port_subscribe *r, /* connect two ports */ -int snd_seq_port_connect(struct snd_seq_client *connector, - struct snd_seq_client *src_client, - struct snd_seq_client_port *src_port, - struct snd_seq_client *dest_client, - struct snd_seq_client_port *dest_port, - struct snd_seq_port_subscribe *info) +int snd_seq_port_connect(client_t *connector, + client_t *src_client, client_port_t *src_port, + client_t *dest_client, client_port_t *dest_port, + snd_seq_port_subscribe_t *info) { - struct snd_seq_port_subs_info *src = &src_port->c_src; - struct snd_seq_port_subs_info *dest = &dest_port->c_dest; - struct snd_seq_subscribers *subs; + port_subs_info_t *src = &src_port->c_src; + port_subs_info_t *dest = &dest_port->c_dest; + subscribers_t *subs; struct list_head *p; int err, src_called = 0; unsigned long flags; @@ -530,12 +508,12 @@ int snd_seq_port_connect(struct snd_seq_client *connector, goto __error; /* check whether already exists */ list_for_each(p, &src->list_head) { - struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, src_list); + subscribers_t *s = list_entry(p, subscribers_t, src_list); if (match_subs_info(info, &s->info)) goto __error; } list_for_each(p, &dest->list_head) { - struct snd_seq_subscribers *s = list_entry(p, struct snd_seq_subscribers, dest_list); + subscribers_t *s = list_entry(p, subscribers_t, dest_list); if (match_subs_info(info, &s->info)) goto __error; } @@ -576,16 +554,14 @@ int snd_seq_port_connect(struct snd_seq_client *connector, /* remove the connection */ -int snd_seq_port_disconnect(struct snd_seq_client *connector, - struct snd_seq_client *src_client, - struct snd_seq_client_port *src_port, - struct snd_seq_client *dest_client, - struct snd_seq_client_port *dest_port, - struct snd_seq_port_subscribe *info) +int snd_seq_port_disconnect(client_t *connector, + client_t *src_client, client_port_t *src_port, + client_t *dest_client, client_port_t *dest_port, + snd_seq_port_subscribe_t *info) { - struct snd_seq_port_subs_info *src = &src_port->c_src; - struct snd_seq_port_subs_info *dest = &dest_port->c_dest; - struct snd_seq_subscribers *subs; + port_subs_info_t *src = &src_port->c_src; + port_subs_info_t *dest = &dest_port->c_dest; + subscribers_t *subs; struct list_head *p; int err = -ENOENT; unsigned long flags; @@ -595,7 +571,7 @@ int snd_seq_port_disconnect(struct snd_seq_client *connector, /* look for the connection */ list_for_each(p, &src->list_head) { - subs = list_entry(p, struct snd_seq_subscribers, src_list); + subs = list_entry(p, subscribers_t, src_list); if (match_subs_info(info, &subs->info)) { write_lock_irqsave(&src->list_lock, flags); // write_lock(&dest->list_lock); // no lock yet @@ -621,15 +597,15 @@ int snd_seq_port_disconnect(struct snd_seq_client *connector, /* get matched subscriber */ -struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp, - struct snd_seq_addr *dest_addr) +subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp, + snd_seq_addr_t *dest_addr) { struct list_head *p; - struct snd_seq_subscribers *s, *found = NULL; + subscribers_t *s, *found = NULL; down_read(&src_grp->list_mutex); list_for_each(p, &src_grp->list_head) { - s = list_entry(p, struct snd_seq_subscribers, src_list); + s = list_entry(p, subscribers_t, src_list); if (addr_match(dest_addr, &s->info.dest)) { found = s; break; @@ -647,11 +623,11 @@ struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_su */ /* exported */ int snd_seq_event_port_attach(int client, - struct snd_seq_port_callback *pcbp, + snd_seq_port_callback_t *pcbp, int cap, int type, int midi_channels, int midi_voices, char *portname) { - struct snd_seq_port_info portinfo; + snd_seq_port_info_t portinfo; int ret; /* Set up the port */ @@ -684,7 +660,7 @@ int snd_seq_event_port_attach(int client, /* exported */ int snd_seq_event_port_detach(int client, int port) { - struct snd_seq_port_info portinfo; + snd_seq_port_info_t portinfo; int err; memset(&portinfo, 0, sizeof(portinfo)); diff --git a/trunk/sound/core/seq/seq_ports.h b/trunk/sound/core/seq/seq_ports.h index 9d7117118ba4..89fd4416f6fa 100644 --- a/trunk/sound/core/seq/seq_ports.h +++ b/trunk/sound/core/seq/seq_ports.h @@ -40,38 +40,37 @@ */ -struct snd_seq_subscribers { - struct snd_seq_port_subscribe info; /* additional info */ +typedef struct subscribers_t { + snd_seq_port_subscribe_t info; /* additional info */ struct list_head src_list; /* link of sources */ struct list_head dest_list; /* link of destinations */ atomic_t ref_count; -}; +} subscribers_t; -struct snd_seq_port_subs_info { +typedef struct port_subs_info_t { struct list_head list_head; /* list of subscribed ports */ unsigned int count; /* count of subscribers */ unsigned int exclusive: 1; /* exclusive mode */ struct rw_semaphore list_mutex; rwlock_t list_lock; - int (*open)(void *private_data, struct snd_seq_port_subscribe *info); - int (*close)(void *private_data, struct snd_seq_port_subscribe *info); -}; + snd_seq_kernel_port_open_t *open; + snd_seq_kernel_port_close_t *close; +} port_subs_info_t; -struct snd_seq_client_port { +typedef struct client_port_t { - struct snd_seq_addr addr; /* client/port number */ + snd_seq_addr_t addr; /* client/port number */ struct module *owner; /* owner of this port */ char name[64]; /* port name */ struct list_head list; /* port list */ snd_use_lock_t use_lock; /* subscribers */ - struct snd_seq_port_subs_info c_src; /* read (sender) list */ - struct snd_seq_port_subs_info c_dest; /* write (dest) list */ + port_subs_info_t c_src; /* read (sender) list */ + port_subs_info_t c_dest; /* write (dest) list */ - int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data, - int atomic, int hop); - void (*private_free)(void *private_data); + snd_seq_kernel_port_input_t *event_input; + snd_seq_kernel_port_private_free_t *private_free; void *private_data; unsigned int callback_all : 1; unsigned int closing : 1; @@ -88,55 +87,42 @@ struct snd_seq_client_port { int midi_voices; int synth_voices; -}; - -struct snd_seq_client; +} client_port_t; /* return pointer to port structure and lock port */ -struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client, int num); +client_port_t *snd_seq_port_use_ptr(client_t *client, int num); /* search for next port - port is locked if found */ -struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client, - struct snd_seq_port_info *pinfo); +client_port_t *snd_seq_port_query_nearest(client_t *client, snd_seq_port_info_t *pinfo); /* unlock the port */ #define snd_seq_port_unlock(port) snd_use_lock_free(&(port)->use_lock) /* create a port, port number is returned (-1 on failure) */ -struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, int port_index); +client_port_t *snd_seq_create_port(client_t *client, int port_index); /* delete a port */ -int snd_seq_delete_port(struct snd_seq_client *client, int port); +int snd_seq_delete_port(client_t *client, int port); /* delete all ports */ -int snd_seq_delete_all_ports(struct snd_seq_client *client); +int snd_seq_delete_all_ports(client_t *client); /* set port info fields */ -int snd_seq_set_port_info(struct snd_seq_client_port *port, - struct snd_seq_port_info *info); +int snd_seq_set_port_info(client_port_t *port, snd_seq_port_info_t *info); /* get port info fields */ -int snd_seq_get_port_info(struct snd_seq_client_port *port, - struct snd_seq_port_info *info); +int snd_seq_get_port_info(client_port_t *port, snd_seq_port_info_t *info); /* add subscriber to subscription list */ -int snd_seq_port_connect(struct snd_seq_client *caller, - struct snd_seq_client *s, struct snd_seq_client_port *sp, - struct snd_seq_client *d, struct snd_seq_client_port *dp, - struct snd_seq_port_subscribe *info); +int snd_seq_port_connect(client_t *caller, client_t *s, client_port_t *sp, client_t *d, client_port_t *dp, snd_seq_port_subscribe_t *info); /* remove subscriber from subscription list */ -int snd_seq_port_disconnect(struct snd_seq_client *caller, - struct snd_seq_client *s, struct snd_seq_client_port *sp, - struct snd_seq_client *d, struct snd_seq_client_port *dp, - struct snd_seq_port_subscribe *info); +int snd_seq_port_disconnect(client_t *caller, client_t *s, client_port_t *sp, client_t *d, client_port_t *dp, snd_seq_port_subscribe_t *info); /* subscribe port */ -int snd_seq_port_subscribe(struct snd_seq_client_port *port, - struct snd_seq_port_subscribe *info); +int snd_seq_port_subscribe(client_port_t *port, snd_seq_port_subscribe_t *info); /* get matched subscriber */ -struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp, - struct snd_seq_addr *dest_addr); +subscribers_t *snd_seq_port_get_subscription(port_subs_info_t *src_grp, snd_seq_addr_t *dest_addr); #endif diff --git a/trunk/sound/core/seq/seq_prioq.c b/trunk/sound/core/seq/seq_prioq.c index 074418617ee9..cd641bca9945 100644 --- a/trunk/sound/core/seq/seq_prioq.c +++ b/trunk/sound/core/seq/seq_prioq.c @@ -55,9 +55,9 @@ /* create new prioq (constructor) */ -struct snd_seq_prioq *snd_seq_prioq_new(void) +prioq_t *snd_seq_prioq_new(void) { - struct snd_seq_prioq *f; + prioq_t *f; f = kzalloc(sizeof(*f), GFP_KERNEL); if (f == NULL) { @@ -74,9 +74,9 @@ struct snd_seq_prioq *snd_seq_prioq_new(void) } /* delete prioq (destructor) */ -void snd_seq_prioq_delete(struct snd_seq_prioq **fifo) +void snd_seq_prioq_delete(prioq_t **fifo) { - struct snd_seq_prioq *f = *fifo; + prioq_t *f = *fifo; *fifo = NULL; if (f == NULL) { @@ -101,8 +101,7 @@ void snd_seq_prioq_delete(struct snd_seq_prioq **fifo) /* compare timestamp between events */ /* return 1 if a >= b; 0 */ -static inline int compare_timestamp(struct snd_seq_event *a, - struct snd_seq_event *b) +static inline int compare_timestamp(snd_seq_event_t * a, snd_seq_event_t * b) { if ((a->flags & SNDRV_SEQ_TIME_STAMP_MASK) == SNDRV_SEQ_TIME_STAMP_TICK) { /* compare ticks */ @@ -118,8 +117,7 @@ static inline int compare_timestamp(struct snd_seq_event *a, * zero if a = b; * positive if a > b; */ -static inline int compare_timestamp_rel(struct snd_seq_event *a, - struct snd_seq_event *b) +static inline int compare_timestamp_rel(snd_seq_event_t *a, snd_seq_event_t *b) { if ((a->flags & SNDRV_SEQ_TIME_STAMP_MASK) == SNDRV_SEQ_TIME_STAMP_TICK) { /* compare ticks */ @@ -146,10 +144,9 @@ static inline int compare_timestamp_rel(struct snd_seq_event *a, } /* enqueue cell to prioq */ -int snd_seq_prioq_cell_in(struct snd_seq_prioq * f, - struct snd_seq_event_cell * cell) +int snd_seq_prioq_cell_in(prioq_t * f, snd_seq_event_cell_t * cell) { - struct snd_seq_event_cell *cur, *prev; + snd_seq_event_cell_t *cur, *prev; unsigned long flags; int count; int prior; @@ -218,9 +215,9 @@ int snd_seq_prioq_cell_in(struct snd_seq_prioq * f, } /* dequeue cell from prioq */ -struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f) +snd_seq_event_cell_t *snd_seq_prioq_cell_out(prioq_t * f) { - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; unsigned long flags; if (f == NULL) { @@ -246,7 +243,7 @@ struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f) } /* return number of events available in prioq */ -int snd_seq_prioq_avail(struct snd_seq_prioq * f) +int snd_seq_prioq_avail(prioq_t * f) { if (f == NULL) { snd_printd("oops: snd_seq_prioq_cell_in() called with NULL prioq\n"); @@ -257,7 +254,7 @@ int snd_seq_prioq_avail(struct snd_seq_prioq * f) /* peek at cell at the head of the prioq */ -struct snd_seq_event_cell *snd_seq_prioq_cell_peek(struct snd_seq_prioq * f) +snd_seq_event_cell_t *snd_seq_prioq_cell_peek(prioq_t * f) { if (f == NULL) { snd_printd("oops: snd_seq_prioq_cell_in() called with NULL prioq\n"); @@ -267,8 +264,7 @@ struct snd_seq_event_cell *snd_seq_prioq_cell_peek(struct snd_seq_prioq * f) } -static inline int prioq_match(struct snd_seq_event_cell *cell, - int client, int timestamp) +static inline int prioq_match(snd_seq_event_cell_t *cell, int client, int timestamp) { if (cell->event.source.client == client || cell->event.dest.client == client) @@ -290,12 +286,12 @@ static inline int prioq_match(struct snd_seq_event_cell *cell, } /* remove cells for left client */ -void snd_seq_prioq_leave(struct snd_seq_prioq * f, int client, int timestamp) +void snd_seq_prioq_leave(prioq_t * f, int client, int timestamp) { - register struct snd_seq_event_cell *cell, *next; + register snd_seq_event_cell_t *cell, *next; unsigned long flags; - struct snd_seq_event_cell *prev = NULL; - struct snd_seq_event_cell *freefirst = NULL, *freeprev = NULL, *freenext; + snd_seq_event_cell_t *prev = NULL; + snd_seq_event_cell_t *freefirst = NULL, *freeprev = NULL, *freenext; /* collect all removed cells */ spin_lock_irqsave(&f->lock, flags); @@ -342,8 +338,8 @@ void snd_seq_prioq_leave(struct snd_seq_prioq * f, int client, int timestamp) } } -static int prioq_remove_match(struct snd_seq_remove_events *info, - struct snd_seq_event *ev) +static int prioq_remove_match(snd_seq_remove_events_t *info, + snd_seq_event_t *ev) { int res; @@ -398,13 +394,13 @@ static int prioq_remove_match(struct snd_seq_remove_events *info, } /* remove cells matching remove criteria */ -void snd_seq_prioq_remove_events(struct snd_seq_prioq * f, int client, - struct snd_seq_remove_events *info) +void snd_seq_prioq_remove_events(prioq_t * f, int client, + snd_seq_remove_events_t *info) { - struct snd_seq_event_cell *cell, *next; + register snd_seq_event_cell_t *cell, *next; unsigned long flags; - struct snd_seq_event_cell *prev = NULL; - struct snd_seq_event_cell *freefirst = NULL, *freeprev = NULL, *freenext; + snd_seq_event_cell_t *prev = NULL; + snd_seq_event_cell_t *freefirst = NULL, *freeprev = NULL, *freenext; /* collect all removed cells */ spin_lock_irqsave(&f->lock, flags); diff --git a/trunk/sound/core/seq/seq_prioq.h b/trunk/sound/core/seq/seq_prioq.h index d38bb78d9345..f12af79308b8 100644 --- a/trunk/sound/core/seq/seq_prioq.h +++ b/trunk/sound/core/seq/seq_prioq.h @@ -26,37 +26,37 @@ /* === PRIOQ === */ -struct snd_seq_prioq { - struct snd_seq_event_cell *head; /* pointer to head of prioq */ - struct snd_seq_event_cell *tail; /* pointer to tail of prioq */ +typedef struct { + snd_seq_event_cell_t* head; /* pointer to head of prioq */ + snd_seq_event_cell_t* tail; /* pointer to tail of prioq */ int cells; spinlock_t lock; -}; +} prioq_t; /* create new prioq (constructor) */ -struct snd_seq_prioq *snd_seq_prioq_new(void); +extern prioq_t *snd_seq_prioq_new(void); /* delete prioq (destructor) */ -void snd_seq_prioq_delete(struct snd_seq_prioq **fifo); +extern void snd_seq_prioq_delete(prioq_t **fifo); /* enqueue cell to prioq */ -int snd_seq_prioq_cell_in(struct snd_seq_prioq *f, struct snd_seq_event_cell *cell); +extern int snd_seq_prioq_cell_in(prioq_t *f, snd_seq_event_cell_t *cell); /* dequeue cell from prioq */ -struct snd_seq_event_cell *snd_seq_prioq_cell_out(struct snd_seq_prioq *f); +extern snd_seq_event_cell_t *snd_seq_prioq_cell_out(prioq_t *f); /* return number of events available in prioq */ -int snd_seq_prioq_avail(struct snd_seq_prioq *f); +extern int snd_seq_prioq_avail(prioq_t *f); /* peek at cell at the head of the prioq */ -struct snd_seq_event_cell *snd_seq_prioq_cell_peek(struct snd_seq_prioq *f); +extern snd_seq_event_cell_t *snd_seq_prioq_cell_peek(prioq_t *f); /* client left queue */ -void snd_seq_prioq_leave(struct snd_seq_prioq *f, int client, int timestamp); +extern void snd_seq_prioq_leave(prioq_t *f, int client, int timestamp); /* Remove events */ -void snd_seq_prioq_remove_events(struct snd_seq_prioq *f, int client, - struct snd_seq_remove_events *info); +void snd_seq_prioq_remove_events(prioq_t * f, int client, + snd_seq_remove_events_t *info); #endif diff --git a/trunk/sound/core/seq/seq_queue.c b/trunk/sound/core/seq/seq_queue.c index 9cf20f045542..5f5c3cb37cbf 100644 --- a/trunk/sound/core/seq/seq_queue.c +++ b/trunk/sound/core/seq/seq_queue.c @@ -29,7 +29,7 @@ * Aug. 30, 2000 Takashi Iwai * - Queues are managed in static array again, but with better way. * The API itself is identical. - * - The queue is locked when struct snd_seq_queue pointer is returned via + * - The queue is locked when queue_t pinter is returned via * queueptr(). This pointer *MUST* be released afterward by * queuefree(ptr). * - Addition of experimental sync support. @@ -48,7 +48,7 @@ #include "seq_info.h" /* list of allocated queues */ -static struct snd_seq_queue *queue_list[SNDRV_SEQ_MAX_QUEUES]; +static queue_t *queue_list[SNDRV_SEQ_MAX_QUEUES]; static DEFINE_SPINLOCK(queue_list_lock); /* number of queues allocated */ static int num_queues; @@ -61,7 +61,7 @@ int snd_seq_queue_get_cur_queues(void) /*----------------------------------------------------------------*/ /* assign queue id and insert to list */ -static int queue_list_add(struct snd_seq_queue *q) +static int queue_list_add(queue_t *q) { int i; unsigned long flags; @@ -80,9 +80,9 @@ static int queue_list_add(struct snd_seq_queue *q) return -1; } -static struct snd_seq_queue *queue_list_remove(int id, int client) +static queue_t *queue_list_remove(int id, int client) { - struct snd_seq_queue *q; + queue_t *q; unsigned long flags; spin_lock_irqsave(&queue_list_lock, flags); @@ -107,9 +107,9 @@ static struct snd_seq_queue *queue_list_remove(int id, int client) /*----------------------------------------------------------------*/ /* create new queue (constructor) */ -static struct snd_seq_queue *queue_new(int owner, int locked) +static queue_t *queue_new(int owner, int locked) { - struct snd_seq_queue *q; + queue_t *q; q = kzalloc(sizeof(*q), GFP_KERNEL); if (q == NULL) { @@ -142,7 +142,7 @@ static struct snd_seq_queue *queue_new(int owner, int locked) } /* delete queue (destructor) */ -static void queue_delete(struct snd_seq_queue *q) +static void queue_delete(queue_t *q) { /* stop and release the timer */ snd_seq_timer_stop(q->timer); @@ -187,7 +187,7 @@ void __exit snd_seq_queues_delete(void) */ int snd_seq_queue_alloc(int client, int locked, unsigned int info_flags) { - struct snd_seq_queue *q; + queue_t *q; q = queue_new(client, locked); if (q == NULL) @@ -204,7 +204,7 @@ int snd_seq_queue_alloc(int client, int locked, unsigned int info_flags) /* delete a queue - queue must be owned by the client */ int snd_seq_queue_delete(int client, int queueid) { - struct snd_seq_queue *q; + queue_t *q; if (queueid < 0 || queueid >= SNDRV_SEQ_MAX_QUEUES) return -EINVAL; @@ -218,9 +218,9 @@ int snd_seq_queue_delete(int client, int queueid) /* return pointer to queue structure for specified id */ -struct snd_seq_queue *queueptr(int queueid) +queue_t *queueptr(int queueid) { - struct snd_seq_queue *q; + queue_t *q; unsigned long flags; if (queueid < 0 || queueid >= SNDRV_SEQ_MAX_QUEUES) @@ -234,10 +234,10 @@ struct snd_seq_queue *queueptr(int queueid) } /* return the (first) queue matching with the specified name */ -struct snd_seq_queue *snd_seq_queue_find_name(char *name) +queue_t *snd_seq_queue_find_name(char *name) { int i; - struct snd_seq_queue *q; + queue_t *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) != NULL) { @@ -252,10 +252,10 @@ struct snd_seq_queue *snd_seq_queue_find_name(char *name) /* -------------------------------------------------------- */ -void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop) +void snd_seq_check_queue(queue_t *q, int atomic, int hop) { unsigned long flags; - struct snd_seq_event_cell *cell; + snd_seq_event_cell_t *cell; if (q == NULL) return; @@ -273,8 +273,7 @@ void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop) __again: /* Process tick queue... */ while ((cell = snd_seq_prioq_cell_peek(q->tickq)) != NULL) { - if (snd_seq_compare_tick_time(&q->timer->tick.cur_tick, - &cell->event.time.tick)) { + if (snd_seq_compare_tick_time(&q->timer->tick.cur_tick, &cell->event.time.tick)) { cell = snd_seq_prioq_cell_out(q->tickq); if (cell) snd_seq_dispatch_event(cell, atomic, hop); @@ -287,8 +286,7 @@ void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop) /* Process time queue... */ while ((cell = snd_seq_prioq_cell_peek(q->timeq)) != NULL) { - if (snd_seq_compare_real_time(&q->timer->cur_time, - &cell->event.time.time)) { + if (snd_seq_compare_real_time(&q->timer->cur_time, &cell->event.time.time)) { cell = snd_seq_prioq_cell_out(q->timeq); if (cell) snd_seq_dispatch_event(cell, atomic, hop); @@ -311,10 +309,10 @@ void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop) /* enqueue a event to singe queue */ -int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop) +int snd_seq_enqueue_event(snd_seq_event_cell_t *cell, int atomic, int hop) { int dest, err; - struct snd_seq_queue *q; + queue_t *q; snd_assert(cell != NULL, return -EINVAL); dest = cell->event.queue; /* destination queue */ @@ -329,8 +327,7 @@ int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop) break; case SNDRV_SEQ_TIME_STAMP_REAL: - snd_seq_inc_real_time(&cell->event.time.time, - &q->timer->cur_time); + snd_seq_inc_real_time(&cell->event.time.time, &q->timer->cur_time); break; } cell->event.flags &= ~SNDRV_SEQ_TIME_MODE_MASK; @@ -364,7 +361,7 @@ int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop) /*----------------------------------------------------------------*/ -static inline int check_access(struct snd_seq_queue *q, int client) +static inline int check_access(queue_t *q, int client) { return (q->owner == client) || (!q->locked && !q->klocked); } @@ -372,7 +369,7 @@ static inline int check_access(struct snd_seq_queue *q, int client) /* check if the client has permission to modify queue parameters. * if it does, lock the queue */ -static int queue_access_lock(struct snd_seq_queue *q, int client) +static int queue_access_lock(queue_t *q, int client) { unsigned long flags; int access_ok; @@ -386,7 +383,7 @@ static int queue_access_lock(struct snd_seq_queue *q, int client) } /* unlock the queue */ -static inline void queue_access_unlock(struct snd_seq_queue *q) +static inline void queue_access_unlock(queue_t *q) { unsigned long flags; @@ -398,7 +395,7 @@ static inline void queue_access_unlock(struct snd_seq_queue *q) /* exported - only checking permission */ int snd_seq_queue_check_access(int queueid, int client) { - struct snd_seq_queue *q = queueptr(queueid); + queue_t *q = queueptr(queueid); int access_ok; unsigned long flags; @@ -418,7 +415,7 @@ int snd_seq_queue_check_access(int queueid, int client) */ int snd_seq_queue_set_owner(int queueid, int client, int locked) { - struct snd_seq_queue *q = queueptr(queueid); + queue_t *q = queueptr(queueid); if (q == NULL) return -EINVAL; @@ -446,8 +443,8 @@ int snd_seq_queue_set_owner(int queueid, int client, int locked) int snd_seq_queue_timer_open(int queueid) { int result = 0; - struct snd_seq_queue *queue; - struct snd_seq_timer *tmr; + queue_t *queue; + seq_timer_t *tmr; queue = queueptr(queueid); if (queue == NULL) @@ -466,8 +463,8 @@ int snd_seq_queue_timer_open(int queueid) */ int snd_seq_queue_timer_close(int queueid) { - struct snd_seq_queue *queue; - struct snd_seq_timer *tmr; + queue_t *queue; + seq_timer_t *tmr; int result = 0; queue = queueptr(queueid); @@ -480,10 +477,9 @@ int snd_seq_queue_timer_close(int queueid) } /* change queue tempo and ppq */ -int snd_seq_queue_timer_set_tempo(int queueid, int client, - struct snd_seq_queue_tempo *info) +int snd_seq_queue_timer_set_tempo(int queueid, int client, snd_seq_queue_tempo_t *info) { - struct snd_seq_queue *q = queueptr(queueid); + queue_t *q = queueptr(queueid); int result; if (q == NULL) @@ -497,8 +493,7 @@ int snd_seq_queue_timer_set_tempo(int queueid, int client, if (result >= 0) result = snd_seq_timer_set_ppq(q->timer, info->ppq); if (result >= 0 && info->skew_base > 0) - result = snd_seq_timer_set_skew(q->timer, info->skew_value, - info->skew_base); + result = snd_seq_timer_set_skew(q->timer, info->skew_value, info->skew_base); queue_access_unlock(q); queuefree(q); return result; @@ -511,7 +506,7 @@ int snd_seq_queue_timer_set_tempo(int queueid, int client, */ int snd_seq_queue_use(int queueid, int client, int use) { - struct snd_seq_queue *queue; + queue_t *queue; queue = queueptr(queueid); if (queue == NULL) @@ -543,7 +538,7 @@ int snd_seq_queue_use(int queueid, int client, int use) */ int snd_seq_queue_is_used(int queueid, int client) { - struct snd_seq_queue *q; + queue_t *q; int result; q = queueptr(queueid); @@ -564,7 +559,7 @@ void snd_seq_queue_client_termination(int client) { unsigned long flags; int i; - struct snd_seq_queue *q; + queue_t *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -589,7 +584,7 @@ void snd_seq_queue_client_termination(int client) void snd_seq_queue_client_leave(int client) { int i; - struct snd_seq_queue *q; + queue_t *q; /* delete own queues from queue list */ for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { @@ -620,7 +615,7 @@ void snd_seq_queue_client_leave(int client) void snd_seq_queue_client_leave_cells(int client) { int i; - struct snd_seq_queue *q; + queue_t *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -632,10 +627,10 @@ void snd_seq_queue_client_leave_cells(int client) } /* remove cells based on flush criteria */ -void snd_seq_queue_remove_cells(int client, struct snd_seq_remove_events *info) +void snd_seq_queue_remove_cells(int client, snd_seq_remove_events_t *info) { int i; - struct snd_seq_queue *q; + queue_t *q; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -655,10 +650,9 @@ void snd_seq_queue_remove_cells(int client, struct snd_seq_remove_events *info) /* * send events to all subscribed ports */ -static void queue_broadcast_event(struct snd_seq_queue *q, struct snd_seq_event *ev, - int atomic, int hop) +static void queue_broadcast_event(queue_t *q, snd_seq_event_t *ev, int atomic, int hop) { - struct snd_seq_event sev; + snd_seq_event_t sev; sev = *ev; @@ -678,8 +672,7 @@ static void queue_broadcast_event(struct snd_seq_queue *q, struct snd_seq_event * process a received queue-control event. * this function is exported for seq_sync.c. */ -static void snd_seq_queue_process_event(struct snd_seq_queue *q, - struct snd_seq_event *ev, +static void snd_seq_queue_process_event(queue_t *q, snd_seq_event_t *ev, int atomic, int hop) { switch (ev->type) { @@ -731,9 +724,9 @@ static void snd_seq_queue_process_event(struct snd_seq_queue *q, * Queue control via timer control port: * this function is exported as a callback of timer port. */ -int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop) +int snd_seq_control_queue(snd_seq_event_t *ev, int atomic, int hop) { - struct snd_seq_queue *q; + queue_t *q; snd_assert(ev != NULL, return -EINVAL); q = queueptr(ev->data.queue.queue); @@ -756,14 +749,13 @@ int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop) /*----------------------------------------------------------------*/ -#ifdef CONFIG_PROC_FS /* exported to seq_info.c */ -void snd_seq_info_queues_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +void snd_seq_info_queues_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { int i, bpm; - struct snd_seq_queue *q; - struct snd_seq_timer *tmr; + queue_t *q; + seq_timer_t *tmr; for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { if ((q = queueptr(i)) == NULL) @@ -790,5 +782,3 @@ void snd_seq_info_queues_read(struct snd_info_entry *entry, queuefree(q); } } -#endif /* CONFIG_PROC_FS */ - diff --git a/trunk/sound/core/seq/seq_queue.h b/trunk/sound/core/seq/seq_queue.h index 888438599387..ea3c54216ea8 100644 --- a/trunk/sound/core/seq/seq_queue.h +++ b/trunk/sound/core/seq/seq_queue.h @@ -30,15 +30,15 @@ #define SEQ_QUEUE_NO_OWNER (-1) -struct snd_seq_queue { +struct _snd_seq_queue { int queue; /* queue number */ char name[64]; /* name of this queue */ - struct snd_seq_prioq *tickq; /* midi tick event queue */ - struct snd_seq_prioq *timeq; /* real-time event queue */ + prioq_t *tickq; /* midi tick event queue */ + prioq_t *timeq; /* real-time event queue */ - struct snd_seq_timer *timer; /* time keeper for this queue */ + seq_timer_t *timer; /* time keeper for this queue */ int owner; /* client that 'owns' the timer */ unsigned int locked:1, /* timer is only accesibble by owner if set */ klocked:1, /* kernel lock (after START) */ @@ -83,26 +83,26 @@ void snd_seq_queue_client_termination(int client); void snd_seq_queue_client_leave(int client); /* enqueue a event received from one the clients */ -int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop); +int snd_seq_enqueue_event(snd_seq_event_cell_t *cell, int atomic, int hop); /* Remove events */ void snd_seq_queue_client_leave_cells(int client); -void snd_seq_queue_remove_cells(int client, struct snd_seq_remove_events *info); +void snd_seq_queue_remove_cells(int client, snd_seq_remove_events_t *info); /* return pointer to queue structure for specified id */ -struct snd_seq_queue *queueptr(int queueid); +queue_t *queueptr(int queueid); /* unlock */ #define queuefree(q) snd_use_lock_free(&(q)->use_lock) /* return the (first) queue matching with the specified name */ -struct snd_seq_queue *snd_seq_queue_find_name(char *name); +queue_t *snd_seq_queue_find_name(char *name); /* check single queue and dispatch events */ -void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop); +void snd_seq_check_queue(queue_t *q, int atomic, int hop); /* access to queue's parameters */ int snd_seq_queue_check_access(int queueid, int client); -int snd_seq_queue_timer_set_tempo(int queueid, int client, struct snd_seq_queue_tempo *info); +int snd_seq_queue_timer_set_tempo(int queueid, int client, snd_seq_queue_tempo_t *info); int snd_seq_queue_set_owner(int queueid, int client, int locked); int snd_seq_queue_set_locked(int queueid, int client, int locked); int snd_seq_queue_timer_open(int queueid); @@ -110,7 +110,7 @@ int snd_seq_queue_timer_close(int queueid); int snd_seq_queue_use(int queueid, int client, int use); int snd_seq_queue_is_used(int queueid, int client); -int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop); +int snd_seq_control_queue(snd_seq_event_t *ev, int atomic, int hop); /* * 64bit division - for sync stuff.. diff --git a/trunk/sound/core/seq/seq_system.c b/trunk/sound/core/seq/seq_system.c index b201b76e9412..0d9eff85ab88 100644 --- a/trunk/sound/core/seq/seq_system.c +++ b/trunk/sound/core/seq/seq_system.c @@ -66,12 +66,12 @@ static int announce_port = -1; /* fill standard header data, source port & channel are filled in */ -static int setheader(struct snd_seq_event * ev, int client, int port) +static int setheader(snd_seq_event_t * ev, int client, int port) { if (announce_port < 0) return -ENODEV; - memset(ev, 0, sizeof(struct snd_seq_event)); + memset(ev, 0, sizeof(snd_seq_event_t)); ev->flags &= ~SNDRV_SEQ_EVENT_LENGTH_MASK; ev->flags |= SNDRV_SEQ_EVENT_LENGTH_FIXED; @@ -92,7 +92,7 @@ static int setheader(struct snd_seq_event * ev, int client, int port) /* entry points for broadcasting system events */ void snd_seq_system_broadcast(int client, int port, int type) { - struct snd_seq_event ev; + snd_seq_event_t ev; if (setheader(&ev, client, port) < 0) return; @@ -101,7 +101,7 @@ void snd_seq_system_broadcast(int client, int port, int type) } /* entry points for broadcasting system events */ -int snd_seq_system_notify(int client, int port, struct snd_seq_event *ev) +int snd_seq_system_notify(int client, int port, snd_seq_event_t *ev) { ev->flags = SNDRV_SEQ_EVENT_LENGTH_FIXED; ev->source.client = sysclient; @@ -112,7 +112,7 @@ int snd_seq_system_notify(int client, int port, struct snd_seq_event *ev) } /* call-back handler for timer events */ -static int event_input_timer(struct snd_seq_event * ev, int direct, void *private_data, int atomic, int hop) +static int event_input_timer(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop) { return snd_seq_control_queue(ev, atomic, hop); } @@ -120,19 +120,34 @@ static int event_input_timer(struct snd_seq_event * ev, int direct, void *privat /* register our internal client */ int __init snd_seq_system_client_init(void) { - struct snd_seq_port_callback pcallbacks; - struct snd_seq_port_info *port; + snd_seq_client_callback_t callbacks; + snd_seq_port_callback_t pcallbacks; + snd_seq_client_info_t *inf; + snd_seq_port_info_t *port; + + inf = kzalloc(sizeof(*inf), GFP_KERNEL); port = kzalloc(sizeof(*port), GFP_KERNEL); - if (!port) + if (! inf || ! port) { + kfree(inf); + kfree(port); return -ENOMEM; + } + memset(&callbacks, 0, sizeof(callbacks)); memset(&pcallbacks, 0, sizeof(pcallbacks)); pcallbacks.owner = THIS_MODULE; pcallbacks.event_input = event_input_timer; /* register client */ - sysclient = snd_seq_create_kernel_client(NULL, 0, "System"); + callbacks.allow_input = callbacks.allow_output = 1; + sysclient = snd_seq_create_kernel_client(NULL, 0, &callbacks); + + /* set our name */ + inf->client = 0; + inf->type = KERNEL_CLIENT; + strcpy(inf->name, "System"); + snd_seq_kernel_client_ctl(sysclient, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, inf); /* register timer */ strcpy(port->name, "Timer"); @@ -156,6 +171,7 @@ int __init snd_seq_system_client_init(void) snd_seq_kernel_client_ctl(sysclient, SNDRV_SEQ_IOCTL_CREATE_PORT, port); announce_port = port->addr.port; + kfree(inf); kfree(port); return 0; } diff --git a/trunk/sound/core/seq/seq_system.h b/trunk/sound/core/seq/seq_system.h index cf2cfa23430e..900007255bb4 100644 --- a/trunk/sound/core/seq/seq_system.h +++ b/trunk/sound/core/seq/seq_system.h @@ -34,7 +34,7 @@ void snd_seq_system_broadcast(int client, int port, int type); #define snd_seq_system_client_ev_port_exit(client, port) snd_seq_system_broadcast(client, port, SNDRV_SEQ_EVENT_PORT_EXIT) #define snd_seq_system_client_ev_port_change(client, port) snd_seq_system_broadcast(client, port, SNDRV_SEQ_EVENT_PORT_CHANGE) -int snd_seq_system_notify(int client, int port, struct snd_seq_event *ev); +int snd_seq_system_notify(int client, int port, snd_seq_event_t *ev); /* register our internal client */ int snd_seq_system_client_init(void); diff --git a/trunk/sound/core/seq/seq_timer.c b/trunk/sound/core/seq/seq_timer.c index b4b9a132cb16..65b64a7c456d 100644 --- a/trunk/sound/core/seq/seq_timer.c +++ b/trunk/sound/core/seq/seq_timer.c @@ -41,7 +41,7 @@ extern int seq_default_timer_resolution; #define SKEW_BASE 0x10000 /* 16bit shift */ -static void snd_seq_timer_set_tick_resolution(struct snd_seq_timer_tick *tick, +static void snd_seq_timer_set_tick_resolution(seq_timer_tick_t *tick, int tempo, int ppq) { if (tempo < 1000000) @@ -60,9 +60,9 @@ static void snd_seq_timer_set_tick_resolution(struct snd_seq_timer_tick *tick, } /* create new timer (constructor) */ -struct snd_seq_timer *snd_seq_timer_new(void) +seq_timer_t *snd_seq_timer_new(void) { - struct snd_seq_timer *tmr; + seq_timer_t *tmr; tmr = kzalloc(sizeof(*tmr), GFP_KERNEL); if (tmr == NULL) { @@ -81,9 +81,9 @@ struct snd_seq_timer *snd_seq_timer_new(void) } /* delete timer (destructor) */ -void snd_seq_timer_delete(struct snd_seq_timer **tmr) +void snd_seq_timer_delete(seq_timer_t **tmr) { - struct snd_seq_timer *t = *tmr; + seq_timer_t *t = *tmr; *tmr = NULL; if (t == NULL) { @@ -99,7 +99,7 @@ void snd_seq_timer_delete(struct snd_seq_timer **tmr) kfree(t); } -void snd_seq_timer_defaults(struct snd_seq_timer * tmr) +void snd_seq_timer_defaults(seq_timer_t * tmr) { /* setup defaults */ tmr->ppq = 96; /* 96 PPQ */ @@ -118,7 +118,7 @@ void snd_seq_timer_defaults(struct snd_seq_timer * tmr) tmr->skew = tmr->skew_base = SKEW_BASE; } -void snd_seq_timer_reset(struct snd_seq_timer * tmr) +void snd_seq_timer_reset(seq_timer_t * tmr) { unsigned long flags; @@ -136,13 +136,13 @@ void snd_seq_timer_reset(struct snd_seq_timer * tmr) /* called by timer interrupt routine. the period time since previous invocation is passed */ -static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, +static void snd_seq_timer_interrupt(snd_timer_instance_t *timeri, unsigned long resolution, unsigned long ticks) { unsigned long flags; - struct snd_seq_queue *q = timeri->callback_data; - struct snd_seq_timer *tmr; + queue_t *q = (queue_t *)timeri->callback_data; + seq_timer_t *tmr; if (q == NULL) return; @@ -177,7 +177,7 @@ static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, } /* set current tempo */ -int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo) +int snd_seq_timer_set_tempo(seq_timer_t * tmr, int tempo) { unsigned long flags; @@ -194,7 +194,7 @@ int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo) } /* set current ppq */ -int snd_seq_timer_set_ppq(struct snd_seq_timer * tmr, int ppq) +int snd_seq_timer_set_ppq(seq_timer_t * tmr, int ppq) { unsigned long flags; @@ -217,8 +217,7 @@ int snd_seq_timer_set_ppq(struct snd_seq_timer * tmr, int ppq) } /* set current tick position */ -int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr, - snd_seq_tick_time_t position) +int snd_seq_timer_set_position_tick(seq_timer_t *tmr, snd_seq_tick_time_t position) { unsigned long flags; @@ -232,8 +231,7 @@ int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr, } /* set current real-time position */ -int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr, - snd_seq_real_time_t position) +int snd_seq_timer_set_position_time(seq_timer_t *tmr, snd_seq_real_time_t position) { unsigned long flags; @@ -247,8 +245,7 @@ int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr, } /* set timer skew */ -int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew, - unsigned int base) +int snd_seq_timer_set_skew(seq_timer_t *tmr, unsigned int skew, unsigned int base) { unsigned long flags; @@ -265,10 +262,10 @@ int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew, return 0; } -int snd_seq_timer_open(struct snd_seq_queue *q) +int snd_seq_timer_open(queue_t *q) { - struct snd_timer_instance *t; - struct snd_seq_timer *tmr; + snd_timer_instance_t *t; + seq_timer_t *tmr; char str[32]; int err; @@ -285,7 +282,7 @@ int snd_seq_timer_open(struct snd_seq_queue *q) if (err < 0 && tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_SLAVE) { if (tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_GLOBAL || tmr->alsa_id.device != SNDRV_TIMER_GLOBAL_SYSTEM) { - struct snd_timer_id tid; + snd_timer_id_t tid; memset(&tid, 0, sizeof(tid)); tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL; tid.dev_sclass = SNDRV_TIMER_SCLASS_SEQUENCER; @@ -305,9 +302,9 @@ int snd_seq_timer_open(struct snd_seq_queue *q) return 0; } -int snd_seq_timer_close(struct snd_seq_queue *q) +int snd_seq_timer_close(queue_t *q) { - struct snd_seq_timer *tmr; + seq_timer_t *tmr; tmr = q->timer; snd_assert(tmr != NULL, return -EINVAL); @@ -319,7 +316,7 @@ int snd_seq_timer_close(struct snd_seq_queue *q) return 0; } -int snd_seq_timer_stop(struct snd_seq_timer * tmr) +int snd_seq_timer_stop(seq_timer_t * tmr) { if (! tmr->timeri) return -EINVAL; @@ -330,9 +327,9 @@ int snd_seq_timer_stop(struct snd_seq_timer * tmr) return 0; } -static int initialize_timer(struct snd_seq_timer *tmr) +static int initialize_timer(seq_timer_t *tmr) { - struct snd_timer *t; + snd_timer_t *t; unsigned long freq; t = tmr->timeri->timer; @@ -361,7 +358,7 @@ static int initialize_timer(struct snd_seq_timer *tmr) return 0; } -int snd_seq_timer_start(struct snd_seq_timer * tmr) +int snd_seq_timer_start(seq_timer_t * tmr) { if (! tmr->timeri) return -EINVAL; @@ -376,7 +373,7 @@ int snd_seq_timer_start(struct snd_seq_timer * tmr) return 0; } -int snd_seq_timer_continue(struct snd_seq_timer * tmr) +int snd_seq_timer_continue(seq_timer_t * tmr) { if (! tmr->timeri) return -EINVAL; @@ -394,7 +391,7 @@ int snd_seq_timer_continue(struct snd_seq_timer * tmr) } /* return current 'real' time. use timeofday() to get better granularity. */ -snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr) +snd_seq_real_time_t snd_seq_timer_get_cur_time(seq_timer_t *tmr) { snd_seq_real_time_t cur_time; @@ -419,21 +416,19 @@ snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr) /* TODO: use interpolation on tick queue (will only be useful for very high PPQ values) */ -snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr) +snd_seq_tick_time_t snd_seq_timer_get_cur_tick(seq_timer_t *tmr) { return tmr->tick.cur_tick; } -#ifdef CONFIG_PROC_FS /* exported to seq_info.c */ -void snd_seq_info_timer_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +void snd_seq_info_timer_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { int idx; - struct snd_seq_queue *q; - struct snd_seq_timer *tmr; - struct snd_timer_instance *ti; + queue_t *q; + seq_timer_t *tmr; + snd_timer_instance_t *ti; unsigned long resolution; for (idx = 0; idx < SNDRV_SEQ_MAX_QUEUES; idx++) { @@ -452,5 +447,3 @@ void snd_seq_info_timer_read(struct snd_info_entry *entry, queuefree(q); } } -#endif /* CONFIG_PROC_FS */ - diff --git a/trunk/sound/core/seq/seq_timer.h b/trunk/sound/core/seq/seq_timer.h index e9ee1543c924..287ed68591de 100644 --- a/trunk/sound/core/seq/seq_timer.h +++ b/trunk/sound/core/seq/seq_timer.h @@ -24,13 +24,13 @@ #include <sound/timer.h> #include <sound/seq_kernel.h> -struct snd_seq_timer_tick { +typedef struct { snd_seq_tick_time_t cur_tick; /* current tick */ unsigned long resolution; /* time per tick in nsec */ unsigned long fraction; /* current time per tick in nsec */ -}; +} seq_timer_tick_t; -struct snd_seq_timer { +typedef struct { /* ... tempo / offset / running state */ unsigned int running:1, /* running state of queue */ @@ -40,12 +40,12 @@ struct snd_seq_timer { int ppq; /* time resolution, ticks/quarter */ snd_seq_real_time_t cur_time; /* current time */ - struct snd_seq_timer_tick tick; /* current tick */ + seq_timer_tick_t tick; /* current tick */ int tick_updated; int type; /* timer type */ - struct snd_timer_id alsa_id; /* ALSA's timer ID */ - struct snd_timer_instance *timeri; /* timer instance */ + snd_timer_id_t alsa_id; /* ALSA's timer ID */ + snd_timer_instance_t *timeri; /* timer instance */ unsigned int ticks; unsigned long preferred_resolution; /* timer resolution, ticks/sec */ @@ -55,18 +55,17 @@ struct snd_seq_timer { struct timeval last_update; /* time of last clock update, used for interpolation */ spinlock_t lock; -}; +} seq_timer_t; /* create new timer (constructor) */ -struct snd_seq_timer *snd_seq_timer_new(void); +extern seq_timer_t *snd_seq_timer_new(void); /* delete timer (destructor) */ -void snd_seq_timer_delete(struct snd_seq_timer **tmr); +extern void snd_seq_timer_delete(seq_timer_t **tmr); /* */ -static inline void snd_seq_timer_update_tick(struct snd_seq_timer_tick *tick, - unsigned long resolution) +static inline void snd_seq_timer_update_tick(seq_timer_tick_t *tick, unsigned long resolution) { if (tick->resolution > 0) { tick->fraction += resolution; @@ -120,22 +119,21 @@ static inline void snd_seq_inc_time_nsec(snd_seq_real_time_t *tm, unsigned long } /* called by timer isr */ -struct snd_seq_queue; -int snd_seq_timer_open(struct snd_seq_queue *q); -int snd_seq_timer_close(struct snd_seq_queue *q); -int snd_seq_timer_midi_open(struct snd_seq_queue *q); -int snd_seq_timer_midi_close(struct snd_seq_queue *q); -void snd_seq_timer_defaults(struct snd_seq_timer *tmr); -void snd_seq_timer_reset(struct snd_seq_timer *tmr); -int snd_seq_timer_stop(struct snd_seq_timer *tmr); -int snd_seq_timer_start(struct snd_seq_timer *tmr); -int snd_seq_timer_continue(struct snd_seq_timer *tmr); -int snd_seq_timer_set_tempo(struct snd_seq_timer *tmr, int tempo); -int snd_seq_timer_set_ppq(struct snd_seq_timer *tmr, int ppq); -int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr, snd_seq_tick_time_t position); -int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr, snd_seq_real_time_t position); -int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew, unsigned int base); -snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr); -snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr); +int snd_seq_timer_open(queue_t *q); +int snd_seq_timer_close(queue_t *q); +int snd_seq_timer_midi_open(queue_t *q); +int snd_seq_timer_midi_close(queue_t *q); +void snd_seq_timer_defaults(seq_timer_t *tmr); +void snd_seq_timer_reset(seq_timer_t *tmr); +int snd_seq_timer_stop(seq_timer_t *tmr); +int snd_seq_timer_start(seq_timer_t *tmr); +int snd_seq_timer_continue(seq_timer_t *tmr); +int snd_seq_timer_set_tempo(seq_timer_t *tmr, int tempo); +int snd_seq_timer_set_ppq(seq_timer_t *tmr, int ppq); +int snd_seq_timer_set_position_tick(seq_timer_t *tmr, snd_seq_tick_time_t position); +int snd_seq_timer_set_position_time(seq_timer_t *tmr, snd_seq_real_time_t position); +int snd_seq_timer_set_skew(seq_timer_t *tmr, unsigned int skew, unsigned int base); +snd_seq_real_time_t snd_seq_timer_get_cur_time(seq_timer_t *tmr); +snd_seq_tick_time_t snd_seq_timer_get_cur_tick(seq_timer_t *tmr); #endif diff --git a/trunk/sound/core/seq/seq_virmidi.c b/trunk/sound/core/seq/seq_virmidi.c index 14fd1a608e14..e4f512aa7426 100644 --- a/trunk/sound/core/seq/seq_virmidi.c +++ b/trunk/sound/core/seq/seq_virmidi.c @@ -56,8 +56,7 @@ MODULE_LICENSE("GPL"); /* * initialize an event record */ -static void snd_virmidi_init_event(struct snd_virmidi *vmidi, - struct snd_seq_event *ev) +static void snd_virmidi_init_event(snd_virmidi_t *vmidi, snd_seq_event_t *ev) { memset(ev, 0, sizeof(*ev)); ev->source.port = vmidi->port; @@ -77,17 +76,16 @@ static void snd_virmidi_init_event(struct snd_virmidi *vmidi, /* * decode input event and put to read buffer of each opened file */ -static int snd_virmidi_dev_receive_event(struct snd_virmidi_dev *rdev, - struct snd_seq_event *ev) +static int snd_virmidi_dev_receive_event(snd_virmidi_dev_t *rdev, snd_seq_event_t *ev) { - struct snd_virmidi *vmidi; + snd_virmidi_t *vmidi; struct list_head *list; unsigned char msg[4]; int len; read_lock(&rdev->filelist_lock); list_for_each(list, &rdev->filelist) { - vmidi = list_entry(list, struct snd_virmidi, list); + vmidi = list_entry(list, snd_virmidi_t, list); if (!vmidi->trigger) continue; if (ev->type == SNDRV_SEQ_EVENT_SYSEX) { @@ -113,9 +111,9 @@ static int snd_virmidi_dev_receive_event(struct snd_virmidi_dev *rdev, * SNDRV_VIRMIDI_SEQ_ATTACH. */ #if 0 -int snd_virmidi_receive(struct snd_rawmidi *rmidi, struct snd_seq_event *ev) +int snd_virmidi_receive(snd_rawmidi_t *rmidi, snd_seq_event_t *ev) { - struct snd_virmidi_dev *rdev; + snd_virmidi_dev_t *rdev; rdev = rmidi->private_data; return snd_virmidi_dev_receive_event(rdev, ev); @@ -125,10 +123,10 @@ int snd_virmidi_receive(struct snd_rawmidi *rmidi, struct snd_seq_event *ev) /* * event handler of virmidi port */ -static int snd_virmidi_event_input(struct snd_seq_event *ev, int direct, +static int snd_virmidi_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct snd_virmidi_dev *rdev; + snd_virmidi_dev_t *rdev; rdev = private_data; if (!(rdev->flags & SNDRV_VIRMIDI_USE)) @@ -139,9 +137,9 @@ static int snd_virmidi_event_input(struct snd_seq_event *ev, int direct, /* * trigger rawmidi stream for input */ -static void snd_virmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_virmidi_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct snd_virmidi *vmidi = substream->runtime->private_data; + snd_virmidi_t *vmidi = substream->runtime->private_data; if (up) { vmidi->trigger = 1; @@ -153,9 +151,9 @@ static void snd_virmidi_input_trigger(struct snd_rawmidi_substream *substream, i /* * trigger rawmidi stream for output */ -static void snd_virmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_virmidi_output_trigger(snd_rawmidi_substream_t * substream, int up) { - struct snd_virmidi *vmidi = substream->runtime->private_data; + snd_virmidi_t *vmidi = substream->runtime->private_data; int count, res; unsigned char buf[32], *pbuf; @@ -200,11 +198,11 @@ static void snd_virmidi_output_trigger(struct snd_rawmidi_substream *substream, /* * open rawmidi handle for input */ -static int snd_virmidi_input_open(struct snd_rawmidi_substream *substream) +static int snd_virmidi_input_open(snd_rawmidi_substream_t * substream) { - struct snd_virmidi_dev *rdev = substream->rmidi->private_data; - struct snd_rawmidi_runtime *runtime = substream->runtime; - struct snd_virmidi *vmidi; + snd_virmidi_dev_t *rdev = substream->rmidi->private_data; + snd_rawmidi_runtime_t *runtime = substream->runtime; + snd_virmidi_t *vmidi; unsigned long flags; vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL); @@ -229,11 +227,11 @@ static int snd_virmidi_input_open(struct snd_rawmidi_substream *substream) /* * open rawmidi handle for output */ -static int snd_virmidi_output_open(struct snd_rawmidi_substream *substream) +static int snd_virmidi_output_open(snd_rawmidi_substream_t * substream) { - struct snd_virmidi_dev *rdev = substream->rmidi->private_data; - struct snd_rawmidi_runtime *runtime = substream->runtime; - struct snd_virmidi *vmidi; + snd_virmidi_dev_t *rdev = substream->rmidi->private_data; + snd_rawmidi_runtime_t *runtime = substream->runtime; + snd_virmidi_t *vmidi; vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL); if (vmidi == NULL) @@ -255,9 +253,9 @@ static int snd_virmidi_output_open(struct snd_rawmidi_substream *substream) /* * close rawmidi handle for input */ -static int snd_virmidi_input_close(struct snd_rawmidi_substream *substream) +static int snd_virmidi_input_close(snd_rawmidi_substream_t * substream) { - struct snd_virmidi *vmidi = substream->runtime->private_data; + snd_virmidi_t *vmidi = substream->runtime->private_data; snd_midi_event_free(vmidi->parser); list_del(&vmidi->list); substream->runtime->private_data = NULL; @@ -268,9 +266,9 @@ static int snd_virmidi_input_close(struct snd_rawmidi_substream *substream) /* * close rawmidi handle for output */ -static int snd_virmidi_output_close(struct snd_rawmidi_substream *substream) +static int snd_virmidi_output_close(snd_rawmidi_substream_t * substream) { - struct snd_virmidi *vmidi = substream->runtime->private_data; + snd_virmidi_t *vmidi = substream->runtime->private_data; snd_midi_event_free(vmidi->parser); substream->runtime->private_data = NULL; kfree(vmidi); @@ -280,10 +278,9 @@ static int snd_virmidi_output_close(struct snd_rawmidi_substream *substream) /* * subscribe callback - allow output to rawmidi device */ -static int snd_virmidi_subscribe(void *private_data, - struct snd_seq_port_subscribe *info) +static int snd_virmidi_subscribe(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_virmidi_dev *rdev; + snd_virmidi_dev_t *rdev; rdev = private_data; if (!try_module_get(rdev->card->module)) @@ -295,10 +292,9 @@ static int snd_virmidi_subscribe(void *private_data, /* * unsubscribe callback - disallow output to rawmidi device */ -static int snd_virmidi_unsubscribe(void *private_data, - struct snd_seq_port_subscribe *info) +static int snd_virmidi_unsubscribe(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_virmidi_dev *rdev; + snd_virmidi_dev_t *rdev; rdev = private_data; rdev->flags &= ~SNDRV_VIRMIDI_SUBSCRIBE; @@ -310,10 +306,9 @@ static int snd_virmidi_unsubscribe(void *private_data, /* * use callback - allow input to rawmidi device */ -static int snd_virmidi_use(void *private_data, - struct snd_seq_port_subscribe *info) +static int snd_virmidi_use(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_virmidi_dev *rdev; + snd_virmidi_dev_t *rdev; rdev = private_data; if (!try_module_get(rdev->card->module)) @@ -325,10 +320,9 @@ static int snd_virmidi_use(void *private_data, /* * unuse callback - disallow input to rawmidi device */ -static int snd_virmidi_unuse(void *private_data, - struct snd_seq_port_subscribe *info) +static int snd_virmidi_unuse(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_virmidi_dev *rdev; + snd_virmidi_dev_t *rdev; rdev = private_data; rdev->flags &= ~SNDRV_VIRMIDI_USE; @@ -341,13 +335,13 @@ static int snd_virmidi_unuse(void *private_data, * Register functions */ -static struct snd_rawmidi_ops snd_virmidi_input_ops = { +static snd_rawmidi_ops_t snd_virmidi_input_ops = { .open = snd_virmidi_input_open, .close = snd_virmidi_input_close, .trigger = snd_virmidi_input_trigger, }; -static struct snd_rawmidi_ops snd_virmidi_output_ops = { +static snd_rawmidi_ops_t snd_virmidi_output_ops = { .open = snd_virmidi_output_open, .close = snd_virmidi_output_close, .trigger = snd_virmidi_output_trigger, @@ -356,32 +350,43 @@ static struct snd_rawmidi_ops snd_virmidi_output_ops = { /* * create a sequencer client and a port */ -static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev) +static int snd_virmidi_dev_attach_seq(snd_virmidi_dev_t *rdev) { int client; - struct snd_seq_port_callback pcallbacks; - struct snd_seq_port_info *pinfo; + snd_seq_client_callback_t callbacks; + snd_seq_port_callback_t pcallbacks; + snd_seq_client_info_t *info; + snd_seq_port_info_t *pinfo; int err; if (rdev->client >= 0) return 0; + info = kmalloc(sizeof(*info), GFP_KERNEL); pinfo = kmalloc(sizeof(*pinfo), GFP_KERNEL); - if (!pinfo) { + if (! info || ! pinfo) { err = -ENOMEM; goto __error; } - client = snd_seq_create_kernel_client(rdev->card, rdev->device, - "%s %d-%d", rdev->rmidi->name, - rdev->card->number, - rdev->device); + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.private_data = rdev; + callbacks.allow_input = 1; + callbacks.allow_output = 1; + client = snd_seq_create_kernel_client(rdev->card, rdev->device, &callbacks); if (client < 0) { err = client; goto __error; } rdev->client = client; + /* set client name */ + memset(info, 0, sizeof(*info)); + info->client = client; + info->type = KERNEL_CLIENT; + sprintf(info->name, "%s %d-%d", rdev->rmidi->name, rdev->card->number, rdev->device); + snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, info); + /* create a port */ memset(pinfo, 0, sizeof(*pinfo)); pinfo->addr.client = client; @@ -412,6 +417,7 @@ static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev) err = 0; /* success */ __error: + kfree(info); kfree(pinfo); return err; } @@ -420,7 +426,7 @@ static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev) /* * release the sequencer client */ -static void snd_virmidi_dev_detach_seq(struct snd_virmidi_dev *rdev) +static void snd_virmidi_dev_detach_seq(snd_virmidi_dev_t *rdev) { if (rdev->client >= 0) { snd_seq_delete_kernel_client(rdev->client); @@ -431,9 +437,9 @@ static void snd_virmidi_dev_detach_seq(struct snd_virmidi_dev *rdev) /* * register the device */ -static int snd_virmidi_dev_register(struct snd_rawmidi *rmidi) +static int snd_virmidi_dev_register(snd_rawmidi_t *rmidi) { - struct snd_virmidi_dev *rdev = rmidi->private_data; + snd_virmidi_dev_t *rdev = rmidi->private_data; int err; switch (rdev->seq_mode) { @@ -458,9 +464,9 @@ static int snd_virmidi_dev_register(struct snd_rawmidi *rmidi) /* * unregister the device */ -static int snd_virmidi_dev_unregister(struct snd_rawmidi *rmidi) +static int snd_virmidi_dev_unregister(snd_rawmidi_t *rmidi) { - struct snd_virmidi_dev *rdev = rmidi->private_data; + snd_virmidi_dev_t *rdev = rmidi->private_data; if (rdev->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH) snd_virmidi_dev_detach_seq(rdev); @@ -470,7 +476,7 @@ static int snd_virmidi_dev_unregister(struct snd_rawmidi *rmidi) /* * */ -static struct snd_rawmidi_global_ops snd_virmidi_global_ops = { +static snd_rawmidi_global_ops_t snd_virmidi_global_ops = { .dev_register = snd_virmidi_dev_register, .dev_unregister = snd_virmidi_dev_unregister, }; @@ -478,9 +484,9 @@ static struct snd_rawmidi_global_ops snd_virmidi_global_ops = { /* * free device */ -static void snd_virmidi_free(struct snd_rawmidi *rmidi) +static void snd_virmidi_free(snd_rawmidi_t *rmidi) { - struct snd_virmidi_dev *rdev = rmidi->private_data; + snd_virmidi_dev_t *rdev = rmidi->private_data; kfree(rdev); } @@ -489,10 +495,10 @@ static void snd_virmidi_free(struct snd_rawmidi *rmidi) * */ /* exported */ -int snd_virmidi_new(struct snd_card *card, int device, struct snd_rawmidi **rrmidi) +int snd_virmidi_new(snd_card_t *card, int device, snd_rawmidi_t **rrmidi) { - struct snd_rawmidi *rmidi; - struct snd_virmidi_dev *rdev; + snd_rawmidi_t *rmidi; + snd_virmidi_dev_t *rdev; int err; *rrmidi = NULL; diff --git a/trunk/sound/core/sound.c b/trunk/sound/core/sound.c index a8eda02bcf1c..6e7cad1e947e 100644 --- a/trunk/sound/core/sound.c +++ b/trunk/sound/core/sound.c @@ -23,7 +23,6 @@ #include <linux/init.h> #include <linux/slab.h> #include <linux/time.h> -#include <linux/device.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/minors.h> @@ -33,6 +32,7 @@ #include <sound/initval.h> #include <linux/kmod.h> #include <linux/devfs_fs_kernel.h> +#include <linux/platform_device.h> #define SNDRV_OS_MINORS 256 @@ -60,7 +60,8 @@ MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR); */ int snd_ecards_limit; -static struct snd_minor *snd_minors[SNDRV_OS_MINORS]; +static struct list_head snd_minors_hash[SNDRV_CARDS]; + static DECLARE_MUTEX(sound_mutex); extern struct class *sound_class; @@ -107,61 +108,44 @@ static void snd_request_other(int minor) #endif /* request_module support */ -/** - * snd_lookup_minor_data - get user data of a registered device - * @minor: the minor number - * @type: device type (SNDRV_DEVICE_TYPE_XXX) - * - * Checks that a minor device with the specified type is registered, and returns - * its user data pointer. - */ -void *snd_lookup_minor_data(unsigned int minor, int type) +static snd_minor_t *snd_minor_search(int minor) { - struct snd_minor *mreg; - void *private_data; + struct list_head *list; + snd_minor_t *mptr; - if (minor > ARRAY_SIZE(snd_minors)) - return NULL; - down(&sound_mutex); - mreg = snd_minors[minor]; - if (mreg && mreg->type == type) - private_data = mreg->private_data; - else - private_data = NULL; - up(&sound_mutex); - return private_data; + list_for_each(list, &snd_minors_hash[SNDRV_MINOR_CARD(minor)]) { + mptr = list_entry(list, snd_minor_t, list); + if (mptr->number == minor) + return mptr; + } + return NULL; } static int snd_open(struct inode *inode, struct file *file) { - unsigned int minor = iminor(inode); - struct snd_minor *mptr = NULL; + int minor = iminor(inode); + int card = SNDRV_MINOR_CARD(minor); + int dev = SNDRV_MINOR_DEVICE(minor); + snd_minor_t *mptr = NULL; struct file_operations *old_fops; int err = 0; - if (minor > ARRAY_SIZE(snd_minors)) - return -ENODEV; - mptr = snd_minors[minor]; - if (mptr == NULL) { + if (dev != SNDRV_MINOR_GLOBAL) { + if (snd_cards[card] == NULL) { #ifdef CONFIG_KMOD - int dev = SNDRV_MINOR_DEVICE(minor); - if (dev == SNDRV_MINOR_CONTROL) { - /* /dev/aloadC? */ - int card = SNDRV_MINOR_CARD(minor); + snd_request_card(card); if (snd_cards[card] == NULL) - snd_request_card(card); - } else if (dev == SNDRV_MINOR_GLOBAL) { - /* /dev/aloadSEQ */ - snd_request_other(minor); - } -#ifndef CONFIG_SND_DYNAMIC_MINORS - /* /dev/snd/{controlC?,seq} */ - mptr = snd_minors[minor]; - if (mptr == NULL) #endif + return -ENODEV; + } + } else { +#ifdef CONFIG_KMOD + if ((mptr = snd_minor_search(minor)) == NULL) + snd_request_other(minor); #endif - return -ENODEV; } + if (mptr == NULL && (mptr = snd_minor_search(minor)) == NULL) + return -ENODEV; old_fops = file->f_op; file->f_op = fops_get(mptr->f_ops); if (file->f_op->open) @@ -180,23 +164,7 @@ static struct file_operations snd_fops = .open = snd_open }; -#ifdef CONFIG_SND_DYNAMIC_MINORS -static int snd_find_free_minor(void) -{ - int minor; - - for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { - /* skip minors still used statically for autoloading devices */ - if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL || - minor == SNDRV_MINOR_SEQUENCER) - continue; - if (!snd_minors[minor]) - return minor; - } - return -EBUSY; -} -#else -static int snd_kernel_minor(int type, struct snd_card *card, int dev) +static int snd_kernel_minor(int type, snd_card_t * card, int dev) { int minor; @@ -222,15 +190,13 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev) snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL); return minor; } -#endif /** * snd_register_device - Register the ALSA device file for the card * @type: the device type, SNDRV_DEVICE_TYPE_XXX * @card: the card instance * @dev: the device index - * @f_ops: the file operations - * @private_data: user pointer for f_ops->open() + * @reg: the snd_minor_t record * @name: the device file name * * Registers an ALSA device file for the given card. @@ -238,39 +204,30 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev) * * Retrurns zero if successful, or a negative error code on failure. */ -int snd_register_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, void *private_data, - const char *name) +int snd_register_device(int type, snd_card_t * card, int dev, snd_minor_t * reg, const char *name) { - int minor; - struct snd_minor *preg; + int minor = snd_kernel_minor(type, card, dev); + snd_minor_t *preg; struct device *device = NULL; + if (minor < 0) + return minor; snd_assert(name, return -EINVAL); - preg = kmalloc(sizeof(struct snd_minor) + strlen(name) + 1, GFP_KERNEL); + preg = (snd_minor_t *)kmalloc(sizeof(snd_minor_t) + strlen(name) + 1, GFP_KERNEL); if (preg == NULL) return -ENOMEM; - preg->type = type; - preg->card = card ? card->number : -1; + *preg = *reg; + preg->number = minor; preg->device = dev; - preg->f_ops = f_ops; - preg->private_data = private_data; strcpy(preg->name, name); down(&sound_mutex); -#ifdef CONFIG_SND_DYNAMIC_MINORS - minor = snd_find_free_minor(); -#else - minor = snd_kernel_minor(type, card, dev); - if (minor >= 0 && snd_minors[minor]) - minor = -EBUSY; -#endif - if (minor < 0) { + if (snd_minor_search(minor)) { up(&sound_mutex); kfree(preg); - return minor; + return -EBUSY; } - snd_minors[minor] = preg; - if (type != SNDRV_DEVICE_TYPE_CONTROL || preg->card >= cards_limit) + list_add_tail(&preg->list, &snd_minors_hash[SNDRV_MINOR_CARD(minor)]); + if (strncmp(name, "controlC", 8) || card->number >= cards_limit) devfs_mk_cdev(MKDEV(major, minor), S_IFCHR | device_mode, "snd/%s", name); if (card) device = card->dev; @@ -291,92 +248,61 @@ int snd_register_device(int type, struct snd_card *card, int dev, * * Returns zero if sucecessful, or a negative error code on failure */ -int snd_unregister_device(int type, struct snd_card *card, int dev) +int snd_unregister_device(int type, snd_card_t * card, int dev) { - int cardnum, minor; - struct snd_minor *mptr; + int minor = snd_kernel_minor(type, card, dev); + snd_minor_t *mptr; - cardnum = card ? card->number : -1; + if (minor < 0) + return minor; down(&sound_mutex); - for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) - if ((mptr = snd_minors[minor]) != NULL && - mptr->type == type && - mptr->card == cardnum && - mptr->device == dev) - break; - if (minor == ARRAY_SIZE(snd_minors)) { + if ((mptr = snd_minor_search(minor)) == NULL) { up(&sound_mutex); return -EINVAL; } - if (mptr->type != SNDRV_DEVICE_TYPE_CONTROL || - mptr->card >= cards_limit) /* created in sound.c */ + if (strncmp(mptr->name, "controlC", 8) || card->number >= cards_limit) /* created in sound.c */ devfs_remove("snd/%s", mptr->name); class_device_destroy(sound_class, MKDEV(major, minor)); - snd_minors[minor] = NULL; + list_del(&mptr->list); up(&sound_mutex); kfree(mptr); return 0; } -#ifdef CONFIG_PROC_FS /* * INFO PART */ -static struct snd_info_entry *snd_minor_info_entry = NULL; - -static const char *snd_device_type_name(int type) -{ - switch (type) { - case SNDRV_DEVICE_TYPE_CONTROL: - return "control"; - case SNDRV_DEVICE_TYPE_HWDEP: - return "hardware dependent"; - case SNDRV_DEVICE_TYPE_RAWMIDI: - return "raw midi"; - case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: - return "digital audio playback"; - case SNDRV_DEVICE_TYPE_PCM_CAPTURE: - return "digital audio capture"; - case SNDRV_DEVICE_TYPE_SEQUENCER: - return "sequencer"; - case SNDRV_DEVICE_TYPE_TIMER: - return "timer"; - default: - return "?"; - } -} +static snd_info_entry_t *snd_minor_info_entry = NULL; -static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void snd_minor_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - int minor; - struct snd_minor *mptr; + int card, device; + struct list_head *list; + snd_minor_t *mptr; down(&sound_mutex); - for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) { - if (!(mptr = snd_minors[minor])) - continue; - if (mptr->card >= 0) { - if (mptr->device >= 0) - snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n", - minor, mptr->card, mptr->device, - snd_device_type_name(mptr->type)); - else - snd_iprintf(buffer, "%3i: [%2i] : %s\n", - minor, mptr->card, - snd_device_type_name(mptr->type)); - } else - snd_iprintf(buffer, "%3i: : %s\n", minor, - snd_device_type_name(mptr->type)); + for (card = 0; card < SNDRV_CARDS; card++) { + list_for_each(list, &snd_minors_hash[card]) { + mptr = list_entry(list, snd_minor_t, list); + if (SNDRV_MINOR_DEVICE(mptr->number) != SNDRV_MINOR_GLOBAL) { + if ((device = mptr->device) >= 0) + snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", mptr->number, card, device, mptr->comment); + else + snd_iprintf(buffer, "%3i: [%i] : %s\n", mptr->number, card, mptr->comment); + } else { + snd_iprintf(buffer, "%3i: : %s\n", mptr->number, mptr->comment); + } + } } up(&sound_mutex); } int __init snd_minor_info_init(void) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL); if (entry) { @@ -397,18 +323,27 @@ int __exit snd_minor_info_done(void) snd_info_unregister(snd_minor_info_entry); return 0; } -#endif /* CONFIG_PROC_FS */ /* * INIT PART */ +#ifdef CONFIG_SND_GENERIC_DRIVER +extern struct platform_driver snd_generic_driver; +#endif + static int __init alsa_sound_init(void) { short controlnum; + int err; + int card; snd_major = major; snd_ecards_limit = cards_limit; + for (card = 0; card < SNDRV_CARDS; card++) + INIT_LIST_HEAD(&snd_minors_hash[card]); + if ((err = snd_oss_init_module()) < 0) + return err; devfs_mk_dir("snd"); if (register_chrdev(major, "alsa", &snd_fops)) { snd_printk(KERN_ERR "unable to register native major device number %d\n", major); @@ -421,6 +356,9 @@ static int __init alsa_sound_init(void) return -ENOMEM; } snd_info_minor_register(); +#ifdef CONFIG_SND_GENERIC_DRIVER + platform_driver_register(&snd_generic_driver); +#endif for (controlnum = 0; controlnum < cards_limit; controlnum++) devfs_mk_cdev(MKDEV(major, controlnum<<5), S_IFCHR | device_mode, "snd/controlC%d", controlnum); #ifndef MODULE @@ -436,6 +374,9 @@ static void __exit alsa_sound_exit(void) for (controlnum = 0; controlnum < cards_limit; controlnum++) devfs_remove("snd/controlC%d", controlnum); +#ifdef CONFIG_SND_GENERIC_DRIVER + platform_driver_unregister(&snd_generic_driver); +#endif snd_info_minor_unregister(); snd_info_done(); if (unregister_chrdev(major, "alsa") != 0) @@ -454,11 +395,9 @@ EXPORT_SYMBOL(snd_request_card); #endif EXPORT_SYMBOL(snd_register_device); EXPORT_SYMBOL(snd_unregister_device); -EXPORT_SYMBOL(snd_lookup_minor_data); #if defined(CONFIG_SND_OSSEMUL) EXPORT_SYMBOL(snd_register_oss_device); EXPORT_SYMBOL(snd_unregister_oss_device); -EXPORT_SYMBOL(snd_lookup_oss_minor_data); #endif /* memory.c */ EXPORT_SYMBOL(copy_to_user_fromio); @@ -476,8 +415,19 @@ EXPORT_SYMBOL(snd_card_register); EXPORT_SYMBOL(snd_component_add); EXPORT_SYMBOL(snd_card_file_add); EXPORT_SYMBOL(snd_card_file_remove); +#ifdef CONFIG_SND_GENERIC_DRIVER +EXPORT_SYMBOL(snd_card_set_generic_dev); +#endif #ifdef CONFIG_PM EXPORT_SYMBOL(snd_power_wait); +EXPORT_SYMBOL(snd_card_set_pm_callback); +#ifdef CONFIG_SND_GENERIC_DRIVER +EXPORT_SYMBOL(snd_card_set_generic_pm_callback); +#endif +#ifdef CONFIG_PCI +EXPORT_SYMBOL(snd_card_pci_suspend); +EXPORT_SYMBOL(snd_card_pci_resume); +#endif #endif /* device.c */ EXPORT_SYMBOL(snd_device_new); diff --git a/trunk/sound/core/sound_oss.c b/trunk/sound/core/sound_oss.c index d0be32b517c1..e401c6703297 100644 --- a/trunk/sound/core/sound_oss.c +++ b/trunk/sound/core/sound_oss.c @@ -35,29 +35,26 @@ #include <sound/info.h> #include <linux/sound.h> -#define SNDRV_OSS_MINORS 128 +#define SNDRV_OS_MINORS 256 + +static struct list_head snd_oss_minors_hash[SNDRV_CARDS]; -static struct snd_minor *snd_oss_minors[SNDRV_OSS_MINORS]; static DECLARE_MUTEX(sound_oss_mutex); -void *snd_lookup_oss_minor_data(unsigned int minor, int type) +static snd_minor_t *snd_oss_minor_search(int minor) { - struct snd_minor *mreg; - void *private_data; + struct list_head *list; + snd_minor_t *mptr; - if (minor > ARRAY_SIZE(snd_oss_minors)) - return NULL; - down(&sound_oss_mutex); - mreg = snd_oss_minors[minor]; - if (mreg && mreg->type == type) - private_data = mreg->private_data; - else - private_data = NULL; - up(&sound_oss_mutex); - return private_data; + list_for_each(list, &snd_oss_minors_hash[SNDRV_MINOR_OSS_CARD(minor)]) { + mptr = list_entry(list, snd_minor_t, list); + if (mptr->number == minor) + return mptr; + } + return NULL; } -static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev) +static int snd_oss_kernel_minor(int type, snd_card_t * card, int dev) { int minor; @@ -89,36 +86,30 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev) default: return -EINVAL; } - snd_assert(minor >= 0 && minor < SNDRV_OSS_MINORS, return -EINVAL); + snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL); return minor; } -int snd_register_oss_device(int type, struct snd_card *card, int dev, - struct file_operations *f_ops, void *private_data, - const char *name) +int snd_register_oss_device(int type, snd_card_t * card, int dev, snd_minor_t * reg, const char *name) { int minor = snd_oss_kernel_minor(type, card, dev); int minor_unit; - struct snd_minor *preg; + snd_minor_t *preg; int cidx = SNDRV_MINOR_OSS_CARD(minor); int track2 = -1; int register1 = -1, register2 = -1; struct device *carddev = NULL; - if (card && card->number >= 8) - return 0; /* ignore silently */ if (minor < 0) return minor; - preg = kmalloc(sizeof(struct snd_minor), GFP_KERNEL); + preg = (snd_minor_t *)kmalloc(sizeof(snd_minor_t), GFP_KERNEL); if (preg == NULL) return -ENOMEM; - preg->type = type; - preg->card = card ? card->number : -1; + *preg = *reg; + preg->number = minor; preg->device = dev; - preg->f_ops = f_ops; - preg->private_data = private_data; down(&sound_oss_mutex); - snd_oss_minors[minor] = preg; + list_add_tail(&preg->list, &snd_oss_minors_hash[cidx]); minor_unit = SNDRV_MINOR_OSS_DEVICE(minor); switch (minor_unit) { case SNDRV_MINOR_OSS_PCM: @@ -133,15 +124,13 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev, } if (card) carddev = card->dev; - register1 = register_sound_special_device(f_ops, minor, carddev); + register1 = register_sound_special_device(reg->f_ops, minor, carddev); if (register1 != minor) goto __end; if (track2 >= 0) { - register2 = register_sound_special_device(f_ops, track2, - carddev); + register2 = register_sound_special_device(reg->f_ops, track2, carddev); if (register2 != track2) goto __end; - snd_oss_minors[track2] = preg; } up(&sound_oss_mutex); return 0; @@ -151,25 +140,23 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev, unregister_sound_special(register2); if (register1 >= 0) unregister_sound_special(register1); - snd_oss_minors[minor] = NULL; + list_del(&preg->list); up(&sound_oss_mutex); kfree(preg); return -EBUSY; } -int snd_unregister_oss_device(int type, struct snd_card *card, int dev) +int snd_unregister_oss_device(int type, snd_card_t * card, int dev) { int minor = snd_oss_kernel_minor(type, card, dev); int cidx = SNDRV_MINOR_OSS_CARD(minor); int track2 = -1; - struct snd_minor *mptr; + snd_minor_t *mptr; - if (card && card->number >= 8) - return 0; if (minor < 0) return minor; down(&sound_oss_mutex); - mptr = snd_oss_minors[minor]; + mptr = snd_oss_minor_search(minor); if (mptr == NULL) { up(&sound_oss_mutex); return -ENOENT; @@ -186,11 +173,9 @@ int snd_unregister_oss_device(int type, struct snd_card *card, int dev) track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1); break; } - if (track2 >= 0) { + if (track2 >= 0) unregister_sound_special(track2); - snd_oss_minors[track2] = NULL; - } - snd_oss_minors[minor] = NULL; + list_del(&mptr->list); up(&sound_oss_mutex); kfree(mptr); return 0; @@ -202,52 +187,36 @@ int snd_unregister_oss_device(int type, struct snd_card *card, int dev) #ifdef CONFIG_PROC_FS -static struct snd_info_entry *snd_minor_info_oss_entry = NULL; - -static const char *snd_oss_device_type_name(int type) -{ - switch (type) { - case SNDRV_OSS_DEVICE_TYPE_MIXER: - return "mixer"; - case SNDRV_OSS_DEVICE_TYPE_SEQUENCER: - case SNDRV_OSS_DEVICE_TYPE_MUSIC: - return "sequencer"; - case SNDRV_OSS_DEVICE_TYPE_PCM: - return "digital audio"; - case SNDRV_OSS_DEVICE_TYPE_MIDI: - return "raw midi"; - case SNDRV_OSS_DEVICE_TYPE_DMFM: - return "hardware dependent"; - default: - return "?"; - } -} +static snd_info_entry_t *snd_minor_info_oss_entry = NULL; -static void snd_minor_info_oss_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_minor_info_oss_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - int minor; - struct snd_minor *mptr; + int card, dev; + struct list_head *list; + snd_minor_t *mptr; down(&sound_oss_mutex); - for (minor = 0; minor < SNDRV_OSS_MINORS; ++minor) { - if (!(mptr = snd_oss_minors[minor])) - continue; - if (mptr->card >= 0) - snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", minor, - mptr->card, mptr->device, - snd_oss_device_type_name(mptr->type)); - else - snd_iprintf(buffer, "%3i: : %s\n", minor, - snd_oss_device_type_name(mptr->type)); + for (card = 0; card < SNDRV_CARDS; card++) { + list_for_each(list, &snd_oss_minors_hash[card]) { + mptr = list_entry(list, snd_minor_t, list); + dev = SNDRV_MINOR_OSS_DEVICE(mptr->number); + if (dev != SNDRV_MINOR_OSS_SNDSTAT && + dev != SNDRV_MINOR_OSS_SEQUENCER && + dev != SNDRV_MINOR_OSS_MUSIC) + snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", mptr->number, card, dev, mptr->comment); + else + snd_iprintf(buffer, "%3i: : %s\n", mptr->number, mptr->comment); + } } up(&sound_oss_mutex); } +#endif /* CONFIG_PROC_FS */ int __init snd_minor_info_oss_init(void) { - struct snd_info_entry *entry; +#ifdef CONFIG_PROC_FS + snd_info_entry_t *entry; entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root); if (entry) { @@ -259,15 +228,26 @@ int __init snd_minor_info_oss_init(void) } } snd_minor_info_oss_entry = entry; +#endif return 0; } int __exit snd_minor_info_oss_done(void) { +#ifdef CONFIG_PROC_FS if (snd_minor_info_oss_entry) snd_info_unregister(snd_minor_info_oss_entry); +#endif + return 0; +} + +int __init snd_oss_init_module(void) +{ + int card; + + for (card = 0; card < SNDRV_CARDS; card++) + INIT_LIST_HEAD(&snd_oss_minors_hash[card]); return 0; } -#endif /* CONFIG_PROC_FS */ #endif /* CONFIG_SND_OSSEMUL */ diff --git a/trunk/sound/core/timer.c b/trunk/sound/core/timer.c index 2425b971b240..1b90a38d10ff 100644 --- a/trunk/sound/core/timer.c +++ b/trunk/sound/core/timer.c @@ -53,8 +53,8 @@ MODULE_LICENSE("GPL"); module_param(timer_limit, int, 0444); MODULE_PARM_DESC(timer_limit, "Maximum global timers in system."); -struct snd_timer_user { - struct snd_timer_instance *timeri; +typedef struct { + snd_timer_instance_t *timeri; int tread; /* enhanced read with timestamps and events */ unsigned long ticks; unsigned long overrun; @@ -62,8 +62,8 @@ struct snd_timer_user { int qtail; int qused; int queue_size; - struct snd_timer_read *queue; - struct snd_timer_tread *tqueue; + snd_timer_read_t *queue; + snd_timer_tread_t *tqueue; spinlock_t qlock; unsigned long last_resolution; unsigned int filter; @@ -71,7 +71,7 @@ struct snd_timer_user { wait_queue_head_t qchange_sleep; struct fasync_struct *fasync; struct semaphore tread_sem; -}; +} snd_timer_user_t; /* list of timers */ static LIST_HEAD(snd_timer_list); @@ -84,21 +84,21 @@ static DEFINE_SPINLOCK(slave_active_lock); static DECLARE_MUTEX(register_mutex); -static int snd_timer_free(struct snd_timer *timer); -static int snd_timer_dev_free(struct snd_device *device); -static int snd_timer_dev_register(struct snd_device *device); -static int snd_timer_dev_unregister(struct snd_device *device); +static int snd_timer_free(snd_timer_t *timer); +static int snd_timer_dev_free(snd_device_t *device); +static int snd_timer_dev_register(snd_device_t *device); +static int snd_timer_dev_unregister(snd_device_t *device); -static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left); +static void snd_timer_reschedule(snd_timer_t * timer, unsigned long ticks_left); /* * create a timer instance with the given owner string. * when timer is not NULL, increments the module counter */ -static struct snd_timer_instance *snd_timer_instance_new(char *owner, - struct snd_timer *timer) +static snd_timer_instance_t *snd_timer_instance_new(char *owner, + snd_timer_t *timer) { - struct snd_timer_instance *timeri; + snd_timer_instance_t *timeri; timeri = kzalloc(sizeof(*timeri), GFP_KERNEL); if (timeri == NULL) return NULL; @@ -126,13 +126,13 @@ static struct snd_timer_instance *snd_timer_instance_new(char *owner, /* * find a timer instance from the given timer id */ -static struct snd_timer *snd_timer_find(struct snd_timer_id *tid) +static snd_timer_t *snd_timer_find(snd_timer_id_t *tid) { - struct snd_timer *timer = NULL; + snd_timer_t *timer = NULL; struct list_head *p; list_for_each(p, &snd_timer_list) { - timer = list_entry(p, struct snd_timer, device_list); + timer = list_entry(p, snd_timer_t, device_list); if (timer->tmr_class != tid->dev_class) continue; @@ -152,7 +152,7 @@ static struct snd_timer *snd_timer_find(struct snd_timer_id *tid) #ifdef CONFIG_KMOD -static void snd_timer_request(struct snd_timer_id *tid) +static void snd_timer_request(snd_timer_id_t *tid) { if (! current->fs->root) return; @@ -179,17 +179,17 @@ static void snd_timer_request(struct snd_timer_id *tid) * * call this with register_mutex down. */ -static void snd_timer_check_slave(struct snd_timer_instance *slave) +static void snd_timer_check_slave(snd_timer_instance_t *slave) { - struct snd_timer *timer; - struct snd_timer_instance *master; + snd_timer_t *timer; + snd_timer_instance_t *master; struct list_head *p, *q; /* FIXME: it's really dumb to look up all entries.. */ list_for_each(p, &snd_timer_list) { - timer = list_entry(p, struct snd_timer, device_list); + timer = list_entry(p, snd_timer_t, device_list); list_for_each(q, &timer->open_list_head) { - master = list_entry(q, struct snd_timer_instance, open_list); + master = list_entry(q, snd_timer_instance_t, open_list); if (slave->slave_class == master->slave_class && slave->slave_id == master->slave_id) { list_del(&slave->open_list); @@ -211,14 +211,14 @@ static void snd_timer_check_slave(struct snd_timer_instance *slave) * * call this with register_mutex down. */ -static void snd_timer_check_master(struct snd_timer_instance *master) +static void snd_timer_check_master(snd_timer_instance_t *master) { - struct snd_timer_instance *slave; + snd_timer_instance_t *slave; struct list_head *p, *n; /* check all pending slaves */ list_for_each_safe(p, n, &snd_timer_slave_list) { - slave = list_entry(p, struct snd_timer_instance, open_list); + slave = list_entry(p, snd_timer_instance_t, open_list); if (slave->slave_class == master->slave_class && slave->slave_id == master->slave_id) { list_del(p); @@ -238,12 +238,12 @@ static void snd_timer_check_master(struct snd_timer_instance *master) * open a timer instance * when opening a master, the slave id must be here given. */ -int snd_timer_open(struct snd_timer_instance **ti, - char *owner, struct snd_timer_id *tid, +int snd_timer_open(snd_timer_instance_t **ti, + char *owner, snd_timer_id_t *tid, unsigned int slave_id) { - struct snd_timer *timer; - struct snd_timer_instance *timeri = NULL; + snd_timer_t *timer; + snd_timer_instance_t *timeri = NULL; if (tid->dev_class == SNDRV_TIMER_CLASS_SLAVE) { /* open a slave instance */ @@ -285,7 +285,7 @@ int snd_timer_open(struct snd_timer_instance **ti, } if (!list_empty(&timer->open_list_head)) { timeri = list_entry(timer->open_list_head.next, - struct snd_timer_instance, open_list); + snd_timer_instance_t, open_list); if (timeri->flags & SNDRV_TIMER_IFLG_EXCLUSIVE) { up(®ister_mutex); return -EBUSY; @@ -307,17 +307,17 @@ int snd_timer_open(struct snd_timer_instance **ti, return 0; } -static int _snd_timer_stop(struct snd_timer_instance *timeri, - int keep_flag, int event); +static int _snd_timer_stop(snd_timer_instance_t * timeri, + int keep_flag, enum sndrv_timer_event event); /* * close a timer instance */ -int snd_timer_close(struct snd_timer_instance *timeri) +int snd_timer_close(snd_timer_instance_t * timeri) { - struct snd_timer *timer = NULL; + snd_timer_t *timer = NULL; struct list_head *p, *n; - struct snd_timer_instance *slave; + snd_timer_instance_t *slave; snd_assert(timeri != NULL, return -ENXIO); @@ -353,7 +353,7 @@ int snd_timer_close(struct snd_timer_instance *timeri) timer->hw.close(timer); /* remove slave links */ list_for_each_safe(p, n, &timeri->slave_list_head) { - slave = list_entry(p, struct snd_timer_instance, open_list); + slave = list_entry(p, snd_timer_instance_t, open_list); spin_lock_irq(&slave_active_lock); _snd_timer_stop(slave, 1, SNDRV_TIMER_EVENT_RESOLUTION); list_del(p); @@ -373,9 +373,9 @@ int snd_timer_close(struct snd_timer_instance *timeri) return 0; } -unsigned long snd_timer_resolution(struct snd_timer_instance *timeri) +unsigned long snd_timer_resolution(snd_timer_instance_t * timeri) { - struct snd_timer * timer; + snd_timer_t * timer; if (timeri == NULL) return 0; @@ -387,12 +387,13 @@ unsigned long snd_timer_resolution(struct snd_timer_instance *timeri) return 0; } -static void snd_timer_notify1(struct snd_timer_instance *ti, int event) +static void snd_timer_notify1(snd_timer_instance_t *ti, + enum sndrv_timer_event event) { - struct snd_timer *timer; + snd_timer_t *timer; unsigned long flags; unsigned long resolution = 0; - struct snd_timer_instance *ts; + snd_timer_instance_t *ts; struct list_head *n; struct timespec tstamp; @@ -413,14 +414,14 @@ static void snd_timer_notify1(struct snd_timer_instance *ti, int event) return; spin_lock_irqsave(&timer->lock, flags); list_for_each(n, &ti->slave_active_head) { - ts = list_entry(n, struct snd_timer_instance, active_list); + ts = list_entry(n, snd_timer_instance_t, active_list); if (ts->ccallback) ts->ccallback(ti, event + 100, &tstamp, resolution); } spin_unlock_irqrestore(&timer->lock, flags); } -static int snd_timer_start1(struct snd_timer *timer, struct snd_timer_instance *timeri, +static int snd_timer_start1(snd_timer_t *timer, snd_timer_instance_t *timeri, unsigned long sticks) { list_del(&timeri->active_list); @@ -441,7 +442,7 @@ static int snd_timer_start1(struct snd_timer *timer, struct snd_timer_instance * } } -static int snd_timer_start_slave(struct snd_timer_instance *timeri) +static int snd_timer_start_slave(snd_timer_instance_t *timeri) { unsigned long flags; @@ -457,9 +458,9 @@ static int snd_timer_start_slave(struct snd_timer_instance *timeri) /* * start the timer instance */ -int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks) +int snd_timer_start(snd_timer_instance_t * timeri, unsigned int ticks) { - struct snd_timer *timer; + snd_timer_t *timer; int result = -EINVAL; unsigned long flags; @@ -482,10 +483,10 @@ int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks) return result; } -static int _snd_timer_stop(struct snd_timer_instance * timeri, - int keep_flag, int event) +static int _snd_timer_stop(snd_timer_instance_t * timeri, + int keep_flag, enum sndrv_timer_event event) { - struct snd_timer *timer; + snd_timer_t *timer; unsigned long flags; snd_assert(timeri != NULL, return -ENXIO); @@ -531,9 +532,9 @@ static int _snd_timer_stop(struct snd_timer_instance * timeri, * * do not call this from the timer callback! */ -int snd_timer_stop(struct snd_timer_instance *timeri) +int snd_timer_stop(snd_timer_instance_t * timeri) { - struct snd_timer *timer; + snd_timer_t *timer; unsigned long flags; int err; @@ -551,9 +552,9 @@ int snd_timer_stop(struct snd_timer_instance *timeri) /* * start again.. the tick is kept. */ -int snd_timer_continue(struct snd_timer_instance *timeri) +int snd_timer_continue(snd_timer_instance_t * timeri) { - struct snd_timer *timer; + snd_timer_t *timer; int result = -EINVAL; unsigned long flags; @@ -577,7 +578,7 @@ int snd_timer_continue(struct snd_timer_instance *timeri) /* * pause.. remember the ticks left */ -int snd_timer_pause(struct snd_timer_instance * timeri) +int snd_timer_pause(snd_timer_instance_t * timeri) { return _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_PAUSE); } @@ -588,14 +589,14 @@ int snd_timer_pause(struct snd_timer_instance * timeri) * start pending instances and check the scheduling ticks. * when the scheduling ticks is changed set CHANGE flag to reprogram the timer. */ -static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left) +static void snd_timer_reschedule(snd_timer_t * timer, unsigned long ticks_left) { - struct snd_timer_instance *ti; + snd_timer_instance_t *ti; unsigned long ticks = ~0UL; struct list_head *p; list_for_each(p, &timer->active_list_head) { - ti = list_entry(p, struct snd_timer_instance, active_list); + ti = list_entry(p, snd_timer_instance_t, active_list); if (ti->flags & SNDRV_TIMER_IFLG_START) { ti->flags &= ~SNDRV_TIMER_IFLG_START; ti->flags |= SNDRV_TIMER_IFLG_RUNNING; @@ -623,8 +624,8 @@ static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_l */ static void snd_timer_tasklet(unsigned long arg) { - struct snd_timer *timer = (struct snd_timer *) arg; - struct snd_timer_instance *ti; + snd_timer_t *timer = (snd_timer_t *) arg; + snd_timer_instance_t *ti; struct list_head *p; unsigned long resolution, ticks; @@ -632,7 +633,7 @@ static void snd_timer_tasklet(unsigned long arg) /* now process all callbacks */ while (!list_empty(&timer->sack_list_head)) { p = timer->sack_list_head.next; /* get first item */ - ti = list_entry(p, struct snd_timer_instance, ack_list); + ti = list_entry(p, snd_timer_instance_t, ack_list); /* remove from ack_list and make empty */ list_del_init(p); @@ -657,18 +658,17 @@ static void snd_timer_tasklet(unsigned long arg) * ticks_left is usually equal to timer->sticks. * */ -void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) +void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left) { - struct snd_timer_instance *ti, *ts; + snd_timer_instance_t *ti, *ts; unsigned long resolution, ticks; struct list_head *p, *q, *n, *ack_list_head; - unsigned long flags; int use_tasklet = 0; if (timer == NULL) return; - spin_lock_irqsave(&timer->lock, flags); + spin_lock(&timer->lock); /* remember the current resolution */ if (timer->hw.c_resolution) @@ -682,7 +682,7 @@ void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) * is called. */ list_for_each_safe(p, n, &timer->active_list_head) { - ti = list_entry(p, struct snd_timer_instance, active_list); + ti = list_entry(p, snd_timer_instance_t, active_list); if (!(ti->flags & SNDRV_TIMER_IFLG_RUNNING)) continue; ti->pticks += ticks_left; @@ -708,7 +708,7 @@ void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) if (list_empty(&ti->ack_list)) list_add_tail(&ti->ack_list, ack_list_head); list_for_each(q, &ti->slave_active_head) { - ts = list_entry(q, struct snd_timer_instance, active_list); + ts = list_entry(q, snd_timer_instance_t, active_list); ts->pticks = ti->pticks; ts->resolution = resolution; if (list_empty(&ts->ack_list)) @@ -735,7 +735,7 @@ void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) /* now process all fast callbacks */ while (!list_empty(&timer->ack_list_head)) { p = timer->ack_list_head.next; /* get first item */ - ti = list_entry(p, struct snd_timer_instance, ack_list); + ti = list_entry(p, snd_timer_instance_t, ack_list); /* remove from ack_list and make empty */ list_del_init(p); @@ -753,7 +753,7 @@ void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) /* do we have any slow callbacks? */ use_tasklet = !list_empty(&timer->sack_list_head); - spin_unlock_irqrestore(&timer->lock, flags); + spin_unlock(&timer->lock); if (use_tasklet) tasklet_hi_schedule(&timer->task_queue); @@ -763,12 +763,12 @@ void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left) */ -int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid, - struct snd_timer **rtimer) +int snd_timer_new(snd_card_t *card, char *id, snd_timer_id_t *tid, + snd_timer_t **rtimer) { - struct snd_timer *timer; + snd_timer_t *timer; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_timer_dev_free, .dev_register = snd_timer_dev_register, .dev_unregister = snd_timer_dev_unregister @@ -778,10 +778,8 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid, snd_assert(rtimer != NULL, return -EINVAL); *rtimer = NULL; timer = kzalloc(sizeof(*timer), GFP_KERNEL); - if (timer == NULL) { - snd_printk(KERN_ERR "timer: cannot allocate\n"); + if (timer == NULL) return -ENOMEM; - } timer->tmr_class = tid->dev_class; timer->card = card; timer->tmr_device = tid->device; @@ -808,7 +806,7 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid, return 0; } -static int snd_timer_free(struct snd_timer *timer) +static int snd_timer_free(snd_timer_t *timer) { snd_assert(timer != NULL, return -ENXIO); if (timer->private_free) @@ -817,16 +815,16 @@ static int snd_timer_free(struct snd_timer *timer) return 0; } -static int snd_timer_dev_free(struct snd_device *device) +static int snd_timer_dev_free(snd_device_t *device) { - struct snd_timer *timer = device->device_data; + snd_timer_t *timer = device->device_data; return snd_timer_free(timer); } -static int snd_timer_dev_register(struct snd_device *dev) +static int snd_timer_dev_register(snd_device_t *dev) { - struct snd_timer *timer = dev->device_data; - struct snd_timer *timer1; + snd_timer_t *timer = dev->device_data; + snd_timer_t *timer1; struct list_head *p; snd_assert(timer != NULL && timer->hw.start != NULL && @@ -837,7 +835,7 @@ static int snd_timer_dev_register(struct snd_device *dev) down(®ister_mutex); list_for_each(p, &snd_timer_list) { - timer1 = list_entry(p, struct snd_timer, device_list); + timer1 = list_entry(p, snd_timer_t, device_list); if (timer1->tmr_class > timer->tmr_class) break; if (timer1->tmr_class < timer->tmr_class) @@ -865,10 +863,10 @@ static int snd_timer_dev_register(struct snd_device *dev) return 0; } -static int snd_timer_unregister(struct snd_timer *timer) +static int snd_timer_unregister(snd_timer_t *timer) { struct list_head *p, *n; - struct snd_timer_instance *ti; + snd_timer_instance_t *ti; snd_assert(timer != NULL, return -ENXIO); down(®ister_mutex); @@ -876,7 +874,7 @@ static int snd_timer_unregister(struct snd_timer *timer) snd_printk(KERN_WARNING "timer 0x%lx is busy?\n", (long)timer); list_for_each_safe(p, n, &timer->open_list_head) { list_del_init(p); - ti = list_entry(p, struct snd_timer_instance, open_list); + ti = list_entry(p, snd_timer_instance_t, open_list); ti->timer = NULL; } } @@ -885,17 +883,18 @@ static int snd_timer_unregister(struct snd_timer *timer) return snd_timer_free(timer); } -static int snd_timer_dev_unregister(struct snd_device *device) +static int snd_timer_dev_unregister(snd_device_t *device) { - struct snd_timer *timer = device->device_data; + snd_timer_t *timer = device->device_data; return snd_timer_unregister(timer); } -void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstamp) +void snd_timer_notify(snd_timer_t *timer, enum sndrv_timer_event event, + struct timespec *tstamp) { unsigned long flags; unsigned long resolution = 0; - struct snd_timer_instance *ti, *ts; + snd_timer_instance_t *ti, *ts; struct list_head *p, *n; if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)) @@ -912,11 +911,11 @@ void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstam resolution = timer->hw.resolution; } list_for_each(p, &timer->active_list_head) { - ti = list_entry(p, struct snd_timer_instance, active_list); + ti = list_entry(p, snd_timer_instance_t, active_list); if (ti->ccallback) ti->ccallback(ti, event, tstamp, resolution); list_for_each(n, &ti->slave_active_head) { - ts = list_entry(n, struct snd_timer_instance, active_list); + ts = list_entry(n, snd_timer_instance_t, active_list); if (ts->ccallback) ts->ccallback(ts, event, tstamp, resolution); } @@ -927,9 +926,9 @@ void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstam /* * exported functions for global timers */ -int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer) +int snd_timer_global_new(char *id, int device, snd_timer_t **rtimer) { - struct snd_timer_id tid; + snd_timer_id_t tid; tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL; tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE; @@ -939,21 +938,21 @@ int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer) return snd_timer_new(NULL, id, &tid, rtimer); } -int snd_timer_global_free(struct snd_timer *timer) +int snd_timer_global_free(snd_timer_t *timer) { return snd_timer_free(timer); } -int snd_timer_global_register(struct snd_timer *timer) +int snd_timer_global_register(snd_timer_t *timer) { - struct snd_device dev; + snd_device_t dev; memset(&dev, 0, sizeof(dev)); dev.device_data = timer; return snd_timer_dev_register(&dev); } -int snd_timer_global_unregister(struct snd_timer *timer) +int snd_timer_global_unregister(snd_timer_t *timer) { return snd_timer_unregister(timer); } @@ -972,7 +971,7 @@ struct snd_timer_system_private { static void snd_timer_s_function(unsigned long data) { - struct snd_timer *timer = (struct snd_timer *)data; + snd_timer_t *timer = (snd_timer_t *)data; struct snd_timer_system_private *priv = timer->private_data; unsigned long jiff = jiffies; if (time_after(jiff, priv->last_expires)) @@ -980,7 +979,7 @@ static void snd_timer_s_function(unsigned long data) snd_timer_interrupt(timer, (long)jiff - (long)priv->last_jiffies); } -static int snd_timer_s_start(struct snd_timer * timer) +static int snd_timer_s_start(snd_timer_t * timer) { struct snd_timer_system_private *priv; unsigned long njiff; @@ -999,7 +998,7 @@ static int snd_timer_s_start(struct snd_timer * timer) return 0; } -static int snd_timer_s_stop(struct snd_timer * timer) +static int snd_timer_s_stop(snd_timer_t * timer) { struct snd_timer_system_private *priv; unsigned long jiff; @@ -1014,7 +1013,7 @@ static int snd_timer_s_stop(struct snd_timer * timer) return 0; } -static struct snd_timer_hardware snd_timer_system = +static struct _snd_timer_hardware snd_timer_system = { .flags = SNDRV_TIMER_HW_FIRST | SNDRV_TIMER_HW_TASKLET, .resolution = 1000000000L / HZ, @@ -1023,14 +1022,14 @@ static struct snd_timer_hardware snd_timer_system = .stop = snd_timer_s_stop }; -static void snd_timer_free_system(struct snd_timer *timer) +static void snd_timer_free_system(snd_timer_t *timer) { kfree(timer->private_data); } static int snd_timer_register_system(void) { - struct snd_timer *timer; + snd_timer_t *timer; struct snd_timer_system_private *priv; int err; @@ -1052,22 +1051,21 @@ static int snd_timer_register_system(void) return snd_timer_global_register(timer); } -#ifdef CONFIG_PROC_FS /* * Info interface */ -static void snd_timer_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_timer_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { unsigned long flags; - struct snd_timer *timer; - struct snd_timer_instance *ti; + snd_timer_t *timer; + snd_timer_instance_t *ti; struct list_head *p, *q; down(®ister_mutex); list_for_each(p, &snd_timer_list) { - timer = list_entry(p, struct snd_timer, device_list); + timer = list_entry(p, snd_timer_t, device_list); switch (timer->tmr_class) { case SNDRV_TIMER_CLASS_GLOBAL: snd_iprintf(buffer, "G%i: ", timer->tmr_device); @@ -1096,7 +1094,7 @@ static void snd_timer_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, "\n"); spin_lock_irqsave(&timer->lock, flags); list_for_each(q, &timer->open_list_head) { - ti = list_entry(q, struct snd_timer_instance, open_list); + ti = list_entry(q, snd_timer_instance_t, open_list); snd_iprintf(buffer, " Client %s : %s\n", ti->owner ? ti->owner : "unknown", ti->flags & (SNDRV_TIMER_IFLG_START | @@ -1108,43 +1106,16 @@ static void snd_timer_proc_read(struct snd_info_entry *entry, up(®ister_mutex); } -static struct snd_info_entry *snd_timer_proc_entry = NULL; - -static void __init snd_timer_proc_init(void) -{ - struct snd_info_entry *entry; - - entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL); - if (entry != NULL) { - entry->c.text.read_size = SNDRV_TIMER_DEVICES * 128; - entry->c.text.read = snd_timer_proc_read; - if (snd_info_register(entry) < 0) { - snd_info_free_entry(entry); - entry = NULL; - } - } - snd_timer_proc_entry = entry; -} - -static void __exit snd_timer_proc_done(void) -{ - snd_info_unregister(snd_timer_proc_entry); -} -#else /* !CONFIG_PROC_FS */ -#define snd_timer_proc_init() -#define snd_timer_proc_done() -#endif - /* * USER SPACE interface */ -static void snd_timer_user_interrupt(struct snd_timer_instance *timeri, +static void snd_timer_user_interrupt(snd_timer_instance_t *timeri, unsigned long resolution, unsigned long ticks) { - struct snd_timer_user *tu = timeri->callback_data; - struct snd_timer_read *r; + snd_timer_user_t *tu = timeri->callback_data; + snd_timer_read_t *r; int prev; spin_lock(&tu->qlock); @@ -1171,8 +1142,8 @@ static void snd_timer_user_interrupt(struct snd_timer_instance *timeri, wake_up(&tu->qchange_sleep); } -static void snd_timer_user_append_to_tqueue(struct snd_timer_user *tu, - struct snd_timer_tread *tread) +static void snd_timer_user_append_to_tqueue(snd_timer_user_t *tu, + snd_timer_tread_t *tread) { if (tu->qused >= tu->queue_size) { tu->overrun++; @@ -1183,13 +1154,13 @@ static void snd_timer_user_append_to_tqueue(struct snd_timer_user *tu, } } -static void snd_timer_user_ccallback(struct snd_timer_instance *timeri, - int event, +static void snd_timer_user_ccallback(snd_timer_instance_t *timeri, + enum sndrv_timer_event event, struct timespec *tstamp, unsigned long resolution) { - struct snd_timer_user *tu = timeri->callback_data; - struct snd_timer_tread r1; + snd_timer_user_t *tu = timeri->callback_data; + snd_timer_tread_t r1; if (event >= SNDRV_TIMER_EVENT_START && event <= SNDRV_TIMER_EVENT_PAUSE) @@ -1206,12 +1177,12 @@ static void snd_timer_user_ccallback(struct snd_timer_instance *timeri, wake_up(&tu->qchange_sleep); } -static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri, +static void snd_timer_user_tinterrupt(snd_timer_instance_t *timeri, unsigned long resolution, unsigned long ticks) { - struct snd_timer_user *tu = timeri->callback_data; - struct snd_timer_tread *r, r1; + snd_timer_user_t *tu = timeri->callback_data; + snd_timer_tread_t *r, r1; struct timespec tstamp; int prev, append = 0; @@ -1262,7 +1233,7 @@ static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri, static int snd_timer_user_open(struct inode *inode, struct file *file) { - struct snd_timer_user *tu; + snd_timer_user_t *tu; tu = kzalloc(sizeof(*tu), GFP_KERNEL); if (tu == NULL) @@ -1272,7 +1243,7 @@ static int snd_timer_user_open(struct inode *inode, struct file *file) init_MUTEX(&tu->tread_sem); tu->ticks = 1; tu->queue_size = 128; - tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read), + tu->queue = kmalloc(tu->queue_size * sizeof(snd_timer_read_t), GFP_KERNEL); if (tu->queue == NULL) { kfree(tu); @@ -1284,7 +1255,7 @@ static int snd_timer_user_open(struct inode *inode, struct file *file) static int snd_timer_user_release(struct inode *inode, struct file *file) { - struct snd_timer_user *tu; + snd_timer_user_t *tu; if (file->private_data) { tu = file->private_data; @@ -1299,7 +1270,7 @@ static int snd_timer_user_release(struct inode *inode, struct file *file) return 0; } -static void snd_timer_user_zero_id(struct snd_timer_id *id) +static void snd_timer_user_zero_id(snd_timer_id_t *id) { id->dev_class = SNDRV_TIMER_CLASS_NONE; id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; @@ -1308,7 +1279,7 @@ static void snd_timer_user_zero_id(struct snd_timer_id *id) id->subdevice = -1; } -static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer) +static void snd_timer_user_copy_id(snd_timer_id_t *id, snd_timer_t *timer) { id->dev_class = timer->tmr_class; id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; @@ -1317,10 +1288,10 @@ static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *ti id->subdevice = timer->tmr_subdevice; } -static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) +static int snd_timer_user_next_device(snd_timer_id_t __user *_tid) { - struct snd_timer_id id; - struct snd_timer *timer; + snd_timer_id_t id; + snd_timer_t *timer; struct list_head *p; if (copy_from_user(&id, _tid, sizeof(id))) @@ -1331,7 +1302,7 @@ static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) snd_timer_user_zero_id(&id); else { timer = list_entry(snd_timer_list.next, - struct snd_timer, device_list); + snd_timer_t, device_list); snd_timer_user_copy_id(&id, timer); } } else { @@ -1339,7 +1310,7 @@ static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) case SNDRV_TIMER_CLASS_GLOBAL: id.device = id.device < 0 ? 0 : id.device + 1; list_for_each(p, &snd_timer_list) { - timer = list_entry(p, struct snd_timer, device_list); + timer = list_entry(p, snd_timer_t, device_list); if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) { snd_timer_user_copy_id(&id, timer); break; @@ -1372,7 +1343,7 @@ static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) } } list_for_each(p, &snd_timer_list) { - timer = list_entry(p, struct snd_timer, device_list); + timer = list_entry(p, snd_timer_t, device_list); if (timer->tmr_class > id.dev_class) { snd_timer_user_copy_id(&id, timer); break; @@ -1414,11 +1385,11 @@ static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) } static int snd_timer_user_ginfo(struct file *file, - struct snd_timer_ginfo __user *_ginfo) + snd_timer_ginfo_t __user *_ginfo) { - struct snd_timer_ginfo *ginfo; - struct snd_timer_id tid; - struct snd_timer *t; + snd_timer_ginfo_t *ginfo; + snd_timer_id_t tid; + snd_timer_t *t; struct list_head *p; int err = 0; @@ -1459,10 +1430,10 @@ static int snd_timer_user_ginfo(struct file *file, } static int snd_timer_user_gparams(struct file *file, - struct snd_timer_gparams __user *_gparams) + snd_timer_gparams_t __user *_gparams) { - struct snd_timer_gparams gparams; - struct snd_timer *t; + snd_timer_gparams_t gparams; + snd_timer_t *t; int err; if (copy_from_user(&gparams, _gparams, sizeof(gparams))) @@ -1488,11 +1459,11 @@ static int snd_timer_user_gparams(struct file *file, } static int snd_timer_user_gstatus(struct file *file, - struct snd_timer_gstatus __user *_gstatus) + snd_timer_gstatus_t __user *_gstatus) { - struct snd_timer_gstatus gstatus; - struct snd_timer_id tid; - struct snd_timer *t; + snd_timer_gstatus_t gstatus; + snd_timer_id_t tid; + snd_timer_t *t; int err = 0; if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus))) @@ -1524,10 +1495,10 @@ static int snd_timer_user_gstatus(struct file *file, } static int snd_timer_user_tselect(struct file *file, - struct snd_timer_select __user *_tselect) + snd_timer_select_t __user *_tselect) { - struct snd_timer_user *tu; - struct snd_timer_select tselect; + snd_timer_user_t *tu; + snd_timer_select_t tselect; char str[32]; int err = 0; @@ -1553,12 +1524,12 @@ static int snd_timer_user_tselect(struct file *file, kfree(tu->tqueue); tu->tqueue = NULL; if (tu->tread) { - tu->tqueue = kmalloc(tu->queue_size * sizeof(struct snd_timer_tread), + tu->tqueue = kmalloc(tu->queue_size * sizeof(snd_timer_tread_t), GFP_KERNEL); if (tu->tqueue == NULL) err = -ENOMEM; } else { - tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read), + tu->queue = kmalloc(tu->queue_size * sizeof(snd_timer_read_t), GFP_KERNEL); if (tu->queue == NULL) err = -ENOMEM; @@ -1581,11 +1552,11 @@ static int snd_timer_user_tselect(struct file *file, } static int snd_timer_user_info(struct file *file, - struct snd_timer_info __user *_info) + snd_timer_info_t __user *_info) { - struct snd_timer_user *tu; - struct snd_timer_info *info; - struct snd_timer *t; + snd_timer_user_t *tu; + snd_timer_info_t *info; + snd_timer_t *t; int err = 0; tu = file->private_data; @@ -1609,13 +1580,13 @@ static int snd_timer_user_info(struct file *file, } static int snd_timer_user_params(struct file *file, - struct snd_timer_params __user *_params) + snd_timer_params_t __user *_params) { - struct snd_timer_user *tu; - struct snd_timer_params params; - struct snd_timer *t; - struct snd_timer_read *tr; - struct snd_timer_tread *ttr; + snd_timer_user_t *tu; + snd_timer_params_t params; + snd_timer_t *t; + snd_timer_read_t *tr; + snd_timer_tread_t *ttr; int err; tu = file->private_data; @@ -1685,14 +1656,14 @@ static int snd_timer_user_params(struct file *file, tu->qhead = tu->qtail = tu->qused = 0; if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) { if (tu->tread) { - struct snd_timer_tread tread; + snd_timer_tread_t tread; tread.event = SNDRV_TIMER_EVENT_EARLY; tread.tstamp.tv_sec = 0; tread.tstamp.tv_nsec = 0; tread.val = 0; snd_timer_user_append_to_tqueue(tu, &tread); } else { - struct snd_timer_read *r = &tu->queue[0]; + snd_timer_read_t *r = &tu->queue[0]; r->resolution = 0; r->ticks = 0; tu->qused++; @@ -1709,10 +1680,10 @@ static int snd_timer_user_params(struct file *file, } static int snd_timer_user_status(struct file *file, - struct snd_timer_status __user *_status) + snd_timer_status_t __user *_status) { - struct snd_timer_user *tu; - struct snd_timer_status status; + snd_timer_user_t *tu; + snd_timer_status_t status; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1732,7 +1703,7 @@ static int snd_timer_user_status(struct file *file, static int snd_timer_user_start(struct file *file) { int err; - struct snd_timer_user *tu; + snd_timer_user_t *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1745,7 +1716,7 @@ static int snd_timer_user_start(struct file *file) static int snd_timer_user_stop(struct file *file) { int err; - struct snd_timer_user *tu; + snd_timer_user_t *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1755,7 +1726,7 @@ static int snd_timer_user_stop(struct file *file) static int snd_timer_user_continue(struct file *file) { int err; - struct snd_timer_user *tu; + snd_timer_user_t *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1766,7 +1737,7 @@ static int snd_timer_user_continue(struct file *file) static int snd_timer_user_pause(struct file *file) { int err; - struct snd_timer_user *tu; + snd_timer_user_t *tu; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -1783,7 +1754,7 @@ enum { static long snd_timer_user_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_timer_user *tu; + snd_timer_user_t *tu; void __user *argp = (void __user *)arg; int __user *p = argp; @@ -1842,7 +1813,7 @@ static long snd_timer_user_ioctl(struct file *file, unsigned int cmd, static int snd_timer_user_fasync(int fd, struct file * file, int on) { - struct snd_timer_user *tu; + snd_timer_user_t *tu; int err; tu = file->private_data; @@ -1855,12 +1826,12 @@ static int snd_timer_user_fasync(int fd, struct file * file, int on) static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, size_t count, loff_t *offset) { - struct snd_timer_user *tu; + snd_timer_user_t *tu; long result = 0, unit; int err = 0; tu = file->private_data; - unit = tu->tread ? sizeof(struct snd_timer_tread) : sizeof(struct snd_timer_read); + unit = tu->tread ? sizeof(snd_timer_tread_t) : sizeof(snd_timer_read_t); spin_lock_irq(&tu->qlock); while ((long)count - result >= unit) { while (!tu->qused) { @@ -1893,13 +1864,13 @@ static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, if (tu->tread) { if (copy_to_user(buffer, &tu->tqueue[tu->qhead++], - sizeof(struct snd_timer_tread))) { + sizeof(snd_timer_tread_t))) { err = -EFAULT; goto _error; } } else { if (copy_to_user(buffer, &tu->queue[tu->qhead++], - sizeof(struct snd_timer_read))) { + sizeof(snd_timer_read_t))) { err = -EFAULT; goto _error; } @@ -1921,7 +1892,7 @@ static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, static unsigned int snd_timer_user_poll(struct file *file, poll_table * wait) { unsigned int mask; - struct snd_timer_user *tu; + snd_timer_user_t *tu; tu = file->private_data; @@ -1952,27 +1923,44 @@ static struct file_operations snd_timer_f_ops = .fasync = snd_timer_user_fasync, }; +static snd_minor_t snd_timer_reg = +{ + .comment = "timer", + .f_ops = &snd_timer_f_ops, +}; + /* * ENTRY functions */ +static snd_info_entry_t *snd_timer_proc_entry = NULL; + static int __init alsa_timer_init(void) { int err; + snd_info_entry_t *entry; #ifdef SNDRV_OSS_INFO_DEV_TIMERS snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1, "system timer"); #endif - + entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL); + if (entry != NULL) { + entry->c.text.read_size = SNDRV_TIMER_DEVICES * 128; + entry->c.text.read = snd_timer_proc_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + snd_timer_proc_entry = entry; if ((err = snd_timer_register_system()) < 0) snd_printk(KERN_ERR "unable to register system timer (%i)\n", err); - if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0, - &snd_timer_f_ops, NULL, "timer")) < 0) + if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, + NULL, 0, &snd_timer_reg, "timer"))<0) snd_printk(KERN_ERR "unable to register timer device (%i)\n", err); - snd_timer_proc_init(); return 0; } @@ -1983,10 +1971,13 @@ static void __exit alsa_timer_exit(void) snd_unregister_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0); /* unregister the system timer */ list_for_each_safe(p, n, &snd_timer_list) { - struct snd_timer *timer = list_entry(p, struct snd_timer, device_list); + snd_timer_t *timer = list_entry(p, snd_timer_t, device_list); snd_timer_unregister(timer); } - snd_timer_proc_done(); + if (snd_timer_proc_entry) { + snd_info_unregister(snd_timer_proc_entry); + snd_timer_proc_entry = NULL; + } #ifdef SNDRV_OSS_INFO_DEV_TIMERS snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1); #endif diff --git a/trunk/sound/core/timer_compat.c b/trunk/sound/core/timer_compat.c index 5512f5373c52..3de552dfe80f 100644 --- a/trunk/sound/core/timer_compat.c +++ b/trunk/sound/core/timer_compat.c @@ -22,7 +22,7 @@ #include <linux/compat.h> -struct snd_timer_info32 { +struct sndrv_timer_info32 { u32 flags; s32 card; unsigned char id[64]; @@ -33,11 +33,11 @@ struct snd_timer_info32 { }; static int snd_timer_user_info_compat(struct file *file, - struct snd_timer_info32 __user *_info) + struct sndrv_timer_info32 __user *_info) { - struct snd_timer_user *tu; - struct snd_timer_info32 info; - struct snd_timer *t; + snd_timer_user_t *tu; + struct sndrv_timer_info32 info; + snd_timer_t *t; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -55,7 +55,7 @@ static int snd_timer_user_info_compat(struct file *file, return 0; } -struct snd_timer_status32 { +struct sndrv_timer_status32 { struct compat_timespec tstamp; u32 resolution; u32 lost; @@ -65,10 +65,10 @@ struct snd_timer_status32 { }; static int snd_timer_user_status_compat(struct file *file, - struct snd_timer_status32 __user *_status) + struct sndrv_timer_status32 __user *_status) { - struct snd_timer_user *tu; - struct snd_timer_status status; + snd_timer_user_t *tu; + snd_timer_status_t status; tu = file->private_data; snd_assert(tu->timeri != NULL, return -ENXIO); @@ -89,8 +89,8 @@ static int snd_timer_user_status_compat(struct file *file, */ enum { - SNDRV_TIMER_IOCTL_INFO32 = _IOR('T', 0x11, struct snd_timer_info32), - SNDRV_TIMER_IOCTL_STATUS32 = _IOW('T', 0x14, struct snd_timer_status32), + SNDRV_TIMER_IOCTL_INFO32 = _IOR('T', 0x11, struct sndrv_timer_info32), + SNDRV_TIMER_IOCTL_STATUS32 = _IOW('T', 0x14, struct sndrv_timer_status32), }; static long snd_timer_user_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) diff --git a/trunk/sound/drivers/Kconfig b/trunk/sound/drivers/Kconfig index 395c4ef52ac9..efcb4eb2d1a0 100644 --- a/trunk/sound/drivers/Kconfig +++ b/trunk/sound/drivers/Kconfig @@ -6,6 +6,7 @@ menu "Generic devices" config SND_MPU401_UART tristate + select SND_TIMER select SND_RAWMIDI config SND_OPL3_LIB @@ -23,19 +24,12 @@ config SND_VX_LIB select SND_HWDEP select SND_PCM -config SND_AC97_CODEC - tristate - select SND_PCM - select SND_AC97_BUS - -config SND_AC97_BUS - tristate - config SND_DUMMY tristate "Dummy (/dev/null) soundcard" depends on SND select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include the dummy driver. This driver does nothing, but emulates various mixer controls and PCM devices. @@ -51,6 +45,7 @@ config SND_VIRMIDI depends on SND_SEQUENCER select SND_TIMER select SND_RAWMIDI + select SND_GENERIC_DRIVER help Say Y here to include the virtual MIDI driver. This driver allows to connect applications using raw MIDI devices to @@ -64,7 +59,9 @@ config SND_VIRMIDI config SND_MTPAV tristate "MOTU MidiTimePiece AV multiport MIDI" depends on SND + select SND_TIMER select SND_RAWMIDI + select SND_GENERIC_DRIVER help To use a MOTU MidiTimePiece AV multiport MIDI adapter connected to the parallel port, say Y here and make sure that @@ -76,7 +73,9 @@ config SND_MTPAV config SND_SERIAL_U16550 tristate "UART16550 serial MIDI driver" depends on SND + select SND_TIMER select SND_RAWMIDI + select SND_GENERIC_DRIVER help To include support for MIDI serial port interfaces, say Y here and read <file:Documentation/sound/alsa/serial-u16550.txt>. @@ -93,6 +92,7 @@ config SND_MPU401 tristate "Generic MPU-401 UART driver" depends on SND select SND_MPU401_UART + select SND_GENERIC_DRIVER help Say Y here to include support for MIDI ports compatible with the Roland MPU-401 interface in UART mode. diff --git a/trunk/sound/drivers/dummy.c b/trunk/sound/drivers/dummy.c index 14e1a671b5cf..64ef7f62851d 100644 --- a/trunk/sound/drivers/dummy.c +++ b/trunk/sound/drivers/dummy.c @@ -20,8 +20,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/jiffies.h> #include <linux/slab.h> #include <linux/time.h> @@ -44,7 +42,7 @@ MODULE_SUPPORTED_DEVICE("{{ALSA,Dummy soundcard}}"); #if 0 /* emu10k1 emulation */ #define MAX_BUFFER_SIZE (128 * 1024) -static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime) +static int emu10k1_playback_constraints(snd_pcm_runtime_t *runtime) { int err; if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) @@ -92,27 +90,11 @@ static int emu10k1_playback_constraints(struct snd_pcm_runtime *runtime) #define USE_RATE_MAX 48000 #endif -#if 0 /* CA0106 */ -#define USE_FORMATS SNDRV_PCM_FMTBIT_S16_LE -#define USE_CHANNELS_MIN 2 -#define USE_CHANNELS_MAX 2 -#define USE_RATE (SNDRV_PCM_RATE_48000|SNDRV_PCM_RATE_96000|SNDRV_PCM_RATE_192000) -#define USE_RATE_MIN 48000 -#define USE_RATE_MAX 192000 -#define MAX_BUFFER_SIZE ((65536-64)*8) -#define MAX_PERIOD_SIZE (65536-64) -#define USE_PERIODS_MIN 2 -#define USE_PERIODS_MAX 8 -#endif - /* defaults */ #ifndef MAX_BUFFER_SIZE #define MAX_BUFFER_SIZE (64*1024) #endif -#ifndef MAX_PERIOD_SIZE -#define MAX_PERIOD_SIZE MAX_BUFFER_SIZE -#endif #ifndef USE_FORMATS #define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE) #endif @@ -160,8 +142,6 @@ MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-16) for dummy driver."); //module_param_array(midi_devs, int, NULL, 0444); //MODULE_PARM_DESC(midi_devs, "MIDI devices # (0-2) for dummy driver."); -static struct platform_device *devices[SNDRV_CARDS]; - #define MIXER_ADDR_MASTER 0 #define MIXER_ADDR_LINE 1 #define MIXER_ADDR_MIC 2 @@ -169,16 +149,15 @@ static struct platform_device *devices[SNDRV_CARDS]; #define MIXER_ADDR_CD 4 #define MIXER_ADDR_LAST 4 -struct snd_dummy { - struct snd_card *card; - struct snd_pcm *pcm; +typedef struct snd_card_dummy { + snd_card_t *card; spinlock_t mixer_lock; int mixer_volume[MIXER_ADDR_LAST+1][2]; int capture_source[MIXER_ADDR_LAST+1][2]; -}; +} snd_card_dummy_t; -struct snd_dummy_pcm { - struct snd_dummy *dummy; +typedef struct snd_card_dummy_pcm { + snd_card_dummy_t *dummy; spinlock_t lock; struct timer_list timer; unsigned int pcm_size; @@ -187,49 +166,59 @@ struct snd_dummy_pcm { unsigned int pcm_jiffie; /* bytes per one jiffie */ unsigned int pcm_irq_pos; /* IRQ position */ unsigned int pcm_buf_pos; /* position in buffer */ - struct snd_pcm_substream *substream; -}; + snd_pcm_substream_t *substream; +} snd_card_dummy_pcm_t; + +static snd_card_t *snd_dummy_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; -static inline void snd_card_dummy_pcm_timer_start(struct snd_dummy_pcm *dpcm) +static void snd_card_dummy_pcm_timer_start(snd_pcm_substream_t * substream) { + snd_pcm_runtime_t *runtime = substream->runtime; + snd_card_dummy_pcm_t *dpcm = runtime->private_data; + dpcm->timer.expires = 1 + jiffies; add_timer(&dpcm->timer); } -static inline void snd_card_dummy_pcm_timer_stop(struct snd_dummy_pcm *dpcm) +static void snd_card_dummy_pcm_timer_stop(snd_pcm_substream_t * substream) { + snd_pcm_runtime_t *runtime = substream->runtime; + snd_card_dummy_pcm_t *dpcm = runtime->private_data; + del_timer(&dpcm->timer); } -static int snd_card_dummy_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_card_dummy_playback_trigger(snd_pcm_substream_t * substream, + int cmd) +{ + if (cmd == SNDRV_PCM_TRIGGER_START) { + snd_card_dummy_pcm_timer_start(substream); + } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { + snd_card_dummy_pcm_timer_stop(substream); + } else { + return -EINVAL; + } + return 0; +} + +static int snd_card_dummy_capture_trigger(snd_pcm_substream_t * substream, + int cmd) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_dummy_pcm *dpcm = runtime->private_data; - int err = 0; - - spin_lock(&dpcm->lock); - switch (cmd) { - case SNDRV_PCM_TRIGGER_START: - case SNDRV_PCM_TRIGGER_RESUME: - snd_card_dummy_pcm_timer_start(dpcm); - break; - case SNDRV_PCM_TRIGGER_STOP: - case SNDRV_PCM_TRIGGER_SUSPEND: - snd_card_dummy_pcm_timer_stop(dpcm); - break; - default: - err = -EINVAL; - break; + if (cmd == SNDRV_PCM_TRIGGER_START) { + snd_card_dummy_pcm_timer_start(substream); + } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { + snd_card_dummy_pcm_timer_stop(substream); + } else { + return -EINVAL; } - spin_unlock(&dpcm->lock); return 0; } -static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_card_dummy_pcm_prepare(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_dummy_pcm *dpcm = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_card_dummy_pcm_t *dpcm = runtime->private_data; unsigned int bps; bps = runtime->rate * runtime->channels; @@ -246,37 +235,53 @@ static int snd_card_dummy_pcm_prepare(struct snd_pcm_substream *substream) return 0; } +static int snd_card_dummy_playback_prepare(snd_pcm_substream_t * substream) +{ + return snd_card_dummy_pcm_prepare(substream); +} + +static int snd_card_dummy_capture_prepare(snd_pcm_substream_t * substream) +{ + return snd_card_dummy_pcm_prepare(substream); +} + static void snd_card_dummy_pcm_timer_function(unsigned long data) { - struct snd_dummy_pcm *dpcm = (struct snd_dummy_pcm *)data; - unsigned long flags; + snd_card_dummy_pcm_t *dpcm = (snd_card_dummy_pcm_t *)data; - spin_lock_irqsave(&dpcm->lock, flags); dpcm->timer.expires = 1 + jiffies; add_timer(&dpcm->timer); + spin_lock_irq(&dpcm->lock); dpcm->pcm_irq_pos += dpcm->pcm_jiffie; dpcm->pcm_buf_pos += dpcm->pcm_jiffie; dpcm->pcm_buf_pos %= dpcm->pcm_size; if (dpcm->pcm_irq_pos >= dpcm->pcm_count) { dpcm->pcm_irq_pos %= dpcm->pcm_count; - spin_unlock_irqrestore(&dpcm->lock, flags); snd_pcm_period_elapsed(dpcm->substream); - } else - spin_unlock_irqrestore(&dpcm->lock, flags); + } + spin_unlock_irq(&dpcm->lock); } -static snd_pcm_uframes_t snd_card_dummy_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_card_dummy_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_dummy_pcm *dpcm = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_card_dummy_pcm_t *dpcm = runtime->private_data; return bytes_to_frames(runtime, dpcm->pcm_buf_pos); } -static struct snd_pcm_hardware snd_card_dummy_playback = +static snd_pcm_uframes_t snd_card_dummy_capture_pointer(snd_pcm_substream_t * substream) +{ + snd_pcm_runtime_t *runtime = substream->runtime; + snd_card_dummy_pcm_t *dpcm = runtime->private_data; + + return bytes_to_frames(runtime, dpcm->pcm_buf_pos); +} + +static snd_pcm_hardware_t snd_card_dummy_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = USE_FORMATS, .rates = USE_RATE, .rate_min = USE_RATE_MIN, @@ -291,10 +296,10 @@ static struct snd_pcm_hardware snd_card_dummy_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_card_dummy_capture = +static snd_pcm_hardware_t snd_card_dummy_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = USE_FORMATS, .rates = USE_RATE, .rate_min = USE_RATE_MIN, @@ -303,51 +308,43 @@ static struct snd_pcm_hardware snd_card_dummy_capture = .channels_max = USE_CHANNELS_MAX, .buffer_bytes_max = MAX_BUFFER_SIZE, .period_bytes_min = 64, - .period_bytes_max = MAX_PERIOD_SIZE, + .period_bytes_max = MAX_BUFFER_SIZE, .periods_min = USE_PERIODS_MIN, .periods_max = USE_PERIODS_MAX, .fifo_size = 0, }; -static void snd_card_dummy_runtime_free(struct snd_pcm_runtime *runtime) +static void snd_card_dummy_runtime_free(snd_pcm_runtime_t *runtime) { - kfree(runtime->private_data); + snd_card_dummy_pcm_t *dpcm = runtime->private_data; + kfree(dpcm); } -static int snd_card_dummy_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_card_dummy_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_card_dummy_hw_free(struct snd_pcm_substream *substream) +static int snd_card_dummy_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static struct snd_dummy_pcm *new_pcm_stream(struct snd_pcm_substream *substream) +static int snd_card_dummy_playback_open(snd_pcm_substream_t * substream) { - struct snd_dummy_pcm *dpcm; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_card_dummy_pcm_t *dpcm; + int err; dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL); - if (! dpcm) - return dpcm; + if (dpcm == NULL) + return -ENOMEM; init_timer(&dpcm->timer); dpcm->timer.data = (unsigned long) dpcm; dpcm->timer.function = snd_card_dummy_pcm_timer_function; spin_lock_init(&dpcm->lock); dpcm->substream = substream; - return dpcm; -} - -static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream) -{ - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_dummy_pcm *dpcm; - int err; - - if ((dpcm = new_pcm_stream(substream)) == NULL) - return -ENOMEM; runtime->private_data = dpcm; runtime->private_free = snd_card_dummy_runtime_free; runtime->hw = snd_card_dummy_playback; @@ -365,14 +362,20 @@ static int snd_card_dummy_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream) +static int snd_card_dummy_capture_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_dummy_pcm *dpcm; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_card_dummy_pcm_t *dpcm; int err; - if ((dpcm = new_pcm_stream(substream)) == NULL) + dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL); + if (dpcm == NULL) return -ENOMEM; + init_timer(&dpcm->timer); + dpcm->timer.data = (unsigned long) dpcm; + dpcm->timer.function = snd_card_dummy_pcm_timer_function; + spin_lock_init(&dpcm->lock); + dpcm->substream = substream; runtime->private_data = dpcm; runtime->private_free = snd_card_dummy_runtime_free; runtime->hw = snd_card_dummy_capture; @@ -390,47 +393,45 @@ static int snd_card_dummy_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_card_dummy_playback_close(struct snd_pcm_substream *substream) +static int snd_card_dummy_playback_close(snd_pcm_substream_t * substream) { return 0; } -static int snd_card_dummy_capture_close(struct snd_pcm_substream *substream) +static int snd_card_dummy_capture_close(snd_pcm_substream_t * substream) { return 0; } -static struct snd_pcm_ops snd_card_dummy_playback_ops = { +static snd_pcm_ops_t snd_card_dummy_playback_ops = { .open = snd_card_dummy_playback_open, .close = snd_card_dummy_playback_close, .ioctl = snd_pcm_lib_ioctl, .hw_params = snd_card_dummy_hw_params, .hw_free = snd_card_dummy_hw_free, - .prepare = snd_card_dummy_pcm_prepare, - .trigger = snd_card_dummy_pcm_trigger, - .pointer = snd_card_dummy_pcm_pointer, + .prepare = snd_card_dummy_playback_prepare, + .trigger = snd_card_dummy_playback_trigger, + .pointer = snd_card_dummy_playback_pointer, }; -static struct snd_pcm_ops snd_card_dummy_capture_ops = { +static snd_pcm_ops_t snd_card_dummy_capture_ops = { .open = snd_card_dummy_capture_open, .close = snd_card_dummy_capture_close, .ioctl = snd_pcm_lib_ioctl, .hw_params = snd_card_dummy_hw_params, .hw_free = snd_card_dummy_hw_free, - .prepare = snd_card_dummy_pcm_prepare, - .trigger = snd_card_dummy_pcm_trigger, - .pointer = snd_card_dummy_pcm_pointer, + .prepare = snd_card_dummy_capture_prepare, + .trigger = snd_card_dummy_capture_trigger, + .pointer = snd_card_dummy_capture_pointer, }; -static int __init snd_card_dummy_pcm(struct snd_dummy *dummy, int device, int substreams) +static int __init snd_card_dummy_pcm(snd_card_dummy_t *dummy, int device, int substreams) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; - if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device, - substreams, substreams, &pcm)) < 0) + if ((err = snd_pcm_new(dummy->card, "Dummy PCM", device, substreams, substreams, &pcm)) < 0) return err; - dummy->pcm = pcm; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_card_dummy_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_dummy_capture_ops); pcm->private_data = dummy; @@ -448,8 +449,7 @@ static int __init snd_card_dummy_pcm(struct snd_dummy *dummy, int device, int su .get = snd_dummy_volume_get, .put = snd_dummy_volume_put, \ .private_value = addr } -static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_dummy_volume_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -458,23 +458,23 @@ static int snd_dummy_volume_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_dummy_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_dummy_volume_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); + snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); + unsigned long flags; int addr = kcontrol->private_value; - spin_lock_irq(&dummy->mixer_lock); + spin_lock_irqsave(&dummy->mixer_lock, flags); ucontrol->value.integer.value[0] = dummy->mixer_volume[addr][0]; ucontrol->value.integer.value[1] = dummy->mixer_volume[addr][1]; - spin_unlock_irq(&dummy->mixer_lock); + spin_unlock_irqrestore(&dummy->mixer_lock, flags); return 0; } -static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_dummy_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); + snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); + unsigned long flags; int change, addr = kcontrol->private_value; int left, right; @@ -488,12 +488,12 @@ static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol, right = -50; if (right > 100) right = 100; - spin_lock_irq(&dummy->mixer_lock); + spin_lock_irqsave(&dummy->mixer_lock, flags); change = dummy->mixer_volume[addr][0] != left || dummy->mixer_volume[addr][1] != right; dummy->mixer_volume[addr][0] = left; dummy->mixer_volume[addr][1] = right; - spin_unlock_irq(&dummy->mixer_lock); + spin_unlock_irqrestore(&dummy->mixer_lock, flags); return change; } @@ -503,8 +503,7 @@ static int snd_dummy_volume_put(struct snd_kcontrol *kcontrol, .get = snd_dummy_capsrc_get, .put = snd_dummy_capsrc_put, \ .private_value = addr } -static int snd_dummy_capsrc_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_dummy_capsrc_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -513,37 +512,38 @@ static int snd_dummy_capsrc_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_dummy_capsrc_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_dummy_capsrc_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); + snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); + unsigned long flags; int addr = kcontrol->private_value; - spin_lock_irq(&dummy->mixer_lock); + spin_lock_irqsave(&dummy->mixer_lock, flags); ucontrol->value.integer.value[0] = dummy->capture_source[addr][0]; ucontrol->value.integer.value[1] = dummy->capture_source[addr][1]; - spin_unlock_irq(&dummy->mixer_lock); + spin_unlock_irqrestore(&dummy->mixer_lock, flags); return 0; } -static int snd_dummy_capsrc_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_dummy_capsrc_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_dummy *dummy = snd_kcontrol_chip(kcontrol); + snd_card_dummy_t *dummy = snd_kcontrol_chip(kcontrol); + unsigned long flags; int change, addr = kcontrol->private_value; int left, right; left = ucontrol->value.integer.value[0] & 1; right = ucontrol->value.integer.value[1] & 1; - spin_lock_irq(&dummy->mixer_lock); + spin_lock_irqsave(&dummy->mixer_lock, flags); change = dummy->capture_source[addr][0] != left && dummy->capture_source[addr][1] != right; dummy->capture_source[addr][0] = left; dummy->capture_source[addr][1] = right; - spin_unlock_irq(&dummy->mixer_lock); + spin_unlock_irqrestore(&dummy->mixer_lock, flags); return change; } -static struct snd_kcontrol_new snd_dummy_controls[] = { +static snd_kcontrol_new_t snd_dummy_controls[] = { DUMMY_VOLUME("Master Volume", 0, MIXER_ADDR_MASTER), DUMMY_CAPSRC("Master Capture Switch", 0, MIXER_ADDR_MASTER), DUMMY_VOLUME("Synth Volume", 0, MIXER_ADDR_SYNTH), @@ -556,9 +556,9 @@ DUMMY_VOLUME("CD Volume", 0, MIXER_ADDR_CD), DUMMY_CAPSRC("CD Capture Switch", 0, MIXER_ADDR_MASTER) }; -static int __init snd_card_dummy_new_mixer(struct snd_dummy *dummy) +static int __init snd_card_dummy_new_mixer(snd_card_dummy_t * dummy) { - struct snd_card *card = dummy->card; + snd_card_t *card = dummy->card; unsigned int idx; int err; @@ -573,18 +573,19 @@ static int __init snd_card_dummy_new_mixer(struct snd_dummy *dummy) return 0; } -static int __init snd_dummy_probe(struct platform_device *devptr) +static int __init snd_card_dummy_probe(int dev) { - struct snd_card *card; - struct snd_dummy *dummy; + snd_card_t *card; + struct snd_card_dummy *dummy; int idx, err; - int dev = devptr->id; + if (!enable[dev]) + return -ENODEV; card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof(struct snd_dummy)); + sizeof(struct snd_card_dummy)); if (card == NULL) return -ENOMEM; - dummy = card->private_data; + dummy = (struct snd_card_dummy *)card->private_data; dummy->card = card; for (idx = 0; idx < MAX_PCM_DEVICES && idx < pcm_devs[dev]; idx++) { if (pcm_substreams[dev] < 1) @@ -600,10 +601,11 @@ static int __init snd_dummy_probe(struct platform_device *devptr) strcpy(card->shortname, "Dummy"); sprintf(card->longname, "Dummy %i", dev + 1); - snd_card_set_dev(card, &devptr->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto __nodev; if ((err = snd_card_register(card)) == 0) { - platform_set_drvdata(devptr, card); + snd_dummy_cards[dev] = card; return 0; } __nodev: @@ -611,92 +613,34 @@ static int __init snd_dummy_probe(struct platform_device *devptr) return err; } -static int snd_dummy_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_dummy_suspend(struct platform_device *pdev, pm_message_t state) -{ - struct snd_card *card = platform_get_drvdata(pdev); - struct snd_dummy *dummy = card->private_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(dummy->pcm); - return 0; -} - -static int snd_dummy_resume(struct platform_device *pdev) -{ - struct snd_card *card = platform_get_drvdata(pdev); - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - -#define SND_DUMMY_DRIVER "snd_dummy" - -static struct platform_driver snd_dummy_driver = { - .probe = snd_dummy_probe, - .remove = snd_dummy_remove, -#ifdef CONFIG_PM - .suspend = snd_dummy_suspend, - .resume = snd_dummy_resume, -#endif - .driver = { - .name = SND_DUMMY_DRIVER - }, -}; - -static void __init_or_module snd_dummy_unregister_all(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_dummy_driver); -} - static int __init alsa_card_dummy_init(void) { - int i, cards, err; - - if ((err = platform_driver_register(&snd_dummy_driver)) < 0) - return err; + int dev, cards; - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(SND_DUMMY_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) { + if (snd_card_dummy_probe(dev) < 0) { +#ifdef MODULE + printk(KERN_ERR "Dummy soundcard #%i not found or device busy\n", dev + 1); +#endif + break; } - devices[i] = device; cards++; } if (!cards) { #ifdef MODULE printk(KERN_ERR "Dummy soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_dummy_unregister_all(); - return err; } static void __exit alsa_card_dummy_exit(void) { - snd_dummy_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_dummy_cards[idx]); } module_init(alsa_card_dummy_init) diff --git a/trunk/sound/drivers/mpu401/mpu401.c b/trunk/sound/drivers/mpu401/mpu401.c index 915589a402ab..54e2ff9b5ca1 100644 --- a/trunk/sound/drivers/mpu401/mpu401.c +++ b/trunk/sound/drivers/mpu401/mpu401.c @@ -23,8 +23,6 @@ #include <sound/driver.h> #include <linux/init.h> #include <linux/pnp.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/mpu401.h> @@ -58,12 +56,12 @@ MODULE_PARM_DESC(port, "Port # for MPU-401 device."); module_param_array(irq, int, NULL, 0444); MODULE_PARM_DESC(irq, "IRQ # for MPU-401 device."); -static struct platform_device *platform_devices[SNDRV_CARDS]; +static snd_card_t *snd_mpu401_legacy_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; static int pnp_registered = 0; -static int snd_mpu401_create(int dev, struct snd_card **rcard) +static int snd_mpu401_create(int dev, snd_card_t **rcard) { - struct snd_card *card; + snd_card_t *card; int err; *rcard = NULL; @@ -87,6 +85,12 @@ static int snd_mpu401_create(int dev, struct snd_card **rcard) goto _err; } + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; + + if ((err = snd_card_register(card)) < 0) + goto _err; + *rcard = card; return 0; @@ -95,12 +99,8 @@ static int snd_mpu401_create(int dev, struct snd_card **rcard) return err; } -static int __devinit snd_mpu401_probe(struct platform_device *devptr) +static int __devinit snd_mpu401_probe(int dev) { - int dev = devptr->id; - int err; - struct snd_card *card; - if (port[dev] == SNDRV_AUTO_PORT) { snd_printk(KERN_ERR "specify port\n"); return -EINVAL; @@ -109,36 +109,9 @@ static int __devinit snd_mpu401_probe(struct platform_device *devptr) snd_printk(KERN_ERR "specify or disable IRQ\n"); return -EINVAL; } - err = snd_mpu401_create(dev, &card); - if (err < 0) - return err; - snd_card_set_dev(card, &devptr->dev); - if ((err = snd_card_register(card)) < 0) { - snd_card_free(card); - return err; - } - platform_set_drvdata(devptr, card); - return 0; + return snd_mpu401_create(dev, &snd_mpu401_legacy_cards[dev]); } -static int __devexit snd_mpu401_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define SND_MPU401_DRIVER "snd_mpu401" - -static struct platform_driver snd_mpu401_driver = { - .probe = snd_mpu401_probe, - .remove = __devexit_p(snd_mpu401_remove), - .driver = { - .name = SND_MPU401_DRIVER - }, -}; - - #ifdef CONFIG_PNP #define IO_EXTENT 2 @@ -179,7 +152,7 @@ static int __devinit snd_mpu401_pnp_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id) { static int dev; - struct snd_card *card; + snd_card_t *card; int err; for ( ; dev < SNDRV_CARDS; ++dev) { @@ -191,10 +164,6 @@ static int __devinit snd_mpu401_pnp_probe(struct pnp_dev *pnp_dev, err = snd_mpu401_create(dev, &card); if (err < 0) return err; - if ((err = snd_card_register(card)) < 0) { - snd_card_free(card); - return err; - } snd_card_set_dev(card, &pnp_dev->dev); pnp_set_drvdata(pnp_dev, card); ++dev; @@ -205,7 +174,7 @@ static int __devinit snd_mpu401_pnp_probe(struct pnp_dev *pnp_dev, static void __devexit snd_mpu401_pnp_remove(struct pnp_dev *dev) { - struct snd_card *card = (struct snd_card *) pnp_get_drvdata(dev); + snd_card_t *card = (snd_card_t *) pnp_get_drvdata(dev); snd_card_disconnect(card); snd_card_free_in_thread(card); @@ -221,39 +190,20 @@ static struct pnp_driver snd_mpu401_pnp_driver = { static struct pnp_driver snd_mpu401_pnp_driver; #endif -static void __init_or_module snd_mpu401_unregister_all(void) -{ - int i; - - if (pnp_registered) - pnp_unregister_driver(&snd_mpu401_pnp_driver); - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_mpu401_driver); -} - static int __init alsa_card_mpu401_init(void) { - int i, err, devices; - - if ((err = platform_driver_register(&snd_mpu401_driver)) < 0) - return err; + int dev, devices = 0; + int err; - devices = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev]) + continue; #ifdef CONFIG_PNP - if (pnp[i]) + if (pnp[dev]) continue; #endif - device = platform_device_register_simple(SND_MPU401_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - platform_devices[i] = device; - devices++; + if (snd_mpu401_probe(dev) >= 0) + devices++; } if ((err = pnp_register_driver(&snd_mpu401_pnp_driver)) >= 0) { pnp_registered = 1; @@ -264,19 +214,21 @@ static int __init alsa_card_mpu401_init(void) #ifdef MODULE printk(KERN_ERR "MPU-401 device not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + if (pnp_registered) + pnp_unregister_driver(&snd_mpu401_pnp_driver); + return -ENODEV; } return 0; - - errout: - snd_mpu401_unregister_all(); - return err; } static void __exit alsa_card_mpu401_exit(void) { - snd_mpu401_unregister_all(); + int idx; + + if (pnp_registered) + pnp_unregister_driver(&snd_mpu401_pnp_driver); + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_mpu401_legacy_cards[idx]); } module_init(alsa_card_mpu401_init) diff --git a/trunk/sound/drivers/mpu401/mpu401_uart.c b/trunk/sound/drivers/mpu401/mpu401_uart.c index 8687ae3c66b8..bdeb2c00dac5 100644 --- a/trunk/sound/drivers/mpu401/mpu401_uart.c +++ b/trunk/sound/drivers/mpu401/mpu401_uart.c @@ -43,8 +43,8 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode"); MODULE_LICENSE("GPL"); -static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu); -static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu); +static void snd_mpu401_uart_input_read(mpu401_t * mpu); +static void snd_mpu401_uart_output_write(mpu401_t * mpu); /* @@ -58,28 +58,28 @@ static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu); #define MPU401_ACK 0xfe /* Build in lowlevel io */ -static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr) +static void mpu401_write_port(mpu401_t *mpu, unsigned char data, unsigned long addr) { outb(data, addr); } -static unsigned char mpu401_read_port(struct snd_mpu401 *mpu, unsigned long addr) +static unsigned char mpu401_read_port(mpu401_t *mpu, unsigned long addr) { return inb(addr); } -static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr) +static void mpu401_write_mmio(mpu401_t *mpu, unsigned char data, unsigned long addr) { writeb(data, (void __iomem *)addr); } -static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu, unsigned long addr) +static unsigned char mpu401_read_mmio(mpu401_t *mpu, unsigned long addr) { return readb((void __iomem *)addr); } /* */ -static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu) +static void snd_mpu401_uart_clear_rx(mpu401_t *mpu) { int timeout = 100000; for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--) @@ -90,7 +90,7 @@ static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu) #endif } -static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu) +static void _snd_mpu401_uart_interrupt(mpu401_t *mpu) { spin_lock(&mpu->input_lock); if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) { @@ -118,7 +118,7 @@ static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu) */ irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_mpu401 *mpu = dev_id; + mpu401_t *mpu = dev_id; if (mpu == NULL) return IRQ_NONE; @@ -132,14 +132,13 @@ irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *reg */ static void snd_mpu401_uart_timer(unsigned long data) { - struct snd_mpu401 *mpu = (struct snd_mpu401 *)data; - unsigned long flags; + mpu401_t *mpu = (mpu401_t *)data; - spin_lock_irqsave(&mpu->timer_lock, flags); + spin_lock(&mpu->timer_lock); /*mpu->mode |= MPU401_MODE_TIMER;*/ mpu->timer.expires = 1 + jiffies; add_timer(&mpu->timer); - spin_unlock_irqrestore(&mpu->timer_lock, flags); + spin_unlock(&mpu->timer_lock); if (mpu->rmidi) _snd_mpu401_uart_interrupt(mpu); } @@ -147,7 +146,7 @@ static void snd_mpu401_uart_timer(unsigned long data) /* * initialize the timer callback if not programmed yet */ -static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input) +static void snd_mpu401_uart_add_timer (mpu401_t *mpu, int input) { unsigned long flags; @@ -166,7 +165,7 @@ static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input) /* * remove the timer callback if still active */ -static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input) +static void snd_mpu401_uart_remove_timer (mpu401_t *mpu, int input) { unsigned long flags; @@ -183,7 +182,7 @@ static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input) */ -static void snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd, int ack) +static void snd_mpu401_uart_cmd(mpu401_t * mpu, unsigned char cmd, int ack) { unsigned long flags; int timeout, ok; @@ -226,9 +225,9 @@ static void snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd, int /* * input/output open/close - protected by open_mutex in rawmidi.c */ -static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream) +static int snd_mpu401_uart_input_open(snd_rawmidi_substream_t * substream) { - struct snd_mpu401 *mpu; + mpu401_t *mpu; int err; mpu = substream->rmidi->private_data; @@ -243,9 +242,9 @@ static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream) +static int snd_mpu401_uart_output_open(snd_rawmidi_substream_t * substream) { - struct snd_mpu401 *mpu; + mpu401_t *mpu; int err; mpu = substream->rmidi->private_data; @@ -260,9 +259,9 @@ static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream) +static int snd_mpu401_uart_input_close(snd_rawmidi_substream_t * substream) { - struct snd_mpu401 *mpu; + mpu401_t *mpu; mpu = substream->rmidi->private_data; clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode); @@ -274,9 +273,9 @@ static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream) +static int snd_mpu401_uart_output_close(snd_rawmidi_substream_t * substream) { - struct snd_mpu401 *mpu; + mpu401_t *mpu; mpu = substream->rmidi->private_data; clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode); @@ -291,10 +290,10 @@ static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream) /* * trigger input callback */ -static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_mpu401_uart_input_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct snd_mpu401 *mpu; + mpu401_t *mpu; int max = 64; mpu = substream->rmidi->private_data; @@ -322,7 +321,7 @@ static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substrea * transfer input pending data * call with input_lock spinlock held */ -static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu) +static void snd_mpu401_uart_input_read(mpu401_t * mpu) { int max = 128; unsigned char byte; @@ -350,7 +349,7 @@ static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu) * write output pending bytes * call with output_lock spinlock held */ -static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu) +static void snd_mpu401_uart_output_write(mpu401_t * mpu) { unsigned char byte; int max = 256, timeout; @@ -376,10 +375,10 @@ static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu) /* * output trigger callback */ -static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_mpu401_uart_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct snd_mpu401 *mpu; + mpu401_t *mpu; mpu = substream->rmidi->private_data; if (up) { @@ -405,23 +404,23 @@ static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substre */ -static struct snd_rawmidi_ops snd_mpu401_uart_output = +static snd_rawmidi_ops_t snd_mpu401_uart_output = { .open = snd_mpu401_uart_output_open, .close = snd_mpu401_uart_output_close, .trigger = snd_mpu401_uart_output_trigger, }; -static struct snd_rawmidi_ops snd_mpu401_uart_input = +static snd_rawmidi_ops_t snd_mpu401_uart_input = { .open = snd_mpu401_uart_input_open, .close = snd_mpu401_uart_input_close, .trigger = snd_mpu401_uart_input_trigger, }; -static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi) +static void snd_mpu401_uart_free(snd_rawmidi_t *rmidi) { - struct snd_mpu401 *mpu = rmidi->private_data; + mpu401_t *mpu = rmidi->private_data; if (mpu->irq_flags && mpu->irq >= 0) free_irq(mpu->irq, (void *) mpu); release_and_free_resource(mpu->res); @@ -443,18 +442,18 @@ static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi) * * Note that the rawmidi instance is returned on the rrawmidi argument, * not the mpu401 instance itself. To access to the mpu401 instance, - * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast). + * cast from rawmidi->private_data (with mpu401_t magic-cast). * * Returns zero if successful, or a negative error code. */ -int snd_mpu401_uart_new(struct snd_card *card, int device, +int snd_mpu401_uart_new(snd_card_t * card, int device, unsigned short hardware, unsigned long port, int integrated, int irq, int irq_flags, - struct snd_rawmidi ** rrawmidi) + snd_rawmidi_t ** rrawmidi) { - struct snd_mpu401 *mpu; - struct snd_rawmidi *rmidi; + mpu401_t *mpu; + snd_rawmidi_t *rmidi; int err; if (rrawmidi) @@ -463,7 +462,6 @@ int snd_mpu401_uart_new(struct snd_card *card, int device, return err; mpu = kzalloc(sizeof(*mpu), GFP_KERNEL); if (mpu == NULL) { - snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n"); snd_device_free(card, rmidi); return -ENOMEM; } diff --git a/trunk/sound/drivers/mtpav.c b/trunk/sound/drivers/mtpav.c index b7a0b42813e1..e9d52c668edc 100644 --- a/trunk/sound/drivers/mtpav.c +++ b/trunk/sound/drivers/mtpav.c @@ -53,8 +53,6 @@ #include <sound/driver.h> #include <linux/init.h> #include <linux/interrupt.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/slab.h> #include <linux/ioport.h> #include <linux/moduleparam.h> @@ -95,8 +93,6 @@ MODULE_PARM_DESC(irq, "Parallel IRQ # for MotuMTPAV MIDI."); module_param(hwports, int, 0444); MODULE_PARM_DESC(hwports, "Hardware ports # for MotuMTPAV MIDI."); -static struct platform_device *device; - /* * defines */ @@ -129,17 +125,17 @@ static struct platform_device *device; /* */ -struct mtpav_port { +typedef struct mtpav_port { u8 number; u8 hwport; u8 mode; u8 running_status; - struct snd_rawmidi_substream *input; - struct snd_rawmidi_substream *output; -}; + snd_rawmidi_substream_t *input; + snd_rawmidi_substream_t *output; +} mtpav_port_t; -struct mtpav { - struct snd_card *card; +typedef struct mtpav { + snd_card_t *card; unsigned long port; struct resource *res_port; int irq; /* interrupt (for inputs) */ @@ -147,17 +143,23 @@ struct mtpav { int share_irq; /* number of accesses to input interrupts */ int istimer; /* number of accesses to timer interrupts */ struct timer_list timer; /* timer interrupts for outputs */ - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int num_ports; /* number of hw ports (1-8) */ - struct mtpav_port ports[NUMPORTS]; /* all ports including computer, adat and bc */ + mtpav_port_t ports[NUMPORTS]; /* all ports including computer, adat and bc */ u32 inmidiport; /* selected input midi port */ u32 inmidistate; /* during midi command 0xf5 */ u32 outmidihwport; /* selected output midi hw port */ -}; +} mtpav_t; +/* + * global instance + * hey, we handle at most only one card.. + */ +static mtpav_t *mtp_card; + /* * possible hardware ports (selected by 0xf5 port message) * 0x00 all ports @@ -181,7 +183,7 @@ struct mtpav { #define MTPAV_PIDX_BROADCAST 2 -static int translate_subdevice_to_hwport(struct mtpav *chip, int subdev) +static int translate_subdevice_to_hwport(mtpav_t *chip, int subdev) { if (subdev < 0) return 0x01; /* invalid - use port 0 as default */ @@ -196,7 +198,7 @@ static int translate_subdevice_to_hwport(struct mtpav *chip, int subdev) return 0; /* all ports */ } -static int translate_hwport_to_subdevice(struct mtpav *chip, int hwport) +static int translate_hwport_to_subdevice(mtpav_t *chip, int hwport) { int p; if (hwport <= 0x00) /* all ports */ @@ -221,7 +223,7 @@ static int translate_hwport_to_subdevice(struct mtpav *chip, int hwport) /* */ -static u8 snd_mtpav_getreg(struct mtpav *chip, u16 reg) +static u8 snd_mtpav_getreg(mtpav_t *chip, u16 reg) { u8 rval = 0; @@ -239,16 +241,19 @@ static u8 snd_mtpav_getreg(struct mtpav *chip, u16 reg) /* */ -static inline void snd_mtpav_mputreg(struct mtpav *chip, u16 reg, u8 val) +static void snd_mtpav_mputreg(mtpav_t *chip, u16 reg, u8 val) { - if (reg == DREG || reg == CREG) - outb(val, chip->port + reg); + if (reg == DREG) { + outb(val, chip->port + DREG); + } else if (reg == CREG) { + outb(val, chip->port + CREG); + } } /* */ -static void snd_mtpav_wait_rfdhi(struct mtpav *chip) +static void snd_mtpav_wait_rfdhi(mtpav_t *chip) { int counts = 10000; u8 sbyte; @@ -260,7 +265,7 @@ static void snd_mtpav_wait_rfdhi(struct mtpav *chip) } } -static void snd_mtpav_send_byte(struct mtpav *chip, u8 byte) +static void snd_mtpav_send_byte(mtpav_t *chip, u8 byte) { u8 tcbyt; u8 clrwrite; @@ -286,9 +291,8 @@ static void snd_mtpav_send_byte(struct mtpav *chip, u8 byte) */ /* call this with spin lock held */ -static void snd_mtpav_output_port_write(struct mtpav *mtp_card, - struct mtpav_port *portp, - struct snd_rawmidi_substream *substream) +static void snd_mtpav_output_port_write(mtpav_port_t *port, + snd_rawmidi_substream_t *substream) { u8 outbyte; @@ -299,35 +303,34 @@ static void snd_mtpav_output_port_write(struct mtpav *mtp_card, // send port change command if necessary - if (portp->hwport != mtp_card->outmidihwport) { - mtp_card->outmidihwport = portp->hwport; + if (port->hwport != mtp_card->outmidihwport) { + mtp_card->outmidihwport = port->hwport; snd_mtpav_send_byte(mtp_card, 0xf5); - snd_mtpav_send_byte(mtp_card, portp->hwport); - //snd_printk("new outport: 0x%x\n", (unsigned int) portp->hwport); + snd_mtpav_send_byte(mtp_card, port->hwport); + //snd_printk("new outport: 0x%x\n", (unsigned int) port->hwport); - if (!(outbyte & 0x80) && portp->running_status) - snd_mtpav_send_byte(mtp_card, portp->running_status); + if (!(outbyte & 0x80) && port->running_status) + snd_mtpav_send_byte(mtp_card, port->running_status); } // send data do { if (outbyte & 0x80) - portp->running_status = outbyte; + port->running_status = outbyte; snd_mtpav_send_byte(mtp_card, outbyte); } while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1); } -static void snd_mtpav_output_write(struct snd_rawmidi_substream *substream) +static void snd_mtpav_output_write(snd_rawmidi_substream_t * substream) { - struct mtpav *mtp_card = substream->rmidi->private_data; - struct mtpav_port *portp = &mtp_card->ports[substream->number]; + mtpav_port_t *port = &mtp_card->ports[substream->number]; unsigned long flags; spin_lock_irqsave(&mtp_card->spinlock, flags); - snd_mtpav_output_port_write(mtp_card, portp, substream); + snd_mtpav_output_port_write(port, substream); spin_unlock_irqrestore(&mtp_card->spinlock, flags); } @@ -336,7 +339,7 @@ static void snd_mtpav_output_write(struct snd_rawmidi_substream *substream) * mtpav control */ -static void snd_mtpav_portscan(struct mtpav *chip) // put mtp into smart routing mode +static void snd_mtpav_portscan(mtpav_t *chip) // put mtp into smart routing mode { u8 p; @@ -350,12 +353,12 @@ static void snd_mtpav_portscan(struct mtpav *chip) // put mtp into smart routing /* */ -static int snd_mtpav_input_open(struct snd_rawmidi_substream *substream) +static int snd_mtpav_input_open(snd_rawmidi_substream_t * substream) { - struct mtpav *mtp_card = substream->rmidi->private_data; - struct mtpav_port *portp = &mtp_card->ports[substream->number]; unsigned long flags; + mtpav_port_t *portp = &mtp_card->ports[substream->number]; + //printk("mtpav port: %d opened\n", (int) substream->number); spin_lock_irqsave(&mtp_card->spinlock, flags); portp->mode |= MTPAV_MODE_INPUT_OPENED; portp->input = substream; @@ -368,17 +371,20 @@ static int snd_mtpav_input_open(struct snd_rawmidi_substream *substream) /* */ -static int snd_mtpav_input_close(struct snd_rawmidi_substream *substream) +static int snd_mtpav_input_close(snd_rawmidi_substream_t *substream) { - struct mtpav *mtp_card = substream->rmidi->private_data; - struct mtpav_port *portp = &mtp_card->ports[substream->number]; unsigned long flags; + mtpav_port_t *portp = &mtp_card->ports[substream->number]; + + //printk("mtpav port: %d closed\n", (int) portp); spin_lock_irqsave(&mtp_card->spinlock, flags); - portp->mode &= ~MTPAV_MODE_INPUT_OPENED; + + portp->mode &= (~MTPAV_MODE_INPUT_OPENED); portp->input = NULL; if (--mtp_card->share_irq == 0) snd_mtpav_mputreg(mtp_card, CREG, 0); // disable pport interrupts + spin_unlock_irqrestore(&mtp_card->spinlock, flags); return 0; } @@ -386,11 +392,10 @@ static int snd_mtpav_input_close(struct snd_rawmidi_substream *substream) /* */ -static void snd_mtpav_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_mtpav_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct mtpav *mtp_card = substream->rmidi->private_data; - struct mtpav_port *portp = &mtp_card->ports[substream->number]; unsigned long flags; + mtpav_port_t *portp = &mtp_card->ports[substream->number]; spin_lock_irqsave(&mtp_card->spinlock, flags); if (up) @@ -409,7 +414,7 @@ static void snd_mtpav_input_trigger(struct snd_rawmidi_substream *substream, int static void snd_mtpav_output_timer(unsigned long data) { unsigned long flags; - struct mtpav *chip = (struct mtpav *)data; + mtpav_t *chip = (mtpav_t *)data; int p; spin_lock_irqsave(&chip->spinlock, flags); @@ -418,22 +423,25 @@ static void snd_mtpav_output_timer(unsigned long data) add_timer(&chip->timer); /* process each port */ for (p = 0; p <= chip->num_ports * 2 + MTPAV_PIDX_BROADCAST; p++) { - struct mtpav_port *portp = &chip->ports[p]; + mtpav_port_t *portp = &mtp_card->ports[p]; if ((portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED) && portp->output) - snd_mtpav_output_port_write(chip, portp, portp->output); + snd_mtpav_output_port_write(portp, portp->output); } spin_unlock_irqrestore(&chip->spinlock, flags); } /* spinlock held! */ -static void snd_mtpav_add_output_timer(struct mtpav *chip) +static void snd_mtpav_add_output_timer(mtpav_t *chip) { + init_timer(&chip->timer); + chip->timer.function = snd_mtpav_output_timer; + chip->timer.data = (unsigned long) mtp_card; chip->timer.expires = 1 + jiffies; add_timer(&chip->timer); } /* spinlock held! */ -static void snd_mtpav_remove_output_timer(struct mtpav *chip) +static void snd_mtpav_remove_output_timer(mtpav_t *chip) { del_timer(&chip->timer); } @@ -441,11 +449,10 @@ static void snd_mtpav_remove_output_timer(struct mtpav *chip) /* */ -static int snd_mtpav_output_open(struct snd_rawmidi_substream *substream) +static int snd_mtpav_output_open(snd_rawmidi_substream_t * substream) { - struct mtpav *mtp_card = substream->rmidi->private_data; - struct mtpav_port *portp = &mtp_card->ports[substream->number]; unsigned long flags; + mtpav_port_t *portp = &mtp_card->ports[substream->number]; spin_lock_irqsave(&mtp_card->spinlock, flags); portp->mode |= MTPAV_MODE_OUTPUT_OPENED; @@ -457,14 +464,13 @@ static int snd_mtpav_output_open(struct snd_rawmidi_substream *substream) /* */ -static int snd_mtpav_output_close(struct snd_rawmidi_substream *substream) +static int snd_mtpav_output_close(snd_rawmidi_substream_t * substream) { - struct mtpav *mtp_card = substream->rmidi->private_data; - struct mtpav_port *portp = &mtp_card->ports[substream->number]; unsigned long flags; + mtpav_port_t *portp = &mtp_card->ports[substream->number]; spin_lock_irqsave(&mtp_card->spinlock, flags); - portp->mode &= ~MTPAV_MODE_OUTPUT_OPENED; + portp->mode &= (~MTPAV_MODE_OUTPUT_OPENED); portp->output = NULL; spin_unlock_irqrestore(&mtp_card->spinlock, flags); return 0; @@ -473,15 +479,14 @@ static int snd_mtpav_output_close(struct snd_rawmidi_substream *substream) /* */ -static void snd_mtpav_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_mtpav_output_trigger(snd_rawmidi_substream_t * substream, int up) { - struct mtpav *mtp_card = substream->rmidi->private_data; - struct mtpav_port *portp = &mtp_card->ports[substream->number]; unsigned long flags; + mtpav_port_t *portp = &mtp_card->ports[substream->number]; spin_lock_irqsave(&mtp_card->spinlock, flags); if (up) { - if (! (portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED)) { + if (! (portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED)) { if (mtp_card->istimer++ == 0) snd_mtpav_add_output_timer(mtp_card); portp->mode |= MTPAV_MODE_OUTPUT_TRIGGERED; @@ -501,20 +506,23 @@ static void snd_mtpav_output_trigger(struct snd_rawmidi_substream *substream, in * midi interrupt for inputs */ -static void snd_mtpav_inmidi_process(struct mtpav *mcrd, u8 inbyte) +static void snd_mtpav_inmidi_process(mtpav_t *mcrd, u8 inbyte) { - struct mtpav_port *portp; + mtpav_port_t *portp; if ((int)mcrd->inmidiport > mcrd->num_ports * 2 + MTPAV_PIDX_BROADCAST) return; portp = &mcrd->ports[mcrd->inmidiport]; - if (portp->mode & MTPAV_MODE_INPUT_TRIGGERED) + if (portp->mode & MTPAV_MODE_INPUT_TRIGGERED) { snd_rawmidi_receive(portp->input, &inbyte, 1); + } } -static void snd_mtpav_inmidi_h(struct mtpav *mcrd, u8 inbyte) +static void snd_mtpav_inmidi_h(mtpav_t * mcrd, u8 inbyte) { + snd_assert(mcrd, return); + if (inbyte >= 0xf8) { /* real-time midi code */ snd_mtpav_inmidi_process(mcrd, inbyte); @@ -532,7 +540,7 @@ static void snd_mtpav_inmidi_h(struct mtpav *mcrd, u8 inbyte) } } -static void snd_mtpav_read_bytes(struct mtpav *mcrd) +static void snd_mtpav_read_bytes(mtpav_t * mcrd) { u8 clrread, setread; u8 mtp_read_byte; @@ -572,8 +580,9 @@ static void snd_mtpav_read_bytes(struct mtpav *mcrd) static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs) { - struct mtpav *mcard = dev_id; + mtpav_t *mcard = dev_id; + //printk("irqh()\n"); spin_lock(&mcard->spinlock); snd_mtpav_read_bytes(mcard); spin_unlock(&mcard->spinlock); @@ -583,14 +592,14 @@ static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs) /* * get ISA resources */ -static int __init snd_mtpav_get_ISA(struct mtpav * mcard) +static int snd_mtpav_get_ISA(mtpav_t * mcard) { if ((mcard->res_port = request_region(port, 3, "MotuMTPAV MIDI")) == NULL) { snd_printk("MTVAP port 0x%lx is busy\n", port); return -EBUSY; } mcard->port = port; - if (request_irq(irq, snd_mtpav_irqh, SA_INTERRUPT, "MOTU MTPAV", mcard)) { + if (request_irq(irq, snd_mtpav_irqh, SA_INTERRUPT, "MOTU MTPAV", (void *)mcard)) { snd_printk("MTVAP IRQ %d busy\n", irq); return -EBUSY; } @@ -602,13 +611,13 @@ static int __init snd_mtpav_get_ISA(struct mtpav * mcard) /* */ -static struct snd_rawmidi_ops snd_mtpav_output = { +static snd_rawmidi_ops_t snd_mtpav_output = { .open = snd_mtpav_output_open, .close = snd_mtpav_output_close, .trigger = snd_mtpav_output_trigger, }; -static struct snd_rawmidi_ops snd_mtpav_input = { +static snd_rawmidi_ops_t snd_mtpav_input = { .open = snd_mtpav_input_open, .close = snd_mtpav_input_close, .trigger = snd_mtpav_input_trigger, @@ -619,8 +628,7 @@ static struct snd_rawmidi_ops snd_mtpav_input = { * get RAWMIDI resources */ -static void __init snd_mtpav_set_name(struct mtpav *chip, - struct snd_rawmidi_substream *substream) +static void snd_mtpav_set_name(mtpav_t *chip, snd_rawmidi_substream_t *substream) { if (substream->number >= 0 && substream->number < chip->num_ports) sprintf(substream->name, "MTP direct %d", (substream->number % chip->num_ports) + 1); @@ -634,18 +642,21 @@ static void __init snd_mtpav_set_name(struct mtpav *chip, strcpy(substream->name, "MTP broadcast"); } -static int __init snd_mtpav_get_RAWMIDI(struct mtpav *mcard) +static int snd_mtpav_get_RAWMIDI(mtpav_t * mcard) { - int rval; - struct snd_rawmidi *rawmidi; - struct snd_rawmidi_substream *substream; + int rval = 0; + snd_rawmidi_t *rawmidi; + snd_rawmidi_substream_t *substream; struct list_head *list; + //printk("entering snd_mtpav_get_RAWMIDI\n"); + if (hwports < 1) - hwports = 1; + mcard->num_ports = 1; else if (hwports > 8) - hwports = 8; - mcard->num_ports = hwports; + mcard->num_ports = 8; + else + mcard->num_ports = hwports; if ((rval = snd_rawmidi_new(mcard->card, "MotuMIDI", 0, mcard->num_ports * 2 + MTPAV_PIDX_BROADCAST + 1, @@ -653,15 +664,14 @@ static int __init snd_mtpav_get_RAWMIDI(struct mtpav *mcard) &mcard->rmidi)) < 0) return rval; rawmidi = mcard->rmidi; - rawmidi->private_data = mcard; list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) { - substream = list_entry(list, struct snd_rawmidi_substream, list); + substream = list_entry(list, snd_rawmidi_substream_t, list); snd_mtpav_set_name(mcard, substream); substream->ops = &snd_mtpav_input; } list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) { - substream = list_entry(list, struct snd_rawmidi_substream, list); + substream = list_entry(list, snd_rawmidi_substream_t, list); snd_mtpav_set_name(mcard, substream); substream->ops = &snd_mtpav_output; mcard->ports[substream->number].hwport = translate_subdevice_to_hwport(mcard, substream->number); @@ -669,15 +679,36 @@ static int __init snd_mtpav_get_RAWMIDI(struct mtpav *mcard) rawmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; sprintf(rawmidi->name, "MTP AV MIDI"); + //printk("exiting snd_mtpav_get_RAWMIDI() \n"); return 0; } /* */ -static void snd_mtpav_free(struct snd_card *card) +static mtpav_t *new_mtpav(void) +{ + mtpav_t *ncrd = kzalloc(sizeof(*ncrd), GFP_KERNEL); + if (ncrd != NULL) { + spin_lock_init(&ncrd->spinlock); + + init_timer(&ncrd->timer); + ncrd->card = NULL; + ncrd->irq = -1; + ncrd->share_irq = 0; + + ncrd->inmidiport = 0xffffffff; + ncrd->inmidistate = 0; + ncrd->outmidihwport = 0xffffffff; + } + return ncrd; +} + +/* + */ + +static void free_mtpav(mtpav_t * crd) { - struct mtpav *crd = card->private_data; unsigned long flags; spin_lock_irqsave(&crd->spinlock, flags); @@ -687,101 +718,78 @@ static void snd_mtpav_free(struct snd_card *card) if (crd->irq >= 0) free_irq(crd->irq, (void *)crd); release_and_free_resource(crd->res_port); + kfree(crd); } /* */ -static int __init snd_mtpav_probe(struct platform_device *dev) + +static int __init alsa_card_mtpav_init(void) { - struct snd_card *card; - int err; - struct mtpav *mtp_card; + int err = 0; + char longname_buffer[80]; - card = snd_card_new(index, id, THIS_MODULE, sizeof(*mtp_card)); - if (! card) + mtp_card = new_mtpav(); + if (mtp_card == NULL) return -ENOMEM; - mtp_card = card->private_data; - spin_lock_init(&mtp_card->spinlock); - init_timer(&mtp_card->timer); - mtp_card->card = card; - mtp_card->irq = -1; - mtp_card->share_irq = 0; - mtp_card->inmidiport = 0xffffffff; - mtp_card->inmidistate = 0; - mtp_card->outmidihwport = 0xffffffff; - init_timer(&mtp_card->timer); - mtp_card->timer.function = snd_mtpav_output_timer; - mtp_card->timer.data = (unsigned long) mtp_card; - - card->private_free = snd_mtpav_free; + mtp_card->card = snd_card_new(index, id, THIS_MODULE, 0); + if (mtp_card->card == NULL) { + free_mtpav(mtp_card); + return -ENOMEM; + } err = snd_mtpav_get_ISA(mtp_card); + //printk("snd_mtpav_get_ISA returned: %d\n", err); if (err < 0) goto __error; - strcpy(card->driver, "MTPAV"); - strcpy(card->shortname, "MTPAV on parallel port"); - snprintf(card->longname, sizeof(card->longname), - "MTPAV on parallel port at 0x%lx", port); + strcpy(mtp_card->card->driver, "MTPAV"); + strcpy(mtp_card->card->shortname, "MTPAV on parallel port"); + memset(longname_buffer, 0, sizeof(longname_buffer)); + sprintf(longname_buffer, "MTPAV on parallel port at"); err = snd_mtpav_get_RAWMIDI(mtp_card); + //snd_printk("snd_mtapv_get_RAWMIDI returned: %d\n", err); if (err < 0) goto __error; - snd_mtpav_portscan(mtp_card); + if ((err = snd_card_set_generic_dev(mtp_card->card)) < 0) + goto __error; + + err = snd_card_register(mtp_card->card); // don't snd_card_register until AFTER all cards reources done! - snd_card_set_dev(card, &dev->dev); - err = snd_card_register(mtp_card->card); + //printk("snd_card_register returned %d\n", err); if (err < 0) goto __error; - platform_set_drvdata(dev, card); + + snd_mtpav_portscan(mtp_card); + printk(KERN_INFO "Motu MidiTimePiece on parallel port irq: %d ioport: 0x%lx\n", irq, port); + return 0; - __error: - snd_card_free(card); + __error: + snd_card_free(mtp_card->card); + free_mtpav(mtp_card); return err; } -static int snd_mtpav_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define SND_MTPAV_DRIVER "snd_mtpav" - -static struct platform_driver snd_mtpav_driver = { - .probe = snd_mtpav_probe, - .remove = snd_mtpav_remove, - .driver = { - .name = SND_MTPAV_DRIVER - }, -}; - -static int __init alsa_card_mtpav_init(void) -{ - int err; - - if ((err = platform_driver_register(&snd_mtpav_driver)) < 0) - return err; - - device = platform_device_register_simple(SND_MTPAV_DRIVER, -1, NULL, 0); - if (IS_ERR(device)) { - platform_driver_unregister(&snd_mtpav_driver); - return PTR_ERR(device); - } - return 0; -} +/* + */ static void __exit alsa_card_mtpav_exit(void) { - platform_device_unregister(device); - platform_driver_unregister(&snd_mtpav_driver); + if (mtp_card == NULL) + return; + if (mtp_card->card) + snd_card_free(mtp_card->card); + free_mtpav(mtp_card); } +/* + */ + module_init(alsa_card_mtpav_init) module_exit(alsa_card_mtpav_exit) diff --git a/trunk/sound/drivers/opl3/opl3_drums.c b/trunk/sound/drivers/opl3/opl3_drums.c index 73694380734a..f26332680c19 100644 --- a/trunk/sound/drivers/opl3/opl3_drums.c +++ b/trunk/sound/drivers/opl3/opl3_drums.c @@ -45,7 +45,7 @@ static char snd_opl3_drum_table[47] = OPL3_CYMBAL_ON, OPL3_CYMBAL_ON /* 80 - 81 */ }; -struct snd_opl3_drum_voice { +typedef struct snd_opl3_drum_voice { int voice; int op; unsigned char am_vib; @@ -54,34 +54,33 @@ struct snd_opl3_drum_voice { unsigned char sustain_release; unsigned char feedback_connection; unsigned char wave_select; -}; +} snd_opl3_drum_voice_t; -struct snd_opl3_drum_note { +typedef struct snd_opl3_drum_note { int voice; unsigned char fnum; unsigned char octave_f; unsigned char feedback_connection; -}; +} snd_opl3_drum_note_t; -static struct snd_opl3_drum_voice bass_op0 = {6, 0, 0x00, 0x32, 0xf8, 0x66, 0x30, 0x00}; -static struct snd_opl3_drum_voice bass_op1 = {6, 1, 0x00, 0x03, 0xf6, 0x57, 0x30, 0x00}; -static struct snd_opl3_drum_note bass_note = {6, 0x90, 0x09}; +static snd_opl3_drum_voice_t bass_op0 = {6, 0, 0x00, 0x32, 0xf8, 0x66, 0x30, 0x00}; +static snd_opl3_drum_voice_t bass_op1 = {6, 1, 0x00, 0x03, 0xf6, 0x57, 0x30, 0x00}; +static snd_opl3_drum_note_t bass_note = {6, 0x90, 0x09}; -static struct snd_opl3_drum_voice hihat = {7, 0, 0x00, 0x03, 0xf0, 0x06, 0x20, 0x00}; +static snd_opl3_drum_voice_t hihat = {7, 0, 0x00, 0x03, 0xf0, 0x06, 0x20, 0x00}; -static struct snd_opl3_drum_voice snare = {7, 1, 0x00, 0x03, 0xf0, 0x07, 0x20, 0x02}; -static struct snd_opl3_drum_note snare_note = {7, 0xf4, 0x0d}; +static snd_opl3_drum_voice_t snare = {7, 1, 0x00, 0x03, 0xf0, 0x07, 0x20, 0x02}; +static snd_opl3_drum_note_t snare_note = {7, 0xf4, 0x0d}; -static struct snd_opl3_drum_voice tomtom = {8, 0, 0x02, 0x03, 0xf0, 0x06, 0x10, 0x00}; -static struct snd_opl3_drum_note tomtom_note = {8, 0xf4, 0x09}; +static snd_opl3_drum_voice_t tomtom = {8, 0, 0x02, 0x03, 0xf0, 0x06, 0x10, 0x00}; +static snd_opl3_drum_note_t tomtom_note = {8, 0xf4, 0x09}; -static struct snd_opl3_drum_voice cymbal = {8, 1, 0x04, 0x03, 0xf0, 0x06, 0x10, 0x00}; +static snd_opl3_drum_voice_t cymbal = {8, 1, 0x04, 0x03, 0xf0, 0x06, 0x10, 0x00}; /* * set drum voice characteristics */ -static void snd_opl3_drum_voice_set(struct snd_opl3 *opl3, - struct snd_opl3_drum_voice *data) +static void snd_opl3_drum_voice_set(opl3_t *opl3, snd_opl3_drum_voice_t *data) { unsigned char op_offset = snd_opl3_regmap[data->voice][data->op]; unsigned char voice_offset = data->voice; @@ -115,8 +114,7 @@ static void snd_opl3_drum_voice_set(struct snd_opl3 *opl3, /* * Set drum voice pitch */ -static void snd_opl3_drum_note_set(struct snd_opl3 *opl3, - struct snd_opl3_drum_note *data) +static void snd_opl3_drum_note_set(opl3_t *opl3, snd_opl3_drum_note_t *data) { unsigned char voice_offset = data->voice; unsigned short opl3_reg; @@ -133,9 +131,8 @@ static void snd_opl3_drum_note_set(struct snd_opl3 *opl3, /* * Set drum voice volume and position */ -static void snd_opl3_drum_vol_set(struct snd_opl3 *opl3, - struct snd_opl3_drum_voice *data, - int vel, struct snd_midi_channel *chan) +static void snd_opl3_drum_vol_set(opl3_t *opl3, snd_opl3_drum_voice_t *data, + int vel, snd_midi_channel_t *chan) { unsigned char op_offset = snd_opl3_regmap[data->voice][data->op]; unsigned char voice_offset = data->voice; @@ -162,7 +159,7 @@ static void snd_opl3_drum_vol_set(struct snd_opl3 *opl3, /* * Loads drum voices at init time */ -void snd_opl3_load_drums(struct snd_opl3 *opl3) +void snd_opl3_load_drums(opl3_t *opl3) { snd_opl3_drum_voice_set(opl3, &bass_op0); snd_opl3_drum_voice_set(opl3, &bass_op1); @@ -182,11 +179,11 @@ void snd_opl3_load_drums(struct snd_opl3 *opl3) /* * Switch drum voice on or off */ -void snd_opl3_drum_switch(struct snd_opl3 *opl3, int note, int vel, int on_off, - struct snd_midi_channel *chan) +void snd_opl3_drum_switch(opl3_t *opl3, int note, int vel, int on_off, + snd_midi_channel_t *chan) { unsigned char drum_mask; - struct snd_opl3_drum_voice *drum_voice; + snd_opl3_drum_voice_t *drum_voice; if (!(opl3->drum_reg & OPL3_PERCUSSION_ENABLE)) return; diff --git a/trunk/sound/drivers/opl3/opl3_lib.c b/trunk/sound/drivers/opl3/opl3_lib.c index 1e0c76b9acfc..06246503083c 100644 --- a/trunk/sound/drivers/opl3/opl3_lib.c +++ b/trunk/sound/drivers/opl3/opl3_lib.c @@ -37,7 +37,7 @@ MODULE_LICENSE("GPL"); extern char snd_opl3_regmap[MAX_OPL2_VOICES][4]; -static void snd_opl2_command(struct snd_opl3 * opl3, unsigned short cmd, unsigned char val) +static void snd_opl2_command(opl3_t * opl3, unsigned short cmd, unsigned char val) { unsigned long flags; unsigned long port; @@ -60,7 +60,7 @@ static void snd_opl2_command(struct snd_opl3 * opl3, unsigned short cmd, unsigne spin_unlock_irqrestore(&opl3->reg_lock, flags); } -static void snd_opl3_command(struct snd_opl3 * opl3, unsigned short cmd, unsigned char val) +static void snd_opl3_command(opl3_t * opl3, unsigned short cmd, unsigned char val) { unsigned long flags; unsigned long port; @@ -85,7 +85,7 @@ static void snd_opl3_command(struct snd_opl3 * opl3, unsigned short cmd, unsigne spin_unlock_irqrestore(&opl3->reg_lock, flags); } -static int snd_opl3_detect(struct snd_opl3 * opl3) +static int snd_opl3_detect(opl3_t * opl3) { /* * This function returns 1 if the FM chip is present at the given I/O port @@ -153,12 +153,12 @@ static int snd_opl3_detect(struct snd_opl3 * opl3) * Timer 1 - 80us */ -static int snd_opl3_timer1_start(struct snd_timer * timer) +static int snd_opl3_timer1_start(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; unsigned int ticks; - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = snd_timer_chip(timer); spin_lock_irqsave(&opl3->timer_lock, flags); @@ -171,11 +171,11 @@ static int snd_opl3_timer1_start(struct snd_timer * timer) return 0; } -static int snd_opl3_timer1_stop(struct snd_timer * timer) +static int snd_opl3_timer1_stop(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = snd_timer_chip(timer); spin_lock_irqsave(&opl3->timer_lock, flags); @@ -190,12 +190,12 @@ static int snd_opl3_timer1_stop(struct snd_timer * timer) * Timer 2 - 320us */ -static int snd_opl3_timer2_start(struct snd_timer * timer) +static int snd_opl3_timer2_start(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; unsigned int ticks; - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = snd_timer_chip(timer); spin_lock_irqsave(&opl3->timer_lock, flags); @@ -208,11 +208,11 @@ static int snd_opl3_timer2_start(struct snd_timer * timer) return 0; } -static int snd_opl3_timer2_stop(struct snd_timer * timer) +static int snd_opl3_timer2_stop(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = snd_timer_chip(timer); spin_lock_irqsave(&opl3->timer_lock, flags); @@ -227,7 +227,7 @@ static int snd_opl3_timer2_stop(struct snd_timer * timer) */ -static struct snd_timer_hardware snd_opl3_timer1 = +static struct _snd_timer_hardware snd_opl3_timer1 = { .flags = SNDRV_TIMER_HW_STOP, .resolution = 80000, @@ -236,7 +236,7 @@ static struct snd_timer_hardware snd_opl3_timer1 = .stop = snd_opl3_timer1_stop, }; -static struct snd_timer_hardware snd_opl3_timer2 = +static struct _snd_timer_hardware snd_opl3_timer2 = { .flags = SNDRV_TIMER_HW_STOP, .resolution = 320000, @@ -245,10 +245,10 @@ static struct snd_timer_hardware snd_opl3_timer2 = .stop = snd_opl3_timer2_stop, }; -static int snd_opl3_timer1_init(struct snd_opl3 * opl3, int timer_no) +static int snd_opl3_timer1_init(opl3_t * opl3, int timer_no) { - struct snd_timer *timer = NULL; - struct snd_timer_id tid; + snd_timer_t *timer = NULL; + snd_timer_id_t tid; int err; tid.dev_class = SNDRV_TIMER_CLASS_CARD; @@ -265,10 +265,10 @@ static int snd_opl3_timer1_init(struct snd_opl3 * opl3, int timer_no) return err; } -static int snd_opl3_timer2_init(struct snd_opl3 * opl3, int timer_no) +static int snd_opl3_timer2_init(opl3_t * opl3, int timer_no) { - struct snd_timer *timer = NULL; - struct snd_timer_id tid; + snd_timer_t *timer = NULL; + snd_timer_id_t tid; int err; tid.dev_class = SNDRV_TIMER_CLASS_CARD; @@ -289,11 +289,11 @@ static int snd_opl3_timer2_init(struct snd_opl3 * opl3, int timer_no) */ -void snd_opl3_interrupt(struct snd_hwdep * hw) +void snd_opl3_interrupt(snd_hwdep_t * hw) { unsigned char status; - struct snd_opl3 *opl3; - struct snd_timer *timer; + opl3_t *opl3; + snd_timer_t *timer; if (hw == NULL) return; @@ -320,7 +320,7 @@ void snd_opl3_interrupt(struct snd_hwdep * hw) */ -static int snd_opl3_free(struct snd_opl3 *opl3) +static int snd_opl3_free(opl3_t *opl3) { snd_assert(opl3 != NULL, return -ENXIO); if (opl3->private_free) @@ -331,28 +331,26 @@ static int snd_opl3_free(struct snd_opl3 *opl3) return 0; } -static int snd_opl3_dev_free(struct snd_device *device) +static int snd_opl3_dev_free(snd_device_t *device) { - struct snd_opl3 *opl3 = device->device_data; + opl3_t *opl3 = device->device_data; return snd_opl3_free(opl3); } -int snd_opl3_new(struct snd_card *card, +int snd_opl3_new(snd_card_t *card, unsigned short hardware, - struct snd_opl3 **ropl3) + opl3_t **ropl3) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_opl3_dev_free, }; - struct snd_opl3 *opl3; + opl3_t *opl3; int err; *ropl3 = NULL; opl3 = kzalloc(sizeof(*opl3), GFP_KERNEL); - if (opl3 == NULL) { - snd_printk(KERN_ERR "opl3: cannot allocate\n"); + if (opl3 == NULL) return -ENOMEM; - } opl3->card = card; opl3->hardware = hardware; @@ -369,7 +367,7 @@ int snd_opl3_new(struct snd_card *card, return 0; } -int snd_opl3_init(struct snd_opl3 *opl3) +int snd_opl3_init(opl3_t *opl3) { if (! opl3->command) { printk(KERN_ERR "snd_opl3_init: command not defined!\n"); @@ -393,14 +391,14 @@ int snd_opl3_init(struct snd_opl3 *opl3) return 0; } -int snd_opl3_create(struct snd_card *card, +int snd_opl3_create(snd_card_t * card, unsigned long l_port, unsigned long r_port, unsigned short hardware, int integrated, - struct snd_opl3 ** ropl3) + opl3_t ** ropl3) { - struct snd_opl3 *opl3; + opl3_t *opl3; int err; *ropl3 = NULL; @@ -409,13 +407,13 @@ int snd_opl3_create(struct snd_card *card, if (! integrated) { if ((opl3->res_l_port = request_region(l_port, 2, "OPL2/3 (left)")) == NULL) { snd_printk(KERN_ERR "opl3: can't grab left port 0x%lx\n", l_port); - snd_device_free(card, opl3); + snd_opl3_free(opl3); return -EBUSY; } if (r_port != 0 && (opl3->res_r_port = request_region(r_port, 2, "OPL2/3 (right)")) == NULL) { snd_printk(KERN_ERR "opl3: can't grab right port 0x%lx\n", r_port); - snd_device_free(card, opl3); + snd_opl3_free(opl3); return -EBUSY; } } @@ -434,7 +432,7 @@ int snd_opl3_create(struct snd_card *card, if ((err = snd_opl3_detect(opl3)) < 0) { snd_printd("OPL2/3 chip not detected at 0x%lx/0x%lx\n", opl3->l_port, opl3->r_port); - snd_device_free(card, opl3); + snd_opl3_free(opl3); return err; } /* detect routine returns correct hardware type */ @@ -451,7 +449,7 @@ int snd_opl3_create(struct snd_card *card, return 0; } -int snd_opl3_timer_new(struct snd_opl3 * opl3, int timer1_dev, int timer2_dev) +int snd_opl3_timer_new(opl3_t * opl3, int timer1_dev, int timer2_dev) { int err; @@ -468,12 +466,12 @@ int snd_opl3_timer_new(struct snd_opl3 * opl3, int timer1_dev, int timer2_dev) return 0; } -int snd_opl3_hwdep_new(struct snd_opl3 * opl3, +int snd_opl3_hwdep_new(opl3_t * opl3, int device, int seq_device, - struct snd_hwdep ** rhwdep) + snd_hwdep_t ** rhwdep) { - struct snd_hwdep *hw; - struct snd_card *card = opl3->card; + snd_hwdep_t *hw; + snd_card_t *card = opl3->card; int err; if (rhwdep) @@ -516,9 +514,9 @@ int snd_opl3_hwdep_new(struct snd_opl3 * opl3, opl3->seq_dev_num = seq_device; #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) if (snd_seq_device_new(card, seq_device, SNDRV_SEQ_DEV_ID_OPL3, - sizeof(struct snd_opl3 *), &opl3->seq_dev) >= 0) { + sizeof(opl3_t*), &opl3->seq_dev) >= 0) { strcpy(opl3->seq_dev->name, hw->name); - *(struct snd_opl3 **)SNDRV_SEQ_DEVICE_ARGPTR(opl3->seq_dev) = opl3; + *(opl3_t**)SNDRV_SEQ_DEVICE_ARGPTR(opl3->seq_dev) = opl3; } #endif if (rhwdep) diff --git a/trunk/sound/drivers/opl3/opl3_midi.c b/trunk/sound/drivers/opl3/opl3_midi.c index 1b6f227af370..93d674070b71 100644 --- a/trunk/sound/drivers/opl3/opl3_midi.c +++ b/trunk/sound/drivers/opl3/opl3_midi.c @@ -60,7 +60,7 @@ static char opl3_volume_table[128] = }; void snd_opl3_calc_volume(unsigned char *volbyte, int vel, - struct snd_midi_channel *chan) + snd_midi_channel_t *chan) { int oldvol, newvol, n; int volume; @@ -93,7 +93,7 @@ static short opl3_note_table[16] = }; static void snd_opl3_calc_pitch(unsigned char *fnum, unsigned char *blocknum, - int note, struct snd_midi_channel *chan) + int note, snd_midi_channel_t *chan) { int block = ((note / 12) & 0x07) - 1; int idx = (note % 12) + 2; @@ -121,7 +121,7 @@ static void snd_opl3_calc_pitch(unsigned char *fnum, unsigned char *blocknum, #ifdef DEBUG_ALLOC -static void debug_alloc(struct snd_opl3 *opl3, char *s, int voice) { +static void debug_alloc(opl3_t *opl3, char *s, int voice) { int i; char *str = "x.24"; @@ -135,12 +135,12 @@ static void debug_alloc(struct snd_opl3 *opl3, char *s, int voice) { /* * Get a FM voice (channel) to play a note on. */ -static int opl3_get_voice(struct snd_opl3 *opl3, int instr_4op, - struct snd_midi_channel *chan) { +static int opl3_get_voice(opl3_t *opl3, int instr_4op, + snd_midi_channel_t *chan) { int chan_4op_1; /* first voice for 4op instrument */ int chan_4op_2; /* second voice for 4op instrument */ - struct snd_opl3_voice *vp, *vp2; + snd_opl3_voice_t *vp, *vp2; unsigned int voice_time; int i; @@ -237,14 +237,13 @@ static int opl3_get_voice(struct snd_opl3 *opl3, int instr_4op, void snd_opl3_timer_func(unsigned long data) { - struct snd_opl3 *opl3 = (struct snd_opl3 *)data; - unsigned long flags; + opl3_t *opl3 = (opl3_t *)data; int again = 0; int i; - spin_lock_irqsave(&opl3->sys_timer_lock, flags); + spin_lock(&opl3->sys_timer_lock); for (i = 0; i < opl3->max_voices; i++) { - struct snd_opl3_voice *vp = &opl3->voices[i]; + snd_opl3_voice_t *vp = &opl3->voices[i]; if (vp->state > 0 && vp->note_off_check) { if (vp->note_off == jiffies) snd_opl3_note_off(opl3, vp->note, 0, vp->chan); @@ -258,13 +257,13 @@ void snd_opl3_timer_func(unsigned long data) } else { opl3->sys_timer_status = 0; } - spin_unlock_irqrestore(&opl3->sys_timer_lock, flags); + spin_unlock(&opl3->sys_timer_lock); } /* * Start system timer */ -static void snd_opl3_start_timer(struct snd_opl3 *opl3) +static void snd_opl3_start_timer(opl3_t *opl3) { unsigned long flags; spin_lock_irqsave(&opl3->sys_timer_lock, flags); @@ -286,15 +285,15 @@ static int snd_opl3_oss_map[MAX_OPL3_VOICES] = { /* * Start a note. */ -void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) +void snd_opl3_note_on(void *p, int note, int vel, snd_midi_channel_t *chan) { - struct snd_opl3 *opl3; - struct snd_seq_instr wanted; - struct snd_seq_kinstr *kinstr; + opl3_t *opl3; + snd_seq_instr_t wanted; + snd_seq_kinstr_t *kinstr; int instr_4op; int voice; - struct snd_opl3_voice *vp, *vp2; + snd_opl3_voice_t *vp, *vp2; unsigned short connect_mask; unsigned char connection; unsigned char vol_op[4]; @@ -311,7 +310,7 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) unsigned char fnum, blocknum; int i; - struct fm_instrument *fm; + fm_instrument_t *fm; unsigned long flags; opl3 = p; @@ -616,13 +615,13 @@ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) spin_unlock_irqrestore(&opl3->voice_lock, flags); } -static void snd_opl3_kill_voice(struct snd_opl3 *opl3, int voice) +static void snd_opl3_kill_voice(opl3_t *opl3, int voice) { unsigned short reg_side; unsigned char voice_offset; unsigned short opl3_reg; - struct snd_opl3_voice *vp, *vp2; + snd_opl3_voice_t *vp, *vp2; snd_assert(voice < MAX_OPL3_VOICES, return); @@ -664,12 +663,12 @@ static void snd_opl3_kill_voice(struct snd_opl3 *opl3, int voice) /* * Release a note in response to a midi note off. */ -void snd_opl3_note_off(void *p, int note, int vel, struct snd_midi_channel *chan) +void snd_opl3_note_off(void *p, int note, int vel, snd_midi_channel_t *chan) { - struct snd_opl3 *opl3; + opl3_t *opl3; int voice; - struct snd_opl3_voice *vp; + snd_opl3_voice_t *vp; unsigned long flags; @@ -709,9 +708,9 @@ void snd_opl3_note_off(void *p, int note, int vel, struct snd_midi_channel *chan /* * key pressure change */ -void snd_opl3_key_press(void *p, int note, int vel, struct snd_midi_channel *chan) +void snd_opl3_key_press(void *p, int note, int vel, snd_midi_channel_t *chan) { - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = p; #ifdef DEBUG_MIDI @@ -723,9 +722,9 @@ void snd_opl3_key_press(void *p, int note, int vel, struct snd_midi_channel *cha /* * terminate note */ -void snd_opl3_terminate_note(void *p, int note, struct snd_midi_channel *chan) +void snd_opl3_terminate_note(void *p, int note, snd_midi_channel_t *chan) { - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = p; #ifdef DEBUG_MIDI @@ -734,7 +733,7 @@ void snd_opl3_terminate_note(void *p, int note, struct snd_midi_channel *chan) #endif } -static void snd_opl3_update_pitch(struct snd_opl3 *opl3, int voice) +static void snd_opl3_update_pitch(opl3_t *opl3, int voice) { unsigned short reg_side; unsigned char voice_offset; @@ -742,7 +741,7 @@ static void snd_opl3_update_pitch(struct snd_opl3 *opl3, int voice) unsigned char fnum, blocknum; - struct snd_opl3_voice *vp; + snd_opl3_voice_t *vp; snd_assert(voice < MAX_OPL3_VOICES, return); @@ -781,10 +780,10 @@ static void snd_opl3_update_pitch(struct snd_opl3 *opl3, int voice) /* * Update voice pitch controller */ -static void snd_opl3_pitch_ctrl(struct snd_opl3 *opl3, struct snd_midi_channel *chan) +static void snd_opl3_pitch_ctrl(opl3_t *opl3, snd_midi_channel_t *chan) { int voice; - struct snd_opl3_voice *vp; + snd_opl3_voice_t *vp; unsigned long flags; @@ -811,9 +810,9 @@ static void snd_opl3_pitch_ctrl(struct snd_opl3 *opl3, struct snd_midi_channel * * Deal with a controler type event. This includes all types of * control events, not just the midi controllers */ -void snd_opl3_control(void *p, int type, struct snd_midi_channel *chan) +void snd_opl3_control(void *p, int type, snd_midi_channel_t *chan) { - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = p; #ifdef DEBUG_MIDI @@ -847,10 +846,10 @@ void snd_opl3_control(void *p, int type, struct snd_midi_channel *chan) /* * NRPN events */ -void snd_opl3_nrpn(void *p, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset) +void snd_opl3_nrpn(void *p, snd_midi_channel_t *chan, + snd_midi_channel_set_t *chset) { - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = p; #ifdef DEBUG_MIDI @@ -863,9 +862,9 @@ void snd_opl3_nrpn(void *p, struct snd_midi_channel *chan, * receive sysex */ void snd_opl3_sysex(void *p, unsigned char *buf, int len, - int parsed, struct snd_midi_channel_set *chset) + int parsed, snd_midi_channel_set_t *chset) { - struct snd_opl3 *opl3; + opl3_t *opl3; opl3 = p; #ifdef DEBUG_MIDI diff --git a/trunk/sound/drivers/opl3/opl3_oss.c b/trunk/sound/drivers/opl3/opl3_oss.c index 31f1f2e25aa0..21a2b409d6d3 100644 --- a/trunk/sound/drivers/opl3/opl3_oss.c +++ b/trunk/sound/drivers/opl3/opl3_oss.c @@ -21,11 +21,11 @@ #include "opl3_voice.h" #include <linux/slab.h> -static int snd_opl3_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure); -static int snd_opl3_close_seq_oss(struct snd_seq_oss_arg *arg); -static int snd_opl3_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned long ioarg); -static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, const char __user *buf, int offs, int count); -static int snd_opl3_reset_seq_oss(struct snd_seq_oss_arg *arg); +static int snd_opl3_open_seq_oss(snd_seq_oss_arg_t *arg, void *closure); +static int snd_opl3_close_seq_oss(snd_seq_oss_arg_t *arg); +static int snd_opl3_ioctl_seq_oss(snd_seq_oss_arg_t *arg, unsigned int cmd, unsigned long ioarg); +static int snd_opl3_load_patch_seq_oss(snd_seq_oss_arg_t *arg, int format, const char __user *buf, int offs, int count); +static int snd_opl3_reset_seq_oss(snd_seq_oss_arg_t *arg); /* */ @@ -43,9 +43,9 @@ static inline void snd_leave_user(mm_segment_t fs) /* operators */ -extern struct snd_midi_op opl3_ops; +extern snd_midi_op_t opl3_ops; -static struct snd_seq_oss_callback oss_callback = { +static snd_seq_oss_callback_t oss_callback = { .owner = THIS_MODULE, .open = snd_opl3_open_seq_oss, .close = snd_opl3_close_seq_oss, @@ -54,10 +54,10 @@ static struct snd_seq_oss_callback oss_callback = { .reset = snd_opl3_reset_seq_oss, }; -static int snd_opl3_oss_event_input(struct snd_seq_event *ev, int direct, +static int snd_opl3_oss_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct snd_opl3 *opl3 = private_data; + opl3_t *opl3 = private_data; if (ev->type != SNDRV_SEQ_EVENT_OSS) snd_midi_process_event(&opl3_ops, ev, opl3->oss_chset); @@ -68,14 +68,14 @@ static int snd_opl3_oss_event_input(struct snd_seq_event *ev, int direct, static void snd_opl3_oss_free_port(void *private_data) { - struct snd_opl3 *opl3 = private_data; + opl3_t *opl3 = private_data; snd_midi_channel_free_set(opl3->oss_chset); } -static int snd_opl3_oss_create_port(struct snd_opl3 * opl3) +static int snd_opl3_oss_create_port(opl3_t * opl3) { - struct snd_seq_port_callback callbacks; + snd_seq_port_callback_t callbacks; char name[32]; int voices, opl_ver; @@ -113,13 +113,13 @@ static int snd_opl3_oss_create_port(struct snd_opl3 * opl3) /* ------------------------------ */ /* register OSS synth */ -void snd_opl3_init_seq_oss(struct snd_opl3 *opl3, char *name) +void snd_opl3_init_seq_oss(opl3_t *opl3, char *name) { - struct snd_seq_oss_reg *arg; - struct snd_seq_device *dev; + snd_seq_oss_reg_t *arg; + snd_seq_device_t *dev; if (snd_seq_device_new(opl3->card, 0, SNDRV_SEQ_DEV_ID_OSS, - sizeof(struct snd_seq_oss_reg), &dev) < 0) + sizeof(snd_seq_oss_reg_t), &dev) < 0) return; opl3->oss_seq_dev = dev; @@ -143,7 +143,7 @@ void snd_opl3_init_seq_oss(struct snd_opl3 *opl3, char *name) } /* unregister */ -void snd_opl3_free_seq_oss(struct snd_opl3 *opl3) +void snd_opl3_free_seq_oss(opl3_t *opl3) { if (opl3->oss_seq_dev) { snd_device_free(opl3->card, opl3->oss_seq_dev); @@ -154,9 +154,9 @@ void snd_opl3_free_seq_oss(struct snd_opl3 *opl3) /* ------------------------------ */ /* open OSS sequencer */ -static int snd_opl3_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure) +static int snd_opl3_open_seq_oss(snd_seq_oss_arg_t *arg, void *closure) { - struct snd_opl3 *opl3 = closure; + opl3_t *opl3 = closure; int err; snd_assert(arg != NULL, return -ENXIO); @@ -177,9 +177,9 @@ static int snd_opl3_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure) } /* close OSS sequencer */ -static int snd_opl3_close_seq_oss(struct snd_seq_oss_arg *arg) +static int snd_opl3_close_seq_oss(snd_seq_oss_arg_t *arg) { - struct snd_opl3 *opl3; + opl3_t *opl3; snd_assert(arg != NULL, return -ENXIO); opl3 = arg->private_data; @@ -206,10 +206,10 @@ static int snd_opl3_close_seq_oss(struct snd_seq_oss_arg *arg) /* from sound_config.h */ #define SBFM_MAXINSTR 256 -static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, +static int snd_opl3_load_patch_seq_oss(snd_seq_oss_arg_t *arg, int format, const char __user *buf, int offs, int count) { - struct snd_opl3 *opl3; + opl3_t *opl3; int err = -EINVAL; snd_assert(arg != NULL, return -ENXIO); @@ -219,11 +219,11 @@ static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, struct sbi_instrument sbi; size_t size; - struct snd_seq_instr_header *put; - struct snd_seq_instr_data *data; - struct fm_xinstrument *xinstr; + snd_seq_instr_header_t *put; + snd_seq_instr_data_t *data; + fm_xinstrument_t *xinstr; - struct snd_seq_event ev; + snd_seq_event_t ev; int i; mm_segment_t fs; @@ -240,7 +240,7 @@ static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, return -EINVAL; } - size = sizeof(*put) + sizeof(struct fm_xinstrument); + size = sizeof(*put) + sizeof(fm_xinstrument_t); put = kzalloc(size, GFP_KERNEL); if (put == NULL) return -ENOMEM; @@ -249,7 +249,7 @@ static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, data->type = SNDRV_SEQ_INSTR_ATYPE_DATA; strcpy(data->data.format, SNDRV_SEQ_INSTR_ID_OPL2_3); /* build data section */ - xinstr = (struct fm_xinstrument *)(data + 1); + xinstr = (fm_xinstrument_t *)(data + 1); xinstr->stype = FM_STRU_INSTR; for (i = 0; i < 2; i++) { @@ -296,7 +296,7 @@ static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, err = snd_seq_instr_event(&opl3->fm_ops, opl3->ilist, &ev, opl3->seq_client, 0, 0); if (err == -EBUSY) { - struct snd_seq_instr_header remove; + snd_seq_instr_header_t remove; memset (&remove, 0, sizeof(remove)); remove.cmd = SNDRV_SEQ_INSTR_FREE_CMD_SINGLE; @@ -319,10 +319,10 @@ static int snd_opl3_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, } /* ioctl */ -static int snd_opl3_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, +static int snd_opl3_ioctl_seq_oss(snd_seq_oss_arg_t *arg, unsigned int cmd, unsigned long ioarg) { - struct snd_opl3 *opl3; + opl3_t *opl3; snd_assert(arg != NULL, return -ENXIO); opl3 = arg->private_data; @@ -345,9 +345,9 @@ static int snd_opl3_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, } /* reset device */ -static int snd_opl3_reset_seq_oss(struct snd_seq_oss_arg *arg) +static int snd_opl3_reset_seq_oss(snd_seq_oss_arg_t *arg) { - struct snd_opl3 *opl3; + opl3_t *opl3; snd_assert(arg != NULL, return -ENXIO); opl3 = arg->private_data; diff --git a/trunk/sound/drivers/opl3/opl3_seq.c b/trunk/sound/drivers/opl3/opl3_seq.c index c4ead790008a..136964b844de 100644 --- a/trunk/sound/drivers/opl3/opl3_seq.c +++ b/trunk/sound/drivers/opl3/opl3_seq.c @@ -35,7 +35,7 @@ int use_internal_drums = 0; module_param(use_internal_drums, bool, 0444); MODULE_PARM_DESC(use_internal_drums, "Enable internal OPL2/3 drums."); -int snd_opl3_synth_use_inc(struct snd_opl3 * opl3) +int snd_opl3_synth_use_inc(opl3_t * opl3) { if (!try_module_get(opl3->card->module)) return -EFAULT; @@ -43,12 +43,12 @@ int snd_opl3_synth_use_inc(struct snd_opl3 * opl3) } -void snd_opl3_synth_use_dec(struct snd_opl3 * opl3) +void snd_opl3_synth_use_dec(opl3_t * opl3) { module_put(opl3->card->module); } -int snd_opl3_synth_setup(struct snd_opl3 * opl3) +int snd_opl3_synth_setup(opl3_t * opl3) { int idx; @@ -78,7 +78,7 @@ int snd_opl3_synth_setup(struct snd_opl3 * opl3) return 0; } -void snd_opl3_synth_cleanup(struct snd_opl3 * opl3) +void snd_opl3_synth_cleanup(opl3_t * opl3) { unsigned long flags; @@ -96,9 +96,9 @@ void snd_opl3_synth_cleanup(struct snd_opl3 * opl3) up(&opl3->access_mutex); } -static int snd_opl3_synth_use(void *private_data, struct snd_seq_port_subscribe * info) +static int snd_opl3_synth_use(void *private_data, snd_seq_port_subscribe_t * info) { - struct snd_opl3 *opl3 = private_data; + opl3_t *opl3 = private_data; int err; if ((err = snd_opl3_synth_setup(opl3)) < 0) @@ -123,9 +123,9 @@ static int snd_opl3_synth_use(void *private_data, struct snd_seq_port_subscribe return 0; } -static int snd_opl3_synth_unuse(void *private_data, struct snd_seq_port_subscribe * info) +static int snd_opl3_synth_unuse(void *private_data, snd_seq_port_subscribe_t * info) { - struct snd_opl3 *opl3 = private_data; + opl3_t *opl3 = private_data; snd_opl3_synth_cleanup(opl3); @@ -137,7 +137,7 @@ static int snd_opl3_synth_unuse(void *private_data, struct snd_seq_port_subscrib /* * MIDI emulation operators */ -struct snd_midi_op opl3_ops = { +snd_midi_op_t opl3_ops = { .note_on = snd_opl3_note_on, .note_off = snd_opl3_note_off, .key_press = snd_opl3_key_press, @@ -147,10 +147,10 @@ struct snd_midi_op opl3_ops = { .sysex = snd_opl3_sysex, }; -static int snd_opl3_synth_event_input(struct snd_seq_event * ev, int direct, +static int snd_opl3_synth_event_input(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop) { - struct snd_opl3 *opl3 = private_data; + opl3_t *opl3 = private_data; if (ev->type >= SNDRV_SEQ_EVENT_INSTR_BEGIN && ev->type <= SNDRV_SEQ_EVENT_INSTR_CHANGE) { @@ -168,14 +168,14 @@ static int snd_opl3_synth_event_input(struct snd_seq_event * ev, int direct, static void snd_opl3_synth_free_port(void *private_data) { - struct snd_opl3 *opl3 = private_data; + opl3_t *opl3 = private_data; snd_midi_channel_free_set(opl3->chset); } -static int snd_opl3_synth_create_port(struct snd_opl3 * opl3) +static int snd_opl3_synth_create_port(opl3_t * opl3) { - struct snd_seq_port_callback callbacks; + snd_seq_port_callback_t callbacks; char name[32]; int voices, opl_ver; @@ -215,14 +215,15 @@ static int snd_opl3_synth_create_port(struct snd_opl3 * opl3) /* ------------------------------ */ -static int snd_opl3_seq_new_device(struct snd_seq_device *dev) +static int snd_opl3_seq_new_device(snd_seq_device_t *dev) { - struct snd_opl3 *opl3; + opl3_t *opl3; int client; - char name[32]; + snd_seq_client_callback_t callbacks; + snd_seq_client_info_t cinfo; int opl_ver; - opl3 = *(struct snd_opl3 **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + opl3 = *(opl3_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (opl3 == NULL) return -EINVAL; @@ -231,14 +232,22 @@ static int snd_opl3_seq_new_device(struct snd_seq_device *dev) opl3->seq_client = -1; /* allocate new client */ - opl_ver = (opl3->hardware & OPL3_HW_MASK) >> 8; - sprintf(name, "OPL%i FM synth", opl_ver); + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.private_data = opl3; + callbacks.allow_output = callbacks.allow_input = 1; client = opl3->seq_client = - snd_seq_create_kernel_client(opl3->card, opl3->seq_dev_num, - name); + snd_seq_create_kernel_client(opl3->card, opl3->seq_dev_num, &callbacks); if (client < 0) return client; + /* change name of client */ + memset(&cinfo, 0, sizeof(cinfo)); + cinfo.client = client; + cinfo.type = KERNEL_CLIENT; + opl_ver = (opl3->hardware & OPL3_HW_MASK) >> 8; + sprintf(cinfo.name, "OPL%i FM synth", opl_ver); + snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); + snd_opl3_synth_create_port(opl3); /* initialize instrument list */ @@ -259,16 +268,16 @@ static int snd_opl3_seq_new_device(struct snd_seq_device *dev) opl3->sys_timer_status = 0; #ifdef CONFIG_SND_SEQUENCER_OSS - snd_opl3_init_seq_oss(opl3, name); + snd_opl3_init_seq_oss(opl3, cinfo.name); #endif return 0; } -static int snd_opl3_seq_delete_device(struct snd_seq_device *dev) +static int snd_opl3_seq_delete_device(snd_seq_device_t *dev) { - struct snd_opl3 *opl3; + opl3_t *opl3; - opl3 = *(struct snd_opl3 **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + opl3 = *(opl3_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (opl3 == NULL) return -EINVAL; @@ -286,14 +295,14 @@ static int snd_opl3_seq_delete_device(struct snd_seq_device *dev) static int __init alsa_opl3_seq_init(void) { - static struct snd_seq_dev_ops ops = + static snd_seq_dev_ops_t ops = { snd_opl3_seq_new_device, snd_opl3_seq_delete_device }; return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OPL3, &ops, - sizeof(struct snd_opl3 *)); + sizeof(opl3_t*)); } static void __exit alsa_opl3_seq_exit(void) diff --git a/trunk/sound/drivers/opl3/opl3_synth.c b/trunk/sound/drivers/opl3/opl3_synth.c index 3534a0e3342a..04f9f955e5b7 100644 --- a/trunk/sound/drivers/opl3/opl3_synth.c +++ b/trunk/sound/drivers/opl3/opl3_synth.c @@ -61,20 +61,20 @@ char snd_opl3_regmap[MAX_OPL2_VOICES][4] = /* * prototypes */ -static int snd_opl3_play_note(struct snd_opl3 * opl3, struct snd_dm_fm_note * note); -static int snd_opl3_set_voice(struct snd_opl3 * opl3, struct snd_dm_fm_voice * voice); -static int snd_opl3_set_params(struct snd_opl3 * opl3, struct snd_dm_fm_params * params); -static int snd_opl3_set_mode(struct snd_opl3 * opl3, int mode); -static int snd_opl3_set_connection(struct snd_opl3 * opl3, int connection); +static int snd_opl3_play_note(opl3_t * opl3, snd_dm_fm_note_t * note); +static int snd_opl3_set_voice(opl3_t * opl3, snd_dm_fm_voice_t * voice); +static int snd_opl3_set_params(opl3_t * opl3, snd_dm_fm_params_t * params); +static int snd_opl3_set_mode(opl3_t * opl3, int mode); +static int snd_opl3_set_connection(opl3_t * opl3, int connection); /* ------------------------------ */ /* * open the device exclusively */ -int snd_opl3_open(struct snd_hwdep * hw, struct file *file) +int snd_opl3_open(snd_hwdep_t * hw, struct file *file) { - struct snd_opl3 *opl3 = hw->private_data; + opl3_t *opl3 = hw->private_data; down(&opl3->access_mutex); if (opl3->used) { @@ -90,10 +90,10 @@ int snd_opl3_open(struct snd_hwdep * hw, struct file *file) /* * ioctl for hwdep device: */ -int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file, +int snd_opl3_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_opl3 *opl3 = hw->private_data; + opl3_t *opl3 = hw->private_data; void __user *argp = (void __user *)arg; snd_assert(opl3 != NULL, return -EINVAL); @@ -102,11 +102,11 @@ int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file, /* get information */ case SNDRV_DM_FM_IOCTL_INFO: { - struct snd_dm_fm_info info; + snd_dm_fm_info_t info; info.fm_mode = opl3->fm_mode; info.rhythm = opl3->rhythm; - if (copy_to_user(argp, &info, sizeof(struct snd_dm_fm_info))) + if (copy_to_user(argp, &info, sizeof(snd_dm_fm_info_t))) return -EFAULT; return 0; } @@ -123,8 +123,8 @@ int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file, case SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE: #endif { - struct snd_dm_fm_note note; - if (copy_from_user(¬e, argp, sizeof(struct snd_dm_fm_note))) + snd_dm_fm_note_t note; + if (copy_from_user(¬e, argp, sizeof(snd_dm_fm_note_t))) return -EFAULT; return snd_opl3_play_note(opl3, ¬e); } @@ -134,8 +134,8 @@ int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file, case SNDRV_DM_FM_OSS_IOCTL_SET_VOICE: #endif { - struct snd_dm_fm_voice voice; - if (copy_from_user(&voice, argp, sizeof(struct snd_dm_fm_voice))) + snd_dm_fm_voice_t voice; + if (copy_from_user(&voice, argp, sizeof(snd_dm_fm_voice_t))) return -EFAULT; return snd_opl3_set_voice(opl3, &voice); } @@ -145,8 +145,8 @@ int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file, case SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS: #endif { - struct snd_dm_fm_params params; - if (copy_from_user(¶ms, argp, sizeof(struct snd_dm_fm_params))) + snd_dm_fm_params_t params; + if (copy_from_user(¶ms, argp, sizeof(snd_dm_fm_params_t))) return -EFAULT; return snd_opl3_set_params(opl3, ¶ms); } @@ -174,9 +174,9 @@ int snd_opl3_ioctl(struct snd_hwdep * hw, struct file *file, /* * close the device */ -int snd_opl3_release(struct snd_hwdep * hw, struct file *file) +int snd_opl3_release(snd_hwdep_t * hw, struct file *file) { - struct snd_opl3 *opl3 = hw->private_data; + opl3_t *opl3 = hw->private_data; snd_opl3_reset(opl3); down(&opl3->access_mutex); @@ -188,7 +188,7 @@ int snd_opl3_release(struct snd_hwdep * hw, struct file *file) /* ------------------------------ */ -void snd_opl3_reset(struct snd_opl3 * opl3) +void snd_opl3_reset(opl3_t * opl3) { unsigned short opl3_reg; @@ -229,7 +229,7 @@ void snd_opl3_reset(struct snd_opl3 * opl3) } -static int snd_opl3_play_note(struct snd_opl3 * opl3, struct snd_dm_fm_note * note) +static int snd_opl3_play_note(opl3_t * opl3, snd_dm_fm_note_t * note) { unsigned short reg_side; unsigned char voice_offset; @@ -276,7 +276,7 @@ static int snd_opl3_play_note(struct snd_opl3 * opl3, struct snd_dm_fm_note * no } -static int snd_opl3_set_voice(struct snd_opl3 * opl3, struct snd_dm_fm_voice * voice) +static int snd_opl3_set_voice(opl3_t * opl3, snd_dm_fm_voice_t * voice) { unsigned short reg_side; unsigned char op_offset; @@ -378,7 +378,7 @@ static int snd_opl3_set_voice(struct snd_opl3 * opl3, struct snd_dm_fm_voice * v return 0; } -static int snd_opl3_set_params(struct snd_opl3 * opl3, struct snd_dm_fm_params * params) +static int snd_opl3_set_params(opl3_t * opl3, snd_dm_fm_params_t * params) { unsigned char reg_val; @@ -418,7 +418,7 @@ static int snd_opl3_set_params(struct snd_opl3 * opl3, struct snd_dm_fm_params * return 0; } -static int snd_opl3_set_mode(struct snd_opl3 * opl3, int mode) +static int snd_opl3_set_mode(opl3_t * opl3, int mode) { if ((mode == SNDRV_DM_FM_MODE_OPL3) && (opl3->hardware < OPL3_HW_OPL3)) return -EINVAL; @@ -430,7 +430,7 @@ static int snd_opl3_set_mode(struct snd_opl3 * opl3, int mode) return 0; } -static int snd_opl3_set_connection(struct snd_opl3 * opl3, int connection) +static int snd_opl3_set_connection(opl3_t * opl3, int connection) { unsigned char reg_val; diff --git a/trunk/sound/drivers/opl3/opl3_voice.h b/trunk/sound/drivers/opl3/opl3_voice.h index a371c075ac87..63346a5c3498 100644 --- a/trunk/sound/drivers/opl3/opl3_voice.h +++ b/trunk/sound/drivers/opl3/opl3_voice.h @@ -22,31 +22,31 @@ #include <sound/opl3.h> /* Prototypes for opl3_seq.c */ -int snd_opl3_synth_use_inc(struct snd_opl3 * opl3); -void snd_opl3_synth_use_dec(struct snd_opl3 * opl3); -int snd_opl3_synth_setup(struct snd_opl3 * opl3); -void snd_opl3_synth_cleanup(struct snd_opl3 * opl3); +int snd_opl3_synth_use_inc(opl3_t * opl3); +void snd_opl3_synth_use_dec(opl3_t * opl3); +int snd_opl3_synth_setup(opl3_t * opl3); +void snd_opl3_synth_cleanup(opl3_t * opl3); /* Prototypes for opl3_midi.c */ void snd_opl3_note_on(void *p, int note, int vel, struct snd_midi_channel *chan); void snd_opl3_note_off(void *p, int note, int vel, struct snd_midi_channel *chan); void snd_opl3_key_press(void *p, int note, int vel, struct snd_midi_channel *chan); -void snd_opl3_terminate_note(void *p, int note, struct snd_midi_channel *chan); +void snd_opl3_terminate_note(void *p, int note, snd_midi_channel_t *chan); void snd_opl3_control(void *p, int type, struct snd_midi_channel *chan); -void snd_opl3_nrpn(void *p, struct snd_midi_channel *chan, struct snd_midi_channel_set *chset); -void snd_opl3_sysex(void *p, unsigned char *buf, int len, int parsed, struct snd_midi_channel_set *chset); +void snd_opl3_nrpn(void *p, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset); +void snd_opl3_sysex(void *p, unsigned char *buf, int len, int parsed, snd_midi_channel_set_t *chset); -void snd_opl3_calc_volume(unsigned char *reg, int vel, struct snd_midi_channel *chan); +void snd_opl3_calc_volume(unsigned char *reg, int vel, snd_midi_channel_t *chan); void snd_opl3_timer_func(unsigned long data); /* Prototypes for opl3_drums.c */ -void snd_opl3_load_drums(struct snd_opl3 *opl3); -void snd_opl3_drum_switch(struct snd_opl3 *opl3, int note, int on_off, int vel, struct snd_midi_channel *chan); +void snd_opl3_load_drums(opl3_t *opl3); +void snd_opl3_drum_switch(opl3_t *opl3, int note, int on_off, int vel, snd_midi_channel_t *chan); /* Prototypes for opl3_oss.c */ #ifdef CONFIG_SND_SEQUENCER_OSS -void snd_opl3_init_seq_oss(struct snd_opl3 *opl3, char *name); -void snd_opl3_free_seq_oss(struct snd_opl3 *opl3); +void snd_opl3_init_seq_oss(opl3_t *opl3, char *name); +void snd_opl3_free_seq_oss(opl3_t *opl3); #endif #endif diff --git a/trunk/sound/drivers/opl4/opl4_lib.c b/trunk/sound/drivers/opl4/opl4_lib.c index ddfc10d04be2..4ae5dd8f011e 100644 --- a/trunk/sound/drivers/opl4/opl4_lib.c +++ b/trunk/sound/drivers/opl4/opl4_lib.c @@ -27,14 +27,14 @@ MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); MODULE_DESCRIPTION("OPL4 driver"); MODULE_LICENSE("GPL"); -static void inline snd_opl4_wait(struct snd_opl4 *opl4) +static void inline snd_opl4_wait(opl4_t *opl4) { int timeout = 10; while ((inb(opl4->fm_port) & OPL4_STATUS_BUSY) && --timeout > 0) ; } -void snd_opl4_write(struct snd_opl4 *opl4, u8 reg, u8 value) +void snd_opl4_write(opl4_t *opl4, u8 reg, u8 value) { snd_opl4_wait(opl4); outb(reg, opl4->pcm_port); @@ -43,7 +43,7 @@ void snd_opl4_write(struct snd_opl4 *opl4, u8 reg, u8 value) outb(value, opl4->pcm_port + 1); } -u8 snd_opl4_read(struct snd_opl4 *opl4, u8 reg) +u8 snd_opl4_read(opl4_t *opl4, u8 reg) { snd_opl4_wait(opl4); outb(reg, opl4->pcm_port); @@ -52,7 +52,7 @@ u8 snd_opl4_read(struct snd_opl4 *opl4, u8 reg) return inb(opl4->pcm_port + 1); } -void snd_opl4_read_memory(struct snd_opl4 *opl4, char *buf, int offset, int size) +void snd_opl4_read_memory(opl4_t *opl4, char *buf, int offset, int size) { unsigned long flags; u8 memcfg; @@ -76,7 +76,7 @@ void snd_opl4_read_memory(struct snd_opl4 *opl4, char *buf, int offset, int size spin_unlock_irqrestore(&opl4->reg_lock, flags); } -void snd_opl4_write_memory(struct snd_opl4 *opl4, const char *buf, int offset, int size) +void snd_opl4_write_memory(opl4_t *opl4, const char *buf, int offset, int size) { unsigned long flags; u8 memcfg; @@ -100,7 +100,7 @@ void snd_opl4_write_memory(struct snd_opl4 *opl4, const char *buf, int offset, i spin_unlock_irqrestore(&opl4->reg_lock, flags); } -static void snd_opl4_enable_opl4(struct snd_opl4 *opl4) +static void snd_opl4_enable_opl4(opl4_t *opl4) { outb(OPL3_REG_MODE, opl4->fm_port + 2); inb(opl4->fm_port); @@ -110,7 +110,7 @@ static void snd_opl4_enable_opl4(struct snd_opl4 *opl4) inb(opl4->fm_port); } -static int snd_opl4_detect(struct snd_opl4 *opl4) +static int snd_opl4_detect(opl4_t *opl4) { u8 id1, id2; @@ -144,19 +144,19 @@ static int snd_opl4_detect(struct snd_opl4 *opl4) } #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) -static void snd_opl4_seq_dev_free(struct snd_seq_device *seq_dev) +static void snd_opl4_seq_dev_free(snd_seq_device_t *seq_dev) { - struct snd_opl4 *opl4 = seq_dev->private_data; + opl4_t *opl4 = seq_dev->private_data; opl4->seq_dev = NULL; } -static int snd_opl4_create_seq_dev(struct snd_opl4 *opl4, int seq_device) +static int snd_opl4_create_seq_dev(opl4_t *opl4, int seq_device) { opl4->seq_dev_num = seq_device; if (snd_seq_device_new(opl4->card, seq_device, SNDRV_SEQ_DEV_ID_OPL4, - sizeof(struct snd_opl4 *), &opl4->seq_dev) >= 0) { + sizeof(opl4_t *), &opl4->seq_dev) >= 0) { strcpy(opl4->seq_dev->name, "OPL4 Wavetable"); - *(struct snd_opl4 **)SNDRV_SEQ_DEVICE_ARGPTR(opl4->seq_dev) = opl4; + *(opl4_t **)SNDRV_SEQ_DEVICE_ARGPTR(opl4->seq_dev) = opl4; opl4->seq_dev->private_data = opl4; opl4->seq_dev->private_free = snd_opl4_seq_dev_free; } @@ -164,7 +164,7 @@ static int snd_opl4_create_seq_dev(struct snd_opl4 *opl4, int seq_device) } #endif -static void snd_opl4_free(struct snd_opl4 *opl4) +static void snd_opl4_free(opl4_t *opl4) { #ifdef CONFIG_PROC_FS snd_opl4_free_proc(opl4); @@ -174,22 +174,22 @@ static void snd_opl4_free(struct snd_opl4 *opl4) kfree(opl4); } -static int snd_opl4_dev_free(struct snd_device *device) +static int snd_opl4_dev_free(snd_device_t *device) { - struct snd_opl4 *opl4 = device->device_data; + opl4_t *opl4 = device->device_data; snd_opl4_free(opl4); return 0; } -int snd_opl4_create(struct snd_card *card, +int snd_opl4_create(snd_card_t *card, unsigned long fm_port, unsigned long pcm_port, int seq_device, - struct snd_opl3 **ropl3, struct snd_opl4 **ropl4) + opl3_t **ropl3, opl4_t **ropl4) { - struct snd_opl4 *opl4; - struct snd_opl3 *opl3; + opl4_t *opl4; + opl3_t *opl3; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_opl4_dev_free }; diff --git a/trunk/sound/drivers/opl4/opl4_local.h b/trunk/sound/drivers/opl4/opl4_local.h index 7e088a4a2f4c..c455680843f6 100644 --- a/trunk/sound/drivers/opl4/opl4_local.h +++ b/trunk/sound/drivers/opl4/opl4_local.h @@ -131,7 +131,7 @@ #define SNDRV_SEQ_DEV_ID_OPL4 "opl4-synth" -struct opl4_sound { +typedef struct opl4_sound { u16 tone; s16 pitch_offset; u8 key_scaling; @@ -144,42 +144,42 @@ struct opl4_sound { u8 reg_level_decay2; u8 reg_release_correction; u8 reg_tremolo; -}; +} opl4_sound_t; -struct opl4_region { +typedef struct opl4_region { u8 key_min, key_max; - struct opl4_sound sound; -}; + opl4_sound_t sound; +} opl4_region_t; -struct opl4_region_ptr { +typedef struct opl4_region_ptr { int count; - const struct opl4_region *regions; -}; + const opl4_region_t *regions; +} opl4_region_ptr_t; -struct opl4_voice { +typedef struct opl4_voice { struct list_head list; int number; - struct snd_midi_channel *chan; + snd_midi_channel_t *chan; int note; int velocity; - const struct opl4_sound *sound; + const opl4_sound_t *sound; u8 level_direct; u8 reg_f_number; u8 reg_misc; u8 reg_lfo_vibrato; -}; +} opl4_voice_t; -struct snd_opl4 { +struct opl4 { unsigned long fm_port; unsigned long pcm_port; struct resource *res_fm_port; struct resource *res_pcm_port; unsigned short hardware; spinlock_t reg_lock; - struct snd_card *card; + snd_card_t *card; #ifdef CONFIG_PROC_FS - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; int memory_access; #endif struct semaphore access_mutex; @@ -189,44 +189,44 @@ struct snd_opl4 { int seq_dev_num; int seq_client; - struct snd_seq_device *seq_dev; + snd_seq_device_t *seq_dev; - struct snd_midi_channel_set *chset; - struct opl4_voice voices[OPL4_MAX_VOICES]; + snd_midi_channel_set_t *chset; + opl4_voice_t voices[OPL4_MAX_VOICES]; struct list_head off_voices; struct list_head on_voices; #endif }; /* opl4_lib.c */ -void snd_opl4_write(struct snd_opl4 *opl4, u8 reg, u8 value); -u8 snd_opl4_read(struct snd_opl4 *opl4, u8 reg); -void snd_opl4_read_memory(struct snd_opl4 *opl4, char *buf, int offset, int size); -void snd_opl4_write_memory(struct snd_opl4 *opl4, const char *buf, int offset, int size); +void snd_opl4_write(opl4_t *opl4, u8 reg, u8 value); +u8 snd_opl4_read(opl4_t *opl4, u8 reg); +void snd_opl4_read_memory(opl4_t *opl4, char *buf, int offset, int size); +void snd_opl4_write_memory(opl4_t *opl4, const char *buf, int offset, int size); /* opl4_mixer.c */ -int snd_opl4_create_mixer(struct snd_opl4 *opl4); +int snd_opl4_create_mixer(opl4_t *opl4); #ifdef CONFIG_PROC_FS /* opl4_proc.c */ -int snd_opl4_create_proc(struct snd_opl4 *opl4); -void snd_opl4_free_proc(struct snd_opl4 *opl4); +int snd_opl4_create_proc(opl4_t *opl4); +void snd_opl4_free_proc(opl4_t *opl4); #endif /* opl4_seq.c */ extern int volume_boost; /* opl4_synth.c */ -void snd_opl4_synth_reset(struct snd_opl4 *opl4); -void snd_opl4_synth_shutdown(struct snd_opl4 *opl4); -void snd_opl4_note_on(void *p, int note, int vel, struct snd_midi_channel *chan); -void snd_opl4_note_off(void *p, int note, int vel, struct snd_midi_channel *chan); -void snd_opl4_terminate_note(void *p, int note, struct snd_midi_channel *chan); -void snd_opl4_control(void *p, int type, struct snd_midi_channel *chan); -void snd_opl4_sysex(void *p, unsigned char *buf, int len, int parsed, struct snd_midi_channel_set *chset); +void snd_opl4_synth_reset(opl4_t *opl4); +void snd_opl4_synth_shutdown(opl4_t *opl4); +void snd_opl4_note_on(void *p, int note, int vel, snd_midi_channel_t *chan); +void snd_opl4_note_off(void *p, int note, int vel, snd_midi_channel_t *chan); +void snd_opl4_terminate_note(void *p, int note, snd_midi_channel_t *chan); +void snd_opl4_control(void *p, int type, snd_midi_channel_t *chan); +void snd_opl4_sysex(void *p, unsigned char *buf, int len, int parsed, snd_midi_channel_set_t *chset); /* yrw801.c */ -int snd_yrw801_detect(struct snd_opl4 *opl4); -extern const struct opl4_region_ptr snd_yrw801_regions[]; +int snd_yrw801_detect(opl4_t *opl4); +extern const opl4_region_ptr_t snd_yrw801_regions[]; #endif /* __OPL4_LOCAL_H */ diff --git a/trunk/sound/drivers/opl4/opl4_mixer.c b/trunk/sound/drivers/opl4/opl4_mixer.c index 04079de4c35f..ec7a228fbe7e 100644 --- a/trunk/sound/drivers/opl4/opl4_mixer.c +++ b/trunk/sound/drivers/opl4/opl4_mixer.c @@ -20,7 +20,7 @@ #include "opl4_local.h" #include <sound/control.h> -static int snd_opl4_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_opl4_ctl_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -29,9 +29,9 @@ static int snd_opl4_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int snd_opl4_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opl4_ctl_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_opl4 *opl4 = snd_kcontrol_chip(kcontrol); + opl4_t *opl4 = snd_kcontrol_chip(kcontrol); unsigned long flags; u8 reg = kcontrol->private_value; u8 value; @@ -44,9 +44,9 @@ static int snd_opl4_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return 0; } -static int snd_opl4_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opl4_ctl_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_opl4 *opl4 = snd_kcontrol_chip(kcontrol); + opl4_t *opl4 = snd_kcontrol_chip(kcontrol); unsigned long flags; u8 reg = kcontrol->private_value; u8 value, old_value; @@ -60,7 +60,7 @@ static int snd_opl4_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return value != old_value; } -static struct snd_kcontrol_new snd_opl4_controls[] = { +static snd_kcontrol_new_t snd_opl4_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "FM Playback Volume", @@ -79,9 +79,9 @@ static struct snd_kcontrol_new snd_opl4_controls[] = { } }; -int snd_opl4_create_mixer(struct snd_opl4 *opl4) +int snd_opl4_create_mixer(opl4_t *opl4) { - struct snd_card *card = opl4->card; + snd_card_t *card = opl4->card; int i, err; strcat(card->mixername, ",OPL4"); diff --git a/trunk/sound/drivers/opl4/opl4_proc.c b/trunk/sound/drivers/opl4/opl4_proc.c index f4b4e74fcc18..6a1486258acf 100644 --- a/trunk/sound/drivers/opl4/opl4_proc.c +++ b/trunk/sound/drivers/opl4/opl4_proc.c @@ -23,10 +23,10 @@ #ifdef CONFIG_PROC_FS -static int snd_opl4_mem_proc_open(struct snd_info_entry *entry, +static int snd_opl4_mem_proc_open(snd_info_entry_t *entry, unsigned short mode, void **file_private_data) { - struct snd_opl4 *opl4 = entry->private_data; + opl4_t *opl4 = entry->private_data; down(&opl4->access_mutex); if (opl4->memory_access) { @@ -38,10 +38,10 @@ static int snd_opl4_mem_proc_open(struct snd_info_entry *entry, return 0; } -static int snd_opl4_mem_proc_release(struct snd_info_entry *entry, +static int snd_opl4_mem_proc_release(snd_info_entry_t *entry, unsigned short mode, void *file_private_data) { - struct snd_opl4 *opl4 = entry->private_data; + opl4_t *opl4 = entry->private_data; down(&opl4->access_mutex); opl4->memory_access--; @@ -49,11 +49,11 @@ static int snd_opl4_mem_proc_release(struct snd_info_entry *entry, return 0; } -static long snd_opl4_mem_proc_read(struct snd_info_entry *entry, void *file_private_data, +static long snd_opl4_mem_proc_read(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *_buf, unsigned long count, unsigned long pos) { - struct snd_opl4 *opl4 = entry->private_data; + opl4_t *opl4 = entry->private_data; long size; char* buf; @@ -75,11 +75,11 @@ static long snd_opl4_mem_proc_read(struct snd_info_entry *entry, void *file_priv return 0; } -static long snd_opl4_mem_proc_write(struct snd_info_entry *entry, void *file_private_data, +static long snd_opl4_mem_proc_write(snd_info_entry_t *entry, void *file_private_data, struct file *file, const char __user *_buf, unsigned long count, unsigned long pos) { - struct snd_opl4 *opl4 = entry->private_data; + opl4_t *opl4 = entry->private_data; long size; char *buf; @@ -101,7 +101,7 @@ static long snd_opl4_mem_proc_write(struct snd_info_entry *entry, void *file_pri return 0; } -static long long snd_opl4_mem_proc_llseek(struct snd_info_entry *entry, void *file_private_data, +static long long snd_opl4_mem_proc_llseek(snd_info_entry_t *entry, void *file_private_data, struct file *file, long long offset, int orig) { switch (orig) { @@ -130,9 +130,9 @@ static struct snd_info_entry_ops snd_opl4_mem_proc_ops = { .llseek = snd_opl4_mem_proc_llseek, }; -int snd_opl4_create_proc(struct snd_opl4 *opl4) +int snd_opl4_create_proc(opl4_t *opl4) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; entry = snd_info_create_card_entry(opl4->card, "opl4-mem", opl4->card->proc_root); if (entry) { @@ -157,7 +157,7 @@ int snd_opl4_create_proc(struct snd_opl4 *opl4) return 0; } -void snd_opl4_free_proc(struct snd_opl4 *opl4) +void snd_opl4_free_proc(opl4_t *opl4) { if (opl4->proc_entry) snd_info_unregister(opl4->proc_entry); diff --git a/trunk/sound/drivers/opl4/opl4_seq.c b/trunk/sound/drivers/opl4/opl4_seq.c index e3480326e735..958dfe88479a 100644 --- a/trunk/sound/drivers/opl4/opl4_seq.c +++ b/trunk/sound/drivers/opl4/opl4_seq.c @@ -45,21 +45,21 @@ int volume_boost = 8; module_param(volume_boost, int, 0644); MODULE_PARM_DESC(volume_boost, "Additional volume for OPL4 wavetable sounds."); -static int snd_opl4_seq_use_inc(struct snd_opl4 *opl4) +static int snd_opl4_seq_use_inc(opl4_t *opl4) { if (!try_module_get(opl4->card->module)) return -EFAULT; return 0; } -static void snd_opl4_seq_use_dec(struct snd_opl4 *opl4) +static void snd_opl4_seq_use_dec(opl4_t *opl4) { module_put(opl4->card->module); } -static int snd_opl4_seq_use(void *private_data, struct snd_seq_port_subscribe *info) +static int snd_opl4_seq_use(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; int err; down(&opl4->access_mutex); @@ -84,9 +84,9 @@ static int snd_opl4_seq_use(void *private_data, struct snd_seq_port_subscribe *i return 0; } -static int snd_opl4_seq_unuse(void *private_data, struct snd_seq_port_subscribe *info) +static int snd_opl4_seq_unuse(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; snd_opl4_synth_shutdown(opl4); @@ -99,7 +99,7 @@ static int snd_opl4_seq_unuse(void *private_data, struct snd_seq_port_subscribe return 0; } -static struct snd_midi_op opl4_ops = { +static snd_midi_op_t opl4_ops = { .note_on = snd_opl4_note_on, .note_off = snd_opl4_note_off, .note_terminate = snd_opl4_terminate_note, @@ -107,10 +107,10 @@ static struct snd_midi_op opl4_ops = { .sysex = snd_opl4_sysex, }; -static int snd_opl4_seq_event_input(struct snd_seq_event *ev, int direct, +static int snd_opl4_seq_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; snd_midi_process_event(&opl4_ops, ev, opl4->chset); return 0; @@ -118,18 +118,20 @@ static int snd_opl4_seq_event_input(struct snd_seq_event *ev, int direct, static void snd_opl4_seq_free_port(void *private_data) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; snd_midi_channel_free_set(opl4->chset); } -static int snd_opl4_seq_new_device(struct snd_seq_device *dev) +static int snd_opl4_seq_new_device(snd_seq_device_t *dev) { - struct snd_opl4 *opl4; + opl4_t *opl4; int client; - struct snd_seq_port_callback pcallbacks; + snd_seq_client_callback_t callbacks; + snd_seq_client_info_t cinfo; + snd_seq_port_callback_t pcallbacks; - opl4 = *(struct snd_opl4 **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + opl4 = *(opl4_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (!opl4) return -EINVAL; @@ -142,8 +144,10 @@ static int snd_opl4_seq_new_device(struct snd_seq_device *dev) opl4->chset->private_data = opl4; /* allocate new client */ - client = snd_seq_create_kernel_client(opl4->card, opl4->seq_dev_num, - "OPL4 Wavetable"); + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.private_data = opl4; + callbacks.allow_output = callbacks.allow_input = 1; + client = snd_seq_create_kernel_client(opl4->card, opl4->seq_dev_num, &callbacks); if (client < 0) { snd_midi_channel_free_set(opl4->chset); return client; @@ -151,6 +155,13 @@ static int snd_opl4_seq_new_device(struct snd_seq_device *dev) opl4->seq_client = client; opl4->chset->client = client; + /* change name of client */ + memset(&cinfo, 0, sizeof(cinfo)); + cinfo.client = client; + cinfo.type = KERNEL_CLIENT; + strcpy(cinfo.name, "OPL4 Wavetable"); + snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); + /* create new port */ memset(&pcallbacks, 0, sizeof(pcallbacks)); pcallbacks.owner = THIS_MODULE; @@ -177,11 +188,11 @@ static int snd_opl4_seq_new_device(struct snd_seq_device *dev) return 0; } -static int snd_opl4_seq_delete_device(struct snd_seq_device *dev) +static int snd_opl4_seq_delete_device(snd_seq_device_t *dev) { - struct snd_opl4 *opl4; + opl4_t *opl4; - opl4 = *(struct snd_opl4 **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + opl4 = *(opl4_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (!opl4) return -EINVAL; @@ -194,13 +205,13 @@ static int snd_opl4_seq_delete_device(struct snd_seq_device *dev) static int __init alsa_opl4_synth_init(void) { - static struct snd_seq_dev_ops ops = { + static snd_seq_dev_ops_t ops = { snd_opl4_seq_new_device, snd_opl4_seq_delete_device }; return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OPL4, &ops, - sizeof(struct snd_opl4 *)); + sizeof(opl4_t*)); } static void __exit alsa_opl4_synth_exit(void) diff --git a/trunk/sound/drivers/opl4/opl4_synth.c b/trunk/sound/drivers/opl4/opl4_synth.c index 74f6e53eae0d..b146a1c995d9 100644 --- a/trunk/sound/drivers/opl4/opl4_synth.c +++ b/trunk/sound/drivers/opl4/opl4_synth.c @@ -270,7 +270,7 @@ static unsigned char snd_opl4_volume_table[128] = { /* * Initializes all voices. */ -void snd_opl4_synth_reset(struct snd_opl4 *opl4) +void snd_opl4_synth_reset(opl4_t *opl4) { unsigned long flags; int i; @@ -294,7 +294,7 @@ void snd_opl4_synth_reset(struct snd_opl4 *opl4) /* * Shuts down all voices. */ -void snd_opl4_synth_shutdown(struct snd_opl4 *opl4) +void snd_opl4_synth_shutdown(opl4_t *opl4) { unsigned long flags; int i; @@ -309,12 +309,12 @@ void snd_opl4_synth_shutdown(struct snd_opl4 *opl4) /* * Executes the callback for all voices playing the specified note. */ -static void snd_opl4_do_for_note(struct snd_opl4 *opl4, int note, struct snd_midi_channel *chan, - void (*func)(struct snd_opl4 *opl4, struct opl4_voice *voice)) +static void snd_opl4_do_for_note(opl4_t *opl4, int note, snd_midi_channel_t *chan, + void (*func)(opl4_t *opl4, opl4_voice_t *voice)) { int i; unsigned long flags; - struct opl4_voice *voice; + opl4_voice_t *voice; spin_lock_irqsave(&opl4->reg_lock, flags); for (i = 0; i < OPL4_MAX_VOICES; i++) { @@ -329,13 +329,12 @@ static void snd_opl4_do_for_note(struct snd_opl4 *opl4, int note, struct snd_mid /* * Executes the callback for all voices of to the specified channel. */ -static void snd_opl4_do_for_channel(struct snd_opl4 *opl4, - struct snd_midi_channel *chan, - void (*func)(struct snd_opl4 *opl4, struct opl4_voice *voice)) +static void snd_opl4_do_for_channel(opl4_t *opl4, snd_midi_channel_t *chan, + void (*func)(opl4_t *opl4, opl4_voice_t *voice)) { int i; unsigned long flags; - struct opl4_voice *voice; + opl4_voice_t *voice; spin_lock_irqsave(&opl4->reg_lock, flags); for (i = 0; i < OPL4_MAX_VOICES; i++) { @@ -350,12 +349,12 @@ static void snd_opl4_do_for_channel(struct snd_opl4 *opl4, /* * Executes the callback for all active voices. */ -static void snd_opl4_do_for_all(struct snd_opl4 *opl4, - void (*func)(struct snd_opl4 *opl4, struct opl4_voice *voice)) +static void snd_opl4_do_for_all(opl4_t *opl4, + void (*func)(opl4_t *opl4, opl4_voice_t *voice)) { int i; unsigned long flags; - struct opl4_voice *voice; + opl4_voice_t *voice; spin_lock_irqsave(&opl4->reg_lock, flags); for (i = 0; i < OPL4_MAX_VOICES; i++) { @@ -366,7 +365,7 @@ static void snd_opl4_do_for_all(struct snd_opl4 *opl4, spin_unlock_irqrestore(&opl4->reg_lock, flags); } -static void snd_opl4_update_volume(struct snd_opl4 *opl4, struct opl4_voice *voice) +static void snd_opl4_update_volume(opl4_t *opl4, opl4_voice_t *voice) { int att; @@ -385,7 +384,7 @@ static void snd_opl4_update_volume(struct snd_opl4 *opl4, struct opl4_voice *voi voice->level_direct = 0; } -static void snd_opl4_update_pan(struct snd_opl4 *opl4, struct opl4_voice *voice) +static void snd_opl4_update_pan(opl4_t *opl4, opl4_voice_t *voice) { int pan = voice->sound->panpot; @@ -400,8 +399,7 @@ static void snd_opl4_update_pan(struct snd_opl4 *opl4, struct opl4_voice *voice) snd_opl4_write(opl4, OPL4_REG_MISC + voice->number, voice->reg_misc); } -static void snd_opl4_update_vibrato_depth(struct snd_opl4 *opl4, - struct opl4_voice *voice) +static void snd_opl4_update_vibrato_depth(opl4_t *opl4, opl4_voice_t *voice) { int depth; @@ -416,10 +414,9 @@ static void snd_opl4_update_vibrato_depth(struct snd_opl4 *opl4, voice->reg_lfo_vibrato); } -static void snd_opl4_update_pitch(struct snd_opl4 *opl4, - struct opl4_voice *voice) +static void snd_opl4_update_pitch(opl4_t *opl4, opl4_voice_t *voice) { - struct snd_midi_channel *chan = voice->chan; + snd_midi_channel_t *chan = voice->chan; int note, pitch, octave; note = chan->drum_channel ? 60 : voice->note; @@ -447,8 +444,7 @@ static void snd_opl4_update_pitch(struct snd_opl4 *opl4, snd_opl4_write(opl4, OPL4_REG_F_NUMBER + voice->number, voice->reg_f_number); } -static void snd_opl4_update_tone_parameters(struct snd_opl4 *opl4, - struct opl4_voice *voice) +static void snd_opl4_update_tone_parameters(opl4_t *opl4, opl4_voice_t *voice) { snd_opl4_write(opl4, OPL4_REG_ATTACK_DECAY1 + voice->number, voice->sound->reg_attack_decay1); @@ -461,17 +457,17 @@ static void snd_opl4_update_tone_parameters(struct snd_opl4 *opl4, } /* allocate one voice */ -static struct opl4_voice *snd_opl4_get_voice(struct snd_opl4 *opl4) +static opl4_voice_t *snd_opl4_get_voice(opl4_t *opl4) { /* first, try to get the oldest key-off voice */ if (!list_empty(&opl4->off_voices)) - return list_entry(opl4->off_voices.next, struct opl4_voice, list); + return list_entry(opl4->off_voices.next, opl4_voice_t, list); /* then get the oldest key-on voice */ snd_assert(!list_empty(&opl4->on_voices), ); - return list_entry(opl4->on_voices.next, struct opl4_voice, list); + return list_entry(opl4->on_voices.next, opl4_voice_t, list); } -static void snd_opl4_wait_for_wave_headers(struct snd_opl4 *opl4) +static void snd_opl4_wait_for_wave_headers(opl4_t *opl4) { int timeout = 200; @@ -479,12 +475,12 @@ static void snd_opl4_wait_for_wave_headers(struct snd_opl4 *opl4) udelay(10); } -void snd_opl4_note_on(void *private_data, int note, int vel, struct snd_midi_channel *chan) +void snd_opl4_note_on(void *private_data, int note, int vel, snd_midi_channel_t *chan) { - struct snd_opl4 *opl4 = private_data; - const struct opl4_region_ptr *regions; - struct opl4_voice *voice[2]; - const struct opl4_sound *sound[2]; + opl4_t *opl4 = private_data; + const opl4_region_ptr_t *regions; + opl4_voice_t *voice[2]; + const opl4_sound_t *sound[2]; int voices = 0, i; unsigned long flags; @@ -553,7 +549,7 @@ void snd_opl4_note_on(void *private_data, int note, int vel, struct snd_midi_cha spin_unlock_irqrestore(&opl4->reg_lock, flags); } -static void snd_opl4_voice_off(struct snd_opl4 *opl4, struct opl4_voice *voice) +static void snd_opl4_voice_off(opl4_t *opl4, opl4_voice_t *voice) { list_del(&voice->list); list_add_tail(&voice->list, &opl4->off_voices); @@ -562,14 +558,14 @@ static void snd_opl4_voice_off(struct snd_opl4 *opl4, struct opl4_voice *voice) snd_opl4_write(opl4, OPL4_REG_MISC + voice->number, voice->reg_misc); } -void snd_opl4_note_off(void *private_data, int note, int vel, struct snd_midi_channel *chan) +void snd_opl4_note_off(void *private_data, int note, int vel, snd_midi_channel_t *chan) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; snd_opl4_do_for_note(opl4, note, chan, snd_opl4_voice_off); } -static void snd_opl4_terminate_voice(struct snd_opl4 *opl4, struct opl4_voice *voice) +static void snd_opl4_terminate_voice(opl4_t *opl4, opl4_voice_t *voice) { list_del(&voice->list); list_add_tail(&voice->list, &opl4->off_voices); @@ -578,16 +574,16 @@ static void snd_opl4_terminate_voice(struct snd_opl4 *opl4, struct opl4_voice *v snd_opl4_write(opl4, OPL4_REG_MISC + voice->number, voice->reg_misc); } -void snd_opl4_terminate_note(void *private_data, int note, struct snd_midi_channel *chan) +void snd_opl4_terminate_note(void *private_data, int note, snd_midi_channel_t *chan) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; snd_opl4_do_for_note(opl4, note, chan, snd_opl4_terminate_voice); } -void snd_opl4_control(void *private_data, int type, struct snd_midi_channel *chan) +void snd_opl4_control(void *private_data, int type, snd_midi_channel_t *chan) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; switch (type) { case MIDI_CTL_MSB_MODWHEEL: @@ -625,9 +621,9 @@ void snd_opl4_control(void *private_data, int type, struct snd_midi_channel *cha } void snd_opl4_sysex(void *private_data, unsigned char *buf, int len, - int parsed, struct snd_midi_channel_set *chset) + int parsed, snd_midi_channel_set_t *chset) { - struct snd_opl4 *opl4 = private_data; + opl4_t *opl4 = private_data; if (parsed == SNDRV_MIDI_SYSEX_GS_MASTER_VOLUME) snd_opl4_do_for_all(opl4, snd_opl4_update_volume); diff --git a/trunk/sound/drivers/opl4/yrw801.c b/trunk/sound/drivers/opl4/yrw801.c index 6c335492d082..a51174dd3e56 100644 --- a/trunk/sound/drivers/opl4/yrw801.c +++ b/trunk/sound/drivers/opl4/yrw801.c @@ -33,7 +33,7 @@ #include "opl4_local.h" -int snd_yrw801_detect(struct snd_opl4 *opl4) +int snd_yrw801_detect(opl4_t *opl4) { char buf[15]; @@ -54,7 +54,7 @@ int snd_yrw801_detect(struct snd_opl4 *opl4) * by this driver. */ -static const struct opl4_region regions_00[] = { /* Acoustic Grand Piano */ +static const opl4_region_t regions_00[] = { /* Acoustic Grand Piano */ {0x14, 0x27, {0x12c,7474,100, 0,0,0x00,0xc8,0x20,0xf2,0x13,0x08,0x0}}, {0x28, 0x2d, {0x12d,6816,100, 0,0,0x00,0xc8,0x20,0xf2,0x14,0x08,0x0}}, {0x2e, 0x33, {0x12e,5899,100, 0,0,0x00,0xc8,0x20,0xf2,0x14,0x08,0x0}}, @@ -66,7 +66,7 @@ static const struct opl4_region regions_00[] = { /* Acoustic Grand Piano */ {0x53, 0x58, {0x134,1444,100, 0,0,0x07,0xc8,0x20,0xf3,0x14,0x18,0x0}}, {0x59, 0x6d, {0x135,1915,100, 0,0,0x00,0xc8,0x20,0xf4,0x15,0x08,0x0}} }; -static const struct opl4_region regions_01[] = { /* Bright Acoustic Piano */ +static const opl4_region_t regions_01[] = { /* Bright Acoustic Piano */ {0x14, 0x2d, {0x12c,7474,100, 0,0,0x00,0xc8,0x20,0xf2,0x13,0x08,0x0}}, {0x2e, 0x33, {0x12d,6816,100, 0,0,0x00,0xc8,0x20,0xf2,0x14,0x08,0x0}}, {0x34, 0x39, {0x12e,5899,100, 0,0,0x00,0xc8,0x20,0xf2,0x14,0x08,0x0}}, @@ -78,7 +78,7 @@ static const struct opl4_region regions_01[] = { /* Bright Acoustic Piano */ {0x59, 0x5e, {0x134,1444,100, 0,0,0x0a,0xc8,0x20,0xf3,0x14,0x18,0x0}}, {0x5f, 0x6d, {0x135,1915,100, 0,0,0x00,0xc8,0x20,0xf4,0x15,0x08,0x0}} }; -static const struct opl4_region regions_02[] = { /* Electric Grand Piano */ +static const opl4_region_t regions_02[] = { /* Electric Grand Piano */ {0x14, 0x2d, {0x12c,7476,100, 1,0,0x00,0xae,0x20,0xf2,0x13,0x07,0x0}}, {0x2e, 0x33, {0x12d,6818,100, 1,0,0x00,0xae,0x20,0xf2,0x14,0x07,0x0}}, {0x34, 0x39, {0x12e,5901,100, 1,0,0x00,0xae,0x20,0xf2,0x14,0x07,0x0}}, @@ -91,7 +91,7 @@ static const struct opl4_region regions_02[] = { /* Electric Grand Piano */ {0x5f, 0x6d, {0x135,1917,100, 1,0,0x00,0xae,0x20,0xf4,0x15,0x07,0x0}}, {0x00, 0x7f, {0x06c,6375,100,-1,0,0x00,0xc2,0x28,0xf4,0x23,0x18,0x0}} }; -static const struct opl4_region regions_03[] = { /* Honky-Tonk Piano */ +static const opl4_region_t regions_03[] = { /* Honky-Tonk Piano */ {0x14, 0x27, {0x12c,7474,100, 0,0,0x00,0xb4,0x20,0xf2,0x13,0x08,0x0}}, {0x28, 0x2d, {0x12d,6816,100, 0,0,0x00,0xb4,0x20,0xf2,0x14,0x08,0x0}}, {0x2e, 0x33, {0x12e,5899,100, 0,0,0x00,0xb4,0x20,0xf2,0x14,0x08,0x0}}, @@ -113,11 +113,11 @@ static const struct opl4_region regions_03[] = { /* Honky-Tonk Piano */ {0x53, 0x58, {0x134,1457,100, 0,0,0x01,0xb4,0x20,0xf3,0x14,0x18,0x0}}, {0x59, 0x6d, {0x135,1903,100, 0,0,0x00,0xb4,0x20,0xf4,0x15,0x08,0x0}} }; -static const struct opl4_region regions_04[] = { /* Electric Piano 1 */ +static const opl4_region_t regions_04[] = { /* Electric Piano 1 */ {0x15, 0x6c, {0x00b,6570,100, 0,0,0x00,0x28,0x38,0xf0,0x00,0x0c,0x0}}, {0x00, 0x7f, {0x06c,6375,100, 0,2,0x00,0xb0,0x22,0xf4,0x23,0x19,0x0}} }; -static const struct opl4_region regions_05[] = { /* Electric Piano 2 */ +static const opl4_region_t regions_05[] = { /* Electric Piano 2 */ {0x14, 0x27, {0x12c,7476,100, 0,3,0x00,0xa2,0x1b,0xf2,0x13,0x08,0x0}}, {0x28, 0x2d, {0x12d,6818,100, 0,3,0x00,0xa2,0x1b,0xf2,0x14,0x08,0x0}}, {0x2e, 0x33, {0x12e,5901,100, 0,3,0x00,0xa2,0x1b,0xf2,0x14,0x08,0x0}}, @@ -139,103 +139,103 @@ static const struct opl4_region regions_05[] = { /* Electric Piano 2 */ {0x59, 0x5e, {0x134,1442,100, 0,0,0x0a,0xa2,0x18,0xf3,0x14,0x18,0x0}}, {0x5f, 0x6d, {0x135,1913,100, 0,0,0x00,0xa2,0x18,0xf4,0x15,0x08,0x0}} }; -static const struct opl4_region regions_06[] = { /* Harpsichord */ +static const opl4_region_t regions_06[] = { /* Harpsichord */ {0x15, 0x39, {0x080,5158,100, 0,0,0x00,0xb2,0x20,0xf5,0x24,0x19,0x0}}, {0x3a, 0x3f, {0x081,4408,100, 0,0,0x00,0xb2,0x20,0xf5,0x25,0x09,0x0}}, {0x40, 0x45, {0x082,3622,100, 0,0,0x00,0xb2,0x20,0xf5,0x25,0x09,0x0}}, {0x46, 0x4d, {0x083,2843,100, 0,0,0x00,0xb2,0x20,0xf5,0x25,0x19,0x0}}, {0x4e, 0x6c, {0x084,1307,100, 0,0,0x00,0xb2,0x20,0xf5,0x25,0x29,0x0}} }; -static const struct opl4_region regions_07[] = { /* Clavinet */ +static const opl4_region_t regions_07[] = { /* Clavinet */ {0x15, 0x51, {0x027,5009,100, 0,0,0x00,0xd2,0x28,0xf5,0x13,0x2b,0x0}}, {0x52, 0x6c, {0x028,3495,100, 0,0,0x00,0xd2,0x28,0xf5,0x13,0x3b,0x0}} }; -static const struct opl4_region regions_08[] = { /* Celesta */ +static const opl4_region_t regions_08[] = { /* Celesta */ {0x15, 0x6c, {0x02b,3267,100, 0,0,0x00,0xdc,0x20,0xf4,0x15,0x07,0x3}} }; -static const struct opl4_region regions_09[] = { /* Glockenspiel */ +static const opl4_region_t regions_09[] = { /* Glockenspiel */ {0x15, 0x78, {0x0f3, 285,100, 0,0,0x00,0xc2,0x28,0xf6,0x25,0x25,0x0}} }; -static const struct opl4_region regions_0a[] = { /* Music Box */ +static const opl4_region_t regions_0a[] = { /* Music Box */ {0x15, 0x6c, {0x0f3,3362,100, 0,0,0x00,0xb6,0x20,0xa6,0x25,0x25,0x0}}, {0x15, 0x6c, {0x101,4773,100, 0,0,0x00,0xaa,0x20,0xd4,0x14,0x16,0x0}} }; -static const struct opl4_region regions_0b[] = { /* Vibraphone */ +static const opl4_region_t regions_0b[] = { /* Vibraphone */ {0x15, 0x6c, {0x101,4778,100, 0,0,0x00,0xc0,0x28,0xf4,0x14,0x16,0x4}} }; -static const struct opl4_region regions_0c[] = { /* Marimba */ +static const opl4_region_t regions_0c[] = { /* Marimba */ {0x15, 0x3f, {0x0f4,4778,100, 0,0,0x00,0xc4,0x38,0xf7,0x47,0x08,0x0}}, {0x40, 0x4c, {0x0f5,3217,100, 0,0,0x00,0xc4,0x38,0xf7,0x47,0x08,0x0}}, {0x4d, 0x5a, {0x0f5,3217,100, 0,0,0x00,0xc4,0x38,0xf7,0x48,0x08,0x0}}, {0x5b, 0x7f, {0x0f5,3218,100, 0,0,0x00,0xc4,0x38,0xf7,0x48,0x18,0x0}} }; -static const struct opl4_region regions_0d[] = { /* Xylophone */ +static const opl4_region_t regions_0d[] = { /* Xylophone */ {0x00, 0x7f, {0x136,1729,100, 0,0,0x00,0xd2,0x38,0xf0,0x06,0x36,0x0}} }; -static const struct opl4_region regions_0e[] = { /* Tubular Bell */ +static const opl4_region_t regions_0e[] = { /* Tubular Bell */ {0x01, 0x7f, {0x0ff,3999,100, 0,1,0x00,0x90,0x21,0xf4,0xa3,0x25,0x1}} }; -static const struct opl4_region regions_0f[] = { /* Dulcimer */ +static const opl4_region_t regions_0f[] = { /* Dulcimer */ {0x00, 0x7f, {0x03f,4236,100, 0,1,0x00,0xbc,0x29,0xf5,0x16,0x07,0x0}}, {0x00, 0x7f, {0x040,4236,100, 0,2,0x0e,0x94,0x2a,0xf5,0x16,0x07,0x0}} }; -static const struct opl4_region regions_10[] = { /* Drawbar Organ */ +static const opl4_region_t regions_10[] = { /* Drawbar Organ */ {0x01, 0x7f, {0x08e,4394,100, 0,2,0x14,0xc2,0x3a,0xf0,0x00,0x0a,0x0}} }; -static const struct opl4_region regions_11[] = { /* Percussive Organ */ +static const opl4_region_t regions_11[] = { /* Percussive Organ */ {0x15, 0x3b, {0x08c,6062,100, 0,3,0x00,0xbe,0x3b,0xf0,0x00,0x09,0x0}}, {0x3c, 0x6c, {0x08d,2984,100, 0,3,0x00,0xbe,0x3b,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_12[] = { /* Rock Organ */ +static const opl4_region_t regions_12[] = { /* Rock Organ */ {0x15, 0x30, {0x128,6574,100, 0,1,0x00,0xcc,0x39,0xf0,0x00,0x0a,0x0}}, {0x31, 0x3c, {0x129,5040,100, 0,1,0x00,0xcc,0x39,0xf0,0x00,0x0a,0x0}}, {0x3d, 0x48, {0x12a,3498,100, 0,1,0x00,0xcc,0x39,0xf0,0x00,0x0a,0x0}}, {0x49, 0x54, {0x12b,1957,100, 0,1,0x00,0xcc,0x39,0xf0,0x00,0x0a,0x0}}, {0x55, 0x6c, {0x127, 423,100, 0,1,0x00,0xcc,0x39,0xf0,0x00,0x0a,0x0}} }; -static const struct opl4_region regions_13[] = { /* Church Organ */ +static const opl4_region_t regions_13[] = { /* Church Organ */ {0x15, 0x29, {0x087,7466,100, 0,1,0x00,0xc4,0x11,0xf0,0x00,0x09,0x0}}, {0x2a, 0x30, {0x088,6456,100, 0,1,0x00,0xc4,0x11,0xf0,0x00,0x09,0x0}}, {0x31, 0x38, {0x089,5428,100, 0,1,0x00,0xc4,0x11,0xf0,0x00,0x09,0x0}}, {0x39, 0x41, {0x08a,4408,100, 0,1,0x00,0xc4,0x11,0xf0,0x00,0x09,0x0}}, {0x42, 0x6c, {0x08b,3406,100, 0,1,0x00,0xc4,0x11,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_14[] = { /* Reed Organ */ +static const opl4_region_t regions_14[] = { /* Reed Organ */ {0x00, 0x53, {0x0ac,5570,100, 0,0,0x06,0xc0,0x38,0xf0,0x00,0x09,0x1}}, {0x54, 0x7f, {0x0ad,2497,100, 0,0,0x00,0xc0,0x38,0xf0,0x00,0x09,0x1}} }; -static const struct opl4_region regions_15[] = { /* Accordion */ +static const opl4_region_t regions_15[] = { /* Accordion */ {0x15, 0x4c, {0x006,4261,100, 0,2,0x00,0xa4,0x22,0x90,0x00,0x09,0x0}}, {0x4d, 0x6c, {0x007,1530,100, 0,2,0x00,0xa4,0x22,0x90,0x00,0x09,0x0}}, {0x15, 0x6c, {0x070,4391,100, 0,3,0x00,0x8a,0x23,0xa0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_16[] = { /* Harmonica */ +static const opl4_region_t regions_16[] = { /* Harmonica */ {0x15, 0x6c, {0x070,4408,100, 0,0,0x00,0xae,0x30,0xa0,0x00,0x09,0x2}} }; -static const struct opl4_region regions_17[] = { /* Tango Accordion */ +static const opl4_region_t regions_17[] = { /* Tango Accordion */ {0x00, 0x53, {0x0ac,5573,100, 0,0,0x00,0xae,0x38,0xf0,0x00,0x09,0x0}}, {0x54, 0x7f, {0x0ad,2500,100, 0,0,0x00,0xae,0x38,0xf0,0x00,0x09,0x0}}, {0x15, 0x6c, {0x041,8479,100, 0,2,0x00,0x6a,0x3a,0x75,0x20,0x0a,0x0}} }; -static const struct opl4_region regions_18[] = { /* Nylon Guitar */ +static const opl4_region_t regions_18[] = { /* Nylon Guitar */ {0x15, 0x2f, {0x0b3,6964,100, 0,0,0x05,0xca,0x28,0xf5,0x34,0x09,0x0}}, {0x30, 0x36, {0x0b7,5567,100, 0,0,0x0c,0xca,0x28,0xf5,0x34,0x09,0x0}}, {0x37, 0x3c, {0x0b5,4653,100, 0,0,0x00,0xca,0x28,0xf6,0x34,0x09,0x0}}, {0x3d, 0x43, {0x0b4,3892,100, 0,0,0x00,0xca,0x28,0xf6,0x35,0x09,0x0}}, {0x44, 0x60, {0x0b6,2723,100, 0,0,0x00,0xca,0x28,0xf6,0x35,0x19,0x0}} }; -static const struct opl4_region regions_19[] = { /* Steel Guitar */ +static const opl4_region_t regions_19[] = { /* Steel Guitar */ {0x15, 0x31, {0x00c,6937,100, 0,0,0x00,0xbc,0x28,0xf0,0x04,0x19,0x0}}, {0x32, 0x38, {0x00d,5410,100, 0,0,0x00,0xbc,0x28,0xf0,0x05,0x09,0x0}}, {0x39, 0x47, {0x00e,4379,100, 0,0,0x00,0xbc,0x28,0xf5,0x94,0x09,0x0}}, {0x48, 0x6c, {0x00f,2843,100, 0,0,0x00,0xbc,0x28,0xf6,0x95,0x09,0x0}} }; -static const struct opl4_region regions_1a[] = { /* Jazz Guitar */ +static const opl4_region_t regions_1a[] = { /* Jazz Guitar */ {0x15, 0x31, {0x05a,6832,100, 0,0,0x00,0xca,0x28,0xf6,0x34,0x09,0x0}}, {0x32, 0x3f, {0x05b,4897,100, 0,0,0x00,0xca,0x28,0xf6,0x34,0x09,0x0}}, {0x40, 0x6c, {0x05c,3218,100, 0,0,0x00,0xca,0x28,0xf6,0x34,0x09,0x0}} }; -static const struct opl4_region regions_1b[] = { /* Clean Guitar */ +static const opl4_region_t regions_1b[] = { /* Clean Guitar */ {0x15, 0x2c, {0x061,7053,100, 0,1,0x00,0xb4,0x29,0xf5,0x54,0x0a,0x0}}, {0x2d, 0x31, {0x060,6434,100, 0,1,0x00,0xb4,0x29,0xf5,0x54,0x0a,0x0}}, {0x32, 0x38, {0x063,5764,100, 0,1,0x00,0xbe,0x29,0xf5,0x55,0x0a,0x0}}, @@ -245,14 +245,14 @@ static const struct opl4_region regions_1b[] = { /* Clean Guitar */ {0x4c, 0x54, {0x066,2462,100, 0,1,0x00,0xb4,0x29,0xf5,0x55,0x2a,0x0}}, {0x55, 0x6c, {0x067,1307,100, 0,1,0x00,0xb4,0x29,0xf6,0x56,0x0a,0x0}} }; -static const struct opl4_region regions_1c[] = { /* Muted Guitar */ +static const opl4_region_t regions_1c[] = { /* Muted Guitar */ {0x01, 0x7f, {0x068,4408,100, 0,0,0x00,0xcc,0x28,0xf6,0x15,0x09,0x0}} }; -static const struct opl4_region regions_1d[] = { /* Overdriven Guitar */ +static const opl4_region_t regions_1d[] = { /* Overdriven Guitar */ {0x00, 0x40, {0x0a5,6589,100, 0,1,0x00,0xc0,0x29,0xf2,0x11,0x09,0x0}}, {0x41, 0x7f, {0x0a6,5428,100, 0,1,0x00,0xc0,0x29,0xf2,0x11,0x09,0x0}} }; -static const struct opl4_region regions_1e[] = { /* Distortion Guitar */ +static const opl4_region_t regions_1e[] = { /* Distortion Guitar */ {0x15, 0x2a, {0x051,6928,100, 0,1,0x00,0xbc,0x21,0xa2,0x12,0x0a,0x0}}, {0x2b, 0x2e, {0x052,6433,100, 0,1,0x00,0xbc,0x21,0xa2,0x12,0x0a,0x0}}, {0x2f, 0x32, {0x053,5944,100, 0,1,0x00,0xbc,0x21,0xa2,0x12,0x0a,0x0}}, @@ -263,44 +263,44 @@ static const struct opl4_region regions_1e[] = { /* Distortion Guitar */ {0x43, 0x46, {0x058,3361,100, 0,1,0x00,0xbc,0x21,0xa2,0x12,0x0a,0x0}}, {0x47, 0x6c, {0x059,2784,100, 0,1,0x00,0xbc,0x21,0xa2,0x12,0x0a,0x0}} }; -static const struct opl4_region regions_1f[] = { /* Guitar Harmonics */ +static const opl4_region_t regions_1f[] = { /* Guitar Harmonics */ {0x15, 0x44, {0x05e,5499,100, 0,0,0x00,0xce,0x28,0xf4,0x24,0x09,0x0}}, {0x45, 0x49, {0x05d,4850,100, 0,0,0x00,0xe2,0x28,0xf4,0x24,0x09,0x0}}, {0x4a, 0x6c, {0x05f,4259,100, 0,0,0x00,0xce,0x28,0xf4,0x24,0x09,0x0}} }; -static const struct opl4_region regions_20[] = { /* Acoustic Bass */ +static const opl4_region_t regions_20[] = { /* Acoustic Bass */ {0x15, 0x30, {0x004,8053,100, 0,0,0x00,0xe2,0x18,0xf5,0x15,0x09,0x0}}, {0x31, 0x6c, {0x005,4754,100, 0,0,0x00,0xe2,0x18,0xf5,0x15,0x09,0x0}} }; -static const struct opl4_region regions_21[] = { /* Fingered Bass */ +static const opl4_region_t regions_21[] = { /* Fingered Bass */ {0x01, 0x20, {0x04a,8762,100, 0,0,0x00,0xde,0x18,0xf6,0x14,0x09,0x0}}, {0x21, 0x25, {0x04b,8114,100, 0,0,0x00,0xde,0x18,0xf6,0x14,0x09,0x0}}, {0x26, 0x2a, {0x04c,7475,100, 0,0,0x00,0xde,0x18,0xf6,0x14,0x09,0x0}}, {0x2b, 0x7f, {0x04d,6841,100, 0,0,0x00,0xde,0x18,0xf6,0x14,0x09,0x0}} }; -static const struct opl4_region regions_22[] = { /* Picked Bass */ +static const opl4_region_t regions_22[] = { /* Picked Bass */ {0x15, 0x23, {0x04f,7954,100, 0,0,0x00,0xcc,0x18,0xf3,0x90,0x0a,0x0}}, {0x24, 0x2a, {0x050,7318,100, 0,0,0x05,0xcc,0x18,0xf3,0x90,0x1a,0x0}}, {0x2b, 0x2f, {0x06b,6654,100, 0,0,0x00,0xcc,0x18,0xf3,0x90,0x2a,0x0}}, {0x30, 0x47, {0x069,6031,100, 0,0,0x00,0xcc,0x18,0xf5,0xb0,0x0a,0x0}}, {0x48, 0x6c, {0x06a,5393,100, 0,0,0x00,0xcc,0x18,0xf5,0xb0,0x0a,0x0}} }; -static const struct opl4_region regions_23[] = { /* Fretless Bass */ +static const opl4_region_t regions_23[] = { /* Fretless Bass */ {0x01, 0x7f, {0x04e,5297,100, 0,0,0x00,0xd2,0x10,0xf3,0x63,0x19,0x0}} }; -static const struct opl4_region regions_24[] = { /* Slap Bass 1 */ +static const opl4_region_t regions_24[] = { /* Slap Bass 1 */ {0x15, 0x6c, {0x0a3,7606,100, 0,1,0x00,0xde,0x19,0xf5,0x32,0x1a,0x0}} }; -static const struct opl4_region regions_25[] = { /* Slap Bass 2 */ +static const opl4_region_t regions_25[] = { /* Slap Bass 2 */ {0x01, 0x7f, {0x0a2,6694,100, 0,0,0x00,0xda,0x20,0xb0,0x02,0x09,0x0}} }; -static const struct opl4_region regions_26[] = { /* Synth Bass 1 */ +static const opl4_region_t regions_26[] = { /* Synth Bass 1 */ {0x15, 0x6c, {0x0be,7466,100, 0,1,0x00,0xb8,0x39,0xf4,0x14,0x09,0x0}} }; -static const struct opl4_region regions_27[] = { /* Synth Bass 2 */ +static const opl4_region_t regions_27[] = { /* Synth Bass 2 */ {0x00, 0x7f, {0x117,8103,100, 0,1,0x00,0xca,0x39,0xf3,0x50,0x08,0x0}} }; -static const struct opl4_region regions_28[] = { /* Violin */ +static const opl4_region_t regions_28[] = { /* Violin */ {0x15, 0x3a, {0x105,5158,100, 0,3,0x00,0xcc,0x3b,0xf3,0x20,0x09,0x0}}, {0x3b, 0x3f, {0x102,4754,100, 0,3,0x00,0xcc,0x3b,0xf3,0x20,0x09,0x0}}, {0x40, 0x41, {0x106,4132,100, 0,3,0x00,0xcc,0x3b,0xf3,0x20,0x09,0x0}}, @@ -312,7 +312,7 @@ static const struct opl4_region regions_28[] = { /* Violin */ {0x4f, 0x51, {0x10d,2166,100, 0,3,0x00,0xcc,0x3b,0xf3,0x20,0x09,0x0}}, {0x52, 0x6c, {0x109,1825,100, 0,3,0x00,0xcc,0x3b,0xf3,0x20,0x09,0x0}} }; -static const struct opl4_region regions_29[] = { /* Viola */ +static const opl4_region_t regions_29[] = { /* Viola */ {0x15, 0x32, {0x103,5780,100, 0,3,0x00,0xc4,0x3b,0xa3,0x20,0x09,0x0}}, {0x33, 0x35, {0x104,5534,100, 0,3,0x00,0xc4,0x3b,0xa3,0x20,0x09,0x0}}, {0x36, 0x38, {0x105,5158,100, 0,3,0x00,0xc4,0x3b,0xa3,0x20,0x09,0x0}}, @@ -326,76 +326,76 @@ static const struct opl4_region regions_29[] = { /* Viola */ {0x4d, 0x4f, {0x10d,2166,100, 0,3,0x00,0xd0,0x3b,0xa3,0x20,0x09,0x0}}, {0x50, 0x6c, {0x109,1825,100, 0,3,0x00,0xd0,0x3b,0xa3,0x20,0x09,0x0}} }; -static const struct opl4_region regions_2a[] = { /* Cello */ +static const opl4_region_t regions_2a[] = { /* Cello */ {0x15, 0x2d, {0x112,6545,100, 0,3,0x00,0xc0,0x33,0xa0,0x00,0x08,0x0}}, {0x2e, 0x37, {0x113,5764,100, 0,3,0x00,0xc0,0x33,0xa0,0x00,0x08,0x0}}, {0x38, 0x3e, {0x115,4378,100, 0,3,0x00,0xc0,0x33,0xa0,0x00,0x18,0x0}}, {0x3f, 0x44, {0x116,3998,100, 0,3,0x00,0xc0,0x33,0xa0,0x00,0x18,0x0}}, {0x45, 0x6c, {0x114,3218,100, 0,3,0x00,0xc0,0x33,0xa0,0x00,0x18,0x0}} }; -static const struct opl4_region regions_2b[] = { /* Contrabass */ +static const opl4_region_t regions_2b[] = { /* Contrabass */ {0x15, 0x29, {0x110,7713,100, 0,1,0x00,0xc2,0x19,0x90,0x00,0x09,0x0}}, {0x2a, 0x6c, {0x111,6162,100, 0,1,0x00,0xc2,0x19,0x90,0x00,0x09,0x0}} }; -static const struct opl4_region regions_2c[] = { /* Tremolo Strings */ +static const opl4_region_t regions_2c[] = { /* Tremolo Strings */ {0x15, 0x3b, {0x0b0,4810,100, 0,0,0x0a,0xde,0x38,0xf0,0x00,0x07,0x6}}, {0x3c, 0x41, {0x035,4035,100, 0,0,0x05,0xde,0x38,0xf0,0x00,0x07,0x6}}, {0x42, 0x47, {0x033,3129,100, 0,0,0x05,0xde,0x38,0xf0,0x00,0x07,0x6}}, {0x48, 0x52, {0x034,2625,100, 0,0,0x05,0xde,0x38,0xf0,0x00,0x07,0x6}}, {0x53, 0x6c, {0x0af, 936,100, 0,0,0x00,0xde,0x38,0xf0,0x00,0x07,0x6}} }; -static const struct opl4_region regions_2d[] = { /* Pizzicato Strings */ +static const opl4_region_t regions_2d[] = { /* Pizzicato Strings */ {0x15, 0x32, {0x0b8,6186,100, 0,0,0x00,0xbc,0x28,0xf0,0x00,0x05,0x0}}, {0x33, 0x3b, {0x0b9,5031,100, 0,0,0x00,0xbc,0x28,0xf0,0x00,0x05,0x0}}, {0x3c, 0x42, {0x0bb,4146,100, 0,0,0x00,0xbc,0x28,0xf0,0x00,0x05,0x0}}, {0x43, 0x48, {0x0ba,3245,100, 0,0,0x00,0xc2,0x28,0xf0,0x00,0x05,0x0}}, {0x49, 0x6c, {0x0bc,2352,100, 0,0,0x00,0xbc,0x28,0xf0,0x00,0x05,0x0}} }; -static const struct opl4_region regions_2e[] = { /* Harp */ +static const opl4_region_t regions_2e[] = { /* Harp */ {0x15, 0x46, {0x07e,3740,100, 0,1,0x00,0xd2,0x29,0xf5,0x25,0x07,0x0}}, {0x47, 0x6c, {0x07f,2319,100, 0,1,0x00,0xd2,0x29,0xf5,0x25,0x07,0x0}} }; -static const struct opl4_region regions_2f[] = { /* Timpani */ +static const opl4_region_t regions_2f[] = { /* Timpani */ {0x15, 0x6c, {0x100,6570,100, 0,0,0x00,0xf8,0x28,0xf0,0x05,0x16,0x0}} }; -static const struct opl4_region regions_30[] = { /* Strings */ +static const opl4_region_t regions_30[] = { /* Strings */ {0x15, 0x3b, {0x13c,4806,100, 0,0,0x00,0xc8,0x20,0x80,0x00,0x07,0x0}}, {0x3c, 0x41, {0x13e,4035,100, 0,0,0x00,0xc8,0x20,0x80,0x00,0x07,0x0}}, {0x42, 0x47, {0x13d,3122,100, 0,0,0x00,0xc8,0x20,0x80,0x00,0x07,0x0}}, {0x48, 0x52, {0x13f,2629,100, 0,0,0x00,0xbe,0x20,0x80,0x00,0x07,0x0}}, {0x53, 0x6c, {0x140, 950,100, 0,0,0x00,0xbe,0x20,0x80,0x00,0x07,0x0}} }; -static const struct opl4_region regions_31[] = { /* Slow Strings */ +static const opl4_region_t regions_31[] = { /* Slow Strings */ {0x15, 0x3b, {0x0b0,4810,100, 0,1,0x0a,0xbe,0x19,0xf0,0x00,0x07,0x0}}, {0x3c, 0x41, {0x035,4035,100, 0,1,0x05,0xbe,0x19,0xf0,0x00,0x07,0x0}}, {0x42, 0x47, {0x033,3129,100, 0,1,0x05,0xbe,0x19,0xf0,0x00,0x07,0x0}}, {0x48, 0x52, {0x034,2625,100, 0,1,0x05,0xbe,0x19,0xf0,0x00,0x07,0x0}}, {0x53, 0x6c, {0x0af, 936,100, 0,1,0x00,0xbe,0x19,0xf0,0x00,0x07,0x0}} }; -static const struct opl4_region regions_32[] = { /* Synth Strings 1 */ +static const opl4_region_t regions_32[] = { /* Synth Strings 1 */ {0x05, 0x71, {0x002,6045,100,-2,0,0x00,0xa6,0x20,0x93,0x22,0x06,0x0}}, {0x15, 0x6c, {0x0ae,3261,100, 2,0,0x00,0xc6,0x20,0x70,0x01,0x06,0x0}} }; -static const struct opl4_region regions_33[] = { /* Synth Strings 2 */ +static const opl4_region_t regions_33[] = { /* Synth Strings 2 */ {0x15, 0x6c, {0x002,4513,100, 5,1,0x00,0xb4,0x19,0x70,0x00,0x06,0x0}}, {0x15, 0x6c, {0x002,4501,100,-5,1,0x00,0xb4,0x19,0x70,0x00,0x06,0x0}} }; -static const struct opl4_region regions_34[] = { /* Choir Aahs */ +static const opl4_region_t regions_34[] = { /* Choir Aahs */ {0x15, 0x3a, {0x018,5010,100, 0,2,0x00,0xc2,0x1a,0x70,0x00,0x08,0x0}}, {0x3b, 0x40, {0x019,4370,100, 0,2,0x00,0xc2,0x1a,0x70,0x00,0x08,0x0}}, {0x41, 0x47, {0x01a,3478,100, 0,2,0x00,0xc2,0x1a,0x70,0x00,0x08,0x0}}, {0x48, 0x6c, {0x01b,2197,100, 0,2,0x00,0xc2,0x1a,0x70,0x00,0x08,0x0}} }; -static const struct opl4_region regions_35[] = { /* Voice Oohs */ +static const opl4_region_t regions_35[] = { /* Voice Oohs */ {0x15, 0x6c, {0x029,3596,100, 0,0,0x00,0xe6,0x20,0xf7,0x20,0x08,0x0}} }; -static const struct opl4_region regions_36[] = { /* Synth Voice */ +static const opl4_region_t regions_36[] = { /* Synth Voice */ {0x15, 0x6c, {0x02a,3482,100, 0,1,0x00,0xc2,0x19,0x85,0x21,0x07,0x0}} }; -static const struct opl4_region regions_37[] = { /* Orchestra Hit */ +static const opl4_region_t regions_37[] = { /* Orchestra Hit */ {0x15, 0x6c, {0x049,4394,100, 0,0,0x00,0xfe,0x30,0x80,0x05,0x05,0x0}} }; -static const struct opl4_region regions_38[] = { /* Trumpet */ +static const opl4_region_t regions_38[] = { /* Trumpet */ {0x15, 0x3c, {0x0f6,4706,100, 0,2,0x00,0xd6,0x32,0xf3,0x20,0x0a,0x0}}, {0x3d, 0x43, {0x0f8,3894,100, 0,2,0x00,0xd6,0x32,0xf3,0x20,0x0a,0x0}}, {0x44, 0x48, {0x0f7,3118,100, 0,2,0x00,0xd6,0x32,0xf3,0x20,0x0a,0x0}}, @@ -403,28 +403,28 @@ static const struct opl4_region regions_38[] = { /* Trumpet */ {0x4f, 0x55, {0x0f9,1634,100, 0,2,0x00,0xd6,0x32,0xf3,0x20,0x0a,0x0}}, {0x56, 0x6c, {0x0fb, 786,100, 0,2,0x00,0xd6,0x32,0xf3,0x20,0x0a,0x0}} }; -static const struct opl4_region regions_39[] = { /* Trombone */ +static const opl4_region_t regions_39[] = { /* Trombone */ {0x15, 0x3a, {0x0f0,5053,100, 0,1,0x00,0xd6,0x21,0xf0,0x00,0x09,0x0}}, {0x3b, 0x3f, {0x0f1,4290,100, 0,1,0x00,0xd6,0x21,0xf0,0x00,0x09,0x0}}, {0x40, 0x6c, {0x0f2,3580,100, 0,1,0x00,0xd6,0x21,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_3a[] = { /* Tuba */ +static const opl4_region_t regions_3a[] = { /* Tuba */ {0x15, 0x2d, {0x085,7096,100, 0,1,0x00,0xde,0x21,0xf5,0x10,0x09,0x0}}, {0x2e, 0x6c, {0x086,6014,100, 0,1,0x00,0xde,0x21,0xf5,0x10,0x09,0x0}} }; -static const struct opl4_region regions_3b[] = { /* Muted Trumpet */ +static const opl4_region_t regions_3b[] = { /* Muted Trumpet */ {0x15, 0x45, {0x0b1,4135,100, 0,0,0x00,0xcc,0x28,0xf3,0x10,0x0a,0x1}}, {0x46, 0x6c, {0x0b2,2599,100, 0,0,0x00,0xcc,0x28,0x83,0x10,0x0a,0x1}} }; -static const struct opl4_region regions_3c[] = { /* French Horns */ +static const opl4_region_t regions_3c[] = { /* French Horns */ {0x15, 0x49, {0x07c,3624,100, 0,2,0x00,0xd0,0x1a,0xf0,0x00,0x09,0x0}}, {0x4a, 0x6c, {0x07d,2664,100, 0,2,0x00,0xd0,0x1a,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_3d[] = { /* Brass Section */ +static const opl4_region_t regions_3d[] = { /* Brass Section */ {0x15, 0x42, {0x0fc,4375,100, 0,0,0x00,0xd6,0x28,0xf0,0x00,0x0a,0x0}}, {0x43, 0x6c, {0x0fd,2854,100, 0,0,0x00,0xd6,0x28,0xf0,0x00,0x0a,0x0}} }; -static const struct opl4_region regions_3e[] = { /* Synth Brass 1 */ +static const opl4_region_t regions_3e[] = { /* Synth Brass 1 */ {0x01, 0x27, {0x0d3,9094,100,-1,0,0x00,0xbe,0x18,0xa5,0x11,0x08,0x0}}, {0x28, 0x2d, {0x0da,8335,100,-1,0,0x00,0xbe,0x18,0xa5,0x11,0x08,0x0}}, {0x2e, 0x33, {0x0d4,7558,100,-1,0,0x00,0xbe,0x18,0xa5,0x11,0x08,0x0}}, @@ -450,7 +450,7 @@ static const struct opl4_region regions_3e[] = { /* Synth Brass 1 */ {0x5e, 0x64, {0x122,1421,100, 1,1,0x00,0xbe,0x19,0x85,0x23,0x08,0x0}}, {0x65, 0x7f, {0x123,-115,100, 1,1,0x00,0xbe,0x19,0x85,0x23,0x08,0x0}} }; -static const struct opl4_region regions_3f[] = { /* Synth Brass 2 */ +static const opl4_region_t regions_3f[] = { /* Synth Brass 2 */ {0x01, 0x27, {0x118,9113,100, 3,6,0x00,0xae,0x26,0x85,0x23,0x08,0x0}}, {0x28, 0x2d, {0x119,8350,100, 3,6,0x00,0xae,0x26,0x85,0x23,0x08,0x0}}, {0x2e, 0x33, {0x11a,7575,100, 3,6,0x00,0xae,0x26,0x85,0x23,0x08,0x0}}, @@ -465,7 +465,7 @@ static const struct opl4_region regions_3f[] = { /* Synth Brass 2 */ {0x65, 0x7f, {0x123,-105,100, 3,6,0x00,0xae,0x26,0x85,0x23,0x08,0x0}}, {0x00, 0x7f, {0x124,4034,100,-3,2,0x00,0xea,0x22,0x85,0x23,0x08,0x0}} }; -static const struct opl4_region regions_40[] = { /* Soprano Sax */ +static const opl4_region_t regions_40[] = { /* Soprano Sax */ {0x15, 0x3f, {0x0e3,4228,100, 0,1,0x00,0xc8,0x21,0xf5,0x20,0x0a,0x0}}, {0x40, 0x45, {0x0e4,3495,100, 0,1,0x00,0xc8,0x21,0xf5,0x20,0x0a,0x0}}, {0x46, 0x4b, {0x0e5,2660,100, 0,1,0x00,0xd6,0x21,0xf5,0x20,0x0a,0x0}}, @@ -473,7 +473,7 @@ static const struct opl4_region regions_40[] = { /* Soprano Sax */ {0x52, 0x59, {0x0e7,1186,100, 0,1,0x00,0xd6,0x21,0xf5,0x20,0x0a,0x0}}, {0x59, 0x6c, {0x0e8,1730,100, 0,1,0x00,0xc8,0x21,0xf5,0x20,0x0a,0x0}} }; -static const struct opl4_region regions_41[] = { /* Alto Sax */ +static const opl4_region_t regions_41[] = { /* Alto Sax */ {0x15, 0x32, {0x092,6204,100, 0,1,0x00,0xbe,0x19,0xf5,0x20,0x0b,0x0}}, {0x33, 0x35, {0x096,5812,100, 0,1,0x00,0xbe,0x19,0xf5,0x20,0x0b,0x0}}, {0x36, 0x3a, {0x099,5318,100, 0,1,0x00,0xbe,0x19,0xf5,0x20,0x0b,0x0}}, @@ -488,7 +488,7 @@ static const struct opl4_region regions_41[] = { /* Alto Sax */ {0x51, 0x53, {0x091,2088,100, 0,1,0x00,0xbe,0x19,0xf5,0x20,0x0b,0x0}}, {0x54, 0x6c, {0x095,1732,100, 0,1,0x00,0xbe,0x19,0xf5,0x20,0x0b,0x0}} }; -static const struct opl4_region regions_42[] = { /* Tenor Sax */ +static const opl4_region_t regions_42[] = { /* Tenor Sax */ {0x24, 0x30, {0x0e9,6301,100, 0,1,0x00,0xbc,0x19,0xf4,0x10,0x0b,0x0}}, {0x31, 0x34, {0x0ea,5781,100, 0,1,0x00,0xbc,0x19,0xf4,0x10,0x0b,0x0}}, {0x35, 0x3a, {0x0eb,5053,100, 0,1,0x00,0xbc,0x19,0xf4,0x10,0x0b,0x0}}, @@ -497,13 +497,13 @@ static const struct opl4_region regions_42[] = { /* Tenor Sax */ {0x48, 0x51, {0x0ee,2462,100, 0,1,0x00,0xbc,0x19,0xf4,0x10,0x0b,0x0}}, {0x52, 0x6c, {0x0ef,1421,100, 0,1,0x00,0xbc,0x19,0xf4,0x10,0x0b,0x0}} }; -static const struct opl4_region regions_43[] = { /* Baritone Sax */ +static const opl4_region_t regions_43[] = { /* Baritone Sax */ {0x15, 0x2d, {0x0df,6714,100, 0,1,0x00,0xce,0x19,0xf0,0x00,0x0a,0x0}}, {0x2e, 0x34, {0x0e1,5552,100, 0,1,0x00,0xce,0x19,0xf0,0x00,0x0a,0x0}}, {0x35, 0x39, {0x0e2,5178,100, 0,1,0x00,0xce,0x19,0xf0,0x00,0x0a,0x0}}, {0x3a, 0x6c, {0x0e0,4437,100, 0,1,0x00,0xce,0x19,0xf0,0x00,0x0a,0x0}} }; -static const struct opl4_region regions_44[] = { /* Oboe */ +static const opl4_region_t regions_44[] = { /* Oboe */ {0x15, 0x3c, {0x042,4493,100, 0,1,0x00,0xe6,0x39,0xf4,0x10,0x0a,0x0}}, {0x3d, 0x43, {0x044,3702,100, 0,1,0x00,0xdc,0x39,0xf4,0x10,0x0a,0x0}}, {0x44, 0x49, {0x043,2956,100, 0,1,0x00,0xdc,0x39,0xf4,0x10,0x0a,0x0}}, @@ -511,55 +511,55 @@ static const struct opl4_region regions_44[] = { /* Oboe */ {0x50, 0x55, {0x045,1420,100, 0,1,0x00,0xdc,0x39,0xf4,0x10,0x0a,0x0}}, {0x56, 0x6c, {0x047, 630,100, 0,1,0x00,0xe6,0x39,0xf4,0x10,0x0a,0x0}} }; -static const struct opl4_region regions_45[] = { /* English Horn */ +static const opl4_region_t regions_45[] = { /* English Horn */ {0x15, 0x38, {0x03c,5098,100, 0,1,0x00,0xc4,0x31,0xf0,0x00,0x09,0x0}}, {0x39, 0x3e, {0x03b,4291,100, 0,1,0x00,0xc4,0x31,0xf0,0x00,0x09,0x0}}, {0x3f, 0x6c, {0x03d,3540,100, 0,1,0x00,0xc4,0x31,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_46[] = { /* Bassoon */ +static const opl4_region_t regions_46[] = { /* Bassoon */ {0x15, 0x22, {0x038,7833,100, 0,1,0x00,0xc6,0x31,0xf0,0x00,0x0b,0x0}}, {0x23, 0x2e, {0x03a,7070,100, 0,1,0x00,0xc6,0x31,0xf0,0x00,0x0b,0x0}}, {0x2f, 0x6c, {0x039,6302,100, 0,1,0x00,0xc6,0x31,0xf0,0x00,0x0b,0x0}} }; -static const struct opl4_region regions_47[] = { /* Clarinet */ +static const opl4_region_t regions_47[] = { /* Clarinet */ {0x15, 0x3b, {0x09e,5900,100, 0,1,0x00,0xc8,0x29,0xf3,0x20,0x0a,0x0}}, {0x3c, 0x41, {0x0a0,5158,100, 0,1,0x00,0xc8,0x29,0xf3,0x20,0x0a,0x0}}, {0x42, 0x4a, {0x09f,4260,100, 0,1,0x00,0xc8,0x29,0xf3,0x20,0x0a,0x0}}, {0x4b, 0x6c, {0x0a1,2957,100, 0,1,0x00,0xc8,0x29,0xf3,0x20,0x0a,0x0}} }; -static const struct opl4_region regions_48[] = { /* Piccolo */ +static const opl4_region_t regions_48[] = { /* Piccolo */ {0x15, 0x40, {0x071,4803,100, 0,0,0x00,0xe6,0x38,0xf0,0x00,0x0a,0x2}}, {0x41, 0x4d, {0x072,3314,100, 0,0,0x00,0xe6,0x38,0xf0,0x00,0x0a,0x2}}, {0x4e, 0x53, {0x073,1731,100, 0,0,0x00,0xe6,0x38,0xf0,0x00,0x0a,0x2}}, {0x54, 0x5f, {0x074,2085,100, 0,0,0x00,0xe6,0x38,0xf0,0x00,0x0a,0x2}}, {0x60, 0x6c, {0x075,1421,100, 0,0,0x00,0xe6,0x38,0xf0,0x00,0x0a,0x2}} }; -static const struct opl4_region regions_49[] = { /* Flute */ +static const opl4_region_t regions_49[] = { /* Flute */ {0x15, 0x40, {0x071,4803,100, 0,0,0x00,0xdc,0x38,0xf0,0x00,0x0a,0x2}}, {0x41, 0x4d, {0x072,3314,100, 0,0,0x00,0xdc,0x38,0xf0,0x00,0x0a,0x2}}, {0x4e, 0x6c, {0x073,1731,100, 0,0,0x00,0xe6,0x38,0xf0,0x00,0x0a,0x2}} }; -static const struct opl4_region regions_4a[] = { /* Recorder */ +static const opl4_region_t regions_4a[] = { /* Recorder */ {0x15, 0x6f, {0x0bd,4897,100, 0,0,0x00,0xec,0x30,0x70,0x00,0x09,0x1}} }; -static const struct opl4_region regions_4b[] = { /* Pan Flute */ +static const opl4_region_t regions_4b[] = { /* Pan Flute */ {0x15, 0x6c, {0x077,2359,100, 0,0,0x00,0xde,0x38,0xf0,0x00,0x09,0x3}} }; -static const struct opl4_region regions_4c[] = { /* Bottle Blow */ +static const opl4_region_t regions_4c[] = { /* Bottle Blow */ {0x15, 0x6c, {0x077,2359,100, 0,0,0x00,0xc8,0x38,0xf0,0x00,0x09,0x1}}, {0x01, 0x7f, {0x125,7372,100, 0,0,0x1e,0x80,0x00,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_4d[] = { /* Shakuhachi */ +static const opl4_region_t regions_4d[] = { /* Shakuhachi */ {0x00, 0x7f, {0x0ab,4548,100, 0,0,0x00,0xd6,0x30,0xf0,0x00,0x0a,0x3}}, {0x15, 0x6c, {0x076,3716,100, 0,0,0x00,0xa2,0x28,0x70,0x00,0x09,0x2}} }; -static const struct opl4_region regions_4e[] = { /* Whistle */ +static const opl4_region_t regions_4e[] = { /* Whistle */ {0x00, 0x7f, {0x0aa,1731,100, 0,4,0x00,0xd2,0x2c,0x70,0x00,0x0a,0x0}} }; -static const struct opl4_region regions_4f[] = { /* Ocarina */ +static const opl4_region_t regions_4f[] = { /* Ocarina */ {0x00, 0x7f, {0x0aa,1731,100, 0,1,0x00,0xce,0x29,0x90,0x00,0x0a,0x1}} }; -static const struct opl4_region regions_50[] = { /* Square Lead */ +static const opl4_region_t regions_50[] = { /* Square Lead */ {0x01, 0x2a, {0x0cc,9853,100, 3,0,0x00,0xac,0x38,0xc6,0x21,0x09,0x0}}, {0x2b, 0x36, {0x0cd,6785,100, 3,0,0x00,0xac,0x38,0xc6,0x21,0x09,0x0}}, {0x37, 0x42, {0x0ca,5248,100, 3,0,0x00,0xac,0x38,0xc6,0x21,0x09,0x0}}, @@ -573,7 +573,7 @@ static const struct opl4_region regions_50[] = { /* Square Lead */ {0x4f, 0x5a, {0x0ce,2167,100,-3,0,0x00,0xac,0x08,0xc6,0x21,0x09,0x0}}, {0x5b, 0x7f, {0x0cb, 631,100,-3,0,0x00,0xac,0x08,0xc6,0x21,0x09,0x0}} }; -static const struct opl4_region regions_51[] = { /* Sawtooth Lead */ +static const opl4_region_t regions_51[] = { /* Sawtooth Lead */ {0x01, 0x27, {0x118,9108,100, 0,0,0x00,0xc8,0x30,0xf2,0x22,0x0a,0x0}}, {0x28, 0x2d, {0x119,8345,100, 0,0,0x00,0xc8,0x30,0xf2,0x22,0x0a,0x0}}, {0x2e, 0x33, {0x11a,7570,100, 0,0,0x00,0xc8,0x30,0xf2,0x22,0x0a,0x0}}, @@ -599,15 +599,15 @@ static const struct opl4_region regions_51[] = { /* Sawtooth Lead */ {0x5e, 0x66, {0x122,1416,100, 0,0,0x00,0xc8,0x30,0xf2,0x22,0x0a,0x0}}, {0x67, 0x7f, {0x123,-120,100, 0,0,0x00,0xc8,0x30,0xf2,0x22,0x0a,0x0}} }; -static const struct opl4_region regions_52[] = { /* Calliope Lead */ +static const opl4_region_t regions_52[] = { /* Calliope Lead */ {0x00, 0x7f, {0x0aa,1731,100, 0,0,0x00,0xc2,0x28,0x90,0x00,0x0a,0x2}}, {0x15, 0x6c, {0x076,3716,100, 0,0,0x00,0xb6,0x28,0xb0,0x00,0x09,0x2}} }; -static const struct opl4_region regions_53[] = { /* Chiffer Lead */ +static const opl4_region_t regions_53[] = { /* Chiffer Lead */ {0x00, 0x7f, {0x13a,3665,100, 0,2,0x00,0xcc,0x2a,0xf0,0x10,0x09,0x1}}, {0x01, 0x7f, {0x0fe,3660,100, 0,0,0x00,0xbe,0x28,0xf3,0x10,0x17,0x0}} }; -static const struct opl4_region regions_54[] = { /* Charang Lead */ +static const opl4_region_t regions_54[] = { /* Charang Lead */ {0x00, 0x40, {0x0a5,6594,100, 0,3,0x00,0xba,0x33,0xf2,0x11,0x09,0x0}}, {0x41, 0x7f, {0x0a6,5433,100, 0,3,0x00,0xba,0x33,0xf2,0x11,0x09,0x0}}, {0x01, 0x27, {0x118,9098,100, 0,2,0x00,0xa4,0x2a,0xf2,0x22,0x0e,0x0}}, @@ -623,11 +623,11 @@ static const struct opl4_region regions_54[] = { /* Charang Lead */ {0x5e, 0x66, {0x122,1416,100, 0,2,0x00,0xa4,0x2a,0xf2,0x22,0x0e,0x0}}, {0x67, 0x7f, {0x123,-120,100, 0,2,0x00,0xa4,0x2a,0xf2,0x22,0x0e,0x0}} }; -static const struct opl4_region regions_55[] = { /* Voice Lead */ +static const opl4_region_t regions_55[] = { /* Voice Lead */ {0x00, 0x7f, {0x0aa,1739,100, 0,6,0x00,0x8c,0x2e,0x90,0x00,0x0a,0x0}}, {0x15, 0x6c, {0x02a,3474,100, 0,1,0x00,0xd8,0x29,0xf0,0x05,0x0a,0x0}} }; -static const struct opl4_region regions_56[] = { /* 5ths Lead */ +static const opl4_region_t regions_56[] = { /* 5ths Lead */ {0x01, 0x27, {0x118,8468,100, 0,2,0x00,0xd0,0x32,0xf5,0x20,0x08,0x0}}, {0x28, 0x2d, {0x119,7705,100, 0,2,0x00,0xd0,0x32,0xf5,0x20,0x08,0x0}}, {0x2e, 0x33, {0x11a,6930,100, 0,2,0x00,0xd0,0x32,0xf5,0x20,0x08,0x0}}, @@ -642,7 +642,7 @@ static const struct opl4_region regions_56[] = { /* 5ths Lead */ {0x65, 0x7f, {0x123,-750,100, 0,2,0x00,0xd0,0x32,0xf5,0x20,0x08,0x0}}, {0x05, 0x71, {0x002,4503,100, 0,1,0x00,0xb8,0x31,0xb3,0x20,0x0b,0x0}} }; -static const struct opl4_region regions_57[] = { /* Bass & Lead */ +static const opl4_region_t regions_57[] = { /* Bass & Lead */ {0x00, 0x7f, {0x117,8109,100, 0,1,0x00,0xbc,0x29,0xf3,0x50,0x08,0x0}}, {0x01, 0x27, {0x118,9097,100, 0,2,0x00,0xbc,0x2a,0xf2,0x20,0x0a,0x0}}, {0x28, 0x2d, {0x119,8334,100, 0,2,0x00,0xbc,0x2a,0xf2,0x20,0x0a,0x0}}, @@ -657,15 +657,15 @@ static const struct opl4_region regions_57[] = { /* Bass & Lead */ {0x5e, 0x66, {0x122,1415,100, 0,2,0x00,0xbc,0x2a,0xf2,0x20,0x0a,0x0}}, {0x67, 0x7f, {0x123,-121,100, 0,2,0x00,0xbc,0x2a,0xf2,0x20,0x0a,0x0}} }; -static const struct opl4_region regions_58[] = { /* New Age Pad */ +static const opl4_region_t regions_58[] = { /* New Age Pad */ {0x15, 0x6c, {0x002,4501,100, 0,4,0x00,0xa4,0x24,0x80,0x01,0x05,0x0}}, {0x15, 0x6c, {0x0f3,4253,100, 0,3,0x00,0x8c,0x23,0xa2,0x14,0x06,0x1}} }; -static const struct opl4_region regions_59[] = { /* Warm Pad */ +static const opl4_region_t regions_59[] = { /* Warm Pad */ {0x15, 0x6c, {0x04e,5306,100, 2,2,0x00,0x92,0x2a,0x34,0x23,0x05,0x2}}, {0x15, 0x6c, {0x029,3575,100,-2,2,0x00,0xbe,0x22,0x31,0x23,0x06,0x0}} }; -static const struct opl4_region regions_5a[] = { /* Polysynth Pad */ +static const opl4_region_t regions_5a[] = { /* Polysynth Pad */ {0x01, 0x27, {0x118,9111,100, 0,3,0x00,0xae,0x23,0xf2,0x20,0x07,0x1}}, {0x28, 0x2d, {0x119,8348,100, 0,3,0x00,0xae,0x23,0xf2,0x20,0x07,0x1}}, {0x2e, 0x33, {0x11a,7573,100, 0,3,0x00,0xae,0x23,0xf2,0x20,0x07,0x1}}, @@ -680,29 +680,29 @@ static const struct opl4_region regions_5a[] = { /* Polysynth Pad */ {0x67, 0x7f, {0x123,-107,100, 0,3,0x00,0xae,0x23,0xf2,0x20,0x07,0x1}}, {0x00, 0x7f, {0x124,4024,100, 0,2,0x00,0xae,0x22,0xe5,0x20,0x08,0x0}} }; -static const struct opl4_region regions_5b[] = { /* Choir Pad */ +static const opl4_region_t regions_5b[] = { /* Choir Pad */ {0x15, 0x3a, {0x018,5010,100, 0,5,0x00,0xb0,0x25,0x70,0x00,0x06,0x0}}, {0x3b, 0x40, {0x019,4370,100, 0,5,0x00,0xb0,0x25,0x70,0x00,0x06,0x0}}, {0x41, 0x47, {0x01a,3478,100, 0,5,0x00,0xb0,0x25,0x70,0x00,0x06,0x0}}, {0x48, 0x6c, {0x01b,2197,100, 0,5,0x00,0xb0,0x25,0x70,0x00,0x06,0x0}}, {0x15, 0x6c, {0x02a,3482,100, 0,4,0x00,0x98,0x24,0x65,0x21,0x06,0x0}} }; -static const struct opl4_region regions_5c[] = { /* Bowed Pad */ +static const opl4_region_t regions_5c[] = { /* Bowed Pad */ {0x15, 0x6c, {0x101,4790,100,-1,1,0x00,0xbe,0x19,0x44,0x14,0x16,0x0}}, {0x00, 0x7f, {0x0aa,1720,100, 1,1,0x00,0x94,0x19,0x40,0x00,0x06,0x0}} }; -static const struct opl4_region regions_5d[] = { /* Metallic Pad */ +static const opl4_region_t regions_5d[] = { /* Metallic Pad */ {0x15, 0x31, {0x00c,6943,100, 0,2,0x00,0xa0,0x0a,0x60,0x03,0x06,0x0}}, {0x32, 0x38, {0x00d,5416,100, 0,2,0x00,0xa0,0x0a,0x60,0x03,0x06,0x0}}, {0x39, 0x47, {0x00e,4385,100, 0,2,0x00,0xa0,0x0a,0x60,0x03,0x06,0x0}}, {0x48, 0x6c, {0x00f,2849,100, 0,2,0x00,0xa0,0x0a,0x60,0x03,0x06,0x0}}, {0x00, 0x7f, {0x03f,4224,100, 0,1,0x00,0x9c,0x31,0x65,0x16,0x07,0x0}} }; -static const struct opl4_region regions_5e[] = { /* Halo Pad */ +static const opl4_region_t regions_5e[] = { /* Halo Pad */ {0x00, 0x7f, {0x124,4038,100, 0,2,0x00,0xa6,0x1a,0x85,0x23,0x08,0x0}}, {0x15, 0x6c, {0x02a,3471,100, 0,3,0x00,0xc0,0x1b,0xc0,0x05,0x06,0x0}} }; -static const struct opl4_region regions_5f[] = { /* Sweep Pad */ +static const opl4_region_t regions_5f[] = { /* Sweep Pad */ {0x01, 0x27, {0x0d3,9100,100, 0,1,0x00,0xce,0x19,0x13,0x11,0x06,0x0}}, {0x28, 0x2d, {0x0da,8341,100, 0,1,0x00,0xce,0x19,0x13,0x11,0x06,0x0}}, {0x2e, 0x33, {0x0d4,7564,100, 0,1,0x00,0xce,0x19,0x13,0x11,0x06,0x0}}, @@ -728,21 +728,21 @@ static const struct opl4_region regions_5f[] = { /* Sweep Pad */ {0x5e, 0x63, {0x0d8,1415,100, 0,0,0x00,0xce,0x18,0x13,0x11,0x06,0x0}}, {0x64, 0x7f, {0x0d9,-121,100, 0,0,0x00,0xce,0x18,0x13,0x11,0x06,0x0}} }; -static const struct opl4_region regions_60[] = { /* Ice Rain */ +static const opl4_region_t regions_60[] = { /* Ice Rain */ {0x01, 0x7f, {0x04e,9345,100, 0,2,0x00,0xcc,0x22,0xa3,0x63,0x17,0x0}}, {0x00, 0x7f, {0x143,5586, 20, 0,2,0x00,0x6e,0x2a,0xf0,0x05,0x05,0x0}} }; -static const struct opl4_region regions_61[] = { /* Soundtrack */ +static const opl4_region_t regions_61[] = { /* Soundtrack */ {0x15, 0x6c, {0x002,4501,100, 0,2,0x00,0xb6,0x2a,0x60,0x01,0x05,0x0}}, {0x15, 0x6c, {0x0f3,1160,100, 0,5,0x00,0xa8,0x2d,0x52,0x14,0x06,0x2}} }; -static const struct opl4_region regions_62[] = { /* Crystal */ +static const opl4_region_t regions_62[] = { /* Crystal */ {0x15, 0x6c, {0x0f3,1826,100, 0,3,0x00,0xb8,0x33,0xf6,0x25,0x25,0x0}}, {0x15, 0x2c, {0x06d,7454,100, 0,3,0x00,0xac,0x3b,0x85,0x24,0x06,0x0}}, {0x2d, 0x36, {0x06e,5925,100, 0,3,0x00,0xac,0x3b,0x85,0x24,0x06,0x0}}, {0x37, 0x6c, {0x06f,4403,100, 0,3,0x09,0xac,0x3b,0x85,0x24,0x06,0x0}} }; -static const struct opl4_region regions_63[] = { /* Atmosphere */ +static const opl4_region_t regions_63[] = { /* Atmosphere */ {0x05, 0x71, {0x002,4509,100, 0,2,0x00,0xc8,0x32,0x73,0x22,0x06,0x1}}, {0x15, 0x2f, {0x0b3,6964,100, 0,2,0x05,0xc2,0x32,0xf5,0x34,0x07,0x2}}, {0x30, 0x36, {0x0b7,5567,100, 0,2,0x0c,0xc2,0x32,0xf5,0x34,0x07,0x2}}, @@ -750,29 +750,29 @@ static const struct opl4_region regions_63[] = { /* Atmosphere */ {0x3d, 0x43, {0x0b4,3892,100, 0,2,0x00,0xc2,0x32,0xf6,0x35,0x07,0x2}}, {0x44, 0x60, {0x0b6,2723,100, 0,2,0x00,0xc2,0x32,0xf6,0x35,0x17,0x2}} }; -static const struct opl4_region regions_64[] = { /* Brightness */ +static const opl4_region_t regions_64[] = { /* Brightness */ {0x00, 0x7f, {0x137,5285,100, 0,2,0x00,0xbe,0x2a,0xa5,0x18,0x08,0x0}}, {0x15, 0x6c, {0x02a,3481,100, 0,1,0x00,0xc8,0x29,0x80,0x05,0x05,0x0}} }; -static const struct opl4_region regions_65[] = { /* Goblins */ +static const opl4_region_t regions_65[] = { /* Goblins */ {0x15, 0x6c, {0x002,4501,100,-1,2,0x00,0xca,0x2a,0x40,0x01,0x05,0x0}}, {0x15, 0x6c, {0x009,9679, 20, 1,4,0x00,0x3c,0x0c,0x22,0x11,0x06,0x0}} }; -static const struct opl4_region regions_66[] = { /* Echoes */ +static const opl4_region_t regions_66[] = { /* Echoes */ {0x15, 0x6c, {0x02a,3487,100, 0,3,0x00,0xae,0x2b,0xf5,0x21,0x06,0x0}}, {0x00, 0x7f, {0x124,4027,100, 0,3,0x00,0xae,0x2b,0x85,0x23,0x07,0x0}} }; -static const struct opl4_region regions_67[] = { /* Sci-Fi */ +static const opl4_region_t regions_67[] = { /* Sci-Fi */ {0x15, 0x31, {0x00c,6940,100, 0,3,0x00,0xc8,0x2b,0x90,0x05,0x06,0x3}}, {0x32, 0x38, {0x00d,5413,100, 0,3,0x00,0xc8,0x2b,0x90,0x05,0x06,0x3}}, {0x39, 0x47, {0x00e,4382,100, 0,3,0x00,0xc8,0x2b,0x90,0x05,0x06,0x3}}, {0x48, 0x6c, {0x00f,2846,100, 0,3,0x00,0xc8,0x2b,0x90,0x05,0x06,0x3}}, {0x15, 0x6c, {0x002,4498,100, 0,2,0x00,0xd4,0x22,0x80,0x01,0x05,0x0}} }; -static const struct opl4_region regions_68[] = { /* Sitar */ +static const opl4_region_t regions_68[] = { /* Sitar */ {0x00, 0x7f, {0x10f,4408,100, 0,2,0x00,0xc4,0x32,0xf4,0x15,0x16,0x1}} }; -static const struct opl4_region regions_69[] = { /* Banjo */ +static const opl4_region_t regions_69[] = { /* Banjo */ {0x15, 0x34, {0x013,5685,100, 0,0,0x00,0xdc,0x38,0xf6,0x15,0x09,0x0}}, {0x35, 0x38, {0x014,5009,100, 0,0,0x00,0xdc,0x38,0xf6,0x15,0x09,0x0}}, {0x39, 0x3c, {0x012,4520,100, 0,0,0x00,0xdc,0x38,0xf6,0x15,0x09,0x0}}, @@ -780,21 +780,21 @@ static const struct opl4_region regions_69[] = { /* Banjo */ {0x45, 0x4c, {0x017,2661,100, 0,0,0x00,0xdc,0x38,0xf6,0x15,0x09,0x0}}, {0x4d, 0x6d, {0x016,1632,100, 0,0,0x00,0xdc,0x38,0xf6,0x15,0x09,0x0}} }; -static const struct opl4_region regions_6a[] = { /* Shamisen */ +static const opl4_region_t regions_6a[] = { /* Shamisen */ {0x15, 0x6c, {0x10e,3273,100, 0,0,0x00,0xc0,0x28,0xf7,0x76,0x08,0x0}} }; -static const struct opl4_region regions_6b[] = { /* Koto */ +static const opl4_region_t regions_6b[] = { /* Koto */ {0x00, 0x7f, {0x0a9,4033,100, 0,0,0x00,0xc6,0x20,0xf0,0x06,0x07,0x0}} }; -static const struct opl4_region regions_6c[] = { /* Kalimba */ +static const opl4_region_t regions_6c[] = { /* Kalimba */ {0x00, 0x7f, {0x137,3749,100, 0,0,0x00,0xce,0x38,0xf5,0x18,0x08,0x0}} }; -static const struct opl4_region regions_6d[] = { /* Bagpipe */ +static const opl4_region_t regions_6d[] = { /* Bagpipe */ {0x15, 0x39, {0x0a4,7683,100, 0,4,0x00,0xc0,0x1c,0xf0,0x00,0x09,0x0}}, {0x15, 0x39, {0x0a7,7680,100, 0,1,0x00,0xaa,0x19,0xf0,0x00,0x09,0x0}}, {0x3a, 0x6c, {0x0a8,3697,100, 0,1,0x00,0xaa,0x19,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_6e[] = { /* Fiddle */ +static const opl4_region_t regions_6e[] = { /* Fiddle */ {0x15, 0x3a, {0x105,5158,100, 0,1,0x00,0xca,0x31,0xf3,0x20,0x09,0x0}}, {0x3b, 0x3f, {0x102,4754,100, 0,1,0x00,0xca,0x31,0xf3,0x20,0x09,0x0}}, {0x40, 0x41, {0x106,4132,100, 0,1,0x00,0xca,0x31,0xf3,0x20,0x09,0x0}}, @@ -806,64 +806,64 @@ static const struct opl4_region regions_6e[] = { /* Fiddle */ {0x4f, 0x51, {0x10d,2166,100, 0,1,0x00,0xca,0x31,0xf3,0x20,0x09,0x0}}, {0x52, 0x6c, {0x109,1825,100, 0,1,0x00,0xca,0x31,0xf3,0x20,0x09,0x0}} }; -static const struct opl4_region regions_6f[] = { /* Shanai */ +static const opl4_region_t regions_6f[] = { /* Shanai */ {0x15, 0x6c, {0x041,6946,100, 0,1,0x00,0xc4,0x31,0x95,0x20,0x09,0x0}} }; -static const struct opl4_region regions_70[] = { /* Tinkle Bell */ +static const opl4_region_t regions_70[] = { /* Tinkle Bell */ {0x15, 0x73, {0x0f3,1821,100, 0,3,0x00,0xc8,0x3b,0xd6,0x25,0x25,0x0}}, {0x00, 0x7f, {0x137,5669,100, 0,3,0x00,0x66,0x3b,0xf5,0x18,0x08,0x0}} }; -static const struct opl4_region regions_71[] = { /* Agogo */ +static const opl4_region_t regions_71[] = { /* Agogo */ {0x15, 0x74, {0x00b,2474,100, 0,0,0x00,0xd2,0x38,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_72[] = { /* Steel Drums */ +static const opl4_region_t regions_72[] = { /* Steel Drums */ {0x01, 0x7f, {0x0fe,3670,100, 0,0,0x00,0xca,0x38,0xf3,0x06,0x17,0x1}}, {0x15, 0x6c, {0x100,9602,100, 0,0,0x00,0x54,0x38,0xb0,0x05,0x16,0x1}} }; -static const struct opl4_region regions_73[] = { /* Woodblock */ +static const opl4_region_t regions_73[] = { /* Woodblock */ {0x15, 0x6c, {0x02c,2963, 50, 0,0,0x07,0xd4,0x00,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_74[] = { /* Taiko Drum */ +static const opl4_region_t regions_74[] = { /* Taiko Drum */ {0x13, 0x6c, {0x03e,1194, 50, 0,0,0x00,0xaa,0x38,0xf0,0x04,0x04,0x0}} }; -static const struct opl4_region regions_75[] = { /* Melodic Tom */ +static const opl4_region_t regions_75[] = { /* Melodic Tom */ {0x15, 0x6c, {0x0c7,6418, 50, 0,0,0x00,0xe4,0x38,0xf0,0x05,0x01,0x0}} }; -static const struct opl4_region regions_76[] = { /* Synth Drum */ +static const opl4_region_t regions_76[] = { /* Synth Drum */ {0x15, 0x6c, {0x026,3898, 50, 0,0,0x00,0xd0,0x38,0xf0,0x04,0x04,0x0}} }; -static const struct opl4_region regions_77[] = { /* Reverse Cymbal */ +static const opl4_region_t regions_77[] = { /* Reverse Cymbal */ {0x15, 0x6c, {0x031,4138, 50, 0,0,0x00,0xfe,0x38,0x3a,0xf0,0x09,0x0}} }; -static const struct opl4_region regions_78[] = { /* Guitar Fret Noise */ +static const opl4_region_t regions_78[] = { /* Guitar Fret Noise */ {0x15, 0x6c, {0x138,5266,100, 0,0,0x00,0xa0,0x38,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_79[] = { /* Breath Noise */ +static const opl4_region_t regions_79[] = { /* Breath Noise */ {0x01, 0x7f, {0x125,4269,100, 0,0,0x1e,0xd0,0x38,0xf0,0x00,0x09,0x0}} }; -static const struct opl4_region regions_7a[] = { /* Seashore */ +static const opl4_region_t regions_7a[] = { /* Seashore */ {0x15, 0x6c, {0x008,2965, 20,-2,0,0x00,0xfe,0x00,0x20,0x03,0x04,0x0}}, {0x01, 0x7f, {0x037,4394, 20, 2,0,0x14,0xfe,0x00,0x20,0x04,0x05,0x0}} }; -static const struct opl4_region regions_7b[] = { /* Bird Tweet */ +static const opl4_region_t regions_7b[] = { /* Bird Tweet */ {0x15, 0x6c, {0x009,8078, 5,-4,7,0x00,0xc2,0x0f,0x22,0x12,0x07,0x0}}, {0x15, 0x6c, {0x009,3583, 5, 4,5,0x00,0xae,0x15,0x72,0x12,0x07,0x0}} }; -static const struct opl4_region regions_7c[] = { /* Telephone Ring */ +static const opl4_region_t regions_7c[] = { /* Telephone Ring */ {0x15, 0x6c, {0x003,3602, 10, 0,0,0x00,0xce,0x00,0xf0,0x00,0x0f,0x0}} }; -static const struct opl4_region regions_7d[] = { /* Helicopter */ +static const opl4_region_t regions_7d[] = { /* Helicopter */ {0x0c, 0x7f, {0x001,2965, 10,-2,0,0x00,0xe0,0x08,0x30,0x01,0x07,0x0}}, {0x01, 0x7f, {0x037,4394, 10, 2,0,0x44,0x76,0x00,0x30,0x01,0x07,0x0}} }; -static const struct opl4_region regions_7e[] = { /* Applause */ +static const opl4_region_t regions_7e[] = { /* Applause */ {0x15, 0x6c, {0x036,8273, 20,-6,7,0x00,0xc4,0x0f,0x70,0x01,0x05,0x0}}, {0x15, 0x6c, {0x036,8115, 5, 6,7,0x00,0xc6,0x07,0x70,0x01,0x05,0x0}} }; -static const struct opl4_region regions_7f[] = { /* Gun Shot */ +static const opl4_region_t regions_7f[] = { /* Gun Shot */ {0x15, 0x6c, {0x139,2858, 20, 0,0,0x00,0xbe,0x38,0xf0,0x03,0x00,0x0}} }; -static const struct opl4_region regions_drums[] = { +static const opl4_region_t regions_drums[] = { {0x18, 0x18, {0x0cb,6397,100, 3,0,0x00,0xf4,0x38,0xc9,0x1c,0x0c,0x0}}, {0x19, 0x19, {0x0c4,3714,100, 0,0,0x00,0xe0,0x00,0x97,0x19,0x09,0x0}}, {0x1a, 0x1a, {0x0c4,3519,100, 0,0,0x00,0xea,0x00,0x61,0x01,0x07,0x0}}, @@ -924,7 +924,7 @@ static const struct opl4_region regions_drums[] = { }; #define REGION(num) { ARRAY_SIZE(regions ## num), regions ## num } -const struct opl4_region_ptr snd_yrw801_regions[0x81] = { +const opl4_region_ptr_t snd_yrw801_regions[0x81] = { REGION(_00), REGION(_01), REGION(_02), REGION(_03), REGION(_04), REGION(_05), REGION(_06), REGION(_07), REGION(_08), REGION(_09), REGION(_0a), REGION(_0b), diff --git a/trunk/sound/drivers/serial-u16550.c b/trunk/sound/drivers/serial-u16550.c index 29676d800cae..1ed58df42671 100644 --- a/trunk/sound/drivers/serial-u16550.c +++ b/trunk/sound/drivers/serial-u16550.c @@ -33,8 +33,6 @@ #include <sound/driver.h> #include <linux/init.h> #include <linux/interrupt.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/slab.h> #include <linux/ioport.h> #include <linux/moduleparam.h> @@ -118,10 +116,10 @@ MODULE_PARM_DESC(adaptor, "Type of adaptor."); #define SERIAL_MODE_OUTPUT_TRIGGERED (1 << 3) typedef struct _snd_uart16550 { - struct snd_card *card; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *midi_output[SNDRV_SERIAL_MAX_OUTS]; - struct snd_rawmidi_substream *midi_input[SNDRV_SERIAL_MAX_INS]; + snd_card_t *card; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *midi_output[SNDRV_SERIAL_MAX_OUTS]; + snd_rawmidi_substream_t *midi_input[SNDRV_SERIAL_MAX_INS]; int filemode; //open status of file @@ -168,7 +166,7 @@ typedef struct _snd_uart16550 { } snd_uart16550_t; -static struct platform_device *devices[SNDRV_CARDS]; +static snd_card_t *snd_serial_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; static inline void snd_uart16550_add_timer(snd_uart16550_t *uart) { @@ -511,7 +509,7 @@ static void snd_uart16550_do_close(snd_uart16550_t * uart) } } -static int snd_uart16550_input_open(struct snd_rawmidi_substream *substream) +static int snd_uart16550_input_open(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_uart16550_t *uart = substream->rmidi->private_data; @@ -525,7 +523,7 @@ static int snd_uart16550_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_uart16550_input_close(struct snd_rawmidi_substream *substream) +static int snd_uart16550_input_close(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_uart16550_t *uart = substream->rmidi->private_data; @@ -539,7 +537,7 @@ static int snd_uart16550_input_close(struct snd_rawmidi_substream *substream) return 0; } -static void snd_uart16550_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_uart16550_input_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; snd_uart16550_t *uart = substream->rmidi->private_data; @@ -553,7 +551,7 @@ static void snd_uart16550_input_trigger(struct snd_rawmidi_substream *substream, spin_unlock_irqrestore(&uart->open_lock, flags); } -static int snd_uart16550_output_open(struct snd_rawmidi_substream *substream) +static int snd_uart16550_output_open(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_uart16550_t *uart = substream->rmidi->private_data; @@ -567,7 +565,7 @@ static int snd_uart16550_output_open(struct snd_rawmidi_substream *substream) return 0; }; -static int snd_uart16550_output_close(struct snd_rawmidi_substream *substream) +static int snd_uart16550_output_close(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_uart16550_t *uart = substream->rmidi->private_data; @@ -605,7 +603,7 @@ static inline int snd_uart16550_write_buffer(snd_uart16550_t *uart, unsigned cha return 0; } -static int snd_uart16550_output_byte(snd_uart16550_t *uart, struct snd_rawmidi_substream *substream, unsigned char midi_byte) +static int snd_uart16550_output_byte(snd_uart16550_t *uart, snd_rawmidi_substream_t * substream, unsigned char midi_byte) { if (uart->buff_in_count == 0 /* Buffer empty? */ && ((uart->adaptor != SNDRV_SERIAL_MS124W_SA && @@ -638,7 +636,7 @@ static int snd_uart16550_output_byte(snd_uart16550_t *uart, struct snd_rawmidi_s return 1; } -static void snd_uart16550_output_write(struct snd_rawmidi_substream *substream) +static void snd_uart16550_output_write(snd_rawmidi_substream_t * substream) { unsigned long flags; unsigned char midi_byte, addr_byte; @@ -717,7 +715,7 @@ static void snd_uart16550_output_write(struct snd_rawmidi_substream *substream) spin_unlock_irqrestore(&uart->open_lock, flags); } -static void snd_uart16550_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_uart16550_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; snd_uart16550_t *uart = substream->rmidi->private_data; @@ -733,14 +731,14 @@ static void snd_uart16550_output_trigger(struct snd_rawmidi_substream *substream snd_uart16550_output_write(substream); } -static struct snd_rawmidi_ops snd_uart16550_output = +static snd_rawmidi_ops_t snd_uart16550_output = { .open = snd_uart16550_output_open, .close = snd_uart16550_output_close, .trigger = snd_uart16550_output_trigger, }; -static struct snd_rawmidi_ops snd_uart16550_input = +static snd_rawmidi_ops_t snd_uart16550_input = { .open = snd_uart16550_input_open, .close = snd_uart16550_input_close, @@ -756,13 +754,13 @@ static int snd_uart16550_free(snd_uart16550_t *uart) return 0; }; -static int snd_uart16550_dev_free(struct snd_device *device) +static int snd_uart16550_dev_free(snd_device_t *device) { snd_uart16550_t *uart = device->device_data; return snd_uart16550_free(uart); } -static int __init snd_uart16550_create(struct snd_card *card, +static int __init snd_uart16550_create(snd_card_t * card, unsigned long iobase, int irq, unsigned int speed, @@ -771,7 +769,7 @@ static int __init snd_uart16550_create(struct snd_card *card, int droponfull, snd_uart16550_t **ruart) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_uart16550_dev_free, }; snd_uart16550_t *uart; @@ -840,19 +838,19 @@ static int __init snd_uart16550_create(struct snd_card *card, return 0; } -static void __init snd_uart16550_substreams(struct snd_rawmidi_str *stream) +static void __init snd_uart16550_substreams(snd_rawmidi_str_t *stream) { struct list_head *list; list_for_each(list, &stream->substreams) { - struct snd_rawmidi_substream *substream = list_entry(list, struct snd_rawmidi_substream, list); + snd_rawmidi_substream_t *substream = list_entry(list, snd_rawmidi_substream_t, list); sprintf(substream->name, "Serial MIDI %d", substream->number + 1); } } -static int __init snd_uart16550_rmidi(snd_uart16550_t *uart, int device, int outs, int ins, struct snd_rawmidi **rmidi) +static int __init snd_uart16550_rmidi(snd_uart16550_t *uart, int device, int outs, int ins, snd_rawmidi_t **rmidi) { - struct snd_rawmidi *rrawmidi; + snd_rawmidi_t *rrawmidi; int err; if ((err = snd_rawmidi_new(uart->card, "UART Serial MIDI", device, outs, ins, &rrawmidi)) < 0) @@ -871,12 +869,14 @@ static int __init snd_uart16550_rmidi(snd_uart16550_t *uart, int device, int out return 0; } -static int __init snd_serial_probe(struct platform_device *devptr) +static int __init snd_serial_probe(int dev) { - struct snd_card *card; + snd_card_t *card; snd_uart16550_t *uart; int err; - int dev = devptr->id; + + if (!enable[dev]) + return -ENOENT; switch (adaptor[dev]) { case SNDRV_SERIAL_SOUNDCANVAS: @@ -942,12 +942,13 @@ static int __init snd_serial_probe(struct platform_device *devptr) adaptor_names[uart->adaptor], uart->drop_on_full); - snd_card_set_dev(card, &devptr->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; - platform_set_drvdata(devptr, card); + snd_serial_cards[dev] = card; return 0; _err: @@ -955,68 +956,33 @@ static int __init snd_serial_probe(struct platform_device *devptr) return err; } -static int snd_serial_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define SND_SERIAL_DRIVER "snd_serial_u16550" - -static struct platform_driver snd_serial_driver = { - .probe = snd_serial_probe, - .remove = snd_serial_remove, - .driver = { - .name = SND_SERIAL_DRIVER - }, -}; - -static void __init_or_module snd_serial_unregister_all(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_serial_driver); -} - static int __init alsa_card_serial_init(void) { - int i, cards, err; - - if ((err = platform_driver_register(&snd_serial_driver)) < 0) - return err; + int dev = 0; + int cards = 0; - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(SND_SERIAL_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (snd_serial_probe(dev) == 0) + cards++; } - if (! cards) { + + if (cards == 0) { #ifdef MODULE printk(KERN_ERR "serial midi soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_serial_unregister_all(); - return err; } static void __exit alsa_card_serial_exit(void) { - snd_serial_unregister_all(); + int dev; + + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (snd_serial_cards[dev] != NULL) + snd_card_free(snd_serial_cards[dev]); + } } module_init(alsa_card_serial_init) diff --git a/trunk/sound/drivers/virmidi.c b/trunk/sound/drivers/virmidi.c index 4258723de2ab..af12185ab8a2 100644 --- a/trunk/sound/drivers/virmidi.c +++ b/trunk/sound/drivers/virmidi.c @@ -45,8 +45,6 @@ #include <linux/init.h> #include <linux/wait.h> #include <linux/sched.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/seq_kernel.h> @@ -61,7 +59,7 @@ MODULE_DESCRIPTION("Dummy soundcard for virtual rawmidi devices"); MODULE_LICENSE("GPL"); MODULE_SUPPORTED_DEVICE("{{ALSA,Virtual rawmidi device}}"); -#define MAX_MIDI_DEVICES 4 +#define MAX_MIDI_DEVICES 8 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ @@ -75,23 +73,24 @@ MODULE_PARM_DESC(id, "ID string for virmidi soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable this soundcard."); module_param_array(midi_devs, int, NULL, 0444); -MODULE_PARM_DESC(midi_devs, "MIDI devices # (1-4)"); +MODULE_PARM_DESC(midi_devs, "MIDI devices # (1-8)"); -struct snd_card_virmidi { - struct snd_card *card; - struct snd_rawmidi *midi[MAX_MIDI_DEVICES]; -}; +typedef struct snd_card_virmidi { + snd_card_t *card; + snd_rawmidi_t *midi[MAX_MIDI_DEVICES]; +} snd_card_virmidi_t; -static struct platform_device *devices[SNDRV_CARDS]; +static snd_card_t *snd_virmidi_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; -static int __init snd_virmidi_probe(struct platform_device *devptr) +static int __init snd_card_virmidi_probe(int dev) { - struct snd_card *card; + snd_card_t *card; struct snd_card_virmidi *vmidi; int idx, err; - int dev = devptr->id; + if (!enable[dev]) + return -ENODEV; card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_card_virmidi)); if (card == NULL) @@ -104,8 +103,8 @@ static int __init snd_virmidi_probe(struct platform_device *devptr) midi_devs[dev] = MAX_MIDI_DEVICES; } for (idx = 0; idx < midi_devs[dev]; idx++) { - struct snd_rawmidi *rmidi; - struct snd_virmidi_dev *rdev; + snd_rawmidi_t *rmidi; + snd_virmidi_dev_t *rdev; if ((err = snd_virmidi_new(card, idx, &rmidi)) < 0) goto __nodev; rdev = rmidi->private_data; @@ -118,10 +117,11 @@ static int __init snd_virmidi_probe(struct platform_device *devptr) strcpy(card->shortname, "VirMIDI"); sprintf(card->longname, "Virtual MIDI Card %i", dev + 1); - snd_card_set_dev(card, &devptr->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto __nodev; if ((err = snd_card_register(card)) == 0) { - platform_set_drvdata(devptr, card); + snd_virmidi_cards[dev] = card; return 0; } __nodev: @@ -129,68 +129,34 @@ static int __init snd_virmidi_probe(struct platform_device *devptr) return err; } -static int snd_virmidi_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define SND_VIRMIDI_DRIVER "snd_virmidi" - -static struct platform_driver snd_virmidi_driver = { - .probe = snd_virmidi_probe, - .remove = snd_virmidi_remove, - .driver = { - .name = SND_VIRMIDI_DRIVER - }, -}; - -static void __init_or_module snd_virmidi_unregister_all(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_virmidi_driver); -} - static int __init alsa_card_virmidi_init(void) { - int i, cards, err; - - if ((err = platform_driver_register(&snd_virmidi_driver)) < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(SND_VIRMIDI_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; + int dev, cards; + + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) { + if (snd_card_virmidi_probe(dev) < 0) { +#ifdef MODULE + printk(KERN_ERR "Card-VirMIDI #%i not found or device busy\n", dev + 1); +#endif + break; } - devices[i] = device; cards++; } if (!cards) { #ifdef MODULE printk(KERN_ERR "Card-VirMIDI soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_virmidi_unregister_all(); - return err; } static void __exit alsa_card_virmidi_exit(void) { - snd_virmidi_unregister_all(); + int dev; + + for (dev = 0; dev < SNDRV_CARDS; dev++) + snd_card_free(snd_virmidi_cards[dev]); } module_init(alsa_card_virmidi_init) diff --git a/trunk/sound/drivers/vx/vx_core.c b/trunk/sound/drivers/vx/vx_core.c index 43f615d7a545..4697b1d75cbb 100644 --- a/trunk/sound/drivers/vx/vx_core.c +++ b/trunk/sound/drivers/vx/vx_core.c @@ -40,6 +40,18 @@ MODULE_DESCRIPTION("Common routines for Digigram VX drivers"); MODULE_LICENSE("GPL"); +/* + * snd_vx_delay - delay for the specified time + * @xmsec: the time to delay in msec + */ +void snd_vx_delay(vx_core_t *chip, int xmsec) +{ + if (! in_interrupt() && xmsec >= 1000 / HZ) + msleep(xmsec); + else + mdelay(xmsec); +} + /* * vx_check_reg_bit - wait for the specified bit is set/reset on a register * @reg: register to check @@ -49,7 +61,7 @@ MODULE_LICENSE("GPL"); * * returns zero if a bit matches, or a negative error code. */ -int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int time) +int snd_vx_check_reg_bit(vx_core_t *chip, int reg, int mask, int bit, int time) { unsigned long end_time = jiffies + (time * HZ + 999) / 1000; #ifdef CONFIG_SND_DEBUG @@ -64,7 +76,7 @@ int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int t do { if ((snd_vx_inb(chip, reg) & mask) == bit) return 0; - //msleep(10); + //snd_vx_delay(chip, 10); } while (time_after_eq(end_time, jiffies)); snd_printd(KERN_DEBUG "vx_check_reg_bit: timeout, reg=%s, mask=0x%x, val=0x%x\n", reg_names[reg], mask, snd_vx_inb(chip, reg)); return -EIO; @@ -78,7 +90,7 @@ int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int t * returns 0 if successful, or a negative error code. * */ -static int vx_send_irq_dsp(struct vx_core *chip, int num) +static int vx_send_irq_dsp(vx_core_t *chip, int num) { int nirq; @@ -99,7 +111,7 @@ static int vx_send_irq_dsp(struct vx_core *chip, int num) * * returns 0 if successful, or a negative error code. */ -static int vx_reset_chk(struct vx_core *chip) +static int vx_reset_chk(vx_core_t *chip) { /* Reset irq CHK */ if (vx_send_irq_dsp(chip, IRQ_RESET_CHK) < 0) @@ -118,7 +130,7 @@ static int vx_reset_chk(struct vx_core *chip) * the error code can be VX-specific, retrieved via vx_get_error(). * NB: call with spinlock held! */ -static int vx_transfer_end(struct vx_core *chip, int cmd) +static int vx_transfer_end(vx_core_t *chip, int cmd) { int err; @@ -156,7 +168,7 @@ static int vx_transfer_end(struct vx_core *chip, int cmd) * the error code can be VX-specific, retrieved via vx_get_error(). * NB: call with spinlock held! */ -static int vx_read_status(struct vx_core *chip, struct vx_rmh *rmh) +static int vx_read_status(vx_core_t *chip, struct vx_rmh *rmh) { int i, err, val, size; @@ -236,7 +248,7 @@ static int vx_read_status(struct vx_core *chip, struct vx_rmh *rmh) * * this function doesn't call spinlock at all. */ -int vx_send_msg_nolock(struct vx_core *chip, struct vx_rmh *rmh) +int vx_send_msg_nolock(vx_core_t *chip, struct vx_rmh *rmh) { int i, err; @@ -341,7 +353,7 @@ int vx_send_msg_nolock(struct vx_core *chip, struct vx_rmh *rmh) * returns 0 if successful, or a negative error code. * see vx_send_msg_nolock(). */ -int vx_send_msg(struct vx_core *chip, struct vx_rmh *rmh) +int vx_send_msg(vx_core_t *chip, struct vx_rmh *rmh) { unsigned long flags; int err; @@ -364,7 +376,7 @@ int vx_send_msg(struct vx_core *chip, struct vx_rmh *rmh) * * unlike RMH, no command is sent to DSP. */ -int vx_send_rih_nolock(struct vx_core *chip, int cmd) +int vx_send_rih_nolock(vx_core_t *chip, int cmd) { int err; @@ -401,7 +413,7 @@ int vx_send_rih_nolock(struct vx_core *chip, int cmd) * * see vx_send_rih_nolock(). */ -int vx_send_rih(struct vx_core *chip, int cmd) +int vx_send_rih(vx_core_t *chip, int cmd) { unsigned long flags; int err; @@ -418,7 +430,7 @@ int vx_send_rih(struct vx_core *chip, int cmd) * snd_vx_boot_xilinx - boot up the xilinx interface * @boot: the boot record to load */ -int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *boot) +int snd_vx_load_boot_image(vx_core_t *chip, const struct firmware *boot) { unsigned int i; int no_fillup = vx_has_new_dsp(chip); @@ -470,7 +482,7 @@ int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *boot) * * called from irq handler only */ -static int vx_test_irq_src(struct vx_core *chip, unsigned int *ret) +static int vx_test_irq_src(vx_core_t *chip, unsigned int *ret) { int err; @@ -491,7 +503,7 @@ static int vx_test_irq_src(struct vx_core *chip, unsigned int *ret) */ static void vx_interrupt(unsigned long private_data) { - struct vx_core *chip = (struct vx_core *) private_data; + vx_core_t *chip = (vx_core_t *) private_data; unsigned int events; if (chip->chip_status & VX_STAT_IS_STALE) @@ -535,7 +547,7 @@ static void vx_interrupt(unsigned long private_data) */ irqreturn_t snd_vx_irq_handler(int irq, void *dev, struct pt_regs *regs) { - struct vx_core *chip = dev; + vx_core_t *chip = dev; if (! (chip->chip_status & VX_STAT_CHIP_INIT) || (chip->chip_status & VX_STAT_IS_STALE)) @@ -548,7 +560,7 @@ irqreturn_t snd_vx_irq_handler(int irq, void *dev, struct pt_regs *regs) /* */ -static void vx_reset_board(struct vx_core *chip, int cold_reset) +static void vx_reset_board(vx_core_t *chip, int cold_reset) { snd_assert(chip->ops->reset_board, return); @@ -587,9 +599,9 @@ static void vx_reset_board(struct vx_core *chip, int cold_reset) * proc interface */ -static void vx_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void vx_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct vx_core *chip = entry->private_data; + vx_core_t *chip = entry->private_data; static char *audio_src_vxp[] = { "Line", "Mic", "Digital" }; static char *audio_src_vx2[] = { "Analog", "Analog", "Digital" }; static char *clock_mode[] = { "Auto", "Internal", "External" }; @@ -630,9 +642,9 @@ static void vx_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *b chip->ibl.granularity); } -static void vx_proc_init(struct vx_core *chip) +static void vx_proc_init(vx_core_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "vx-status", &entry)) snd_info_set_text_ops(entry, chip, 1024, vx_proc_read); @@ -642,7 +654,7 @@ static void vx_proc_init(struct vx_core *chip) /** * snd_vx_dsp_boot - load the DSP boot */ -int snd_vx_dsp_boot(struct vx_core *chip, const struct firmware *boot) +int snd_vx_dsp_boot(vx_core_t *chip, const struct firmware *boot) { int err; int cold_reset = !(chip->chip_status & VX_STAT_DEVICE_INIT); @@ -652,7 +664,7 @@ int snd_vx_dsp_boot(struct vx_core *chip, const struct firmware *boot) if ((err = snd_vx_load_boot_image(chip, boot)) < 0) return err; - msleep(10); + snd_vx_delay(chip, 10); return 0; } @@ -660,7 +672,7 @@ int snd_vx_dsp_boot(struct vx_core *chip, const struct firmware *boot) /** * snd_vx_dsp_load - load the DSP image */ -int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp) +int snd_vx_dsp_load(vx_core_t *chip, const struct firmware *dsp) { unsigned int i; int err; @@ -692,7 +704,7 @@ int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp) } snd_printdd(KERN_DEBUG "checksum = 0x%08x\n", csum); - msleep(200); + snd_vx_delay(chip, 200); if ((err = vx_wait_isr_bit(chip, ISR_CHK)) < 0) return err; @@ -709,11 +721,13 @@ int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp) /* * suspend */ -int snd_vx_suspend(struct vx_core *chip, pm_message_t state) +static int snd_vx_suspend(snd_card_t *card, pm_message_t state) { + vx_core_t *chip = card->pm_private_data; unsigned int i; - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot); + snd_assert(chip, return -EINVAL); + chip->chip_status |= VX_STAT_IN_SUSPEND; for (i = 0; i < chip->hw->num_codecs; i++) snd_pcm_suspend_all(chip->pcm[i]); @@ -724,10 +738,13 @@ int snd_vx_suspend(struct vx_core *chip, pm_message_t state) /* * resume */ -int snd_vx_resume(struct vx_core *chip) +static int snd_vx_resume(snd_card_t *card) { + vx_core_t *chip = card->pm_private_data; int i, err; + snd_assert(chip, return -EINVAL); + chip->chip_status &= ~VX_STAT_CHIP_INIT; for (i = 0; i < 4; i++) { @@ -743,14 +760,13 @@ int snd_vx_resume(struct vx_core *chip) chip->chip_status |= VX_STAT_CHIP_INIT; chip->chip_status &= ~VX_STAT_IN_SUSPEND; - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0); return 0; } #endif /** - * snd_vx_create - constructor for struct vx_core + * snd_vx_create - constructor for vx_core_t * @hw: hardware specific record * * this function allocates the instance and prepare for the hardware @@ -758,11 +774,11 @@ int snd_vx_resume(struct vx_core *chip) * * return the instance pointer if successful, NULL in error. */ -struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw, - struct snd_vx_ops *ops, - int extra_size) +vx_core_t *snd_vx_create(snd_card_t *card, struct snd_vx_hardware *hw, + struct snd_vx_ops *ops, + int extra_size) { - struct vx_core *chip; + vx_core_t *chip; snd_assert(card && hw && ops, return NULL); @@ -785,6 +801,8 @@ struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw, strcpy(card->driver, hw->name); sprintf(card->shortname, "Digigram %s", hw->name); + snd_card_set_pm_callback(card, snd_vx_suspend, snd_vx_resume, chip); + vx_proc_init(chip); return chip; @@ -813,10 +831,7 @@ EXPORT_SYMBOL(snd_vx_create); EXPORT_SYMBOL(snd_vx_setup_firmware); EXPORT_SYMBOL(snd_vx_free_firmware); EXPORT_SYMBOL(snd_vx_irq_handler); +EXPORT_SYMBOL(snd_vx_delay); EXPORT_SYMBOL(snd_vx_dsp_boot); EXPORT_SYMBOL(snd_vx_dsp_load); EXPORT_SYMBOL(snd_vx_load_boot_image); -#ifdef CONFIG_PM -EXPORT_SYMBOL(snd_vx_suspend); -EXPORT_SYMBOL(snd_vx_resume); -#endif diff --git a/trunk/sound/drivers/vx/vx_hwdep.c b/trunk/sound/drivers/vx/vx_hwdep.c index d837783fb538..c4993b004c42 100644 --- a/trunk/sound/drivers/vx/vx_hwdep.c +++ b/trunk/sound/drivers/vx/vx_hwdep.c @@ -30,7 +30,7 @@ #ifdef SND_VX_FW_LOADER -int snd_vx_setup_firmware(struct vx_core *chip) +int snd_vx_setup_firmware(vx_core_t *chip) { static char *fw_files[VX_TYPE_NUMS][4] = { [VX_TYPE_BOARD] = { @@ -95,7 +95,7 @@ int snd_vx_setup_firmware(struct vx_core *chip) } /* exported */ -void snd_vx_free_firmware(struct vx_core *chip) +void snd_vx_free_firmware(vx_core_t *chip) { #ifdef CONFIG_PM int i; @@ -106,18 +106,17 @@ void snd_vx_free_firmware(struct vx_core *chip) #else /* old style firmware loading */ -static int vx_hwdep_open(struct snd_hwdep *hw, struct file *file) +static int vx_hwdep_open(snd_hwdep_t *hw, struct file *file) { return 0; } -static int vx_hwdep_release(struct snd_hwdep *hw, struct file *file) +static int vx_hwdep_release(snd_hwdep_t *hw, struct file *file) { return 0; } -static int vx_hwdep_dsp_status(struct snd_hwdep *hw, - struct snd_hwdep_dsp_status *info) +static int vx_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t *info) { static char *type_ids[VX_TYPE_NUMS] = { [VX_TYPE_BOARD] = "vxboard", @@ -126,7 +125,7 @@ static int vx_hwdep_dsp_status(struct snd_hwdep *hw, [VX_TYPE_VXPOCKET] = "vxpocket", [VX_TYPE_VXP440] = "vxp440", }; - struct vx_core *vx = hw->private_data; + vx_core_t *vx = hw->private_data; snd_assert(type_ids[vx->type], return -EINVAL); strcpy(info->id, type_ids[vx->type]); @@ -148,10 +147,9 @@ static void free_fw(const struct firmware *fw) } } -static int vx_hwdep_dsp_load(struct snd_hwdep *hw, - struct snd_hwdep_dsp_image *dsp) +static int vx_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp) { - struct vx_core *vx = hw->private_data; + vx_core_t *vx = hw->private_data; int index, err; struct firmware *fw; @@ -218,10 +216,10 @@ static int vx_hwdep_dsp_load(struct snd_hwdep *hw, /* exported */ -int snd_vx_setup_firmware(struct vx_core *chip) +int snd_vx_setup_firmware(vx_core_t *chip) { int err; - struct snd_hwdep *hw; + snd_hwdep_t *hw; if ((err = snd_hwdep_new(chip->card, SND_VX_HWDEP_ID, 0, &hw)) < 0) return err; @@ -240,7 +238,7 @@ int snd_vx_setup_firmware(struct vx_core *chip) } /* exported */ -void snd_vx_free_firmware(struct vx_core *chip) +void snd_vx_free_firmware(vx_core_t *chip) { #ifdef CONFIG_PM int i; diff --git a/trunk/sound/drivers/vx/vx_mixer.c b/trunk/sound/drivers/vx/vx_mixer.c index 8ec2c605d2f0..19fc68c23378 100644 --- a/trunk/sound/drivers/vx/vx_mixer.c +++ b/trunk/sound/drivers/vx/vx_mixer.c @@ -30,7 +30,7 @@ /* * write a codec data (24bit) */ -static void vx_write_codec_reg(struct vx_core *chip, int codec, unsigned int data) +static void vx_write_codec_reg(vx_core_t *chip, int codec, unsigned int data) { unsigned long flags; @@ -47,7 +47,7 @@ static void vx_write_codec_reg(struct vx_core *chip, int codec, unsigned int dat /* * Data type used to access the Codec */ -union vx_codec_data { +typedef union { u32 l; #ifdef SNDRV_BIG_ENDIAN struct w { @@ -72,7 +72,7 @@ union vx_codec_data { u8 hh; } b; #endif -}; +} vx_codec_data_t; #define SET_CDC_DATA_SEL(di,s) ((di).b.mh = (u8) (s)) #define SET_CDC_DATA_REG(di,r) ((di).b.ml = (u8) (r)) @@ -85,9 +85,9 @@ union vx_codec_data { * @reg: register index * @val: data value */ -static void vx_set_codec_reg(struct vx_core *chip, int codec, int reg, int val) +static void vx_set_codec_reg(vx_core_t *chip, int codec, int reg, int val) { - union vx_codec_data data; + vx_codec_data_t data; /* DAC control register */ SET_CDC_DATA_INIT(data); SET_CDC_DATA_REG(data, reg); @@ -102,7 +102,7 @@ static void vx_set_codec_reg(struct vx_core *chip, int codec, int reg, int val) * @left: left output level, 0 = mute * @right: right output level */ -static void vx_set_analog_output_level(struct vx_core *chip, int codec, int left, int right) +static void vx_set_analog_output_level(vx_core_t *chip, int codec, int left, int right) { left = chip->hw->output_level_max - left; right = chip->hw->output_level_max - right; @@ -126,7 +126,7 @@ static void vx_set_analog_output_level(struct vx_core *chip, int codec, int left #define DAC_ATTEN_MIN 0x08 #define DAC_ATTEN_MAX 0x38 -void vx_toggle_dac_mute(struct vx_core *chip, int mute) +void vx_toggle_dac_mute(vx_core_t *chip, int mute) { unsigned int i; for (i = 0; i < chip->hw->num_codecs; i++) { @@ -141,7 +141,7 @@ void vx_toggle_dac_mute(struct vx_core *chip, int mute) /* * vx_reset_codec - reset and initialize the codecs */ -void vx_reset_codec(struct vx_core *chip, int cold_reset) +void vx_reset_codec(vx_core_t *chip, int cold_reset) { unsigned int i; int port = chip->type >= VX_TYPE_VXPOCKET ? 0x75 : 0x65; @@ -175,7 +175,7 @@ void vx_reset_codec(struct vx_core *chip, int cold_reset) * change the audio input source * @src: the target source (VX_AUDIO_SRC_XXX) */ -static void vx_change_audio_source(struct vx_core *chip, int src) +static void vx_change_audio_source(vx_core_t *chip, int src) { unsigned long flags; @@ -192,7 +192,7 @@ static void vx_change_audio_source(struct vx_core *chip, int src) * change the audio source if necessary and possible * returns 1 if the source is actually changed. */ -int vx_sync_audio_source(struct vx_core *chip) +int vx_sync_audio_source(vx_core_t *chip) { if (chip->audio_source_target == chip->audio_source || chip->pcm_running) @@ -217,7 +217,7 @@ struct vx_audio_level { short monitor_level; }; -static int vx_adjust_audio_level(struct vx_core *chip, int audio, int capture, +static int vx_adjust_audio_level(vx_core_t *chip, int audio, int capture, struct vx_audio_level *info) { struct vx_rmh rmh; @@ -256,7 +256,7 @@ static int vx_adjust_audio_level(struct vx_core *chip, int audio, int capture, #if 0 // not used -static int vx_read_audio_level(struct vx_core *chip, int audio, int capture, +static int vx_read_audio_level(vx_core_t *chip, int audio, int capture, struct vx_audio_level *info) { int err; @@ -283,7 +283,7 @@ static int vx_read_audio_level(struct vx_core *chip, int audio, int capture, * set the monitoring level and mute state of the given audio * no more static, because must be called from vx_pcm to demute monitoring */ -int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active) +int vx_set_monitor_level(vx_core_t *chip, int audio, int level, int active) { struct vx_audio_level info; @@ -301,7 +301,7 @@ int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active) /* * set the mute status of the given audio */ -static int vx_set_audio_switch(struct vx_core *chip, int audio, int active) +static int vx_set_audio_switch(vx_core_t *chip, int audio, int active) { struct vx_audio_level info; @@ -315,7 +315,7 @@ static int vx_set_audio_switch(struct vx_core *chip, int audio, int active) /* * set the mute status of the given audio */ -static int vx_set_audio_gain(struct vx_core *chip, int audio, int capture, int level) +static int vx_set_audio_gain(vx_core_t *chip, int audio, int capture, int level) { struct vx_audio_level info; @@ -329,7 +329,7 @@ static int vx_set_audio_gain(struct vx_core *chip, int audio, int capture, int l /* * reset all audio levels */ -static void vx_reset_audio_levels(struct vx_core *chip) +static void vx_reset_audio_levels(vx_core_t *chip) { unsigned int i, c; struct vx_audio_level info; @@ -375,7 +375,7 @@ struct vx_vu_meter { * @capture: 0 = playback, 1 = capture operation * @info: the array of vx_vu_meter records (size = 2). */ -static int vx_get_audio_vu_meter(struct vx_core *chip, int audio, int capture, struct vx_vu_meter *info) +static int vx_get_audio_vu_meter(vx_core_t *chip, int audio, int capture, struct vx_vu_meter *info) { struct vx_rmh rmh; int i, err; @@ -413,9 +413,9 @@ static int vx_get_audio_vu_meter(struct vx_core *chip, int audio, int capture, s /* * output level control */ -static int vx_output_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_output_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; @@ -423,9 +423,9 @@ static int vx_output_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int vx_output_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_output_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int codec = kcontrol->id.index; down(&chip->mixer_mutex); ucontrol->value.integer.value[0] = chip->output_level[codec][0]; @@ -434,9 +434,9 @@ static int vx_output_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int vx_output_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_output_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int codec = kcontrol->id.index; down(&chip->mixer_mutex); if (ucontrol->value.integer.value[0] != chip->output_level[codec][0] || @@ -453,7 +453,7 @@ static int vx_output_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static struct snd_kcontrol_new vx_control_output_level = { +static snd_kcontrol_new_t vx_control_output_level = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Volume", .info = vx_output_level_info, @@ -464,7 +464,7 @@ static struct snd_kcontrol_new vx_control_output_level = { /* * audio source select */ -static int vx_audio_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_audio_src_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts_mic[3] = { "Digital", "Line", "Mic" @@ -472,7 +472,7 @@ static int vx_audio_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ static char *texts_vx2[2] = { "Digital", "Analog" }; - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -492,16 +492,16 @@ static int vx_audio_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_audio_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_src_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = chip->audio_source_target; return 0; } -static int vx_audio_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_src_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); down(&chip->mixer_mutex); if (chip->audio_source_target != ucontrol->value.enumerated.item[0]) { chip->audio_source_target = ucontrol->value.enumerated.item[0]; @@ -513,7 +513,7 @@ static int vx_audio_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return 0; } -static struct snd_kcontrol_new vx_control_audio_src = { +static snd_kcontrol_new_t vx_control_audio_src = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Source", .info = vx_audio_src_info, @@ -524,7 +524,7 @@ static struct snd_kcontrol_new vx_control_audio_src = { /* * clock mode selection */ -static int vx_clock_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_clock_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[3] = { "Auto", "Internal", "External" @@ -540,16 +540,16 @@ static int vx_clock_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int vx_clock_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_clock_mode_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = chip->clock_mode; return 0; } -static int vx_clock_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_clock_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); down(&chip->mixer_mutex); if (chip->clock_mode != ucontrol->value.enumerated.item[0]) { chip->clock_mode = ucontrol->value.enumerated.item[0]; @@ -561,7 +561,7 @@ static int vx_clock_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static struct snd_kcontrol_new vx_control_clock_mode = { +static snd_kcontrol_new_t vx_control_clock_mode = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Clock Mode", .info = vx_clock_mode_info, @@ -572,7 +572,7 @@ static struct snd_kcontrol_new vx_control_clock_mode = { /* * Audio Gain */ -static int vx_audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_audio_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -581,9 +581,9 @@ static int vx_audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int vx_audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; int capture = (kcontrol->private_value >> 8) & 1; @@ -594,9 +594,9 @@ static int vx_audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; int capture = (kcontrol->private_value >> 8) & 1; @@ -612,9 +612,9 @@ static int vx_audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_audio_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_monitor_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; down(&chip->mixer_mutex); @@ -624,9 +624,9 @@ static int vx_audio_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int vx_audio_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_monitor_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; down(&chip->mixer_mutex); @@ -643,7 +643,7 @@ static int vx_audio_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int vx_audio_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_audio_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -652,9 +652,9 @@ static int vx_audio_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_i return 0; } -static int vx_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; down(&chip->mixer_mutex); @@ -664,9 +664,9 @@ static int vx_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va return 0; } -static int vx_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_audio_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; down(&chip->mixer_mutex); @@ -681,9 +681,9 @@ static int vx_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va return 0; } -static int vx_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_monitor_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; down(&chip->mixer_mutex); @@ -693,9 +693,9 @@ static int vx_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_monitor_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); int audio = kcontrol->private_value & 0xff; down(&chip->mixer_mutex); @@ -712,28 +712,28 @@ static int vx_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static struct snd_kcontrol_new vx_control_audio_gain = { +static snd_kcontrol_new_t vx_control_audio_gain = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, /* name will be filled later */ .info = vx_audio_gain_info, .get = vx_audio_gain_get, .put = vx_audio_gain_put }; -static struct snd_kcontrol_new vx_control_output_switch = { +static snd_kcontrol_new_t vx_control_output_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Switch", .info = vx_audio_sw_info, .get = vx_audio_sw_get, .put = vx_audio_sw_put }; -static struct snd_kcontrol_new vx_control_monitor_gain = { +static snd_kcontrol_new_t vx_control_monitor_gain = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitoring Volume", .info = vx_audio_gain_info, /* shared */ .get = vx_audio_monitor_get, .put = vx_audio_monitor_put }; -static struct snd_kcontrol_new vx_control_monitor_switch = { +static snd_kcontrol_new_t vx_control_monitor_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitoring Switch", .info = vx_audio_sw_info, /* shared */ @@ -745,16 +745,16 @@ static struct snd_kcontrol_new vx_control_monitor_switch = { /* * IEC958 status bits */ -static int vx_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_iec958_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int vx_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_iec958_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); down(&chip->mixer_mutex); ucontrol->value.iec958.status[0] = (chip->uer_bits >> 0) & 0xff; @@ -765,7 +765,7 @@ static int vx_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu return 0; } -static int vx_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_iec958_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -774,9 +774,9 @@ static int vx_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int vx_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_iec958_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); unsigned int val; val = (ucontrol->value.iec958.status[0] << 0) | @@ -794,7 +794,7 @@ static int vx_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu return 0; } -static struct snd_kcontrol_new vx_control_iec958_mask = { +static snd_kcontrol_new_t vx_control_iec958_mask = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), @@ -802,7 +802,7 @@ static struct snd_kcontrol_new vx_control_iec958_mask = { .get = vx_iec958_mask_get, }; -static struct snd_kcontrol_new vx_control_iec958 = { +static snd_kcontrol_new_t vx_control_iec958 = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), .info = vx_iec958_info, @@ -818,7 +818,7 @@ static struct snd_kcontrol_new vx_control_iec958 = { #define METER_MAX 0xff #define METER_SHIFT 16 -static int vx_vu_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_vu_meter_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -827,9 +827,9 @@ static int vx_vu_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_i return 0; } -static int vx_vu_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_vu_meter_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); struct vx_vu_meter meter[2]; int audio = kcontrol->private_value & 0xff; int capture = (kcontrol->private_value >> 8) & 1; @@ -840,9 +840,9 @@ static int vx_vu_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va return 0; } -static int vx_peak_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_peak_meter_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); struct vx_vu_meter meter[2]; int audio = kcontrol->private_value & 0xff; int capture = (kcontrol->private_value >> 8) & 1; @@ -853,7 +853,7 @@ static int vx_peak_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_saturation_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_saturation_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -862,9 +862,9 @@ static int vx_saturation_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int vx_saturation_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_saturation_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *chip = snd_kcontrol_chip(kcontrol); + vx_core_t *chip = snd_kcontrol_chip(kcontrol); struct vx_vu_meter meter[2]; int audio = kcontrol->private_value & 0xff; @@ -874,7 +874,7 @@ static int vx_saturation_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static struct snd_kcontrol_new vx_control_vu_meter = { +static snd_kcontrol_new_t vx_control_vu_meter = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, /* name will be filled later */ @@ -882,7 +882,7 @@ static struct snd_kcontrol_new vx_control_vu_meter = { .get = vx_vu_meter_get, }; -static struct snd_kcontrol_new vx_control_peak_meter = { +static snd_kcontrol_new_t vx_control_peak_meter = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, /* name will be filled later */ @@ -890,7 +890,7 @@ static struct snd_kcontrol_new vx_control_peak_meter = { .get = vx_peak_meter_get, }; -static struct snd_kcontrol_new vx_control_saturation = { +static snd_kcontrol_new_t vx_control_saturation = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Input Saturation", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, @@ -904,12 +904,12 @@ static struct snd_kcontrol_new vx_control_saturation = { * */ -int snd_vx_mixer_new(struct vx_core *chip) +int snd_vx_mixer_new(vx_core_t *chip) { unsigned int i, c; int err; - struct snd_kcontrol_new temp; - struct snd_card *card = chip->card; + snd_kcontrol_new_t temp; + snd_card_t *card = chip->card; char name[32]; strcpy(card->mixername, card->driver); diff --git a/trunk/sound/drivers/vx/vx_pcm.c b/trunk/sound/drivers/vx/vx_pcm.c index 464109e421d4..2b46758fe86f 100644 --- a/trunk/sound/drivers/vx/vx_pcm.c +++ b/trunk/sound/drivers/vx/vx_pcm.c @@ -61,8 +61,7 @@ */ /* get the physical page pointer on the given offset */ -static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, - unsigned long offset) +static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs, unsigned long offset) { void *pageptr = subs->runtime->dma_area + offset; return vmalloc_to_page(pageptr); @@ -73,9 +72,9 @@ static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, * called from hw_params * NOTE: this may be called not only once per pcm open! */ -static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size) +static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size) { - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (runtime->dma_area) { /* already allocated */ if (runtime->dma_bytes >= size) @@ -95,9 +94,9 @@ static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t s * called from hw_free callback * NOTE: this may be called not only once per pcm open! */ -static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs) +static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (runtime->dma_area) { vfree(runtime->dma_area); runtime->dma_area = NULL; @@ -109,8 +108,7 @@ static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs) /* * read three pending pcm bytes via inb() */ -static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe) +static void vx_pcm_read_per_bytes(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe) { int offset = pipe->hw_ptr; unsigned char *buf = (unsigned char *)(runtime->dma_area + offset); @@ -137,8 +135,7 @@ static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime * * @pc_time: the pointer for the PC-time to set * @dsp_time: the pointer for RMH status time array */ -static void vx_set_pcx_time(struct vx_core *chip, pcx_time_t *pc_time, - unsigned int *dsp_time) +static void vx_set_pcx_time(vx_core_t *chip, pcx_time_t *pc_time, unsigned int *dsp_time) { dsp_time[0] = (unsigned int)((*pc_time) >> 24) & PCX_TIME_HI_MASK; dsp_time[1] = (unsigned int)(*pc_time) & MASK_DSP_WORD; @@ -154,8 +151,7 @@ static void vx_set_pcx_time(struct vx_core *chip, pcx_time_t *pc_time, * * returns the increase of the command length. */ -static int vx_set_differed_time(struct vx_core *chip, struct vx_rmh *rmh, - struct vx_pipe *pipe) +static int vx_set_differed_time(vx_core_t *chip, struct vx_rmh *rmh, vx_pipe_t *pipe) { /* Update The length added to the RMH command by the timestamp */ if (! (pipe->differed_type & DC_DIFFERED_DELAY)) @@ -188,8 +184,7 @@ static int vx_set_differed_time(struct vx_core *chip, struct vx_rmh *rmh, * @pipe: the affected pipe * @data: format bitmask */ -static int vx_set_stream_format(struct vx_core *chip, struct vx_pipe *pipe, - unsigned int data) +static int vx_set_stream_format(vx_core_t *chip, vx_pipe_t *pipe, unsigned int data) { struct vx_rmh rmh; @@ -215,8 +210,8 @@ static int vx_set_stream_format(struct vx_core *chip, struct vx_pipe *pipe, * * returns 0 if successful, or a negative error code. */ -static int vx_set_format(struct vx_core *chip, struct vx_pipe *pipe, - struct snd_pcm_runtime *runtime) +static int vx_set_format(vx_core_t *chip, vx_pipe_t *pipe, + snd_pcm_runtime_t *runtime) { unsigned int header = HEADER_FMT_BASE; @@ -244,7 +239,7 @@ static int vx_set_format(struct vx_core *chip, struct vx_pipe *pipe, /* * set / query the IBL size */ -static int vx_set_ibl(struct vx_core *chip, struct vx_ibl_info *info) +static int vx_set_ibl(vx_core_t *chip, struct vx_ibl_info *info) { int err; struct vx_rmh rmh; @@ -274,7 +269,7 @@ static int vx_set_ibl(struct vx_core *chip, struct vx_ibl_info *info) * * called from trigger callback only */ -static int vx_get_pipe_state(struct vx_core *chip, struct vx_pipe *pipe, int *state) +static int vx_get_pipe_state(vx_core_t *chip, vx_pipe_t *pipe, int *state) { int err; struct vx_rmh rmh; @@ -299,7 +294,7 @@ static int vx_get_pipe_state(struct vx_core *chip, struct vx_pipe *pipe, int *st * you'll need to disconnect the host to get back to the * normal mode. */ -static int vx_query_hbuffer_size(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_query_hbuffer_size(vx_core_t *chip, vx_pipe_t *pipe) { int result; struct vx_rmh rmh; @@ -323,7 +318,7 @@ static int vx_query_hbuffer_size(struct vx_core *chip, struct vx_pipe *pipe) * * called from trigger callback only */ -static int vx_pipe_can_start(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_pipe_can_start(vx_core_t *chip, vx_pipe_t *pipe) { int err; struct vx_rmh rmh; @@ -344,7 +339,7 @@ static int vx_pipe_can_start(struct vx_core *chip, struct vx_pipe *pipe) * vx_conf_pipe - tell the pipe to stand by and wait for IRQA. * @pipe: the pipe to be configured */ -static int vx_conf_pipe(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_conf_pipe(vx_core_t *chip, vx_pipe_t *pipe) { struct vx_rmh rmh; @@ -358,7 +353,7 @@ static int vx_conf_pipe(struct vx_core *chip, struct vx_pipe *pipe) /* * vx_send_irqa - trigger IRQA */ -static int vx_send_irqa(struct vx_core *chip) +static int vx_send_irqa(vx_core_t *chip) { struct vx_rmh rmh; @@ -383,7 +378,7 @@ static int vx_send_irqa(struct vx_core *chip) * called from trigger callback only * */ -static int vx_toggle_pipe(struct vx_core *chip, struct vx_pipe *pipe, int state) +static int vx_toggle_pipe(vx_core_t *chip, vx_pipe_t *pipe, int state) { int err, i, cur_state; @@ -436,7 +431,7 @@ static int vx_toggle_pipe(struct vx_core *chip, struct vx_pipe *pipe, int state) * * called from trigger callback only */ -static int vx_stop_pipe(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_stop_pipe(vx_core_t *chip, vx_pipe_t *pipe) { struct vx_rmh rmh; vx_init_rmh(&rmh, CMD_STOP_PIPE); @@ -454,12 +449,12 @@ static int vx_stop_pipe(struct vx_core *chip, struct vx_pipe *pipe) * * return 0 on success, or a negative error code. */ -static int vx_alloc_pipe(struct vx_core *chip, int capture, +static int vx_alloc_pipe(vx_core_t *chip, int capture, int audioid, int num_audio, - struct vx_pipe **pipep) + vx_pipe_t **pipep) { int err; - struct vx_pipe *pipe; + vx_pipe_t *pipe; struct vx_rmh rmh; int data_mode; @@ -504,7 +499,7 @@ static int vx_alloc_pipe(struct vx_core *chip, int capture, * vx_free_pipe - release a pipe * @pipe: pipe to be released */ -static int vx_free_pipe(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_free_pipe(vx_core_t *chip, vx_pipe_t *pipe) { struct vx_rmh rmh; @@ -522,7 +517,7 @@ static int vx_free_pipe(struct vx_core *chip, struct vx_pipe *pipe) * * called from trigger callback only */ -static int vx_start_stream(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_start_stream(vx_core_t *chip, vx_pipe_t *pipe) { struct vx_rmh rmh; @@ -538,7 +533,7 @@ static int vx_start_stream(struct vx_core *chip, struct vx_pipe *pipe) * * called from trigger callback only */ -static int vx_stop_stream(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_stop_stream(vx_core_t *chip, vx_pipe_t *pipe) { struct vx_rmh rmh; @@ -552,12 +547,11 @@ static int vx_stop_stream(struct vx_core *chip, struct vx_pipe *pipe) * playback hw information */ -static struct snd_pcm_hardware vx_pcm_playback_hw = { +static snd_pcm_hardware_t vx_pcm_playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/ /*SNDRV_PCM_INFO_RESUME*/), - .formats = (/*SNDRV_PCM_FMTBIT_U8 |*/ - SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE), + .formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, .rate_min = 5000, .rate_max = 48000, @@ -577,11 +571,11 @@ static void vx_pcm_delayed_start(unsigned long arg); /* * vx_pcm_playback_open - open callback for playback */ -static int vx_pcm_playback_open(struct snd_pcm_substream *subs) +static int vx_pcm_playback_open(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; - struct vx_core *chip = snd_pcm_substream_chip(subs); - struct vx_pipe *pipe = NULL; + snd_pcm_runtime_t *runtime = subs->runtime; + vx_core_t *chip = snd_pcm_substream_chip(subs); + vx_pipe_t *pipe = NULL; unsigned int audio; int err; @@ -621,10 +615,10 @@ static int vx_pcm_playback_open(struct snd_pcm_substream *subs) /* * vx_pcm_playback_close - close callback for playback */ -static int vx_pcm_playback_close(struct snd_pcm_substream *subs) +static int vx_pcm_playback_close(snd_pcm_substream_t *subs) { - struct vx_core *chip = snd_pcm_substream_chip(subs); - struct vx_pipe *pipe; + vx_core_t *chip = snd_pcm_substream_chip(subs); + vx_pipe_t *pipe; if (! subs->runtime->private_data) return -EINVAL; @@ -647,7 +641,7 @@ static int vx_pcm_playback_close(struct snd_pcm_substream *subs) * * NB: call with a certain lock. */ -static int vx_notify_end_of_buffer(struct vx_core *chip, struct vx_pipe *pipe) +static int vx_notify_end_of_buffer(vx_core_t *chip, vx_pipe_t *pipe) { int err; struct vx_rmh rmh; /* use a temporary rmh here */ @@ -675,9 +669,7 @@ static int vx_notify_end_of_buffer(struct vx_core *chip, struct vx_pipe *pipe) * * return 0 if ok. */ -static int vx_pcm_playback_transfer_chunk(struct vx_core *chip, - struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int size) +static int vx_pcm_playback_transfer_chunk(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe, int size) { int space, err = 0; @@ -713,9 +705,7 @@ static int vx_pcm_playback_transfer_chunk(struct vx_core *chip, * so that the caller can check the total transferred size later * (to call snd_pcm_period_elapsed). */ -static int vx_update_pipe_position(struct vx_core *chip, - struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe) +static int vx_update_pipe_position(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe) { struct vx_rmh rmh; int err, update; @@ -741,12 +731,10 @@ static int vx_update_pipe_position(struct vx_core *chip, * transfer the pending playback buffer data to DSP * called from interrupt handler */ -static void vx_pcm_playback_transfer(struct vx_core *chip, - struct snd_pcm_substream *subs, - struct vx_pipe *pipe, int nchunks) +static void vx_pcm_playback_transfer(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe, int nchunks) { int i, err; - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE)) return; @@ -761,12 +749,10 @@ static void vx_pcm_playback_transfer(struct vx_core *chip, * update the playback position and call snd_pcm_period_elapsed() if necessary * called from interrupt handler */ -static void vx_pcm_playback_update(struct vx_core *chip, - struct snd_pcm_substream *subs, - struct vx_pipe *pipe) +static void vx_pcm_playback_update(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe) { int err; - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (pipe->running && ! (chip->chip_status & VX_STAT_IS_STALE)) { if ((err = vx_update_pipe_position(chip, runtime, pipe)) < 0) @@ -785,9 +771,9 @@ static void vx_pcm_playback_update(struct vx_core *chip, */ static void vx_pcm_delayed_start(unsigned long arg) { - struct snd_pcm_substream *subs = (struct snd_pcm_substream *)arg; - struct vx_core *chip = subs->pcm->private_data; - struct vx_pipe *pipe = subs->runtime->private_data; + snd_pcm_substream_t *subs = (snd_pcm_substream_t *)arg; + vx_core_t *chip = subs->pcm->private_data; + vx_pipe_t *pipe = subs->runtime->private_data; int err; /* printk( KERN_DEBUG "DDDD tasklet delayed start jiffies = %ld\n", jiffies);*/ @@ -806,10 +792,10 @@ static void vx_pcm_delayed_start(unsigned long arg) /* * vx_pcm_playback_trigger - trigger callback for playback */ -static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd) +static int vx_pcm_trigger(snd_pcm_substream_t *subs, int cmd) { - struct vx_core *chip = snd_pcm_substream_chip(subs); - struct vx_pipe *pipe = subs->runtime->private_data; + vx_core_t *chip = snd_pcm_substream_chip(subs); + vx_pipe_t *pipe = subs->runtime->private_data; int err; if (chip->chip_status & VX_STAT_IS_STALE) @@ -853,18 +839,18 @@ static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd) /* * vx_pcm_playback_pointer - pointer callback for playback */ -static snd_pcm_uframes_t vx_pcm_playback_pointer(struct snd_pcm_substream *subs) +static snd_pcm_uframes_t vx_pcm_playback_pointer(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; - struct vx_pipe *pipe = runtime->private_data; + snd_pcm_runtime_t *runtime = subs->runtime; + vx_pipe_t *pipe = runtime->private_data; return pipe->position; } /* * vx_pcm_hw_params - hw_params callback for playback and capture */ -static int vx_pcm_hw_params(struct snd_pcm_substream *subs, - struct snd_pcm_hw_params *hw_params) +static int vx_pcm_hw_params(snd_pcm_substream_t *subs, + snd_pcm_hw_params_t *hw_params) { return snd_pcm_alloc_vmalloc_buffer(subs, params_buffer_bytes(hw_params)); } @@ -872,7 +858,7 @@ static int vx_pcm_hw_params(struct snd_pcm_substream *subs, /* * vx_pcm_hw_free - hw_free callback for playback and capture */ -static int vx_pcm_hw_free(struct snd_pcm_substream *subs) +static int vx_pcm_hw_free(snd_pcm_substream_t *subs) { return snd_pcm_free_vmalloc_buffer(subs); } @@ -880,11 +866,11 @@ static int vx_pcm_hw_free(struct snd_pcm_substream *subs) /* * vx_pcm_prepare - prepare callback for playback and capture */ -static int vx_pcm_prepare(struct snd_pcm_substream *subs) +static int vx_pcm_prepare(snd_pcm_substream_t *subs) { - struct vx_core *chip = snd_pcm_substream_chip(subs); - struct snd_pcm_runtime *runtime = subs->runtime; - struct vx_pipe *pipe = runtime->private_data; + vx_core_t *chip = snd_pcm_substream_chip(subs); + snd_pcm_runtime_t *runtime = subs->runtime; + vx_pipe_t *pipe = runtime->private_data; int err, data_mode; // int max_size, nchunks; @@ -911,8 +897,7 @@ static int vx_pcm_prepare(struct snd_pcm_substream *subs) } if (chip->pcm_running && chip->freq != runtime->rate) { - snd_printk(KERN_ERR "vx: cannot set different clock %d " - "from the current %d\n", runtime->rate, chip->freq); + snd_printk(KERN_ERR "vx: cannot set different clock %d from the current %d\n", runtime->rate, chip->freq); return -EINVAL; } vx_set_clock(chip, runtime->rate); @@ -945,7 +930,7 @@ static int vx_pcm_prepare(struct snd_pcm_substream *subs) /* * operators for PCM playback */ -static struct snd_pcm_ops vx_pcm_playback_ops = { +static snd_pcm_ops_t vx_pcm_playback_ops = { .open = vx_pcm_playback_open, .close = vx_pcm_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -962,12 +947,11 @@ static struct snd_pcm_ops vx_pcm_playback_ops = { * playback hw information */ -static struct snd_pcm_hardware vx_pcm_capture_hw = { +static snd_pcm_hardware_t vx_pcm_capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/ /*SNDRV_PCM_INFO_RESUME*/), - .formats = (/*SNDRV_PCM_FMTBIT_U8 |*/ - SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE), + .formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, .rate_min = 5000, .rate_max = 48000, @@ -985,12 +969,12 @@ static struct snd_pcm_hardware vx_pcm_capture_hw = { /* * vx_pcm_capture_open - open callback for capture */ -static int vx_pcm_capture_open(struct snd_pcm_substream *subs) +static int vx_pcm_capture_open(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; - struct vx_core *chip = snd_pcm_substream_chip(subs); - struct vx_pipe *pipe; - struct vx_pipe *pipe_out_monitoring = NULL; + snd_pcm_runtime_t *runtime = subs->runtime; + vx_core_t *chip = snd_pcm_substream_chip(subs); + vx_pipe_t *pipe; + vx_pipe_t *pipe_out_monitoring = NULL; unsigned int audio; int err; @@ -1021,11 +1005,9 @@ static int vx_pcm_capture_open(struct snd_pcm_substream *subs) if an output pipe is available, it's audios still may need to be unmuted. hence we'll have to call a mixer entry point. */ - vx_set_monitor_level(chip, audio, chip->audio_monitor[audio], - chip->audio_monitor_active[audio]); + vx_set_monitor_level(chip, audio, chip->audio_monitor[audio], chip->audio_monitor_active[audio]); /* assuming stereo */ - vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1], - chip->audio_monitor_active[audio+1]); + vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1], chip->audio_monitor_active[audio+1]); } pipe->monitoring_pipe = pipe_out_monitoring; /* default value NULL */ @@ -1044,11 +1026,11 @@ static int vx_pcm_capture_open(struct snd_pcm_substream *subs) /* * vx_pcm_capture_close - close callback for capture */ -static int vx_pcm_capture_close(struct snd_pcm_substream *subs) +static int vx_pcm_capture_close(snd_pcm_substream_t *subs) { - struct vx_core *chip = snd_pcm_substream_chip(subs); - struct vx_pipe *pipe; - struct vx_pipe *pipe_out_monitoring; + vx_core_t *chip = snd_pcm_substream_chip(subs); + vx_pipe_t *pipe; + vx_pipe_t *pipe_out_monitoring; if (! subs->runtime->private_data) return -EINVAL; @@ -1080,11 +1062,10 @@ static int vx_pcm_capture_close(struct snd_pcm_substream *subs) /* * vx_pcm_capture_update - update the capture buffer */ -static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream *subs, - struct vx_pipe *pipe) +static void vx_pcm_capture_update(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe) { int size, space, count; - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE)) return; @@ -1154,17 +1135,17 @@ static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream /* * vx_pcm_capture_pointer - pointer callback for capture */ -static snd_pcm_uframes_t vx_pcm_capture_pointer(struct snd_pcm_substream *subs) +static snd_pcm_uframes_t vx_pcm_capture_pointer(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; - struct vx_pipe *pipe = runtime->private_data; + snd_pcm_runtime_t *runtime = subs->runtime; + vx_pipe_t *pipe = runtime->private_data; return bytes_to_frames(runtime, pipe->hw_ptr); } /* * operators for PCM capture */ -static struct snd_pcm_ops vx_pcm_capture_ops = { +static snd_pcm_ops_t vx_pcm_capture_ops = { .open = vx_pcm_capture_open, .close = vx_pcm_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1180,10 +1161,10 @@ static struct snd_pcm_ops vx_pcm_capture_ops = { /* * interrupt handler for pcm streams */ -void vx_pcm_update_intr(struct vx_core *chip, unsigned int events) +void vx_pcm_update_intr(vx_core_t *chip, unsigned int events) { unsigned int i; - struct vx_pipe *pipe; + vx_pipe_t *pipe; #define EVENT_MASK (END_OF_BUFFER_EVENTS_PENDING|ASYNC_EVENTS_PENDING) @@ -1237,7 +1218,7 @@ void vx_pcm_update_intr(struct vx_core *chip, unsigned int events) /* * vx_init_audio_io - check the availabe audio i/o and allocate pipe arrays */ -static int vx_init_audio_io(struct vx_core *chip) +static int vx_init_audio_io(vx_core_t *chip) { struct vx_rmh rmh; int preferred; @@ -1253,20 +1234,19 @@ static int vx_init_audio_io(struct vx_core *chip) chip->audio_info = rmh.Stat[1]; /* allocate pipes */ - chip->playback_pipes = kmalloc(sizeof(struct vx_pipe *) * chip->audio_outs, GFP_KERNEL); - chip->capture_pipes = kmalloc(sizeof(struct vx_pipe *) * chip->audio_ins, GFP_KERNEL); + chip->playback_pipes = kmalloc(sizeof(vx_pipe_t *) * chip->audio_outs, GFP_KERNEL); + chip->capture_pipes = kmalloc(sizeof(vx_pipe_t *) * chip->audio_ins, GFP_KERNEL); if (! chip->playback_pipes || ! chip->capture_pipes) return -ENOMEM; - memset(chip->playback_pipes, 0, sizeof(struct vx_pipe *) * chip->audio_outs); - memset(chip->capture_pipes, 0, sizeof(struct vx_pipe *) * chip->audio_ins); + memset(chip->playback_pipes, 0, sizeof(vx_pipe_t *) * chip->audio_outs); + memset(chip->capture_pipes, 0, sizeof(vx_pipe_t *) * chip->audio_ins); preferred = chip->ibl.size; chip->ibl.size = 0; vx_set_ibl(chip, &chip->ibl); /* query the info */ if (preferred > 0) { - chip->ibl.size = ((preferred + chip->ibl.granularity - 1) / - chip->ibl.granularity) * chip->ibl.granularity; + chip->ibl.size = ((preferred + chip->ibl.granularity - 1) / chip->ibl.granularity) * chip->ibl.granularity; if (chip->ibl.size > chip->ibl.max_size) chip->ibl.size = chip->ibl.max_size; } else @@ -1280,9 +1260,9 @@ static int vx_init_audio_io(struct vx_core *chip) /* * free callback for pcm */ -static void snd_vx_pcm_free(struct snd_pcm *pcm) +static void snd_vx_pcm_free(snd_pcm_t *pcm) { - struct vx_core *chip = pcm->private_data; + vx_core_t *chip = pcm->private_data; chip->pcm[pcm->device] = NULL; kfree(chip->playback_pipes); chip->playback_pipes = NULL; @@ -1293,9 +1273,9 @@ static void snd_vx_pcm_free(struct snd_pcm *pcm) /* * snd_vx_pcm_new - create and initialize a pcm */ -int snd_vx_pcm_new(struct vx_core *chip) +int snd_vx_pcm_new(vx_core_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; unsigned int i; int err; diff --git a/trunk/sound/drivers/vx/vx_uer.c b/trunk/sound/drivers/vx/vx_uer.c index 7400306b7f28..4fc38bde34f4 100644 --- a/trunk/sound/drivers/vx/vx_uer.c +++ b/trunk/sound/drivers/vx/vx_uer.c @@ -31,7 +31,7 @@ * vx_modify_board_clock - tell the board that its clock has been modified * @sync: DSP needs to resynchronize its FIFO */ -static int vx_modify_board_clock(struct vx_core *chip, int sync) +static int vx_modify_board_clock(vx_core_t *chip, int sync) { struct vx_rmh rmh; @@ -45,7 +45,7 @@ static int vx_modify_board_clock(struct vx_core *chip, int sync) /* * vx_modify_board_inputs - resync audio inputs */ -static int vx_modify_board_inputs(struct vx_core *chip) +static int vx_modify_board_inputs(vx_core_t *chip) { struct vx_rmh rmh; @@ -59,7 +59,7 @@ static int vx_modify_board_inputs(struct vx_core *chip) * @index: the bit index * returns 0 or 1. */ -static int vx_read_one_cbit(struct vx_core *chip, int index) +static int vx_read_one_cbit(vx_core_t *chip, int index) { unsigned long flags; int val; @@ -82,7 +82,7 @@ static int vx_read_one_cbit(struct vx_core *chip, int index) * @index: the bit index * @val: bit value, 0 or 1 */ -static void vx_write_one_cbit(struct vx_core *chip, int index, int val) +static void vx_write_one_cbit(vx_core_t *chip, int index, int val) { unsigned long flags; val = !!val; /* 0 or 1 */ @@ -104,7 +104,7 @@ static void vx_write_one_cbit(struct vx_core *chip, int index, int val) * returns the frequency of UER, or 0 if not sync, * or a negative error code. */ -static int vx_read_uer_status(struct vx_core *chip, int *mode) +static int vx_read_uer_status(vx_core_t *chip, int *mode) { int val, freq; @@ -160,7 +160,7 @@ static int vx_read_uer_status(struct vx_core *chip, int *mode) * default : HexFreq = (dword) ((double) 28224000 / (double) (Frequency*4)) - 0x000001FF */ -static int vx_calc_clock_from_freq(struct vx_core *chip, int freq) +static int vx_calc_clock_from_freq(vx_core_t *chip, int freq) { int hexfreq; @@ -187,7 +187,7 @@ static int vx_calc_clock_from_freq(struct vx_core *chip, int freq) * vx_change_clock_source - change the clock source * @source: the new source */ -static void vx_change_clock_source(struct vx_core *chip, int source) +static void vx_change_clock_source(vx_core_t *chip, int source) { unsigned long flags; @@ -205,7 +205,7 @@ static void vx_change_clock_source(struct vx_core *chip, int source) /* * set the internal clock */ -void vx_set_internal_clock(struct vx_core *chip, unsigned int freq) +void vx_set_internal_clock(vx_core_t *chip, unsigned int freq) { int clock; unsigned long flags; @@ -228,7 +228,7 @@ void vx_set_internal_clock(struct vx_core *chip, unsigned int freq) * set the iec958 status bits * @bits: 32-bit status bits */ -void vx_set_iec958_status(struct vx_core *chip, unsigned int bits) +void vx_set_iec958_status(vx_core_t *chip, unsigned int bits) { int i; @@ -243,7 +243,7 @@ void vx_set_iec958_status(struct vx_core *chip, unsigned int bits) /* * vx_set_clock - change the clock and audio source if necessary */ -int vx_set_clock(struct vx_core *chip, unsigned int freq) +int vx_set_clock(vx_core_t *chip, unsigned int freq) { int src_changed = 0; @@ -285,7 +285,7 @@ int vx_set_clock(struct vx_core *chip, unsigned int freq) /* * vx_change_frequency - called from interrupt handler */ -int vx_change_frequency(struct vx_core *chip) +int vx_change_frequency(vx_core_t *chip) { int freq; diff --git a/trunk/sound/i2c/cs8427.c b/trunk/sound/i2c/cs8427.c index 9deba80a587c..1a05cfbdc7c6 100644 --- a/trunk/sound/i2c/cs8427.c +++ b/trunk/sound/i2c/cs8427.c @@ -30,7 +30,7 @@ #include <sound/cs8427.h> #include <sound/asoundef.h> -static void snd_cs8427_reset(struct snd_i2c_device *cs8427); +static void snd_cs8427_reset(snd_i2c_device_t *cs8427); MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("IEC958 (S/PDIF) receiver & transmitter by Cirrus Logic"); @@ -38,22 +38,22 @@ MODULE_LICENSE("GPL"); #define CS8427_ADDR (0x20>>1) /* fixed address */ -struct cs8427_stream { - struct snd_pcm_substream *substream; +typedef struct { + snd_pcm_substream_t *substream; char hw_status[24]; /* hardware status */ char def_status[24]; /* default status */ char pcm_status[24]; /* PCM private status */ char hw_udata[32]; - struct snd_kcontrol *pcm_ctl; -}; + snd_kcontrol_t *pcm_ctl; +} cs8427_stream_t; -struct cs8427 { +typedef struct { unsigned char regmap[0x14]; /* map of first 1 + 13 registers */ unsigned int rate; unsigned int reset_timeout; - struct cs8427_stream playback; - struct cs8427_stream capture; -}; + cs8427_stream_t playback; + cs8427_stream_t capture; +} cs8427_t; static unsigned char swapbits(unsigned char val) { @@ -67,8 +67,7 @@ static unsigned char swapbits(unsigned char val) return res; } -int snd_cs8427_reg_write(struct snd_i2c_device *device, unsigned char reg, - unsigned char val) +int snd_cs8427_reg_write(snd_i2c_device_t *device, unsigned char reg, unsigned char val) { int err; unsigned char buf[2]; @@ -82,7 +81,7 @@ int snd_cs8427_reg_write(struct snd_i2c_device *device, unsigned char reg, return 0; } -static int snd_cs8427_reg_read(struct snd_i2c_device *device, unsigned char reg) +static int snd_cs8427_reg_read(snd_i2c_device_t *device, unsigned char reg) { int err; unsigned char buf; @@ -98,29 +97,28 @@ static int snd_cs8427_reg_read(struct snd_i2c_device *device, unsigned char reg) return buf; } -static int snd_cs8427_select_corudata(struct snd_i2c_device *device, int udata) +static int snd_cs8427_select_corudata(snd_i2c_device_t *device, int udata) { - struct cs8427 *chip = device->private_data; + cs8427_t *chip = device->private_data; int err; udata = udata ? CS8427_BSEL : 0; if (udata != (chip->regmap[CS8427_REG_CSDATABUF] & udata)) { chip->regmap[CS8427_REG_CSDATABUF] &= ~CS8427_BSEL; chip->regmap[CS8427_REG_CSDATABUF] |= udata; - err = snd_cs8427_reg_write(device, CS8427_REG_CSDATABUF, - chip->regmap[CS8427_REG_CSDATABUF]); + err = snd_cs8427_reg_write(device, CS8427_REG_CSDATABUF, chip->regmap[CS8427_REG_CSDATABUF]); if (err < 0) return err; } return 0; } -static int snd_cs8427_send_corudata(struct snd_i2c_device *device, +static int snd_cs8427_send_corudata(snd_i2c_device_t *device, int udata, unsigned char *ndata, int count) { - struct cs8427 *chip = device->private_data; + cs8427_t *chip = device->private_data; char *hw_data = udata ? chip->playback.hw_udata : chip->playback.hw_status; char data[32]; int err, idx; @@ -135,8 +133,7 @@ static int snd_cs8427_send_corudata(struct snd_i2c_device *device, if (memcmp(hw_data, data, count) == 0) { chip->regmap[CS8427_REG_UDATABUF] &= ~CS8427_UBMMASK; chip->regmap[CS8427_REG_UDATABUF] |= CS8427_UBMZEROS | CS8427_EFTUI; - if ((err = snd_cs8427_reg_write(device, CS8427_REG_UDATABUF, - chip->regmap[CS8427_REG_UDATABUF])) < 0) + if ((err = snd_cs8427_reg_write(device, CS8427_REG_UDATABUF, chip->regmap[CS8427_REG_UDATABUF])) < 0) return err; return 0; } @@ -149,15 +146,15 @@ static int snd_cs8427_send_corudata(struct snd_i2c_device *device, return 1; } -static void snd_cs8427_free(struct snd_i2c_device *device) +static void snd_cs8427_free(snd_i2c_device_t *device) { kfree(device->private_data); } -int snd_cs8427_create(struct snd_i2c_bus *bus, +int snd_cs8427_create(snd_i2c_bus_t *bus, unsigned char addr, unsigned int reset_timeout, - struct snd_i2c_device **r_cs8427) + snd_i2c_device_t **r_cs8427) { static unsigned char initvals1[] = { CS8427_REG_CONTROL1 | CS8427_REG_AUTOINC, @@ -197,12 +194,11 @@ int snd_cs8427_create(struct snd_i2c_bus *bus, CS8427_UD | CS8427_EFTUI | CS8427_DETUI, }; int err; - struct cs8427 *chip; - struct snd_i2c_device *device; + cs8427_t *chip; + snd_i2c_device_t *device; unsigned char buf[24]; - if ((err = snd_i2c_device_create(bus, "CS8427", CS8427_ADDR | (addr & 7), - &device)) < 0) + if ((err = snd_i2c_device_create(bus, "CS8427", CS8427_ADDR | (addr & 7), &device)) < 0) return err; chip = device->private_data = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) { @@ -212,13 +208,9 @@ int snd_cs8427_create(struct snd_i2c_bus *bus, device->private_free = snd_cs8427_free; snd_i2c_lock(bus); - if ((err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER)) != - CS8427_VER8427A) { + if ((err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER)) != CS8427_VER8427A) { snd_i2c_unlock(bus); - snd_printk(KERN_ERR "unable to find CS8427 signature " - "(expected 0x%x, read 0x%x),\n", - CS8427_VER8427A, err); - snd_printk(KERN_ERR " initialization is not completed\n"); + snd_printk(KERN_ERR "unable to find CS8427 signature (expected 0x%x, read 0x%x), initialization is not completed\n", CS8427_VER8427A, err); return -EFAULT; } /* turn off run bit while making changes to configuration */ @@ -287,9 +279,9 @@ int snd_cs8427_create(struct snd_i2c_bus *bus, * put back AES3INPUT. This workaround is described in latest * CS8427 datasheet, otherwise TXDSERIAL will not work. */ -static void snd_cs8427_reset(struct snd_i2c_device *cs8427) +static void snd_cs8427_reset(snd_i2c_device_t *cs8427) { - struct cs8427 *chip; + cs8427_t *chip; unsigned long end_time; int data; @@ -297,12 +289,10 @@ static void snd_cs8427_reset(struct snd_i2c_device *cs8427) chip = cs8427->private_data; snd_i2c_lock(cs8427->bus); chip->regmap[CS8427_REG_CLOCKSOURCE] &= ~(CS8427_RUN | CS8427_RXDMASK); - snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, - chip->regmap[CS8427_REG_CLOCKSOURCE]); + snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, chip->regmap[CS8427_REG_CLOCKSOURCE]); udelay(200); chip->regmap[CS8427_REG_CLOCKSOURCE] |= CS8427_RUN | CS8427_RXDILRCK; - snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, - chip->regmap[CS8427_REG_CLOCKSOURCE]); + snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, chip->regmap[CS8427_REG_CLOCKSOURCE]); udelay(200); snd_i2c_unlock(cs8427->bus); end_time = jiffies + chip->reset_timeout; @@ -317,13 +307,12 @@ static void snd_cs8427_reset(struct snd_i2c_device *cs8427) snd_i2c_lock(cs8427->bus); chip->regmap[CS8427_REG_CLOCKSOURCE] &= ~CS8427_RXDMASK; chip->regmap[CS8427_REG_CLOCKSOURCE] |= CS8427_RXDAES3INPUT; - snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, - chip->regmap[CS8427_REG_CLOCKSOURCE]); + snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, chip->regmap[CS8427_REG_CLOCKSOURCE]); snd_i2c_unlock(cs8427->bus); } -static int snd_cs8427_in_status_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs8427_in_status_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -332,10 +321,10 @@ static int snd_cs8427_in_status_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs8427_in_status_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs8427_in_status_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); + snd_i2c_device_t *device = snd_kcontrol_chip(kcontrol); int data; snd_i2c_lock(device->bus); @@ -347,18 +336,18 @@ static int snd_cs8427_in_status_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs8427_qsubcode_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs8427_qsubcode_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; uinfo->count = 10; return 0; } -static int snd_cs8427_qsubcode_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs8427_qsubcode_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); + snd_i2c_device_t *device = snd_kcontrol_chip(kcontrol); unsigned char reg = CS8427_REG_QSUBCODE; int err; @@ -377,18 +366,18 @@ static int snd_cs8427_qsubcode_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs8427_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_cs8427_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_cs8427_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs8427_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); - struct cs8427 *chip = device->private_data; + snd_i2c_device_t *device = snd_kcontrol_chip(kcontrol); + cs8427_t *chip = device->private_data; snd_i2c_lock(device->bus); memcpy(ucontrol->value.iec958.status, chip->playback.def_status, 24); @@ -396,15 +385,13 @@ static int snd_cs8427_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs8427_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs8427_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); - struct cs8427 *chip = device->private_data; - unsigned char *status = kcontrol->private_value ? - chip->playback.pcm_status : chip->playback.def_status; - struct snd_pcm_runtime *runtime = chip->playback.substream ? - chip->playback.substream->runtime : NULL; + snd_i2c_device_t *device = snd_kcontrol_chip(kcontrol); + cs8427_t *chip = device->private_data; + unsigned char *status = kcontrol->private_value ? chip->playback.pcm_status : chip->playback.def_status; + snd_pcm_runtime_t *runtime = chip->playback.substream ? chip->playback.substream->runtime : NULL; int err, change; snd_i2c_lock(device->bus); @@ -419,22 +406,21 @@ static int snd_cs8427_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_cs8427_spdif_mask_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs8427_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_cs8427_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs8427_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { memset(ucontrol->value.iec958.status, 0xff, 24); return 0; } -static struct snd_kcontrol_new snd_cs8427_iec958_controls[] = { +static snd_kcontrol_new_t snd_cs8427_iec958_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .info = snd_cs8427_in_status_info, @@ -483,12 +469,12 @@ static struct snd_kcontrol_new snd_cs8427_iec958_controls[] = { .get = snd_cs8427_qsubcode_get }}; -int snd_cs8427_iec958_build(struct snd_i2c_device *cs8427, - struct snd_pcm_substream *play_substream, - struct snd_pcm_substream *cap_substream) +int snd_cs8427_iec958_build(snd_i2c_device_t *cs8427, + snd_pcm_substream_t *play_substream, + snd_pcm_substream_t *cap_substream) { - struct cs8427 *chip = cs8427->private_data; - struct snd_kcontrol *kctl; + cs8427_t *chip = cs8427->private_data; + snd_kcontrol_t *kctl; unsigned int idx; int err; @@ -512,9 +498,9 @@ int snd_cs8427_iec958_build(struct snd_i2c_device *cs8427, return 0; } -int snd_cs8427_iec958_active(struct snd_i2c_device *cs8427, int active) +int snd_cs8427_iec958_active(snd_i2c_device_t *cs8427, int active) { - struct cs8427 *chip; + cs8427_t *chip; snd_assert(cs8427, return -ENXIO); chip = cs8427->private_data; @@ -526,9 +512,9 @@ int snd_cs8427_iec958_active(struct snd_i2c_device *cs8427, int active) return 0; } -int snd_cs8427_iec958_pcm(struct snd_i2c_device *cs8427, unsigned int rate) +int snd_cs8427_iec958_pcm(snd_i2c_device_t *cs8427, unsigned int rate) { - struct cs8427 *chip; + cs8427_t *chip; char *status; int err, reset; diff --git a/trunk/sound/i2c/i2c.c b/trunk/sound/i2c/i2c.c index c4e1f2c23ced..e4e505b9d88b 100644 --- a/trunk/sound/i2c/i2c.c +++ b/trunk/sound/i2c/i2c.c @@ -32,23 +32,20 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("Generic i2c interface for ALSA"); MODULE_LICENSE("GPL"); -static int snd_i2c_bit_sendbytes(struct snd_i2c_device *device, - unsigned char *bytes, int count); -static int snd_i2c_bit_readbytes(struct snd_i2c_device *device, - unsigned char *bytes, int count); -static int snd_i2c_bit_probeaddr(struct snd_i2c_bus *bus, - unsigned short addr); - -static struct snd_i2c_ops snd_i2c_bit_ops = { +static int snd_i2c_bit_sendbytes(snd_i2c_device_t *device, unsigned char *bytes, int count); +static int snd_i2c_bit_readbytes(snd_i2c_device_t *device, unsigned char *bytes, int count); +static int snd_i2c_bit_probeaddr(snd_i2c_bus_t *bus, unsigned short addr); + +static snd_i2c_ops_t snd_i2c_bit_ops = { .sendbytes = snd_i2c_bit_sendbytes, .readbytes = snd_i2c_bit_readbytes, .probeaddr = snd_i2c_bit_probeaddr, }; -static int snd_i2c_bus_free(struct snd_i2c_bus *bus) +static int snd_i2c_bus_free(snd_i2c_bus_t *bus) { - struct snd_i2c_bus *slave; - struct snd_i2c_device *device; + snd_i2c_bus_t *slave; + snd_i2c_device_t *device; snd_assert(bus != NULL, return -EINVAL); while (!list_empty(&bus->devices)) { @@ -69,18 +66,17 @@ static int snd_i2c_bus_free(struct snd_i2c_bus *bus) return 0; } -static int snd_i2c_bus_dev_free(struct snd_device *device) +static int snd_i2c_bus_dev_free(snd_device_t *device) { - struct snd_i2c_bus *bus = device->device_data; + snd_i2c_bus_t *bus = device->device_data; return snd_i2c_bus_free(bus); } -int snd_i2c_bus_create(struct snd_card *card, const char *name, - struct snd_i2c_bus *master, struct snd_i2c_bus **ri2c) +int snd_i2c_bus_create(snd_card_t *card, const char *name, snd_i2c_bus_t *master, snd_i2c_bus_t **ri2c) { - struct snd_i2c_bus *bus; + snd_i2c_bus_t *bus; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_i2c_bus_dev_free, }; @@ -106,10 +102,9 @@ int snd_i2c_bus_create(struct snd_card *card, const char *name, return 0; } -int snd_i2c_device_create(struct snd_i2c_bus *bus, const char *name, - unsigned char addr, struct snd_i2c_device **rdevice) +int snd_i2c_device_create(snd_i2c_bus_t *bus, const char *name, unsigned char addr, snd_i2c_device_t **rdevice) { - struct snd_i2c_device *device; + snd_i2c_device_t *device; *rdevice = NULL; snd_assert(bus != NULL, return -EINVAL); @@ -124,7 +119,7 @@ int snd_i2c_device_create(struct snd_i2c_bus *bus, const char *name, return 0; } -int snd_i2c_device_free(struct snd_i2c_device *device) +int snd_i2c_device_free(snd_i2c_device_t *device) { if (device->bus) list_del(&device->list); @@ -134,18 +129,18 @@ int snd_i2c_device_free(struct snd_i2c_device *device) return 0; } -int snd_i2c_sendbytes(struct snd_i2c_device *device, unsigned char *bytes, int count) +int snd_i2c_sendbytes(snd_i2c_device_t *device, unsigned char *bytes, int count) { return device->bus->ops->sendbytes(device, bytes, count); } -int snd_i2c_readbytes(struct snd_i2c_device *device, unsigned char *bytes, int count) +int snd_i2c_readbytes(snd_i2c_device_t *device, unsigned char *bytes, int count) { return device->bus->ops->readbytes(device, bytes, count); } -int snd_i2c_probeaddr(struct snd_i2c_bus *bus, unsigned short addr) +int snd_i2c_probeaddr(snd_i2c_bus_t *bus, unsigned short addr) { return bus->ops->probeaddr(bus, addr); } @@ -154,31 +149,31 @@ int snd_i2c_probeaddr(struct snd_i2c_bus *bus, unsigned short addr) * bit-operations */ -static inline void snd_i2c_bit_hw_start(struct snd_i2c_bus *bus) +static inline void snd_i2c_bit_hw_start(snd_i2c_bus_t *bus) { if (bus->hw_ops.bit->start) bus->hw_ops.bit->start(bus); } -static inline void snd_i2c_bit_hw_stop(struct snd_i2c_bus *bus) +static inline void snd_i2c_bit_hw_stop(snd_i2c_bus_t *bus) { if (bus->hw_ops.bit->stop) bus->hw_ops.bit->stop(bus); } -static void snd_i2c_bit_direction(struct snd_i2c_bus *bus, int clock, int data) +static void snd_i2c_bit_direction(snd_i2c_bus_t *bus, int clock, int data) { if (bus->hw_ops.bit->direction) bus->hw_ops.bit->direction(bus, clock, data); } -static void snd_i2c_bit_set(struct snd_i2c_bus *bus, int clock, int data) +static void snd_i2c_bit_set(snd_i2c_bus_t *bus, int clock, int data) { bus->hw_ops.bit->setlines(bus, clock, data); } #if 0 -static int snd_i2c_bit_clock(struct snd_i2c_bus *bus) +static int snd_i2c_bit_clock(snd_i2c_bus_t *bus) { if (bus->hw_ops.bit->getclock) return bus->hw_ops.bit->getclock(bus); @@ -186,12 +181,12 @@ static int snd_i2c_bit_clock(struct snd_i2c_bus *bus) } #endif -static int snd_i2c_bit_data(struct snd_i2c_bus *bus, int ack) +static int snd_i2c_bit_data(snd_i2c_bus_t *bus, int ack) { return bus->hw_ops.bit->getdata(bus, ack); } -static void snd_i2c_bit_start(struct snd_i2c_bus *bus) +static void snd_i2c_bit_start(snd_i2c_bus_t *bus) { snd_i2c_bit_hw_start(bus); snd_i2c_bit_direction(bus, 1, 1); /* SCL - wr, SDA - wr */ @@ -200,7 +195,7 @@ static void snd_i2c_bit_start(struct snd_i2c_bus *bus) snd_i2c_bit_set(bus, 0, 0); } -static void snd_i2c_bit_stop(struct snd_i2c_bus *bus) +static void snd_i2c_bit_stop(snd_i2c_bus_t *bus) { snd_i2c_bit_set(bus, 0, 0); snd_i2c_bit_set(bus, 1, 0); @@ -208,14 +203,14 @@ static void snd_i2c_bit_stop(struct snd_i2c_bus *bus) snd_i2c_bit_hw_stop(bus); } -static void snd_i2c_bit_send(struct snd_i2c_bus *bus, int data) +static void snd_i2c_bit_send(snd_i2c_bus_t *bus, int data) { snd_i2c_bit_set(bus, 0, data); snd_i2c_bit_set(bus, 1, data); snd_i2c_bit_set(bus, 0, data); } -static int snd_i2c_bit_ack(struct snd_i2c_bus *bus) +static int snd_i2c_bit_ack(snd_i2c_bus_t *bus) { int ack; @@ -228,7 +223,7 @@ static int snd_i2c_bit_ack(struct snd_i2c_bus *bus) return ack ? -EIO : 0; } -static int snd_i2c_bit_sendbyte(struct snd_i2c_bus *bus, unsigned char data) +static int snd_i2c_bit_sendbyte(snd_i2c_bus_t *bus, unsigned char data) { int i, err; @@ -239,7 +234,7 @@ static int snd_i2c_bit_sendbyte(struct snd_i2c_bus *bus, unsigned char data) return 0; } -static int snd_i2c_bit_readbyte(struct snd_i2c_bus *bus, int last) +static int snd_i2c_bit_readbyte(snd_i2c_bus_t *bus, int last) { int i; unsigned char data = 0; @@ -257,10 +252,9 @@ static int snd_i2c_bit_readbyte(struct snd_i2c_bus *bus, int last) return data; } -static int snd_i2c_bit_sendbytes(struct snd_i2c_device *device, - unsigned char *bytes, int count) +static int snd_i2c_bit_sendbytes(snd_i2c_device_t *device, unsigned char *bytes, int count) { - struct snd_i2c_bus *bus = device->bus; + snd_i2c_bus_t *bus = device->bus; int err, res = 0; if (device->flags & SND_I2C_DEVICE_ADDRTEN) @@ -281,10 +275,9 @@ static int snd_i2c_bit_sendbytes(struct snd_i2c_device *device, return res; } -static int snd_i2c_bit_readbytes(struct snd_i2c_device *device, - unsigned char *bytes, int count) +static int snd_i2c_bit_readbytes(snd_i2c_device_t *device, unsigned char *bytes, int count) { - struct snd_i2c_bus *bus = device->bus; + snd_i2c_bus_t *bus = device->bus; int err, res = 0; if (device->flags & SND_I2C_DEVICE_ADDRTEN) @@ -306,7 +299,7 @@ static int snd_i2c_bit_readbytes(struct snd_i2c_device *device, return res; } -static int snd_i2c_bit_probeaddr(struct snd_i2c_bus *bus, unsigned short addr) +static int snd_i2c_bit_probeaddr(snd_i2c_bus_t *bus, unsigned short addr) { int err; diff --git a/trunk/sound/i2c/l3/uda1341.c b/trunk/sound/i2c/l3/uda1341.c index 746500e06950..103a7dcd0dde 100644 --- a/trunk/sound/i2c/l3/uda1341.c +++ b/trunk/sound/i2c/l3/uda1341.c @@ -17,7 +17,7 @@ * 2002-05-12 Tomas Kasparek another code cleanup */ -/* $Id: uda1341.c,v 1.18 2005/11/17 14:17:21 tiwai Exp $ */ +/* $Id: uda1341.c,v 1.16 2005/09/09 13:22:34 tiwai Exp $ */ #include <sound/driver.h> #include <linux/module.h> @@ -56,33 +56,6 @@ /* }}} */ - -static const char *peak_names[] = { - "before", - "after", -}; - -static const char *filter_names[] = { - "flat", - "min", - "min", - "max", -}; - -static const char *mixer_names[] = { - "double differential", - "input channel 1 (line in)", - "input channel 2 (microphone)", - "digital mixer", -}; - -static const char *deemp_names[] = { - "none", - "32 kHz", - "44.1 kHz", - "48 kHz", -}; - enum uda1341_regs_names { stat0, stat1, @@ -100,7 +73,7 @@ enum uda1341_regs_names { uda1341_reg_last, }; -static const char *uda1341_reg_names[] = { +const char *uda1341_reg_names[] = { "stat 0 ", "stat 1 ", "data 00", @@ -116,7 +89,7 @@ static const char *uda1341_reg_names[] = { "ext 6", }; -static const int uda1341_enum_items[] = { +const int uda1341_enum_items[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, //peak - before/after 4, //deemp - none/32/44.1/48 @@ -127,7 +100,7 @@ static const int uda1341_enum_items[] = { 0, 0, 0, 0, 0, }; -static const char ** uda1341_enum_names[] = { +const char ** uda1341_enum_names[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, peak_names, //peak - before/after deemp_names, //deemp - none/32/44.1/48 @@ -140,13 +113,15 @@ static const char ** uda1341_enum_names[] = { typedef int uda1341_cfg[CMD_LAST]; +typedef struct uda1341 uda1341_t; + struct uda1341 { int (*write) (struct l3_client *uda1341, unsigned short reg, unsigned short val); int (*read) (struct l3_client *uda1341, unsigned short reg); unsigned char regs[uda1341_reg_last]; int active; spinlock_t reg_lock; - struct snd_card *card; + snd_card_t *card; uda1341_cfg cfg; #ifdef CONFIG_PM unsigned char suspend_regs[uda1341_reg_last]; @@ -154,9 +129,11 @@ struct uda1341 { #endif }; +//hack for ALSA magic casting +typedef struct l3_client l3_client_t; + /* transfer 8bit integer into string with binary representation */ -static void int2str_bin8(uint8_t val, char *buf) -{ +void int2str_bin8(uint8_t val, char *buf){ const int size = sizeof(val) * 8; int i; @@ -169,7 +146,7 @@ static void int2str_bin8(uint8_t val, char *buf) /* {{{ HW manipulation routines */ -static int snd_uda1341_codec_write(struct l3_client *clnt, unsigned short reg, unsigned short val) +int snd_uda1341_codec_write(struct l3_client *clnt, unsigned short reg, unsigned short val) { struct uda1341 *uda = clnt->driver_data; unsigned char buf[2] = { 0xc0, 0xe0 }; // for EXT addressing @@ -194,7 +171,7 @@ static int snd_uda1341_codec_write(struct l3_client *clnt, unsigned short reg, u return err; } -static int snd_uda1341_codec_read(struct l3_client *clnt, unsigned short reg) +int snd_uda1341_codec_read(struct l3_client *clnt, unsigned short reg) { unsigned char val; int err; @@ -211,9 +188,8 @@ static inline int snd_uda1341_valid_reg(struct l3_client *clnt, unsigned short r return reg < uda1341_reg_last; } -static int snd_uda1341_update_bits(struct l3_client *clnt, unsigned short reg, - unsigned short mask, unsigned short shift, - unsigned short value, int flush) +int snd_uda1341_update_bits(struct l3_client *clnt, unsigned short reg, unsigned short mask, + unsigned short shift, unsigned short value, int flush) { int change; unsigned short old, new; @@ -238,8 +214,8 @@ static int snd_uda1341_update_bits(struct l3_client *clnt, unsigned short reg, return change; } -static int snd_uda1341_cfg_write(struct l3_client *clnt, unsigned short what, - unsigned short value, int flush) +int snd_uda1341_cfg_write(struct l3_client *clnt, unsigned short what, + unsigned short value, int flush) { struct uda1341 *uda = clnt->driver_data; int ret = 0; @@ -351,84 +327,9 @@ static int snd_uda1341_cfg_write(struct l3_client *clnt, unsigned short what, /* }}} */ /* {{{ Proc interface */ -#ifdef CONFIG_PROC_FS - -static const char *format_names[] = { - "I2S-bus", - "LSB 16bits", - "LSB 18bits", - "LSB 20bits", - "MSB", - "in LSB 16bits/out MSB", - "in LSB 18bits/out MSB", - "in LSB 20bits/out MSB", -}; - -static const char *fs_names[] = { - "512*fs", - "384*fs", - "256*fs", - "Unused - bad value!", -}; - -static const char* bass_values[][16] = { - {"0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", "0 dB", - "0 dB", "0 dB", "0 dB", "0 dB", "undefined", }, //flat - {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "18 dB", - "18 dB", "18 dB", "18 dB", "18 dB", "undefined",}, // min - {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "18 dB", - "18 dB", "18 dB", "18 dB", "18 dB", "undefined",}, // min - {"0 dB", "2 dB", "4 dB", "6 dB", "8 dB", "10 dB", "12 dB", "14 dB", "16 dB", "18 dB", "20 dB", - "22 dB", "24 dB", "24 dB", "24 dB", "undefined",}, // max -}; - -static const char *mic_sens_value[] = { - "-3 dB", "0 dB", "3 dB", "9 dB", "15 dB", "21 dB", "27 dB", "not used", -}; - -static const unsigned short AGC_atime[] = { - 11, 16, 11, 16, 21, 11, 16, 21, -}; - -static const unsigned short AGC_dtime[] = { - 100, 100, 200, 200, 200, 400, 400, 400, -}; -static const char *AGC_level[] = { - "-9.0", "-11.5", "-15.0", "-17.5", -}; - -static const char *ig_small_value[] = { - "-3.0", "-2.5", "-2.0", "-1.5", "-1.0", "-0.5", -}; - -/* - * this was computed as peak_value[i] = pow((63-i)*1.42,1.013) - * - * UDA1341 datasheet on page 21: Peak value (dB) = (Peak level - 63.5)*5*log2 - * There is an table with these values [level]=value: [3]=-90.31, [7]=-84.29 - * [61]=-2.78, [62] = -1.48, [63] = 0.0 - * I tried to compute it, but using but even using logarithm with base either 10 or 2 - * i was'n able to get values in the table from the formula. So I constructed another - * formula (see above) to interpolate the values as good as possible. If there is some - * mistake, please contact me on tomas.kasparek@seznam.cz. Thanks. - * UDA1341TS datasheet is available at: - * http://www-us9.semiconductors.com/acrobat/datasheets/UDA1341TS_3.pdf - */ -static const char *peak_value[] = { - "-INF dB", "N.A.", "N.A", "90.31 dB", "N.A.", "N.A.", "N.A.", "-84.29 dB", - "-82.65 dB", "-81.13 dB", "-79.61 dB", "-78.09 dB", "-76.57 dB", "-75.05 dB", "-73.53 dB", - "-72.01 dB", "-70.49 dB", "-68.97 dB", "-67.45 dB", "-65.93 dB", "-64.41 dB", "-62.90 dB", - "-61.38 dB", "-59.86 dB", "-58.35 dB", "-56.83 dB", "-55.32 dB", "-53.80 dB", "-52.29 dB", - "-50.78 dB", "-49.26 dB", "-47.75 dB", "-46.24 dB", "-44.73 dB", "-43.22 dB", "-41.71 dB", - "-40.20 dB", "-38.69 dB", "-37.19 dB", "-35.68 dB", "-34.17 dB", "-32.67 dB", "-31.17 dB", - "-29.66 dB", "-28.16 dB", "-26.66 dB", "-25.16 dB", "-23.66 dB", "-22.16 dB", "-20.67 dB", - "-19.17 dB", "-17.68 dB", "-16.19 dB", "-14.70 dB", "-13.21 dB", "-11.72 dB", "-10.24 dB", - "-8.76 dB", "-7.28 dB", "-5.81 dB", "-4.34 dB", "-2.88 dB", "-1.43 dB", "0.00 dB", -}; - -static void snd_uda1341_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_uda1341_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { struct l3_client *clnt = entry->private_data; struct uda1341 *uda = clnt->driver_data; @@ -492,14 +393,15 @@ static void snd_uda1341_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, "Input Amp. Gain ch 2: %s dB\n", ig_small_value[uda->cfg[CMD_IG]]); } -static void snd_uda1341_proc_regs_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_uda1341_proc_regs_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { struct l3_client *clnt = entry->private_data; struct uda1341 *uda = clnt->driver_data; int reg; char buf[12]; + spin_lock(&uda->reg_lock); for (reg = 0; reg < uda1341_reg_last; reg ++) { if (reg == empty) continue; @@ -509,12 +411,13 @@ static void snd_uda1341_proc_regs_read(struct snd_info_entry *entry, int2str_bin8(snd_uda1341_codec_read(clnt, UDA1341_DATA1), buf); snd_iprintf(buffer, "DATA1 = %s\n", buf); + + spin_unlock(&uda->reg_lock); } -#endif /* CONFIG_PROC_FS */ -static void __devinit snd_uda1341_proc_init(struct snd_card *card, struct l3_client *clnt) +static void __devinit snd_uda1341_proc_init(snd_card_t *card, struct l3_client *clnt) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(card, "uda1341", &entry)) snd_info_set_text_ops(entry, clnt, 1024, snd_uda1341_proc_read); @@ -534,8 +437,7 @@ static void __devinit snd_uda1341_proc_init(struct snd_card *card, struct l3_cli .private_value = where | (reg << 5) | (shift << 9) | (mask << 12) | (invert << 18) \ } -static int snd_uda1341_info_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_uda1341_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 12) & 63; @@ -546,11 +448,10 @@ static int snd_uda1341_info_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_uda1341_get_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_uda1341_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { struct l3_client *clnt = snd_kcontrol_chip(kcontrol); - struct uda1341 *uda = clnt->driver_data; + uda1341_t *uda = clnt->driver_data; int where = kcontrol->private_value & 31; int mask = (kcontrol->private_value >> 12) & 63; int invert = (kcontrol->private_value >> 18) & 1; @@ -562,11 +463,10 @@ static int snd_uda1341_get_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_uda1341_put_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_uda1341_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { struct l3_client *clnt = snd_kcontrol_chip(kcontrol); - struct uda1341 *uda = clnt->driver_data; + uda1341_t *uda = clnt->driver_data; int where = kcontrol->private_value & 31; int reg = (kcontrol->private_value >> 5) & 15; int shift = (kcontrol->private_value >> 9) & 7; @@ -592,8 +492,7 @@ static int snd_uda1341_put_single(struct snd_kcontrol *kcontrol, .private_value = where | (reg << 5) | (shift << 9) | (mask << 12) | (invert << 18) \ } -static int snd_uda1341_info_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_uda1341_info_enum(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int where = kcontrol->private_value & 31; const char **texts; @@ -614,22 +513,20 @@ static int snd_uda1341_info_enum(struct snd_kcontrol *kcontrol, return 0; } -static int snd_uda1341_get_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_uda1341_get_enum(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { struct l3_client *clnt = snd_kcontrol_chip(kcontrol); - struct uda1341 *uda = clnt->driver_data; + uda1341_t *uda = clnt->driver_data; int where = kcontrol->private_value & 31; ucontrol->value.enumerated.item[0] = uda->cfg[where]; return 0; } -static int snd_uda1341_put_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_uda1341_put_enum(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { struct l3_client *clnt = snd_kcontrol_chip(kcontrol); - struct uda1341 *uda = clnt->driver_data; + uda1341_t *uda = clnt->driver_data; int where = kcontrol->private_value & 31; int reg = (kcontrol->private_value >> 5) & 15; int shift = (kcontrol->private_value >> 9) & 7; @@ -652,8 +549,7 @@ static int snd_uda1341_put_enum(struct snd_kcontrol *kcontrol, } -static int snd_uda1341_info_2regs(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_uda1341_info_2regs(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask_1 = (kcontrol->private_value >> 19) & 63; int mask_2 = (kcontrol->private_value >> 25) & 63; @@ -667,11 +563,10 @@ static int snd_uda1341_info_2regs(struct snd_kcontrol *kcontrol, return 0; } -static int snd_uda1341_get_2regs(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_uda1341_get_2regs(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { struct l3_client *clnt = snd_kcontrol_chip(kcontrol); - struct uda1341 *uda = clnt->driver_data; + uda1341_t *uda = clnt->driver_data; int where = kcontrol->private_value & 31; int mask_1 = (kcontrol->private_value >> 19) & 63; int mask_2 = (kcontrol->private_value >> 25) & 63; @@ -686,11 +581,10 @@ static int snd_uda1341_get_2regs(struct snd_kcontrol *kcontrol, return 0; } -static int snd_uda1341_put_2regs(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_uda1341_put_2regs(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { struct l3_client *clnt = snd_kcontrol_chip(kcontrol); - struct uda1341 *uda = clnt->driver_data; + uda1341_t *uda = clnt->driver_data; int where = kcontrol->private_value & 31; int reg_1 = (kcontrol->private_value >> 5) & 15; int reg_2 = (kcontrol->private_value >> 9) & 15; @@ -723,7 +617,7 @@ static int snd_uda1341_put_2regs(struct snd_kcontrol *kcontrol, /* }}} */ -static struct snd_kcontrol_new snd_uda1341_controls[] = { +static snd_kcontrol_new_t snd_uda1341_controls[] = { UDA1341_SINGLE("Master Playback Switch", CMD_MUTE, data0_2, 2, 1, 1), UDA1341_SINGLE("Master Playback Volume", CMD_VOLUME, data0_0, 0, 63, 1), @@ -753,55 +647,54 @@ static struct snd_kcontrol_new snd_uda1341_controls[] = { UDA1341_2REGS("Gain Input Amplifier Gain (channel 2)", CMD_IG, ext4, ext5, 0, 0, 3, 31, 0), }; -static void uda1341_free(struct l3_client *clnt) +static void uda1341_free(struct l3_client *uda1341) { - l3_detach_client(clnt); // calls kfree for driver_data (struct uda1341) - kfree(clnt); + l3_detach_client(uda1341); // calls kfree for driver_data (uda1341_t) + kfree(uda1341); } -static int uda1341_dev_free(struct snd_device *device) +static int uda1341_dev_free(snd_device_t *device) { struct l3_client *clnt = device->device_data; uda1341_free(clnt); return 0; } -int __init snd_chip_uda1341_mixer_new(struct snd_card *card, struct l3_client **clntp) +int __init snd_chip_uda1341_mixer_new(snd_card_t *card, struct l3_client **clnt) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = uda1341_dev_free, }; - struct l3_client *clnt; + struct l3_client *uda1341; int idx, err; snd_assert(card != NULL, return -EINVAL); - clnt = kzalloc(sizeof(*clnt), GFP_KERNEL); - if (clnt == NULL) + uda1341 = kzalloc(sizeof(*uda1341), GFP_KERNEL); + if (uda1341 == NULL) return -ENOMEM; - if ((err = l3_attach_client(clnt, "l3-bit-sa1100-gpio", UDA1341_ALSA_NAME))) { - kfree(clnt); + if ((err = l3_attach_client(uda1341, "l3-bit-sa1100-gpio", "snd-uda1341"))) { + kfree(uda1341); return err; } - for (idx = 0; idx < ARRAY_SIZE(snd_uda1341_controls); idx++) { - if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_uda1341_controls[idx], clnt))) < 0) { - uda1341_free(clnt); - return err; - } + if ((err = snd_device_new(card, SNDRV_DEV_CODEC, uda1341, &ops)) < 0) { + l3_detach_client(uda1341); + kfree(uda1341); + return err; } - if ((err = snd_device_new(card, SNDRV_DEV_CODEC, clnt, &ops)) < 0) { - uda1341_free(clnt); - return err; + for (idx = 0; idx < ARRAY_SIZE(snd_uda1341_controls); idx++) { + if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_uda1341_controls[idx], uda1341))) < 0) + return err; } - *clntp = clnt; + *clnt = uda1341; strcpy(card->mixername, "UDA1341TS Mixer"); - ((struct uda1341 *)clnt->driver_data)->card = card; + ((uda1341_t *)uda1341->driver_data)->card = card; - snd_uda1341_proc_init(card, clnt); + snd_uda1341_proc_init(card, uda1341); return 0; } diff --git a/trunk/sound/i2c/other/ak4114.c b/trunk/sound/i2c/other/ak4114.c index 12ffffc9e814..d351b3aa1916 100644 --- a/trunk/sound/i2c/other/ak4114.c +++ b/trunk/sound/i2c/other/ak4114.c @@ -37,7 +37,7 @@ MODULE_LICENSE("GPL"); static void ak4114_stats(void *); -static void reg_write(struct ak4114 *ak4114, unsigned char reg, unsigned char val) +static void reg_write(ak4114_t *ak4114, unsigned char reg, unsigned char val) { ak4114->write(ak4114->private_data, reg, val); if (reg <= AK4114_REG_INT1_MASK) @@ -46,13 +46,13 @@ static void reg_write(struct ak4114 *ak4114, unsigned char reg, unsigned char va ak4114->txcsb[reg-AK4114_REG_RXCSB0] = val; } -static inline unsigned char reg_read(struct ak4114 *ak4114, unsigned char reg) +static inline unsigned char reg_read(ak4114_t *ak4114, unsigned char reg) { return ak4114->read(ak4114->private_data, reg); } #if 0 -static void reg_dump(struct ak4114 *ak4114) +static void reg_dump(ak4114_t *ak4114) { int i; @@ -62,7 +62,7 @@ static void reg_dump(struct ak4114 *ak4114) } #endif -static void snd_ak4114_free(struct ak4114 *chip) +static void snd_ak4114_free(ak4114_t *chip) { chip->init = 1; /* don't schedule new work */ mb(); @@ -73,22 +73,22 @@ static void snd_ak4114_free(struct ak4114 *chip) kfree(chip); } -static int snd_ak4114_dev_free(struct snd_device *device) +static int snd_ak4114_dev_free(snd_device_t *device) { - struct ak4114 *chip = device->device_data; + ak4114_t *chip = device->device_data; snd_ak4114_free(chip); return 0; } -int snd_ak4114_create(struct snd_card *card, +int snd_ak4114_create(snd_card_t *card, ak4114_read_t *read, ak4114_write_t *write, unsigned char pgm[7], unsigned char txcsb[5], - void *private_data, struct ak4114 **r_ak4114) + void *private_data, ak4114_t **r_ak4114) { - struct ak4114 *chip; + ak4114_t *chip; int err = 0; unsigned char reg; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ak4114_dev_free, }; @@ -129,7 +129,7 @@ int snd_ak4114_create(struct snd_card *card, return err < 0 ? err : -EIO; } -void snd_ak4114_reg_write(struct ak4114 *chip, unsigned char reg, unsigned char mask, unsigned char val) +void snd_ak4114_reg_write(ak4114_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { if (reg <= AK4114_REG_INT1_MASK) reg_write(chip, reg, (chip->regmap[reg] & ~mask) | val); @@ -137,7 +137,7 @@ void snd_ak4114_reg_write(struct ak4114 *chip, unsigned char reg, unsigned char reg_write(chip, reg, (chip->txcsb[reg] & ~mask) | val); } -void snd_ak4114_reinit(struct ak4114 *chip) +void snd_ak4114_reinit(ak4114_t *chip) { unsigned char old = chip->regmap[AK4114_REG_PWRDN], reg; @@ -176,8 +176,8 @@ static unsigned int external_rate(unsigned char rcs1) } } -static int snd_ak4114_in_error_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ak4114_in_error_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -186,10 +186,10 @@ static int snd_ak4114_in_error_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_in_error_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_in_error_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); long *ptr; spin_lock_irq(&chip->lock); @@ -200,8 +200,8 @@ static int snd_ak4114_in_error_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_in_bit_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ak4114_in_bit_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -210,10 +210,10 @@ static int snd_ak4114_in_bit_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_in_bit_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_in_bit_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); unsigned char reg = kcontrol->private_value & 0xff; unsigned char bit = (kcontrol->private_value >> 8) & 0xff; unsigned char inv = (kcontrol->private_value >> 31) & 1; @@ -222,8 +222,8 @@ static int snd_ak4114_in_bit_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_rate_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ak4114_rate_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -232,26 +232,26 @@ static int snd_ak4114_rate_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_rate_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_rate_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = external_rate(reg_read(chip, AK4114_REG_RCS1)); return 0; } -static int snd_ak4114_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4114_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ak4114_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); unsigned i; for (i = 0; i < AK4114_REG_RXCSB_SIZE; i++) @@ -259,10 +259,10 @@ static int snd_ak4114_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_spdif_playback_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_spdif_playback_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); unsigned i; for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++) @@ -270,10 +270,10 @@ static int snd_ak4114_spdif_playback_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_spdif_playback_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_spdif_playback_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); unsigned i; for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++) @@ -281,21 +281,21 @@ static int snd_ak4114_spdif_playback_put(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4114_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ak4114_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { memset(ucontrol->value.iec958.status, 0xff, AK4114_REG_RXCSB_SIZE); return 0; } -static int snd_ak4114_spdif_pinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4114_spdif_pinfo(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->value.integer.min = 0; @@ -304,10 +304,10 @@ static int snd_ak4114_spdif_pinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ak4114_spdif_pget(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_spdif_pget(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); unsigned short tmp; ucontrol->value.integer.value[0] = 0xf8f2; @@ -319,17 +319,17 @@ static int snd_ak4114_spdif_pget(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4114_spdif_qinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4114_spdif_qinfo(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; uinfo->count = AK4114_REG_QSUB_SIZE; return 0; } -static int snd_ak4114_spdif_qget(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4114_spdif_qget(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4114 *chip = snd_kcontrol_chip(kcontrol); + ak4114_t *chip = snd_kcontrol_chip(kcontrol); unsigned i; for (i = 0; i < AK4114_REG_QSUB_SIZE; i++) @@ -338,14 +338,14 @@ static int snd_ak4114_spdif_qget(struct snd_kcontrol *kcontrol, } /* Don't forget to change AK4114_CONTROLS define!!! */ -static struct snd_kcontrol_new snd_ak4114_iec958_controls[] = { +static snd_kcontrol_new_t snd_ak4114_iec958_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = "IEC958 Parity Errors", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4114_in_error_info, .get = snd_ak4114_in_error_get, - .private_value = offsetof(struct ak4114, parity_errors), + .private_value = offsetof(ak4114_t, parity_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -353,7 +353,7 @@ static struct snd_kcontrol_new snd_ak4114_iec958_controls[] = { .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4114_in_error_info, .get = snd_ak4114_in_error_get, - .private_value = offsetof(struct ak4114, v_bit_errors), + .private_value = offsetof(ak4114_t, v_bit_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -361,7 +361,7 @@ static struct snd_kcontrol_new snd_ak4114_iec958_controls[] = { .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4114_in_error_info, .get = snd_ak4114_in_error_get, - .private_value = offsetof(struct ak4114, ccrc_errors), + .private_value = offsetof(ak4114_t, ccrc_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -369,7 +369,7 @@ static struct snd_kcontrol_new snd_ak4114_iec958_controls[] = { .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4114_in_error_info, .get = snd_ak4114_in_error_get, - .private_value = offsetof(struct ak4114, qcrc_errors), + .private_value = offsetof(ak4114_t, qcrc_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -447,11 +447,11 @@ static struct snd_kcontrol_new snd_ak4114_iec958_controls[] = { } }; -int snd_ak4114_build(struct ak4114 *ak4114, - struct snd_pcm_substream *ply_substream, - struct snd_pcm_substream *cap_substream) +int snd_ak4114_build(ak4114_t *ak4114, + snd_pcm_substream_t *ply_substream, + snd_pcm_substream_t *cap_substream) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; unsigned int idx; int err; @@ -482,7 +482,7 @@ int snd_ak4114_build(struct ak4114 *ak4114, return 0; } -int snd_ak4114_external_rate(struct ak4114 *ak4114) +int snd_ak4114_external_rate(ak4114_t *ak4114) { unsigned char rcs1; @@ -490,9 +490,9 @@ int snd_ak4114_external_rate(struct ak4114 *ak4114) return external_rate(rcs1); } -int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags) +int snd_ak4114_check_rate_and_errors(ak4114_t *ak4114, unsigned int flags) { - struct snd_pcm_runtime *runtime = ak4114->capture_substream ? ak4114->capture_substream->runtime : NULL; + snd_pcm_runtime_t *runtime = ak4114->capture_substream ? ak4114->capture_substream->runtime : NULL; unsigned long _flags; int res = 0; unsigned char rcs0, rcs1; @@ -563,7 +563,7 @@ int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags) static void ak4114_stats(void *data) { - struct ak4114 *chip = (struct ak4114 *)data; + ak4114_t *chip = (ak4114_t *)data; if (chip->init) return; diff --git a/trunk/sound/i2c/other/ak4117.c b/trunk/sound/i2c/other/ak4117.c index 4e45952dd95a..35b4584483a3 100644 --- a/trunk/sound/i2c/other/ak4117.c +++ b/trunk/sound/i2c/other/ak4117.c @@ -37,20 +37,20 @@ MODULE_LICENSE("GPL"); static void snd_ak4117_timer(unsigned long data); -static void reg_write(struct ak4117 *ak4117, unsigned char reg, unsigned char val) +static void reg_write(ak4117_t *ak4117, unsigned char reg, unsigned char val) { ak4117->write(ak4117->private_data, reg, val); if (reg < sizeof(ak4117->regmap)) ak4117->regmap[reg] = val; } -static inline unsigned char reg_read(struct ak4117 *ak4117, unsigned char reg) +static inline unsigned char reg_read(ak4117_t *ak4117, unsigned char reg) { return ak4117->read(ak4117->private_data, reg); } #if 0 -static void reg_dump(struct ak4117 *ak4117) +static void reg_dump(ak4117_t *ak4117) { int i; @@ -60,26 +60,26 @@ static void reg_dump(struct ak4117 *ak4117) } #endif -static void snd_ak4117_free(struct ak4117 *chip) +static void snd_ak4117_free(ak4117_t *chip) { del_timer(&chip->timer); kfree(chip); } -static int snd_ak4117_dev_free(struct snd_device *device) +static int snd_ak4117_dev_free(snd_device_t *device) { - struct ak4117 *chip = device->device_data; + ak4117_t *chip = device->device_data; snd_ak4117_free(chip); return 0; } -int snd_ak4117_create(struct snd_card *card, ak4117_read_t *read, ak4117_write_t *write, - unsigned char pgm[5], void *private_data, struct ak4117 **r_ak4117) +int snd_ak4117_create(snd_card_t *card, ak4117_read_t *read, ak4117_write_t *write, + unsigned char pgm[5], void *private_data, ak4117_t **r_ak4117) { - struct ak4117 *chip; + ak4117_t *chip; int err = 0; unsigned char reg; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ak4117_dev_free, }; @@ -115,14 +115,14 @@ int snd_ak4117_create(struct snd_card *card, ak4117_read_t *read, ak4117_write_t return err < 0 ? err : -EIO; } -void snd_ak4117_reg_write(struct ak4117 *chip, unsigned char reg, unsigned char mask, unsigned char val) +void snd_ak4117_reg_write(ak4117_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { if (reg >= 5) return; reg_write(chip, reg, (chip->regmap[reg] & ~mask) | val); } -void snd_ak4117_reinit(struct ak4117 *chip) +void snd_ak4117_reinit(ak4117_t *chip) { unsigned char old = chip->regmap[AK4117_REG_PWRDN], reg; @@ -157,8 +157,8 @@ static unsigned int external_rate(unsigned char rcs1) } } -static int snd_ak4117_in_error_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_in_error_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -167,10 +167,10 @@ static int snd_ak4117_in_error_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_in_error_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_in_error_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); long *ptr; spin_lock_irq(&chip->lock); @@ -181,8 +181,8 @@ static int snd_ak4117_in_error_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_in_bit_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_in_bit_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -191,10 +191,10 @@ static int snd_ak4117_in_bit_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_in_bit_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_in_bit_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); unsigned char reg = kcontrol->private_value & 0xff; unsigned char bit = (kcontrol->private_value >> 8) & 0xff; unsigned char inv = (kcontrol->private_value >> 31) & 1; @@ -203,8 +203,8 @@ static int snd_ak4117_in_bit_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_rx_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_rx_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -213,19 +213,19 @@ static int snd_ak4117_rx_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_rx_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_rx_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (chip->regmap[AK4117_REG_IO] & AK4117_IPS) ? 1 : 0; return 0; } -static int snd_ak4117_rx_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_rx_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); int change; u8 old_val; @@ -238,8 +238,8 @@ static int snd_ak4117_rx_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_ak4117_rate_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_rate_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -248,26 +248,26 @@ static int snd_ak4117_rate_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_rate_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_rate_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = external_rate(reg_read(chip, AK4117_REG_RCS1)); return 0; } -static int snd_ak4117_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ak4117_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); unsigned i; for (i = 0; i < AK4117_REG_RXCSB_SIZE; i++) @@ -275,21 +275,21 @@ static int snd_ak4117_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ak4117_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { memset(ucontrol->value.iec958.status, 0xff, AK4117_REG_RXCSB_SIZE); return 0; } -static int snd_ak4117_spdif_pinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_spdif_pinfo(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->value.integer.min = 0; @@ -298,10 +298,10 @@ static int snd_ak4117_spdif_pinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ak4117_spdif_pget(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_spdif_pget(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); unsigned short tmp; ucontrol->value.integer.value[0] = 0xf8f2; @@ -313,17 +313,17 @@ static int snd_ak4117_spdif_pget(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ak4117_spdif_qinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4117_spdif_qinfo(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; uinfo->count = AK4117_REG_QSUB_SIZE; return 0; } -static int snd_ak4117_spdif_qget(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ak4117_spdif_qget(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ak4117 *chip = snd_kcontrol_chip(kcontrol); + ak4117_t *chip = snd_kcontrol_chip(kcontrol); unsigned i; for (i = 0; i < AK4117_REG_QSUB_SIZE; i++) @@ -332,14 +332,14 @@ static int snd_ak4117_spdif_qget(struct snd_kcontrol *kcontrol, } /* Don't forget to change AK4117_CONTROLS define!!! */ -static struct snd_kcontrol_new snd_ak4117_iec958_controls[] = { +static snd_kcontrol_new_t snd_ak4117_iec958_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = "IEC958 Parity Errors", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4117_in_error_info, .get = snd_ak4117_in_error_get, - .private_value = offsetof(struct ak4117, parity_errors), + .private_value = offsetof(ak4117_t, parity_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -347,7 +347,7 @@ static struct snd_kcontrol_new snd_ak4117_iec958_controls[] = { .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4117_in_error_info, .get = snd_ak4117_in_error_get, - .private_value = offsetof(struct ak4117, v_bit_errors), + .private_value = offsetof(ak4117_t, v_bit_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -355,7 +355,7 @@ static struct snd_kcontrol_new snd_ak4117_iec958_controls[] = { .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4117_in_error_info, .get = snd_ak4117_in_error_get, - .private_value = offsetof(struct ak4117, ccrc_errors), + .private_value = offsetof(ak4117_t, ccrc_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -363,7 +363,7 @@ static struct snd_kcontrol_new snd_ak4117_iec958_controls[] = { .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_ak4117_in_error_info, .get = snd_ak4117_in_error_get, - .private_value = offsetof(struct ak4117, qcrc_errors), + .private_value = offsetof(ak4117_t, qcrc_errors), }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -434,9 +434,9 @@ static struct snd_kcontrol_new snd_ak4117_iec958_controls[] = { } }; -int snd_ak4117_build(struct ak4117 *ak4117, struct snd_pcm_substream *cap_substream) +int snd_ak4117_build(ak4117_t *ak4117, snd_pcm_substream_t *cap_substream) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; unsigned int idx; int err; @@ -456,7 +456,7 @@ int snd_ak4117_build(struct ak4117 *ak4117, struct snd_pcm_substream *cap_substr return 0; } -int snd_ak4117_external_rate(struct ak4117 *ak4117) +int snd_ak4117_external_rate(ak4117_t *ak4117) { unsigned char rcs1; @@ -464,9 +464,9 @@ int snd_ak4117_external_rate(struct ak4117 *ak4117) return external_rate(rcs1); } -int snd_ak4117_check_rate_and_errors(struct ak4117 *ak4117, unsigned int flags) +int snd_ak4117_check_rate_and_errors(ak4117_t *ak4117, unsigned int flags) { - struct snd_pcm_runtime *runtime = ak4117->substream ? ak4117->substream->runtime : NULL; + snd_pcm_runtime_t *runtime = ak4117->substream ? ak4117->substream->runtime : NULL; unsigned long _flags; int res = 0; unsigned char rcs0, rcs1, rcs2; @@ -542,7 +542,7 @@ int snd_ak4117_check_rate_and_errors(struct ak4117 *ak4117, unsigned int flags) static void snd_ak4117_timer(unsigned long data) { - struct ak4117 *chip = (struct ak4117 *)data; + ak4117_t *chip = (ak4117_t *)data; if (chip->init) return; diff --git a/trunk/sound/i2c/other/ak4xxx-adda.c b/trunk/sound/i2c/other/ak4xxx-adda.c index 045e32a311e0..db2b7274a9d6 100644 --- a/trunk/sound/i2c/other/ak4xxx-adda.c +++ b/trunk/sound/i2c/other/ak4xxx-adda.c @@ -34,7 +34,7 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Takashi Iwai <tiwai@suse.de>"); MODULE_DESCRIPTION("Routines for control of AK452x / AK43xx AD/DA converters"); MODULE_LICENSE("GPL"); -void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg, unsigned char val) +void snd_akm4xxx_write(akm4xxx_t *ak, int chip, unsigned char reg, unsigned char val) { ak->ops.lock(ak, chip); ak->ops.write(ak, chip, reg, val); @@ -58,7 +58,7 @@ void snd_akm4xxx_write(struct snd_akm4xxx *ak, int chip, unsigned char reg, unsi * * assert the reset operation and restores the register values to the chips. */ -void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state) +void snd_akm4xxx_reset(akm4xxx_t *ak, int state) { unsigned int chip; unsigned char reg; @@ -109,7 +109,7 @@ void snd_akm4xxx_reset(struct snd_akm4xxx *ak, int state) /* * initialize all the ak4xxx chips */ -void snd_akm4xxx_init(struct snd_akm4xxx *ak) +void snd_akm4xxx_init(akm4xxx_t *ak) { static unsigned char inits_ak4524[] = { 0x00, 0x07, /* 0: all power up */ @@ -247,8 +247,7 @@ void snd_akm4xxx_init(struct snd_akm4xxx *ak) #define AK_COMPOSE(chip,addr,shift,mask) (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24)) #define AK_INVERT (1<<23) -static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_akm4xxx_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { unsigned int mask = AK_GET_MASK(kcontrol->private_value); @@ -259,10 +258,9 @@ static int snd_akm4xxx_volume_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_akm4xxx_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); + akm4xxx_t *ak = snd_kcontrol_chip(kcontrol); int chip = AK_GET_CHIP(kcontrol->private_value); int addr = AK_GET_ADDR(kcontrol->private_value); int invert = AK_GET_INVERT(kcontrol->private_value); @@ -273,10 +271,9 @@ static int snd_akm4xxx_volume_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_akm4xxx_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); + akm4xxx_t *ak = snd_kcontrol_chip(kcontrol); int chip = AK_GET_CHIP(kcontrol->private_value); int addr = AK_GET_ADDR(kcontrol->private_value); int invert = AK_GET_INVERT(kcontrol->private_value); @@ -292,8 +289,7 @@ static int snd_akm4xxx_volume_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_akm4xxx_ipga_gain_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_akm4xxx_ipga_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -302,20 +298,18 @@ static int snd_akm4xxx_ipga_gain_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_akm4xxx_ipga_gain_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_akm4xxx_ipga_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); + akm4xxx_t *ak = snd_kcontrol_chip(kcontrol); int chip = AK_GET_CHIP(kcontrol->private_value); int addr = AK_GET_ADDR(kcontrol->private_value); ucontrol->value.integer.value[0] = snd_akm4xxx_get_ipga(ak, chip, addr) & 0x7f; return 0; } -static int snd_akm4xxx_ipga_gain_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_akm4xxx_ipga_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); + akm4xxx_t *ak = snd_kcontrol_chip(kcontrol); int chip = AK_GET_CHIP(kcontrol->private_value); int addr = AK_GET_ADDR(kcontrol->private_value); unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80; @@ -325,8 +319,7 @@ static int snd_akm4xxx_ipga_gain_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_akm4xxx_deemphasis_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[4] = { "44.1kHz", "Off", "48kHz", "32kHz", @@ -340,10 +333,9 @@ static int snd_akm4xxx_deemphasis_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_akm4xxx_deemphasis_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); + akm4xxx_t *ak = snd_kcontrol_chip(kcontrol); int chip = AK_GET_CHIP(kcontrol->private_value); int addr = AK_GET_ADDR(kcontrol->private_value); int shift = AK_GET_SHIFT(kcontrol->private_value); @@ -351,10 +343,9 @@ static int snd_akm4xxx_deemphasis_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_akm4xxx_deemphasis_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_akm4xxx *ak = snd_kcontrol_chip(kcontrol); + akm4xxx_t *ak = snd_kcontrol_chip(kcontrol); int chip = AK_GET_CHIP(kcontrol->private_value); int addr = AK_GET_ADDR(kcontrol->private_value); int shift = AK_GET_SHIFT(kcontrol->private_value); @@ -372,10 +363,10 @@ static int snd_akm4xxx_deemphasis_put(struct snd_kcontrol *kcontrol, * build AK4xxx controls */ -int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) +int snd_akm4xxx_build_controls(akm4xxx_t *ak) { unsigned int idx, num_emphs; - struct snd_kcontrol *ctl; + snd_kcontrol_t *ctl; int err; ctl = kmalloc(sizeof(*ctl), GFP_KERNEL); diff --git a/trunk/sound/i2c/other/tea575x-tuner.c b/trunk/sound/i2c/other/tea575x-tuner.c index 4c2fd14c1056..0f05a2b9a370 100644 --- a/trunk/sound/i2c/other/tea575x-tuner.c +++ b/trunk/sound/i2c/other/tea575x-tuner.c @@ -58,7 +58,7 @@ MODULE_LICENSE("GPL"); * lowlevel part */ -static void snd_tea575x_set_freq(struct snd_tea575x *tea) +static void snd_tea575x_set_freq(tea575x_t *tea) { unsigned long freq; @@ -89,7 +89,7 @@ static int snd_tea575x_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long data) { struct video_device *dev = video_devdata(file); - struct snd_tea575x *tea = video_get_drvdata(dev); + tea575x_t *tea = video_get_drvdata(dev); void __user *arg = (void __user *)data; switch(cmd) { @@ -175,7 +175,7 @@ static void snd_tea575x_release(struct video_device *vfd) /* * initialize all the tea575x chips */ -void snd_tea575x_init(struct snd_tea575x *tea) +void snd_tea575x_init(tea575x_t *tea) { unsigned int val; @@ -209,7 +209,7 @@ void snd_tea575x_init(struct snd_tea575x *tea) snd_tea575x_set_freq(tea); } -void snd_tea575x_exit(struct snd_tea575x *tea) +void snd_tea575x_exit(tea575x_t *tea) { if (tea->vd_registered) { video_unregister_device(&tea->vd); diff --git a/trunk/sound/i2c/tea6330t.c b/trunk/sound/i2c/tea6330t.c index ae5b1e3a68ce..4fdd1fb57dfe 100644 --- a/trunk/sound/i2c/tea6330t.c +++ b/trunk/sound/i2c/tea6330t.c @@ -24,7 +24,6 @@ #include <linux/init.h> #include <linux/slab.h> #include <sound/core.h> -#include <sound/control.h> #include <sound/tea6330t.h> MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); @@ -44,20 +43,7 @@ MODULE_LICENSE("GPL"); #define TEA6330T_GMU 0x80 /* mute control, general mute */ #define TEA6330T_EQN 0x40 /* equalizer switchover (0=equalizer-on) */ - -struct tea6330t { - struct snd_i2c_device *device; - struct snd_i2c_bus *bus; - int equalizer; - int fader; - unsigned char regs[8]; - unsigned char mleft, mright; - unsigned char bass, treble; - unsigned char max_bass, max_treble; -}; - - -int snd_tea6330t_detect(struct snd_i2c_bus *bus, int equalizer) +int snd_tea6330t_detect(snd_i2c_bus_t *bus, int equalizer) { int res; @@ -68,7 +54,7 @@ int snd_tea6330t_detect(struct snd_i2c_bus *bus, int equalizer) } #if 0 -static void snd_tea6330t_set(struct tea6330t *tea, +static void snd_tea6330t_set(tea6330t_t *tea, unsigned char addr, unsigned char value) { #if 0 @@ -83,8 +69,7 @@ static void snd_tea6330t_set(struct tea6330t *tea, .info = snd_tea6330t_info_master_volume, \ .get = snd_tea6330t_get_master_volume, .put = snd_tea6330t_put_master_volume } -static int snd_tea6330t_info_master_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_tea6330t_info_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -93,10 +78,9 @@ static int snd_tea6330t_info_master_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_tea6330t_get_master_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_get_master_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); snd_i2c_lock(tea->bus); ucontrol->value.integer.value[0] = tea->mleft - 0x14; @@ -105,10 +89,9 @@ static int snd_tea6330t_get_master_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_tea6330t_put_master_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_put_master_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); int change, count, err; unsigned char bytes[3]; unsigned char val1, val2; @@ -142,8 +125,7 @@ static int snd_tea6330t_put_master_volume(struct snd_kcontrol *kcontrol, .info = snd_tea6330t_info_master_switch, \ .get = snd_tea6330t_get_master_switch, .put = snd_tea6330t_put_master_switch } -static int snd_tea6330t_info_master_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_tea6330t_info_master_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -152,10 +134,9 @@ static int snd_tea6330t_info_master_switch(struct snd_kcontrol *kcontrol, return 0; } -static int snd_tea6330t_get_master_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_get_master_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); snd_i2c_lock(tea->bus); ucontrol->value.integer.value[0] = tea->regs[TEA6330T_SADDR_VOLUME_LEFT] == 0 ? 0 : 1; @@ -164,10 +145,9 @@ static int snd_tea6330t_get_master_switch(struct snd_kcontrol *kcontrol, return 0; } -static int snd_tea6330t_put_master_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_put_master_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); int change, err; unsigned char bytes[3]; unsigned char oval1, oval2, val1, val2; @@ -194,10 +174,9 @@ static int snd_tea6330t_put_master_switch(struct snd_kcontrol *kcontrol, .info = snd_tea6330t_info_bass, \ .get = snd_tea6330t_get_bass, .put = snd_tea6330t_put_bass } -static int snd_tea6330t_info_bass(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_tea6330t_info_bass(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -206,19 +185,17 @@ static int snd_tea6330t_info_bass(struct snd_kcontrol *kcontrol, return 0; } -static int snd_tea6330t_get_bass(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_get_bass(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = tea->bass; return 0; } -static int snd_tea6330t_put_bass(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_put_bass(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); int change, err; unsigned char bytes[2]; unsigned char val1; @@ -241,10 +218,9 @@ static int snd_tea6330t_put_bass(struct snd_kcontrol *kcontrol, .info = snd_tea6330t_info_treble, \ .get = snd_tea6330t_get_treble, .put = snd_tea6330t_put_treble } -static int snd_tea6330t_info_treble(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_tea6330t_info_treble(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -253,19 +229,17 @@ static int snd_tea6330t_info_treble(struct snd_kcontrol *kcontrol, return 0; } -static int snd_tea6330t_get_treble(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_get_treble(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = tea->treble; return 0; } -static int snd_tea6330t_put_treble(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_tea6330t_put_treble(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct tea6330t *tea = snd_kcontrol_chip(kcontrol); + tea6330t_t *tea = snd_kcontrol_chip(kcontrol); int change, err; unsigned char bytes[2]; unsigned char val1; @@ -283,25 +257,25 @@ static int snd_tea6330t_put_treble(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_tea6330t_controls[] = { +static snd_kcontrol_new_t snd_tea6330t_controls[] = { TEA6330T_MASTER_SWITCH("Master Playback Switch", 0), TEA6330T_MASTER_VOLUME("Master Playback Volume", 0), TEA6330T_BASS("Tone Control - Bass", 0), TEA6330T_TREBLE("Tone Control - Treble", 0) }; -static void snd_tea6330_free(struct snd_i2c_device *device) +static void snd_tea6330_free(snd_i2c_device_t *device) { kfree(device->private_data); } -int snd_tea6330t_update_mixer(struct snd_card *card, - struct snd_i2c_bus *bus, +int snd_tea6330t_update_mixer(snd_card_t * card, + snd_i2c_bus_t *bus, int equalizer, int fader) { - struct snd_i2c_device *device; - struct tea6330t *tea; - struct snd_kcontrol_new *knew; + snd_i2c_device_t *device; + tea6330t_t *tea; + snd_kcontrol_new_t *knew; unsigned int idx; int err = -ENOMEM; u8 default_treble, default_bass; diff --git a/trunk/sound/isa/Kconfig b/trunk/sound/isa/Kconfig index ff8fef932786..5d6c300ac0d5 100644 --- a/trunk/sound/isa/Kconfig +++ b/trunk/sound/isa/Kconfig @@ -6,10 +6,12 @@ menu "ISA devices" config SND_AD1848_LIB tristate select SND_PCM + select SND_GENERIC_DRIVER config SND_CS4231_LIB tristate select SND_PCM + select SND_GENERIC_DRIVER config SND_AD1816A tristate "Analog Devices SoundPort AD1816A" @@ -39,45 +41,6 @@ config SND_AD1848 To compile this driver as a module, choose M here: the module will be called snd-ad1848. -config SND_ALS100 - tristate "Avance Logic ALS100/ALS120" - depends on SND && PNP && ISA - select ISAPNP - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_PCM - help - Say Y here to include support for soundcards based on Avance - Logic ALS100, ALS110, ALS120 and ALS200 chips. - - To compile this driver as a module, choose M here: the module - will be called snd-als100. - -config SND_AZT2320 - tristate "Aztech Systems AZT2320" - depends on SND && PNP && ISA - select ISAPNP - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_CS4231_LIB - help - Say Y here to include support for soundcards based on the - Aztech Systems AZT2320 chip. - - To compile this driver as a module, choose M here: the module - will be called snd-azt2320. - -config SND_CMI8330 - tristate "C-Media CMI8330" - depends on SND - select SND_AD1848_LIB - help - Say Y here to include support for soundcards based on the - C-Media CMI8330 chip. - - To compile this driver as a module, choose M here: the module - will be called snd-cmi8330. - config SND_CS4231 tristate "Generic Cirrus Logic CS4231 driver" depends on SND @@ -116,20 +79,6 @@ config SND_CS4236 To compile this driver as a module, choose M here: the module will be called snd-cs4236. -config SND_DT019X - tristate "Diamond Technologies DT-019X, Avance Logic ALS-007" - depends on SND && PNP && ISA - select ISAPNP - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_PCM - help - Say Y here to include support for soundcards based on the - Diamond Technologies DT-019X or Avance Logic ALS-007 chips. - - To compile this driver as a module, choose M here: the module - will be called snd-dt019x. - config SND_ES968 tristate "Generic ESS ES968 driver" depends on SND && PNP && ISA @@ -148,6 +97,7 @@ config SND_ES1688 select SND_OPL3_LIB select SND_MPU401_UART select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for ESS AudioDrive ES688 or ES1688 chips. @@ -161,6 +111,7 @@ config SND_ES18XX select SND_OPL3_LIB select SND_MPU401_UART select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for ESS AudioDrive ES18xx chips. @@ -176,6 +127,7 @@ config SND_GUSCLASSIC select SND_RAWMIDI select SND_PCM select SND_GUS_SYNTH + select SND_GENERIC_DRIVER help Say Y here to include support for Gravis UltraSound Classic soundcards. @@ -190,6 +142,7 @@ config SND_GUSEXTREME select SND_MPU401_UART select SND_PCM select SND_GUS_SYNTH + select SND_GENERIC_DRIVER help Say Y here to include support for Gravis UltraSound Extreme soundcards. @@ -203,6 +156,7 @@ config SND_GUSMAX select SND_RAWMIDI select SND_CS4231_LIB select SND_GUS_SYNTH + select SND_GENERIC_DRIVER help Say Y here to include support for Gravis UltraSound MAX soundcards. @@ -216,6 +170,7 @@ config SND_INTERWAVE select SND_RAWMIDI select SND_CS4231_LIB select SND_GUS_SYNTH + select SND_GENERIC_DRIVER help Say Y here to include support for AMD InterWave based soundcards (Gravis UltraSound Plug & Play, STB SoundRage32, @@ -230,6 +185,7 @@ config SND_INTERWAVE_STB select SND_RAWMIDI select SND_CS4231_LIB select SND_GUS_SYNTH + select SND_GENERIC_DRIVER help Say Y here to include support for AMD InterWave based soundcards with a TEA6330T bass and treble regulator @@ -238,19 +194,6 @@ config SND_INTERWAVE_STB To compile this driver as a module, choose M here: the module will be called snd-interwave-stb. -config SND_OPL3SA2 - tristate "Yamaha OPL3-SA2/SA3" - depends on SND - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_CS4231_LIB - help - Say Y here to include support for Yamaha OPL3-SA2 and OPL3-SA3 - chips. - - To compile this driver as a module, choose M here: the module - will be called snd-opl3sa2. - config SND_OPTI92X_AD1848 tristate "OPTi 82C92x - AD1848" depends on SND @@ -285,6 +228,7 @@ config SND_OPTI93X select SND_OPL3_LIB select SND_MPU401_UART select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for soundcards based on Opti 82C93x chips. @@ -298,6 +242,7 @@ config SND_SB8 select SND_OPL3_LIB select SND_RAWMIDI select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for Creative Sound Blaster 1.0/ 2.0/Pro (8-bit) or 100% compatible soundcards. @@ -311,6 +256,7 @@ config SND_SB16 select SND_OPL3_LIB select SND_MPU401_UART select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for Sound Blaster 16 soundcards (including the Plug and Play version). @@ -324,6 +270,7 @@ config SND_SBAWE select SND_OPL3_LIB select SND_MPU401_UART select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for Sound Blaster AWE soundcards (including the Plug and Play version). @@ -339,6 +286,85 @@ config SND_SB16_CSP coprocessor can do variable tasks like various compression and decompression algorithms. +config SND_WAVEFRONT + tristate "Turtle Beach Maui,Tropez,Tropez+ (Wavefront)" + depends on SND + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_CS4231_LIB + help + Say Y here to include support for Turtle Beach Maui, Tropez + and Tropez+ soundcards based on the Wavefront chip. + + To compile this driver as a module, choose M here: the module + will be called snd-wavefront. + +config SND_ALS100 + tristate "Avance Logic ALS100/ALS120" + depends on SND && PNP && ISA + select ISAPNP + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_PCM + help + Say Y here to include support for soundcards based on Avance + Logic ALS100, ALS110, ALS120 and ALS200 chips. + + To compile this driver as a module, choose M here: the module + will be called snd-als100. + +config SND_AZT2320 + tristate "Aztech Systems AZT2320" + depends on SND && PNP && ISA + select ISAPNP + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_CS4231_LIB + help + Say Y here to include support for soundcards based on the + Aztech Systems AZT2320 chip. + + To compile this driver as a module, choose M here: the module + will be called snd-azt2320. + +config SND_CMI8330 + tristate "C-Media CMI8330" + depends on SND + select SND_AD1848_LIB + help + Say Y here to include support for soundcards based on the + C-Media CMI8330 chip. + + To compile this driver as a module, choose M here: the module + will be called snd-cmi8330. + +config SND_DT019X + tristate "Diamond Technologies DT-019X, Avance Logic ALS-007" + depends on SND && PNP && ISA + select ISAPNP + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_PCM + help + Say Y here to include support for soundcards based on the + Diamond Technologies DT-019X or Avance Logic ALS-007 chips. + + To compile this driver as a module, choose M here: the module + will be called snd-dt019x. + +config SND_OPL3SA2 + tristate "Yamaha OPL3-SA2/SA3" + depends on SND + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_CS4231_LIB + help + Say Y here to include support for Yamaha OPL3-SA2 and OPL3-SA3 + chips. + + To compile this driver as a module, choose M here: the module + will be called snd-opl3sa2. + config SND_SGALAXY tristate "Aztech Sound Galaxy" depends on SND @@ -363,17 +389,4 @@ config SND_SSCAPE To compile this driver as a module, choose M here: the module will be called snd-sscape. -config SND_WAVEFRONT - tristate "Turtle Beach Maui,Tropez,Tropez+ (Wavefront)" - depends on SND - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_CS4231_LIB - help - Say Y here to include support for Turtle Beach Maui, Tropez - and Tropez+ soundcards based on the Wavefront chip. - - To compile this driver as a module, choose M here: the module - will be called snd-wavefront. - endmenu diff --git a/trunk/sound/isa/ad1816a/Makefile b/trunk/sound/isa/ad1816a/Makefile index 90e00e842e49..a42b29cf8549 100644 --- a/trunk/sound/isa/ad1816a/Makefile +++ b/trunk/sound/isa/ad1816a/Makefile @@ -3,7 +3,8 @@ # Copyright (c) 2001 by Jaroslav Kysela <perex@suse.cz> # -snd-ad1816a-objs := ad1816a.o ad1816a_lib.o +snd-ad1816a-lib-objs := ad1816a_lib.o +snd-ad1816a-objs := ad1816a.o # Toplevel Module Dependency -obj-$(CONFIG_SND_AD1816A) += snd-ad1816a.o +obj-$(CONFIG_SND_AD1816A) += snd-ad1816a.o snd-ad1816a-lib.o diff --git a/trunk/sound/isa/ad1816a/ad1816a.c b/trunk/sound/isa/ad1816a/ad1816a.c index 7051f7798ed7..0eb442ca23d6 100644 --- a/trunk/sound/isa/ad1816a/ad1816a.c +++ b/trunk/sound/isa/ad1816a/ad1816a.c @@ -188,10 +188,10 @@ static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard const struct pnp_card_device_id *pid) { int error; - struct snd_card *card; + snd_card_t *card; struct snd_card_ad1816a *acard; - struct snd_ad1816a *chip; - struct snd_opl3 *opl3; + ad1816a_t *chip; + opl3_t *opl3; if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_card_ad1816a))) == NULL) @@ -282,8 +282,10 @@ static int __devinit snd_ad1816a_pnp_detect(struct pnp_card_link *card, static void __devexit snd_ad1816a_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + + snd_card_disconnect(card); + snd_card_free_in_thread(card); } static struct pnp_card_driver ad1816a_pnpc_driver = { @@ -292,22 +294,20 @@ static struct pnp_card_driver ad1816a_pnpc_driver = { .id_table = snd_ad1816a_pnpids, .probe = snd_ad1816a_pnp_detect, .remove = __devexit_p(snd_ad1816a_pnp_remove), - /* FIXME: suspend/resume */ }; static int __init alsa_card_ad1816a_init(void) { - int cards; + int cards = 0; - cards = pnp_register_card_driver(&ad1816a_pnpc_driver); - if (cards <= 0) { - pnp_unregister_card_driver(&ad1816a_pnpc_driver); + cards += pnp_register_card_driver(&ad1816a_pnpc_driver); #ifdef MODULE + if (!cards) { + pnp_unregister_card_driver(&ad1816a_pnpc_driver); printk(KERN_ERR "no AD1816A based soundcards found.\n"); -#endif /* MODULE */ - return -ENODEV; } - return 0; +#endif /* MODULE */ + return cards ? 0 : -ENODEV; } static void __exit alsa_card_ad1816a_exit(void) diff --git a/trunk/sound/isa/ad1816a/ad1816a_lib.c b/trunk/sound/isa/ad1816a/ad1816a_lib.c index ac0d808fff57..7ae02396cae2 100644 --- a/trunk/sound/isa/ad1816a/ad1816a_lib.c +++ b/trunk/sound/isa/ad1816a/ad1816a_lib.c @@ -30,7 +30,11 @@ #include <asm/io.h> #include <asm/dma.h> -static inline int snd_ad1816a_busy_wait(struct snd_ad1816a *chip) +MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>"); +MODULE_DESCRIPTION("lowlevel code for Analog Devices AD1816A chip"); +MODULE_LICENSE("GPL"); + +static inline int snd_ad1816a_busy_wait(ad1816a_t *chip) { int timeout; @@ -42,34 +46,34 @@ static inline int snd_ad1816a_busy_wait(struct snd_ad1816a *chip) return -EBUSY; } -static inline unsigned char snd_ad1816a_in(struct snd_ad1816a *chip, unsigned char reg) +static inline unsigned char snd_ad1816a_in(ad1816a_t *chip, unsigned char reg) { snd_ad1816a_busy_wait(chip); return inb(AD1816A_REG(reg)); } -static inline void snd_ad1816a_out(struct snd_ad1816a *chip, unsigned char reg, +static inline void snd_ad1816a_out(ad1816a_t *chip, unsigned char reg, unsigned char value) { snd_ad1816a_busy_wait(chip); outb(value, AD1816A_REG(reg)); } -static inline void snd_ad1816a_out_mask(struct snd_ad1816a *chip, unsigned char reg, +static inline void snd_ad1816a_out_mask(ad1816a_t *chip, unsigned char reg, unsigned char mask, unsigned char value) { snd_ad1816a_out(chip, reg, (value & mask) | (snd_ad1816a_in(chip, reg) & ~mask)); } -static unsigned short snd_ad1816a_read(struct snd_ad1816a *chip, unsigned char reg) +static unsigned short snd_ad1816a_read(ad1816a_t *chip, unsigned char reg) { snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, reg & 0x3f); return snd_ad1816a_in(chip, AD1816A_INDIR_DATA_LOW) | (snd_ad1816a_in(chip, AD1816A_INDIR_DATA_HIGH) << 8); } -static void snd_ad1816a_write(struct snd_ad1816a *chip, unsigned char reg, +static void snd_ad1816a_write(ad1816a_t *chip, unsigned char reg, unsigned short value) { snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, reg & 0x3f); @@ -77,7 +81,7 @@ static void snd_ad1816a_write(struct snd_ad1816a *chip, unsigned char reg, snd_ad1816a_out(chip, AD1816A_INDIR_DATA_HIGH, (value >> 8) & 0xff); } -static void snd_ad1816a_write_mask(struct snd_ad1816a *chip, unsigned char reg, +static void snd_ad1816a_write_mask(ad1816a_t *chip, unsigned char reg, unsigned short mask, unsigned short value) { snd_ad1816a_write(chip, reg, @@ -85,7 +89,7 @@ static void snd_ad1816a_write_mask(struct snd_ad1816a *chip, unsigned char reg, } -static unsigned char snd_ad1816a_get_format(struct snd_ad1816a *chip, +static unsigned char snd_ad1816a_get_format(ad1816a_t *chip, unsigned int format, int channels) { unsigned char retval = AD1816A_FMT_LINEAR_8; @@ -106,7 +110,7 @@ static unsigned char snd_ad1816a_get_format(struct snd_ad1816a *chip, return (channels > 1) ? (retval | AD1816A_FMT_STEREO) : retval; } -static int snd_ad1816a_open(struct snd_ad1816a *chip, unsigned int mode) +static int snd_ad1816a_open(ad1816a_t *chip, unsigned int mode) { unsigned long flags; @@ -142,7 +146,7 @@ static int snd_ad1816a_open(struct snd_ad1816a *chip, unsigned int mode) return 0; } -static void snd_ad1816a_close(struct snd_ad1816a *chip, unsigned int mode) +static void snd_ad1816a_close(ad1816a_t *chip, unsigned int mode) { unsigned long flags; @@ -174,7 +178,7 @@ static void snd_ad1816a_close(struct snd_ad1816a *chip, unsigned int mode) } -static int snd_ad1816a_trigger(struct snd_ad1816a *chip, unsigned char what, +static int snd_ad1816a_trigger(ad1816a_t *chip, unsigned char what, int channel, int cmd) { int error = 0; @@ -200,36 +204,36 @@ static int snd_ad1816a_trigger(struct snd_ad1816a *chip, unsigned char what, return error; } -static int snd_ad1816a_playback_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_ad1816a_playback_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); return snd_ad1816a_trigger(chip, AD1816A_PLAYBACK_ENABLE, SNDRV_PCM_STREAM_PLAYBACK, cmd); } -static int snd_ad1816a_capture_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_ad1816a_capture_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); return snd_ad1816a_trigger(chip, AD1816A_CAPTURE_ENABLE, SNDRV_PCM_STREAM_CAPTURE, cmd); } -static int snd_ad1816a_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ad1816a_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_ad1816a_hw_free(struct snd_pcm_substream *substream) +static int snd_ad1816a_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_ad1816a_playback_prepare(struct snd_pcm_substream *substream) +static int snd_ad1816a_playback_prepare(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); unsigned long flags; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size, rate; spin_lock_irqsave(&chip->lock, flags); @@ -257,11 +261,11 @@ static int snd_ad1816a_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1816a_capture_prepare(struct snd_pcm_substream *substream) +static int snd_ad1816a_capture_prepare(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); unsigned long flags; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size, rate; spin_lock_irqsave(&chip->lock, flags); @@ -290,9 +294,9 @@ static int snd_ad1816a_capture_prepare(struct snd_pcm_substream *substream) } -static snd_pcm_uframes_t snd_ad1816a_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ad1816a_playback_pointer(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->mode & AD1816A_MODE_PLAYBACK)) return 0; @@ -300,9 +304,9 @@ static snd_pcm_uframes_t snd_ad1816a_playback_pointer(struct snd_pcm_substream * return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_ad1816a_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ad1816a_capture_pointer(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->mode & AD1816A_MODE_CAPTURE)) return 0; @@ -313,7 +317,7 @@ static snd_pcm_uframes_t snd_ad1816a_capture_pointer(struct snd_pcm_substream *s static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_ad1816a *chip = dev_id; + ad1816a_t *chip = dev_id; unsigned char status; spin_lock(&chip->lock); @@ -336,7 +340,7 @@ static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs * } -static struct snd_pcm_hardware snd_ad1816a_playback = { +static snd_pcm_hardware_t snd_ad1816a_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | @@ -355,7 +359,7 @@ static struct snd_pcm_hardware snd_ad1816a_playback = { .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ad1816a_capture = { +static snd_pcm_hardware_t snd_ad1816a_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | @@ -375,32 +379,32 @@ static struct snd_pcm_hardware snd_ad1816a_capture = { }; #if 0 /* not used now */ -static int snd_ad1816a_timer_close(struct snd_timer *timer) +static int snd_ad1816a_timer_close(snd_timer_t *timer) { - struct snd_ad1816a *chip = snd_timer_chip(timer); + ad1816a_t *chip = snd_timer_chip(timer); snd_ad1816a_close(chip, AD1816A_MODE_TIMER); return 0; } -static int snd_ad1816a_timer_open(struct snd_timer *timer) +static int snd_ad1816a_timer_open(snd_timer_t *timer) { - struct snd_ad1816a *chip = snd_timer_chip(timer); + ad1816a_t *chip = snd_timer_chip(timer); snd_ad1816a_open(chip, AD1816A_MODE_TIMER); return 0; } -static unsigned long snd_ad1816a_timer_resolution(struct snd_timer *timer) +static unsigned long snd_ad1816a_timer_resolution(snd_timer_t *timer) { snd_assert(timer != NULL, return 0); return 10000; } -static int snd_ad1816a_timer_start(struct snd_timer *timer) +static int snd_ad1816a_timer_start(snd_timer_t *timer) { unsigned short bits; unsigned long flags; - struct snd_ad1816a *chip = snd_timer_chip(timer); + ad1816a_t *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->lock, flags); bits = snd_ad1816a_read(chip, AD1816A_INTERRUPT_ENABLE); @@ -415,10 +419,10 @@ static int snd_ad1816a_timer_start(struct snd_timer *timer) return 0; } -static int snd_ad1816a_timer_stop(struct snd_timer *timer) +static int snd_ad1816a_timer_stop(snd_timer_t *timer) { unsigned long flags; - struct snd_ad1816a *chip = snd_timer_chip(timer); + ad1816a_t *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->lock, flags); snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE, @@ -428,7 +432,7 @@ static int snd_ad1816a_timer_stop(struct snd_timer *timer) return 0; } -static struct snd_timer_hardware snd_ad1816a_timer_table = { +static struct _snd_timer_hardware snd_ad1816a_timer_table = { .flags = SNDRV_TIMER_HW_AUTO, .resolution = 10000, .ticks = 65535, @@ -441,10 +445,10 @@ static struct snd_timer_hardware snd_ad1816a_timer_table = { #endif /* not used now */ -static int snd_ad1816a_playback_open(struct snd_pcm_substream *substream) +static int snd_ad1816a_playback_open(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ad1816a_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int error; if ((error = snd_ad1816a_open(chip, AD1816A_MODE_PLAYBACK)) < 0) @@ -457,10 +461,10 @@ static int snd_ad1816a_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1816a_capture_open(struct snd_pcm_substream *substream) +static int snd_ad1816a_capture_open(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ad1816a_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int error; if ((error = snd_ad1816a_open(chip, AD1816A_MODE_CAPTURE)) < 0) @@ -473,18 +477,18 @@ static int snd_ad1816a_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1816a_playback_close(struct snd_pcm_substream *substream) +static int snd_ad1816a_playback_close(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); chip->playback_substream = NULL; snd_ad1816a_close(chip, AD1816A_MODE_PLAYBACK); return 0; } -static int snd_ad1816a_capture_close(struct snd_pcm_substream *substream) +static int snd_ad1816a_capture_close(snd_pcm_substream_t *substream) { - struct snd_ad1816a *chip = snd_pcm_substream_chip(substream); + ad1816a_t *chip = snd_pcm_substream_chip(substream); chip->capture_substream = NULL; snd_ad1816a_close(chip, AD1816A_MODE_CAPTURE); @@ -492,7 +496,7 @@ static int snd_ad1816a_capture_close(struct snd_pcm_substream *substream) } -static void __devinit snd_ad1816a_init(struct snd_ad1816a *chip) +static void snd_ad1816a_init(ad1816a_t *chip) { unsigned long flags; @@ -512,7 +516,7 @@ static void __devinit snd_ad1816a_init(struct snd_ad1816a *chip) spin_unlock_irqrestore(&chip->lock, flags); } -static int __devinit snd_ad1816a_probe(struct snd_ad1816a *chip) +static int snd_ad1816a_probe(ad1816a_t *chip) { unsigned long flags; @@ -536,7 +540,7 @@ static int __devinit snd_ad1816a_probe(struct snd_ad1816a *chip) return 0; } -static int snd_ad1816a_free(struct snd_ad1816a *chip) +static int snd_ad1816a_free(ad1816a_t *chip) { release_and_free_resource(chip->res_port); if (chip->irq >= 0) @@ -553,13 +557,13 @@ static int snd_ad1816a_free(struct snd_ad1816a *chip) return 0; } -static int snd_ad1816a_dev_free(struct snd_device *device) +static int snd_ad1816a_dev_free(snd_device_t *device) { - struct snd_ad1816a *chip = device->device_data; + ad1816a_t *chip = device->device_data; return snd_ad1816a_free(chip); } -static const char __devinit *snd_ad1816a_chip_id(struct snd_ad1816a *chip) +static const char *snd_ad1816a_chip_id(ad1816a_t *chip) { switch (chip->hardware) { case AD1816A_HW_AD1816A: return "AD1816A"; @@ -572,15 +576,15 @@ static const char __devinit *snd_ad1816a_chip_id(struct snd_ad1816a *chip) } } -int __devinit snd_ad1816a_create(struct snd_card *card, - unsigned long port, int irq, int dma1, int dma2, - struct snd_ad1816a **rchip) +int snd_ad1816a_create(snd_card_t *card, + unsigned long port, int irq, int dma1, int dma2, + ad1816a_t **rchip) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ad1816a_dev_free, }; int error; - struct snd_ad1816a *chip; + ad1816a_t *chip; *rchip = NULL; @@ -636,7 +640,7 @@ int __devinit snd_ad1816a_create(struct snd_card *card, return 0; } -static struct snd_pcm_ops snd_ad1816a_playback_ops = { +static snd_pcm_ops_t snd_ad1816a_playback_ops = { .open = snd_ad1816a_playback_open, .close = snd_ad1816a_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -647,7 +651,7 @@ static struct snd_pcm_ops snd_ad1816a_playback_ops = { .pointer = snd_ad1816a_playback_pointer, }; -static struct snd_pcm_ops snd_ad1816a_capture_ops = { +static snd_pcm_ops_t snd_ad1816a_capture_ops = { .open = snd_ad1816a_capture_open, .close = snd_ad1816a_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -658,10 +662,17 @@ static struct snd_pcm_ops snd_ad1816a_capture_ops = { .pointer = snd_ad1816a_capture_pointer, }; -int __devinit snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_pcm **rpcm) +static void snd_ad1816a_pcm_free(snd_pcm_t *pcm) +{ + ad1816a_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int snd_ad1816a_pcm(ad1816a_t *chip, int device, snd_pcm_t **rpcm) { int error; - struct snd_pcm *pcm; + snd_pcm_t *pcm; if ((error = snd_pcm_new(chip->card, "AD1816A", device, 1, 1, &pcm))) return error; @@ -670,6 +681,7 @@ int __devinit snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_p snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ad1816a_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_ad1816a_pcm_free; pcm->info_flags = (chip->dma1 == chip->dma2 ) ? SNDRV_PCM_INFO_JOINT_DUPLEX : 0; strcpy(pcm->name, snd_ad1816a_chip_id(chip)); @@ -686,10 +698,16 @@ int __devinit snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_p } #if 0 /* not used now */ -int __devinit snd_ad1816a_timer(struct snd_ad1816a *chip, int device, struct snd_timer **rtimer) +static void snd_ad1816a_timer_free(snd_timer_t *timer) { - struct snd_timer *timer; - struct snd_timer_id tid; + ad1816a_t *chip = timer->private_data; + chip->timer = NULL; +} + +int snd_ad1816a_timer(ad1816a_t *chip, int device, snd_timer_t **rtimer) +{ + snd_timer_t *timer; + snd_timer_id_t tid; int error; tid.dev_class = SNDRV_TIMER_CLASS_CARD; @@ -701,6 +719,7 @@ int __devinit snd_ad1816a_timer(struct snd_ad1816a *chip, int device, struct snd return error; strcpy(timer->name, snd_ad1816a_chip_id(chip)); timer->private_data = chip; + timer->private_free = snd_ad1816a_timer_free; chip->timer = timer; timer->hw = snd_ad1816a_timer_table; if (rtimer) @@ -713,7 +732,7 @@ int __devinit snd_ad1816a_timer(struct snd_ad1816a *chip, int device, struct snd * */ -static int snd_ad1816a_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ad1816a_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[8] = { "Line", "Mix", "CD", "Synth", "Video", @@ -729,9 +748,9 @@ static int snd_ad1816a_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int snd_ad1816a_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1816a_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol); + ad1816a_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned short val; @@ -743,9 +762,9 @@ static int snd_ad1816a_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_ad1816a_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1816a_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol); + ad1816a_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned short val; int change; @@ -767,7 +786,7 @@ static int snd_ad1816a_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele .get = snd_ad1816a_get_single, .put = snd_ad1816a_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_ad1816a_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ad1816a_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -778,9 +797,9 @@ static int snd_ad1816a_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_ad1816a_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1816a_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol); + ad1816a_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -795,9 +814,9 @@ static int snd_ad1816a_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ad1816a_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1816a_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol); + ad1816a_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -824,7 +843,7 @@ static int snd_ad1816a_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ .get = snd_ad1816a_get_double, .put = snd_ad1816a_put_double, \ .private_value = reg | (shift_left << 8) | (shift_right << 12) | (mask << 16) | (invert << 24) } -static int snd_ad1816a_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ad1816a_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -835,9 +854,9 @@ static int snd_ad1816a_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_ad1816a_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1816a_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol); + ad1816a_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift_left = (kcontrol->private_value >> 8) & 0x0f; @@ -858,9 +877,9 @@ static int snd_ad1816a_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ad1816a_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1816a_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol); + ad1816a_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift_left = (kcontrol->private_value >> 8) & 0x0f; @@ -887,7 +906,7 @@ static int snd_ad1816a_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return change; } -static struct snd_kcontrol_new snd_ad1816a_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_ad1816a_controls[] = { AD1816A_DOUBLE("Master Playback Switch", AD1816A_MASTER_ATT, 15, 7, 1, 1), AD1816A_DOUBLE("Master Playback Volume", AD1816A_MASTER_ATT, 8, 0, 31, 1), AD1816A_DOUBLE("PCM Playback Switch", AD1816A_VOICE_ATT, 15, 7, 1, 1), @@ -922,9 +941,9 @@ AD1816A_SINGLE("3D Control - Switch", AD1816A_3D_PHAT_CTRL, 15, 1, 1), AD1816A_SINGLE("3D Control - Level", AD1816A_3D_PHAT_CTRL, 0, 15, 0), }; -int __devinit snd_ad1816a_mixer(struct snd_ad1816a *chip) +int snd_ad1816a_mixer(ad1816a_t *chip) { - struct snd_card *card; + snd_card_t *card; unsigned int idx; int err; @@ -940,3 +959,19 @@ int __devinit snd_ad1816a_mixer(struct snd_ad1816a *chip) } return 0; } + +EXPORT_SYMBOL(snd_ad1816a_create); +EXPORT_SYMBOL(snd_ad1816a_pcm); +EXPORT_SYMBOL(snd_ad1816a_mixer); + +static int __init alsa_ad1816a_init(void) +{ + return 0; +} + +static void __exit alsa_ad1816a_exit(void) +{ +} + +module_init(alsa_ad1816a_init) +module_exit(alsa_ad1816a_exit) diff --git a/trunk/sound/isa/ad1848/ad1848.c b/trunk/sound/isa/ad1848/ad1848.c index e091bbeffd2a..3ebcc482b07a 100644 --- a/trunk/sound/isa/ad1848/ad1848.c +++ b/trunk/sound/isa/ad1848/ad1848.c @@ -23,8 +23,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/time.h> #include <linux/wait.h> #include <linux/moduleparam.h> @@ -62,15 +60,14 @@ MODULE_PARM_DESC(dma1, "DMA1 # for AD1848 driver."); module_param_array(thinkpad, bool, NULL, 0444); MODULE_PARM_DESC(thinkpad, "Enable only for the onboard CS4248 of IBM Thinkpad 360/750/755 series."); -static struct platform_device *devices[SNDRV_CARDS]; +static snd_card_t *snd_ad1848_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; -static int __init snd_ad1848_probe(struct platform_device *pdev) +static int __init snd_card_ad1848_probe(int dev) { - int dev = pdev->id; - struct snd_card *card; - struct snd_ad1848 *chip; - struct snd_pcm *pcm; + snd_card_t *card; + ad1848_t *chip; + snd_pcm_t *pcm; int err; if (port[dev] == SNDRV_AUTO_PORT) { @@ -96,7 +93,6 @@ static int __init snd_ad1848_probe(struct platform_device *pdev) thinkpad[dev] ? AD1848_HW_THINKPAD : AD1848_HW_DETECT, &chip)) < 0) goto _err; - card->private_data = chip; if ((err = snd_ad1848_pcm(chip, 0, &pcm)) < 0) goto _err; @@ -113,12 +109,13 @@ static int __init snd_ad1848_probe(struct platform_device *pdev) if (thinkpad[dev]) strcat(card->longname, " [Thinkpad]"); - snd_card_set_dev(card, &pdev->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; - platform_set_drvdata(pdev, card); + snd_ad1848_cards[dev] = card; return 0; _err: @@ -126,95 +123,29 @@ static int __init snd_ad1848_probe(struct platform_device *pdev) return err; } -static int __devexit snd_ad1848_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_ad1848_suspend(struct platform_device *pdev, pm_message_t state) -{ - struct snd_card *card = platform_get_drvdata(pdev); - struct snd_ad1848 *chip = card->private_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - chip->suspend(chip); - return 0; -} - -static int snd_ad1848_resume(struct platform_device *pdev) -{ - struct snd_card *card = platform_get_drvdata(pdev); - struct snd_ad1848 *chip = card->private_data; - - chip->resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - -#define SND_AD1848_DRIVER "snd_ad1848" - -static struct platform_driver snd_ad1848_driver = { - .probe = snd_ad1848_probe, - .remove = __devexit_p(snd_ad1848_remove), -#ifdef CONFIG_PM - .suspend = snd_ad1848_suspend, - .resume = snd_ad1848_resume, -#endif - .driver = { - .name = SND_AD1848_DRIVER - }, -}; - -static void __init_or_module snd_ad1848_unregister_all(void) +static int __init alsa_card_ad1848_init(void) { - int i; + int dev, cards; - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_ad1848_driver); -} + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) + if (snd_card_ad1848_probe(dev) >= 0) + cards++; -static int __init alsa_card_ad1848_init(void) -{ - int i, cards, err; - - err = platform_driver_register(&snd_ad1848_driver); - if (err < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(SND_AD1848_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; - } if (!cards) { #ifdef MODULE printk(KERN_ERR "AD1848 soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_ad1848_unregister_all(); - return err; } static void __exit alsa_card_ad1848_exit(void) { - snd_ad1848_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_ad1848_cards[idx]); } module_init(alsa_card_ad1848_init) diff --git a/trunk/sound/isa/ad1848/ad1848_lib.c b/trunk/sound/isa/ad1848/ad1848_lib.c index b78530d7ea90..891bacc94f68 100644 --- a/trunk/sound/isa/ad1848/ad1848_lib.c +++ b/trunk/sound/isa/ad1848/ad1848_lib.c @@ -24,6 +24,7 @@ #include <linux/delay.h> #include <linux/init.h> #include <linux/interrupt.h> +#include <linux/pm.h> #include <linux/slab.h> #include <linux/ioport.h> #include <sound/core.h> @@ -68,7 +69,7 @@ static unsigned int rates[14] = { 27042, 32000, 33075, 37800, 44100, 48000 }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = 14, .list = rates, .mask = 0, @@ -98,7 +99,7 @@ static unsigned char snd_ad1848_original_image[16] = * Basic I/O functions */ -void snd_ad1848_out(struct snd_ad1848 *chip, +void snd_ad1848_out(ad1848_t *chip, unsigned char reg, unsigned char value) { @@ -118,7 +119,7 @@ void snd_ad1848_out(struct snd_ad1848 *chip, #endif } -static void snd_ad1848_dout(struct snd_ad1848 *chip, +static void snd_ad1848_dout(ad1848_t *chip, unsigned char reg, unsigned char value) { int timeout; @@ -130,7 +131,7 @@ static void snd_ad1848_dout(struct snd_ad1848 *chip, mb(); } -static unsigned char snd_ad1848_in(struct snd_ad1848 *chip, unsigned char reg) +static unsigned char snd_ad1848_in(ad1848_t *chip, unsigned char reg) { int timeout; @@ -147,7 +148,7 @@ static unsigned char snd_ad1848_in(struct snd_ad1848 *chip, unsigned char reg) #if 0 -static void snd_ad1848_debug(struct snd_ad1848 *chip) +static void snd_ad1848_debug(ad1848_t *chip) { printk("AD1848 REGS: INDEX = 0x%02x ", inb(AD1848P(chip, REGSEL))); printk(" STATUS = 0x%02x\n", inb(AD1848P(chip, STATUS))); @@ -175,7 +176,7 @@ static void snd_ad1848_debug(struct snd_ad1848 *chip) * AD1848 detection / MCE routines */ -static void snd_ad1848_mce_up(struct snd_ad1848 *chip) +static void snd_ad1848_mce_up(ad1848_t *chip) { unsigned long flags; int timeout; @@ -196,7 +197,7 @@ static void snd_ad1848_mce_up(struct snd_ad1848 *chip) spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_ad1848_mce_down(struct snd_ad1848 *chip) +static void snd_ad1848_mce_down(ad1848_t *chip) { unsigned long flags; int timeout; @@ -278,7 +279,7 @@ static unsigned int snd_ad1848_get_count(unsigned char format, return size; } -static int snd_ad1848_trigger(struct snd_ad1848 *chip, unsigned char what, +static int snd_ad1848_trigger(ad1848_t *chip, unsigned char what, int channel, int cmd) { int result = 0; @@ -323,7 +324,7 @@ static unsigned char snd_ad1848_get_rate(unsigned int rate) return freq_bits[13]; } -static int snd_ad1848_ioctl(struct snd_pcm_substream *substream, +static int snd_ad1848_ioctl(snd_pcm_substream_t * substream, unsigned int cmd, void *arg) { return snd_pcm_lib_ioctl(substream, cmd, arg); @@ -347,7 +348,7 @@ static unsigned char snd_ad1848_get_format(int format, int channels) return rformat; } -static void snd_ad1848_calibrate_mute(struct snd_ad1848 *chip, int mute) +static void snd_ad1848_calibrate_mute(ad1848_t *chip, int mute) { unsigned long flags; @@ -371,7 +372,7 @@ static void snd_ad1848_calibrate_mute(struct snd_ad1848 *chip, int mute) spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_ad1848_set_data_format(struct snd_ad1848 *chip, struct snd_pcm_hw_params *hw_params) +static void snd_ad1848_set_data_format(ad1848_t *chip, snd_pcm_hw_params_t *hw_params) { if (hw_params == NULL) { chip->image[AD1848_DATA_FORMAT] = 0x20; @@ -383,7 +384,7 @@ static void snd_ad1848_set_data_format(struct snd_ad1848 *chip, struct snd_pcm_h // snd_printk(">>> pmode = 0x%x, dfr = 0x%x\n", pstr->mode, chip->image[AD1848_DATA_FORMAT]); } -static int snd_ad1848_open(struct snd_ad1848 *chip, unsigned int mode) +static int snd_ad1848_open(ad1848_t *chip, unsigned int mode) { unsigned long flags; @@ -437,7 +438,7 @@ static int snd_ad1848_open(struct snd_ad1848 *chip, unsigned int mode) return 0; } -static void snd_ad1848_close(struct snd_ad1848 *chip) +static void snd_ad1848_close(ad1848_t *chip) { unsigned long flags; @@ -478,24 +479,24 @@ static void snd_ad1848_close(struct snd_ad1848 *chip) * ok.. exported functions.. */ -static int snd_ad1848_playback_trigger(struct snd_pcm_substream *substream, +static int snd_ad1848_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); return snd_ad1848_trigger(chip, AD1848_PLAYBACK_ENABLE, SNDRV_PCM_STREAM_PLAYBACK, cmd); } -static int snd_ad1848_capture_trigger(struct snd_pcm_substream *substream, +static int snd_ad1848_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); return snd_ad1848_trigger(chip, AD1848_CAPTURE_ENABLE, SNDRV_PCM_STREAM_CAPTURE, cmd); } -static int snd_ad1848_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ad1848_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); unsigned long flags; int err; @@ -512,15 +513,15 @@ static int snd_ad1848_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_ad1848_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_ad1848_playback_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_ad1848_playback_prepare(struct snd_pcm_substream *substream) +static int snd_ad1848_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ad1848_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -536,10 +537,10 @@ static int snd_ad1848_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1848_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ad1848_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); unsigned long flags; int err; @@ -556,15 +557,15 @@ static int snd_ad1848_capture_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_ad1848_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_ad1848_capture_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_ad1848_capture_prepare(struct snd_pcm_substream *substream) +static int snd_ad1848_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ad1848_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -582,7 +583,7 @@ static int snd_ad1848_capture_prepare(struct snd_pcm_substream *substream) static irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_ad1848 *chip = dev_id; + ad1848_t *chip = dev_id; if ((chip->mode & AD1848_MODE_PLAY) && chip->playback_substream && (chip->mode & AD1848_MODE_RUNNING)) @@ -594,9 +595,9 @@ static irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *r return IRQ_HANDLED; } -static snd_pcm_uframes_t snd_ad1848_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ad1848_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_PLAYBACK_ENABLE)) @@ -605,9 +606,9 @@ static snd_pcm_uframes_t snd_ad1848_playback_pointer(struct snd_pcm_substream *s return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_ad1848_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ad1848_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_CAPTURE_ENABLE)) @@ -620,7 +621,7 @@ static snd_pcm_uframes_t snd_ad1848_capture_pointer(struct snd_pcm_substream *su */ -static void snd_ad1848_thinkpad_twiddle(struct snd_ad1848 *chip, int on) { +static void snd_ad1848_thinkpad_twiddle(ad1848_t *chip, int on) { int tmp; @@ -641,34 +642,33 @@ static void snd_ad1848_thinkpad_twiddle(struct snd_ad1848 *chip, int on) { } #ifdef CONFIG_PM -static void snd_ad1848_suspend(struct snd_ad1848 *chip) +static int snd_ad1848_suspend(snd_card_t *card, pm_message_t state) { + ad1848_t *chip = card->pm_private_data; + snd_pcm_suspend_all(chip->pcm); + /* FIXME: save registers? */ + if (chip->thinkpad_flag) snd_ad1848_thinkpad_twiddle(chip, 0); + + return 0; } -static void snd_ad1848_resume(struct snd_ad1848 *chip) +static int snd_ad1848_resume(snd_card_t *card) { - int i; + ad1848_t *chip = card->pm_private_data; if (chip->thinkpad_flag) snd_ad1848_thinkpad_twiddle(chip, 1); - /* clear any pendings IRQ */ - inb(AD1848P(chip, STATUS)); - outb(0, AD1848P(chip, STATUS)); - mb(); + /* FIXME: restore registers? */ - snd_ad1848_mce_down(chip); - for (i = 0; i < 16; i++) - snd_ad1848_out(chip, i, chip->image[i]); - snd_ad1848_mce_up(chip); - snd_ad1848_mce_down(chip); + return 0; } #endif /* CONFIG_PM */ -static int snd_ad1848_probe(struct snd_ad1848 * chip) +static int snd_ad1848_probe(ad1848_t * chip) { unsigned long flags; int i, id, rev, ad1847; @@ -748,7 +748,7 @@ static int snd_ad1848_probe(struct snd_ad1848 * chip) */ -static struct snd_pcm_hardware snd_ad1848_playback = +static snd_pcm_hardware_t snd_ad1848_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -767,7 +767,7 @@ static struct snd_pcm_hardware snd_ad1848_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ad1848_capture = +static snd_pcm_hardware_t snd_ad1848_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -790,10 +790,10 @@ static struct snd_pcm_hardware snd_ad1848_capture = */ -static int snd_ad1848_playback_open(struct snd_pcm_substream *substream) +static int snd_ad1848_playback_open(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ad1848_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = snd_ad1848_open(chip, AD1848_MODE_PLAY)) < 0) @@ -806,10 +806,10 @@ static int snd_ad1848_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1848_capture_open(struct snd_pcm_substream *substream) +static int snd_ad1848_capture_open(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ad1848_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = snd_ad1848_open(chip, AD1848_MODE_CAPTURE)) < 0) @@ -822,9 +822,9 @@ static int snd_ad1848_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1848_playback_close(struct snd_pcm_substream *substream) +static int snd_ad1848_playback_close(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); chip->mode &= ~AD1848_MODE_PLAY; chip->playback_substream = NULL; @@ -832,9 +832,9 @@ static int snd_ad1848_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1848_capture_close(struct snd_pcm_substream *substream) +static int snd_ad1848_capture_close(snd_pcm_substream_t * substream) { - struct snd_ad1848 *chip = snd_pcm_substream_chip(substream); + ad1848_t *chip = snd_pcm_substream_chip(substream); chip->mode &= ~AD1848_MODE_CAPTURE; chip->capture_substream = NULL; @@ -842,7 +842,7 @@ static int snd_ad1848_capture_close(struct snd_pcm_substream *substream) return 0; } -static int snd_ad1848_free(struct snd_ad1848 *chip) +static int snd_ad1848_free(ad1848_t *chip) { release_and_free_resource(chip->res_port); if (chip->irq >= 0) @@ -855,13 +855,13 @@ static int snd_ad1848_free(struct snd_ad1848 *chip) return 0; } -static int snd_ad1848_dev_free(struct snd_device *device) +static int snd_ad1848_dev_free(snd_device_t *device) { - struct snd_ad1848 *chip = device->device_data; + ad1848_t *chip = device->device_data; return snd_ad1848_free(chip); } -static const char *snd_ad1848_chip_id(struct snd_ad1848 *chip) +static const char *snd_ad1848_chip_id(ad1848_t *chip) { switch (chip->hardware) { case AD1848_HW_AD1847: return "AD1847"; @@ -872,16 +872,16 @@ static const char *snd_ad1848_chip_id(struct snd_ad1848 *chip) } } -int snd_ad1848_create(struct snd_card *card, +int snd_ad1848_create(snd_card_t * card, unsigned long port, int irq, int dma, unsigned short hardware, - struct snd_ad1848 ** rchip) + ad1848_t ** rchip) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ad1848_dev_free, }; - struct snd_ad1848 *chip; + ad1848_t *chip; int err; *rchip = NULL; @@ -919,6 +919,7 @@ int snd_ad1848_create(struct snd_card *card, chip->thinkpad_flag = 1; chip->hardware = AD1848_HW_DETECT; /* reset */ snd_ad1848_thinkpad_twiddle(chip, 1); + snd_card_set_isa_pm_callback(card, snd_ad1848_suspend, snd_ad1848_resume, chip); } if (snd_ad1848_probe(chip) < 0) { @@ -932,16 +933,11 @@ int snd_ad1848_create(struct snd_card *card, return err; } -#ifdef CONFIG_PM - chip->suspend = snd_ad1848_suspend; - chip->resume = snd_ad1848_resume; -#endif - *rchip = chip; return 0; } -static struct snd_pcm_ops snd_ad1848_playback_ops = { +static snd_pcm_ops_t snd_ad1848_playback_ops = { .open = snd_ad1848_playback_open, .close = snd_ad1848_playback_close, .ioctl = snd_ad1848_ioctl, @@ -952,7 +948,7 @@ static struct snd_pcm_ops snd_ad1848_playback_ops = { .pointer = snd_ad1848_playback_pointer, }; -static struct snd_pcm_ops snd_ad1848_capture_ops = { +static snd_pcm_ops_t snd_ad1848_capture_ops = { .open = snd_ad1848_capture_open, .close = snd_ad1848_capture_close, .ioctl = snd_ad1848_ioctl, @@ -963,9 +959,16 @@ static struct snd_pcm_ops snd_ad1848_capture_ops = { .pointer = snd_ad1848_capture_pointer, }; -int snd_ad1848_pcm(struct snd_ad1848 *chip, int device, struct snd_pcm **rpcm) +static void snd_ad1848_pcm_free(snd_pcm_t *pcm) +{ + ad1848_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int snd_ad1848_pcm(ad1848_t *chip, int device, snd_pcm_t **rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(chip->card, "AD1848", device, 1, 1, &pcm)) < 0) @@ -974,6 +977,7 @@ int snd_ad1848_pcm(struct snd_ad1848 *chip, int device, struct snd_pcm **rpcm) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ad1848_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ad1848_capture_ops); + pcm->private_free = snd_ad1848_pcm_free; pcm->private_data = chip; pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX; strcpy(pcm->name, snd_ad1848_chip_id(chip)); @@ -988,7 +992,7 @@ int snd_ad1848_pcm(struct snd_ad1848 *chip, int device, struct snd_pcm **rpcm) return 0; } -const struct snd_pcm_ops *snd_ad1848_get_pcm_ops(int direction) +const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction) { return direction == SNDRV_PCM_STREAM_PLAYBACK ? &snd_ad1848_playback_ops : &snd_ad1848_capture_ops; @@ -998,7 +1002,7 @@ const struct snd_pcm_ops *snd_ad1848_get_pcm_ops(int direction) * MIXER part */ -static int snd_ad1848_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ad1848_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = { "Line", "Aux", "Mic", "Mix" @@ -1013,9 +1017,9 @@ static int snd_ad1848_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_ad1848_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1848_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol); + ad1848_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -1025,9 +1029,9 @@ static int snd_ad1848_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int snd_ad1848_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1848_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol); + ad1848_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned short left, right; int change; @@ -1048,7 +1052,7 @@ static int snd_ad1848_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return change; } -static int snd_ad1848_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1059,9 +1063,9 @@ static int snd_ad1848_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ad1848_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol); + ad1848_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1076,9 +1080,9 @@ static int snd_ad1848_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_ad1848_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol); + ad1848_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1099,7 +1103,7 @@ static int snd_ad1848_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e return change; } -static int snd_ad1848_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -1110,9 +1114,9 @@ static int snd_ad1848_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ad1848_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol); + ad1848_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1132,9 +1136,9 @@ static int snd_ad1848_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_ad1848_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ad1848 *chip = snd_kcontrol_chip(kcontrol); + ad1848_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1171,9 +1175,9 @@ static int snd_ad1848_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e /* */ -int snd_ad1848_add_ctl(struct snd_ad1848 *chip, const char *name, int index, int type, unsigned long value) +int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, unsigned long value) { - static struct snd_kcontrol_new newctls[] = { + static snd_kcontrol_new_t newctls[] = { [AD1848_MIX_SINGLE] = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .info = snd_ad1848_info_single, @@ -1193,7 +1197,7 @@ int snd_ad1848_add_ctl(struct snd_ad1848 *chip, const char *name, int index, int .put = snd_ad1848_put_mux, }, }; - struct snd_kcontrol *ctl; + snd_kcontrol_t *ctl; int err; ctl = snd_ctl_new1(&newctls[type], chip); @@ -1226,10 +1230,10 @@ AD1848_SINGLE("Loopback Capture Switch", 0, AD1848_LOOPBACK, 0, 1, 0), AD1848_SINGLE("Loopback Capture Volume", 0, AD1848_LOOPBACK, 1, 63, 0) }; -int snd_ad1848_mixer(struct snd_ad1848 *chip) +int snd_ad1848_mixer(ad1848_t *chip) { - struct snd_card *card; - struct snd_pcm *pcm; + snd_card_t *card; + snd_pcm_t *pcm; unsigned int idx; int err; diff --git a/trunk/sound/isa/als100.c b/trunk/sound/isa/als100.c index 9b77c17b3f66..ac8f13664983 100644 --- a/trunk/sound/isa/als100.c +++ b/trunk/sound/isa/als100.c @@ -83,7 +83,6 @@ struct snd_card_als100 { struct pnp_dev *dev; struct pnp_dev *devmpu; struct pnp_dev *devopl; - struct snd_sb *chip; }; static struct pnp_card_device_id snd_als100_pnpids[] = { @@ -204,15 +203,15 @@ static int __init snd_card_als100_probe(int dev, const struct pnp_card_device_id *pid) { int error; - struct snd_sb *chip; - struct snd_card *card; + sb_t *chip; + snd_card_t *card; struct snd_card_als100 *acard; - struct snd_opl3 *opl3; + opl3_t *opl3; if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_card_als100))) == NULL) return -ENOMEM; - acard = card->private_data; + acard = (struct snd_card_als100 *)card->private_data; if ((error = snd_card_als100_pnp(dev, acard, pcard, pid))) { snd_card_free(card); @@ -229,7 +228,6 @@ static int __init snd_card_als100_probe(int dev, snd_card_free(card); return error; } - acard->chip = chip; strcpy(card->driver, "ALS100"); strcpy(card->shortname, "Avance Logic ALS100"); @@ -301,61 +299,32 @@ static int __devinit snd_als100_pnp_detect(struct pnp_card_link *card, static void __devexit snd_als100_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); -} - -#ifdef CONFIG_PM -static int snd_als100_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_als100 *acard = card->private_data; - struct snd_sb *chip = acard->chip; + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(chip->pcm); - snd_sbmixer_suspend(chip); - return 0; + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -static int snd_als100_pnp_resume(struct pnp_card_link *pcard) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_als100 *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_sbdsp_reset(chip); - snd_sbmixer_resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - static struct pnp_card_driver als100_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, .name = "als100", .id_table = snd_als100_pnpids, .probe = snd_als100_pnp_detect, .remove = __devexit_p(snd_als100_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_als100_pnp_suspend, - .resume = snd_als100_pnp_resume, -#endif }; static int __init alsa_card_als100_init(void) { - int cards; + int cards = 0; - cards = pnp_register_card_driver(&als100_pnpc_driver); - if (cards <= 0) { - pnp_unregister_card_driver(&als100_pnpc_driver); + cards += pnp_register_card_driver(&als100_pnpc_driver); #ifdef MODULE + if (!cards) { + pnp_unregister_card_driver(&als100_pnpc_driver); snd_printk(KERN_ERR "no ALS100 based soundcards found\n"); -#endif - return -ENODEV; } - return 0; +#endif + return cards ? 0 : -ENODEV; } static void __exit alsa_card_als100_exit(void) diff --git a/trunk/sound/isa/azt2320.c b/trunk/sound/isa/azt2320.c index a530691bf4f7..bb41c6ec2f43 100644 --- a/trunk/sound/isa/azt2320.c +++ b/trunk/sound/isa/azt2320.c @@ -93,7 +93,6 @@ struct snd_card_azt2320 { int dev_no; struct pnp_dev *dev; struct pnp_dev *devmpu; - struct snd_cs4231 *chip; }; static struct pnp_card_device_id snd_azt2320_pnpids[] = { @@ -228,10 +227,10 @@ static int __devinit snd_card_azt2320_probe(int dev, const struct pnp_card_device_id *pid) { int error; - struct snd_card *card; + snd_card_t *card; struct snd_card_azt2320 *acard; - struct snd_cs4231 *chip; - struct snd_opl3 *opl3; + cs4231_t *chip; + opl3_t *opl3; if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_card_azt2320))) == NULL) @@ -330,59 +329,32 @@ static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card, static void __devexit snd_azt2320_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); -} - -#ifdef CONFIG_PM -static int snd_azt2320_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_azt2320 *acard = card->private_data; - struct snd_cs4231 *chip = acard->chip; + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - chip->suspend(chip); - return 0; + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -static int snd_azt2320_pnp_resume(struct pnp_card_link *pcard) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_azt2320 *acard = card->private_data; - struct snd_cs4231 *chip = acard->chip; - - chip->resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - static struct pnp_card_driver azt2320_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, .name = "azt2320", .id_table = snd_azt2320_pnpids, .probe = snd_azt2320_pnp_detect, .remove = __devexit_p(snd_azt2320_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_azt2320_pnp_suspend, - .resume = snd_azt2320_pnp_resume, -#endif }; static int __init alsa_card_azt2320_init(void) { - int cards; + int cards = 0; - cards = pnp_register_card_driver(&azt2320_pnpc_driver); - if (cards <= 0) { - pnp_unregister_card_driver(&azt2320_pnpc_driver); + cards += pnp_register_card_driver(&azt2320_pnpc_driver); #ifdef MODULE + if (!cards) { + pnp_unregister_card_driver(&azt2320_pnpc_driver); snd_printk(KERN_ERR "no AZT2320 based soundcards found\n"); -#endif - return -ENODEV; } - return 0; +#endif + return cards ? 0 : -ENODEV; } static void __exit alsa_card_azt2320_exit(void) diff --git a/trunk/sound/isa/cmi8330.c b/trunk/sound/isa/cmi8330.c index bd8e23818460..5252206ea388 100644 --- a/trunk/sound/isa/cmi8330.c +++ b/trunk/sound/isa/cmi8330.c @@ -45,8 +45,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/slab.h> #include <linux/pnp.h> #include <linux/moduleparam.h> @@ -108,9 +106,6 @@ MODULE_PARM_DESC(wssirq, "IRQ # for CMI8330 WSS driver."); module_param_array(wssdma, int, NULL, 0444); MODULE_PARM_DESC(wssdma, "DMA for CMI8330 WSS driver."); -static struct platform_device *platform_devices[SNDRV_CARDS]; -static int pnp_registered; - #define CMI8330_RMUX3D 16 #define CMI8330_MUTEMUX 17 #define CMI8330_OUTPUTVOL 18 @@ -142,25 +137,27 @@ static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] = 0x0 /* 26 - cd-in rec gain */ }; -typedef int (*snd_pcm_open_callback_t)(struct snd_pcm_substream *); +typedef int (*snd_pcm_open_callback_t)(snd_pcm_substream_t *); struct snd_cmi8330 { #ifdef CONFIG_PNP struct pnp_dev *cap; struct pnp_dev *play; #endif - struct snd_card *card; - struct snd_ad1848 *wss; - struct snd_sb *sb; + snd_card_t *card; + ad1848_t *wss; + sb_t *sb; - struct snd_pcm *pcm; + snd_pcm_t *pcm; struct snd_cmi8330_stream { - struct snd_pcm_ops ops; + snd_pcm_ops_t ops; snd_pcm_open_callback_t open; void *private_data; /* sb or wss */ } streams[2]; }; +static snd_card_t *snd_cmi8330_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; + #ifdef CONFIG_PNP static struct pnp_card_device_id snd_cmi8330_pnpids[] = { @@ -234,7 +231,7 @@ static unsigned char cmi8330_sb_init_values[][2] __initdata = { }; -static int __devinit cmi8330_add_sb_mixers(struct snd_sb *chip) +static int __devinit cmi8330_add_sb_mixers(sb_t *chip) { int idx, err; unsigned long flags; @@ -259,7 +256,7 @@ static int __devinit cmi8330_add_sb_mixers(struct snd_sb *chip) } #endif -static int __devinit snd_cmi8330_mixer(struct snd_card *card, struct snd_cmi8330 *acard) +static int __devinit snd_cmi8330_mixer(snd_card_t *card, struct snd_cmi8330 *acard) { unsigned int idx; int err; @@ -373,7 +370,7 @@ static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard, #define CMI_AD_STREAM SNDRV_PCM_STREAM_PLAYBACK #endif -static int snd_cmi8330_playback_open(struct snd_pcm_substream *substream) +static int snd_cmi8330_playback_open(snd_pcm_substream_t * substream) { struct snd_cmi8330 *chip = snd_pcm_substream_chip(substream); @@ -382,7 +379,7 @@ static int snd_cmi8330_playback_open(struct snd_pcm_substream *substream) return chip->streams[SNDRV_PCM_STREAM_PLAYBACK].open(substream); } -static int snd_cmi8330_capture_open(struct snd_pcm_substream *substream) +static int snd_cmi8330_capture_open(snd_pcm_substream_t * substream) { struct snd_cmi8330 *chip = snd_pcm_substream_chip(substream); @@ -391,10 +388,15 @@ static int snd_cmi8330_capture_open(struct snd_pcm_substream *substream) return chip->streams[SNDRV_PCM_STREAM_CAPTURE].open(substream); } -static int __devinit snd_cmi8330_pcm(struct snd_card *card, struct snd_cmi8330 *chip) +static void snd_cmi8330_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; - const struct snd_pcm_ops *ops; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip) +{ + snd_pcm_t *pcm; + const snd_pcm_ops_t *ops; int err; static snd_pcm_open_callback_t cmi_open_callbacks[2] = { snd_cmi8330_playback_open, @@ -405,6 +407,7 @@ static int __devinit snd_cmi8330_pcm(struct snd_card *card, struct snd_cmi8330 * return err; strcpy(pcm->name, "CMI8330"); pcm->private_data = chip; + pcm->private_free = snd_cmi8330_pcm_free; /* SB16 */ ops = snd_sb16dsp_get_pcm_ops(CMI_SB_STREAM); @@ -432,31 +435,6 @@ static int __devinit snd_cmi8330_pcm(struct snd_card *card, struct snd_cmi8330 * } -#ifdef CONFIG_PM -static int snd_cmi8330_suspend(struct snd_card *card) -{ - struct snd_cmi8330 *acard = card->private_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(acard->pcm); - acard->wss->suspend(acard->wss); - snd_sbmixer_suspend(acard->sb); - return 0; -} - -static int snd_cmi8330_resume(struct snd_card *card) -{ - struct snd_cmi8330 *acard = card->private_data; - - snd_sbdsp_reset(acard->sb); - snd_sbmixer_suspend(acard->sb); - acard->wss->resume(acard->wss); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - - /* */ @@ -468,28 +446,44 @@ static int snd_cmi8330_resume(struct snd_card *card) #define PFX "cmi8330: " -static struct snd_card *snd_cmi8330_card_new(int dev) +static int __devinit snd_cmi8330_probe(int dev, + struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { - struct snd_card *card; + snd_card_t *card; struct snd_cmi8330 *acard; + int i, err; + + if (! is_isapnp_selected(dev)) { + if (wssport[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR PFX "specify wssport\n"); + return -EINVAL; + } + if (sbport[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR PFX "specify sbport\n"); + return -EINVAL; + } + } card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_cmi8330)); if (card == NULL) { snd_printk(KERN_ERR PFX "could not get a new card\n"); - return NULL; + return -ENOMEM; } - acard = card->private_data; + acard = (struct snd_cmi8330 *)card->private_data; acard->card = card; - return card; -} -static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) -{ - struct snd_cmi8330 *acard; - int i, err; +#ifdef CONFIG_PNP + if (isapnp[dev]) { + if ((err = snd_cmi8330_pnp(dev, acard, pcard, pid)) < 0) { + snd_printk(KERN_ERR PFX "PnP detection failed\n"); + goto _err; + } + snd_card_set_dev(card, &pcard->card->dev); + } +#endif - acard = card->private_data; if ((err = snd_ad1848_create(card, wssport[dev] + 4, wssirq[dev], @@ -497,11 +491,12 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) AD1848_HW_DETECT, &acard->wss)) < 0) { snd_printk(KERN_ERR PFX "(AD1848) device busy??\n"); - return err; + goto _err; } if (acard->wss->hardware != AD1848_HW_CMI8330) { snd_printk(KERN_ERR PFX "(AD1848) not found during probe\n"); - return -ENODEV; + err = -ENODEV; + goto _err; } if ((err = snd_sbdsp_create(card, sbport[dev], @@ -511,11 +506,11 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) sbdma16[dev], SB_HW_AUTO, &acard->sb)) < 0) { snd_printk(KERN_ERR PFX "(SB16) device busy??\n"); - return err; + goto _err; } if (acard->sb->hardware != SB_HW_16) { snd_printk(KERN_ERR PFX "(SB16) not found during probe\n"); - return err; + goto _err; } snd_ad1848_out(acard->wss, AD1848_MISC_INFO, 0x40); /* switch on MODE2 */ @@ -524,12 +519,12 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) if ((err = snd_cmi8330_mixer(card, acard)) < 0) { snd_printk(KERN_ERR PFX "failed to create mixers\n"); - return err; + goto _err; } if ((err = snd_cmi8330_pcm(card, acard)) < 0) { snd_printk(KERN_ERR PFX "failed to create pcms\n"); - return err; + goto _err; } strcpy(card->driver, "CMI8330/C3D"); @@ -540,120 +535,49 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) wssirq[dev], wssdma[dev]); - return snd_card_register(card); -} + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; -static int __init snd_cmi8330_nonpnp_probe(struct platform_device *pdev) -{ - struct snd_card *card; - int err; - int dev = pdev->id; - - if (wssport[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify wssport\n"); - return -EINVAL; - } - if (sbport[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify sbport\n"); - return -EINVAL; - } + if ((err = snd_card_register(card)) < 0) + goto _err; - card = snd_cmi8330_card_new(dev); - if (! card) - return -ENOMEM; - snd_card_set_dev(card, &pdev->dev); - if ((err = snd_cmi8330_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - platform_set_drvdata(pdev, card); + if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_cmi8330_legacy[dev] = card; return 0; -} -static int snd_cmi8330_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_cmi8330_nonpnp_suspend(struct platform_device *dev, pm_message_t state) -{ - return snd_cmi8330_suspend(platform_get_drvdata(dev)); -} - -static int snd_cmi8330_nonpnp_resume(struct platform_device *dev) -{ - return snd_cmi8330_resume(platform_get_drvdata(dev)); + _err: + snd_card_free(card); + return err; } -#endif - -#define CMI8330_DRIVER "snd_cmi8330" - -static struct platform_driver snd_cmi8330_driver = { - .probe = snd_cmi8330_nonpnp_probe, - .remove = snd_cmi8330_nonpnp_remove, -#ifdef CONFIG_PM - .suspend = snd_cmi8330_nonpnp_suspend, - .resume = snd_cmi8330_nonpnp_resume, -#endif - .driver = { - .name = CMI8330_DRIVER - }, -}; - #ifdef CONFIG_PNP -static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *pcard, - const struct pnp_card_device_id *pid) +static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *card, + const struct pnp_card_device_id *id) { static int dev; - struct snd_card *card; int res; for ( ; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_cmi8330_card_new(dev); - if (! card) - return -ENOMEM; - if ((res = snd_cmi8330_pnp(dev, card->private_data, pcard, pid)) < 0) { - snd_printk(KERN_ERR PFX "PnP detection failed\n"); - snd_card_free(card); - return res; - } - snd_card_set_dev(card, &pcard->card->dev); - if ((res = snd_cmi8330_probe(card, dev)) < 0) { - snd_card_free(card); - return res; + if (!enable[dev] || !isapnp[dev]) + continue; + res = snd_cmi8330_probe(dev, card, id); + if (res < 0) + return res; + dev++; + return 0; } - pnp_set_card_drvdata(pcard, card); - dev++; - return 0; + return -ENODEV; } static void __devexit snd_cmi8330_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); -} - -#ifdef CONFIG_PM -static int snd_cmi8330_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - return snd_cmi8330_suspend(pnp_get_card_drvdata(pcard)); -} + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); -static int snd_cmi8330_pnp_resume(struct pnp_card_link *pcard) -{ - return snd_cmi8330_resume(pnp_get_card_drvdata(pcard)); + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -#endif static struct pnp_card_driver cmi8330_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, @@ -661,68 +585,47 @@ static struct pnp_card_driver cmi8330_pnpc_driver = { .id_table = snd_cmi8330_pnpids, .probe = snd_cmi8330_pnp_detect, .remove = __devexit_p(snd_cmi8330_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_cmi8330_pnp_suspend, - .resume = snd_cmi8330_pnp_resume, -#endif }; #endif /* CONFIG_PNP */ -static void __init_or_module snd_cmi8330_unregister_all(void) -{ - int i; - - if (pnp_registered) - pnp_unregister_card_driver(&cmi8330_pnpc_driver); - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_cmi8330_driver); -} - static int __init alsa_card_cmi8330_init(void) { - int i, err, cards = 0; + int dev, cards = 0; - if ((err = platform_driver_register(&snd_cmi8330_driver)) < 0) - return err; - - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - if (is_isapnp_selected(i)) + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev]) continue; - device = platform_device_register_simple(CMI8330_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - platform_devices[i] = device; - cards++; - } - - err = pnp_register_card_driver(&cmi8330_pnpc_driver); - if (err >= 0) { - pnp_registered = 1; - cards += err; + if (is_isapnp_selected(dev)) + continue; + if (snd_cmi8330_probe(dev, NULL, NULL) >= 0) + cards++; } +#ifdef CONFIG_PNP + cards += pnp_register_card_driver(&cmi8330_pnpc_driver); +#endif if (!cards) { +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&cmi8330_pnpc_driver); +#endif #ifdef MODULE snd_printk(KERN_ERR "CMI8330 not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_cmi8330_unregister_all(); - return err; } static void __exit alsa_card_cmi8330_exit(void) { - snd_cmi8330_unregister_all(); + int i; + +#ifdef CONFIG_PNP + /* PnP cards first */ + pnp_unregister_card_driver(&cmi8330_pnpc_driver); +#endif + for (i = 0; i < SNDRV_CARDS; i++) + snd_card_free(snd_cmi8330_legacy[i]); } module_init(alsa_card_cmi8330_init) diff --git a/trunk/sound/isa/cs423x/cs4231.c b/trunk/sound/isa/cs423x/cs4231.c index ab67b5c2590d..9be5416bcb92 100644 --- a/trunk/sound/isa/cs423x/cs4231.c +++ b/trunk/sound/isa/cs423x/cs4231.c @@ -22,8 +22,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/time.h> #include <linux/wait.h> #include <linux/moduleparam.h> @@ -66,15 +64,15 @@ MODULE_PARM_DESC(dma1, "DMA1 # for CS4231 driver."); module_param_array(dma2, int, NULL, 0444); MODULE_PARM_DESC(dma2, "DMA2 # for CS4231 driver."); -static struct platform_device *devices[SNDRV_CARDS]; +static snd_card_t *snd_cs4231_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; -static int __init snd_cs4231_probe(struct platform_device *pdev) +static int __init snd_card_cs4231_probe(int dev) { - int dev = pdev->id; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_cs4231 *chip; + snd_card_t *card; + struct snd_card_cs4231 *acard; + snd_pcm_t *pcm = NULL; + cs4231_t *chip; int err; if (port[dev] == SNDRV_AUTO_PORT) { @@ -92,6 +90,7 @@ static int __init snd_cs4231_probe(struct platform_device *pdev) card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); if (card == NULL) return -ENOMEM; + acard = (struct snd_card_cs4231 *)card->private_data; if ((err = snd_cs4231_create(card, port[dev], -1, irq[dev], dma1[dev], @@ -99,7 +98,6 @@ static int __init snd_cs4231_probe(struct platform_device *pdev) CS4231_HW_DETECT, 0, &chip)) < 0) goto _err; - card->private_data = chip; if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0) goto _err; @@ -127,12 +125,12 @@ static int __init snd_cs4231_probe(struct platform_device *pdev) printk(KERN_WARNING "cs4231: MPU401 not detected\n"); } - snd_card_set_dev(card, &pdev->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; - - platform_set_drvdata(pdev, card); + snd_cs4231_cards[dev] = card; return 0; _err: @@ -140,97 +138,29 @@ static int __init snd_cs4231_probe(struct platform_device *pdev) return err; } -static int __devexit snd_cs4231_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_cs4231_suspend(struct platform_device *dev, pm_message_t state) -{ - struct snd_card *card; - struct snd_cs4231 *chip; - card = platform_get_drvdata(dev); - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - chip = card->private_data; - chip->suspend(chip); - return 0; -} - -static int snd_cs4231_resume(struct platform_device *dev) -{ - struct snd_card *card; - struct snd_cs4231 *chip; - card = platform_get_drvdata(dev); - chip = card->private_data; - chip->resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - -#define SND_CS4231_DRIVER "snd_cs4231" - -static struct platform_driver snd_cs4231_driver = { - .probe = snd_cs4231_probe, - .remove = __devexit_p(snd_cs4231_remove), -#ifdef CONFIG_PM - .suspend = snd_cs4231_suspend, - .resume = snd_cs4231_resume, -#endif - .driver = { - .name = SND_CS4231_DRIVER - }, -}; - -static void __init_or_module snd_cs4231_unregister_all(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_cs4231_driver); -} - static int __init alsa_card_cs4231_init(void) { - int i, cards, err; - - err = platform_driver_register(&snd_cs4231_driver); - if (err < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(SND_CS4231_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + int dev, cards; + + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) { + if (snd_card_cs4231_probe(dev) >= 0) + cards++; } if (!cards) { #ifdef MODULE printk(KERN_ERR "CS4231 soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_cs4231_unregister_all(); - return err; } static void __exit alsa_card_cs4231_exit(void) { - snd_cs4231_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_cs4231_cards[idx]); } module_init(alsa_card_cs4231_init) diff --git a/trunk/sound/isa/cs423x/cs4231_lib.c b/trunk/sound/isa/cs423x/cs4231_lib.c index eab7eb59b5f7..4af769030beb 100644 --- a/trunk/sound/isa/cs423x/cs4231_lib.c +++ b/trunk/sound/isa/cs423x/cs4231_lib.c @@ -73,13 +73,13 @@ static unsigned int rates[14] = { 27042, 32000, 33075, 37800, 44100, 48000 }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = 14, .list = rates, .mask = 0, }; -static int snd_cs4231_xrate(struct snd_pcm_runtime *runtime) +static int snd_cs4231_xrate(snd_pcm_runtime_t *runtime) { return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates); } @@ -124,17 +124,49 @@ static unsigned char snd_cs4231_original_image[32] = * Basic I/O functions */ -static inline void cs4231_outb(struct snd_cs4231 *chip, u8 offset, u8 val) +#if !defined(EBUS_SUPPORT) && !defined(SBUS_SUPPORT) +#define __CS4231_INLINE__ inline +#else +#define __CS4231_INLINE__ /* nothing */ +#endif + +static __CS4231_INLINE__ void cs4231_outb(cs4231_t *chip, u8 offset, u8 val) { +#ifdef EBUS_SUPPORT + if (chip->ebus->flag) { + writeb(val, chip->port + (offset << 2)); + } else { +#endif +#ifdef SBUS_SUPPORT + sbus_writeb(val, chip->port + (offset << 2)); +#endif +#ifdef EBUS_SUPPORT + } +#endif +#ifdef LEGACY_SUPPORT outb(val, chip->port + offset); +#endif } -static inline u8 cs4231_inb(struct snd_cs4231 *chip, u8 offset) +static __CS4231_INLINE__ u8 cs4231_inb(cs4231_t *chip, u8 offset) { +#ifdef EBUS_SUPPORT + if (chip->ebus_flag) { + return readb(chip->port + (offset << 2)); + } else { +#endif +#ifdef SBUS_SUPPORT + return sbus_readb(chip->port + (offset << 2)); +#endif +#ifdef EBUS_SUPPORT + } +#endif +#ifdef LEGACY_SUPPORT return inb(chip->port + offset); +#endif } -static void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg, +static void snd_cs4231_outm(cs4231_t *chip, unsigned char reg, unsigned char mask, unsigned char value) { int timeout; @@ -161,7 +193,7 @@ static void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg, } } -static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg, unsigned char value) +static void snd_cs4231_dout(cs4231_t *chip, unsigned char reg, unsigned char value) { int timeout; @@ -174,7 +206,7 @@ static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg, unsigned mb(); } -void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char value) +void snd_cs4231_out(cs4231_t *chip, unsigned char reg, unsigned char value) { int timeout; @@ -195,7 +227,7 @@ void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char va #endif } -unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg) +unsigned char snd_cs4231_in(cs4231_t *chip, unsigned char reg) { int timeout; @@ -212,7 +244,7 @@ unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg) return cs4231_inb(chip, CS4231P(REG)); } -void snd_cs4236_ext_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char val) +void snd_cs4236_ext_out(cs4231_t *chip, unsigned char reg, unsigned char val) { cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17); cs4231_outb(chip, CS4231P(REG), reg | (chip->image[CS4236_EXT_REG] & 0x01)); @@ -223,7 +255,7 @@ void snd_cs4236_ext_out(struct snd_cs4231 *chip, unsigned char reg, unsigned cha #endif } -unsigned char snd_cs4236_ext_in(struct snd_cs4231 *chip, unsigned char reg) +unsigned char snd_cs4236_ext_in(cs4231_t *chip, unsigned char reg) { cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17); cs4231_outb(chip, CS4231P(REG), reg | (chip->image[CS4236_EXT_REG] & 0x01)); @@ -241,7 +273,7 @@ unsigned char snd_cs4236_ext_in(struct snd_cs4231 *chip, unsigned char reg) #if 0 -static void snd_cs4231_debug(struct snd_cs4231 *chip) +static void snd_cs4231_debug(cs4231_t *chip) { printk("CS4231 REGS: INDEX = 0x%02x ", cs4231_inb(chip, CS4231P(REGSEL))); printk(" STATUS = 0x%02x\n", cs4231_inb(chip, CS4231P(STATUS))); @@ -285,7 +317,7 @@ static void snd_cs4231_debug(struct snd_cs4231 *chip) * CS4231 detection / MCE routines */ -static void snd_cs4231_busy_wait(struct snd_cs4231 *chip) +static void snd_cs4231_busy_wait(cs4231_t *chip) { int timeout; @@ -299,7 +331,7 @@ static void snd_cs4231_busy_wait(struct snd_cs4231 *chip) udelay(10); } -void snd_cs4231_mce_up(struct snd_cs4231 *chip) +void snd_cs4231_mce_up(cs4231_t *chip) { unsigned long flags; int timeout; @@ -320,7 +352,7 @@ void snd_cs4231_mce_up(struct snd_cs4231 *chip) spin_unlock_irqrestore(&chip->reg_lock, flags); } -void snd_cs4231_mce_down(struct snd_cs4231 *chip) +void snd_cs4231_mce_down(cs4231_t *chip) { unsigned long flags; int timeout; @@ -399,14 +431,14 @@ static unsigned int snd_cs4231_get_count(unsigned char format, unsigned int size return size; } -static int snd_cs4231_trigger(struct snd_pcm_substream *substream, +static int snd_cs4231_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); int result = 0; unsigned int what; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; int do_start; #if 0 @@ -468,7 +500,7 @@ static unsigned char snd_cs4231_get_rate(unsigned int rate) return freq_bits[13]; } -static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip, +static unsigned char snd_cs4231_get_format(cs4231_t *chip, int format, int channels) { @@ -490,7 +522,7 @@ static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip, return rformat; } -static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute) +static void snd_cs4231_calibrate_mute(cs4231_t *chip, int mute) { unsigned long flags; @@ -524,8 +556,8 @@ static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute) spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_cs4231_playback_format(struct snd_cs4231 *chip, - struct snd_pcm_hw_params *params, +static void snd_cs4231_playback_format(cs4231_t *chip, + snd_pcm_hw_params_t *params, unsigned char pdfr) { unsigned long flags; @@ -563,8 +595,8 @@ static void snd_cs4231_playback_format(struct snd_cs4231 *chip, up(&chip->mce_mutex); } -static void snd_cs4231_capture_format(struct snd_cs4231 *chip, - struct snd_pcm_hw_params *params, +static void snd_cs4231_capture_format(cs4231_t *chip, + snd_pcm_hw_params_t *params, unsigned char cdfr) { unsigned long flags; @@ -610,20 +642,20 @@ static void snd_cs4231_capture_format(struct snd_cs4231 *chip, * Timer interface */ -static unsigned long snd_cs4231_timer_resolution(struct snd_timer * timer) +static unsigned long snd_cs4231_timer_resolution(snd_timer_t * timer) { - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); if (chip->hardware & CS4231_HW_CS4236B_MASK) return 14467; else return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920; } -static int snd_cs4231_timer_start(struct snd_timer * timer) +static int snd_cs4231_timer_start(snd_timer_t * timer) { unsigned long flags; unsigned int ticks; - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->reg_lock, flags); ticks = timer->sticks; if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 || @@ -637,17 +669,17 @@ static int snd_cs4231_timer_start(struct snd_timer * timer) return 0; } -static int snd_cs4231_timer_stop(struct snd_timer * timer) +static int snd_cs4231_timer_stop(snd_timer_t * timer) { unsigned long flags; - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->reg_lock, flags); snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE); spin_unlock_irqrestore(&chip->reg_lock, flags); return 0; } -static void snd_cs4231_init(struct snd_cs4231 *chip) +static void snd_cs4231_init(cs4231_t *chip) { unsigned long flags; @@ -705,7 +737,7 @@ static void snd_cs4231_init(struct snd_cs4231 *chip) #endif } -static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode) +static int snd_cs4231_open(cs4231_t *chip, unsigned int mode) { unsigned long flags; @@ -741,7 +773,7 @@ static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode) return 0; } -static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode) +static void snd_cs4231_close(cs4231_t *chip, unsigned int mode) { unsigned long flags; @@ -792,21 +824,21 @@ static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode) * timer open/close */ -static int snd_cs4231_timer_open(struct snd_timer * timer) +static int snd_cs4231_timer_open(snd_timer_t * timer) { - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); snd_cs4231_open(chip, CS4231_MODE_TIMER); return 0; } -static int snd_cs4231_timer_close(struct snd_timer * timer) +static int snd_cs4231_timer_close(snd_timer_t * timer) { - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); snd_cs4231_close(chip, CS4231_MODE_TIMER); return 0; } -static struct snd_timer_hardware snd_cs4231_timer_table = +static struct _snd_timer_hardware snd_cs4231_timer_table = { .flags = SNDRV_TIMER_HW_AUTO, .resolution = 9945, @@ -822,10 +854,10 @@ static struct snd_timer_hardware snd_cs4231_timer_table = * ok.. exported functions.. */ -static int snd_cs4231_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cs4231_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); unsigned char new_pdfr; int err; @@ -837,15 +869,16 @@ static int snd_cs4231_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_cs4231_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_cs4231_playback_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_cs4231_playback_prepare(struct snd_pcm_substream *substream) +#ifdef LEGACY_SUPPORT +static int snd_cs4231_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs4231_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -863,11 +896,12 @@ static int snd_cs4231_playback_prepare(struct snd_pcm_substream *substream) #endif return 0; } +#endif /* LEGACY_SUPPORT */ -static int snd_cs4231_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cs4231_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); unsigned char new_cdfr; int err; @@ -879,15 +913,16 @@ static int snd_cs4231_capture_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_cs4231_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_cs4231_capture_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_cs4231_capture_prepare(struct snd_pcm_substream *substream) +#ifdef LEGACY_SUPPORT +static int snd_cs4231_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs4231_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -907,8 +942,9 @@ static int snd_cs4231_capture_prepare(struct snd_pcm_substream *substream) spin_unlock_irqrestore(&chip->reg_lock, flags); return 0; } +#endif -static void snd_cs4231_overrange(struct snd_cs4231 *chip) +static void snd_cs4231_overrange(cs4231_t *chip) { unsigned long flags; unsigned char res; @@ -922,7 +958,7 @@ static void snd_cs4231_overrange(struct snd_cs4231 *chip) irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_cs4231 *chip = dev_id; + cs4231_t *chip = dev_id; unsigned char status; status = snd_cs4231_in(chip, CS4231_IRQ_STATUS); @@ -962,9 +998,10 @@ irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs) return IRQ_HANDLED; } -static snd_pcm_uframes_t snd_cs4231_playback_pointer(struct snd_pcm_substream *substream) +#ifdef LEGACY_SUPPORT +static snd_pcm_uframes_t snd_cs4231_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) @@ -973,9 +1010,9 @@ static snd_pcm_uframes_t snd_cs4231_playback_pointer(struct snd_pcm_substream *s return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_cs4231_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs4231_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE)) @@ -983,12 +1020,13 @@ static snd_pcm_uframes_t snd_cs4231_capture_pointer(struct snd_pcm_substream *su ptr = snd_dma_pointer(chip->dma2, chip->c_dma_size); return bytes_to_frames(substream->runtime, ptr); } +#endif /* LEGACY_SUPPORT */ /* */ -static int snd_cs4231_probe(struct snd_cs4231 *chip) +static int snd_cs4231_probe(cs4231_t *chip) { unsigned long flags; int i, id, rev; @@ -1152,7 +1190,7 @@ static int snd_cs4231_probe(struct snd_cs4231 *chip) */ -static struct snd_pcm_hardware snd_cs4231_playback = +static snd_pcm_hardware_t snd_cs4231_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | @@ -1173,7 +1211,7 @@ static struct snd_pcm_hardware snd_cs4231_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_cs4231_capture = +static snd_pcm_hardware_t snd_cs4231_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | @@ -1198,10 +1236,10 @@ static struct snd_pcm_hardware snd_cs4231_capture = */ -static int snd_cs4231_playback_open(struct snd_pcm_substream *substream) +static int snd_cs4231_playback_open(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs4231_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; runtime->hw = snd_cs4231_playback; @@ -1215,6 +1253,7 @@ static int snd_cs4231_playback_open(struct snd_pcm_substream *substream) chip->hardware == CS4231_HW_CS4239) runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE; +#ifdef LEGACY_SUPPORT snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.buffer_bytes_max); snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.period_bytes_max); @@ -1222,23 +1261,29 @@ static int snd_cs4231_playback_open(struct snd_pcm_substream *substream) if ((err = chip->claim_dma(chip, chip->dma_private_data, chip->dma1)) < 0) return err; } +#endif if ((err = snd_cs4231_open(chip, CS4231_MODE_PLAY)) < 0) { +#ifdef LEGACY_SUPPORT if (chip->release_dma) chip->release_dma(chip, chip->dma_private_data, chip->dma1); +#endif snd_free_pages(runtime->dma_area, runtime->dma_bytes); return err; } chip->playback_substream = substream; +#if defined(SBUS_SUPPORT) || defined(EBUS_SUPPORT) + chip->p_periods_sent = 0; +#endif snd_pcm_set_sync(substream); chip->rate_constraint(runtime); return 0; } -static int snd_cs4231_capture_open(struct snd_pcm_substream *substream) +static int snd_cs4231_capture_open(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs4231_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; runtime->hw = snd_cs4231_capture; @@ -1248,6 +1293,7 @@ static int snd_cs4231_capture_open(struct snd_pcm_substream *substream) chip->hardware == CS4231_HW_CS4239) runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE; +#ifdef LEGACY_SUPPORT snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.buffer_bytes_max); snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.period_bytes_max); @@ -1255,31 +1301,37 @@ static int snd_cs4231_capture_open(struct snd_pcm_substream *substream) if ((err = chip->claim_dma(chip, chip->dma_private_data, chip->dma2)) < 0) return err; } +#endif if ((err = snd_cs4231_open(chip, CS4231_MODE_RECORD)) < 0) { +#ifdef LEGACY_SUPPORT if (chip->release_dma) chip->release_dma(chip, chip->dma_private_data, chip->dma2); +#endif snd_free_pages(runtime->dma_area, runtime->dma_bytes); return err; } chip->capture_substream = substream; +#if defined(SBUS_SUPPORT) || defined(EBUS_SUPPORT) + chip->c_periods_sent = 0; +#endif snd_pcm_set_sync(substream); chip->rate_constraint(runtime); return 0; } -static int snd_cs4231_playback_close(struct snd_pcm_substream *substream) +static int snd_cs4231_playback_close(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); chip->playback_substream = NULL; snd_cs4231_close(chip, CS4231_MODE_PLAY); return 0; } -static int snd_cs4231_capture_close(struct snd_pcm_substream *substream) +static int snd_cs4231_capture_close(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); chip->capture_substream = NULL; snd_cs4231_close(chip, CS4231_MODE_RECORD); @@ -1289,12 +1341,13 @@ static int snd_cs4231_capture_close(struct snd_pcm_substream *substream) #ifdef CONFIG_PM /* lowlevel suspend callback for CS4231 */ -static void snd_cs4231_suspend(struct snd_cs4231 *chip) +static void snd_cs4231_suspend(cs4231_t *chip) { int reg; unsigned long flags; - snd_pcm_suspend_all(chip->pcm); + if (chip->pcm) + snd_pcm_suspend_all(chip->pcm); spin_lock_irqsave(&chip->reg_lock, flags); for (reg = 0; reg < 32; reg++) chip->image[reg] = snd_cs4231_in(chip, reg); @@ -1302,11 +1355,11 @@ static void snd_cs4231_suspend(struct snd_cs4231 *chip) } /* lowlevel resume callback for CS4231 */ -static void snd_cs4231_resume(struct snd_cs4231 *chip) +static void snd_cs4231_resume(cs4231_t *chip) { int reg; unsigned long flags; - /* int timeout; */ + int timeout; snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->reg_lock, flags); @@ -1320,7 +1373,7 @@ static void snd_cs4231_resume(struct snd_cs4231 *chip) } } spin_unlock_irqrestore(&chip->reg_lock, flags); -#if 1 +#if 0 snd_cs4231_mce_down(chip); #else /* The following is a workaround to avoid freeze after resume on TP600E. @@ -1342,9 +1395,27 @@ static void snd_cs4231_resume(struct snd_cs4231 *chip) snd_cs4231_busy_wait(chip); #endif } + +static int snd_cs4231_pm_suspend(snd_card_t *card, pm_message_t state) +{ + cs4231_t *chip = card->pm_private_data; + if (chip->suspend) + chip->suspend(chip); + return 0; +} + +static int snd_cs4231_pm_resume(snd_card_t *card) +{ + cs4231_t *chip = card->pm_private_data; + if (chip->resume) + chip->resume(chip); + return 0; +} #endif /* CONFIG_PM */ -static int snd_cs4231_free(struct snd_cs4231 *chip) +#ifdef LEGACY_SUPPORT + +static int snd_cs4231_free(cs4231_t *chip) { release_and_free_resource(chip->res_port); release_and_free_resource(chip->res_cport); @@ -1367,13 +1438,15 @@ static int snd_cs4231_free(struct snd_cs4231 *chip) return 0; } -static int snd_cs4231_dev_free(struct snd_device *device) +static int snd_cs4231_dev_free(snd_device_t *device) { - struct snd_cs4231 *chip = device->device_data; + cs4231_t *chip = device->device_data; return snd_cs4231_free(chip); } -const char *snd_cs4231_chip_id(struct snd_cs4231 *chip) +#endif /* LEGACY_SUPPORT */ + +const char *snd_cs4231_chip_id(cs4231_t *chip) { switch (chip->hardware) { case CS4231_HW_CS4231: return "CS4231"; @@ -1393,12 +1466,12 @@ const char *snd_cs4231_chip_id(struct snd_cs4231 *chip) } } -static int snd_cs4231_new(struct snd_card *card, +static int snd_cs4231_new(snd_card_t * card, unsigned short hardware, unsigned short hwshare, - struct snd_cs4231 ** rchip) + cs4231_t ** rchip) { - struct snd_cs4231 *chip; + cs4231_t *chip; *rchip = NULL; chip = kzalloc(sizeof(*chip), GFP_KERNEL); @@ -1420,18 +1493,20 @@ static int snd_cs4231_new(struct snd_card *card, return 0; } -int snd_cs4231_create(struct snd_card *card, +#ifdef LEGACY_SUPPORT + +int snd_cs4231_create(snd_card_t * card, unsigned long port, unsigned long cport, int irq, int dma1, int dma2, unsigned short hardware, unsigned short hwshare, - struct snd_cs4231 ** rchip) + cs4231_t ** rchip) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_cs4231_dev_free, }; - struct snd_cs4231 *chip; + cs4231_t *chip; int err; err = snd_cs4231_new(card, hardware, hwshare, &chip); @@ -1484,12 +1559,10 @@ int snd_cs4231_create(struct snd_card *card, } snd_cs4231_init(chip); -#if 0 if (chip->hardware & CS4231_HW_CS4232_MASK) { if (chip->res_cport == NULL) snd_printk("CS4232 control port features are not accessible\n"); } -#endif /* Register device */ if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { @@ -1501,13 +1574,16 @@ int snd_cs4231_create(struct snd_card *card, /* Power Management */ chip->suspend = snd_cs4231_suspend; chip->resume = snd_cs4231_resume; + snd_card_set_isa_pm_callback(card, snd_cs4231_pm_suspend, snd_cs4231_pm_resume, chip); #endif *rchip = chip; return 0; } -static struct snd_pcm_ops snd_cs4231_playback_ops = { +#endif /* LEGACY_SUPPORT */ + +static snd_pcm_ops_t snd_cs4231_playback_ops = { .open = snd_cs4231_playback_open, .close = snd_cs4231_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1518,7 +1594,7 @@ static struct snd_pcm_ops snd_cs4231_playback_ops = { .pointer = snd_cs4231_playback_pointer, }; -static struct snd_pcm_ops snd_cs4231_capture_ops = { +static snd_pcm_ops_t snd_cs4231_capture_ops = { .open = snd_cs4231_capture_open, .close = snd_cs4231_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1529,9 +1605,16 @@ static struct snd_pcm_ops snd_cs4231_capture_ops = { .pointer = snd_cs4231_capture_pointer, }; -int snd_cs4231_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm) +static void snd_cs4231_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + cs4231_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int snd_cs4231_pcm(cs4231_t *chip, int device, snd_pcm_t **rpcm) +{ + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(chip->card, "CS4231", device, 1, 1, &pcm)) < 0) @@ -1546,6 +1629,7 @@ int snd_cs4231_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm) /* global setup */ pcm->private_data = chip; + pcm->private_free = snd_cs4231_pcm_free; pcm->info_flags = 0; if (chip->single_dma) pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX; @@ -1553,9 +1637,27 @@ int snd_cs4231_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm) pcm->info_flags |= SNDRV_PCM_INFO_JOINT_DUPLEX; strcpy(pcm->name, snd_cs4231_chip_id(chip)); +#ifdef LEGACY_SUPPORT snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_isa_data(), 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024); +#else +# ifdef EBUS_SUPPORT + if (chip->ebus_flag) { + snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, + chip->dev_u.pdev, + 64*1024, 128*1024); + } else { +# endif +# ifdef SBUS_SUPPORT + snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_SBUS, + chip->dev_u.sdev, + 64*1024, 128*1024); +# endif +# ifdef EBUS_SUPPORT + } +# endif +#endif chip->pcm = pcm; if (rpcm) @@ -1563,16 +1665,16 @@ int snd_cs4231_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm) return 0; } -static void snd_cs4231_timer_free(struct snd_timer *timer) +static void snd_cs4231_timer_free(snd_timer_t *timer) { - struct snd_cs4231 *chip = timer->private_data; + cs4231_t *chip = timer->private_data; chip->timer = NULL; } -int snd_cs4231_timer(struct snd_cs4231 *chip, int device, struct snd_timer **rtimer) +int snd_cs4231_timer(cs4231_t *chip, int device, snd_timer_t **rtimer) { - struct snd_timer *timer; - struct snd_timer_id tid; + snd_timer_t *timer; + snd_timer_id_t tid; int err; /* Timer initialization */ @@ -1597,7 +1699,7 @@ int snd_cs4231_timer(struct snd_cs4231 *chip, int device, struct snd_timer **rti * MIXER part */ -static int snd_cs4231_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_cs4231_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = { "Line", "Aux", "Mic", "Mix" @@ -1609,7 +1711,7 @@ static int snd_cs4231_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele "Line", "Synth", "Mic", "Mix" }; char **ptexts = texts; - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); snd_assert(chip->card != NULL, return -EINVAL); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -1627,9 +1729,9 @@ static int snd_cs4231_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_cs4231_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4231_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -1639,9 +1741,9 @@ static int snd_cs4231_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int snd_cs4231_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4231_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned short left, right; int change; @@ -1662,7 +1764,7 @@ static int snd_cs4231_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return change; } -int snd_cs4231_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +int snd_cs4231_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1673,9 +1775,9 @@ int snd_cs4231_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -int snd_cs4231_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1690,9 +1792,9 @@ int snd_cs4231_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1713,7 +1815,7 @@ int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return change; } -int snd_cs4231_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +int snd_cs4231_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -1724,9 +1826,9 @@ int snd_cs4231_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -int snd_cs4231_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1746,9 +1848,9 @@ int snd_cs4231_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -int snd_cs4231_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1777,7 +1879,7 @@ int snd_cs4231_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return change; } -static struct snd_kcontrol_new snd_cs4231_controls[] = { +static snd_kcontrol_new_t snd_cs4231_controls[] = { CS4231_DOUBLE("PCM Playback Switch", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1), CS4231_DOUBLE("PCM Playback Volume", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1), CS4231_DOUBLE("Line Playback Switch", 0, CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1), @@ -1803,9 +1905,9 @@ CS4231_SINGLE("Loopback Capture Switch", 0, CS4231_LOOPBACK, 0, 1, 0), CS4231_SINGLE("Loopback Capture Volume", 0, CS4231_LOOPBACK, 2, 63, 1) }; -int snd_cs4231_mixer(struct snd_cs4231 *chip) +int snd_cs4231_mixer(cs4231_t *chip) { - struct snd_card *card; + snd_card_t *card; unsigned int idx; int err; diff --git a/trunk/sound/isa/cs423x/cs4236.c b/trunk/sound/isa/cs423x/cs4236.c index e1683337e6cd..d60a55e6a0b1 100644 --- a/trunk/sound/isa/cs423x/cs4236.c +++ b/trunk/sound/isa/cs423x/cs4236.c @@ -21,8 +21,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/slab.h> #include <linux/pnp.h> #include <linux/moduleparam.h> @@ -124,14 +122,7 @@ MODULE_PARM_DESC(dma1, "DMA1 # for " IDENT " driver."); module_param_array(dma2, int, NULL, 0444); MODULE_PARM_DESC(dma2, "DMA2 # for " IDENT " driver."); -static struct platform_device *platform_devices[SNDRV_CARDS]; -static int pnpc_registered; -#ifdef CS4232 -static int pnp_registered; -#endif - struct snd_card_cs4236 { - struct snd_cs4231 *chip; struct resource *res_sb_port; #ifdef CONFIG_PNP struct pnp_dev *wss; @@ -140,26 +131,33 @@ struct snd_card_cs4236 { #endif }; +static snd_card_t *snd_cs4236_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; + #ifdef CONFIG_PNP -#ifdef CS4232 -/* - * PNP BIOS - */ -static const struct pnp_device_id snd_cs4232_pnpbiosids[] = { - { .id = "CSC0100" }, - { .id = "CSC0000" }, - /* Guillemot Turtlebeach something appears to be cs4232 compatible - * (untested) */ - { .id = "GIM0100" }, - { .id = "" } -}; -MODULE_DEVICE_TABLE(pnp, snd_cs4232_pnpbiosids); -#endif /* CS4232 */ +#define ISAPNP_CS4232(_va, _vb, _vc, _device, _wss, _ctrl, _mpu401) \ + { \ + ISAPNP_CARD_ID(_va, _vb, _vc, _device), \ + .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \ + ISAPNP_DEVICE_ID(_va, _vb, _vc, _ctrl), \ + ISAPNP_DEVICE_ID(_va, _vb, _vc, _mpu401) } \ + } +#define ISAPNP_CS4232_1(_va, _vb, _vc, _device, _wss, _ctrl, _mpu401) \ + { \ + ISAPNP_CARD_ID(_va, _vb, _vc, _device), \ + .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \ + ISAPNP_DEVICE_ID(_va, _vb, _vc, _ctrl), \ + ISAPNP_DEVICE_ID('P', 'N', 'P', _mpu401) } \ + } +#define ISAPNP_CS4232_WOMPU(_va, _vb, _vc, _device, _wss, _ctrl) \ + { \ + ISAPNP_CARD_ID(_va, _vb, _vc, _device), \ + .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \ + ISAPNP_DEVICE_ID(_va, _vb, _vc, _ctrl) } \ + } + #ifdef CS4232 -#define CS423X_DRIVER "snd_cs4232" -#define CS423X_ISAPNP_DRIVER "cs4232_isapnp" static struct pnp_card_device_id snd_cs423x_pnpids[] = { /* Philips PCA70PS */ { .id = "CSC0d32", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } }, @@ -179,8 +177,6 @@ static struct pnp_card_device_id snd_cs423x_pnpids[] = { { .id = "" } /* end */ }; #else /* CS4236 */ -#define CS423X_DRIVER "snd_cs4236" -#define CS423X_ISAPNP_DRIVER "cs4236_isapnp" static struct pnp_card_device_id snd_cs423x_pnpids[] = { /* Intel Marlin Spike Motherboard - CS4235 */ { .id = "CSC0225", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } }, @@ -265,12 +261,37 @@ static struct pnp_card_device_id snd_cs423x_pnpids[] = { MODULE_DEVICE_TABLE(pnp_card, snd_cs423x_pnpids); -/* WSS initialization */ -static int __devinit snd_cs423x_pnp_init_wss(int dev, struct pnp_dev *pdev, - struct pnp_resource_table *cfg) +static int __devinit snd_card_cs4236_pnp(int dev, struct snd_card_cs4236 *acard, + struct pnp_card_link *card, + const struct pnp_card_device_id *id) { + struct pnp_dev *pdev; + struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL); int err; + if (!cfg) + return -ENOMEM; + + acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL); + if (acard->wss == NULL) { + kfree(cfg); + return -EBUSY; + } + acard->ctrl = pnp_request_card_device(card, id->devs[1].id, NULL); + if (acard->ctrl == NULL) { + kfree(cfg); + return -EBUSY; + } + if (id->devs[2].id[0]) { + acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL); + if (acard->mpu == NULL) { + kfree(cfg); + return -EBUSY; + } + } + + /* WSS initialization */ + pdev = acard->wss; pnp_init_resource_table(cfg); if (port[dev] != SNDRV_AUTO_PORT) pnp_resource_change(&cfg->port_resource[0], port[dev], 4); @@ -289,6 +310,7 @@ static int __devinit snd_cs423x_pnp_init_wss(int dev, struct pnp_dev *pdev, snd_printk(KERN_ERR IDENT " WSS PnP manual resources are invalid, using auto config\n"); err = pnp_activate_dev(pdev); if (err < 0) { + kfree(cfg); printk(KERN_ERR IDENT " WSS PnP configure failed for WSS (out of resources?)\n"); return -EBUSY; } @@ -303,124 +325,63 @@ static int __devinit snd_cs423x_pnp_init_wss(int dev, struct pnp_dev *pdev, port[dev], fm_port[dev], sb_port[dev]); snd_printdd("isapnp WSS: irq=%i, dma1=%i, dma2=%i\n", irq[dev], dma1[dev], dma2[dev]); - return 0; -} - -/* CTRL initialization */ -static int __devinit snd_cs423x_pnp_init_ctrl(int dev, struct pnp_dev *pdev, - struct pnp_resource_table *cfg) -{ - int err; - - pnp_init_resource_table(cfg); - if (cport[dev] != SNDRV_AUTO_PORT) - pnp_resource_change(&cfg->port_resource[0], cport[dev], 8); - err = pnp_manual_config_dev(pdev, cfg, 0); - if (err < 0) - snd_printk(KERN_ERR IDENT " CTRL PnP manual resources are invalid, using auto config\n"); - err = pnp_activate_dev(pdev); - if (err < 0) { - printk(KERN_ERR IDENT " CTRL PnP configure failed for WSS (out of resources?)\n"); - return -EBUSY; + /* CTRL initialization */ + if (acard->ctrl && cport[dev] > 0) { + pdev = acard->ctrl; + pnp_init_resource_table(cfg); + if (cport[dev] != SNDRV_AUTO_PORT) + pnp_resource_change(&cfg->port_resource[0], cport[dev], 8); + err = pnp_manual_config_dev(pdev, cfg, 0); + if (err < 0) + snd_printk(KERN_ERR IDENT " CTRL PnP manual resources are invalid, using auto config\n"); + err = pnp_activate_dev(pdev); + if (err < 0) { + kfree(cfg); + printk(KERN_ERR IDENT " CTRL PnP configure failed for WSS (out of resources?)\n"); + return -EBUSY; + } + cport[dev] = pnp_port_start(pdev, 0); + snd_printdd("isapnp CTRL: control port=0x%lx\n", cport[dev]); } - cport[dev] = pnp_port_start(pdev, 0); - snd_printdd("isapnp CTRL: control port=0x%lx\n", cport[dev]); - return 0; -} - -/* MPU initialization */ -static int __devinit snd_cs423x_pnp_init_mpu(int dev, struct pnp_dev *pdev, - struct pnp_resource_table *cfg) -{ - int err; - - pnp_init_resource_table(cfg); - if (mpu_port[dev] != SNDRV_AUTO_PORT) - pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2); - if (mpu_irq[dev] != SNDRV_AUTO_IRQ && mpu_irq[dev] >= 0) - pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1); - err = pnp_manual_config_dev(pdev, cfg, 0); - if (err < 0) - snd_printk(KERN_ERR IDENT " MPU401 PnP manual resources are invalid, using auto config\n"); - err = pnp_activate_dev(pdev); - if (err < 0) { - printk(KERN_ERR IDENT " MPU401 PnP configure failed for WSS (out of resources?)\n"); - mpu_port[dev] = SNDRV_AUTO_PORT; - mpu_irq[dev] = SNDRV_AUTO_IRQ; - } else { - mpu_port[dev] = pnp_port_start(pdev, 0); - if (mpu_irq[dev] >= 0 && - pnp_irq_valid(pdev, 0) && pnp_irq(pdev, 0) >= 0) { - mpu_irq[dev] = pnp_irq(pdev, 0); + /* MPU initialization */ + if (acard->mpu && mpu_port[dev] > 0) { + pdev = acard->mpu; + pnp_init_resource_table(cfg); + if (mpu_port[dev] != SNDRV_AUTO_PORT) + pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2); + if (mpu_irq[dev] != SNDRV_AUTO_IRQ && mpu_irq[dev] >= 0) + pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1); + err = pnp_manual_config_dev(pdev, cfg, 0); + if (err < 0) + snd_printk(KERN_ERR IDENT " MPU401 PnP manual resources are invalid, using auto config\n"); + err = pnp_activate_dev(pdev); + if (err < 0) { + printk(KERN_ERR IDENT " MPU401 PnP configure failed for WSS (out of resources?)\n"); + mpu_port[dev] = SNDRV_AUTO_PORT; + mpu_irq[dev] = SNDRV_AUTO_IRQ; } else { - mpu_irq[dev] = -1; /* disable interrupt */ + mpu_port[dev] = pnp_port_start(pdev, 0); + if (mpu_irq[dev] >= 0 && + pnp_irq_valid(pdev, 0) && pnp_irq(pdev, 0) >= 0) { + mpu_irq[dev] = pnp_irq(pdev, 0); + } else { + mpu_irq[dev] = -1; /* disable interrupt */ + } } - } - snd_printdd("isapnp MPU: port=0x%lx, irq=%i\n", mpu_port[dev], mpu_irq[dev]); - return 0; -} - -#ifdef CS4232 -static int __devinit snd_card_cs4232_pnp(int dev, struct snd_card_cs4236 *acard, - struct pnp_dev *pdev) -{ - struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL); - - if (!cfg) - return -ENOMEM; - if (snd_cs423x_pnp_init_wss(dev, acard->wss, cfg) < 0) { - kfree(cfg); - return -EBUSY; + snd_printdd("isapnp MPU: port=0x%lx, irq=%i\n", mpu_port[dev], mpu_irq[dev]); } kfree(cfg); - cport[dev] = -1; return 0; } -#endif +#endif /* CONFIG_PNP */ -static int __devinit snd_card_cs423x_pnpc(int dev, struct snd_card_cs4236 *acard, - struct pnp_card_link *card, - const struct pnp_card_device_id *id) +static void snd_card_cs4236_free(snd_card_t *card) { - struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL); - - if (!cfg) - return -ENOMEM; - - acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL); - if (acard->wss == NULL) - goto error; - acard->ctrl = pnp_request_card_device(card, id->devs[1].id, NULL); - if (acard->ctrl == NULL) - goto error; - if (id->devs[2].id[0]) { - acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL); - if (acard->mpu == NULL) - goto error; - } + struct snd_card_cs4236 *acard = (struct snd_card_cs4236 *)card->private_data; - /* WSS initialization */ - if (snd_cs423x_pnp_init_wss(dev, acard->wss, cfg) < 0) - goto error; - - /* CTRL initialization */ - if (acard->ctrl && cport[dev] > 0) { - if (snd_cs423x_pnp_init_ctrl(dev, acard->ctrl, cfg) < 0) - goto error; - } - /* MPU initialization */ - if (acard->mpu && mpu_port[dev] > 0) { - if (snd_cs423x_pnp_init_mpu(dev, acard->ctrl, cfg) < 0) - goto error; - } - kfree(cfg); - return 0; - - error: - kfree(cfg); - return -EBUSY; + if (acard) + release_and_free_resource(acard->res_sb_port); } -#endif /* CONFIG_PNP */ #ifdef CONFIG_PNP #define is_isapnp_selected(dev) isapnp[dev] @@ -428,38 +389,46 @@ static int __devinit snd_card_cs423x_pnpc(int dev, struct snd_card_cs4236 *acard #define is_isapnp_selected(dev) 0 #endif -static void snd_card_cs4236_free(struct snd_card *card) +static int __devinit snd_card_cs423x_probe(int dev, struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { - struct snd_card_cs4236 *acard = card->private_data; - - release_and_free_resource(acard->res_sb_port); -} - -static struct snd_card *snd_cs423x_card_new(int dev) -{ - struct snd_card *card; + snd_card_t *card; + struct snd_card_cs4236 *acard; + snd_pcm_t *pcm = NULL; + cs4231_t *chip; + opl3_t *opl3; + int err; + if (! is_isapnp_selected(dev)) { + if (port[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR "specify port\n"); + return -EINVAL; + } + if (cport[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR "specify cport\n"); + return -EINVAL; + } + } card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_card_cs4236)); if (card == NULL) - return NULL; + return -ENOMEM; + acard = (struct snd_card_cs4236 *)card->private_data; card->private_free = snd_card_cs4236_free; - return card; -} - -static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) -{ - struct snd_card_cs4236 *acard; - struct snd_pcm *pcm; - struct snd_cs4231 *chip; - struct snd_opl3 *opl3; - int err; - - acard = card->private_data; +#ifdef CONFIG_PNP + if (isapnp[dev]) { + if ((err = snd_card_cs4236_pnp(dev, acard, pcard, pid))<0) { + printk(KERN_ERR "isapnp detection failed and probing for " IDENT " is not supported\n"); + goto _err; + } + snd_card_set_dev(card, &pcard->card->dev); + } +#endif if (sb_port[dev] > 0 && sb_port[dev] != SNDRV_AUTO_PORT) if ((acard->res_sb_port = request_region(sb_port[dev], 16, IDENT " SB")) == NULL) { printk(KERN_ERR IDENT ": unable to register SB port at 0x%lx\n", sb_port[dev]); - return -EBUSY; + err = -EBUSY; + goto _err; } #ifdef CS4232 @@ -472,14 +441,13 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) CS4231_HW_DETECT, 0, &chip)) < 0) - return err; - acard->chip = chip; + goto _err; if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0) - return err; + goto _err; if ((err = snd_cs4231_mixer(chip)) < 0) - return err; + goto _err; #else /* CS4236 */ if ((err = snd_cs4236_create(card, @@ -491,14 +459,13 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) CS4231_HW_DETECT, 0, &chip)) < 0) - return err; - acard->chip = chip; + goto _err; if ((err = snd_cs4236_pcm(chip, 0, &pcm)) < 0) - return err; + goto _err; if ((err = snd_cs4236_mixer(chip)) < 0) - return err; + goto _err; #endif strcpy(card->driver, pcm->name); strcpy(card->shortname, pcm->name); @@ -511,7 +478,7 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]); if ((err = snd_cs4231_timer(chip, 0, NULL)) < 0) - return err; + goto _err; if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { if (snd_opl3_create(card, @@ -520,7 +487,7 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) printk(KERN_WARNING IDENT ": OPL3 not detected\n"); } else { if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) - return err; + goto _err; } } @@ -534,279 +501,95 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) printk(KERN_WARNING IDENT ": MPU401 not detected\n"); } - return snd_card_register(card); -} + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; -static int __init snd_cs423x_nonpnp_probe(struct platform_device *pdev) -{ - int dev = pdev->id; - struct snd_card *card; - int err; - - if (port[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR "specify port\n"); - return -EINVAL; - } - if (cport[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR "specify cport\n"); - return -EINVAL; - } - - card = snd_cs423x_card_new(dev); - if (! card) - return -ENOMEM; - snd_card_set_dev(card, &pdev->dev); - if ((err = snd_cs423x_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - - platform_set_drvdata(pdev, card); + if ((err = snd_card_register(card)) < 0) + goto _err; + if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_cs4236_legacy[dev] = card; return 0; -} -static int __devexit snd_cs423x_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_cs423x_suspend(struct snd_card *card) -{ - struct snd_card_cs4236 *acard = card->private_data; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - acard->chip->suspend(acard->chip); - return 0; -} - -static int snd_cs423x_resume(struct snd_card *card) -{ - struct snd_card_cs4236 *acard = card->private_data; - acard->chip->resume(acard->chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} - -static int snd_cs423x_nonpnp_suspend(struct platform_device *dev, pm_message_t state) -{ - return snd_cs423x_suspend(platform_get_drvdata(dev)); -} - -static int snd_cs423x_nonpnp_resume(struct platform_device *dev) -{ - return snd_cs423x_resume(platform_get_drvdata(dev)); + _err: + snd_card_free(card); + return err; } -#endif - -static struct platform_driver cs423x_nonpnp_driver = { - .probe = snd_cs423x_nonpnp_probe, - .remove = __devexit_p(snd_cs423x_nonpnp_remove), -#ifdef CONFIG_PM - .suspend = snd_cs423x_nonpnp_suspend, - .resume = snd_cs423x_nonpnp_resume, -#endif - .driver = { - .name = CS423X_DRIVER - }, -}; - #ifdef CONFIG_PNP -#ifdef CS4232 -static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev, - const struct pnp_device_id *id) +static int __devinit snd_cs423x_pnp_detect(struct pnp_card_link *card, + const struct pnp_card_device_id *id) { static int dev; - int err; - struct snd_card *card; - - if (pnp_device_is_isapnp(pdev)) - return -ENOENT; /* we have another procedure - card */ - for (; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_cs423x_card_new(dev); - if (! card) - return -ENOMEM; - if ((err = snd_card_cs4232_pnp(dev, card->private_data, pdev)) < 0) { - printk(KERN_ERR "PnP BIOS detection failed for " IDENT "\n"); - snd_card_free(card); - return err; - } - snd_card_set_dev(card, &pdev->dev); - if ((err = snd_cs423x_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - pnp_set_drvdata(pdev, card); - dev++; - return 0; -} - -static void __devexit snd_cs4232_pnp_remove(struct pnp_dev * pdev) -{ - snd_card_free(pnp_get_drvdata(pdev)); - pnp_set_drvdata(pdev, NULL); -} - -#ifdef CONFIG_PM -static int snd_cs4232_pnp_suspend(struct pnp_dev *pdev, pm_message_t state) -{ - return snd_cs423x_suspend(pnp_get_drvdata(pdev)); -} - -static int snd_cs4232_pnp_resume(struct pnp_dev *pdev) -{ - return snd_cs423x_resume(pnp_get_drvdata(pdev)); -} -#endif - -static struct pnp_driver cs4232_pnp_driver = { - .name = "cs4232-pnpbios", - .id_table = snd_cs4232_pnpbiosids, - .probe = snd_cs4232_pnpbios_detect, - .remove = __devexit_p(snd_cs4232_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_cs4232_pnp_suspend, - .resume = snd_cs4232_pnp_resume, -#endif -}; -#endif /* CS4232 */ - -static int __devinit snd_cs423x_pnpc_detect(struct pnp_card_link *pcard, - const struct pnp_card_device_id *pid) -{ - static int dev; - struct snd_card *card; int res; for ( ; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_cs423x_card_new(dev); - if (! card) - return -ENOMEM; - if ((res = snd_card_cs423x_pnpc(dev, card->private_data, pcard, pid)) < 0) { - printk(KERN_ERR "isapnp detection failed and probing for " IDENT - " is not supported\n"); - snd_card_free(card); - return res; - } - snd_card_set_dev(card, &pcard->card->dev); - if ((res = snd_cs423x_probe(card, dev)) < 0) { - snd_card_free(card); - return res; + if (!enable[dev] || !isapnp[dev]) + continue; + res = snd_card_cs423x_probe(dev, card, id); + if (res < 0) + return res; + dev++; + return 0; } - pnp_set_card_drvdata(pcard, card); - dev++; - return 0; + return -ENODEV; } -static void __devexit snd_cs423x_pnpc_remove(struct pnp_card_link * pcard) +static void __devexit snd_cs423x_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -#ifdef CONFIG_PM -static int snd_cs423x_pnpc_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - return snd_cs423x_suspend(pnp_get_card_drvdata(pcard)); -} - -static int snd_cs423x_pnpc_resume(struct pnp_card_link *pcard) -{ - return snd_cs423x_resume(pnp_get_card_drvdata(pcard)); -} -#endif - static struct pnp_card_driver cs423x_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, - .name = CS423X_ISAPNP_DRIVER, + .name = "cs423x", .id_table = snd_cs423x_pnpids, - .probe = snd_cs423x_pnpc_detect, - .remove = __devexit_p(snd_cs423x_pnpc_remove), -#ifdef CONFIG_PM - .suspend = snd_cs423x_pnpc_suspend, - .resume = snd_cs423x_pnpc_resume, -#endif + .probe = snd_cs423x_pnp_detect, + .remove = __devexit_p(snd_cs423x_pnp_remove), }; #endif /* CONFIG_PNP */ -static void __init_or_module snd_cs423x_unregister_all(void) -{ - int i; - - if (pnpc_registered) - pnp_unregister_card_driver(&cs423x_pnpc_driver); -#ifdef CS4232 - if (pnp_registered) - pnp_unregister_driver(&cs4232_pnp_driver); -#endif - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&cs423x_nonpnp_driver); -} - static int __init alsa_card_cs423x_init(void) { - int i, err, cards = 0; + int dev, cards = 0; - if ((err = platform_driver_register(&cs423x_nonpnp_driver)) < 0) - return err; - - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - if (is_isapnp_selected(i)) + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev]) continue; - device = platform_device_register_simple(CS423X_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - platform_devices[i] = device; - cards++; - } -#ifdef CS4232 - i = pnp_register_driver(&cs4232_pnp_driver); - if (i >= 0) { - pnp_registered = 1; - cards += i; + if (is_isapnp_selected(dev)) + continue; + if (snd_card_cs423x_probe(dev, NULL, NULL) >= 0) + cards++; } +#ifdef CONFIG_PNP + cards += pnp_register_card_driver(&cs423x_pnpc_driver); #endif - i = pnp_register_card_driver(&cs423x_pnpc_driver); - if (i >= 0) { - pnpc_registered = 1; - cards += i; - } if (!cards) { +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&cs423x_pnpc_driver); +#endif #ifdef MODULE printk(KERN_ERR IDENT " soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_cs423x_unregister_all(); - return err; } static void __exit alsa_card_cs423x_exit(void) { - snd_cs423x_unregister_all(); + int idx; + +#ifdef CONFIG_PNP + /* PnP cards first */ + pnp_unregister_card_driver(&cs423x_pnpc_driver); +#endif + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_cs4236_legacy[idx]); } module_init(alsa_card_cs423x_init) diff --git a/trunk/sound/isa/cs423x/cs4236_lib.c b/trunk/sound/isa/cs423x/cs4236_lib.c index e36981d64ec5..1adb88d5f8f4 100644 --- a/trunk/sound/isa/cs423x/cs4236_lib.c +++ b/trunk/sound/isa/cs423x/cs4236_lib.c @@ -122,13 +122,13 @@ static unsigned char snd_cs4236_ext_map[18] = { * */ -static void snd_cs4236_ctrl_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char val) +static void snd_cs4236_ctrl_out(cs4231_t *chip, unsigned char reg, unsigned char val) { outb(reg, chip->cport + 3); outb(chip->cimage[reg] = val, chip->cport + 4); } -static unsigned char snd_cs4236_ctrl_in(struct snd_cs4231 *chip, unsigned char reg) +static unsigned char snd_cs4236_ctrl_in(cs4231_t *chip, unsigned char reg) { outb(reg, chip->cport + 3); return inb(chip->cport + 4); @@ -140,7 +140,7 @@ static unsigned char snd_cs4236_ctrl_in(struct snd_cs4231 *chip, unsigned char r #define CLOCKS 8 -static struct snd_ratnum clocks[CLOCKS] = { +static ratnum_t clocks[CLOCKS] = { { .num = 16934400, .den_min = 353, .den_max = 353, .den_step = 1 }, { .num = 16934400, .den_min = 529, .den_max = 529, .den_step = 1 }, { .num = 16934400, .den_min = 617, .den_max = 617, .den_step = 1 }, @@ -151,12 +151,12 @@ static struct snd_ratnum clocks[CLOCKS] = { { .num = 16934400/16, .den_min = 21, .den_max = 192, .den_step = 1 } }; -static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = { +static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = { .nrats = CLOCKS, .rats = clocks, }; -static int snd_cs4236_xrate(struct snd_pcm_runtime *runtime) +static int snd_cs4236_xrate(snd_pcm_runtime_t *runtime) { return snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_clocks); @@ -181,7 +181,7 @@ static unsigned char divisor_to_rate_register(unsigned int divisor) } } -static void snd_cs4236_playback_format(struct snd_cs4231 *chip, struct snd_pcm_hw_params *params, unsigned char pdfr) +static void snd_cs4236_playback_format(cs4231_t *chip, snd_pcm_hw_params_t *params, unsigned char pdfr) { unsigned long flags; unsigned char rate = divisor_to_rate_register(params->rate_den); @@ -195,7 +195,7 @@ static void snd_cs4236_playback_format(struct snd_cs4231 *chip, struct snd_pcm_h spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_cs4236_capture_format(struct snd_cs4231 *chip, struct snd_pcm_hw_params *params, unsigned char cdfr) +static void snd_cs4236_capture_format(cs4231_t *chip, snd_pcm_hw_params_t *params, unsigned char cdfr) { unsigned long flags; unsigned char rate = divisor_to_rate_register(params->rate_den); @@ -211,7 +211,7 @@ static void snd_cs4236_capture_format(struct snd_cs4231 *chip, struct snd_pcm_hw #ifdef CONFIG_PM -static void snd_cs4236_suspend(struct snd_cs4231 *chip) +static void snd_cs4236_suspend(cs4231_t *chip) { int reg; unsigned long flags; @@ -226,7 +226,7 @@ static void snd_cs4236_suspend(struct snd_cs4231 *chip) spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_cs4236_resume(struct snd_cs4231 *chip) +static void snd_cs4236_resume(cs4231_t *chip) { int reg; unsigned long flags; @@ -261,15 +261,15 @@ static void snd_cs4236_resume(struct snd_cs4231 *chip) #endif /* CONFIG_PM */ -int snd_cs4236_create(struct snd_card *card, +int snd_cs4236_create(snd_card_t * card, unsigned long port, unsigned long cport, int irq, int dma1, int dma2, unsigned short hardware, unsigned short hwshare, - struct snd_cs4231 ** rchip) + cs4231_t ** rchip) { - struct snd_cs4231 *chip; + cs4231_t *chip; unsigned char ver1, ver2; unsigned int reg; int err; @@ -352,9 +352,9 @@ int snd_cs4236_create(struct snd_card *card, return 0; } -int snd_cs4236_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm) +int snd_cs4236_pcm(cs4231_t *chip, int device, snd_pcm_t **rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_cs4231_pcm(chip, device, &pcm)) < 0) @@ -375,7 +375,7 @@ int snd_cs4236_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm) .get = snd_cs4236_get_single, .put = snd_cs4236_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_cs4236_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_cs4236_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -386,9 +386,9 @@ static int snd_cs4236_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_cs4236_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -403,9 +403,9 @@ static int snd_cs4236_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_cs4236_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -432,9 +432,9 @@ static int snd_cs4236_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e .get = snd_cs4236_get_singlec, .put = snd_cs4236_put_singlec, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_cs4236_get_singlec(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_get_singlec(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -449,9 +449,9 @@ static int snd_cs4236_get_singlec(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_cs4236_put_singlec(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_put_singlec(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -478,7 +478,7 @@ static int snd_cs4236_put_singlec(struct snd_kcontrol *kcontrol, struct snd_ctl_ .get = snd_cs4236_get_double, .put = snd_cs4236_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static int snd_cs4236_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_cs4236_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -489,9 +489,9 @@ static int snd_cs4236_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_cs4236_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -511,9 +511,9 @@ static int snd_cs4236_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_cs4236_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -554,9 +554,9 @@ static int snd_cs4236_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e .get = snd_cs4236_get_double1, .put = snd_cs4236_put_double1, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static int snd_cs4236_get_double1(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_get_double1(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -576,9 +576,9 @@ static int snd_cs4236_get_double1(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_cs4236_put_double1(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_put_double1(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -618,9 +618,9 @@ static inline int snd_cs4236_mixer_master_digital_invert_volume(int vol) return (vol < 64) ? 63 - vol : 64 + (71 - vol); } -static int snd_cs4236_get_master_digital(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_get_master_digital(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -630,9 +630,9 @@ static int snd_cs4236_get_master_digital(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_cs4236_put_master_digital(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_put_master_digital(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned short val1, val2; @@ -677,9 +677,9 @@ static inline int snd_cs4235_mixer_output_accu_set_volume(int vol) return 1 << 5; } -static int snd_cs4235_get_output_accu(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4235_get_output_accu(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -689,9 +689,9 @@ static int snd_cs4235_get_output_accu(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_cs4235_put_output_accu(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4235_put_output_accu(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned short val1, val2; @@ -708,7 +708,7 @@ static int snd_cs4235_put_output_accu(struct snd_kcontrol *kcontrol, struct snd_ return change; } -static struct snd_kcontrol_new snd_cs4236_controls[] = { +static snd_kcontrol_new_t snd_cs4236_controls[] = { CS4236_DOUBLE("Master Digital Playback Switch", 0, CS4236_LEFT_MASTER, CS4236_RIGHT_MASTER, 7, 7, 1, 1), CS4236_DOUBLE("Master Digital Capture Switch", 0, CS4236_DAC_MUTE, CS4236_DAC_MUTE, 7, 6, 1, 1), @@ -759,7 +759,7 @@ CS4231_SINGLE("Digital Loopback Playback Switch", 0, CS4231_LOOPBACK, 0, 1, 0), CS4236_DOUBLE1("Digital Loopback Playback Volume", 0, CS4231_LOOPBACK, CS4236_RIGHT_LOOPBACK, 2, 0, 63, 1) }; -static struct snd_kcontrol_new snd_cs4235_controls[] = { +static snd_kcontrol_new_t snd_cs4235_controls[] = { CS4231_DOUBLE("Master Switch", 0, CS4235_LEFT_MASTER, CS4235_RIGHT_MASTER, 7, 7, 1, 1), CS4231_DOUBLE("Master Volume", 0, CS4235_LEFT_MASTER, CS4235_RIGHT_MASTER, 0, 0, 31, 1), @@ -812,9 +812,9 @@ CS4231_DOUBLE("Analog Loopback Switch", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT .get = snd_cs4236_get_iec958_switch, .put = snd_cs4236_put_iec958_switch, \ .private_value = 1 << 16 } -static int snd_cs4236_get_iec958_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_get_iec958_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -832,9 +832,9 @@ static int snd_cs4236_get_iec958_switch(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_cs4236_put_iec958_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs4236_put_iec958_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned short enable, val; @@ -868,7 +868,7 @@ static int snd_cs4236_put_iec958_switch(struct snd_kcontrol *kcontrol, struct sn return change; } -static struct snd_kcontrol_new snd_cs4236_iec958_controls[] = { +static snd_kcontrol_new_t snd_cs4236_iec958_controls[] = { CS4236_IEC958_ENABLE("IEC958 Output Enable", 0), CS4236_SINGLEC("IEC958 Output Validity", 0, 4, 4, 1, 0), CS4236_SINGLEC("IEC958 Output User", 0, 4, 5, 1, 0), @@ -877,12 +877,12 @@ CS4236_SINGLEC("IEC958 Output Channel Status Low", 0, 5, 1, 127, 0), CS4236_SINGLEC("IEC958 Output Channel Status High", 0, 6, 0, 255, 0) }; -static struct snd_kcontrol_new snd_cs4236_3d_controls_cs4235[] = { +static snd_kcontrol_new_t snd_cs4236_3d_controls_cs4235[] = { CS4236_SINGLEC("3D Control - Switch", 0, 3, 4, 1, 0), CS4236_SINGLEC("3D Control - Space", 0, 2, 4, 15, 1) }; -static struct snd_kcontrol_new snd_cs4236_3d_controls_cs4237[] = { +static snd_kcontrol_new_t snd_cs4236_3d_controls_cs4237[] = { CS4236_SINGLEC("3D Control - Switch", 0, 3, 7, 1, 0), CS4236_SINGLEC("3D Control - Space", 0, 2, 4, 15, 1), CS4236_SINGLEC("3D Control - Center", 0, 2, 0, 15, 1), @@ -890,19 +890,19 @@ CS4236_SINGLEC("3D Control - Mono", 0, 3, 6, 1, 0), CS4236_SINGLEC("3D Control - IEC958", 0, 3, 5, 1, 0) }; -static struct snd_kcontrol_new snd_cs4236_3d_controls_cs4238[] = { +static snd_kcontrol_new_t snd_cs4236_3d_controls_cs4238[] = { CS4236_SINGLEC("3D Control - Switch", 0, 3, 4, 1, 0), CS4236_SINGLEC("3D Control - Space", 0, 2, 4, 15, 1), CS4236_SINGLEC("3D Control - Volume", 0, 2, 0, 15, 1), CS4236_SINGLEC("3D Control - IEC958", 0, 3, 5, 1, 0) }; -int snd_cs4236_mixer(struct snd_cs4231 *chip) +int snd_cs4236_mixer(cs4231_t *chip) { - struct snd_card *card; + snd_card_t *card; unsigned int idx, count; int err; - struct snd_kcontrol_new *kcontrol; + snd_kcontrol_new_t *kcontrol; snd_assert(chip != NULL && chip->card != NULL, return -EINVAL); card = chip->card; diff --git a/trunk/sound/isa/dt019x.c b/trunk/sound/isa/dt019x.c index 50e7bc5ef561..db7c3397b323 100644 --- a/trunk/sound/isa/dt019x.c +++ b/trunk/sound/isa/dt019x.c @@ -74,7 +74,6 @@ struct snd_card_dt019x { struct pnp_dev *dev; struct pnp_dev *devmpu; struct pnp_dev *devopl; - struct snd_sb *chip; }; static struct pnp_card_device_id snd_dt019x_pnpids[] = { @@ -189,15 +188,15 @@ static int __devinit snd_card_dt019x_pnp(int dev, struct snd_card_dt019x *acard, static int __devinit snd_card_dt019x_probe(int dev, struct pnp_card_link *pcard, const struct pnp_card_device_id *pid) { int error; - struct snd_sb *chip; - struct snd_card *card; + sb_t *chip; + snd_card_t *card; struct snd_card_dt019x *acard; - struct snd_opl3 *opl3; + opl3_t *opl3; if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_card_dt019x))) == NULL) return -ENOMEM; - acard = card->private_data; + acard = (struct snd_card_dt019x *)card->private_data; snd_card_set_dev(card, &pcard->card->dev); if ((error = snd_card_dt019x_pnp(dev, acard, pcard, pid))) { @@ -215,7 +214,6 @@ static int __devinit snd_card_dt019x_probe(int dev, struct pnp_card_link *pcard, snd_card_free(card); return error; } - acard->chip = chip; strcpy(card->driver, "DT-019X"); strcpy(card->shortname, "Diamond Tech. DT-019X"); @@ -292,61 +290,32 @@ static int __devinit snd_dt019x_pnp_probe(struct pnp_card_link *card, static void __devexit snd_dt019x_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -#ifdef CONFIG_PM -static int snd_dt019x_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_dt019x *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(chip->pcm); - snd_sbmixer_suspend(chip); - return 0; -} - -static int snd_dt019x_pnp_resume(struct pnp_card_link *pcard) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_dt019x *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_sbdsp_reset(chip); - snd_sbmixer_resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - static struct pnp_card_driver dt019x_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, .name = "dt019x", .id_table = snd_dt019x_pnpids, .probe = snd_dt019x_pnp_probe, .remove = __devexit_p(snd_dt019x_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_dt019x_pnp_suspend, - .resume = snd_dt019x_pnp_resume, -#endif }; static int __init alsa_card_dt019x_init(void) { int cards = 0; - cards = pnp_register_card_driver(&dt019x_pnpc_driver); - if (cards <= 0) { - pnp_unregister_card_driver(&dt019x_pnpc_driver); + cards += pnp_register_card_driver(&dt019x_pnpc_driver); + #ifdef MODULE + if (!cards) { + pnp_unregister_card_driver(&dt019x_pnpc_driver); snd_printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n"); -#endif - return -ENODEV; } - return 0; +#endif + return cards ? 0 : -ENODEV; } static void __exit alsa_card_dt019x_exit(void) diff --git a/trunk/sound/isa/es1688/es1688.c b/trunk/sound/isa/es1688/es1688.c index 50d23cf3d7cc..26a7d335ed8e 100644 --- a/trunk/sound/isa/es1688/es1688.c +++ b/trunk/sound/isa/es1688/es1688.c @@ -20,17 +20,16 @@ */ #include <sound/driver.h> +#include <asm/dma.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/time.h> #include <linux/wait.h> #include <linux/moduleparam.h> -#include <asm/dma.h> #include <sound/core.h> #include <sound/es1688.h> #include <sound/mpu401.h> #include <sound/opl3.h> +#define SNDRV_LEGACY_AUTO_PROBE #define SNDRV_LEGACY_FIND_FREE_IRQ #define SNDRV_LEGACY_FIND_FREE_DMA #include <sound/initval.h> @@ -69,20 +68,19 @@ MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for ESx688 driver."); module_param_array(dma8, int, NULL, 0444); MODULE_PARM_DESC(dma8, "8-bit DMA # for ESx688 driver."); -static struct platform_device *devices[SNDRV_CARDS]; +static snd_card_t *snd_audiodrive_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; #define PFX "es1688: " -static int __init snd_es1688_probe(struct platform_device *pdev) +static int __init snd_audiodrive_probe(int dev) { - int dev = pdev->id; static int possible_irqs[] = {5, 9, 10, 7, -1}; static int possible_dmas[] = {1, 3, 0, -1}; int xirq, xdma, xmpu_irq; - struct snd_card *card; - struct snd_es1688 *chip; - struct snd_opl3 *opl3; - struct snd_pcm *pcm; + snd_card_t *card; + es1688_t *chip; + opl3_t *opl3; + snd_pcm_t *pcm; int err; card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); @@ -107,30 +105,10 @@ static int __init snd_es1688_probe(struct platform_device *pdev) } } - if (port[dev] != SNDRV_AUTO_PORT) { - if ((err = snd_es1688_create(card, port[dev], mpu_port[dev], - xirq, xmpu_irq, xdma, - ES1688_HW_AUTO, &chip)) < 0) - goto _err; - } else { - /* auto-probe legacy ports */ - static unsigned long possible_ports[] = { - 0x220, 0x240, 0x260, - }; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - err = snd_es1688_create(card, possible_ports[i], - mpu_port[dev], - xirq, xmpu_irq, xdma, - ES1688_HW_AUTO, &chip); - if (err >= 0) { - port[dev] = possible_ports[i]; - break; - } - } - if (i >= ARRAY_SIZE(possible_ports)) - goto _err; - } + if ((err = snd_es1688_create(card, port[dev], mpu_port[dev], + xirq, xmpu_irq, xdma, + ES1688_HW_AUTO, &chip)) < 0) + goto _err; if ((err = snd_es1688_pcm(chip, 0, &pcm)) < 0) goto _err; @@ -158,12 +136,13 @@ static int __init snd_es1688_probe(struct platform_device *pdev) goto _err; } - snd_card_set_dev(card, &pdev->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; - platform_set_drvdata(pdev, card); + snd_audiodrive_cards[dev] = card; return 0; _err: @@ -171,70 +150,53 @@ static int __init snd_es1688_probe(struct platform_device *pdev) return err; } -static int snd_es1688_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define ES1688_DRIVER "snd_es1688" - -static struct platform_driver snd_es1688_driver = { - .probe = snd_es1688_probe, - .remove = snd_es1688_remove, - /* FIXME: suspend/resume */ - .driver = { - .name = ES1688_DRIVER - }, -}; - -static void __init_or_module snd_es1688_unregister_all(void) +static int __init snd_audiodrive_legacy_auto_probe(unsigned long xport) { - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_es1688_driver); + static int dev; + int res; + + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; + port[dev] = xport; + res = snd_audiodrive_probe(dev); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; + } + return -ENODEV; } static int __init alsa_card_es1688_init(void) { - int i, cards, err; - - err = platform_driver_register(&snd_es1688_driver); - if (err < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(ES1688_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + static unsigned long possible_ports[] = {0x220, 0x240, 0x260, -1}; + int dev, cards = 0, i; + + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) { + if (port[dev] == SNDRV_AUTO_PORT) + continue; + if (snd_audiodrive_probe(dev) >= 0) + cards++; } + i = snd_legacy_auto_probe(possible_ports, snd_audiodrive_legacy_auto_probe); + if (i > 0) + cards += i; + if (!cards) { #ifdef MODULE printk(KERN_ERR "ESS AudioDrive ES1688 soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_es1688_unregister_all(); - return err; } static void __exit alsa_card_es1688_exit(void) { - snd_es1688_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_audiodrive_cards[idx]); } module_init(alsa_card_es1688_init) diff --git a/trunk/sound/isa/es1688/es1688_lib.c b/trunk/sound/isa/es1688/es1688_lib.c index 702ad51ee9d5..2edc9c9f0445 100644 --- a/trunk/sound/isa/es1688/es1688_lib.c +++ b/trunk/sound/isa/es1688/es1688_lib.c @@ -36,7 +36,7 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("ESS ESx688 lowlevel module"); MODULE_LICENSE("GPL"); -static int snd_es1688_dsp_command(struct snd_es1688 *chip, unsigned char val) +static int snd_es1688_dsp_command(es1688_t *chip, unsigned char val) { int i; @@ -51,7 +51,7 @@ static int snd_es1688_dsp_command(struct snd_es1688 *chip, unsigned char val) return 0; } -static int snd_es1688_dsp_get_byte(struct snd_es1688 *chip) +static int snd_es1688_dsp_get_byte(es1688_t *chip) { int i; @@ -62,7 +62,7 @@ static int snd_es1688_dsp_get_byte(struct snd_es1688 *chip) return -ENODEV; } -static int snd_es1688_write(struct snd_es1688 *chip, +static int snd_es1688_write(es1688_t *chip, unsigned char reg, unsigned char data) { if (!snd_es1688_dsp_command(chip, reg)) @@ -70,7 +70,7 @@ static int snd_es1688_write(struct snd_es1688 *chip, return snd_es1688_dsp_command(chip, data); } -static int snd_es1688_read(struct snd_es1688 *chip, unsigned char reg) +static int snd_es1688_read(es1688_t *chip, unsigned char reg) { /* Read a byte from an extended mode register of ES1688 */ if (!snd_es1688_dsp_command(chip, 0xc0)) @@ -80,7 +80,7 @@ static int snd_es1688_read(struct snd_es1688 *chip, unsigned char reg) return snd_es1688_dsp_get_byte(chip); } -void snd_es1688_mixer_write(struct snd_es1688 *chip, +void snd_es1688_mixer_write(es1688_t *chip, unsigned char reg, unsigned char data) { outb(reg, ES1688P(chip, MIXER_ADDR)); @@ -89,7 +89,7 @@ void snd_es1688_mixer_write(struct snd_es1688 *chip, udelay(10); } -static unsigned char snd_es1688_mixer_read(struct snd_es1688 *chip, unsigned char reg) +static unsigned char snd_es1688_mixer_read(es1688_t *chip, unsigned char reg) { unsigned char result; @@ -100,7 +100,7 @@ static unsigned char snd_es1688_mixer_read(struct snd_es1688 *chip, unsigned cha return result; } -static int snd_es1688_reset(struct snd_es1688 *chip) +static int snd_es1688_reset(es1688_t *chip) { int i; @@ -117,7 +117,7 @@ static int snd_es1688_reset(struct snd_es1688 *chip) return 0; } -static int snd_es1688_probe(struct snd_es1688 *chip) +static int snd_es1688_probe(es1688_t *chip) { unsigned long flags; unsigned short major, minor, hw; @@ -191,7 +191,7 @@ static int snd_es1688_probe(struct snd_es1688 *chip) return 0; } -static int snd_es1688_init(struct snd_es1688 * chip, int enable) +static int snd_es1688_init(es1688_t * chip, int enable) { static int irqs[16] = {-1, -1, 0, -1, -1, 1, -1, 2, -1, 0, 3, -1, -1, -1, -1, -1}; unsigned long flags; @@ -283,7 +283,7 @@ static int snd_es1688_init(struct snd_es1688 * chip, int enable) */ -static struct snd_ratnum clocks[2] = { +static ratnum_t clocks[2] = { { .num = 795444, .den_min = 1, @@ -298,14 +298,14 @@ static struct snd_ratnum clocks[2] = { } }; -static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = { +static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = { .nrats = 2, .rats = clocks, }; -static void snd_es1688_set_rate(struct snd_es1688 *chip, struct snd_pcm_substream *substream) +static void snd_es1688_set_rate(es1688_t *chip, snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int bits, divider; if (runtime->rate_num == clocks[0].num) @@ -319,13 +319,13 @@ static void snd_es1688_set_rate(struct snd_es1688 *chip, struct snd_pcm_substrea snd_es1688_write(chip, 0xa2, divider); } -static int snd_es1688_ioctl(struct snd_pcm_substream *substream, +static int snd_es1688_ioctl(snd_pcm_substream_t * substream, unsigned int cmd, void *arg) { return snd_pcm_lib_ioctl(substream, cmd, arg); } -static int snd_es1688_trigger(struct snd_es1688 *chip, int cmd, unsigned char value) +static int snd_es1688_trigger(es1688_t *chip, int cmd, unsigned char value) { int val; @@ -350,22 +350,22 @@ static int snd_es1688_trigger(struct snd_es1688 *chip, int cmd, unsigned char va return 0; } -static int snd_es1688_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_es1688_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_es1688_hw_free(struct snd_pcm_substream *substream) +static int snd_es1688_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_es1688_playback_prepare(struct snd_pcm_substream *substream) +static int snd_es1688_playback_prepare(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1688_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -415,18 +415,18 @@ static int snd_es1688_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_es1688_playback_trigger(struct snd_pcm_substream *substream, +static int snd_es1688_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); + es1688_t *chip = snd_pcm_substream_chip(substream); return snd_es1688_trigger(chip, cmd, 0x05); } -static int snd_es1688_capture_prepare(struct snd_pcm_substream *substream) +static int snd_es1688_capture_prepare(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1688_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -472,16 +472,16 @@ static int snd_es1688_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_es1688_capture_trigger(struct snd_pcm_substream *substream, +static int snd_es1688_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); + es1688_t *chip = snd_pcm_substream_chip(substream); return snd_es1688_trigger(chip, cmd, 0x0f); } static irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_es1688 *chip = dev_id; + es1688_t *chip = dev_id; if (chip->trigger_value == 0x05) /* ok.. playback is active */ snd_pcm_period_elapsed(chip->playback_substream); @@ -492,9 +492,9 @@ static irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *r return IRQ_HANDLED; } -static snd_pcm_uframes_t snd_es1688_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es1688_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); + es1688_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (chip->trigger_value != 0x05) @@ -503,9 +503,9 @@ static snd_pcm_uframes_t snd_es1688_playback_pointer(struct snd_pcm_substream *s return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_es1688_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es1688_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); + es1688_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (chip->trigger_value != 0x0f) @@ -518,7 +518,7 @@ static snd_pcm_uframes_t snd_es1688_capture_pointer(struct snd_pcm_substream *su */ -static struct snd_pcm_hardware snd_es1688_playback = +static snd_pcm_hardware_t snd_es1688_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -536,7 +536,7 @@ static struct snd_pcm_hardware snd_es1688_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_es1688_capture = +static snd_pcm_hardware_t snd_es1688_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -558,10 +558,10 @@ static struct snd_pcm_hardware snd_es1688_capture = */ -static int snd_es1688_playback_open(struct snd_pcm_substream *substream) +static int snd_es1688_playback_open(snd_pcm_substream_t * substream) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1688_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (chip->capture_substream != NULL) return -EAGAIN; @@ -572,10 +572,10 @@ static int snd_es1688_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es1688_capture_open(struct snd_pcm_substream *substream) +static int snd_es1688_capture_open(snd_pcm_substream_t * substream) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1688_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (chip->playback_substream != NULL) return -EAGAIN; @@ -586,23 +586,23 @@ static int snd_es1688_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es1688_playback_close(struct snd_pcm_substream *substream) +static int snd_es1688_playback_close(snd_pcm_substream_t * substream) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); + es1688_t *chip = snd_pcm_substream_chip(substream); chip->playback_substream = NULL; return 0; } -static int snd_es1688_capture_close(struct snd_pcm_substream *substream) +static int snd_es1688_capture_close(snd_pcm_substream_t * substream) { - struct snd_es1688 *chip = snd_pcm_substream_chip(substream); + es1688_t *chip = snd_pcm_substream_chip(substream); chip->capture_substream = NULL; return 0; } -static int snd_es1688_free(struct snd_es1688 *chip) +static int snd_es1688_free(es1688_t *chip) { if (chip->res_port) { snd_es1688_init(chip, 0); @@ -618,33 +618,33 @@ static int snd_es1688_free(struct snd_es1688 *chip) return 0; } -static int snd_es1688_dev_free(struct snd_device *device) +static int snd_es1688_dev_free(snd_device_t *device) { - struct snd_es1688 *chip = device->device_data; + es1688_t *chip = device->device_data; return snd_es1688_free(chip); } -static const char *snd_es1688_chip_id(struct snd_es1688 *chip) +static const char *snd_es1688_chip_id(es1688_t *chip) { static char tmp[16]; sprintf(tmp, "ES%s688 rev %i", chip->hardware == ES1688_HW_688 ? "" : "1", chip->version & 0x0f); return tmp; } -int snd_es1688_create(struct snd_card *card, +int snd_es1688_create(snd_card_t * card, unsigned long port, unsigned long mpu_port, int irq, int mpu_irq, int dma8, unsigned short hardware, - struct snd_es1688 **rchip) + es1688_t **rchip) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_es1688_dev_free, }; - struct snd_es1688 *chip; + es1688_t *chip; int err; *rchip = NULL; @@ -702,7 +702,7 @@ int snd_es1688_create(struct snd_card *card, return 0; } -static struct snd_pcm_ops snd_es1688_playback_ops = { +static snd_pcm_ops_t snd_es1688_playback_ops = { .open = snd_es1688_playback_open, .close = snd_es1688_playback_close, .ioctl = snd_es1688_ioctl, @@ -713,7 +713,7 @@ static struct snd_pcm_ops snd_es1688_playback_ops = { .pointer = snd_es1688_playback_pointer, }; -static struct snd_pcm_ops snd_es1688_capture_ops = { +static snd_pcm_ops_t snd_es1688_capture_ops = { .open = snd_es1688_capture_open, .close = snd_es1688_capture_close, .ioctl = snd_es1688_ioctl, @@ -724,9 +724,16 @@ static struct snd_pcm_ops snd_es1688_capture_ops = { .pointer = snd_es1688_capture_pointer, }; -int snd_es1688_pcm(struct snd_es1688 * chip, int device, struct snd_pcm ** rpcm) +static void snd_es1688_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + es1688_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int snd_es1688_pcm(es1688_t * chip, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(chip->card, "ESx688", device, 1, 1, &pcm)) < 0) @@ -736,6 +743,7 @@ int snd_es1688_pcm(struct snd_es1688 * chip, int device, struct snd_pcm ** rpcm) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1688_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_es1688_pcm_free; pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX; sprintf(pcm->name, snd_es1688_chip_id(chip)); chip->pcm = pcm; @@ -753,7 +761,7 @@ int snd_es1688_pcm(struct snd_es1688 * chip, int device, struct snd_pcm ** rpcm) * MIXER part */ -static int snd_es1688_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es1688_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[9] = { "Mic", "Mic Master", "CD", "AOUT", @@ -769,16 +777,16 @@ static int snd_es1688_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_es1688_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es1688_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es1688 *chip = snd_kcontrol_chip(kcontrol); + es1688_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = snd_es1688_mixer_read(chip, ES1688_REC_DEV) & 7; return 0; } -static int snd_es1688_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es1688_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es1688 *chip = snd_kcontrol_chip(kcontrol); + es1688_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned char oval, nval; int change; @@ -801,7 +809,7 @@ static int snd_es1688_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem .get = snd_es1688_get_single, .put = snd_es1688_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_es1688_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es1688_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -812,9 +820,9 @@ static int snd_es1688_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_es1688_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es1688_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es1688 *chip = snd_kcontrol_chip(kcontrol); + es1688_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -829,9 +837,9 @@ static int snd_es1688_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_es1688_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es1688_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es1688 *chip = snd_kcontrol_chip(kcontrol); + es1688_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -860,7 +868,7 @@ static int snd_es1688_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e .get = snd_es1688_get_double, .put = snd_es1688_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static int snd_es1688_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es1688_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -871,9 +879,9 @@ static int snd_es1688_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_es1688_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es1688_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es1688 *chip = snd_kcontrol_chip(kcontrol); + es1688_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -905,9 +913,9 @@ static int snd_es1688_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_es1688_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es1688_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es1688 *chip = snd_kcontrol_chip(kcontrol); + es1688_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -968,7 +976,7 @@ static int snd_es1688_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return change; } -static struct snd_kcontrol_new snd_es1688_controls[] = { +static snd_kcontrol_new_t snd_es1688_controls[] = { ES1688_DOUBLE("Master Playback Volume", 0, ES1688_MASTER_DEV, ES1688_MASTER_DEV, 4, 0, 15, 0), ES1688_DOUBLE("PCM Playback Volume", 0, ES1688_PCM_DEV, ES1688_PCM_DEV, 4, 0, 15, 0), ES1688_DOUBLE("Line Playback Volume", 0, ES1688_LINE_DEV, ES1688_LINE_DEV, 4, 0, 15, 0), @@ -1003,9 +1011,9 @@ static unsigned char snd_es1688_init_table[][2] = { { ES1688_REC_DEV, 0x17 } }; -int snd_es1688_mixer(struct snd_es1688 *chip) +int snd_es1688_mixer(es1688_t *chip) { - struct snd_card *card; + snd_card_t *card; unsigned int idx; int err; unsigned char reg, val; diff --git a/trunk/sound/isa/es18xx.c b/trunk/sound/isa/es18xx.c index bf5de0782eb0..970e2aaade27 100644 --- a/trunk/sound/isa/es18xx.c +++ b/trunk/sound/isa/es18xx.c @@ -65,28 +65,28 @@ #include <sound/driver.h> +#include <asm/io.h> +#include <asm/dma.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> +#include <linux/pm.h> #include <linux/slab.h> #include <linux/pnp.h> #include <linux/isapnp.h> #include <linux/moduleparam.h> -#include <asm/io.h> -#include <asm/dma.h> #include <sound/core.h> #include <sound/control.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include <sound/mpu401.h> #include <sound/opl3.h> +#define SNDRV_LEGACY_AUTO_PROBE #define SNDRV_LEGACY_FIND_FREE_IRQ #define SNDRV_LEGACY_FIND_FREE_DMA #include <sound/initval.h> #define PFX "es18xx: " -struct snd_es18xx { +struct _snd_es18xx { unsigned long port; /* port of ESS chip */ unsigned long mpu_port; /* MPU-401 port of ESS chip */ unsigned long fm_port; /* FM port */ @@ -107,18 +107,18 @@ struct snd_es18xx { unsigned int dma1_shift; unsigned int dma2_shift; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_a_substream; - struct snd_pcm_substream *capture_a_substream; - struct snd_pcm_substream *playback_b_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_a_substream; + snd_pcm_substream_t *capture_a_substream; + snd_pcm_substream_t *playback_b_substream; - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; - struct snd_kcontrol *hw_volume; - struct snd_kcontrol *hw_switch; - struct snd_kcontrol *master_volume; - struct snd_kcontrol *master_switch; + snd_kcontrol_t *hw_volume; + snd_kcontrol_t *hw_switch; + snd_kcontrol_t *master_volume; + snd_kcontrol_t *master_switch; spinlock_t reg_lock; spinlock_t mixer_lock; @@ -128,14 +128,6 @@ struct snd_es18xx { #endif }; -struct snd_audiodrive { - struct snd_es18xx *chip; -#ifdef CONFIG_PNP - struct pnp_dev *dev; - struct pnp_dev *devc; -#endif -}; - #define AUDIO1_IRQ 0x01 #define AUDIO2_IRQ 0x02 #define HWV_IRQ 0x04 @@ -163,6 +155,8 @@ struct snd_audiodrive { #define ES18XX_PM_FM 0x020 #define ES18XX_PM_SUS 0x080 +typedef struct _snd_es18xx es18xx_t; + /* Lowlevel */ #define DAC1 0x01 @@ -170,7 +164,7 @@ struct snd_audiodrive { #define DAC2 0x04 #define MILLISECOND 10000 -static int snd_es18xx_dsp_command(struct snd_es18xx *chip, unsigned char val) +static int snd_es18xx_dsp_command(es18xx_t *chip, unsigned char val) { int i; @@ -183,7 +177,7 @@ static int snd_es18xx_dsp_command(struct snd_es18xx *chip, unsigned char val) return -EINVAL; } -static int snd_es18xx_dsp_get_byte(struct snd_es18xx *chip) +static int snd_es18xx_dsp_get_byte(es18xx_t *chip) { int i; @@ -197,7 +191,7 @@ static int snd_es18xx_dsp_get_byte(struct snd_es18xx *chip) #undef REG_DEBUG -static int snd_es18xx_write(struct snd_es18xx *chip, +static int snd_es18xx_write(es18xx_t *chip, unsigned char reg, unsigned char data) { unsigned long flags; @@ -216,7 +210,7 @@ static int snd_es18xx_write(struct snd_es18xx *chip, return ret; } -static int snd_es18xx_read(struct snd_es18xx *chip, unsigned char reg) +static int snd_es18xx_read(es18xx_t *chip, unsigned char reg) { unsigned long flags; int ret, data; @@ -238,7 +232,7 @@ static int snd_es18xx_read(struct snd_es18xx *chip, unsigned char reg) } /* Return old value */ -static int snd_es18xx_bits(struct snd_es18xx *chip, unsigned char reg, +static int snd_es18xx_bits(es18xx_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { int ret; @@ -276,7 +270,7 @@ static int snd_es18xx_bits(struct snd_es18xx *chip, unsigned char reg, return ret; } -static inline void snd_es18xx_mixer_write(struct snd_es18xx *chip, +static inline void snd_es18xx_mixer_write(es18xx_t *chip, unsigned char reg, unsigned char data) { unsigned long flags; @@ -289,7 +283,7 @@ static inline void snd_es18xx_mixer_write(struct snd_es18xx *chip, #endif } -static inline int snd_es18xx_mixer_read(struct snd_es18xx *chip, unsigned char reg) +static inline int snd_es18xx_mixer_read(es18xx_t *chip, unsigned char reg) { unsigned long flags; int data; @@ -304,7 +298,7 @@ static inline int snd_es18xx_mixer_read(struct snd_es18xx *chip, unsigned char r } /* Return old value */ -static inline int snd_es18xx_mixer_bits(struct snd_es18xx *chip, unsigned char reg, +static inline int snd_es18xx_mixer_bits(es18xx_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { unsigned char old, new, oval; @@ -325,7 +319,7 @@ static inline int snd_es18xx_mixer_bits(struct snd_es18xx *chip, unsigned char r return oval; } -static inline int snd_es18xx_mixer_writable(struct snd_es18xx *chip, unsigned char reg, +static inline int snd_es18xx_mixer_writable(es18xx_t *chip, unsigned char reg, unsigned char mask) { int old, expected, new; @@ -345,7 +339,7 @@ static inline int snd_es18xx_mixer_writable(struct snd_es18xx *chip, unsigned ch } -static int snd_es18xx_reset(struct snd_es18xx *chip) +static int snd_es18xx_reset(es18xx_t *chip) { int i; outb(0x03, chip->port + 0x06); @@ -357,7 +351,7 @@ static int snd_es18xx_reset(struct snd_es18xx *chip) return 0; } -static int snd_es18xx_reset_fifo(struct snd_es18xx *chip) +static int snd_es18xx_reset_fifo(es18xx_t *chip) { outb(0x02, chip->port + 0x06); inb(chip->port + 0x06); @@ -365,7 +359,7 @@ static int snd_es18xx_reset_fifo(struct snd_es18xx *chip) return 0; } -static struct snd_ratnum new_clocks[2] = { +static ratnum_t new_clocks[2] = { { .num = 793800, .den_min = 1, @@ -380,12 +374,12 @@ static struct snd_ratnum new_clocks[2] = { } }; -static struct snd_pcm_hw_constraint_ratnums new_hw_constraints_clocks = { +static snd_pcm_hw_constraint_ratnums_t new_hw_constraints_clocks = { .nrats = 2, .rats = new_clocks, }; -static struct snd_ratnum old_clocks[2] = { +static ratnum_t old_clocks[2] = { { .num = 795444, .den_min = 1, @@ -400,18 +394,18 @@ static struct snd_ratnum old_clocks[2] = { } }; -static struct snd_pcm_hw_constraint_ratnums old_hw_constraints_clocks = { +static snd_pcm_hw_constraint_ratnums_t old_hw_constraints_clocks = { .nrats = 2, .rats = old_clocks, }; -static void snd_es18xx_rate_set(struct snd_es18xx *chip, - struct snd_pcm_substream *substream, +static void snd_es18xx_rate_set(es18xx_t *chip, + snd_pcm_substream_t *substream, int mode) { unsigned int bits, div0; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (chip->caps & ES18XX_NEW_RATE) { if (runtime->rate_num == new_clocks[0].num) bits = 128 - runtime->rate_den; @@ -441,10 +435,10 @@ static void snd_es18xx_rate_set(struct snd_es18xx *chip, } } -static int snd_es18xx_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_es18xx_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); int shift, err; shift = 0; @@ -469,15 +463,15 @@ static int snd_es18xx_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_es18xx_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_es18xx_pcm_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_es18xx_playback1_prepare(struct snd_es18xx *chip, - struct snd_pcm_substream *substream) +static int snd_es18xx_playback1_prepare(es18xx_t *chip, + snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -502,8 +496,8 @@ static int snd_es18xx_playback1_prepare(struct snd_es18xx *chip, return 0; } -static int snd_es18xx_playback1_trigger(struct snd_es18xx *chip, - struct snd_pcm_substream *substream, +static int snd_es18xx_playback1_trigger(es18xx_t *chip, + snd_pcm_substream_t * substream, int cmd) { switch (cmd) { @@ -552,10 +546,10 @@ static int snd_es18xx_playback1_trigger(struct snd_es18xx *chip, return 0; } -static int snd_es18xx_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_es18xx_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); int shift, err; shift = 0; @@ -575,10 +569,10 @@ static int snd_es18xx_capture_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_es18xx_capture_prepare(struct snd_pcm_substream *substream) +static int snd_es18xx_capture_prepare(snd_pcm_substream_t *substream) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es18xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -614,10 +608,10 @@ static int snd_es18xx_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_es18xx_capture_trigger(struct snd_pcm_substream *substream, +static int snd_es18xx_capture_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -643,10 +637,10 @@ static int snd_es18xx_capture_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_es18xx_playback2_prepare(struct snd_es18xx *chip, - struct snd_pcm_substream *substream) +static int snd_es18xx_playback2_prepare(es18xx_t *chip, + snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -680,8 +674,8 @@ static int snd_es18xx_playback2_prepare(struct snd_es18xx *chip, return 0; } -static int snd_es18xx_playback2_trigger(struct snd_es18xx *chip, - struct snd_pcm_substream *substream, +static int snd_es18xx_playback2_trigger(es18xx_t *chip, + snd_pcm_substream_t *substream, int cmd) { switch (cmd) { @@ -720,19 +714,19 @@ static int snd_es18xx_playback2_trigger(struct snd_es18xx *chip, return 0; } -static int snd_es18xx_playback_prepare(struct snd_pcm_substream *substream) +static int snd_es18xx_playback_prepare(snd_pcm_substream_t *substream) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) return snd_es18xx_playback1_prepare(chip, substream); else return snd_es18xx_playback2_prepare(chip, substream); } -static int snd_es18xx_playback_trigger(struct snd_pcm_substream *substream, +static int snd_es18xx_playback_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) return snd_es18xx_playback1_trigger(chip, substream, cmd); else @@ -741,7 +735,7 @@ static int snd_es18xx_playback_trigger(struct snd_pcm_substream *substream, static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_es18xx *chip = dev_id; + es18xx_t *chip = dev_id; unsigned char status; if (chip->caps & ES18XX_CONTROL) { @@ -801,9 +795,9 @@ static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *r return IRQ_HANDLED; } -static snd_pcm_uframes_t snd_es18xx_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es18xx_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); int pos; if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) { @@ -819,9 +813,9 @@ static snd_pcm_uframes_t snd_es18xx_playback_pointer(struct snd_pcm_substream *s } } -static snd_pcm_uframes_t snd_es18xx_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es18xx_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); int pos; if (!(chip->active & ADC1)) @@ -830,7 +824,7 @@ static snd_pcm_uframes_t snd_es18xx_capture_pointer(struct snd_pcm_substream *su return pos >> chip->dma1_shift; } -static struct snd_pcm_hardware snd_es18xx_playback = +static snd_pcm_hardware_t snd_es18xx_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_RESUME | @@ -850,7 +844,7 @@ static struct snd_pcm_hardware snd_es18xx_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_es18xx_capture = +static snd_pcm_hardware_t snd_es18xx_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_RESUME | @@ -870,10 +864,10 @@ static struct snd_pcm_hardware snd_es18xx_capture = .fifo_size = 0, }; -static int snd_es18xx_playback_open(struct snd_pcm_substream *substream) +static int snd_es18xx_playback_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + es18xx_t *chip = snd_pcm_substream_chip(substream); if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) { if ((chip->caps & ES18XX_DUPLEX_MONO) && @@ -895,10 +889,10 @@ static int snd_es18xx_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es18xx_capture_open(struct snd_pcm_substream *substream) +static int snd_es18xx_capture_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + es18xx_t *chip = snd_pcm_substream_chip(substream); if (chip->playback_b_substream) return -EAGAIN; @@ -913,9 +907,9 @@ static int snd_es18xx_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es18xx_playback_close(struct snd_pcm_substream *substream) +static int snd_es18xx_playback_close(snd_pcm_substream_t * substream) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) chip->playback_a_substream = NULL; @@ -926,9 +920,9 @@ static int snd_es18xx_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_es18xx_capture_close(struct snd_pcm_substream *substream) +static int snd_es18xx_capture_close(snd_pcm_substream_t * substream) { - struct snd_es18xx *chip = snd_pcm_substream_chip(substream); + es18xx_t *chip = snd_pcm_substream_chip(substream); chip->capture_a_substream = NULL; snd_pcm_lib_free_pages(substream); @@ -939,7 +933,7 @@ static int snd_es18xx_capture_close(struct snd_pcm_substream *substream) * MIXER part */ -static int snd_es18xx_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es18xx_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[8] = { "Mic", "Mic Master", "CD", "AOUT", @@ -955,16 +949,16 @@ static int snd_es18xx_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_es18xx_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = snd_es18xx_mixer_read(chip, 0x1c) & 0x07; return 0; } -static int snd_es18xx_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned char val = ucontrol->value.enumerated.item[0]; if (val > 7) @@ -972,7 +966,7 @@ static int snd_es18xx_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return snd_es18xx_mixer_bits(chip, 0x1c, 0x07, val) != val; } -static int snd_es18xx_info_spatializer_enable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es18xx_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -981,17 +975,17 @@ static int snd_es18xx_info_spatializer_enable(struct snd_kcontrol *kcontrol, str return 0; } -static int snd_es18xx_get_spatializer_enable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_get_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned char val = snd_es18xx_mixer_read(chip, 0x50); ucontrol->value.integer.value[0] = !!(val & 8); return 0; } -static int snd_es18xx_put_spatializer_enable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned char oval, nval; int change; nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04; @@ -1004,7 +998,7 @@ static int snd_es18xx_put_spatializer_enable(struct snd_kcontrol *kcontrol, stru return change; } -static int snd_es18xx_info_hw_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es18xx_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1013,15 +1007,15 @@ static int snd_es18xx_info_hw_volume(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_es18xx_get_hw_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = snd_es18xx_mixer_read(chip, 0x61) & 0x3f; ucontrol->value.integer.value[1] = snd_es18xx_mixer_read(chip, 0x63) & 0x3f; return 0; } -static int snd_es18xx_info_hw_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es18xx_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -1030,24 +1024,24 @@ static int snd_es18xx_info_hw_switch(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_es18xx_get_hw_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = !(snd_es18xx_mixer_read(chip, 0x61) & 0x40); ucontrol->value.integer.value[1] = !(snd_es18xx_mixer_read(chip, 0x63) & 0x40); return 0; } -static void snd_es18xx_hwv_free(struct snd_kcontrol *kcontrol) +static void snd_es18xx_hwv_free(snd_kcontrol_t *kcontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); chip->master_volume = NULL; chip->master_switch = NULL; chip->hw_volume = NULL; chip->hw_switch = NULL; } -static int snd_es18xx_reg_bits(struct snd_es18xx *chip, unsigned char reg, +static int snd_es18xx_reg_bits(es18xx_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { if (reg < 0xa0) @@ -1056,7 +1050,7 @@ static int snd_es18xx_reg_bits(struct snd_es18xx *chip, unsigned char reg, return snd_es18xx_bits(chip, reg, mask, val); } -static int snd_es18xx_reg_read(struct snd_es18xx *chip, unsigned char reg) +static int snd_es18xx_reg_read(es18xx_t *chip, unsigned char reg) { if (reg < 0xa0) return snd_es18xx_mixer_read(chip, reg); @@ -1070,7 +1064,7 @@ static int snd_es18xx_reg_read(struct snd_es18xx *chip, unsigned char reg) .get = snd_es18xx_get_single, .put = snd_es18xx_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_es18xx_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es18xx_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1081,9 +1075,9 @@ static int snd_es18xx_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_es18xx_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1097,9 +1091,9 @@ static int snd_es18xx_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_es18xx_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1120,7 +1114,7 @@ static int snd_es18xx_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e .get = snd_es18xx_get_double, .put = snd_es18xx_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static int snd_es18xx_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_es18xx_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -1131,9 +1125,9 @@ static int snd_es18xx_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_es18xx_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; @@ -1156,9 +1150,9 @@ static int snd_es18xx_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_es18xx_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_es18xx_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_es18xx *chip = snd_kcontrol_chip(kcontrol); + es18xx_t *chip = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; @@ -1191,7 +1185,7 @@ static int snd_es18xx_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return change; } -static struct snd_kcontrol_new snd_es18xx_base_controls[] = { +static snd_kcontrol_new_t snd_es18xx_base_controls[] = { ES18XX_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0), ES18XX_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1), ES18XX_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0), @@ -1213,10 +1207,10 @@ ES18XX_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1), } }; -static struct snd_kcontrol_new snd_es18xx_mono_in_control = +static snd_kcontrol_new_t snd_es18xx_mono_in_control = ES18XX_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0); -static struct snd_kcontrol_new snd_es18xx_recmix_controls[] = { +static snd_kcontrol_new_t snd_es18xx_recmix_controls[] = { ES18XX_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0), ES18XX_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0), ES18XX_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0), @@ -1226,16 +1220,16 @@ ES18XX_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0), ES18XX_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0) }; -static struct snd_kcontrol_new snd_es18xx_pcm1_controls[] = { +static snd_kcontrol_new_t snd_es18xx_pcm1_controls[] = { ES18XX_DOUBLE("PCM Playback Volume", 0, 0x14, 0x14, 4, 0, 15, 0), }; -static struct snd_kcontrol_new snd_es18xx_pcm2_controls[] = { +static snd_kcontrol_new_t snd_es18xx_pcm2_controls[] = { ES18XX_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0), ES18XX_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0) }; -static struct snd_kcontrol_new snd_es18xx_spatializer_controls[] = { +static snd_kcontrol_new_t snd_es18xx_spatializer_controls[] = { ES18XX_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0), { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, @@ -1246,13 +1240,13 @@ ES18XX_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0), } }; -static struct snd_kcontrol_new snd_es18xx_micpre1_control = +static snd_kcontrol_new_t snd_es18xx_micpre1_control = ES18XX_SINGLE("Mic Boost (+26dB)", 0, 0xa9, 2, 1, 0); -static struct snd_kcontrol_new snd_es18xx_micpre2_control = +static snd_kcontrol_new_t snd_es18xx_micpre2_control = ES18XX_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0); -static struct snd_kcontrol_new snd_es18xx_hw_volume_controls[] = { +static snd_kcontrol_new_t snd_es18xx_hw_volume_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Hardware Master Playback Volume", @@ -1271,7 +1265,7 @@ ES18XX_SINGLE("Hardware Master Volume Split", 0, 0x64, 7, 1, 0), }; #if 0 -static int __devinit snd_es18xx_config_read(struct snd_es18xx *chip, unsigned char reg) +static int __devinit snd_es18xx_config_read(es18xx_t *chip, unsigned char reg) { int data; unsigned long flags; @@ -1283,7 +1277,7 @@ static int __devinit snd_es18xx_config_read(struct snd_es18xx *chip, unsigned ch } #endif -static void __devinit snd_es18xx_config_write(struct snd_es18xx *chip, +static void __devinit snd_es18xx_config_write(es18xx_t *chip, unsigned char reg, unsigned char data) { /* No need for spinlocks, this function is used only in @@ -1295,7 +1289,7 @@ static void __devinit snd_es18xx_config_write(struct snd_es18xx *chip, #endif } -static int __devinit snd_es18xx_initialize(struct snd_es18xx *chip) +static int __devinit snd_es18xx_initialize(es18xx_t *chip) { int mask = 0; @@ -1444,7 +1438,7 @@ static int __devinit snd_es18xx_initialize(struct snd_es18xx *chip) return 0; } -static int __devinit snd_es18xx_identify(struct snd_es18xx *chip) +static int __devinit snd_es18xx_identify(es18xx_t *chip) { int hi,lo; @@ -1510,7 +1504,7 @@ static int __devinit snd_es18xx_identify(struct snd_es18xx *chip) return 0; } -static int __devinit snd_es18xx_probe(struct snd_es18xx *chip) +static int __devinit snd_es18xx_probe(es18xx_t *chip) { if (snd_es18xx_identify(chip) < 0) { snd_printk(KERN_ERR PFX "[0x%lx] ESS chip not found\n", chip->port); @@ -1550,7 +1544,7 @@ static int __devinit snd_es18xx_probe(struct snd_es18xx *chip) return snd_es18xx_initialize(chip); } -static struct snd_pcm_ops snd_es18xx_playback_ops = { +static snd_pcm_ops_t snd_es18xx_playback_ops = { .open = snd_es18xx_playback_open, .close = snd_es18xx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1561,7 +1555,7 @@ static struct snd_pcm_ops snd_es18xx_playback_ops = { .pointer = snd_es18xx_playback_pointer, }; -static struct snd_pcm_ops snd_es18xx_capture_ops = { +static snd_pcm_ops_t snd_es18xx_capture_ops = { .open = snd_es18xx_capture_open, .close = snd_es18xx_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1572,19 +1566,27 @@ static struct snd_pcm_ops snd_es18xx_capture_ops = { .pointer = snd_es18xx_capture_pointer, }; -static int __devinit snd_es18xx_pcm(struct snd_es18xx *chip, int device, struct snd_pcm ** rpcm) +static void snd_es18xx_pcm_free(snd_pcm_t *pcm) +{ + es18xx_t *codec = pcm->private_data; + codec->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_es18xx_pcm(es18xx_t *chip, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; char str[16]; int err; if (rpcm) *rpcm = NULL; sprintf(str, "ES%x", chip->version); - if (chip->caps & ES18XX_PCM2) + if (chip->caps & ES18XX_PCM2) { err = snd_pcm_new(chip->card, str, device, 2, 1, &pcm); - else + } else { err = snd_pcm_new(chip->card, str, device, 1, 1, &pcm); + } if (err < 0) return err; @@ -1593,6 +1595,7 @@ static int __devinit snd_es18xx_pcm(struct snd_es18xx *chip, int device, struct /* global setup */ pcm->private_data = chip; + pcm->private_free = snd_es18xx_pcm_free; pcm->info_flags = 0; if (chip->caps & ES18XX_DUPLEX_SAME) pcm->info_flags |= SNDRV_PCM_INFO_JOINT_DUPLEX; @@ -1613,12 +1616,9 @@ static int __devinit snd_es18xx_pcm(struct snd_es18xx *chip, int device, struct /* Power Management support functions */ #ifdef CONFIG_PM -static int snd_es18xx_suspend(struct snd_card *card, pm_message_t state) +static int snd_es18xx_suspend(snd_card_t *card, pm_message_t state) { - struct snd_audiodrive *acard = card->private_data; - struct snd_es18xx *chip = acard->chip; - - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot); + es18xx_t *chip = card->pm_private_data; snd_pcm_suspend_all(chip->pcm); @@ -1631,20 +1631,18 @@ static int snd_es18xx_suspend(struct snd_card *card, pm_message_t state) return 0; } -static int snd_es18xx_resume(struct snd_card *card) +static int snd_es18xx_resume(snd_card_t *card) { - struct snd_audiodrive *acard = card->private_data; - struct snd_es18xx *chip = acard->chip; + es18xx_t *chip = card->pm_private_data; /* restore PM register, we won't wake till (not 0x07) i/o activity though */ snd_es18xx_write(chip, ES18XX_PM, chip->pm_reg ^= ES18XX_PM_FM); - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -static int snd_es18xx_free(struct snd_es18xx *chip) +static int snd_es18xx_free(es18xx_t *chip) { release_and_free_resource(chip->res_port); release_and_free_resource(chip->res_ctrl_port); @@ -1663,21 +1661,21 @@ static int snd_es18xx_free(struct snd_es18xx *chip) return 0; } -static int snd_es18xx_dev_free(struct snd_device *device) +static int snd_es18xx_dev_free(snd_device_t *device) { - struct snd_es18xx *chip = device->device_data; + es18xx_t *chip = device->device_data; return snd_es18xx_free(chip); } -static int __devinit snd_es18xx_new_device(struct snd_card *card, +static int __devinit snd_es18xx_new_device(snd_card_t * card, unsigned long port, unsigned long mpu_port, unsigned long fm_port, int irq, int dma1, int dma2, - struct snd_es18xx ** rchip) + es18xx_t ** rchip) { - struct snd_es18xx *chip; - static struct snd_device_ops ops = { + es18xx_t *chip; + static snd_device_ops_t ops = { .dev_free = snd_es18xx_dev_free, }; int err; @@ -1738,9 +1736,9 @@ static int __devinit snd_es18xx_new_device(struct snd_card *card, return 0; } -static int __devinit snd_es18xx_mixer(struct snd_es18xx *chip) +static int __devinit snd_es18xx_mixer(es18xx_t *chip) { - struct snd_card *card; + snd_card_t *card; int err; unsigned int idx; @@ -1749,7 +1747,7 @@ static int __devinit snd_es18xx_mixer(struct snd_es18xx *chip) strcpy(card->mixername, chip->pcm->name); for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_base_controls); idx++) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; kctl = snd_ctl_new1(&snd_es18xx_base_controls[idx], chip); if (chip->caps & ES18XX_HWV) { switch (idx) { @@ -1807,7 +1805,7 @@ static int __devinit snd_es18xx_mixer(struct snd_es18xx *chip) } if (chip->caps & ES18XX_HWV) { for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_hw_volume_controls); idx++) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; kctl = snd_ctl_new1(&snd_es18xx_hw_volume_controls[idx], chip); if (idx == 0) chip->hw_volume = kctl; @@ -1877,8 +1875,14 @@ MODULE_PARM_DESC(dma1, "DMA 1 # for ES18xx driver."); module_param_array(dma2, int, NULL, 0444); MODULE_PARM_DESC(dma2, "DMA 2 # for ES18xx driver."); -static struct platform_device *platform_devices[SNDRV_CARDS]; -static int pnp_registered; +struct snd_audiodrive { +#ifdef CONFIG_PNP + struct pnp_dev *dev; + struct pnp_dev *devc; +#endif +}; + +static snd_card_t *snd_audiodrive_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; #ifdef CONFIG_PNP @@ -1985,281 +1989,227 @@ static int __devinit snd_audiodrive_pnp(int dev, struct snd_audiodrive *acard, #define is_isapnp_selected(dev) 0 #endif -static struct snd_card *snd_es18xx_card_new(int dev) +static int __devinit snd_audiodrive_probe(int dev, struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { - return snd_card_new(index[dev], id[dev], THIS_MODULE, + static int possible_irqs[] = {5, 9, 10, 7, 11, 12, -1}; + static int possible_dmas[] = {1, 0, 3, 5, -1}; + int xirq, xdma1, xdma2; + snd_card_t *card; + struct snd_audiodrive *acard; + es18xx_t *chip; + opl3_t *opl3; + int err; + + card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_audiodrive)); -} + if (card == NULL) + return -ENOMEM; + acard = (struct snd_audiodrive *)card->private_data; +#ifdef CONFIG_PNP + if (isapnp[dev]) { + if ((err = snd_audiodrive_pnp(dev, acard, pcard, pid)) < 0) { + snd_card_free(card); + return err; + } + snd_card_set_dev(card, &pcard->card->dev); + } +#endif -static int __devinit snd_audiodrive_probe(struct snd_card *card, int dev) -{ - struct snd_audiodrive *acard = card->private_data; - struct snd_es18xx *chip; - struct snd_opl3 *opl3; - int err; + xirq = irq[dev]; + if (xirq == SNDRV_AUTO_IRQ) { + if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); + err = -EBUSY; + goto _err; + } + } + xdma1 = dma1[dev]; + if (xdma1 == SNDRV_AUTO_DMA) { + if ((xdma1 = snd_legacy_find_free_dma(possible_dmas)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free DMA1\n"); + err = -EBUSY; + goto _err; + } + } + xdma2 = dma2[dev]; + if (xdma2 == SNDRV_AUTO_DMA) { + if ((xdma2 = snd_legacy_find_free_dma(possible_dmas)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free DMA2\n"); + err = -EBUSY; + goto _err; + } + } if ((err = snd_es18xx_new_device(card, port[dev], mpu_port[dev], fm_port[dev], - irq[dev], dma1[dev], dma2[dev], + xirq, xdma1, xdma2, &chip)) < 0) - return err; - acard->chip = chip; + goto _err; sprintf(card->driver, "ES%x", chip->version); - sprintf(card->shortname, "ESS AudioDrive ES%x", chip->version); - if (dma1[dev] != dma2[dev]) + if (xdma1 != xdma2) sprintf(card->longname, "%s at 0x%lx, irq %d, dma1 %d, dma2 %d", card->shortname, chip->port, - irq[dev], dma1[dev], dma2[dev]); + xirq, xdma1, xdma2); else sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d", card->shortname, chip->port, - irq[dev], dma1[dev]); + xirq, xdma1); if ((err = snd_es18xx_pcm(chip, 0, NULL)) < 0) - return err; + goto _err; if ((err = snd_es18xx_mixer(chip)) < 0) - return err; + goto _err; if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { if (snd_opl3_create(card, chip->fm_port, chip->fm_port + 2, OPL3_HW_OPL3, 0, &opl3) < 0) { snd_printk(KERN_WARNING PFX "opl3 not detected at 0x%lx\n", chip->fm_port); } else { if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) - return err; + goto _err; } } if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) { if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_ES18XX, chip->mpu_port, 0, - irq[dev], 0, + xirq, 0, &chip->rmidi)) < 0) - return err; + goto _err; } - return snd_card_register(card); -} - -static int __init snd_es18xx_nonpnp_probe1(int dev, struct platform_device *devptr) -{ - struct snd_card *card; - int err; + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; - card = snd_es18xx_card_new(dev); - if (! card) - return -ENOMEM; - snd_card_set_dev(card, &devptr->dev); - if ((err = snd_audiodrive_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - platform_set_drvdata(devptr, card); - return 0; -} - -static int __init snd_es18xx_nonpnp_probe(struct platform_device *pdev) -{ - int dev = pdev->id; - int err; - static int possible_irqs[] = {5, 9, 10, 7, 11, 12, -1}; - static int possible_dmas[] = {1, 0, 3, 5, -1}; - - if (irq[dev] == SNDRV_AUTO_IRQ) { - if ((irq[dev] = snd_legacy_find_free_irq(possible_irqs)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); - return -EBUSY; - } - } - if (dma1[dev] == SNDRV_AUTO_DMA) { - if ((dma1[dev] = snd_legacy_find_free_dma(possible_dmas)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free DMA1\n"); - return -EBUSY; - } - } - if (dma2[dev] == SNDRV_AUTO_DMA) { - if ((dma2[dev] = snd_legacy_find_free_dma(possible_dmas)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free DMA2\n"); - return -EBUSY; - } - } + /* Power Management */ + snd_card_set_isa_pm_callback(card, snd_es18xx_suspend, snd_es18xx_resume, chip); - if (port[dev] != SNDRV_AUTO_PORT) { - return snd_es18xx_nonpnp_probe1(dev, pdev); - } else { - static unsigned long possible_ports[] = {0x220, 0x240, 0x260, 0x280}; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - port[dev] = possible_ports[i]; - err = snd_es18xx_nonpnp_probe1(dev, pdev); - if (! err) - return 0; - } - return err; - } -} + if ((err = snd_card_register(card)) < 0) + goto _err; -static int __devexit snd_es18xx_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); + if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_audiodrive_legacy[dev] = card; return 0; -} -#ifdef CONFIG_PM -static int snd_es18xx_nonpnp_suspend(struct platform_device *dev, pm_message_t state) -{ - return snd_es18xx_suspend(platform_get_drvdata(dev), state); + _err: + snd_card_free(card); + return err; } -static int snd_es18xx_nonpnp_resume(struct platform_device *dev) +static int __devinit snd_audiodrive_probe_legacy_port(unsigned long xport) { - return snd_es18xx_resume(platform_get_drvdata(dev)); -} -#endif - -#define ES18XX_DRIVER "snd_es18xx" + static int dev; + int res; -static struct platform_driver snd_es18xx_nonpnp_driver = { - .probe = snd_es18xx_nonpnp_probe, - .remove = __devexit_p(snd_es18xx_nonpnp_remove), -#ifdef CONFIG_PM - .suspend = snd_es18xx_nonpnp_suspend, - .resume = snd_es18xx_nonpnp_resume, -#endif - .driver = { - .name = ES18XX_DRIVER - }, -}; + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; + if (is_isapnp_selected(dev)) + continue; + port[dev] = xport; + res = snd_audiodrive_probe(dev, NULL, NULL); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; + } + return -ENODEV; +} #ifdef CONFIG_PNP -static int __devinit snd_audiodrive_pnp_detect(struct pnp_card_link *pcard, - const struct pnp_card_device_id *pid) +static int __devinit snd_audiodrive_pnp_detect(struct pnp_card_link *card, + const struct pnp_card_device_id *id) { static int dev; - struct snd_card *card; int res; for ( ; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_es18xx_card_new(dev); - if (! card) - return -ENOMEM; - - if ((res = snd_audiodrive_pnp(dev, card->private_data, pcard, pid)) < 0) { - snd_card_free(card); - return res; - } - snd_card_set_dev(card, &pcard->card->dev); - if ((res = snd_audiodrive_probe(card, dev)) < 0) { - snd_card_free(card); - return res; - } + if (!enable[dev] || !isapnp[dev]) + continue; + res = snd_audiodrive_probe(dev, card, id); + if (res < 0) + return res; + dev++; + return 0; + } - pnp_set_card_drvdata(pcard, card); - dev++; - return 0; + return -ENODEV; } static void __devexit snd_audiodrive_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); -} - -#ifdef CONFIG_PM -static int snd_audiodrive_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - return snd_es18xx_suspend(pnp_get_card_drvdata(pcard), state); -} + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); -static int snd_audiodrive_pnp_resume(struct pnp_card_link *pcard) -{ - return snd_es18xx_resume(pnp_get_card_drvdata(pcard)); + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -#endif - static struct pnp_card_driver es18xx_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, .name = "es18xx", .id_table = snd_audiodrive_pnpids, .probe = snd_audiodrive_pnp_detect, .remove = __devexit_p(snd_audiodrive_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_audiodrive_pnp_suspend, - .resume = snd_audiodrive_pnp_resume, -#endif }; #endif /* CONFIG_PNP */ -static void __init_or_module snd_es18xx_unregister_all(void) -{ - int i; - - if (pnp_registered) - pnp_unregister_card_driver(&es18xx_pnpc_driver); - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_es18xx_nonpnp_driver); -} - static int __init alsa_card_es18xx_init(void) { - int i, err, cards = 0; + static unsigned long possible_ports[] = {0x220, 0x240, 0x260, 0x280, -1}; + int dev, cards = 0, i; - if ((err = platform_driver_register(&snd_es18xx_nonpnp_driver)) < 0) - return err; - - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - if (is_isapnp_selected(i)) + /* legacy non-auto cards at first */ + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT) continue; - device = platform_device_register_simple(ES18XX_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - platform_devices[i] = device; - cards++; + if (is_isapnp_selected(dev)) + continue; + if (snd_audiodrive_probe(dev, NULL, NULL) >= 0) + cards++; } + /* legacy auto configured cards */ + i = snd_legacy_auto_probe(possible_ports, snd_audiodrive_probe_legacy_port); + if (i > 0) + cards += i; +#ifdef CONFIG_PNP + /* ISA PnP cards at last */ i = pnp_register_card_driver(&es18xx_pnpc_driver); - if (i >= 0) { - pnp_registered = 1; + if (i > 0) cards += i; - } +#endif if(!cards) { +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&es18xx_pnpc_driver); +#endif #ifdef MODULE snd_printk(KERN_ERR "ESS AudioDrive ES18xx soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_es18xx_unregister_all(); - return err; } static void __exit alsa_card_es18xx_exit(void) { - snd_es18xx_unregister_all(); + int idx; + +#ifdef CONFIG_PNP + /* PnP cards first */ + pnp_unregister_card_driver(&es18xx_pnpc_driver); +#endif + for(idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_audiodrive_legacy[idx]); } module_init(alsa_card_es18xx_init) diff --git a/trunk/sound/isa/gus/gus_dma.c b/trunk/sound/isa/gus/gus_dma.c index 930f4bc56f34..ef1b2e9832e4 100644 --- a/trunk/sound/isa/gus/gus_dma.c +++ b/trunk/sound/isa/gus/gus_dma.c @@ -25,7 +25,7 @@ #include <sound/core.h> #include <sound/gus.h> -static void snd_gf1_dma_ack(struct snd_gus_card * gus) +static void snd_gf1_dma_ack(snd_gus_card_t * gus) { unsigned long flags; @@ -35,7 +35,7 @@ static void snd_gf1_dma_ack(struct snd_gus_card * gus) spin_unlock_irqrestore(&gus->reg_lock, flags); } -static void snd_gf1_dma_program(struct snd_gus_card * gus, +static void snd_gf1_dma_program(snd_gus_card_t * gus, unsigned int addr, unsigned long buf_addr, unsigned int count, @@ -91,9 +91,9 @@ static void snd_gf1_dma_program(struct snd_gus_card * gus, spin_unlock_irqrestore(&gus->reg_lock, flags); } -static struct snd_gf1_dma_block *snd_gf1_dma_next_block(struct snd_gus_card * gus) +static snd_gf1_dma_block_t *snd_gf1_dma_next_block(snd_gus_card_t * gus) { - struct snd_gf1_dma_block *block; + snd_gf1_dma_block_t *block; /* PCM block have bigger priority than synthesizer one */ if (gus->gf1.dma_data_pcm) { @@ -123,9 +123,9 @@ static struct snd_gf1_dma_block *snd_gf1_dma_next_block(struct snd_gus_card * gu } -static void snd_gf1_dma_interrupt(struct snd_gus_card * gus) +static void snd_gf1_dma_interrupt(snd_gus_card_t * gus) { - struct snd_gf1_dma_block *block; + snd_gf1_dma_block_t *block; snd_gf1_dma_ack(gus); if (gus->gf1.dma_ack) @@ -147,7 +147,7 @@ static void snd_gf1_dma_interrupt(struct snd_gus_card * gus) #endif } -int snd_gf1_dma_init(struct snd_gus_card * gus) +int snd_gf1_dma_init(snd_gus_card_t * gus) { down(&gus->dma_mutex); gus->gf1.dma_shared++; @@ -164,9 +164,9 @@ int snd_gf1_dma_init(struct snd_gus_card * gus) return 0; } -int snd_gf1_dma_done(struct snd_gus_card * gus) +int snd_gf1_dma_done(snd_gus_card_t * gus) { - struct snd_gf1_dma_block *block; + snd_gf1_dma_block_t *block; down(&gus->dma_mutex); gus->gf1.dma_shared--; @@ -189,13 +189,13 @@ int snd_gf1_dma_done(struct snd_gus_card * gus) return 0; } -int snd_gf1_dma_transfer_block(struct snd_gus_card * gus, - struct snd_gf1_dma_block * __block, +int snd_gf1_dma_transfer_block(snd_gus_card_t * gus, + snd_gf1_dma_block_t * __block, int atomic, int synth) { unsigned long flags; - struct snd_gf1_dma_block *block; + snd_gf1_dma_block_t *block; block = kmalloc(sizeof(*block), atomic ? GFP_ATOMIC : GFP_KERNEL); if (block == NULL) { diff --git a/trunk/sound/isa/gus/gus_dram.c b/trunk/sound/isa/gus/gus_dram.c index f22fe7967fcc..22120b868b5c 100644 --- a/trunk/sound/isa/gus/gus_dram.c +++ b/trunk/sound/isa/gus/gus_dram.c @@ -26,7 +26,7 @@ #include <sound/info.h> -static int snd_gus_dram_poke(struct snd_gus_card *gus, char __user *_buffer, +static int snd_gus_dram_poke(snd_gus_card_t *gus, char __user *_buffer, unsigned int address, unsigned int size) { unsigned long flags; @@ -57,13 +57,13 @@ static int snd_gus_dram_poke(struct snd_gus_card *gus, char __user *_buffer, } -int snd_gus_dram_write(struct snd_gus_card *gus, char __user *buffer, +int snd_gus_dram_write(snd_gus_card_t *gus, char __user *buffer, unsigned int address, unsigned int size) { return snd_gus_dram_poke(gus, buffer, address, size); } -static int snd_gus_dram_peek(struct snd_gus_card *gus, char __user *_buffer, +static int snd_gus_dram_peek(snd_gus_card_t *gus, char __user *_buffer, unsigned int address, unsigned int size, int rom) { @@ -95,7 +95,7 @@ static int snd_gus_dram_peek(struct snd_gus_card *gus, char __user *_buffer, return 0; } -int snd_gus_dram_read(struct snd_gus_card *gus, char __user *buffer, +int snd_gus_dram_read(snd_gus_card_t *gus, char __user *buffer, unsigned int address, unsigned int size, int rom) { diff --git a/trunk/sound/isa/gus/gus_instr.c b/trunk/sound/isa/gus/gus_instr.c index d0c38e1856ef..591a9a17feb5 100644 --- a/trunk/sound/isa/gus/gus_instr.c +++ b/trunk/sound/isa/gus/gus_instr.c @@ -28,11 +28,11 @@ * */ -int snd_gus_iwffff_put_sample(void *private_data, struct iwffff_wave *wave, +int snd_gus_iwffff_put_sample(void *private_data, iwffff_wave_t *wave, char __user *data, long len, int atomic) { - struct snd_gus_card *gus = private_data; - struct snd_gf1_mem_block *block; + snd_gus_card_t *gus = private_data; + snd_gf1_mem_block_t *block; int err; if (wave->format & IWFFFF_WAVE_ROM) @@ -58,19 +58,19 @@ int snd_gus_iwffff_put_sample(void *private_data, struct iwffff_wave *wave, return 0; } -int snd_gus_iwffff_get_sample(void *private_data, struct iwffff_wave *wave, +int snd_gus_iwffff_get_sample(void *private_data, iwffff_wave_t *wave, char __user *data, long len, int atomic) { - struct snd_gus_card *gus = private_data; + snd_gus_card_t *gus = private_data; return snd_gus_dram_read(gus, data, wave->address.memory, wave->size, wave->format & IWFFFF_WAVE_ROM ? 1 : 0); } -int snd_gus_iwffff_remove_sample(void *private_data, struct iwffff_wave *wave, +int snd_gus_iwffff_remove_sample(void *private_data, iwffff_wave_t *wave, int atomic) { - struct snd_gus_card *gus = private_data; + snd_gus_card_t *gus = private_data; if (wave->format & IWFFFF_WAVE_ROM) return 0; /* it's probably ok - verify the address? */ @@ -81,11 +81,11 @@ int snd_gus_iwffff_remove_sample(void *private_data, struct iwffff_wave *wave, * */ -int snd_gus_gf1_put_sample(void *private_data, struct gf1_wave *wave, +int snd_gus_gf1_put_sample(void *private_data, gf1_wave_t *wave, char __user *data, long len, int atomic) { - struct snd_gus_card *gus = private_data; - struct snd_gf1_mem_block *block; + snd_gus_card_t *gus = private_data; + snd_gf1_mem_block_t *block; int err; if (wave->format & GF1_WAVE_STEREO) @@ -109,18 +109,18 @@ int snd_gus_gf1_put_sample(void *private_data, struct gf1_wave *wave, return 0; } -int snd_gus_gf1_get_sample(void *private_data, struct gf1_wave *wave, +int snd_gus_gf1_get_sample(void *private_data, gf1_wave_t *wave, char __user *data, long len, int atomic) { - struct snd_gus_card *gus = private_data; + snd_gus_card_t *gus = private_data; return snd_gus_dram_read(gus, data, wave->address.memory, wave->size, 0); } -int snd_gus_gf1_remove_sample(void *private_data, struct gf1_wave *wave, +int snd_gus_gf1_remove_sample(void *private_data, gf1_wave_t *wave, int atomic) { - struct snd_gus_card *gus = private_data; + snd_gus_card_t *gus = private_data; return snd_gf1_mem_free(&gus->gf1.mem_alloc, wave->address.memory); } @@ -129,11 +129,11 @@ int snd_gus_gf1_remove_sample(void *private_data, struct gf1_wave *wave, * */ -int snd_gus_simple_put_sample(void *private_data, struct simple_instrument *instr, +int snd_gus_simple_put_sample(void *private_data, simple_instrument_t *instr, char __user *data, long len, int atomic) { - struct snd_gus_card *gus = private_data; - struct snd_gf1_mem_block *block; + snd_gus_card_t *gus = private_data; + snd_gf1_mem_block_t *block; int err; if (instr->format & SIMPLE_WAVE_STEREO) @@ -156,18 +156,18 @@ int snd_gus_simple_put_sample(void *private_data, struct simple_instrument *inst return 0; } -int snd_gus_simple_get_sample(void *private_data, struct simple_instrument *instr, +int snd_gus_simple_get_sample(void *private_data, simple_instrument_t *instr, char __user *data, long len, int atomic) { - struct snd_gus_card *gus = private_data; + snd_gus_card_t *gus = private_data; return snd_gus_dram_read(gus, data, instr->address.memory, instr->size, 0); } -int snd_gus_simple_remove_sample(void *private_data, struct simple_instrument *instr, +int snd_gus_simple_remove_sample(void *private_data, simple_instrument_t *instr, int atomic) { - struct snd_gus_card *gus = private_data; + snd_gus_card_t *gus = private_data; return snd_gf1_mem_free(&gus->gf1.mem_alloc, instr->address.memory); } diff --git a/trunk/sound/isa/gus/gus_io.c b/trunk/sound/isa/gus/gus_io.c index 9b1fe292de4d..8d5752b23787 100644 --- a/trunk/sound/isa/gus/gus_io.c +++ b/trunk/sound/isa/gus/gus_io.c @@ -25,7 +25,7 @@ #include <sound/core.h> #include <sound/gus.h> -void snd_gf1_delay(struct snd_gus_card * gus) +void snd_gf1_delay(snd_gus_card_t * gus) { int i; @@ -44,7 +44,7 @@ void snd_gf1_delay(struct snd_gus_card * gus) * big UltraClick (tm) elimination... */ -static inline void __snd_gf1_ctrl_stop(struct snd_gus_card * gus, unsigned char reg) +static inline void __snd_gf1_ctrl_stop(snd_gus_card_t * gus, unsigned char reg) { unsigned char value; @@ -58,7 +58,7 @@ static inline void __snd_gf1_ctrl_stop(struct snd_gus_card * gus, unsigned char mb(); } -static inline void __snd_gf1_write8(struct snd_gus_card * gus, +static inline void __snd_gf1_write8(snd_gus_card_t * gus, unsigned char reg, unsigned char data) { @@ -68,7 +68,7 @@ static inline void __snd_gf1_write8(struct snd_gus_card * gus, mb(); } -static inline unsigned char __snd_gf1_look8(struct snd_gus_card * gus, +static inline unsigned char __snd_gf1_look8(snd_gus_card_t * gus, unsigned char reg) { outb(reg, gus->gf1.reg_regsel); @@ -76,7 +76,7 @@ static inline unsigned char __snd_gf1_look8(struct snd_gus_card * gus, return inb(gus->gf1.reg_data8); } -static inline void __snd_gf1_write16(struct snd_gus_card * gus, +static inline void __snd_gf1_write16(snd_gus_card_t * gus, unsigned char reg, unsigned int data) { outb(reg, gus->gf1.reg_regsel); @@ -85,7 +85,7 @@ static inline void __snd_gf1_write16(struct snd_gus_card * gus, mb(); } -static inline unsigned short __snd_gf1_look16(struct snd_gus_card * gus, +static inline unsigned short __snd_gf1_look16(snd_gus_card_t * gus, unsigned char reg) { outb(reg, gus->gf1.reg_regsel); @@ -93,7 +93,7 @@ static inline unsigned short __snd_gf1_look16(struct snd_gus_card * gus, return inw(gus->gf1.reg_data16); } -static inline void __snd_gf1_adlib_write(struct snd_gus_card * gus, +static inline void __snd_gf1_adlib_write(snd_gus_card_t * gus, unsigned char reg, unsigned char data) { outb(reg, gus->gf1.reg_timerctrl); @@ -104,7 +104,7 @@ static inline void __snd_gf1_adlib_write(struct snd_gus_card * gus, inb(gus->gf1.reg_timerctrl); } -static inline void __snd_gf1_write_addr(struct snd_gus_card * gus, unsigned char reg, +static inline void __snd_gf1_write_addr(snd_gus_card_t * gus, unsigned char reg, unsigned int addr, int w_16bit) { if (gus->gf1.enh_mode) { @@ -117,7 +117,7 @@ static inline void __snd_gf1_write_addr(struct snd_gus_card * gus, unsigned char __snd_gf1_write16(gus, reg + 1, (unsigned short) (addr << 5)); } -static inline unsigned int __snd_gf1_read_addr(struct snd_gus_card * gus, +static inline unsigned int __snd_gf1_read_addr(snd_gus_card_t * gus, unsigned char reg, short w_16bit) { unsigned int res; @@ -138,49 +138,49 @@ static inline unsigned int __snd_gf1_read_addr(struct snd_gus_card * gus, * ======================================================================= */ -void snd_gf1_ctrl_stop(struct snd_gus_card * gus, unsigned char reg) +void snd_gf1_ctrl_stop(snd_gus_card_t * gus, unsigned char reg) { __snd_gf1_ctrl_stop(gus, reg); } -void snd_gf1_write8(struct snd_gus_card * gus, +void snd_gf1_write8(snd_gus_card_t * gus, unsigned char reg, unsigned char data) { __snd_gf1_write8(gus, reg, data); } -unsigned char snd_gf1_look8(struct snd_gus_card * gus, unsigned char reg) +unsigned char snd_gf1_look8(snd_gus_card_t * gus, unsigned char reg) { return __snd_gf1_look8(gus, reg); } -void snd_gf1_write16(struct snd_gus_card * gus, +void snd_gf1_write16(snd_gus_card_t * gus, unsigned char reg, unsigned int data) { __snd_gf1_write16(gus, reg, data); } -unsigned short snd_gf1_look16(struct snd_gus_card * gus, unsigned char reg) +unsigned short snd_gf1_look16(snd_gus_card_t * gus, unsigned char reg) { return __snd_gf1_look16(gus, reg); } -void snd_gf1_adlib_write(struct snd_gus_card * gus, +void snd_gf1_adlib_write(snd_gus_card_t * gus, unsigned char reg, unsigned char data) { __snd_gf1_adlib_write(gus, reg, data); } -void snd_gf1_write_addr(struct snd_gus_card * gus, unsigned char reg, +void snd_gf1_write_addr(snd_gus_card_t * gus, unsigned char reg, unsigned int addr, short w_16bit) { __snd_gf1_write_addr(gus, reg, addr, w_16bit); } -unsigned int snd_gf1_read_addr(struct snd_gus_card * gus, +unsigned int snd_gf1_read_addr(snd_gus_card_t * gus, unsigned char reg, short w_16bit) { @@ -191,7 +191,7 @@ unsigned int snd_gf1_read_addr(struct snd_gus_card * gus, */ -void snd_gf1_i_ctrl_stop(struct snd_gus_card * gus, unsigned char reg) +void snd_gf1_i_ctrl_stop(snd_gus_card_t * gus, unsigned char reg) { unsigned long flags; @@ -200,7 +200,7 @@ void snd_gf1_i_ctrl_stop(struct snd_gus_card * gus, unsigned char reg) spin_unlock_irqrestore(&gus->reg_lock, flags); } -void snd_gf1_i_write8(struct snd_gus_card * gus, +void snd_gf1_i_write8(snd_gus_card_t * gus, unsigned char reg, unsigned char data) { @@ -211,7 +211,7 @@ void snd_gf1_i_write8(struct snd_gus_card * gus, spin_unlock_irqrestore(&gus->reg_lock, flags); } -unsigned char snd_gf1_i_look8(struct snd_gus_card * gus, unsigned char reg) +unsigned char snd_gf1_i_look8(snd_gus_card_t * gus, unsigned char reg) { unsigned long flags; unsigned char res; @@ -222,7 +222,7 @@ unsigned char snd_gf1_i_look8(struct snd_gus_card * gus, unsigned char reg) return res; } -void snd_gf1_i_write16(struct snd_gus_card * gus, +void snd_gf1_i_write16(snd_gus_card_t * gus, unsigned char reg, unsigned int data) { @@ -233,7 +233,7 @@ void snd_gf1_i_write16(struct snd_gus_card * gus, spin_unlock_irqrestore(&gus->reg_lock, flags); } -unsigned short snd_gf1_i_look16(struct snd_gus_card * gus, unsigned char reg) +unsigned short snd_gf1_i_look16(snd_gus_card_t * gus, unsigned char reg) { unsigned long flags; unsigned short res; @@ -246,7 +246,7 @@ unsigned short snd_gf1_i_look16(struct snd_gus_card * gus, unsigned char reg) #if 0 -void snd_gf1_i_adlib_write(struct snd_gus_card * gus, +void snd_gf1_i_adlib_write(snd_gus_card_t * gus, unsigned char reg, unsigned char data) { @@ -257,7 +257,7 @@ void snd_gf1_i_adlib_write(struct snd_gus_card * gus, spin_unlock_irqrestore(&gus->reg_lock, flags); } -void snd_gf1_i_write_addr(struct snd_gus_card * gus, unsigned char reg, +void snd_gf1_i_write_addr(snd_gus_card_t * gus, unsigned char reg, unsigned int addr, short w_16bit) { unsigned long flags; @@ -270,7 +270,7 @@ void snd_gf1_i_write_addr(struct snd_gus_card * gus, unsigned char reg, #endif /* 0 */ #ifdef CONFIG_SND_DEBUG -static unsigned int snd_gf1_i_read_addr(struct snd_gus_card * gus, +static unsigned int snd_gf1_i_read_addr(snd_gus_card_t * gus, unsigned char reg, short w_16bit) { unsigned int res; @@ -287,7 +287,7 @@ static unsigned int snd_gf1_i_read_addr(struct snd_gus_card * gus, */ -void snd_gf1_dram_addr(struct snd_gus_card * gus, unsigned int addr) +void snd_gf1_dram_addr(snd_gus_card_t * gus, unsigned int addr) { outb(0x43, gus->gf1.reg_regsel); mb(); @@ -299,7 +299,7 @@ void snd_gf1_dram_addr(struct snd_gus_card * gus, unsigned int addr) mb(); } -void snd_gf1_poke(struct snd_gus_card * gus, unsigned int addr, unsigned char data) +void snd_gf1_poke(snd_gus_card_t * gus, unsigned int addr, unsigned char data) { unsigned long flags; @@ -316,7 +316,7 @@ void snd_gf1_poke(struct snd_gus_card * gus, unsigned int addr, unsigned char da spin_unlock_irqrestore(&gus->reg_lock, flags); } -unsigned char snd_gf1_peek(struct snd_gus_card * gus, unsigned int addr) +unsigned char snd_gf1_peek(snd_gus_card_t * gus, unsigned int addr) { unsigned long flags; unsigned char res; @@ -337,7 +337,7 @@ unsigned char snd_gf1_peek(struct snd_gus_card * gus, unsigned int addr) #if 0 -void snd_gf1_pokew(struct snd_gus_card * gus, unsigned int addr, unsigned short data) +void snd_gf1_pokew(snd_gus_card_t * gus, unsigned int addr, unsigned short data) { unsigned long flags; @@ -360,7 +360,7 @@ void snd_gf1_pokew(struct snd_gus_card * gus, unsigned int addr, unsigned short spin_unlock_irqrestore(&gus->reg_lock, flags); } -unsigned short snd_gf1_peekw(struct snd_gus_card * gus, unsigned int addr) +unsigned short snd_gf1_peekw(snd_gus_card_t * gus, unsigned int addr) { unsigned long flags; unsigned short res; @@ -385,7 +385,7 @@ unsigned short snd_gf1_peekw(struct snd_gus_card * gus, unsigned int addr) return res; } -void snd_gf1_dram_setmem(struct snd_gus_card * gus, unsigned int addr, +void snd_gf1_dram_setmem(snd_gus_card_t * gus, unsigned int addr, unsigned short value, unsigned int count) { unsigned long port; @@ -415,7 +415,7 @@ void snd_gf1_dram_setmem(struct snd_gus_card * gus, unsigned int addr, #endif /* 0 */ -void snd_gf1_select_active_voices(struct snd_gus_card * gus) +void snd_gf1_select_active_voices(snd_gus_card_t * gus) { unsigned short voices; @@ -443,7 +443,7 @@ void snd_gf1_select_active_voices(struct snd_gus_card * gus) #ifdef CONFIG_SND_DEBUG -void snd_gf1_print_voice_registers(struct snd_gus_card * gus) +void snd_gf1_print_voice_registers(snd_gus_card_t * gus) { unsigned char mode; int voice, ctrl; @@ -477,7 +477,7 @@ void snd_gf1_print_voice_registers(struct snd_gus_card * gus) #if 0 -void snd_gf1_print_global_registers(struct snd_gus_card * gus) +void snd_gf1_print_global_registers(snd_gus_card_t * gus) { unsigned char global_mode = 0x00; @@ -504,7 +504,7 @@ void snd_gf1_print_global_registers(struct snd_gus_card * gus) } } -void snd_gf1_print_setup_registers(struct snd_gus_card * gus) +void snd_gf1_print_setup_registers(snd_gus_card_t * gus) { printk(KERN_INFO " -S- mix control = 0x%x\n", inb(GUSP(gus, MIXCNTRLREG))); printk(KERN_INFO " -S- IRQ status = 0x%x\n", inb(GUSP(gus, IRQSTAT))); @@ -523,7 +523,7 @@ void snd_gf1_print_setup_registers(struct snd_gus_card * gus) } } -void snd_gf1_peek_print_block(struct snd_gus_card * gus, unsigned int addr, int count, int w_16bit) +void snd_gf1_peek_print_block(snd_gus_card_t * gus, unsigned int addr, int count, int w_16bit) { if (!w_16bit) { while (count-- > 0) diff --git a/trunk/sound/isa/gus/gus_irq.c b/trunk/sound/isa/gus/gus_irq.c index c19ba2910b72..1e2a15eb8106 100644 --- a/trunk/sound/isa/gus/gus_irq.c +++ b/trunk/sound/isa/gus/gus_irq.c @@ -32,7 +32,7 @@ irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_gus_card * gus = dev_id; + snd_gus_card_t * gus = dev_id; unsigned char status; int loop = 100; int handled = 0; @@ -54,7 +54,7 @@ irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs) if (status & (0x20 | 0x40)) { unsigned int already, _current_; unsigned char voice_status, voice; - struct snd_gus_voice *pvoice; + snd_gus_voice_t *pvoice; already = 0; while (((voice_status = snd_gf1_i_read8(gus, SNDRV_GF1_GB_VOICES_IRQ)) & 0xc0) != 0xc0) { @@ -107,11 +107,11 @@ irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs) } #ifdef CONFIG_SND_DEBUG -static void snd_gus_irq_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_gus_irq_info_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_gus_card *gus; - struct snd_gus_voice *pvoice; + snd_gus_card_t *gus; + snd_gus_voice_t *pvoice; int idx; gus = entry->private_data; @@ -131,9 +131,9 @@ static void snd_gus_irq_info_read(struct snd_info_entry *entry, } } -void snd_gus_irq_profile_init(struct snd_gus_card *gus) +void snd_gus_irq_profile_init(snd_gus_card_t *gus) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(gus->card, "gusirq", &entry)) snd_info_set_text_ops(entry, gus, 1024, snd_gus_irq_info_read); diff --git a/trunk/sound/isa/gus/gus_main.c b/trunk/sound/isa/gus/gus_main.c index 6d15b3d18a87..4f57ff4ab351 100644 --- a/trunk/sound/isa/gus/gus_main.c +++ b/trunk/sound/isa/gus/gus_main.c @@ -35,21 +35,21 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("Routines for Gravis UltraSound soundcards"); MODULE_LICENSE("GPL"); -static int snd_gus_init_dma_irq(struct snd_gus_card * gus, int latches); +static int snd_gus_init_dma_irq(snd_gus_card_t * gus, int latches); -int snd_gus_use_inc(struct snd_gus_card * gus) +int snd_gus_use_inc(snd_gus_card_t * gus) { if (!try_module_get(gus->card->module)) return 0; return 1; } -void snd_gus_use_dec(struct snd_gus_card * gus) +void snd_gus_use_dec(snd_gus_card_t * gus) { module_put(gus->card->module); } -static int snd_gus_joystick_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_gus_joystick_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -58,17 +58,17 @@ static int snd_gus_joystick_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_gus_joystick_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_gus_joystick_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = gus->joystick_dac & 31; return 0; } -static int snd_gus_joystick_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_gus_joystick_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned char nval; @@ -82,7 +82,7 @@ static int snd_gus_joystick_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el return change; } -static struct snd_kcontrol_new snd_gus_joystick_control = { +static snd_kcontrol_new_t snd_gus_joystick_control = { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = "Joystick Speed", .info = snd_gus_joystick_info, @@ -90,7 +90,7 @@ static struct snd_kcontrol_new snd_gus_joystick_control = { .put = snd_gus_joystick_put }; -static void snd_gus_init_control(struct snd_gus_card *gus) +static void snd_gus_init_control(snd_gus_card_t *gus) { if (!gus->ace_flag) snd_ctl_add(gus->card, snd_ctl_new1(&snd_gus_joystick_control, gus)); @@ -100,7 +100,7 @@ static void snd_gus_init_control(struct snd_gus_card *gus) * */ -static int snd_gus_free(struct snd_gus_card *gus) +static int snd_gus_free(snd_gus_card_t *gus) { if (gus->gf1.res_port2 == NULL) goto __hw_end; @@ -129,24 +129,24 @@ static int snd_gus_free(struct snd_gus_card *gus) return 0; } -static int snd_gus_dev_free(struct snd_device *device) +static int snd_gus_dev_free(snd_device_t *device) { - struct snd_gus_card *gus = device->device_data; + snd_gus_card_t *gus = device->device_data; return snd_gus_free(gus); } -int snd_gus_create(struct snd_card *card, +int snd_gus_create(snd_card_t * card, unsigned long port, int irq, int dma1, int dma2, int timer_dev, int voices, int pcm_channels, int effect, - struct snd_gus_card **rgus) + snd_gus_card_t **rgus) { - struct snd_gus_card *gus; + snd_gus_card_t *gus; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_gus_dev_free, }; @@ -238,7 +238,7 @@ int snd_gus_create(struct snd_card *card, * Memory detection routine for plain GF1 soundcards */ -static int snd_gus_detect_memory(struct snd_gus_card * gus) +static int snd_gus_detect_memory(snd_gus_card_t * gus) { int l, idx, local; unsigned char d; @@ -273,9 +273,9 @@ static int snd_gus_detect_memory(struct snd_gus_card * gus) return 0; /* some memory were detected */ } -static int snd_gus_init_dma_irq(struct snd_gus_card * gus, int latches) +static int snd_gus_init_dma_irq(snd_gus_card_t * gus, int latches) { - struct snd_card *card; + snd_card_t *card; unsigned long flags; int irq, dma1, dma2; static unsigned char irqs[16] = @@ -360,11 +360,11 @@ static int snd_gus_init_dma_irq(struct snd_gus_card * gus, int latches) return 0; } -static int snd_gus_check_version(struct snd_gus_card * gus) +static int snd_gus_check_version(snd_gus_card_t * gus) { unsigned long flags; unsigned char val, rev; - struct snd_card *card; + snd_card_t *card; card = gus->card; spin_lock_irqsave(&gus->reg_lock, flags); @@ -409,14 +409,14 @@ static int snd_gus_check_version(struct snd_gus_card * gus) } #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) -static void snd_gus_seq_dev_free(struct snd_seq_device *seq_dev) +static void snd_gus_seq_dev_free(snd_seq_device_t *seq_dev) { - struct snd_gus_card *gus = seq_dev->private_data; + snd_gus_card_t *gus = seq_dev->private_data; gus->seq_dev = NULL; } #endif -int snd_gus_initialize(struct snd_gus_card *gus) +int snd_gus_initialize(snd_gus_card_t *gus) { int err; @@ -432,9 +432,9 @@ int snd_gus_initialize(struct snd_gus_card *gus) return err; #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) if (snd_seq_device_new(gus->card, 1, SNDRV_SEQ_DEV_ID_GUS, - sizeof(struct snd_gus_card *), &gus->seq_dev) >= 0) { + sizeof(snd_gus_card_t*), &gus->seq_dev) >= 0) { strcpy(gus->seq_dev->name, "GUS"); - *(struct snd_gus_card **)SNDRV_SEQ_DEVICE_ARGPTR(gus->seq_dev) = gus; + *(snd_gus_card_t**)SNDRV_SEQ_DEVICE_ARGPTR(gus->seq_dev) = gus; gus->seq_dev->private_data = gus; gus->seq_dev->private_free = snd_gus_seq_dev_free; } diff --git a/trunk/sound/isa/gus/gus_mem.c b/trunk/sound/isa/gus/gus_mem.c index e8bdb860a19f..2e23f2a8c627 100644 --- a/trunk/sound/isa/gus/gus_mem.c +++ b/trunk/sound/isa/gus/gus_mem.c @@ -27,11 +27,11 @@ #include <sound/info.h> #ifdef CONFIG_SND_DEBUG -static void snd_gf1_mem_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer); +static void snd_gf1_mem_info_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer); #endif -void snd_gf1_mem_lock(struct snd_gf1_mem * alloc, int xup) +void snd_gf1_mem_lock(snd_gf1_mem_t * alloc, int xup) { if (!xup) { down(&alloc->memory_mutex); @@ -40,12 +40,12 @@ void snd_gf1_mem_lock(struct snd_gf1_mem * alloc, int xup) } } -static struct snd_gf1_mem_block *snd_gf1_mem_xalloc(struct snd_gf1_mem * alloc, - struct snd_gf1_mem_block * block) +static snd_gf1_mem_block_t *snd_gf1_mem_xalloc(snd_gf1_mem_t * alloc, + snd_gf1_mem_block_t * block) { - struct snd_gf1_mem_block *pblock, *nblock; + snd_gf1_mem_block_t *pblock, *nblock; - nblock = kmalloc(sizeof(struct snd_gf1_mem_block), GFP_KERNEL); + nblock = (snd_gf1_mem_block_t *) kmalloc(sizeof(snd_gf1_mem_block_t), GFP_KERNEL); if (nblock == NULL) return NULL; *nblock = *block; @@ -76,7 +76,7 @@ static struct snd_gf1_mem_block *snd_gf1_mem_xalloc(struct snd_gf1_mem * alloc, return nblock; } -int snd_gf1_mem_xfree(struct snd_gf1_mem * alloc, struct snd_gf1_mem_block * block) +int snd_gf1_mem_xfree(snd_gf1_mem_t * alloc, snd_gf1_mem_block_t * block) { if (block->share) { /* ok.. shared block */ block->share--; @@ -106,10 +106,10 @@ int snd_gf1_mem_xfree(struct snd_gf1_mem * alloc, struct snd_gf1_mem_block * blo return 0; } -static struct snd_gf1_mem_block *snd_gf1_mem_look(struct snd_gf1_mem * alloc, +static snd_gf1_mem_block_t *snd_gf1_mem_look(snd_gf1_mem_t * alloc, unsigned int address) { - struct snd_gf1_mem_block *block; + snd_gf1_mem_block_t *block; for (block = alloc->first; block; block = block->next) { if (block->ptr == address) { @@ -119,10 +119,10 @@ static struct snd_gf1_mem_block *snd_gf1_mem_look(struct snd_gf1_mem * alloc, return NULL; } -static struct snd_gf1_mem_block *snd_gf1_mem_share(struct snd_gf1_mem * alloc, +static snd_gf1_mem_block_t *snd_gf1_mem_share(snd_gf1_mem_t * alloc, unsigned int *share_id) { - struct snd_gf1_mem_block *block; + snd_gf1_mem_block_t *block; if (!share_id[0] && !share_id[1] && !share_id[2] && !share_id[3]) @@ -133,14 +133,14 @@ static struct snd_gf1_mem_block *snd_gf1_mem_share(struct snd_gf1_mem * alloc, return NULL; } -static int snd_gf1_mem_find(struct snd_gf1_mem * alloc, - struct snd_gf1_mem_block * block, +static int snd_gf1_mem_find(snd_gf1_mem_t * alloc, + snd_gf1_mem_block_t * block, unsigned int size, int w_16, int align) { - struct snd_gf1_bank_info *info = w_16 ? alloc->banks_16 : alloc->banks_8; + snd_gf1_bank_info_t *info = w_16 ? alloc->banks_16 : alloc->banks_8; unsigned int idx, boundary; int size1; - struct snd_gf1_mem_block *pblock; + snd_gf1_mem_block_t *pblock; unsigned int ptr1, ptr2; align--; @@ -186,11 +186,11 @@ static int snd_gf1_mem_find(struct snd_gf1_mem * alloc, return -ENOMEM; } -struct snd_gf1_mem_block *snd_gf1_mem_alloc(struct snd_gf1_mem * alloc, int owner, +snd_gf1_mem_block_t *snd_gf1_mem_alloc(snd_gf1_mem_t * alloc, int owner, char *name, int size, int w_16, int align, unsigned int *share_id) { - struct snd_gf1_mem_block block, *nblock; + snd_gf1_mem_block_t block, *nblock; snd_gf1_mem_lock(alloc, 0); if (share_id != NULL) { @@ -220,10 +220,10 @@ struct snd_gf1_mem_block *snd_gf1_mem_alloc(struct snd_gf1_mem * alloc, int owne return nblock; } -int snd_gf1_mem_free(struct snd_gf1_mem * alloc, unsigned int address) +int snd_gf1_mem_free(snd_gf1_mem_t * alloc, unsigned int address) { int result; - struct snd_gf1_mem_block *block; + snd_gf1_mem_block_t *block; snd_gf1_mem_lock(alloc, 0); if ((block = snd_gf1_mem_look(alloc, address)) != NULL) { @@ -235,12 +235,12 @@ int snd_gf1_mem_free(struct snd_gf1_mem * alloc, unsigned int address) return -EINVAL; } -int snd_gf1_mem_init(struct snd_gus_card * gus) +int snd_gf1_mem_init(snd_gus_card_t * gus) { - struct snd_gf1_mem *alloc; - struct snd_gf1_mem_block block; + snd_gf1_mem_t *alloc; + snd_gf1_mem_block_t block; #ifdef CONFIG_SND_DEBUG - struct snd_info_entry *entry; + snd_info_entry_t *entry; #endif alloc = &gus->gf1.mem_alloc; @@ -272,10 +272,10 @@ int snd_gf1_mem_init(struct snd_gus_card * gus) return 0; } -int snd_gf1_mem_done(struct snd_gus_card * gus) +int snd_gf1_mem_done(snd_gus_card_t * gus) { - struct snd_gf1_mem *alloc; - struct snd_gf1_mem_block *block, *nblock; + snd_gf1_mem_t *alloc; + snd_gf1_mem_block_t *block, *nblock; alloc = &gus->gf1.mem_alloc; block = alloc->first; @@ -288,12 +288,12 @@ int snd_gf1_mem_done(struct snd_gus_card * gus) } #ifdef CONFIG_SND_DEBUG -static void snd_gf1_mem_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_gf1_mem_info_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_gus_card *gus; - struct snd_gf1_mem *alloc; - struct snd_gf1_mem_block *block; + snd_gus_card_t *gus; + snd_gf1_mem_t *alloc; + snd_gf1_mem_block_t *block; unsigned int total, used; int i; diff --git a/trunk/sound/isa/gus/gus_mem_proc.c b/trunk/sound/isa/gus/gus_mem_proc.c index 4080255007d5..7f96ac237f3c 100644 --- a/trunk/sound/isa/gus/gus_mem_proc.c +++ b/trunk/sound/isa/gus/gus_mem_proc.c @@ -25,20 +25,20 @@ #include <sound/gus.h> #include <sound/info.h> -struct gus_proc_private { +typedef struct gus_proc_private { int rom; /* data are in ROM */ unsigned int address; unsigned int size; - struct snd_gus_card * gus; -}; + snd_gus_card_t * gus; +} gus_proc_private_t; -static long snd_gf1_mem_proc_dump(struct snd_info_entry *entry, void *file_private_data, +static long snd_gf1_mem_proc_dump(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *buf, unsigned long count, unsigned long pos) { long size; - struct gus_proc_private *priv = entry->private_data; - struct snd_gus_card *gus = priv->gus; + gus_proc_private_t *priv = entry->private_data; + snd_gus_card_t *gus = priv->gus; int err; size = count; @@ -52,13 +52,13 @@ static long snd_gf1_mem_proc_dump(struct snd_info_entry *entry, void *file_priva return 0; } -static long long snd_gf1_mem_proc_llseek(struct snd_info_entry *entry, +static long long snd_gf1_mem_proc_llseek(snd_info_entry_t *entry, void *private_file_data, struct file *file, long long offset, int orig) { - struct gus_proc_private *priv = entry->private_data; + gus_proc_private_t *priv = entry->private_data; switch (orig) { case 0: /* SEEK_SET */ @@ -78,9 +78,9 @@ static long long snd_gf1_mem_proc_llseek(struct snd_info_entry *entry, return file->f_pos; } -static void snd_gf1_mem_proc_free(struct snd_info_entry *entry) +static void snd_gf1_mem_proc_free(snd_info_entry_t *entry) { - struct gus_proc_private *priv = entry->private_data; + gus_proc_private_t *priv = entry->private_data; kfree(priv); } @@ -89,12 +89,12 @@ static struct snd_info_entry_ops snd_gf1_mem_proc_ops = { .llseek = snd_gf1_mem_proc_llseek, }; -int snd_gf1_mem_proc_init(struct snd_gus_card * gus) +int snd_gf1_mem_proc_init(snd_gus_card_t * gus) { int idx; char name[16]; - struct gus_proc_private *priv; - struct snd_info_entry *entry; + gus_proc_private_t *priv; + snd_info_entry_t *entry; for (idx = 0; idx < 4; idx++) { if (gus->gf1.mem_alloc.banks_8[idx].size > 0) { diff --git a/trunk/sound/isa/gus/gus_mixer.c b/trunk/sound/isa/gus/gus_mixer.c index acc25a297200..a051094d510e 100644 --- a/trunk/sound/isa/gus/gus_mixer.c +++ b/trunk/sound/isa/gus/gus_mixer.c @@ -36,7 +36,7 @@ .get = snd_gf1_get_single, .put = snd_gf1_put_single, \ .private_value = shift | (invert << 8) } -static int snd_gf1_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_gf1_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -45,9 +45,9 @@ static int snd_gf1_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_gf1_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_gf1_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value >> 8) & 1; @@ -57,9 +57,9 @@ static int snd_gf1_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int snd_gf1_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_gf1_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); unsigned long flags; int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value >> 8) & 1; @@ -86,7 +86,7 @@ static int snd_gf1_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem .get = snd_ics_get_double, .put = snd_ics_put_double, \ .private_value = addr } -static int snd_ics_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ics_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -95,9 +95,9 @@ static int snd_ics_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_ics_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ics_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); unsigned long flags; int addr = kcontrol->private_value & 0xff; unsigned char left, right; @@ -111,9 +111,9 @@ static int snd_ics_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int snd_ics_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ics_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); unsigned long flags; int addr = kcontrol->private_value & 0xff; int change; @@ -146,13 +146,13 @@ static int snd_ics_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return change; } -static struct snd_kcontrol_new snd_gf1_controls[] = { +static snd_kcontrol_new_t snd_gf1_controls[] = { GF1_SINGLE("Master Playback Switch", 0, 1, 1), GF1_SINGLE("Line Switch", 0, 0, 1), GF1_SINGLE("Mic Switch", 0, 2, 0) }; -static struct snd_kcontrol_new snd_ics_controls[] = { +static snd_kcontrol_new_t snd_ics_controls[] = { GF1_SINGLE("Master Playback Switch", 0, 1, 1), ICS_DOUBLE("Master Playback Volume", 0, SNDRV_ICS_MASTER_DEV), ICS_DOUBLE("Synth Playback Volume", 0, SNDRV_ICS_GF1_DEV), @@ -163,9 +163,9 @@ ICS_DOUBLE("Mic Playback Volume", 0, SNDRV_ICS_MIC_DEV), ICS_DOUBLE("CD Playback Volume", 0, SNDRV_ICS_CD_DEV) }; -int snd_gf1_new_mixer(struct snd_gus_card * gus) +int snd_gf1_new_mixer(snd_gus_card_t * gus) { - struct snd_card *card; + snd_card_t *card; unsigned int idx, max; int err; diff --git a/trunk/sound/isa/gus/gus_pcm.c b/trunk/sound/isa/gus/gus_pcm.c index d0829393ec8a..1cc89fb67bf2 100644 --- a/trunk/sound/isa/gus/gus_pcm.c +++ b/trunk/sound/isa/gus/gus_pcm.c @@ -42,12 +42,12 @@ #define SNDRV_GF1_PCM_PFLG_ACTIVE (1<<0) #define SNDRV_GF1_PCM_PFLG_NEUTRAL (2<<0) -struct gus_pcm_private { - struct snd_gus_card * gus; - struct snd_pcm_substream *substream; +typedef struct { + snd_gus_card_t * gus; + snd_pcm_substream_t * substream; spinlock_t lock; unsigned int voices; - struct snd_gus_voice *pvoices[2]; + snd_gus_voice_t *pvoices[2]; unsigned int memory; unsigned short flags; unsigned char voice_ctrl, ramp_ctrl; @@ -58,13 +58,13 @@ struct gus_pcm_private { wait_queue_head_t sleep; atomic_t dma_count; int final_volume; -}; +} gus_pcm_private_t; static int snd_gf1_pcm_use_dma = 1; -static void snd_gf1_pcm_block_change_ack(struct snd_gus_card * gus, void *private_data) +static void snd_gf1_pcm_block_change_ack(snd_gus_card_t * gus, void *private_data) { - struct gus_pcm_private *pcmp = private_data; + gus_pcm_private_t *pcmp = private_data; if (pcmp) { atomic_dec(&pcmp->dma_count); @@ -72,14 +72,14 @@ static void snd_gf1_pcm_block_change_ack(struct snd_gus_card * gus, void *privat } } -static int snd_gf1_pcm_block_change(struct snd_pcm_substream *substream, +static int snd_gf1_pcm_block_change(snd_pcm_substream_t * substream, unsigned int offset, unsigned int addr, unsigned int count) { - struct snd_gf1_dma_block block; - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_gf1_dma_block_t block; + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; count += offset & 31; offset &= ~31; @@ -101,11 +101,11 @@ static int snd_gf1_pcm_block_change(struct snd_pcm_substream *substream, return 0; } -static void snd_gf1_pcm_trigger_up(struct snd_pcm_substream *substream) +static void snd_gf1_pcm_trigger_up(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; - struct snd_gus_card * gus = pcmp->gus; + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; + snd_gus_card_t * gus = pcmp->gus; unsigned long flags; unsigned char voice_ctrl, ramp_ctrl; unsigned short rate; @@ -179,11 +179,10 @@ static void snd_gf1_pcm_trigger_up(struct snd_pcm_substream *substream) spin_unlock_irqrestore(&gus->reg_lock, flags); } -static void snd_gf1_pcm_interrupt_wave(struct snd_gus_card * gus, - struct snd_gus_voice *pvoice) +static void snd_gf1_pcm_interrupt_wave(snd_gus_card_t * gus, snd_gus_voice_t *pvoice) { - struct gus_pcm_private * pcmp; - struct snd_pcm_runtime *runtime; + gus_pcm_private_t * pcmp; + snd_pcm_runtime_t * runtime; unsigned char voice_ctrl, ramp_ctrl; unsigned int idx; unsigned int end, step; @@ -262,12 +261,11 @@ static void snd_gf1_pcm_interrupt_wave(struct snd_gus_card * gus, #endif } -static void snd_gf1_pcm_interrupt_volume(struct snd_gus_card * gus, - struct snd_gus_voice * pvoice) +static void snd_gf1_pcm_interrupt_volume(snd_gus_card_t * gus, snd_gus_voice_t * pvoice) { unsigned short vol; int cvoice; - struct gus_pcm_private *pcmp = pvoice->private_data; + gus_pcm_private_t *pcmp = pvoice->private_data; /* stop ramp, but leave rollover bit untouched */ spin_lock(&gus->reg_lock); @@ -291,11 +289,11 @@ static void snd_gf1_pcm_interrupt_volume(struct snd_gus_card * gus, spin_unlock(&gus->reg_lock); } -static void snd_gf1_pcm_volume_change(struct snd_gus_card * gus) +static void snd_gf1_pcm_volume_change(snd_gus_card_t * gus) { } -static int snd_gf1_pcm_poke_block(struct snd_gus_card *gus, unsigned char *buf, +static int snd_gf1_pcm_poke_block(snd_gus_card_t *gus, unsigned char *buf, unsigned int pos, unsigned int count, int w16, int invert) { @@ -343,14 +341,14 @@ static int snd_gf1_pcm_poke_block(struct snd_gus_card *gus, unsigned char *buf, return 0; } -static int snd_gf1_pcm_playback_copy(struct snd_pcm_substream *substream, +static int snd_gf1_pcm_playback_copy(snd_pcm_substream_t *substream, int voice, snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; unsigned int bpos, len; bpos = samples_to_bytes(runtime, pos) + (voice * (pcmp->dma_size / 2)); @@ -362,7 +360,7 @@ static int snd_gf1_pcm_playback_copy(struct snd_pcm_substream *substream, if (snd_gf1_pcm_use_dma && len > 32) { return snd_gf1_pcm_block_change(substream, bpos, pcmp->memory + bpos, len); } else { - struct snd_gus_card *gus = pcmp->gus; + snd_gus_card_t *gus = pcmp->gus; int err, w16, invert; w16 = (snd_pcm_format_width(runtime->format) == 16); @@ -373,13 +371,13 @@ static int snd_gf1_pcm_playback_copy(struct snd_pcm_substream *substream, return 0; } -static int snd_gf1_pcm_playback_silence(struct snd_pcm_substream *substream, +static int snd_gf1_pcm_playback_silence(snd_pcm_substream_t *substream, int voice, snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; unsigned int bpos, len; bpos = samples_to_bytes(runtime, pos) + (voice * (pcmp->dma_size / 2)); @@ -390,7 +388,7 @@ static int snd_gf1_pcm_playback_silence(struct snd_pcm_substream *substream, if (snd_gf1_pcm_use_dma && len > 32) { return snd_gf1_pcm_block_change(substream, bpos, pcmp->memory + bpos, len); } else { - struct snd_gus_card *gus = pcmp->gus; + snd_gus_card_t *gus = pcmp->gus; int err, w16, invert; w16 = (snd_pcm_format_width(runtime->format) == 16); @@ -401,18 +399,18 @@ static int snd_gf1_pcm_playback_silence(struct snd_pcm_substream *substream, return 0; } -static int snd_gf1_pcm_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_gf1_pcm_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; int err; if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) return err; if (err > 0) { /* change */ - struct snd_gf1_mem_block *block; + snd_gf1_mem_block_t *block; if (pcmp->memory > 0) { snd_gf1_mem_free(&gus->gf1.mem_alloc, pcmp->memory); pcmp->memory = 0; @@ -450,10 +448,10 @@ static int snd_gf1_pcm_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_gf1_pcm_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_playback_hw_free(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; snd_pcm_lib_free_pages(substream); if (pcmp->pvoices[0]) { @@ -471,10 +469,10 @@ static int snd_gf1_pcm_playback_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_gf1_pcm_playback_prepare(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; pcmp->bpos = 0; pcmp->dma_size = snd_pcm_lib_buffer_bytes(substream); @@ -483,12 +481,12 @@ static int snd_gf1_pcm_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_gf1_pcm_playback_trigger(struct snd_pcm_substream *substream, +static int snd_gf1_pcm_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; int voice; if (cmd == SNDRV_PCM_TRIGGER_START) { @@ -509,11 +507,11 @@ static int snd_gf1_pcm_playback_trigger(struct snd_pcm_substream *substream, return 0; } -static snd_pcm_uframes_t snd_gf1_pcm_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_gf1_pcm_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; unsigned int pos; unsigned char voice_ctrl; @@ -531,22 +529,22 @@ static snd_pcm_uframes_t snd_gf1_pcm_playback_pointer(struct snd_pcm_substream * return pos; } -static struct snd_ratnum clock = { +static ratnum_t clock = { .num = 9878400/16, .den_min = 2, .den_max = 257, .den_step = 1, }; -static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = { +static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = { .nrats = 1, .rats = &clock, }; -static int snd_gf1_pcm_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_gf1_pcm_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); gus->c_dma_size = params_buffer_bytes(hw_params); gus->c_period_size = params_period_bytes(hw_params); @@ -561,15 +559,15 @@ static int snd_gf1_pcm_capture_hw_params(struct snd_pcm_substream *substream, return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_gf1_pcm_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_capture_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_gf1_pcm_capture_prepare(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_gf1_i_write8(gus, SNDRV_GF1_GB_RECORD_RATE, runtime->rate_den - 2); snd_gf1_i_write8(gus, SNDRV_GF1_GB_REC_DMA_CONTROL, 0); /* disable sampling */ @@ -578,10 +576,10 @@ static int snd_gf1_pcm_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_gf1_pcm_capture_trigger(struct snd_pcm_substream *substream, +static int snd_gf1_pcm_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); int val; if (cmd == SNDRV_PCM_TRIGGER_START) { @@ -599,15 +597,15 @@ static int snd_gf1_pcm_capture_trigger(struct snd_pcm_substream *substream, return 0; } -static snd_pcm_uframes_t snd_gf1_pcm_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_gf1_pcm_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); int pos = snd_dma_pointer(gus->gf1.dma2, gus->c_period_size); pos = bytes_to_frames(substream->runtime, (gus->c_pos + pos) % gus->c_dma_size); return pos; } -static void snd_gf1_pcm_interrupt_dma_read(struct snd_gus_card * gus) +static void snd_gf1_pcm_interrupt_dma_read(snd_gus_card_t * gus) { snd_gf1_i_write8(gus, SNDRV_GF1_GB_REC_DMA_CONTROL, 0); /* disable sampling */ snd_gf1_i_look8(gus, SNDRV_GF1_GB_REC_DMA_CONTROL); /* Sampling Control Register */ @@ -619,7 +617,7 @@ static void snd_gf1_pcm_interrupt_dma_read(struct snd_gus_card * gus) } } -static struct snd_pcm_hardware snd_gf1_pcm_playback = +static snd_pcm_hardware_t snd_gf1_pcm_playback = { .info = SNDRV_PCM_INFO_NONINTERLEAVED, .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 | @@ -637,7 +635,7 @@ static struct snd_pcm_hardware snd_gf1_pcm_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_gf1_pcm_capture = +static snd_pcm_hardware_t snd_gf1_pcm_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -655,16 +653,16 @@ static struct snd_pcm_hardware snd_gf1_pcm_capture = .fifo_size = 0, }; -static void snd_gf1_pcm_playback_free(struct snd_pcm_runtime *runtime) +static void snd_gf1_pcm_playback_free(snd_pcm_runtime_t *runtime) { kfree(runtime->private_data); } -static int snd_gf1_pcm_playback_open(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_playback_open(snd_pcm_substream_t *substream) { - struct gus_pcm_private *pcmp; - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + gus_pcm_private_t *pcmp; + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; pcmp = kzalloc(sizeof(*pcmp), GFP_KERNEL); @@ -692,11 +690,11 @@ static int snd_gf1_pcm_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_gf1_pcm_playback_close(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_playback_close(snd_pcm_substream_t * substream) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct gus_pcm_private *pcmp = runtime->private_data; + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + gus_pcm_private_t *pcmp = runtime->private_data; if (!wait_event_timeout(pcmp->sleep, (atomic_read(&pcmp->dma_count) <= 0), 2*HZ)) snd_printk(KERN_ERR "gf1 pcm - serious DMA problem\n"); @@ -705,10 +703,10 @@ static int snd_gf1_pcm_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_gf1_pcm_capture_open(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_capture_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); gus->gf1.interrupt_handler_dma_read = snd_gf1_pcm_interrupt_dma_read; gus->pcm_cap_substream = substream; @@ -720,16 +718,23 @@ static int snd_gf1_pcm_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_gf1_pcm_capture_close(struct snd_pcm_substream *substream) +static int snd_gf1_pcm_capture_close(snd_pcm_substream_t * substream) { - struct snd_gus_card *gus = snd_pcm_substream_chip(substream); + snd_gus_card_t *gus = snd_pcm_substream_chip(substream); gus->pcm_cap_substream = NULL; snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_DMA_READ); return 0; } -static int snd_gf1_pcm_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static void snd_gf1_pcm_free(snd_pcm_t *pcm) +{ + snd_gus_card_t *gus = pcm->private_data; + gus->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int snd_gf1_pcm_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -738,9 +743,9 @@ static int snd_gf1_pcm_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_gf1_pcm_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_gf1_pcm_volume_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&gus->pcm_volume_level_lock, flags); @@ -750,15 +755,15 @@ static int snd_gf1_pcm_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_gf1_pcm_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_gf1_pcm_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_gus_card *gus = snd_kcontrol_chip(kcontrol); + snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned int idx; unsigned short val1, val2, vol; - struct gus_pcm_private *pcmp; - struct snd_gus_voice *pvoice; + gus_pcm_private_t *pcmp; + snd_gus_voice_t *pvoice; val1 = ucontrol->value.integer.value[0] & 127; val2 = ucontrol->value.integer.value[1] & 127; @@ -792,7 +797,7 @@ static int snd_gf1_pcm_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ return change; } -static struct snd_kcontrol_new snd_gf1_pcm_volume_control = +static snd_kcontrol_new_t snd_gf1_pcm_volume_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Volume", @@ -801,7 +806,7 @@ static struct snd_kcontrol_new snd_gf1_pcm_volume_control = .put = snd_gf1_pcm_volume_put }; -static struct snd_kcontrol_new snd_gf1_pcm_volume_control1 = +static snd_kcontrol_new_t snd_gf1_pcm_volume_control1 = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "GPCM Playback Volume", @@ -810,7 +815,7 @@ static struct snd_kcontrol_new snd_gf1_pcm_volume_control1 = .put = snd_gf1_pcm_volume_put }; -static struct snd_pcm_ops snd_gf1_pcm_playback_ops = { +static snd_pcm_ops_t snd_gf1_pcm_playback_ops = { .open = snd_gf1_pcm_playback_open, .close = snd_gf1_pcm_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -823,7 +828,7 @@ static struct snd_pcm_ops snd_gf1_pcm_playback_ops = { .silence = snd_gf1_pcm_playback_silence, }; -static struct snd_pcm_ops snd_gf1_pcm_capture_ops = { +static snd_pcm_ops_t snd_gf1_pcm_capture_ops = { .open = snd_gf1_pcm_capture_open, .close = snd_gf1_pcm_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -834,12 +839,12 @@ static struct snd_pcm_ops snd_gf1_pcm_capture_ops = { .pointer = snd_gf1_pcm_capture_pointer, }; -int snd_gf1_pcm_new(struct snd_gus_card * gus, int pcm_dev, int control_index, struct snd_pcm ** rpcm) +int snd_gf1_pcm_new(snd_gus_card_t * gus, int pcm_dev, int control_index, snd_pcm_t ** rpcm) { - struct snd_card *card; - struct snd_kcontrol *kctl; - struct snd_pcm *pcm; - struct snd_pcm_substream *substream; + snd_card_t *card; + snd_kcontrol_t *kctl; + snd_pcm_t *pcm; + snd_pcm_substream_t *substream; int capture, err; if (rpcm) @@ -855,6 +860,7 @@ int snd_gf1_pcm_new(struct snd_gus_card * gus, int pcm_dev, int control_index, s if (err < 0) return err; pcm->private_data = gus; + pcm->private_free = snd_gf1_pcm_free; /* playback setup */ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_gf1_pcm_playback_ops); diff --git a/trunk/sound/isa/gus/gus_reset.c b/trunk/sound/isa/gus/gus_reset.c index b263655c4116..90710969ef7f 100644 --- a/trunk/sound/isa/gus/gus_reset.c +++ b/trunk/sound/isa/gus/gus_reset.c @@ -25,52 +25,52 @@ #include <sound/core.h> #include <sound/gus.h> -extern void snd_gf1_timers_init(struct snd_gus_card * gus); -extern void snd_gf1_timers_done(struct snd_gus_card * gus); -extern int snd_gf1_synth_init(struct snd_gus_card * gus); -extern void snd_gf1_synth_done(struct snd_gus_card * gus); +extern void snd_gf1_timers_init(snd_gus_card_t * gus); +extern void snd_gf1_timers_done(snd_gus_card_t * gus); +extern int snd_gf1_synth_init(snd_gus_card_t * gus); +extern void snd_gf1_synth_done(snd_gus_card_t * gus); /* * ok.. default interrupt handlers... */ -static void snd_gf1_default_interrupt_handler_midi_out(struct snd_gus_card * gus) +static void snd_gf1_default_interrupt_handler_midi_out(snd_gus_card_t * gus) { snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd &= ~0x20); } -static void snd_gf1_default_interrupt_handler_midi_in(struct snd_gus_card * gus) +static void snd_gf1_default_interrupt_handler_midi_in(snd_gus_card_t * gus) { snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd &= ~0x80); } -static void snd_gf1_default_interrupt_handler_timer1(struct snd_gus_card * gus) +static void snd_gf1_default_interrupt_handler_timer1(snd_gus_card_t * gus) { snd_gf1_i_write8(gus, SNDRV_GF1_GB_SOUND_BLASTER_CONTROL, gus->gf1.timer_enabled &= ~4); } -static void snd_gf1_default_interrupt_handler_timer2(struct snd_gus_card * gus) +static void snd_gf1_default_interrupt_handler_timer2(snd_gus_card_t * gus) { snd_gf1_i_write8(gus, SNDRV_GF1_GB_SOUND_BLASTER_CONTROL, gus->gf1.timer_enabled &= ~8); } -static void snd_gf1_default_interrupt_handler_wave_and_volume(struct snd_gus_card * gus, struct snd_gus_voice * voice) +static void snd_gf1_default_interrupt_handler_wave_and_volume(snd_gus_card_t * gus, snd_gus_voice_t * voice) { snd_gf1_i_ctrl_stop(gus, 0x00); snd_gf1_i_ctrl_stop(gus, 0x0d); } -static void snd_gf1_default_interrupt_handler_dma_write(struct snd_gus_card * gus) +static void snd_gf1_default_interrupt_handler_dma_write(snd_gus_card_t * gus) { snd_gf1_i_write8(gus, 0x41, 0x00); } -static void snd_gf1_default_interrupt_handler_dma_read(struct snd_gus_card * gus) +static void snd_gf1_default_interrupt_handler_dma_read(snd_gus_card_t * gus) { snd_gf1_i_write8(gus, 0x49, 0x00); } -void snd_gf1_set_default_handlers(struct snd_gus_card * gus, unsigned int what) +void snd_gf1_set_default_handlers(snd_gus_card_t * gus, unsigned int what) { if (what & SNDRV_GF1_HANDLER_MIDI_OUT) gus->gf1.interrupt_handler_midi_out = snd_gf1_default_interrupt_handler_midi_out; @@ -81,7 +81,7 @@ void snd_gf1_set_default_handlers(struct snd_gus_card * gus, unsigned int what) if (what & SNDRV_GF1_HANDLER_TIMER2) gus->gf1.interrupt_handler_timer2 = snd_gf1_default_interrupt_handler_timer2; if (what & SNDRV_GF1_HANDLER_VOICE) { - struct snd_gus_voice *voice; + snd_gus_voice_t *voice; voice = &gus->gf1.voices[what & 0xffff]; voice->handler_wave = @@ -99,7 +99,7 @@ void snd_gf1_set_default_handlers(struct snd_gus_card * gus, unsigned int what) */ -static void snd_gf1_clear_regs(struct snd_gus_card * gus) +static void snd_gf1_clear_regs(snd_gus_card_t * gus) { unsigned long flags; @@ -111,7 +111,7 @@ static void snd_gf1_clear_regs(struct snd_gus_card * gus) spin_unlock_irqrestore(&gus->reg_lock, flags); } -static void snd_gf1_look_regs(struct snd_gus_card * gus) +static void snd_gf1_look_regs(snd_gus_card_t * gus) { unsigned long flags; @@ -127,7 +127,7 @@ static void snd_gf1_look_regs(struct snd_gus_card * gus) * put selected GF1 voices to initial stage... */ -void snd_gf1_smart_stop_voice(struct snd_gus_card * gus, unsigned short voice) +void snd_gf1_smart_stop_voice(snd_gus_card_t * gus, unsigned short voice) { unsigned long flags; @@ -141,7 +141,7 @@ void snd_gf1_smart_stop_voice(struct snd_gus_card * gus, unsigned short voice) spin_unlock_irqrestore(&gus->reg_lock, flags); } -void snd_gf1_stop_voice(struct snd_gus_card * gus, unsigned short voice) +void snd_gf1_stop_voice(snd_gus_card_t * gus, unsigned short voice) { unsigned long flags; @@ -161,7 +161,7 @@ void snd_gf1_stop_voice(struct snd_gus_card * gus, unsigned short voice) #endif } -static void snd_gf1_clear_voices(struct snd_gus_card * gus, unsigned short v_min, +static void snd_gf1_clear_voices(snd_gus_card_t * gus, unsigned short v_min, unsigned short v_max) { unsigned long flags; @@ -203,7 +203,7 @@ static void snd_gf1_clear_voices(struct snd_gus_card * gus, unsigned short v_min } } -void snd_gf1_stop_voices(struct snd_gus_card * gus, unsigned short v_min, unsigned short v_max) +void snd_gf1_stop_voices(snd_gus_card_t * gus, unsigned short v_min, unsigned short v_max) { unsigned long flags; short i, ramp_ok; @@ -232,8 +232,8 @@ void snd_gf1_stop_voices(struct snd_gus_card * gus, unsigned short v_min, unsign snd_gf1_clear_voices(gus, v_min, v_max); } -static void snd_gf1_alloc_voice_use(struct snd_gus_card * gus, - struct snd_gus_voice * pvoice, +static void snd_gf1_alloc_voice_use(snd_gus_card_t * gus, + snd_gus_voice_t * pvoice, int type, int client, int port) { pvoice->use = 1; @@ -255,9 +255,9 @@ static void snd_gf1_alloc_voice_use(struct snd_gus_card * gus, } } -struct snd_gus_voice *snd_gf1_alloc_voice(struct snd_gus_card * gus, int type, int client, int port) +snd_gus_voice_t *snd_gf1_alloc_voice(snd_gus_card_t * gus, int type, int client, int port) { - struct snd_gus_voice *pvoice; + snd_gus_voice_t *pvoice; unsigned long flags; int idx; @@ -289,10 +289,10 @@ struct snd_gus_voice *snd_gf1_alloc_voice(struct snd_gus_card * gus, int type, i return NULL; } -void snd_gf1_free_voice(struct snd_gus_card * gus, struct snd_gus_voice *voice) +void snd_gf1_free_voice(snd_gus_card_t * gus, snd_gus_voice_t *voice) { unsigned long flags; - void (*private_free)(struct snd_gus_voice *voice); + void (*private_free)(snd_gus_voice_t *voice); void *private_data; if (voice == NULL || !voice->use) @@ -317,7 +317,7 @@ void snd_gf1_free_voice(struct snd_gus_card * gus, struct snd_gus_voice *voice) * call this function only by start of driver */ -int snd_gf1_start(struct snd_gus_card * gus) +int snd_gf1_start(snd_gus_card_t * gus) { unsigned long flags; unsigned int i; @@ -400,7 +400,7 @@ int snd_gf1_start(struct snd_gus_card * gus) * call this function only by shutdown of driver */ -int snd_gf1_stop(struct snd_gus_card * gus) +int snd_gf1_stop(snd_gus_card_t * gus) { snd_gf1_i_write8(gus, SNDRV_GF1_GB_SOUND_BLASTER_CONTROL, 0); /* stop all timers */ snd_gf1_stop_voices(gus, 0, 31); /* stop all voices */ diff --git a/trunk/sound/isa/gus/gus_sample.c b/trunk/sound/isa/gus/gus_sample.c index 9e0c55ab25b2..4290e03acd51 100644 --- a/trunk/sound/isa/gus/gus_sample.c +++ b/trunk/sound/isa/gus/gus_sample.c @@ -28,9 +28,9 @@ * */ -static void select_instrument(struct snd_gus_card * gus, struct snd_gus_voice * v) +static void select_instrument(snd_gus_card_t * gus, snd_gus_voice_t * v) { - struct snd_seq_kinstr *instr; + snd_seq_kinstr_t *instr; #if 0 printk("select instrument: cluster = %li, std = 0x%x, bank = %i, prg = %i\n", @@ -53,8 +53,7 @@ static void select_instrument(struct snd_gus_card * gus, struct snd_gus_voice * * */ -static void event_sample(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_sample(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_stop) v->sample_ops->sample_stop(p->gus, v, SAMPLE_STOP_IMMEDIATELY); @@ -68,8 +67,7 @@ static void event_sample(struct snd_seq_event *ev, struct snd_gus_port *p, select_instrument(p->gus, v); } -static void event_cluster(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_cluster(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_stop) v->sample_ops->sample_stop(p->gus, v, SAMPLE_STOP_IMMEDIATELY); @@ -77,58 +75,50 @@ static void event_cluster(struct snd_seq_event *ev, struct snd_gus_port *p, select_instrument(p->gus, v); } -static void event_start(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_start(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_start) v->sample_ops->sample_start(p->gus, v, ev->data.sample.param.position); } -static void event_stop(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_stop(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_stop) v->sample_ops->sample_stop(p->gus, v, ev->data.sample.param.stop_mode); } -static void event_freq(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_freq(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_freq) v->sample_ops->sample_freq(p->gus, v, ev->data.sample.param.frequency); } -static void event_volume(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_volume(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_volume) v->sample_ops->sample_volume(p->gus, v, &ev->data.sample.param.volume); } -static void event_loop(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_loop(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_loop) v->sample_ops->sample_loop(p->gus, v, &ev->data.sample.param.loop); } -static void event_position(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_position(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_pos) v->sample_ops->sample_pos(p->gus, v, ev->data.sample.param.position); } -static void event_private1(struct snd_seq_event *ev, struct snd_gus_port *p, - struct snd_gus_voice *v) +static void event_private1(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v) { if (v->sample_ops && v->sample_ops->sample_private1) v->sample_ops->sample_private1(p->gus, v, (unsigned char *)&ev->data.sample.param.raw8); } -typedef void (gus_sample_event_handler_t)(struct snd_seq_event *ev, - struct snd_gus_port *p, - struct snd_gus_voice *v); +typedef void (gus_sample_event_handler_t)(snd_seq_event_t *ev, snd_gus_port_t *p, snd_gus_voice_t *v); + static gus_sample_event_handler_t *gus_sample_event_handlers[9] = { event_sample, event_cluster, @@ -141,11 +131,11 @@ static gus_sample_event_handler_t *gus_sample_event_handlers[9] = { event_private1 }; -void snd_gus_sample_event(struct snd_seq_event *ev, struct snd_gus_port *p) +void snd_gus_sample_event(snd_seq_event_t *ev, snd_gus_port_t *p) { int idx, voice; - struct snd_gus_card *gus = p->gus; - struct snd_gus_voice *v; + snd_gus_card_t *gus = p->gus; + snd_gus_voice_t *v; unsigned long flags; idx = ev->type - SNDRV_SEQ_EVENT_SAMPLE; diff --git a/trunk/sound/isa/gus/gus_simple.c b/trunk/sound/isa/gus/gus_simple.c index dcad6ed0198c..dfed85b58b3a 100644 --- a/trunk/sound/isa/gus/gus_simple.c +++ b/trunk/sound/isa/gus/gus_simple.c @@ -29,19 +29,19 @@ * */ -static void interrupt_wave(struct snd_gus_card *gus, struct snd_gus_voice *voice); -static void interrupt_volume(struct snd_gus_card *gus, struct snd_gus_voice *voice); -static void interrupt_effect(struct snd_gus_card *gus, struct snd_gus_voice *voice); - -static void sample_start(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_position_t position); -static void sample_stop(struct snd_gus_card *gus, struct snd_gus_voice *voice, int mode); -static void sample_freq(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_frequency_t freq); -static void sample_volume(struct snd_gus_card *card, struct snd_gus_voice *voice, struct snd_seq_ev_volume *volume); -static void sample_loop(struct snd_gus_card *card, struct snd_gus_voice *voice, struct snd_seq_ev_loop *loop); -static void sample_pos(struct snd_gus_card *card, struct snd_gus_voice *voice, snd_seq_position_t position); -static void sample_private1(struct snd_gus_card *card, struct snd_gus_voice *voice, unsigned char *data); - -static struct snd_gus_sample_ops sample_ops = { +static void interrupt_wave(snd_gus_card_t *gus, snd_gus_voice_t *voice); +static void interrupt_volume(snd_gus_card_t *gus, snd_gus_voice_t *voice); +static void interrupt_effect(snd_gus_card_t *gus, snd_gus_voice_t *voice); + +static void sample_start(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_position_t position); +static void sample_stop(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_stop_mode_t mode); +static void sample_freq(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_frequency_t freq); +static void sample_volume(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_ev_volume_t *volume); +static void sample_loop(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_ev_loop_t *loop); +static void sample_pos(snd_gus_card_t *card, snd_gus_voice_t *voice, snd_seq_position_t position); +static void sample_private1(snd_gus_card_t *card, snd_gus_voice_t *voice, unsigned char *data); + +static snd_gus_sample_ops_t sample_ops = { sample_start, sample_stop, sample_freq, @@ -53,13 +53,13 @@ static struct snd_gus_sample_ops sample_ops = { #if 0 -static void note_stop(struct snd_gus_card *gus, struct snd_gus_voice *voice, int wait); -static void note_wait(struct snd_gus_card *gus, struct snd_gus_voice *voice); -static void note_off(struct snd_gus_card *gus, struct snd_gus_voice *voice); -static void note_volume(struct snd_gus_card *card, struct snd_gus_voice *voice); -static void note_pitchbend(struct snd_gus_card *card, struct snd_gus_voice *voice); -static void note_vibrato(struct snd_gus_card *card, struct snd_gus_voice *voice); -static void note_tremolo(struct snd_gus_card *card, struct snd_gus_voice *voice); +static void note_stop(snd_gus_card_t *gus, snd_gus_voice_t *voice, int wait); +static void note_wait(snd_gus_card_t *gus, snd_gus_voice_t *voice); +static void note_off(snd_gus_card_t *gus, snd_gus_voice_t *voice); +static void note_volume(snd_gus_card_t *card, snd_gus_voice_t *voice); +static void note_pitchbend(snd_gus_card_t *card, snd_gus_voice_t *voice); +static void note_vibrato(snd_gus_card_t *card, snd_gus_voice_t *voice); +static void note_tremolo(snd_gus_card_t *card, snd_gus_voice_t *voice); static struct snd_gus_note_handlers note_commands = { note_stop, @@ -71,7 +71,7 @@ static struct snd_gus_note_handlers note_commands = { note_tremolo }; -static void chn_trigger_down(struct snd_gus_card *card, ultra_channel_t *channel, ultra_instrument_t *instrument, unsigned char note, unsigned char velocity, unsigned char priority ); +static void chn_trigger_down(snd_gus_card_t *card, ultra_channel_t *channel, ultra_instrument_t *instrument, unsigned char note, unsigned char velocity, unsigned char priority ); static void chn_trigger_up( ultra_card_t *card, ultra_note_t *note ); static void chn_control( ultra_card_t *card, ultra_channel_t *channel, unsigned short p1, unsigned short p2 ); @@ -83,14 +83,14 @@ static struct ULTRA_STRU_INSTRUMENT_CHANNEL_COMMANDS channel_commands = { #endif -static void do_volume_envelope(struct snd_gus_card *card, struct snd_gus_voice *voice); -static void do_pan_envelope(struct snd_gus_card *card, struct snd_gus_voice *voice); +static void do_volume_envelope(snd_gus_card_t *card, snd_gus_voice_t *voice); +static void do_pan_envelope(snd_gus_card_t *card, snd_gus_voice_t *voice); /* * */ -static void interrupt_wave(struct snd_gus_card *gus, struct snd_gus_voice *voice) +static void interrupt_wave(snd_gus_card_t *gus, snd_gus_voice_t *voice) { spin_lock(&gus->event_lock); snd_gf1_stop_voice(gus, voice->number); @@ -102,7 +102,7 @@ static void interrupt_wave(struct snd_gus_card *gus, struct snd_gus_voice *voice spin_unlock(&gus->event_lock); } -static void interrupt_volume(struct snd_gus_card *gus, struct snd_gus_voice *voice) +static void interrupt_volume(snd_gus_card_t *gus, snd_gus_voice_t *voice) { spin_lock(&gus->event_lock); if (voice->flags & SNDRV_GF1_VFLG_RUNNING) @@ -112,7 +112,7 @@ static void interrupt_volume(struct snd_gus_card *gus, struct snd_gus_voice *voi spin_unlock(&gus->event_lock); } -static void interrupt_effect(struct snd_gus_card *gus, struct snd_gus_voice *voice) +static void interrupt_effect(snd_gus_card_t *gus, snd_gus_voice_t *voice) { spin_lock(&gus->event_lock); if ((voice->flags & (SNDRV_GF1_VFLG_RUNNING|SNDRV_GF1_VFLG_EFFECT_TIMER1)) == @@ -125,7 +125,7 @@ static void interrupt_effect(struct snd_gus_card *gus, struct snd_gus_voice *voi * */ -static void do_volume_envelope(struct snd_gus_card *gus, struct snd_gus_voice *voice) +static void do_volume_envelope(snd_gus_card_t *gus, snd_gus_voice_t *voice) { unsigned short next, rate, old_volume; int program_next_ramp; @@ -229,7 +229,7 @@ static void do_volume_envelope(struct snd_gus_card *gus, struct snd_gus_voice *v } } -static void do_pan_envelope(struct snd_gus_card *gus, struct snd_gus_voice *voice) +static void do_pan_envelope(snd_gus_card_t *gus, snd_gus_voice_t *voice) { unsigned long flags; unsigned char old_pan; @@ -276,7 +276,7 @@ static void do_pan_envelope(struct snd_gus_card *gus, struct snd_gus_voice *voic #endif } -static void set_enhanced_pan(struct snd_gus_card *gus, struct snd_gus_voice *voice, unsigned short pan) +static void set_enhanced_pan(snd_gus_card_t *gus, snd_gus_voice_t *voice, unsigned short pan) { unsigned long flags; unsigned short vlo, vro; @@ -307,13 +307,13 @@ static void set_enhanced_pan(struct snd_gus_card *gus, struct snd_gus_voice *voi * */ -static void sample_start(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_position_t position) +static void sample_start(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_position_t position) { unsigned long flags; unsigned int begin, addr, addr_end, addr_start; int w_16; - struct simple_instrument *simple; - struct snd_seq_kinstr *instr; + simple_instrument_t *simple; + snd_seq_kinstr_t *instr; instr = snd_seq_instr_find(gus->gf1.ilist, &voice->instr, 0, 1); if (instr == NULL) @@ -397,7 +397,7 @@ static void sample_start(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_instr_free_use(gus->gf1.ilist, instr); } -static void sample_stop(struct snd_gus_card *gus, struct snd_gus_voice *voice, int mode) +static void sample_stop(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_stop_mode_t mode) { unsigned char control; unsigned long flags; @@ -433,7 +433,7 @@ static void sample_stop(struct snd_gus_card *gus, struct snd_gus_voice *voice, i } } -static void sample_freq(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_frequency_t freq) +static void sample_freq(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_frequency_t freq) { unsigned long flags; @@ -444,7 +444,7 @@ static void sample_freq(struct snd_gus_card *gus, struct snd_gus_voice *voice, s spin_unlock_irqrestore(&gus->reg_lock, flags); } -static void sample_volume(struct snd_gus_card *gus, struct snd_gus_voice *voice, struct snd_seq_ev_volume *volume) +static void sample_volume(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_ev_volume_t *volume) { if (volume->volume >= 0) { volume->volume &= 0x3fff; @@ -471,13 +471,13 @@ static void sample_volume(struct snd_gus_card *gus, struct snd_gus_voice *voice, } } -static void sample_loop(struct snd_gus_card *gus, struct snd_gus_voice *voice, struct snd_seq_ev_loop *loop) +static void sample_loop(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_ev_loop_t *loop) { unsigned long flags; int w_16 = voice->control & 0x04; unsigned int begin, addr_start, addr_end; - struct simple_instrument *simple; - struct snd_seq_kinstr *instr; + simple_instrument_t *simple; + snd_seq_kinstr_t *instr; #if 0 printk("voice_loop: start = 0x%x, end = 0x%x\n", loop->start, loop->end); @@ -500,13 +500,13 @@ static void sample_loop(struct snd_gus_card *gus, struct snd_gus_voice *voice, s snd_seq_instr_free_use(gus->gf1.ilist, instr); } -static void sample_pos(struct snd_gus_card *gus, struct snd_gus_voice *voice, snd_seq_position_t position) +static void sample_pos(snd_gus_card_t *gus, snd_gus_voice_t *voice, snd_seq_position_t position) { unsigned long flags; int w_16 = voice->control & 0x04; unsigned int begin, addr; - struct simple_instrument *simple; - struct snd_seq_kinstr *instr; + simple_instrument_t *simple; + snd_seq_kinstr_t *instr; #if 0 printk("voice_loop: start = 0x%x, end = 0x%x\n", loop->start, loop->end); @@ -537,7 +537,7 @@ static unsigned char get_effects_mask( ultra_card_t *card, int value ) #endif -static void sample_private1(struct snd_gus_card *card, struct snd_gus_voice *voice, unsigned char *data) +static void sample_private1(snd_gus_card_t *card, snd_gus_voice_t *voice, unsigned char *data) { #if 0 unsigned long flags; @@ -624,7 +624,7 @@ static void chn_control( ultra_card_t *card, ultra_channel_t *channel, unsigned #endif -void snd_gf1_simple_init(struct snd_gus_voice *voice) +void snd_gf1_simple_init(snd_gus_voice_t *voice) { voice->handler_wave = interrupt_wave; voice->handler_volume = interrupt_volume; diff --git a/trunk/sound/isa/gus/gus_synth.c b/trunk/sound/isa/gus/gus_synth.c index 85a1b051f09a..f51c386ee192 100644 --- a/trunk/sound/isa/gus/gus_synth.c +++ b/trunk/sound/isa/gus/gus_synth.c @@ -34,10 +34,10 @@ MODULE_LICENSE("GPL"); * */ -static void snd_gus_synth_free_voices(struct snd_gus_card * gus, int client, int port) +static void snd_gus_synth_free_voices(snd_gus_card_t * gus, int client, int port) { int idx; - struct snd_gus_voice * voice; + snd_gus_voice_t * voice; for (idx = 0; idx < 32; idx++) { voice = &gus->gf1.voices[idx]; @@ -46,11 +46,11 @@ static void snd_gus_synth_free_voices(struct snd_gus_card * gus, int client, int } } -static int snd_gus_synth_use(void *private_data, struct snd_seq_port_subscribe *info) +static int snd_gus_synth_use(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_gus_port * port = private_data; - struct snd_gus_card * gus = port->gus; - struct snd_gus_voice * voice; + snd_gus_port_t * port = (snd_gus_port_t *)private_data; + snd_gus_card_t * gus = port->gus; + snd_gus_voice_t * voice; unsigned int idx; if (info->voices > 32) @@ -74,10 +74,10 @@ static int snd_gus_synth_use(void *private_data, struct snd_seq_port_subscribe * return 0; } -static int snd_gus_synth_unuse(void *private_data, struct snd_seq_port_subscribe *info) +static int snd_gus_synth_unuse(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_gus_port * port = private_data; - struct snd_gus_card * gus = port->gus; + snd_gus_port_t * port = (snd_gus_port_t *)private_data; + snd_gus_card_t * gus = port->gus; down(&gus->register_mutex); snd_gus_synth_free_voices(gus, info->sender.client, info->sender.port); @@ -90,19 +90,19 @@ static int snd_gus_synth_unuse(void *private_data, struct snd_seq_port_subscribe * */ -static void snd_gus_synth_free_private_instruments(struct snd_gus_port *p, int client) +static void snd_gus_synth_free_private_instruments(snd_gus_port_t *p, int client) { - struct snd_seq_instr_header ifree; + snd_seq_instr_header_t ifree; memset(&ifree, 0, sizeof(ifree)); ifree.cmd = SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE; snd_seq_instr_list_free_cond(p->gus->gf1.ilist, &ifree, client, 0); } -static int snd_gus_synth_event_input(struct snd_seq_event *ev, int direct, +static int snd_gus_synth_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct snd_gus_port * p = private_data; + snd_gus_port_t * p = (snd_gus_port_t *) private_data; snd_assert(p != NULL, return -EINVAL); if (ev->type >= SNDRV_SEQ_EVENT_SAMPLE && @@ -131,12 +131,12 @@ static int snd_gus_synth_event_input(struct snd_seq_event *ev, int direct, } static void snd_gus_synth_instr_notify(void *private_data, - struct snd_seq_kinstr *instr, + snd_seq_kinstr_t *instr, int what) { unsigned int idx; - struct snd_gus_card *gus = private_data; - struct snd_gus_voice *pvoice; + snd_gus_card_t *gus = private_data; + snd_gus_voice_t *pvoice; unsigned long flags; spin_lock_irqsave(&gus->event_lock, flags); @@ -160,16 +160,16 @@ static void snd_gus_synth_instr_notify(void *private_data, static void snd_gus_synth_free_port(void *private_data) { - struct snd_gus_port * p = private_data; + snd_gus_port_t * p = (snd_gus_port_t *)private_data; if (p) snd_midi_channel_free_set(p->chset); } -static int snd_gus_synth_create_port(struct snd_gus_card * gus, int idx) +static int snd_gus_synth_create_port(snd_gus_card_t * gus, int idx) { - struct snd_gus_port * p; - struct snd_seq_port_callback callbacks; + snd_gus_port_t * p; + snd_seq_port_callback_t callbacks; char name[32]; int result; @@ -210,28 +210,46 @@ static int snd_gus_synth_create_port(struct snd_gus_card * gus, int idx) * */ -static int snd_gus_synth_new_device(struct snd_seq_device *dev) +static int snd_gus_synth_new_device(snd_seq_device_t *dev) { - struct snd_gus_card *gus; + snd_gus_card_t *gus; int client, i; - struct snd_seq_port_subscribe sub; - struct snd_iwffff_ops *iwops; - struct snd_gf1_ops *gf1ops; - struct snd_simple_ops *simpleops; - - gus = *(struct snd_gus_card **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + snd_seq_client_callback_t callbacks; + snd_seq_client_info_t *cinfo; + snd_seq_port_subscribe_t sub; + snd_iwffff_ops_t *iwops; + snd_gf1_ops_t *gf1ops; + snd_simple_ops_t *simpleops; + + gus = *(snd_gus_card_t**)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (gus == NULL) return -EINVAL; init_MUTEX(&gus->register_mutex); gus->gf1.seq_client = -1; + cinfo = kmalloc(sizeof(*cinfo), GFP_KERNEL); + if (! cinfo) + return -ENOMEM; + /* allocate new client */ + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.private_data = gus; + callbacks.allow_output = callbacks.allow_input = 1; client = gus->gf1.seq_client = - snd_seq_create_kernel_client(gus->card, 1, gus->interwave ? - "AMD InterWave" : "GF1"); - if (client < 0) + snd_seq_create_kernel_client(gus->card, 1, &callbacks); + if (client < 0) { + kfree(cinfo); return client; + } + + /* change name of client */ + memset(cinfo, 0, sizeof(*cinfo)); + cinfo->client = client; + cinfo->type = KERNEL_CLIENT; + sprintf(cinfo->name, gus->interwave ? "AMD InterWave" : "GF1"); + snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, cinfo); + kfree(cinfo); for (i = 0; i < 4; i++) snd_gus_synth_create_port(gus, i); @@ -275,11 +293,11 @@ static int snd_gus_synth_new_device(struct snd_seq_device *dev) return 0; } -static int snd_gus_synth_delete_device(struct snd_seq_device *dev) +static int snd_gus_synth_delete_device(snd_seq_device_t *dev) { - struct snd_gus_card *gus; + snd_gus_card_t *gus; - gus = *(struct snd_gus_card **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + gus = *(snd_gus_card_t**)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (gus == NULL) return -EINVAL; @@ -294,13 +312,13 @@ static int snd_gus_synth_delete_device(struct snd_seq_device *dev) static int __init alsa_gus_synth_init(void) { - static struct snd_seq_dev_ops ops = { + static snd_seq_dev_ops_t ops = { snd_gus_synth_new_device, snd_gus_synth_delete_device }; return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_GUS, &ops, - sizeof(struct snd_gus_card *)); + sizeof(snd_gus_card_t*)); } static void __exit alsa_gus_synth_exit(void) diff --git a/trunk/sound/isa/gus/gus_timer.c b/trunk/sound/isa/gus/gus_timer.c index a43b662f17c7..9876603ff6c1 100644 --- a/trunk/sound/isa/gus/gus_timer.c +++ b/trunk/sound/isa/gus/gus_timer.c @@ -30,12 +30,12 @@ * Timer 1 - 80us */ -static int snd_gf1_timer1_start(struct snd_timer * timer) +static int snd_gf1_timer1_start(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; unsigned int ticks; - struct snd_gus_card *gus; + snd_gus_card_t *gus; gus = snd_timer_chip(timer); spin_lock_irqsave(&gus->reg_lock, flags); @@ -48,11 +48,11 @@ static int snd_gf1_timer1_start(struct snd_timer * timer) return 0; } -static int snd_gf1_timer1_stop(struct snd_timer * timer) +static int snd_gf1_timer1_stop(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; - struct snd_gus_card *gus; + snd_gus_card_t *gus; gus = snd_timer_chip(timer); spin_lock_irqsave(&gus->reg_lock, flags); @@ -66,12 +66,12 @@ static int snd_gf1_timer1_stop(struct snd_timer * timer) * Timer 2 - 320us */ -static int snd_gf1_timer2_start(struct snd_timer * timer) +static int snd_gf1_timer2_start(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; unsigned int ticks; - struct snd_gus_card *gus; + snd_gus_card_t *gus; gus = snd_timer_chip(timer); spin_lock_irqsave(&gus->reg_lock, flags); @@ -84,11 +84,11 @@ static int snd_gf1_timer2_start(struct snd_timer * timer) return 0; } -static int snd_gf1_timer2_stop(struct snd_timer * timer) +static int snd_gf1_timer2_stop(snd_timer_t * timer) { unsigned long flags; unsigned char tmp; - struct snd_gus_card *gus; + snd_gus_card_t *gus; gus = snd_timer_chip(timer); spin_lock_irqsave(&gus->reg_lock, flags); @@ -102,18 +102,18 @@ static int snd_gf1_timer2_stop(struct snd_timer * timer) */ -static void snd_gf1_interrupt_timer1(struct snd_gus_card * gus) +static void snd_gf1_interrupt_timer1(snd_gus_card_t * gus) { - struct snd_timer *timer = gus->gf1.timer1; + snd_timer_t *timer = gus->gf1.timer1; if (timer == NULL) return; snd_timer_interrupt(timer, timer->sticks); } -static void snd_gf1_interrupt_timer2(struct snd_gus_card * gus) +static void snd_gf1_interrupt_timer2(snd_gus_card_t * gus) { - struct snd_timer *timer = gus->gf1.timer2; + snd_timer_t *timer = gus->gf1.timer2; if (timer == NULL) return; @@ -124,7 +124,7 @@ static void snd_gf1_interrupt_timer2(struct snd_gus_card * gus) */ -static struct snd_timer_hardware snd_gf1_timer1 = +static struct _snd_timer_hardware snd_gf1_timer1 = { .flags = SNDRV_TIMER_HW_STOP, .resolution = 80000, @@ -133,7 +133,7 @@ static struct snd_timer_hardware snd_gf1_timer1 = .stop = snd_gf1_timer1_stop, }; -static struct snd_timer_hardware snd_gf1_timer2 = +static struct _snd_timer_hardware snd_gf1_timer2 = { .flags = SNDRV_TIMER_HW_STOP, .resolution = 320000, @@ -142,22 +142,22 @@ static struct snd_timer_hardware snd_gf1_timer2 = .stop = snd_gf1_timer2_stop, }; -static void snd_gf1_timer1_free(struct snd_timer *timer) +static void snd_gf1_timer1_free(snd_timer_t *timer) { - struct snd_gus_card *gus = timer->private_data; + snd_gus_card_t *gus = timer->private_data; gus->gf1.timer1 = NULL; } -static void snd_gf1_timer2_free(struct snd_timer *timer) +static void snd_gf1_timer2_free(snd_timer_t *timer) { - struct snd_gus_card *gus = timer->private_data; + snd_gus_card_t *gus = timer->private_data; gus->gf1.timer2 = NULL; } -void snd_gf1_timers_init(struct snd_gus_card * gus) +void snd_gf1_timers_init(snd_gus_card_t * gus) { - struct snd_timer *timer; - struct snd_timer_id tid; + snd_timer_t *timer; + snd_timer_id_t tid; if (gus->gf1.timer1 != NULL || gus->gf1.timer2 != NULL) return; @@ -190,7 +190,7 @@ void snd_gf1_timers_init(struct snd_gus_card * gus) gus->gf1.timer2 = timer; } -void snd_gf1_timers_done(struct snd_gus_card * gus) +void snd_gf1_timers_done(snd_gus_card_t * gus) { snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_TIMER1 | SNDRV_GF1_HANDLER_TIMER2); if (gus->gf1.timer1) { diff --git a/trunk/sound/isa/gus/gus_uart.c b/trunk/sound/isa/gus/gus_uart.c index 654290a8b21c..fbc95e99105c 100644 --- a/trunk/sound/isa/gus/gus_uart.c +++ b/trunk/sound/isa/gus/gus_uart.c @@ -26,7 +26,7 @@ #include <sound/core.h> #include <sound/gus.h> -static void snd_gf1_interrupt_midi_in(struct snd_gus_card * gus) +static void snd_gf1_interrupt_midi_in(snd_gus_card_t * gus) { int count; unsigned char stat, data, byte; @@ -61,7 +61,7 @@ static void snd_gf1_interrupt_midi_in(struct snd_gus_card * gus) } } -static void snd_gf1_interrupt_midi_out(struct snd_gus_card * gus) +static void snd_gf1_interrupt_midi_out(snd_gus_card_t * gus) { char byte; unsigned long flags; @@ -81,7 +81,7 @@ static void snd_gf1_interrupt_midi_out(struct snd_gus_card * gus) spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); } -static void snd_gf1_uart_reset(struct snd_gus_card * gus, int close) +static void snd_gf1_uart_reset(snd_gus_card_t * gus, int close) { snd_gf1_uart_cmd(gus, 0x03); /* reset */ if (!close && gus->uart_enable) { @@ -90,10 +90,10 @@ static void snd_gf1_uart_reset(struct snd_gus_card * gus, int close) } } -static int snd_gf1_uart_output_open(struct snd_rawmidi_substream *substream) +static int snd_gf1_uart_output_open(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_gus_card *gus; + snd_gus_card_t *gus; gus = substream->rmidi->private_data; spin_lock_irqsave(&gus->uart_cmd_lock, flags); @@ -109,10 +109,10 @@ static int snd_gf1_uart_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_gf1_uart_input_open(struct snd_rawmidi_substream *substream) +static int snd_gf1_uart_input_open(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_gus_card *gus; + snd_gus_card_t *gus; int i; gus = substream->rmidi->private_data; @@ -136,10 +136,10 @@ static int snd_gf1_uart_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_gf1_uart_output_close(struct snd_rawmidi_substream *substream) +static int snd_gf1_uart_output_close(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_gus_card *gus; + snd_gus_card_t *gus; gus = substream->rmidi->private_data; spin_lock_irqsave(&gus->uart_cmd_lock, flags); @@ -151,10 +151,10 @@ static int snd_gf1_uart_output_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_gf1_uart_input_close(struct snd_rawmidi_substream *substream) +static int snd_gf1_uart_input_close(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_gus_card *gus; + snd_gus_card_t *gus; gus = substream->rmidi->private_data; spin_lock_irqsave(&gus->uart_cmd_lock, flags); @@ -166,9 +166,9 @@ static int snd_gf1_uart_input_close(struct snd_rawmidi_substream *substream) return 0; } -static void snd_gf1_uart_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_gf1_uart_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct snd_gus_card *gus; + snd_gus_card_t *gus; unsigned long flags; gus = substream->rmidi->private_data; @@ -184,10 +184,10 @@ static void snd_gf1_uart_input_trigger(struct snd_rawmidi_substream *substream, spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); } -static void snd_gf1_uart_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_gf1_uart_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct snd_gus_card *gus; + snd_gus_card_t *gus; char byte; int timeout; @@ -222,23 +222,23 @@ static void snd_gf1_uart_output_trigger(struct snd_rawmidi_substream *substream, spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); } -static struct snd_rawmidi_ops snd_gf1_uart_output = +static snd_rawmidi_ops_t snd_gf1_uart_output = { .open = snd_gf1_uart_output_open, .close = snd_gf1_uart_output_close, .trigger = snd_gf1_uart_output_trigger, }; -static struct snd_rawmidi_ops snd_gf1_uart_input = +static snd_rawmidi_ops_t snd_gf1_uart_input = { .open = snd_gf1_uart_input_open, .close = snd_gf1_uart_input_close, .trigger = snd_gf1_uart_input_trigger, }; -int snd_gf1_rawmidi_new(struct snd_gus_card * gus, int device, struct snd_rawmidi ** rrawmidi) +int snd_gf1_rawmidi_new(snd_gus_card_t * gus, int device, snd_rawmidi_t ** rrawmidi) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if (rrawmidi) diff --git a/trunk/sound/isa/gus/gus_volume.c b/trunk/sound/isa/gus/gus_volume.c index dbbc0a6d7659..b3382fec5298 100644 --- a/trunk/sound/isa/gus/gus_volume.c +++ b/trunk/sound/isa/gus/gus_volume.c @@ -72,7 +72,7 @@ unsigned int snd_gf1_gvol_to_lvol_raw(unsigned short gf1_vol) return rvol | (m >> (8 - e)); } -unsigned int snd_gf1_calc_ramp_rate(struct snd_gus_card * gus, +unsigned int snd_gf1_calc_ramp_rate(snd_gus_card_t * gus, unsigned short start, unsigned short end, unsigned int us) @@ -112,7 +112,7 @@ unsigned int snd_gf1_calc_ramp_rate(struct snd_gus_card * gus, #endif /* 0 */ -unsigned short snd_gf1_translate_freq(struct snd_gus_card * gus, unsigned int freq16) +unsigned short snd_gf1_translate_freq(snd_gus_card_t * gus, unsigned int freq16) { freq16 >>= 3; if (freq16 < 50) diff --git a/trunk/sound/isa/gus/gusclassic.c b/trunk/sound/isa/gus/gusclassic.c index d1165b96fa3f..39cef38835ca 100644 --- a/trunk/sound/isa/gus/gusclassic.c +++ b/trunk/sound/isa/gus/gusclassic.c @@ -20,15 +20,14 @@ */ #include <sound/driver.h> +#include <asm/dma.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/delay.h> #include <linux/time.h> #include <linux/moduleparam.h> -#include <asm/dma.h> #include <sound/core.h> #include <sound/gus.h> +#define SNDRV_LEGACY_AUTO_PROBE #define SNDRV_LEGACY_FIND_FREE_IRQ #define SNDRV_LEGACY_FIND_FREE_DMA #include <sound/initval.h> @@ -71,12 +70,11 @@ MODULE_PARM_DESC(channels, "GF1 channels for GUS Classic driver."); module_param_array(pcm_channels, int, NULL, 0444); MODULE_PARM_DESC(pcm_channels, "Reserved PCM channels for GUS Classic driver."); -static struct platform_device *devices[SNDRV_CARDS]; - +static snd_card_t *snd_gusclassic_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; #define PFX "gusclassic: " -static int __init snd_gusclassic_detect(struct snd_gus_card * gus) +static int __init snd_gusclassic_detect(snd_gus_card_t * gus) { unsigned char d; @@ -95,7 +93,7 @@ static int __init snd_gusclassic_detect(struct snd_gus_card * gus) return 0; } -static void __init snd_gusclassic_init(int dev, struct snd_gus_card * gus) +static void __init snd_gusclassic_init(int dev, snd_gus_card_t * gus) { gus->equal_irq = 0; gus->codec_flag = 0; @@ -103,19 +101,20 @@ static void __init snd_gusclassic_init(int dev, struct snd_gus_card * gus) gus->joystick_dac = joystick_dac[dev]; } -static int __init snd_gusclassic_probe(struct platform_device *pdev) +static int __init snd_gusclassic_probe(int dev) { - int dev = pdev->id; static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, 4, -1}; static int possible_dmas[] = {5, 6, 7, 1, 3, -1}; int xirq, xdma1, xdma2; - struct snd_card *card; - struct snd_gus_card *gus = NULL; + snd_card_t *card; + struct snd_gusclassic *guscard; + snd_gus_card_t *gus = NULL; int err; card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); if (card == NULL) return -ENOMEM; + guscard = (struct snd_gusclassic *)card->private_data; if (pcm_channels[dev] < 2) pcm_channels[dev] = 2; @@ -144,31 +143,12 @@ static int __init snd_gusclassic_probe(struct platform_device *pdev) } } - if (port[dev] != SNDRV_AUTO_PORT) { - err = snd_gus_create(card, - port[dev], - xirq, xdma1, xdma2, - 0, channels[dev], pcm_channels[dev], - 0, &gus); - } else { - /* auto-probe legacy ports */ - static unsigned long possible_ports[] = { - 0x220, 0x230, 0x240, 0x250, 0x260, - }; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - err = snd_gus_create(card, - possible_ports[i], - xirq, xdma1, xdma2, - 0, channels[dev], pcm_channels[dev], - 0, &gus); - if (err >= 0) { - port[dev] = possible_ports[i]; - break; - } - } - } - if (err < 0) + + if ((err = snd_gus_create(card, + port[dev], + xirq, xdma1, xdma2, + 0, channels[dev], pcm_channels[dev], + 0, &gus)) < 0) goto _err; if ((err = snd_gusclassic_detect(gus)) < 0) @@ -198,12 +178,13 @@ static int __init snd_gusclassic_probe(struct platform_device *pdev) if (dma2 >= 0) sprintf(card->longname + strlen(card->longname), "&%d", xdma2); - snd_card_set_dev(card, &pdev->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; - platform_set_drvdata(pdev, card); + snd_gusclassic_cards[dev] = card; return 0; _err: @@ -211,70 +192,53 @@ static int __init snd_gusclassic_probe(struct platform_device *pdev) return err; } -static int snd_gusclassic_remove(struct platform_device *devptr) +static int __init snd_gusclassic_legacy_auto_probe(unsigned long xport) { - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define GUSCLASSIC_DRIVER "snd_gusclassic" - -static struct platform_driver snd_gusclassic_driver = { - .probe = snd_gusclassic_probe, - .remove = snd_gusclassic_remove, - /* FIXME: suspend/resume */ - .driver = { - .name = GUSCLASSIC_DRIVER - }, -}; - -static void __init_or_module snd_gusclassic_unregister_all(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_gusclassic_driver); + static int dev; + int res; + + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; + port[dev] = xport; + res = snd_gusclassic_probe(dev); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; + } + return -ENODEV; } static int __init alsa_card_gusclassic_init(void) { - int i, cards, err; - - err = platform_driver_register(&snd_gusclassic_driver); - if (err < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(GUSCLASSIC_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + static unsigned long possible_ports[] = {0x220, 0x230, 0x240, 0x250, 0x260, -1}; + int dev, cards, i; + + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) { + if (port[dev] == SNDRV_AUTO_PORT) + continue; + if (snd_gusclassic_probe(dev) >= 0) + cards++; } + i = snd_legacy_auto_probe(possible_ports, snd_gusclassic_legacy_auto_probe); + if (i > 0) + cards += i; + if (!cards) { #ifdef MODULE printk(KERN_ERR "GUS Classic soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_gusclassic_unregister_all(); - return err; } static void __exit alsa_card_gusclassic_exit(void) { - snd_gusclassic_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_gusclassic_cards[idx]); } module_init(alsa_card_gusclassic_init) diff --git a/trunk/sound/isa/gus/gusextreme.c b/trunk/sound/isa/gus/gusextreme.c index 239f16e6b9ee..d2e7cb1df537 100644 --- a/trunk/sound/isa/gus/gusextreme.c +++ b/trunk/sound/isa/gus/gusextreme.c @@ -20,13 +20,11 @@ */ #include <sound/driver.h> +#include <asm/dma.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/delay.h> #include <linux/time.h> #include <linux/moduleparam.h> -#include <asm/dma.h> #include <sound/core.h> #include <sound/gus.h> #include <sound/es1688.h> @@ -87,15 +85,14 @@ MODULE_PARM_DESC(channels, "GF1 channels for GUS Extreme driver."); module_param_array(pcm_channels, int, NULL, 0444); MODULE_PARM_DESC(pcm_channels, "Reserved PCM channels for GUS Extreme driver."); -struct platform_device *devices[SNDRV_CARDS]; - +static snd_card_t *snd_gusextreme_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; #define PFX "gusextreme: " static int __init snd_gusextreme_detect(int dev, - struct snd_card *card, - struct snd_gus_card * gus, - struct snd_es1688 *es1688) + snd_card_t * card, + snd_gus_card_t * gus, + es1688_t *es1688) { unsigned long flags; unsigned char d; @@ -142,15 +139,15 @@ static int __init snd_gusextreme_detect(int dev, return 0; } -static void __init snd_gusextreme_init(int dev, struct snd_gus_card * gus) +static void __init snd_gusextreme_init(int dev, snd_gus_card_t * gus) { gus->joystick_dac = joystick_dac[dev]; } -static int __init snd_gusextreme_mixer(struct snd_es1688 *chip) +static int __init snd_gusextreme_mixer(es1688_t *chip) { - struct snd_card *card = chip->card; - struct snd_ctl_elem_id id1, id2; + snd_card_t *card = chip->card; + snd_ctl_elem_id_t id1, id2; int err; memset(&id1, 0, sizeof(id1)); @@ -169,23 +166,24 @@ static int __init snd_gusextreme_mixer(struct snd_es1688 *chip) return 0; } -static int __init snd_gusextreme_probe(struct platform_device *pdev) +static int __init snd_gusextreme_probe(int dev) { - int dev = pdev->id; static int possible_ess_irqs[] = {5, 9, 10, 7, -1}; static int possible_ess_dmas[] = {1, 3, 0, -1}; static int possible_gf1_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1}; static int possible_gf1_dmas[] = {5, 6, 7, 1, 3, -1}; int xgf1_irq, xgf1_dma, xess_irq, xmpu_irq, xess_dma; - struct snd_card *card; - struct snd_gus_card *gus; - struct snd_es1688 *es1688; - struct snd_opl3 *opl3; + snd_card_t *card; + struct snd_gusextreme *acard; + snd_gus_card_t *gus; + es1688_t *es1688; + opl3_t *opl3; int err; card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); if (card == NULL) return -ENOMEM; + acard = (struct snd_gusextreme *)card->private_data; xgf1_irq = gf1_irq[dev]; if (xgf1_irq == SNDRV_AUTO_IRQ) { @@ -225,29 +223,10 @@ static int __init snd_gusextreme_probe(struct platform_device *pdev) } } - if (port[dev] != SNDRV_AUTO_PORT) { - err = snd_es1688_create(card, port[dev], mpu_port[dev], - xess_irq, xmpu_irq, xess_dma, - ES1688_HW_1688, &es1688); - } else { - /* auto-probe legacy ports */ - static unsigned long possible_ports[] = {0x220, 0x240, 0x260}; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - err = snd_es1688_create(card, - possible_ports[i], - mpu_port[dev], - xess_irq, xmpu_irq, xess_dma, - ES1688_HW_1688, &es1688); - if (err >= 0) { - port[dev] = possible_ports[i]; - break; - } - } - } - if (err < 0) + if ((err = snd_es1688_create(card, port[dev], mpu_port[dev], + xess_irq, xmpu_irq, xess_dma, + ES1688_HW_1688, &es1688)) < 0) goto out; - if (gf1_port[dev] < 0) gf1_port[dev] = port[dev] + 0x20; if ((err = snd_gus_create(card, @@ -308,12 +287,13 @@ static int __init snd_gusextreme_probe(struct platform_device *pdev) sprintf(card->longname, "Gravis UltraSound Extreme at 0x%lx, irq %i&%i, dma %i&%i", es1688->port, xgf1_irq, xess_irq, xgf1_dma, xess_dma); - snd_card_set_dev(card, &pdev->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto out; if ((err = snd_card_register(card)) < 0) goto out; - platform_set_drvdata(pdev, card); + snd_gusextreme_cards[dev] = card; return 0; out: @@ -321,70 +301,60 @@ static int __init snd_gusextreme_probe(struct platform_device *pdev) return err; } -static int snd_gusextreme_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define GUSEXTREME_DRIVER "snd_gusextreme" - -static struct platform_driver snd_gusextreme_driver = { - .probe = snd_gusextreme_probe, - .remove = snd_gusextreme_remove, - /* FIXME: suspend/resume */ - .driver = { - .name = GUSEXTREME_DRIVER - }, -}; - -static void __init_or_module snd_gusextreme_unregister_all(void) +static int __init snd_gusextreme_legacy_auto_probe(unsigned long xport) { - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_gusextreme_driver); + static int dev; + int res; + + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; + port[dev] = xport; + res = snd_gusextreme_probe(dev); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; + } + return -ENODEV; } static int __init alsa_card_gusextreme_init(void) { - int i, cards, err; - - err = platform_driver_register(&snd_gusextreme_driver); - if (err < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(GUSEXTREME_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + static unsigned long possible_ports[] = {0x220, 0x240, 0x260, -1}; + int dev, cards, i; + + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev] > 0; dev++) { + if (port[dev] == SNDRV_AUTO_PORT) + continue; + if (snd_gusextreme_probe(dev) >= 0) + cards++; } + i = snd_legacy_auto_probe(possible_ports, snd_gusextreme_legacy_auto_probe); + if (i > 0) + cards += i; + if (!cards) { #ifdef MODULE printk(KERN_ERR "GUS Extreme soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_gusextreme_unregister_all(); - return err; } static void __exit alsa_card_gusextreme_exit(void) { - snd_gusextreme_unregister_all(); + int idx; + snd_card_t *card; + struct snd_gusextreme *acard; + + for (idx = 0; idx < SNDRV_CARDS; idx++) { + card = snd_gusextreme_cards[idx]; + if (card == NULL) + continue; + acard = (struct snd_gusextreme *)card->private_data; + snd_card_free(snd_gusextreme_cards[idx]); + } } module_init(alsa_card_gusextreme_init) diff --git a/trunk/sound/isa/gus/gusmax.c b/trunk/sound/isa/gus/gusmax.c index d4d2b2a517d5..0bb44b519340 100644 --- a/trunk/sound/isa/gus/gusmax.c +++ b/trunk/sound/isa/gus/gusmax.c @@ -20,16 +20,15 @@ */ #include <sound/driver.h> +#include <asm/dma.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/delay.h> #include <linux/time.h> #include <linux/moduleparam.h> -#include <asm/dma.h> #include <sound/core.h> #include <sound/gus.h> #include <sound/cs4231.h> +#define SNDRV_LEGACY_AUTO_PROBE #define SNDRV_LEGACY_FIND_FREE_IRQ #define SNDRV_LEGACY_FIND_FREE_DMA #include <sound/initval.h> @@ -72,20 +71,20 @@ MODULE_PARM_DESC(channels, "Used GF1 channels for GUS MAX driver."); module_param_array(pcm_channels, int, NULL, 0444); MODULE_PARM_DESC(pcm_channels, "Reserved PCM channels for GUS MAX driver."); -static struct platform_device *devices[SNDRV_CARDS]; - struct snd_gusmax { int irq; - struct snd_card *card; - struct snd_gus_card *gus; - struct snd_cs4231 *cs4231; + snd_card_t *card; + snd_gus_card_t *gus; + cs4231_t *cs4231; unsigned short gus_status_reg; unsigned short pcm_status_reg; }; +static snd_card_t *snd_gusmax_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; + #define PFX "gusmax: " -static int __init snd_gusmax_detect(struct snd_gus_card * gus) +static int __init snd_gusmax_detect(snd_gus_card_t * gus) { unsigned char d; @@ -127,7 +126,7 @@ static irqreturn_t snd_gusmax_interrupt(int irq, void *dev_id, struct pt_regs *r return IRQ_RETVAL(handled); } -static void __init snd_gusmax_init(int dev, struct snd_card *card, struct snd_gus_card * gus) +static void __init snd_gusmax_init(int dev, snd_card_t * card, snd_gus_card_t * gus) { gus->equal_irq = 1; gus->codec_flag = 1; @@ -145,10 +144,10 @@ static void __init snd_gusmax_init(int dev, struct snd_card *card, struct snd_gu #define CS4231_PRIVATE( left, right, shift, mute ) \ ((left << 24)|(right << 16)|(shift<<8)|mute) -static int __init snd_gusmax_mixer(struct snd_cs4231 *chip) +static int __init snd_gusmax_mixer(cs4231_t *chip) { - struct snd_card *card = chip->card; - struct snd_ctl_elem_id id1, id2; + snd_card_t *card = chip->card; + snd_ctl_elem_id_t id1, id2; int err; memset(&id1, 0, sizeof(id1)); @@ -194,7 +193,7 @@ static int __init snd_gusmax_mixer(struct snd_cs4231 *chip) return 0; } -static void snd_gusmax_free(struct snd_card *card) +static void snd_gusmax_free(snd_card_t *card) { struct snd_gusmax *maxcard = (struct snd_gusmax *)card->private_data; @@ -204,15 +203,14 @@ static void snd_gusmax_free(struct snd_card *card) free_irq(maxcard->irq, (void *)maxcard); } -static int __init snd_gusmax_probe(struct platform_device *pdev) +static int __init snd_gusmax_probe(int dev) { - int dev = pdev->id; static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1}; static int possible_dmas[] = {5, 6, 7, 1, 3, -1}; int xirq, xdma1, xdma2, err; - struct snd_card *card; - struct snd_gus_card *gus = NULL; - struct snd_cs4231 *cs4231; + snd_card_t *card; + snd_gus_card_t *gus = NULL; + cs4231_t *cs4231; struct snd_gusmax *maxcard; card = snd_card_new(index[dev], id[dev], THIS_MODULE, @@ -249,32 +247,12 @@ static int __init snd_gusmax_probe(struct platform_device *pdev) } } - if (port[dev] != SNDRV_AUTO_PORT) { - err = snd_gus_create(card, - port[dev], - -xirq, xdma1, xdma2, - 0, channels[dev], - pcm_channels[dev], - 0, &gus); - } else { - static unsigned long possible_ports[] = { - 0x220, 0x230, 0x240, 0x250, 0x260 - }; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - err = snd_gus_create(card, - possible_ports[i], - -xirq, xdma1, xdma2, - 0, channels[dev], - pcm_channels[dev], - 0, &gus); - if (err >= 0) { - port[dev] = possible_ports[i]; - break; - } - } - } - if (err < 0) + if ((err = snd_gus_create(card, + port[dev], + -xirq, xdma1, xdma2, + 0, channels[dev], + pcm_channels[dev], + 0, &gus)) < 0) goto _err; if ((err = snd_gusmax_detect(gus)) < 0) @@ -332,15 +310,15 @@ static int __init snd_gusmax_probe(struct platform_device *pdev) if (xdma2 >= 0) sprintf(card->longname + strlen(card->longname), "&%i", xdma2); - snd_card_set_dev(card, &pdev->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; maxcard->gus = gus; maxcard->cs4231 = cs4231; - - platform_set_drvdata(pdev, card); + snd_gusmax_cards[dev] = card; return 0; _err: @@ -348,70 +326,53 @@ static int __init snd_gusmax_probe(struct platform_device *pdev) return err; } -static int snd_gusmax_remove(struct platform_device *devptr) +static int __init snd_gusmax_legacy_auto_probe(unsigned long xport) { - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define GUSMAX_DRIVER "snd_gusmax" - -static struct platform_driver snd_gusmax_driver = { - .probe = snd_gusmax_probe, - .remove = snd_gusmax_remove, - /* FIXME: suspend/resume */ - .driver = { - .name = GUSMAX_DRIVER - }, -}; - -static void __init_or_module snd_gusmax_unregister_all(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_gusmax_driver); + static int dev; + int res; + + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; + port[dev] = xport; + res = snd_gusmax_probe(dev); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; + } + return -ENODEV; } static int __init alsa_card_gusmax_init(void) { - int i, cards, err; - - err = platform_driver_register(&snd_gusmax_driver); - if (err < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(GUSMAX_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + static unsigned long possible_ports[] = {0x220, 0x230, 0x240, 0x250, 0x260, -1}; + int dev, cards, i; + + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev] > 0; dev++) { + if (port[dev] == SNDRV_AUTO_PORT) + continue; + if (snd_gusmax_probe(dev) >= 0) + cards++; } + i = snd_legacy_auto_probe(possible_ports, snd_gusmax_legacy_auto_probe); + if (i > 0) + cards += i; + if (!cards) { #ifdef MODULE printk(KERN_ERR "GUS MAX soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_gusmax_unregister_all(); - return err; } static void __exit alsa_card_gusmax_exit(void) { - snd_gusmax_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_gusmax_cards[idx]); } module_init(alsa_card_gusmax_init) diff --git a/trunk/sound/isa/gus/interwave.c b/trunk/sound/isa/gus/interwave.c index 9838d992b101..f703a9f4257c 100644 --- a/trunk/sound/isa/gus/interwave.c +++ b/trunk/sound/isa/gus/interwave.c @@ -23,20 +23,19 @@ */ #include <sound/driver.h> -#include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> +#include <asm/dma.h> #include <linux/delay.h> +#include <linux/init.h> #include <linux/slab.h> #include <linux/pnp.h> #include <linux/moduleparam.h> -#include <asm/dma.h> #include <sound/core.h> #include <sound/gus.h> #include <sound/cs4231.h> #ifdef SNDRV_STB #include <sound/tea6330t.h> #endif +#define SNDRV_LEGACY_AUTO_PROBE #define SNDRV_LEGACY_FIND_FREE_IRQ #define SNDRV_LEGACY_FIND_FREE_DMA #include <sound/initval.h> @@ -76,12 +75,8 @@ static int effect[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0}; #ifdef SNDRV_STB #define PFX "interwave-stb: " -#define INTERWAVE_DRIVER "snd_interwave_stb" -#define INTERWAVE_PNP_DRIVER "interwave-stb" #else #define PFX "interwave: " -#define INTERWAVE_DRIVER "snd_interwave" -#define INTERWAVE_PNP_DRIVER "interwave" #endif module_param_array(index, int, NULL, 0444); @@ -115,14 +110,11 @@ MODULE_PARM_DESC(pcm_channels, "Reserved PCM channels for InterWave driver."); module_param_array(effect, int, NULL, 0444); MODULE_PARM_DESC(effect, "Effects enable for InterWave driver."); -static struct platform_device *platform_devices[SNDRV_CARDS]; -static int pnp_registered; - struct snd_interwave { int irq; - struct snd_card *card; - struct snd_gus_card *gus; - struct snd_cs4231 *cs4231; + snd_card_t *card; + snd_gus_card_t *gus; + cs4231_t *cs4231; #ifdef SNDRV_STB struct resource *i2c_res; #endif @@ -136,6 +128,7 @@ struct snd_interwave { #endif }; +static snd_card_t *snd_interwave_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; #ifdef CONFIG_PNP @@ -167,7 +160,7 @@ MODULE_DEVICE_TABLE(pnp_card, snd_interwave_pnpids); #ifdef SNDRV_STB -static void snd_interwave_i2c_setlines(struct snd_i2c_bus *bus, int ctrl, int data) +static void snd_interwave_i2c_setlines(snd_i2c_bus_t *bus, int ctrl, int data) { unsigned long port = bus->private_value; @@ -178,7 +171,7 @@ static void snd_interwave_i2c_setlines(struct snd_i2c_bus *bus, int ctrl, int da udelay(10); } -static int snd_interwave_i2c_getclockline(struct snd_i2c_bus *bus) +static int snd_interwave_i2c_getclockline(snd_i2c_bus_t *bus) { unsigned long port = bus->private_value; unsigned char res; @@ -190,7 +183,7 @@ static int snd_interwave_i2c_getclockline(struct snd_i2c_bus *bus) return res; } -static int snd_interwave_i2c_getdataline(struct snd_i2c_bus *bus, int ack) +static int snd_interwave_i2c_getdataline(snd_i2c_bus_t *bus, int ack) { unsigned long port = bus->private_value; unsigned char res; @@ -204,19 +197,19 @@ static int snd_interwave_i2c_getdataline(struct snd_i2c_bus *bus, int ack) return res; } -static struct snd_i2c_bit_ops snd_interwave_i2c_bit_ops = { +static snd_i2c_bit_ops_t snd_interwave_i2c_bit_ops = { .setlines = snd_interwave_i2c_setlines, .getclock = snd_interwave_i2c_getclockline, .getdata = snd_interwave_i2c_getdataline, }; static int __devinit snd_interwave_detect_stb(struct snd_interwave *iwcard, - struct snd_gus_card * gus, int dev, - struct snd_i2c_bus **rbus) + snd_gus_card_t * gus, int dev, + snd_i2c_bus_t **rbus) { unsigned long port; - struct snd_i2c_bus *bus; - struct snd_card *card = iwcard->card; + snd_i2c_bus_t *bus; + snd_card_t *card = iwcard->card; char name[32]; int err; @@ -253,10 +246,10 @@ static int __devinit snd_interwave_detect_stb(struct snd_interwave *iwcard, #endif static int __devinit snd_interwave_detect(struct snd_interwave *iwcard, - struct snd_gus_card * gus, + snd_gus_card_t * gus, int dev #ifdef SNDRV_STB - , struct snd_i2c_bus **rbus + , snd_i2c_bus_t **rbus #endif ) { @@ -321,7 +314,7 @@ static irqreturn_t snd_interwave_interrupt(int irq, void *dev_id, struct pt_regs return IRQ_RETVAL(handled); } -static void __devinit snd_interwave_reset(struct snd_gus_card * gus) +static void __devinit snd_interwave_reset(snd_gus_card_t * gus) { snd_gf1_write8(gus, SNDRV_GF1_GB_RESET, 0x00); udelay(160); @@ -329,7 +322,7 @@ static void __devinit snd_interwave_reset(struct snd_gus_card * gus) udelay(160); } -static void __devinit snd_interwave_bank_sizes(struct snd_gus_card * gus, int *sizes) +static void __devinit snd_interwave_bank_sizes(snd_gus_card_t * gus, int *sizes) { unsigned int idx; unsigned int local; @@ -378,7 +371,7 @@ struct rom_hdr { /* 511 */ unsigned char csum; }; -static void __devinit snd_interwave_detect_memory(struct snd_gus_card * gus) +static void __devinit snd_interwave_detect_memory(snd_gus_card_t * gus) { static unsigned int lmc[13] = { @@ -477,7 +470,7 @@ static void __devinit snd_interwave_detect_memory(struct snd_gus_card * gus) snd_interwave_reset(gus); } -static void __devinit snd_interwave_init(int dev, struct snd_gus_card * gus) +static void __devinit snd_interwave_init(int dev, snd_gus_card_t * gus) { unsigned long flags; @@ -499,17 +492,17 @@ static void __devinit snd_interwave_init(int dev, struct snd_gus_card * gus) } -static struct snd_kcontrol_new snd_interwave_controls[] = { +static snd_kcontrol_new_t snd_interwave_controls[] = { CS4231_DOUBLE("Master Playback Switch", 0, CS4231_LINE_LEFT_OUTPUT, CS4231_LINE_RIGHT_OUTPUT, 7, 7, 1, 1), CS4231_DOUBLE("Master Playback Volume", 0, CS4231_LINE_LEFT_OUTPUT, CS4231_LINE_RIGHT_OUTPUT, 0, 0, 31, 1), CS4231_DOUBLE("Mic Playback Switch", 0, CS4231_LEFT_MIC_INPUT, CS4231_RIGHT_MIC_INPUT, 7, 7, 1, 1), CS4231_DOUBLE("Mic Playback Volume", 0, CS4231_LEFT_MIC_INPUT, CS4231_RIGHT_MIC_INPUT, 0, 0, 31, 1) }; -static int __devinit snd_interwave_mixer(struct snd_cs4231 *chip) +static int __devinit snd_interwave_mixer(cs4231_t *chip) { - struct snd_card *card = chip->card; - struct snd_ctl_elem_id id1, id2; + snd_card_t *card = chip->card; + snd_ctl_elem_id_t id1, id2; unsigned int idx; int err; @@ -638,9 +631,9 @@ static int __devinit snd_interwave_pnp(int dev, struct snd_interwave *iwcard, } #endif /* CONFIG_PNP */ -static void snd_interwave_free(struct snd_card *card) +static void snd_interwave_free(snd_card_t *card) { - struct snd_interwave *iwcard = card->private_data; + struct snd_interwave *iwcard = (struct snd_interwave *)card->private_data; if (iwcard == NULL) return; @@ -651,52 +644,76 @@ static void snd_interwave_free(struct snd_card *card) free_irq(iwcard->irq, (void *)iwcard); } -static struct snd_card *snd_interwave_card_new(int dev) +static int __devinit snd_interwave_probe(int dev, struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { - struct snd_card *card; + static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1}; + static int possible_dmas[] = {0, 1, 3, 5, 6, 7, -1}; + int xirq, xdma1, xdma2; + snd_card_t *card; struct snd_interwave *iwcard; + cs4231_t *cs4231; + snd_gus_card_t *gus; +#ifdef SNDRV_STB + snd_i2c_bus_t *i2c_bus; +#endif + snd_pcm_t *pcm; + char *str; + int err; card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_interwave)); if (card == NULL) - return NULL; - iwcard = card->private_data; + return -ENOMEM; + iwcard = (struct snd_interwave *)card->private_data; iwcard->card = card; iwcard->irq = -1; card->private_free = snd_interwave_free; - return card; -} - -static int __devinit snd_interwave_probe(struct snd_card *card, int dev) -{ - int xirq, xdma1, xdma2; - struct snd_interwave *iwcard = card->private_data; - struct snd_cs4231 *cs4231; - struct snd_gus_card *gus; -#ifdef SNDRV_STB - struct snd_i2c_bus *i2c_bus; +#ifdef CONFIG_PNP + if (isapnp[dev]) { + if ((err = snd_interwave_pnp(dev, iwcard, pcard, pid)) < 0) + goto _err; + snd_card_set_dev(card, &pcard->card->dev); + } #endif - struct snd_pcm *pcm; - char *str; - int err; - xirq = irq[dev]; + if (xirq == SNDRV_AUTO_IRQ) { + if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); + err = -EBUSY; + goto _err; + } + } xdma1 = dma1[dev]; + if (xdma1 == SNDRV_AUTO_DMA) { + if ((xdma1 = snd_legacy_find_free_dma(possible_dmas)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free DMA1\n"); + err = -EBUSY; + goto _err; + } + } xdma2 = dma2[dev]; + if (xdma2 == SNDRV_AUTO_DMA) { + if ((xdma2 = snd_legacy_find_free_dma(possible_dmas)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free DMA2\n"); + err = -EBUSY; + goto _err; + } + } if ((err = snd_gus_create(card, port[dev], -xirq, xdma1, xdma2, 0, 32, pcm_channels[dev], effect[dev], &gus)) < 0) - return err; + goto _err; if ((err = snd_interwave_detect(iwcard, gus, dev #ifdef SNDRV_STB , &i2c_bus #endif )) < 0) - return err; + goto _err; iwcard->gus_status_reg = gus->gf1.reg_irqstat; iwcard->pcm_status_reg = gus->gf1.port + 0x10c + 2; @@ -704,12 +721,12 @@ static int __devinit snd_interwave_probe(struct snd_card *card, int dev) snd_interwave_init(dev, gus); snd_interwave_detect_memory(gus); if ((err = snd_gus_initialize(gus)) < 0) - return err; + goto _err; - if (request_irq(xirq, snd_interwave_interrupt, SA_INTERRUPT, - "InterWave", iwcard)) { + if (request_irq(xirq, snd_interwave_interrupt, SA_INTERRUPT, "InterWave", (void *)iwcard)) { snd_printk(KERN_ERR PFX "unable to grab IRQ %d\n", xirq); - return -EBUSY; + err = -EBUSY; + goto _err; } iwcard->irq = xirq; @@ -721,30 +738,30 @@ static int __devinit snd_interwave_probe(struct snd_card *card, int dev) CS4231_HWSHARE_DMA1 | CS4231_HWSHARE_DMA2, &cs4231)) < 0) - return err; + goto _err; if ((err = snd_cs4231_pcm(cs4231, 0, &pcm)) < 0) - return err; + goto _err; sprintf(pcm->name + strlen(pcm->name), " rev %c", gus->revision + 'A'); strcat(pcm->name, " (codec)"); if ((err = snd_cs4231_timer(cs4231, 2, NULL)) < 0) - return err; + goto _err; if ((err = snd_cs4231_mixer(cs4231)) < 0) - return err; + goto _err; if (pcm_channels[dev] > 0) { if ((err = snd_gf1_pcm_new(gus, 1, 1, NULL)) < 0) - return err; + goto _err; } if ((err = snd_interwave_mixer(cs4231)) < 0) - return err; + goto _err; #ifdef SNDRV_STB { - struct snd_ctl_elem_id id1, id2; + snd_ctl_elem_id_t id1, id2; memset(&id1, 0, sizeof(id1)); memset(&id2, 0, sizeof(id2)); id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER; @@ -752,19 +769,19 @@ static int __devinit snd_interwave_probe(struct snd_card *card, int dev) strcpy(id2.name, id1.name); id2.index = 1; if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) - return err; + goto _err; strcpy(id1.name, "Master Playback Volume"); strcpy(id2.name, id1.name); if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) - return err; + goto _err; if ((err = snd_tea6330t_update_mixer(card, i2c_bus, 0, 1)) < 0) - return err; + goto _err; } #endif gus->uart_enable = midi[dev]; if ((err = snd_gf1_rawmidi_new(gus, 0, NULL)) < 0) - return err; + goto _err; #ifndef SNDRV_STB str = "AMD InterWave"; @@ -783,198 +800,139 @@ static int __devinit snd_interwave_probe(struct snd_card *card, int dev) if (xdma2 >= 0) sprintf(card->longname + strlen(card->longname), "&%d", xdma2); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; + if ((err = snd_card_register(card)) < 0) - return err; + goto _err; iwcard->cs4231 = cs4231; iwcard->gus = gus; + if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_interwave_legacy[dev++] = card; return 0; -} - -static int __init snd_interwave_nonpnp_probe1(int dev, struct platform_device *devptr) -{ - struct snd_card *card; - int err; - - card = snd_interwave_card_new(dev); - if (! card) - return -ENOMEM; - snd_card_set_dev(card, &devptr->dev); - if ((err = snd_interwave_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - platform_set_drvdata(devptr, card); - return 0; + _err: + snd_card_free(card); + return err; } -static int __init snd_interwave_nonpnp_probe(struct platform_device *pdev) +static int __devinit snd_interwave_probe_legacy_port(unsigned long xport) { - int dev = pdev->id; - int err; - static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1}; - static int possible_dmas[] = {0, 1, 3, 5, 6, 7, -1}; - - if (irq[dev] == SNDRV_AUTO_IRQ) { - if ((irq[dev] = snd_legacy_find_free_irq(possible_irqs)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); - return -EBUSY; - } - } - if (dma1[dev] == SNDRV_AUTO_DMA) { - if ((dma1[dev] = snd_legacy_find_free_dma(possible_dmas)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free DMA1\n"); - return -EBUSY; - } - } - if (dma2[dev] == SNDRV_AUTO_DMA) { - if ((dma2[dev] = snd_legacy_find_free_dma(possible_dmas)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free DMA2\n"); - return -EBUSY; - } - } + static int dev; + int res; - if (port[dev] != SNDRV_AUTO_PORT) - return snd_interwave_nonpnp_probe1(dev, pdev); - else { - static long possible_ports[] = {0x210, 0x220, 0x230, 0x240, 0x250, 0x260}; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - port[dev] = possible_ports[i]; - err = snd_interwave_nonpnp_probe1(dev, pdev); - if (! err) - return 0; - } - return err; + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; +#ifdef CONFIG_PNP + if (isapnp[dev]) + continue; +#endif + port[dev] = xport; + res = snd_interwave_probe(dev, NULL, NULL); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; } + return -ENODEV; } -static int __devexit snd_interwave_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -static struct platform_driver snd_interwave_driver = { - .probe = snd_interwave_nonpnp_probe, - .remove = __devexit_p(snd_interwave_nonpnp_remove), - /* FIXME: suspend,resume */ - .driver = { - .name = INTERWAVE_DRIVER - }, -}; - #ifdef CONFIG_PNP -static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *pcard, - const struct pnp_card_device_id *pid) +static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *card, + const struct pnp_card_device_id *id) { static int dev; - struct snd_card *card; int res; for ( ; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_interwave_card_new(dev); - if (! card) - return -ENOMEM; - - if ((res = snd_interwave_pnp(dev, card->private_data, pcard, pid)) < 0) { - snd_card_free(card); - return res; - } - snd_card_set_dev(card, &pcard->card->dev); - if ((res = snd_interwave_probe(card, dev)) < 0) { - snd_card_free(card); - return res; - } - pnp_set_card_drvdata(pcard, card); - dev++; - return 0; + if (!enable[dev] || !isapnp[dev]) + continue; + res = snd_interwave_probe(dev, card, id); + if (res < 0) + return res; + dev++; + return 0; + } + + return -ENODEV; } static void __devexit snd_interwave_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + + snd_card_disconnect(card); + snd_card_free_in_thread(card); } static struct pnp_card_driver interwave_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, - .name = INTERWAVE_PNP_DRIVER, + .name = "interwave", .id_table = snd_interwave_pnpids, .probe = snd_interwave_pnp_detect, .remove = __devexit_p(snd_interwave_pnp_remove), - /* FIXME: suspend,resume */ }; #endif /* CONFIG_PNP */ -static void __init_or_module snd_interwave_unregister_all(void) -{ - int i; - - if (pnp_registered) - pnp_unregister_card_driver(&interwave_pnpc_driver); - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_interwave_driver); -} - static int __init alsa_card_interwave_init(void) { - int i, err, cards = 0; - - if ((err = platform_driver_register(&snd_interwave_driver)) < 0) - return err; + int cards = 0, i; + static long possible_ports[] = {0x210, 0x220, 0x230, 0x240, 0x250, 0x260, -1}; + int dev; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT) + continue; #ifdef CONFIG_PNP - if (isapnp[i]) + if (isapnp[dev]) continue; #endif - device = platform_device_register_simple(INTERWAVE_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; + if (!snd_interwave_probe(dev, NULL, NULL)) { + cards++; + continue; } - platform_devices[i] = device; - cards++; +#ifdef MODULE + printk(KERN_ERR "InterWave soundcard #%i not found at 0x%lx or device busy\n", dev, port[dev]); +#endif } - + /* legacy auto configured cards */ + i = snd_legacy_auto_probe(possible_ports, snd_interwave_probe_legacy_port); + if (i > 0) + cards += i; +#ifdef CONFIG_PNP /* ISA PnP cards */ i = pnp_register_card_driver(&interwave_pnpc_driver); - if (i >= 0) { - pnp_registered = 1; + if (i > 0) cards += i; - } +#endif if (!cards) { +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&interwave_pnpc_driver); +#endif #ifdef MODULE printk(KERN_ERR "InterWave soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_interwave_unregister_all(); - return err; } static void __exit alsa_card_interwave_exit(void) { - snd_interwave_unregister_all(); + int dev; + +#ifdef CONFIG_PNP + /* PnP cards first */ + pnp_unregister_card_driver(&interwave_pnpc_driver); +#endif + for (dev = 0; dev < SNDRV_CARDS; dev++) + snd_card_free(snd_interwave_legacy[dev]); } module_init(alsa_card_interwave_init) diff --git a/trunk/sound/isa/opl3sa2.c b/trunk/sound/isa/opl3sa2.c index ca359e0c674b..47cabda792b6 100644 --- a/trunk/sound/isa/opl3sa2.c +++ b/trunk/sound/isa/opl3sa2.c @@ -21,8 +21,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/interrupt.h> #include <linux/pm.h> #include <linux/slab.h> @@ -90,10 +88,6 @@ MODULE_PARM_DESC(dma2, "DMA2 # for OPL3-SA driver."); module_param_array(opl3sa3_ymode, int, NULL, 0444); MODULE_PARM_DESC(opl3sa3_ymode, "Speaker size selection for 3D Enhancement mode: Desktop/Large Notebook/Small Notebook/HiFi."); -static struct platform_device *platform_devices[SNDRV_CARDS]; -static int pnp_registered; -static int pnpc_registered; - /* control ports */ #define OPL3SA2_PM_CTRL 0x01 #define OPL3SA2_SYS_CTRL 0x02 @@ -121,23 +115,34 @@ static int pnpc_registered; #define OPL3SA2_PM_D0 0x00 #define OPL3SA2_PM_D3 (OPL3SA2_PM_ADOWN|OPL3SA2_PM_PSV|OPL3SA2_PM_PDN|OPL3SA2_PM_PDX) +typedef struct snd_opl3sa2 opl3sa2_t; + struct snd_opl3sa2 { - struct snd_card *card; + snd_card_t *card; int version; /* 2 or 3 */ unsigned long port; /* control port */ struct resource *res_port; /* control port resource */ int irq; int single_dma; spinlock_t reg_lock; - struct snd_hwdep *synth; - struct snd_rawmidi *rmidi; - struct snd_cs4231 *cs4231; + snd_hwdep_t *synth; + snd_rawmidi_t *rmidi; + cs4231_t *cs4231; +#ifdef CONFIG_PNP + struct pnp_dev *dev; +#endif unsigned char ctlregs[0x20]; int ymode; /* SL added */ - struct snd_kcontrol *master_switch; - struct snd_kcontrol *master_volume; + snd_kcontrol_t *master_switch; + snd_kcontrol_t *master_volume; +#ifdef CONFIG_PM + void (*cs4231_suspend)(cs4231_t *); + void (*cs4231_resume)(cs4231_t *); +#endif }; +static snd_card_t *snd_opl3sa2_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; + #define PFX "opl3sa2: " #ifdef CONFIG_PNP @@ -171,7 +176,7 @@ MODULE_DEVICE_TABLE(pnp_card, snd_opl3sa2_pnpids); /* read control port (w/o spinlock) */ -static unsigned char __snd_opl3sa2_read(struct snd_opl3sa2 *chip, unsigned char reg) +static unsigned char __snd_opl3sa2_read(opl3sa2_t *chip, unsigned char reg) { unsigned char result; #if 0 @@ -187,7 +192,7 @@ static unsigned char __snd_opl3sa2_read(struct snd_opl3sa2 *chip, unsigned char } /* read control port (with spinlock) */ -static unsigned char snd_opl3sa2_read(struct snd_opl3sa2 *chip, unsigned char reg) +static unsigned char snd_opl3sa2_read(opl3sa2_t *chip, unsigned char reg) { unsigned long flags; unsigned char result; @@ -199,7 +204,7 @@ static unsigned char snd_opl3sa2_read(struct snd_opl3sa2 *chip, unsigned char re } /* write control port (w/o spinlock) */ -static void __snd_opl3sa2_write(struct snd_opl3sa2 *chip, unsigned char reg, unsigned char value) +static void __snd_opl3sa2_write(opl3sa2_t *chip, unsigned char reg, unsigned char value) { #if 0 outb(0x1d, port); /* password */ @@ -210,7 +215,7 @@ static void __snd_opl3sa2_write(struct snd_opl3sa2 *chip, unsigned char reg, uns } /* write control port (with spinlock) */ -static void snd_opl3sa2_write(struct snd_opl3sa2 *chip, unsigned char reg, unsigned char value) +static void snd_opl3sa2_write(opl3sa2_t *chip, unsigned char reg, unsigned char value) { unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -218,9 +223,9 @@ static void snd_opl3sa2_write(struct snd_opl3sa2 *chip, unsigned char reg, unsig spin_unlock_irqrestore(&chip->reg_lock, flags); } -static int __init snd_opl3sa2_detect(struct snd_opl3sa2 *chip) +static int __init snd_opl3sa2_detect(opl3sa2_t *chip) { - struct snd_card *card; + snd_card_t *card; unsigned long port; unsigned char tmp, tmp1; char str[2]; @@ -293,7 +298,7 @@ static int __init snd_opl3sa2_detect(struct snd_opl3sa2 *chip) static irqreturn_t snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs) { unsigned short status; - struct snd_opl3sa2 *chip = dev_id; + opl3sa2_t *chip = dev_id; int handled = 0; if (chip == NULL || chip->card == NULL) @@ -335,7 +340,7 @@ static irqreturn_t snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs * .get = snd_opl3sa2_get_single, .put = snd_opl3sa2_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_opl3sa2_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_opl3sa2_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -346,9 +351,9 @@ static int snd_opl3sa2_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_opl3sa2_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opl3sa2_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opl3sa2 *chip = snd_kcontrol_chip(kcontrol); + opl3sa2_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -363,9 +368,9 @@ static int snd_opl3sa2_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_opl3sa2_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opl3sa2_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opl3sa2 *chip = snd_kcontrol_chip(kcontrol); + opl3sa2_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -393,7 +398,7 @@ static int snd_opl3sa2_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ .get = snd_opl3sa2_get_double, .put = snd_opl3sa2_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static int snd_opl3sa2_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_opl3sa2_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -404,9 +409,9 @@ static int snd_opl3sa2_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_opl3sa2_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opl3sa2_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opl3sa2 *chip = snd_kcontrol_chip(kcontrol); + opl3sa2_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -426,9 +431,9 @@ static int snd_opl3sa2_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_opl3sa2_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opl3sa2_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opl3sa2 *chip = snd_kcontrol_chip(kcontrol); + opl3sa2_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -466,31 +471,31 @@ static int snd_opl3sa2_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return change; } -static struct snd_kcontrol_new snd_opl3sa2_controls[] = { +static snd_kcontrol_new_t snd_opl3sa2_controls[] = { OPL3SA2_DOUBLE("Master Playback Switch", 0, 0x07, 0x08, 7, 7, 1, 1), OPL3SA2_DOUBLE("Master Playback Volume", 0, 0x07, 0x08, 0, 0, 15, 1), OPL3SA2_SINGLE("Mic Playback Switch", 0, 0x09, 7, 1, 1), OPL3SA2_SINGLE("Mic Playback Volume", 0, 0x09, 0, 31, 1) }; -static struct snd_kcontrol_new snd_opl3sa2_tone_controls[] = { +static snd_kcontrol_new_t snd_opl3sa2_tone_controls[] = { OPL3SA2_DOUBLE("3D Control - Wide", 0, 0x14, 0x14, 4, 0, 7, 0), OPL3SA2_DOUBLE("Tone Control - Bass", 0, 0x15, 0x15, 4, 0, 7, 0), OPL3SA2_DOUBLE("Tone Control - Treble", 0, 0x16, 0x16, 4, 0, 7, 0) }; -static void snd_opl3sa2_master_free(struct snd_kcontrol *kcontrol) +static void snd_opl3sa2_master_free(snd_kcontrol_t *kcontrol) { - struct snd_opl3sa2 *chip = snd_kcontrol_chip(kcontrol); + opl3sa2_t *chip = snd_kcontrol_chip(kcontrol); chip->master_switch = NULL; chip->master_volume = NULL; } -static int __init snd_opl3sa2_mixer(struct snd_opl3sa2 *chip) +static int __init snd_opl3sa2_mixer(opl3sa2_t *chip) { - struct snd_card *card = chip->card; - struct snd_ctl_elem_id id1, id2; - struct snd_kcontrol *kctl; + snd_card_t *card = chip->card; + snd_ctl_elem_id_t id1, id2; + snd_kcontrol_t *kctl; unsigned int idx; int err; @@ -500,29 +505,21 @@ static int __init snd_opl3sa2_mixer(struct snd_opl3sa2 *chip) /* reassign AUX0 to CD */ strcpy(id1.name, "Aux Playback Switch"); strcpy(id2.name, "CD Playback Switch"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) { - snd_printk(KERN_ERR "Cannot rename opl3sa2 control\n"); + if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) return err; - } strcpy(id1.name, "Aux Playback Volume"); strcpy(id2.name, "CD Playback Volume"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) { - snd_printk(KERN_ERR "Cannot rename opl3sa2 control\n"); + if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) return err; - } /* reassign AUX1 to FM */ strcpy(id1.name, "Aux Playback Switch"); id1.index = 1; strcpy(id2.name, "FM Playback Switch"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) { - snd_printk(KERN_ERR "Cannot rename opl3sa2 control\n"); + if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) return err; - } strcpy(id1.name, "Aux Playback Volume"); strcpy(id2.name, "FM Playback Volume"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) { - snd_printk(KERN_ERR "Cannot rename opl3sa2 control\n"); + if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) return err; - } /* add OPL3SA2 controls */ for (idx = 0; idx < ARRAY_SIZE(snd_opl3sa2_controls); idx++) { if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_opl3sa2_controls[idx], chip))) < 0) @@ -542,21 +539,22 @@ static int __init snd_opl3sa2_mixer(struct snd_opl3sa2 *chip) /* Power Management support functions */ #ifdef CONFIG_PM -static int snd_opl3sa2_suspend(struct snd_card *card, pm_message_t state) +static int snd_opl3sa2_suspend(snd_card_t *card, pm_message_t state) { - struct snd_opl3sa2 *chip = card->private_data; + opl3sa2_t *chip = card->pm_private_data; + + snd_pcm_suspend_all(chip->cs4231->pcm); /* stop before saving regs */ + chip->cs4231_suspend(chip->cs4231); - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - chip->cs4231->suspend(chip->cs4231); /* power down */ snd_opl3sa2_write(chip, OPL3SA2_PM_CTRL, OPL3SA2_PM_D3); return 0; } -static int snd_opl3sa2_resume(struct snd_card *card) +static int snd_opl3sa2_resume(snd_card_t *card) { - struct snd_opl3sa2 *chip = card->private_data; + opl3sa2_t *chip = card->pm_private_data; int i; /* power up */ @@ -572,25 +570,26 @@ static int snd_opl3sa2_resume(struct snd_card *card) snd_opl3sa2_write(chip, i, chip->ctlregs[i]); } /* restore cs4231 */ - chip->cs4231->resume(chip->cs4231); + chip->cs4231_resume(chip->cs4231); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ #ifdef CONFIG_PNP -static int __init snd_opl3sa2_pnp(int dev, struct snd_opl3sa2 *chip, - struct pnp_dev *pdev) +static int __init snd_opl3sa2_pnp(int dev, opl3sa2_t *chip, + struct pnp_dev *pdev, + int isapnp) { struct pnp_resource_table * cfg; int err; + if (!isapnp && pnp_device_is_isapnp(pdev)) + return -ENOENT; /* we have another procedure - card */ + cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL); - if (!cfg) { - snd_printk(KERN_ERR PFX "cannot allocate pnp cfg\n"); + if (!cfg) return -ENOMEM; - } /* PnP initialization */ pnp_init_resource_table(cfg); if (sb_port[dev] != SNDRV_AUTO_PORT) @@ -610,8 +609,8 @@ static int __init snd_opl3sa2_pnp(int dev, struct snd_opl3sa2 *chip, if (irq[dev] != SNDRV_AUTO_IRQ) pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1); err = pnp_manual_config_dev(pdev, cfg, 0); - if (err < 0) - snd_printk(KERN_WARNING "PnP manual resources are invalid, using auto config\n"); + if (err < 0 && isapnp) + snd_printk(KERN_ERR "PnP manual resources are invalid, using auto config\n"); err = pnp_activate_dev(pdev); if (err < 0) { kfree(cfg); @@ -631,47 +630,111 @@ static int __init snd_opl3sa2_pnp(int dev, struct snd_opl3sa2 *chip, snd_printdd("%sPnP OPL3-SA: control port=0x%lx, dma1=%i, dma2=%i, irq=%i\n", pnp_device_is_pnpbios(pdev) ? "BIOS" : "ISA", port[dev], dma1[dev], dma2[dev], irq[dev]); kfree(cfg); + chip->dev = pdev; return 0; } + +static int __init snd_opl3sa2_cpnp(int dev, opl3sa2_t *chip, + struct pnp_card_link *card, + const struct pnp_card_device_id *id) +{ + struct pnp_dev *pdev; + struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL); + + if (!cfg) + return -ENOMEM; + pdev = pnp_request_card_device(card, id->devs[0].id, NULL); + if (pdev == NULL) { + kfree(cfg); + return -EBUSY; + } + return snd_opl3sa2_pnp(dev, chip, pdev, 1); +} #endif /* CONFIG_PNP */ -static void snd_opl3sa2_free(struct snd_card *card) +static int snd_opl3sa2_free(opl3sa2_t *chip) { - struct snd_opl3sa2 *chip = card->private_data; if (chip->irq >= 0) free_irq(chip->irq, (void *)chip); release_and_free_resource(chip->res_port); + kfree(chip); + return 0; } -static struct snd_card *snd_opl3sa2_card_new(int dev) +static int snd_opl3sa2_dev_free(snd_device_t *device) +{ + opl3sa2_t *chip = device->device_data; + return snd_opl3sa2_free(chip); +} + +#ifdef CONFIG_PNP +#define is_isapnp_selected(dev) isapnp[dev] +#else +#define is_isapnp_selected(dev) 0 +#endif + +static int __devinit snd_opl3sa2_probe(int dev, + struct pnp_dev *pdev, + struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { - struct snd_card *card; + int xirq, xdma1, xdma2; + snd_card_t *card; struct snd_opl3sa2 *chip; + cs4231_t *cs4231; + opl3_t *opl3; + static snd_device_ops_t ops = { + .dev_free = snd_opl3sa2_dev_free, + }; + int err; + + if (! is_isapnp_selected(dev)) { + if (port[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR PFX "specify port\n"); + return -EINVAL; + } + if (wss_port[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR PFX "specify wss_port\n"); + return -EINVAL; + } + if (fm_port[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR PFX "specify fm_port\n"); + return -EINVAL; + } + if (midi_port[dev] == SNDRV_AUTO_PORT) { + snd_printk(KERN_ERR PFX "specify midi_port\n"); + return -EINVAL; + } + } - card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_opl3sa2)); + card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); if (card == NULL) - return NULL; + return -ENOMEM; strcpy(card->driver, "OPL3SA2"); strcpy(card->shortname, "Yamaha OPL3-SA2"); - chip = card->private_data; + chip = kzalloc(sizeof(*chip), GFP_KERNEL); + if (chip == NULL) { + err = -ENOMEM; + goto __error; + } spin_lock_init(&chip->reg_lock); chip->irq = -1; + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) + goto __error; +#ifdef CONFIG_PNP + if (pdev) { + if ((err = snd_opl3sa2_pnp(dev, chip, pdev, 0)) < 0) + goto __error; + snd_card_set_dev(card, &pdev->dev); + } + if (pcard) { + if ((err = snd_opl3sa2_cpnp(dev, chip, pcard, pid)) < 0) + goto __error; + snd_card_set_dev(card, &pcard->card->dev); + } +#endif + chip->ymode = opl3sa3_ymode[dev] & 0x03 ; /* initialise this card from supplied (or default) parameter*/ chip->card = card; - card->private_free = snd_opl3sa2_free; - return card; -} - -static int __devinit snd_opl3sa2_probe(struct snd_card *card, int dev) -{ - int xirq, xdma1, xdma2; - struct snd_opl3sa2 *chip; - struct snd_cs4231 *cs4231; - struct snd_opl3 *opl3; - int err; - - /* initialise this card from supplied (or default) parameter*/ - chip = card->private_data; - chip->ymode = opl3sa3_ymode[dev] & 0x03 ; chip->port = port[dev]; xirq = irq[dev]; xdma1 = dma1[dev]; @@ -679,10 +742,11 @@ static int __devinit snd_opl3sa2_probe(struct snd_card *card, int dev) if (xdma2 < 0) chip->single_dma = 1; if ((err = snd_opl3sa2_detect(chip)) < 0) - return err; - if (request_irq(xirq, snd_opl3sa2_interrupt, SA_INTERRUPT, "OPL3-SA2", chip)) { + goto __error; + if (request_irq(xirq, snd_opl3sa2_interrupt, SA_INTERRUPT, "OPL3-SA2", (void *)chip)) { snd_printk(KERN_ERR PFX "can't grab IRQ %d\n", xirq); - return -ENODEV; + err = -ENODEV; + goto __error; } chip->irq = xirq; if ((err = snd_cs4231_create(card, @@ -692,303 +756,179 @@ static int __devinit snd_opl3sa2_probe(struct snd_card *card, int dev) CS4231_HWSHARE_IRQ, &cs4231)) < 0) { snd_printd("Oops, WSS not detected at 0x%lx\n", wss_port[dev] + 4); - return err; + goto __error; } chip->cs4231 = cs4231; if ((err = snd_cs4231_pcm(cs4231, 0, NULL)) < 0) - return err; + goto __error; if ((err = snd_cs4231_mixer(cs4231)) < 0) - return err; + goto __error; if ((err = snd_opl3sa2_mixer(chip)) < 0) - return err; + goto __error; if ((err = snd_cs4231_timer(cs4231, 0, NULL)) < 0) - return err; + goto __error; if (fm_port[dev] >= 0x340 && fm_port[dev] < 0x400) { if ((err = snd_opl3_create(card, fm_port[dev], fm_port[dev] + 2, OPL3_HW_OPL3, 0, &opl3)) < 0) - return err; + goto __error; if ((err = snd_opl3_timer_new(opl3, 1, 2)) < 0) - return err; + goto __error; if ((err = snd_opl3_hwdep_new(opl3, 0, 1, &chip->synth)) < 0) - return err; + goto __error; } if (midi_port[dev] >= 0x300 && midi_port[dev] < 0x340) { if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_OPL3SA2, midi_port[dev], 0, xirq, 0, &chip->rmidi)) < 0) - return err; + goto __error; } +#ifdef CONFIG_PM + chip->cs4231_suspend = chip->cs4231->suspend; + chip->cs4231_resume = chip->cs4231->resume; + /* now clear callbacks for cs4231 */ + chip->cs4231->suspend = NULL; + chip->cs4231->resume = NULL; + snd_card_set_isa_pm_callback(card, snd_opl3sa2_suspend, snd_opl3sa2_resume, chip); +#endif + sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d", card->shortname, chip->port, xirq, xdma1); if (dma2 >= 0) sprintf(card->longname + strlen(card->longname), "&%d", xdma2); - return snd_card_register(card); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto __error; + + if ((err = snd_card_register(card)) < 0) + goto __error; + + if (pdev) + pnp_set_drvdata(pdev, card); + else if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_opl3sa2_legacy[dev] = card; + return 0; + + __error: + snd_card_free(card); + return err; } #ifdef CONFIG_PNP static int __devinit snd_opl3sa2_pnp_detect(struct pnp_dev *pdev, const struct pnp_device_id *id) { - static int dev; - int err; - struct snd_card *card; + static int dev; + int res; - if (pnp_device_is_isapnp(pdev)) - return -ENOENT; /* we have another procedure - card */ - for (; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_opl3sa2_card_new(dev); - if (! card) - return -ENOMEM; - if ((err = snd_opl3sa2_pnp(dev, card->private_data, pdev)) < 0) { - snd_card_free(card); - return err; - } - snd_card_set_dev(card, &pdev->dev); - if ((err = snd_opl3sa2_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - pnp_set_drvdata(pdev, card); - dev++; - return 0; + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || !isapnp[dev]) + continue; + res = snd_opl3sa2_probe(dev, pdev, NULL, NULL); + if (res < 0) + return res; + dev++; + return 0; + } + return -ENODEV; } static void __devexit snd_opl3sa2_pnp_remove(struct pnp_dev * pdev) { - snd_card_free(pnp_get_drvdata(pdev)); - pnp_set_drvdata(pdev, NULL); -} - -#ifdef CONFIG_PM -static int snd_opl3sa2_pnp_suspend(struct pnp_dev *pdev, pm_message_t state) -{ - return snd_opl3sa2_suspend(pnp_get_drvdata(pdev), state); + snd_card_t *card = (snd_card_t *) pnp_get_drvdata(pdev); + + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -static int snd_opl3sa2_pnp_resume(struct pnp_dev *pdev) -{ - return snd_opl3sa2_resume(pnp_get_drvdata(pdev)); -} -#endif static struct pnp_driver opl3sa2_pnp_driver = { .name = "opl3sa2-pnpbios", .id_table = snd_opl3sa2_pnpbiosids, .probe = snd_opl3sa2_pnp_detect, .remove = __devexit_p(snd_opl3sa2_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_opl3sa2_pnp_suspend, - .resume = snd_opl3sa2_pnp_resume, -#endif }; -static int __devinit snd_opl3sa2_pnp_cdetect(struct pnp_card_link *pcard, +static int __devinit snd_opl3sa2_pnp_cdetect(struct pnp_card_link *card, const struct pnp_card_device_id *id) { - static int dev; - struct pnp_dev *pdev; - int err; - struct snd_card *card; + static int dev; + int res; - pdev = pnp_request_card_device(pcard, id->devs[0].id, NULL); - if (pdev == NULL) { - snd_printk(KERN_ERR PFX "can't get pnp device from id '%s'\n", - id->devs[0].id); - return -EBUSY; - } - for (; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_opl3sa2_card_new(dev); - if (! card) - return -ENOMEM; - if ((err = snd_opl3sa2_pnp(dev, card->private_data, pdev)) < 0) { - snd_card_free(card); - return err; - } - snd_card_set_dev(card, &pdev->dev); - if ((err = snd_opl3sa2_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - pnp_set_card_drvdata(pcard, card); - dev++; - return 0; + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev]) + continue; + if (is_isapnp_selected(dev)) + continue; + res = snd_opl3sa2_probe(dev, NULL, card, id); + if (res < 0) + return res; + dev++; + return 0; + } + return -ENODEV; } static void __devexit snd_opl3sa2_pnp_cremove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -#ifdef CONFIG_PM -static int snd_opl3sa2_pnp_csuspend(struct pnp_card_link *pcard, pm_message_t state) -{ - return snd_opl3sa2_suspend(pnp_get_card_drvdata(pcard), state); -} -static int snd_opl3sa2_pnp_cresume(struct pnp_card_link *pcard) -{ - return snd_opl3sa2_resume(pnp_get_card_drvdata(pcard)); -} -#endif - static struct pnp_card_driver opl3sa2_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, .name = "opl3sa2", .id_table = snd_opl3sa2_pnpids, .probe = snd_opl3sa2_pnp_cdetect, .remove = __devexit_p(snd_opl3sa2_pnp_cremove), -#ifdef CONFIG_PM - .suspend = snd_opl3sa2_pnp_csuspend, - .resume = snd_opl3sa2_pnp_cresume, -#endif }; #endif /* CONFIG_PNP */ -static int __init snd_opl3sa2_nonpnp_probe(struct platform_device *pdev) -{ - struct snd_card *card; - int err; - int dev = pdev->id; - - if (port[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify port\n"); - return -EINVAL; - } - if (wss_port[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify wss_port\n"); - return -EINVAL; - } - if (fm_port[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify fm_port\n"); - return -EINVAL; - } - if (midi_port[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify midi_port\n"); - return -EINVAL; - } - - card = snd_opl3sa2_card_new(dev); - if (! card) - return -ENOMEM; - snd_card_set_dev(card, &pdev->dev); - if ((err = snd_opl3sa2_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - platform_set_drvdata(pdev, card); - return 0; -} - -static int snd_opl3sa2_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_opl3sa2_nonpnp_suspend(struct platform_device *dev, pm_message_t state) -{ - return snd_opl3sa2_suspend(platform_get_drvdata(dev), state); -} - -static int snd_opl3sa2_nonpnp_resume(struct platform_device *dev) -{ - return snd_opl3sa2_resume(platform_get_drvdata(dev)); -} -#endif - -#define OPL3SA2_DRIVER "snd_opl3sa2" - -static struct platform_driver snd_opl3sa2_nonpnp_driver = { - .probe = snd_opl3sa2_nonpnp_probe, - .remove = snd_opl3sa2_nonpnp_remove, -#ifdef CONFIG_PM - .suspend = snd_opl3sa2_nonpnp_suspend, - .resume = snd_opl3sa2_nonpnp_resume, -#endif - .driver = { - .name = OPL3SA2_DRIVER - }, -}; - -static void __init_or_module snd_opl3sa2_unregister_all(void) -{ - int i; - - if (pnpc_registered) - pnp_unregister_card_driver(&opl3sa2_pnpc_driver); - if (pnp_registered) - pnp_unregister_driver(&opl3sa2_pnp_driver); - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_opl3sa2_nonpnp_driver); -} - static int __init alsa_card_opl3sa2_init(void) { - int i, err, cards = 0; + int dev, cards = 0; - if ((err = platform_driver_register(&snd_opl3sa2_nonpnp_driver)) < 0) - return err; - - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev]) + continue; #ifdef CONFIG_PNP - if (isapnp[i]) + if (isapnp[dev]) continue; #endif - device = platform_device_register_simple(OPL3SA2_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - platform_devices[i] = device; - cards++; - } - - err = pnp_register_driver(&opl3sa2_pnp_driver); - if (err >= 0) { - pnp_registered = 1; - cards += err; + if (snd_opl3sa2_probe(dev, NULL, NULL, NULL) >= 0) + cards++; } - err = pnp_register_card_driver(&opl3sa2_pnpc_driver); - if (err >= 0) { - pnpc_registered = 1; - cards += err; - } - +#ifdef CONFIG_PNP + cards += pnp_register_driver(&opl3sa2_pnp_driver); + cards += pnp_register_card_driver(&opl3sa2_pnpc_driver); +#endif if (!cards) { #ifdef MODULE snd_printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&opl3sa2_pnpc_driver); + pnp_unregister_driver(&opl3sa2_pnp_driver); +#endif + return -ENODEV; } return 0; - - errout: - snd_opl3sa2_unregister_all(); - return err; } static void __exit alsa_card_opl3sa2_exit(void) { - snd_opl3sa2_unregister_all(); + int idx; + +#ifdef CONFIG_PNP + /* PnP cards first */ + pnp_unregister_card_driver(&opl3sa2_pnpc_driver); + pnp_unregister_driver(&opl3sa2_pnp_driver); +#endif + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_opl3sa2_legacy[idx]); } module_init(alsa_card_opl3sa2_init) diff --git a/trunk/sound/isa/opti9xx/opti92x-ad1848.c b/trunk/sound/isa/opti9xx/opti92x-ad1848.c index 1ea3944ef7ab..b94339f8306f 100644 --- a/trunk/sound/isa/opti9xx/opti92x-ad1848.c +++ b/trunk/sound/isa/opti9xx/opti92x-ad1848.c @@ -24,15 +24,13 @@ #include <sound/driver.h> -#include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> +#include <asm/io.h> +#include <asm/dma.h> #include <linux/delay.h> +#include <linux/init.h> #include <linux/slab.h> #include <linux/pnp.h> #include <linux/moduleparam.h> -#include <asm/io.h> -#include <asm/dma.h> #include <sound/core.h> #ifdef CS4231 #include <sound/cs4231.h> @@ -122,6 +120,8 @@ MODULE_PARM_DESC(dma2, "2nd dma # for opti9xx driver."); #define OPTi9XX_MC_REG(n) n +typedef struct _snd_opti9xx opti9xx_t; + #ifdef OPTi93X #define OPTi93X_INDEX 0x00 @@ -193,14 +193,16 @@ MODULE_PARM_DESC(dma2, "2nd dma # for opti9xx driver."); #define OPTi93X_IRQ_CAPTURE 0x08 -struct snd_opti93x { +typedef struct _snd_opti93x opti93x_t; + +struct _snd_opti93x { unsigned long port; struct resource *res_port; int irq; int dma1; int dma2; - struct snd_opti9xx *chip; + opti9xx_t *chip; unsigned short hardware; unsigned char image[32]; @@ -210,10 +212,10 @@ struct snd_opti93x { spinlock_t lock; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; unsigned int p_dma_size; unsigned int c_dma_size; }; @@ -225,7 +227,7 @@ struct snd_opti93x { #endif /* OPTi93X */ -struct snd_opti9xx { +struct _snd_opti9xx { unsigned short hardware; unsigned char password; char name[7]; @@ -258,8 +260,8 @@ struct snd_opti9xx { #endif /* CONFIG_PNP */ }; -static int snd_opti9xx_pnp_is_probed; -static struct platform_device *snd_opti9xx_platform_device; +static int snd_opti9xx_first_hit = 1; +static snd_card_t *snd_opti9xx_legacy = SNDRV_DEFAULT_PTR1; #ifdef CONFIG_PNP @@ -294,7 +296,7 @@ static char * snd_opti9xx_names[] = { }; -static long __init snd_legacy_find_free_ioport(long *port_table, long size) +static long snd_legacy_find_free_ioport(long *port_table, long size) { while (*port_table != -1) { if (request_region(*port_table, size, "ALSA test")) { @@ -306,7 +308,7 @@ static long __init snd_legacy_find_free_ioport(long *port_table, long size) return -1; } -static int __init snd_opti9xx_init(struct snd_opti9xx *chip, unsigned short hardware) +static int __devinit snd_opti9xx_init(opti9xx_t *chip, unsigned short hardware) { static int opti9xx_mc_size[] = {7, 7, 10, 10, 2, 2, 2}; @@ -361,7 +363,7 @@ static int __init snd_opti9xx_init(struct snd_opti9xx *chip, unsigned short hard return 0; } -static unsigned char snd_opti9xx_read(struct snd_opti9xx *chip, +static unsigned char snd_opti9xx_read(opti9xx_t *chip, unsigned char reg) { unsigned long flags; @@ -404,7 +406,7 @@ static unsigned char snd_opti9xx_read(struct snd_opti9xx *chip, return retval; } -static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg, +static void snd_opti9xx_write(opti9xx_t *chip, unsigned char reg, unsigned char value) { unsigned long flags; @@ -451,7 +453,7 @@ static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg, (snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask))) -static int __init snd_opti9xx_configure(struct snd_opti9xx *chip) +static int __devinit snd_opti9xx_configure(opti9xx_t *chip) { unsigned char wss_base_bits; unsigned char irq_bits; @@ -682,7 +684,7 @@ static unsigned char snd_opti93x_default_image[32] = }; -static int snd_opti93x_busy_wait(struct snd_opti93x *chip) +static int snd_opti93x_busy_wait(opti93x_t *chip) { int timeout; @@ -694,14 +696,14 @@ static int snd_opti93x_busy_wait(struct snd_opti93x *chip) return -EBUSY; } -static unsigned char snd_opti93x_in(struct snd_opti93x *chip, unsigned char reg) +static unsigned char snd_opti93x_in(opti93x_t *chip, unsigned char reg) { snd_opti93x_busy_wait(chip); outb(chip->mce_bit | (reg & 0x1f), OPTi93X_PORT(chip, INDEX)); return inb(OPTi93X_PORT(chip, DATA)); } -static void snd_opti93x_out(struct snd_opti93x *chip, unsigned char reg, +static void snd_opti93x_out(opti93x_t *chip, unsigned char reg, unsigned char value) { snd_opti93x_busy_wait(chip); @@ -709,13 +711,13 @@ static void snd_opti93x_out(struct snd_opti93x *chip, unsigned char reg, outb(value, OPTi93X_PORT(chip, DATA)); } -static void snd_opti93x_out_image(struct snd_opti93x *chip, unsigned char reg, +static void snd_opti93x_out_image(opti93x_t *chip, unsigned char reg, unsigned char value) { snd_opti93x_out(chip, reg, chip->image[reg] = value); } -static void snd_opti93x_out_mask(struct snd_opti93x *chip, unsigned char reg, +static void snd_opti93x_out_mask(opti93x_t *chip, unsigned char reg, unsigned char mask, unsigned char value) { snd_opti93x_out_image(chip, reg, @@ -723,7 +725,7 @@ static void snd_opti93x_out_mask(struct snd_opti93x *chip, unsigned char reg, } -static void snd_opti93x_mce_up(struct snd_opti93x *chip) +static void snd_opti93x_mce_up(opti93x_t *chip) { snd_opti93x_busy_wait(chip); @@ -732,7 +734,7 @@ static void snd_opti93x_mce_up(struct snd_opti93x *chip) outb(chip->mce_bit, OPTi93X_PORT(chip, INDEX)); } -static void snd_opti93x_mce_down(struct snd_opti93x *chip) +static void snd_opti93x_mce_down(opti93x_t *chip) { snd_opti93x_busy_wait(chip); @@ -744,7 +746,7 @@ static void snd_opti93x_mce_down(struct snd_opti93x *chip) #define snd_opti93x_mute_reg(chip, reg, mute) \ snd_opti93x_out(chip, reg, mute ? 0x80 : chip->image[reg]); -static void snd_opti93x_mute(struct snd_opti93x *chip, int mute) +static void snd_opti93x_mute(opti93x_t *chip, int mute) { mute = mute ? 1 : 0; if (chip->mute == mute) @@ -796,7 +798,7 @@ static unsigned int rates[] = { 5512, 6615, 8000, 9600, 11025, 16000, 44100, 48000 }; #define RATES ARRAY_SIZE(rates) -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = RATES, .list = rates, .mask = 0, @@ -818,7 +820,7 @@ static unsigned char snd_opti93x_get_freq(unsigned int rate) return bits[RATES-1]; } -static unsigned char snd_opti93x_get_format(struct snd_opti93x *chip, +static unsigned char snd_opti93x_get_format(opti93x_t *chip, unsigned int format, int channels) { unsigned char retval = OPTi93X_LINEAR_8; @@ -843,7 +845,7 @@ static unsigned char snd_opti93x_get_format(struct snd_opti93x *chip, } -static void snd_opti93x_playback_format(struct snd_opti93x *chip, unsigned char fmt) +static void snd_opti93x_playback_format(opti93x_t *chip, unsigned char fmt) { unsigned char mask; @@ -857,7 +859,7 @@ static void snd_opti93x_playback_format(struct snd_opti93x *chip, unsigned char snd_opti93x_mute(chip, 0); } -static void snd_opti93x_capture_format(struct snd_opti93x *chip, unsigned char fmt) +static void snd_opti93x_capture_format(opti93x_t *chip, unsigned char fmt) { snd_opti93x_mute(chip, 1); @@ -873,7 +875,7 @@ static void snd_opti93x_capture_format(struct snd_opti93x *chip, unsigned char f } -static int snd_opti93x_open(struct snd_opti93x *chip, unsigned int mode) +static int snd_opti93x_open(opti93x_t *chip, unsigned int mode) { unsigned long flags; @@ -897,7 +899,7 @@ static int snd_opti93x_open(struct snd_opti93x *chip, unsigned int mode) return 0; } -static void snd_opti93x_close(struct snd_opti93x *chip, unsigned int mode) +static void snd_opti93x_close(opti93x_t *chip, unsigned int mode) { unsigned long flags; @@ -924,10 +926,10 @@ static void snd_opti93x_close(struct snd_opti93x *chip, unsigned int mode) spin_unlock_irqrestore(&chip->lock, flags); } -static int snd_opti93x_trigger(struct snd_pcm_substream *substream, +static int snd_opti93x_trigger(snd_pcm_substream_t *substream, unsigned char what, int cmd) { - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); + opti93x_t *chip = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -935,7 +937,7 @@ static int snd_opti93x_trigger(struct snd_pcm_substream *substream, { unsigned int what = 0; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == chip->playback_substream) { @@ -962,36 +964,36 @@ static int snd_opti93x_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_opti93x_playback_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_opti93x_playback_trigger(snd_pcm_substream_t *substream, int cmd) { return snd_opti93x_trigger(substream, OPTi93X_PLAYBACK_ENABLE, cmd); } -static int snd_opti93x_capture_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_opti93x_capture_trigger(snd_pcm_substream_t * substream, int cmd) { return snd_opti93x_trigger(substream, OPTi93X_CAPTURE_ENABLE, cmd); } -static int snd_opti93x_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_opti93x_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_opti93x_hw_free(struct snd_pcm_substream *substream) +static int snd_opti93x_hw_free(snd_pcm_substream_t * substream) { snd_pcm_lib_free_pages(substream); return 0; } -static int snd_opti93x_playback_prepare(struct snd_pcm_substream *substream) +static int snd_opti93x_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + opti93x_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; unsigned char format; unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -1021,10 +1023,10 @@ static int snd_opti93x_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_opti93x_capture_prepare(struct snd_pcm_substream *substream) +static int snd_opti93x_capture_prepare(snd_pcm_substream_t *substream) { - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + opti93x_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; unsigned char format; unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -1053,9 +1055,9 @@ static int snd_opti93x_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_opti93x_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_opti93x_playback_pointer(snd_pcm_substream_t *substream) { - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); + opti93x_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->image[OPTi93X_IFACE_CONF] & OPTi93X_PLAYBACK_ENABLE)) @@ -1065,9 +1067,9 @@ static snd_pcm_uframes_t snd_opti93x_playback_pointer(struct snd_pcm_substream * return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_opti93x_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_opti93x_capture_pointer(snd_pcm_substream_t *substream) { - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); + opti93x_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->image[OPTi93X_IFACE_CONF] & OPTi93X_CAPTURE_ENABLE)) @@ -1078,7 +1080,7 @@ static snd_pcm_uframes_t snd_opti93x_capture_pointer(struct snd_pcm_substream *s } -static void snd_opti93x_overrange(struct snd_opti93x *chip) +static void snd_opti93x_overrange(opti93x_t *chip) { unsigned long flags; @@ -1092,7 +1094,7 @@ static void snd_opti93x_overrange(struct snd_opti93x *chip) static irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_opti93x *codec = dev_id; + opti93x_t *codec = dev_id; unsigned char status; status = snd_opti9xx_read(codec->chip, OPTi9XX_MC_REG(11)); @@ -1107,7 +1109,7 @@ static irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs * } -static struct snd_pcm_hardware snd_opti93x_playback = { +static snd_pcm_hardware_t snd_opti93x_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM | @@ -1125,7 +1127,7 @@ static struct snd_pcm_hardware snd_opti93x_playback = { .fifo_size = 0, }; -static struct snd_pcm_hardware snd_opti93x_capture = { +static snd_pcm_hardware_t snd_opti93x_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM | @@ -1143,11 +1145,11 @@ static struct snd_pcm_hardware snd_opti93x_capture = { .fifo_size = 0, }; -static int snd_opti93x_playback_open(struct snd_pcm_substream *substream) +static int snd_opti93x_playback_open(snd_pcm_substream_t *substream) { int error; - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + opti93x_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if ((error = snd_opti93x_open(chip, OPTi93X_MODE_PLAY)) < 0) return error; @@ -1159,11 +1161,11 @@ static int snd_opti93x_playback_open(struct snd_pcm_substream *substream) return error; } -static int snd_opti93x_capture_open(struct snd_pcm_substream *substream) +static int snd_opti93x_capture_open(snd_pcm_substream_t *substream) { int error; - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + opti93x_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if ((error = snd_opti93x_open(chip, OPTi93X_MODE_CAPTURE)) < 0) return error; @@ -1175,18 +1177,18 @@ static int snd_opti93x_capture_open(struct snd_pcm_substream *substream) return error; } -static int snd_opti93x_playback_close(struct snd_pcm_substream *substream) +static int snd_opti93x_playback_close(snd_pcm_substream_t *substream) { - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); + opti93x_t *chip = snd_pcm_substream_chip(substream); chip->playback_substream = NULL; snd_opti93x_close(chip, OPTi93X_MODE_PLAY); return 0; } -static int snd_opti93x_capture_close(struct snd_pcm_substream *substream) +static int snd_opti93x_capture_close(snd_pcm_substream_t *substream) { - struct snd_opti93x *chip = snd_pcm_substream_chip(substream); + opti93x_t *chip = snd_pcm_substream_chip(substream); chip->capture_substream = NULL; snd_opti93x_close(chip, OPTi93X_MODE_CAPTURE); @@ -1194,7 +1196,7 @@ static int snd_opti93x_capture_close(struct snd_pcm_substream *substream) } -static void snd_opti93x_init(struct snd_opti93x *chip) +static void snd_opti93x_init(opti93x_t *chip) { unsigned long flags; int i; @@ -1209,7 +1211,7 @@ static void snd_opti93x_init(struct snd_opti93x *chip) spin_unlock_irqrestore(&chip->lock, flags); } -static int snd_opti93x_probe(struct snd_opti93x *chip) +static int snd_opti93x_probe(opti93x_t *chip) { unsigned long flags; unsigned char val; @@ -1221,7 +1223,7 @@ static int snd_opti93x_probe(struct snd_opti93x *chip) return (val == 0x0a) ? 0 : -ENODEV; } -static int snd_opti93x_free(struct snd_opti93x *chip) +static int snd_opti93x_free(opti93x_t *chip) { release_and_free_resource(chip->res_port); if (chip->dma1 >= 0) { @@ -1239,13 +1241,13 @@ static int snd_opti93x_free(struct snd_opti93x *chip) return 0; } -static int snd_opti93x_dev_free(struct snd_device *device) +static int snd_opti93x_dev_free(snd_device_t *device) { - struct snd_opti93x *chip = device->device_data; + opti93x_t *chip = device->device_data; return snd_opti93x_free(chip); } -static const char *snd_opti93x_chip_id(struct snd_opti93x *codec) +static const char *snd_opti93x_chip_id(opti93x_t *codec) { switch (codec->hardware) { case OPTi9XX_HW_82C930: return "82C930"; @@ -1255,15 +1257,15 @@ static const char *snd_opti93x_chip_id(struct snd_opti93x *codec) } } -static int snd_opti93x_create(struct snd_card *card, struct snd_opti9xx *chip, +static int snd_opti93x_create(snd_card_t *card, opti9xx_t *chip, int dma1, int dma2, - struct snd_opti93x **rcodec) + opti93x_t **rcodec) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_opti93x_dev_free, }; int error; - struct snd_opti93x *codec; + opti93x_t *codec; *rcodec = NULL; codec = kzalloc(sizeof(*codec), GFP_KERNEL); @@ -1322,7 +1324,7 @@ static int snd_opti93x_create(struct snd_card *card, struct snd_opti9xx *chip, return 0; } -static struct snd_pcm_ops snd_opti93x_playback_ops = { +static snd_pcm_ops_t snd_opti93x_playback_ops = { .open = snd_opti93x_playback_open, .close = snd_opti93x_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1333,7 +1335,7 @@ static struct snd_pcm_ops snd_opti93x_playback_ops = { .pointer = snd_opti93x_playback_pointer, }; -static struct snd_pcm_ops snd_opti93x_capture_ops = { +static snd_pcm_ops_t snd_opti93x_capture_ops = { .open = snd_opti93x_capture_open, .close = snd_opti93x_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1344,10 +1346,17 @@ static struct snd_pcm_ops snd_opti93x_capture_ops = { .pointer = snd_opti93x_capture_pointer, }; -static int snd_opti93x_pcm(struct snd_opti93x *codec, int device, struct snd_pcm **rpcm) +static void snd_opti93x_pcm_free(snd_pcm_t *pcm) +{ + opti93x_t *codec = pcm->private_data; + codec->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int snd_opti93x_pcm(opti93x_t *codec, int device, snd_pcm_t **rpcm) { int error; - struct snd_pcm *pcm; + snd_pcm_t *pcm; if ((error = snd_pcm_new(codec->card, "OPTi 82C93X", device, 1, 1, &pcm))) return error; @@ -1356,6 +1365,7 @@ static int snd_opti93x_pcm(struct snd_opti93x *codec, int device, struct snd_pcm snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_opti93x_capture_ops); pcm->private_data = codec; + pcm->private_free = snd_opti93x_pcm_free; pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; strcpy(pcm->name, snd_opti93x_chip_id(codec)); @@ -1374,7 +1384,7 @@ static int snd_opti93x_pcm(struct snd_opti93x *codec, int device, struct snd_pcm * MIXER part */ -static int snd_opti93x_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_opti93x_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = { "Line1", "Aux", "Mic", "Mix" @@ -1389,9 +1399,9 @@ static int snd_opti93x_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int snd_opti93x_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opti93x_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opti93x *chip = snd_kcontrol_chip(kcontrol); + opti93x_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->lock, flags); @@ -1401,9 +1411,9 @@ static int snd_opti93x_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_opti93x_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opti93x_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opti93x *chip = snd_kcontrol_chip(kcontrol); + opti93x_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned short left, right; int change; @@ -1432,7 +1442,7 @@ static int snd_opti93x_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ele .get = snd_opti93x_get_single, .put = snd_opti93x_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_opti93x_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_opti93x_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1443,9 +1453,9 @@ static int snd_opti93x_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_opti93x_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opti93x_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opti93x *chip = snd_kcontrol_chip(kcontrol); + opti93x_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1460,9 +1470,9 @@ static int snd_opti93x_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_opti93x_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opti93x_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opti93x *chip = snd_kcontrol_chip(kcontrol); + opti93x_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1497,7 +1507,7 @@ static int snd_opti93x_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ do { xctl.private_value &= ~0x0000ffff; \ xctl.private_value |= left_reg | (right_reg << 8); } while (0) -static int snd_opti93x_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_opti93x_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -1508,9 +1518,9 @@ static int snd_opti93x_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_opti93x_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opti93x_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opti93x *chip = snd_kcontrol_chip(kcontrol); + opti93x_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1530,9 +1540,9 @@ static int snd_opti93x_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_opti93x_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_opti93x_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_opti93x *chip = snd_kcontrol_chip(kcontrol); + opti93x_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1561,7 +1571,7 @@ static int snd_opti93x_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return change; } -static struct snd_kcontrol_new snd_opti93x_controls[] = { +static snd_kcontrol_new_t snd_opti93x_controls[] = { OPTi93X_DOUBLE("Master Playback Switch", 0, OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1), OPTi93X_DOUBLE("Master Playback Volume", 0, OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1), OPTi93X_DOUBLE("PCM Playback Switch", 0, OPTi93X_DAC_LEFT, OPTi93X_DAC_RIGHT, 7, 7, 1, 1), @@ -1587,10 +1597,10 @@ OPTi93X_DOUBLE("Capture Volume", 0, OPTi93X_MIXOUT_LEFT, OPTi93X_MIXOUT_RIGHT, 0 } }; -static int snd_opti93x_mixer(struct snd_opti93x *chip) +static int snd_opti93x_mixer(opti93x_t *chip) { - struct snd_card *card; - struct snd_kcontrol_new knew; + snd_card_t *card; + snd_kcontrol_new_t knew; int err; unsigned int idx; @@ -1622,7 +1632,7 @@ static int snd_opti93x_mixer(struct snd_opti93x *chip) #endif /* OPTi93X */ -static int __init snd_card_opti9xx_detect(struct snd_card *card, struct snd_opti9xx *chip) +static int __devinit snd_card_opti9xx_detect(snd_card_t *card, opti9xx_t *chip) { int i, err; @@ -1676,8 +1686,8 @@ static int __init snd_card_opti9xx_detect(struct snd_card *card, struct snd_opti } #ifdef CONFIG_PNP -static int __init snd_card_opti9xx_pnp(struct snd_opti9xx *chip, struct pnp_card_link *card, - const struct pnp_card_device_id *pid) +static int __devinit snd_card_opti9xx_pnp(opti9xx_t *chip, struct pnp_card_link *card, + const struct pnp_card_device_id *pid) { struct pnp_dev *pdev; struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL); @@ -1768,35 +1778,195 @@ static int __init snd_card_opti9xx_pnp(struct snd_opti9xx *chip, struct pnp_card } #endif /* CONFIG_PNP */ -static void snd_card_opti9xx_free(struct snd_card *card) +#if 0 +static int __devinit snd_card_opti9xx_resources(struct snd_card_opti9xx *chip, + snd_card_t *card) +{ + int error, i, pnp = 0; + +#ifdef CONFIG_PNP + pnp = chip->dev != NULL; +#endif /* CONFIG_PNP */ + +#ifndef OPTi93X + if (chip->chip->hardware == OPTi9XX_HW_82C928) + mpu_port = -1; +#endif /* OPTi93X */ + error = 0; + if (!pnp && (mpu_port == SNDRV_DEFAULT_PORT1)) { + for (i = 0; possible_mpu_ports[i] != -1; i++) + if (!snd_register_ioport(card, possible_mpu_ports[i], 2, + DRIVER_NAME" - MPU-401", NULL)) { + mpu_port = possible_mpu_ports[i]; + break; + } + if (mpu_port == SNDRV_DEFAULT_PORT1) + error = -EBUSY; + } + else + error = (mpu_port == -1) ? -ENODEV : + snd_register_ioport(card, mpu_port, 2, + DRIVER_NAME" - MPU-401", NULL); + if (error) + chip->chip->mpu_port = -1; + else if (pnp && (irq == mpu_irq)) + chip->chip->mpu_irq = mpu_irq; + else if (!snd_register_interrupt(card, + DRIVER_NAME" - MPU-401", + mpu_irq, SNDRV_IRQ_TYPE_ISA, + snd_card_opti9xx_mpu_interrupt, chip, + pnp ? no_alternatives : possible_mpu_irqs, + &chip->mpuirqptr)) { + chip->chip->mpu_port = mpu_port; + chip->chip->mpu_irq = chip->mpuirqptr->irq; + } + else + chip->chip->mpu_port = -1; + + if (!pnp && (port == SNDRV_DEFAULT_PORT1)) { + for (i = 0; possible_ports[i] != -1; i++) + if (!snd_register_ioport(card, possible_ports[i], 8, + DRIVER_NAME" - WSS", NULL)) { + port = possible_ports[i]; + break; + } + if (port == SNDRV_DEFAULT_PORT1) + return -EBUSY; + } + else if ((error = snd_register_ioport(card, port, 8, + DRIVER_NAME" - WSS", NULL)) < 0) + return error; + chip->chip->wss_base = port; + if ((error = snd_register_interrupt(card, DRIVER_NAME" - WSS", + irq, SNDRV_IRQ_TYPE_ISA, + snd_card_opti9xx_interrupt, chip, + pnp ? no_alternatives : possible_irqs, + &chip->irqptr)) < 0) + return error; + chip->chip->irq = chip->irqptr->irq; + if ((error = snd_register_dma_channel(card, +#if defined(CS4231) || defined(OPTi93X) + DRIVER_NAME" - WSS playback", +#else + DRIVER_NAME" - WSS", +#endif /* CS4231 || OPTi93X */ + dma1, SNDRV_DMA_TYPE_ISA, dma1_size, + pnp ? no_alternatives : possible_dma1s, + &chip->dma1ptr)) < 0) + return error; + chip->chip->dma1 = chip->dma1ptr->dma; +#if defined(CS4231) || defined(OPTi93X) + if ((error = snd_register_dma_channel(card, DRIVER_NAME" - WSS capture", + dma2, SNDRV_DMA_TYPE_ISA, dma2_size, + pnp ? no_alternatives : + possible_dma2s[chip->dma1ptr->dma], + &chip->dma2ptr)) < 0) + return error; + chip->chip->dma2 = chip->dma2ptr->dma; +#endif /* CS4231 || OPTi93X */ + + if (snd_register_ioport(card, + pnp ? fm_port : fm_port = 0x388, 4, + DRIVER_NAME" - OPL", NULL) < 0) + fm_port = -1; + chip->chip->fm_port = fm_port; + + return 0; +} +#endif + +static void snd_card_opti9xx_free(snd_card_t *card) { - struct snd_opti9xx *chip = card->private_data; + opti9xx_t *chip = (opti9xx_t *)card->private_data; if (chip) release_and_free_resource(chip->res_mc_base); } -static int __init snd_opti9xx_probe(struct snd_card *card) +static int snd_card_opti9xx_probe(struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1}; + static long possible_mpu_ports[] = {0x300, 0x310, 0x320, 0x330, -1}; +#ifdef OPTi93X + static int possible_irqs[] = {5, 9, 10, 11, 7, -1}; +#else + static int possible_irqs[] = {9, 10, 11, 7, -1}; +#endif /* OPTi93X */ + static int possible_mpu_irqs[] = {5, 9, 10, 7, -1}; + static int possible_dma1s[] = {3, 1, 0, -1}; +#if defined(CS4231) || defined(OPTi93X) + static int possible_dma2s[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}}; +#endif /* CS4231 || OPTi93X */ int error; - struct snd_opti9xx *chip = card->private_data; + opti9xx_t *chip; #if defined(OPTi93X) - struct snd_opti93x *codec; + opti93x_t *codec; #elif defined(CS4231) - struct snd_cs4231 *codec; - struct snd_timer *timer; + cs4231_t *codec; + snd_timer_t *timer; #else - struct snd_ad1848 *codec; + ad1848_t *codec; #endif - struct snd_pcm *pcm; - struct snd_rawmidi *rmidi; - struct snd_hwdep *synth; + snd_card_t *card; + snd_pcm_t *pcm; + snd_rawmidi_t *rmidi; + snd_hwdep_t *synth; +#ifdef CONFIG_PNP + int hw; +#endif /* CONFIG_PNP */ + + if (pcard && !snd_opti9xx_first_hit) + return -EBUSY; + if (!(card = snd_card_new(index, id, THIS_MODULE, + sizeof(opti9xx_t)))) + return -ENOMEM; + card->private_free = snd_card_opti9xx_free; + chip = (opti9xx_t *)card->private_data; + +#ifdef CONFIG_PNP + if (isapnp && pcard && (hw = snd_card_opti9xx_pnp(chip, pcard, pid)) > 0) { + switch (hw) { + case 0x0924: + hw = OPTi9XX_HW_82C924; + break; + case 0x0925: + hw = OPTi9XX_HW_82C925; + break; + case 0x0931: + hw = OPTi9XX_HW_82C931; + break; + default: + snd_card_free(card); + return -ENODEV; + } + + if ((error = snd_opti9xx_init(chip, hw))) { + snd_card_free(card); + return error; + } + if (hw <= OPTi9XX_HW_82C930) + chip->mc_base -= 0x80; + snd_card_set_dev(card, &pcard->card->dev); + } else { +#endif /* CONFIG_PNP */ + if ((error = snd_card_opti9xx_detect(card, chip)) < 0) { + snd_card_free(card); + return error; + } + if ((error = snd_card_set_generic_dev(card)) < 0) { + snd_card_free(card); + return error; + } +#ifdef CONFIG_PNP + } +#endif /* CONFIG_PNP */ if (! chip->res_mc_base && - (chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, - "OPTi9xx MC")) == NULL) + (chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL) { + snd_card_free(card); return -ENOMEM; + } chip->wss_base = port; chip->fm_port = fm_port; @@ -1810,42 +1980,110 @@ static int __init snd_opti9xx_probe(struct snd_card *card) if (chip->wss_base == SNDRV_AUTO_PORT) { if ((chip->wss_base = snd_legacy_find_free_ioport(possible_ports, 4)) < 0) { + snd_card_free(card); snd_printk("unable to find a free WSS port\n"); return -EBUSY; } } - if ((error = snd_opti9xx_configure(chip))) +#ifdef CONFIG_PNP + if (!isapnp) { +#endif + if (chip->mpu_port == SNDRV_AUTO_PORT) { + if ((chip->mpu_port = snd_legacy_find_free_ioport(possible_mpu_ports, 2)) < 0) { + snd_card_free(card); + snd_printk("unable to find a free MPU401 port\n"); + return -EBUSY; + } + } + if (chip->irq == SNDRV_AUTO_IRQ) { + if ((chip->irq = snd_legacy_find_free_irq(possible_irqs)) < 0) { + snd_card_free(card); + snd_printk("unable to find a free IRQ\n"); + return -EBUSY; + } + } + if (chip->mpu_irq == SNDRV_AUTO_IRQ) { + if ((chip->mpu_irq = snd_legacy_find_free_irq(possible_mpu_irqs)) < 0) { + snd_card_free(card); + snd_printk("unable to find a free MPU401 IRQ\n"); + return -EBUSY; + } + } + if (chip->dma1 == SNDRV_AUTO_DMA) { + if ((chip->dma1 = snd_legacy_find_free_dma(possible_dma1s)) < 0) { + snd_card_free(card); + snd_printk("unable to find a free DMA1\n"); + return -EBUSY; + } + } +#if defined(CS4231) || defined(OPTi93X) + if (chip->dma2 == SNDRV_AUTO_DMA) { + if ((chip->dma2 = snd_legacy_find_free_dma(possible_dma2s[chip->dma1 % 4])) < 0) { + snd_card_free(card); + snd_printk("unable to find a free DMA2\n"); + return -EBUSY; + } + } +#endif + +#ifdef CONFIG_PNP + } +#endif + + if ((error = snd_opti9xx_configure(chip))) { + snd_card_free(card); return error; + } #if defined(OPTi93X) - if ((error = snd_opti93x_create(card, chip, chip->dma1, chip->dma2, &codec))) + if ((error = snd_opti93x_create(card, chip, chip->dma1, chip->dma2, &codec))) { + snd_card_free(card); return error; - if ((error = snd_opti93x_pcm(codec, 0, &pcm)) < 0) + } + if ((error = snd_opti93x_pcm(codec, 0, &pcm)) < 0) { + snd_card_free(card); return error; - if ((error = snd_opti93x_mixer(codec)) < 0) + } + if ((error = snd_opti93x_mixer(codec)) < 0) { + snd_card_free(card); return error; + } #elif defined(CS4231) if ((error = snd_cs4231_create(card, chip->wss_base + 4, -1, chip->irq, chip->dma1, chip->dma2, CS4231_HW_DETECT, 0, - &codec)) < 0) + &codec)) < 0) { + snd_card_free(card); return error; - if ((error = snd_cs4231_pcm(codec, 0, &pcm)) < 0) + } + if ((error = snd_cs4231_pcm(codec, 0, &pcm)) < 0) { + snd_card_free(card); return error; - if ((error = snd_cs4231_mixer(codec)) < 0) + } + if ((error = snd_cs4231_mixer(codec)) < 0) { + snd_card_free(card); return error; - if ((error = snd_cs4231_timer(codec, 0, &timer)) < 0) + } + if ((error = snd_cs4231_timer(codec, 0, &timer)) < 0) { + snd_card_free(card); return error; + } #else if ((error = snd_ad1848_create(card, chip->wss_base + 4, chip->irq, chip->dma1, - AD1848_HW_DETECT, &codec)) < 0) + AD1848_HW_DETECT, &codec)) < 0) { + snd_card_free(card); return error; - if ((error = snd_ad1848_pcm(codec, 0, &pcm)) < 0) + } + if ((error = snd_ad1848_pcm(codec, 0, &pcm)) < 0) { + snd_card_free(card); return error; - if ((error = snd_ad1848_mixer(codec)) < 0) + } + if ((error = snd_ad1848_mixer(codec)) < 0) { + snd_card_free(card); return error; + } #endif strcpy(card->driver, chip->name); sprintf(card->shortname, "OPTi %s", card->driver); @@ -1865,16 +2103,15 @@ static int __init snd_opti9xx_probe(struct snd_card *card) if ((error = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, chip->mpu_port, 0, chip->mpu_irq, SA_INTERRUPT, &rmidi))) - snd_printk(KERN_WARNING "no MPU-401 device at 0x%lx?\n", - chip->mpu_port); + snd_printk("no MPU-401 device at 0x%lx?\n", chip->mpu_port); if (chip->fm_port > 0 && chip->fm_port != SNDRV_AUTO_PORT) { - struct snd_opl3 *opl3 = NULL; + opl3_t *opl3 = NULL; #ifndef OPTi93X if (chip->hardware == OPTi9XX_HW_82C928 || chip->hardware == OPTi9XX_HW_82C929 || chip->hardware == OPTi9XX_HW_82C924) { - struct snd_opl4 *opl4; + opl4_t *opl4; /* assume we have an OPL4 */ snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), 0x20, 0x20); @@ -1892,230 +2129,89 @@ static int __init snd_opti9xx_probe(struct snd_card *card) chip->fm_port, chip->fm_port + 2, OPL3_HW_AUTO, 0, &opl3) < 0) { - snd_printk(KERN_WARNING "no OPL device at 0x%lx-0x%lx\n", + snd_printk("no OPL device at 0x%lx-0x%lx\n", chip->fm_port, chip->fm_port + 4 - 1); } if (opl3) { + if ((error = snd_opl3_timer_new(opl3, #ifdef CS4231 - const int t1dev = 1; + 1, 2)) < 0) { #else - const int t1dev = 0; -#endif - if ((error = snd_opl3_timer_new(opl3, t1dev, t1dev+1)) < 0) + 0, 1)) < 0) { +#endif /* CS4231 */ + snd_card_free(card); return error; - if ((error = snd_opl3_hwdep_new(opl3, 0, 1, &synth)) < 0) + } + if ((error = snd_opl3_hwdep_new(opl3, 0, 1, &synth)) < 0) { + snd_card_free(card); return error; + } } } - return snd_card_register(card); -} - -static struct snd_card *snd_opti9xx_card_new(void) -{ - struct snd_card *card; - - card = snd_card_new(index, id, THIS_MODULE, sizeof(struct snd_opti9xx)); - if (! card) - return NULL; - card->private_free = snd_card_opti9xx_free; - return card; -} - -static int __init snd_opti9xx_nonpnp_probe(struct platform_device *devptr) -{ - struct snd_card *card; - int error; - static long possible_mpu_ports[] = {0x300, 0x310, 0x320, 0x330, -1}; -#ifdef OPTi93X - static int possible_irqs[] = {5, 9, 10, 11, 7, -1}; -#else - static int possible_irqs[] = {9, 10, 11, 7, -1}; -#endif /* OPTi93X */ - static int possible_mpu_irqs[] = {5, 9, 10, 7, -1}; - static int possible_dma1s[] = {3, 1, 0, -1}; -#if defined(CS4231) || defined(OPTi93X) - static int possible_dma2s[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}}; -#endif /* CS4231 || OPTi93X */ - - if (snd_opti9xx_pnp_is_probed) - return -EBUSY; - - if (mpu_port == SNDRV_AUTO_PORT) { - if ((mpu_port = snd_legacy_find_free_ioport(possible_mpu_ports, 2)) < 0) { - snd_printk(KERN_ERR "unable to find a free MPU401 port\n"); - return -EBUSY; - } - } - if (irq == SNDRV_AUTO_IRQ) { - if ((irq = snd_legacy_find_free_irq(possible_irqs)) < 0) { - snd_printk(KERN_ERR "unable to find a free IRQ\n"); - return -EBUSY; - } - } - if (mpu_irq == SNDRV_AUTO_IRQ) { - if ((mpu_irq = snd_legacy_find_free_irq(possible_mpu_irqs)) < 0) { - snd_printk(KERN_ERR "unable to find a free MPU401 IRQ\n"); - return -EBUSY; - } - } - if (dma1 == SNDRV_AUTO_DMA) { - if ((dma1 = snd_legacy_find_free_dma(possible_dma1s)) < 0) { - snd_printk(KERN_ERR "unable to find a free DMA1\n"); - return -EBUSY; - } - } -#if defined(CS4231) || defined(OPTi93X) - if (dma2 == SNDRV_AUTO_DMA) { - if ((dma2 = snd_legacy_find_free_dma(possible_dma2s[dma1 % 4])) < 0) { - snd_printk("unable to find a free DMA2\n"); - return -EBUSY; - } - } -#endif - - card = snd_opti9xx_card_new(); - if (! card) - return -ENOMEM; - - if ((error = snd_card_opti9xx_detect(card, card->private_data)) < 0) { + if ((error = snd_card_register(card))) { snd_card_free(card); return error; } - snd_card_set_dev(card, &devptr->dev); - if ((error = snd_opti9xx_probe(card)) < 0) { - snd_card_free(card); - return error; - } - platform_set_drvdata(devptr, card); - return 0; -} - -static int __devexit snd_opti9xx_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); + snd_opti9xx_first_hit = 0; + if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_opti9xx_legacy = card; return 0; } -static struct platform_driver snd_opti9xx_driver = { - .probe = snd_opti9xx_nonpnp_probe, - .remove = __devexit_p(snd_opti9xx_nonpnp_remove), - /* FIXME: suspend/resume */ - .driver = { - .name = DRIVER_NAME - }, -}; - #ifdef CONFIG_PNP -static int __init snd_opti9xx_pnp_probe(struct pnp_card_link *pcard, - const struct pnp_card_device_id *pid) -{ - struct snd_card *card; - int error, hw; - struct snd_opti9xx *chip; - - if (snd_opti9xx_pnp_is_probed) - return -EBUSY; - if (! isapnp) - return -ENODEV; - card = snd_opti9xx_card_new(); - if (! card) - return -ENOMEM; - chip = card->private_data; - - hw = snd_card_opti9xx_pnp(chip, pcard, pid); - switch (hw) { - case 0x0924: - hw = OPTi9XX_HW_82C924; - break; - case 0x0925: - hw = OPTi9XX_HW_82C925; - break; - case 0x0931: - hw = OPTi9XX_HW_82C931; - break; - default: - snd_card_free(card); - return -ENODEV; - } - - if ((error = snd_opti9xx_init(chip, hw))) { - snd_card_free(card); - return error; - } - if (hw <= OPTi9XX_HW_82C930) - chip->mc_base -= 0x80; - snd_card_set_dev(card, &pcard->card->dev); - if ((error = snd_opti9xx_probe(card)) < 0) { - snd_card_free(card); - return error; - } - pnp_set_card_drvdata(pcard, card); - snd_opti9xx_pnp_is_probed = 1; - return 0; -} - static void __devexit snd_opti9xx_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); - snd_opti9xx_pnp_is_probed = 0; + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + + snd_card_disconnect(card); + snd_card_free_in_thread(card); + snd_opti9xx_first_hit = 0; } static struct pnp_card_driver opti9xx_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, .name = "opti9xx", .id_table = snd_opti9xx_pnpids, - .probe = snd_opti9xx_pnp_probe, + .probe = snd_card_opti9xx_probe, .remove = __devexit_p(snd_opti9xx_pnp_remove), }; #endif +static int __init alsa_card_opti9xx_init(void) +{ + int cards, error; + #ifdef CONFIG_PNP -#define is_isapnp_selected() isapnp + cards = pnp_register_card_driver(&opti9xx_pnpc_driver); #else -#define is_isapnp_selected() 0 + cards = 0; +#endif + if (cards == 0 && (error = snd_card_opti9xx_probe(NULL, NULL)) < 0) { +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&opti9xx_pnpc_driver); #endif +#ifdef MODULE #ifdef OPTi93X -#define CHIP_NAME "82C93x" + printk(KERN_ERR "no OPTi 82C93x soundcard found\n"); #else -#define CHIP_NAME "82C92x" + printk(KERN_ERR "no OPTi 82C92x soundcard found\n"); +#endif /* OPTi93X */ #endif - -static int __init alsa_card_opti9xx_init(void) -{ - int error; - struct platform_device *device; - - pnp_register_card_driver(&opti9xx_pnpc_driver); - if (snd_opti9xx_pnp_is_probed) - return 0; - if (! is_isapnp_selected()) { - error = platform_driver_register(&snd_opti9xx_driver); - if (error < 0) - return error; - device = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0); - if (!IS_ERR(device)) { - snd_opti9xx_platform_device = device; - return 0; - } - platform_driver_unregister(&snd_opti9xx_driver); + return error; } - pnp_unregister_card_driver(&opti9xx_pnpc_driver); -#ifdef MODULE - printk(KERN_ERR "no OPTi " CHIP_NAME " soundcard found\n"); -#endif - return -ENODEV; + return 0; } static void __exit alsa_card_opti9xx_exit(void) { - if (!snd_opti9xx_pnp_is_probed) { - platform_device_unregister(snd_opti9xx_platform_device); - platform_driver_unregister(&snd_opti9xx_driver); - } +#ifdef CONFIG_PNP pnp_unregister_card_driver(&opti9xx_pnpc_driver); +#endif + if (snd_opti9xx_legacy) + snd_card_free(snd_opti9xx_legacy); } module_init(alsa_card_opti9xx_init) diff --git a/trunk/sound/isa/sb/emu8000.c b/trunk/sound/isa/sb/emu8000.c index c0b8d61b75e7..b09c6575e01a 100644 --- a/trunk/sound/isa/sb/emu8000.c +++ b/trunk/sound/isa/sb/emu8000.c @@ -45,7 +45,7 @@ * directly. The macros handle the port number and command word. */ /* Write a word */ -void snd_emu8000_poke(struct snd_emu8000 *emu, unsigned int port, unsigned int reg, unsigned int val) +void snd_emu8000_poke(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val) { unsigned long flags; spin_lock_irqsave(&emu->reg_lock, flags); @@ -58,7 +58,7 @@ void snd_emu8000_poke(struct snd_emu8000 *emu, unsigned int port, unsigned int r } /* Read a word */ -unsigned short snd_emu8000_peek(struct snd_emu8000 *emu, unsigned int port, unsigned int reg) +unsigned short snd_emu8000_peek(emu8000_t *emu, unsigned int port, unsigned int reg) { unsigned short res; unsigned long flags; @@ -73,7 +73,7 @@ unsigned short snd_emu8000_peek(struct snd_emu8000 *emu, unsigned int port, unsi } /* Write a double word */ -void snd_emu8000_poke_dw(struct snd_emu8000 *emu, unsigned int port, unsigned int reg, unsigned int val) +void snd_emu8000_poke_dw(emu8000_t *emu, unsigned int port, unsigned int reg, unsigned int val) { unsigned long flags; spin_lock_irqsave(&emu->reg_lock, flags); @@ -87,7 +87,7 @@ void snd_emu8000_poke_dw(struct snd_emu8000 *emu, unsigned int port, unsigned in } /* Read a double word */ -unsigned int snd_emu8000_peek_dw(struct snd_emu8000 *emu, unsigned int port, unsigned int reg) +unsigned int snd_emu8000_peek_dw(emu8000_t *emu, unsigned int port, unsigned int reg) { unsigned short low; unsigned int res; @@ -107,7 +107,7 @@ unsigned int snd_emu8000_peek_dw(struct snd_emu8000 *emu, unsigned int port, uns * Set up / close a channel to be used for DMA. */ /*exported*/ void -snd_emu8000_dma_chan(struct snd_emu8000 *emu, int ch, int mode) +snd_emu8000_dma_chan(emu8000_t *emu, int ch, int mode) { unsigned right_bit = (mode & EMU8000_RAM_RIGHT) ? 0x01000000 : 0; mode &= EMU8000_RAM_MODE_MASK; @@ -132,7 +132,7 @@ snd_emu8000_dma_chan(struct snd_emu8000 *emu, int ch, int mode) /* */ static void __init -snd_emu8000_read_wait(struct snd_emu8000 *emu) +snd_emu8000_read_wait(emu8000_t *emu) { while ((EMU8000_SMALR_READ(emu) & 0x80000000) != 0) { schedule_timeout_interruptible(1); @@ -144,7 +144,7 @@ snd_emu8000_read_wait(struct snd_emu8000 *emu) /* */ static void __init -snd_emu8000_write_wait(struct snd_emu8000 *emu) +snd_emu8000_write_wait(emu8000_t *emu) { while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) { schedule_timeout_interruptible(1); @@ -157,7 +157,7 @@ snd_emu8000_write_wait(struct snd_emu8000 *emu) * detect a card at the given port */ static int __init -snd_emu8000_detect(struct snd_emu8000 *emu) +snd_emu8000_detect(emu8000_t *emu) { /* Initialise */ EMU8000_HWCF1_WRITE(emu, 0x0059); @@ -183,7 +183,7 @@ snd_emu8000_detect(struct snd_emu8000 *emu) * intiailize audio channels */ static void __init -init_audio(struct snd_emu8000 *emu) +init_audio(emu8000_t *emu) { int ch; @@ -224,7 +224,7 @@ init_audio(struct snd_emu8000 *emu) * initialize DMA address */ static void __init -init_dma(struct snd_emu8000 *emu) +init_dma(emu8000_t *emu) { EMU8000_SMALR_WRITE(emu, 0); EMU8000_SMARR_WRITE(emu, 0); @@ -328,7 +328,7 @@ static unsigned short init4[128] /*__devinitdata*/ = { * is meant to work */ static void __init -send_array(struct snd_emu8000 *emu, unsigned short *data, int size) +send_array(emu8000_t *emu, unsigned short *data, int size) { int i; unsigned short *p; @@ -350,7 +350,7 @@ send_array(struct snd_emu8000 *emu, unsigned short *data, int size) * initialisation sequence in the adip. */ static void __init -init_arrays(struct snd_emu8000 *emu) +init_arrays(emu8000_t *emu) { send_array(emu, init1, ARRAY_SIZE(init1)/4); @@ -376,7 +376,7 @@ init_arrays(struct snd_emu8000 *emu) * reallocating between read and write. */ static void __init -size_dram(struct snd_emu8000 *emu) +size_dram(emu8000_t *emu) { int i, size; @@ -455,7 +455,7 @@ size_dram(struct snd_emu8000 *emu) * and therefore lose 2 voices. */ /*exported*/ void -snd_emu8000_init_fm(struct snd_emu8000 *emu) +snd_emu8000_init_fm(emu8000_t *emu) { unsigned long flags; @@ -501,7 +501,7 @@ snd_emu8000_init_fm(struct snd_emu8000 *emu) * The main initialization routine. */ static void __init -snd_emu8000_init_hw(struct snd_emu8000 *emu) +snd_emu8000_init_hw(emu8000_t *emu) { int i; @@ -585,7 +585,7 @@ static unsigned short treble_parm[12][9] = { * set Emu8000 digital equalizer; from 0 to 11 [-12dB - 12dB] */ /*exported*/ void -snd_emu8000_update_equalizer(struct snd_emu8000 *emu) +snd_emu8000_update_equalizer(emu8000_t *emu) { unsigned short w; int bass = emu->bass_level; @@ -628,17 +628,17 @@ snd_emu8000_update_equalizer(struct snd_emu8000 *emu) /* user can define chorus modes up to 32 */ #define SNDRV_EMU8000_CHORUS_NUMBERS 32 -struct soundfont_chorus_fx { +typedef struct soundfont_chorus_fx_t { unsigned short feedback; /* feedback level (0xE600-0xE6FF) */ unsigned short delay_offset; /* delay (0-0x0DA3) [1/44100 sec] */ unsigned short lfo_depth; /* LFO depth (0xBC00-0xBCFF) */ unsigned int delay; /* right delay (0-0xFFFFFFFF) [1/256/44100 sec] */ unsigned int lfo_freq; /* LFO freq LFO freq (0-0xFFFFFFFF) */ -}; +} soundfont_chorus_fx_t; /* 5 parameters for each chorus mode; 3 x 16bit, 2 x 32bit */ static char chorus_defined[SNDRV_EMU8000_CHORUS_NUMBERS]; -static struct soundfont_chorus_fx chorus_parm[SNDRV_EMU8000_CHORUS_NUMBERS] = { +static soundfont_chorus_fx_t chorus_parm[SNDRV_EMU8000_CHORUS_NUMBERS] = { {0xE600, 0x03F6, 0xBC2C ,0x00000000, 0x0000006D}, /* chorus 1 */ {0xE608, 0x031A, 0xBC6E, 0x00000000, 0x0000017C}, /* chorus 2 */ {0xE610, 0x031A, 0xBC84, 0x00000000, 0x00000083}, /* chorus 3 */ @@ -650,9 +650,9 @@ static struct soundfont_chorus_fx chorus_parm[SNDRV_EMU8000_CHORUS_NUMBERS] = { }; /*exported*/ int -snd_emu8000_load_chorus_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len) +snd_emu8000_load_chorus_fx(emu8000_t *emu, int mode, const void __user *buf, long len) { - struct soundfont_chorus_fx rec; + soundfont_chorus_fx_t rec; if (mode < SNDRV_EMU8000_CHORUS_PREDEFINED || mode >= SNDRV_EMU8000_CHORUS_NUMBERS) { snd_printk(KERN_WARNING "invalid chorus mode %d for uploading\n", mode); return -EINVAL; @@ -665,7 +665,7 @@ snd_emu8000_load_chorus_fx(struct snd_emu8000 *emu, int mode, const void __user } /*exported*/ void -snd_emu8000_update_chorus_mode(struct snd_emu8000 *emu) +snd_emu8000_update_chorus_mode(emu8000_t *emu) { int effect = emu->chorus_mode; if (effect < 0 || effect >= SNDRV_EMU8000_CHORUS_NUMBERS || @@ -699,15 +699,15 @@ snd_emu8000_update_chorus_mode(struct snd_emu8000 *emu) /* user can define reverb modes up to 32 */ #define SNDRV_EMU8000_REVERB_NUMBERS 32 -struct soundfont_reverb_fx { +typedef struct soundfont_reverb_fx_t { unsigned short parms[28]; -}; +} soundfont_reverb_fx_t; /* reverb mode settings; write the following 28 data of 16 bit length * on the corresponding ports in the reverb_cmds array */ static char reverb_defined[SNDRV_EMU8000_CHORUS_NUMBERS]; -static struct soundfont_reverb_fx reverb_parm[SNDRV_EMU8000_REVERB_NUMBERS] = { +static soundfont_reverb_fx_t reverb_parm[SNDRV_EMU8000_REVERB_NUMBERS] = { {{ /* room 1 */ 0xB488, 0xA450, 0x9550, 0x84B5, 0x383A, 0x3EB5, 0x72F4, 0x72A4, 0x7254, 0x7204, 0x7204, 0x7204, 0x4416, 0x4516, @@ -777,9 +777,9 @@ static struct reverb_cmd_pair { }; /*exported*/ int -snd_emu8000_load_reverb_fx(struct snd_emu8000 *emu, int mode, const void __user *buf, long len) +snd_emu8000_load_reverb_fx(emu8000_t *emu, int mode, const void __user *buf, long len) { - struct soundfont_reverb_fx rec; + soundfont_reverb_fx_t rec; if (mode < SNDRV_EMU8000_REVERB_PREDEFINED || mode >= SNDRV_EMU8000_REVERB_NUMBERS) { snd_printk(KERN_WARNING "invalid reverb mode %d for uploading\n", mode); @@ -793,7 +793,7 @@ snd_emu8000_load_reverb_fx(struct snd_emu8000 *emu, int mode, const void __user } /*exported*/ void -snd_emu8000_update_reverb_mode(struct snd_emu8000 *emu) +snd_emu8000_update_reverb_mode(emu8000_t *emu) { int effect = emu->reverb_mode; int i; @@ -819,7 +819,7 @@ snd_emu8000_update_reverb_mode(struct snd_emu8000 *emu) /* * bass/treble */ -static int mixer_bass_treble_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixer_bass_treble_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -828,17 +828,17 @@ static int mixer_bass_treble_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int mixer_bass_treble_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_bass_treble_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol); + emu8000_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = kcontrol->private_value ? emu->treble_level : emu->bass_level; return 0; } -static int mixer_bass_treble_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_bass_treble_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol); + emu8000_t *emu = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned short val1; @@ -857,7 +857,7 @@ static int mixer_bass_treble_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e return change; } -static struct snd_kcontrol_new mixer_bass_control = +static snd_kcontrol_new_t mixer_bass_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Synth Tone Control - Bass", @@ -867,7 +867,7 @@ static struct snd_kcontrol_new mixer_bass_control = .private_value = 0, }; -static struct snd_kcontrol_new mixer_treble_control = +static snd_kcontrol_new_t mixer_treble_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Synth Tone Control - Treble", @@ -880,7 +880,7 @@ static struct snd_kcontrol_new mixer_treble_control = /* * chorus/reverb mode */ -static int mixer_chorus_reverb_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixer_chorus_reverb_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -889,17 +889,17 @@ static int mixer_chorus_reverb_info(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int mixer_chorus_reverb_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_chorus_reverb_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol); + emu8000_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = kcontrol->private_value ? emu->chorus_mode : emu->reverb_mode; return 0; } -static int mixer_chorus_reverb_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_chorus_reverb_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol); + emu8000_t *emu = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned short val1; @@ -924,7 +924,7 @@ static int mixer_chorus_reverb_put(struct snd_kcontrol *kcontrol, struct snd_ctl return change; } -static struct snd_kcontrol_new mixer_chorus_mode_control = +static snd_kcontrol_new_t mixer_chorus_mode_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Chorus Mode", @@ -934,7 +934,7 @@ static struct snd_kcontrol_new mixer_chorus_mode_control = .private_value = 1, }; -static struct snd_kcontrol_new mixer_reverb_mode_control = +static snd_kcontrol_new_t mixer_reverb_mode_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Reverb Mode", @@ -947,7 +947,7 @@ static struct snd_kcontrol_new mixer_reverb_mode_control = /* * FM OPL3 chorus/reverb depth */ -static int mixer_fm_depth_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixer_fm_depth_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -956,17 +956,17 @@ static int mixer_fm_depth_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int mixer_fm_depth_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_fm_depth_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol); + emu8000_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = kcontrol->private_value ? emu->fm_chorus_depth : emu->fm_reverb_depth; return 0; } -static int mixer_fm_depth_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_fm_depth_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu8000 *emu = snd_kcontrol_chip(kcontrol); + emu8000_t *emu = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned short val1; @@ -986,7 +986,7 @@ static int mixer_fm_depth_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return change; } -static struct snd_kcontrol_new mixer_fm_chorus_depth_control = +static snd_kcontrol_new_t mixer_fm_chorus_depth_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "FM Chorus Depth", @@ -996,7 +996,7 @@ static struct snd_kcontrol_new mixer_fm_chorus_depth_control = .private_value = 1, }; -static struct snd_kcontrol_new mixer_fm_reverb_depth_control = +static snd_kcontrol_new_t mixer_fm_reverb_depth_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "FM Reverb Depth", @@ -1007,7 +1007,7 @@ static struct snd_kcontrol_new mixer_fm_reverb_depth_control = }; -static struct snd_kcontrol_new *mixer_defs[EMU8000_NUM_CONTROLS] = { +static snd_kcontrol_new_t *mixer_defs[EMU8000_NUM_CONTROLS] = { &mixer_bass_control, &mixer_treble_control, &mixer_chorus_mode_control, @@ -1020,7 +1020,7 @@ static struct snd_kcontrol_new *mixer_defs[EMU8000_NUM_CONTROLS] = { * create and attach mixer elements for WaveTable treble/bass controls */ static int __init -snd_emu8000_create_mixer(struct snd_card *card, struct snd_emu8000 *emu) +snd_emu8000_create_mixer(snd_card_t *card, emu8000_t *emu) { int i, err = 0; @@ -1049,7 +1049,7 @@ snd_emu8000_create_mixer(struct snd_card *card, struct snd_emu8000 *emu) /* * free resources */ -static int snd_emu8000_free(struct snd_emu8000 *hw) +static int snd_emu8000_free(emu8000_t *hw) { release_and_free_resource(hw->res_port1); release_and_free_resource(hw->res_port2); @@ -1060,9 +1060,9 @@ static int snd_emu8000_free(struct snd_emu8000 *hw) /* */ -static int snd_emu8000_dev_free(struct snd_device *device) +static int snd_emu8000_dev_free(snd_device_t *device) { - struct snd_emu8000 *hw = device->device_data; + emu8000_t *hw = device->device_data; return snd_emu8000_free(hw); } @@ -1070,13 +1070,12 @@ static int snd_emu8000_dev_free(struct snd_device *device) * initialize and register emu8000 synth device. */ int __init -snd_emu8000_new(struct snd_card *card, int index, long port, int seq_ports, - struct snd_seq_device **awe_ret) +snd_emu8000_new(snd_card_t *card, int index, long port, int seq_ports, snd_seq_device_t **awe_ret) { - struct snd_seq_device *awe; - struct snd_emu8000 *hw; + snd_seq_device_t *awe; + emu8000_t *hw; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_emu8000_dev_free, }; @@ -1128,9 +1127,9 @@ snd_emu8000_new(struct snd_card *card, int index, long port, int seq_ports, } #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) if (snd_seq_device_new(card, index, SNDRV_SEQ_DEV_ID_EMU8000, - sizeof(struct snd_emu8000*), &awe) >= 0) { + sizeof(emu8000_t*), &awe) >= 0) { strcpy(awe->name, "EMU-8000"); - *(struct snd_emu8000 **)SNDRV_SEQ_DEVICE_ARGPTR(awe) = hw; + *(emu8000_t**)SNDRV_SEQ_DEVICE_ARGPTR(awe) = hw; } #else awe = NULL; diff --git a/trunk/sound/isa/sb/emu8000_callback.c b/trunk/sound/isa/sb/emu8000_callback.c index 9a3c71cc2e07..1cc4101a17a4 100644 --- a/trunk/sound/isa/sb/emu8000_callback.c +++ b/trunk/sound/isa/sb/emu8000_callback.c @@ -25,30 +25,27 @@ /* * prototypes */ -static struct snd_emux_voice *get_voice(struct snd_emux *emu, - struct snd_emux_port *port); -static int start_voice(struct snd_emux_voice *vp); -static void trigger_voice(struct snd_emux_voice *vp); -static void release_voice(struct snd_emux_voice *vp); -static void update_voice(struct snd_emux_voice *vp, int update); -static void reset_voice(struct snd_emux *emu, int ch); -static void terminate_voice(struct snd_emux_voice *vp); -static void sysex(struct snd_emux *emu, char *buf, int len, int parsed, - struct snd_midi_channel_set *chset); +static snd_emux_voice_t *get_voice(snd_emux_t *emu, snd_emux_port_t *port); +static int start_voice(snd_emux_voice_t *vp); +static void trigger_voice(snd_emux_voice_t *vp); +static void release_voice(snd_emux_voice_t *vp); +static void update_voice(snd_emux_voice_t *vp, int update); +static void reset_voice(snd_emux_t *emu, int ch); +static void terminate_voice(snd_emux_voice_t *vp); +static void sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset); #ifdef CONFIG_SND_SEQUENCER_OSS -static int oss_ioctl(struct snd_emux *emu, int cmd, int p1, int p2); +static int oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2); #endif -static int load_fx(struct snd_emux *emu, int type, int mode, - const void __user *buf, long len); - -static void set_pitch(struct snd_emu8000 *hw, struct snd_emux_voice *vp); -static void set_volume(struct snd_emu8000 *hw, struct snd_emux_voice *vp); -static void set_pan(struct snd_emu8000 *hw, struct snd_emux_voice *vp); -static void set_fmmod(struct snd_emu8000 *hw, struct snd_emux_voice *vp); -static void set_tremfreq(struct snd_emu8000 *hw, struct snd_emux_voice *vp); -static void set_fm2frq2(struct snd_emu8000 *hw, struct snd_emux_voice *vp); -static void set_filterQ(struct snd_emu8000 *hw, struct snd_emux_voice *vp); -static void snd_emu8000_tweak_voice(struct snd_emu8000 *emu, int ch); +static int load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len); + +static void set_pitch(emu8000_t *hw, snd_emux_voice_t *vp); +static void set_volume(emu8000_t *hw, snd_emux_voice_t *vp); +static void set_pan(emu8000_t *hw, snd_emux_voice_t *vp); +static void set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp); +static void set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp); +static void set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp); +static void set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp); +static void snd_emu8000_tweak_voice(emu8000_t *emu, int ch); /* * Ensure a value is between two points @@ -61,7 +58,7 @@ static void snd_emu8000_tweak_voice(struct snd_emu8000 *emu, int ch); /* * set up operators */ -static struct snd_emux_operators emu8000_ops = { +static snd_emux_operators_t emu8000_ops = { .owner = THIS_MODULE, .get_voice = get_voice, .prepare = start_voice, @@ -81,7 +78,7 @@ static struct snd_emux_operators emu8000_ops = { }; void -snd_emu8000_ops_setup(struct snd_emu8000 *hw) +snd_emu8000_ops_setup(emu8000_t *hw) { hw->emu->ops = emu8000_ops; } @@ -92,10 +89,10 @@ snd_emu8000_ops_setup(struct snd_emu8000 *hw) * Terminate a voice */ static void -release_voice(struct snd_emux_voice *vp) +release_voice(snd_emux_voice_t *vp) { int dcysusv; - struct snd_emu8000 *hw; + emu8000_t *hw; hw = vp->hw; dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease; @@ -108,9 +105,9 @@ release_voice(struct snd_emux_voice *vp) /* */ static void -terminate_voice(struct snd_emux_voice *vp) +terminate_voice(snd_emux_voice_t *vp) { - struct snd_emu8000 *hw; + emu8000_t *hw; hw = vp->hw; EMU8000_DCYSUSV_WRITE(hw, vp->ch, 0x807F); @@ -120,9 +117,9 @@ terminate_voice(struct snd_emux_voice *vp) /* */ static void -update_voice(struct snd_emux_voice *vp, int update) +update_voice(snd_emux_voice_t *vp, int update) { - struct snd_emu8000 *hw; + emu8000_t *hw; hw = vp->hw; if (update & SNDRV_EMUX_UPDATE_VOLUME) @@ -152,12 +149,12 @@ update_voice(struct snd_emux_voice *vp, int update) * The channel index (vp->ch) must be initialized in this routine. * In Emu8k, it is identical with the array index. */ -static struct snd_emux_voice * -get_voice(struct snd_emux *emu, struct snd_emux_port *port) +static snd_emux_voice_t * +get_voice(snd_emux_t *emu, snd_emux_port_t *port) { int i; - struct snd_emux_voice *vp; - struct snd_emu8000 *hw; + snd_emux_voice_t *vp; + emu8000_t *hw; /* what we are looking for, in order of preference */ enum { @@ -230,13 +227,13 @@ get_voice(struct snd_emux *emu, struct snd_emux_port *port) /* */ static int -start_voice(struct snd_emux_voice *vp) +start_voice(snd_emux_voice_t *vp) { unsigned int temp; int ch; int addr; - struct snd_midi_channel *chan; - struct snd_emu8000 *hw; + snd_midi_channel_t *chan; + emu8000_t *hw; hw = vp->hw; ch = vp->ch; @@ -310,11 +307,11 @@ start_voice(struct snd_emux_voice *vp) * Start envelope */ static void -trigger_voice(struct snd_emux_voice *vp) +trigger_voice(snd_emux_voice_t *vp) { int ch = vp->ch; unsigned int temp; - struct snd_emu8000 *hw; + emu8000_t *hw; hw = vp->hw; @@ -332,9 +329,9 @@ trigger_voice(struct snd_emux_voice *vp) * reset voice parameters */ static void -reset_voice(struct snd_emux *emu, int ch) +reset_voice(snd_emux_t *emu, int ch) { - struct snd_emu8000 *hw; + emu8000_t *hw; hw = emu->hw; EMU8000_DCYSUSV_WRITE(hw, ch, 0x807F); @@ -345,7 +342,7 @@ reset_voice(struct snd_emux *emu, int ch) * Set the pitch of a possibly playing note. */ static void -set_pitch(struct snd_emu8000 *hw, struct snd_emux_voice *vp) +set_pitch(emu8000_t *hw, snd_emux_voice_t *vp) { EMU8000_IP_WRITE(hw, vp->ch, vp->apitch); } @@ -354,7 +351,7 @@ set_pitch(struct snd_emu8000 *hw, struct snd_emux_voice *vp) * Set the volume of a possibly already playing note */ static void -set_volume(struct snd_emu8000 *hw, struct snd_emux_voice *vp) +set_volume(emu8000_t *hw, snd_emux_voice_t *vp) { int ifatn; @@ -368,7 +365,7 @@ set_volume(struct snd_emu8000 *hw, struct snd_emux_voice *vp) * Set pan and loop start address. */ static void -set_pan(struct snd_emu8000 *hw, struct snd_emux_voice *vp) +set_pan(emu8000_t *hw, snd_emux_voice_t *vp) { unsigned int temp; @@ -379,7 +376,7 @@ set_pan(struct snd_emu8000 *hw, struct snd_emux_voice *vp) #define MOD_SENSE 18 static void -set_fmmod(struct snd_emu8000 *hw, struct snd_emux_voice *vp) +set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp) { unsigned short fmmod; short pitch; @@ -397,14 +394,14 @@ set_fmmod(struct snd_emu8000 *hw, struct snd_emux_voice *vp) /* set tremolo (lfo1) volume & frequency */ static void -set_tremfreq(struct snd_emu8000 *hw, struct snd_emux_voice *vp) +set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp) { EMU8000_TREMFRQ_WRITE(hw, vp->ch, vp->reg.parm.tremfrq); } /* set lfo2 pitch & frequency */ static void -set_fm2frq2(struct snd_emu8000 *hw, struct snd_emux_voice *vp) +set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp) { unsigned short fm2frq2; short pitch; @@ -422,7 +419,7 @@ set_fm2frq2(struct snd_emu8000 *hw, struct snd_emux_voice *vp) /* set filterQ */ static void -set_filterQ(struct snd_emu8000 *hw, struct snd_emux_voice *vp) +set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp) { unsigned int addr; addr = EMU8000_CCCA_READ(hw, vp->ch) & 0xffffff; @@ -434,7 +431,7 @@ set_filterQ(struct snd_emu8000 *hw, struct snd_emux_voice *vp) * set the envelope & LFO parameters to the default values */ static void -snd_emu8000_tweak_voice(struct snd_emu8000 *emu, int i) +snd_emu8000_tweak_voice(emu8000_t *emu, int i) { /* set all mod/vol envelope shape to minimum */ EMU8000_ENVVOL_WRITE(emu, i, 0x8000); @@ -456,9 +453,9 @@ snd_emu8000_tweak_voice(struct snd_emu8000 *emu, int i) * sysex callback */ static void -sysex(struct snd_emux *emu, char *buf, int len, int parsed, struct snd_midi_channel_set *chset) +sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset) { - struct snd_emu8000 *hw; + emu8000_t *hw; hw = emu->hw; @@ -481,9 +478,9 @@ sysex(struct snd_emux *emu, char *buf, int len, int parsed, struct snd_midi_chan * OSS ioctl callback */ static int -oss_ioctl(struct snd_emux *emu, int cmd, int p1, int p2) +oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2) { - struct snd_emu8000 *hw; + emu8000_t *hw; hw = emu->hw; @@ -526,9 +523,9 @@ oss_ioctl(struct snd_emux *emu, int cmd, int p1, int p2) */ static int -load_fx(struct snd_emux *emu, int type, int mode, const void __user *buf, long len) +load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len) { - struct snd_emu8000 *hw; + emu8000_t *hw; hw = emu->hw; /* skip header */ diff --git a/trunk/sound/isa/sb/emu8000_local.h b/trunk/sound/isa/sb/emu8000_local.h index 2ac77f10bb4e..ea4996a895fc 100644 --- a/trunk/sound/isa/sb/emu8000_local.h +++ b/trunk/sound/isa/sb/emu8000_local.h @@ -30,17 +30,14 @@ #include <sound/emu8000_reg.h> /* emu8000_patch.c */ -int snd_emu8000_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr, - const void __user *data, long count); -int snd_emu8000_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr); -void snd_emu8000_sample_reset(struct snd_emux *rec); +int snd_emu8000_sample_new(snd_emux_t *rec, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr, const void __user *data, long count); +int snd_emu8000_sample_free(snd_emux_t *rec, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr); +void snd_emu8000_sample_reset(snd_emux_t *rec); /* emu8000_callback.c */ -void snd_emu8000_ops_setup(struct snd_emu8000 *emu); +void snd_emu8000_ops_setup(emu8000_t *emu); /* emu8000_pcm.c */ -int snd_emu8000_pcm_new(struct snd_card *card, struct snd_emu8000 *emu, int index); +int snd_emu8000_pcm_new(snd_card_t *card, emu8000_t *emu, int index); #endif /* __EMU8000_LOCAL_H */ diff --git a/trunk/sound/isa/sb/emu8000_patch.c b/trunk/sound/isa/sb/emu8000_patch.c index 80b1cf84a1ae..2fea67e71c78 100644 --- a/trunk/sound/isa/sb/emu8000_patch.c +++ b/trunk/sound/isa/sb/emu8000_patch.c @@ -32,7 +32,7 @@ MODULE_PARM_DESC(emu8000_reset_addr, "reset write address at each time (makes sl * Open up channels. */ static int -snd_emu8000_open_dma(struct snd_emu8000 *emu, int write) +snd_emu8000_open_dma(emu8000_t *emu, int write) { int i; @@ -59,7 +59,7 @@ snd_emu8000_open_dma(struct snd_emu8000 *emu, int write) * Close all dram channels. */ static void -snd_emu8000_close_dma(struct snd_emu8000 *emu) +snd_emu8000_close_dma(emu8000_t *emu) { int i; @@ -106,7 +106,7 @@ read_word(const void __user *buf, int offset, int mode) /* */ static void -snd_emu8000_write_wait(struct snd_emu8000 *emu) +snd_emu8000_write_wait(emu8000_t *emu) { while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) { schedule_timeout_interruptible(1); @@ -128,7 +128,7 @@ snd_emu8000_write_wait(struct snd_emu8000 *emu) * working. */ static inline void -write_word(struct snd_emu8000 *emu, int *offset, unsigned short data) +write_word(emu8000_t *emu, int *offset, unsigned short data) { if (emu8000_reset_addr) { if (emu8000_reset_addr > 1) @@ -144,16 +144,15 @@ write_word(struct snd_emu8000 *emu, int *offset, unsigned short data) * the generic soundfont routines as a callback. */ int -snd_emu8000_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr, - const void __user *data, long count) +snd_emu8000_sample_new(snd_emux_t *rec, snd_sf_sample_t *sp, + snd_util_memhdr_t *hdr, const void __user *data, long count) { int i; int rc; int offset; int truesize; int dram_offset, dram_start; - struct snd_emu8000 *emu; + emu8000_t *emu; emu = rec->hw; snd_assert(sp != NULL, return -EINVAL); @@ -283,8 +282,7 @@ snd_emu8000_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp, * free a sample block */ int -snd_emu8000_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr) +snd_emu8000_sample_free(snd_emux_t *rec, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr) { if (sp->block) { snd_util_mem_free(hdr, sp->block); @@ -298,7 +296,7 @@ snd_emu8000_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp, * sample_reset callback - terminate voices */ void -snd_emu8000_sample_reset(struct snd_emux *rec) +snd_emu8000_sample_reset(snd_emux_t *rec) { snd_emux_terminate_all(rec); } diff --git a/trunk/sound/isa/sb/emu8000_pcm.c b/trunk/sound/isa/sb/emu8000_pcm.c index 91dc3d83e2cf..b323beeeda15 100644 --- a/trunk/sound/isa/sb/emu8000_pcm.c +++ b/trunk/sound/isa/sb/emu8000_pcm.c @@ -46,12 +46,14 @@ */ +typedef struct snd_emu8k_pcm emu8k_pcm_t; + struct snd_emu8k_pcm { - struct snd_emu8000 *emu; - struct snd_pcm_substream *substream; + emu8000_t *emu; + snd_pcm_substream_t *substream; unsigned int allocated_bytes; - struct snd_util_memblk *block; + snd_util_memblk_t *block; unsigned int offset; unsigned int buf_size; unsigned int period_size; @@ -75,7 +77,7 @@ struct snd_emu8k_pcm { * open up channels for the simultaneous data transfer and playback */ static int -emu8k_open_dram_for_pcm(struct snd_emu8000 *emu, int channels) +emu8k_open_dram_for_pcm(emu8000_t *emu, int channels) { int i; @@ -111,7 +113,7 @@ emu8k_open_dram_for_pcm(struct snd_emu8000 *emu, int channels) /* */ static void -snd_emu8000_write_wait(struct snd_emu8000 *emu, int can_schedule) +snd_emu8000_write_wait(emu8000_t *emu, int can_schedule) { while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) { if (can_schedule) { @@ -126,7 +128,7 @@ snd_emu8000_write_wait(struct snd_emu8000 *emu, int can_schedule) * close all channels */ static void -emu8k_close_dram(struct snd_emu8000 *emu) +emu8k_close_dram(emu8000_t *emu) { int i; @@ -154,7 +156,7 @@ static int calc_rate_offset(int hz) /* */ -static struct snd_pcm_hardware emu8k_pcm_hw = { +static snd_pcm_hardware_t emu8k_pcm_hw = { #ifdef USE_NONINTERLEAVE .info = SNDRV_PCM_INFO_NONINTERLEAVED, #else @@ -178,7 +180,7 @@ static struct snd_pcm_hardware emu8k_pcm_hw = { /* * get the current position at the given channel from CCCA register */ -static inline int emu8k_get_curpos(struct snd_emu8k_pcm *rec, int ch) +static inline int emu8k_get_curpos(emu8k_pcm_t *rec, int ch) { int val = EMU8000_CCCA_READ(rec->emu, ch) & 0xfffffff; val -= rec->loop_start[ch] - 1; @@ -192,7 +194,7 @@ static inline int emu8k_get_curpos(struct snd_emu8k_pcm *rec, int ch) */ static void emu8k_pcm_timer_func(unsigned long data) { - struct snd_emu8k_pcm *rec = (struct snd_emu8k_pcm *)data; + emu8k_pcm_t *rec = (emu8k_pcm_t *)data; int ptr, delta; spin_lock(&rec->timer_lock); @@ -224,11 +226,11 @@ static void emu8k_pcm_timer_func(unsigned long data) * open pcm * creating an instance here */ -static int emu8k_pcm_open(struct snd_pcm_substream *subs) +static int emu8k_pcm_open(snd_pcm_substream_t *subs) { - struct snd_emu8000 *emu = snd_pcm_substream_chip(subs); - struct snd_emu8k_pcm *rec; - struct snd_pcm_runtime *runtime = subs->runtime; + emu8000_t *emu = snd_pcm_substream_chip(subs); + emu8k_pcm_t *rec; + snd_pcm_runtime_t *runtime = subs->runtime; rec = kzalloc(sizeof(*rec), GFP_KERNEL); if (! rec) @@ -254,9 +256,9 @@ static int emu8k_pcm_open(struct snd_pcm_substream *subs) return 0; } -static int emu8k_pcm_close(struct snd_pcm_substream *subs) +static int emu8k_pcm_close(snd_pcm_substream_t *subs) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; + emu8k_pcm_t *rec = subs->runtime->private_data; kfree(rec); subs->runtime->private_data = NULL; return 0; @@ -279,9 +281,9 @@ static int calc_pitch_target(int pitch) /* * set up the voice */ -static void setup_voice(struct snd_emu8k_pcm *rec, int ch) +static void setup_voice(emu8k_pcm_t *rec, int ch) { - struct snd_emu8000 *hw = rec->emu; + emu8000_t *hw = rec->emu; unsigned int temp; /* channel to be silent and idle */ @@ -332,10 +334,10 @@ static void setup_voice(struct snd_emu8k_pcm *rec, int ch) /* * trigger the voice */ -static void start_voice(struct snd_emu8k_pcm *rec, int ch) +static void start_voice(emu8k_pcm_t *rec, int ch) { unsigned long flags; - struct snd_emu8000 *hw = rec->emu; + emu8000_t *hw = rec->emu; unsigned int temp, aux; int pt = calc_pitch_target(rec->pitch); @@ -368,10 +370,10 @@ static void start_voice(struct snd_emu8k_pcm *rec, int ch) /* * stop the voice immediately */ -static void stop_voice(struct snd_emu8k_pcm *rec, int ch) +static void stop_voice(emu8k_pcm_t *rec, int ch) { unsigned long flags; - struct snd_emu8000 *hw = rec->emu; + emu8000_t *hw = rec->emu; EMU8000_DCYSUSV_WRITE(hw, ch, 0x807F); @@ -384,9 +386,9 @@ static void stop_voice(struct snd_emu8k_pcm *rec, int ch) spin_unlock_irqrestore(&rec->timer_lock, flags); } -static int emu8k_pcm_trigger(struct snd_pcm_substream *subs, int cmd) +static int emu8k_pcm_trigger(snd_pcm_substream_t *subs, int cmd) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; + emu8k_pcm_t *rec = subs->runtime->private_data; int ch; switch (cmd) { @@ -426,7 +428,7 @@ do { \ #ifdef USE_NONINTERLEAVE /* copy one channel block */ -static int emu8k_transfer_block(struct snd_emu8000 *emu, int offset, unsigned short *buf, int count) +static int emu8k_transfer_block(emu8000_t *emu, int offset, unsigned short *buf, int count) { EMU8000_SMALW_WRITE(emu, offset); while (count > 0) { @@ -440,14 +442,14 @@ static int emu8k_transfer_block(struct snd_emu8000 *emu, int offset, unsigned sh return 0; } -static int emu8k_pcm_copy(struct snd_pcm_substream *subs, +static int emu8k_pcm_copy(snd_pcm_substream_t *subs, int voice, snd_pcm_uframes_t pos, void *src, snd_pcm_uframes_t count) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; - struct snd_emu8000 *emu = rec->emu; + emu8k_pcm_t *rec = subs->runtime->private_data; + emu8000_t *emu = rec->emu; snd_emu8000_write_wait(emu, 1); if (voice == -1) { @@ -467,7 +469,7 @@ static int emu8k_pcm_copy(struct snd_pcm_substream *subs, } /* make a channel block silence */ -static int emu8k_silence_block(struct snd_emu8000 *emu, int offset, int count) +static int emu8k_silence_block(emu8000_t *emu, int offset, int count) { EMU8000_SMALW_WRITE(emu, offset); while (count > 0) { @@ -478,13 +480,13 @@ static int emu8k_silence_block(struct snd_emu8000 *emu, int offset, int count) return 0; } -static int emu8k_pcm_silence(struct snd_pcm_substream *subs, +static int emu8k_pcm_silence(snd_pcm_substream_t *subs, int voice, snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; - struct snd_emu8000 *emu = rec->emu; + emu8k_pcm_t *rec = subs->runtime->private_data; + emu8000_t *emu = rec->emu; snd_emu8000_write_wait(emu, 1); if (voice == -1 && rec->voices == 1) @@ -506,14 +508,14 @@ static int emu8k_pcm_silence(struct snd_pcm_substream *subs, * copy the interleaved data can be done easily by using * DMA "left" and "right" channels on emu8k engine. */ -static int emu8k_pcm_copy(struct snd_pcm_substream *subs, +static int emu8k_pcm_copy(snd_pcm_substream_t *subs, int voice, snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; - struct snd_emu8000 *emu = rec->emu; + emu8k_pcm_t *rec = subs->runtime->private_data; + emu8000_t *emu = rec->emu; unsigned short __user *buf = src; snd_emu8000_write_wait(emu, 1); @@ -537,13 +539,13 @@ static int emu8k_pcm_copy(struct snd_pcm_substream *subs, return 0; } -static int emu8k_pcm_silence(struct snd_pcm_substream *subs, +static int emu8k_pcm_silence(snd_pcm_substream_t *subs, int voice, snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; - struct snd_emu8000 *emu = rec->emu; + emu8k_pcm_t *rec = subs->runtime->private_data; + emu8000_t *emu = rec->emu; snd_emu8000_write_wait(emu, 1); EMU8000_SMALW_WRITE(emu, rec->loop_start[0] + pos); @@ -565,10 +567,10 @@ static int emu8k_pcm_silence(struct snd_pcm_substream *subs, /* * allocate a memory block */ -static int emu8k_pcm_hw_params(struct snd_pcm_substream *subs, - struct snd_pcm_hw_params *hw_params) +static int emu8k_pcm_hw_params(snd_pcm_substream_t *subs, + snd_pcm_hw_params_t *hw_params) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; + emu8k_pcm_t *rec = subs->runtime->private_data; if (rec->block) { /* reallocation - release the old block */ @@ -590,9 +592,9 @@ static int emu8k_pcm_hw_params(struct snd_pcm_substream *subs, /* * free the memory block */ -static int emu8k_pcm_hw_free(struct snd_pcm_substream *subs) +static int emu8k_pcm_hw_free(snd_pcm_substream_t *subs) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; + emu8k_pcm_t *rec = subs->runtime->private_data; if (rec->block) { int ch; @@ -608,9 +610,9 @@ static int emu8k_pcm_hw_free(struct snd_pcm_substream *subs) /* */ -static int emu8k_pcm_prepare(struct snd_pcm_substream *subs) +static int emu8k_pcm_prepare(snd_pcm_substream_t *subs) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; + emu8k_pcm_t *rec = subs->runtime->private_data; rec->pitch = 0xe000 + calc_rate_offset(subs->runtime->rate); rec->last_ptr = 0; @@ -654,16 +656,16 @@ static int emu8k_pcm_prepare(struct snd_pcm_substream *subs) return 0; } -static snd_pcm_uframes_t emu8k_pcm_pointer(struct snd_pcm_substream *subs) +static snd_pcm_uframes_t emu8k_pcm_pointer(snd_pcm_substream_t *subs) { - struct snd_emu8k_pcm *rec = subs->runtime->private_data; + emu8k_pcm_t *rec = subs->runtime->private_data; if (rec->running) return emu8k_get_curpos(rec, 0); return 0; } -static struct snd_pcm_ops emu8k_pcm_ops = { +static snd_pcm_ops_t emu8k_pcm_ops = { .open = emu8k_pcm_open, .close = emu8k_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -677,15 +679,15 @@ static struct snd_pcm_ops emu8k_pcm_ops = { }; -static void snd_emu8000_pcm_free(struct snd_pcm *pcm) +static void snd_emu8000_pcm_free(snd_pcm_t *pcm) { - struct snd_emu8000 *emu = pcm->private_data; + emu8000_t *emu = pcm->private_data; emu->pcm = NULL; } -int snd_emu8000_pcm_new(struct snd_card *card, struct snd_emu8000 *emu, int index) +int snd_emu8000_pcm_new(snd_card_t *card, emu8000_t *emu, int index) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(card, "Emu8000 PCM", index, 1, 0, &pcm)) < 0) diff --git a/trunk/sound/isa/sb/emu8000_synth.c b/trunk/sound/isa/sb/emu8000_synth.c index 3d72742b342f..f68e217416a6 100644 --- a/trunk/sound/isa/sb/emu8000_synth.c +++ b/trunk/sound/isa/sb/emu8000_synth.c @@ -33,12 +33,12 @@ MODULE_LICENSE("GPL"); /* * create a new hardware dependent device for Emu8000 */ -static int snd_emu8000_new_device(struct snd_seq_device *dev) +static int snd_emu8000_new_device(snd_seq_device_t *dev) { - struct snd_emu8000 *hw; - struct snd_emux *emu; + emu8000_t *hw; + snd_emux_t *emu; - hw = *(struct snd_emu8000**)SNDRV_SEQ_DEVICE_ARGPTR(dev); + hw = *(emu8000_t**)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (hw == NULL) return -EINVAL; @@ -92,9 +92,9 @@ static int snd_emu8000_new_device(struct snd_seq_device *dev) /* * free all resources */ -static int snd_emu8000_delete_device(struct snd_seq_device *dev) +static int snd_emu8000_delete_device(snd_seq_device_t *dev) { - struct snd_emu8000 *hw; + emu8000_t *hw; if (dev->driver_data == NULL) return 0; /* no synth was allocated actually */ @@ -118,12 +118,11 @@ static int snd_emu8000_delete_device(struct snd_seq_device *dev) static int __init alsa_emu8000_init(void) { - static struct snd_seq_dev_ops ops = { + static snd_seq_dev_ops_t ops = { snd_emu8000_new_device, snd_emu8000_delete_device, }; - return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_EMU8000, &ops, - sizeof(struct snd_emu8000*)); + return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_EMU8000, &ops, sizeof(emu8000_t*)); } static void __exit alsa_emu8000_exit(void) diff --git a/trunk/sound/isa/sb/es968.c b/trunk/sound/isa/sb/es968.c index 9da80bfa3027..c859917c14db 100644 --- a/trunk/sound/isa/sb/es968.c +++ b/trunk/sound/isa/sb/es968.c @@ -58,7 +58,6 @@ MODULE_PARM_DESC(dma8, "8-bit DMA # for es968 driver."); struct snd_card_es968 { struct pnp_dev *dev; - struct snd_sb *chip; }; static struct pnp_card_device_id snd_es968_pnpids[] = { @@ -73,7 +72,7 @@ MODULE_DEVICE_TABLE(pnp_card, snd_es968_pnpids); static irqreturn_t snd_card_es968_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_sb *chip = dev_id; + sb_t *chip = dev_id; if (chip->open & SB_OPEN_PCM) { return snd_sb8dsp_interrupt(chip); @@ -129,14 +128,14 @@ static int __init snd_card_es968_probe(int dev, const struct pnp_card_device_id *pid) { int error; - struct snd_sb *chip; - struct snd_card *card; + sb_t *chip; + snd_card_t *card; struct snd_card_es968 *acard; if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_card_es968))) == NULL) return -ENOMEM; - acard = card->private_data; + acard = (struct snd_card_es968 *)card->private_data; if ((error = snd_card_es968_pnp(dev, acard, pcard, pid))) { snd_card_free(card); return error; @@ -152,7 +151,6 @@ static int __init snd_card_es968_probe(int dev, snd_card_free(card); return error; } - acard->chip = chip; if ((error = snd_sb8dsp_pcm(chip, 0, NULL)) < 0) { snd_card_free(card); @@ -202,59 +200,30 @@ static int __devinit snd_es968_pnp_detect(struct pnp_card_link *card, static void __devexit snd_es968_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); -} - -#ifdef CONFIG_PM -static int snd_es968_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_es968 *acard = card->private_data; - struct snd_sb *chip = acard->chip; + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(chip->pcm); - snd_sbmixer_suspend(chip); - return 0; + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -static int snd_es968_pnp_resume(struct pnp_card_link *pcard) -{ - struct snd_card *card = pnp_get_card_drvdata(pcard); - struct snd_card_es968 *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_sbdsp_reset(chip); - snd_sbmixer_resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - static struct pnp_card_driver es968_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, .name = "es968", .id_table = snd_es968_pnpids, .probe = snd_es968_pnp_detect, .remove = __devexit_p(snd_es968_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_es968_pnp_suspend, - .resume = snd_es968_pnp_resume, -#endif }; static int __init alsa_card_es968_init(void) { int cards = pnp_register_card_driver(&es968_pnpc_driver); - if (cards <= 0) { - pnp_unregister_card_driver(&es968_pnpc_driver); #ifdef MODULE + if (cards == 0) { + pnp_unregister_card_driver(&es968_pnpc_driver); snd_printk(KERN_ERR "no ES968 based soundcards found\n"); -#endif - return -ENODEV; } - return 0; +#endif + return cards ? 0 : -ENODEV; } static void __exit alsa_card_es968_exit(void) diff --git a/trunk/sound/isa/sb/sb16.c b/trunk/sound/isa/sb/sb16.c index c0be7a5a3425..c2fa451bc8f0 100644 --- a/trunk/sound/isa/sb/sb16.c +++ b/trunk/sound/isa/sb/sb16.c @@ -24,8 +24,6 @@ #include <linux/init.h> #include <linux/slab.h> #include <linux/pnp.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/sb.h> @@ -34,6 +32,7 @@ #include <sound/opl3.h> #include <sound/emu8000.h> #include <sound/seq_device.h> +#define SNDRV_LEGACY_AUTO_PROBE #define SNDRV_LEGACY_FIND_FREE_IRQ #define SNDRV_LEGACY_FIND_FREE_DMA #include <sound/initval.h> @@ -128,14 +127,8 @@ module_param_array(seq_ports, int, NULL, 0444); MODULE_PARM_DESC(seq_ports, "Number of sequencer ports for WaveTable synth."); #endif -static struct platform_device *platform_devices[SNDRV_CARDS]; -#ifdef CONFIG_PNP -static int pnp_registered; -#endif - struct snd_card_sb16 { struct resource *fm_res; /* used to block FM i/o region for legacy cards */ - struct snd_sb *chip; #ifdef CONFIG_PNP int dev_no; struct pnp_dev *dev; @@ -145,6 +138,8 @@ struct snd_card_sb16 { #endif }; +static snd_card_t *snd_sb16_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; + #ifdef CONFIG_PNP static struct pnp_card_device_id snd_sb16_pnpids[] = { @@ -344,9 +339,9 @@ static int __devinit snd_card_sb16_pnp(int dev, struct snd_card_sb16 *acard, #endif /* CONFIG_PNP */ -static void snd_sb16_free(struct snd_card *card) +static void snd_sb16_free(snd_card_t *card) { - struct snd_card_sb16 *acard = card->private_data; + struct snd_card_sb16 *acard = (struct snd_card_sb16 *)card->private_data; if (acard == NULL) return; @@ -359,32 +354,73 @@ static void snd_sb16_free(struct snd_card *card) #define is_isapnp_selected(dev) 0 #endif -static struct snd_card *snd_sb16_card_new(int dev) -{ - struct snd_card *card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof(struct snd_card_sb16)); - if (card == NULL) - return NULL; - card->private_free = snd_sb16_free; - return card; -} - -static int __init snd_sb16_probe(struct snd_card *card, int dev) +static int __init snd_sb16_probe(int dev, + struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { + static int possible_irqs[] = {5, 9, 10, 7, -1}; + static int possible_dmas8[] = {1, 3, 0, -1}; + static int possible_dmas16[] = {5, 6, 7, -1}; int xirq, xdma8, xdma16; - struct snd_sb *chip; - struct snd_card_sb16 *acard = card->private_data; - struct snd_opl3 *opl3; - struct snd_hwdep *synth = NULL; + sb_t *chip; + snd_card_t *card; + struct snd_card_sb16 *acard; + opl3_t *opl3; + snd_hwdep_t *synth = NULL; #ifdef CONFIG_SND_SB16_CSP - struct snd_hwdep *xcsp = NULL; + snd_hwdep_t *xcsp = NULL; #endif unsigned long flags; int err; + card = snd_card_new(index[dev], id[dev], THIS_MODULE, + sizeof(struct snd_card_sb16)); + if (card == NULL) + return -ENOMEM; + acard = (struct snd_card_sb16 *) card->private_data; + card->private_free = snd_sb16_free; +#ifdef CONFIG_PNP + if (isapnp[dev]) { + if ((err = snd_card_sb16_pnp(dev, acard, pcard, pid))) + goto _err; + snd_card_set_dev(card, &pcard->card->dev); + } +#endif + xirq = irq[dev]; xdma8 = dma8[dev]; xdma16 = dma16[dev]; + if (! is_isapnp_selected(dev)) { + if (xirq == SNDRV_AUTO_IRQ) { + if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); + err = -EBUSY; + goto _err; + } + } + if (xdma8 == SNDRV_AUTO_DMA) { + if ((xdma8 = snd_legacy_find_free_dma(possible_dmas8)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free 8-bit DMA\n"); + err = -EBUSY; + goto _err; + } + } + if (xdma16 == SNDRV_AUTO_DMA) { + if ((xdma16 = snd_legacy_find_free_dma(possible_dmas16)) < 0) { + snd_printk(KERN_ERR PFX "unable to find a free 16-bit DMA\n"); + err = -EBUSY; + goto _err; + } + } + /* non-PnP FM port address is hardwired with base port address */ + fm_port[dev] = port[dev]; + /* block the 0x388 port to avoid PnP conflicts */ + acard->fm_res = request_region(0x388, 4, "SoundBlaster FM"); +#ifdef SNDRV_SBAWE_EMU8000 + /* non-PnP AWE port address is hardwired with base port address */ + awe_port[dev] = port[dev] + 0x400; +#endif + } if ((err = snd_sbdsp_create(card, port[dev], @@ -394,19 +430,19 @@ static int __init snd_sb16_probe(struct snd_card *card, int dev) xdma16, SB_HW_AUTO, &chip)) < 0) - return err; + goto _err; - acard->chip = chip; if (chip->hardware != SB_HW_16) { snd_printk(KERN_ERR PFX "SB 16 chip was not detected at 0x%lx\n", port[dev]); - return -ENODEV; + err = -ENODEV; + goto _err; } chip->mpu_port = mpu_port[dev]; if (! is_isapnp_selected(dev) && (err = snd_sb16dsp_configure(chip)) < 0) - return err; + goto _err; - if ((err = snd_sb16dsp_pcm(chip, 0, &chip->pcm)) < 0) - return err; + if ((err = snd_sb16dsp_pcm(chip, 0, NULL)) < 0) + goto _err; strcpy(card->driver, #ifdef SNDRV_SBAWE_EMU8000 @@ -428,7 +464,7 @@ static int __init snd_sb16_probe(struct snd_card *card, int dev) if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_SB, chip->mpu_port, 0, xirq, 0, &chip->rmidi)) < 0) - return err; + goto _err; chip->rmidi_callback = snd_mpu401_uart_interrupt; } @@ -451,12 +487,12 @@ static int __init snd_sb16_probe(struct snd_card *card, int dev) int seqdev = 1; #endif if ((err = snd_opl3_hwdep_new(opl3, 0, seqdev, &synth)) < 0) - return err; + goto _err; } } if ((err = snd_sbmixer_new(chip)) < 0) - return err; + goto _err; #ifdef CONFIG_SND_SB16_CSP /* CSP chip on SB16ASP/AWE32 */ @@ -476,7 +512,7 @@ static int __init snd_sb16_probe(struct snd_card *card, int dev) seq_ports[dev], NULL)) < 0) { snd_printk(KERN_ERR PFX "fatal error - EMU-8000 synthesizer not detected at 0x%lx\n", awe_port[dev]); - return err; + goto _err; } } #endif @@ -488,168 +524,56 @@ static int __init snd_sb16_probe(struct snd_card *card, int dev) (mic_agc[dev] ? 0x00 : 0x01)); spin_unlock_irqrestore(&chip->mixer_lock, flags); - if ((err = snd_card_register(card)) < 0) - return err; - - return 0; -} - -#ifdef CONFIG_PM -static int snd_sb16_suspend(struct snd_card *card, pm_message_t state) -{ - struct snd_card_sb16 *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(chip->pcm); - snd_sbmixer_suspend(chip); - return 0; -} + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; -static int snd_sb16_resume(struct snd_card *card) -{ - struct snd_card_sb16 *acard = card->private_data; - struct snd_sb *chip = acard->chip; + if ((err = snd_card_register(card)) < 0) + goto _err; - snd_sbdsp_reset(chip); - snd_sbmixer_resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); + if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_sb16_legacy[dev] = card; return 0; -} -#endif - -static int __init snd_sb16_nonpnp_probe1(int dev, struct platform_device *devptr) -{ - struct snd_card_sb16 *acard; - struct snd_card *card; - int err; - - card = snd_sb16_card_new(dev); - if (! card) - return -ENOMEM; - acard = card->private_data; - /* non-PnP FM port address is hardwired with base port address */ - fm_port[dev] = port[dev]; - /* block the 0x388 port to avoid PnP conflicts */ - acard->fm_res = request_region(0x388, 4, "SoundBlaster FM"); -#ifdef SNDRV_SBAWE_EMU8000 - /* non-PnP AWE port address is hardwired with base port address */ - awe_port[dev] = port[dev] + 0x400; -#endif - - snd_card_set_dev(card, &devptr->dev); - if ((err = snd_sb16_probe(card, dev)) < 0) { - snd_card_free(card); - return err; - } - platform_set_drvdata(devptr, card); - return 0; + _err: + snd_card_free(card); + return err; } - -static int __init snd_sb16_nonpnp_probe(struct platform_device *pdev) +static int __init snd_sb16_probe_legacy_port(unsigned long xport) { - int dev = pdev->id; - int err; - static int possible_irqs[] = {5, 9, 10, 7, -1}; - static int possible_dmas8[] = {1, 3, 0, -1}; - static int possible_dmas16[] = {5, 6, 7, -1}; - - if (irq[dev] == SNDRV_AUTO_IRQ) { - if ((irq[dev] = snd_legacy_find_free_irq(possible_irqs)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); - return -EBUSY; - } - } - if (dma8[dev] == SNDRV_AUTO_DMA) { - if ((dma8[dev] = snd_legacy_find_free_dma(possible_dmas8)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free 8-bit DMA\n"); - return -EBUSY; - } - } - if (dma16[dev] == SNDRV_AUTO_DMA) { - if ((dma16[dev] = snd_legacy_find_free_dma(possible_dmas16)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free 16-bit DMA\n"); - return -EBUSY; - } - } + static int dev; + int res; - if (port[dev] != SNDRV_AUTO_PORT) - return snd_sb16_nonpnp_probe1(dev, pdev); - else { - static int possible_ports[] = {0x220, 0x240, 0x260, 0x280}; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - port[dev] = possible_ports[i]; - err = snd_sb16_nonpnp_probe1(dev, pdev); - if (! err) - return 0; - } - return err; + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; + if (is_isapnp_selected(dev)) + continue; + port[dev] = xport; + res = snd_sb16_probe(dev, NULL, NULL); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; } + return -ENODEV; } -static int __devexit snd_sb16_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_sb16_nonpnp_suspend(struct platform_device *dev, pm_message_t state) -{ - return snd_sb16_suspend(platform_get_drvdata(dev), state); -} - -static int snd_sb16_nonpnp_resume(struct platform_device *dev) -{ - return snd_sb16_resume(platform_get_drvdata(dev)); -} -#endif - -#ifdef SNDRV_SBAWE -#define SND_SB16_DRIVER "snd_sbawe" -#else -#define SND_SB16_DRIVER "snd_sb16" -#endif - -static struct platform_driver snd_sb16_nonpnp_driver = { - .probe = snd_sb16_nonpnp_probe, - .remove = __devexit_p(snd_sb16_nonpnp_remove), -#ifdef CONFIG_PM - .suspend = snd_sb16_nonpnp_suspend, - .resume = snd_sb16_nonpnp_resume, -#endif - .driver = { - .name = SND_SB16_DRIVER - }, -}; - - #ifdef CONFIG_PNP -static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *pcard, - const struct pnp_card_device_id *pid) +static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *card, + const struct pnp_card_device_id *id) { static int dev; - struct snd_card *card; int res; for ( ; dev < SNDRV_CARDS; dev++) { if (!enable[dev] || !isapnp[dev]) continue; - card = snd_sb16_card_new(dev); - if (! card) - return -ENOMEM; - snd_card_set_dev(card, &pcard->card->dev); - if ((res = snd_card_sb16_pnp(dev, card->private_data, pcard, pid)) < 0 || - (res = snd_sb16_probe(card, dev)) < 0) { - snd_card_free(card); + res = snd_sb16_probe(dev, card, id); + if (res < 0) return res; - } - pnp_set_card_drvdata(pcard, card); dev++; return 0; } @@ -659,82 +583,57 @@ static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *pcard, static void __devexit snd_sb16_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); -} + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); -#ifdef CONFIG_PM -static int snd_sb16_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) -{ - return snd_sb16_suspend(pnp_get_card_drvdata(pcard), state); + snd_card_disconnect(card); + snd_card_free_in_thread(card); } -static int snd_sb16_pnp_resume(struct pnp_card_link *pcard) -{ - return snd_sb16_resume(pnp_get_card_drvdata(pcard)); -} -#endif static struct pnp_card_driver sb16_pnpc_driver = { .flags = PNP_DRIVER_RES_DISABLE, -#ifdef SNDRV_SBAWE - .name = "sbawe", -#else .name = "sb16", -#endif .id_table = snd_sb16_pnpids, .probe = snd_sb16_pnp_detect, .remove = __devexit_p(snd_sb16_pnp_remove), -#ifdef CONFIG_PM - .suspend = snd_sb16_pnp_suspend, - .resume = snd_sb16_pnp_resume, -#endif }; #endif /* CONFIG_PNP */ -static void __init_or_module snd_sb16_unregister_all(void) -{ - int i; - -#ifdef CONFIG_PNP - if (pnp_registered) - pnp_unregister_card_driver(&sb16_pnpc_driver); -#endif - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_sb16_nonpnp_driver); -} - static int __init alsa_card_sb16_init(void) { - int i, err, cards = 0; + int dev, cards = 0, i; + static unsigned long possible_ports[] = {0x220, 0x240, 0x260, 0x280, -1}; - if ((err = platform_driver_register(&snd_sb16_nonpnp_driver)) < 0) - return err; - - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - if (is_isapnp_selected(i)) + /* legacy non-auto cards at first */ + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT) + continue; + if (is_isapnp_selected(dev)) + continue; + if (!snd_sb16_probe(dev, NULL, NULL)) { + cards++; continue; - device = platform_device_register_simple(SND_SB16_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; } - platform_devices[i] = device; - cards++; +#ifdef MODULE + snd_printk(KERN_ERR "Sound Blaster 16+ soundcard #%i not found at 0x%lx or device busy\n", dev, port[dev]); +#endif } + /* legacy auto configured cards */ + i = snd_legacy_auto_probe(possible_ports, snd_sb16_probe_legacy_port); + if (i > 0) + cards += i; + #ifdef CONFIG_PNP /* PnP cards at last */ i = pnp_register_card_driver(&sb16_pnpc_driver); - if (i >= 0) { - pnp_registered = 1; + if (i >0) cards += i; - } #endif if (!cards) { +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&sb16_pnpc_driver); +#endif #ifdef MODULE snd_printk(KERN_ERR "Sound Blaster 16 soundcard not found or device busy\n"); #ifdef SNDRV_SBAWE_EMU8000 @@ -743,19 +642,21 @@ static int __init alsa_card_sb16_init(void) snd_printk(KERN_ERR "In case, if you have AWE card, try snd-sbawe module\n"); #endif #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_sb16_unregister_all(); - return err; } static void __exit alsa_card_sb16_exit(void) { - snd_sb16_unregister_all(); + int dev; + +#ifdef CONFIG_PNP + /* PnP cards first */ + pnp_unregister_card_driver(&sb16_pnpc_driver); +#endif + for (dev = 0; dev < SNDRV_CARDS; dev++) + snd_card_free(snd_sb16_legacy[dev]); } module_init(alsa_card_sb16_init) diff --git a/trunk/sound/isa/sb/sb16_csp.c b/trunk/sound/isa/sb/sb16_csp.c index 9c2b5efbacbf..7192d4c758e6 100644 --- a/trunk/sound/isa/sb/sb16_csp.c +++ b/trunk/sound/isa/sb/sb16_csp.c @@ -72,47 +72,46 @@ struct desc_header { /* * prototypes */ -static void snd_sb_csp_free(struct snd_hwdep *hw); -static int snd_sb_csp_open(struct snd_hwdep * hw, struct file *file); -static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg); -static int snd_sb_csp_release(struct snd_hwdep * hw, struct file *file); - -static int csp_detect(struct snd_sb *chip, int *version); -static int set_codec_parameter(struct snd_sb *chip, unsigned char par, unsigned char val); -static int set_register(struct snd_sb *chip, unsigned char reg, unsigned char val); -static int read_register(struct snd_sb *chip, unsigned char reg); -static int set_mode_register(struct snd_sb *chip, unsigned char mode); -static int get_version(struct snd_sb *chip); - -static int snd_sb_csp_riff_load(struct snd_sb_csp * p, - struct snd_sb_csp_microcode __user * code); -static int snd_sb_csp_unload(struct snd_sb_csp * p); -static int snd_sb_csp_load_user(struct snd_sb_csp * p, const unsigned char __user *buf, int size, int load_flags); -static int snd_sb_csp_autoload(struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode); -static int snd_sb_csp_check_version(struct snd_sb_csp * p); - -static int snd_sb_csp_use(struct snd_sb_csp * p); -static int snd_sb_csp_unuse(struct snd_sb_csp * p); -static int snd_sb_csp_start(struct snd_sb_csp * p, int sample_width, int channels); -static int snd_sb_csp_stop(struct snd_sb_csp * p); -static int snd_sb_csp_pause(struct snd_sb_csp * p); -static int snd_sb_csp_restart(struct snd_sb_csp * p); - -static int snd_sb_qsound_build(struct snd_sb_csp * p); -static void snd_sb_qsound_destroy(struct snd_sb_csp * p); -static int snd_sb_csp_qsound_transfer(struct snd_sb_csp * p); - -static int init_proc_entry(struct snd_sb_csp * p, int device); -static void info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer); +static void snd_sb_csp_free(snd_hwdep_t *hw); +static int snd_sb_csp_open(snd_hwdep_t * hw, struct file *file); +static int snd_sb_csp_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg); +static int snd_sb_csp_release(snd_hwdep_t * hw, struct file *file); + +static int csp_detect(sb_t *chip, int *version); +static int set_codec_parameter(sb_t *chip, unsigned char par, unsigned char val); +static int set_register(sb_t *chip, unsigned char reg, unsigned char val); +static int read_register(sb_t *chip, unsigned char reg); +static int set_mode_register(sb_t *chip, unsigned char mode); +static int get_version(sb_t *chip); + +static int snd_sb_csp_riff_load(snd_sb_csp_t * p, snd_sb_csp_microcode_t __user * code); +static int snd_sb_csp_unload(snd_sb_csp_t * p); +static int snd_sb_csp_load_user(snd_sb_csp_t * p, const unsigned char __user *buf, int size, int load_flags); +static int snd_sb_csp_autoload(snd_sb_csp_t * p, int pcm_sfmt, int play_rec_mode); +static int snd_sb_csp_check_version(snd_sb_csp_t * p); + +static int snd_sb_csp_use(snd_sb_csp_t * p); +static int snd_sb_csp_unuse(snd_sb_csp_t * p); +static int snd_sb_csp_start(snd_sb_csp_t * p, int sample_width, int channels); +static int snd_sb_csp_stop(snd_sb_csp_t * p); +static int snd_sb_csp_pause(snd_sb_csp_t * p); +static int snd_sb_csp_restart(snd_sb_csp_t * p); + +static int snd_sb_qsound_build(snd_sb_csp_t * p); +static void snd_sb_qsound_destroy(snd_sb_csp_t * p); +static int snd_sb_csp_qsound_transfer(snd_sb_csp_t * p); + +static int init_proc_entry(snd_sb_csp_t * p, int device); +static void info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer); /* * Detect CSP chip and create a new instance */ -int snd_sb_csp_new(struct snd_sb *chip, int device, struct snd_hwdep ** rhwdep) +int snd_sb_csp_new(sb_t *chip, int device, snd_hwdep_t ** rhwdep) { - struct snd_sb_csp *p; + snd_sb_csp_t *p; int version, err; - struct snd_hwdep *hw; + snd_hwdep_t *hw; if (rhwdep) *rhwdep = NULL; @@ -159,9 +158,9 @@ int snd_sb_csp_new(struct snd_sb *chip, int device, struct snd_hwdep ** rhwdep) /* * free_private for hwdep instance */ -static void snd_sb_csp_free(struct snd_hwdep *hwdep) +static void snd_sb_csp_free(snd_hwdep_t *hwdep) { - struct snd_sb_csp *p = hwdep->private_data; + snd_sb_csp_t *p = hwdep->private_data; if (p) { if (p->running & SNDRV_SB_CSP_ST_RUNNING) snd_sb_csp_stop(p); @@ -174,20 +173,20 @@ static void snd_sb_csp_free(struct snd_hwdep *hwdep) /* * open the device exclusively */ -static int snd_sb_csp_open(struct snd_hwdep * hw, struct file *file) +static int snd_sb_csp_open(snd_hwdep_t * hw, struct file *file) { - struct snd_sb_csp *p = hw->private_data; + snd_sb_csp_t *p = hw->private_data; return (snd_sb_csp_use(p)); } /* * ioctl for hwdep device: */ -static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg) +static int snd_sb_csp_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_sb_csp *p = hw->private_data; - struct snd_sb_csp_info info; - struct snd_sb_csp_start start_info; + snd_sb_csp_t *p = hw->private_data; + snd_sb_csp_info_t info; + snd_sb_csp_start_t start_info; int err; snd_assert(p != NULL, return -EINVAL); @@ -218,7 +217,7 @@ static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned i /* load CSP microcode */ case SNDRV_SB_CSP_IOCTL_LOAD_CODE: err = (p->running & SNDRV_SB_CSP_ST_RUNNING ? - -EBUSY : snd_sb_csp_riff_load(p, (struct snd_sb_csp_microcode __user *) arg)); + -EBUSY : snd_sb_csp_riff_load(p, (snd_sb_csp_microcode_t __user *) arg)); break; case SNDRV_SB_CSP_IOCTL_UNLOAD_CODE: err = (p->running & SNDRV_SB_CSP_ST_RUNNING ? @@ -252,9 +251,9 @@ static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned i /* * close the device */ -static int snd_sb_csp_release(struct snd_hwdep * hw, struct file *file) +static int snd_sb_csp_release(snd_hwdep_t * hw, struct file *file) { - struct snd_sb_csp *p = hw->private_data; + snd_sb_csp_t *p = hw->private_data; return (snd_sb_csp_unuse(p)); } @@ -263,7 +262,7 @@ static int snd_sb_csp_release(struct snd_hwdep * hw, struct file *file) /* * acquire device */ -static int snd_sb_csp_use(struct snd_sb_csp * p) +static int snd_sb_csp_use(snd_sb_csp_t * p) { down(&p->access_mutex); if (p->used) { @@ -280,7 +279,7 @@ static int snd_sb_csp_use(struct snd_sb_csp * p) /* * release device */ -static int snd_sb_csp_unuse(struct snd_sb_csp * p) +static int snd_sb_csp_unuse(snd_sb_csp_t * p) { down(&p->access_mutex); p->used--; @@ -293,10 +292,9 @@ static int snd_sb_csp_unuse(struct snd_sb_csp * p) * load microcode via ioctl: * code is user-space pointer */ -static int snd_sb_csp_riff_load(struct snd_sb_csp * p, - struct snd_sb_csp_microcode __user * mcode) +static int snd_sb_csp_riff_load(snd_sb_csp_t * p, snd_sb_csp_microcode_t __user * mcode) { - struct snd_sb_csp_mc_header info; + snd_sb_csp_mc_header_t info; unsigned char __user *data_ptr; unsigned char __user *data_end; @@ -451,7 +449,7 @@ static int snd_sb_csp_riff_load(struct snd_sb_csp * p, /* * unload CSP microcode */ -static int snd_sb_csp_unload(struct snd_sb_csp * p) +static int snd_sb_csp_unload(snd_sb_csp_t * p) { if (p->running & SNDRV_SB_CSP_ST_RUNNING) return -EBUSY; @@ -474,7 +472,7 @@ static int snd_sb_csp_unload(struct snd_sb_csp * p) /* * send command sequence to DSP */ -static inline int command_seq(struct snd_sb *chip, const unsigned char *seq, int size) +static inline int command_seq(sb_t *chip, const unsigned char *seq, int size) { int i; for (i = 0; i < size; i++) { @@ -487,7 +485,7 @@ static inline int command_seq(struct snd_sb *chip, const unsigned char *seq, int /* * set CSP codec parameter */ -static int set_codec_parameter(struct snd_sb *chip, unsigned char par, unsigned char val) +static int set_codec_parameter(sb_t *chip, unsigned char par, unsigned char val) { unsigned char dsp_cmd[3]; @@ -504,7 +502,7 @@ static int set_codec_parameter(struct snd_sb *chip, unsigned char par, unsigned /* * set CSP register */ -static int set_register(struct snd_sb *chip, unsigned char reg, unsigned char val) +static int set_register(sb_t *chip, unsigned char reg, unsigned char val) { unsigned char dsp_cmd[3]; @@ -518,7 +516,7 @@ static int set_register(struct snd_sb *chip, unsigned char reg, unsigned char va * read CSP register * return < 0 -> error */ -static int read_register(struct snd_sb *chip, unsigned char reg) +static int read_register(sb_t *chip, unsigned char reg) { unsigned char dsp_cmd[2]; @@ -531,7 +529,7 @@ static int read_register(struct snd_sb *chip, unsigned char reg) /* * set CSP mode register */ -static int set_mode_register(struct snd_sb *chip, unsigned char mode) +static int set_mode_register(sb_t *chip, unsigned char mode) { unsigned char dsp_cmd[2]; @@ -544,7 +542,7 @@ static int set_mode_register(struct snd_sb *chip, unsigned char mode) * Detect CSP * return 0 if CSP exists. */ -static int csp_detect(struct snd_sb *chip, int *version) +static int csp_detect(sb_t *chip, int *version) { unsigned char csp_test1, csp_test2; unsigned long flags; @@ -581,7 +579,7 @@ static int csp_detect(struct snd_sb *chip, int *version) /* * get CSP version number */ -static int get_version(struct snd_sb *chip) +static int get_version(sb_t *chip) { unsigned char dsp_cmd[2]; @@ -595,7 +593,7 @@ static int get_version(struct snd_sb *chip) /* * check if the CSP version is valid */ -static int snd_sb_csp_check_version(struct snd_sb_csp * p) +static int snd_sb_csp_check_version(snd_sb_csp_t * p) { if (p->version < 0x10 || p->version > 0x1f) { snd_printd("%s: Invalid CSP version: 0x%x\n", __FUNCTION__, p->version); @@ -607,7 +605,7 @@ static int snd_sb_csp_check_version(struct snd_sb_csp * p) /* * download microcode to CSP (microcode should have one "main" block). */ -static int snd_sb_csp_load(struct snd_sb_csp * p, const unsigned char *buf, int size, int load_flags) +static int snd_sb_csp_load(snd_sb_csp_t * p, const unsigned char *buf, int size, int load_flags) { int status, i; int err; @@ -673,7 +671,7 @@ static int snd_sb_csp_load(struct snd_sb_csp * p, const unsigned char *buf, int return result; } -static int snd_sb_csp_load_user(struct snd_sb_csp * p, const unsigned char __user *buf, int size, int load_flags) +static int snd_sb_csp_load_user(snd_sb_csp_t * p, const unsigned char __user *buf, int size, int load_flags) { int err = -ENOMEM; unsigned char *kbuf = kmalloc(size, GFP_KERNEL); @@ -693,7 +691,7 @@ static int snd_sb_csp_load_user(struct snd_sb_csp * p, const unsigned char __use * autoload hardware codec if necessary * return 0 if CSP is loaded and ready to run (p->running != 0) */ -static int snd_sb_csp_autoload(struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode) +static int snd_sb_csp_autoload(snd_sb_csp_t * p, int pcm_sfmt, int play_rec_mode) { unsigned long flags; int err = 0; @@ -765,7 +763,7 @@ static int snd_sb_csp_autoload(struct snd_sb_csp * p, int pcm_sfmt, int play_rec /* * start CSP */ -static int snd_sb_csp_start(struct snd_sb_csp * p, int sample_width, int channels) +static int snd_sb_csp_start(snd_sb_csp_t * p, int sample_width, int channels) { unsigned char s_type; /* sample type */ unsigned char mixL, mixR; @@ -844,7 +842,7 @@ static int snd_sb_csp_start(struct snd_sb_csp * p, int sample_width, int channel /* * stop CSP */ -static int snd_sb_csp_stop(struct snd_sb_csp * p) +static int snd_sb_csp_stop(snd_sb_csp_t * p) { int result; unsigned char mixL, mixR; @@ -885,7 +883,7 @@ static int snd_sb_csp_stop(struct snd_sb_csp * p) /* * pause CSP codec and hold DMA transfer */ -static int snd_sb_csp_pause(struct snd_sb_csp * p) +static int snd_sb_csp_pause(snd_sb_csp_t * p) { int result; unsigned long flags; @@ -905,7 +903,7 @@ static int snd_sb_csp_pause(struct snd_sb_csp * p) /* * restart CSP codec and resume DMA transfer */ -static int snd_sb_csp_restart(struct snd_sb_csp * p) +static int snd_sb_csp_restart(snd_sb_csp_t * p) { int result; unsigned long flags; @@ -928,7 +926,7 @@ static int snd_sb_csp_restart(struct snd_sb_csp * p) * QSound mixer control for PCM */ -static int snd_sb_qsound_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sb_qsound_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -937,17 +935,17 @@ static int snd_sb_qsound_switch_info(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_sb_qsound_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb_qsound_switch_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol); + snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = p->q_enabled ? 1 : 0; return 0; } -static int snd_sb_qsound_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb_qsound_switch_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol); + snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned char nval; @@ -960,7 +958,7 @@ static int snd_sb_qsound_switch_put(struct snd_kcontrol *kcontrol, struct snd_ct return change; } -static int snd_sb_qsound_space_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sb_qsound_space_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -969,9 +967,9 @@ static int snd_sb_qsound_space_info(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_sb_qsound_space_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb_qsound_space_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol); + snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&p->q_lock, flags); @@ -981,9 +979,9 @@ static int snd_sb_qsound_space_get(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_sb_qsound_space_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb_qsound_space_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb_csp *p = snd_kcontrol_chip(kcontrol); + snd_sb_csp_t *p = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned char nval1, nval2; @@ -1003,7 +1001,7 @@ static int snd_sb_qsound_space_put(struct snd_kcontrol *kcontrol, struct snd_ctl return change; } -static struct snd_kcontrol_new snd_sb_qsound_switch = { +static snd_kcontrol_new_t snd_sb_qsound_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "3D Control - Switch", .info = snd_sb_qsound_switch_info, @@ -1011,7 +1009,7 @@ static struct snd_kcontrol_new snd_sb_qsound_switch = { .put = snd_sb_qsound_switch_put }; -static struct snd_kcontrol_new snd_sb_qsound_space = { +static snd_kcontrol_new_t snd_sb_qsound_space = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "3D Control - Space", .info = snd_sb_qsound_space_info, @@ -1019,9 +1017,9 @@ static struct snd_kcontrol_new snd_sb_qsound_space = { .put = snd_sb_qsound_space_put }; -static int snd_sb_qsound_build(struct snd_sb_csp * p) +static int snd_sb_qsound_build(snd_sb_csp_t * p) { - struct snd_card *card; + snd_card_t * card; int err; snd_assert(p != NULL, return -EINVAL); @@ -1044,9 +1042,9 @@ static int snd_sb_qsound_build(struct snd_sb_csp * p) return err; } -static void snd_sb_qsound_destroy(struct snd_sb_csp * p) +static void snd_sb_qsound_destroy(snd_sb_csp_t * p) { - struct snd_card *card; + snd_card_t * card; unsigned long flags; snd_assert(p != NULL, return); @@ -1070,7 +1068,7 @@ static void snd_sb_qsound_destroy(struct snd_sb_csp * p) * Transfer qsound parameters to CSP, * function should be called from interrupt routine */ -static int snd_sb_csp_qsound_transfer(struct snd_sb_csp * p) +static int snd_sb_csp_qsound_transfer(snd_sb_csp_t * p) { int err = -ENXIO; @@ -1095,19 +1093,19 @@ static int snd_sb_csp_qsound_transfer(struct snd_sb_csp * p) /* * proc interface */ -static int init_proc_entry(struct snd_sb_csp * p, int device) +static int init_proc_entry(snd_sb_csp_t * p, int device) { char name[16]; - struct snd_info_entry *entry; + snd_info_entry_t *entry; sprintf(name, "cspD%d", device); if (! snd_card_proc_new(p->chip->card, name, &entry)) snd_info_set_text_ops(entry, p, 1024, info_read); return 0; } -static void info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_sb_csp *p = entry->private_data; + snd_sb_csp_t *p = entry->private_data; snd_iprintf(buffer, "Creative Signal Processor [v%d.%d]\n", (p->version >> 4), (p->version & 0x0f)); snd_iprintf(buffer, "State: %cx%c%c%c\n", ((p->running & SNDRV_SB_CSP_ST_QSOUND) ? 'Q' : '-'), diff --git a/trunk/sound/isa/sb/sb16_main.c b/trunk/sound/isa/sb/sb16_main.c index f183f1845a36..556b95e3e22f 100644 --- a/trunk/sound/isa/sb/sb16_main.c +++ b/trunk/sound/isa/sb/sb16_main.c @@ -50,10 +50,10 @@ MODULE_DESCRIPTION("Routines for control of 16-bit SoundBlaster cards and clones MODULE_LICENSE("GPL"); #ifdef CONFIG_SND_SB16_CSP -static void snd_sb16_csp_playback_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime) +static void snd_sb16_csp_playback_prepare(sb_t *chip, snd_pcm_runtime_t *runtime) { if (chip->hardware == SB_HW_16CSP) { - struct snd_sb_csp *csp = chip->csp; + snd_sb_csp_t *csp = chip->csp; if (csp->running & SNDRV_SB_CSP_ST_LOADED) { /* manually loaded codec */ @@ -98,10 +98,10 @@ static void snd_sb16_csp_playback_prepare(struct snd_sb *chip, struct snd_pcm_ru } } -static void snd_sb16_csp_capture_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime) +static void snd_sb16_csp_capture_prepare(sb_t *chip, snd_pcm_runtime_t *runtime) { if (chip->hardware == SB_HW_16CSP) { - struct snd_sb_csp *csp = chip->csp; + snd_sb_csp_t *csp = chip->csp; if (csp->running & SNDRV_SB_CSP_ST_LOADED) { /* manually loaded codec */ @@ -136,10 +136,10 @@ static void snd_sb16_csp_capture_prepare(struct snd_sb *chip, struct snd_pcm_run } } -static void snd_sb16_csp_update(struct snd_sb *chip) +static void snd_sb16_csp_update(sb_t *chip) { if (chip->hardware == SB_HW_16CSP) { - struct snd_sb_csp *csp = chip->csp; + snd_sb_csp_t *csp = chip->csp; if (csp->qpos_changed) { spin_lock(&chip->reg_lock); @@ -149,11 +149,11 @@ static void snd_sb16_csp_update(struct snd_sb *chip) } } -static void snd_sb16_csp_playback_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime) +static void snd_sb16_csp_playback_open(sb_t *chip, snd_pcm_runtime_t *runtime) { /* CSP decoders (QSound excluded) support only 16bit transfers */ if (chip->hardware == SB_HW_16CSP) { - struct snd_sb_csp *csp = chip->csp; + snd_sb_csp_t *csp = chip->csp; if (csp->running & SNDRV_SB_CSP_ST_LOADED) { /* manually loaded codec */ @@ -168,10 +168,10 @@ static void snd_sb16_csp_playback_open(struct snd_sb *chip, struct snd_pcm_runti } } -static void snd_sb16_csp_playback_close(struct snd_sb *chip) +static void snd_sb16_csp_playback_close(sb_t *chip) { if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_WRITE)) { - struct snd_sb_csp *csp = chip->csp; + snd_sb_csp_t *csp = chip->csp; if (csp->ops.csp_stop(csp) == 0) { csp->ops.csp_unuse(csp); @@ -180,11 +180,11 @@ static void snd_sb16_csp_playback_close(struct snd_sb *chip) } } -static void snd_sb16_csp_capture_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime) +static void snd_sb16_csp_capture_open(sb_t *chip, snd_pcm_runtime_t *runtime) { /* CSP coders support only 16bit transfers */ if (chip->hardware == SB_HW_16CSP) { - struct snd_sb_csp *csp = chip->csp; + snd_sb_csp_t *csp = chip->csp; if (csp->running & SNDRV_SB_CSP_ST_LOADED) { /* manually loaded codec */ @@ -199,10 +199,10 @@ static void snd_sb16_csp_capture_open(struct snd_sb *chip, struct snd_pcm_runtim } } -static void snd_sb16_csp_capture_close(struct snd_sb *chip) +static void snd_sb16_csp_capture_close(sb_t *chip) { if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_READ)) { - struct snd_sb_csp *csp = chip->csp; + snd_sb_csp_t *csp = chip->csp; if (csp->ops.csp_stop(csp) == 0) { csp->ops.csp_unuse(csp); @@ -221,7 +221,7 @@ static void snd_sb16_csp_capture_close(struct snd_sb *chip) #endif -static void snd_sb16_setup_rate(struct snd_sb *chip, +static void snd_sb16_setup_rate(sb_t *chip, unsigned short rate, int channel) { @@ -244,23 +244,23 @@ static void snd_sb16_setup_rate(struct snd_sb *chip, spin_unlock_irqrestore(&chip->reg_lock, flags); } -static int snd_sb16_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_sb16_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_sb16_hw_free(struct snd_pcm_substream *substream) +static int snd_sb16_hw_free(snd_pcm_substream_t * substream) { snd_pcm_lib_free_pages(substream); return 0; } -static int snd_sb16_playback_prepare(struct snd_pcm_substream *substream) +static int snd_sb16_playback_prepare(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned char format; unsigned int size, count, dma; @@ -298,21 +298,19 @@ static int snd_sb16_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_sb16_playback_trigger(struct snd_pcm_substream *substream, +static int snd_sb16_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); int result = 0; spin_lock(&chip->reg_lock); switch (cmd) { case SNDRV_PCM_TRIGGER_START: - case SNDRV_PCM_TRIGGER_RESUME: chip->mode |= SB_RATE_LOCK_PLAYBACK; snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON); break; case SNDRV_PCM_TRIGGER_STOP: - case SNDRV_PCM_TRIGGER_SUSPEND: snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_OFF : SB_DSP_DMA8_OFF); /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */ if (chip->mode & SB_RATE_LOCK_CAPTURE) @@ -326,11 +324,11 @@ static int snd_sb16_playback_trigger(struct snd_pcm_substream *substream, return result; } -static int snd_sb16_capture_prepare(struct snd_pcm_substream *substream) +static int snd_sb16_capture_prepare(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned char format; unsigned int size, count, dma; @@ -367,21 +365,19 @@ static int snd_sb16_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_sb16_capture_trigger(struct snd_pcm_substream *substream, +static int snd_sb16_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); int result = 0; spin_lock(&chip->reg_lock); switch (cmd) { case SNDRV_PCM_TRIGGER_START: - case SNDRV_PCM_TRIGGER_RESUME: chip->mode |= SB_RATE_LOCK_CAPTURE; snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON); break; case SNDRV_PCM_TRIGGER_STOP: - case SNDRV_PCM_TRIGGER_SUSPEND: snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_OFF : SB_DSP_DMA8_OFF); /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */ if (chip->mode & SB_RATE_LOCK_PLAYBACK) @@ -397,7 +393,7 @@ static int snd_sb16_capture_trigger(struct snd_pcm_substream *substream, irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_sb *chip = dev_id; + sb_t *chip = dev_id; unsigned char status; int ok; @@ -447,9 +443,9 @@ irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs) */ -static snd_pcm_uframes_t snd_sb16_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_sb16_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); unsigned int dma; size_t ptr; @@ -458,9 +454,9 @@ static snd_pcm_uframes_t snd_sb16_playback_pointer(struct snd_pcm_substream *sub return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_sb16_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_sb16_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); unsigned int dma; size_t ptr; @@ -473,7 +469,7 @@ static snd_pcm_uframes_t snd_sb16_capture_pointer(struct snd_pcm_substream *subs */ -static struct snd_pcm_hardware snd_sb16_playback = +static snd_pcm_hardware_t snd_sb16_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -491,7 +487,7 @@ static struct snd_pcm_hardware snd_sb16_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_sb16_capture = +static snd_pcm_hardware_t snd_sb16_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -513,11 +509,11 @@ static struct snd_pcm_hardware snd_sb16_capture = * open/close */ -static int snd_sb16_playback_open(struct snd_pcm_substream *substream) +static int snd_sb16_playback_open(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; spin_lock_irqsave(&chip->open_lock, flags); if (chip->mode & SB_MODE_PLAYBACK) { @@ -570,10 +566,10 @@ static int snd_sb16_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_sb16_playback_close(struct snd_pcm_substream *substream) +static int snd_sb16_playback_close(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); snd_sb16_csp_playback_close(chip); spin_lock_irqsave(&chip->open_lock, flags); @@ -583,11 +579,11 @@ static int snd_sb16_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_sb16_capture_open(struct snd_pcm_substream *substream) +static int snd_sb16_capture_open(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; spin_lock_irqsave(&chip->open_lock, flags); if (chip->mode & SB_MODE_CAPTURE) { @@ -640,10 +636,10 @@ static int snd_sb16_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_sb16_capture_close(struct snd_pcm_substream *substream) +static int snd_sb16_capture_close(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); snd_sb16_csp_capture_close(chip); spin_lock_irqsave(&chip->open_lock, flags); @@ -657,7 +653,7 @@ static int snd_sb16_capture_close(struct snd_pcm_substream *substream) * DMA control interface */ -static int snd_sb16_set_dma_mode(struct snd_sb *chip, int what) +static int snd_sb16_set_dma_mode(sb_t *chip, int what) { if (chip->dma8 < 0 || chip->dma16 < 0) { snd_assert(what == 0, return -EINVAL); @@ -675,7 +671,7 @@ static int snd_sb16_set_dma_mode(struct snd_sb *chip, int what) return 0; } -static int snd_sb16_get_dma_mode(struct snd_sb *chip) +static int snd_sb16_get_dma_mode(sb_t *chip) { if (chip->dma8 < 0 || chip->dma16 < 0) return 0; @@ -689,7 +685,7 @@ static int snd_sb16_get_dma_mode(struct snd_sb *chip) } } -static int snd_sb16_dma_control_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sb16_dma_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[3] = { "Auto", "Playback", "Capture" @@ -704,9 +700,9 @@ static int snd_sb16_dma_control_info(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_sb16_dma_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb16_dma_control_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *chip = snd_kcontrol_chip(kcontrol); + sb_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -715,9 +711,9 @@ static int snd_sb16_dma_control_get(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_sb16_dma_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb16_dma_control_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *chip = snd_kcontrol_chip(kcontrol); + sb_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned char nval, oval; int change; @@ -732,7 +728,7 @@ static int snd_sb16_dma_control_put(struct snd_kcontrol *kcontrol, struct snd_ct return change; } -static struct snd_kcontrol_new snd_sb16_dma_control = { +static snd_kcontrol_new_t snd_sb16_dma_control = { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = "16-bit DMA Allocation", .info = snd_sb16_dma_control_info, @@ -744,7 +740,7 @@ static struct snd_kcontrol_new snd_sb16_dma_control = { * Initialization part */ -int snd_sb16dsp_configure(struct snd_sb * chip) +int snd_sb16dsp_configure(sb_t * chip) { unsigned long flags; unsigned char irqreg = 0, dmareg = 0, mpureg; @@ -833,7 +829,7 @@ int snd_sb16dsp_configure(struct snd_sb * chip) return 0; } -static struct snd_pcm_ops snd_sb16_playback_ops = { +static snd_pcm_ops_t snd_sb16_playback_ops = { .open = snd_sb16_playback_open, .close = snd_sb16_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -844,7 +840,7 @@ static struct snd_pcm_ops snd_sb16_playback_ops = { .pointer = snd_sb16_playback_pointer, }; -static struct snd_pcm_ops snd_sb16_capture_ops = { +static snd_pcm_ops_t snd_sb16_capture_ops = { .open = snd_sb16_capture_open, .close = snd_sb16_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -855,10 +851,15 @@ static struct snd_pcm_ops snd_sb16_capture_ops = { .pointer = snd_sb16_capture_pointer, }; -int snd_sb16dsp_pcm(struct snd_sb * chip, int device, struct snd_pcm ** rpcm) +static void snd_sb16dsp_pcm_free(snd_pcm_t *pcm) { - struct snd_card *card = chip->card; - struct snd_pcm *pcm; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int snd_sb16dsp_pcm(sb_t * chip, int device, snd_pcm_t ** rpcm) +{ + snd_card_t *card = chip->card; + snd_pcm_t *pcm; int err; if (rpcm) @@ -868,6 +869,7 @@ int snd_sb16dsp_pcm(struct snd_sb * chip, int device, struct snd_pcm ** rpcm) sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff); pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; pcm->private_data = chip; + pcm->private_free = snd_sb16dsp_pcm_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb16_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb16_capture_ops); @@ -886,7 +888,7 @@ int snd_sb16dsp_pcm(struct snd_sb * chip, int device, struct snd_pcm ** rpcm) return 0; } -const struct snd_pcm_ops *snd_sb16dsp_get_pcm_ops(int direction) +const snd_pcm_ops_t *snd_sb16dsp_get_pcm_ops(int direction) { return direction == SNDRV_PCM_STREAM_PLAYBACK ? &snd_sb16_playback_ops : &snd_sb16_capture_ops; diff --git a/trunk/sound/isa/sb/sb8.c b/trunk/sound/isa/sb/sb8.c index 60ee79cd14a3..0bc0a3afdabc 100644 --- a/trunk/sound/isa/sb/sb8.c +++ b/trunk/sound/isa/sb/sb8.c @@ -21,14 +21,13 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/slab.h> #include <linux/ioport.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/sb.h> #include <sound/opl3.h> +#define SNDRV_LEGACY_AUTO_PROBE #include <sound/initval.h> MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); @@ -56,16 +55,15 @@ MODULE_PARM_DESC(irq, "IRQ # for SB8 driver."); module_param_array(dma8, int, NULL, 0444); MODULE_PARM_DESC(dma8, "8-bit DMA # for SB8 driver."); -static struct platform_device *devices[SNDRV_CARDS]; - struct snd_sb8 { struct resource *fm_res; /* used to block FM i/o region for legacy cards */ - struct snd_sb *chip; }; +static snd_card_t *snd_sb8_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; + static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_sb *chip = dev_id; + sb_t *chip = dev_id; if (chip->open & SB_OPEN_PCM) { return snd_sb8dsp_interrupt(chip); @@ -74,7 +72,7 @@ static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs } } -static void snd_sb8_free(struct snd_card *card) +static void snd_sb8_free(snd_card_t *card) { struct snd_sb8 *acard = (struct snd_sb8 *)card->private_data; @@ -83,57 +81,32 @@ static void snd_sb8_free(struct snd_card *card) release_and_free_resource(acard->fm_res); } -static int __init snd_sb8_probe(struct platform_device *pdev) +static int __init snd_sb8_probe(int dev) { - int dev = pdev->id; - struct snd_sb *chip; - struct snd_card *card; + sb_t *chip; + snd_card_t *card; struct snd_sb8 *acard; - struct snd_opl3 *opl3; + opl3_t *opl3; int err; card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_sb8)); if (card == NULL) return -ENOMEM; - acard = card->private_data; + acard = (struct snd_sb8 *)card->private_data; card->private_free = snd_sb8_free; /* block the 0x388 port to avoid PnP conflicts */ acard->fm_res = request_region(0x388, 4, "SoundBlaster FM"); - if (port[dev] != SNDRV_AUTO_PORT) { - if ((err = snd_sbdsp_create(card, port[dev], irq[dev], - snd_sb8_interrupt, - dma8[dev], - -1, - SB_HW_AUTO, - &chip)) < 0) - goto _err; - } else { - /* auto-probe legacy ports */ - static unsigned long possible_ports[] = { - 0x220, 0x240, 0x260, - }; - int i; - for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { - err = snd_sbdsp_create(card, possible_ports[i], - irq[dev], - snd_sb8_interrupt, - dma8[dev], - -1, - SB_HW_AUTO, - &chip); - if (err >= 0) { - port[dev] = possible_ports[i]; - break; - } - } - if (i >= ARRAY_SIZE(possible_ports)) - goto _err; - } - acard->chip = chip; - + if ((err = snd_sbdsp_create(card, port[dev], irq[dev], + snd_sb8_interrupt, + dma8[dev], + -1, + SB_HW_AUTO, + &chip)) < 0) + goto _err; + if (chip->hardware >= SB_HW_16) { if (chip->hardware == SB_HW_ALS100) snd_printk(KERN_WARNING "ALS100 chip detected at 0x%lx, try snd-als100 module\n", @@ -180,12 +153,13 @@ static int __init snd_sb8_probe(struct platform_device *pdev) chip->port, irq[dev], dma8[dev]); - snd_card_set_dev(card, &pdev->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; - platform_set_drvdata(pdev, card); + snd_sb8_cards[dev] = card; return 0; _err: @@ -193,99 +167,53 @@ static int __init snd_sb8_probe(struct platform_device *pdev) return err; } -static int snd_sb8_remove(struct platform_device *pdev) -{ - snd_card_free(platform_get_drvdata(pdev)); - platform_set_drvdata(pdev, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_sb8_suspend(struct platform_device *dev, pm_message_t state) -{ - struct snd_card *card = platform_get_drvdata(dev); - struct snd_sb8 *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(chip->pcm); - snd_sbmixer_suspend(chip); - return 0; -} - -static int snd_sb8_resume(struct platform_device *dev) -{ - struct snd_card *card = platform_get_drvdata(dev); - struct snd_sb8 *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_sbdsp_reset(chip); - snd_sbmixer_resume(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - -#define SND_SB8_DRIVER "snd_sb8" - -static struct platform_driver snd_sb8_driver = { - .probe = snd_sb8_probe, - .remove = snd_sb8_remove, -#ifdef CONFIG_PM - .suspend = snd_sb8_suspend, - .resume = snd_sb8_resume, -#endif - .driver = { - .name = SND_SB8_DRIVER - }, -}; - -static void __init_or_module snd_sb8_unregister_all(void) +static int __init snd_card_sb8_legacy_auto_probe(unsigned long xport) { - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_sb8_driver); + static int dev; + int res; + + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT) + continue; + port[dev] = xport; + res = snd_sb8_probe(dev); + if (res < 0) + port[dev] = SNDRV_AUTO_PORT; + return res; + } + return -ENODEV; } static int __init alsa_card_sb8_init(void) { - int i, cards, err; - - err = platform_driver_register(&snd_sb8_driver); - if (err < 0) - return err; - - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(SND_SB8_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + static unsigned long possible_ports[] = {0x220, 0x240, 0x260, -1}; + int dev, cards, i; + + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) { + if (port[dev] == SNDRV_AUTO_PORT) + continue; + if (snd_sb8_probe(dev) >= 0) + cards++; } + i = snd_legacy_auto_probe(possible_ports, snd_card_sb8_legacy_auto_probe); + if (i > 0) + cards += i; + if (!cards) { #ifdef MODULE snd_printk(KERN_ERR "Sound Blaster soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_sb8_unregister_all(); - return err; } static void __exit alsa_card_sb8_exit(void) { - snd_sb8_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_sb8_cards[idx]); } module_init(alsa_card_sb8_init) diff --git a/trunk/sound/isa/sb/sb8_main.c b/trunk/sound/isa/sb/sb8_main.c index aea9e5ec7b36..5ddc6e41d909 100644 --- a/trunk/sound/isa/sb/sb8_main.c +++ b/trunk/sound/isa/sb/sb8_main.c @@ -46,19 +46,19 @@ MODULE_LICENSE("GPL"); #define SB8_DEN(v) ((SB8_CLOCK + (v) / 2) / (v)) #define SB8_RATE(v) (SB8_CLOCK / SB8_DEN(v)) -static struct snd_ratnum clock = { +static ratnum_t clock = { .num = SB8_CLOCK, .den_min = 1, .den_max = 256, .den_step = 1, }; -static struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = { +static snd_pcm_hw_constraint_ratnums_t hw_constraints_clock = { .nrats = 1, .rats = &clock, }; -static struct snd_ratnum stereo_clocks[] = { +static ratnum_t stereo_clocks[] = { { .num = SB8_CLOCK, .den_min = SB8_DEN(22050), @@ -73,10 +73,10 @@ static struct snd_ratnum stereo_clocks[] = { } }; -static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_sb8_hw_constraint_rate_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); if (c->min > 1) { unsigned int num = 0, den = 0; int err = snd_interval_ratnum(hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE), @@ -90,22 +90,22 @@ static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params, return 0; } -static int snd_sb8_hw_constraint_channels_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_sb8_hw_constraint_channels_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (r->min > SB8_RATE(22050) || r->max <= SB8_RATE(11025)) { - struct snd_interval t = { .min = 1, .max = 1 }; + snd_interval_t t = { .min = 1, .max = 1 }; return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t); } return 0; } -static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream) +static int snd_sb8_playback_prepare(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int mixreg, rate, size, count; rate = runtime->rate; @@ -178,11 +178,11 @@ static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream, +static int snd_sb8_playback_trigger(snd_pcm_substream_t * substream, int cmd) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); unsigned int count; spin_lock_irqsave(&chip->reg_lock, flags); @@ -197,7 +197,7 @@ static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream, break; case SNDRV_PCM_TRIGGER_STOP: if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_sbdsp_reset(chip); if (runtime->channels > 1) { spin_lock(&chip->mixer_lock); @@ -215,23 +215,23 @@ static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_sb8_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_sb8_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_sb8_hw_free(struct snd_pcm_substream *substream) +static int snd_sb8_hw_free(snd_pcm_substream_t * substream) { snd_pcm_lib_free_pages(substream); return 0; } -static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream) +static int snd_sb8_capture_prepare(snd_pcm_substream_t * substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int mixreg, rate, size, count; rate = runtime->rate; @@ -290,11 +290,11 @@ static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream, +static int snd_sb8_capture_trigger(snd_pcm_substream_t * substream, int cmd) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); unsigned int count; spin_lock_irqsave(&chip->reg_lock, flags); @@ -309,7 +309,7 @@ static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream, break; case SNDRV_PCM_TRIGGER_STOP: if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; snd_sbdsp_reset(chip); if (runtime->channels > 1) { /* restore input filter status */ @@ -329,10 +329,10 @@ static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream, return 0; } -irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip) +irqreturn_t snd_sb8dsp_interrupt(sb_t *chip) { - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; snd_sb_ack_8bit(chip); switch (chip->mode) { @@ -354,9 +354,9 @@ irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip) return IRQ_HANDLED; } -static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_sb8_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (chip->mode != SB_MODE_PLAYBACK_8) @@ -365,9 +365,9 @@ static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *subs return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_sb8_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (chip->mode != SB_MODE_CAPTURE_8) @@ -380,7 +380,7 @@ static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *subst */ -static struct snd_pcm_hardware snd_sb8_playback = +static snd_pcm_hardware_t snd_sb8_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -399,7 +399,7 @@ static struct snd_pcm_hardware snd_sb8_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_sb8_capture = +static snd_pcm_hardware_t snd_sb8_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -422,10 +422,10 @@ static struct snd_pcm_hardware snd_sb8_capture = * */ -static int snd_sb8_open(struct snd_pcm_substream *substream) +static int snd_sb8_open(snd_pcm_substream_t *substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; spin_lock_irqsave(&chip->open_lock, flags); @@ -468,10 +468,10 @@ static int snd_sb8_open(struct snd_pcm_substream *substream) return 0; } -static int snd_sb8_close(struct snd_pcm_substream *substream) +static int snd_sb8_close(snd_pcm_substream_t *substream) { unsigned long flags; - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); chip->playback_substream = NULL; chip->capture_substream = NULL; @@ -485,7 +485,7 @@ static int snd_sb8_close(struct snd_pcm_substream *substream) * Initialization part */ -static struct snd_pcm_ops snd_sb8_playback_ops = { +static snd_pcm_ops_t snd_sb8_playback_ops = { .open = snd_sb8_open, .close = snd_sb8_close, .ioctl = snd_pcm_lib_ioctl, @@ -496,7 +496,7 @@ static struct snd_pcm_ops snd_sb8_playback_ops = { .pointer = snd_sb8_playback_pointer, }; -static struct snd_pcm_ops snd_sb8_capture_ops = { +static snd_pcm_ops_t snd_sb8_capture_ops = { .open = snd_sb8_open, .close = snd_sb8_close, .ioctl = snd_pcm_lib_ioctl, @@ -507,10 +507,15 @@ static struct snd_pcm_ops snd_sb8_capture_ops = { .pointer = snd_sb8_capture_pointer, }; -int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm) +static void snd_sb8dsp_pcm_free(snd_pcm_t *pcm) { - struct snd_card *card = chip->card; - struct snd_pcm *pcm; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int snd_sb8dsp_pcm(sb_t *chip, int device, snd_pcm_t ** rpcm) +{ + snd_card_t *card = chip->card; + snd_pcm_t *pcm; int err; if (rpcm) @@ -520,6 +525,7 @@ int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm) sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff); pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX; pcm->private_data = chip; + pcm->private_free = snd_sb8dsp_pcm_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops); diff --git a/trunk/sound/isa/sb/sb8_midi.c b/trunk/sound/isa/sb/sb8_midi.c index c549aceea294..d2c633a40e74 100644 --- a/trunk/sound/isa/sb/sb8_midi.c +++ b/trunk/sound/isa/sb/sb8_midi.c @@ -36,9 +36,9 @@ */ -irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb * chip) +irqreturn_t snd_sb8dsp_midi_interrupt(sb_t * chip) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int max = 64; char byte; @@ -63,10 +63,10 @@ irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb * chip) */ -static int snd_sb8dsp_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_sb8dsp_midi_input_open(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_sb *chip; + sb_t *chip; unsigned int valid_open_flags; chip = substream->rmidi->private_data; @@ -90,10 +90,10 @@ static int snd_sb8dsp_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_sb8dsp_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_sb8dsp_midi_output_open(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_sb *chip; + sb_t *chip; unsigned int valid_open_flags; chip = substream->rmidi->private_data; @@ -117,10 +117,10 @@ static int snd_sb8dsp_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_sb8dsp_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_sb8dsp_midi_input_close(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_sb *chip; + sb_t *chip; chip = substream->rmidi->private_data; spin_lock_irqsave(&chip->open_lock, flags); @@ -135,10 +135,10 @@ static int snd_sb8dsp_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_sb8dsp_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_sb8dsp_midi_output_close(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_sb *chip; + sb_t *chip; chip = substream->rmidi->private_data; spin_lock_irqsave(&chip->open_lock, flags); @@ -153,10 +153,10 @@ static int snd_sb8dsp_midi_output_close(struct snd_rawmidi_substream *substream) return 0; } -static void snd_sb8dsp_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_sb8dsp_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct snd_sb *chip; + sb_t *chip; chip = substream->rmidi->private_data; spin_lock_irqsave(&chip->open_lock, flags); @@ -176,10 +176,10 @@ static void snd_sb8dsp_midi_input_trigger(struct snd_rawmidi_substream *substrea spin_unlock_irqrestore(&chip->open_lock, flags); } -static void snd_sb8dsp_midi_output_write(struct snd_rawmidi_substream *substream) +static void snd_sb8dsp_midi_output_write(snd_rawmidi_substream_t * substream) { unsigned long flags; - struct snd_sb *chip; + sb_t *chip; char byte; int max = 32; @@ -214,8 +214,8 @@ static void snd_sb8dsp_midi_output_write(struct snd_rawmidi_substream *substream static void snd_sb8dsp_midi_output_timer(unsigned long data) { - struct snd_rawmidi_substream *substream = (struct snd_rawmidi_substream *) data; - struct snd_sb * chip = substream->rmidi->private_data; + snd_rawmidi_substream_t * substream = (snd_rawmidi_substream_t *) data; + sb_t * chip = substream->rmidi->private_data; unsigned long flags; spin_lock_irqsave(&chip->open_lock, flags); @@ -225,10 +225,10 @@ static void snd_sb8dsp_midi_output_timer(unsigned long data) snd_sb8dsp_midi_output_write(substream); } -static void snd_sb8dsp_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_sb8dsp_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct snd_sb *chip; + sb_t *chip; chip = substream->rmidi->private_data; spin_lock_irqsave(&chip->open_lock, flags); @@ -256,23 +256,23 @@ static void snd_sb8dsp_midi_output_trigger(struct snd_rawmidi_substream *substre */ -static struct snd_rawmidi_ops snd_sb8dsp_midi_output = +static snd_rawmidi_ops_t snd_sb8dsp_midi_output = { .open = snd_sb8dsp_midi_output_open, .close = snd_sb8dsp_midi_output_close, .trigger = snd_sb8dsp_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_sb8dsp_midi_input = +static snd_rawmidi_ops_t snd_sb8dsp_midi_input = { .open = snd_sb8dsp_midi_input_open, .close = snd_sb8dsp_midi_input_close, .trigger = snd_sb8dsp_midi_input_trigger, }; -int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawmidi) +int snd_sb8dsp_midi(sb_t *chip, int device, snd_rawmidi_t ** rrawmidi) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if (rrawmidi) diff --git a/trunk/sound/isa/sb/sb_common.c b/trunk/sound/isa/sb/sb_common.c index f343a8211d2d..603e923b5d2f 100644 --- a/trunk/sound/isa/sb/sb_common.c +++ b/trunk/sound/isa/sb/sb_common.c @@ -41,7 +41,7 @@ MODULE_LICENSE("GPL"); #undef IO_DEBUG -int snd_sbdsp_command(struct snd_sb *chip, unsigned char val) +int snd_sbdsp_command(sb_t *chip, unsigned char val) { int i; #ifdef IO_DEBUG @@ -56,7 +56,7 @@ int snd_sbdsp_command(struct snd_sb *chip, unsigned char val) return 0; } -int snd_sbdsp_get_byte(struct snd_sb *chip) +int snd_sbdsp_get_byte(sb_t *chip) { int val; int i; @@ -73,7 +73,7 @@ int snd_sbdsp_get_byte(struct snd_sb *chip) return -ENODEV; } -int snd_sbdsp_reset(struct snd_sb *chip) +int snd_sbdsp_reset(sb_t *chip) { int i; @@ -92,7 +92,7 @@ int snd_sbdsp_reset(struct snd_sb *chip) return -ENODEV; } -static int snd_sbdsp_version(struct snd_sb * chip) +static int snd_sbdsp_version(sb_t * chip) { unsigned int result = -ENODEV; @@ -102,7 +102,7 @@ static int snd_sbdsp_version(struct snd_sb * chip) return result; } -static int snd_sbdsp_probe(struct snd_sb * chip) +static int snd_sbdsp_probe(sb_t * chip) { int version; int major, minor; @@ -176,7 +176,7 @@ static int snd_sbdsp_probe(struct snd_sb * chip) return 0; } -static int snd_sbdsp_free(struct snd_sb *chip) +static int snd_sbdsp_free(sb_t *chip) { if (chip->res_port) release_and_free_resource(chip->res_port); @@ -196,24 +196,24 @@ static int snd_sbdsp_free(struct snd_sb *chip) return 0; } -static int snd_sbdsp_dev_free(struct snd_device *device) +static int snd_sbdsp_dev_free(snd_device_t *device) { - struct snd_sb *chip = device->device_data; + sb_t *chip = device->device_data; return snd_sbdsp_free(chip); } -int snd_sbdsp_create(struct snd_card *card, +int snd_sbdsp_create(snd_card_t *card, unsigned long port, int irq, irqreturn_t (*irq_handler)(int, void *, struct pt_regs *), int dma8, int dma16, unsigned short hardware, - struct snd_sb **r_chip) + sb_t **r_chip) { - struct snd_sb *chip; + sb_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_sbdsp_dev_free, }; @@ -293,10 +293,6 @@ EXPORT_SYMBOL(snd_sbmixer_write); EXPORT_SYMBOL(snd_sbmixer_read); EXPORT_SYMBOL(snd_sbmixer_new); EXPORT_SYMBOL(snd_sbmixer_add_ctl); -#ifdef CONFIG_PM -EXPORT_SYMBOL(snd_sbmixer_suspend); -EXPORT_SYMBOL(snd_sbmixer_resume); -#endif /* * INIT part diff --git a/trunk/sound/isa/sb/sb_mixer.c b/trunk/sound/isa/sb/sb_mixer.c index 1a6ee344dddb..5a926a452d38 100644 --- a/trunk/sound/isa/sb/sb_mixer.c +++ b/trunk/sound/isa/sb/sb_mixer.c @@ -29,7 +29,7 @@ #undef IO_DEBUG -void snd_sbmixer_write(struct snd_sb *chip, unsigned char reg, unsigned char data) +void snd_sbmixer_write(sb_t *chip, unsigned char reg, unsigned char data) { outb(reg, SBP(chip, MIXER_ADDR)); udelay(10); @@ -40,7 +40,7 @@ void snd_sbmixer_write(struct snd_sb *chip, unsigned char reg, unsigned char dat #endif } -unsigned char snd_sbmixer_read(struct snd_sb *chip, unsigned char reg) +unsigned char snd_sbmixer_read(sb_t *chip, unsigned char reg) { unsigned char result; @@ -58,7 +58,7 @@ unsigned char snd_sbmixer_read(struct snd_sb *chip, unsigned char reg) * Single channel mixer element */ -static int snd_sbmixer_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sbmixer_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -69,9 +69,9 @@ static int snd_sbmixer_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_sbmixer_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sbmixer_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 16) & 0xff; @@ -85,9 +85,9 @@ static int snd_sbmixer_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_sbmixer_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sbmixer_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 16) & 0x07; @@ -110,7 +110,7 @@ static int snd_sbmixer_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ * Double channel mixer element */ -static int snd_sbmixer_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sbmixer_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -121,9 +121,9 @@ static int snd_sbmixer_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_sbmixer_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sbmixer_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -141,9 +141,9 @@ static int snd_sbmixer_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_sbmixer_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sbmixer_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -181,7 +181,7 @@ static int snd_sbmixer_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ * DT-019x / ALS-007 capture/input switch */ -static int snd_dt019x_input_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_dt019x_input_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[5] = { "CD", "Mic", "Line", "Synth", "Master" @@ -196,9 +196,9 @@ static int snd_dt019x_input_sw_info(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_dt019x_input_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_dt019x_input_sw_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned char oval; @@ -232,9 +232,9 @@ static int snd_dt019x_input_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_dt019x_input_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_dt019x_input_sw_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned char nval, oval; @@ -273,7 +273,7 @@ static int snd_dt019x_input_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl * SBPRO input multiplexer */ -static int snd_sb8mixer_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sb8mixer_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[3] = { "Mic", "CD", "Line" @@ -289,9 +289,9 @@ static int snd_sb8mixer_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_e } -static int snd_sb8mixer_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb8mixer_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned char oval; @@ -312,9 +312,9 @@ static int snd_sb8mixer_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int snd_sb8mixer_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb8mixer_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int change; unsigned char nval, oval; @@ -346,7 +346,7 @@ static int snd_sb8mixer_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_el * SB16 input switch */ -static int snd_sb16mixer_info_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sb16mixer_info_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 4; @@ -355,9 +355,9 @@ static int snd_sb16mixer_info_input_sw(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_sb16mixer_get_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb16mixer_get_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg1 = kcontrol->private_value & 0xff; int reg2 = (kcontrol->private_value >> 8) & 0xff; @@ -376,9 +376,9 @@ static int snd_sb16mixer_get_input_sw(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_sb16mixer_put_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sb16mixer_put_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_sb *sb = snd_kcontrol_chip(kcontrol); + sb_t *sb = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg1 = kcontrol->private_value & 0xff; int reg2 = (kcontrol->private_value >> 8) & 0xff; @@ -410,9 +410,9 @@ static int snd_sb16mixer_put_input_sw(struct snd_kcontrol *kcontrol, struct snd_ */ /* */ -int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int type, unsigned long value) +int snd_sbmixer_add_ctl(sb_t *chip, const char *name, int index, int type, unsigned long value) { - static struct snd_kcontrol_new newctls[] = { + static snd_kcontrol_new_t newctls[] = { [SB_MIX_SINGLE] = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .info = snd_sbmixer_info_single, @@ -444,7 +444,7 @@ int snd_sbmixer_add_ctl(struct snd_sb *chip, const char *name, int index, int ty .put = snd_dt019x_input_sw_put, }, }; - struct snd_kcontrol *ctl; + snd_kcontrol_t *ctl; int err; ctl = snd_ctl_new1(&newctls[type], chip); @@ -669,34 +669,25 @@ static unsigned char snd_dt019x_init_values[][2] = { /* * ALS4000 specific mixer elements */ -/* FIXME: SB_ALS4000_MONO_IO_CTRL needs output select ctrl! */ -static struct sbmix_elem snd_als4000_ctl_master_mono_playback_switch = - SB_SINGLE("Master Mono Playback Switch", SB_ALS4000_MONO_IO_CTRL, 5, 1); -static struct sbmix_elem snd_als4000_ctl_master_mono_capture_route = - SB_SINGLE("Master Mono Capture Route", SB_ALS4000_MONO_IO_CTRL, 6, 0x03); -/* FIXME: mono playback switch also available on DT019X? */ -static struct sbmix_elem snd_als4000_ctl_mono_playback_switch = - SB_SINGLE("Mono Playback Switch", SB_DT019X_OUTPUT_SW2, 0, 1); +/* FIXME: SB_ALS4000_MONO_IO_CTRL needs output select ctrl ! */ +static struct sbmix_elem snd_als4000_ctl_mono_output_switch = + SB_SINGLE("Mono Output Switch", SB_ALS4000_MONO_IO_CTRL, 5, 1); +/* FIXME: mono input switch also available on DT019X ? */ +static struct sbmix_elem snd_als4000_ctl_mono_input_switch = + SB_SINGLE("Mono Input Switch", SB_DT019X_OUTPUT_SW2, 0, 1); static struct sbmix_elem snd_als4000_ctl_mic_20db_boost = SB_SINGLE("Mic Boost (+20dB)", SB_ALS4000_MIC_IN_GAIN, 0, 0x03); -static struct sbmix_elem snd_als4000_ctl_mixer_loopback = - SB_SINGLE("Analog Loopback", SB_ALS4000_MIC_IN_GAIN, 7, 0x01); -/* FIXME: functionality of 3D controls might be swapped, I didn't find - * a description of how to identify what is supposed to be what */ -static struct sbmix_elem snd_als4000_3d_control_switch = - SB_SINGLE("3D Control - Switch", SB_ALS4000_3D_SND_FX, 6, 0x01); -static struct sbmix_elem snd_als4000_3d_control_ratio = - SB_SINGLE("3D Control - Level", SB_ALS4000_3D_SND_FX, 0, 0x07); -static struct sbmix_elem snd_als4000_3d_control_freq = - /* FIXME: maybe there's actually some standard 3D ctrl name for it?? */ - SB_SINGLE("3D Control - Freq", SB_ALS4000_3D_SND_FX, 4, 0x03); -static struct sbmix_elem snd_als4000_3d_control_delay = - /* FIXME: ALS4000a.pdf mentions BBD (Bucket Brigade Device) time delay, - * but what ALSA 3D attribute is that actually? "Center", "Depth", - * "Wide" or "Space" or even "Level"? Assuming "Wide" for now... */ - SB_SINGLE("3D Control - Wide", SB_ALS4000_3D_TIME_DELAY, 0, 0x0f); -static struct sbmix_elem snd_als4000_3d_control_poweroff_switch = +static struct sbmix_elem snd_als4000_ctl_mixer_out_to_in = + SB_SINGLE("Mixer Out To In", SB_ALS4000_MIC_IN_GAIN, 7, 0x01); +/* FIXME: 3D needs much more sophisticated controls, many more features ! */ +static struct sbmix_elem snd_als4000_ctl_3d_output_switch = + SB_SINGLE("3D Output Switch", SB_ALS4000_3D_SND_FX, 6, 0x01); +static struct sbmix_elem snd_als4000_ctl_3d_output_ratio = + SB_SINGLE("3D Output Ratio", SB_ALS4000_3D_SND_FX, 0, 0x07); +static struct sbmix_elem snd_als4000_ctl_3d_poweroff_switch = SB_SINGLE("3D PowerOff Switch", SB_ALS4000_3D_TIME_DELAY, 4, 0x01); +static struct sbmix_elem snd_als4000_ctl_3d_delay = + SB_SINGLE("3D Delay", SB_ALS4000_3D_TIME_DELAY, 0, 0x0f); #ifdef NOT_AVAILABLE static struct sbmix_elem snd_als4000_ctl_fmdac = SB_SINGLE("FMDAC Switch (Option ?)", SB_ALS4000_FMDAC, 0, 0x01); @@ -725,15 +716,13 @@ static struct sbmix_elem *snd_als4000_controls[] = { &snd_sb16_ctl_pc_speaker_vol, &snd_sb16_ctl_capture_vol, &snd_sb16_ctl_play_vol, - &snd_als4000_ctl_master_mono_playback_switch, - &snd_als4000_ctl_master_mono_capture_route, - &snd_als4000_ctl_mono_playback_switch, - &snd_als4000_ctl_mixer_loopback, - &snd_als4000_3d_control_switch, - &snd_als4000_3d_control_ratio, - &snd_als4000_3d_control_freq, - &snd_als4000_3d_control_delay, - &snd_als4000_3d_control_poweroff_switch, + &snd_als4000_ctl_mono_output_switch, + &snd_als4000_ctl_mono_input_switch, + &snd_als4000_ctl_mixer_out_to_in, + &snd_als4000_ctl_3d_output_switch, + &snd_als4000_ctl_3d_output_ratio, + &snd_als4000_ctl_3d_delay, + &snd_als4000_ctl_3d_poweroff_switch, #ifdef NOT_AVAILABLE &snd_als4000_ctl_fmdac, &snd_als4000_ctl_qsound, @@ -758,7 +747,7 @@ static unsigned char snd_als4000_init_values[][2] = { /* */ -static int snd_sbmixer_init(struct snd_sb *chip, +static int snd_sbmixer_init(sb_t *chip, struct sbmix_elem **controls, int controls_count, unsigned char map[][2], @@ -766,7 +755,7 @@ static int snd_sbmixer_init(struct snd_sb *chip, char *name) { unsigned long flags; - struct snd_card *card = chip->card; + snd_card_t *card = chip->card; int idx, err; /* mixer reset */ @@ -790,9 +779,9 @@ static int snd_sbmixer_init(struct snd_sb *chip, return 0; } -int snd_sbmixer_new(struct snd_sb *chip) +int snd_sbmixer_new(sb_t *chip) { - struct snd_card *card; + snd_card_t * card; int err; snd_assert(chip != NULL && chip->card != NULL, return -EINVAL); @@ -853,140 +842,3 @@ int snd_sbmixer_new(struct snd_sb *chip) } return 0; } - -#ifdef CONFIG_PM -static unsigned char sb20_saved_regs[] = { - SB_DSP20_MASTER_DEV, - SB_DSP20_PCM_DEV, - SB_DSP20_FM_DEV, - SB_DSP20_CD_DEV, -}; - -static unsigned char sbpro_saved_regs[] = { - SB_DSP_MASTER_DEV, - SB_DSP_PCM_DEV, - SB_DSP_PLAYBACK_FILT, - SB_DSP_FM_DEV, - SB_DSP_CD_DEV, - SB_DSP_LINE_DEV, - SB_DSP_MIC_DEV, - SB_DSP_CAPTURE_SOURCE, - SB_DSP_CAPTURE_FILT, -}; - -static unsigned char sb16_saved_regs[] = { - SB_DSP4_MASTER_DEV, SB_DSP4_MASTER_DEV + 1, - SB_DSP4_3DSE, - SB_DSP4_BASS_DEV, SB_DSP4_BASS_DEV + 1, - SB_DSP4_TREBLE_DEV, SB_DSP4_TREBLE_DEV + 1, - SB_DSP4_PCM_DEV, SB_DSP4_PCM_DEV + 1, - SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, - SB_DSP4_SYNTH_DEV, SB_DSP4_SYNTH_DEV + 1, - SB_DSP4_OUTPUT_SW, - SB_DSP4_CD_DEV, SB_DSP4_CD_DEV + 1, - SB_DSP4_LINE_DEV, SB_DSP4_LINE_DEV + 1, - SB_DSP4_MIC_DEV, - SB_DSP4_SPEAKER_DEV, - SB_DSP4_IGAIN_DEV, SB_DSP4_IGAIN_DEV + 1, - SB_DSP4_OGAIN_DEV, SB_DSP4_OGAIN_DEV + 1, - SB_DSP4_MIC_AGC -}; - -static unsigned char dt019x_saved_regs[] = { - SB_DT019X_MASTER_DEV, - SB_DT019X_PCM_DEV, - SB_DT019X_SYNTH_DEV, - SB_DT019X_CD_DEV, - SB_DT019X_MIC_DEV, - SB_DT019X_SPKR_DEV, - SB_DT019X_LINE_DEV, - SB_DSP4_OUTPUT_SW, - SB_DT019X_OUTPUT_SW2, - SB_DT019X_CAPTURE_SW, -}; - -static unsigned char als4000_saved_regs[] = { - SB_DSP4_MASTER_DEV, SB_DSP4_MASTER_DEV + 1, - SB_DSP4_OUTPUT_SW, - SB_DSP4_PCM_DEV, SB_DSP4_PCM_DEV + 1, - SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, - SB_DSP4_SYNTH_DEV, SB_DSP4_SYNTH_DEV + 1, - SB_DSP4_CD_DEV, SB_DSP4_CD_DEV + 1, - SB_DSP4_MIC_AGC, - SB_DSP4_MIC_DEV, - SB_DSP4_SPEAKER_DEV, - SB_DSP4_IGAIN_DEV, SB_DSP4_IGAIN_DEV + 1, - SB_DSP4_OGAIN_DEV, SB_DSP4_OGAIN_DEV + 1, - SB_DT019X_OUTPUT_SW2, - SB_ALS4000_MONO_IO_CTRL, - SB_ALS4000_MIC_IN_GAIN, - SB_ALS4000_3D_SND_FX, - SB_ALS4000_3D_TIME_DELAY, -}; - -static void save_mixer(struct snd_sb *chip, unsigned char *regs, int num_regs) -{ - unsigned char *val = chip->saved_regs; - snd_assert(num_regs > ARRAY_SIZE(chip->saved_regs), return); - for (; num_regs; num_regs--) - *val++ = snd_sbmixer_read(chip, *regs++); -} - -static void restore_mixer(struct snd_sb *chip, unsigned char *regs, int num_regs) -{ - unsigned char *val = chip->saved_regs; - snd_assert(num_regs > ARRAY_SIZE(chip->saved_regs), return); - for (; num_regs; num_regs--) - snd_sbmixer_write(chip, *regs++, *val++); -} - -void snd_sbmixer_suspend(struct snd_sb *chip) -{ - switch (chip->hardware) { - case SB_HW_20: - case SB_HW_201: - save_mixer(chip, sb20_saved_regs, ARRAY_SIZE(sb20_saved_regs)); - break; - case SB_HW_PRO: - save_mixer(chip, sbpro_saved_regs, ARRAY_SIZE(sbpro_saved_regs)); - break; - case SB_HW_16: - case SB_HW_ALS100: - save_mixer(chip, sb16_saved_regs, ARRAY_SIZE(sb16_saved_regs)); - break; - case SB_HW_ALS4000: - save_mixer(chip, als4000_saved_regs, ARRAY_SIZE(als4000_saved_regs)); - break; - case SB_HW_DT019X: - save_mixer(chip, dt019x_saved_regs, ARRAY_SIZE(dt019x_saved_regs)); - break; - default: - break; - } -} - -void snd_sbmixer_resume(struct snd_sb *chip) -{ - switch (chip->hardware) { - case SB_HW_20: - case SB_HW_201: - restore_mixer(chip, sb20_saved_regs, ARRAY_SIZE(sb20_saved_regs)); - break; - case SB_HW_PRO: - restore_mixer(chip, sbpro_saved_regs, ARRAY_SIZE(sbpro_saved_regs)); - break; - case SB_HW_16: - case SB_HW_ALS100: - restore_mixer(chip, sb16_saved_regs, ARRAY_SIZE(sb16_saved_regs)); - break; - case SB_HW_ALS4000: - restore_mixer(chip, als4000_saved_regs, ARRAY_SIZE(als4000_saved_regs)); - break; - case SB_HW_DT019X: - restore_mixer(chip, dt019x_saved_regs, ARRAY_SIZE(dt019x_saved_regs)); - break; - default: - break; - } -} -#endif diff --git a/trunk/sound/isa/sgalaxy.c b/trunk/sound/isa/sgalaxy.c index 0dbbb35b242c..52f2294da62b 100644 --- a/trunk/sound/isa/sgalaxy.c +++ b/trunk/sound/isa/sgalaxy.c @@ -22,14 +22,12 @@ */ #include <sound/driver.h> +#include <asm/dma.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/delay.h> #include <linux/time.h> #include <linux/interrupt.h> #include <linux/moduleparam.h> -#include <asm/dma.h> #include <sound/core.h> #include <sound/sb.h> #include <sound/ad1848.h> @@ -64,11 +62,11 @@ MODULE_PARM_DESC(irq, "IRQ # for Sound Galaxy driver."); module_param_array(dma1, int, NULL, 0444); MODULE_PARM_DESC(dma1, "DMA1 # for Sound Galaxy driver."); -static struct platform_device *devices[SNDRV_CARDS]; - #define SGALAXY_AUXC_LEFT 18 #define SGALAXY_AUXC_RIGHT 19 +static snd_card_t *snd_sgalaxy_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; + #define PFX "sgalaxy: " /* @@ -77,7 +75,7 @@ static struct platform_device *devices[SNDRV_CARDS]; #define AD1848P1( port, x ) ( port + c_d_c_AD1848##x ) -/* from lowlevel/sb/sb.c - to avoid having to allocate a struct snd_sb for the */ +/* from lowlevel/sb/sb.c - to avoid having to allocate a sb_t for the */ /* short time we actually need it.. */ static int snd_sgalaxy_sbdsp_reset(unsigned long port) @@ -182,10 +180,10 @@ AD1848_DOUBLE("Aux Playback Switch", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 7 AD1848_DOUBLE("Aux Playback Volume", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 0, 0, 31, 0) }; -static int __init snd_sgalaxy_mixer(struct snd_ad1848 *chip) +static int __init snd_sgalaxy_mixer(ad1848_t *chip) { - struct snd_card *card = chip->card; - struct snd_ctl_elem_id id1, id2; + snd_card_t *card = chip->card; + snd_ctl_elem_id_t id1, id2; unsigned int idx; int err; @@ -218,14 +216,13 @@ static int __init snd_sgalaxy_mixer(struct snd_ad1848 *chip) return 0; } -static int __init snd_sgalaxy_probe(struct platform_device *devptr) +static int __init snd_sgalaxy_probe(int dev) { - int dev = devptr->id; static int possible_irqs[] = {7, 9, 10, 11, -1}; static int possible_dmas[] = {1, 3, 0, -1}; int err, xirq, xdma1; - struct snd_card *card; - struct snd_ad1848 *chip; + snd_card_t *card; + ad1848_t *chip; if (sbport[dev] == SNDRV_AUTO_PORT) { snd_printk(KERN_ERR PFX "specify SB port\n"); @@ -263,7 +260,6 @@ static int __init snd_sgalaxy_probe(struct platform_device *devptr) xirq, xdma1, AD1848_HW_DETECT, &chip)) < 0) goto _err; - card->private_data = chip; if ((err = snd_ad1848_pcm(chip, 0, NULL)) < 0) { snd_printdd(PFX "error creating new ad1848 PCM device\n"); @@ -283,12 +279,13 @@ static int __init snd_sgalaxy_probe(struct platform_device *devptr) sprintf(card->longname, "Sound Galaxy at 0x%lx, irq %d, dma %d", wssport[dev], xirq, xdma1); - snd_card_set_dev(card, &devptr->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; if ((err = snd_card_register(card)) < 0) goto _err; - platform_set_drvdata(devptr, card); + snd_sgalaxy_cards[dev] = card; return 0; _err: @@ -296,98 +293,30 @@ static int __init snd_sgalaxy_probe(struct platform_device *devptr) return err; } -static int __devexit snd_sgalaxy_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_sgalaxy_suspend(struct platform_device *pdev, pm_message_t state) -{ - struct snd_card *card = platform_get_drvdata(pdev); - struct snd_ad1848 *chip = card->private_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - chip->suspend(chip); - return 0; -} - -static int snd_sgalaxy_resume(struct platform_device *pdev) -{ - struct snd_card *card = platform_get_drvdata(pdev); - struct snd_ad1848 *chip = card->private_data; - - chip->resume(chip); - snd_ad1848_out(chip, SGALAXY_AUXC_LEFT, chip->image[SGALAXY_AUXC_LEFT]); - snd_ad1848_out(chip, SGALAXY_AUXC_RIGHT, chip->image[SGALAXY_AUXC_RIGHT]); - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - -#define SND_SGALAXY_DRIVER "snd_sgalaxy" - -static struct platform_driver snd_sgalaxy_driver = { - .probe = snd_sgalaxy_probe, - .remove = __devexit_p(snd_sgalaxy_remove), -#ifdef CONFIG_PM - .suspend = snd_sgalaxy_suspend, - .resume = snd_sgalaxy_resume, -#endif - .driver = { - .name = SND_SGALAXY_DRIVER - }, -}; - -static void __init_or_module snd_sgalaxy_unregister_all(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(devices); ++i) - platform_device_unregister(devices[i]); - platform_driver_unregister(&snd_sgalaxy_driver); -} - static int __init alsa_card_sgalaxy_init(void) { - int i, cards, err; - - err = platform_driver_register(&snd_sgalaxy_driver); - if (err < 0) - return err; + int dev, cards; - cards = 0; - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; - device = platform_device_register_simple(SND_SGALAXY_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - devices[i] = device; - cards++; + for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) { + if (snd_sgalaxy_probe(dev) >= 0) + cards++; } if (!cards) { #ifdef MODULE snd_printk(KERN_ERR "Sound Galaxy soundcard not found or device busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } - return 0; - errout: - snd_sgalaxy_unregister_all(); - return err; + return 0; } static void __exit alsa_card_sgalaxy_exit(void) { - snd_sgalaxy_unregister_all(); + int idx; + + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_sgalaxy_cards[idx]); } module_init(alsa_card_sgalaxy_init) diff --git a/trunk/sound/isa/sscape.c b/trunk/sound/isa/sscape.c index 5fb981c0a281..11588067fa4f 100644 --- a/trunk/sound/isa/sscape.c +++ b/trunk/sound/isa/sscape.c @@ -23,8 +23,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/delay.h> #include <linux/pnp.h> #include <linux/spinlock.h> @@ -67,9 +65,6 @@ MODULE_PARM_DESC(mpu_irq, "MPU401 IRQ # for SoundScape driver."); module_param_array(dma, int, NULL, 0444); MODULE_PARM_DESC(dma, "DMA # for SoundScape driver."); - -static struct platform_device *platform_devices[SNDRV_CARDS]; -static int pnp_registered; #ifdef CONFIG_PNP static struct pnp_card_device_id sscape_pnpids[] = { @@ -80,6 +75,8 @@ static struct pnp_card_device_id sscape_pnpids[] = { MODULE_DEVICE_TABLE(pnp_card, sscape_pnpids); #endif +static snd_card_t *sscape_card[SNDRV_CARDS]; + #define MPU401_IO(i) ((i) + 0) #define MIDI_DATA_IO(i) ((i) + 0) @@ -130,9 +127,9 @@ struct soundscape { int codec_type; int ic_type; struct resource *io_res; - struct snd_cs4231 *chip; - struct snd_mpu401 *mpu; - struct snd_hwdep *hw; + cs4231_t *chip; + mpu401_t *mpu; + snd_hwdep_t *hw; /* * The MIDI device won't work until we've loaded @@ -147,17 +144,17 @@ struct soundscape { #define INVALID_IRQ ((unsigned)-1) -static inline struct soundscape *get_card_soundscape(struct snd_card *c) +static inline struct soundscape *get_card_soundscape(snd_card_t * c) { return (struct soundscape *) (c->private_data); } -static inline struct soundscape *get_mpu401_soundscape(struct snd_mpu401 * mpu) +static inline struct soundscape *get_mpu401_soundscape(mpu401_t * mpu) { return (struct soundscape *) (mpu->private_data); } -static inline struct soundscape *get_hwdep_soundscape(struct snd_hwdep * hw) +static inline struct soundscape *get_hwdep_soundscape(snd_hwdep_t * hw) { return (struct soundscape *) (hw->private_data); } @@ -311,7 +308,7 @@ static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data, * * NOTE: This check is based upon observation, not documentation. */ -static inline int verify_mpu401(const struct snd_mpu401 * mpu) +static inline int verify_mpu401(const mpu401_t * mpu) { return ((inb(MIDI_CTRL_IO(mpu->port)) & 0xc0) == 0x80); } @@ -319,7 +316,7 @@ static inline int verify_mpu401(const struct snd_mpu401 * mpu) /* * This is apparently the standard way to initailise an MPU-401 */ -static inline void initialise_mpu401(const struct snd_mpu401 * mpu) +static inline void initialise_mpu401(const mpu401_t * mpu) { outb(0, MIDI_DATA_IO(mpu->port)); } @@ -338,7 +335,7 @@ static inline void activate_ad1845_unsafe(unsigned io_base) /* * Do the necessary ALSA-level cleanup to deallocate our driver ... */ -static void soundscape_free(struct snd_card *c) +static void soundscape_free(snd_card_t * c) { register struct soundscape *sscape = get_card_soundscape(c); release_and_free_resource(sscape->io_res); @@ -616,7 +613,7 @@ static int sscape_upload_microcode(struct soundscape *sscape, * simultaneously, and that we can't open it at all if * someone is using the MIDI device. */ -static int sscape_hw_open(struct snd_hwdep * hw, struct file *file) +static int sscape_hw_open(snd_hwdep_t * hw, struct file *file) { register struct soundscape *sscape = get_hwdep_soundscape(hw); unsigned long flags; @@ -635,7 +632,7 @@ static int sscape_hw_open(struct snd_hwdep * hw, struct file *file) return err; } -static int sscape_hw_release(struct snd_hwdep * hw, struct file *file) +static int sscape_hw_release(snd_hwdep_t * hw, struct file *file) { register struct soundscape *sscape = get_hwdep_soundscape(hw); unsigned long flags; @@ -646,7 +643,7 @@ static int sscape_hw_release(struct snd_hwdep * hw, struct file *file) return 0; } -static int sscape_hw_ioctl(struct snd_hwdep * hw, struct file *file, +static int sscape_hw_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg) { struct soundscape *sscape = get_hwdep_soundscape(hw); @@ -695,8 +692,8 @@ static int sscape_hw_ioctl(struct snd_hwdep * hw, struct file *file, /* * Mixer control for the SoundScape's MIDI device. */ -static int sscape_midi_info(struct snd_kcontrol *ctl, - struct snd_ctl_elem_info *uinfo) +static int sscape_midi_info(snd_kcontrol_t * ctl, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -705,11 +702,11 @@ static int sscape_midi_info(struct snd_kcontrol *ctl, return 0; } -static int sscape_midi_get(struct snd_kcontrol *kctl, - struct snd_ctl_elem_value *uctl) +static int sscape_midi_get(snd_kcontrol_t * kctl, + snd_ctl_elem_value_t * uctl) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kctl); - struct snd_card *card = chip->card; + cs4231_t *chip = snd_kcontrol_chip(kctl); + snd_card_t *card = chip->card; register struct soundscape *s = get_card_soundscape(card); unsigned long flags; @@ -725,11 +722,11 @@ static int sscape_midi_get(struct snd_kcontrol *kctl, return 0; } -static int sscape_midi_put(struct snd_kcontrol *kctl, - struct snd_ctl_elem_value *uctl) +static int sscape_midi_put(snd_kcontrol_t * kctl, + snd_ctl_elem_value_t * uctl) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kctl); - struct snd_card *card = chip->card; + cs4231_t *chip = snd_kcontrol_chip(kctl); + snd_card_t *card = chip->card; register struct soundscape *s = get_card_soundscape(card); unsigned long flags; int change; @@ -766,7 +763,7 @@ static int sscape_midi_put(struct snd_kcontrol *kctl, return change; } -static struct snd_kcontrol_new midi_mixer_ctl = { +static snd_kcontrol_new_t midi_mixer_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "MIDI", .info = sscape_midi_info, @@ -852,7 +849,7 @@ static int __devinit detect_sscape(struct soundscape *s) * to crash the machine. Also check that someone isn't using the hardware * IOCTL device. */ -static int mpu401_open(struct snd_mpu401 * mpu) +static int mpu401_open(mpu401_t * mpu) { int err; @@ -878,7 +875,7 @@ static int mpu401_open(struct snd_mpu401 * mpu) return err; } -static void mpu401_close(struct snd_mpu401 * mpu) +static void mpu401_close(mpu401_t * mpu) { register struct soundscape *sscape = get_mpu401_soundscape(mpu); unsigned long flags; @@ -891,10 +888,10 @@ static void mpu401_close(struct snd_mpu401 * mpu) /* * Initialse an MPU-401 subdevice for MIDI support on the SoundScape. */ -static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned long port, int irq) +static int __devinit create_mpu401(snd_card_t * card, int devnum, unsigned long port, int irq) { struct soundscape *sscape = get_card_soundscape(card); - struct snd_rawmidi *rawmidi; + snd_rawmidi_t *rawmidi; int err; #define MPU401_SHARE_HARDWARE 1 @@ -903,7 +900,7 @@ static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned l port, MPU401_SHARE_HARDWARE, irq, SA_INTERRUPT, &rawmidi)) == 0) { - struct snd_mpu401 *mpu = (struct snd_mpu401 *) rawmidi->private_data; + mpu401_t *mpu = (mpu401_t *) rawmidi->private_data; mpu->open_input = mpu401_open; mpu->open_output = mpu401_open; mpu->close_input = mpu401_close; @@ -922,7 +919,7 @@ static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned l * Override for the CS4231 playback format function. * The AD1845 has much simpler format and rate selection. */ -static void ad1845_playback_format(struct snd_cs4231 * chip, struct snd_pcm_hw_params *params, unsigned char format) +static void ad1845_playback_format(cs4231_t * chip, snd_pcm_hw_params_t * params, unsigned char format) { unsigned long flags; unsigned rate = params_rate(params); @@ -958,7 +955,7 @@ static void ad1845_playback_format(struct snd_cs4231 * chip, struct snd_pcm_hw_p * Override for the CS4231 capture format function. * The AD1845 has much simpler format and rate selection. */ -static void ad1845_capture_format(struct snd_cs4231 * chip, struct snd_pcm_hw_params *params, unsigned char format) +static void ad1845_capture_format(cs4231_t * chip, snd_pcm_hw_params_t * params, unsigned char format) { unsigned long flags; unsigned rate = params_rate(params); @@ -996,10 +993,10 @@ static void ad1845_capture_format(struct snd_cs4231 * chip, struct snd_pcm_hw_pa * try to support at least some of the extra bits by overriding * some of the CS4231 callback. */ -static int __devinit create_ad1845(struct snd_card *card, unsigned port, int irq, int dma1) +static int __devinit create_ad1845(snd_card_t * card, unsigned port, int irq, int dma1) { register struct soundscape *sscape = get_card_soundscape(card); - struct snd_cs4231 *chip; + cs4231_t *chip; int err; #define CS4231_SHARE_HARDWARE (CS4231_HWSHARE_DMA1 | CS4231_HWSHARE_DMA2) @@ -1012,7 +1009,7 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port, int irq CS4231_HW_DETECT, CS4231_HWSHARE_DMA1, &chip)) == 0) { unsigned long flags; - struct snd_pcm *pcm; + snd_pcm_t *pcm; #define AD1845_FREQ_SEL_ENABLE 0x08 @@ -1083,18 +1080,48 @@ static int __devinit create_ad1845(struct snd_card *card, unsigned port, int irq } +struct params +{ + int index; + const char *id; + unsigned port; + int irq; + int mpu_irq; + int dma1; +}; + + +static inline struct params* +init_params(struct params *params, + int index, + const char *id, + unsigned port, + int irq, + int mpu_irq, + int dma1) +{ + params->index = index; + params->id = id; + params->port = port; + params->irq = irq; + params->mpu_irq = mpu_irq; + params->dma1 = (dma1 & 0x03); + + return params; +} + + /* * Create an ALSA soundcard entry for the SoundScape, using * the given list of port, IRQ and DMA resources. */ -static int __devinit create_sscape(int dev, struct snd_card **rcardp) +static int __devinit create_sscape(const struct params *params, snd_card_t **rcardp) { - struct snd_card *card; + snd_card_t *card; register struct soundscape *sscape; register unsigned dma_cfg; unsigned irq_cfg; unsigned mpu_irq_cfg; - unsigned xport; struct resource *io_res; unsigned long flags; int err; @@ -1102,33 +1129,32 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) /* * Check that the user didn't pass us garbage data ... */ - irq_cfg = get_irq_config(irq[dev]); + irq_cfg = get_irq_config(params->irq); if (irq_cfg == INVALID_IRQ) { - snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", irq[dev]); + snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", params->irq); return -ENXIO; } - mpu_irq_cfg = get_irq_config(mpu_irq[dev]); + mpu_irq_cfg = get_irq_config(params->mpu_irq); if (mpu_irq_cfg == INVALID_IRQ) { - printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]); + printk(KERN_ERR "sscape: Invalid IRQ %d\n", params->mpu_irq); return -ENXIO; } - xport = port[dev]; /* * Grab IO ports that we will need to probe so that we * can detect and control this hardware ... */ - if ((io_res = request_region(xport, 8, "SoundScape")) == NULL) { - snd_printk(KERN_ERR "sscape: can't grab port 0x%x\n", xport); + if ((io_res = request_region(params->port, 8, "SoundScape")) == NULL) { + snd_printk(KERN_ERR "sscape: can't grab port 0x%x\n", params->port); return -EBUSY; } /* * Grab both DMA channels (OK, only one for now) ... */ - if ((err = request_dma(dma[dev], "SoundScape")) < 0) { - snd_printk(KERN_ERR "sscape: can't grab DMA %d\n", dma[dev]); + if ((err = request_dma(params->dma1, "SoundScape")) < 0) { + snd_printk(KERN_ERR "sscape: can't grab DMA %d\n", params->dma1); goto _release_region; } @@ -1136,8 +1162,7 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) * Create a new ALSA sound card entry, in anticipation * of detecting our hardware ... */ - if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof(struct soundscape))) == NULL) { + if ((card = snd_card_new(params->index, params->id, THIS_MODULE, sizeof(struct soundscape))) == NULL) { err = -ENOMEM; goto _release_dma; } @@ -1146,7 +1171,7 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) spin_lock_init(&sscape->lock); spin_lock_init(&sscape->fwlock); sscape->io_res = io_res; - sscape->io_base = xport; + sscape->io_base = params->port; if (!detect_sscape(sscape)) { printk(KERN_ERR "sscape: hardware not detected at 0x%x\n", sscape->io_base); @@ -1155,7 +1180,7 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) } printk(KERN_INFO "sscape: hardware detected at 0x%x, using IRQ %d, DMA %d\n", - sscape->io_base, irq[dev], dma[dev]); + sscape->io_base, params->irq, params->dma1); /* * Now create the hardware-specific device so that we can @@ -1198,7 +1223,7 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) sscape_write_unsafe(sscape->io_base, GA_INTCFG_REG, 0xf0 | (mpu_irq_cfg << 2) | mpu_irq_cfg); sscape_write_unsafe(sscape->io_base, - GA_CDCFG_REG, 0x09 | DMA_8BIT | (dma[dev] << 4) | (irq_cfg << 1)); + GA_CDCFG_REG, 0x09 | DMA_8BIT | (params->dma1 << 4) | (irq_cfg << 1)); spin_unlock_irqrestore(&sscape->lock, flags); @@ -1206,15 +1231,15 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) * We have now enabled the codec chip, and so we should * detect the AD1845 device ... */ - if ((err = create_ad1845(card, CODEC_IO(xport), irq[dev], dma[dev])) < 0) { + if ((err = create_ad1845(card, CODEC_IO(params->port), params->irq, params->dma1)) < 0) { printk(KERN_ERR "sscape: No AD1845 device at 0x%x, IRQ %d\n", - CODEC_IO(xport), irq[dev]); + CODEC_IO(params->port), params->irq); goto _release_card; } #define MIDI_DEVNUM 0 - if ((err = create_mpu401(card, MIDI_DEVNUM, MPU401_IO(xport), mpu_irq[dev])) < 0) { + if ((err = create_mpu401(card, MIDI_DEVNUM, MPU401_IO(params->port), params->mpu_irq)) < 0) { printk(KERN_ERR "sscape: Failed to create MPU-401 device at 0x%x\n", - MPU401_IO(xport)); + MPU401_IO(params->port)); goto _release_card; } @@ -1246,7 +1271,7 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) snd_card_free(card); _release_dma: - free_dma(dma[dev]); + free_dma(params->dma1); _release_region: release_and_free_resource(io_res); @@ -1255,66 +1280,44 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp) } -static int __init snd_sscape_probe(struct platform_device *pdev) -{ - int dev = pdev->id; - struct snd_card *card; - int ret; - - dma[dev] &= 0x03; - ret = create_sscape(dev, &card); - if (ret < 0) - return ret; - snd_card_set_dev(card, &pdev->dev); - if ((ret = snd_card_register(card)) < 0) { - printk(KERN_ERR "sscape: Failed to register sound card\n"); - return ret; - } - platform_set_drvdata(pdev, card); - return 0; -} - -static int __devexit snd_sscape_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define SSCAPE_DRIVER "snd_sscape" - -static struct platform_driver snd_sscape_driver = { - .probe = snd_sscape_probe, - .remove = __devexit_p(snd_sscape_remove), - /* FIXME: suspend/resume */ - .driver = { - .name = SSCAPE_DRIVER - }, -}; +static int sscape_cards __devinitdata; +static struct params sscape_params[SNDRV_CARDS] __devinitdata; #ifdef CONFIG_PNP static inline int __devinit get_next_autoindex(int i) { - while (i < SNDRV_CARDS && port[i] != SNDRV_AUTO_PORT) + while ((i < SNDRV_CARDS) && (port[i] != SNDRV_AUTO_PORT)) { ++i; + } /* while */ + return i; } +static inline int __devinit is_port_known(unsigned io, struct params *params, int cards) +{ + while (--cards >= 0) { + if (params[cards].port == io) + return 1; + } /* while */ + + return 0; +} + static int __devinit sscape_pnp_detect(struct pnp_card_link *pcard, const struct pnp_card_device_id *pid) { - static int idx = 0; struct pnp_dev *dev; - struct snd_card *card; + static int idx = 0; int ret; /* * Allow this function to fail *quietly* if all the ISA PnP * devices were configured using module parameters instead. */ - if ((idx = get_next_autoindex(idx)) >= SNDRV_CARDS) + if ((idx = get_next_autoindex(idx)) >= SNDRV_CARDS) { return -ENOSPC; + } /* * We have found a candidate ISA PnP card. Now we @@ -1336,45 +1339,66 @@ static int __devinit sscape_pnp_detect(struct pnp_card_link *pcard, /* * Check that we still have room for another sound card ... */ - dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL); - if (! dev) - return -ENODEV; - - if (!pnp_is_active(dev)) { - if (pnp_activate_dev(dev) < 0) { - printk(KERN_INFO "sscape: device is inactive\n"); - return -EBUSY; - } + if (sscape_cards >= SNDRV_CARDS) { + printk(KERN_ERR "sscape: No room for another ALSA device\n"); + return -ENOSPC; } - /* - * Read the correct parameters off the ISA PnP bus ... - */ - port[idx] = pnp_port_start(dev, 0); - irq[idx] = pnp_irq(dev, 0); - mpu_irq[idx] = pnp_irq(dev, 1); - dma[idx] = pnp_dma(dev, 0) & 0x03; + ret = -ENODEV; - ret = create_sscape(idx, &card); - if (ret < 0) - return ret; - snd_card_set_dev(card, &pcard->card->dev); - if ((ret = snd_card_register(card)) < 0) { - printk(KERN_ERR "sscape: Failed to register sound card\n"); - snd_card_free(card); - return ret; - } + dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL); + if (dev) { + struct params *this; + if (!pnp_is_active(dev)) { + if (pnp_activate_dev(dev) < 0) { + printk(KERN_INFO "sscape: device is inactive\n"); + return -EBUSY; + } + } + /* + * Read the correct parameters off the ISA PnP bus ... + */ + this = init_params(&sscape_params[sscape_cards], + index[idx], + id[idx], + pnp_port_start(dev, 0), + pnp_irq(dev, 0), + pnp_irq(dev, 1), + pnp_dma(dev, 0)); - pnp_set_card_drvdata(pcard, card); - ++idx; + /* + * Do we know about this sound card already? + */ + if ( !is_port_known(this->port, sscape_params, sscape_cards) ) { + snd_card_t *card; + + ret = create_sscape(this, &card); + if (ret < 0) + return ret; + snd_card_set_dev(card, &pcard->card->dev); + + if ((ret = snd_card_register(card)) < 0) { + printk(KERN_ERR "sscape: Failed to register sound card\n"); + snd_card_free(card); + return ret; + } + + pnp_set_card_drvdata(pcard, card); + ++sscape_cards; + ++idx; + } + } return ret; } static void __devexit sscape_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + pnp_set_card_drvdata(pcard, NULL); + snd_card_disconnect(card); + snd_card_free_in_thread(card); } static struct pnp_card_driver sscape_pnpc_driver = { @@ -1387,25 +1411,11 @@ static struct pnp_card_driver sscape_pnpc_driver = { #endif /* CONFIG_PNP */ -static void __init_or_module sscape_unregister_all(void) -{ - int i; - - if (pnp_registered) - pnp_unregister_card_driver(&sscape_pnpc_driver); - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_sscape_driver); -} - -static int __init sscape_manual_probe(void) +static int __init sscape_manual_probe(struct params *params) { - struct platform_device *device; - int i, ret; - - ret = platform_driver_register(&snd_sscape_driver); - if (ret < 0) - return ret; + int ret; + unsigned i; + snd_card_t *card; for (i = 0; i < SNDRV_CARDS; ++i) { /* @@ -1420,36 +1430,52 @@ static int __init sscape_manual_probe(void) /* * Make sure we were given ALL of the other parameters. */ - if (irq[i] == SNDRV_AUTO_IRQ || - mpu_irq[i] == SNDRV_AUTO_IRQ || - dma[i] == SNDRV_AUTO_DMA) { + if ( (irq[i] == SNDRV_AUTO_IRQ) || + (mpu_irq[i] == SNDRV_AUTO_IRQ) || + (dma[i] == SNDRV_AUTO_DMA) ) { printk(KERN_INFO "sscape: insufficient parameters, need IO, IRQ, MPU-IRQ and DMA\n"); - ret = -ENXIO; - goto errout; + return -ENXIO; } /* * This cards looks OK ... */ - device = platform_device_register_simple(SSCAPE_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - ret = PTR_ERR(device); - goto errout; + init_params(params, index[i], id[i], port[i], irq[i], mpu_irq[i], dma[i]); + + ret = create_sscape(params, &card); + if (ret < 0) + return ret; + + if ((ret = snd_card_set_generic_dev(card)) < 0) { + snd_card_free(card); + return ret; + } + if ((ret = snd_card_register(card)) < 0) { + printk(KERN_ERR "sscape: Failed to register sound card\n"); + snd_card_free(card); + return ret; } - platform_devices[i] = device; - } - return 0; - errout: - sscape_unregister_all(); - return ret; + sscape_card[sscape_cards] = card; + params++; + sscape_cards++; + } /* for */ + + return 0; } + static void sscape_exit(void) { - sscape_unregister_all(); + unsigned i; + +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&sscape_pnpc_driver); +#endif + for (i = 0; i < ARRAY_SIZE(sscape_card); ++i) { + snd_card_free(sscape_card[i]); + } /* for */ } @@ -1463,11 +1489,24 @@ static int __init sscape_init(void) * of allocating cards, because the operator is * S-P-E-L-L-I-N-G it out for us... */ - ret = sscape_manual_probe(); - if (ret < 0) + ret = sscape_manual_probe(sscape_params); + if (ret < 0) { + int i; + for (i = 0; i < sscape_cards; ++i) + snd_card_free(sscape_card[i]); return ret; - if (pnp_register_card_driver(&sscape_pnpc_driver) >= 0) - pnp_registered = 1; + } + +#ifdef CONFIG_PNP + if (sscape_cards < SNDRV_CARDS) { + ret = pnp_register_card_driver(&sscape_pnpc_driver); + if (ret < 0) { + sscape_exit(); + return ret; + } + } +#endif + return 0; } diff --git a/trunk/sound/isa/wavefront/wavefront.c b/trunk/sound/isa/wavefront/wavefront.c index a6dcb2f970ca..1818f1013c3f 100644 --- a/trunk/sound/isa/wavefront/wavefront.c +++ b/trunk/sound/isa/wavefront/wavefront.c @@ -23,8 +23,6 @@ #include <linux/init.h> #include <linux/interrupt.h> #include <linux/slab.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/pnp.h> #include <linux/moduleparam.h> #include <sound/core.h> @@ -83,9 +81,7 @@ MODULE_PARM_DESC(fm_port, "FM port #."); module_param_array(use_cs4232_midi, bool, NULL, 0444); MODULE_PARM_DESC(use_cs4232_midi, "Use CS4232 MPU-401 interface (inaccessibly located inside your computer)"); -static struct platform_device *platform_devices[SNDRV_CARDS]; -static int pnp_registered; - +static snd_card_t *snd_wavefront_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; #ifdef CONFIG_PNP @@ -244,7 +240,7 @@ snd_wavefront_pnp (int dev, snd_wavefront_card_t *acard, struct pnp_card_link *c cs4232_mpu_irq[dev] = pnp_irq(pdev, 0); } - snd_printk (KERN_INFO "CS4232 MPU: port=0x%lx, irq=%i\n", + snd_printk ("CS4232 MPU: port=0x%lx, irq=%i\n", cs4232_mpu_port[dev], cs4232_mpu_irq[dev]); } @@ -283,12 +279,12 @@ static irqreturn_t snd_wavefront_ics2115_interrupt(int irq, return IRQ_HANDLED; } -static struct snd_hwdep * __devinit -snd_wavefront_new_synth (struct snd_card *card, +static snd_hwdep_t * __devinit +snd_wavefront_new_synth (snd_card_t *card, int hw_dev, snd_wavefront_card_t *acard) { - struct snd_hwdep *wavefront_synth; + snd_hwdep_t *wavefront_synth; if (snd_wavefront_detect (acard) < 0) { return NULL; @@ -309,17 +305,17 @@ snd_wavefront_new_synth (struct snd_card *card, return wavefront_synth; } -static struct snd_hwdep * __devinit -snd_wavefront_new_fx (struct snd_card *card, +static snd_hwdep_t * __devinit +snd_wavefront_new_fx (snd_card_t *card, int hw_dev, snd_wavefront_card_t *acard, unsigned long port) { - struct snd_hwdep *fx_processor; + snd_hwdep_t *fx_processor; if (snd_wavefront_fx_start (&acard->wavefront)) { - snd_printk (KERN_ERR "cannot initialize YSS225 FX processor"); + snd_printk ("cannot initialize YSS225 FX processor"); return NULL; } @@ -336,22 +332,22 @@ snd_wavefront_new_fx (struct snd_card *card, static snd_wavefront_mpu_id internal_id = internal_mpu; static snd_wavefront_mpu_id external_id = external_mpu; -static struct snd_rawmidi *__devinit -snd_wavefront_new_midi (struct snd_card *card, +static snd_rawmidi_t * __devinit +snd_wavefront_new_midi (snd_card_t *card, int midi_dev, snd_wavefront_card_t *acard, unsigned long port, snd_wavefront_mpu_id mpu) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; static int first = 1; if (first) { first = 0; acard->wavefront.midi.base = port; if (snd_wavefront_midi_start (acard)) { - snd_printk (KERN_ERR "cannot initialize MIDI interface\n"); + snd_printk ("cannot initialize MIDI interface\n"); return NULL; } } @@ -378,7 +374,7 @@ snd_wavefront_new_midi (struct snd_card *card, } static void -snd_wavefront_free(struct snd_card *card) +snd_wavefront_free(snd_card_t *card) { snd_wavefront_card_t *acard = (snd_wavefront_card_t *)card->private_data; @@ -389,17 +385,42 @@ snd_wavefront_free(struct snd_card *card) } } -static struct snd_card *snd_wavefront_card_new(int dev) +static int __devinit +snd_wavefront_probe (int dev, struct pnp_card_link *pcard, + const struct pnp_card_device_id *pid) { - struct snd_card *card; + snd_card_t *card; snd_wavefront_card_t *acard; + cs4231_t *chip; + snd_hwdep_t *wavefront_synth; + snd_rawmidi_t *ics2115_internal_rmidi = NULL; + snd_rawmidi_t *ics2115_external_rmidi = NULL; + snd_hwdep_t *fx_processor; + int hw_dev = 0, midi_dev = 0, err; - card = snd_card_new (index[dev], id[dev], THIS_MODULE, +#ifdef CONFIG_PNP + if (!isapnp[dev]) { +#endif + if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { + snd_printk("specify CS4232 port\n"); + return -EINVAL; + } + if (ics2115_port[dev] == SNDRV_AUTO_PORT) { + snd_printk("specify ICS2115 port\n"); + return -ENODEV; + } +#ifdef CONFIG_PNP + } +#endif + card = snd_card_new (index[dev], + id[dev], + THIS_MODULE, sizeof(snd_wavefront_card_t)); - if (card == NULL) - return NULL; - acard = card->private_data; + if (card == NULL) { + return -ENOMEM; + } + acard = (snd_wavefront_card_t *)card->private_data; acard->wavefront.irq = -1; spin_lock_init(&acard->wavefront.irq_lock); init_waitqueue_head(&acard->wavefront.interrupt_sleeper); @@ -407,19 +428,18 @@ static struct snd_card *snd_wavefront_card_new(int dev) spin_lock_init(&acard->wavefront.midi.virtual); card->private_free = snd_wavefront_free; - return card; -} - -static int __devinit -snd_wavefront_probe (struct snd_card *card, int dev) -{ - snd_wavefront_card_t *acard = card->private_data; - struct snd_cs4231 *chip; - struct snd_hwdep *wavefront_synth; - struct snd_rawmidi *ics2115_internal_rmidi = NULL; - struct snd_rawmidi *ics2115_external_rmidi = NULL; - struct snd_hwdep *fx_processor; - int hw_dev = 0, midi_dev = 0, err; +#ifdef CONFIG_PNP + if (isapnp[dev]) { + if (snd_wavefront_pnp (dev, acard, pcard, pid) < 0) { + if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { + snd_printk ("isapnp detection failed\n"); + snd_card_free (card); + return -ENODEV; + } + } + snd_card_set_dev(card, &pcard->card->dev); + } +#endif /* CONFIG_PNP */ /* --------- PCM --------------- */ @@ -430,46 +450,52 @@ snd_wavefront_probe (struct snd_card *card, int dev) dma1[dev], dma2[dev], CS4231_HW_DETECT, 0, &chip)) < 0) { - snd_printk (KERN_ERR "can't allocate CS4231 device\n"); + snd_card_free(card); + snd_printk ("can't allocate CS4231 device\n"); return err; } - if ((err = snd_cs4231_pcm (chip, 0, NULL)) < 0) + if ((err = snd_cs4231_pcm (chip, 0, NULL)) < 0) { + snd_card_free(card); return err; - - if ((err = snd_cs4231_timer (chip, 0, NULL)) < 0) + } + if ((err = snd_cs4231_timer (chip, 0, NULL)) < 0) { + snd_card_free(card); return err; + } /* ---------- OPL3 synth --------- */ if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { - struct snd_opl3 *opl3; + opl3_t *opl3; if ((err = snd_opl3_create(card, fm_port[dev], fm_port[dev] + 2, OPL3_HW_OPL3_CS, 0, &opl3)) < 0) { - snd_printk (KERN_ERR "can't allocate or detect OPL3 synth\n"); + snd_printk ("can't allocate or detect OPL3 synth\n"); + snd_card_free(card); return err; } - if ((err = snd_opl3_hwdep_new(opl3, hw_dev, 1, NULL)) < 0) + if ((err = snd_opl3_hwdep_new(opl3, hw_dev, 1, NULL)) < 0) { + snd_card_free(card); return err; + } hw_dev++; } /* ------- ICS2115 Wavetable synth ------- */ - if ((acard->wavefront.res_base = request_region(ics2115_port[dev], 16, - "ICS2115")) == NULL) { - snd_printk(KERN_ERR "unable to grab ICS2115 i/o region 0x%lx-0x%lx\n", - ics2115_port[dev], ics2115_port[dev] + 16 - 1); + if ((acard->wavefront.res_base = request_region(ics2115_port[dev], 16, "ICS2115")) == NULL) { + snd_printk("unable to grab ICS2115 i/o region 0x%lx-0x%lx\n", ics2115_port[dev], ics2115_port[dev] + 16 - 1); + snd_card_free(card); return -EBUSY; } - if (request_irq(ics2115_irq[dev], snd_wavefront_ics2115_interrupt, - SA_INTERRUPT, "ICS2115", acard)) { - snd_printk(KERN_ERR "unable to use ICS2115 IRQ %d\n", ics2115_irq[dev]); + if (request_irq(ics2115_irq[dev], snd_wavefront_ics2115_interrupt, SA_INTERRUPT, "ICS2115", (void *)acard)) { + snd_printk("unable to use ICS2115 IRQ %d\n", ics2115_irq[dev]); + snd_card_free(card); return -EBUSY; } @@ -477,7 +503,8 @@ snd_wavefront_probe (struct snd_card *card, int dev) acard->wavefront.base = ics2115_port[dev]; if ((wavefront_synth = snd_wavefront_new_synth (card, hw_dev, acard)) == NULL) { - snd_printk (KERN_ERR "can't create WaveFront synth device\n"); + snd_printk ("can't create WaveFront synth device\n"); + snd_card_free(card); return -ENOMEM; } @@ -488,7 +515,8 @@ snd_wavefront_probe (struct snd_card *card, int dev) /* --------- Mixer ------------ */ if ((err = snd_cs4231_mixer(chip)) < 0) { - snd_printk (KERN_ERR "can't allocate mixer device\n"); + snd_printk ("can't allocate mixer device\n"); + snd_card_free(card); return err; } @@ -500,7 +528,8 @@ snd_wavefront_probe (struct snd_card *card, int dev) cs4232_mpu_irq[dev], SA_INTERRUPT, NULL)) < 0) { - snd_printk (KERN_ERR "can't allocate CS4232 MPU-401 device\n"); + snd_printk ("can't allocate CS4232 MPU-401 device\n"); + snd_card_free(card); return err; } midi_dev++; @@ -516,7 +545,8 @@ snd_wavefront_probe (struct snd_card *card, int dev) ics2115_port[dev], internal_mpu); if (ics2115_internal_rmidi == NULL) { - snd_printk (KERN_ERR "can't setup ICS2115 internal MIDI device\n"); + snd_printk ("can't setup ICS2115 internal MIDI device\n"); + snd_card_free(card); return -ENOMEM; } midi_dev++; @@ -532,7 +562,8 @@ snd_wavefront_probe (struct snd_card *card, int dev) ics2115_port[dev], external_mpu); if (ics2115_external_rmidi == NULL) { - snd_printk (KERN_ERR "can't setup ICS2115 external MIDI device\n"); + snd_printk ("can't setup ICS2115 external MIDI device\n"); + snd_card_free(card); return -ENOMEM; } midi_dev++; @@ -546,7 +577,8 @@ snd_wavefront_probe (struct snd_card *card, int dev) acard, ics2115_port[dev]); if (fx_processor == NULL) { - snd_printk (KERN_ERR "can't setup FX device\n"); + snd_printk ("can't setup FX device\n"); + snd_card_free(card); return -ENOMEM; } @@ -587,97 +619,49 @@ snd_wavefront_probe (struct snd_card *card, int dev) ics2115_port[dev], ics2115_irq[dev]); - return snd_card_register(card); -} - -static int __init snd_wavefront_nonpnp_probe(struct platform_device *pdev) -{ - int dev = pdev->id; - struct snd_card *card; - int err; - - if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { - snd_printk("specify CS4232 port\n"); - return -EINVAL; - } - if (ics2115_port[dev] == SNDRV_AUTO_PORT) { - snd_printk("specify ICS2115 port\n"); - return -ENODEV; + if ((err = snd_card_set_generic_dev(card)) < 0) { + snd_card_free(card); + return err; } - card = snd_wavefront_card_new(dev); - if (! card) - return -ENOMEM; - snd_card_set_dev(card, &pdev->dev); - if ((err = snd_wavefront_probe(card, dev)) < 0) { + if ((err = snd_card_register(card)) < 0) { snd_card_free(card); return err; } - - platform_set_drvdata(pdev, card); + if (pcard) + pnp_set_card_drvdata(pcard, card); + else + snd_wavefront_legacy[dev] = card; return 0; -} - -static int __devexit snd_wavefront_nonpnp_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#define WAVEFRONT_DRIVER "snd_wavefront" - -static struct platform_driver snd_wavefront_driver = { - .probe = snd_wavefront_nonpnp_probe, - .remove = __devexit_p(snd_wavefront_nonpnp_remove), - /* FIXME: suspend, resume */ - .driver = { - .name = WAVEFRONT_DRIVER - }, -}; - +} #ifdef CONFIG_PNP -static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard, - const struct pnp_card_device_id *pid) +static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *card, + const struct pnp_card_device_id *id) { - static int dev; - struct snd_card *card; - int res; - - for ( ; dev < SNDRV_CARDS; dev++) { - if (enable[dev] && isapnp[dev]) - break; - } - if (dev >= SNDRV_CARDS) - return -ENODEV; - - card = snd_wavefront_card_new(dev); - if (! card) - return -ENOMEM; - - if (snd_wavefront_pnp (dev, card->private_data, pcard, pid) < 0) { - if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { - snd_printk (KERN_ERR "isapnp detection failed\n"); - snd_card_free (card); - return -ENODEV; - } - } - snd_card_set_dev(card, &pcard->card->dev); - - if ((res = snd_wavefront_probe(card, dev)) < 0) - return res; - - pnp_set_card_drvdata(pcard, card); - dev++; - return 0; + static int dev; + int res; + + for ( ; dev < SNDRV_CARDS; dev++) { + if (!enable[dev] || !isapnp[dev]) + continue; + res = snd_wavefront_probe(dev, card, id); + if (res < 0) + return res; + dev++; + return 0; + } + + return -ENODEV; } static void __devexit snd_wavefront_pnp_remove(struct pnp_card_link * pcard) { - snd_card_free(pnp_get_card_drvdata(pcard)); - pnp_set_card_drvdata(pcard, NULL); + snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard); + + snd_card_disconnect(card); + snd_card_free_in_thread(card); } static struct pnp_card_driver wavefront_pnpc_driver = { @@ -686,68 +670,48 @@ static struct pnp_card_driver wavefront_pnpc_driver = { .id_table = snd_wavefront_pnpids, .probe = snd_wavefront_pnp_detect, .remove = __devexit_p(snd_wavefront_pnp_remove), - /* FIXME: suspend,resume */ }; #endif /* CONFIG_PNP */ -static void __init_or_module snd_wavefront_unregister_all(void) -{ - int i; - - if (pnp_registered) - pnp_unregister_card_driver(&wavefront_pnpc_driver); - for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) - platform_device_unregister(platform_devices[i]); - platform_driver_unregister(&snd_wavefront_driver); -} - static int __init alsa_card_wavefront_init(void) { - int i, err, cards = 0; - - if ((err = platform_driver_register(&snd_wavefront_driver)) < 0) - return err; - - for (i = 0; i < SNDRV_CARDS && enable[i]; i++) { - struct platform_device *device; + int cards = 0; + int dev; + for (dev = 0; dev < SNDRV_CARDS; dev++) { + if (!enable[dev]) + continue; #ifdef CONFIG_PNP - if (isapnp[i]) + if (isapnp[dev]) continue; #endif - device = platform_device_register_simple(WAVEFRONT_DRIVER, - i, NULL, 0); - if (IS_ERR(device)) { - err = PTR_ERR(device); - goto errout; - } - platform_devices[i] = device; - cards++; - } - - i = pnp_register_card_driver(&wavefront_pnpc_driver); - if (i >= 0) { - pnp_registered = 1; - cards += i; + if (snd_wavefront_probe(dev, NULL, NULL) >= 0) + cards++; } - +#ifdef CONFIG_PNP + cards += pnp_register_card_driver(&wavefront_pnpc_driver); +#endif if (!cards) { +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&wavefront_pnpc_driver); +#endif #ifdef MODULE printk (KERN_ERR "No WaveFront cards found or devices busy\n"); #endif - err = -ENODEV; - goto errout; + return -ENODEV; } return 0; - - errout: - snd_wavefront_unregister_all(); - return err; } static void __exit alsa_card_wavefront_exit(void) { - snd_wavefront_unregister_all(); + int idx; + +#ifdef CONFIG_PNP + pnp_unregister_card_driver(&wavefront_pnpc_driver); +#endif + for (idx = 0; idx < SNDRV_CARDS; idx++) + snd_card_free(snd_wavefront_legacy[idx]); } module_init(alsa_card_wavefront_init) diff --git a/trunk/sound/isa/wavefront/wavefront_fx.c b/trunk/sound/isa/wavefront/wavefront_fx.c index 180661c5ffdc..32379688eed4 100644 --- a/trunk/sound/isa/wavefront/wavefront_fx.c +++ b/trunk/sound/isa/wavefront/wavefront_fx.c @@ -460,7 +460,7 @@ snd_wavefront_fx_detect (snd_wavefront_t *dev) } int -snd_wavefront_fx_open (struct snd_hwdep *hw, struct file *file) +snd_wavefront_fx_open (snd_hwdep_t *hw, struct file *file) { if (!try_module_get(hw->card->module)) @@ -470,7 +470,7 @@ snd_wavefront_fx_open (struct snd_hwdep *hw, struct file *file) } int -snd_wavefront_fx_release (struct snd_hwdep *hw, struct file *file) +snd_wavefront_fx_release (snd_hwdep_t *hw, struct file *file) { module_put(hw->card->module); @@ -478,11 +478,11 @@ snd_wavefront_fx_release (struct snd_hwdep *hw, struct file *file) } int -snd_wavefront_fx_ioctl (struct snd_hwdep *sdev, struct file *file, +snd_wavefront_fx_ioctl (snd_hwdep_t *sdev, struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_card *card; + snd_card_t *card; snd_wavefront_card_t *acard; snd_wavefront_t *dev; wavefront_fx_info r; diff --git a/trunk/sound/isa/wavefront/wavefront_midi.c b/trunk/sound/isa/wavefront/wavefront_midi.c index 15888ba2169b..6f51d64fb565 100644 --- a/trunk/sound/isa/wavefront/wavefront_midi.c +++ b/trunk/sound/isa/wavefront/wavefront_midi.c @@ -91,10 +91,10 @@ write_data (snd_wavefront_midi_t *midi, unsigned char byte) } static snd_wavefront_midi_t * -get_wavefront_midi (struct snd_rawmidi_substream *substream) +get_wavefront_midi (snd_rawmidi_substream_t *substream) { - struct snd_card *card; + snd_card_t *card; snd_wavefront_card_t *acard; if (substream == NULL || substream->rmidi == NULL) @@ -230,7 +230,7 @@ static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card) } } -static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_wavefront_midi_input_open(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_wavefront_midi_t *midi; @@ -252,7 +252,7 @@ static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream return 0; } -static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_wavefront_midi_output_open(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_wavefront_midi_t *midi; @@ -274,7 +274,7 @@ static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substrea return 0; } -static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_wavefront_midi_input_close(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_wavefront_midi_t *midi; @@ -295,7 +295,7 @@ static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substrea return 0; } -static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_wavefront_midi_output_close(snd_rawmidi_substream_t * substream) { unsigned long flags; snd_wavefront_midi_t *midi; @@ -315,7 +315,7 @@ static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substre return 0; } -static void snd_wavefront_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_wavefront_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; snd_wavefront_midi_t *midi; @@ -355,7 +355,7 @@ static void snd_wavefront_midi_output_timer(unsigned long data) snd_wavefront_midi_output_write(card); } -static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_wavefront_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; snd_wavefront_midi_t *midi; @@ -401,7 +401,7 @@ snd_wavefront_midi_interrupt (snd_wavefront_card_t *card) { unsigned long flags; snd_wavefront_midi_t *midi; - static struct snd_rawmidi_substream *substream = NULL; + static snd_rawmidi_substream_t *substream = NULL; static int mpu = external_mpu; int max = 128; unsigned char byte; @@ -554,14 +554,14 @@ snd_wavefront_midi_start (snd_wavefront_card_t *card) return 0; } -struct snd_rawmidi_ops snd_wavefront_midi_output = +snd_rawmidi_ops_t snd_wavefront_midi_output = { .open = snd_wavefront_midi_output_open, .close = snd_wavefront_midi_output_close, .trigger = snd_wavefront_midi_output_trigger, }; -struct snd_rawmidi_ops snd_wavefront_midi_input = +snd_rawmidi_ops_t snd_wavefront_midi_input = { .open = snd_wavefront_midi_input_open, .close = snd_wavefront_midi_input_close, diff --git a/trunk/sound/isa/wavefront/wavefront_synth.c b/trunk/sound/isa/wavefront/wavefront_synth.c index 679d0ae97e4f..abd79b781412 100644 --- a/trunk/sound/isa/wavefront/wavefront_synth.c +++ b/trunk/sound/isa/wavefront/wavefront_synth.c @@ -144,13 +144,13 @@ MODULE_PARM_DESC(osrun_time, "how many seconds to wait for the ICS2115 OS"); static int wavefront_delete_sample (snd_wavefront_t *, int sampnum); static int wavefront_find_free_sample (snd_wavefront_t *); -struct wavefront_command { +typedef struct { int cmd; char *action; unsigned int read_cnt; unsigned int write_cnt; int need_ack; -}; +} wavefront_command; static struct { int errno; @@ -170,7 +170,7 @@ static struct { #define NEEDS_ACK 1 -static struct wavefront_command wavefront_commands[] = { +static wavefront_command wavefront_commands[] = { { WFC_SET_SYNTHVOL, "set synthesizer volume", 0, 1, NEEDS_ACK }, { WFC_GET_SYNTHVOL, "get synthesizer volume", 1, 0, 0}, { WFC_SET_NVOICES, "set number of voices", 0, 1, NEEDS_ACK }, @@ -249,7 +249,7 @@ wavefront_errorstr (int errnum) return "Unknown WaveFront error"; } -static struct wavefront_command * +static wavefront_command * wavefront_get_command (int cmd) { @@ -261,7 +261,7 @@ wavefront_get_command (int cmd) } } - return NULL; + return (wavefront_command *) 0; } static inline int @@ -345,9 +345,9 @@ snd_wavefront_cmd (snd_wavefront_t *dev, int ack; unsigned int i; int c; - struct wavefront_command *wfcmd; + wavefront_command *wfcmd; - if ((wfcmd = wavefront_get_command (cmd)) == NULL) { + if ((wfcmd = wavefront_get_command (cmd)) == (wavefront_command *) 0) { snd_printk ("command 0x%x not supported.\n", cmd); return 1; @@ -1625,7 +1625,7 @@ wavefront_synth_control (snd_wavefront_card_t *acard, } int -snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file) +snd_wavefront_synth_open (snd_hwdep_t *hw, struct file *file) { if (!try_module_get(hw->card->module)) @@ -1635,7 +1635,7 @@ snd_wavefront_synth_open (struct snd_hwdep *hw, struct file *file) } int -snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file) +snd_wavefront_synth_release (snd_hwdep_t *hw, struct file *file) { module_put(hw->card->module); @@ -1643,18 +1643,18 @@ snd_wavefront_synth_release (struct snd_hwdep *hw, struct file *file) } int -snd_wavefront_synth_ioctl (struct snd_hwdep *hw, struct file *file, +snd_wavefront_synth_ioctl (snd_hwdep_t *hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_card *card; + snd_card_t *card; snd_wavefront_t *dev; snd_wavefront_card_t *acard; wavefront_control *wc; void __user *argp = (void __user *)arg; int err; - card = (struct snd_card *) hw->card; + card = (snd_card_t *) hw->card; snd_assert(card != NULL, return -ENODEV); diff --git a/trunk/sound/mips/Kconfig b/trunk/sound/mips/Kconfig index 531f8ba96a71..2433b7727404 100644 --- a/trunk/sound/mips/Kconfig +++ b/trunk/sound/mips/Kconfig @@ -8,6 +8,7 @@ config SND_AU1X00 depends on (SOC_AU1000 || SOC_AU1100 || SOC_AU1500) && SND select SND_PCM select SND_AC97_CODEC + select SND_GENERIC_DRIVER help ALSA Sound driver for the Au1x00's AC97 port. diff --git a/trunk/sound/mips/au1x00.c b/trunk/sound/mips/au1x00.c index 6d8f8b3eabd0..d08a42b24b1f 100644 --- a/trunk/sound/mips/au1x00.c +++ b/trunk/sound/mips/au1x00.c @@ -50,7 +50,12 @@ MODULE_AUTHOR("Charles Eidsness <charles@cooper-street.com>"); MODULE_DESCRIPTION("Au1000 AC'97 ALSA Driver"); MODULE_LICENSE("GPL"); +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8) MODULE_SUPPORTED_DEVICE("{{AMD,Au1000 AC'97}}"); +#else +MODULE_CLASSES("{sound}"); +MODULE_DEVICES("{{AMD,Au1000 AC'97}}"); +#endif #define PLAYBACK 0 #define CAPTURE 1 @@ -63,14 +68,18 @@ MODULE_SUPPORTED_DEVICE("{{AMD,Au1000 AC'97}}"); #define READ_WAIT 2 #define RW_DONE 3 +DECLARE_WAIT_QUEUE_HEAD(ac97_command_wq); + +typedef struct au1000_period au1000_period_t; struct au1000_period { u32 start; u32 relative_end; /*realtive to start of buffer*/ - struct au1000_period * next; + au1000_period_t * next; }; /*Au1000 AC97 Port Control Reisters*/ +typedef struct au1000_ac97_reg au1000_ac97_reg_t; struct au1000_ac97_reg { u32 volatile config; u32 volatile status; @@ -79,30 +88,32 @@ struct au1000_ac97_reg { u32 volatile cntrl; }; +typedef struct audio_stream audio_stream_t; struct audio_stream { - struct snd_pcm_substream *substream; + snd_pcm_substream_t * substream; int dma; spinlock_t dma_lock; - struct au1000_period * buffer; - unsigned int period_size; - unsigned int periods; + au1000_period_t * buffer; + unsigned long period_size; }; -struct snd_au1000 { - struct snd_card *card; - struct au1000_ac97_reg volatile *ac97_ioport; +typedef struct snd_card_au1000 { + snd_card_t *card; + au1000_ac97_reg_t volatile *ac97_ioport; struct resource *ac97_res_port; spinlock_t ac97_lock; - struct snd_ac97 *ac97; + ac97_t *ac97; - struct snd_pcm *pcm; - struct audio_stream *stream[2]; /* playback & capture */ -}; + snd_pcm_t *pcm; + audio_stream_t *stream[2]; /* playback & capture */ +} au1000_t; + +static au1000_t *au1000 = NULL; /*--------------------------- Local Functions --------------------------------*/ static void -au1000_set_ac97_xmit_slots(struct snd_au1000 *au1000, long xmit_slots) +au1000_set_ac97_xmit_slots(long xmit_slots) { u32 volatile ac97_config; @@ -115,7 +126,7 @@ au1000_set_ac97_xmit_slots(struct snd_au1000 *au1000, long xmit_slots) } static void -au1000_set_ac97_recv_slots(struct snd_au1000 *au1000, long recv_slots) +au1000_set_ac97_recv_slots(long recv_slots) { u32 volatile ac97_config; @@ -129,99 +140,86 @@ au1000_set_ac97_recv_slots(struct snd_au1000 *au1000, long recv_slots) static void -au1000_release_dma_link(struct audio_stream *stream) +au1000_dma_stop(audio_stream_t *stream) { - struct au1000_period * pointer; - struct au1000_period * pointer_next; - - stream->period_size = 0; - stream->periods = 0; - pointer = stream->buffer; - if (! pointer) - return; - do { - pointer_next = pointer->next; - kfree(pointer); - pointer = pointer_next; - } while (pointer != stream->buffer); - stream->buffer = NULL; -} - -static int -au1000_setup_dma_link(struct audio_stream *stream, unsigned int period_bytes, - unsigned int periods) -{ - struct snd_pcm_substream *substream = stream->substream; - struct snd_pcm_runtime *runtime = substream->runtime; - unsigned long dma_start; - int i; - - dma_start = virt_to_phys(runtime->dma_area); + unsigned long flags; + au1000_period_t * pointer; + au1000_period_t * pointer_next; - if (stream->period_size == period_bytes && - stream->periods == periods) - return 0; /* not changed */ + if (stream->buffer != NULL) { + spin_lock_irqsave(&stream->dma_lock, flags); + disable_dma(stream->dma); + spin_unlock_irqrestore(&stream->dma_lock, flags); - au1000_release_dma_link(stream); + pointer = stream->buffer; + pointer_next = stream->buffer->next; - stream->period_size = period_bytes; - stream->periods = periods; + do { + kfree(pointer); + pointer = pointer_next; + pointer_next = pointer->next; + } while (pointer != stream->buffer); - stream->buffer = kmalloc(sizeof(struct au1000_period), GFP_KERNEL); - if (! stream->buffer) - return -ENOMEM; - pointer = stream->buffer; - for (i = 0; i < periods; i++) { - pointer->start = (u32)(dma_start + (i * period_bytes)); - pointer->relative_end = (u32) (((i+1) * period_bytes) - 0x1); - if (i < periods - 1) { - pointer->next = kmalloc(sizeof(struct au1000_period), GFP_KERNEL); - if (! pointer->next) { - au1000_release_dma_link(stream); - return -ENOMEM; - } - pointer = pointer->next; - } + stream->buffer = NULL; } - pointer->next = stream->buffer; - return 0; } static void -au1000_dma_stop(struct audio_stream *stream) +au1000_dma_start(audio_stream_t *stream) { - snd_assert(stream->buffer, return); - disable_dma(stream->dma); -} + snd_pcm_substream_t *substream = stream->substream; + snd_pcm_runtime_t *runtime = substream->runtime; -static void -au1000_dma_start(struct audio_stream *stream) -{ - snd_assert(stream->buffer, return); - - init_dma(stream->dma); - if (get_dma_active_buffer(stream->dma) == 0) { - clear_dma_done0(stream->dma); - set_dma_addr0(stream->dma, stream->buffer->start); - set_dma_count0(stream->dma, stream->period_size >> 1); - set_dma_addr1(stream->dma, stream->buffer->next->start); - set_dma_count1(stream->dma, stream->period_size >> 1); - } else { - clear_dma_done1(stream->dma); - set_dma_addr1(stream->dma, stream->buffer->start); - set_dma_count1(stream->dma, stream->period_size >> 1); - set_dma_addr0(stream->dma, stream->buffer->next->start); - set_dma_count0(stream->dma, stream->period_size >> 1); + unsigned long flags, dma_start; + int i; + au1000_period_t * pointer; + + if (stream->buffer == NULL) { + dma_start = virt_to_phys(runtime->dma_area); + + stream->period_size = frames_to_bytes(runtime, + runtime->period_size); + stream->buffer = kmalloc(sizeof(au1000_period_t), GFP_KERNEL); + pointer = stream->buffer; + for (i = 0 ; i < runtime->periods ; i++) { + pointer->start = (u32)(dma_start + + (i * stream->period_size)); + pointer->relative_end = (u32) + (((i+1) * stream->period_size) - 0x1); + if ( i < runtime->periods - 1) { + pointer->next = kmalloc(sizeof(au1000_period_t) + , GFP_KERNEL); + pointer = pointer->next; + } + } + pointer->next = stream->buffer; + + spin_lock_irqsave(&stream->dma_lock, flags); + init_dma(stream->dma); + if (get_dma_active_buffer(stream->dma) == 0) { + clear_dma_done0(stream->dma); + set_dma_addr0(stream->dma, stream->buffer->start); + set_dma_count0(stream->dma, stream->period_size >> 1); + set_dma_addr1(stream->dma, stream->buffer->next->start); + set_dma_count1(stream->dma, stream->period_size >> 1); + } else { + clear_dma_done1(stream->dma); + set_dma_addr1(stream->dma, stream->buffer->start); + set_dma_count1(stream->dma, stream->period_size >> 1); + set_dma_addr0(stream->dma, stream->buffer->next->start); + set_dma_count0(stream->dma, stream->period_size >> 1); + } + enable_dma_buffers(stream->dma); + start_dma(stream->dma); + spin_unlock_irqrestore(&stream->dma_lock, flags); } - enable_dma_buffers(stream->dma); - start_dma(stream->dma); } static irqreturn_t au1000_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct audio_stream *stream = (struct audio_stream *) dev_id; - struct snd_pcm_substream *substream = stream->substream; + audio_stream_t *stream = (audio_stream_t *) dev_id; + snd_pcm_substream_t *substream = stream->substream; spin_lock(&stream->dma_lock); switch (get_dma_buffer_done(stream->dma)) { @@ -240,9 +238,11 @@ au1000_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs) enable_dma_buffer1(stream->dma); break; case (DMA_D0 | DMA_D1): + spin_unlock(&stream->dma_lock); printk(KERN_ERR "DMA %d missed interrupt.\n",stream->dma); au1000_dma_stop(stream); au1000_dma_start(stream); + spin_lock(&stream->dma_lock); break; case (~DMA_D0 & ~DMA_D1): printk(KERN_ERR "DMA %d empty irq.\n",stream->dma); @@ -255,13 +255,13 @@ au1000_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs) /*-------------------------- PCM Audio Streams -------------------------------*/ static unsigned int rates[] = {8000, 11025, 16000, 22050}; -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = sizeof(rates) / sizeof(rates[0]), .list = rates, .mask = 0, }; -static struct snd_pcm_hardware snd_au1000_hw = +static snd_pcm_hardware_t snd_au1000 = { .info = (SNDRV_PCM_INFO_INTERLEAVED | \ SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID), @@ -281,108 +281,88 @@ static struct snd_pcm_hardware snd_au1000_hw = }; static int -snd_au1000_playback_open(struct snd_pcm_substream *substream) +snd_au1000_playback_open(snd_pcm_substream_t * substream) { - struct snd_au1000 *au1000 = substream->pcm->private_data; - au1000->stream[PLAYBACK]->substream = substream; au1000->stream[PLAYBACK]->buffer = NULL; substream->private_data = au1000->stream[PLAYBACK]; - substream->runtime->hw = snd_au1000_hw; + substream->runtime->hw = snd_au1000; return (snd_pcm_hw_constraint_list(substream->runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates) < 0); } static int -snd_au1000_capture_open(struct snd_pcm_substream *substream) +snd_au1000_capture_open(snd_pcm_substream_t * substream) { - struct snd_au1000 *au1000 = substream->pcm->private_data; - au1000->stream[CAPTURE]->substream = substream; au1000->stream[CAPTURE]->buffer = NULL; substream->private_data = au1000->stream[CAPTURE]; - substream->runtime->hw = snd_au1000_hw; + substream->runtime->hw = snd_au1000; return (snd_pcm_hw_constraint_list(substream->runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates) < 0); + } static int -snd_au1000_playback_close(struct snd_pcm_substream *substream) +snd_au1000_playback_close(snd_pcm_substream_t * substream) { - struct snd_au1000 *au1000 = substream->pcm->private_data; - au1000->stream[PLAYBACK]->substream = NULL; return 0; } static int -snd_au1000_capture_close(struct snd_pcm_substream *substream) +snd_au1000_capture_close(snd_pcm_substream_t * substream) { - struct snd_au1000 *au1000 = substream->pcm->private_data; - au1000->stream[CAPTURE]->substream = NULL; return 0; } static int -snd_au1000_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +snd_au1000_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct audio_stream *stream = substream->private_data; - int err; - - err = snd_pcm_lib_malloc_pages(substream, - params_buffer_bytes(hw_params)); - if (err < 0) - return err; - return au1000_setup_dma_link(stream, - params_period_bytes(hw_params), - params_periods(hw_params)); + return snd_pcm_lib_malloc_pages(substream, + params_buffer_bytes(hw_params)); } static int -snd_au1000_hw_free(struct snd_pcm_substream *substream) +snd_au1000_hw_free(snd_pcm_substream_t * substream) { - struct audio_stream *stream = substream->private_data; - au1000_release_dma_link(stream); return snd_pcm_lib_free_pages(substream); } static int -snd_au1000_playback_prepare(struct snd_pcm_substream *substream) +snd_au1000_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_au1000 *au1000 = substream->pcm->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; - if (runtime->channels == 1) - au1000_set_ac97_xmit_slots(au1000, AC97_SLOT_4); + if (runtime->channels == 1 ) + au1000_set_ac97_xmit_slots(AC97_SLOT_4); else - au1000_set_ac97_xmit_slots(au1000, AC97_SLOT_3 | AC97_SLOT_4); + au1000_set_ac97_xmit_slots(AC97_SLOT_3 | AC97_SLOT_4); snd_ac97_set_rate(au1000->ac97, AC97_PCM_FRONT_DAC_RATE, runtime->rate); return 0; } static int -snd_au1000_capture_prepare(struct snd_pcm_substream *substream) +snd_au1000_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_au1000 *au1000 = substream->pcm->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; - if (runtime->channels == 1) - au1000_set_ac97_recv_slots(au1000, AC97_SLOT_4); + if (runtime->channels == 1 ) + au1000_set_ac97_recv_slots(AC97_SLOT_4); else - au1000_set_ac97_recv_slots(au1000, AC97_SLOT_3 | AC97_SLOT_4); + au1000_set_ac97_recv_slots(AC97_SLOT_3 | AC97_SLOT_4); snd_ac97_set_rate(au1000->ac97, AC97_PCM_LR_ADC_RATE, runtime->rate); return 0; } static int -snd_au1000_trigger(struct snd_pcm_substream *substream, int cmd) +snd_au1000_trigger(snd_pcm_substream_t * substream, int cmd) { - struct audio_stream *stream = substream->private_data; + audio_stream_t *stream = substream->private_data; int err = 0; - spin_lock(&stream->dma_lock); switch (cmd) { case SNDRV_PCM_TRIGGER_START: au1000_dma_start(stream); @@ -394,27 +374,27 @@ snd_au1000_trigger(struct snd_pcm_substream *substream, int cmd) err = -EINVAL; break; } - spin_unlock(&stream->dma_lock); return err; } static snd_pcm_uframes_t -snd_au1000_pointer(struct snd_pcm_substream *substream) +snd_au1000_pointer(snd_pcm_substream_t * substream) { - struct audio_stream *stream = substream->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + audio_stream_t *stream = substream->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + unsigned long flags; long location; - spin_lock(&stream->dma_lock); + spin_lock_irqsave(&stream->dma_lock, flags); location = get_dma_residue(stream->dma); - spin_unlock(&stream->dma_lock); + spin_unlock_irqrestore(&stream->dma_lock, flags); location = stream->buffer->relative_end - location; if (location == -1) location = 0; return bytes_to_frames(runtime,location); } -static struct snd_pcm_ops snd_card_au1000_playback_ops = { +static snd_pcm_ops_t snd_card_au1000_playback_ops = { .open = snd_au1000_playback_open, .close = snd_au1000_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -425,7 +405,7 @@ static struct snd_pcm_ops snd_card_au1000_playback_ops = { .pointer = snd_au1000_pointer, }; -static struct snd_pcm_ops snd_card_au1000_capture_ops = { +static snd_pcm_ops_t snd_card_au1000_capture_ops = { .open = snd_au1000_capture_open, .close = snd_au1000_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -437,9 +417,9 @@ static struct snd_pcm_ops snd_card_au1000_capture_ops = { }; static int __devinit -snd_au1000_pcm_new(struct snd_au1000 *au1000) +snd_au1000_pcm_new(void) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; unsigned long flags; @@ -458,9 +438,6 @@ snd_au1000_pcm_new(struct snd_au1000 *au1000) pcm->info_flags = 0; strcpy(pcm->name, "Au1000 AC97 PCM"); - spin_lock_init(&au1000->stream[PLAYBACK]->dma_lock); - spin_lock_init(&au1000->stream[CAPTURE]->dma_lock); - flags = claim_dma_lock(); if ((au1000->stream[PLAYBACK]->dma = request_au1000_dma(DMA_ID_AC97C_TX, "AC97 TX", au1000_dma_interrupt, SA_INTERRUPT, @@ -480,6 +457,8 @@ snd_au1000_pcm_new(struct snd_au1000 *au1000) set_dma_mode(au1000->stream[CAPTURE]->dma, get_dma_mode(au1000->stream[CAPTURE]->dma) & ~DMA_NC); release_dma_lock(flags); + spin_lock_init(&au1000->stream[PLAYBACK]->dma_lock); + spin_lock_init(&au1000->stream[CAPTURE]->dma_lock); au1000->pcm = pcm; return 0; } @@ -488,13 +467,11 @@ snd_au1000_pcm_new(struct snd_au1000 *au1000) /*-------------------------- AC97 CODEC Control ------------------------------*/ static unsigned short -snd_au1000_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +snd_au1000_ac97_read(ac97_t *ac97, unsigned short reg) { - struct snd_au1000 *au1000 = ac97->private_data; u32 volatile cmd; u16 volatile data; int i; - spin_lock(&au1000->ac97_lock); /* would rather use the interupt than this polling but it works and I can't get the interupt driven case to work efficiently */ @@ -526,12 +503,10 @@ get the interupt driven case to work efficiently */ static void -snd_au1000_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) +snd_au1000_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct snd_au1000 *au1000 = ac97->private_data; u32 cmd; int i; - spin_lock(&au1000->ac97_lock); /* would rather use the interupt than this polling but it works and I can't get the interupt driven case to work efficiently */ @@ -547,27 +522,40 @@ get the interupt driven case to work efficiently */ au1000->ac97_ioport->cmd = cmd; spin_unlock(&au1000->ac97_lock); } +static void +snd_au1000_ac97_free(ac97_t *ac97) +{ + au1000->ac97 = NULL; +} static int __devinit -snd_au1000_ac97_new(struct snd_au1000 *au1000) +snd_au1000_ac97_new(void) { int err; - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; - static struct snd_ac97_bus_ops ops = { + +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8) + ac97_bus_t *pbus; + ac97_template_t ac97; + static ac97_bus_ops_t ops = { .write = snd_au1000_ac97_write, .read = snd_au1000_ac97_read, }; +#else + ac97_bus_t bus, *pbus; + ac97_t ac97; +#endif if ((au1000->ac97_res_port = request_region(AC97C_CONFIG, - sizeof(struct au1000_ac97_reg), "Au1x00 AC97")) == NULL) { + sizeof(au1000_ac97_reg_t), "Au1x00 AC97")) == NULL) { snd_printk(KERN_ERR "ALSA AC97: can't grap AC97 port\n"); return -EBUSY; } - au1000->ac97_ioport = (struct au1000_ac97_reg *) au1000->ac97_res_port->start; + au1000->ac97_ioport = (au1000_ac97_reg_t *) au1000->ac97_res_port->start; spin_lock_init(&au1000->ac97_lock); + spin_lock(&au1000->ac97_lock); + /* configure pins for AC'97 TODO: move to board_setup.c */ au_writel(au_readl(SYS_PINFUNC) & ~0x02, SYS_PINFUNC); @@ -584,24 +572,33 @@ snd_au1000_ac97_new(struct snd_au1000 *au1000) au1000->ac97_ioport->config = 0x0; mdelay(5); + spin_unlock(&au1000->ac97_lock); + /* Initialise AC97 middle-layer */ +#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8) if ((err = snd_ac97_bus(au1000->card, 0, &ops, au1000, &pbus)) < 0) return err; - +#else + memset(&bus, 0, sizeof(bus)); + bus.write = snd_au1000_ac97_write; + bus.read = snd_au1000_ac97_read; + if ((err = snd_ac97_bus(au1000->card, &bus, &pbus)) < 0) + return err; +#endif memset(&ac97, 0, sizeof(ac97)); ac97.private_data = au1000; + ac97.private_free = snd_au1000_ac97_free; if ((err = snd_ac97_mixer(pbus, &ac97, &au1000->ac97)) < 0) return err; - return 0; + } /*------------------------------ Setup / Destroy ----------------------------*/ void -snd_au1000_free(struct snd_card *card) +snd_au1000_free(snd_card_t *card) { - struct snd_au1000 *au1000 = card->private_data; if (au1000->ac97_res_port) { /* put internal AC97 block into reset */ @@ -617,65 +614,73 @@ snd_au1000_free(struct snd_card *card) free_au1000_dma(au1000->stream[CAPTURE]->dma); kfree(au1000->stream[PLAYBACK]); + au1000->stream[PLAYBACK] = NULL; kfree(au1000->stream[CAPTURE]); -} - + au1000->stream[CAPTURE] = NULL; + kfree(au1000); + au1000 = NULL; -static struct snd_card *au1000_card; +} static int __init au1000_init(void) { int err; - struct snd_card *card; - struct snd_au1000 *au1000; - card = snd_card_new(-1, "AC97", THIS_MODULE, sizeof(struct snd_au1000)); - if (card == NULL) + au1000 = kmalloc(sizeof(au1000_t), GFP_KERNEL); + if (au1000 == NULL) + return -ENOMEM; + au1000->stream[PLAYBACK] = kmalloc(sizeof(audio_stream_t), GFP_KERNEL); + if (au1000->stream[PLAYBACK] == NULL) + return -ENOMEM; + au1000->stream[CAPTURE] = kmalloc(sizeof(audio_stream_t), GFP_KERNEL); + if (au1000->stream[CAPTURE] == NULL) return -ENOMEM; - - card->private_free = snd_au1000_free; - au1000 = card->private_data; /* so that snd_au1000_free will work as intended */ - au1000->card = card; au1000->stream[PLAYBACK]->dma = -1; au1000->stream[CAPTURE]->dma = -1; au1000->ac97_res_port = NULL; - au1000->stream[PLAYBACK] = kmalloc(sizeof(struct audio_stream), GFP_KERNEL); - au1000->stream[CAPTURE] = kmalloc(sizeof(struct audio_stream), GFP_KERNEL); - if (au1000->stream[PLAYBACK] == NULL || - au1000->stream[CAPTURE] == NULL) { - snd_card_free(card); + + au1000->card = snd_card_new(-1, "AC97", THIS_MODULE, sizeof(au1000_t)); + if (au1000->card == NULL) { + snd_au1000_free(au1000->card); return -ENOMEM; } - if ((err = snd_au1000_ac97_new(au1000)) < 0 ) { - snd_card_free(card); + au1000->card->private_data = (au1000_t *)au1000; + au1000->card->private_free = snd_au1000_free; + + if ((err = snd_au1000_ac97_new()) < 0 ) { + snd_card_free(au1000->card); return err; } - if ((err = snd_au1000_pcm_new(au1000)) < 0) { - snd_card_free(card); + if ((err = snd_au1000_pcm_new()) < 0) { + snd_card_free(au1000->card); return err; } - strcpy(card->driver, "Au1000-AC97"); - strcpy(card->shortname, "AMD Au1000-AC97"); - sprintf(card->longname, "AMD Au1000--AC97 ALSA Driver"); + strcpy(au1000->card->driver, "AMD-Au1000-AC97"); + strcpy(au1000->card->shortname, "Au1000-AC97"); + sprintf(au1000->card->longname, "AMD Au1000--AC97 ALSA Driver"); + + if ((err = snd_card_set_generic_dev(au1000->card)) < 0) { + snd_card_free(au1000->card); + return err; + } - if ((err = snd_card_register(card)) < 0) { - snd_card_free(card); + if ((err = snd_card_register(au1000->card)) < 0) { + snd_card_free(au1000->card); return err; } printk( KERN_INFO "ALSA AC97: Driver Initialized\n" ); - au1000_card = card; return 0; } static void __exit au1000_exit(void) { - snd_card_free(au1000_card); + snd_card_free(au1000->card); } module_init(au1000_init); diff --git a/trunk/sound/parisc/harmony.c b/trunk/sound/parisc/harmony.c index ce73f3eae78c..d833349ed518 100644 --- a/trunk/sound/parisc/harmony.c +++ b/trunk/sound/parisc/harmony.c @@ -59,14 +59,6 @@ #include "harmony.h" -static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ -static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ -module_param(index, int, 0444); -MODULE_PARM_DESC(index, "Index value for Harmony driver."); -module_param(id, charp, 0444); -MODULE_PARM_DESC(id, "ID string for Harmony driver."); - - static struct parisc_device_id snd_harmony_devtable[] = { /* bushmaster / flounder */ { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007A }, @@ -99,32 +91,32 @@ static unsigned int rate_bits[14] = { HARMONY_SR_44KHZ, HARMONY_SR_48KHZ }; -static struct snd_pcm_hw_constraint_list hw_constraint_rates = { +static snd_pcm_hw_constraint_list_t hw_constraint_rates = { .count = ARRAY_SIZE(snd_harmony_rates), .list = snd_harmony_rates, .mask = 0, }; -static inline unsigned long -harmony_read(struct snd_harmony *h, unsigned r) +inline unsigned long +harmony_read(harmony_t *h, unsigned r) { return __raw_readl(h->iobase + r); } -static inline void -harmony_write(struct snd_harmony *h, unsigned r, unsigned long v) +inline void +harmony_write(harmony_t *h, unsigned r, unsigned long v) { __raw_writel(v, h->iobase + r); } -static inline void -harmony_wait_for_control(struct snd_harmony *h) +static void +harmony_wait_for_control(harmony_t *h) { while (harmony_read(h, HARMONY_CNTL) & HARMONY_CNTL_C) ; } -static inline void -harmony_reset(struct snd_harmony *h) +inline void +harmony_reset(harmony_t *h) { harmony_write(h, HARMONY_RESET, 1); mdelay(50); @@ -132,7 +124,7 @@ harmony_reset(struct snd_harmony *h) } static void -harmony_disable_interrupts(struct snd_harmony *h) +harmony_disable_interrupts(harmony_t *h) { u32 dstatus; harmony_wait_for_control(h); @@ -142,7 +134,7 @@ harmony_disable_interrupts(struct snd_harmony *h) } static void -harmony_enable_interrupts(struct snd_harmony *h) +harmony_enable_interrupts(harmony_t *h) { u32 dstatus; harmony_wait_for_control(h); @@ -152,7 +144,7 @@ harmony_enable_interrupts(struct snd_harmony *h) } static void -harmony_mute(struct snd_harmony *h) +harmony_mute(harmony_t *h) { unsigned long flags; @@ -163,7 +155,7 @@ harmony_mute(struct snd_harmony *h) } static void -harmony_unmute(struct snd_harmony *h) +harmony_unmute(harmony_t *h) { unsigned long flags; @@ -174,7 +166,7 @@ harmony_unmute(struct snd_harmony *h) } static void -harmony_set_control(struct snd_harmony *h) +harmony_set_control(harmony_t *h) { u32 ctrl; unsigned long flags; @@ -196,7 +188,7 @@ static irqreturn_t snd_harmony_interrupt(int irq, void *dev, struct pt_regs *regs) { u32 dstatus; - struct snd_harmony *h = dev; + harmony_t *h = dev; spin_lock(&h->lock); harmony_disable_interrupts(h); @@ -261,7 +253,7 @@ snd_harmony_rate_bits(int rate) return HARMONY_SR_44KHZ; } -static struct snd_pcm_hardware snd_harmony_playback = +static snd_pcm_hardware_t snd_harmony_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_JOINT_DUPLEX | SNDRV_PCM_INFO_MMAP_VALID | @@ -282,7 +274,7 @@ static struct snd_pcm_hardware snd_harmony_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_harmony_capture = +static snd_pcm_hardware_t snd_harmony_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_JOINT_DUPLEX | SNDRV_PCM_INFO_MMAP_VALID | @@ -304,14 +296,15 @@ static struct snd_pcm_hardware snd_harmony_capture = }; static int -snd_harmony_playback_trigger(struct snd_pcm_substream *ss, int cmd) +snd_harmony_playback_trigger(snd_pcm_substream_t *ss, int cmd) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); + harmony_t *h = snd_pcm_substream_chip(ss); + unsigned long flags; if (h->st.capturing) return -EBUSY; - spin_lock(&h->lock); + spin_lock_irqsave(&h->lock, flags); switch (cmd) { case SNDRV_PCM_TRIGGER_START: h->st.playing = 1; @@ -330,24 +323,25 @@ snd_harmony_playback_trigger(struct snd_pcm_substream *ss, int cmd) case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_SUSPEND: default: - spin_unlock(&h->lock); + spin_unlock_irqrestore(&h->lock, flags); snd_BUG(); return -EINVAL; } - spin_unlock(&h->lock); + spin_unlock_irqrestore(&h->lock, flags); return 0; } static int -snd_harmony_capture_trigger(struct snd_pcm_substream *ss, int cmd) +snd_harmony_capture_trigger(snd_pcm_substream_t *ss, int cmd) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); + harmony_t *h = snd_pcm_substream_chip(ss); + unsigned long flags; if (h->st.playing) return -EBUSY; - spin_lock(&h->lock); + spin_lock_irqsave(&h->lock, flags); switch (cmd) { case SNDRV_PCM_TRIGGER_START: h->st.capturing = 1; @@ -366,17 +360,17 @@ snd_harmony_capture_trigger(struct snd_pcm_substream *ss, int cmd) case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_SUSPEND: default: - spin_unlock(&h->lock); + spin_unlock_irqrestore(&h->lock, flags); snd_BUG(); return -EINVAL; } - spin_unlock(&h->lock); + spin_unlock_irqrestore(&h->lock, flags); return 0; } static int -snd_harmony_set_data_format(struct snd_harmony *h, int fmt, int force) +snd_harmony_set_data_format(harmony_t *h, int fmt, int force) { int o = h->st.format; int n; @@ -406,10 +400,10 @@ snd_harmony_set_data_format(struct snd_harmony *h, int fmt, int force) } static int -snd_harmony_playback_prepare(struct snd_pcm_substream *ss) +snd_harmony_playback_prepare(snd_pcm_substream_t *ss) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + harmony_t *h = snd_pcm_substream_chip(ss); + snd_pcm_runtime_t *rt = ss->runtime; if (h->st.capturing) return -EBUSY; @@ -436,10 +430,10 @@ snd_harmony_playback_prepare(struct snd_pcm_substream *ss) } static int -snd_harmony_capture_prepare(struct snd_pcm_substream *ss) +snd_harmony_capture_prepare(snd_pcm_substream_t *ss) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + harmony_t *h = snd_pcm_substream_chip(ss); + snd_pcm_runtime_t *rt = ss->runtime; if (h->st.playing) return -EBUSY; @@ -466,10 +460,10 @@ snd_harmony_capture_prepare(struct snd_pcm_substream *ss) } static snd_pcm_uframes_t -snd_harmony_playback_pointer(struct snd_pcm_substream *ss) +snd_harmony_playback_pointer(snd_pcm_substream_t *ss) { - struct snd_pcm_runtime *rt = ss->runtime; - struct snd_harmony *h = snd_pcm_substream_chip(ss); + snd_pcm_runtime_t *rt = ss->runtime; + harmony_t *h = snd_pcm_substream_chip(ss); unsigned long pcuradd; unsigned long played; @@ -495,10 +489,10 @@ snd_harmony_playback_pointer(struct snd_pcm_substream *ss) } static snd_pcm_uframes_t -snd_harmony_capture_pointer(struct snd_pcm_substream *ss) +snd_harmony_capture_pointer(snd_pcm_substream_t *ss) { - struct snd_pcm_runtime *rt = ss->runtime; - struct snd_harmony *h = snd_pcm_substream_chip(ss); + snd_pcm_runtime_t *rt = ss->runtime; + harmony_t *h = snd_pcm_substream_chip(ss); unsigned long rcuradd; unsigned long caught; @@ -524,10 +518,10 @@ snd_harmony_capture_pointer(struct snd_pcm_substream *ss) } static int -snd_harmony_playback_open(struct snd_pcm_substream *ss) +snd_harmony_playback_open(snd_pcm_substream_t *ss) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + harmony_t *h = snd_pcm_substream_chip(ss); + snd_pcm_runtime_t *rt = ss->runtime; int err; h->psubs = ss; @@ -543,10 +537,10 @@ snd_harmony_playback_open(struct snd_pcm_substream *ss) } static int -snd_harmony_capture_open(struct snd_pcm_substream *ss) +snd_harmony_capture_open(snd_pcm_substream_t *ss) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + harmony_t *h = snd_pcm_substream_chip(ss); + snd_pcm_runtime_t *rt = ss->runtime; int err; h->csubs = ss; @@ -562,27 +556,27 @@ snd_harmony_capture_open(struct snd_pcm_substream *ss) } static int -snd_harmony_playback_close(struct snd_pcm_substream *ss) +snd_harmony_playback_close(snd_pcm_substream_t *ss) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); + harmony_t *h = snd_pcm_substream_chip(ss); h->psubs = NULL; return 0; } static int -snd_harmony_capture_close(struct snd_pcm_substream *ss) +snd_harmony_capture_close(snd_pcm_substream_t *ss) { - struct snd_harmony *h = snd_pcm_substream_chip(ss); + harmony_t *h = snd_pcm_substream_chip(ss); h->csubs = NULL; return 0; } static int -snd_harmony_hw_params(struct snd_pcm_substream *ss, - struct snd_pcm_hw_params *hw) +snd_harmony_hw_params(snd_pcm_substream_t *ss, + snd_pcm_hw_params_t *hw) { int err; - struct snd_harmony *h = snd_pcm_substream_chip(ss); + harmony_t *h = snd_pcm_substream_chip(ss); err = snd_pcm_lib_malloc_pages(ss, params_buffer_bytes(hw)); if (err > 0 && h->dma.type == SNDRV_DMA_TYPE_CONTINUOUS) @@ -592,12 +586,12 @@ snd_harmony_hw_params(struct snd_pcm_substream *ss, } static int -snd_harmony_hw_free(struct snd_pcm_substream *ss) +snd_harmony_hw_free(snd_pcm_substream_t *ss) { return snd_pcm_lib_free_pages(ss); } -static struct snd_pcm_ops snd_harmony_playback_ops = { +static snd_pcm_ops_t snd_harmony_playback_ops = { .open = snd_harmony_playback_open, .close = snd_harmony_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -608,7 +602,7 @@ static struct snd_pcm_ops snd_harmony_playback_ops = { .pointer = snd_harmony_playback_pointer, }; -static struct snd_pcm_ops snd_harmony_capture_ops = { +static snd_pcm_ops_t snd_harmony_capture_ops = { .open = snd_harmony_capture_open, .close = snd_harmony_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -620,9 +614,9 @@ static struct snd_pcm_ops snd_harmony_capture_ops = { }; static int -snd_harmony_pcm_init(struct snd_harmony *h) +snd_harmony_pcm_init(harmony_t *h) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; harmony_disable_interrupts(h); @@ -683,15 +677,15 @@ snd_harmony_pcm_init(struct snd_harmony *h) } static void -snd_harmony_set_new_gain(struct snd_harmony *h) +snd_harmony_set_new_gain(harmony_t *h) { harmony_wait_for_control(h); harmony_write(h, HARMONY_GAINCTL, h->st.gain); } static int -snd_harmony_mixercontrol_info(struct snd_kcontrol *kc, - struct snd_ctl_elem_info *uinfo) +snd_harmony_mixercontrol_info(snd_kcontrol_t *kc, + snd_ctl_elem_info_t *uinfo) { int mask = (kc->private_value >> 16) & 0xff; int left_shift = (kc->private_value) & 0xff; @@ -707,17 +701,18 @@ snd_harmony_mixercontrol_info(struct snd_kcontrol *kc, } static int -snd_harmony_volume_get(struct snd_kcontrol *kc, - struct snd_ctl_elem_value *ucontrol) +snd_harmony_volume_get(snd_kcontrol_t *kc, + snd_ctl_elem_value_t *ucontrol) { - struct snd_harmony *h = snd_kcontrol_chip(kc); + harmony_t *h = snd_kcontrol_chip(kc); int shift_left = (kc->private_value) & 0xff; int shift_right = (kc->private_value >> 8) & 0xff; int mask = (kc->private_value >> 16) & 0xff; int invert = (kc->private_value >> 24) & 0xff; int left, right; + unsigned long flags; - spin_lock_irq(&h->mixer_lock); + spin_lock_irqsave(&h->mixer_lock, flags); left = (h->st.gain >> shift_left) & mask; right = (h->st.gain >> shift_right) & mask; @@ -730,24 +725,25 @@ snd_harmony_volume_get(struct snd_kcontrol *kc, if (shift_left != shift_right) ucontrol->value.integer.value[1] = right; - spin_unlock_irq(&h->mixer_lock); + spin_unlock_irqrestore(&h->mixer_lock, flags); return 0; } static int -snd_harmony_volume_put(struct snd_kcontrol *kc, - struct snd_ctl_elem_value *ucontrol) +snd_harmony_volume_put(snd_kcontrol_t *kc, + snd_ctl_elem_value_t *ucontrol) { - struct snd_harmony *h = snd_kcontrol_chip(kc); + harmony_t *h = snd_kcontrol_chip(kc); int shift_left = (kc->private_value) & 0xff; int shift_right = (kc->private_value >> 8) & 0xff; int mask = (kc->private_value >> 16) & 0xff; int invert = (kc->private_value >> 24) & 0xff; int left, right; int old_gain = h->st.gain; + unsigned long flags; - spin_lock_irq(&h->mixer_lock); + spin_lock_irqsave(&h->mixer_lock, flags); left = ucontrol->value.integer.value[0] & mask; if (invert) @@ -765,14 +761,14 @@ snd_harmony_volume_put(struct snd_kcontrol *kc, snd_harmony_set_new_gain(h); - spin_unlock_irq(&h->mixer_lock); + spin_unlock_irqrestore(&h->mixer_lock, flags); return h->st.gain != old_gain; } static int -snd_harmony_captureroute_info(struct snd_kcontrol *kc, - struct snd_ctl_elem_info *uinfo) +snd_harmony_captureroute_info(snd_kcontrol_t *kc, + snd_ctl_elem_info_t *uinfo) { static char *texts[2] = { "Line", "Mic" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -786,31 +782,33 @@ snd_harmony_captureroute_info(struct snd_kcontrol *kc, } static int -snd_harmony_captureroute_get(struct snd_kcontrol *kc, - struct snd_ctl_elem_value *ucontrol) +snd_harmony_captureroute_get(snd_kcontrol_t *kc, + snd_ctl_elem_value_t *ucontrol) { - struct snd_harmony *h = snd_kcontrol_chip(kc); + harmony_t *h = snd_kcontrol_chip(kc); int value; + unsigned long flags; - spin_lock_irq(&h->mixer_lock); + spin_lock_irqsave(&h->mixer_lock, flags); value = (h->st.gain >> HARMONY_GAIN_IS_SHIFT) & 1; ucontrol->value.enumerated.item[0] = value; - spin_unlock_irq(&h->mixer_lock); + spin_unlock_irqrestore(&h->mixer_lock, flags); return 0; } static int -snd_harmony_captureroute_put(struct snd_kcontrol *kc, - struct snd_ctl_elem_value *ucontrol) +snd_harmony_captureroute_put(snd_kcontrol_t *kc, + snd_ctl_elem_value_t *ucontrol) { - struct snd_harmony *h = snd_kcontrol_chip(kc); + harmony_t *h = snd_kcontrol_chip(kc); int value; int old_gain = h->st.gain; + unsigned long flags; - spin_lock_irq(&h->mixer_lock); + spin_lock_irqsave(&h->mixer_lock, flags); value = ucontrol->value.enumerated.item[0] & 1; h->st.gain &= ~HARMONY_GAIN_IS_MASK; @@ -818,12 +816,13 @@ snd_harmony_captureroute_put(struct snd_kcontrol *kc, snd_harmony_set_new_gain(h); - spin_unlock_irq(&h->mixer_lock); + spin_unlock_irqrestore(&h->mixer_lock, flags); return h->st.gain != old_gain; } -#define HARMONY_CONTROLS ARRAY_SIZE(snd_harmony_controls) +#define HARMONY_CONTROLS (sizeof(snd_harmony_controls)/ \ + sizeof(snd_kcontrol_new_t)) #define HARMONY_VOLUME(xname, left_shift, right_shift, mask, invert) \ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ @@ -832,7 +831,7 @@ snd_harmony_captureroute_put(struct snd_kcontrol *kc, .private_value = ((left_shift) | ((right_shift) << 8) | \ ((mask) << 16) | ((invert) << 24)) } -static struct snd_kcontrol_new snd_harmony_controls[] = { +static snd_kcontrol_new_t snd_harmony_controls[] = { HARMONY_VOLUME("Master Playback Volume", HARMONY_GAIN_LO_SHIFT, HARMONY_GAIN_RO_SHIFT, HARMONY_GAIN_OUT, 1), HARMONY_VOLUME("Capture Volume", HARMONY_GAIN_LI_SHIFT, @@ -855,7 +854,7 @@ static struct snd_kcontrol_new snd_harmony_controls[] = { }; static void __init -snd_harmony_mixer_reset(struct snd_harmony *h) +snd_harmony_mixer_reset(harmony_t *h) { harmony_mute(h); harmony_reset(h); @@ -864,9 +863,9 @@ snd_harmony_mixer_reset(struct snd_harmony *h) } static int __init -snd_harmony_mixer_init(struct snd_harmony *h) +snd_harmony_mixer_init(harmony_t *h) { - struct snd_card *card = h->card; + snd_card_t *card = h->card; int idx, err; snd_assert(h != NULL, return -EINVAL); @@ -885,7 +884,7 @@ snd_harmony_mixer_init(struct snd_harmony *h) } static int -snd_harmony_free(struct snd_harmony *h) +snd_harmony_free(harmony_t *h) { if (h->gdma.addr) snd_dma_free_pages(&h->gdma); @@ -905,33 +904,38 @@ snd_harmony_free(struct snd_harmony *h) } static int -snd_harmony_dev_free(struct snd_device *dev) +snd_harmony_dev_free(snd_device_t *dev) { - struct snd_harmony *h = dev->device_data; + harmony_t *h = dev->device_data; return snd_harmony_free(h); } static int __devinit -snd_harmony_create(struct snd_card *card, +snd_harmony_create(snd_card_t *card, struct parisc_device *padev, - struct snd_harmony **rchip) + harmony_t **rchip) { int err; - struct snd_harmony *h; - static struct snd_device_ops ops = { + harmony_t *h; + static snd_device_ops_t ops = { .dev_free = snd_harmony_dev_free, }; *rchip = NULL; - h = kzalloc(sizeof(*h), GFP_KERNEL); + h = kmalloc(sizeof(*h), GFP_KERNEL); if (h == NULL) return -ENOMEM; + memset(&h->st, 0, sizeof(h->st)); + memset(&h->stats, 0, sizeof(h->stats)); + memset(&h->pbuf, 0, sizeof(h->pbuf)); + memset(&h->cbuf, 0, sizeof(h->cbuf)); + h->hpa = padev->hpa.start; h->card = card; h->dev = padev; - h->irq = -1; + h->irq = padev->irq; h->iobase = ioremap_nocache(padev->hpa.start, HARMONY_SIZE); if (h->iobase == NULL) { printk(KERN_ERR PFX "unable to remap hpa 0x%lx\n", @@ -940,14 +944,13 @@ snd_harmony_create(struct snd_card *card, goto free_and_ret; } - err = request_irq(padev->irq, snd_harmony_interrupt, 0, + err = request_irq(h->irq, snd_harmony_interrupt, 0, "harmony", h); if (err) { printk(KERN_ERR PFX "could not obtain interrupt %d", - padev->irq); + h->irq); goto free_and_ret; } - h->irq = padev->irq; spin_lock_init(&h->mixer_lock); spin_lock_init(&h->lock); @@ -972,24 +975,35 @@ static int __devinit snd_harmony_probe(struct parisc_device *padev) { int err; - struct snd_card *card; - struct snd_harmony *h; + static int dev; + snd_card_t *card; + harmony_t *h; + static int index = SNDRV_DEFAULT_IDX1; + static char *id = SNDRV_DEFAULT_STR1; + + h = parisc_get_drvdata(padev); + if (h != NULL) { + return -ENODEV; + } card = snd_card_new(index, id, THIS_MODULE, 0); if (card == NULL) return -ENOMEM; err = snd_harmony_create(card, padev, &h); - if (err < 0) + if (err < 0) { goto free_and_ret; + } err = snd_harmony_pcm_init(h); - if (err < 0) + if (err < 0) { goto free_and_ret; + } err = snd_harmony_mixer_init(h); - if (err < 0) + if (err < 0) { goto free_and_ret; + } strcpy(card->driver, "harmony"); strcpy(card->shortname, "Harmony"); @@ -997,10 +1011,13 @@ snd_harmony_probe(struct parisc_device *padev) card->shortname, h->hpa, h->irq); err = snd_card_register(card); - if (err < 0) + if (err < 0) { goto free_and_ret; + } + + dev++; + parisc_set_drvdata(padev, h); - parisc_set_drvdata(padev, card); return 0; free_and_ret: @@ -1011,8 +1028,8 @@ snd_harmony_probe(struct parisc_device *padev) static int __devexit snd_harmony_remove(struct parisc_device *padev) { - snd_card_free(parisc_get_drvdata(padev)); - parisc_set_drvdata(padev, NULL); + harmony_t *h = parisc_get_drvdata(padev); + snd_card_free(h->card); return 0; } @@ -1026,13 +1043,28 @@ static struct parisc_driver snd_harmony_driver = { static int __init alsa_harmony_init(void) { - return register_parisc_driver(&snd_harmony_driver); + int err; + + err = register_parisc_driver(&snd_harmony_driver); + if (err < 0) { + printk(KERN_ERR PFX "device not found\n"); + return err; + } + + return 0; } static void __exit alsa_harmony_fini(void) { - unregister_parisc_driver(&snd_harmony_driver); + int err; + + err = unregister_parisc_driver(&snd_harmony_driver); + if (err < 0) { + printk(KERN_ERR PFX "failed to unregister\n"); + } + + return; } MODULE_LICENSE("GPL"); diff --git a/trunk/sound/parisc/harmony.h b/trunk/sound/parisc/harmony.h index 2e434523fedf..526c52389de2 100644 --- a/trunk/sound/parisc/harmony.h +++ b/trunk/sound/parisc/harmony.h @@ -13,7 +13,7 @@ struct harmony_buffer { int coherent; }; -struct snd_harmony { +typedef struct snd_card_harmony { int irq; unsigned long hpa; /* hard physical address */ @@ -44,15 +44,15 @@ struct snd_harmony { unsigned long silence_intr; } stats; - struct snd_pcm *pcm; - struct snd_card *card; - struct snd_pcm_substream *psubs; - struct snd_pcm_substream *csubs; - struct snd_info_entry *proc; + snd_pcm_t *pcm; + snd_card_t *card; + snd_pcm_substream_t *psubs; + snd_pcm_substream_t *csubs; + snd_info_entry_t *proc; spinlock_t lock; spinlock_t mixer_lock; -}; +} harmony_t; #define MAX_PCM_DEVICES 1 #define MAX_PCM_SUBSTREAMS 4 diff --git a/trunk/sound/pci/Kconfig b/trunk/sound/pci/Kconfig index 1e2e19305e38..0fb16cf335ea 100644 --- a/trunk/sound/pci/Kconfig +++ b/trunk/sound/pci/Kconfig @@ -3,31 +3,6 @@ menu "PCI devices" depends on SND!=n && PCI -config SND_AD1889 - tristate "Analog Devices AD1889" - depends on SND - select SND_AC97_CODEC - help - Say Y here to include support for the integrated AC97 sound - device found in particular on the Hewlett-Packard [BCJ]-xxx0 - class PA-RISC workstations, using the AD1819 codec. - - To compile this as a module, choose M here: the module - will be called snd-ad1889. - -config SND_ALS4000 - tristate "Avance Logic ALS4000" - depends on SND && ISA_DMA_API - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_PCM - help - Say Y here to include support for soundcards based on Avance Logic - ALS4000 chips. - - To compile this driver as a module, choose M here: the module - will be called snd-als4000. - config SND_ALI5451 tristate "ALi M5451 PCI Audio Controller" depends on SND @@ -144,44 +119,6 @@ config SND_BT87X_OVERCLOCK Higher sample rates won't hurt your hardware, but audio quality may suffer. -config SND_CA0106 - tristate "SB Audigy LS / Live 24bit" - depends on SND - select SND_AC97_CODEC - select SND_RAWMIDI - help - Say Y here to include support for the Sound Blaster Audigy LS - and Live 24bit. - - To compile this driver as a module, choose M here: the module - will be called snd-ca0106. - -config SND_CMIPCI - tristate "C-Media 8738, 8338" - depends on SND - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_PCM - help - If you want to use soundcards based on C-Media CMI8338 or CMI8738 - chips, say Y here and read - <file:Documentation/sound/alsa/CMIPCI.txt>. - - To compile this driver as a module, choose M here: the module - will be called snd-cmipci. - -config SND_CS4281 - tristate "Cirrus Logic (Sound Fusion) CS4281" - depends on SND - select SND_OPL3_LIB - select SND_RAWMIDI - select SND_AC97_CODEC - help - Say Y here to include support for Cirrus Logic CS4281 chips. - - To compile this driver as a module, choose M here: the module - will be called snd-cs4281. - config SND_CS46XX tristate "Cirrus Logic (Sound Fusion) CS4280/CS461x/CS462x/CS463x" depends on SND @@ -202,18 +139,17 @@ config SND_CS46XX_NEW_DSP This works better than the old code, so say Y. -config SND_CS5535AUDIO - tristate "CS5535 Audio" - depends on SND && X86 && !X86_64 - select SND_PCM +config SND_CS4281 + tristate "Cirrus Logic (Sound Fusion) CS4281" + depends on SND + select SND_OPL3_LIB + select SND_RAWMIDI select SND_AC97_CODEC help - Say Y here to include support for audio on CS5535 chips. It is - referred to as NS CS5535 IO or AMD CS5535 IO companion in - various literature. + Say Y here to include support for Cirrus Logic CS4281 chips. To compile this driver as a module, choose M here: the module - will be called snd-cs5535audio. + will be called snd-cs4281. config SND_EMU10K1 tristate "Emu10k1 (SB Live!, Audigy, E-mu APS)" @@ -244,89 +180,83 @@ config SND_EMU10K1X To compile this driver as a module, choose M here: the module will be called snd-emu10k1x. -config SND_ENS1370 - tristate "(Creative) Ensoniq AudioPCI 1370" +config SND_CA0106 + tristate "SB Audigy LS / Live 24bit" depends on SND + select SND_AC97_CODEC select SND_RAWMIDI - select SND_PCM help - Say Y here to include support for Ensoniq AudioPCI ES1370 chips. + Say Y here to include support for the Sound Blaster Audigy LS + and Live 24bit. To compile this driver as a module, choose M here: the module - will be called snd-ens1370. + will be called snd-ca0106. -config SND_ENS1371 - tristate "(Creative) Ensoniq AudioPCI 1371/1373" +config SND_KORG1212 + tristate "Korg 1212 IO" depends on SND - select SND_RAWMIDI - select SND_AC97_CODEC + select SND_PCM help - Say Y here to include support for Ensoniq AudioPCI ES1371 chips and - Sound Blaster PCI 64 or 128 soundcards. + Say Y here to include support for Korg 1212IO soundcards. To compile this driver as a module, choose M here: the module - will be called snd-ens1371. + will be called snd-korg1212. -config SND_ES1938 - tristate "ESS ES1938/1946/1969 (Solo-1)" +config SND_MIXART + tristate "Digigram miXart" depends on SND - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_AC97_CODEC + select SND_HWDEP + select SND_PCM help - Say Y here to include support for soundcards based on ESS Solo-1 - (ES1938, ES1946, ES1969) chips. + If you want to use Digigram miXart soundcards, say Y here and + read <file:Documentation/sound/alsa/MIXART.txt>. To compile this driver as a module, choose M here: the module - will be called snd-es1938. + will be called snd-mixart. -config SND_ES1968 - tristate "ESS ES1968/1978 (Maestro-1/2/2E)" +config SND_NM256 + tristate "NeoMagic NM256AV/ZX" depends on SND - select SND_MPU401_UART select SND_AC97_CODEC help - Say Y here to include support for soundcards based on ESS Maestro - 1/2/2E chips. + Say Y here to include support for NeoMagic NM256AV/ZX chips. To compile this driver as a module, choose M here: the module - will be called snd-es1968. + will be called snd-nm256. -config SND_FM801 - tristate "ForteMedia FM801" +config SND_RME32 + tristate "RME Digi32, 32/8, 32 PRO" depends on SND - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_AC97_CODEC + select SND_PCM help - Say Y here to include support for soundcards based on the ForteMedia - FM801 chip. + Say Y to include support for RME Digi32, Digi32 PRO and + Digi32/8 (Sek'd Prodif32, Prodif96 and Prodif Gold) audio + devices. To compile this driver as a module, choose M here: the module - will be called snd-fm801. + will be called snd-rme32. -config SND_FM801_TEA575X - tristate "ForteMedia FM801 + TEA5757 tuner" - depends on SND_FM801 - select VIDEO_DEV +config SND_RME96 + tristate "RME Digi96, 96/8, 96/8 PRO" + depends on SND + select SND_PCM help - Say Y here to include support for soundcards based on the ForteMedia - FM801 chip with a TEA5757 tuner connected to GPIO1-3 pins (Media - Forte SF256-PCS-02). + Say Y here to include support for RME Digi96, Digi96/8 and + Digi96/8 PRO/PAD/PST soundcards. To compile this driver as a module, choose M here: the module - will be called snd-fm801-tea575x. + will be called snd-rme96. -config SND_HDA_INTEL - tristate "Intel HD Audio" +config SND_RME9652 + tristate "RME Digi9652 (Hammerfall)" depends on SND select SND_PCM help - Say Y here to include support for Intel "High Definition - Audio" (Azalia) motherboard devices. + Say Y here to include support for RME Hammerfall (RME + Digi9652/Digi9636) soundcards. To compile this driver as a module, choose M here: the module - will be called snd-hda-intel. + will be called snd-rme9652. config SND_HDSP tristate "RME Hammerfall DSP Audio" @@ -354,73 +284,117 @@ config SND_HDSPM To compile this driver as a module, choose M here: the module will be called snd-hdspm. -config SND_ICE1712 - tristate "ICEnsemble ICE1712 (Envy24)" +config SND_TRIDENT + tristate "Trident 4D-Wave DX/NX; SiS 7018" depends on SND select SND_MPU401_UART select SND_AC97_CODEC help - Say Y here to include support for soundcards based on the - ICE1712 (Envy24) chip. - - Currently supported hardware is: M-Audio Delta 1010(LT), - DiO 2496, 66, 44, 410, Audiophile 24/96; Digigram VX442; - TerraTec EWX 24/96, EWS 88MT, 88D, DMX 6Fire, Phase 88; - Hoontech SoundTrack DSP 24/Value/Media7.1; Event EZ8. + Say Y here to include support for soundcards based on Trident + 4D-Wave DX/NX or SiS 7018 chips. To compile this driver as a module, choose M here: the module - will be called snd-ice1712. + will be called snd-trident. -config SND_ICE1724 - tristate "ICE/VT1724/1720 (Envy24HT/PT)" +config SND_YMFPCI + tristate "Yamaha YMF724/740/744/754" depends on SND + select SND_OPL3_LIB select SND_MPU401_UART select SND_AC97_CODEC help - Say Y here to include support for soundcards based on - ICE/VT1724/1720 (Envy24HT/PT) chips. - - Currently supported hardware is: AMP AUDIO2000; M-Audio - Revolution 7.1; TerraTec Aureon 5.1 Sky, 7.1 Space/Universe; - AudioTrak Prodigy 7.1; Pontis MS300; Albatron K8X800 Pro II; - Chaintech ZNF3-150/250. + Say Y here to include support for Yamaha PCI audio chips - + YMF724, YMF724F, YMF740, YMF740C, YMF744, YMF754. To compile this driver as a module, choose M here: the module - will be called snd-ice1724. + will be called snd-ymfpci. -config SND_INTEL8X0 - tristate "Intel/SiS/nVidia/AMD/ALi AC97 Controller" +config SND_AD1889 + tristate "Analog Devices AD1889" depends on SND select SND_AC97_CODEC help Say Y here to include support for the integrated AC97 sound - device on motherboards with Intel/SiS/nVidia/AMD chipsets, or - ALi chipsets using the M5455 Audio Controller. (There is a - separate driver for ALi M5451 Audio Controllers.) + device found in particular on the Hewlett-Packard [BCJ]-xxx0 + class PA-RISC workstations, using the AD1819 codec. + + To compile this as a module, choose M here: the module + will be called snd-ad1889. + +config SND_ALS4000 + tristate "Avance Logic ALS4000" + depends on SND && ISA_DMA_API + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_PCM + help + Say Y here to include support for soundcards based on Avance Logic + ALS4000 chips. To compile this driver as a module, choose M here: the module - will be called snd-intel8x0. + will be called snd-als4000. -config SND_INTEL8X0M - tristate "Intel/SiS/nVidia/AMD MC97 Modem (EXPERIMENTAL)" - depends on SND && EXPERIMENTAL - select SND_AC97_CODEC +config SND_CMIPCI + tristate "C-Media 8738, 8338" + depends on SND + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_PCM help - Say Y here to include support for the integrated MC97 modem on - motherboards with Intel/SiS/nVidia/AMD chipsets. + If you want to use soundcards based on C-Media CMI8338 or CMI8738 + chips, say Y here and read + <file:Documentation/sound/alsa/CMIPCI.txt>. To compile this driver as a module, choose M here: the module - will be called snd-intel8x0m. + will be called snd-cmipci. -config SND_KORG1212 - tristate "Korg 1212 IO" +config SND_ENS1370 + tristate "(Creative) Ensoniq AudioPCI 1370" depends on SND + select SND_RAWMIDI select SND_PCM help - Say Y here to include support for Korg 1212IO soundcards. + Say Y here to include support for Ensoniq AudioPCI ES1370 chips. To compile this driver as a module, choose M here: the module - will be called snd-korg1212. + will be called snd-ens1370. + +config SND_ENS1371 + tristate "(Creative) Ensoniq AudioPCI 1371/1373" + depends on SND + select SND_RAWMIDI + select SND_AC97_CODEC + help + Say Y here to include support for Ensoniq AudioPCI ES1371 chips and + Sound Blaster PCI 64 or 128 soundcards. + + To compile this driver as a module, choose M here: the module + will be called snd-ens1371. + +config SND_ES1938 + tristate "ESS ES1938/1946/1969 (Solo-1)" + depends on SND + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_AC97_CODEC + help + Say Y here to include support for soundcards based on ESS Solo-1 + (ES1938, ES1946, ES1969) chips. + + To compile this driver as a module, choose M here: the module + will be called snd-es1938. + +config SND_ES1968 + tristate "ESS ES1968/1978 (Maestro-1/2/2E)" + depends on SND + select SND_MPU401_UART + select SND_AC97_CODEC + help + Say Y here to include support for soundcards based on ESS Maestro + 1/2/2E chips. + + To compile this driver as a module, choose M here: the module + will be called snd-es1968. config SND_MAESTRO3 tristate "ESS Allegro/Maestro3" @@ -433,72 +407,88 @@ config SND_MAESTRO3 To compile this driver as a module, choose M here: the module will be called snd-maestro3. -config SND_MIXART - tristate "Digigram miXart" +config SND_FM801 + tristate "ForteMedia FM801" depends on SND - select SND_HWDEP - select SND_PCM + select SND_OPL3_LIB + select SND_MPU401_UART + select SND_AC97_CODEC help - If you want to use Digigram miXart soundcards, say Y here and - read <file:Documentation/sound/alsa/MIXART.txt>. + Say Y here to include support for soundcards based on the ForteMedia + FM801 chip. To compile this driver as a module, choose M here: the module - will be called snd-mixart. + will be called snd-fm801. -config SND_NM256 - tristate "NeoMagic NM256AV/ZX" - depends on SND - select SND_AC97_CODEC +config SND_FM801_TEA575X + tristate "ForteMedia FM801 + TEA5757 tuner" + depends on SND_FM801 + select VIDEO_DEV help - Say Y here to include support for NeoMagic NM256AV/ZX chips. + Say Y here to include support for soundcards based on the ForteMedia + FM801 chip with a TEA5757 tuner connected to GPIO1-3 pins (Media + Forte SF256-PCS-02). To compile this driver as a module, choose M here: the module - will be called snd-nm256. + will be called snd-fm801-tea575x. -config SND_PCXHR - tristate "Digigram PCXHR" +config SND_ICE1712 + tristate "ICEnsemble ICE1712 (Envy24)" depends on SND - select SND_PCM - select SND_HWDEP + select SND_MPU401_UART + select SND_AC97_CODEC help - Say Y here to include support for Digigram PCXHR boards. + Say Y here to include support for soundcards based on the + ICE1712 (Envy24) chip. + + Currently supported hardware is: M-Audio Delta 1010(LT), + DiO 2496, 66, 44, 410, Audiophile 24/96; Digigram VX442; + TerraTec EWX 24/96, EWS 88MT, 88D, DMX 6Fire, Phase 88; + Hoontech SoundTrack DSP 24/Value/Media7.1; Event EZ8. To compile this driver as a module, choose M here: the module - will be called snd-pcxhr. + will be called snd-ice1712. -config SND_RME32 - tristate "RME Digi32, 32/8, 32 PRO" +config SND_ICE1724 + tristate "ICE/VT1724/1720 (Envy24HT/PT)" depends on SND - select SND_PCM + select SND_MPU401_UART + select SND_AC97_CODEC help - Say Y to include support for RME Digi32, Digi32 PRO and - Digi32/8 (Sek'd Prodif32, Prodif96 and Prodif Gold) audio - devices. + Say Y here to include support for soundcards based on + ICE/VT1724/1720 (Envy24HT/PT) chips. + + Currently supported hardware is: AMP AUDIO2000; M-Audio + Revolution 7.1; TerraTec Aureon 5.1 Sky, 7.1 Space/Universe; + AudioTrak Prodigy 7.1; Pontis MS300; Albatron K8X800 Pro II; + Chaintech ZNF3-150/250. To compile this driver as a module, choose M here: the module - will be called snd-rme32. + will be called snd-ice1724. -config SND_RME96 - tristate "RME Digi96, 96/8, 96/8 PRO" +config SND_INTEL8X0 + tristate "Intel/SiS/nVidia/AMD/ALi AC97 Controller" depends on SND - select SND_PCM + select SND_AC97_CODEC help - Say Y here to include support for RME Digi96, Digi96/8 and - Digi96/8 PRO/PAD/PST soundcards. + Say Y here to include support for the integrated AC97 sound + device on motherboards with Intel/SiS/nVidia/AMD chipsets, or + ALi chipsets using the M5455 Audio Controller. (There is a + separate driver for ALi M5451 Audio Controllers.) To compile this driver as a module, choose M here: the module - will be called snd-rme96. + will be called snd-intel8x0. -config SND_RME9652 - tristate "RME Digi9652 (Hammerfall)" - depends on SND - select SND_PCM +config SND_INTEL8X0M + tristate "Intel/SiS/nVidia/AMD MC97 Modem (EXPERIMENTAL)" + depends on SND && EXPERIMENTAL + select SND_AC97_CODEC help - Say Y here to include support for RME Hammerfall (RME - Digi9652/Digi9636) soundcards. + Say Y here to include support for the integrated MC97 modem on + motherboards with Intel/SiS/nVidia/AMD chipsets. To compile this driver as a module, choose M here: the module - will be called snd-rme9652. + will be called snd-intel8x0m. config SND_SONICVIBES tristate "S3 SonicVibes" @@ -513,18 +503,6 @@ config SND_SONICVIBES To compile this driver as a module, choose M here: the module will be called snd-sonicvibes. -config SND_TRIDENT - tristate "Trident 4D-Wave DX/NX; SiS 7018" - depends on SND - select SND_MPU401_UART - select SND_AC97_CODEC - help - Say Y here to include support for soundcards based on Trident - 4D-Wave DX/NX or SiS 7018 chips. - - To compile this driver as a module, choose M here: the module - will be called snd-trident. - config SND_VIA82XX tristate "VIA 82C686A/B, 8233/8235 AC97 Controller" depends on SND @@ -558,17 +536,15 @@ config SND_VX222 To compile this driver as a module, choose M here: the module will be called snd-vx222. -config SND_YMFPCI - tristate "Yamaha YMF724/740/744/754" +config SND_HDA_INTEL + tristate "Intel HD Audio" depends on SND - select SND_OPL3_LIB - select SND_MPU401_UART - select SND_AC97_CODEC + select SND_PCM help - Say Y here to include support for Yamaha PCI audio chips - - YMF724, YMF724F, YMF740, YMF740C, YMF744, YMF754. + Say Y here to include support for Intel "High Definition + Audio" (Azalia) motherboard devices. To compile this driver as a module, choose M here: the module - will be called snd-ymfpci. + will be called snd-hda-intel. endmenu diff --git a/trunk/sound/pci/Makefile b/trunk/sound/pci/Makefile index a6c3cd58fe94..42fabfcfc2a9 100644 --- a/trunk/sound/pci/Makefile +++ b/trunk/sound/pci/Makefile @@ -54,14 +54,12 @@ obj-$(CONFIG_SND) += \ au88x0/ \ ca0106/ \ cs46xx/ \ - cs5535audio/ \ emu10k1/ \ hda/ \ ice1712/ \ korg1212/ \ mixart/ \ nm256/ \ - pcxhr/ \ rme9652/ \ trident/ \ ymfpci/ \ diff --git a/trunk/sound/pci/ac97/ac97_bus.c b/trunk/sound/pci/ac97/ac97_bus.c index 66de2c2f1554..ec70fadde7d9 100644 --- a/trunk/sound/pci/ac97/ac97_bus.c +++ b/trunk/sound/pci/ac97/ac97_bus.c @@ -18,7 +18,7 @@ /* * Let drivers decide whether they want to support given codec from their - * probe method. Drivers have direct access to the struct snd_ac97 structure and may + * probe method. Drivers have direct access to the ac97_t structure and may * decide based on the id field amongst other things. */ static int ac97_bus_match(struct device *dev, struct device_driver *drv) diff --git a/trunk/sound/pci/ac97/ac97_codec.c b/trunk/sound/pci/ac97/ac97_codec.c index 3020ca2b602b..9bde76c4c6a2 100644 --- a/trunk/sound/pci/ac97/ac97_codec.c +++ b/trunk/sound/pci/ac97/ac97_codec.c @@ -50,16 +50,16 @@ MODULE_PARM_DESC(enable_loopback, "Enable AC97 ADC/DAC Loopback Control"); */ -struct ac97_codec_id { +typedef struct { unsigned int id; unsigned int mask; const char *name; - int (*patch)(struct snd_ac97 *ac97); - int (*mpatch)(struct snd_ac97 *ac97); + int (*patch)(ac97_t *ac97); + int (*mpatch)(ac97_t *ac97); unsigned int flags; -}; +} ac97_codec_id_t; -static const struct ac97_codec_id snd_ac97_codec_id_vendors[] = { +static const ac97_codec_id_t snd_ac97_codec_id_vendors[] = { { 0x414b4d00, 0xffffff00, "Asahi Kasei", NULL, NULL }, { 0x41445300, 0xffffff00, "Analog Devices", NULL, NULL }, { 0x414c4300, 0xffffff00, "Realtek", NULL, NULL }, @@ -86,7 +86,7 @@ static const struct ac97_codec_id snd_ac97_codec_id_vendors[] = { { 0, 0, NULL, NULL, NULL } }; -static const struct ac97_codec_id snd_ac97_codec_ids[] = { +static const ac97_codec_id_t snd_ac97_codec_ids[] = { { 0x414b4d00, 0xffffffff, "AK4540", NULL, NULL }, { 0x414b4d01, 0xffffffff, "AK4542", NULL, NULL }, { 0x414b4d02, 0xffffffff, "AK4543", NULL, NULL }, @@ -137,7 +137,7 @@ static const struct ac97_codec_id snd_ac97_codec_ids[] = { { 0x43585421, 0xffffffff, "HSD11246", NULL, NULL }, // SmartMC II { 0x43585428, 0xfffffff8, "Cx20468", patch_conexant, NULL }, // SmartAMC fixme: the mask might be different { 0x44543031, 0xfffffff0, "DT0398", NULL, NULL }, -{ 0x454d4328, 0xffffffff, "EM28028", NULL, NULL }, // same as TR28028? +{ 0x454d4328, 0xffffffff, "28028", NULL, NULL }, // same as TR28028? { 0x45838308, 0xffffffff, "ESS1988", NULL, NULL }, { 0x48525300, 0xffffff00, "HMP9701", NULL, NULL }, { 0x49434501, 0xffffffff, "ICE1230", NULL, NULL }, @@ -184,12 +184,48 @@ static const struct ac97_codec_id snd_ac97_codec_ids[] = { { 0, 0, NULL, NULL, NULL } }; +const char *snd_ac97_stereo_enhancements[] = +{ + /* 0 */ "No 3D Stereo Enhancement", + /* 1 */ "Analog Devices Phat Stereo", + /* 2 */ "Creative Stereo Enhancement", + /* 3 */ "National Semi 3D Stereo Enhancement", + /* 4 */ "YAMAHA Ymersion", + /* 5 */ "BBE 3D Stereo Enhancement", + /* 6 */ "Crystal Semi 3D Stereo Enhancement", + /* 7 */ "Qsound QXpander", + /* 8 */ "Spatializer 3D Stereo Enhancement", + /* 9 */ "SRS 3D Stereo Enhancement", + /* 10 */ "Platform Tech 3D Stereo Enhancement", + /* 11 */ "AKM 3D Audio", + /* 12 */ "Aureal Stereo Enhancement", + /* 13 */ "Aztech 3D Enhancement", + /* 14 */ "Binaura 3D Audio Enhancement", + /* 15 */ "ESS Technology Stereo Enhancement", + /* 16 */ "Harman International VMAx", + /* 17 */ "Nvidea/IC Ensemble/KS Waves 3D Stereo Enhancement", + /* 18 */ "Philips Incredible Sound", + /* 19 */ "Texas Instruments 3D Stereo Enhancement", + /* 20 */ "VLSI Technology 3D Stereo Enhancement", + /* 21 */ "TriTech 3D Stereo Enhancement", + /* 22 */ "Realtek 3D Stereo Enhancement", + /* 23 */ "Samsung 3D Stereo Enhancement", + /* 24 */ "Wolfson Microelectronics 3D Enhancement", + /* 25 */ "Delta Integration 3D Enhancement", + /* 26 */ "SigmaTel 3D Enhancement", + /* 27 */ "IC Ensemble/KS Waves", + /* 28 */ "Rockwell 3D Stereo Enhancement", + /* 29 */ "Reserved 29", + /* 30 */ "Reserved 30", + /* 31 */ "Reserved 31" +}; + /* * I/O routines */ -static int snd_ac97_valid_reg(struct snd_ac97 *ac97, unsigned short reg) +static int snd_ac97_valid_reg(ac97_t *ac97, unsigned short reg) { if (ac97->limited_regs && ! test_bit(reg, ac97->reg_accessed)) return 0; @@ -242,7 +278,7 @@ static int snd_ac97_valid_reg(struct snd_ac97 *ac97, unsigned short reg) * #snd_ca97_write_cache(), so use this only when you don't want to * reflect the change to the suspend/resume state. */ -void snd_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short value) +void snd_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short value) { if (!snd_ac97_valid_reg(ac97, reg)) return; @@ -265,7 +301,7 @@ void snd_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short va * * Returns the read value. */ -unsigned short snd_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +unsigned short snd_ac97_read(ac97_t *ac97, unsigned short reg) { if (!snd_ac97_valid_reg(ac97, reg)) return 0; @@ -273,7 +309,7 @@ unsigned short snd_ac97_read(struct snd_ac97 *ac97, unsigned short reg) } /* read a register - return the cached value if already read */ -static inline unsigned short snd_ac97_read_cache(struct snd_ac97 *ac97, unsigned short reg) +static inline unsigned short snd_ac97_read_cache(ac97_t *ac97, unsigned short reg) { if (! test_bit(reg, ac97->reg_accessed)) { ac97->regs[reg] = ac97->bus->ops->read(ac97, reg); @@ -292,7 +328,7 @@ static inline unsigned short snd_ac97_read_cache(struct snd_ac97 *ac97, unsigned * cache. The cached values are used for the cached-read and the * suspend/resume. */ -void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned short value) +void snd_ac97_write_cache(ac97_t *ac97, unsigned short reg, unsigned short value) { if (!snd_ac97_valid_reg(ac97, reg)) return; @@ -315,7 +351,7 @@ void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned sh * Returns 1 if the value is changed, 0 if no change, or a negative * code on failure. */ -int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short value) +int snd_ac97_update(ac97_t *ac97, unsigned short reg, unsigned short value) { int change; @@ -345,7 +381,7 @@ int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short va * Returns 1 if the bits are changed, 0 if no change, or a negative * code on failure. */ -int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value) +int snd_ac97_update_bits(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value) { int change; @@ -358,7 +394,7 @@ int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned sho } /* no lock version - see snd_ac97_updat_bits() */ -int snd_ac97_update_bits_nolock(struct snd_ac97 *ac97, unsigned short reg, +int snd_ac97_update_bits_nolock(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value) { int change; @@ -375,7 +411,7 @@ int snd_ac97_update_bits_nolock(struct snd_ac97 *ac97, unsigned short reg, return change; } -static int snd_ac97_ad18xx_update_pcm_bits(struct snd_ac97 *ac97, int codec, unsigned short mask, unsigned short value) +static int snd_ac97_ad18xx_update_pcm_bits(ac97_t *ac97, int codec, unsigned short mask, unsigned short value) { int change; unsigned short old, new, cfg; @@ -407,7 +443,7 @@ static int snd_ac97_ad18xx_update_pcm_bits(struct snd_ac97 *ac97, int codec, uns * Controls */ -int snd_ac97_info_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +int snd_ac97_info_enum_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value; @@ -421,9 +457,9 @@ int snd_ac97_info_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -int snd_ac97_get_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_ac97_get_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value; unsigned short val, bitmask; @@ -437,9 +473,9 @@ int snd_ac97_get_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -int snd_ac97_put_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_ac97_put_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value; unsigned short val; unsigned short mask, bitmask; @@ -460,7 +496,7 @@ int snd_ac97_put_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ } /* save/restore ac97 v2.3 paging */ -static int snd_ac97_page_save(struct snd_ac97 *ac97, int reg, struct snd_kcontrol *kcontrol) +static int snd_ac97_page_save(ac97_t *ac97, int reg, snd_kcontrol_t *kcontrol) { int page_save = -1; if ((kcontrol->private_value & (1<<25)) && @@ -474,7 +510,7 @@ static int snd_ac97_page_save(struct snd_ac97 *ac97, int reg, struct snd_kcontro return page_save; } -static void snd_ac97_page_restore(struct snd_ac97 *ac97, int page_save) +static void snd_ac97_page_restore(ac97_t *ac97, int page_save) { if (page_save >= 0) { snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save); @@ -483,7 +519,7 @@ static void snd_ac97_page_restore(struct snd_ac97 *ac97, int page_save) } /* volume and switch controls */ -int snd_ac97_info_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +int snd_ac97_info_volsw(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; int shift = (kcontrol->private_value >> 8) & 0x0f; @@ -496,9 +532,9 @@ int snd_ac97_info_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info return 0; } -int snd_ac97_get_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_ac97_get_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0x0f; int rshift = (kcontrol->private_value >> 12) & 0x0f; @@ -519,9 +555,9 @@ int snd_ac97_get_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value return 0; } -int snd_ac97_put_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_ac97_put_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0x0f; int rshift = (kcontrol->private_value >> 12) & 0x0f; @@ -548,22 +584,22 @@ int snd_ac97_put_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value return err; } -static const struct snd_kcontrol_new snd_ac97_controls_master_mono[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_master_mono[2] = { AC97_SINGLE("Master Mono Playback Switch", AC97_MASTER_MONO, 15, 1, 1), AC97_SINGLE("Master Mono Playback Volume", AC97_MASTER_MONO, 0, 31, 1) }; -static const struct snd_kcontrol_new snd_ac97_controls_tone[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_tone[2] = { AC97_SINGLE("Tone Control - Bass", AC97_MASTER_TONE, 8, 15, 1), AC97_SINGLE("Tone Control - Treble", AC97_MASTER_TONE, 0, 15, 1) }; -static const struct snd_kcontrol_new snd_ac97_controls_pc_beep[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_pc_beep[2] = { AC97_SINGLE("PC Speaker Playback Switch", AC97_PC_BEEP, 15, 1, 1), AC97_SINGLE("PC Speaker Playback Volume", AC97_PC_BEEP, 1, 15, 1) }; -static const struct snd_kcontrol_new snd_ac97_controls_mic_boost = +static const snd_kcontrol_new_t snd_ac97_controls_mic_boost = AC97_SINGLE("Mic Boost (+20dB)", AC97_MIC, 6, 1, 0); @@ -579,18 +615,18 @@ AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 9, 2, std_mix), AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 8, 2, std_mic), }; -static const struct snd_kcontrol_new snd_ac97_control_capture_src = +static const snd_kcontrol_new_t snd_ac97_control_capture_src = AC97_ENUM("Capture Source", std_enum[0]); -static const struct snd_kcontrol_new snd_ac97_control_capture_vol = +static const snd_kcontrol_new_t snd_ac97_control_capture_vol = AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 15, 0); -static const struct snd_kcontrol_new snd_ac97_controls_mic_capture[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_mic_capture[2] = { AC97_SINGLE("Mic Capture Switch", AC97_REC_GAIN_MIC, 15, 1, 1), AC97_SINGLE("Mic Capture Volume", AC97_REC_GAIN_MIC, 0, 15, 0) }; -enum { +typedef enum { AC97_GENERAL_PCM_OUT = 0, AC97_GENERAL_STEREO_ENHANCEMENT, AC97_GENERAL_3D, @@ -598,9 +634,9 @@ enum { AC97_GENERAL_MONO, AC97_GENERAL_MIC, AC97_GENERAL_LOOPBACK -}; +} ac97_general_index_t; -static const struct snd_kcontrol_new snd_ac97_controls_general[7] = { +static const snd_kcontrol_new_t snd_ac97_controls_general[7] = { AC97_ENUM("PCM Out Path & Mute", std_enum[1]), AC97_SINGLE("Simulated Stereo Enhancement", AC97_GENERAL_PURPOSE, 14, 1, 0), AC97_SINGLE("3D Control - Switch", AC97_GENERAL_PURPOSE, 13, 1, 0), @@ -610,45 +646,45 @@ AC97_ENUM("Mic Select", std_enum[3]), AC97_SINGLE("ADC/DAC Loopback", AC97_GENERAL_PURPOSE, 7, 1, 0) }; -const struct snd_kcontrol_new snd_ac97_controls_3d[2] = { +const snd_kcontrol_new_t snd_ac97_controls_3d[2] = { AC97_SINGLE("3D Control - Center", AC97_3D_CONTROL, 8, 15, 0), AC97_SINGLE("3D Control - Depth", AC97_3D_CONTROL, 0, 15, 0) }; -static const struct snd_kcontrol_new snd_ac97_controls_center[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_center[2] = { AC97_SINGLE("Center Playback Switch", AC97_CENTER_LFE_MASTER, 7, 1, 1), AC97_SINGLE("Center Playback Volume", AC97_CENTER_LFE_MASTER, 0, 31, 1) }; -static const struct snd_kcontrol_new snd_ac97_controls_lfe[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_lfe[2] = { AC97_SINGLE("LFE Playback Switch", AC97_CENTER_LFE_MASTER, 15, 1, 1), AC97_SINGLE("LFE Playback Volume", AC97_CENTER_LFE_MASTER, 8, 31, 1) }; -static const struct snd_kcontrol_new snd_ac97_control_eapd = +static const snd_kcontrol_new_t snd_ac97_control_eapd = AC97_SINGLE("External Amplifier", AC97_POWERDOWN, 15, 1, 1); -static const struct snd_kcontrol_new snd_ac97_controls_modem_switches[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_modem_switches[2] = { AC97_SINGLE("Off-hook Switch", AC97_GPIO_STATUS, 0, 1, 0), AC97_SINGLE("Caller ID Switch", AC97_GPIO_STATUS, 2, 1, 0) }; /* change the existing EAPD control as inverted */ -static void set_inv_eapd(struct snd_ac97 *ac97, struct snd_kcontrol *kctl) +static void set_inv_eapd(ac97_t *ac97, snd_kcontrol_t *kctl) { kctl->private_value = AC97_SINGLE_VALUE(AC97_POWERDOWN, 15, 1, 0); snd_ac97_update_bits(ac97, AC97_POWERDOWN, (1<<15), (1<<15)); /* EAPD up */ ac97->scaps |= AC97_SCAP_INV_EAPD; } -static int snd_ac97_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ac97_spdif_cmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_spdif_cmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | IEC958_AES0_NONAUDIO | @@ -660,7 +696,7 @@ static int snd_ac97_spdif_cmask_get(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_ac97_spdif_pmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_spdif_pmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol) { /* FIXME: AC'97 spec doesn't say which bits are used for what */ ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | @@ -670,9 +706,9 @@ static int snd_ac97_spdif_pmask_get(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_ac97_spdif_default_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_spdif_default_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); down(&ac97->reg_mutex); ucontrol->value.iec958.status[0] = ac97->spdif_status & 0xff; @@ -683,9 +719,9 @@ static int snd_ac97_spdif_default_get(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_ac97_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_spdif_default_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned int new = 0; unsigned short val = 0; int change; @@ -751,9 +787,9 @@ static int snd_ac97_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_ return change; } -static int snd_ac97_put_spsa(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_put_spsa(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -781,7 +817,7 @@ static int snd_ac97_put_spsa(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return change; } -const struct snd_kcontrol_new snd_ac97_controls_spdif[5] = { +const snd_kcontrol_new_t snd_ac97_controls_spdif[5] = { { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_MIXER, @@ -820,9 +856,9 @@ const struct snd_kcontrol_new snd_ac97_controls_spdif[5] = { .get = snd_ac97_ad18xx_pcm_get_bits, .put = snd_ac97_ad18xx_pcm_put_bits, \ .private_value = (codec) | ((lshift) << 8) | ((rshift) << 12) | ((mask) << 16) } -static int snd_ac97_ad18xx_pcm_info_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ad18xx_pcm_info_bits(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int mask = (kcontrol->private_value >> 16) & 0x0f; int lshift = (kcontrol->private_value >> 8) & 0x0f; int rshift = (kcontrol->private_value >> 12) & 0x0f; @@ -837,9 +873,9 @@ static int snd_ac97_ad18xx_pcm_info_bits(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_ac97_ad18xx_pcm_get_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad18xx_pcm_get_bits(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int codec = kcontrol->private_value & 3; int lshift = (kcontrol->private_value >> 8) & 0x0f; int rshift = (kcontrol->private_value >> 12) & 0x0f; @@ -851,9 +887,9 @@ static int snd_ac97_ad18xx_pcm_get_bits(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_ac97_ad18xx_pcm_put_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad18xx_pcm_put_bits(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int codec = kcontrol->private_value & 3; int lshift = (kcontrol->private_value >> 8) & 0x0f; int rshift = (kcontrol->private_value >> 12) & 0x0f; @@ -874,7 +910,7 @@ static int snd_ac97_ad18xx_pcm_put_bits(struct snd_kcontrol *kcontrol, struct sn .get = snd_ac97_ad18xx_pcm_get_volume, .put = snd_ac97_ad18xx_pcm_put_volume, \ .private_value = codec } -static int snd_ac97_ad18xx_pcm_info_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ad18xx_pcm_info_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -883,9 +919,9 @@ static int snd_ac97_ad18xx_pcm_info_volume(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_ac97_ad18xx_pcm_get_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad18xx_pcm_get_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int codec = kcontrol->private_value & 3; down(&ac97->page_mutex); @@ -895,9 +931,9 @@ static int snd_ac97_ad18xx_pcm_get_volume(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_ac97_ad18xx_pcm_put_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad18xx_pcm_put_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int codec = kcontrol->private_value & 3; unsigned short val1, val2; @@ -906,22 +942,22 @@ static int snd_ac97_ad18xx_pcm_put_volume(struct snd_kcontrol *kcontrol, struct return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, 0x1f1f, (val1 << 8) | val2); } -static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_pcm[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_pcm[2] = { AD18XX_PCM_BITS("PCM Playback Switch", 0, 15, 7, 1), AD18XX_PCM_VOLUME("PCM Playback Volume", 0) }; -static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_surround[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_surround[2] = { AD18XX_PCM_BITS("Surround Playback Switch", 1, 15, 7, 1), AD18XX_PCM_VOLUME("Surround Playback Volume", 1) }; -static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_center[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_center[2] = { AD18XX_PCM_BITS("Center Playback Switch", 2, 15, 15, 1), AD18XX_PCM_BITS("Center Playback Volume", 2, 8, 8, 31) }; -static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_lfe[2] = { +static const snd_kcontrol_new_t snd_ac97_controls_ad18xx_lfe[2] = { AD18XX_PCM_BITS("LFE Playback Switch", 2, 7, 7, 1), AD18XX_PCM_BITS("LFE Playback Volume", 2, 0, 0, 31) }; @@ -930,9 +966,9 @@ AD18XX_PCM_BITS("LFE Playback Volume", 2, 0, 0, 31) * */ -static void snd_ac97_powerdown(struct snd_ac97 *ac97); +static void snd_ac97_powerdown(ac97_t *ac97); -static int snd_ac97_bus_free(struct snd_ac97_bus *bus) +static int snd_ac97_bus_free(ac97_bus_t *bus) { if (bus) { snd_ac97_bus_proc_done(bus); @@ -944,13 +980,13 @@ static int snd_ac97_bus_free(struct snd_ac97_bus *bus) return 0; } -static int snd_ac97_bus_dev_free(struct snd_device *device) +static int snd_ac97_bus_dev_free(snd_device_t *device) { - struct snd_ac97_bus *bus = device->device_data; + ac97_bus_t *bus = device->device_data; return snd_ac97_bus_free(bus); } -static int snd_ac97_free(struct snd_ac97 *ac97) +static int snd_ac97_free(ac97_t *ac97) { if (ac97) { snd_ac97_proc_done(ac97); @@ -963,14 +999,14 @@ static int snd_ac97_free(struct snd_ac97 *ac97) return 0; } -static int snd_ac97_dev_free(struct snd_device *device) +static int snd_ac97_dev_free(snd_device_t *device) { - struct snd_ac97 *ac97 = device->device_data; + ac97_t *ac97 = device->device_data; snd_ac97_powerdown(ac97); /* for avoiding click noises during shut down */ return snd_ac97_free(ac97); } -static int snd_ac97_try_volume_mix(struct snd_ac97 * ac97, int reg) +static int snd_ac97_try_volume_mix(ac97_t * ac97, int reg) { unsigned short val, mask = 0x8000; @@ -1016,14 +1052,13 @@ static int snd_ac97_try_volume_mix(struct snd_ac97 * ac97, int reg) /* try another test */ snd_ac97_write_cache(ac97, reg, val | mask); val = snd_ac97_read(ac97, reg); - val = snd_ac97_read(ac97, reg); if (!(val & mask)) return 0; /* nothing here */ } return 1; /* success, useable */ } -static void check_volume_resolution(struct snd_ac97 *ac97, int reg, unsigned char *lo_max, unsigned char *hi_max) +static void check_volume_resolution(ac97_t *ac97, int reg, unsigned char *lo_max, unsigned char *hi_max) { unsigned short cbit[3] = { 0x20, 0x10, 0x01 }; unsigned char max[3] = { 63, 31, 15 }; @@ -1048,7 +1083,7 @@ static void check_volume_resolution(struct snd_ac97 *ac97, int reg, unsigned cha } } -int snd_ac97_try_bit(struct snd_ac97 * ac97, int reg, int bit) +int snd_ac97_try_bit(ac97_t * ac97, int reg, int bit) { unsigned short mask, val, orig, res; @@ -1062,7 +1097,7 @@ int snd_ac97_try_bit(struct snd_ac97 * ac97, int reg, int bit) } /* check the volume resolution of center/lfe */ -static void snd_ac97_change_volume_params2(struct snd_ac97 * ac97, int reg, int shift, unsigned char *max) +static void snd_ac97_change_volume_params2(ac97_t * ac97, int reg, int shift, unsigned char *max) { unsigned short val, val1; @@ -1088,9 +1123,9 @@ static inline int printable(unsigned int x) return x; } -struct snd_kcontrol *snd_ac97_cnew(const struct snd_kcontrol_new *_template, struct snd_ac97 * ac97) +snd_kcontrol_t *snd_ac97_cnew(const snd_kcontrol_new_t *_template, ac97_t * ac97) { - struct snd_kcontrol_new template; + snd_kcontrol_new_t template; memcpy(&template, _template, sizeof(template)); template.index = ac97->num; return snd_ctl_new1(&template, ac97); @@ -1099,9 +1134,9 @@ struct snd_kcontrol *snd_ac97_cnew(const struct snd_kcontrol_new *_template, str /* * create mute switch(es) for normal stereo controls */ -static int snd_ac97_cmute_new_stereo(struct snd_card *card, char *name, int reg, int check_stereo, struct snd_ac97 *ac97) +static int snd_ac97_cmute_new_stereo(snd_card_t *card, char *name, int reg, int check_stereo, ac97_t *ac97) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; int err; unsigned short val, val1, mute_mask; @@ -1118,11 +1153,11 @@ static int snd_ac97_cmute_new_stereo(struct snd_card *card, char *name, int reg, mute_mask = 0x8080; } if (mute_mask == 0x8080) { - struct snd_kcontrol_new tmp = AC97_DOUBLE(name, reg, 15, 7, 1, 1); + snd_kcontrol_new_t tmp = AC97_DOUBLE(name, reg, 15, 7, 1, 1); tmp.index = ac97->num; kctl = snd_ctl_new1(&tmp, ac97); } else { - struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 15, 1, 1); + snd_kcontrol_new_t tmp = AC97_SINGLE(name, reg, 15, 1, 1); tmp.index = ac97->num; kctl = snd_ctl_new1(&tmp, ac97); } @@ -1137,22 +1172,22 @@ static int snd_ac97_cmute_new_stereo(struct snd_card *card, char *name, int reg, /* * create a volume for normal stereo/mono controls */ -static int snd_ac97_cvol_new(struct snd_card *card, char *name, int reg, unsigned int lo_max, - unsigned int hi_max, struct snd_ac97 *ac97) +static int snd_ac97_cvol_new(snd_card_t *card, char *name, int reg, unsigned int lo_max, + unsigned int hi_max, ac97_t *ac97) { int err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; if (! snd_ac97_valid_reg(ac97, reg)) return 0; if (hi_max) { /* invert */ - struct snd_kcontrol_new tmp = AC97_DOUBLE(name, reg, 8, 0, lo_max, 1); + snd_kcontrol_new_t tmp = AC97_DOUBLE(name, reg, 8, 0, lo_max, 1); tmp.index = ac97->num; kctl = snd_ctl_new1(&tmp, ac97); } else { /* invert */ - struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 0, lo_max, 1); + snd_kcontrol_new_t tmp = AC97_SINGLE(name, reg, 0, lo_max, 1); tmp.index = ac97->num; kctl = snd_ctl_new1(&tmp, ac97); } @@ -1168,7 +1203,7 @@ static int snd_ac97_cvol_new(struct snd_card *card, char *name, int reg, unsigne /* * create a mute-switch and a volume for normal stereo/mono controls */ -static int snd_ac97_cmix_new_stereo(struct snd_card *card, const char *pfx, int reg, int check_stereo, struct snd_ac97 *ac97) +static int snd_ac97_cmix_new_stereo(snd_card_t *card, const char *pfx, int reg, int check_stereo, ac97_t *ac97) { int err; char name[44]; @@ -1194,12 +1229,12 @@ static int snd_ac97_cmix_new_stereo(struct snd_card *card, const char *pfx, int #define snd_ac97_cmix_new(card, pfx, reg, ac97) snd_ac97_cmix_new_stereo(card, pfx, reg, 0, ac97) #define snd_ac97_cmute_new(card, name, reg, ac97) snd_ac97_cmute_new_stereo(card, name, reg, 0, ac97) -static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97); +static unsigned int snd_ac97_determine_spdif_rates(ac97_t *ac97); -static int snd_ac97_mixer_build(struct snd_ac97 * ac97) +static int snd_ac97_mixer_build(ac97_t * ac97) { - struct snd_card *card = ac97->bus->card; - struct snd_kcontrol *kctl; + snd_card_t *card = ac97->bus->card; + snd_kcontrol_t *kctl; int err; unsigned int idx; unsigned char max; @@ -1496,7 +1531,7 @@ static int snd_ac97_mixer_build(struct snd_ac97 * ac97) return 0; } -static int snd_ac97_modem_build(struct snd_card *card, struct snd_ac97 * ac97) +static int snd_ac97_modem_build(snd_card_t * card, ac97_t * ac97) { int err, idx; @@ -1520,7 +1555,7 @@ static int snd_ac97_modem_build(struct snd_card *card, struct snd_ac97 * ac97) return 0; } -static int snd_ac97_test_rate(struct snd_ac97 *ac97, int reg, int shadow_reg, int rate) +static int snd_ac97_test_rate(ac97_t *ac97, int reg, int shadow_reg, int rate) { unsigned short val; unsigned int tmp; @@ -1533,7 +1568,7 @@ static int snd_ac97_test_rate(struct snd_ac97 *ac97, int reg, int shadow_reg, in return val == (tmp & 0xffff); } -static void snd_ac97_determine_rates(struct snd_ac97 *ac97, int reg, int shadow_reg, unsigned int *r_result) +static void snd_ac97_determine_rates(ac97_t *ac97, int reg, int shadow_reg, unsigned int *r_result) { unsigned int result = 0; unsigned short saved; @@ -1593,7 +1628,7 @@ static void snd_ac97_determine_rates(struct snd_ac97 *ac97, int reg, int shadow_ } /* check AC97_SPDIF register to accept which sample rates */ -static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97) +static unsigned int snd_ac97_determine_spdif_rates(ac97_t *ac97) { unsigned int result = 0; int i; @@ -1613,10 +1648,10 @@ static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97) } /* look for the codec id table matching with the given id */ -static const struct ac97_codec_id *look_for_codec_id(const struct ac97_codec_id *table, - unsigned int id) +static const ac97_codec_id_t *look_for_codec_id(const ac97_codec_id_t *table, + unsigned int id) { - const struct ac97_codec_id *pid; + const ac97_codec_id_t *pid; for (pid = table; pid->id; pid++) if (pid->id == (id & pid->mask)) @@ -1624,9 +1659,9 @@ static const struct ac97_codec_id *look_for_codec_id(const struct ac97_codec_id return NULL; } -void snd_ac97_get_name(struct snd_ac97 *ac97, unsigned int id, char *name, int modem) +void snd_ac97_get_name(ac97_t *ac97, unsigned int id, char *name, int modem) { - const struct ac97_codec_id *pid; + const ac97_codec_id_t *pid; sprintf(name, "0x%x %c%c%c", id, printable(id >> 24), @@ -1664,9 +1699,9 @@ void snd_ac97_get_name(struct snd_ac97 *ac97, unsigned int id, char *name, int m * * Returns the short identifying name of the codec. */ -const char *snd_ac97_get_short_name(struct snd_ac97 *ac97) +const char *snd_ac97_get_short_name(ac97_t *ac97) { - const struct ac97_codec_id *pid; + const ac97_codec_id_t *pid; for (pid = snd_ac97_codec_ids; pid->id; pid++) if (pid->id == (ac97->id & pid->mask)) @@ -1678,7 +1713,7 @@ const char *snd_ac97_get_short_name(struct snd_ac97 *ac97) /* wait for a while until registers are accessible after RESET * return 0 if ok, negative not ready */ -static int ac97_reset_wait(struct snd_ac97 *ac97, int timeout, int with_modem) +static int ac97_reset_wait(ac97_t *ac97, int timeout, int with_modem) { unsigned long end_time; unsigned short val; @@ -1723,7 +1758,7 @@ static int ac97_reset_wait(struct snd_ac97 *ac97, int timeout, int with_modem) * @private_data: private data pointer for the new instance * @rbus: the pointer to store the new AC97 bus instance. * - * Creates an AC97 bus component. An struct snd_ac97_bus instance is newly + * Creates an AC97 bus component. An ac97_bus_t instance is newly * allocated and initialized. * * The ops table must include valid callbacks (at least read and @@ -1737,12 +1772,12 @@ static int ac97_reset_wait(struct snd_ac97 *ac97, int timeout, int with_modem) * * Returns zero if successful, or a negative error code on failure. */ -int snd_ac97_bus(struct snd_card *card, int num, struct snd_ac97_bus_ops *ops, - void *private_data, struct snd_ac97_bus **rbus) +int snd_ac97_bus(snd_card_t *card, int num, ac97_bus_ops_t *ops, + void *private_data, ac97_bus_t **rbus) { int err; - struct snd_ac97_bus *bus; - static struct snd_device_ops dev_ops = { + ac97_bus_t *bus; + static snd_device_ops_t dev_ops = { .dev_free = snd_ac97_bus_dev_free, }; @@ -1772,17 +1807,15 @@ static void ac97_device_release(struct device * dev) } /* register ac97 codec to bus */ -static int snd_ac97_dev_register(struct snd_device *device) +static int snd_ac97_dev_register(snd_device_t *device) { - struct snd_ac97 *ac97 = device->device_data; + ac97_t *ac97 = device->device_data; int err; ac97->dev.bus = &ac97_bus_type; ac97->dev.parent = ac97->bus->card->dev; ac97->dev.release = ac97_device_release; - snprintf(ac97->dev.bus_id, BUS_ID_SIZE, "%d-%d:%s", - ac97->bus->card->number, ac97->num, - snd_ac97_get_short_name(ac97)); + snprintf(ac97->dev.bus_id, BUS_ID_SIZE, "card%d-%d", ac97->bus->card->number, ac97->num); if ((err = device_register(&ac97->dev)) < 0) { snd_printk(KERN_ERR "Can't register ac97 bus\n"); ac97->dev.bus = NULL; @@ -1792,9 +1825,9 @@ static int snd_ac97_dev_register(struct snd_device *device) } /* unregister ac97 codec */ -static int snd_ac97_dev_unregister(struct snd_device *device) +static int snd_ac97_dev_unregister(snd_device_t *device) { - struct snd_ac97 *ac97 = device->device_data; + ac97_t *ac97 = device->device_data; if (ac97->dev.bus) device_unregister(&ac97->dev); return snd_ac97_free(ac97); @@ -1810,7 +1843,7 @@ static struct snd_ac97_build_ops null_build_ops; * the private data. * @rac97: the pointer to store the new ac97 instance. * - * Creates an Codec97 component. An struct snd_ac97 instance is newly + * Creates an Codec97 component. An ac97_t instance is newly * allocated and initialized from the template. The codec * is then initialized by the standard procedure. * @@ -1822,16 +1855,16 @@ static struct snd_ac97_build_ops null_build_ops; * * Returns zero if successful, or a negative error code on failure. */ -int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, struct snd_ac97 **rac97) +int snd_ac97_mixer(ac97_bus_t *bus, ac97_template_t *template, ac97_t **rac97) { int err; - struct snd_ac97 *ac97; - struct snd_card *card; + ac97_t *ac97; + snd_card_t *card; char name[64]; unsigned long end_time; unsigned int reg; - const struct ac97_codec_id *pid; - static struct snd_device_ops ops = { + const ac97_codec_id_t *pid; + static snd_device_ops_t ops = { .dev_free = snd_ac97_dev_free, .dev_register = snd_ac97_dev_register, .dev_unregister = snd_ac97_dev_unregister, @@ -1859,12 +1892,10 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, init_MUTEX(&ac97->reg_mutex); init_MUTEX(&ac97->page_mutex); -#ifdef CONFIG_PCI if (ac97->pci) { pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_VENDOR_ID, &ac97->subsystem_vendor); pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_ID, &ac97->subsystem_device); } -#endif if (bus->ops->reset) { bus->ops->reset(ac97); goto __access_ok; @@ -2117,7 +2148,7 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, * MASTER and HEADPHONE registers are muted but the register cache values * are not changed, so that the values can be restored in snd_ac97_resume(). */ -static void snd_ac97_powerdown(struct snd_ac97 *ac97) +static void snd_ac97_powerdown(ac97_t *ac97) { unsigned short power; @@ -2150,10 +2181,8 @@ static void snd_ac97_powerdown(struct snd_ac97 *ac97) * * Suspends the codec, power down the chip. */ -void snd_ac97_suspend(struct snd_ac97 *ac97) +void snd_ac97_suspend(ac97_t *ac97) { - if (! ac97) - return; if (ac97->build_ops->suspend) ac97->build_ops->suspend(ac97); snd_ac97_powerdown(ac97); @@ -2162,7 +2191,7 @@ void snd_ac97_suspend(struct snd_ac97 *ac97) /* * restore ac97 status */ -void snd_ac97_restore_status(struct snd_ac97 *ac97) +void snd_ac97_restore_status(ac97_t *ac97) { int i; @@ -2183,7 +2212,7 @@ void snd_ac97_restore_status(struct snd_ac97 *ac97) /* * restore IEC958 status */ -void snd_ac97_restore_iec958(struct snd_ac97 *ac97) +void snd_ac97_restore_iec958(ac97_t *ac97) { if (ac97->ext_id & AC97_EI_SPDIF) { if (ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_SPDIF) { @@ -2206,13 +2235,10 @@ void snd_ac97_restore_iec958(struct snd_ac97 *ac97) * Do the standard resume procedure, power up and restoring the * old register values. */ -void snd_ac97_resume(struct snd_ac97 *ac97) +void snd_ac97_resume(ac97_t *ac97) { unsigned long end_time; - if (! ac97) - return; - if (ac97->bus->ops->reset) { ac97->bus->ops->reset(ac97); goto __reset_ready; @@ -2275,18 +2301,18 @@ static void set_ctl_name(char *dst, const char *src, const char *suffix) } /* remove the control with the given name and optional suffix */ -int snd_ac97_remove_ctl(struct snd_ac97 *ac97, const char *name, const char *suffix) +int snd_ac97_remove_ctl(ac97_t *ac97, const char *name, const char *suffix) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; memset(&id, 0, sizeof(id)); set_ctl_name(id.name, name, suffix); id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; return snd_ctl_remove_id(ac97->bus->card, &id); } -static struct snd_kcontrol *ctl_find(struct snd_ac97 *ac97, const char *name, const char *suffix) +static snd_kcontrol_t *ctl_find(ac97_t *ac97, const char *name, const char *suffix) { - struct snd_ctl_elem_id sid; + snd_ctl_elem_id_t sid; memset(&sid, 0, sizeof(sid)); set_ctl_name(sid.name, name, suffix); sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; @@ -2294,9 +2320,9 @@ static struct snd_kcontrol *ctl_find(struct snd_ac97 *ac97, const char *name, co } /* rename the control with the given name and optional suffix */ -int snd_ac97_rename_ctl(struct snd_ac97 *ac97, const char *src, const char *dst, const char *suffix) +int snd_ac97_rename_ctl(ac97_t *ac97, const char *src, const char *dst, const char *suffix) { - struct snd_kcontrol *kctl = ctl_find(ac97, src, suffix); + snd_kcontrol_t *kctl = ctl_find(ac97, src, suffix); if (kctl) { set_ctl_name(kctl->id.name, dst, suffix); return 0; @@ -2305,16 +2331,16 @@ int snd_ac97_rename_ctl(struct snd_ac97 *ac97, const char *src, const char *dst, } /* rename both Volume and Switch controls - don't check the return value */ -void snd_ac97_rename_vol_ctl(struct snd_ac97 *ac97, const char *src, const char *dst) +void snd_ac97_rename_vol_ctl(ac97_t *ac97, const char *src, const char *dst) { snd_ac97_rename_ctl(ac97, src, dst, "Switch"); snd_ac97_rename_ctl(ac97, src, dst, "Volume"); } /* swap controls */ -int snd_ac97_swap_ctl(struct snd_ac97 *ac97, const char *s1, const char *s2, const char *suffix) +int snd_ac97_swap_ctl(ac97_t *ac97, const char *s1, const char *s2, const char *suffix) { - struct snd_kcontrol *kctl1, *kctl2; + snd_kcontrol_t *kctl1, *kctl2; kctl1 = ctl_find(ac97, s1, suffix); kctl2 = ctl_find(ac97, s2, suffix); if (kctl1 && kctl2) { @@ -2327,7 +2353,7 @@ int snd_ac97_swap_ctl(struct snd_ac97 *ac97, const char *s1, const char *s2, con #if 1 /* bind hp and master controls instead of using only hp control */ -static int bind_hp_volsw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int bind_hp_volsw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int err = snd_ac97_put_volsw(kcontrol, ucontrol); if (err > 0) { @@ -2340,10 +2366,10 @@ static int bind_hp_volsw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ } /* ac97 tune: bind Master and Headphone controls */ -static int tune_hp_only(struct snd_ac97 *ac97) +static int tune_hp_only(ac97_t *ac97) { - struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL); - struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL); + snd_kcontrol_t *msw = ctl_find(ac97, "Master Playback Switch", NULL); + snd_kcontrol_t *mvol = ctl_find(ac97, "Master Playback Volume", NULL); if (! msw || ! mvol) return -ENOENT; msw->put = bind_hp_volsw_put; @@ -2355,7 +2381,7 @@ static int tune_hp_only(struct snd_ac97 *ac97) #else /* ac97 tune: use Headphone control as master */ -static int tune_hp_only(struct snd_ac97 *ac97) +static int tune_hp_only(ac97_t *ac97) { if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL) return -ENOENT; @@ -2367,7 +2393,7 @@ static int tune_hp_only(struct snd_ac97 *ac97) #endif /* ac97 tune: swap Headphone and Master controls */ -static int tune_swap_hp(struct snd_ac97 *ac97) +static int tune_swap_hp(ac97_t *ac97) { if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL) return -ENOENT; @@ -2377,7 +2403,7 @@ static int tune_swap_hp(struct snd_ac97 *ac97) } /* ac97 tune: swap Surround and Master controls */ -static int tune_swap_surround(struct snd_ac97 *ac97) +static int tune_swap_surround(ac97_t *ac97) { if (snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Switch") || snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Volume")) @@ -2386,7 +2412,7 @@ static int tune_swap_surround(struct snd_ac97 *ac97) } /* ac97 tune: set up mic sharing for AD codecs */ -static int tune_ad_sharing(struct snd_ac97 *ac97) +static int tune_ad_sharing(ac97_t *ac97) { unsigned short scfg; if ((ac97->id & 0xffffff00) != 0x41445300) { @@ -2399,11 +2425,11 @@ static int tune_ad_sharing(struct snd_ac97 *ac97) return 0; } -static const struct snd_kcontrol_new snd_ac97_alc_jack_detect = +static const snd_kcontrol_new_t snd_ac97_alc_jack_detect = AC97_SINGLE("Jack Detect", AC97_ALC650_CLOCK, 5, 1, 0); /* ac97 tune: set up ALC jack-select */ -static int tune_alc_jack(struct snd_ac97 *ac97) +static int tune_alc_jack(ac97_t *ac97) { if ((ac97->id & 0xffffff00) != 0x414c4700) { snd_printk(KERN_ERR "ac97_quirk ALC_JACK is only for Realtek codecs\n"); @@ -2411,26 +2437,24 @@ static int tune_alc_jack(struct snd_ac97 *ac97) } snd_ac97_update_bits(ac97, 0x7a, 0x20, 0x20); /* select jack detect function */ snd_ac97_update_bits(ac97, 0x7a, 0x01, 0x01); /* Line-out auto mute */ - if (ac97->id == AC97_ID_ALC658D) - snd_ac97_update_bits(ac97, 0x74, 0x0800, 0x0800); return snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_alc_jack_detect, ac97)); } /* ac97 tune: inversed EAPD bit */ -static int tune_inv_eapd(struct snd_ac97 *ac97) +static int tune_inv_eapd(ac97_t *ac97) { - struct snd_kcontrol *kctl = ctl_find(ac97, "External Amplifier", NULL); + snd_kcontrol_t *kctl = ctl_find(ac97, "External Amplifier", NULL); if (! kctl) return -ENOENT; set_inv_eapd(ac97, kctl); return 0; } -static int master_mute_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int master_mute_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int err = snd_ac97_put_volsw(kcontrol, ucontrol); if (err > 0) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int shift = (kcontrol->private_value >> 8) & 0x0f; int rshift = (kcontrol->private_value >> 12) & 0x0f; unsigned short mask; @@ -2446,9 +2470,9 @@ static int master_mute_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem } /* ac97 tune: EAPD controls mute LED bound with the master mute */ -static int tune_mute_led(struct snd_ac97 *ac97) +static int tune_mute_led(ac97_t *ac97) { - struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL); + snd_kcontrol_t *msw = ctl_find(ac97, "Master Playback Switch", NULL); if (! msw) return -ENOENT; msw->put = master_mute_sw_put; @@ -2457,44 +2481,9 @@ static int tune_mute_led(struct snd_ac97 *ac97) return 0; } -static int hp_master_mute_sw_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - int err = bind_hp_volsw_put(kcontrol, ucontrol); - if (err > 0) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); - int shift = (kcontrol->private_value >> 8) & 0x0f; - int rshift = (kcontrol->private_value >> 12) & 0x0f; - unsigned short mask; - if (shift != rshift) - mask = 0x8080; - else - mask = 0x8000; - snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000, - (ac97->regs[AC97_MASTER] & mask) == mask ? - 0x8000 : 0); - } - return err; -} - -static int tune_hp_mute_led(struct snd_ac97 *ac97) -{ - struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL); - struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL); - if (! msw || ! mvol) - return -ENOENT; - msw->put = hp_master_mute_sw_put; - mvol->put = bind_hp_volsw_put; - snd_ac97_remove_ctl(ac97, "External Amplifier", NULL); - snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch"); - snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume"); - snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000, 0x8000); /* mute LED on */ - return 0; -} - struct quirk_table { const char *name; - int (*func)(struct snd_ac97 *); + int (*func)(ac97_t *); }; static struct quirk_table applicable_quirks[] = { @@ -2506,11 +2495,10 @@ static struct quirk_table applicable_quirks[] = { { "alc_jack", tune_alc_jack }, { "inv_eapd", tune_inv_eapd }, { "mute_led", tune_mute_led }, - { "hp_mute_led", tune_hp_mute_led }, }; /* apply the quirk with the given type */ -static int apply_quirk(struct snd_ac97 *ac97, int type) +static int apply_quirk(ac97_t *ac97, int type) { if (type <= 0) return 0; @@ -2522,7 +2510,7 @@ static int apply_quirk(struct snd_ac97 *ac97, int type) } /* apply the quirk with the given name */ -static int apply_quirk_str(struct snd_ac97 *ac97, const char *typestr) +static int apply_quirk_str(ac97_t *ac97, const char *typestr) { int i; struct quirk_table *q; @@ -2551,7 +2539,7 @@ static int apply_quirk_str(struct snd_ac97 *ac97, const char *typestr) * Returns zero if successful, or a negative error code on failure. */ -int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, const char *override) +int snd_ac97_tune_hardware(ac97_t *ac97, struct ac97_quirk *quirk, const char *override) { int result; diff --git a/trunk/sound/pci/ac97/ac97_local.h b/trunk/sound/pci/ac97/ac97_local.h index a6244c720a1d..536a4d4793af 100644 --- a/trunk/sound/pci/ac97/ac97_local.h +++ b/trunk/sound/pci/ac97/ac97_local.h @@ -36,16 +36,6 @@ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), .info = snd_ac97_info_volsw, \ .get = snd_ac97_get_volsw, .put = snd_ac97_put_volsw, \ .private_value = (reg) | ((shift_left) << 8) | ((shift_right) << 12) | ((mask) << 16) | ((invert) << 24) } - -/* enum control */ -struct ac97_enum { - unsigned char reg; - unsigned char shift_l; - unsigned char shift_r; - unsigned short mask; - const char **texts; -}; - #define AC97_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmask, xtexts) \ { .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \ .mask = xmask, .texts = xtexts } @@ -57,33 +47,34 @@ struct ac97_enum { .private_value = (unsigned long)&xenum } /* ac97_codec.c */ -extern const struct snd_kcontrol_new snd_ac97_controls_3d[]; -extern const struct snd_kcontrol_new snd_ac97_controls_spdif[]; -struct snd_kcontrol *snd_ac97_cnew(const struct snd_kcontrol_new *_template, struct snd_ac97 * ac97); -void snd_ac97_get_name(struct snd_ac97 *ac97, unsigned int id, char *name, int modem); -int snd_ac97_info_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_ac97_get_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_ac97_put_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_ac97_try_bit(struct snd_ac97 * ac97, int reg, int bit); -int snd_ac97_remove_ctl(struct snd_ac97 *ac97, const char *name, const char *suffix); -int snd_ac97_rename_ctl(struct snd_ac97 *ac97, const char *src, const char *dst, const char *suffix); -int snd_ac97_swap_ctl(struct snd_ac97 *ac97, const char *s1, const char *s2, const char *suffix); -void snd_ac97_rename_vol_ctl(struct snd_ac97 *ac97, const char *src, const char *dst); -void snd_ac97_restore_status(struct snd_ac97 *ac97); -void snd_ac97_restore_iec958(struct snd_ac97 *ac97); -int snd_ac97_info_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_ac97_get_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_ac97_put_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); +extern const char *snd_ac97_stereo_enhancements[]; +extern const snd_kcontrol_new_t snd_ac97_controls_3d[]; +extern const snd_kcontrol_new_t snd_ac97_controls_spdif[]; +snd_kcontrol_t *snd_ac97_cnew(const snd_kcontrol_new_t *_template, ac97_t * ac97); +void snd_ac97_get_name(ac97_t *ac97, unsigned int id, char *name, int modem); +int snd_ac97_info_volsw(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo); +int snd_ac97_get_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); +int snd_ac97_put_volsw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); +int snd_ac97_try_bit(ac97_t * ac97, int reg, int bit); +int snd_ac97_remove_ctl(ac97_t *ac97, const char *name, const char *suffix); +int snd_ac97_rename_ctl(ac97_t *ac97, const char *src, const char *dst, const char *suffix); +int snd_ac97_swap_ctl(ac97_t *ac97, const char *s1, const char *s2, const char *suffix); +void snd_ac97_rename_vol_ctl(ac97_t *ac97, const char *src, const char *dst); +void snd_ac97_restore_status(ac97_t *ac97); +void snd_ac97_restore_iec958(ac97_t *ac97); +int snd_ac97_info_enum_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo); +int snd_ac97_get_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); +int snd_ac97_put_enum_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); -int snd_ac97_update_bits_nolock(struct snd_ac97 *ac97, unsigned short reg, +int snd_ac97_update_bits_nolock(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value); /* ac97_proc.c */ #ifdef CONFIG_PROC_FS -void snd_ac97_bus_proc_init(struct snd_ac97_bus * ac97); -void snd_ac97_bus_proc_done(struct snd_ac97_bus * ac97); -void snd_ac97_proc_init(struct snd_ac97 * ac97); -void snd_ac97_proc_done(struct snd_ac97 * ac97); +void snd_ac97_bus_proc_init(ac97_bus_t * ac97); +void snd_ac97_bus_proc_done(ac97_bus_t * ac97); +void snd_ac97_proc_init(ac97_t * ac97); +void snd_ac97_proc_done(ac97_t * ac97); #else #define snd_ac97_bus_proc_init(ac97_bus_t) do { } while (0) #define snd_ac97_bus_proc_done(ac97_bus_t) do { } while (0) diff --git a/trunk/sound/pci/ac97/ac97_patch.c b/trunk/sound/pci/ac97/ac97_patch.c index 4aa5fdc5688e..de1c72ad2c6b 100644 --- a/trunk/sound/pci/ac97/ac97_patch.c +++ b/trunk/sound/pci/ac97/ac97_patch.c @@ -39,7 +39,7 @@ * Chip specific initialization */ -static int patch_build_controls(struct snd_ac97 * ac97, const struct snd_kcontrol_new *controls, int count) +static int patch_build_controls(ac97_t * ac97, const snd_kcontrol_new_t *controls, int count) { int idx, err; @@ -50,7 +50,7 @@ static int patch_build_controls(struct snd_ac97 * ac97, const struct snd_kcontro } /* set to the page, update bits and restore the page */ -static int ac97_update_bits_page(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value, unsigned short page) +static int ac97_update_bits_page(ac97_t *ac97, unsigned short reg, unsigned short mask, unsigned short value, unsigned short page) { unsigned short page_save; int ret; @@ -67,7 +67,7 @@ static int ac97_update_bits_page(struct snd_ac97 *ac97, unsigned short reg, unsi /* * shared line-in/mic controls */ -static int ac97_enum_text_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo, +static int ac97_enum_text_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo, const char **texts, unsigned int nums) { uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -79,23 +79,23 @@ static int ac97_enum_text_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int ac97_surround_jack_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int ac97_surround_jack_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static const char *texts[] = { "Shared", "Independent" }; return ac97_enum_text_info(kcontrol, uinfo, texts, 2); } -static int ac97_surround_jack_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ac97_surround_jack_mode_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = ac97->indep_surround; return 0; } -static int ac97_surround_jack_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ac97_surround_jack_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned char indep = !!ucontrol->value.enumerated.item[0]; if (indep != ac97->indep_surround) { @@ -107,7 +107,7 @@ static int ac97_surround_jack_mode_put(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int ac97_channel_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int ac97_channel_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static const char *texts[] = { "2ch", "4ch", "6ch" }; if (kcontrol->private_value) @@ -115,17 +115,17 @@ static int ac97_channel_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return ac97_enum_text_info(kcontrol, uinfo, texts, 3); } -static int ac97_channel_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ac97_channel_mode_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = ac97->channel_mode; return 0; } -static int ac97_channel_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ac97_channel_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned char mode = ucontrol->value.enumerated.item[0]; if (mode != ac97->channel_mode) { @@ -163,22 +163,22 @@ static int ac97_channel_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e .private_value = 1, \ } -static inline int is_surround_on(struct snd_ac97 *ac97) +static inline int is_surround_on(ac97_t *ac97) { return ac97->channel_mode >= 1; } -static inline int is_clfe_on(struct snd_ac97 *ac97) +static inline int is_clfe_on(ac97_t *ac97) { return ac97->channel_mode >= 2; } -static inline int is_shared_linein(struct snd_ac97 *ac97) +static inline int is_shared_linein(ac97_t *ac97) { return ! ac97->indep_surround && is_surround_on(ac97); } -static inline int is_shared_micin(struct snd_ac97 *ac97) +static inline int is_shared_micin(ac97_t *ac97) { return ! ac97->indep_surround && is_clfe_on(ac97); } @@ -187,7 +187,7 @@ static inline int is_shared_micin(struct snd_ac97 *ac97) /* The following snd_ac97_ymf753_... items added by David Shust (dshust@shustring.com) */ /* It is possible to indicate to the Yamaha YMF753 the type of speakers being used. */ -static int snd_ac97_ymf753_info_speaker(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ymf753_info_speaker(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[3] = { "Standard", "Small", "Smaller" @@ -202,9 +202,9 @@ static int snd_ac97_ymf753_info_speaker(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_ac97_ymf753_get_speaker(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ymf753_get_speaker(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_YMF753_3D_MODE_SEL]; @@ -215,9 +215,9 @@ static int snd_ac97_ymf753_get_speaker(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_ac97_ymf753_put_speaker(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ymf753_put_speaker(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; if (ucontrol->value.enumerated.item[0] > 2) @@ -226,7 +226,7 @@ static int snd_ac97_ymf753_put_speaker(struct snd_kcontrol *kcontrol, struct snd return snd_ac97_update(ac97, AC97_YMF753_3D_MODE_SEL, val); } -static const struct snd_kcontrol_new snd_ac97_ymf753_controls_speaker = +static const snd_kcontrol_new_t snd_ac97_ymf753_controls_speaker = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "3D Control - Speaker", @@ -236,7 +236,7 @@ static const struct snd_kcontrol_new snd_ac97_ymf753_controls_speaker = }; /* It is possible to indicate to the Yamaha YMF753 the source to direct to the S/PDIF output. */ -static int snd_ac97_ymf753_spdif_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ymf753_spdif_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[2] = { "AC-Link", "A/D Converter" }; @@ -249,9 +249,9 @@ static int snd_ac97_ymf753_spdif_source_info(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_ac97_ymf753_spdif_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ymf753_spdif_source_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_YMF753_DIT_CTRL2]; @@ -259,9 +259,9 @@ static int snd_ac97_ymf753_spdif_source_get(struct snd_kcontrol *kcontrol, struc return 0; } -static int snd_ac97_ymf753_spdif_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ymf753_spdif_source_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; if (ucontrol->value.enumerated.item[0] > 1) @@ -274,7 +274,7 @@ static int snd_ac97_ymf753_spdif_source_put(struct snd_kcontrol *kcontrol, struc The YMF753 will output the S/PDIF signal to pin 43, 47 (EAPD), or 48. By default, no output pin is selected, and the S/PDIF signal is not output. There is also a bit to mute S/PDIF output in a vendor-specific register. */ -static int snd_ac97_ymf753_spdif_output_pin_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ymf753_spdif_output_pin_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[3] = { "Disabled", "Pin 43", "Pin 48" }; @@ -287,9 +287,9 @@ static int snd_ac97_ymf753_spdif_output_pin_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ac97_ymf753_spdif_output_pin_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ymf753_spdif_output_pin_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_YMF753_DIT_CTRL2]; @@ -297,9 +297,9 @@ static int snd_ac97_ymf753_spdif_output_pin_get(struct snd_kcontrol *kcontrol, s return 0; } -static int snd_ac97_ymf753_spdif_output_pin_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ymf753_spdif_output_pin_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; if (ucontrol->value.enumerated.item[0] > 2) @@ -311,7 +311,7 @@ static int snd_ac97_ymf753_spdif_output_pin_put(struct snd_kcontrol *kcontrol, s snd_ac97_write_cache(ac97, 0x62, snd_ac97_read(ac97, 0x62) | 0x0008); */ } -static const struct snd_kcontrol_new snd_ac97_ymf753_controls_spdif[3] = { +static const snd_kcontrol_new_t snd_ac97_ymf753_controls_spdif[3] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", @@ -329,9 +329,9 @@ static const struct snd_kcontrol_new snd_ac97_ymf753_controls_spdif[3] = { AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",NONE,NONE) "Mute", AC97_YMF753_DIT_CTRL2, 2, 1, 1) }; -static int patch_yamaha_ymf753_3d(struct snd_ac97 * ac97) +static int patch_yamaha_ymf753_3d(ac97_t * ac97) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; int err; if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0) @@ -345,7 +345,7 @@ static int patch_yamaha_ymf753_3d(struct snd_ac97 * ac97) return 0; } -static int patch_yamaha_ymf753_post_spdif(struct snd_ac97 * ac97) +static int patch_yamaha_ymf753_post_spdif(ac97_t * ac97) { int err; @@ -359,7 +359,7 @@ static struct snd_ac97_build_ops patch_yamaha_ymf753_ops = { .build_post_spdif = patch_yamaha_ymf753_post_spdif }; -int patch_yamaha_ymf753(struct snd_ac97 * ac97) +int patch_yamaha_ymf753(ac97_t * ac97) { /* Patch for Yamaha YMF753, Copyright (c) by David Shust, dshust@shustring.com. This chip has nonstandard and extended behaviour with regard to its S/PDIF output. @@ -380,12 +380,12 @@ int patch_yamaha_ymf753(struct snd_ac97 * ac97) * added support for WM9705,WM9708,WM9709,WM9710,WM9711,WM9712 and WM9717. */ -static const struct snd_kcontrol_new wm97xx_snd_ac97_controls[] = { +static const snd_kcontrol_new_t wm97xx_snd_ac97_controls[] = { AC97_DOUBLE("Front Playback Volume", AC97_WM97XX_FMIXER_VOL, 8, 0, 31, 1), AC97_SINGLE("Front Playback Switch", AC97_WM97XX_FMIXER_VOL, 15, 1, 1), }; -static int patch_wolfson_wm9703_specific(struct snd_ac97 * ac97) +static int patch_wolfson_wm9703_specific(ac97_t * ac97) { /* This is known to work for the ViewSonic ViewPad 1000 * Randolph Bentson <bentson@holmsjoen.com> @@ -405,13 +405,13 @@ static struct snd_ac97_build_ops patch_wolfson_wm9703_ops = { .build_specific = patch_wolfson_wm9703_specific, }; -int patch_wolfson03(struct snd_ac97 * ac97) +int patch_wolfson03(ac97_t * ac97) { ac97->build_ops = &patch_wolfson_wm9703_ops; return 0; } -static const struct snd_kcontrol_new wm9704_snd_ac97_controls[] = { +static const snd_kcontrol_new_t wm9704_snd_ac97_controls[] = { AC97_DOUBLE("Front Playback Volume", AC97_WM97XX_FMIXER_VOL, 8, 0, 31, 1), AC97_SINGLE("Front Playback Switch", AC97_WM97XX_FMIXER_VOL, 15, 1, 1), AC97_DOUBLE("Rear Playback Volume", AC97_WM9704_RMIXER_VOL, 8, 0, 31, 1), @@ -420,7 +420,7 @@ AC97_DOUBLE("Rear DAC Volume", AC97_WM9704_RPCM_VOL, 8, 0, 31, 1), AC97_DOUBLE("Surround Volume", AC97_SURROUND_MASTER, 8, 0, 31, 1), }; -static int patch_wolfson_wm9704_specific(struct snd_ac97 * ac97) +static int patch_wolfson_wm9704_specific(ac97_t * ac97) { int err, i; for (i = 0; i < ARRAY_SIZE(wm9704_snd_ac97_controls); i++) { @@ -436,14 +436,14 @@ static struct snd_ac97_build_ops patch_wolfson_wm9704_ops = { .build_specific = patch_wolfson_wm9704_specific, }; -int patch_wolfson04(struct snd_ac97 * ac97) +int patch_wolfson04(ac97_t * ac97) { /* WM9704M/9704Q */ ac97->build_ops = &patch_wolfson_wm9704_ops; return 0; } -static int patch_wolfson_wm9705_specific(struct snd_ac97 * ac97) +static int patch_wolfson_wm9705_specific(ac97_t * ac97) { int err, i; for (i = 0; i < ARRAY_SIZE(wm97xx_snd_ac97_controls); i++) { @@ -458,7 +458,7 @@ static struct snd_ac97_build_ops patch_wolfson_wm9705_ops = { .build_specific = patch_wolfson_wm9705_specific, }; -int patch_wolfson05(struct snd_ac97 * ac97) +int patch_wolfson05(ac97_t * ac97) { /* WM9705, WM9710 */ ac97->build_ops = &patch_wolfson_wm9705_ops; @@ -490,7 +490,7 @@ AC97_ENUM_DOUBLE(AC97_REC_SEL, 8, 0, 8, wm9711_rec_sel), AC97_ENUM_SINGLE(AC97_PCI_SVID, 5, 2, wm9711_ng_type), }; -static const struct snd_kcontrol_new wm9711_snd_ac97_controls[] = { +static const snd_kcontrol_new_t wm9711_snd_ac97_controls[] = { AC97_SINGLE("ALC Target Volume", AC97_CODEC_CLASS_REV, 12, 15, 0), AC97_SINGLE("ALC Hold Time", AC97_CODEC_CLASS_REV, 8, 15, 0), AC97_SINGLE("ALC Decay Time", AC97_CODEC_CLASS_REV, 4, 15, 0), @@ -568,7 +568,7 @@ AC97_SINGLE("Headphone ZC Switch", AC97_HEADPHONE, 7, 1, 0), AC97_SINGLE("Mono ZC Switch", AC97_MASTER_MONO, 7, 1, 0), }; -static int patch_wolfson_wm9711_specific(struct snd_ac97 * ac97) +static int patch_wolfson_wm9711_specific(ac97_t * ac97) { int err, i; @@ -589,7 +589,7 @@ static struct snd_ac97_build_ops patch_wolfson_wm9711_ops = { .build_specific = patch_wolfson_wm9711_specific, }; -int patch_wolfson11(struct snd_ac97 * ac97) +int patch_wolfson11(ac97_t * ac97) { /* WM9711, WM9712 */ ac97->build_ops = &patch_wolfson_wm9711_ops; @@ -636,7 +636,7 @@ AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 15, 2, wm9713_base), AC97_ENUM_SINGLE(AC97_PCI_SVID, 5, 2, wm9713_ng_type), }; -static const struct snd_kcontrol_new wm13_snd_ac97_controls[] = { +static const snd_kcontrol_new_t wm13_snd_ac97_controls[] = { AC97_DOUBLE("Line In Volume", AC97_PC_BEEP, 8, 0, 31, 1), AC97_SINGLE("Line In to Headphone Switch", AC97_PC_BEEP, 15, 1, 1), AC97_SINGLE("Line In to Master Switch", AC97_PC_BEEP, 14, 1, 1), @@ -728,14 +728,14 @@ AC97_SINGLE("Bass Volume", AC97_GENERAL_PURPOSE, 8, 15, 1), AC97_SINGLE("Tone Volume", AC97_GENERAL_PURPOSE, 0, 15, 1), }; -static const struct snd_kcontrol_new wm13_snd_ac97_controls_3d[] = { +static const snd_kcontrol_new_t wm13_snd_ac97_controls_3d[] = { AC97_ENUM("Inv Input Mux", wm9713_enum[11]), AC97_SINGLE("3D Upper Cut-off Switch", AC97_REC_GAIN_MIC, 5, 1, 0), AC97_SINGLE("3D Lower Cut-off Switch", AC97_REC_GAIN_MIC, 4, 1, 0), AC97_SINGLE("3D Depth", AC97_REC_GAIN_MIC, 0, 15, 1), }; -static int patch_wolfson_wm9713_3d (struct snd_ac97 * ac97) +static int patch_wolfson_wm9713_3d (ac97_t * ac97) { int err, i; @@ -746,7 +746,7 @@ static int patch_wolfson_wm9713_3d (struct snd_ac97 * ac97) return 0; } -static int patch_wolfson_wm9713_specific(struct snd_ac97 * ac97) +static int patch_wolfson_wm9713_specific(ac97_t * ac97) { int err, i; @@ -765,13 +765,13 @@ static int patch_wolfson_wm9713_specific(struct snd_ac97 * ac97) } #ifdef CONFIG_PM -static void patch_wolfson_wm9713_suspend (struct snd_ac97 * ac97) +static void patch_wolfson_wm9713_suspend (ac97_t * ac97) { snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xfeff); snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xffff); } -static void patch_wolfson_wm9713_resume (struct snd_ac97 * ac97) +static void patch_wolfson_wm9713_resume (ac97_t * ac97) { snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xda00); snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0x3810); @@ -788,7 +788,7 @@ static struct snd_ac97_build_ops patch_wolfson_wm9713_ops = { #endif }; -int patch_wolfson13(struct snd_ac97 * ac97) +int patch_wolfson13(ac97_t * ac97) { /* WM9713, WM9714 */ ac97->build_ops = &patch_wolfson_wm9713_ops; @@ -808,7 +808,7 @@ int patch_wolfson13(struct snd_ac97 * ac97) /* * Tritech codec */ -int patch_tritech_tr28028(struct snd_ac97 * ac97) +int patch_tritech_tr28028(ac97_t * ac97) { snd_ac97_write_cache(ac97, 0x26, 0x0300); snd_ac97_write_cache(ac97, 0x26, 0x0000); @@ -820,9 +820,9 @@ int patch_tritech_tr28028(struct snd_ac97 * ac97) /* * Sigmatel STAC97xx codecs */ -static int patch_sigmatel_stac9700_3d(struct snd_ac97 * ac97) +static int patch_sigmatel_stac9700_3d(ac97_t * ac97) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; int err; if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0) @@ -833,9 +833,9 @@ static int patch_sigmatel_stac9700_3d(struct snd_ac97 * ac97) return 0; } -static int patch_sigmatel_stac9708_3d(struct snd_ac97 * ac97) +static int patch_sigmatel_stac9708_3d(ac97_t * ac97) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; int err; if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0) @@ -850,18 +850,18 @@ static int patch_sigmatel_stac9708_3d(struct snd_ac97 * ac97) return 0; } -static const struct snd_kcontrol_new snd_ac97_sigmatel_4speaker = +static const snd_kcontrol_new_t snd_ac97_sigmatel_4speaker = AC97_SINGLE("Sigmatel 4-Speaker Stereo Playback Switch", AC97_SIGMATEL_DAC2INVERT, 2, 1, 0); -static const struct snd_kcontrol_new snd_ac97_sigmatel_phaseinvert = +static const snd_kcontrol_new_t snd_ac97_sigmatel_phaseinvert = AC97_SINGLE("Sigmatel Surround Phase Inversion Playback Switch", AC97_SIGMATEL_DAC2INVERT, 3, 1, 0); -static const struct snd_kcontrol_new snd_ac97_sigmatel_controls[] = { +static const snd_kcontrol_new_t snd_ac97_sigmatel_controls[] = { AC97_SINGLE("Sigmatel DAC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 1, 1, 0), AC97_SINGLE("Sigmatel ADC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 0, 1, 0) }; -static int patch_sigmatel_stac97xx_specific(struct snd_ac97 * ac97) +static int patch_sigmatel_stac97xx_specific(ac97_t * ac97) { int err; @@ -886,15 +886,15 @@ static struct snd_ac97_build_ops patch_sigmatel_stac9700_ops = { .build_specific = patch_sigmatel_stac97xx_specific }; -int patch_sigmatel_stac9700(struct snd_ac97 * ac97) +int patch_sigmatel_stac9700(ac97_t * ac97) { ac97->build_ops = &patch_sigmatel_stac9700_ops; return 0; } -static int snd_ac97_stac9708_put_bias(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_stac9708_put_bias(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int err; down(&ac97->page_mutex); @@ -906,7 +906,7 @@ static int snd_ac97_stac9708_put_bias(struct snd_kcontrol *kcontrol, struct snd_ return err; } -static const struct snd_kcontrol_new snd_ac97_stac9708_bias_control = { +static const snd_kcontrol_new_t snd_ac97_stac9708_bias_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Sigmatel Output Bias Switch", .info = snd_ac97_info_volsw, @@ -915,7 +915,7 @@ static const struct snd_kcontrol_new snd_ac97_stac9708_bias_control = { .private_value = AC97_SINGLE_VALUE(AC97_SIGMATEL_BIAS2, 4, 1, 0), }; -static int patch_sigmatel_stac9708_specific(struct snd_ac97 *ac97) +static int patch_sigmatel_stac9708_specific(ac97_t *ac97) { int err; @@ -930,7 +930,7 @@ static struct snd_ac97_build_ops patch_sigmatel_stac9708_ops = { .build_specific = patch_sigmatel_stac9708_specific }; -int patch_sigmatel_stac9708(struct snd_ac97 * ac97) +int patch_sigmatel_stac9708(ac97_t * ac97) { unsigned int codec72, codec6c; @@ -956,7 +956,7 @@ int patch_sigmatel_stac9708(struct snd_ac97 * ac97) return 0; } -int patch_sigmatel_stac9721(struct snd_ac97 * ac97) +int patch_sigmatel_stac9721(ac97_t * ac97) { ac97->build_ops = &patch_sigmatel_stac9700_ops; if (snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG) == 0) { @@ -970,7 +970,7 @@ int patch_sigmatel_stac9721(struct snd_ac97 * ac97) return 0; } -int patch_sigmatel_stac9744(struct snd_ac97 * ac97) +int patch_sigmatel_stac9744(ac97_t * ac97) { // patch for SigmaTel ac97->build_ops = &patch_sigmatel_stac9700_ops; @@ -982,7 +982,7 @@ int patch_sigmatel_stac9744(struct snd_ac97 * ac97) return 0; } -int patch_sigmatel_stac9756(struct snd_ac97 * ac97) +int patch_sigmatel_stac9756(ac97_t * ac97) { // patch for SigmaTel ac97->build_ops = &patch_sigmatel_stac9700_ops; @@ -994,7 +994,7 @@ int patch_sigmatel_stac9756(struct snd_ac97 * ac97) return 0; } -static int snd_ac97_stac9758_output_jack_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_stac9758_output_jack_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[5] = { "Input/Disabled", "Front Output", "Rear Output", "Center/LFE Output", "Mixer Output" }; @@ -1008,9 +1008,9 @@ static int snd_ac97_stac9758_output_jack_info(struct snd_kcontrol *kcontrol, str return 0; } -static int snd_ac97_stac9758_output_jack_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_stac9758_output_jack_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value; unsigned short val; @@ -1022,9 +1022,9 @@ static int snd_ac97_stac9758_output_jack_get(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_ac97_stac9758_output_jack_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_stac9758_output_jack_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value; unsigned short val; @@ -1038,7 +1038,7 @@ static int snd_ac97_stac9758_output_jack_put(struct snd_kcontrol *kcontrol, stru 7 << shift, val << shift, 0); } -static int snd_ac97_stac9758_input_jack_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_stac9758_input_jack_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[7] = { "Mic2 Jack", "Mic1 Jack", "Line In Jack", "Front Jack", "Rear Jack", "Center/LFE Jack", "Mute" }; @@ -1052,9 +1052,9 @@ static int snd_ac97_stac9758_input_jack_info(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_ac97_stac9758_input_jack_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_stac9758_input_jack_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value; unsigned short val; @@ -1063,16 +1063,16 @@ static int snd_ac97_stac9758_input_jack_get(struct snd_kcontrol *kcontrol, struc return 0; } -static int snd_ac97_stac9758_input_jack_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_stac9758_input_jack_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value; return ac97_update_bits_page(ac97, AC97_SIGMATEL_INSEL, 7 << shift, ucontrol->value.enumerated.item[0] << shift, 0); } -static int snd_ac97_stac9758_phonesel_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_stac9758_phonesel_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[3] = { "None", "Front Jack", "Rear Jack" }; @@ -1085,17 +1085,17 @@ static int snd_ac97_stac9758_phonesel_info(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_ac97_stac9758_phonesel_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_stac9758_phonesel_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = ac97->regs[AC97_SIGMATEL_IOMISC] & 3; return 0; } -static int snd_ac97_stac9758_phonesel_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_stac9758_phonesel_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); return ac97_update_bits_page(ac97, AC97_SIGMATEL_IOMISC, 3, ucontrol->value.enumerated.item[0], 0); @@ -1113,7 +1113,7 @@ static int snd_ac97_stac9758_phonesel_put(struct snd_kcontrol *kcontrol, struct .get = snd_ac97_stac9758_input_jack_get, \ .put = snd_ac97_stac9758_input_jack_put, \ .private_value = shift } -static const struct snd_kcontrol_new snd_ac97_sigmatel_stac9758_controls[] = { +static const snd_kcontrol_new_t snd_ac97_sigmatel_stac9758_controls[] = { STAC9758_OUTPUT_JACK("Mic1 Jack", 1), STAC9758_OUTPUT_JACK("LineIn Jack", 4), STAC9758_OUTPUT_JACK("Front Jack", 7), @@ -1132,7 +1132,7 @@ static const struct snd_kcontrol_new snd_ac97_sigmatel_stac9758_controls[] = { AC97_SINGLE("Headphone +3dB Boost", AC97_SIGMATEL_IOMISC, 8, 1, 0) }; -static int patch_sigmatel_stac9758_specific(struct snd_ac97 *ac97) +static int patch_sigmatel_stac9758_specific(ac97_t *ac97) { int err; @@ -1159,7 +1159,7 @@ static struct snd_ac97_build_ops patch_sigmatel_stac9758_ops = { .build_specific = patch_sigmatel_stac9758_specific }; -int patch_sigmatel_stac9758(struct snd_ac97 * ac97) +int patch_sigmatel_stac9758(ac97_t * ac97) { static unsigned short regs[4] = { AC97_SIGMATEL_OUTSEL, @@ -1202,12 +1202,12 @@ int patch_sigmatel_stac9758(struct snd_ac97 * ac97) /* * Cirrus Logic CS42xx codecs */ -static const struct snd_kcontrol_new snd_ac97_cirrus_controls_spdif[2] = { +static const snd_kcontrol_new_t snd_ac97_cirrus_controls_spdif[2] = { AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CSR_SPDIF, 15, 1, 0), AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA", AC97_CSR_ACMODE, 0, 3, 0) }; -static int patch_cirrus_build_spdif(struct snd_ac97 * ac97) +static int patch_cirrus_build_spdif(ac97_t * ac97) { int err; @@ -1233,7 +1233,7 @@ static struct snd_ac97_build_ops patch_cirrus_ops = { .build_spdif = patch_cirrus_build_spdif }; -int patch_cirrus_spdif(struct snd_ac97 * ac97) +int patch_cirrus_spdif(ac97_t * ac97) { /* Basically, the cs4201/cs4205/cs4297a has non-standard sp/dif registers. WHY CAN'T ANYONE FOLLOW THE BLOODY SPEC? *sigh* @@ -1254,7 +1254,7 @@ int patch_cirrus_spdif(struct snd_ac97 * ac97) return 0; } -int patch_cirrus_cs4299(struct snd_ac97 * ac97) +int patch_cirrus_cs4299(ac97_t * ac97) { /* force the detection of PC Beep */ ac97->flags |= AC97_HAS_PC_BEEP; @@ -1265,11 +1265,11 @@ int patch_cirrus_cs4299(struct snd_ac97 * ac97) /* * Conexant codecs */ -static const struct snd_kcontrol_new snd_ac97_conexant_controls_spdif[1] = { +static const snd_kcontrol_new_t snd_ac97_conexant_controls_spdif[1] = { AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CXR_AUDIO_MISC, 3, 1, 0), }; -static int patch_conexant_build_spdif(struct snd_ac97 * ac97) +static int patch_conexant_build_spdif(ac97_t * ac97) { int err; @@ -1290,7 +1290,7 @@ static struct snd_ac97_build_ops patch_conexant_ops = { .build_spdif = patch_conexant_build_spdif }; -int patch_conexant(struct snd_ac97 * ac97) +int patch_conexant(ac97_t * ac97) { ac97->build_ops = &patch_conexant_ops; ac97->flags |= AC97_CX_SPDIF; @@ -1303,7 +1303,7 @@ int patch_conexant(struct snd_ac97 * ac97) * Analog Device AD18xx, AD19xx codecs */ #ifdef CONFIG_PM -static void ad18xx_resume(struct snd_ac97 *ac97) +static void ad18xx_resume(ac97_t *ac97) { static unsigned short setup_regs[] = { AC97_AD_MISC, AC97_AD_SERIAL_CFG, AC97_AD_JACK_SPDIF, @@ -1367,7 +1367,7 @@ static void ad18xx_resume(struct snd_ac97 *ac97) } #endif -int patch_ad1819(struct snd_ac97 * ac97) +int patch_ad1819(ac97_t * ac97) { unsigned short scfg; @@ -1377,7 +1377,7 @@ int patch_ad1819(struct snd_ac97 * ac97) return 0; } -static unsigned short patch_ad1881_unchained(struct snd_ac97 * ac97, int idx, unsigned short mask) +static unsigned short patch_ad1881_unchained(ac97_t * ac97, int idx, unsigned short mask) { unsigned short val; @@ -1393,7 +1393,7 @@ static unsigned short patch_ad1881_unchained(struct snd_ac97 * ac97, int idx, un return mask; } -static int patch_ad1881_chained1(struct snd_ac97 * ac97, int idx, unsigned short codec_bits) +static int patch_ad1881_chained1(ac97_t * ac97, int idx, unsigned short codec_bits) { static int cfg_bits[3] = { 1<<12, 1<<14, 1<<13 }; unsigned short val; @@ -1411,7 +1411,7 @@ static int patch_ad1881_chained1(struct snd_ac97 * ac97, int idx, unsigned short return 1; } -static void patch_ad1881_chained(struct snd_ac97 * ac97, int unchained_idx, int cidx1, int cidx2) +static void patch_ad1881_chained(ac97_t * ac97, int unchained_idx, int cidx1, int cidx2) { // already detected? if (ac97->spec.ad18xx.unchained[cidx1] || ac97->spec.ad18xx.chained[cidx1]) @@ -1441,7 +1441,7 @@ static struct snd_ac97_build_ops patch_ad1881_build_ops = { #endif }; -int patch_ad1881(struct snd_ac97 * ac97) +int patch_ad1881(ac97_t * ac97) { static const char cfg_idxs[3][2] = { {2, 1}, @@ -1500,7 +1500,7 @@ int patch_ad1881(struct snd_ac97 * ac97) return 0; } -static const struct snd_kcontrol_new snd_ac97_controls_ad1885[] = { +static const snd_kcontrol_new_t snd_ac97_controls_ad1885[] = { AC97_SINGLE("Digital Mono Direct", AC97_AD_MISC, 11, 1, 0), /* AC97_SINGLE("Digital Audio Mode", AC97_AD_MISC, 12, 1, 0), */ /* seems problematic */ AC97_SINGLE("Low Power Mixer", AC97_AD_MISC, 14, 1, 0), @@ -1509,7 +1509,7 @@ static const struct snd_kcontrol_new snd_ac97_controls_ad1885[] = { AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 8, 1, 1), /* inverted */ }; -static int patch_ad1885_specific(struct snd_ac97 * ac97) +static int patch_ad1885_specific(ac97_t * ac97) { int err; @@ -1525,7 +1525,7 @@ static struct snd_ac97_build_ops patch_ad1885_build_ops = { #endif }; -int patch_ad1885(struct snd_ac97 * ac97) +int patch_ad1885(ac97_t * ac97) { patch_ad1881(ac97); /* This is required to deal with the Intel D815EEAL2 */ @@ -1538,7 +1538,7 @@ int patch_ad1885(struct snd_ac97 * ac97) return 0; } -int patch_ad1886(struct snd_ac97 * ac97) +int patch_ad1886(ac97_t * ac97) { patch_ad1881(ac97); /* Presario700 workaround */ @@ -1569,7 +1569,7 @@ int patch_ad1886(struct snd_ac97 * ac97) #define AC97_AD198X_DACZ 0x8000 /* DAC zero-fill mode */ -static int snd_ac97_ad198x_spdif_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ad198x_spdif_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[2] = { "AC-Link", "A/D Converter" }; @@ -1582,9 +1582,9 @@ static int snd_ac97_ad198x_spdif_source_info(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_ac97_ad198x_spdif_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad198x_spdif_source_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_AD_SERIAL_CFG]; @@ -1592,9 +1592,9 @@ static int snd_ac97_ad198x_spdif_source_get(struct snd_kcontrol *kcontrol, struc return 0; } -static int snd_ac97_ad198x_spdif_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad198x_spdif_source_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; if (ucontrol->value.enumerated.item[0] > 1) @@ -1603,7 +1603,7 @@ static int snd_ac97_ad198x_spdif_source_put(struct snd_kcontrol *kcontrol, struc return snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x0004, val); } -static const struct snd_kcontrol_new snd_ac97_ad198x_spdif_source = { +static const snd_kcontrol_new_t snd_ac97_ad198x_spdif_source = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", .info = snd_ac97_ad198x_spdif_source_info, @@ -1611,17 +1611,17 @@ static const struct snd_kcontrol_new snd_ac97_ad198x_spdif_source = { .put = snd_ac97_ad198x_spdif_source_put, }; -static int patch_ad198x_post_spdif(struct snd_ac97 * ac97) +static int patch_ad198x_post_spdif(ac97_t * ac97) { return patch_build_controls(ac97, &snd_ac97_ad198x_spdif_source, 1); } -static const struct snd_kcontrol_new snd_ac97_ad1981x_jack_sense[] = { +static const snd_kcontrol_new_t snd_ac97_ad1981x_jack_sense[] = { AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 11, 1, 0), AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0), }; -static int patch_ad1981a_specific(struct snd_ac97 * ac97) +static int patch_ad1981a_specific(ac97_t * ac97) { return patch_build_controls(ac97, snd_ac97_ad1981x_jack_sense, ARRAY_SIZE(snd_ac97_ad1981x_jack_sense)); @@ -1635,16 +1635,12 @@ static struct snd_ac97_build_ops patch_ad1981a_build_ops = { #endif }; -static void check_ad1981_hp_jack_sense(struct snd_ac97 *ac97) +static void check_ad1981_hp_jack_sense(ac97_t *ac97) { u32 subid = ((u32)ac97->subsystem_vendor << 16) | ac97->subsystem_device; switch (subid) { - case 0x0e11005a: /* HP nc4000/4010 */ case 0x103c0890: /* HP nc6000 */ - case 0x103c0938: /* HP nc4220 */ case 0x103c099c: /* HP nx6110 */ - case 0x103c0944: /* HP nc6220 */ - case 0x103c0934: /* HP nc8220 */ case 0x103c006d: /* HP nx9105 */ case 0x17340088: /* FSC Scenic-W */ /* enable headphone jack sense */ @@ -1653,7 +1649,7 @@ static void check_ad1981_hp_jack_sense(struct snd_ac97 *ac97) } } -int patch_ad1981a(struct snd_ac97 *ac97) +int patch_ad1981a(ac97_t *ac97) { patch_ad1881(ac97); ac97->build_ops = &patch_ad1981a_build_ops; @@ -1663,10 +1659,10 @@ int patch_ad1981a(struct snd_ac97 *ac97) return 0; } -static const struct snd_kcontrol_new snd_ac97_ad198x_2cmic = +static const snd_kcontrol_new_t snd_ac97_ad198x_2cmic = AC97_SINGLE("Stereo Mic", AC97_AD_MISC, 6, 1, 0); -static int patch_ad1981b_specific(struct snd_ac97 *ac97) +static int patch_ad1981b_specific(ac97_t *ac97) { int err; @@ -1684,7 +1680,7 @@ static struct snd_ac97_build_ops patch_ad1981b_build_ops = { #endif }; -int patch_ad1981b(struct snd_ac97 *ac97) +int patch_ad1981b(ac97_t *ac97) { patch_ad1881(ac97); ac97->build_ops = &patch_ad1981b_build_ops; @@ -1694,7 +1690,7 @@ int patch_ad1981b(struct snd_ac97 *ac97) return 0; } -static int snd_ac97_ad1888_lohpsel_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ad1888_lohpsel_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1703,9 +1699,9 @@ static int snd_ac97_ad1888_lohpsel_info(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_ac97_ad1888_lohpsel_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad1888_lohpsel_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_AD_MISC]; @@ -1713,9 +1709,9 @@ static int snd_ac97_ad1888_lohpsel_get(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_ac97_ad1888_lohpsel_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad1888_lohpsel_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = !ucontrol->value.integer.value[0] @@ -1724,7 +1720,7 @@ static int snd_ac97_ad1888_lohpsel_put(struct snd_kcontrol *kcontrol, struct snd AC97_AD198X_LOSEL | AC97_AD198X_HPSEL, val); } -static int snd_ac97_ad1888_downmix_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_ad1888_downmix_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[3] = {"Off", "6 -> 4", "6 -> 2"}; @@ -1737,9 +1733,9 @@ static int snd_ac97_ad1888_downmix_info(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_ac97_ad1888_downmix_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad1888_downmix_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t* ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_AD_MISC]; @@ -1750,9 +1746,9 @@ static int snd_ac97_ad1888_downmix_get(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_ac97_ad1888_downmix_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_ad1888_downmix_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; if (ucontrol->value.enumerated.item[0] > 2) @@ -1766,7 +1762,7 @@ static int snd_ac97_ad1888_downmix_put(struct snd_kcontrol *kcontrol, struct snd AC97_AD198X_DMIX0 | AC97_AD198X_DMIX1, val); } -static void ad1888_update_jacks(struct snd_ac97 *ac97) +static void ad1888_update_jacks(ac97_t *ac97) { unsigned short val = 0; if (! is_shared_linein(ac97)) @@ -1777,7 +1773,7 @@ static void ad1888_update_jacks(struct snd_ac97 *ac97) snd_ac97_update_bits(ac97, AC97_AD_MISC, (1 << 11) | (1 << 12), val); } -static const struct snd_kcontrol_new snd_ac97_ad1888_controls[] = { +static const snd_kcontrol_new_t snd_ac97_ad1888_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Exchange Front/Surround", @@ -1800,7 +1796,7 @@ static const struct snd_kcontrol_new snd_ac97_ad1888_controls[] = { AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0), }; -static int patch_ad1888_specific(struct snd_ac97 *ac97) +static int patch_ad1888_specific(ac97_t *ac97) { /* rename 0x04 as "Master" and 0x02 as "Master Surround" */ snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Master Surround Playback"); @@ -1817,7 +1813,7 @@ static struct snd_ac97_build_ops patch_ad1888_build_ops = { .update_jacks = ad1888_update_jacks, }; -int patch_ad1888(struct snd_ac97 * ac97) +int patch_ad1888(ac97_t * ac97) { unsigned short misc; @@ -1837,7 +1833,7 @@ int patch_ad1888(struct snd_ac97 * ac97) return 0; } -static int patch_ad1980_specific(struct snd_ac97 *ac97) +static int patch_ad1980_specific(ac97_t *ac97) { int err; @@ -1855,25 +1851,25 @@ static struct snd_ac97_build_ops patch_ad1980_build_ops = { .update_jacks = ad1888_update_jacks, }; -int patch_ad1980(struct snd_ac97 * ac97) +int patch_ad1980(ac97_t * ac97) { patch_ad1888(ac97); ac97->build_ops = &patch_ad1980_build_ops; return 0; } -static const struct snd_kcontrol_new snd_ac97_ad1985_controls[] = { +static const snd_kcontrol_new_t snd_ac97_ad1985_controls[] = { AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0) }; -static void ad1985_update_jacks(struct snd_ac97 *ac97) +static void ad1985_update_jacks(ac97_t *ac97) { ad1888_update_jacks(ac97); snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 1 << 9, is_shared_micin(ac97) ? 0 : 1 << 9); } -static int patch_ad1985_specific(struct snd_ac97 *ac97) +static int patch_ad1985_specific(ac97_t *ac97) { int err; @@ -1891,7 +1887,7 @@ static struct snd_ac97_build_ops patch_ad1985_build_ops = { .update_jacks = ad1985_update_jacks, }; -int patch_ad1985(struct snd_ac97 * ac97) +int patch_ad1985(ac97_t * ac97) { unsigned short misc; @@ -1920,7 +1916,7 @@ int patch_ad1985(struct snd_ac97 * ac97) /* * realtek ALC65x/850 codecs */ -static void alc650_update_jacks(struct snd_ac97 *ac97) +static void alc650_update_jacks(ac97_t *ac97) { int shared; @@ -1941,7 +1937,7 @@ static void alc650_update_jacks(struct snd_ac97 *ac97) shared ? 0 : 0x100); } -static const struct snd_kcontrol_new snd_ac97_controls_alc650[] = { +static const snd_kcontrol_new_t snd_ac97_controls_alc650[] = { AC97_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0), AC97_SINGLE("Surround Down Mix", AC97_ALC650_MULTICH, 1, 1, 0), AC97_SINGLE("Center/LFE Down Mix", AC97_ALC650_MULTICH, 2, 1, 0), @@ -1967,14 +1963,14 @@ static const struct snd_kcontrol_new snd_ac97_controls_alc650[] = { AC97_CHANNEL_MODE_CTL, }; -static const struct snd_kcontrol_new snd_ac97_spdif_controls_alc650[] = { +static const snd_kcontrol_new_t snd_ac97_spdif_controls_alc650[] = { AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_ALC650_MULTICH, 11, 1, 0), AC97_SINGLE("Analog to IEC958 Output", AC97_ALC650_MULTICH, 12, 1, 0), /* disable this controls since it doesn't work as expected */ /* AC97_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 13, 1, 0), */ }; -static int patch_alc650_specific(struct snd_ac97 * ac97) +static int patch_alc650_specific(ac97_t * ac97) { int err; @@ -1992,7 +1988,7 @@ static struct snd_ac97_build_ops patch_alc650_ops = { .update_jacks = alc650_update_jacks }; -int patch_alc650(struct snd_ac97 * ac97) +int patch_alc650(ac97_t * ac97) { unsigned short val; @@ -2047,7 +2043,7 @@ int patch_alc650(struct snd_ac97 * ac97) return 0; } -static void alc655_update_jacks(struct snd_ac97 *ac97) +static void alc655_update_jacks(ac97_t *ac97) { int shared; @@ -2064,17 +2060,17 @@ static void alc655_update_jacks(struct snd_ac97 *ac97) shared ? (1 << 10) : 0, 0); } -static const struct snd_kcontrol_new snd_ac97_controls_alc655[] = { +static const snd_kcontrol_new_t snd_ac97_controls_alc655[] = { AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0), AC97_SURROUND_JACK_MODE_CTL, AC97_CHANNEL_MODE_CTL, }; -static int alc655_iec958_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int alc655_iec958_route_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts_655[3] = { "PCM", "Analog In", "IEC958 In" }; static char *texts_658[4] = { "PCM", "Analog1 In", "Analog2 In", "IEC958 In" }; - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -2088,9 +2084,9 @@ static int alc655_iec958_route_info(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int alc655_iec958_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc655_iec958_route_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_ALC650_MULTICH]; @@ -2101,29 +2097,29 @@ static int alc655_iec958_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int alc655_iec958_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc655_iec958_route_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); return ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 3 << 12, (unsigned short)ucontrol->value.enumerated.item[0] << 12, 0); } -static const struct snd_kcontrol_new snd_ac97_spdif_controls_alc655[] = { +static const snd_kcontrol_new_t snd_ac97_spdif_controls_alc655[] = { AC97_PAGE_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_ALC650_MULTICH, 11, 1, 0, 0), /* disable this controls since it doesn't work as expected */ /* AC97_PAGE_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 14, 1, 0, 0), */ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", + .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Route", .info = alc655_iec958_route_info, .get = alc655_iec958_route_get, .put = alc655_iec958_route_put, }, }; -static int patch_alc655_specific(struct snd_ac97 * ac97) +static int patch_alc655_specific(ac97_t * ac97) { int err; @@ -2141,7 +2137,7 @@ static struct snd_ac97_build_ops patch_alc655_ops = { .update_jacks = alc655_update_jacks }; -int patch_alc655(struct snd_ac97 * ac97) +int patch_alc655(ac97_t * ac97) { unsigned int val; @@ -2193,7 +2189,7 @@ int patch_alc655(struct snd_ac97 * ac97) #define AC97_ALC850_JACK_SELECT 0x76 #define AC97_ALC850_MISC1 0x7a -static void alc850_update_jacks(struct snd_ac97 *ac97) +static void alc850_update_jacks(ac97_t *ac97) { int shared; @@ -2215,14 +2211,14 @@ static void alc850_update_jacks(struct snd_ac97 *ac97) shared ? (2<<4) : (1<<4)); } -static const struct snd_kcontrol_new snd_ac97_controls_alc850[] = { +static const snd_kcontrol_new_t snd_ac97_controls_alc850[] = { AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0), AC97_SINGLE("Mic Front Input Switch", AC97_ALC850_JACK_SELECT, 15, 1, 1), AC97_SURROUND_JACK_MODE_CTL, AC97_CHANNEL_MODE_CTL, }; -static int patch_alc850_specific(struct snd_ac97 *ac97) +static int patch_alc850_specific(ac97_t *ac97) { int err; @@ -2240,7 +2236,7 @@ static struct snd_ac97_build_ops patch_alc850_ops = { .update_jacks = alc850_update_jacks }; -int patch_alc850(struct snd_ac97 *ac97) +int patch_alc850(ac97_t *ac97) { ac97->build_ops = &patch_alc850_ops; @@ -2277,20 +2273,20 @@ int patch_alc850(struct snd_ac97 *ac97) /* * C-Media CM97xx codecs */ -static void cm9738_update_jacks(struct snd_ac97 *ac97) +static void cm9738_update_jacks(ac97_t *ac97) { /* shared Line-In */ snd_ac97_update_bits(ac97, AC97_CM9738_VENDOR_CTRL, 1 << 10, is_shared_linein(ac97) ? (1 << 10) : 0); } -static const struct snd_kcontrol_new snd_ac97_cm9738_controls[] = { +static const snd_kcontrol_new_t snd_ac97_cm9738_controls[] = { AC97_SINGLE("Duplicate Front", AC97_CM9738_VENDOR_CTRL, 13, 1, 0), AC97_SURROUND_JACK_MODE_CTL, AC97_CHANNEL_MODE_4CH_CTL, }; -static int patch_cm9738_specific(struct snd_ac97 * ac97) +static int patch_cm9738_specific(ac97_t * ac97) { return patch_build_controls(ac97, snd_ac97_cm9738_controls, ARRAY_SIZE(snd_ac97_cm9738_controls)); } @@ -2300,7 +2296,7 @@ static struct snd_ac97_build_ops patch_cm9738_ops = { .update_jacks = cm9738_update_jacks }; -int patch_cm9738(struct snd_ac97 * ac97) +int patch_cm9738(ac97_t * ac97) { ac97->build_ops = &patch_cm9738_ops; /* FIXME: can anyone confirm below? */ @@ -2311,7 +2307,7 @@ int patch_cm9738(struct snd_ac97 * ac97) return 0; } -static int snd_ac97_cmedia_spdif_playback_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ac97_cmedia_spdif_playback_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "Analog", "Digital" }; @@ -2324,9 +2320,9 @@ static int snd_ac97_cmedia_spdif_playback_source_info(struct snd_kcontrol *kcont return 0; } -static int snd_ac97_cmedia_spdif_playback_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_cmedia_spdif_playback_source_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); unsigned short val; val = ac97->regs[AC97_CM9739_SPDIF_CTRL]; @@ -2334,16 +2330,16 @@ static int snd_ac97_cmedia_spdif_playback_source_get(struct snd_kcontrol *kcontr return 0; } -static int snd_ac97_cmedia_spdif_playback_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ac97_cmedia_spdif_playback_source_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); return snd_ac97_update_bits(ac97, AC97_CM9739_SPDIF_CTRL, 0x01 << 1, (ucontrol->value.enumerated.item[0] & 0x01) << 1); } -static const struct snd_kcontrol_new snd_ac97_cm9739_controls_spdif[] = { +static const snd_kcontrol_new_t snd_ac97_cm9739_controls_spdif[] = { /* BIT 0: SPDI_EN - always true */ { /* BIT 1: SPDIFS */ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, @@ -2361,7 +2357,7 @@ static const struct snd_kcontrol_new snd_ac97_cm9739_controls_spdif[] = { /* BIT 8: SPD32 - 32bit SPDIF - not supported yet */ }; -static void cm9739_update_jacks(struct snd_ac97 *ac97) +static void cm9739_update_jacks(ac97_t *ac97) { /* shared Line-In */ snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 1 << 10, @@ -2371,17 +2367,17 @@ static void cm9739_update_jacks(struct snd_ac97 *ac97) is_shared_micin(ac97) ? 0x1000 : 0x2000); } -static const struct snd_kcontrol_new snd_ac97_cm9739_controls[] = { +static const snd_kcontrol_new_t snd_ac97_cm9739_controls[] = { AC97_SURROUND_JACK_MODE_CTL, AC97_CHANNEL_MODE_CTL, }; -static int patch_cm9739_specific(struct snd_ac97 * ac97) +static int patch_cm9739_specific(ac97_t * ac97) { return patch_build_controls(ac97, snd_ac97_cm9739_controls, ARRAY_SIZE(snd_ac97_cm9739_controls)); } -static int patch_cm9739_post_spdif(struct snd_ac97 * ac97) +static int patch_cm9739_post_spdif(ac97_t * ac97) { return patch_build_controls(ac97, snd_ac97_cm9739_controls_spdif, ARRAY_SIZE(snd_ac97_cm9739_controls_spdif)); } @@ -2392,7 +2388,7 @@ static struct snd_ac97_build_ops patch_cm9739_ops = { .update_jacks = cm9739_update_jacks }; -int patch_cm9739(struct snd_ac97 * ac97) +int patch_cm9739(ac97_t * ac97) { unsigned short val; @@ -2451,7 +2447,7 @@ int patch_cm9739(struct snd_ac97 * ac97) #define AC97_CM9761_FUNC 0x66 #define AC97_CM9761_SPDIF_CTRL 0x6c -static void cm9761_update_jacks(struct snd_ac97 *ac97) +static void cm9761_update_jacks(ac97_t *ac97) { /* FIXME: check the bits for each model * model 83 is confirmed to work @@ -2486,12 +2482,12 @@ static void cm9761_update_jacks(struct snd_ac97 *ac97) snd_ac97_update_bits(ac97, AC97_CM9761_MULTI_CHAN, 0x3c88, val); } -static const struct snd_kcontrol_new snd_ac97_cm9761_controls[] = { +static const snd_kcontrol_new_t snd_ac97_cm9761_controls[] = { AC97_SURROUND_JACK_MODE_CTL, AC97_CHANNEL_MODE_CTL, }; -static int cm9761_spdif_out_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int cm9761_spdif_out_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[] = { "AC-Link", "ADC", "SPDIF-In" }; @@ -2504,9 +2500,9 @@ static int cm9761_spdif_out_source_info(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int cm9761_spdif_out_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cm9761_spdif_out_source_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); if (ac97->regs[AC97_CM9761_FUNC] & 0x1) ucontrol->value.enumerated.item[0] = 2; /* SPDIF-loopback */ @@ -2517,9 +2513,9 @@ static int cm9761_spdif_out_source_get(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int cm9761_spdif_out_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cm9761_spdif_out_source_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); + ac97_t *ac97 = snd_kcontrol_chip(kcontrol); if (ucontrol->value.enumerated.item[0] == 2) return snd_ac97_update_bits(ac97, AC97_CM9761_FUNC, 0x1, 0x1); @@ -2532,7 +2528,7 @@ static const char *cm9761_dac_clock[] = { "AC-Link", "SPDIF-In", "Both" }; static const struct ac97_enum cm9761_dac_clock_enum = AC97_ENUM_SINGLE(AC97_CM9761_SPDIF_CTRL, 9, 3, cm9761_dac_clock); -static const struct snd_kcontrol_new snd_ac97_cm9761_controls_spdif[] = { +static const snd_kcontrol_new_t snd_ac97_cm9761_controls_spdif[] = { { /* BIT 1: SPDIFS */ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", @@ -2550,12 +2546,12 @@ static const struct snd_kcontrol_new snd_ac97_cm9761_controls_spdif[] = { AC97_ENUM("DAC Clock Source", cm9761_dac_clock_enum), }; -static int patch_cm9761_post_spdif(struct snd_ac97 * ac97) +static int patch_cm9761_post_spdif(ac97_t * ac97) { return patch_build_controls(ac97, snd_ac97_cm9761_controls_spdif, ARRAY_SIZE(snd_ac97_cm9761_controls_spdif)); } -static int patch_cm9761_specific(struct snd_ac97 * ac97) +static int patch_cm9761_specific(ac97_t * ac97) { return patch_build_controls(ac97, snd_ac97_cm9761_controls, ARRAY_SIZE(snd_ac97_cm9761_controls)); } @@ -2566,7 +2562,7 @@ static struct snd_ac97_build_ops patch_cm9761_ops = { .update_jacks = cm9761_update_jacks }; -int patch_cm9761(struct snd_ac97 *ac97) +int patch_cm9761(ac97_t *ac97) { unsigned short val; @@ -2645,13 +2641,13 @@ int patch_cm9761(struct snd_ac97 *ac97) static const char *cm9780_ch_select[] = { "Front", "Side", "Center/LFE", "Rear" }; static const struct ac97_enum cm9780_ch_select_enum = AC97_ENUM_SINGLE(AC97_CM9780_MULTI_CHAN, 6, 4, cm9780_ch_select); -static const struct snd_kcontrol_new cm9780_controls[] = { +static const snd_kcontrol_new_t cm9780_controls[] = { AC97_DOUBLE("Side Playback Switch", AC97_CM9780_SIDE, 15, 7, 1, 1), AC97_DOUBLE("Side Playback Volume", AC97_CM9780_SIDE, 8, 0, 31, 0), AC97_ENUM("Side Playback Route", cm9780_ch_select_enum), }; -static int patch_cm9780_specific(struct snd_ac97 *ac97) +static int patch_cm9780_specific(ac97_t *ac97) { return patch_build_controls(ac97, cm9780_controls, ARRAY_SIZE(cm9780_controls)); } @@ -2661,7 +2657,7 @@ static struct snd_ac97_build_ops patch_cm9780_ops = { .build_post_spdif = patch_cm9761_post_spdif /* identical with CM9761 */ }; -int patch_cm9780(struct snd_ac97 *ac97) +int patch_cm9780(ac97_t *ac97) { unsigned short val; @@ -2681,14 +2677,14 @@ int patch_cm9780(struct snd_ac97 *ac97) /* * VIA VT1616 codec */ -static const struct snd_kcontrol_new snd_ac97_controls_vt1616[] = { +static const snd_kcontrol_new_t snd_ac97_controls_vt1616[] = { AC97_SINGLE("DC Offset removal", 0x5a, 10, 1, 0), AC97_SINGLE("Alternate Level to Surround Out", 0x5a, 15, 1, 0), AC97_SINGLE("Downmix LFE and Center to Front", 0x5a, 12, 1, 0), AC97_SINGLE("Downmix Surround to Front", 0x5a, 11, 1, 0), }; -static int patch_vt1616_specific(struct snd_ac97 * ac97) +static int patch_vt1616_specific(ac97_t * ac97) { int err; @@ -2704,7 +2700,7 @@ static struct snd_ac97_build_ops patch_vt1616_ops = { .build_specific = patch_vt1616_specific }; -int patch_vt1616(struct snd_ac97 * ac97) +int patch_vt1616(ac97_t * ac97) { ac97->build_ops = &patch_vt1616_ops; return 0; @@ -2713,7 +2709,7 @@ int patch_vt1616(struct snd_ac97 * ac97) /* * VT1617A codec */ -int patch_vt1617a(struct snd_ac97 * ac97) +int patch_vt1617a(ac97_t * ac97) { ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */ ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000; @@ -2722,7 +2718,7 @@ int patch_vt1617a(struct snd_ac97 * ac97) /* */ -static void it2646_update_jacks(struct snd_ac97 *ac97) +static void it2646_update_jacks(ac97_t *ac97) { /* shared Line-In */ snd_ac97_update_bits(ac97, 0x76, 1 << 9, @@ -2732,18 +2728,18 @@ static void it2646_update_jacks(struct snd_ac97 *ac97) is_shared_micin(ac97) ? (1<<10) : 0); } -static const struct snd_kcontrol_new snd_ac97_controls_it2646[] = { +static const snd_kcontrol_new_t snd_ac97_controls_it2646[] = { AC97_SURROUND_JACK_MODE_CTL, AC97_CHANNEL_MODE_CTL, }; -static const struct snd_kcontrol_new snd_ac97_spdif_controls_it2646[] = { +static const snd_kcontrol_new_t snd_ac97_spdif_controls_it2646[] = { AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0x76, 11, 1, 0), AC97_SINGLE("Analog to IEC958 Output", 0x76, 12, 1, 0), AC97_SINGLE("IEC958 Input Monitor", 0x76, 13, 1, 0), }; -static int patch_it2646_specific(struct snd_ac97 * ac97) +static int patch_it2646_specific(ac97_t * ac97) { int err; if ((err = patch_build_controls(ac97, snd_ac97_controls_it2646, ARRAY_SIZE(snd_ac97_controls_it2646))) < 0) @@ -2758,7 +2754,7 @@ static struct snd_ac97_build_ops patch_it2646_ops = { .update_jacks = it2646_update_jacks }; -int patch_it2646(struct snd_ac97 * ac97) +int patch_it2646(ac97_t * ac97) { ac97->build_ops = &patch_it2646_ops; /* full DAC volume */ @@ -2774,11 +2770,11 @@ int patch_it2646(struct snd_ac97 * ac97) #define AC97_SI3036_CHIP_ID 0x5a #define AC97_SI3036_LINE_CFG 0x5c -static const struct snd_kcontrol_new snd_ac97_controls_si3036[] = { +static const snd_kcontrol_new_t snd_ac97_controls_si3036[] = { AC97_DOUBLE("Modem Speaker Volume", 0x5c, 14, 12, 3, 1) }; -static int patch_si3036_specific(struct snd_ac97 * ac97) +static int patch_si3036_specific(ac97_t * ac97) { int idx, err; for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_si3036); idx++) @@ -2791,7 +2787,7 @@ static struct snd_ac97_build_ops patch_si3036_ops = { .build_specific = patch_si3036_specific, }; -int mpatch_si3036(struct snd_ac97 * ac97) +int mpatch_si3036(ac97_t * ac97) { ac97->build_ops = &patch_si3036_ops; snd_ac97_write_cache(ac97, 0x5c, 0xf210 ); diff --git a/trunk/sound/pci/ac97/ac97_patch.h b/trunk/sound/pci/ac97/ac97_patch.h index 5060cb6f2ec3..ec1811320106 100644 --- a/trunk/sound/pci/ac97/ac97_patch.h +++ b/trunk/sound/pci/ac97/ac97_patch.h @@ -22,40 +22,40 @@ * */ -int patch_yamaha_ymf753(struct snd_ac97 * ac97); -int patch_wolfson00(struct snd_ac97 * ac97); -int patch_wolfson03(struct snd_ac97 * ac97); -int patch_wolfson04(struct snd_ac97 * ac97); -int patch_wolfson05(struct snd_ac97 * ac97); -int patch_wolfson11(struct snd_ac97 * ac97); -int patch_wolfson13(struct snd_ac97 * ac97); -int patch_tritech_tr28028(struct snd_ac97 * ac97); -int patch_sigmatel_stac9700(struct snd_ac97 * ac97); -int patch_sigmatel_stac9708(struct snd_ac97 * ac97); -int patch_sigmatel_stac9721(struct snd_ac97 * ac97); -int patch_sigmatel_stac9744(struct snd_ac97 * ac97); -int patch_sigmatel_stac9756(struct snd_ac97 * ac97); -int patch_sigmatel_stac9758(struct snd_ac97 * ac97); -int patch_cirrus_cs4299(struct snd_ac97 * ac97); -int patch_cirrus_spdif(struct snd_ac97 * ac97); -int patch_conexant(struct snd_ac97 * ac97); -int patch_ad1819(struct snd_ac97 * ac97); -int patch_ad1881(struct snd_ac97 * ac97); -int patch_ad1885(struct snd_ac97 * ac97); -int patch_ad1886(struct snd_ac97 * ac97); -int patch_ad1888(struct snd_ac97 * ac97); -int patch_ad1980(struct snd_ac97 * ac97); -int patch_ad1981a(struct snd_ac97 * ac97); -int patch_ad1981b(struct snd_ac97 * ac97); -int patch_ad1985(struct snd_ac97 * ac97); -int patch_alc650(struct snd_ac97 * ac97); -int patch_alc655(struct snd_ac97 * ac97); -int patch_alc850(struct snd_ac97 * ac97); -int patch_cm9738(struct snd_ac97 * ac97); -int patch_cm9739(struct snd_ac97 * ac97); -int patch_cm9761(struct snd_ac97 * ac97); -int patch_cm9780(struct snd_ac97 * ac97); -int patch_vt1616(struct snd_ac97 * ac97); -int patch_vt1617a(struct snd_ac97 * ac97); -int patch_it2646(struct snd_ac97 * ac97); -int mpatch_si3036(struct snd_ac97 * ac97); +int patch_yamaha_ymf753(ac97_t * ac97); +int patch_wolfson00(ac97_t * ac97); +int patch_wolfson03(ac97_t * ac97); +int patch_wolfson04(ac97_t * ac97); +int patch_wolfson05(ac97_t * ac97); +int patch_wolfson11(ac97_t * ac97); +int patch_wolfson13(ac97_t * ac97); +int patch_tritech_tr28028(ac97_t * ac97); +int patch_sigmatel_stac9700(ac97_t * ac97); +int patch_sigmatel_stac9708(ac97_t * ac97); +int patch_sigmatel_stac9721(ac97_t * ac97); +int patch_sigmatel_stac9744(ac97_t * ac97); +int patch_sigmatel_stac9756(ac97_t * ac97); +int patch_sigmatel_stac9758(ac97_t * ac97); +int patch_cirrus_cs4299(ac97_t * ac97); +int patch_cirrus_spdif(ac97_t * ac97); +int patch_conexant(ac97_t * ac97); +int patch_ad1819(ac97_t * ac97); +int patch_ad1881(ac97_t * ac97); +int patch_ad1885(ac97_t * ac97); +int patch_ad1886(ac97_t * ac97); +int patch_ad1888(ac97_t * ac97); +int patch_ad1980(ac97_t * ac97); +int patch_ad1981a(ac97_t * ac97); +int patch_ad1981b(ac97_t * ac97); +int patch_ad1985(ac97_t * ac97); +int patch_alc650(ac97_t * ac97); +int patch_alc655(ac97_t * ac97); +int patch_alc850(ac97_t * ac97); +int patch_cm9738(ac97_t * ac97); +int patch_cm9739(ac97_t * ac97); +int patch_cm9761(ac97_t * ac97); +int patch_cm9780(ac97_t * ac97); +int patch_vt1616(ac97_t * ac97); +int patch_vt1617a(ac97_t * ac97); +int patch_it2646(ac97_t * ac97); +int mpatch_si3036(ac97_t * ac97); diff --git a/trunk/sound/pci/ac97/ac97_pcm.c b/trunk/sound/pci/ac97/ac97_pcm.c index c3e590bf7a02..ded13165d635 100644 --- a/trunk/sound/pci/ac97/ac97_pcm.c +++ b/trunk/sound/pci/ac97/ac97_pcm.c @@ -170,7 +170,7 @@ static unsigned char get_slot_reg(struct ac97_pcm *pcm, unsigned short cidx, return rate_cregs[slot - 3]; } -static int set_spdif_rate(struct snd_ac97 *ac97, unsigned short rate) +static int set_spdif_rate(ac97_t *ac97, unsigned short rate) { unsigned short old, bits, reg, mask; unsigned int sbits; @@ -254,7 +254,7 @@ static int set_spdif_rate(struct snd_ac97 *ac97, unsigned short rate) * * Returns zero if successful, or a negative error code on failure. */ -int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate) +int snd_ac97_set_rate(ac97_t *ac97, int reg, unsigned int rate) { int dbl; unsigned int tmp; @@ -315,7 +315,7 @@ int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate) return 0; } -static unsigned short get_pslots(struct snd_ac97 *ac97, unsigned char *rate_table, unsigned short *spdif_slots) +static unsigned short get_pslots(ac97_t *ac97, unsigned char *rate_table, unsigned short *spdif_slots) { if (!ac97_is_audio(ac97)) return 0; @@ -390,7 +390,7 @@ static unsigned short get_pslots(struct snd_ac97 *ac97, unsigned char *rate_tabl } } -static unsigned short get_cslots(struct snd_ac97 *ac97) +static unsigned short get_cslots(ac97_t *ac97) { unsigned short slots; @@ -437,7 +437,7 @@ static unsigned int get_rates(struct ac97_pcm *pcm, unsigned int cidx, unsigned * some slots are available, pcm->xxx.slots and pcm->xxx.rslots[] members * are reduced and might be zero. */ -int snd_ac97_pcm_assign(struct snd_ac97_bus *bus, +int snd_ac97_pcm_assign(ac97_bus_t *bus, unsigned short pcms_count, const struct ac97_pcm *pcms) { @@ -449,7 +449,7 @@ int snd_ac97_pcm_assign(struct snd_ac97_bus *bus, unsigned short tmp, slots; unsigned short spdif_slots[4]; unsigned int rates; - struct snd_ac97 *codec; + ac97_t *codec; rpcms = kcalloc(pcms_count, sizeof(struct ac97_pcm), GFP_KERNEL); if (rpcms == NULL) @@ -560,7 +560,7 @@ int snd_ac97_pcm_assign(struct snd_ac97_bus *bus, int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate, enum ac97_pcm_cfg cfg, unsigned short slots) { - struct snd_ac97_bus *bus; + ac97_bus_t *bus; int i, cidx, r, ok_flag; unsigned int reg_ok[4] = {0,0,0,0}; unsigned char reg; @@ -639,7 +639,7 @@ int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate, */ int snd_ac97_pcm_close(struct ac97_pcm *pcm) { - struct snd_ac97_bus *bus; + ac97_bus_t *bus; unsigned short slots = pcm->aslots; int i, cidx; @@ -656,31 +656,31 @@ int snd_ac97_pcm_close(struct ac97_pcm *pcm) return 0; } -static int double_rate_hw_constraint_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int double_rate_hw_constraint_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); if (channels->min > 2) { - static const struct snd_interval single_rates = { + static const snd_interval_t single_rates = { .min = 1, .max = 48000, }; - struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + snd_interval_t *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); return snd_interval_refine(rate, &single_rates); } return 0; } -static int double_rate_hw_constraint_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int double_rate_hw_constraint_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + snd_interval_t *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (rate->min > 48000) { - static const struct snd_interval double_rate_channels = { + static const snd_interval_t double_rate_channels = { .min = 2, .max = 2, }; - struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); return snd_interval_refine(channels, &double_rate_channels); } return 0; @@ -693,7 +693,7 @@ static int double_rate_hw_constraint_channels(struct snd_pcm_hw_params *params, * Installs the hardware constraint rules to prevent using double rates and * more than two channels at the same time. */ -int snd_ac97_pcm_double_rate_rules(struct snd_pcm_runtime *runtime) +int snd_ac97_pcm_double_rate_rules(snd_pcm_runtime_t *runtime) { int err; diff --git a/trunk/sound/pci/ac97/ac97_proc.c b/trunk/sound/pci/ac97/ac97_proc.c index 7134b3f55fb5..a040b2666ed7 100644 --- a/trunk/sound/pci/ac97/ac97_proc.c +++ b/trunk/sound/pci/ac97/ac97_proc.c @@ -34,7 +34,7 @@ * proc interface */ -static void snd_ac97_proc_read_functions(struct snd_ac97 *ac97, struct snd_info_buffer *buffer) +static void snd_ac97_proc_read_functions(ac97_t *ac97, snd_info_buffer_t *buffer) { int header = 0, function; unsigned short info, sense_info; @@ -68,43 +68,7 @@ static void snd_ac97_proc_read_functions(struct snd_ac97 *ac97, struct snd_info_ } } -static const char *snd_ac97_stereo_enhancements[] = -{ - /* 0 */ "No 3D Stereo Enhancement", - /* 1 */ "Analog Devices Phat Stereo", - /* 2 */ "Creative Stereo Enhancement", - /* 3 */ "National Semi 3D Stereo Enhancement", - /* 4 */ "YAMAHA Ymersion", - /* 5 */ "BBE 3D Stereo Enhancement", - /* 6 */ "Crystal Semi 3D Stereo Enhancement", - /* 7 */ "Qsound QXpander", - /* 8 */ "Spatializer 3D Stereo Enhancement", - /* 9 */ "SRS 3D Stereo Enhancement", - /* 10 */ "Platform Tech 3D Stereo Enhancement", - /* 11 */ "AKM 3D Audio", - /* 12 */ "Aureal Stereo Enhancement", - /* 13 */ "Aztech 3D Enhancement", - /* 14 */ "Binaura 3D Audio Enhancement", - /* 15 */ "ESS Technology Stereo Enhancement", - /* 16 */ "Harman International VMAx", - /* 17 */ "Nvidea/IC Ensemble/KS Waves 3D Stereo Enhancement", - /* 18 */ "Philips Incredible Sound", - /* 19 */ "Texas Instruments 3D Stereo Enhancement", - /* 20 */ "VLSI Technology 3D Stereo Enhancement", - /* 21 */ "TriTech 3D Stereo Enhancement", - /* 22 */ "Realtek 3D Stereo Enhancement", - /* 23 */ "Samsung 3D Stereo Enhancement", - /* 24 */ "Wolfson Microelectronics 3D Enhancement", - /* 25 */ "Delta Integration 3D Enhancement", - /* 26 */ "SigmaTel 3D Enhancement", - /* 27 */ "IC Ensemble/KS Waves", - /* 28 */ "Rockwell 3D Stereo Enhancement", - /* 29 */ "Reserved 29", - /* 30 */ "Reserved 30", - /* 31 */ "Reserved 31" -}; - -static void snd_ac97_proc_read_main(struct snd_ac97 *ac97, struct snd_info_buffer *buffer, int subidx) +static void snd_ac97_proc_read_main(ac97_t *ac97, snd_info_buffer_t * buffer, int subidx) { char name[64]; unsigned short val, tmp, ext, mext; @@ -115,15 +79,9 @@ static void snd_ac97_proc_read_main(struct snd_ac97 *ac97, struct snd_info_buffe snd_ac97_get_name(NULL, ac97->id, name, 0); snd_iprintf(buffer, "%d-%d/%d: %s\n\n", ac97->addr, ac97->num, subidx, name); - if ((ac97->scaps & AC97_SCAP_AUDIO) == 0) goto __modem; - snd_iprintf(buffer, "PCI Subsys Vendor: 0x%04x\n", - ac97->subsystem_vendor); - snd_iprintf(buffer, "PCI Subsys Device: 0x%04x\n\n", - ac97->subsystem_device); - if ((ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23) { val = snd_ac97_read(ac97, AC97_INT_PAGING); snd_ac97_update_bits(ac97, AC97_INT_PAGING, @@ -334,9 +292,9 @@ static void snd_ac97_proc_read_main(struct snd_ac97 *ac97, struct snd_info_buffe } } -static void snd_ac97_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void snd_ac97_proc_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_ac97 *ac97 = entry->private_data; + ac97_t *ac97 = entry->private_data; down(&ac97->page_mutex); if ((ac97->id & 0xffffff40) == AC97_ID_AD1881) { // Analog Devices AD1881/85/86 @@ -369,9 +327,9 @@ static void snd_ac97_proc_read(struct snd_info_entry *entry, struct snd_info_buf #ifdef CONFIG_SND_DEBUG /* direct register write for debugging */ -static void snd_ac97_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void snd_ac97_proc_regs_write(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_ac97 *ac97 = entry->private_data; + ac97_t *ac97 = entry->private_data; char line[64]; unsigned int reg, val; down(&ac97->page_mutex); @@ -386,7 +344,7 @@ static void snd_ac97_proc_regs_write(struct snd_info_entry *entry, struct snd_in } #endif -static void snd_ac97_proc_regs_read_main(struct snd_ac97 *ac97, struct snd_info_buffer *buffer, int subidx) +static void snd_ac97_proc_regs_read_main(ac97_t *ac97, snd_info_buffer_t * buffer, int subidx) { int reg, val; @@ -396,10 +354,10 @@ static void snd_ac97_proc_regs_read_main(struct snd_ac97 *ac97, struct snd_info_ } } -static void snd_ac97_proc_regs_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ac97_proc_regs_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ac97 *ac97 = entry->private_data; + ac97_t *ac97 = entry->private_data; down(&ac97->page_mutex); if ((ac97->id & 0xffffff40) == AC97_ID_AD1881) { // Analog Devices AD1881/85/86 @@ -420,9 +378,9 @@ static void snd_ac97_proc_regs_read(struct snd_info_entry *entry, up(&ac97->page_mutex); } -void snd_ac97_proc_init(struct snd_ac97 * ac97) +void snd_ac97_proc_init(ac97_t * ac97) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; char name[32]; const char *prefix; @@ -454,7 +412,7 @@ void snd_ac97_proc_init(struct snd_ac97 * ac97) ac97->proc_regs = entry; } -void snd_ac97_proc_done(struct snd_ac97 * ac97) +void snd_ac97_proc_done(ac97_t * ac97) { if (ac97->proc_regs) { snd_info_unregister(ac97->proc_regs); @@ -466,9 +424,9 @@ void snd_ac97_proc_done(struct snd_ac97 * ac97) } } -void snd_ac97_bus_proc_init(struct snd_ac97_bus * bus) +void snd_ac97_bus_proc_init(ac97_bus_t * bus) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; char name[32]; sprintf(name, "codec97#%d", bus->num); @@ -482,7 +440,7 @@ void snd_ac97_bus_proc_init(struct snd_ac97_bus * bus) bus->proc = entry; } -void snd_ac97_bus_proc_done(struct snd_ac97_bus * bus) +void snd_ac97_bus_proc_done(ac97_bus_t * bus) { if (bus->proc) { snd_info_unregister(bus->proc); diff --git a/trunk/sound/pci/ac97/ak4531_codec.c b/trunk/sound/pci/ac97/ak4531_codec.c index dcfb5036ff8b..4032c5748370 100644 --- a/trunk/sound/pci/ac97/ak4531_codec.c +++ b/trunk/sound/pci/ac97/ak4531_codec.c @@ -30,11 +30,7 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("Universal routines for AK4531 codec"); MODULE_LICENSE("GPL"); -#ifdef CONFIG_PROC_FS -static void snd_ak4531_proc_init(struct snd_card *card, struct snd_ak4531 *ak4531); -#else -#define snd_ak4531_proc_init(card,ak) -#endif +static void snd_ak4531_proc_init(snd_card_t * card, ak4531_t * ak4531); /* * @@ -42,7 +38,7 @@ static void snd_ak4531_proc_init(struct snd_card *card, struct snd_ak4531 *ak453 #if 0 -static void snd_ak4531_dump(struct snd_ak4531 *ak4531) +static void snd_ak4531_dump(ak4531_t *ak4531) { int idx; @@ -62,7 +58,7 @@ static void snd_ak4531_dump(struct snd_ak4531 *ak4531) .get = snd_ak4531_get_single, .put = snd_ak4531_put_single, \ .private_value = reg | (shift << 16) | (mask << 24) | (invert << 22) } -static int snd_ak4531_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4531_info_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -73,9 +69,9 @@ static int snd_ak4531_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ak4531_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ak4531_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ak4531 *ak4531 = snd_kcontrol_chip(kcontrol); + ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 16) & 0x07; int mask = (kcontrol->private_value >> 24) & 0xff; @@ -92,9 +88,9 @@ static int snd_ak4531_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_ak4531_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ak4531_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ak4531 *ak4531 = snd_kcontrol_chip(kcontrol); + ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 16) & 0x07; int mask = (kcontrol->private_value >> 24) & 0xff; @@ -121,7 +117,7 @@ static int snd_ak4531_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_e .get = snd_ak4531_get_double, .put = snd_ak4531_put_double, \ .private_value = left_reg | (right_reg << 8) | (left_shift << 16) | (right_shift << 19) | (mask << 24) | (invert << 22) } -static int snd_ak4531_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4531_info_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -132,9 +128,9 @@ static int snd_ak4531_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ak4531_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ak4531_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ak4531 *ak4531 = snd_kcontrol_chip(kcontrol); + ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int left_shift = (kcontrol->private_value >> 16) & 0x07; @@ -156,9 +152,9 @@ static int snd_ak4531_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_ak4531_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ak4531_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ak4531 *ak4531 = snd_kcontrol_chip(kcontrol); + ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int left_shift = (kcontrol->private_value >> 16) & 0x07; @@ -198,7 +194,7 @@ static int snd_ak4531_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e .get = snd_ak4531_get_input_sw, .put = snd_ak4531_put_input_sw, \ .private_value = reg1 | (reg2 << 8) | (left_shift << 16) | (right_shift << 24) } -static int snd_ak4531_info_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ak4531_info_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 4; @@ -207,9 +203,9 @@ static int snd_ak4531_info_input_sw(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_ak4531_get_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ak4531_get_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ak4531 *ak4531 = snd_kcontrol_chip(kcontrol); + ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol); int reg1 = kcontrol->private_value & 0xff; int reg2 = (kcontrol->private_value >> 8) & 0xff; int left_shift = (kcontrol->private_value >> 16) & 0x0f; @@ -224,9 +220,9 @@ static int snd_ak4531_get_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_ak4531_put_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ak4531_put_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ak4531 *ak4531 = snd_kcontrol_chip(kcontrol); + ak4531_t *ak4531 = snd_kcontrol_chip(kcontrol); int reg1 = kcontrol->private_value & 0xff; int reg2 = (kcontrol->private_value >> 8) & 0xff; int left_shift = (kcontrol->private_value >> 16) & 0x0f; @@ -248,7 +244,7 @@ static int snd_ak4531_put_input_sw(struct snd_kcontrol *kcontrol, struct snd_ctl return change; } -static struct snd_kcontrol_new snd_ak4531_controls[] = { +static snd_kcontrol_new_t snd_ak4531_controls[] = { AK4531_DOUBLE("Master Playback Switch", 0, AK4531_LMASTER, AK4531_RMASTER, 7, 7, 1, 1), AK4531_DOUBLE("Master Playback Volume", 0, AK4531_LMASTER, AK4531_RMASTER, 0, 0, 0x1f, 1), @@ -304,7 +300,7 @@ AK4531_SINGLE("AD Input Select", 0, AK4531_AD_IN, 0, 1, 0), AK4531_SINGLE("Mic Boost (+30dB)", 0, AK4531_MIC_GAIN, 0, 1, 0) }; -static int snd_ak4531_free(struct snd_ak4531 *ak4531) +static int snd_ak4531_free(ak4531_t *ak4531) { if (ak4531) { if (ak4531->private_free) @@ -314,9 +310,9 @@ static int snd_ak4531_free(struct snd_ak4531 *ak4531) return 0; } -static int snd_ak4531_dev_free(struct snd_device *device) +static int snd_ak4531_dev_free(snd_device_t *device) { - struct snd_ak4531 *ak4531 = device->device_data; + ak4531_t *ak4531 = device->device_data; return snd_ak4531_free(ak4531); } @@ -349,13 +345,12 @@ static u8 snd_ak4531_initial_map[0x19 + 1] = { 0x01 /* 19: Mic Amp Setup */ }; -int snd_ak4531_mixer(struct snd_card *card, struct snd_ak4531 *_ak4531, - struct snd_ak4531 **rak4531) +int snd_ak4531_mixer(snd_card_t * card, ak4531_t * _ak4531, ak4531_t ** rak4531) { unsigned int idx; int err; - struct snd_ak4531 *ak4531; - static struct snd_device_ops ops = { + ak4531_t * ak4531; + static snd_device_ops_t ops = { .dev_free = snd_ak4531_dev_free, }; @@ -375,7 +370,7 @@ int snd_ak4531_mixer(struct snd_card *card, struct snd_ak4531 *_ak4531, ak4531->write(ak4531, AK4531_RESET, 0x03); /* no RST, PD */ udelay(100); ak4531->write(ak4531, AK4531_CLOCK, 0x00); /* CODEC ADC and CODEC DAC use {LR,B}CLK2 and run off LRCLK2 PLL */ - for (idx = 0; idx <= 0x19; idx++) { + for (idx = 0; idx < 0x19; idx++) { if (idx == AK4531_RESET || idx == AK4531_CLOCK) continue; ak4531->write(ak4531, idx, ak4531->regs[idx] = snd_ak4531_initial_map[idx]); /* recording source is mixer */ @@ -400,44 +395,13 @@ int snd_ak4531_mixer(struct snd_card *card, struct snd_ak4531 *_ak4531, } /* - * power management - */ -#ifdef CONFIG_PM -void snd_ak4531_suspend(struct snd_ak4531 *ak4531) -{ - /* mute */ - ak4531->write(ak4531, AK4531_LMASTER, 0x9f); - ak4531->write(ak4531, AK4531_RMASTER, 0x9f); - /* powerdown */ - ak4531->write(ak4531, AK4531_RESET, 0x01); -} -void snd_ak4531_resume(struct snd_ak4531 *ak4531) -{ - int idx; - - /* initialize */ - ak4531->write(ak4531, AK4531_RESET, 0x03); - udelay(100); - ak4531->write(ak4531, AK4531_CLOCK, 0x00); - /* restore mixer registers */ - for (idx = 0; idx <= 0x19; idx++) { - if (idx == AK4531_RESET || idx == AK4531_CLOCK) - continue; - ak4531->write(ak4531, idx, ak4531->regs[idx]); - } -} -#endif - -#ifdef CONFIG_PROC_FS -/* - * /proc interface */ -static void snd_ak4531_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ak4531_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ak4531 *ak4531 = entry->private_data; + ak4531_t *ak4531 = entry->private_data; snd_iprintf(buffer, "Asahi Kasei AK4531\n\n"); snd_iprintf(buffer, "Recording source : %s\n" @@ -446,20 +410,15 @@ static void snd_ak4531_proc_read(struct snd_info_entry *entry, ak4531->regs[AK4531_MIC_GAIN] & 1 ? "+30dB" : "+0dB"); } -static void snd_ak4531_proc_init(struct snd_card *card, struct snd_ak4531 *ak4531) +static void snd_ak4531_proc_init(snd_card_t * card, ak4531_t * ak4531) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(card, "ak4531", &entry)) snd_info_set_text_ops(entry, ak4531, 1024, snd_ak4531_proc_read); } -#endif EXPORT_SYMBOL(snd_ak4531_mixer); -#ifdef CONFIG_PM -EXPORT_SYMBOL(snd_ak4531_suspend); -EXPORT_SYMBOL(snd_ak4531_resume); -#endif /* * INIT part diff --git a/trunk/sound/pci/ad1889.c b/trunk/sound/pci/ad1889.c index a208075cdc1e..1fdae678a345 100644 --- a/trunk/sound/pci/ad1889.c +++ b/trunk/sound/pci/ad1889.c @@ -50,7 +50,7 @@ #include "ad1889.h" #include "ac97/ac97_id.h" -#define AD1889_DRVVER "Version: 1.7" +#define AD1889_DRVVER "$Revision: 1.4 $" MODULE_AUTHOR("Kyle McMartin <kyle@parisc-linux.org>, Thibaut Varene <t-bone@parisc-linux.org>"); MODULE_DESCRIPTION("Analog Devices AD1889 ALSA sound driver"); @@ -87,20 +87,20 @@ struct ad1889_register_state { }; struct snd_ad1889 { - struct snd_card *card; + snd_card_t *card; struct pci_dev *pci; int irq; unsigned long bar; void __iomem *iobase; - struct snd_ac97 *ac97; - struct snd_ac97_bus *ac97_bus; - struct snd_pcm *pcm; - struct snd_info_entry *proc; + ac97_t *ac97; + ac97_bus_t *ac97_bus; + snd_pcm_t *pcm; + snd_info_entry_t *proc; - struct snd_pcm_substream *psubs; - struct snd_pcm_substream *csubs; + snd_pcm_substream_t *psubs; + snd_pcm_substream_t *csubs; /* playback register state */ struct ad1889_register_state wave; @@ -241,14 +241,14 @@ ad1889_channel_reset(struct snd_ad1889 *chip, unsigned int channel) } static inline u16 -snd_ad1889_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +snd_ad1889_ac97_read(ac97_t *ac97, unsigned short reg) { struct snd_ad1889 *chip = ac97->private_data; return ad1889_readw(chip, AD_AC97_BASE + reg); } static inline void -snd_ad1889_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) +snd_ad1889_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { struct snd_ad1889 *chip = ac97->private_data; ad1889_writew(chip, AD_AC97_BASE + reg, val); @@ -273,20 +273,20 @@ snd_ad1889_ac97_ready(struct snd_ad1889 *chip) } static int -snd_ad1889_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +snd_ad1889_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } static int -snd_ad1889_hw_free(struct snd_pcm_substream *substream) +snd_ad1889_hw_free(snd_pcm_substream_t *substream) { return snd_pcm_lib_free_pages(substream); } -static struct snd_pcm_hardware snd_ad1889_playback_hw = { +static snd_pcm_hardware_t snd_ad1889_playback_hw = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BLOCK_TRANSFER, .formats = SNDRV_PCM_FMTBIT_S16_LE, @@ -303,7 +303,7 @@ static struct snd_pcm_hardware snd_ad1889_playback_hw = { /*.fifo_size = 0,*/ }; -static struct snd_pcm_hardware snd_ad1889_capture_hw = { +static snd_pcm_hardware_t snd_ad1889_capture_hw = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BLOCK_TRANSFER, .formats = SNDRV_PCM_FMTBIT_S16_LE, @@ -321,10 +321,10 @@ static struct snd_pcm_hardware snd_ad1889_capture_hw = { }; static int -snd_ad1889_playback_open(struct snd_pcm_substream *ss) +snd_ad1889_playback_open(snd_pcm_substream_t *ss) { struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + snd_pcm_runtime_t *rt = ss->runtime; chip->psubs = ss; rt->hw = snd_ad1889_playback_hw; @@ -333,10 +333,10 @@ snd_ad1889_playback_open(struct snd_pcm_substream *ss) } static int -snd_ad1889_capture_open(struct snd_pcm_substream *ss) +snd_ad1889_capture_open(snd_pcm_substream_t *ss) { struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + snd_pcm_runtime_t *rt = ss->runtime; chip->csubs = ss; rt->hw = snd_ad1889_capture_hw; @@ -345,7 +345,7 @@ snd_ad1889_capture_open(struct snd_pcm_substream *ss) } static int -snd_ad1889_playback_close(struct snd_pcm_substream *ss) +snd_ad1889_playback_close(snd_pcm_substream_t *ss) { struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); chip->psubs = NULL; @@ -353,7 +353,7 @@ snd_ad1889_playback_close(struct snd_pcm_substream *ss) } static int -snd_ad1889_capture_close(struct snd_pcm_substream *ss) +snd_ad1889_capture_close(snd_pcm_substream_t *ss) { struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); chip->csubs = NULL; @@ -361,10 +361,10 @@ snd_ad1889_capture_close(struct snd_pcm_substream *ss) } static int -snd_ad1889_playback_prepare(struct snd_pcm_substream *ss) +snd_ad1889_playback_prepare(snd_pcm_substream_t *ss) { struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + snd_pcm_runtime_t *rt = ss->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(ss); unsigned int count = snd_pcm_lib_period_bytes(ss); u16 reg; @@ -411,10 +411,10 @@ snd_ad1889_playback_prepare(struct snd_pcm_substream *ss) } static int -snd_ad1889_capture_prepare(struct snd_pcm_substream *ss) +snd_ad1889_capture_prepare(snd_pcm_substream_t *ss) { struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); - struct snd_pcm_runtime *rt = ss->runtime; + snd_pcm_runtime_t *rt = ss->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(ss); unsigned int count = snd_pcm_lib_period_bytes(ss); u16 reg; @@ -462,7 +462,7 @@ snd_ad1889_capture_prepare(struct snd_pcm_substream *ss) DMA should be *triggered* by this call. The WSMC "WAEN" bit triggers DMA Wave On/Off */ static int -snd_ad1889_playback_trigger(struct snd_pcm_substream *ss, int cmd) +snd_ad1889_playback_trigger(snd_pcm_substream_t *ss, int cmd) { u16 wsmc; struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); @@ -503,7 +503,7 @@ snd_ad1889_playback_trigger(struct snd_pcm_substream *ss, int cmd) DMA should be *triggered* by this call. The RAMC "ADEN" bit triggers DMA ADC On/Off */ static int -snd_ad1889_capture_trigger(struct snd_pcm_substream *ss, int cmd) +snd_ad1889_capture_trigger(snd_pcm_substream_t *ss, int cmd) { u16 ramc; struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); @@ -538,7 +538,7 @@ snd_ad1889_capture_trigger(struct snd_pcm_substream *ss, int cmd) /* Called in atomic context with IRQ disabled */ static snd_pcm_uframes_t -snd_ad1889_playback_pointer(struct snd_pcm_substream *ss) +snd_ad1889_playback_pointer(snd_pcm_substream_t *ss) { size_t ptr = 0; struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); @@ -556,7 +556,7 @@ snd_ad1889_playback_pointer(struct snd_pcm_substream *ss) /* Called in atomic context with IRQ disabled */ static snd_pcm_uframes_t -snd_ad1889_capture_pointer(struct snd_pcm_substream *ss) +snd_ad1889_capture_pointer(snd_pcm_substream_t *ss) { size_t ptr = 0; struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); @@ -572,7 +572,7 @@ snd_ad1889_capture_pointer(struct snd_pcm_substream *ss) return bytes_to_frames(ss->runtime, ptr); } -static struct snd_pcm_ops snd_ad1889_playback_ops = { +static snd_pcm_ops_t snd_ad1889_playback_ops = { .open = snd_ad1889_playback_open, .close = snd_ad1889_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -583,7 +583,7 @@ static struct snd_pcm_ops snd_ad1889_playback_ops = { .pointer = snd_ad1889_playback_pointer, }; -static struct snd_pcm_ops snd_ad1889_capture_ops = { +static snd_pcm_ops_t snd_ad1889_capture_ops = { .open = snd_ad1889_capture_open, .close = snd_ad1889_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -623,11 +623,19 @@ snd_ad1889_interrupt(int irq, return IRQ_HANDLED; } +static void +snd_ad1889_pcm_free(snd_pcm_t *pcm) +{ + struct snd_ad1889 *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + static int __devinit -snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm) +snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, snd_pcm_t **rpcm) { int err; - struct snd_pcm *pcm; + snd_pcm_t *pcm; if (rpcm) *rpcm = NULL; @@ -642,6 +650,7 @@ snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm) &snd_ad1889_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_ad1889_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, chip->card->shortname); @@ -666,7 +675,7 @@ snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm) } static void -snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +snd_ad1889_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { struct snd_ad1889 *chip = entry->private_data; u16 reg; @@ -749,7 +758,7 @@ snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffe static void __devinit snd_ad1889_proc_init(struct snd_ad1889 *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (!snd_card_proc_new(chip->card, chip->card->driver, &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_ad1889_proc_read); @@ -791,14 +800,14 @@ snd_ad1889_ac97_xinit(struct snd_ad1889 *chip) } static void -snd_ad1889_ac97_bus_free(struct snd_ac97_bus *bus) +snd_ad1889_ac97_bus_free(ac97_bus_t *bus) { struct snd_ad1889 *chip = bus->private_data; chip->ac97_bus = NULL; } static void -snd_ad1889_ac97_free(struct snd_ac97 *ac97) +snd_ad1889_ac97_free(ac97_t *ac97) { struct snd_ad1889 *chip = ac97->private_data; chip->ac97 = NULL; @@ -808,8 +817,8 @@ static int __devinit snd_ad1889_ac97_init(struct snd_ad1889 *chip, const char *quirk_override) { int err; - struct snd_ac97_template ac97; - static struct snd_ac97_bus_ops ops = { + ac97_template_t ac97; + static ac97_bus_ops_t ops = { .write = snd_ad1889_ac97_write, .read = snd_ad1889_ac97_read, }; @@ -873,7 +882,7 @@ snd_ad1889_free(struct snd_ad1889 *chip) } static inline int -snd_ad1889_dev_free(struct snd_device *device) +snd_ad1889_dev_free(snd_device_t *device) { struct snd_ad1889 *chip = device->device_data; return snd_ad1889_free(chip); @@ -894,14 +903,14 @@ snd_ad1889_init(struct snd_ad1889 *chip) } static int __devinit -snd_ad1889_create(struct snd_card *card, +snd_ad1889_create(snd_card_t *card, struct pci_dev *pci, struct snd_ad1889 **rchip) { int err; struct snd_ad1889 *chip; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ad1889_dev_free, }; @@ -985,7 +994,7 @@ snd_ad1889_probe(struct pci_dev *pci, { int err; static int devno; - struct snd_card *card; + snd_card_t *card; struct snd_ad1889 *chip; /* (1) */ diff --git a/trunk/sound/pci/ali5451/ali5451.c b/trunk/sound/pci/ali5451/ali5451.c index bc4d1ef08efa..feffbe73387e 100644 --- a/trunk/sound/pci/ali5451/ali5451.c +++ b/trunk/sound/pci/ali5451/ali5451.c @@ -170,10 +170,10 @@ module_param(enable, bool, 0444); #define MAX_CODECS 2 -struct snd_ali; -struct snd_ali_voice; +typedef struct snd_stru_ali ali_t; +typedef struct snd_ali_stru_voice snd_ali_voice_t; -struct snd_ali_channel_control { +typedef struct snd_ali_channel_control { // register data struct REGDATA { unsigned int start; @@ -192,9 +192,9 @@ struct snd_ali_channel_control { unsigned int ac97write; } regs; -}; +} snd_ali_channel_control_t; -struct snd_ali_voice { +struct snd_ali_stru_voice { unsigned int number; unsigned int use: 1, pcm: 1, @@ -203,9 +203,9 @@ struct snd_ali_voice { synth: 1; /* PCM data */ - struct snd_ali *codec; - struct snd_pcm_substream *substream; - struct snd_ali_voice *extra; + ali_t *codec; + snd_pcm_substream_t *substream; + snd_ali_voice_t *extra; unsigned int running: 1; @@ -219,28 +219,28 @@ struct snd_ali_voice { }; -struct snd_alidev { +typedef struct snd_stru_alidev { - struct snd_ali_voice voices[ALI_CHANNELS]; + snd_ali_voice_t voices[ALI_CHANNELS]; unsigned int chcnt; /* num of opened channels */ unsigned int chmap; /* bitmap for opened channels */ unsigned int synthcount; -}; +} alidev_t; #ifdef CONFIG_PM #define ALI_GLOBAL_REGS 56 #define ALI_CHANNEL_REGS 8 -struct snd_ali_image { +typedef struct snd_ali_image { unsigned long regs[ALI_GLOBAL_REGS]; unsigned long channel_regs[ALI_CHANNELS][ALI_CHANNEL_REGS]; -}; +} ali_image_t; #endif -struct snd_ali { +struct snd_stru_ali { unsigned long irq; unsigned long port; unsigned char revision; @@ -252,10 +252,10 @@ struct snd_ali { struct pci_dev *pci_m1533; struct pci_dev *pci_m7101; - struct snd_card *card; - struct snd_pcm *pcm[MAX_CODECS]; - struct snd_alidev synth; - struct snd_ali_channel_control chregs; + snd_card_t *card; + snd_pcm_t *pcm[MAX_CODECS]; + alidev_t synth; + snd_ali_channel_control_t chregs; /* S/PDIF Mask */ unsigned int spdif_mask; @@ -265,8 +265,8 @@ struct snd_ali { unsigned int num_of_codecs; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97[MAX_CODECS]; + ac97_bus_t *ac97_bus; + ac97_t *ac97[MAX_CODECS]; unsigned short ac97_ext_id; unsigned short ac97_ext_status; @@ -274,7 +274,7 @@ struct snd_ali { spinlock_t voice_alloc; #ifdef CONFIG_PM - struct snd_ali_image *image; + ali_image_t *image; #endif }; @@ -284,9 +284,9 @@ static struct pci_device_id snd_ali_ids[] = { }; MODULE_DEVICE_TABLE(pci, snd_ali_ids); -static void snd_ali_clear_voices(struct snd_ali *, unsigned int, unsigned int); -static unsigned short snd_ali_codec_peek(struct snd_ali *, int, unsigned short); -static void snd_ali_codec_poke(struct snd_ali *, int, unsigned short, unsigned short); +static void snd_ali_clear_voices(ali_t *, unsigned int, unsigned int); +static unsigned short snd_ali_codec_peek(ali_t *, int, unsigned short); +static void snd_ali_codec_poke(ali_t *, int, unsigned short, unsigned short); /* * Debug Part @@ -294,7 +294,7 @@ static void snd_ali_codec_poke(struct snd_ali *, int, unsigned short, unsigned s #ifdef ALI_DEBUG -static void ali_read_regs(struct snd_ali *codec, int channel) +static void ali_read_regs(ali_t *codec, int channel) { int i,j; unsigned int dwVal; @@ -344,7 +344,7 @@ static void ali_read_cfg(unsigned int vendor, unsigned deviceid) } pci_dev_put(pci_dev); } -static void ali_read_ac97regs(struct snd_ali *codec, int secondary) +static void ali_read_ac97regs(ali_t *codec, int secondary) { unsigned short i,j; unsigned short wVal; @@ -373,38 +373,40 @@ static void ali_read_ac97regs(struct snd_ali *codec, int secondary) * AC97 ACCESS */ -static inline unsigned int snd_ali_5451_peek(struct snd_ali *codec, +static inline unsigned int snd_ali_5451_peek(ali_t *codec, unsigned int port ) { return (unsigned int)inl(ALI_REG(codec, port)); } -static inline void snd_ali_5451_poke( struct snd_ali *codec, +static inline void snd_ali_5451_poke( ali_t *codec, unsigned int port, unsigned int val ) { outl((unsigned int)val, ALI_REG(codec, port)); } -static int snd_ali_codec_ready( struct snd_ali *codec, - unsigned int port ) +static int snd_ali_codec_ready( ali_t *codec, + unsigned int port, + int sched ) { unsigned long end_time; unsigned int res; - end_time = jiffies + msecs_to_jiffies(250); + end_time = jiffies + 10 * msecs_to_jiffies(250); do { res = snd_ali_5451_peek(codec,port); if (! (res & 0x8000)) return 0; - schedule_timeout_uninterruptible(1); + if (sched) + schedule_timeout_uninterruptible(1); } while (time_after_eq(end_time, jiffies)); snd_ali_5451_poke(codec, port, res & ~0x8000); snd_printdd("ali_codec_ready: codec is not ready.\n "); return -EIO; } -static int snd_ali_stimer_ready(struct snd_ali *codec) +static int snd_ali_stimer_ready(ali_t *codec, int sched) { unsigned long end_time; unsigned long dwChk1,dwChk2; @@ -412,18 +414,19 @@ static int snd_ali_stimer_ready(struct snd_ali *codec) dwChk1 = snd_ali_5451_peek(codec, ALI_STIMER); dwChk2 = snd_ali_5451_peek(codec, ALI_STIMER); - end_time = jiffies + msecs_to_jiffies(250); + end_time = jiffies + 10 * msecs_to_jiffies(250); do { dwChk2 = snd_ali_5451_peek(codec, ALI_STIMER); if (dwChk2 != dwChk1) return 0; - schedule_timeout_uninterruptible(1); + if (sched) + schedule_timeout_uninterruptible(1); } while (time_after_eq(end_time, jiffies)); snd_printk(KERN_ERR "ali_stimer_read: stimer is not ready.\n"); return -EIO; } -static void snd_ali_codec_poke(struct snd_ali *codec,int secondary, +static void snd_ali_codec_poke(ali_t *codec,int secondary, unsigned short reg, unsigned short val) { @@ -437,9 +440,9 @@ static void snd_ali_codec_poke(struct snd_ali *codec,int secondary, port = codec->chregs.regs.ac97write; - if (snd_ali_codec_ready(codec, port) < 0) + if (snd_ali_codec_ready(codec, port, 0) < 0) return; - if (snd_ali_stimer_ready(codec) < 0) + if (snd_ali_stimer_ready(codec, 0) < 0) return; dwVal = (unsigned int) (reg & 0xff); @@ -452,7 +455,7 @@ static void snd_ali_codec_poke(struct snd_ali *codec,int secondary, return ; } -static unsigned short snd_ali_codec_peek( struct snd_ali *codec, +static unsigned short snd_ali_codec_peek( ali_t *codec, int secondary, unsigned short reg) { @@ -466,9 +469,9 @@ static unsigned short snd_ali_codec_peek( struct snd_ali *codec, port = codec->chregs.regs.ac97read; - if (snd_ali_codec_ready(codec, port) < 0) + if (snd_ali_codec_ready(codec, port, 0) < 0) return ~0; - if (snd_ali_stimer_ready(codec) < 0) + if (snd_ali_stimer_ready(codec, 0) < 0) return ~0; dwVal = (unsigned int) (reg & 0xff); @@ -477,19 +480,19 @@ static unsigned short snd_ali_codec_peek( struct snd_ali *codec, snd_ali_5451_poke(codec, port, dwVal); - if (snd_ali_stimer_ready(codec) < 0) + if (snd_ali_stimer_ready(codec, 0) < 0) return ~0; - if (snd_ali_codec_ready(codec, port) < 0) + if (snd_ali_codec_ready(codec, port, 0) < 0) return ~0; return (snd_ali_5451_peek(codec, port) & 0xffff0000)>>16; } -static void snd_ali_codec_write(struct snd_ac97 *ac97, +static void snd_ali_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val ) { - struct snd_ali *codec = ac97->private_data; + ali_t *codec = ac97->private_data; snd_ali_printk("codec_write: reg=%xh data=%xh.\n", reg, val); if(reg == AC97_GPIO_STATUS) { @@ -502,9 +505,9 @@ static void snd_ali_codec_write(struct snd_ac97 *ac97, } -static unsigned short snd_ali_codec_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_ali_codec_read(ac97_t *ac97, unsigned short reg) { - struct snd_ali *codec = ac97->private_data; + ali_t *codec = ac97->private_data; snd_ali_printk("codec_read reg=%xh.\n", reg); return (snd_ali_codec_peek(codec, ac97->num, reg)); @@ -514,7 +517,7 @@ static unsigned short snd_ali_codec_read(struct snd_ac97 *ac97, unsigned short r * AC97 Reset */ -static int snd_ali_reset_5451(struct snd_ali *codec) +static int snd_ali_reset_5451(ali_t *codec) { struct pci_dev *pci_dev = NULL; unsigned short wCount, wReg; @@ -552,7 +555,7 @@ static int snd_ali_reset_5451(struct snd_ali *codec) #ifdef CODEC_RESET -static int snd_ali_reset_codec(struct snd_ali *codec) +static int snd_ali_reset_codec(ali_t *codec) { struct pci_dev *pci_dev = NULL; unsigned char bVal = 0; @@ -593,7 +596,7 @@ static int snd_ali_reset_codec(struct snd_ali *codec) * ALI 5451 Controller */ -static void snd_ali_enable_special_channel(struct snd_ali *codec, unsigned int channel) +static void snd_ali_enable_special_channel(ali_t *codec, unsigned int channel) { unsigned long dwVal = 0; @@ -602,7 +605,7 @@ static void snd_ali_enable_special_channel(struct snd_ali *codec, unsigned int c outl(dwVal, ALI_REG(codec,ALI_GLOBAL_CONTROL)); } -static void snd_ali_disable_special_channel(struct snd_ali *codec, unsigned int channel) +static void snd_ali_disable_special_channel(ali_t *codec, unsigned int channel) { unsigned long dwVal = 0; @@ -611,7 +614,7 @@ static void snd_ali_disable_special_channel(struct snd_ali *codec, unsigned int outl(dwVal, ALI_REG(codec,ALI_GLOBAL_CONTROL)); } -static void snd_ali_enable_address_interrupt(struct snd_ali * codec) +static void snd_ali_enable_address_interrupt(ali_t * codec) { unsigned int gc; @@ -621,7 +624,7 @@ static void snd_ali_enable_address_interrupt(struct snd_ali * codec) outl( gc, ALI_REG(codec, ALI_GC_CIR)); } -static void snd_ali_disable_address_interrupt(struct snd_ali * codec) +static void snd_ali_disable_address_interrupt(ali_t * codec) { unsigned int gc; @@ -632,10 +635,10 @@ static void snd_ali_disable_address_interrupt(struct snd_ali * codec) } #if 0 // not used -static void snd_ali_enable_voice_irq(struct snd_ali *codec, unsigned int channel) +static void snd_ali_enable_voice_irq(ali_t *codec, unsigned int channel) { unsigned int mask; - struct snd_ali_channel_control *pchregs = &(codec->chregs); + snd_ali_channel_control_t *pchregs = &(codec->chregs); snd_ali_printk("enable_voice_irq channel=%d\n",channel); @@ -646,10 +649,10 @@ static void snd_ali_enable_voice_irq(struct snd_ali *codec, unsigned int channel } #endif -static void snd_ali_disable_voice_irq(struct snd_ali *codec, unsigned int channel) +static void snd_ali_disable_voice_irq(ali_t *codec, unsigned int channel) { unsigned int mask; - struct snd_ali_channel_control *pchregs = &(codec->chregs); + snd_ali_channel_control_t *pchregs = &(codec->chregs); snd_ali_printk("disable_voice_irq channel=%d\n",channel); @@ -659,7 +662,7 @@ static void snd_ali_disable_voice_irq(struct snd_ali *codec, unsigned int channe outl(pchregs->data.ainten,ALI_REG(codec,pchregs->regs.ainten)); } -static int snd_ali_alloc_pcm_channel(struct snd_ali *codec, int channel) +static int snd_ali_alloc_pcm_channel(ali_t *codec, int channel) { unsigned int idx = channel & 0x1f; @@ -677,7 +680,7 @@ static int snd_ali_alloc_pcm_channel(struct snd_ali *codec, int channel) return -1; } -static int snd_ali_find_free_channel(struct snd_ali * codec, int rec) +static int snd_ali_find_free_channel(ali_t * codec, int rec) { int idx; int result = -1; @@ -719,7 +722,7 @@ static int snd_ali_find_free_channel(struct snd_ali * codec, int rec) return -1; } -static void snd_ali_free_channel_pcm(struct snd_ali *codec, int channel) +static void snd_ali_free_channel_pcm(ali_t *codec, int channel) { unsigned int idx = channel & 0x0000001f; @@ -738,7 +741,7 @@ static void snd_ali_free_channel_pcm(struct snd_ali *codec, int channel) } #if 0 // not used -static void snd_ali_start_voice(struct snd_ali * codec, unsigned int channel) +static void snd_ali_start_voice(ali_t * codec, unsigned int channel) { unsigned int mask = 1 << (channel & 0x1f); @@ -747,7 +750,7 @@ static void snd_ali_start_voice(struct snd_ali * codec, unsigned int channel) } #endif -static void snd_ali_stop_voice(struct snd_ali * codec, unsigned int channel) +static void snd_ali_stop_voice(ali_t * codec, unsigned int channel) { unsigned int mask = 1 << (channel & 0x1f); @@ -759,7 +762,7 @@ static void snd_ali_stop_voice(struct snd_ali * codec, unsigned int channel) * S/PDIF Part */ -static void snd_ali_delay(struct snd_ali *codec,int interval) +static void snd_ali_delay(ali_t *codec,int interval) { unsigned long begintimer,currenttimer; @@ -767,13 +770,13 @@ static void snd_ali_delay(struct snd_ali *codec,int interval) currenttimer = inl(ALI_REG(codec, ALI_STIMER)); while (currenttimer < begintimer + interval) { - if(snd_ali_stimer_ready(codec) < 0) + if(snd_ali_stimer_ready(codec, 1) < 0) break; currenttimer = inl(ALI_REG(codec, ALI_STIMER)); } } -static void snd_ali_detect_spdif_rate(struct snd_ali *codec) +static void snd_ali_detect_spdif_rate(ali_t *codec) { u16 wval = 0; u16 count = 0; @@ -827,7 +830,7 @@ static void snd_ali_detect_spdif_rate(struct snd_ali *codec) } } -static unsigned int snd_ali_get_spdif_in_rate(struct snd_ali *codec) +static unsigned int snd_ali_get_spdif_in_rate(ali_t *codec) { u32 dwRate = 0; u8 bval = 0; @@ -849,7 +852,7 @@ static unsigned int snd_ali_get_spdif_in_rate(struct snd_ali *codec) return dwRate; } -static void snd_ali_enable_spdif_in(struct snd_ali *codec) +static void snd_ali_enable_spdif_in(ali_t *codec) { unsigned int dwVal; @@ -864,7 +867,7 @@ static void snd_ali_enable_spdif_in(struct snd_ali *codec) snd_ali_enable_special_channel(codec, ALI_SPDIF_IN_CHANNEL); } -static void snd_ali_disable_spdif_in(struct snd_ali *codec) +static void snd_ali_disable_spdif_in(ali_t *codec) { unsigned int dwVal; @@ -876,7 +879,7 @@ static void snd_ali_disable_spdif_in(struct snd_ali *codec) } -static void snd_ali_set_spdif_out_rate(struct snd_ali *codec, unsigned int rate) +static void snd_ali_set_spdif_out_rate(ali_t *codec, unsigned int rate) { unsigned char bVal; unsigned int dwRate = 0; @@ -897,7 +900,7 @@ static void snd_ali_set_spdif_out_rate(struct snd_ali *codec, unsigned int rate) outw(rate | 0x10, ALI_REG(codec, ALI_SPDIF_CS + 2)); } -static void snd_ali_enable_spdif_out(struct snd_ali *codec) +static void snd_ali_enable_spdif_out(ali_t *codec) { unsigned short wVal; unsigned char bVal; @@ -933,7 +936,7 @@ static void snd_ali_enable_spdif_out(struct snd_ali *codec) } } -static void snd_ali_enable_spdif_chnout(struct snd_ali *codec) +static void snd_ali_enable_spdif_chnout(ali_t *codec) { unsigned short wVal = 0; @@ -951,7 +954,7 @@ static void snd_ali_enable_spdif_chnout(struct snd_ali *codec) snd_ali_enable_special_channel(codec,ALI_SPDIF_OUT_CHANNEL); } -static void snd_ali_disable_spdif_chnout(struct snd_ali *codec) +static void snd_ali_disable_spdif_chnout(ali_t *codec) { unsigned short wVal = 0; wVal = inw(ALI_REG(codec, ALI_GLOBAL_CONTROL)); @@ -961,7 +964,7 @@ static void snd_ali_disable_spdif_chnout(struct snd_ali *codec) snd_ali_enable_special_channel(codec, ALI_SPDIF_OUT_CHANNEL); } -static void snd_ali_disable_spdif_out(struct snd_ali *codec) +static void snd_ali_disable_spdif_out(ali_t *codec) { unsigned char bVal; @@ -971,11 +974,11 @@ static void snd_ali_disable_spdif_out(struct snd_ali *codec) snd_ali_disable_spdif_chnout(codec); } -static void snd_ali_update_ptr(struct snd_ali *codec,int channel) +static void snd_ali_update_ptr(ali_t *codec,int channel) { - struct snd_ali_voice *pvoice = NULL; - struct snd_pcm_runtime *runtime; - struct snd_ali_channel_control *pchregs = NULL; + snd_ali_voice_t *pvoice = NULL; + snd_pcm_runtime_t *runtime; + snd_ali_channel_control_t *pchregs = NULL; unsigned int old, mask; #ifdef ALI_DEBUG unsigned int temp, cspf; @@ -1026,11 +1029,11 @@ static void snd_ali_update_ptr(struct snd_ali *codec,int channel) pchregs->data.aint = old & (~mask); } -static void snd_ali_interrupt(struct snd_ali * codec) +static void snd_ali_interrupt(ali_t * codec) { int channel; unsigned int audio_int; - struct snd_ali_channel_control *pchregs = NULL; + snd_ali_channel_control_t *pchregs = NULL; pchregs = &(codec->chregs); audio_int = inl(ALI_REG(codec, ALI_MISCINT)); @@ -1050,7 +1053,7 @@ static irqreturn_t snd_ali_card_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_ali *codec = dev_id; + ali_t *codec = dev_id; if (codec == NULL) return IRQ_NONE; @@ -1059,37 +1062,38 @@ static irqreturn_t snd_ali_card_interrupt(int irq, } -static struct snd_ali_voice *snd_ali_alloc_voice(struct snd_ali * codec, int type, int rec, int channel) +static snd_ali_voice_t *snd_ali_alloc_voice(ali_t * codec, int type, int rec, int channel) { - struct snd_ali_voice *pvoice = NULL; + snd_ali_voice_t *pvoice = NULL; + unsigned long flags; int idx; snd_ali_printk("alloc_voice: type=%d rec=%d\n",type,rec); - spin_lock_irq(&codec->voice_alloc); + spin_lock_irqsave(&codec->voice_alloc, flags); if (type == SNDRV_ALI_VOICE_TYPE_PCM) { idx = channel > 0 ? snd_ali_alloc_pcm_channel(codec, channel) : snd_ali_find_free_channel(codec,rec); if(idx < 0) { snd_printk(KERN_ERR "ali_alloc_voice: err.\n"); - spin_unlock_irq(&codec->voice_alloc); + spin_unlock_irqrestore(&codec->voice_alloc, flags); return NULL; } pvoice = &(codec->synth.voices[idx]); - pvoice->codec = codec; pvoice->use = 1; pvoice->pcm = 1; pvoice->mode = rec; - spin_unlock_irq(&codec->voice_alloc); + spin_unlock_irqrestore(&codec->voice_alloc, flags); return pvoice; } - spin_unlock_irq(&codec->voice_alloc); + spin_unlock_irqrestore(&codec->voice_alloc, flags); return NULL; } -static void snd_ali_free_voice(struct snd_ali * codec, struct snd_ali_voice *pvoice) +static void snd_ali_free_voice(ali_t * codec, snd_ali_voice_t *pvoice) { + unsigned long flags; void (*private_free)(void *); void *private_data; @@ -1097,7 +1101,7 @@ static void snd_ali_free_voice(struct snd_ali * codec, struct snd_ali_voice *pvo if (pvoice == NULL || !pvoice->use) return; snd_ali_clear_voices(codec, pvoice->number, pvoice->number); - spin_lock_irq(&codec->voice_alloc); + spin_lock_irqsave(&codec->voice_alloc, flags); private_free = pvoice->private_free; private_data = pvoice->private_data; pvoice->private_free = NULL; @@ -1107,13 +1111,13 @@ static void snd_ali_free_voice(struct snd_ali * codec, struct snd_ali_voice *pvo } pvoice->use = pvoice->pcm = pvoice->synth = 0; pvoice->substream = NULL; - spin_unlock_irq(&codec->voice_alloc); + spin_unlock_irqrestore(&codec->voice_alloc, flags); if (private_free) private_free(private_data); } -static void snd_ali_clear_voices(struct snd_ali * codec, +static void snd_ali_clear_voices(ali_t * codec, unsigned int v_min, unsigned int v_max) { @@ -1125,7 +1129,7 @@ static void snd_ali_clear_voices(struct snd_ali * codec, } } -static void snd_ali_write_voice_regs(struct snd_ali * codec, +static void snd_ali_write_voice_regs(ali_t * codec, unsigned int Channel, unsigned int LBA, unsigned int CSO, @@ -1192,10 +1196,10 @@ static unsigned int snd_ali_convert_rate(unsigned int rate, int rec) return delta; } -static unsigned int snd_ali_control_mode(struct snd_pcm_substream *substream) +static unsigned int snd_ali_control_mode(snd_pcm_substream_t *substream) { unsigned int CTRL; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; /* set ctrl mode CTRL default: 8-bit (unsigned) mono, loop mode enabled @@ -1214,21 +1218,21 @@ static unsigned int snd_ali_control_mode(struct snd_pcm_substream *substream) * PCM part */ -static int snd_ali_ioctl(struct snd_pcm_substream *substream, +static int snd_ali_ioctl(snd_pcm_substream_t * substream, unsigned int cmd, void *arg) { return snd_pcm_lib_ioctl(substream, cmd, arg); } -static int snd_ali_trigger(struct snd_pcm_substream *substream, +static int snd_ali_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); + ali_t *codec = snd_pcm_substream_chip(substream); struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; unsigned int what, whati, capture_flag; - struct snd_ali_voice *pvoice = NULL, *evoice = NULL; + snd_ali_voice_t *pvoice = NULL, *evoice = NULL; unsigned int val; int do_start; @@ -1246,8 +1250,8 @@ static int snd_ali_trigger(struct snd_pcm_substream *substream, what = whati = capture_flag = 0; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); - if ((struct snd_ali *) snd_pcm_substream_chip(s) == codec) { - pvoice = s->runtime->private_data; + if ((ali_t *) snd_pcm_substream_chip(s) == codec) { + pvoice = (snd_ali_voice_t *) s->runtime->private_data; evoice = pvoice->extra; what |= 1 << (pvoice->number & 0x1f); if (evoice == NULL) { @@ -1290,13 +1294,13 @@ static int snd_ali_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_ali_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ali_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ali_voice *pvoice = runtime->private_data; - struct snd_ali_voice *evoice = pvoice->extra; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) runtime->private_data; + snd_ali_voice_t *evoice = pvoice->extra; int err; err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); if (err < 0) return err; @@ -1321,12 +1325,12 @@ static int snd_ali_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_ali_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_ali_playback_hw_free(snd_pcm_substream_t * substream) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ali_voice *pvoice = runtime->private_data; - struct snd_ali_voice *evoice = pvoice ? pvoice->extra : NULL; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) runtime->private_data; + snd_ali_voice_t *evoice = pvoice ? pvoice->extra : NULL; snd_pcm_lib_free_pages(substream); if (evoice != NULL) { @@ -1336,23 +1340,24 @@ static int snd_ali_playback_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_ali_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ali_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_ali_hw_free(struct snd_pcm_substream *substream) +static int snd_ali_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_ali_playback_prepare(struct snd_pcm_substream *substream) +static int snd_ali_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ali_voice *pvoice = runtime->private_data; - struct snd_ali_voice *evoice = pvoice->extra; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) runtime->private_data; + snd_ali_voice_t *evoice = pvoice->extra; + unsigned long flags; unsigned int LBA; unsigned int Delta; @@ -1365,7 +1370,7 @@ static int snd_ali_playback_prepare(struct snd_pcm_substream *substream) snd_ali_printk("playback_prepare ...\n"); - spin_lock_irq(&codec->reg_lock); + spin_lock_irqsave(&codec->reg_lock, flags); /* set Delta (rate) value */ Delta = snd_ali_convert_rate(runtime->rate, 0); @@ -1430,16 +1435,17 @@ static int snd_ali_playback_prepare(struct snd_pcm_substream *substream) CTRL, EC); } - spin_unlock_irq(&codec->reg_lock); + spin_unlock_irqrestore(&codec->reg_lock, flags); return 0; } -static int snd_ali_prepare(struct snd_pcm_substream *substream) +static int snd_ali_prepare(snd_pcm_substream_t * substream) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ali_voice *pvoice = runtime->private_data; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) runtime->private_data; + unsigned long flags; unsigned int LBA; unsigned int Delta; unsigned int ESO; @@ -1450,7 +1456,7 @@ static int snd_ali_prepare(struct snd_pcm_substream *substream) unsigned int EC; u8 bValue; - spin_lock_irq(&codec->reg_lock); + spin_lock_irqsave(&codec->reg_lock, flags); snd_ali_printk("ali_prepare...\n"); @@ -1465,16 +1471,15 @@ static int snd_ali_prepare(struct snd_pcm_substream *substream) unsigned int rate; - spin_unlock_irq(&codec->reg_lock); - if (codec->revision != ALI_5451_V02) + if (codec->revision != ALI_5451_V02) { + spin_unlock_irqrestore(&codec->reg_lock, flags); return -1; - + } rate = snd_ali_get_spdif_in_rate(codec); if (rate == 0) { snd_printk(KERN_WARNING "ali_capture_preapre: spdif rate detect err!\n"); rate = 48000; } - spin_lock_irq(&codec->reg_lock); bValue = inb(ALI_REG(codec,ALI_SPDIF_CTRL)); if (bValue & 0x10) { outb(bValue,ALI_REG(codec,ALI_SPDIF_CTRL)); @@ -1516,17 +1521,17 @@ static int snd_ali_prepare(struct snd_pcm_substream *substream) EC); - spin_unlock_irq(&codec->reg_lock); + spin_unlock_irqrestore(&codec->reg_lock, flags); return 0; } -static snd_pcm_uframes_t snd_ali_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ali_playback_pointer(snd_pcm_substream_t *substream) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ali_voice *pvoice = runtime->private_data; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) runtime->private_data; unsigned int cso; spin_lock(&codec->reg_lock); @@ -1543,26 +1548,27 @@ static snd_pcm_uframes_t snd_ali_playback_pointer(struct snd_pcm_substream *subs } -static snd_pcm_uframes_t snd_ali_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ali_pointer(snd_pcm_substream_t *substream) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ali_voice *pvoice = runtime->private_data; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) runtime->private_data; unsigned int cso; + unsigned long flags; - spin_lock(&codec->reg_lock); + spin_lock_irqsave(&codec->reg_lock, flags); if (!pvoice->running) { - spin_unlock_irq(&codec->reg_lock); + spin_unlock_irqrestore(&codec->reg_lock, flags); return 0; } outb(pvoice->number, ALI_REG(codec, ALI_GC_CIR)); cso = inw(ALI_REG(codec, ALI_CSO_ALPHA_FMS + 2)); - spin_unlock(&codec->reg_lock); + spin_unlock_irqrestore(&codec->reg_lock, flags); return cso; } -static struct snd_pcm_hardware snd_ali_playback = +static snd_pcm_hardware_t snd_ali_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1588,7 +1594,7 @@ static struct snd_pcm_hardware snd_ali_playback = * Capture support device description */ -static struct snd_pcm_hardware snd_ali_capture = +static snd_pcm_hardware_t snd_ali_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1610,27 +1616,36 @@ static struct snd_pcm_hardware snd_ali_capture = .fifo_size = 0, }; -static void snd_ali_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_ali_pcm_free_substream(snd_pcm_runtime_t *runtime) { - struct snd_ali_voice *pvoice = runtime->private_data; - struct snd_ali *codec; + unsigned long flags; + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) runtime->private_data; + ali_t *codec; if (pvoice) { codec = pvoice->codec; + spin_lock_irqsave(&codec->reg_lock, flags); snd_ali_free_voice(pvoice->codec, pvoice); + spin_unlock_irqrestore(&codec->reg_lock, flags); } } -static int snd_ali_open(struct snd_pcm_substream *substream, int rec, int channel, - struct snd_pcm_hardware *phw) +static int snd_ali_open(snd_pcm_substream_t * substream, int rec, int channel, + snd_pcm_hardware_t *phw) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ali_voice *pvoice; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_ali_voice_t *pvoice; + unsigned long flags = 0; + spin_lock_irqsave(&codec->reg_lock, flags); pvoice = snd_ali_alloc_voice(codec, SNDRV_ALI_VOICE_TYPE_PCM, rec, channel); - if (pvoice == NULL) + if (pvoice == NULL) { + spin_unlock_irqrestore(&codec->reg_lock, flags); return -EAGAIN; + } + pvoice->codec = codec; + spin_unlock_irqrestore(&codec->reg_lock, flags); pvoice->substream = substream; runtime->private_data = pvoice; @@ -1642,32 +1657,32 @@ static int snd_ali_open(struct snd_pcm_substream *substream, int rec, int channe return 0; } -static int snd_ali_playback_open(struct snd_pcm_substream *substream) +static int snd_ali_playback_open(snd_pcm_substream_t * substream) { return snd_ali_open(substream, 0, -1, &snd_ali_playback); } -static int snd_ali_capture_open(struct snd_pcm_substream *substream) +static int snd_ali_capture_open(snd_pcm_substream_t * substream) { return snd_ali_open(substream, 1, -1, &snd_ali_capture); } -static int snd_ali_playback_close(struct snd_pcm_substream *substream) +static int snd_ali_playback_close(snd_pcm_substream_t * substream) { return 0; } -static int snd_ali_close(struct snd_pcm_substream *substream) +static int snd_ali_close(snd_pcm_substream_t * substream) { - struct snd_ali *codec = snd_pcm_substream_chip(substream); - struct snd_ali_voice *pvoice = substream->runtime->private_data; + ali_t *codec = snd_pcm_substream_chip(substream); + snd_ali_voice_t *pvoice = (snd_ali_voice_t *) substream->runtime->private_data; snd_ali_disable_special_channel(codec,pvoice->number); return 0; } -static struct snd_pcm_ops snd_ali_playback_ops = { +static snd_pcm_ops_t snd_ali_playback_ops = { .open = snd_ali_playback_open, .close = snd_ali_playback_close, .ioctl = snd_ali_ioctl, @@ -1678,7 +1693,7 @@ static struct snd_pcm_ops snd_ali_playback_ops = { .pointer = snd_ali_playback_pointer, }; -static struct snd_pcm_ops snd_ali_capture_ops = { +static snd_pcm_ops_t snd_ali_capture_ops = { .open = snd_ali_capture_open, .close = snd_ali_close, .ioctl = snd_ali_ioctl, @@ -1693,17 +1708,17 @@ static struct snd_pcm_ops snd_ali_capture_ops = { * Modem PCM */ -static int snd_ali_modem_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ali_modem_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_ali *chip = snd_pcm_substream_chip(substream); + ali_t *chip = snd_pcm_substream_chip(substream); unsigned int modem_num = chip->num_of_codecs - 1; snd_ac97_write(chip->ac97[modem_num], AC97_LINE1_RATE, params_rate(hw_params)); snd_ac97_write(chip->ac97[modem_num], AC97_LINE1_LEVEL, 0); return snd_ali_hw_params(substream, hw_params); } -static struct snd_pcm_hardware snd_ali_modem = +static snd_pcm_hardware_t snd_ali_modem = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1724,10 +1739,10 @@ static struct snd_pcm_hardware snd_ali_modem = .fifo_size = 0, }; -static int snd_ali_modem_open(struct snd_pcm_substream *substream, int rec, int channel) +static int snd_ali_modem_open(snd_pcm_substream_t * substream, int rec, int channel) { static unsigned int rates [] = {8000,9600,12000,16000}; - static struct snd_pcm_hw_constraint_list hw_constraint_rates = { + static snd_pcm_hw_constraint_list_t hw_constraint_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, @@ -1739,17 +1754,17 @@ static int snd_ali_modem_open(struct snd_pcm_substream *substream, int rec, int SNDRV_PCM_HW_PARAM_RATE, &hw_constraint_rates); } -static int snd_ali_modem_playback_open(struct snd_pcm_substream *substream) +static int snd_ali_modem_playback_open(snd_pcm_substream_t * substream) { return snd_ali_modem_open(substream, 0, ALI_MODEM_OUT_CHANNEL); } -static int snd_ali_modem_capture_open(struct snd_pcm_substream *substream) +static int snd_ali_modem_capture_open(snd_pcm_substream_t * substream) { return snd_ali_modem_open(substream, 1, ALI_MODEM_IN_CHANNEL); } -static struct snd_pcm_ops snd_ali_modem_playback_ops = { +static snd_pcm_ops_t snd_ali_modem_playback_ops = { .open = snd_ali_modem_playback_open, .close = snd_ali_close, .ioctl = snd_pcm_lib_ioctl, @@ -1760,7 +1775,7 @@ static struct snd_pcm_ops snd_ali_modem_playback_ops = { .pointer = snd_ali_pointer, }; -static struct snd_pcm_ops snd_ali_modem_capture_ops = { +static snd_pcm_ops_t snd_ali_modem_capture_ops = { .open = snd_ali_modem_capture_open, .close = snd_ali_close, .ioctl = snd_pcm_lib_ioctl, @@ -1776,22 +1791,22 @@ struct ali_pcm_description { char *name; unsigned int playback_num; unsigned int capture_num; - struct snd_pcm_ops *playback_ops; - struct snd_pcm_ops *capture_ops; + snd_pcm_ops_t *playback_ops; + snd_pcm_ops_t *capture_ops; unsigned short class; }; -static void snd_ali_pcm_free(struct snd_pcm *pcm) +static void snd_ali_pcm_free(snd_pcm_t *pcm) { - struct snd_ali *codec = pcm->private_data; + ali_t *codec = pcm->private_data; codec->pcm[pcm->device] = NULL; } -static int __devinit snd_ali_pcm(struct snd_ali * codec, int device, struct ali_pcm_description *desc) +static int __devinit snd_ali_pcm(ali_t * codec, int device, struct ali_pcm_description *desc) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; err = snd_pcm_new(codec->card, desc->name, device, @@ -1823,7 +1838,7 @@ static struct ali_pcm_description ali_pcms[] = { { "ALI 5451 modem", 1, 1, &snd_ali_modem_playback_ops, &snd_ali_modem_capture_ops, SNDRV_PCM_CLASS_MODEM } }; -static int __devinit snd_ali_build_pcms(struct snd_ali *codec) +static int __devinit snd_ali_build_pcms(ali_t *codec) { int i, err; for(i = 0 ; i < codec->num_of_codecs && i < ARRAY_SIZE(ali_pcms) ; i++) @@ -1838,7 +1853,7 @@ static int __devinit snd_ali_build_pcms(struct snd_ali *codec) .info = snd_ali5451_spdif_info, .get = snd_ali5451_spdif_get, \ .put = snd_ali5451_spdif_put, .private_value = value} -static int snd_ali5451_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ali5451_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1847,14 +1862,15 @@ static int snd_ali5451_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ali5451_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ali5451_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ali *codec = kcontrol->private_data; + unsigned long flags; + ali_t *codec = kcontrol->private_data; unsigned int enable; enable = ucontrol->value.integer.value[0] ? 1 : 0; - spin_lock_irq(&codec->reg_lock); + spin_lock_irqsave(&codec->reg_lock, flags); switch(kcontrol->private_value) { case 0: enable = (codec->spdif_mask & 0x02) ? 1 : 0; @@ -1869,18 +1885,19 @@ static int snd_ali5451_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e break; } ucontrol->value.integer.value[0] = enable; - spin_unlock_irq(&codec->reg_lock); + spin_unlock_irqrestore(&codec->reg_lock, flags); return 0; } -static int snd_ali5451_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ali5451_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ali *codec = kcontrol->private_data; + unsigned long flags; + ali_t *codec = kcontrol->private_data; unsigned int change = 0, enable = 0; enable = ucontrol->value.integer.value[0] ? 1 : 0; - spin_lock_irq(&codec->reg_lock); + spin_lock_irqsave(&codec->reg_lock, flags); switch (kcontrol->private_value) { case 0: change = (codec->spdif_mask & 0x02) ? 1 : 0; @@ -1925,12 +1942,12 @@ static int snd_ali5451_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e default: break; } - spin_unlock_irq(&codec->reg_lock); + spin_unlock_irqrestore(&codec->reg_lock, flags); return change; } -static struct snd_kcontrol_new snd_ali5451_mixer_spdif[] __devinitdata = { +static snd_kcontrol_new_t snd_ali5451_mixer_spdif[] __devinitdata = { /* spdif aplayback switch */ /* FIXME: "IEC958 Playback Switch" may conflict with one on ac97_codec */ ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Output ",NONE,SWITCH), 0, 0), @@ -1940,24 +1957,24 @@ static struct snd_kcontrol_new snd_ali5451_mixer_spdif[] __devinitdata = { ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0, 2) }; -static void snd_ali_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_ali_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct snd_ali *codec = bus->private_data; + ali_t *codec = bus->private_data; codec->ac97_bus = NULL; } -static void snd_ali_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_ali_mixer_free_ac97(ac97_t *ac97) { - struct snd_ali *codec = ac97->private_data; + ali_t *codec = ac97->private_data; codec->ac97[ac97->num] = NULL; } -static int __devinit snd_ali_mixer(struct snd_ali * codec) +static int __devinit snd_ali_mixer(ali_t * codec) { - struct snd_ac97_template ac97; + ac97_template_t ac97; unsigned int idx; int i, err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_ali_codec_write, .read = snd_ali_codec_read, }; @@ -1991,21 +2008,21 @@ static int __devinit snd_ali_mixer(struct snd_ali * codec) } #ifdef CONFIG_PM -static int ali_suspend(struct pci_dev *pci, pm_message_t state) +static int ali_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_ali *chip = card->private_data; - struct snd_ali_image *im; + ali_t *chip = card->pm_private_data; + ali_image_t *im; int i, j; im = chip->image; if (! im) return 0; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for(i = 0 ; i < chip->num_of_codecs ; i++) { - snd_pcm_suspend_all(chip->pcm[i]); - snd_ac97_suspend(chip->ac97[i]); + if (chip->pcm[i]) + snd_pcm_suspend_all(chip->pcm[i]); + if(chip->ac97[i]) + snd_ac97_suspend(chip->ac97[i]); } spin_lock_irq(&chip->reg_lock); @@ -2033,24 +2050,21 @@ static int ali_suspend(struct pci_dev *pci, pm_message_t state) outl(0xffffffff, ALI_REG(chip, ALI_STOP)); spin_unlock_irq(&chip->reg_lock); - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -static int ali_resume(struct pci_dev *pci) +static int ali_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_ali *chip = card->private_data; - struct snd_ali_image *im; + ali_t *chip = card->pm_private_data; + ali_image_t *im; int i, j; im = chip->image; if (! im) return 0; - pci_restore_state(pci); - pci_enable_device(pci); + pci_enable_device(chip->pci); spin_lock_irq(&chip->reg_lock); @@ -2074,14 +2088,14 @@ static int ali_resume(struct pci_dev *pci) spin_unlock_irq(&chip->reg_lock); for(i = 0 ; i < chip->num_of_codecs ; i++) - snd_ac97_resume(chip->ac97[i]); + if(chip->ac97[i]) + snd_ac97_resume(chip->ac97[i]); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -static int snd_ali_free(struct snd_ali * codec) +static int snd_ali_free(ali_t * codec) { if (codec->hw_initialized) snd_ali_disable_address_interrupt(codec); @@ -2101,7 +2115,7 @@ static int snd_ali_free(struct snd_ali * codec) return 0; } -static int snd_ali_chip_init(struct snd_ali *codec) +static int snd_ali_chip_init(ali_t *codec) { unsigned int legacy; unsigned char temp; @@ -2160,22 +2174,22 @@ static int snd_ali_chip_init(struct snd_ali *codec) } /* proc for register dump */ -static void snd_ali_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) +static void snd_ali_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buf) { - struct snd_ali *codec = entry->private_data; + ali_t *codec = entry->private_data; int i; for(i = 0 ; i < 256 ; i+= 4) snd_iprintf(buf, "%02x: %08x\n", i, inl(ALI_REG(codec, i))); } -static void __devinit snd_ali_proc_init(struct snd_ali *codec) +static void __devinit snd_ali_proc_init(ali_t *codec) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if(!snd_card_proc_new(codec->card, "ali5451", &entry)) snd_info_set_text_ops(entry, codec, 1024, snd_ali_proc_read); } -static int __devinit snd_ali_resources(struct snd_ali *codec) +static int __devinit snd_ali_resources(ali_t *codec) { int err; @@ -2192,24 +2206,27 @@ static int __devinit snd_ali_resources(struct snd_ali *codec) snd_ali_printk("resouces allocated.\n"); return 0; } -static int snd_ali_dev_free(struct snd_device *device) +static int snd_ali_dev_free(snd_device_t *device) { - struct snd_ali *codec=device->device_data; + ali_t *codec=device->device_data; snd_ali_free(codec); return 0; } -static int __devinit snd_ali_create(struct snd_card *card, +static int __devinit snd_ali_create(snd_card_t * card, struct pci_dev *pci, int pcm_streams, int spdif_support, - struct snd_ali ** r_ali) + ali_t ** r_ali) { - struct snd_ali *codec; + ali_t *codec; int i, err; - unsigned short cmdw; - static struct snd_device_ops ops = { - .dev_free = snd_ali_dev_free, + unsigned short cmdw = 0; + struct pci_dev *pci_dev = NULL; + static snd_device_ops_t ops = { + (snd_dev_free_t *)snd_ali_dev_free, + NULL, + NULL }; *r_ali = NULL; @@ -2283,14 +2300,16 @@ static int __devinit snd_ali_create(struct snd_card *card, codec->chregs.data.ainten = 0x00; /* M1533: southbridge */ - codec->pci_m1533 = pci_get_device(0x10b9, 0x1533, NULL); + pci_dev = pci_get_device(0x10b9, 0x1533, NULL); + codec->pci_m1533 = pci_dev; if (! codec->pci_m1533) { snd_printk(KERN_ERR "ali5451: cannot find ALi 1533 chip.\n"); snd_ali_free(codec); return -ENODEV; } /* M7101: power management */ - codec->pci_m7101 = pci_get_device(0x10b9, 0x7101, NULL); + pci_dev = pci_get_device(0x10b9, 0x7101, NULL); + codec->pci_m7101 = pci_dev; if (! codec->pci_m7101 && codec->revision == ALI_5451_V02) { snd_printk(KERN_ERR "ali5451: cannot find ALi 7101 chip.\n"); snd_ali_free(codec); @@ -2317,6 +2336,8 @@ static int __devinit snd_ali_create(struct snd_card *card, codec->image = kmalloc(sizeof(*codec->image), GFP_KERNEL); if (! codec->image) snd_printk(KERN_WARNING "can't allocate apm buffer\n"); + else + snd_card_set_pm_callback(card, ali_suspend, ali_resume, codec); #endif snd_ali_enable_address_interrupt(codec); @@ -2330,8 +2351,8 @@ static int __devinit snd_ali_create(struct snd_card *card, static int __devinit snd_ali_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct snd_ali *codec; + snd_card_t *card; + ali_t *codec; int err; snd_ali_printk("probe ...\n"); @@ -2344,7 +2365,6 @@ static int __devinit snd_ali_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = codec; snd_ali_printk("mixer building ...\n"); if ((err = snd_ali_mixer(codec)) < 0) { @@ -2386,10 +2406,7 @@ static struct pci_driver driver = { .id_table = snd_ali_ids, .probe = snd_ali_probe, .remove = __devexit_p(snd_ali_remove), -#ifdef CONFIG_PM - .suspend = ali_suspend, - .resume = ali_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_ali_init(void) diff --git a/trunk/sound/pci/als4000.c b/trunk/sound/pci/als4000.c index 7b2ff5f4672e..1904df650265 100644 --- a/trunk/sound/pci/als4000.c +++ b/trunk/sound/pci/als4000.c @@ -6,21 +6,6 @@ * * Framework borrowed from Massimo Piccioni's card-als100.c. * - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * * NOTES * * Since Avance does not provide any meaningful documentation, and I @@ -58,9 +43,19 @@ * Set KSound: * - value -> some port 0x0c0d * - * ToDo: - * - Proper shared IRQ handling? - * - power management? (card can do voice wakeup according to datasheet!!) + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include <sound/driver.h> @@ -105,15 +100,13 @@ module_param_array(joystick_port, int, NULL, 0444); MODULE_PARM_DESC(joystick_port, "Joystick port address for ALS4000 soundcard. (0 = disabled)"); #endif -struct snd_card_als4000 { - /* most frequent access first */ - unsigned long gcr; +typedef struct { struct pci_dev *pci; - struct snd_sb *chip; + unsigned long gcr; #ifdef SUPPORT_JOYSTICK struct gameport *gameport; #endif -}; +} snd_card_als4000_t; static struct pci_device_id snd_als4000_ids[] = { { 0x4005, 0x4000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* ALS4000 */ @@ -128,7 +121,7 @@ static inline void snd_als4000_gcr_write_addr(unsigned long port, u32 reg, u32 v outl(val, port+0x08); } -static inline void snd_als4000_gcr_write(struct snd_sb *sb, u32 reg, u32 val) +static inline void snd_als4000_gcr_write(sb_t *sb, u32 reg, u32 val) { snd_als4000_gcr_write_addr(sb->alt_port, reg, val); } @@ -139,12 +132,12 @@ static inline u32 snd_als4000_gcr_read_addr(unsigned long port, u32 reg) return inl(port+0x08); } -static inline u32 snd_als4000_gcr_read(struct snd_sb *sb, u32 reg) +static inline u32 snd_als4000_gcr_read(sb_t *sb, u32 reg) { return snd_als4000_gcr_read_addr(sb->alt_port, reg); } -static void snd_als4000_set_rate(struct snd_sb *chip, unsigned int rate) +static void snd_als4000_set_rate(sb_t *chip, unsigned int rate) { if (!(chip->mode & SB_RATE_LOCK)) { snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE_OUT); @@ -153,15 +146,13 @@ static void snd_als4000_set_rate(struct snd_sb *chip, unsigned int rate) } } -static inline void snd_als4000_set_capture_dma(struct snd_sb *chip, - dma_addr_t addr, unsigned size) +static void snd_als4000_set_capture_dma(sb_t *chip, dma_addr_t addr, unsigned size) { snd_als4000_gcr_write(chip, 0xa2, addr); snd_als4000_gcr_write(chip, 0xa3, (size-1)); } -static inline void snd_als4000_set_playback_dma(struct snd_sb *chip, - dma_addr_t addr, unsigned size) +static void snd_als4000_set_playback_dma(sb_t *chip, dma_addr_t addr, unsigned size) { snd_als4000_gcr_write(chip, 0x91, addr); snd_als4000_gcr_write(chip, 0x92, (size-1)|0x180000); @@ -171,7 +162,7 @@ static inline void snd_als4000_set_playback_dma(struct snd_sb *chip, #define ALS4000_FORMAT_16BIT (1<<1) #define ALS4000_FORMAT_STEREO (1<<2) -static int snd_als4000_get_format(struct snd_pcm_runtime *runtime) +static int snd_als4000_get_format(snd_pcm_runtime_t *runtime) { int result; @@ -186,7 +177,7 @@ static int snd_als4000_get_format(struct snd_pcm_runtime *runtime) } /* structure for setting up playback */ -static const struct { +static struct { unsigned char dsp_cmd, dma_on, dma_off, format; } playback_cmd_vals[]={ /* ALS4000_FORMAT_U8_MONO */ @@ -210,7 +201,7 @@ static const struct { /* structure for setting up capture */ enum { CMD_WIDTH8=0x04, CMD_SIGNED=0x10, CMD_MONO=0x80, CMD_STEREO=0xA0 }; -static const unsigned char capture_cmd_vals[]= +static unsigned char capture_cmd_vals[]= { CMD_WIDTH8|CMD_MONO, /* ALS4000_FORMAT_U8_MONO */ CMD_WIDTH8|CMD_SIGNED|CMD_MONO, /* ALS4000_FORMAT_S8_MONO */ @@ -223,22 +214,23 @@ CMD_SIGNED|CMD_STEREO, /* ALS4000_FORMAT_S16L_STEREO */ }; #define capture_cmd(chip) (capture_cmd_vals[(chip)->capture_format]) -static int snd_als4000_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_als4000_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_als4000_hw_free(struct snd_pcm_substream *substream) +static int snd_als4000_hw_free(snd_pcm_substream_t * substream) { snd_pcm_lib_free_pages(substream); return 0; } -static int snd_als4000_capture_prepare(struct snd_pcm_substream *substream) +static int snd_als4000_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + unsigned long flags; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long size; unsigned count; @@ -251,21 +243,22 @@ static int snd_als4000_capture_prepare(struct snd_pcm_substream *substream) count >>=1; count--; - spin_lock_irq(&chip->reg_lock); + spin_lock_irqsave(&chip->reg_lock, flags); snd_als4000_set_rate(chip, runtime->rate); snd_als4000_set_capture_dma(chip, runtime->dma_addr, size); - spin_unlock_irq(&chip->reg_lock); - spin_lock_irq(&chip->mixer_lock); + spin_unlock_irqrestore(&chip->reg_lock, flags); + spin_lock_irqsave(&chip->mixer_lock, flags ); snd_sbmixer_write(chip, 0xdc, count); snd_sbmixer_write(chip, 0xdd, count>>8); - spin_unlock_irq(&chip->mixer_lock); + spin_unlock_irqrestore(&chip->mixer_lock, flags ); return 0; } -static int snd_als4000_playback_prepare(struct snd_pcm_substream *substream) +static int snd_als4000_playback_prepare(snd_pcm_substream_t *substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + unsigned long flags; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long size; unsigned count; @@ -284,7 +277,7 @@ static int snd_als4000_playback_prepare(struct snd_pcm_substream *substream) * reordering, ...). Something seems to get enabled on playback * that I haven't found out how to disable again, which then causes * the switching pops to reach the speakers the next time here. */ - spin_lock_irq(&chip->reg_lock); + spin_lock_irqsave(&chip->reg_lock, flags); snd_als4000_set_rate(chip, runtime->rate); snd_als4000_set_playback_dma(chip, runtime->dma_addr, size); @@ -295,64 +288,52 @@ static int snd_als4000_playback_prepare(struct snd_pcm_substream *substream) snd_sbdsp_command(chip, count); snd_sbdsp_command(chip, count>>8); snd_sbdsp_command(chip, playback_cmd(chip).dma_off); - spin_unlock_irq(&chip->reg_lock); + spin_unlock_irqrestore(&chip->reg_lock, flags); return 0; } -static int snd_als4000_capture_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_als4000_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); int result = 0; spin_lock(&chip->mixer_lock); - switch (cmd) { - case SNDRV_PCM_TRIGGER_START: - case SNDRV_PCM_TRIGGER_RESUME: + if (cmd == SNDRV_PCM_TRIGGER_START) { chip->mode |= SB_RATE_LOCK_CAPTURE; snd_sbmixer_write(chip, 0xde, capture_cmd(chip)); - break; - case SNDRV_PCM_TRIGGER_STOP: - case SNDRV_PCM_TRIGGER_SUSPEND: + } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { chip->mode &= ~SB_RATE_LOCK_CAPTURE; snd_sbmixer_write(chip, 0xde, 0); - break; - default: + } else { result = -EINVAL; - break; } spin_unlock(&chip->mixer_lock); return result; } -static int snd_als4000_playback_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_als4000_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); int result = 0; spin_lock(&chip->reg_lock); - switch (cmd) { - case SNDRV_PCM_TRIGGER_START: - case SNDRV_PCM_TRIGGER_RESUME: + if (cmd == SNDRV_PCM_TRIGGER_START) { chip->mode |= SB_RATE_LOCK_PLAYBACK; snd_sbdsp_command(chip, playback_cmd(chip).dma_on); - break; - case SNDRV_PCM_TRIGGER_STOP: - case SNDRV_PCM_TRIGGER_SUSPEND: + } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { snd_sbdsp_command(chip, playback_cmd(chip).dma_off); chip->mode &= ~SB_RATE_LOCK_PLAYBACK; - break; - default: + } else { result = -EINVAL; - break; } spin_unlock(&chip->reg_lock); return result; } -static snd_pcm_uframes_t snd_als4000_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_als4000_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); unsigned int result; spin_lock(&chip->reg_lock); @@ -361,9 +342,9 @@ static snd_pcm_uframes_t snd_als4000_capture_pointer(struct snd_pcm_substream *s return bytes_to_frames( substream->runtime, result ); } -static snd_pcm_uframes_t snd_als4000_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_als4000_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); unsigned result; spin_lock(&chip->reg_lock); @@ -372,21 +353,9 @@ static snd_pcm_uframes_t snd_als4000_playback_pointer(struct snd_pcm_substream * return bytes_to_frames( substream->runtime, result ); } -/* FIXME: this IRQ routine doesn't really support IRQ sharing (we always - * return IRQ_HANDLED no matter whether we actually had an IRQ flag or not). - * ALS4000a.PDF writes that while ACKing IRQ in PCI block will *not* ACK - * the IRQ in the SB core, ACKing IRQ in SB block *will* ACK the PCI IRQ - * register (alt_port + 0x0e). Probably something could be optimized here to - * query/write one register only... - * And even if both registers need to be queried, then there's still the - * question of whether it's actually correct to ACK PCI IRQ before reading - * SB IRQ like we do now, since ALS4000a.PDF mentions that PCI IRQ will *clear* - * SB IRQ status. - * And do we *really* need the lock here for *reading* SB_DSP4_IRQSTATUS?? - * */ static irqreturn_t snd_als4000_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_sb *chip = dev_id; + sb_t *chip = dev_id; unsigned gcr_status; unsigned sb_status; @@ -419,7 +388,7 @@ static irqreturn_t snd_als4000_interrupt(int irq, void *dev_id, struct pt_regs * /*****************************************************************/ -static struct snd_pcm_hardware snd_als4000_playback = +static snd_pcm_hardware_t snd_als4000_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -438,7 +407,7 @@ static struct snd_pcm_hardware snd_als4000_playback = .fifo_size = 0 }; -static struct snd_pcm_hardware snd_als4000_capture = +static snd_pcm_hardware_t snd_als4000_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID), @@ -459,38 +428,38 @@ static struct snd_pcm_hardware snd_als4000_capture = /*****************************************************************/ -static int snd_als4000_playback_open(struct snd_pcm_substream *substream) +static int snd_als4000_playback_open(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; chip->playback_substream = substream; runtime->hw = snd_als4000_playback; return 0; } -static int snd_als4000_playback_close(struct snd_pcm_substream *substream) +static int snd_als4000_playback_close(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); chip->playback_substream = NULL; snd_pcm_lib_free_pages(substream); return 0; } -static int snd_als4000_capture_open(struct snd_pcm_substream *substream) +static int snd_als4000_capture_open(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sb_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; chip->capture_substream = substream; runtime->hw = snd_als4000_capture; return 0; } -static int snd_als4000_capture_close(struct snd_pcm_substream *substream) +static int snd_als4000_capture_close(snd_pcm_substream_t * substream) { - struct snd_sb *chip = snd_pcm_substream_chip(substream); + sb_t *chip = snd_pcm_substream_chip(substream); chip->capture_substream = NULL; snd_pcm_lib_free_pages(substream); @@ -499,7 +468,7 @@ static int snd_als4000_capture_close(struct snd_pcm_substream *substream) /******************************************************************/ -static struct snd_pcm_ops snd_als4000_playback_ops = { +static snd_pcm_ops_t snd_als4000_playback_ops = { .open = snd_als4000_playback_open, .close = snd_als4000_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -510,7 +479,7 @@ static struct snd_pcm_ops snd_als4000_playback_ops = { .pointer = snd_als4000_playback_pointer }; -static struct snd_pcm_ops snd_als4000_capture_ops = { +static snd_pcm_ops_t snd_als4000_capture_ops = { .open = snd_als4000_capture_open, .close = snd_als4000_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -521,13 +490,21 @@ static struct snd_pcm_ops snd_als4000_capture_ops = { .pointer = snd_als4000_capture_pointer }; -static int __devinit snd_als4000_pcm(struct snd_sb *chip, int device) +static void snd_als4000_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + sb_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_als4000_pcm(sb_t *chip, int device) +{ + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(chip->card, "ALS4000 DSP", device, 1, 1, &pcm)) < 0) return err; + pcm->private_free = snd_als4000_pcm_free; pcm->private_data = chip; pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_als4000_playback_ops); @@ -564,7 +541,7 @@ static void snd_als4000_set_addr(unsigned long gcr, snd_als4000_gcr_write_addr(gcr, 0xa9, confB); } -static void snd_als4000_configure(struct snd_sb *chip) +static void __devinit snd_als4000_configure(sb_t *chip) { unsigned tmp; int i; @@ -589,7 +566,7 @@ static void snd_als4000_configure(struct snd_sb *chip) } #ifdef SUPPORT_JOYSTICK -static int __devinit snd_als4000_create_gameport(struct snd_card_als4000 *acard, int dev) +static int __devinit snd_als4000_create_gameport(snd_card_als4000_t *acard, int dev) { struct gameport *gp; struct resource *r; @@ -635,7 +612,7 @@ static int __devinit snd_als4000_create_gameport(struct snd_card_als4000 *acard, return 0; } -static void snd_als4000_free_gameport(struct snd_card_als4000 *acard) +static void snd_als4000_free_gameport(snd_card_als4000_t *acard) { if (acard->gameport) { struct resource *r = gameport_get_port_data(acard->gameport); @@ -648,13 +625,13 @@ static void snd_als4000_free_gameport(struct snd_card_als4000 *acard) } } #else -static inline int snd_als4000_create_gameport(struct snd_card_als4000 *acard, int dev) { return -ENOSYS; } -static inline void snd_als4000_free_gameport(struct snd_card_als4000 *acard) { } +static inline int snd_als4000_create_gameport(snd_card_als4000_t *acard, int dev) { return -ENOSYS; } +static inline void snd_als4000_free_gameport(snd_card_als4000_t *acard) { } #endif -static void snd_card_als4000_free( struct snd_card *card ) +static void snd_card_als4000_free( snd_card_t *card ) { - struct snd_card_als4000 * acard = (struct snd_card_als4000 *)card->private_data; + snd_card_als4000_t * acard = (snd_card_als4000_t *)card->private_data; /* make sure that interrupts are disabled */ snd_als4000_gcr_write_addr( acard->gcr, 0x8c, 0); @@ -668,11 +645,11 @@ static int __devinit snd_card_als4000_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_card_als4000 *acard; + snd_card_t *card; + snd_card_als4000_t *acard; unsigned long gcr; - struct snd_sb *chip; - struct snd_opl3 *opl3; + sb_t *chip; + opl3_t *opl3; unsigned short word; int err; @@ -706,14 +683,14 @@ static int __devinit snd_card_als4000_probe(struct pci_dev *pci, pci_set_master(pci); card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof( struct snd_card_als4000 ) ); + sizeof( snd_card_als4000_t ) ); if (card == NULL) { pci_release_regions(pci); pci_disable_device(pci); return -ENOMEM; } - acard = (struct snd_card_als4000 *)card->private_data; + acard = (snd_card_als4000_t *)card->private_data; acard->pci = pci; acard->gcr = gcr; card->private_free = snd_card_als4000_free; @@ -729,9 +706,9 @@ static int __devinit snd_card_als4000_probe(struct pci_dev *pci, -1, SB_HW_ALS4000, &chip)) < 0) { - goto out_err; + snd_card_free(card); + return err; } - acard->chip = chip; chip->pci = pci; chip->alt_port = gcr; @@ -747,42 +724,40 @@ static int __devinit snd_card_als4000_probe(struct pci_dev *pci, if ((err = snd_mpu401_uart_new( card, 0, MPU401_HW_ALS4000, gcr+0x30, 1, pci->irq, 0, &chip->rmidi)) < 0) { - printk(KERN_ERR "als4000: no MPU-401 device at 0x%lx?\n", gcr+0x30); - goto out_err; + snd_card_free(card); + printk(KERN_ERR "als4000: no MPU-401device at 0x%lx ?\n", gcr+0x30); + return err; } if ((err = snd_als4000_pcm(chip, 0)) < 0) { - goto out_err; + snd_card_free(card); + return err; } if ((err = snd_sbmixer_new(chip)) < 0) { - goto out_err; + snd_card_free(card); + return err; } if (snd_opl3_create(card, gcr+0x10, gcr+0x12, OPL3_HW_AUTO, 1, &opl3) < 0) { - printk(KERN_ERR "als4000: no OPL device at 0x%lx-0x%lx?\n", + printk(KERN_ERR "als4000: no OPL device at 0x%lx-0x%lx ?\n", gcr+0x10, gcr+0x12 ); } else { if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) { - goto out_err; + snd_card_free(card); + return err; } } snd_als4000_create_gameport(acard, dev); if ((err = snd_card_register(card)) < 0) { - goto out_err; + snd_card_free(card); + return err; } pci_set_drvdata(pci, card); dev++; - err = 0; - goto out; - -out_err: - snd_card_free(card); - -out: - return err; + return 0; } static void __devexit snd_card_als4000_remove(struct pci_dev *pci) @@ -791,59 +766,11 @@ static void __devexit snd_card_als4000_remove(struct pci_dev *pci) pci_set_drvdata(pci, NULL); } -#ifdef CONFIG_PM -static int snd_als4000_suspend(struct pci_dev *pci, pm_message_t state) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_card_als4000 *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - - snd_pcm_suspend_all(chip->pcm); - snd_sbmixer_suspend(chip); - - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); - return 0; -} - -static int snd_als4000_resume(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_card_als4000 *acard = card->private_data; - struct snd_sb *chip = acard->chip; - - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); - - snd_als4000_configure(chip); - snd_sbdsp_reset(chip); - snd_sbmixer_resume(chip); - -#ifdef SUPPORT_JOYSTICK - if (acard->gameport) - snd_als4000_set_addr(acard->gcr, 0, 0, 0, 1); -#endif - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - - static struct pci_driver driver = { .name = "ALS4000", .id_table = snd_als4000_ids, .probe = snd_card_als4000_probe, .remove = __devexit_p(snd_card_als4000_remove), -#ifdef CONFIG_PM - .suspend = snd_als4000_suspend, - .resume = snd_als4000_resume, -#endif }; static int __init alsa_card_als4000_init(void) diff --git a/trunk/sound/pci/atiixp.c b/trunk/sound/pci/atiixp.c index b7217adaf1d7..8bae10d93529 100644 --- a/trunk/sound/pci/atiixp.c +++ b/trunk/sound/pci/atiixp.c @@ -197,18 +197,24 @@ module_param(enable, bool, 0444); #define ATI_MAX_DESCRIPTORS 256 /* max number of descriptor packets */ -struct atiixp; +/* + */ + +typedef struct snd_atiixp atiixp_t; +typedef struct snd_atiixp_dma atiixp_dma_t; +typedef struct snd_atiixp_dma_ops atiixp_dma_ops_t; + /* * DMA packate descriptor */ -struct atiixp_dma_desc { +typedef struct atiixp_dma_desc { u32 addr; /* DMA buffer address */ u16 status; /* status bits */ u16 size; /* size of the packet in dwords */ u32 next; /* address of the next packet descriptor */ -}; +} atiixp_dma_desc_t; /* * stream enum @@ -223,25 +229,22 @@ enum { ATI_PCMDEV_ANALOG, ATI_PCMDEV_DIGITAL, NUM_ATI_PCMDEVS }; /* pcm devices /* * constants and callbacks for each DMA type */ -struct atiixp_dma_ops { +struct snd_atiixp_dma_ops { int type; /* ATI_DMA_XXX */ unsigned int llp_offset; /* LINKPTR offset */ unsigned int dt_cur; /* DT_CUR offset */ - /* called from open callback */ - void (*enable_dma)(struct atiixp *chip, int on); - /* called from trigger (START/STOP) */ - void (*enable_transfer)(struct atiixp *chip, int on); - /* called from trigger (STOP only) */ - void (*flush_dma)(struct atiixp *chip); + void (*enable_dma)(atiixp_t *chip, int on); /* called from open callback */ + void (*enable_transfer)(atiixp_t *chip, int on); /* called from trigger (START/STOP) */ + void (*flush_dma)(atiixp_t *chip); /* called from trigger (STOP only) */ }; /* * DMA stream */ -struct atiixp_dma { - const struct atiixp_dma_ops *ops; +struct snd_atiixp_dma { + const atiixp_dma_ops_t *ops; struct snd_dma_buffer desc_buf; - struct snd_pcm_substream *substream; /* assigned PCM substream */ + snd_pcm_substream_t *substream; /* assigned PCM substream */ unsigned int buf_addr, buf_bytes; /* DMA buffer address, bytes */ unsigned int period_bytes, periods; int opened; @@ -255,22 +258,22 @@ struct atiixp_dma { /* * ATI IXP chip */ -struct atiixp { - struct snd_card *card; +struct snd_atiixp { + snd_card_t *card; struct pci_dev *pci; unsigned long addr; void __iomem *remap_addr; int irq; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97[NUM_ATI_CODECS]; + ac97_bus_t *ac97_bus; + ac97_t *ac97[NUM_ATI_CODECS]; spinlock_t reg_lock; - struct atiixp_dma dmas[NUM_ATI_DMAS]; + atiixp_dma_t dmas[NUM_ATI_DMAS]; struct ac97_pcm *pcms[NUM_ATI_PCMS]; - struct snd_pcm *pcmdevs[NUM_ATI_PCMDEVS]; + snd_pcm_t *pcmdevs[NUM_ATI_PCMDEVS]; int max_channels; /* max. channels for PCM out */ @@ -301,7 +304,7 @@ MODULE_DEVICE_TABLE(pci, snd_atiixp_ids); * update the bits of the given register. * return 1 if the bits changed. */ -static int snd_atiixp_update_bits(struct atiixp *chip, unsigned int reg, +static int snd_atiixp_update_bits(atiixp_t *chip, unsigned int reg, unsigned int mask, unsigned int value) { void __iomem *addr = chip->remap_addr + reg; @@ -325,6 +328,12 @@ static int snd_atiixp_update_bits(struct atiixp *chip, unsigned int reg, #define atiixp_update(chip,reg,mask,val) \ snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val) +/* delay for one tick */ +#define do_delay() do { \ + schedule_timeout_uninterruptible(1); \ +} while (0) + + /* * handling DMA packets * @@ -333,7 +342,7 @@ static int snd_atiixp_update_bits(struct atiixp *chip, unsigned int reg, */ #define ATI_DESC_LIST_SIZE \ - PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(struct atiixp_dma_desc)) + PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(atiixp_dma_desc_t)) /* * build packets ring for the given buffer size. @@ -344,10 +353,10 @@ static int snd_atiixp_update_bits(struct atiixp *chip, unsigned int reg, * * the ring is built in this function, and is set up to the hardware. */ -static int atiixp_build_dma_packets(struct atiixp *chip, struct atiixp_dma *dma, - struct snd_pcm_substream *substream, - unsigned int periods, - unsigned int period_bytes) +static int atiixp_build_dma_packets(atiixp_t *chip, atiixp_dma_t *dma, + snd_pcm_substream_t *substream, + unsigned int periods, + unsigned int period_bytes) { unsigned int i; u32 addr, desc_addr; @@ -357,10 +366,8 @@ static int atiixp_build_dma_packets(struct atiixp *chip, struct atiixp_dma *dma, return -ENOMEM; if (dma->desc_buf.area == NULL) { - if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(chip->pci), - ATI_DESC_LIST_SIZE, - &dma->desc_buf) < 0) + if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci), + ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0) return -ENOMEM; dma->period_bytes = dma->periods = 0; /* clear */ } @@ -379,12 +386,11 @@ static int atiixp_build_dma_packets(struct atiixp *chip, struct atiixp_dma *dma, addr = (u32)substream->runtime->dma_addr; desc_addr = (u32)dma->desc_buf.addr; for (i = 0; i < periods; i++) { - struct atiixp_dma_desc *desc; - desc = &((struct atiixp_dma_desc *)dma->desc_buf.area)[i]; + atiixp_dma_desc_t *desc = &((atiixp_dma_desc_t *)dma->desc_buf.area)[i]; desc->addr = cpu_to_le32(addr); desc->status = 0; desc->size = period_bytes >> 2; /* in dwords */ - desc_addr += sizeof(struct atiixp_dma_desc); + desc_addr += sizeof(atiixp_dma_desc_t); if (i == periods - 1) desc->next = cpu_to_le32((u32)dma->desc_buf.addr); else @@ -404,8 +410,7 @@ static int atiixp_build_dma_packets(struct atiixp *chip, struct atiixp_dma *dma, /* * remove the ring buffer and release it if assigned */ -static void atiixp_clear_dma_packets(struct atiixp *chip, struct atiixp_dma *dma, - struct snd_pcm_substream *substream) +static void atiixp_clear_dma_packets(atiixp_t *chip, atiixp_dma_t *dma, snd_pcm_substream_t *substream) { if (dma->desc_buf.area) { writel(0, chip->remap_addr + dma->ops->llp_offset); @@ -417,7 +422,7 @@ static void atiixp_clear_dma_packets(struct atiixp *chip, struct atiixp_dma *dma /* * AC97 interface */ -static int snd_atiixp_acquire_codec(struct atiixp *chip) +static int snd_atiixp_acquire_codec(atiixp_t *chip) { int timeout = 1000; @@ -431,7 +436,7 @@ static int snd_atiixp_acquire_codec(struct atiixp *chip) return 0; } -static unsigned short snd_atiixp_codec_read(struct atiixp *chip, unsigned short codec, unsigned short reg) +static unsigned short snd_atiixp_codec_read(atiixp_t *chip, unsigned short codec, unsigned short reg) { unsigned int data; int timeout; @@ -459,8 +464,7 @@ static unsigned short snd_atiixp_codec_read(struct atiixp *chip, unsigned short } -static void snd_atiixp_codec_write(struct atiixp *chip, unsigned short codec, - unsigned short reg, unsigned short val) +static void snd_atiixp_codec_write(atiixp_t *chip, unsigned short codec, unsigned short reg, unsigned short val) { unsigned int data; @@ -473,25 +477,23 @@ static void snd_atiixp_codec_write(struct atiixp *chip, unsigned short codec, } -static unsigned short snd_atiixp_ac97_read(struct snd_ac97 *ac97, - unsigned short reg) +static unsigned short snd_atiixp_ac97_read(ac97_t *ac97, unsigned short reg) { - struct atiixp *chip = ac97->private_data; + atiixp_t *chip = ac97->private_data; return snd_atiixp_codec_read(chip, ac97->num, reg); } -static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg, - unsigned short val) +static void snd_atiixp_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct atiixp *chip = ac97->private_data; + atiixp_t *chip = ac97->private_data; snd_atiixp_codec_write(chip, ac97->num, reg, val); } /* * reset AC link */ -static int snd_atiixp_aclink_reset(struct atiixp *chip) +static int snd_atiixp_aclink_reset(atiixp_t *chip) { int timeout; @@ -511,7 +513,7 @@ static int snd_atiixp_aclink_reset(struct atiixp *chip) atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_SYNC); atiixp_read(chip, CMD); - mdelay(1); + do_delay(); atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET); if (--timeout) { snd_printk(KERN_ERR "atiixp: codec reset timeout\n"); @@ -527,7 +529,7 @@ static int snd_atiixp_aclink_reset(struct atiixp *chip) } #ifdef CONFIG_PM -static int snd_atiixp_aclink_down(struct atiixp *chip) +static int snd_atiixp_aclink_down(atiixp_t *chip) { // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */ // return -EBUSY; @@ -552,16 +554,16 @@ static int snd_atiixp_aclink_down(struct atiixp *chip) ATI_REG_ISR_CODEC2_NOT_READY) #define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME) -static int snd_atiixp_codec_detect(struct atiixp *chip) +static int snd_atiixp_codec_detect(atiixp_t *chip) { int timeout; chip->codec_not_ready_bits = 0; atiixp_write(chip, IER, CODEC_CHECK_BITS); /* wait for the interrupts */ - timeout = 50; + timeout = HZ / 10; while (timeout-- > 0) { - mdelay(1); + do_delay(); if (chip->codec_not_ready_bits) break; } @@ -578,7 +580,7 @@ static int snd_atiixp_codec_detect(struct atiixp *chip) /* * enable DMA and irqs */ -static int snd_atiixp_chip_start(struct atiixp *chip) +static int snd_atiixp_chip_start(atiixp_t *chip) { unsigned int reg; @@ -608,7 +610,7 @@ static int snd_atiixp_chip_start(struct atiixp *chip) /* * disable DMA and IRQs */ -static int snd_atiixp_chip_stop(struct atiixp *chip) +static int snd_atiixp_chip_stop(atiixp_t *chip) { /* clear interrupt source */ atiixp_write(chip, ISR, atiixp_read(chip, ISR)); @@ -627,11 +629,11 @@ static int snd_atiixp_chip_stop(struct atiixp *chip) * position. when SG-buffer is implemented, the offset must be calculated * correctly... */ -static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_atiixp_pcm_pointer(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct atiixp_dma *dma = runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + atiixp_dma_t *dma = (atiixp_dma_t *)runtime->private_data; unsigned int curptr; int timeout = 1000; @@ -652,7 +654,7 @@ static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substr /* * XRUN detected, and stop the PCM substream */ -static void snd_atiixp_xrun_dma(struct atiixp *chip, struct atiixp_dma *dma) +static void snd_atiixp_xrun_dma(atiixp_t *chip, atiixp_dma_t *dma) { if (! dma->substream || ! dma->running) return; @@ -663,7 +665,7 @@ static void snd_atiixp_xrun_dma(struct atiixp *chip, struct atiixp_dma *dma) /* * the period ack. update the substream. */ -static void snd_atiixp_update_dma(struct atiixp *chip, struct atiixp_dma *dma) +static void snd_atiixp_update_dma(atiixp_t *chip, atiixp_dma_t *dma) { if (! dma->substream || ! dma->running) return; @@ -672,7 +674,7 @@ static void snd_atiixp_update_dma(struct atiixp *chip, struct atiixp_dma *dma) /* set BUS_BUSY interrupt bit if any DMA is running */ /* call with spinlock held */ -static void snd_atiixp_check_bus_busy(struct atiixp *chip) +static void snd_atiixp_check_bus_busy(atiixp_t *chip) { unsigned int bus_busy; if (atiixp_read(chip, CMD) & (ATI_REG_CMD_SEND_EN | @@ -687,10 +689,10 @@ static void snd_atiixp_check_bus_busy(struct atiixp *chip) /* common trigger callback * calling the lowlevel callbacks in it */ -static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_atiixp_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct atiixp *chip = snd_pcm_substream_chip(substream); - struct atiixp_dma *dma = substream->runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; int err = 0; snd_assert(dma->ops->enable_transfer && dma->ops->flush_dma, return -EINVAL); @@ -734,13 +736,13 @@ static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd) */ /* flush FIFO of analog OUT DMA */ -static void atiixp_out_flush_dma(struct atiixp *chip) +static void atiixp_out_flush_dma(atiixp_t *chip) { atiixp_write(chip, FIFO_FLUSH, ATI_REG_FIFO_OUT_FLUSH); } /* enable/disable analog OUT DMA */ -static void atiixp_out_enable_dma(struct atiixp *chip, int on) +static void atiixp_out_enable_dma(atiixp_t *chip, int on) { unsigned int data; data = atiixp_read(chip, CMD); @@ -755,21 +757,21 @@ static void atiixp_out_enable_dma(struct atiixp *chip, int on) } /* start/stop transfer over OUT DMA */ -static void atiixp_out_enable_transfer(struct atiixp *chip, int on) +static void atiixp_out_enable_transfer(atiixp_t *chip, int on) { atiixp_update(chip, CMD, ATI_REG_CMD_SEND_EN, on ? ATI_REG_CMD_SEND_EN : 0); } /* enable/disable analog IN DMA */ -static void atiixp_in_enable_dma(struct atiixp *chip, int on) +static void atiixp_in_enable_dma(atiixp_t *chip, int on) { atiixp_update(chip, CMD, ATI_REG_CMD_IN_DMA_EN, on ? ATI_REG_CMD_IN_DMA_EN : 0); } /* start/stop analog IN DMA */ -static void atiixp_in_enable_transfer(struct atiixp *chip, int on) +static void atiixp_in_enable_transfer(atiixp_t *chip, int on) { if (on) { unsigned int data = atiixp_read(chip, CMD); @@ -788,20 +790,20 @@ static void atiixp_in_enable_transfer(struct atiixp *chip, int on) } /* flush FIFO of analog IN DMA */ -static void atiixp_in_flush_dma(struct atiixp *chip) +static void atiixp_in_flush_dma(atiixp_t *chip) { atiixp_write(chip, FIFO_FLUSH, ATI_REG_FIFO_IN_FLUSH); } /* enable/disable SPDIF OUT DMA */ -static void atiixp_spdif_enable_dma(struct atiixp *chip, int on) +static void atiixp_spdif_enable_dma(atiixp_t *chip, int on) { atiixp_update(chip, CMD, ATI_REG_CMD_SPDF_DMA_EN, on ? ATI_REG_CMD_SPDF_DMA_EN : 0); } /* start/stop SPDIF OUT DMA */ -static void atiixp_spdif_enable_transfer(struct atiixp *chip, int on) +static void atiixp_spdif_enable_transfer(atiixp_t *chip, int on) { unsigned int data; data = atiixp_read(chip, CMD); @@ -813,7 +815,7 @@ static void atiixp_spdif_enable_transfer(struct atiixp *chip, int on) } /* flush FIFO of SPDIF OUT DMA */ -static void atiixp_spdif_flush_dma(struct atiixp *chip) +static void atiixp_spdif_flush_dma(atiixp_t *chip) { int timeout; @@ -832,9 +834,9 @@ static void atiixp_spdif_flush_dma(struct atiixp *chip) } /* set up slots and formats for SPDIF OUT */ -static int snd_atiixp_spdif_prepare(struct snd_pcm_substream *substream) +static int snd_atiixp_spdif_prepare(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); spin_lock_irq(&chip->reg_lock); if (chip->spdif_over_aclink) { @@ -859,9 +861,9 @@ static int snd_atiixp_spdif_prepare(struct snd_pcm_substream *substream) } /* set up slots and formats for analog OUT */ -static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream) +static int snd_atiixp_playback_prepare(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); unsigned int data; spin_lock_irq(&chip->reg_lock); @@ -904,9 +906,9 @@ static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream) } /* set up slots and formats for analog IN */ -static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream) +static int snd_atiixp_capture_prepare(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); spin_lock_irq(&chip->reg_lock); atiixp_update(chip, CMD, ATI_REG_CMD_INTERLEAVE_IN, @@ -919,11 +921,11 @@ static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream) /* * hw_params - allocate the buffer and set up buffer descriptors */ -static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_atiixp_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { - struct atiixp *chip = snd_pcm_substream_chip(substream); - struct atiixp_dma *dma = substream->runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; int err; err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); @@ -957,10 +959,10 @@ static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream, return err; } -static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_atiixp_pcm_hw_free(snd_pcm_substream_t * substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); - struct atiixp_dma *dma = substream->runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; if (dma->pcm_open_flag) { struct ac97_pcm *pcm = chip->pcms[dma->ac97_pcm_type]; @@ -976,7 +978,7 @@ static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream) /* * pcm hardware definition, identical for all DMA types */ -static struct snd_pcm_hardware snd_atiixp_pcm_hw = +static snd_pcm_hardware_t snd_atiixp_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -996,11 +998,10 @@ static struct snd_pcm_hardware snd_atiixp_pcm_hw = .periods_max = ATI_MAX_DESCRIPTORS, }; -static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream, - struct atiixp_dma *dma, int pcm_type) +static int snd_atiixp_pcm_open(snd_pcm_substream_t *substream, atiixp_dma_t *dma, int pcm_type) { - struct atiixp *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + atiixp_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL); @@ -1030,10 +1031,9 @@ static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream, return 0; } -static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream, - struct atiixp_dma *dma) +static int snd_atiixp_pcm_close(snd_pcm_substream_t *substream, atiixp_dma_t *dma) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); /* disable DMA bits */ snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL); spin_lock_irq(&chip->reg_lock); @@ -1046,9 +1046,9 @@ static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream, /* */ -static int snd_atiixp_playback_open(struct snd_pcm_substream *substream) +static int snd_atiixp_playback_open(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); @@ -1064,9 +1064,9 @@ static int snd_atiixp_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_atiixp_playback_close(struct snd_pcm_substream *substream) +static int snd_atiixp_playback_close(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]); @@ -1074,21 +1074,21 @@ static int snd_atiixp_playback_close(struct snd_pcm_substream *substream) return err; } -static int snd_atiixp_capture_open(struct snd_pcm_substream *substream) +static int snd_atiixp_capture_open(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1); } -static int snd_atiixp_capture_close(struct snd_pcm_substream *substream) +static int snd_atiixp_capture_close(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]); } -static int snd_atiixp_spdif_open(struct snd_pcm_substream *substream) +static int snd_atiixp_spdif_open(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); if (chip->spdif_over_aclink) /* share DMA_PLAYBACK */ @@ -1099,9 +1099,9 @@ static int snd_atiixp_spdif_open(struct snd_pcm_substream *substream) return err; } -static int snd_atiixp_spdif_close(struct snd_pcm_substream *substream) +static int snd_atiixp_spdif_close(snd_pcm_substream_t *substream) { - struct atiixp *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); if (chip->spdif_over_aclink) @@ -1113,7 +1113,7 @@ static int snd_atiixp_spdif_close(struct snd_pcm_substream *substream) } /* AC97 playback */ -static struct snd_pcm_ops snd_atiixp_playback_ops = { +static snd_pcm_ops_t snd_atiixp_playback_ops = { .open = snd_atiixp_playback_open, .close = snd_atiixp_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1125,7 +1125,7 @@ static struct snd_pcm_ops snd_atiixp_playback_ops = { }; /* AC97 capture */ -static struct snd_pcm_ops snd_atiixp_capture_ops = { +static snd_pcm_ops_t snd_atiixp_capture_ops = { .open = snd_atiixp_capture_open, .close = snd_atiixp_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1137,7 +1137,7 @@ static struct snd_pcm_ops snd_atiixp_capture_ops = { }; /* SPDIF playback */ -static struct snd_pcm_ops snd_atiixp_spdif_ops = { +static snd_pcm_ops_t snd_atiixp_spdif_ops = { .open = snd_atiixp_spdif_open, .close = snd_atiixp_spdif_close, .ioctl = snd_pcm_lib_ioctl, @@ -1184,7 +1184,7 @@ static struct ac97_pcm atiixp_pcm_defs[] __devinitdata = { }, }; -static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = { +static atiixp_dma_ops_t snd_atiixp_playback_dma_ops = { .type = ATI_DMA_PLAYBACK, .llp_offset = ATI_REG_OUT_DMA_LINKPTR, .dt_cur = ATI_REG_OUT_DMA_DT_CUR, @@ -1193,7 +1193,7 @@ static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = { .flush_dma = atiixp_out_flush_dma, }; -static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = { +static atiixp_dma_ops_t snd_atiixp_capture_dma_ops = { .type = ATI_DMA_CAPTURE, .llp_offset = ATI_REG_IN_DMA_LINKPTR, .dt_cur = ATI_REG_IN_DMA_DT_CUR, @@ -1202,7 +1202,7 @@ static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = { .flush_dma = atiixp_in_flush_dma, }; -static struct atiixp_dma_ops snd_atiixp_spdif_dma_ops = { +static atiixp_dma_ops_t snd_atiixp_spdif_dma_ops = { .type = ATI_DMA_SPDIF, .llp_offset = ATI_REG_SPDF_DMA_LINKPTR, .dt_cur = ATI_REG_SPDF_DMA_DT_CUR, @@ -1212,10 +1212,10 @@ static struct atiixp_dma_ops snd_atiixp_spdif_dma_ops = { }; -static int __devinit snd_atiixp_pcm_new(struct atiixp *chip) +static int __devinit snd_atiixp_pcm_new(atiixp_t *chip) { - struct snd_pcm *pcm; - struct snd_ac97_bus *pbus = chip->ac97_bus; + snd_pcm_t *pcm; + ac97_bus_t *pbus = chip->ac97_bus; int err, i, num_pcms; /* initialize constants */ @@ -1244,8 +1244,7 @@ static int __devinit snd_atiixp_pcm_new(struct atiixp *chip) } /* PCM #0: analog I/O */ - err = snd_pcm_new(chip->card, "ATI IXP AC97", - ATI_PCMDEV_ANALOG, 1, 1, &pcm); + err = snd_pcm_new(chip->card, "ATI IXP AC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops); @@ -1255,8 +1254,7 @@ static int __devinit snd_atiixp_pcm_new(struct atiixp *chip) chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm; snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024); + snd_dma_pci_data(chip->pci), 64*1024, 128*1024); /* no SPDIF support on codec? */ if (chip->pcms[ATI_PCM_SPDIF] && ! chip->pcms[ATI_PCM_SPDIF]->rates) @@ -1267,8 +1265,7 @@ static int __devinit snd_atiixp_pcm_new(struct atiixp *chip) chip->pcms[ATI_PCM_SPDIF]->rates = SNDRV_PCM_RATE_48000; /* PCM #1: spdif playback */ - err = snd_pcm_new(chip->card, "ATI IXP IEC958", - ATI_PCMDEV_DIGITAL, 1, 0, &pcm); + err = snd_pcm_new(chip->card, "ATI IXP IEC958", ATI_PCMDEV_DIGITAL, 1, 0, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_spdif_ops); @@ -1280,15 +1277,12 @@ static int __devinit snd_atiixp_pcm_new(struct atiixp *chip) chip->pcmdevs[ATI_PCMDEV_DIGITAL] = pcm; snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024); + snd_dma_pci_data(chip->pci), 64*1024, 128*1024); /* pre-select AC97 SPDIF slots 10/11 */ for (i = 0; i < NUM_ATI_CODECS; i++) { if (chip->ac97[i]) - snd_ac97_update_bits(chip->ac97[i], - AC97_EXTENDED_STATUS, - 0x03 << 4, 0x03 << 4); + snd_ac97_update_bits(chip->ac97[i], AC97_EXTENDED_STATUS, 0x03 << 4, 0x03 << 4); } return 0; @@ -1301,7 +1295,7 @@ static int __devinit snd_atiixp_pcm_new(struct atiixp *chip) */ static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct atiixp *chip = dev_id; + atiixp_t *chip = dev_id; unsigned int status; status = atiixp_read(chip, ISR); @@ -1353,23 +1347,16 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = { .name = "HP Pavilion ZV5030US", .type = AC97_TUNE_MUTE_LED }, - { - .subvendor = 0x103c, - .subdevice = 0x308b, - .name = "HP nx6125", - .type = AC97_TUNE_MUTE_LED - }, { } /* terminator */ }; -static int __devinit snd_atiixp_mixer_new(struct atiixp *chip, int clock, - const char *quirk_override) +static int __devinit snd_atiixp_mixer_new(atiixp_t *chip, int clock, const char *quirk_override) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + ac97_bus_t *pbus; + ac97_template_t ac97; int i, err; int codec_count; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_atiixp_ac97_write, .read = snd_atiixp_ac97_read, }; @@ -1421,100 +1408,90 @@ static int __devinit snd_atiixp_mixer_new(struct atiixp *chip, int clock, /* * power management */ -static int snd_atiixp_suspend(struct pci_dev *pci, pm_message_t state) +static int snd_atiixp_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct atiixp *chip = card->private_data; + atiixp_t *chip = card->pm_private_data; int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < NUM_ATI_PCMDEVS; i++) if (chip->pcmdevs[i]) { - struct atiixp_dma *dma = &chip->dmas[i]; + atiixp_dma_t *dma = &chip->dmas[i]; if (dma->substream && dma->running) - dma->saved_curptr = readl(chip->remap_addr + - dma->ops->dt_cur); + dma->saved_curptr = readl(chip->remap_addr + dma->ops->dt_cur); snd_pcm_suspend_all(chip->pcmdevs[i]); } for (i = 0; i < NUM_ATI_CODECS; i++) - snd_ac97_suspend(chip->ac97[i]); + if (chip->ac97[i]) + snd_ac97_suspend(chip->ac97[i]); snd_atiixp_aclink_down(chip); snd_atiixp_chip_stop(chip); - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); + pci_set_power_state(chip->pci, PCI_D3hot); + pci_disable_device(chip->pci); return 0; } -static int snd_atiixp_resume(struct pci_dev *pci) +static int snd_atiixp_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct atiixp *chip = card->private_data; + atiixp_t *chip = card->pm_private_data; int i; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_power_state(chip->pci, PCI_D0); + pci_set_master(chip->pci); snd_atiixp_aclink_reset(chip); snd_atiixp_chip_start(chip); for (i = 0; i < NUM_ATI_CODECS; i++) - snd_ac97_resume(chip->ac97[i]); + if (chip->ac97[i]) + snd_ac97_resume(chip->ac97[i]); for (i = 0; i < NUM_ATI_PCMDEVS; i++) if (chip->pcmdevs[i]) { - struct atiixp_dma *dma = &chip->dmas[i]; + atiixp_dma_t *dma = &chip->dmas[i]; if (dma->substream && dma->suspended) { dma->ops->enable_dma(chip, 1); dma->substream->ops->prepare(dma->substream); writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN, chip->remap_addr + dma->ops->llp_offset); - writel(dma->saved_curptr, chip->remap_addr + - dma->ops->dt_cur); + writel(dma->saved_curptr, chip->remap_addr + dma->ops->dt_cur); } } - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -#ifdef CONFIG_PROC_FS /* * proc interface for register dump */ -static void snd_atiixp_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_atiixp_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct atiixp *chip = entry->private_data; + atiixp_t *chip = entry->private_data; int i; for (i = 0; i < 256; i += 4) snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i)); } -static void __devinit snd_atiixp_proc_init(struct atiixp *chip) +static void __devinit snd_atiixp_proc_init(atiixp_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "atiixp", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_atiixp_proc_read); } -#else /* !CONFIG_PROC_FS */ -#define snd_atiixp_proc_init(chip) -#endif + /* * destructor */ -static int snd_atiixp_free(struct atiixp *chip) +static int snd_atiixp_free(atiixp_t *chip) { if (chip->irq < 0) goto __hw_end; @@ -1522,7 +1499,7 @@ static int snd_atiixp_free(struct atiixp *chip) synchronize_irq(chip->irq); __hw_end: if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); if (chip->remap_addr) iounmap(chip->remap_addr); pci_release_regions(chip->pci); @@ -1531,23 +1508,23 @@ static int snd_atiixp_free(struct atiixp *chip) return 0; } -static int snd_atiixp_dev_free(struct snd_device *device) +static int snd_atiixp_dev_free(snd_device_t *device) { - struct atiixp *chip = device->device_data; + atiixp_t *chip = device->device_data; return snd_atiixp_free(chip); } /* * constructor for chip instance */ -static int __devinit snd_atiixp_create(struct snd_card *card, +static int __devinit snd_atiixp_create(snd_card_t *card, struct pci_dev *pci, - struct atiixp **r_chip) + atiixp_t **r_chip) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_atiixp_dev_free, }; - struct atiixp *chip; + atiixp_t *chip; int err; if ((err = pci_enable_device(pci)) < 0) @@ -1577,8 +1554,7 @@ static int __devinit snd_atiixp_create(struct snd_card *card, return -EIO; } - if (request_irq(pci->irq, snd_atiixp_interrupt, SA_INTERRUPT|SA_SHIRQ, - card->shortname, chip)) { + if (request_irq(pci->irq, snd_atiixp_interrupt, SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_atiixp_free(chip); return -EBUSY; @@ -1602,8 +1578,8 @@ static int __devinit snd_atiixp_create(struct snd_card *card, static int __devinit snd_atiixp_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct atiixp *chip; + snd_card_t *card; + atiixp_t *chip; unsigned char revision; int err; @@ -1617,7 +1593,6 @@ static int __devinit snd_atiixp_probe(struct pci_dev *pci, strcpy(card->shortname, "ATI IXP"); if ((err = snd_atiixp_create(card, pci, &chip)) < 0) goto __error; - card->private_data = chip; if ((err = snd_atiixp_aclink_reset(chip)) < 0) goto __error; @@ -1639,6 +1614,8 @@ static int __devinit snd_atiixp_probe(struct pci_dev *pci, chip->ac97[0] ? snd_ac97_get_short_name(chip->ac97[0]) : "?", chip->addr, chip->irq); + snd_card_set_pm_callback(card, snd_atiixp_suspend, snd_atiixp_resume, chip); + if ((err = snd_card_register(card)) < 0) goto __error; @@ -1661,10 +1638,7 @@ static struct pci_driver driver = { .id_table = snd_atiixp_ids, .probe = snd_atiixp_probe, .remove = __devexit_p(snd_atiixp_remove), -#ifdef CONFIG_PM - .suspend = snd_atiixp_suspend, - .resume = snd_atiixp_resume, -#endif + SND_PCI_PM_CALLBACKS }; diff --git a/trunk/sound/pci/atiixp_modem.c b/trunk/sound/pci/atiixp_modem.c index 8d8fd5a4ed35..3174b6625419 100644 --- a/trunk/sound/pci/atiixp_modem.c +++ b/trunk/sound/pci/atiixp_modem.c @@ -176,18 +176,24 @@ module_param(enable, bool, 0444); #define ATI_MAX_DESCRIPTORS 256 /* max number of descriptor packets */ -struct atiixp_modem; +/* + */ + +typedef struct snd_atiixp atiixp_t; +typedef struct snd_atiixp_dma atiixp_dma_t; +typedef struct snd_atiixp_dma_ops atiixp_dma_ops_t; + /* * DMA packate descriptor */ -struct atiixp_dma_desc { +typedef struct atiixp_dma_desc { u32 addr; /* DMA buffer address */ u16 status; /* status bits */ u16 size; /* size of the packet in dwords */ u32 next; /* address of the next packet descriptor */ -}; +} atiixp_dma_desc_t; /* * stream enum @@ -202,25 +208,22 @@ enum { ATI_PCMDEV_ANALOG, NUM_ATI_PCMDEVS }; /* pcm devices */ /* * constants and callbacks for each DMA type */ -struct atiixp_dma_ops { +struct snd_atiixp_dma_ops { int type; /* ATI_DMA_XXX */ unsigned int llp_offset; /* LINKPTR offset */ unsigned int dt_cur; /* DT_CUR offset */ - /* called from open callback */ - void (*enable_dma)(struct atiixp_modem *chip, int on); - /* called from trigger (START/STOP) */ - void (*enable_transfer)(struct atiixp_modem *chip, int on); - /* called from trigger (STOP only) */ - void (*flush_dma)(struct atiixp_modem *chip); + void (*enable_dma)(atiixp_t *chip, int on); /* called from open callback */ + void (*enable_transfer)(atiixp_t *chip, int on); /* called from trigger (START/STOP) */ + void (*flush_dma)(atiixp_t *chip); /* called from trigger (STOP only) */ }; /* * DMA stream */ -struct atiixp_dma { - const struct atiixp_dma_ops *ops; +struct snd_atiixp_dma { + const atiixp_dma_ops_t *ops; struct snd_dma_buffer desc_buf; - struct snd_pcm_substream *substream; /* assigned PCM substream */ + snd_pcm_substream_t *substream; /* assigned PCM substream */ unsigned int buf_addr, buf_bytes; /* DMA buffer address, bytes */ unsigned int period_bytes, periods; int opened; @@ -232,8 +235,8 @@ struct atiixp_dma { /* * ATI IXP chip */ -struct atiixp_modem { - struct snd_card *card; +struct snd_atiixp { + snd_card_t *card; struct pci_dev *pci; struct resource *res; /* memory i/o */ @@ -241,14 +244,14 @@ struct atiixp_modem { void __iomem *remap_addr; int irq; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97[NUM_ATI_CODECS]; + ac97_bus_t *ac97_bus; + ac97_t *ac97[NUM_ATI_CODECS]; spinlock_t reg_lock; - struct atiixp_dma dmas[NUM_ATI_DMAS]; + atiixp_dma_t dmas[NUM_ATI_DMAS]; struct ac97_pcm *pcms[NUM_ATI_PCMS]; - struct snd_pcm *pcmdevs[NUM_ATI_PCMDEVS]; + snd_pcm_t *pcmdevs[NUM_ATI_PCMDEVS]; int max_channels; /* max. channels for PCM out */ @@ -278,8 +281,8 @@ MODULE_DEVICE_TABLE(pci, snd_atiixp_ids); * update the bits of the given register. * return 1 if the bits changed. */ -static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg, - unsigned int mask, unsigned int value) +static int snd_atiixp_update_bits(atiixp_t *chip, unsigned int reg, + unsigned int mask, unsigned int value) { void __iomem *addr = chip->remap_addr + reg; unsigned int data, old_data; @@ -302,6 +305,12 @@ static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg, #define atiixp_update(chip,reg,mask,val) \ snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val) +/* delay for one tick */ +#define do_delay() do { \ + schedule_timeout_uninterruptible(1); \ +} while (0) + + /* * handling DMA packets * @@ -310,7 +319,7 @@ static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg, */ #define ATI_DESC_LIST_SIZE \ - PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(struct atiixp_dma_desc)) + PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(atiixp_dma_desc_t)) /* * build packets ring for the given buffer size. @@ -321,11 +330,10 @@ static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg, * * the ring is built in this function, and is set up to the hardware. */ -static int atiixp_build_dma_packets(struct atiixp_modem *chip, - struct atiixp_dma *dma, - struct snd_pcm_substream *substream, - unsigned int periods, - unsigned int period_bytes) +static int atiixp_build_dma_packets(atiixp_t *chip, atiixp_dma_t *dma, + snd_pcm_substream_t *substream, + unsigned int periods, + unsigned int period_bytes) { unsigned int i; u32 addr, desc_addr; @@ -355,12 +363,11 @@ static int atiixp_build_dma_packets(struct atiixp_modem *chip, addr = (u32)substream->runtime->dma_addr; desc_addr = (u32)dma->desc_buf.addr; for (i = 0; i < periods; i++) { - struct atiixp_dma_desc *desc; - desc = &((struct atiixp_dma_desc *)dma->desc_buf.area)[i]; + atiixp_dma_desc_t *desc = &((atiixp_dma_desc_t *)dma->desc_buf.area)[i]; desc->addr = cpu_to_le32(addr); desc->status = 0; desc->size = period_bytes >> 2; /* in dwords */ - desc_addr += sizeof(struct atiixp_dma_desc); + desc_addr += sizeof(atiixp_dma_desc_t); if (i == periods - 1) desc->next = cpu_to_le32((u32)dma->desc_buf.addr); else @@ -380,9 +387,7 @@ static int atiixp_build_dma_packets(struct atiixp_modem *chip, /* * remove the ring buffer and release it if assigned */ -static void atiixp_clear_dma_packets(struct atiixp_modem *chip, - struct atiixp_dma *dma, - struct snd_pcm_substream *substream) +static void atiixp_clear_dma_packets(atiixp_t *chip, atiixp_dma_t *dma, snd_pcm_substream_t *substream) { if (dma->desc_buf.area) { writel(0, chip->remap_addr + dma->ops->llp_offset); @@ -394,7 +399,7 @@ static void atiixp_clear_dma_packets(struct atiixp_modem *chip, /* * AC97 interface */ -static int snd_atiixp_acquire_codec(struct atiixp_modem *chip) +static int snd_atiixp_acquire_codec(atiixp_t *chip) { int timeout = 1000; @@ -408,9 +413,7 @@ static int snd_atiixp_acquire_codec(struct atiixp_modem *chip) return 0; } -static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip, - unsigned short codec, - unsigned short reg) +static unsigned short snd_atiixp_codec_read(atiixp_t *chip, unsigned short codec, unsigned short reg) { unsigned int data; int timeout; @@ -438,9 +441,7 @@ static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip, } -static void snd_atiixp_codec_write(struct atiixp_modem *chip, - unsigned short codec, - unsigned short reg, unsigned short val) +static void snd_atiixp_codec_write(atiixp_t *chip, unsigned short codec, unsigned short reg, unsigned short val) { unsigned int data; @@ -453,18 +454,16 @@ static void snd_atiixp_codec_write(struct atiixp_modem *chip, } -static unsigned short snd_atiixp_ac97_read(struct snd_ac97 *ac97, - unsigned short reg) +static unsigned short snd_atiixp_ac97_read(ac97_t *ac97, unsigned short reg) { - struct atiixp_modem *chip = ac97->private_data; + atiixp_t *chip = ac97->private_data; return snd_atiixp_codec_read(chip, ac97->num, reg); } -static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg, - unsigned short val) +static void snd_atiixp_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct atiixp_modem *chip = ac97->private_data; + atiixp_t *chip = ac97->private_data; if (reg == AC97_GPIO_STATUS) { atiixp_write(chip, MODEM_OUT_GPIO, (val << ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT) | ATI_REG_MODEM_OUT_GPIO_EN); @@ -476,7 +475,7 @@ static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg, /* * reset AC link */ -static int snd_atiixp_aclink_reset(struct atiixp_modem *chip) +static int snd_atiixp_aclink_reset(atiixp_t *chip) { int timeout; @@ -496,7 +495,7 @@ static int snd_atiixp_aclink_reset(struct atiixp_modem *chip) atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_SYNC); atiixp_read(chip, CMD); - msleep(1); + do_delay(); atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET); if (--timeout) { snd_printk(KERN_ERR "atiixp-modem: codec reset timeout\n"); @@ -512,7 +511,7 @@ static int snd_atiixp_aclink_reset(struct atiixp_modem *chip) } #ifdef CONFIG_PM -static int snd_atiixp_aclink_down(struct atiixp_modem *chip) +static int snd_atiixp_aclink_down(atiixp_t *chip) { // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */ // return -EBUSY; @@ -537,16 +536,16 @@ static int snd_atiixp_aclink_down(struct atiixp_modem *chip) ATI_REG_ISR_CODEC2_NOT_READY) #define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME) -static int snd_atiixp_codec_detect(struct atiixp_modem *chip) +static int snd_atiixp_codec_detect(atiixp_t *chip) { int timeout; chip->codec_not_ready_bits = 0; atiixp_write(chip, IER, CODEC_CHECK_BITS); /* wait for the interrupts */ - timeout = 50; + timeout = HZ / 10; while (timeout-- > 0) { - msleep(1); + do_delay(); if (chip->codec_not_ready_bits) break; } @@ -563,7 +562,7 @@ static int snd_atiixp_codec_detect(struct atiixp_modem *chip) /* * enable DMA and irqs */ -static int snd_atiixp_chip_start(struct atiixp_modem *chip) +static int snd_atiixp_chip_start(atiixp_t *chip) { unsigned int reg; @@ -588,7 +587,7 @@ static int snd_atiixp_chip_start(struct atiixp_modem *chip) /* * disable DMA and IRQs */ -static int snd_atiixp_chip_stop(struct atiixp_modem *chip) +static int snd_atiixp_chip_stop(atiixp_t *chip) { /* clear interrupt source */ atiixp_write(chip, ISR, atiixp_read(chip, ISR)); @@ -607,11 +606,11 @@ static int snd_atiixp_chip_stop(struct atiixp_modem *chip) * position. when SG-buffer is implemented, the offset must be calculated * correctly... */ -static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_atiixp_pcm_pointer(snd_pcm_substream_t *substream) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct atiixp_dma *dma = runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + atiixp_dma_t *dma = (atiixp_dma_t *)runtime->private_data; unsigned int curptr; int timeout = 1000; @@ -632,8 +631,7 @@ static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substr /* * XRUN detected, and stop the PCM substream */ -static void snd_atiixp_xrun_dma(struct atiixp_modem *chip, - struct atiixp_dma *dma) +static void snd_atiixp_xrun_dma(atiixp_t *chip, atiixp_dma_t *dma) { if (! dma->substream || ! dma->running) return; @@ -644,8 +642,7 @@ static void snd_atiixp_xrun_dma(struct atiixp_modem *chip, /* * the period ack. update the substream. */ -static void snd_atiixp_update_dma(struct atiixp_modem *chip, - struct atiixp_dma *dma) +static void snd_atiixp_update_dma(atiixp_t *chip, atiixp_dma_t *dma) { if (! dma->substream || ! dma->running) return; @@ -654,7 +651,7 @@ static void snd_atiixp_update_dma(struct atiixp_modem *chip, /* set BUS_BUSY interrupt bit if any DMA is running */ /* call with spinlock held */ -static void snd_atiixp_check_bus_busy(struct atiixp_modem *chip) +static void snd_atiixp_check_bus_busy(atiixp_t *chip) { unsigned int bus_busy; if (atiixp_read(chip, CMD) & (ATI_REG_CMD_MODEM_SEND1_EN | @@ -668,10 +665,10 @@ static void snd_atiixp_check_bus_busy(struct atiixp_modem *chip) /* common trigger callback * calling the lowlevel callbacks in it */ -static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_atiixp_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); - struct atiixp_dma *dma = substream->runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; int err = 0; snd_assert(dma->ops->enable_transfer && dma->ops->flush_dma, return -EINVAL); @@ -709,13 +706,13 @@ static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd) */ /* flush FIFO of analog OUT DMA */ -static void atiixp_out_flush_dma(struct atiixp_modem *chip) +static void atiixp_out_flush_dma(atiixp_t *chip) { atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_OUT1_FLUSH); } /* enable/disable analog OUT DMA */ -static void atiixp_out_enable_dma(struct atiixp_modem *chip, int on) +static void atiixp_out_enable_dma(atiixp_t *chip, int on) { unsigned int data; data = atiixp_read(chip, CMD); @@ -730,21 +727,21 @@ static void atiixp_out_enable_dma(struct atiixp_modem *chip, int on) } /* start/stop transfer over OUT DMA */ -static void atiixp_out_enable_transfer(struct atiixp_modem *chip, int on) +static void atiixp_out_enable_transfer(atiixp_t *chip, int on) { atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_SEND1_EN, on ? ATI_REG_CMD_MODEM_SEND1_EN : 0); } /* enable/disable analog IN DMA */ -static void atiixp_in_enable_dma(struct atiixp_modem *chip, int on) +static void atiixp_in_enable_dma(atiixp_t *chip, int on) { atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_IN_DMA_EN, on ? ATI_REG_CMD_MODEM_IN_DMA_EN : 0); } /* start/stop analog IN DMA */ -static void atiixp_in_enable_transfer(struct atiixp_modem *chip, int on) +static void atiixp_in_enable_transfer(atiixp_t *chip, int on) { if (on) { unsigned int data = atiixp_read(chip, CMD); @@ -757,15 +754,15 @@ static void atiixp_in_enable_transfer(struct atiixp_modem *chip, int on) } /* flush FIFO of analog IN DMA */ -static void atiixp_in_flush_dma(struct atiixp_modem *chip) +static void atiixp_in_flush_dma(atiixp_t *chip) { atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_IN_FLUSH); } /* set up slots and formats for analog OUT */ -static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream) +static int snd_atiixp_playback_prepare(snd_pcm_substream_t *substream) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); unsigned int data; spin_lock_irq(&chip->reg_lock); @@ -779,7 +776,7 @@ static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream) } /* set up slots and formats for analog IN */ -static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream) +static int snd_atiixp_capture_prepare(snd_pcm_substream_t *substream) { return 0; } @@ -787,11 +784,11 @@ static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream) /* * hw_params - allocate the buffer and set up buffer descriptors */ -static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_atiixp_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); - struct atiixp_dma *dma = substream->runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; int err; int i; @@ -818,10 +815,10 @@ static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream, return err; } -static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_atiixp_pcm_hw_free(snd_pcm_substream_t * substream) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); - struct atiixp_dma *dma = substream->runtime->private_data; + atiixp_t *chip = snd_pcm_substream_chip(substream); + atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; atiixp_clear_dma_packets(chip, dma, substream); snd_pcm_lib_free_pages(substream); @@ -832,15 +829,13 @@ static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream) /* * pcm hardware definition, identical for all DMA types */ -static struct snd_pcm_hardware snd_atiixp_pcm_hw = +static snd_pcm_hardware_t snd_atiixp_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE, - .rates = (SNDRV_PCM_RATE_8000 | - SNDRV_PCM_RATE_16000 | - SNDRV_PCM_RATE_KNOT), + .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_KNOT, .rate_min = 8000, .rate_max = 16000, .channels_min = 2, @@ -852,14 +847,13 @@ static struct snd_pcm_hardware snd_atiixp_pcm_hw = .periods_max = ATI_MAX_DESCRIPTORS, }; -static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream, - struct atiixp_dma *dma, int pcm_type) +static int snd_atiixp_pcm_open(snd_pcm_substream_t *substream, atiixp_dma_t *dma, int pcm_type) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + atiixp_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; static unsigned int rates[] = { 8000, 9600, 12000, 16000 }; - static struct snd_pcm_hw_constraint_list hw_constraints_rates = { + static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, @@ -872,12 +866,9 @@ static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream, dma->substream = substream; runtime->hw = snd_atiixp_pcm_hw; dma->ac97_pcm_type = pcm_type; - if ((err = snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates)) < 0) + if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates)) < 0) return err; - if ((err = snd_pcm_hw_constraint_integer(runtime, - SNDRV_PCM_HW_PARAM_PERIODS)) < 0) + if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) return err; runtime->private_data = dma; @@ -890,10 +881,9 @@ static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream, return 0; } -static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream, - struct atiixp_dma *dma) +static int snd_atiixp_pcm_close(snd_pcm_substream_t *substream, atiixp_dma_t *dma) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); /* disable DMA bits */ snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL); spin_lock_irq(&chip->reg_lock); @@ -906,9 +896,9 @@ static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream, /* */ -static int snd_atiixp_playback_open(struct snd_pcm_substream *substream) +static int snd_atiixp_playback_open(snd_pcm_substream_t *substream) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); @@ -919,9 +909,9 @@ static int snd_atiixp_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_atiixp_playback_close(struct snd_pcm_substream *substream) +static int snd_atiixp_playback_close(snd_pcm_substream_t *substream) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]); @@ -929,21 +919,21 @@ static int snd_atiixp_playback_close(struct snd_pcm_substream *substream) return err; } -static int snd_atiixp_capture_open(struct snd_pcm_substream *substream) +static int snd_atiixp_capture_open(snd_pcm_substream_t *substream) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1); } -static int snd_atiixp_capture_close(struct snd_pcm_substream *substream) +static int snd_atiixp_capture_close(snd_pcm_substream_t *substream) { - struct atiixp_modem *chip = snd_pcm_substream_chip(substream); + atiixp_t *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]); } /* AC97 playback */ -static struct snd_pcm_ops snd_atiixp_playback_ops = { +static snd_pcm_ops_t snd_atiixp_playback_ops = { .open = snd_atiixp_playback_open, .close = snd_atiixp_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -955,7 +945,7 @@ static struct snd_pcm_ops snd_atiixp_playback_ops = { }; /* AC97 capture */ -static struct snd_pcm_ops snd_atiixp_capture_ops = { +static snd_pcm_ops_t snd_atiixp_capture_ops = { .open = snd_atiixp_capture_open, .close = snd_atiixp_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -966,7 +956,7 @@ static struct snd_pcm_ops snd_atiixp_capture_ops = { .pointer = snd_atiixp_pcm_pointer, }; -static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = { +static atiixp_dma_ops_t snd_atiixp_playback_dma_ops = { .type = ATI_DMA_PLAYBACK, .llp_offset = ATI_REG_MODEM_OUT_DMA1_LINKPTR, .dt_cur = ATI_REG_MODEM_OUT_DMA1_DT_CUR, @@ -975,7 +965,7 @@ static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = { .flush_dma = atiixp_out_flush_dma, }; -static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = { +static atiixp_dma_ops_t snd_atiixp_capture_dma_ops = { .type = ATI_DMA_CAPTURE, .llp_offset = ATI_REG_MODEM_IN_DMA_LINKPTR, .dt_cur = ATI_REG_MODEM_IN_DMA_DT_CUR, @@ -984,9 +974,9 @@ static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = { .flush_dma = atiixp_in_flush_dma, }; -static int __devinit snd_atiixp_pcm_new(struct atiixp_modem *chip) +static int __devinit snd_atiixp_pcm_new(atiixp_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; /* initialize constants */ @@ -1005,8 +995,7 @@ static int __devinit snd_atiixp_pcm_new(struct atiixp_modem *chip) chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm; snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024); + snd_dma_pci_data(chip->pci), 64*1024, 128*1024); return 0; } @@ -1018,7 +1007,7 @@ static int __devinit snd_atiixp_pcm_new(struct atiixp_modem *chip) */ static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct atiixp_modem *chip = dev_id; + atiixp_t *chip = dev_id; unsigned int status; status = atiixp_read(chip, ISR); @@ -1057,13 +1046,13 @@ static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id, struct pt_regs *r * ac97 mixer section */ -static int __devinit snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock) +static int __devinit snd_atiixp_mixer_new(atiixp_t *chip, int clock) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + ac97_bus_t *pbus; + ac97_template_t ac97; int i, err; int codec_count; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_atiixp_ac97_write, .read = snd_atiixp_ac97_read, }; @@ -1113,81 +1102,74 @@ static int __devinit snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock) /* * power management */ -static int snd_atiixp_suspend(struct pci_dev *pci, pm_message_t state) +static int snd_atiixp_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct atiixp_modem *chip = card->private_data; + atiixp_t *chip = card->pm_private_data; int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < NUM_ATI_PCMDEVS; i++) - snd_pcm_suspend_all(chip->pcmdevs[i]); + if (chip->pcmdevs[i]) + snd_pcm_suspend_all(chip->pcmdevs[i]); for (i = 0; i < NUM_ATI_CODECS; i++) - snd_ac97_suspend(chip->ac97[i]); + if (chip->ac97[i]) + snd_ac97_suspend(chip->ac97[i]); snd_atiixp_aclink_down(chip); snd_atiixp_chip_stop(chip); - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); + pci_set_power_state(chip->pci, PCI_D3hot); + pci_disable_device(chip->pci); return 0; } -static int snd_atiixp_resume(struct pci_dev *pci) +static int snd_atiixp_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct atiixp_modem *chip = card->private_data; + atiixp_t *chip = card->pm_private_data; int i; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_power_state(chip->pci, PCI_D0); + pci_set_master(chip->pci); snd_atiixp_aclink_reset(chip); snd_atiixp_chip_start(chip); for (i = 0; i < NUM_ATI_CODECS; i++) - snd_ac97_resume(chip->ac97[i]); + if (chip->ac97[i]) + snd_ac97_resume(chip->ac97[i]); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -#ifdef CONFIG_PROC_FS /* * proc interface for register dump */ -static void snd_atiixp_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_atiixp_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct atiixp_modem *chip = entry->private_data; + atiixp_t *chip = entry->private_data; int i; for (i = 0; i < 256; i += 4) snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i)); } -static void __devinit snd_atiixp_proc_init(struct atiixp_modem *chip) +static void __devinit snd_atiixp_proc_init(atiixp_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_atiixp_proc_read); } -#else -#define snd_atiixp_proc_init(chip) -#endif + /* * destructor */ -static int snd_atiixp_free(struct atiixp_modem *chip) +static int snd_atiixp_free(atiixp_t *chip) { if (chip->irq < 0) goto __hw_end; @@ -1195,7 +1177,7 @@ static int snd_atiixp_free(struct atiixp_modem *chip) synchronize_irq(chip->irq); __hw_end: if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); if (chip->remap_addr) iounmap(chip->remap_addr); pci_release_regions(chip->pci); @@ -1204,23 +1186,23 @@ static int snd_atiixp_free(struct atiixp_modem *chip) return 0; } -static int snd_atiixp_dev_free(struct snd_device *device) +static int snd_atiixp_dev_free(snd_device_t *device) { - struct atiixp_modem *chip = device->device_data; + atiixp_t *chip = device->device_data; return snd_atiixp_free(chip); } /* * constructor for chip instance */ -static int __devinit snd_atiixp_create(struct snd_card *card, - struct pci_dev *pci, - struct atiixp_modem **r_chip) +static int __devinit snd_atiixp_create(snd_card_t *card, + struct pci_dev *pci, + atiixp_t **r_chip) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_atiixp_dev_free, }; - struct atiixp_modem *chip; + atiixp_t *chip; int err; if ((err = pci_enable_device(pci)) < 0) @@ -1250,8 +1232,7 @@ static int __devinit snd_atiixp_create(struct snd_card *card, return -EIO; } - if (request_irq(pci->irq, snd_atiixp_interrupt, SA_INTERRUPT|SA_SHIRQ, - card->shortname, chip)) { + if (request_irq(pci->irq, snd_atiixp_interrupt, SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_atiixp_free(chip); return -EBUSY; @@ -1275,8 +1256,8 @@ static int __devinit snd_atiixp_create(struct snd_card *card, static int __devinit snd_atiixp_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct atiixp_modem *chip; + snd_card_t *card; + atiixp_t *chip; unsigned char revision; int err; @@ -1290,7 +1271,6 @@ static int __devinit snd_atiixp_probe(struct pci_dev *pci, strcpy(card->shortname, "ATI IXP Modem"); if ((err = snd_atiixp_create(card, pci, &chip)) < 0) goto __error; - card->private_data = chip; if ((err = snd_atiixp_aclink_reset(chip)) < 0) goto __error; @@ -1308,6 +1288,8 @@ static int __devinit snd_atiixp_probe(struct pci_dev *pci, sprintf(card->longname, "%s rev %x at 0x%lx, irq %i", card->shortname, revision, chip->addr, chip->irq); + snd_card_set_pm_callback(card, snd_atiixp_suspend, snd_atiixp_resume, chip); + if ((err = snd_card_register(card)) < 0) goto __error; @@ -1330,10 +1312,7 @@ static struct pci_driver driver = { .id_table = snd_atiixp_ids, .probe = snd_atiixp_probe, .remove = __devexit_p(snd_atiixp_remove), -#ifdef CONFIG_PM - .suspend = snd_atiixp_suspend, - .resume = snd_atiixp_resume, -#endif + SND_PCI_PM_CALLBACKS }; diff --git a/trunk/sound/pci/au88x0/au88x0.c b/trunk/sound/pci/au88x0/au88x0.c index 7d9184f7367a..d965609d8b38 100644 --- a/trunk/sound/pci/au88x0/au88x0.c +++ b/trunk/sound/pci/au88x0/au88x0.c @@ -20,7 +20,6 @@ #include <linux/slab.h> #include <linux/interrupt.h> #include <linux/moduleparam.h> -#include <linux/dma-mapping.h> #include <sound/initval.h> // module parameters (see "Module Parameters") @@ -119,7 +118,7 @@ static void __devinit snd_vortex_workaround(struct pci_dev *vortex, int fix) // component-destructor // (see "Management of Cards and Components") -static int snd_vortex_dev_free(struct snd_device *device) +static int snd_vortex_dev_free(snd_device_t * device) { vortex_t *vortex = device->device_data; @@ -138,11 +137,11 @@ static int snd_vortex_dev_free(struct snd_device *device) // chip-specific constructor // (see "Management of Cards and Components") static int __devinit -snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip) +snd_vortex_create(snd_card_t * card, struct pci_dev *pci, vortex_t ** rchip) { vortex_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_vortex_dev_free, }; @@ -151,10 +150,11 @@ snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip) // check PCI availability (DMA). if ((err = pci_enable_device(pci)) < 0) return err; - if (pci_set_dma_mask(pci, DMA_32BIT_MASK)) { + if (!pci_dma_supported(pci, VORTEX_DMA_MASK)) { printk(KERN_ERR "error to set DMA mask\n"); return -ENXIO; } + pci_set_dma_mask(pci, VORTEX_DMA_MASK); chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) @@ -233,7 +233,7 @@ static int __devinit snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; + snd_card_t *card; vortex_t *chip; int err; diff --git a/trunk/sound/pci/au88x0/au88x0.h b/trunk/sound/pci/au88x0/au88x0.h index c2ad2674bea7..b1197cfab3fb 100644 --- a/trunk/sound/pci/au88x0/au88x0.h +++ b/trunk/sound/pci/au88x0/au88x0.h @@ -39,6 +39,8 @@ #include "au88x0_wt.h" #endif +#define VORTEX_DMA_MASK 0xffffffff + #define hwread(x,y) readl((x)+((y)>>2)) #define hwwrite(x,y,z) writel((z),(x)+((y)>>2)) @@ -127,21 +129,21 @@ typedef struct { /* Virtual page extender stuff */ int nr_periods; int period_bytes; - struct snd_sg_buf *sgbuf; /* DMA Scatter Gather struct */ + snd_pcm_sgbuf_t *sgbuf; /* DMA Scatter Gather struct */ int period_real; int period_virt; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; } stream_t; typedef struct snd_vortex vortex_t; struct snd_vortex { /* ALSA structs. */ - struct snd_card *card; - struct snd_pcm *pcm[VORTEX_PCM_LAST]; + snd_card_t *card; + snd_pcm_t *pcm[VORTEX_PCM_LAST]; - struct snd_rawmidi *rmidi; /* Legacy Midi interface. */ - struct snd_ac97 *codec; + snd_rawmidi_t *rmidi; /* Legacy Midi interface. */ + ac97_t *codec; /* Stream structs. */ stream_t dma_adb[NR_ADB]; @@ -197,7 +199,7 @@ static void vortex_adb_setsrc(vortex_t * vortex, int adbdma, /* DMA Engines. */ static void vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma, - struct snd_sg_buf * sgbuf, int size, + snd_pcm_sgbuf_t * sgbuf, int size, int count); static void vortex_adbdma_setmode(vortex_t * vortex, int adbdma, int ie, int dir, int fmt, int d, @@ -205,7 +207,7 @@ static void vortex_adbdma_setmode(vortex_t * vortex, int adbdma, int ie, static void vortex_adbdma_setstartbuffer(vortex_t * vortex, int adbdma, int sb); #ifndef CHIP_AU8810 static void vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma, - struct snd_sg_buf * sgbuf, int size, + snd_pcm_sgbuf_t * sgbuf, int size, int count); static void vortex_wtdma_setmode(vortex_t * vortex, int wtdma, int ie, int fmt, int d, /*int e, */ unsigned long offset); @@ -229,9 +231,9 @@ static int inline vortex_wtdma_getlinearpos(vortex_t * vortex, int wtdma); /* global stuff. */ static void vortex_codec_init(vortex_t * vortex); -static void vortex_codec_write(struct snd_ac97 * codec, unsigned short addr, +static void vortex_codec_write(ac97_t * codec, unsigned short addr, unsigned short data); -static unsigned short vortex_codec_read(struct snd_ac97 * codec, unsigned short addr); +static unsigned short vortex_codec_read(ac97_t * codec, unsigned short addr); static void vortex_spdif_init(vortex_t * vortex, int spdif_sr, int spdif_mode); static int vortex_core_init(vortex_t * card); diff --git a/trunk/sound/pci/au88x0/au88x0_a3d.c b/trunk/sound/pci/au88x0/au88x0_a3d.c index d215f393ea64..d5755db5141f 100644 --- a/trunk/sound/pci/au88x0/au88x0_a3d.c +++ b/trunk/sound/pci/au88x0/au88x0_a3d.c @@ -725,7 +725,7 @@ static void vortex_a3d_translate_filter(a3d_atmos_t filter, int *params) /* ALSA control interface. */ static int -snd_vortex_a3d_hrtf_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_vortex_a3d_hrtf_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 6; @@ -734,7 +734,7 @@ snd_vortex_a3d_hrtf_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info return 0; } static int -snd_vortex_a3d_itd_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_vortex_a3d_itd_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -743,7 +743,7 @@ snd_vortex_a3d_itd_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info return 0; } static int -snd_vortex_a3d_ild_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_vortex_a3d_ild_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -752,8 +752,8 @@ snd_vortex_a3d_ild_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info return 0; } static int -snd_vortex_a3d_filter_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +snd_vortex_a3d_filter_info(snd_kcontrol_t * + kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 4; @@ -763,7 +763,7 @@ snd_vortex_a3d_filter_info(struct snd_kcontrol *kcontrol, } static int -snd_vortex_a3d_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_vortex_a3d_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { //a3dsrc_t *a = kcontrol->private_data; /* No read yet. Would this be really useable/needed ? */ @@ -772,8 +772,8 @@ snd_vortex_a3d_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *uco } static int -snd_vortex_a3d_hrtf_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_vortex_a3d_hrtf_put(snd_kcontrol_t * + kcontrol, snd_ctl_elem_value_t * ucontrol) { a3dsrc_t *a = kcontrol->private_data; int changed = 1, i; @@ -789,8 +789,8 @@ snd_vortex_a3d_hrtf_put(struct snd_kcontrol *kcontrol, } static int -snd_vortex_a3d_itd_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_vortex_a3d_itd_put(snd_kcontrol_t * + kcontrol, snd_ctl_elem_value_t * ucontrol) { a3dsrc_t *a = kcontrol->private_data; int coord[6]; @@ -808,8 +808,8 @@ snd_vortex_a3d_itd_put(struct snd_kcontrol *kcontrol, } static int -snd_vortex_a3d_ild_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_vortex_a3d_ild_put(snd_kcontrol_t * + kcontrol, snd_ctl_elem_value_t * ucontrol) { a3dsrc_t *a = kcontrol->private_data; int changed = 1; @@ -825,8 +825,8 @@ snd_vortex_a3d_ild_put(struct snd_kcontrol *kcontrol, } static int -snd_vortex_a3d_filter_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_vortex_a3d_filter_put(snd_kcontrol_t + * kcontrol, snd_ctl_elem_value_t * ucontrol) { a3dsrc_t *a = kcontrol->private_data; int i, changed = 1; @@ -845,7 +845,7 @@ snd_vortex_a3d_filter_put(struct snd_kcontrol *kcontrol, return changed; } -static struct snd_kcontrol_new vortex_a3d_kcontrol __devinitdata = { +static snd_kcontrol_new_t vortex_a3d_kcontrol __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = "Playback PCM advanced processing", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, @@ -857,7 +857,7 @@ static struct snd_kcontrol_new vortex_a3d_kcontrol __devinitdata = { /* Control (un)registration. */ static int vortex_a3d_register_controls(vortex_t * vortex) { - struct snd_kcontrol *kcontrol; + snd_kcontrol_t *kcontrol; int err, i; /* HRTF controls. */ for (i = 0; i < NR_A3D; i++) { diff --git a/trunk/sound/pci/au88x0/au88x0_core.c b/trunk/sound/pci/au88x0/au88x0_core.c index e3394fe63253..5905188d06b5 100644 --- a/trunk/sound/pci/au88x0/au88x0_core.c +++ b/trunk/sound/pci/au88x0/au88x0_core.c @@ -1097,7 +1097,7 @@ static void vortex_adbdma_setstartbuffer(vortex_t * vortex, int adbdma, int sb) static void vortex_adbdma_setbuffers(vortex_t * vortex, int adbdma, - struct snd_sg_buf * sgbuf, int psize, int count) + snd_pcm_sgbuf_t * sgbuf, int psize, int count) { stream_t *dma = &vortex->dma_adb[adbdma]; @@ -1367,7 +1367,7 @@ static void vortex_wtdma_setstartbuffer(vortex_t * vortex, int wtdma, int sb) static void vortex_wtdma_setbuffers(vortex_t * vortex, int wtdma, - struct snd_sg_buf * sgbuf, int psize, int count) + snd_pcm_sgbuf_t * sgbuf, int psize, int count) { stream_t *dma = &vortex->dma_wt[wtdma]; @@ -2514,7 +2514,7 @@ static void vortex_codec_init(vortex_t * vortex) } static void -vortex_codec_write(struct snd_ac97 * codec, unsigned short addr, unsigned short data) +vortex_codec_write(ac97_t * codec, unsigned short addr, unsigned short data) { vortex_t *card = (vortex_t *) codec->private_data; @@ -2539,7 +2539,7 @@ vortex_codec_write(struct snd_ac97 * codec, unsigned short addr, unsigned short hwread(card->mmio, VORTEX_CODEC_IO); } -static unsigned short vortex_codec_read(struct snd_ac97 * codec, unsigned short addr) +static unsigned short vortex_codec_read(ac97_t * codec, unsigned short addr) { vortex_t *card = (vortex_t *) codec->private_data; diff --git a/trunk/sound/pci/au88x0/au88x0_eq.c b/trunk/sound/pci/au88x0/au88x0_eq.c index 13bc8ed301c5..9d933cc0ea0b 100644 --- a/trunk/sound/pci/au88x0/au88x0_eq.c +++ b/trunk/sound/pci/au88x0/au88x0_eq.c @@ -730,7 +730,7 @@ static void vortex_Eqlzr_shutdown(vortex_t * vortex) /* Control interface */ static int -snd_vortex_eqtoggle_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_vortex_eqtoggle_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -740,8 +740,8 @@ snd_vortex_eqtoggle_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info } static int -snd_vortex_eqtoggle_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_vortex_eqtoggle_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { vortex_t *vortex = snd_kcontrol_chip(kcontrol); eqlzr_t *eq = &(vortex->eq); @@ -753,8 +753,8 @@ snd_vortex_eqtoggle_get(struct snd_kcontrol *kcontrol, } static int -snd_vortex_eqtoggle_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_vortex_eqtoggle_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { vortex_t *vortex = snd_kcontrol_chip(kcontrol); eqlzr_t *eq = &(vortex->eq); @@ -766,7 +766,7 @@ snd_vortex_eqtoggle_put(struct snd_kcontrol *kcontrol, return 1; /* Allways changes */ } -static struct snd_kcontrol_new vortex_eqtoggle_kcontrol __devinitdata = { +static snd_kcontrol_new_t vortex_eqtoggle_kcontrol __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "EQ Enable", .index = 0, @@ -778,7 +778,7 @@ static struct snd_kcontrol_new vortex_eqtoggle_kcontrol __devinitdata = { }; static int -snd_vortex_eq_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_vortex_eq_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -788,7 +788,7 @@ snd_vortex_eq_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinf } static int -snd_vortex_eq_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_vortex_eq_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { vortex_t *vortex = snd_kcontrol_chip(kcontrol); int i = kcontrol->private_value; @@ -802,7 +802,7 @@ snd_vortex_eq_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucon } static int -snd_vortex_eq_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_vortex_eq_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { vortex_t *vortex = snd_kcontrol_chip(kcontrol); int changed = 0, i = kcontrol->private_value; @@ -824,7 +824,7 @@ snd_vortex_eq_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucon return changed; } -static struct snd_kcontrol_new vortex_eq_kcontrol __devinitdata = { +static snd_kcontrol_new_t vortex_eq_kcontrol __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = " .", .index = 0, @@ -836,7 +836,7 @@ static struct snd_kcontrol_new vortex_eq_kcontrol __devinitdata = { }; static int -snd_vortex_peaks_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_vortex_peaks_info(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 20; @@ -846,7 +846,7 @@ snd_vortex_peaks_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *u } static int -snd_vortex_peaks_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_vortex_peaks_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { vortex_t *vortex = snd_kcontrol_chip(kcontrol); int i, count; @@ -863,7 +863,7 @@ snd_vortex_peaks_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *u return 0; } -static struct snd_kcontrol_new vortex_levels_kcontrol __devinitdata = { +static snd_kcontrol_new_t vortex_levels_kcontrol __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "EQ Peaks", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, @@ -888,7 +888,7 @@ static char *EqBandLabels[10] __devinitdata = { /* ALSA driver entry points. Init and exit. */ static int vortex_eq_init(vortex_t * vortex) { - struct snd_kcontrol *kcontrol; + snd_kcontrol_t *kcontrol; int err, i; vortex_Eqlzr_init(vortex); diff --git a/trunk/sound/pci/au88x0/au88x0_mixer.c b/trunk/sound/pci/au88x0/au88x0_mixer.c index c96da1dab863..86e27d695c37 100644 --- a/trunk/sound/pci/au88x0/au88x0_mixer.c +++ b/trunk/sound/pci/au88x0/au88x0_mixer.c @@ -13,10 +13,10 @@ static int __devinit snd_vortex_mixer(vortex_t * vortex) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + ac97_bus_t *pbus; + ac97_template_t ac97; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = vortex_codec_write, .read = vortex_codec_read, }; diff --git a/trunk/sound/pci/au88x0/au88x0_mpu401.c b/trunk/sound/pci/au88x0/au88x0_mpu401.c index 8ba6dd36222b..c0c23466eb0e 100644 --- a/trunk/sound/pci/au88x0/au88x0_mpu401.c +++ b/trunk/sound/pci/au88x0/au88x0_mpu401.c @@ -44,9 +44,9 @@ static int __devinit snd_vortex_midi(vortex_t * vortex) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int temp, mode; - struct snd_mpu401 *mpu; + mpu401_t *mpu; int port; #ifdef VORTEX_MPU401_LEGACY diff --git a/trunk/sound/pci/au88x0/au88x0_pcm.c b/trunk/sound/pci/au88x0/au88x0_pcm.c index 6a13ca1d545e..38bd2b5dd434 100644 --- a/trunk/sound/pci/au88x0/au88x0_pcm.c +++ b/trunk/sound/pci/au88x0/au88x0_pcm.c @@ -31,7 +31,7 @@ #define VORTEX_PCM_TYPE(x) (x->name[40]) /* hardware definition */ -static struct snd_pcm_hardware snd_vortex_playback_hw_adb = { +static snd_pcm_hardware_t snd_vortex_playback_hw_adb = { .info = (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */ SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED | @@ -56,7 +56,7 @@ static struct snd_pcm_hardware snd_vortex_playback_hw_adb = { }; #ifndef CHIP_AU8820 -static struct snd_pcm_hardware snd_vortex_playback_hw_a3d = { +static snd_pcm_hardware_t snd_vortex_playback_hw_a3d = { .info = (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */ SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED | @@ -76,7 +76,7 @@ static struct snd_pcm_hardware snd_vortex_playback_hw_a3d = { .periods_max = 64, }; #endif -static struct snd_pcm_hardware snd_vortex_playback_hw_spdif = { +static snd_pcm_hardware_t snd_vortex_playback_hw_spdif = { .info = (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */ SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED | @@ -99,7 +99,7 @@ static struct snd_pcm_hardware snd_vortex_playback_hw_spdif = { }; #ifndef CHIP_AU8810 -static struct snd_pcm_hardware snd_vortex_playback_hw_wt = { +static snd_pcm_hardware_t snd_vortex_playback_hw_wt = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), @@ -117,10 +117,10 @@ static struct snd_pcm_hardware snd_vortex_playback_hw_wt = { }; #endif /* open callback */ -static int snd_vortex_pcm_open(struct snd_pcm_substream *substream) +static int snd_vortex_pcm_open(snd_pcm_substream_t * substream) { vortex_t *vortex = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; /* Force equal size periods */ @@ -169,7 +169,7 @@ static int snd_vortex_pcm_open(struct snd_pcm_substream *substream) } /* close callback */ -static int snd_vortex_pcm_close(struct snd_pcm_substream *substream) +static int snd_vortex_pcm_close(snd_pcm_substream_t * substream) { //vortex_t *chip = snd_pcm_substream_chip(substream); stream_t *stream = (stream_t *) substream->runtime->private_data; @@ -185,12 +185,12 @@ static int snd_vortex_pcm_close(struct snd_pcm_substream *substream) /* hw_params callback */ static int -snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +snd_vortex_pcm_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { vortex_t *chip = snd_pcm_substream_chip(substream); stream_t *stream = (stream_t *) (substream->runtime->private_data); - struct snd_sg_buf *sgbuf; + snd_pcm_sgbuf_t *sgbuf; int err; // Alloc buffer memory. @@ -200,7 +200,7 @@ snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream, printk(KERN_ERR "Vortex: pcm page alloc failed!\n"); return err; } - //sgbuf = (struct snd_sg_buf *) substream->runtime->dma_private; + //sgbuf = (snd_pcm_sgbuf_t *) substream->runtime->dma_private; sgbuf = snd_pcm_substream_sgbuf(substream); /* printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params), @@ -251,7 +251,7 @@ snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream, } /* hw_free callback */ -static int snd_vortex_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_vortex_pcm_hw_free(snd_pcm_substream_t * substream) { vortex_t *chip = snd_pcm_substream_chip(substream); stream_t *stream = (stream_t *) (substream->runtime->private_data); @@ -277,10 +277,10 @@ static int snd_vortex_pcm_hw_free(struct snd_pcm_substream *substream) } /* prepare callback */ -static int snd_vortex_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_vortex_pcm_prepare(snd_pcm_substream_t * substream) { vortex_t *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; stream_t *stream = (stream_t *) substream->runtime->private_data; int dma = stream->dma, fmt, dir; @@ -310,7 +310,7 @@ static int snd_vortex_pcm_prepare(struct snd_pcm_substream *substream) } /* trigger callback */ -static int snd_vortex_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_vortex_pcm_trigger(snd_pcm_substream_t * substream, int cmd) { vortex_t *chip = snd_pcm_substream_chip(substream); stream_t *stream = (stream_t *) substream->runtime->private_data; @@ -374,7 +374,7 @@ static int snd_vortex_pcm_trigger(struct snd_pcm_substream *substream, int cmd) } /* pointer callback */ -static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_vortex_pcm_pointer(snd_pcm_substream_t * substream) { vortex_t *chip = snd_pcm_substream_chip(substream); stream_t *stream = (stream_t *) substream->runtime->private_data; @@ -395,13 +395,13 @@ static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substr /* Page callback. */ /* -static struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset) { +static struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset) { } */ /* operators */ -static struct snd_pcm_ops snd_vortex_playback_ops = { +static snd_pcm_ops_t snd_vortex_playback_ops = { .open = snd_vortex_pcm_open, .close = snd_vortex_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -434,14 +434,14 @@ static char *vortex_pcm_name[VORTEX_PCM_LAST] = { /* SPDIF kcontrol */ -static int snd_vortex_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_vortex_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_vortex_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_vortex_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -450,7 +450,7 @@ static int snd_vortex_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_vortex_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_vortex_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { vortex_t *vortex = snd_kcontrol_chip(kcontrol); ucontrol->value.iec958.status[0] = 0x00; @@ -464,7 +464,7 @@ static int snd_vortex_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int snd_vortex_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_vortex_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { vortex_t *vortex = snd_kcontrol_chip(kcontrol); int spdif_sr = 48000; @@ -481,7 +481,7 @@ static int snd_vortex_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el } /* spdif controls */ -static struct snd_kcontrol_new snd_vortex_mixer_spdif[] __devinitdata = { +static snd_kcontrol_new_t snd_vortex_mixer_spdif[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -501,8 +501,8 @@ static struct snd_kcontrol_new snd_vortex_mixer_spdif[] __devinitdata = { /* create a pcm device */ static int __devinit snd_vortex_new_pcm(vortex_t * chip, int idx, int nr) { - struct snd_pcm *pcm; - struct snd_kcontrol *kctl; + snd_pcm_t *pcm; + snd_kcontrol_t *kctl; int i; int err, nr_capt; diff --git a/trunk/sound/pci/azt3328.c b/trunk/sound/pci/azt3328.c index e077eb3fbe2f..ab737d6df41d 100644 --- a/trunk/sound/pci/azt3328.c +++ b/trunk/sound/pci/azt3328.c @@ -186,7 +186,7 @@ static int seqtimer_scaling = 128; module_param(seqtimer_scaling, int, 0444); MODULE_PARM_DESC(seqtimer_scaling, "Set 1024000Hz sequencer timer scale factor (lockup danger!). Default 128."); -struct snd_azf3328 { +typedef struct _snd_azf3328 { /* often-used fields towards beginning, then grouped */ unsigned long codec_port; unsigned long io2_port; @@ -196,16 +196,16 @@ struct snd_azf3328 { spinlock_t reg_lock; - struct snd_timer *timer; + snd_timer_t *timer; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; unsigned int is_playing; unsigned int is_recording; - struct snd_card *card; - struct snd_rawmidi *rmidi; + snd_card_t *card; + snd_rawmidi_t *rmidi; #ifdef SUPPORT_JOYSTICK struct gameport *gameport; @@ -213,7 +213,7 @@ struct snd_azf3328 { struct pci_dev *pci; int irq; -}; +} azf3328_t; static const struct pci_device_id snd_azf3328_ids[] = { { 0x122D, 0x50DC, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* PCI168/3328 */ @@ -224,61 +224,61 @@ static const struct pci_device_id snd_azf3328_ids[] = { MODULE_DEVICE_TABLE(pci, snd_azf3328_ids); static inline void -snd_azf3328_codec_outb(const struct snd_azf3328 *chip, int reg, u8 value) +snd_azf3328_codec_outb(const azf3328_t *chip, int reg, u8 value) { outb(value, chip->codec_port + reg); } static inline u8 -snd_azf3328_codec_inb(const struct snd_azf3328 *chip, int reg) +snd_azf3328_codec_inb(const azf3328_t *chip, int reg) { return inb(chip->codec_port + reg); } static inline void -snd_azf3328_codec_outw(const struct snd_azf3328 *chip, int reg, u16 value) +snd_azf3328_codec_outw(const azf3328_t *chip, int reg, u16 value) { outw(value, chip->codec_port + reg); } static inline u16 -snd_azf3328_codec_inw(const struct snd_azf3328 *chip, int reg) +snd_azf3328_codec_inw(const azf3328_t *chip, int reg) { return inw(chip->codec_port + reg); } static inline void -snd_azf3328_codec_outl(const struct snd_azf3328 *chip, int reg, u32 value) +snd_azf3328_codec_outl(const azf3328_t *chip, int reg, u32 value) { outl(value, chip->codec_port + reg); } static inline void -snd_azf3328_io2_outb(const struct snd_azf3328 *chip, int reg, u8 value) +snd_azf3328_io2_outb(const azf3328_t *chip, int reg, u8 value) { outb(value, chip->io2_port + reg); } static inline u8 -snd_azf3328_io2_inb(const struct snd_azf3328 *chip, int reg) +snd_azf3328_io2_inb(const azf3328_t *chip, int reg) { return inb(chip->io2_port + reg); } static inline void -snd_azf3328_mixer_outw(const struct snd_azf3328 *chip, int reg, u16 value) +snd_azf3328_mixer_outw(const azf3328_t *chip, int reg, u16 value) { outw(value, chip->mixer_port + reg); } static inline u16 -snd_azf3328_mixer_inw(const struct snd_azf3328 *chip, int reg) +snd_azf3328_mixer_inw(const azf3328_t *chip, int reg) { return inw(chip->mixer_port + reg); } static void -snd_azf3328_mixer_set_mute(const struct snd_azf3328 *chip, int reg, int do_mute) +snd_azf3328_mixer_set_mute(const azf3328_t *chip, int reg, int do_mute) { unsigned long portbase = chip->mixer_port + reg + 1; unsigned char oldval; @@ -294,7 +294,7 @@ snd_azf3328_mixer_set_mute(const struct snd_azf3328 *chip, int reg, int do_mute) } static void -snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip, int reg, unsigned char dst_vol_left, unsigned char dst_vol_right, int chan_sel, int delay) +snd_azf3328_mixer_write_volume_gradually(const azf3328_t *chip, int reg, unsigned char dst_vol_left, unsigned char dst_vol_right, int chan_sel, int delay) { unsigned long portbase = chip->mixer_port + reg; unsigned char curr_vol_left = 0, curr_vol_right = 0; @@ -353,14 +353,14 @@ snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip, int reg /* * general mixer element */ -struct azf3328_mixer_reg { +typedef struct azf3328_mixer_reg { unsigned int reg; unsigned int lchan_shift, rchan_shift; unsigned int mask; unsigned int invert: 1; unsigned int stereo: 1; unsigned int enum_c: 4; -}; +} azf3328_mixer_reg_t; #define COMPOSE_MIXER_REG(reg,lchan_shift,rchan_shift,mask,invert,stereo,enum_c) \ ((reg) | (lchan_shift << 8) | (rchan_shift << 12) | \ @@ -369,7 +369,7 @@ struct azf3328_mixer_reg { (stereo << 25) | \ (enum_c << 26)) -static void snd_azf3328_mixer_reg_decode(struct azf3328_mixer_reg *r, unsigned long val) +static void snd_azf3328_mixer_reg_decode(azf3328_mixer_reg_t *r, unsigned long val) { r->reg = val & 0xff; r->lchan_shift = (val >> 8) & 0x0f; @@ -420,10 +420,9 @@ static void snd_azf3328_mixer_reg_decode(struct azf3328_mixer_reg *r, unsigned l } static int -snd_azf3328_info_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +snd_azf3328_info_mixer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { - struct azf3328_mixer_reg reg; + azf3328_mixer_reg_t reg; snd_azf3328_dbgcallenter(); snd_azf3328_mixer_reg_decode(®, kcontrol->private_value); @@ -437,11 +436,10 @@ snd_azf3328_info_mixer(struct snd_kcontrol *kcontrol, } static int -snd_azf3328_get_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_azf3328_get_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol); - struct azf3328_mixer_reg reg; + azf3328_t *chip = snd_kcontrol_chip(kcontrol); + azf3328_mixer_reg_t reg; unsigned int oreg, val; snd_azf3328_dbgcallenter(); @@ -468,11 +466,10 @@ snd_azf3328_get_mixer(struct snd_kcontrol *kcontrol, } static int -snd_azf3328_put_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_azf3328_put_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol); - struct azf3328_mixer_reg reg; + azf3328_t *chip = snd_kcontrol_chip(kcontrol); + azf3328_mixer_reg_t reg; unsigned int oreg, nreg, val; snd_azf3328_dbgcallenter(); @@ -509,8 +506,7 @@ snd_azf3328_put_mixer(struct snd_kcontrol *kcontrol, } static int -snd_azf3328_info_mixer_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +snd_azf3328_info_mixer_enum(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static const char * const texts1[] = { "ModemOut1", "ModemOut2" @@ -522,7 +518,7 @@ snd_azf3328_info_mixer_enum(struct snd_kcontrol *kcontrol, "Mic", "CD", "Video", "Aux", "Line", "Mix", "Mix Mono", "Phone" }; - struct azf3328_mixer_reg reg; + azf3328_mixer_reg_t reg; snd_azf3328_mixer_reg_decode(®, kcontrol->private_value); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -544,11 +540,10 @@ snd_azf3328_info_mixer_enum(struct snd_kcontrol *kcontrol, } static int -snd_azf3328_get_mixer_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_azf3328_get_mixer_enum(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol); - struct azf3328_mixer_reg reg; + azf3328_t *chip = snd_kcontrol_chip(kcontrol); + azf3328_mixer_reg_t reg; unsigned short val; snd_azf3328_mixer_reg_decode(®, kcontrol->private_value); @@ -568,11 +563,10 @@ snd_azf3328_get_mixer_enum(struct snd_kcontrol *kcontrol, } static int -snd_azf3328_put_mixer_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_azf3328_put_mixer_enum(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_azf3328 *chip = snd_kcontrol_chip(kcontrol); - struct azf3328_mixer_reg reg; + azf3328_t *chip = snd_kcontrol_chip(kcontrol); + azf3328_mixer_reg_t reg; unsigned int oreg, nreg, val; snd_azf3328_mixer_reg_decode(®, kcontrol->private_value); @@ -600,7 +594,7 @@ snd_azf3328_put_mixer_enum(struct snd_kcontrol *kcontrol, return (nreg != oreg); } -static const struct snd_kcontrol_new snd_azf3328_mixer_controls[] __devinitdata = { +static const snd_kcontrol_new_t snd_azf3328_mixer_controls[] __devinitdata = { AZF3328_MIXER_SWITCH("Master Playback Switch", IDX_MIXER_PLAY_MASTER, 15, 1), AZF3328_MIXER_VOL_STEREO("Master Playback Volume", IDX_MIXER_PLAY_MASTER, 0x1f, 1), AZF3328_MIXER_SWITCH("Wave Playback Switch", IDX_MIXER_WAVEOUT, 15, 1), @@ -672,10 +666,10 @@ static const u16 __devinitdata snd_azf3328_init_values[][2] = { }; static int __devinit -snd_azf3328_mixer_new(struct snd_azf3328 *chip) +snd_azf3328_mixer_new(azf3328_t *chip) { - struct snd_card *card; - const struct snd_kcontrol_new *sw; + snd_card_t *card; + const snd_kcontrol_new_t *sw; unsigned int idx; int err; @@ -708,8 +702,8 @@ snd_azf3328_mixer_new(struct snd_azf3328 *chip) } static int -snd_azf3328_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +snd_azf3328_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { int res; snd_azf3328_dbgcallenter(); @@ -719,7 +713,7 @@ snd_azf3328_hw_params(struct snd_pcm_substream *substream, } static int -snd_azf3328_hw_free(struct snd_pcm_substream *substream) +snd_azf3328_hw_free(snd_pcm_substream_t * substream) { snd_azf3328_dbgcallenter(); snd_pcm_lib_free_pages(substream); @@ -728,7 +722,7 @@ snd_azf3328_hw_free(struct snd_pcm_substream *substream) } static void -snd_azf3328_setfmt(struct snd_azf3328 *chip, +snd_azf3328_setfmt(azf3328_t *chip, unsigned int reg, unsigned int bitrate, unsigned int format_width, @@ -802,7 +796,7 @@ snd_azf3328_setfmt(struct snd_azf3328 *chip, } static void -snd_azf3328_setdmaa(struct snd_azf3328 *chip, +snd_azf3328_setdmaa(azf3328_t *chip, long unsigned int addr, unsigned int count, unsigned int size, @@ -848,11 +842,11 @@ snd_azf3328_setdmaa(struct snd_azf3328 *chip, } static int -snd_azf3328_playback_prepare(struct snd_pcm_substream *substream) +snd_azf3328_playback_prepare(snd_pcm_substream_t *substream) { #if 0 - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + azf3328_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); #endif @@ -870,11 +864,11 @@ snd_azf3328_playback_prepare(struct snd_pcm_substream *substream) } static int -snd_azf3328_capture_prepare(struct snd_pcm_substream *substream) +snd_azf3328_capture_prepare(snd_pcm_substream_t * substream) { #if 0 - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + azf3328_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); #endif @@ -892,10 +886,10 @@ snd_azf3328_capture_prepare(struct snd_pcm_substream *substream) } static int -snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd) +snd_azf3328_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + azf3328_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int result = 0; unsigned int status1; @@ -1004,10 +998,10 @@ snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd) /* this is just analogous to playback; I'm not quite sure whether recording * should actually be triggered like that */ static int -snd_azf3328_capture_trigger(struct snd_pcm_substream *substream, int cmd) +snd_azf3328_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + azf3328_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int result = 0; unsigned int status1; @@ -1102,9 +1096,9 @@ snd_azf3328_capture_trigger(struct snd_pcm_substream *substream, int cmd) } static snd_pcm_uframes_t -snd_azf3328_playback_pointer(struct snd_pcm_substream *substream) +snd_azf3328_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); + azf3328_t *chip = snd_pcm_substream_chip(substream); unsigned long bufptr, result; snd_pcm_uframes_t frmres; @@ -1123,9 +1117,9 @@ snd_azf3328_playback_pointer(struct snd_pcm_substream *substream) } static snd_pcm_uframes_t -snd_azf3328_capture_pointer(struct snd_pcm_substream *substream) +snd_azf3328_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); + azf3328_t *chip = snd_pcm_substream_chip(substream); unsigned long bufptr, result; snd_pcm_uframes_t frmres; @@ -1146,7 +1140,7 @@ snd_azf3328_capture_pointer(struct snd_pcm_substream *substream) static irqreturn_t snd_azf3328_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_azf3328 *chip = dev_id; + azf3328_t *chip = dev_id; u8 status, which; static unsigned long irq_count; @@ -1229,7 +1223,7 @@ snd_azf3328_interrupt(int irq, void *dev_id, struct pt_regs *regs) /*****************************************************************/ -static const struct snd_pcm_hardware snd_azf3328_playback = +static const snd_pcm_hardware_t snd_azf3328_playback = { /* FIXME!! Correct? */ .info = SNDRV_PCM_INFO_MMAP | @@ -1257,7 +1251,7 @@ static const struct snd_pcm_hardware snd_azf3328_playback = .fifo_size = 0, }; -static const struct snd_pcm_hardware snd_azf3328_capture = +static const snd_pcm_hardware_t snd_azf3328_capture = { /* FIXME */ .info = SNDRV_PCM_INFO_MMAP | @@ -1286,7 +1280,7 @@ static const struct snd_pcm_hardware snd_azf3328_capture = static unsigned int snd_azf3328_fixed_rates[] = { 4000, 4800, 5512, 6620, 8000, 9600, 11025, 13240, 16000, 22050, 32000, 44100, 48000, 66200 }; -static struct snd_pcm_hw_constraint_list snd_azf3328_hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t snd_azf3328_hw_constraints_rates = { .count = ARRAY_SIZE(snd_azf3328_fixed_rates), .list = snd_azf3328_fixed_rates, .mask = 0, @@ -1295,10 +1289,10 @@ static struct snd_pcm_hw_constraint_list snd_azf3328_hw_constraints_rates = { /*****************************************************************/ static int -snd_azf3328_playback_open(struct snd_pcm_substream *substream) +snd_azf3328_playback_open(snd_pcm_substream_t * substream) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + azf3328_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_azf3328_dbgcallenter(); chip->playback_substream = substream; @@ -1310,10 +1304,10 @@ snd_azf3328_playback_open(struct snd_pcm_substream *substream) } static int -snd_azf3328_capture_open(struct snd_pcm_substream *substream) +snd_azf3328_capture_open(snd_pcm_substream_t * substream) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + azf3328_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_azf3328_dbgcallenter(); chip->capture_substream = substream; @@ -1325,9 +1319,9 @@ snd_azf3328_capture_open(struct snd_pcm_substream *substream) } static int -snd_azf3328_playback_close(struct snd_pcm_substream *substream) +snd_azf3328_playback_close(snd_pcm_substream_t * substream) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); + azf3328_t *chip = snd_pcm_substream_chip(substream); snd_azf3328_dbgcallenter(); @@ -1337,9 +1331,9 @@ snd_azf3328_playback_close(struct snd_pcm_substream *substream) } static int -snd_azf3328_capture_close(struct snd_pcm_substream *substream) +snd_azf3328_capture_close(snd_pcm_substream_t * substream) { - struct snd_azf3328 *chip = snd_pcm_substream_chip(substream); + azf3328_t *chip = snd_pcm_substream_chip(substream); snd_azf3328_dbgcallenter(); chip->capture_substream = NULL; @@ -1349,7 +1343,7 @@ snd_azf3328_capture_close(struct snd_pcm_substream *substream) /******************************************************************/ -static struct snd_pcm_ops snd_azf3328_playback_ops = { +static snd_pcm_ops_t snd_azf3328_playback_ops = { .open = snd_azf3328_playback_open, .close = snd_azf3328_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1360,7 +1354,7 @@ static struct snd_pcm_ops snd_azf3328_playback_ops = { .pointer = snd_azf3328_playback_pointer }; -static struct snd_pcm_ops snd_azf3328_capture_ops = { +static snd_pcm_ops_t snd_azf3328_capture_ops = { .open = snd_azf3328_capture_open, .close = snd_azf3328_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1371,10 +1365,18 @@ static struct snd_pcm_ops snd_azf3328_capture_ops = { .pointer = snd_azf3328_capture_pointer }; +static void +snd_azf3328_pcm_free(snd_pcm_t *pcm) +{ + azf3328_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + static int __devinit -snd_azf3328_pcm(struct snd_azf3328 *chip, int device) +snd_azf3328_pcm(azf3328_t *chip, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; snd_azf3328_dbgcallenter(); @@ -1384,6 +1386,7 @@ snd_azf3328_pcm(struct snd_azf3328 *chip, int device) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_azf3328_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_azf3328_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, chip->card->shortname); chip->pcm = pcm; @@ -1399,7 +1402,7 @@ snd_azf3328_pcm(struct snd_azf3328 *chip, int device) #ifdef SUPPORT_JOYSTICK static int __devinit -snd_azf3328_config_joystick(struct snd_azf3328 *chip, int dev) +snd_azf3328_config_joystick(azf3328_t *chip, int dev) { struct gameport *gp; struct resource *r; @@ -1434,7 +1437,7 @@ snd_azf3328_config_joystick(struct snd_azf3328 *chip, int dev) } static void -snd_azf3328_free_joystick(struct snd_azf3328 *chip) +snd_azf3328_free_joystick(azf3328_t *chip) { if (chip->gameport) { struct resource *r = gameport_get_port_data(chip->gameport); @@ -1449,15 +1452,15 @@ snd_azf3328_free_joystick(struct snd_azf3328 *chip) } #else static inline int -snd_azf3328_config_joystick(struct snd_azf3328 *chip, int dev) { return -ENOSYS; } +snd_azf3328_config_joystick(azf3328_t *chip, int dev) { return -ENOSYS; } static inline void -snd_azf3328_free_joystick(struct snd_azf3328 *chip) { } +snd_azf3328_free_joystick(azf3328_t *chip) { } #endif /******************************************************************/ static int -snd_azf3328_free(struct snd_azf3328 *chip) +snd_azf3328_free(azf3328_t *chip) { if (chip->irq < 0) goto __end_hw; @@ -1483,9 +1486,9 @@ snd_azf3328_free(struct snd_azf3328 *chip) } static int -snd_azf3328_dev_free(struct snd_device *device) +snd_azf3328_dev_free(snd_device_t *device) { - struct snd_azf3328 *chip = device->device_data; + azf3328_t *chip = device->device_data; return snd_azf3328_free(chip); } @@ -1501,9 +1504,9 @@ snd_azf3328_dev_free(struct snd_device *device) ***/ static int -snd_azf3328_timer_start(struct snd_timer *timer) +snd_azf3328_timer_start(snd_timer_t *timer) { - struct snd_azf3328 *chip; + azf3328_t *chip; unsigned long flags; unsigned int delay; @@ -1529,9 +1532,9 @@ snd_azf3328_timer_start(struct snd_timer *timer) } static int -snd_azf3328_timer_stop(struct snd_timer *timer) +snd_azf3328_timer_stop(snd_timer_t *timer) { - struct snd_azf3328 *chip; + azf3328_t *chip; unsigned long flags; snd_azf3328_dbgcallenter(); @@ -1547,7 +1550,7 @@ snd_azf3328_timer_stop(struct snd_timer *timer) static int -snd_azf3328_timer_precise_resolution(struct snd_timer *timer, +snd_azf3328_timer_precise_resolution(snd_timer_t *timer, unsigned long *num, unsigned long *den) { snd_azf3328_dbgcallenter(); @@ -1557,7 +1560,7 @@ snd_azf3328_timer_precise_resolution(struct snd_timer *timer, return 0; } -static struct snd_timer_hardware snd_azf3328_timer_hw = { +static struct _snd_timer_hardware snd_azf3328_timer_hw = { .flags = SNDRV_TIMER_HW_AUTO, .resolution = 977, /* 1000000/1024000 = 0.9765625us */ .ticks = 1024000, /* max tick count, defined by the value register; actually it's not 1024000, but 1048576, but we don't care */ @@ -1567,10 +1570,10 @@ static struct snd_timer_hardware snd_azf3328_timer_hw = { }; static int __devinit -snd_azf3328_timer(struct snd_azf3328 *chip, int device) +snd_azf3328_timer(azf3328_t *chip, int device) { - struct snd_timer *timer = NULL; - struct snd_timer_id tid; + snd_timer_t *timer = NULL; + snd_timer_id_t tid; int err; snd_azf3328_dbgcallenter(); @@ -1623,7 +1626,7 @@ snd_azf3328_test_bit(unsigned int reg, int bit) #endif static void -snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip) +snd_azf3328_debug_show_ports(const azf3328_t *chip) { #if DEBUG_MISC u16 tmp; @@ -1641,14 +1644,14 @@ snd_azf3328_debug_show_ports(const struct snd_azf3328 *chip) } static int __devinit -snd_azf3328_create(struct snd_card *card, +snd_azf3328_create(snd_card_t * card, struct pci_dev *pci, unsigned long device_type, - struct snd_azf3328 ** rchip) + azf3328_t ** rchip) { - struct snd_azf3328 *chip; + azf3328_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_azf3328_dev_free, }; u16 tmp; @@ -1741,9 +1744,9 @@ static int __devinit snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_azf3328 *chip; - struct snd_opl3 *opl3; + snd_card_t *card; + azf3328_t *chip; + opl3_t *opl3; int err; snd_azf3328_dbgcallenter(); diff --git a/trunk/sound/pci/bt87x.c b/trunk/sound/pci/bt87x.c index dc9cd3079b14..8feca228c6d4 100644 --- a/trunk/sound/pci/bt87x.c +++ b/trunk/sound/pci/bt87x.c @@ -147,8 +147,9 @@ MODULE_PARM_DESC(load_all, "Allow to load the non-whitelisted cards"); /* SYNC, one WRITE per line, one extra WRITE per page boundary, SYNC, JUMP */ #define MAX_RISC_SIZE ((1 + 255 + (PAGE_ALIGN(255 * 4092) / PAGE_SIZE - 1) + 1 + 1) * 8) +typedef struct snd_bt87x bt87x_t; struct snd_bt87x { - struct snd_card *card; + snd_card_t *card; struct pci_dev *pci; void __iomem *mmio; @@ -158,7 +159,7 @@ struct snd_bt87x { spinlock_t reg_lock; long opened; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; struct snd_dma_buffer dma_risc; unsigned int line_bytes; @@ -174,17 +175,17 @@ struct snd_bt87x { enum { DEVICE_DIGITAL, DEVICE_ANALOG }; -static inline u32 snd_bt87x_readl(struct snd_bt87x *chip, u32 reg) +static inline u32 snd_bt87x_readl(bt87x_t *chip, u32 reg) { return readl(chip->mmio + reg); } -static inline void snd_bt87x_writel(struct snd_bt87x *chip, u32 reg, u32 value) +static inline void snd_bt87x_writel(bt87x_t *chip, u32 reg, u32 value) { writel(value, chip->mmio + reg); } -static int snd_bt87x_create_risc(struct snd_bt87x *chip, struct snd_pcm_substream *substream, +static int snd_bt87x_create_risc(bt87x_t *chip, snd_pcm_substream_t *substream, unsigned int periods, unsigned int period_bytes) { struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); @@ -234,7 +235,7 @@ static int snd_bt87x_create_risc(struct snd_bt87x *chip, struct snd_pcm_substrea return 0; } -static void snd_bt87x_free_risc(struct snd_bt87x *chip) +static void snd_bt87x_free_risc(bt87x_t *chip) { if (chip->dma_risc.area) { snd_dma_free_pages(&chip->dma_risc); @@ -242,7 +243,7 @@ static void snd_bt87x_free_risc(struct snd_bt87x *chip) } } -static void snd_bt87x_pci_error(struct snd_bt87x *chip, unsigned int status) +static void snd_bt87x_pci_error(bt87x_t *chip, unsigned int status) { u16 pci_status; @@ -271,7 +272,7 @@ static void snd_bt87x_pci_error(struct snd_bt87x *chip, unsigned int status) static irqreturn_t snd_bt87x_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_bt87x *chip = dev_id; + bt87x_t *chip = dev_id; unsigned int status, irq_status; status = snd_bt87x_readl(chip, REG_INT_STAT); @@ -304,7 +305,7 @@ static irqreturn_t snd_bt87x_interrupt(int irq, void *dev_id, struct pt_regs *re return IRQ_HANDLED; } -static struct snd_pcm_hardware snd_bt87x_digital_hw = { +static snd_pcm_hardware_t snd_bt87x_digital_hw = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -320,7 +321,7 @@ static struct snd_pcm_hardware snd_bt87x_digital_hw = { .periods_max = 255, }; -static struct snd_pcm_hardware snd_bt87x_analog_hw = { +static snd_pcm_hardware_t snd_bt87x_analog_hw = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -338,7 +339,7 @@ static struct snd_pcm_hardware snd_bt87x_analog_hw = { .periods_max = 255, }; -static int snd_bt87x_set_digital_hw(struct snd_bt87x *chip, struct snd_pcm_runtime *runtime) +static int snd_bt87x_set_digital_hw(bt87x_t *chip, snd_pcm_runtime_t *runtime) { static struct { int rate; @@ -367,15 +368,15 @@ static int snd_bt87x_set_digital_hw(struct snd_bt87x *chip, struct snd_pcm_runti return 0; } -static int snd_bt87x_set_analog_hw(struct snd_bt87x *chip, struct snd_pcm_runtime *runtime) +static int snd_bt87x_set_analog_hw(bt87x_t *chip, snd_pcm_runtime_t *runtime) { - static struct snd_ratnum analog_clock = { + static ratnum_t analog_clock = { .num = ANALOG_CLOCK, .den_min = CLOCK_DIV_MIN, .den_max = CLOCK_DIV_MAX, .den_step = 1 }; - static struct snd_pcm_hw_constraint_ratnums constraint_rates = { + static snd_pcm_hw_constraint_ratnums_t constraint_rates = { .nrats = 1, .rats = &analog_clock }; @@ -386,10 +387,10 @@ static int snd_bt87x_set_analog_hw(struct snd_bt87x *chip, struct snd_pcm_runtim &constraint_rates); } -static int snd_bt87x_pcm_open(struct snd_pcm_substream *substream) +static int snd_bt87x_pcm_open(snd_pcm_substream_t *substream) { - struct snd_bt87x *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + bt87x_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if (test_and_set_bit(0, &chip->opened)) @@ -415,9 +416,9 @@ static int snd_bt87x_pcm_open(struct snd_pcm_substream *substream) return err; } -static int snd_bt87x_close(struct snd_pcm_substream *substream) +static int snd_bt87x_close(snd_pcm_substream_t *substream) { - struct snd_bt87x *chip = snd_pcm_substream_chip(substream); + bt87x_t *chip = snd_pcm_substream_chip(substream); chip->substream = NULL; clear_bit(0, &chip->opened); @@ -425,10 +426,10 @@ static int snd_bt87x_close(struct snd_pcm_substream *substream) return 0; } -static int snd_bt87x_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_bt87x_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { - struct snd_bt87x *chip = snd_pcm_substream_chip(substream); + bt87x_t *chip = snd_pcm_substream_chip(substream); int err; err = snd_pcm_lib_malloc_pages(substream, @@ -440,19 +441,19 @@ static int snd_bt87x_hw_params(struct snd_pcm_substream *substream, params_period_bytes(hw_params)); } -static int snd_bt87x_hw_free(struct snd_pcm_substream *substream) +static int snd_bt87x_hw_free(snd_pcm_substream_t *substream) { - struct snd_bt87x *chip = snd_pcm_substream_chip(substream); + bt87x_t *chip = snd_pcm_substream_chip(substream); snd_bt87x_free_risc(chip); snd_pcm_lib_free_pages(substream); return 0; } -static int snd_bt87x_prepare(struct snd_pcm_substream *substream) +static int snd_bt87x_prepare(snd_pcm_substream_t *substream) { - struct snd_bt87x *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + bt87x_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int decimation; spin_lock_irq(&chip->reg_lock); @@ -466,7 +467,7 @@ static int snd_bt87x_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_bt87x_start(struct snd_bt87x *chip) +static int snd_bt87x_start(bt87x_t *chip) { spin_lock(&chip->reg_lock); chip->current_line = 0; @@ -480,7 +481,7 @@ static int snd_bt87x_start(struct snd_bt87x *chip) return 0; } -static int snd_bt87x_stop(struct snd_bt87x *chip) +static int snd_bt87x_stop(bt87x_t *chip) { spin_lock(&chip->reg_lock); chip->reg_control &= ~(CTL_FIFO_ENABLE | CTL_RISC_ENABLE | CTL_ACAP_EN); @@ -491,9 +492,9 @@ static int snd_bt87x_stop(struct snd_bt87x *chip) return 0; } -static int snd_bt87x_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_bt87x_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_bt87x *chip = snd_pcm_substream_chip(substream); + bt87x_t *chip = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -505,15 +506,15 @@ static int snd_bt87x_trigger(struct snd_pcm_substream *substream, int cmd) } } -static snd_pcm_uframes_t snd_bt87x_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_bt87x_pointer(snd_pcm_substream_t *substream) { - struct snd_bt87x *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + bt87x_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; return (snd_pcm_uframes_t)bytes_to_frames(runtime, chip->current_line * chip->line_bytes); } -static struct snd_pcm_ops snd_bt87x_pcm_ops = { +static snd_pcm_ops_t snd_bt87x_pcm_ops = { .open = snd_bt87x_pcm_open, .close = snd_bt87x_close, .ioctl = snd_pcm_lib_ioctl, @@ -525,8 +526,7 @@ static struct snd_pcm_ops snd_bt87x_pcm_ops = { .page = snd_pcm_sgbuf_ops_page, }; -static int snd_bt87x_capture_volume_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *info) +static int snd_bt87x_capture_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *info) { info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; info->count = 1; @@ -535,19 +535,17 @@ static int snd_bt87x_capture_volume_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_bt87x_capture_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *value) +static int snd_bt87x_capture_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol); + bt87x_t *chip = snd_kcontrol_chip(kcontrol); value->value.integer.value[0] = (chip->reg_control & CTL_A_GAIN_MASK) >> CTL_A_GAIN_SHIFT; return 0; } -static int snd_bt87x_capture_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *value) +static int snd_bt87x_capture_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol); + bt87x_t *chip = snd_kcontrol_chip(kcontrol); u32 old_control; int changed; @@ -561,7 +559,7 @@ static int snd_bt87x_capture_volume_put(struct snd_kcontrol *kcontrol, return changed; } -static struct snd_kcontrol_new snd_bt87x_capture_volume = { +static snd_kcontrol_new_t snd_bt87x_capture_volume = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Volume", .info = snd_bt87x_capture_volume_info, @@ -569,8 +567,7 @@ static struct snd_kcontrol_new snd_bt87x_capture_volume = { .put = snd_bt87x_capture_volume_put, }; -static int snd_bt87x_capture_boost_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *info) +static int snd_bt87x_capture_boost_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *info) { info->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; info->count = 1; @@ -579,19 +576,17 @@ static int snd_bt87x_capture_boost_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_bt87x_capture_boost_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *value) +static int snd_bt87x_capture_boost_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol); + bt87x_t *chip = snd_kcontrol_chip(kcontrol); value->value.integer.value[0] = !! (chip->reg_control & CTL_A_G2X); return 0; } -static int snd_bt87x_capture_boost_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *value) +static int snd_bt87x_capture_boost_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol); + bt87x_t *chip = snd_kcontrol_chip(kcontrol); u32 old_control; int changed; @@ -605,7 +600,7 @@ static int snd_bt87x_capture_boost_put(struct snd_kcontrol *kcontrol, return changed; } -static struct snd_kcontrol_new snd_bt87x_capture_boost = { +static snd_kcontrol_new_t snd_bt87x_capture_boost = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Boost", .info = snd_bt87x_capture_boost_info, @@ -613,8 +608,7 @@ static struct snd_kcontrol_new snd_bt87x_capture_boost = { .put = snd_bt87x_capture_boost_put, }; -static int snd_bt87x_capture_source_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *info) +static int snd_bt87x_capture_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *info) { static char *texts[3] = {"TV Tuner", "FM", "Mic/Line"}; @@ -627,19 +621,17 @@ static int snd_bt87x_capture_source_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_bt87x_capture_source_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *value) +static int snd_bt87x_capture_source_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol); + bt87x_t *chip = snd_kcontrol_chip(kcontrol); value->value.enumerated.item[0] = (chip->reg_control & CTL_A_SEL_MASK) >> CTL_A_SEL_SHIFT; return 0; } -static int snd_bt87x_capture_source_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *value) +static int snd_bt87x_capture_source_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol); + bt87x_t *chip = snd_kcontrol_chip(kcontrol); u32 old_control; int changed; @@ -653,7 +645,7 @@ static int snd_bt87x_capture_source_put(struct snd_kcontrol *kcontrol, return changed; } -static struct snd_kcontrol_new snd_bt87x_capture_source = { +static snd_kcontrol_new_t snd_bt87x_capture_source = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Source", .info = snd_bt87x_capture_source_info, @@ -661,7 +653,7 @@ static struct snd_kcontrol_new snd_bt87x_capture_source = { .put = snd_bt87x_capture_source_put, }; -static int snd_bt87x_free(struct snd_bt87x *chip) +static int snd_bt87x_free(bt87x_t *chip) { if (chip->mmio) { snd_bt87x_stop(chip); @@ -678,16 +670,16 @@ static int snd_bt87x_free(struct snd_bt87x *chip) return 0; } -static int snd_bt87x_dev_free(struct snd_device *device) +static int snd_bt87x_dev_free(snd_device_t *device) { - struct snd_bt87x *chip = device->device_data; + bt87x_t *chip = device->device_data; return snd_bt87x_free(chip); } -static int __devinit snd_bt87x_pcm(struct snd_bt87x *chip, int device, char *name) +static int __devinit snd_bt87x_pcm(bt87x_t *chip, int device, char *name) { int err; - struct snd_pcm *pcm; + snd_pcm_t *pcm; err = snd_pcm_new(chip->card, name, device, 0, 1, &pcm); if (err < 0) @@ -702,13 +694,13 @@ static int __devinit snd_bt87x_pcm(struct snd_bt87x *chip, int device, char *nam (255 * 4092 + 1023) & ~1023); } -static int __devinit snd_bt87x_create(struct snd_card *card, +static int __devinit snd_bt87x_create(snd_card_t *card, struct pci_dev *pci, - struct snd_bt87x **rchip) + bt87x_t **rchip) { - struct snd_bt87x *chip; + bt87x_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_bt87x_dev_free }; @@ -831,8 +823,8 @@ static int __devinit snd_bt87x_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_bt87x *chip; + snd_card_t *card; + bt87x_t *chip; int err, rate; rate = pci_id->driver_data; diff --git a/trunk/sound/pci/ca0106/ca0106.h b/trunk/sound/pci/ca0106/ca0106.h index c8131ea92ed6..9a4b6406f7a5 100644 --- a/trunk/sound/pci/ca0106/ca0106.h +++ b/trunk/sound/pci/ca0106/ca0106.h @@ -554,36 +554,37 @@ #include "ca_midi.h" -struct snd_ca0106; +typedef struct snd_ca0106_channel ca0106_channel_t; +typedef struct snd_ca0106 ca0106_t; +typedef struct snd_ca0106_pcm ca0106_pcm_t; struct snd_ca0106_channel { - struct snd_ca0106 *emu; + ca0106_t *emu; int number; int use; - void (*interrupt)(struct snd_ca0106 *emu, struct snd_ca0106_channel *channel); - struct snd_ca0106_pcm *epcm; + void (*interrupt)(ca0106_t *emu, ca0106_channel_t *channel); + ca0106_pcm_t *epcm; }; struct snd_ca0106_pcm { - struct snd_ca0106 *emu; - struct snd_pcm_substream *substream; + ca0106_t *emu; + snd_pcm_substream_t *substream; int channel_id; unsigned short running; }; -struct snd_ca0106_details { +typedef struct { u32 serial; char * name; int ac97; int gpio_type; int i2c_adc; - int spi_dac; -}; +} ca0106_details_t; // definition of the chip-specific record struct snd_ca0106 { - struct snd_card *card; - struct snd_ca0106_details *details; + snd_card_t *card; + ca0106_details_t *details; struct pci_dev *pci; unsigned long port; @@ -596,11 +597,11 @@ struct snd_ca0106 { spinlock_t emu_lock; - struct snd_ac97 *ac97; - struct snd_pcm *pcm; + ac97_t *ac97; + snd_pcm_t *pcm; - struct snd_ca0106_channel playback_channels[4]; - struct snd_ca0106_channel capture_channels[4]; + ca0106_channel_t playback_channels[4]; + ca0106_channel_t capture_channels[4]; u32 spdif_bits[4]; /* s/pdif out setup */ int spdif_enable; int capture_source; @@ -608,22 +609,22 @@ struct snd_ca0106 { struct snd_dma_buffer buffer; - struct snd_ca_midi midi; - struct snd_ca_midi midi2; + ca_midi_t midi; + ca_midi_t midi2; }; -int snd_ca0106_mixer(struct snd_ca0106 *emu); -int snd_ca0106_proc_init(struct snd_ca0106 * emu); +int __devinit snd_ca0106_mixer(ca0106_t *emu); +int __devinit snd_ca0106_proc_init(ca0106_t * emu); -unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu, - unsigned int reg, - unsigned int chn); +unsigned int snd_ca0106_ptr_read(ca0106_t * emu, + unsigned int reg, + unsigned int chn); -void snd_ca0106_ptr_write(struct snd_ca0106 *emu, - unsigned int reg, - unsigned int chn, - unsigned int data); +void snd_ca0106_ptr_write(ca0106_t *emu, + unsigned int reg, + unsigned int chn, + unsigned int data); -int snd_ca0106_i2c_write(struct snd_ca0106 *emu, u32 reg, u32 value); +int snd_ca0106_i2c_write(ca0106_t *emu, u32 reg, u32 value); diff --git a/trunk/sound/pci/ca0106/ca0106_main.c b/trunk/sound/pci/ca0106/ca0106_main.c index 6ed7c0bfa091..389d967c97f4 100644 --- a/trunk/sound/pci/ca0106/ca0106_main.c +++ b/trunk/sound/pci/ca0106/ca0106_main.c @@ -164,7 +164,7 @@ MODULE_PARM_DESC(enable, "Enable the CA0106 soundcard."); #include "ca0106.h" -static struct snd_ca0106_details ca0106_chip_details[] = { +static ca0106_details_t ca0106_chip_details[] = { /* AudigyLS[SB0310] */ { .serial = 0x10021102, .name = "AudigyLS [SB0310]", @@ -183,17 +183,6 @@ static struct snd_ca0106_details ca0106_chip_details[] = { .name = "Live! 7.1 24bit [SB0413]", .gpio_type = 1, .i2c_adc = 1 } , - /* New Audigy SE. Has a different DAC. */ - /* SB0570: - * CTRL:CA0106-DAT - * ADC: WM8768GEDS - * DAC: WM8775EDS - */ - { .serial = 0x100a1102, - .name = "Audigy SE [SB0570]", - .gpio_type = 1, - .i2c_adc = 1, - .spi_dac = 1 } , /* MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97 */ { .serial = 0x10091462, .name = "MSI K8N Diamond MB [SB0438]", @@ -212,14 +201,13 @@ static struct snd_ca0106_details ca0106_chip_details[] = { }; /* hardware definition */ -static struct snd_pcm_hardware snd_ca0106_playback_hw = { +static snd_pcm_hardware_t snd_ca0106_playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE, - .rates = (SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | - SNDRV_PCM_RATE_192000), + .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000, .rate_min = 48000, .rate_max = 192000, .channels_min = 2, //1, @@ -232,14 +220,13 @@ static struct snd_pcm_hardware snd_ca0106_playback_hw = { .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ca0106_capture_hw = { +static snd_pcm_hardware_t snd_ca0106_capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE, - .rates = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | - SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000), + .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000, .rate_min = 44100, .rate_max = 192000, .channels_min = 2, @@ -252,7 +239,7 @@ static struct snd_pcm_hardware snd_ca0106_capture_hw = { .fifo_size = 0, }; -unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu, +unsigned int snd_ca0106_ptr_read(ca0106_t * emu, unsigned int reg, unsigned int chn) { @@ -268,7 +255,7 @@ unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu, return val; } -void snd_ca0106_ptr_write(struct snd_ca0106 *emu, +void snd_ca0106_ptr_write(ca0106_t *emu, unsigned int reg, unsigned int chn, unsigned int data) @@ -284,47 +271,16 @@ void snd_ca0106_ptr_write(struct snd_ca0106 *emu, spin_unlock_irqrestore(&emu->emu_lock, flags); } -int snd_ca0106_spi_write(struct snd_ca0106 * emu, - unsigned int data) -{ - unsigned int reset, set; - unsigned int reg, tmp; - int n, result; - reg = SPI; - if (data > 0xffff) /* Only 16bit values allowed */ - return 1; - tmp = snd_ca0106_ptr_read(emu, reg, 0); - reset = (tmp & ~0x3ffff) | 0x20000; /* Set xxx20000 */ - set = reset | 0x10000; /* Set xxx1xxxx */ - snd_ca0106_ptr_write(emu, reg, 0, reset | data); - tmp = snd_ca0106_ptr_read(emu, reg, 0); /* write post */ - snd_ca0106_ptr_write(emu, reg, 0, set | data); - result = 1; - /* Wait for status bit to return to 0 */ - for (n = 0; n < 100; n++) { - udelay(10); - tmp = snd_ca0106_ptr_read(emu, reg, 0); - if (!(tmp & 0x10000)) { - result = 0; - break; - } - } - if (result) /* Timed out */ - return 1; - snd_ca0106_ptr_write(emu, reg, 0, reset | data); - tmp = snd_ca0106_ptr_read(emu, reg, 0); /* Write post */ - return 0; -} - -int snd_ca0106_i2c_write(struct snd_ca0106 *emu, +int snd_ca0106_i2c_write(ca0106_t *emu, u32 reg, u32 value) { u32 tmp; - int timeout = 0; + int timeout=0; int status; int retry; - if ((reg > 0x7f) || (value > 0x1ff)) { + if ((reg > 0x7f) || (value > 0x1ff)) + { snd_printk(KERN_ERR "i2c_write: invalid values.\n"); return -EINVAL; } @@ -336,7 +292,8 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu, /* This controls the I2C connected to the WM8775 ADC Codec */ snd_ca0106_ptr_write(emu, I2C_D1, 0, tmp); - for (retry = 0; retry < 10; retry++) { + for(retry=0;retry<10;retry++) + { /* Send the data to i2c */ tmp = snd_ca0106_ptr_read(emu, I2C_A, 0); tmp = tmp & ~(I2C_A_ADC_READ|I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD_MASK); @@ -344,22 +301,24 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu, snd_ca0106_ptr_write(emu, I2C_A, 0, tmp); /* Wait till the transaction ends */ - while (1) { + while(1) + { status = snd_ca0106_ptr_read(emu, I2C_A, 0); //snd_printk("I2C:status=0x%x\n", status); timeout++; - if ((status & I2C_A_ADC_START) == 0) + if((status & I2C_A_ADC_START)==0) break; - if (timeout > 1000) + if(timeout>1000) break; } //Read back and see if the transaction is successful - if ((status & I2C_A_ADC_ABORT) == 0) + if((status & I2C_A_ADC_ABORT)==0) break; } - if (retry == 10) { + if(retry==10) + { snd_printk(KERN_ERR "Writing to ADC failed!\n"); return -EINVAL; } @@ -368,7 +327,7 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu, } -static void snd_ca0106_intr_enable(struct snd_ca0106 *emu, unsigned int intrenb) +static void snd_ca0106_intr_enable(ca0106_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int enable; @@ -379,7 +338,7 @@ static void snd_ca0106_intr_enable(struct snd_ca0106 *emu, unsigned int intrenb) spin_unlock_irqrestore(&emu->emu_lock, flags); } -static void snd_ca0106_intr_disable(struct snd_ca0106 *emu, unsigned int intrenb) +static void snd_ca0106_intr_disable(ca0106_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int enable; @@ -391,19 +350,18 @@ static void snd_ca0106_intr_disable(struct snd_ca0106 *emu, unsigned int intrenb } -static void snd_ca0106_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_ca0106_pcm_free_substream(snd_pcm_runtime_t *runtime) { kfree(runtime->private_data); } /* open_playback callback */ -static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream, - int channel_id) +static int snd_ca0106_pcm_open_playback_channel(snd_pcm_substream_t *substream, int channel_id) { - struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); - struct snd_ca0106_channel *channel = &(chip->playback_channels[channel_id]); - struct snd_ca0106_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + ca0106_t *chip = snd_pcm_substream_chip(substream); + ca0106_channel_t *channel = &(chip->playback_channels[channel_id]); + ca0106_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; int err; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); @@ -422,10 +380,10 @@ static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substr channel->emu = chip; channel->number = channel_id; - channel->use = 1; + channel->use=1; //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel); //channel->interrupt = snd_ca0106_pcm_channel_interrupt; - channel->epcm = epcm; + channel->epcm=epcm; if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) return err; if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0) @@ -434,44 +392,43 @@ static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substr } /* close callback */ -static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_close_playback(snd_pcm_substream_t *substream) { - struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ca0106_pcm *epcm = runtime->private_data; - chip->playback_channels[epcm->channel_id].use = 0; - /* FIXME: maybe zero others */ + ca0106_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ca0106_pcm_t *epcm = runtime->private_data; + chip->playback_channels[epcm->channel_id].use=0; +/* FIXME: maybe zero others */ return 0; } -static int snd_ca0106_pcm_open_playback_front(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_playback_front(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL); } -static int snd_ca0106_pcm_open_playback_center_lfe(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_playback_center_lfe(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_playback_channel(substream, PCM_CENTER_LFE_CHANNEL); } -static int snd_ca0106_pcm_open_playback_unknown(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_playback_unknown(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_playback_channel(substream, PCM_UNKNOWN_CHANNEL); } -static int snd_ca0106_pcm_open_playback_rear(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_playback_rear(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_playback_channel(substream, PCM_REAR_CHANNEL); } /* open_capture callback */ -static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substream, - int channel_id) +static int snd_ca0106_pcm_open_capture_channel(snd_pcm_substream_t *substream, int channel_id) { - struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); - struct snd_ca0106_channel *channel = &(chip->capture_channels[channel_id]); - struct snd_ca0106_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + ca0106_t *chip = snd_pcm_substream_chip(substream); + ca0106_channel_t *channel = &(chip->capture_channels[channel_id]); + ca0106_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; int err; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); @@ -491,10 +448,10 @@ static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substre channel->emu = chip; channel->number = channel_id; - channel->use = 1; + channel->use=1; //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel); //channel->interrupt = snd_ca0106_pcm_channel_interrupt; - channel->epcm = epcm; + channel->epcm=epcm; if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) return err; //snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hw_constraints_capture_period_sizes); @@ -504,70 +461,70 @@ static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substre } /* close callback */ -static int snd_ca0106_pcm_close_capture(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_close_capture(snd_pcm_substream_t *substream) { - struct snd_ca0106 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ca0106_pcm *epcm = runtime->private_data; - chip->capture_channels[epcm->channel_id].use = 0; - /* FIXME: maybe zero others */ + ca0106_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ca0106_pcm_t *epcm = runtime->private_data; + chip->capture_channels[epcm->channel_id].use=0; +/* FIXME: maybe zero others */ return 0; } -static int snd_ca0106_pcm_open_0_capture(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_0_capture(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_capture_channel(substream, 0); } -static int snd_ca0106_pcm_open_1_capture(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_1_capture(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_capture_channel(substream, 1); } -static int snd_ca0106_pcm_open_2_capture(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_2_capture(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_capture_channel(substream, 2); } -static int snd_ca0106_pcm_open_3_capture(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_open_3_capture(snd_pcm_substream_t *substream) { return snd_ca0106_pcm_open_capture_channel(substream, 3); } /* hw_params callback */ -static int snd_ca0106_pcm_hw_params_playback(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ca0106_pcm_hw_params_playback(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } /* hw_free callback */ -static int snd_ca0106_pcm_hw_free_playback(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_hw_free_playback(snd_pcm_substream_t *substream) { return snd_pcm_lib_free_pages(substream); } /* hw_params callback */ -static int snd_ca0106_pcm_hw_params_capture(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ca0106_pcm_hw_params_capture(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } /* hw_free callback */ -static int snd_ca0106_pcm_hw_free_capture(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_hw_free_capture(snd_pcm_substream_t *substream) { return snd_pcm_lib_free_pages(substream); } /* prepare playback callback */ -static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_prepare_playback(snd_pcm_substream_t *substream) { - struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ca0106_pcm *epcm = runtime->private_data; + ca0106_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ca0106_pcm_t *epcm = runtime->private_data; int channel = epcm->channel_id; u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel)); u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size); @@ -636,8 +593,8 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream) /* FIXME: Check emu->buffer.size before actually writing to it. */ for(i=0; i < runtime->periods; i++) { - table_base[i*2] = runtime->dma_addr + (i * period_size_bytes); - table_base[i*2+1] = period_size_bytes << 16; + table_base[i*2]=runtime->dma_addr+(i*period_size_bytes); + table_base[(i*2)+1]=period_size_bytes<<16; } snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel)); @@ -664,11 +621,11 @@ static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream) } /* prepare capture callback */ -static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream) +static int snd_ca0106_pcm_prepare_capture(snd_pcm_substream_t *substream) { - struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ca0106_pcm *epcm = runtime->private_data; + ca0106_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ca0106_pcm_t *epcm = runtime->private_data; int channel = epcm->channel_id; u32 hcfg_mask = HCFG_CAPTURE_S32_LE; u32 hcfg_set = 0x00000000; @@ -735,16 +692,16 @@ static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream) } /* trigger_playback callback */ -static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream, +static int snd_ca0106_pcm_trigger_playback(snd_pcm_substream_t *substream, int cmd) { - struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime; - struct snd_ca0106_pcm *epcm; + ca0106_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime; + ca0106_pcm_t *epcm; int channel; int result = 0; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; u32 basic = 0; u32 extended = 0; int running=0; @@ -788,12 +745,12 @@ static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream, } /* trigger_capture callback */ -static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream, +static int snd_ca0106_pcm_trigger_capture(snd_pcm_substream_t *substream, int cmd) { - struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ca0106_pcm *epcm = runtime->private_data; + ca0106_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ca0106_pcm_t *epcm = runtime->private_data; int channel = epcm->channel_id; int result = 0; @@ -817,11 +774,11 @@ static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream, /* pointer_playback callback */ static snd_pcm_uframes_t -snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream) +snd_ca0106_pcm_pointer_playback(snd_pcm_substream_t *substream) { - struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ca0106_pcm *epcm = runtime->private_data; + ca0106_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ca0106_pcm_t *epcm = runtime->private_data; snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0; int channel = epcm->channel_id; @@ -844,11 +801,11 @@ snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream) /* pointer_capture callback */ static snd_pcm_uframes_t -snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream) +snd_ca0106_pcm_pointer_capture(snd_pcm_substream_t *substream) { - struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ca0106_pcm *epcm = runtime->private_data; + ca0106_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ca0106_pcm_t *epcm = runtime->private_data; snd_pcm_uframes_t ptr, ptr1, ptr2 = 0; int channel = channel=epcm->channel_id; @@ -866,7 +823,7 @@ snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream) } /* operators */ -static struct snd_pcm_ops snd_ca0106_playback_front_ops = { +static snd_pcm_ops_t snd_ca0106_playback_front_ops = { .open = snd_ca0106_pcm_open_playback_front, .close = snd_ca0106_pcm_close_playback, .ioctl = snd_pcm_lib_ioctl, @@ -877,7 +834,7 @@ static struct snd_pcm_ops snd_ca0106_playback_front_ops = { .pointer = snd_ca0106_pcm_pointer_playback, }; -static struct snd_pcm_ops snd_ca0106_capture_0_ops = { +static snd_pcm_ops_t snd_ca0106_capture_0_ops = { .open = snd_ca0106_pcm_open_0_capture, .close = snd_ca0106_pcm_close_capture, .ioctl = snd_pcm_lib_ioctl, @@ -888,7 +845,7 @@ static struct snd_pcm_ops snd_ca0106_capture_0_ops = { .pointer = snd_ca0106_pcm_pointer_capture, }; -static struct snd_pcm_ops snd_ca0106_capture_1_ops = { +static snd_pcm_ops_t snd_ca0106_capture_1_ops = { .open = snd_ca0106_pcm_open_1_capture, .close = snd_ca0106_pcm_close_capture, .ioctl = snd_pcm_lib_ioctl, @@ -899,7 +856,7 @@ static struct snd_pcm_ops snd_ca0106_capture_1_ops = { .pointer = snd_ca0106_pcm_pointer_capture, }; -static struct snd_pcm_ops snd_ca0106_capture_2_ops = { +static snd_pcm_ops_t snd_ca0106_capture_2_ops = { .open = snd_ca0106_pcm_open_2_capture, .close = snd_ca0106_pcm_close_capture, .ioctl = snd_pcm_lib_ioctl, @@ -910,7 +867,7 @@ static struct snd_pcm_ops snd_ca0106_capture_2_ops = { .pointer = snd_ca0106_pcm_pointer_capture, }; -static struct snd_pcm_ops snd_ca0106_capture_3_ops = { +static snd_pcm_ops_t snd_ca0106_capture_3_ops = { .open = snd_ca0106_pcm_open_3_capture, .close = snd_ca0106_pcm_close_capture, .ioctl = snd_pcm_lib_ioctl, @@ -921,7 +878,7 @@ static struct snd_pcm_ops snd_ca0106_capture_3_ops = { .pointer = snd_ca0106_pcm_pointer_capture, }; -static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = { +static snd_pcm_ops_t snd_ca0106_playback_center_lfe_ops = { .open = snd_ca0106_pcm_open_playback_center_lfe, .close = snd_ca0106_pcm_close_playback, .ioctl = snd_pcm_lib_ioctl, @@ -932,7 +889,7 @@ static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = { .pointer = snd_ca0106_pcm_pointer_playback, }; -static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = { +static snd_pcm_ops_t snd_ca0106_playback_unknown_ops = { .open = snd_ca0106_pcm_open_playback_unknown, .close = snd_ca0106_pcm_close_playback, .ioctl = snd_pcm_lib_ioctl, @@ -943,7 +900,7 @@ static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = { .pointer = snd_ca0106_pcm_pointer_playback, }; -static struct snd_pcm_ops snd_ca0106_playback_rear_ops = { +static snd_pcm_ops_t snd_ca0106_playback_rear_ops = { .open = snd_ca0106_pcm_open_playback_rear, .close = snd_ca0106_pcm_close_playback, .ioctl = snd_pcm_lib_ioctl, @@ -955,10 +912,10 @@ static struct snd_pcm_ops snd_ca0106_playback_rear_ops = { }; -static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97, +static unsigned short snd_ca0106_ac97_read(ac97_t *ac97, unsigned short reg) { - struct snd_ca0106 *emu = ac97->private_data; + ca0106_t *emu = ac97->private_data; unsigned long flags; unsigned short val; @@ -969,10 +926,10 @@ static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97, return val; } -static void snd_ca0106_ac97_write(struct snd_ac97 *ac97, +static void snd_ca0106_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct snd_ca0106 *emu = ac97->private_data; + ca0106_t *emu = ac97->private_data; unsigned long flags; spin_lock_irqsave(&emu->emu_lock, flags); @@ -981,12 +938,12 @@ static void snd_ca0106_ac97_write(struct snd_ac97 *ac97, spin_unlock_irqrestore(&emu->emu_lock, flags); } -static int snd_ca0106_ac97(struct snd_ca0106 *chip) +static int snd_ca0106_ac97(ca0106_t *chip) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + ac97_bus_t *pbus; + ac97_template_t ac97; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_ca0106_ac97_write, .read = snd_ca0106_ac97_read, }; @@ -1001,7 +958,7 @@ static int snd_ca0106_ac97(struct snd_ca0106 *chip) return snd_ac97_mixer(pbus, &ac97, &chip->ac97); } -static int snd_ca0106_free(struct snd_ca0106 *chip) +static int snd_ca0106_free(ca0106_t *chip) { if (chip->res_port != NULL) { /* avoid access to already used hardware */ // disable interrupts @@ -1034,9 +991,9 @@ static int snd_ca0106_free(struct snd_ca0106 *chip) return 0; } -static int snd_ca0106_dev_free(struct snd_device *device) +static int snd_ca0106_dev_free(snd_device_t *device) { - struct snd_ca0106 *chip = device->device_data; + ca0106_t *chip = device->device_data; return snd_ca0106_free(chip); } @@ -1045,13 +1002,19 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id, { unsigned int status; - struct snd_ca0106 *chip = dev_id; + ca0106_t *chip = dev_id; int i; int mask; unsigned int stat76; - struct snd_ca0106_channel *pchannel; + ca0106_channel_t *pchannel; + + spin_lock(&chip->emu_lock); status = inl(chip->port + IPR); + + // call updater, unlock before it + spin_unlock(&chip->emu_lock); + if (! status) return IRQ_NONE; @@ -1061,11 +1024,11 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id, mask = 0x11; /* 0x1 for one half, 0x10 for the other half period. */ for(i = 0; i < 4; i++) { pchannel = &(chip->playback_channels[i]); - if (stat76 & mask) { + if(stat76 & mask) { /* FIXME: Select the correct substream for period elapsed */ if(pchannel->use) { - snd_pcm_period_elapsed(pchannel->epcm->substream); - //printk(KERN_INFO "interrupt [%d] used\n", i); + snd_pcm_period_elapsed(pchannel->epcm->substream); + //printk(KERN_INFO "interrupt [%d] used\n", i); } } //printk(KERN_INFO "channel=%p\n",pchannel); @@ -1075,11 +1038,11 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id, mask = 0x110000; /* 0x1 for one half, 0x10 for the other half period. */ for(i = 0; i < 4; i++) { pchannel = &(chip->capture_channels[i]); - if (stat76 & mask) { + if(stat76 & mask) { /* FIXME: Select the correct substream for period elapsed */ if(pchannel->use) { - snd_pcm_period_elapsed(pchannel->epcm->substream); - //printk(KERN_INFO "interrupt [%d] used\n", i); + snd_pcm_period_elapsed(pchannel->epcm->substream); + //printk(KERN_INFO "interrupt [%d] used\n", i); } } //printk(KERN_INFO "channel=%p\n",pchannel); @@ -1088,9 +1051,10 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id, } snd_ca0106_ptr_write(chip, EXTENDED_INT, 0, stat76); + spin_lock(&chip->emu_lock); if (chip->midi.dev_id && - (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) { + (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) { if (chip->midi.interrupt) chip->midi.interrupt(&chip->midi, status); else @@ -1100,13 +1064,22 @@ static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id, // acknowledge the interrupt if necessary outl(status, chip->port+IPR); + spin_unlock(&chip->emu_lock); + return IRQ_HANDLED; } -static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct snd_pcm **rpcm) +static void snd_ca0106_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; - struct snd_pcm_substream *substream; + ca0106_t *emu = pcm->private_data; + emu->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_ca0106_pcm(ca0106_t *emu, int device, snd_pcm_t **rpcm) +{ + snd_pcm_t *pcm; + snd_pcm_substream_t *substream; int err; if (rpcm) @@ -1115,6 +1088,7 @@ static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct s return err; pcm->private_data = emu; + pcm->private_free = snd_ca0106_pcm_free; switch (device) { case 0: @@ -1166,39 +1140,15 @@ static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct s return 0; } -static unsigned int spi_dac_init[] = { - 0x00ff, - 0x02ff, - 0x0400, - 0x0520, - 0x0600, - 0x08ff, - 0x0aff, - 0x0cff, - 0x0eff, - 0x10ff, - 0x1200, - 0x1400, - 0x1480, - 0x1800, - 0x1aff, - 0x1cff, - 0x1e00, - 0x0530, - 0x0602, - 0x0622, - 0x1400, -}; - -static int __devinit snd_ca0106_create(struct snd_card *card, +static int __devinit snd_ca0106_create(snd_card_t *card, struct pci_dev *pci, - struct snd_ca0106 **rchip) + ca0106_t **rchip) { - struct snd_ca0106 *chip; - struct snd_ca0106_details *c; + ca0106_t *chip; + ca0106_details_t *c; int err; int ch; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ca0106_dev_free, }; @@ -1260,9 +1210,8 @@ static int __devinit snd_ca0106_create(struct snd_card *card, strcpy(card->driver, "CA0106"); strcpy(card->shortname, "CA0106"); - for (c = ca0106_chip_details; c->serial; c++) { - if (c->serial == chip->serial) - break; + for (c=ca0106_chip_details; c->serial; c++) { + if (c->serial == chip->serial) break; } chip->details = c; sprintf(card->longname, "%s at 0x%lx irq %i", @@ -1371,13 +1320,6 @@ static int __devinit snd_ca0106_create(struct snd_card *card, if (chip->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */ snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); /* Enable Line-in capture. MIC in currently untested. */ } - if (chip->details->spi_dac == 1) { /* The SB0570 use SPI to control DAC. */ - int size, n; - - size = ARRAY_SIZE(spi_dac_init); - for (n=0; n < size; n++) - snd_ca0106_spi_write(chip, spi_dac_init[n]); - } if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { @@ -1389,44 +1331,43 @@ static int __devinit snd_ca0106_create(struct snd_card *card, } -static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr) +static void ca0106_midi_interrupt_enable(ca_midi_t *midi, int intr) { - snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr); + snd_ca0106_intr_enable((ca0106_t *)(midi->dev_id), intr); } -static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr) +static void ca0106_midi_interrupt_disable(ca_midi_t *midi, int intr) { - snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr); + snd_ca0106_intr_disable((ca0106_t *)(midi->dev_id), intr); } -static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx) +static unsigned char ca0106_midi_read(ca_midi_t *midi, int idx) { - return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id), - midi->port + idx, 0); + return (unsigned char)snd_ca0106_ptr_read((ca0106_t *)(midi->dev_id), midi->port + idx, 0); } -static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx) +static void ca0106_midi_write(ca_midi_t *midi, int data, int idx) { - snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data); + snd_ca0106_ptr_write((ca0106_t *)(midi->dev_id), midi->port + idx, 0, data); } -static struct snd_card *ca0106_dev_id_card(void *dev_id) +static snd_card_t *ca0106_dev_id_card(void *dev_id) { - return ((struct snd_ca0106 *)dev_id)->card; + return ((ca0106_t *)dev_id)->card; } static int ca0106_dev_id_port(void *dev_id) { - return ((struct snd_ca0106 *)dev_id)->port; + return ((ca0106_t *)dev_id)->port; } -static int __devinit snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel) +static int __devinit snd_ca0106_midi(ca0106_t *chip, unsigned int channel) { - struct snd_ca_midi *midi; + ca_midi_t *midi; char *name; int err; - if (channel == CA0106_MIDI_CHAN_B) { + if(channel==CA0106_MIDI_CHAN_B) { name = "CA0106 MPU-401 (UART) B"; midi = &chip->midi2; midi->tx_enable = INTE_MIDI_TX_B; @@ -1475,8 +1416,8 @@ static int __devinit snd_ca0106_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_ca0106 *chip; + snd_card_t *card; + ca0106_t *chip; int err; if (dev >= SNDRV_CARDS) @@ -1530,9 +1471,7 @@ static int __devinit snd_ca0106_probe(struct pci_dev *pci, } snd_printdd(" done.\n"); -#ifdef CONFIG_PROC_FS snd_ca0106_proc_init(chip); -#endif if ((err = snd_card_register(card)) < 0) { snd_card_free(card); @@ -1568,7 +1507,12 @@ static struct pci_driver driver = { // initialization of the module static int __init alsa_card_ca0106_init(void) { - return pci_register_driver(&driver); + int err; + + if ((err = pci_register_driver(&driver)) > 0) + return err; + + return 0; } // clean up the module diff --git a/trunk/sound/pci/ca0106/ca0106_mixer.c b/trunk/sound/pci/ca0106/ca0106_mixer.c index 06fe055674fb..c10e4a54301b 100644 --- a/trunk/sound/pci/ca0106/ca0106_mixer.c +++ b/trunk/sound/pci/ca0106/ca0106_mixer.c @@ -73,8 +73,7 @@ #include "ca0106.h" -static int snd_ca0106_shared_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ca0106_shared_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -83,19 +82,19 @@ static int snd_ca0106_shared_spdif_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ca0106_shared_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_shared_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = emu->spdif_enable; return 0; } -static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_shared_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); unsigned int val; int change = 0; u32 mask; @@ -126,12 +125,18 @@ static int snd_ca0106_shared_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static snd_kcontrol_new_t snd_ca0106_shared_spdif __devinitdata = { - static char *texts[6] = { - "IEC958 out", "i2s mixer out", "IEC958 in", "i2s in", "AC97 in", "SRC out" - }; + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "SPDIF Out", + .info = snd_ca0106_shared_spdif_info, + .get = snd_ca0106_shared_spdif_get, + .put = snd_ca0106_shared_spdif_put +}; + +static int snd_ca0106_capture_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) +{ + static char *texts[6] = { "SPDIF out", "i2s mixer out", "SPDIF in", "i2s in", "AC97 in", "SRC out" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -142,19 +147,19 @@ static int snd_ca0106_capture_source_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ca0106_capture_source_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_capture_source_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = emu->capture_source; return 0; } -static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_capture_source_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); unsigned int val; int change = 0; u32 mask; @@ -171,8 +176,16 @@ static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static snd_kcontrol_new_t snd_ca0106_capture_source __devinitdata = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Capture Source", + .info = snd_ca0106_capture_source_info, + .get = snd_ca0106_capture_source_get, + .put = snd_ca0106_capture_source_put +}; + +static int snd_ca0106_capture_mic_line_in_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[2] = { "Line in", "Mic in" }; @@ -185,19 +198,19 @@ static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ca0106_capture_mic_line_in_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_capture_mic_line_in_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = emu->capture_mic_line_in; return 0; } -static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_capture_mic_line_in_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); unsigned int val; int change = 0; u32 tmp; @@ -222,7 +235,7 @@ static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata = +static snd_kcontrol_new_t snd_ca0106_capture_mic_line_in __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mic/Line in Capture", @@ -231,18 +244,17 @@ static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata = .put = snd_ca0106_capture_mic_line_in_put }; -static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ca0106_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff; @@ -252,8 +264,8 @@ static int snd_ca0106_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_spdif_get_mask(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -262,10 +274,10 @@ static int snd_ca0106_spdif_get_mask(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); int change; unsigned int val; @@ -282,8 +294,27 @@ static int snd_ca0106_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static snd_kcontrol_new_t snd_ca0106_spdif_mask_control = +{ + .access = SNDRV_CTL_ELEM_ACCESS_READ, + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), + .count = 4, + .info = snd_ca0106_spdif_info, + .get = snd_ca0106_spdif_get_mask +}; + +static snd_kcontrol_new_t snd_ca0106_spdif_control = +{ + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), + .count = 4, + .info = snd_ca0106_spdif_info, + .get = snd_ca0106_spdif_get, + .put = snd_ca0106_spdif_put +}; + +static int snd_ca0106_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -292,15 +323,11 @@ static int snd_ca0106_volume_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_volume_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol, int reg, int channel_id) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); + ca0106_t *emu = snd_kcontrol_chip(kcontrol); unsigned int value; - int channel_id, reg; - - channel_id = (kcontrol->private_value >> 8) & 0xff; - reg = kcontrol->private_value & 0xff; value = snd_ca0106_ptr_read(emu, reg, channel_id); ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */ @@ -308,103 +335,237 @@ static int snd_ca0106_volume_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ca0106_volume_get_spdif_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_FRONT_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} + +static int snd_ca0106_volume_get_spdif_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_CENTER_LFE_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_get_spdif_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_UNKNOWN_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_get_spdif_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_REAR_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_get_analog_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol); - unsigned int oval, nval; - int channel_id, reg; + int channel_id = CONTROL_FRONT_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} - channel_id = (kcontrol->private_value >> 8) & 0xff; - reg = kcontrol->private_value & 0xff; +static int snd_ca0106_volume_get_analog_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_CENTER_LFE_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_get_analog_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_UNKNOWN_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_get_analog_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_REAR_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} - oval = snd_ca0106_ptr_read(emu, reg, channel_id); - nval = ((0xff - ucontrol->value.integer.value[0]) << 24) | - ((0xff - ucontrol->value.integer.value[1]) << 16); - nval |= ((0xff - ucontrol->value.integer.value[0]) << 8) | - ((0xff - ucontrol->value.integer.value[1]) ); - if (oval == nval) - return 0; - snd_ca0106_ptr_write(emu, reg, channel_id, nval); - return 1; -} - -#define CA_VOLUME(xname,chid,reg) \ -{ \ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ - .info = snd_ca0106_volume_info, \ - .get = snd_ca0106_volume_get, \ - .put = snd_ca0106_volume_put, \ - .private_value = ((chid) << 8) | (reg) \ -} - - -static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = { - CA_VOLUME("Analog Front Playback Volume", - CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME2), - CA_VOLUME("Analog Rear Playback Volume", - CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME2), - CA_VOLUME("Analog Center/LFE Playback Volume", - CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME2), - CA_VOLUME("Analog Side Playback Volume", - CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME2), - - CA_VOLUME("IEC958 Front Playback Volume", - CONTROL_FRONT_CHANNEL, PLAYBACK_VOLUME1), - CA_VOLUME("IEC958 Rear Playback Volume", - CONTROL_REAR_CHANNEL, PLAYBACK_VOLUME1), - CA_VOLUME("IEC958 Center/LFE Playback Volume", - CONTROL_CENTER_LFE_CHANNEL, PLAYBACK_VOLUME1), - CA_VOLUME("IEC958 Unknown Playback Volume", - CONTROL_UNKNOWN_CHANNEL, PLAYBACK_VOLUME1), - - CA_VOLUME("CAPTURE feedback Playback Volume", - 1, CAPTURE_CONTROL), - - { - .access = SNDRV_CTL_ELEM_ACCESS_READ, - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), - .count = 4, - .info = snd_ca0106_spdif_info, - .get = snd_ca0106_spdif_get_mask - }, - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "IEC958 Playback Switch", - .info = snd_ca0106_shared_spdif_info, - .get = snd_ca0106_shared_spdif_get, - .put = snd_ca0106_shared_spdif_put - }, - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Capture Source", - .info = snd_ca0106_capture_source_info, - .get = snd_ca0106_capture_source_get, - .put = snd_ca0106_capture_source_put - }, - { - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), - .count = 4, - .info = snd_ca0106_spdif_info, - .get = snd_ca0106_spdif_get, - .put = snd_ca0106_spdif_put - }, +static int snd_ca0106_volume_get_feedback(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = 1; + int reg = CAPTURE_CONTROL; + return snd_ca0106_volume_get(kcontrol, ucontrol, reg, channel_id); +} + +static int snd_ca0106_volume_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol, int reg, int channel_id) +{ + ca0106_t *emu = snd_kcontrol_chip(kcontrol); + unsigned int value; + //value = snd_ca0106_ptr_read(emu, reg, channel_id); + //value = value & 0xffff; + value = ((0xff - ucontrol->value.integer.value[0]) << 24) | ((0xff - ucontrol->value.integer.value[1]) << 16); + value = value | ((0xff - ucontrol->value.integer.value[0]) << 8) | ((0xff - ucontrol->value.integer.value[1]) ); + snd_ca0106_ptr_write(emu, reg, channel_id, value); + return 1; +} +static int snd_ca0106_volume_put_spdif_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_FRONT_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_put_spdif_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_CENTER_LFE_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_put_spdif_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_UNKNOWN_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_put_spdif_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_REAR_CHANNEL; + int reg = PLAYBACK_VOLUME1; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_put_analog_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_FRONT_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_put_analog_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_CENTER_LFE_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_put_analog_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_UNKNOWN_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} +static int snd_ca0106_volume_put_analog_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = CONTROL_REAR_CHANNEL; + int reg = PLAYBACK_VOLUME2; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} + +static int snd_ca0106_volume_put_feedback(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int channel_id = 1; + int reg = CAPTURE_CONTROL; + return snd_ca0106_volume_put(kcontrol, ucontrol, reg, channel_id); +} + +static snd_kcontrol_new_t snd_ca0106_volume_control_analog_front = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Analog Front Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_analog_front, + .put = snd_ca0106_volume_put_analog_front +}; +static snd_kcontrol_new_t snd_ca0106_volume_control_analog_center_lfe = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Analog Center/LFE Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_analog_center_lfe, + .put = snd_ca0106_volume_put_analog_center_lfe +}; +static snd_kcontrol_new_t snd_ca0106_volume_control_analog_unknown = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Analog Side Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_analog_unknown, + .put = snd_ca0106_volume_put_analog_unknown +}; +static snd_kcontrol_new_t snd_ca0106_volume_control_analog_rear = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Analog Rear Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_analog_rear, + .put = snd_ca0106_volume_put_analog_rear +}; +static snd_kcontrol_new_t snd_ca0106_volume_control_spdif_front = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "SPDIF Front Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_spdif_front, + .put = snd_ca0106_volume_put_spdif_front +}; +static snd_kcontrol_new_t snd_ca0106_volume_control_spdif_center_lfe = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "SPDIF Center/LFE Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_spdif_center_lfe, + .put = snd_ca0106_volume_put_spdif_center_lfe +}; +static snd_kcontrol_new_t snd_ca0106_volume_control_spdif_unknown = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "SPDIF Unknown Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_spdif_unknown, + .put = snd_ca0106_volume_put_spdif_unknown +}; +static snd_kcontrol_new_t snd_ca0106_volume_control_spdif_rear = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "SPDIF Rear Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_spdif_rear, + .put = snd_ca0106_volume_put_spdif_rear }; -static int __devinit remove_ctl(struct snd_card *card, const char *name) +static snd_kcontrol_new_t snd_ca0106_volume_control_feedback = { - struct snd_ctl_elem_id id; + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "CAPTURE feedback Playback Volume", + .info = snd_ca0106_volume_info, + .get = snd_ca0106_volume_get_feedback, + .put = snd_ca0106_volume_put_feedback +}; + + +static int remove_ctl(snd_card_t *card, const char *name) +{ + snd_ctl_elem_id_t id; memset(&id, 0, sizeof(id)); strcpy(id.name, name); id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; return snd_ctl_remove_id(card, &id); } -static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char *name) +static snd_kcontrol_t *ctl_find(snd_card_t *card, const char *name) { - struct snd_ctl_elem_id sid; + snd_ctl_elem_id_t sid; memset(&sid, 0, sizeof(sid)); /* FIXME: strcpy is bad. */ strcpy(sid.name, name); @@ -412,9 +573,9 @@ static struct snd_kcontrol __devinit *ctl_find(struct snd_card *card, const char return snd_ctl_find_id(card, &sid); } -static int __devinit rename_ctl(struct snd_card *card, const char *src, const char *dst) +static int rename_ctl(snd_card_t *card, const char *src, const char *dst) { - struct snd_kcontrol *kctl = ctl_find(card, src); + snd_kcontrol_t *kctl = ctl_find(card, src); if (kctl) { strcpy(kctl->id.name, dst); return 0; @@ -422,10 +583,11 @@ static int __devinit rename_ctl(struct snd_card *card, const char *src, const ch return -ENOENT; } -int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu) +int __devinit snd_ca0106_mixer(ca0106_t *emu) { - int i, err; - struct snd_card *card = emu->card; + int err; + snd_kcontrol_t *kctl; + snd_card_t *card = emu->card; char **c; static char *ca0106_remove_ctls[] = { "Master Mono Playback Switch", @@ -465,22 +627,70 @@ int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu) NULL }; #if 1 - for (c = ca0106_remove_ctls; *c; c++) + for (c=ca0106_remove_ctls; *c; c++) remove_ctl(card, *c); - for (c = ca0106_rename_ctls; *c; c += 2) + for (c=ca0106_rename_ctls; *c; c += 2) rename_ctl(card, c[0], c[1]); #endif - for (i = 0; i < ARRAY_SIZE(snd_ca0106_volume_ctls); i++) { - err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_volume_ctls[i], emu)); - if (err < 0) - return err; - } + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_analog_front, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_analog_rear, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_analog_center_lfe, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_analog_unknown, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_spdif_front, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_spdif_rear, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_spdif_center_lfe, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_spdif_unknown, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_volume_control_feedback, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_spdif_mask_control, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_shared_spdif, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_ca0106_capture_source, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; if (emu->details->i2c_adc == 1) { - err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu)); - if (err < 0) + if ((kctl = snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) return err; } + if ((kctl = snd_ctl_new1(&snd_ca0106_spdif_control, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; return 0; } diff --git a/trunk/sound/pci/ca0106/ca0106_proc.c b/trunk/sound/pci/ca0106/ca0106_proc.c index 63757273bfb7..1c9cc821d1b9 100644 --- a/trunk/sound/pci/ca0106/ca0106_proc.c +++ b/trunk/sound/pci/ca0106/ca0106_proc.c @@ -77,8 +77,6 @@ #include "ca0106.h" -#ifdef CONFIG_PROC_FS - struct snd_ca0106_category_str { int val; const char *name; @@ -99,7 +97,7 @@ static struct snd_ca0106_category_str snd_ca0106_con_category[] = { }; -static void snd_ca0106_proc_dump_iec958( struct snd_info_buffer *buffer, u32 value) +static void snd_ca0106_proc_dump_iec958( snd_info_buffer_t *buffer, u32 value) { int i; u32 status[4]; @@ -273,10 +271,10 @@ static void snd_ca0106_proc_dump_iec958( struct snd_info_buffer *buffer, u32 val } } -static void snd_ca0106_proc_iec958(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_iec958(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; u32 value; value = snd_ca0106_ptr_read(emu, SAMPLE_RATE_TRACKER_STATUS, 0); @@ -295,10 +293,10 @@ static void snd_ca0106_proc_iec958(struct snd_info_entry *entry, snd_iprintf(buffer, "\n"); } -static void snd_ca0106_proc_reg_write32(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_reg_write32(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; unsigned long flags; char line[64]; u32 reg, val; @@ -313,10 +311,10 @@ static void snd_ca0106_proc_reg_write32(struct snd_info_entry *entry, } } -static void snd_ca0106_proc_reg_read32(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_reg_read32(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; unsigned long value; unsigned long flags; int i; @@ -329,10 +327,10 @@ static void snd_ca0106_proc_reg_read32(struct snd_info_entry *entry, } } -static void snd_ca0106_proc_reg_read16(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_reg_read16(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; unsigned int value; unsigned long flags; int i; @@ -345,10 +343,10 @@ static void snd_ca0106_proc_reg_read16(struct snd_info_entry *entry, } } -static void snd_ca0106_proc_reg_read8(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_reg_read8(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; unsigned int value; unsigned long flags; int i; @@ -361,10 +359,10 @@ static void snd_ca0106_proc_reg_read8(struct snd_info_entry *entry, } } -static void snd_ca0106_proc_reg_read1(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_reg_read1(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; unsigned long value; int i,j; @@ -379,10 +377,10 @@ static void snd_ca0106_proc_reg_read1(struct snd_info_entry *entry, } } -static void snd_ca0106_proc_reg_read2(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_reg_read2(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; unsigned long value; int i,j; @@ -397,10 +395,10 @@ static void snd_ca0106_proc_reg_read2(struct snd_info_entry *entry, } } -static void snd_ca0106_proc_reg_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_reg_write(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; char line[64]; unsigned int reg, channel_id , val; while (!snd_info_get_line(buffer, line, sizeof(line))) { @@ -411,10 +409,10 @@ static void snd_ca0106_proc_reg_write(struct snd_info_entry *entry, } } -static void snd_ca0106_proc_i2c_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ca0106_proc_i2c_write(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ca0106 *emu = entry->private_data; + ca0106_t *emu = entry->private_data; char line[64]; unsigned int reg, val; while (!snd_info_get_line(buffer, line, sizeof(line))) { @@ -426,9 +424,9 @@ static void snd_ca0106_proc_i2c_write(struct snd_info_entry *entry, } } -int __devinit snd_ca0106_proc_init(struct snd_ca0106 * emu) +int __devinit snd_ca0106_proc_init(ca0106_t * emu) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if(! snd_card_proc_new(emu->card, "iec958", &entry)) snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_iec958); @@ -461,4 +459,3 @@ int __devinit snd_ca0106_proc_init(struct snd_ca0106 * emu) return 0; } -#endif /* CONFIG_PROC_FS */ diff --git a/trunk/sound/pci/ca0106/ca_midi.c b/trunk/sound/pci/ca0106/ca_midi.c index 2e6eab1f1189..2e08b27b8349 100644 --- a/trunk/sound/pci/ca0106/ca_midi.c +++ b/trunk/sound/pci/ca0106/ca_midi.c @@ -40,20 +40,18 @@ #define ca_midi_input_avail(midi) (!(ca_midi_read_stat(midi) & midi->input_avail)) #define ca_midi_output_ready(midi) (!(ca_midi_read_stat(midi) & midi->output_ready)) -static void ca_midi_clear_rx(struct snd_ca_midi *midi) +static void ca_midi_clear_rx(ca_midi_t *midi) { int timeout = 100000; for (; timeout > 0 && ca_midi_input_avail(midi); timeout--) ca_midi_read_data(midi); #ifdef CONFIG_SND_DEBUG if (timeout <= 0) - snd_printk(KERN_ERR "ca_midi_clear_rx: timeout (status = 0x%x)\n", - ca_midi_read_stat(midi)); + snd_printk(KERN_ERR "ca_midi_clear_rx: timeout (status = 0x%x)\n", ca_midi_read_stat(midi)); #endif } -static void ca_midi_interrupt(struct snd_ca_midi *midi, unsigned int status) -{ +static void ca_midi_interrupt(ca_midi_t *midi, unsigned int status) { unsigned char byte; if (midi->rmidi == NULL) { @@ -88,7 +86,7 @@ static void ca_midi_interrupt(struct snd_ca_midi *midi, unsigned int status) } -static void ca_midi_cmd(struct snd_ca_midi *midi, unsigned char cmd, int ack) +static void ca_midi_cmd(ca_midi_t *midi, unsigned char cmd, int ack) { unsigned long flags; int timeout, ok; @@ -121,9 +119,9 @@ static void ca_midi_cmd(struct snd_ca_midi *midi, unsigned char cmd, int ack) ca_midi_read_data(midi)); } -static int ca_midi_input_open(struct snd_rawmidi_substream *substream) +static int ca_midi_input_open(snd_rawmidi_substream_t * substream) { - struct snd_ca_midi *midi = substream->rmidi->private_data; + ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data; unsigned long flags; snd_assert(midi->dev_id, return -ENXIO); @@ -140,9 +138,9 @@ static int ca_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int ca_midi_output_open(struct snd_rawmidi_substream *substream) +static int ca_midi_output_open(snd_rawmidi_substream_t * substream) { - struct snd_ca_midi *midi = substream->rmidi->private_data; + ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data; unsigned long flags; snd_assert(midi->dev_id, return -ENXIO); @@ -159,9 +157,9 @@ static int ca_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int ca_midi_input_close(struct snd_rawmidi_substream *substream) +static int ca_midi_input_close(snd_rawmidi_substream_t * substream) { - struct snd_ca_midi *midi = substream->rmidi->private_data; + ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data; unsigned long flags; snd_assert(midi->dev_id, return -ENXIO); @@ -178,9 +176,9 @@ static int ca_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int ca_midi_output_close(struct snd_rawmidi_substream *substream) +static int ca_midi_output_close(snd_rawmidi_substream_t * substream) { - struct snd_ca_midi *midi = substream->rmidi->private_data; + ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data; unsigned long flags; snd_assert(midi->dev_id, return -ENXIO); @@ -199,9 +197,9 @@ static int ca_midi_output_close(struct snd_rawmidi_substream *substream) return 0; } -static void ca_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void ca_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct snd_ca_midi *midi = substream->rmidi->private_data; + ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data; snd_assert(midi->dev_id, return); if (up) { @@ -211,9 +209,9 @@ static void ca_midi_input_trigger(struct snd_rawmidi_substream *substream, int u } } -static void ca_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void ca_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { - struct snd_ca_midi *midi = substream->rmidi->private_data; + ca_midi_t *midi = (ca_midi_t *)substream->rmidi->private_data; unsigned long flags; snd_assert(midi->dev_id, return); @@ -248,22 +246,21 @@ static void ca_midi_output_trigger(struct snd_rawmidi_substream *substream, int } } -static struct snd_rawmidi_ops ca_midi_output = +static snd_rawmidi_ops_t ca_midi_output = { .open = ca_midi_output_open, .close = ca_midi_output_close, .trigger = ca_midi_output_trigger, }; -static struct snd_rawmidi_ops ca_midi_input = +static snd_rawmidi_ops_t ca_midi_input = { .open = ca_midi_input_open, .close = ca_midi_input_close, .trigger = ca_midi_input_trigger, }; -static void ca_midi_free(struct snd_ca_midi *midi) -{ +static void ca_midi_free(ca_midi_t *midi) { midi->interrupt = NULL; midi->interrupt_enable = NULL; midi->interrupt_disable = NULL; @@ -274,14 +271,14 @@ static void ca_midi_free(struct snd_ca_midi *midi) midi->rmidi = NULL; } -static void ca_rmidi_free(struct snd_rawmidi *rmidi) +static void ca_rmidi_free(snd_rawmidi_t *rmidi) { - ca_midi_free(rmidi->private_data); + ca_midi_free((ca_midi_t *)rmidi->private_data); } -int __devinit ca_midi_init(void *dev_id, struct snd_ca_midi *midi, int device, char *name) +int __devinit ca_midi_init(void *dev_id, ca_midi_t *midi, int device, char *name) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if ((err = snd_rawmidi_new(midi->get_dev_id_card(midi->dev_id), name, device, 1, 1, &rmidi)) < 0) diff --git a/trunk/sound/pci/ca0106/ca_midi.h b/trunk/sound/pci/ca0106/ca_midi.h index b72c0933bd22..b452cec2bf57 100644 --- a/trunk/sound/pci/ca0106/ca_midi.h +++ b/trunk/sound/pci/ca0106/ca_midi.h @@ -29,11 +29,12 @@ #define CA_MIDI_MODE_INPUT MPU401_MODE_INPUT #define CA_MIDI_MODE_OUTPUT MPU401_MODE_OUTPUT -struct snd_ca_midi { +typedef struct ca_midi ca_midi_t; +struct ca_midi { - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *substream_input; - struct snd_rawmidi_substream *substream_output; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *substream_input; + snd_rawmidi_substream_t *substream_output; void *dev_id; @@ -51,16 +52,18 @@ struct snd_ca_midi { int input_avail, output_ready; int ack, reset, enter_uart; - void (*interrupt)(struct snd_ca_midi *midi, unsigned int status); - void (*interrupt_enable)(struct snd_ca_midi *midi, int intr); - void (*interrupt_disable)(struct snd_ca_midi *midi, int intr); + void (*interrupt)(ca_midi_t *midi, unsigned int status); + void (*interrupt_enable)(ca_midi_t *midi, int intr); + void (*interrupt_disable)(ca_midi_t *midi, int intr); - unsigned char (*read)(struct snd_ca_midi *midi, int idx); - void (*write)(struct snd_ca_midi *midi, int data, int idx); + unsigned char (*read)(ca_midi_t *midi, int idx); + void (*write)(ca_midi_t *midi, int data, int idx); /* get info from dev_id */ - struct snd_card *(*get_dev_id_card)(void *dev_id); + snd_card_t *(*get_dev_id_card)(void *dev_id); int (*get_dev_id_port)(void *dev_id); }; -int ca_midi_init(void *card, struct snd_ca_midi *midi, int device, char *name); +int __devinit ca_midi_init(void *card, ca_midi_t *midi, int device, char *name); + + diff --git a/trunk/sound/pci/cmipci.c b/trunk/sound/pci/cmipci.c index c03b0a0a3b27..db605373b3bc 100644 --- a/trunk/sound/pci/cmipci.c +++ b/trunk/sound/pci/cmipci.c @@ -269,7 +269,6 @@ MODULE_PARM_DESC(joystick_port, "Joystick port address."); #define CM_MICGAINZ 0x01 /* mic boost */ #define CM_MICGAINZ_SHIFT 0 -#define CM_REG_MIXER3 0x24 #define CM_REG_AUX_VOL 0x26 #define CM_VAUXL_MASK 0xf0 #define CM_VAUXR_MASK 0x0f @@ -325,7 +324,6 @@ MODULE_PARM_DESC(joystick_port, "Joystick port address."); #define CM_REG_CH0_FRAME2 0x84 #define CM_REG_CH1_FRAME1 0x88 /* 0-15: count of samples at bus master; buffer size */ #define CM_REG_CH1_FRAME2 0x8C /* 16-31: count of samples at codec; fragment size */ -#define CM_REG_EXT_MISC 0x90 #define CM_REG_MISC_CTRL_8768 0x92 /* reg. name the same as 0x18 */ #define CM_CHB3D8C 0x20 /* 7.1 channels support */ #define CM_SPD32FMT 0x10 /* SPDIF/IN 32k */ @@ -380,8 +378,11 @@ MODULE_PARM_DESC(joystick_port, "Joystick port address."); * driver data */ -struct cmipci_pcm { - struct snd_pcm_substream *substream; +typedef struct snd_stru_cmipci cmipci_t; +typedef struct snd_stru_cmipci_pcm cmipci_pcm_t; + +struct snd_stru_cmipci_pcm { + snd_pcm_substream_t *substream; int running; /* dac/adc running? */ unsigned int dma_size; /* in frames */ unsigned int period_size; /* in frames */ @@ -407,8 +408,8 @@ static const struct cmipci_mixer_auto_switches cm_saved_mixer[] = { }; #define CM_SAVED_MIXERS ARRAY_SIZE(cm_saved_mixer) -struct cmipci { - struct snd_card *card; +struct snd_stru_cmipci { + snd_card_t *card; struct pci_dev *pci; unsigned int device; /* device ID */ @@ -417,9 +418,9 @@ struct cmipci { unsigned long iobase; unsigned int ctrl; /* FUNCTRL0 current value */ - struct snd_pcm *pcm; /* DAC/ADC PCM */ - struct snd_pcm *pcm2; /* 2nd DAC */ - struct snd_pcm *pcm_spdif; /* SPDIF */ + snd_pcm_t *pcm; /* DAC/ADC PCM */ + snd_pcm_t *pcm2; /* 2nd DAC */ + snd_pcm_t *pcm_spdif; /* SPDIF */ int chip_version; int max_channels; @@ -436,68 +437,63 @@ struct cmipci { unsigned int dig_status; unsigned int dig_pcm_status; - struct snd_pcm_hardware *hw_info[3]; /* for playbacks */ + snd_pcm_hardware_t *hw_info[3]; /* for playbacks */ int opened[2]; /* open mode */ struct semaphore open_mutex; unsigned int mixer_insensitive: 1; - struct snd_kcontrol *mixer_res_ctl[CM_SAVED_MIXERS]; + snd_kcontrol_t *mixer_res_ctl[CM_SAVED_MIXERS]; int mixer_res_status[CM_SAVED_MIXERS]; - struct cmipci_pcm channel[2]; /* ch0 - DAC, ch1 - ADC or 2nd DAC */ + cmipci_pcm_t channel[2]; /* ch0 - DAC, ch1 - ADC or 2nd DAC */ /* external MIDI */ - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; #ifdef SUPPORT_JOYSTICK struct gameport *gameport; #endif spinlock_t reg_lock; - -#ifdef CONFIG_PM - unsigned int saved_regs[0x20]; - unsigned char saved_mixers[0x20]; -#endif }; /* read/write operations for dword register */ -static inline void snd_cmipci_write(struct cmipci *cm, unsigned int cmd, unsigned int data) +static inline void snd_cmipci_write(cmipci_t *cm, unsigned int cmd, unsigned int data) { outl(data, cm->iobase + cmd); } -static inline unsigned int snd_cmipci_read(struct cmipci *cm, unsigned int cmd) +static inline unsigned int snd_cmipci_read(cmipci_t *cm, unsigned int cmd) { return inl(cm->iobase + cmd); } /* read/write operations for word register */ -static inline void snd_cmipci_write_w(struct cmipci *cm, unsigned int cmd, unsigned short data) +static inline void snd_cmipci_write_w(cmipci_t *cm, unsigned int cmd, unsigned short data) { outw(data, cm->iobase + cmd); } -static inline unsigned short snd_cmipci_read_w(struct cmipci *cm, unsigned int cmd) +static inline unsigned short snd_cmipci_read_w(cmipci_t *cm, unsigned int cmd) { return inw(cm->iobase + cmd); } /* read/write operations for byte register */ -static inline void snd_cmipci_write_b(struct cmipci *cm, unsigned int cmd, unsigned char data) +static inline void snd_cmipci_write_b(cmipci_t *cm, unsigned int cmd, unsigned char data) { outb(data, cm->iobase + cmd); } -static inline unsigned char snd_cmipci_read_b(struct cmipci *cm, unsigned int cmd) +static inline unsigned char snd_cmipci_read_b(cmipci_t *cm, unsigned int cmd) { return inb(cm->iobase + cmd); } /* bit operations for dword register */ -static int snd_cmipci_set_bit(struct cmipci *cm, unsigned int cmd, unsigned int flag) +static int snd_cmipci_set_bit(cmipci_t *cm, unsigned int cmd, unsigned int flag) { unsigned int val, oval; val = oval = inl(cm->iobase + cmd); @@ -508,7 +504,7 @@ static int snd_cmipci_set_bit(struct cmipci *cm, unsigned int cmd, unsigned int return 1; } -static int snd_cmipci_clear_bit(struct cmipci *cm, unsigned int cmd, unsigned int flag) +static int snd_cmipci_clear_bit(cmipci_t *cm, unsigned int cmd, unsigned int flag) { unsigned int val, oval; val = oval = inl(cm->iobase + cmd); @@ -520,7 +516,7 @@ static int snd_cmipci_clear_bit(struct cmipci *cm, unsigned int cmd, unsigned in } /* bit operations for byte register */ -static int snd_cmipci_set_bit_b(struct cmipci *cm, unsigned int cmd, unsigned char flag) +static int snd_cmipci_set_bit_b(cmipci_t *cm, unsigned int cmd, unsigned char flag) { unsigned char val, oval; val = oval = inb(cm->iobase + cmd); @@ -531,7 +527,7 @@ static int snd_cmipci_set_bit_b(struct cmipci *cm, unsigned int cmd, unsigned ch return 1; } -static int snd_cmipci_clear_bit_b(struct cmipci *cm, unsigned int cmd, unsigned char flag) +static int snd_cmipci_clear_bit_b(cmipci_t *cm, unsigned int cmd, unsigned char flag) { unsigned char val, oval; val = oval = inb(cm->iobase + cmd); @@ -612,7 +608,7 @@ static int snd_cmipci_pll_rmn(unsigned int rate, unsigned int adcmult, int *r, i * at the register CM_REG_FUNCTRL1 (0x04). * Problem: other ways are also possible (any information about that?) */ -static void snd_cmipci_set_pll(struct cmipci *cm, unsigned int rate, unsigned int slot) +static void snd_cmipci_set_pll(cmipci_t *cm, unsigned int rate, unsigned int slot) { unsigned int reg = CM_REG_PLL + slot; /* @@ -630,16 +626,16 @@ static void snd_cmipci_set_pll(struct cmipci *cm, unsigned int rate, unsigned in } #endif /* USE_VAR48KRATE */ -static int snd_cmipci_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cmipci_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_cmipci_playback2_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cmipci_playback2_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); if (params_channels(hw_params) > 2) { down(&cm->open_mutex); if (cm->opened[CM_CH_PLAY]) { @@ -653,7 +649,7 @@ static int snd_cmipci_playback2_hw_params(struct snd_pcm_substream *substream, return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static void snd_cmipci_ch_reset(struct cmipci *cm, int ch) +static void snd_cmipci_ch_reset(cmipci_t *cm, int ch) { int reset = CM_RST_CH0 << (cm->channel[ch].ch); snd_cmipci_write(cm, CM_REG_FUNCTRL0, cm->ctrl | reset); @@ -661,7 +657,7 @@ static void snd_cmipci_ch_reset(struct cmipci *cm, int ch) udelay(10); } -static int snd_cmipci_hw_free(struct snd_pcm_substream *substream) +static int snd_cmipci_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } @@ -671,23 +667,23 @@ static int snd_cmipci_hw_free(struct snd_pcm_substream *substream) */ static unsigned int hw_channels[] = {1, 2, 4, 5, 6, 8}; -static struct snd_pcm_hw_constraint_list hw_constraints_channels_4 = { +static snd_pcm_hw_constraint_list_t hw_constraints_channels_4 = { .count = 3, .list = hw_channels, .mask = 0, }; -static struct snd_pcm_hw_constraint_list hw_constraints_channels_6 = { +static snd_pcm_hw_constraint_list_t hw_constraints_channels_6 = { .count = 5, .list = hw_channels, .mask = 0, }; -static struct snd_pcm_hw_constraint_list hw_constraints_channels_8 = { +static snd_pcm_hw_constraint_list_t hw_constraints_channels_8 = { .count = 6, .list = hw_channels, .mask = 0, }; -static int set_dac_channels(struct cmipci *cm, struct cmipci_pcm *rec, int channels) +static int set_dac_channels(cmipci_t *cm, cmipci_pcm_t *rec, int channels) { if (channels > 2) { if (! cm->can_multi_ch) @@ -741,11 +737,11 @@ static int set_dac_channels(struct cmipci *cm, struct cmipci_pcm *rec, int chann * prepare playback/capture channel * channel to be used must have been set in rec->ch. */ -static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec, - struct snd_pcm_substream *substream) +static int snd_cmipci_pcm_prepare(cmipci_t *cm, cmipci_pcm_t *rec, + snd_pcm_substream_t *substream) { unsigned int reg, freq, val; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; rec->fmt = 0; rec->shift = 0; @@ -824,8 +820,8 @@ static int snd_cmipci_pcm_prepare(struct cmipci *cm, struct cmipci_pcm *rec, /* * PCM trigger/stop */ -static int snd_cmipci_pcm_trigger(struct cmipci *cm, struct cmipci_pcm *rec, - struct snd_pcm_substream *substream, int cmd) +static int snd_cmipci_pcm_trigger(cmipci_t *cm, cmipci_pcm_t *rec, + snd_pcm_substream_t *substream, int cmd) { unsigned int inthld, chen, reset, pause; int result = 0; @@ -856,12 +852,10 @@ static int snd_cmipci_pcm_trigger(struct cmipci *cm, struct cmipci_pcm *rec, snd_cmipci_write(cm, CM_REG_FUNCTRL0, cm->ctrl & ~reset); break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - case SNDRV_PCM_TRIGGER_SUSPEND: cm->ctrl |= pause; snd_cmipci_write(cm, CM_REG_FUNCTRL0, cm->ctrl); break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - case SNDRV_PCM_TRIGGER_RESUME: cm->ctrl &= ~pause; snd_cmipci_write(cm, CM_REG_FUNCTRL0, cm->ctrl); break; @@ -876,8 +870,8 @@ static int snd_cmipci_pcm_trigger(struct cmipci *cm, struct cmipci_pcm *rec, /* * return the current pointer */ -static snd_pcm_uframes_t snd_cmipci_pcm_pointer(struct cmipci *cm, struct cmipci_pcm *rec, - struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cmipci_pcm_pointer(cmipci_t *cm, cmipci_pcm_t *rec, + snd_pcm_substream_t *substream) { size_t ptr; unsigned int reg; @@ -901,16 +895,16 @@ static snd_pcm_uframes_t snd_cmipci_pcm_pointer(struct cmipci *cm, struct cmipci * playback */ -static int snd_cmipci_playback_trigger(struct snd_pcm_substream *substream, +static int snd_cmipci_playback_trigger(snd_pcm_substream_t *substream, int cmd) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); return snd_cmipci_pcm_trigger(cm, &cm->channel[CM_CH_PLAY], substream, cmd); } -static snd_pcm_uframes_t snd_cmipci_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cmipci_playback_pointer(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); return snd_cmipci_pcm_pointer(cm, &cm->channel[CM_CH_PLAY], substream); } @@ -920,16 +914,16 @@ static snd_pcm_uframes_t snd_cmipci_playback_pointer(struct snd_pcm_substream *s * capture */ -static int snd_cmipci_capture_trigger(struct snd_pcm_substream *substream, +static int snd_cmipci_capture_trigger(snd_pcm_substream_t *substream, int cmd) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); return snd_cmipci_pcm_trigger(cm, &cm->channel[CM_CH_CAPT], substream, cmd); } -static snd_pcm_uframes_t snd_cmipci_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cmipci_capture_pointer(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); return snd_cmipci_pcm_pointer(cm, &cm->channel[CM_CH_CAPT], substream); } @@ -938,18 +932,18 @@ static snd_pcm_uframes_t snd_cmipci_capture_pointer(struct snd_pcm_substream *su * hw preparation for spdif */ -static int snd_cmipci_spdif_default_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_spdif_default_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_cmipci_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_spdif_default_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct cmipci *chip = snd_kcontrol_chip(kcontrol); + cmipci_t *chip = snd_kcontrol_chip(kcontrol); int i; spin_lock_irq(&chip->reg_lock); @@ -959,10 +953,10 @@ static int snd_cmipci_spdif_default_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_spdif_default_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct cmipci *chip = snd_kcontrol_chip(kcontrol); + cmipci_t *chip = snd_kcontrol_chip(kcontrol); int i, change; unsigned int val; @@ -976,7 +970,7 @@ static int snd_cmipci_spdif_default_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_cmipci_spdif_default __devinitdata = +static snd_kcontrol_new_t snd_cmipci_spdif_default __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -985,16 +979,16 @@ static struct snd_kcontrol_new snd_cmipci_spdif_default __devinitdata = .put = snd_cmipci_spdif_default_put }; -static int snd_cmipci_spdif_mask_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_spdif_mask_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_cmipci_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t *ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -1003,7 +997,7 @@ static int snd_cmipci_spdif_mask_get(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_cmipci_spdif_mask __devinitdata = +static snd_kcontrol_new_t snd_cmipci_spdif_mask __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1012,18 +1006,18 @@ static struct snd_kcontrol_new snd_cmipci_spdif_mask __devinitdata = .get = snd_cmipci_spdif_mask_get, }; -static int snd_cmipci_spdif_stream_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_spdif_stream_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_cmipci_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_spdif_stream_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct cmipci *chip = snd_kcontrol_chip(kcontrol); + cmipci_t *chip = snd_kcontrol_chip(kcontrol); int i; spin_lock_irq(&chip->reg_lock); @@ -1033,10 +1027,10 @@ static int snd_cmipci_spdif_stream_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_spdif_stream_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct cmipci *chip = snd_kcontrol_chip(kcontrol); + cmipci_t *chip = snd_kcontrol_chip(kcontrol); int i, change; unsigned int val; @@ -1050,7 +1044,7 @@ static int snd_cmipci_spdif_stream_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_cmipci_spdif_stream __devinitdata = +static snd_kcontrol_new_t snd_cmipci_spdif_stream __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1064,17 +1058,17 @@ static struct snd_kcontrol_new snd_cmipci_spdif_stream __devinitdata = */ /* save mixer setting and mute for AC3 playback */ -static int save_mixer_state(struct cmipci *cm) +static int save_mixer_state(cmipci_t *cm) { if (! cm->mixer_insensitive) { - struct snd_ctl_elem_value *val; + snd_ctl_elem_value_t *val; unsigned int i; val = kmalloc(sizeof(*val), GFP_ATOMIC); if (!val) return -ENOMEM; for (i = 0; i < CM_SAVED_MIXERS; i++) { - struct snd_kcontrol *ctl = cm->mixer_res_ctl[i]; + snd_kcontrol_t *ctl = cm->mixer_res_ctl[i]; if (ctl) { int event; memset(val, 0, sizeof(*val)); @@ -1098,10 +1092,10 @@ static int save_mixer_state(struct cmipci *cm) /* restore the previously saved mixer status */ -static void restore_mixer_state(struct cmipci *cm) +static void restore_mixer_state(cmipci_t *cm) { if (cm->mixer_insensitive) { - struct snd_ctl_elem_value *val; + snd_ctl_elem_value_t *val; unsigned int i; val = kmalloc(sizeof(*val), GFP_KERNEL); @@ -1110,7 +1104,7 @@ static void restore_mixer_state(struct cmipci *cm) cm->mixer_insensitive = 0; /* at first clear this; otherwise the changes will be ignored */ for (i = 0; i < CM_SAVED_MIXERS; i++) { - struct snd_kcontrol *ctl = cm->mixer_res_ctl[i]; + snd_kcontrol_t *ctl = cm->mixer_res_ctl[i]; if (ctl) { int event; @@ -1131,7 +1125,7 @@ static void restore_mixer_state(struct cmipci *cm) } /* spinlock held! */ -static void setup_ac3(struct cmipci *cm, struct snd_pcm_substream *subs, int do_ac3, int rate) +static void setup_ac3(cmipci_t *cm, snd_pcm_substream_t *subs, int do_ac3, int rate) { if (do_ac3) { /* AC3EN for 037 */ @@ -1178,7 +1172,7 @@ static void setup_ac3(struct cmipci *cm, struct snd_pcm_substream *subs, int do_ } } -static int setup_spdif_playback(struct cmipci *cm, struct snd_pcm_substream *subs, int up, int do_ac3) +static int setup_spdif_playback(cmipci_t *cm, snd_pcm_substream_t *subs, int up, int do_ac3) { int rate, err; @@ -1220,9 +1214,9 @@ static int setup_spdif_playback(struct cmipci *cm, struct snd_pcm_substream *sub */ /* playback - enable spdif only on the certain condition */ -static int snd_cmipci_playback_prepare(struct snd_pcm_substream *substream) +static int snd_cmipci_playback_prepare(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); int rate = substream->runtime->rate; int err, do_spdif, do_ac3 = 0; @@ -1237,9 +1231,9 @@ static int snd_cmipci_playback_prepare(struct snd_pcm_substream *substream) } /* playback (via device #2) - enable spdif always */ -static int snd_cmipci_playback_spdif_prepare(struct snd_pcm_substream *substream) +static int snd_cmipci_playback_spdif_prepare(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); int err, do_ac3; if (cm->can_ac3_hw) @@ -1251,25 +1245,25 @@ static int snd_cmipci_playback_spdif_prepare(struct snd_pcm_substream *substream return snd_cmipci_pcm_prepare(cm, &cm->channel[CM_CH_PLAY], substream); } -static int snd_cmipci_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_cmipci_playback_hw_free(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); setup_spdif_playback(cm, substream, 0, 0); restore_mixer_state(cm); return snd_cmipci_hw_free(substream); } /* capture */ -static int snd_cmipci_capture_prepare(struct snd_pcm_substream *substream) +static int snd_cmipci_capture_prepare(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); return snd_cmipci_pcm_prepare(cm, &cm->channel[CM_CH_CAPT], substream); } /* capture with spdif (via device #2) */ -static int snd_cmipci_capture_spdif_prepare(struct snd_pcm_substream *substream) +static int snd_cmipci_capture_spdif_prepare(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); spin_lock_irq(&cm->reg_lock); snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_CAPTURE_SPDF); @@ -1278,9 +1272,9 @@ static int snd_cmipci_capture_spdif_prepare(struct snd_pcm_substream *substream) return snd_cmipci_pcm_prepare(cm, &cm->channel[CM_CH_CAPT], substream); } -static int snd_cmipci_capture_spdif_hw_free(struct snd_pcm_substream *subs) +static int snd_cmipci_capture_spdif_hw_free(snd_pcm_substream_t *subs) { - struct cmipci *cm = snd_pcm_substream_chip(subs); + cmipci_t *cm = snd_pcm_substream_chip(subs); spin_lock_irq(&cm->reg_lock); snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_CAPTURE_SPDF); @@ -1295,7 +1289,7 @@ static int snd_cmipci_capture_spdif_hw_free(struct snd_pcm_substream *subs) */ static irqreturn_t snd_cmipci_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct cmipci *cm = dev_id; + cmipci_t *cm = dev_id; unsigned int status, mask = 0; /* fastpath out, to ease interrupt sharing */ @@ -1330,11 +1324,11 @@ static irqreturn_t snd_cmipci_interrupt(int irq, void *dev_id, struct pt_regs *r */ /* playback on channel A */ -static struct snd_pcm_hardware snd_cmipci_playback = +static snd_pcm_hardware_t snd_cmipci_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_48000, .rate_min = 5512, @@ -1350,11 +1344,11 @@ static struct snd_pcm_hardware snd_cmipci_playback = }; /* capture on channel B */ -static struct snd_pcm_hardware snd_cmipci_capture = +static snd_pcm_hardware_t snd_cmipci_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_48000, .rate_min = 5512, @@ -1370,11 +1364,11 @@ static struct snd_pcm_hardware snd_cmipci_capture = }; /* playback on channel B - stereo 16bit only? */ -static struct snd_pcm_hardware snd_cmipci_playback2 = +static snd_pcm_hardware_t snd_cmipci_playback2 = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_48000, .rate_min = 5512, @@ -1390,11 +1384,11 @@ static struct snd_pcm_hardware snd_cmipci_playback2 = }; /* spdif playback on channel A */ -static struct snd_pcm_hardware snd_cmipci_playback_spdif = +static snd_pcm_hardware_t snd_cmipci_playback_spdif = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .rate_min = 44100, @@ -1410,11 +1404,11 @@ static struct snd_pcm_hardware snd_cmipci_playback_spdif = }; /* spdif playback on channel A (32bit, IEC958 subframes) */ -static struct snd_pcm_hardware snd_cmipci_playback_iec958_subframe = +static snd_pcm_hardware_t snd_cmipci_playback_iec958_subframe = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE, .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .rate_min = 44100, @@ -1430,11 +1424,11 @@ static struct snd_pcm_hardware snd_cmipci_playback_iec958_subframe = }; /* spdif capture on channel B */ -static struct snd_pcm_hardware snd_cmipci_capture_spdif = +static snd_pcm_hardware_t snd_cmipci_capture_spdif = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .rate_min = 44100, @@ -1452,7 +1446,7 @@ static struct snd_pcm_hardware snd_cmipci_capture_spdif = /* * check device open/close */ -static int open_device_check(struct cmipci *cm, int mode, struct snd_pcm_substream *subs) +static int open_device_check(cmipci_t *cm, int mode, snd_pcm_substream_t *subs) { int ch = mode & CM_OPEN_CH_MASK; @@ -1479,7 +1473,7 @@ static int open_device_check(struct cmipci *cm, int mode, struct snd_pcm_substre return 0; } -static void close_device_check(struct cmipci *cm, int mode) +static void close_device_check(cmipci_t *cm, int mode) { int ch = mode & CM_OPEN_CH_MASK; @@ -1505,10 +1499,10 @@ static void close_device_check(struct cmipci *cm, int mode) /* */ -static int snd_cmipci_playback_open(struct snd_pcm_substream *substream) +static int snd_cmipci_playback_open(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cmipci_t *cm = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = open_device_check(cm, CM_OPEN_PLAYBACK, substream)) < 0) @@ -1520,10 +1514,10 @@ static int snd_cmipci_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cmipci_capture_open(struct snd_pcm_substream *substream) +static int snd_cmipci_capture_open(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cmipci_t *cm = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = open_device_check(cm, CM_OPEN_CAPTURE, substream)) < 0) @@ -1537,10 +1531,10 @@ static int snd_cmipci_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cmipci_playback2_open(struct snd_pcm_substream *substream) +static int snd_cmipci_playback2_open(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cmipci_t *cm = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = open_device_check(cm, CM_OPEN_PLAYBACK2, substream)) < 0) /* use channel B */ @@ -1563,10 +1557,10 @@ static int snd_cmipci_playback2_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cmipci_playback_spdif_open(struct snd_pcm_substream *substream) +static int snd_cmipci_playback_spdif_open(snd_pcm_substream_t *substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cmipci_t *cm = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = open_device_check(cm, CM_OPEN_SPDIF_PLAYBACK, substream)) < 0) /* use channel A */ @@ -1583,10 +1577,10 @@ static int snd_cmipci_playback_spdif_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cmipci_capture_spdif_open(struct snd_pcm_substream *substream) +static int snd_cmipci_capture_spdif_open(snd_pcm_substream_t * substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cmipci_t *cm = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = open_device_check(cm, CM_OPEN_SPDIF_CAPTURE, substream)) < 0) /* use channel B */ @@ -1600,38 +1594,38 @@ static int snd_cmipci_capture_spdif_open(struct snd_pcm_substream *substream) /* */ -static int snd_cmipci_playback_close(struct snd_pcm_substream *substream) +static int snd_cmipci_playback_close(snd_pcm_substream_t * substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); close_device_check(cm, CM_OPEN_PLAYBACK); return 0; } -static int snd_cmipci_capture_close(struct snd_pcm_substream *substream) +static int snd_cmipci_capture_close(snd_pcm_substream_t * substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); close_device_check(cm, CM_OPEN_CAPTURE); return 0; } -static int snd_cmipci_playback2_close(struct snd_pcm_substream *substream) +static int snd_cmipci_playback2_close(snd_pcm_substream_t * substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); close_device_check(cm, CM_OPEN_PLAYBACK2); close_device_check(cm, CM_OPEN_PLAYBACK_MULTI); return 0; } -static int snd_cmipci_playback_spdif_close(struct snd_pcm_substream *substream) +static int snd_cmipci_playback_spdif_close(snd_pcm_substream_t * substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); close_device_check(cm, CM_OPEN_SPDIF_PLAYBACK); return 0; } -static int snd_cmipci_capture_spdif_close(struct snd_pcm_substream *substream) +static int snd_cmipci_capture_spdif_close(snd_pcm_substream_t * substream) { - struct cmipci *cm = snd_pcm_substream_chip(substream); + cmipci_t *cm = snd_pcm_substream_chip(substream); close_device_check(cm, CM_OPEN_SPDIF_CAPTURE); return 0; } @@ -1640,7 +1634,7 @@ static int snd_cmipci_capture_spdif_close(struct snd_pcm_substream *substream) /* */ -static struct snd_pcm_ops snd_cmipci_playback_ops = { +static snd_pcm_ops_t snd_cmipci_playback_ops = { .open = snd_cmipci_playback_open, .close = snd_cmipci_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1651,7 +1645,7 @@ static struct snd_pcm_ops snd_cmipci_playback_ops = { .pointer = snd_cmipci_playback_pointer, }; -static struct snd_pcm_ops snd_cmipci_capture_ops = { +static snd_pcm_ops_t snd_cmipci_capture_ops = { .open = snd_cmipci_capture_open, .close = snd_cmipci_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1662,7 +1656,7 @@ static struct snd_pcm_ops snd_cmipci_capture_ops = { .pointer = snd_cmipci_capture_pointer, }; -static struct snd_pcm_ops snd_cmipci_playback2_ops = { +static snd_pcm_ops_t snd_cmipci_playback2_ops = { .open = snd_cmipci_playback2_open, .close = snd_cmipci_playback2_close, .ioctl = snd_pcm_lib_ioctl, @@ -1673,7 +1667,7 @@ static struct snd_pcm_ops snd_cmipci_playback2_ops = { .pointer = snd_cmipci_capture_pointer, /* channel B */ }; -static struct snd_pcm_ops snd_cmipci_playback_spdif_ops = { +static snd_pcm_ops_t snd_cmipci_playback_spdif_ops = { .open = snd_cmipci_playback_spdif_open, .close = snd_cmipci_playback_spdif_close, .ioctl = snd_pcm_lib_ioctl, @@ -1684,7 +1678,7 @@ static struct snd_pcm_ops snd_cmipci_playback_spdif_ops = { .pointer = snd_cmipci_playback_pointer, }; -static struct snd_pcm_ops snd_cmipci_capture_spdif_ops = { +static snd_pcm_ops_t snd_cmipci_capture_spdif_ops = { .open = snd_cmipci_capture_spdif_open, .close = snd_cmipci_capture_spdif_close, .ioctl = snd_pcm_lib_ioctl, @@ -1699,9 +1693,14 @@ static struct snd_pcm_ops snd_cmipci_capture_spdif_ops = { /* */ -static int __devinit snd_cmipci_pcm_new(struct cmipci *cm, int device) +static void snd_cmipci_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_cmipci_pcm_new(cmipci_t *cm, int device) +{ + snd_pcm_t *pcm; int err; err = snd_pcm_new(cm->card, cm->card->driver, device, 1, 1, &pcm); @@ -1712,6 +1711,7 @@ static int __devinit snd_cmipci_pcm_new(struct cmipci *cm, int device) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cmipci_capture_ops); pcm->private_data = cm; + pcm->private_free = snd_cmipci_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, "C-Media PCI DAC/ADC"); cm->pcm = pcm; @@ -1722,9 +1722,9 @@ static int __devinit snd_cmipci_pcm_new(struct cmipci *cm, int device) return 0; } -static int __devinit snd_cmipci_pcm2_new(struct cmipci *cm, int device) +static int __devinit snd_cmipci_pcm2_new(cmipci_t *cm, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; err = snd_pcm_new(cm->card, cm->card->driver, device, 1, 0, &pcm); @@ -1734,6 +1734,7 @@ static int __devinit snd_cmipci_pcm2_new(struct cmipci *cm, int device) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cmipci_playback2_ops); pcm->private_data = cm; + pcm->private_free = snd_cmipci_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, "C-Media PCI 2nd DAC"); cm->pcm2 = pcm; @@ -1744,9 +1745,9 @@ static int __devinit snd_cmipci_pcm2_new(struct cmipci *cm, int device) return 0; } -static int __devinit snd_cmipci_pcm_spdif_new(struct cmipci *cm, int device) +static int __devinit snd_cmipci_pcm_spdif_new(cmipci_t *cm, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; err = snd_pcm_new(cm->card, cm->card->driver, device, 1, 1, &pcm); @@ -1757,6 +1758,7 @@ static int __devinit snd_cmipci_pcm_spdif_new(struct cmipci *cm, int device) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cmipci_capture_spdif_ops); pcm->private_data = cm; + pcm->private_free = snd_cmipci_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, "C-Media PCI IEC958"); cm->pcm_spdif = pcm; @@ -1776,13 +1778,13 @@ static int __devinit snd_cmipci_pcm_spdif_new(struct cmipci *cm, int device) * - Output mute switches */ -static void snd_cmipci_mixer_write(struct cmipci *s, unsigned char idx, unsigned char data) +static void snd_cmipci_mixer_write(cmipci_t *s, unsigned char idx, unsigned char data) { outb(idx, s->iobase + CM_REG_SB16_ADDR); outb(data, s->iobase + CM_REG_SB16_DATA); } -static unsigned char snd_cmipci_mixer_read(struct cmipci *s, unsigned char idx) +static unsigned char snd_cmipci_mixer_read(cmipci_t *s, unsigned char idx) { unsigned char v; @@ -1794,13 +1796,13 @@ static unsigned char snd_cmipci_mixer_read(struct cmipci *s, unsigned char idx) /* * general mixer element */ -struct cmipci_sb_reg { +typedef struct cmipci_sb_reg { unsigned int left_reg, right_reg; unsigned int left_shift, right_shift; unsigned int mask; unsigned int invert: 1; unsigned int stereo: 1; -}; +} cmipci_sb_reg_t; #define COMPOSE_SB_REG(lreg,rreg,lshift,rshift,mask,invert,stereo) \ ((lreg) | ((rreg) << 8) | (lshift << 16) | (rshift << 19) | (mask << 24) | (invert << 22) | (stereo << 23)) @@ -1817,7 +1819,7 @@ struct cmipci_sb_reg { #define CMIPCI_SB_SW_STEREO(xname,lshift,rshift) CMIPCI_DOUBLE(xname, SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, lshift, rshift, 1, 0, 1) #define CMIPCI_SB_SW_MONO(xname,shift) CMIPCI_DOUBLE(xname, SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, shift, shift, 1, 0, 0) -static void cmipci_sb_reg_decode(struct cmipci_sb_reg *r, unsigned long val) +static void cmipci_sb_reg_decode(cmipci_sb_reg_t *r, unsigned long val) { r->left_reg = val & 0xff; r->right_reg = (val >> 8) & 0xff; @@ -1828,10 +1830,9 @@ static void cmipci_sb_reg_decode(struct cmipci_sb_reg *r, unsigned long val) r->mask = (val >> 24) & 0xff; } -static int snd_cmipci_info_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_info_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { - struct cmipci_sb_reg reg; + cmipci_sb_reg_t reg; cmipci_sb_reg_decode(®, kcontrol->private_value); uinfo->type = reg.mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; @@ -1841,11 +1842,10 @@ static int snd_cmipci_info_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_get_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_get_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); - struct cmipci_sb_reg reg; + cmipci_t *cm = snd_kcontrol_chip(kcontrol); + cmipci_sb_reg_t reg; int val; cmipci_sb_reg_decode(®, kcontrol->private_value); @@ -1864,11 +1864,10 @@ static int snd_cmipci_get_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_put_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_put_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); - struct cmipci_sb_reg reg; + cmipci_t *cm = snd_kcontrol_chip(kcontrol); + cmipci_sb_reg_t reg; int change; int left, right, oleft, oright; @@ -1913,8 +1912,7 @@ static int snd_cmipci_put_volume(struct snd_kcontrol *kcontrol, .private_value = COMPOSE_SB_REG(SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, left_shift, right_shift, 1, 0, 1), \ } -static int snd_cmipci_info_input_sw(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_info_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 4; @@ -1923,11 +1921,10 @@ static int snd_cmipci_info_input_sw(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_get_input_sw(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_get_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); - struct cmipci_sb_reg reg; + cmipci_t *cm = snd_kcontrol_chip(kcontrol); + cmipci_sb_reg_t reg; int val1, val2; cmipci_sb_reg_decode(®, kcontrol->private_value); @@ -1942,11 +1939,10 @@ static int snd_cmipci_get_input_sw(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_put_input_sw(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_put_input_sw(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); - struct cmipci_sb_reg reg; + cmipci_t *cm = snd_kcontrol_chip(kcontrol); + cmipci_sb_reg_t reg; int change; int val1, val2, oval1, oval2; @@ -1999,10 +1995,9 @@ static int snd_cmipci_put_input_sw(struct snd_kcontrol *kcontrol, .private_value = COMPOSE_SB_REG(reg, reg, shift, shift, mask, 0, 0), \ } -static int snd_cmipci_info_native_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_info_native_mixer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { - struct cmipci_sb_reg reg; + cmipci_sb_reg_t reg; cmipci_sb_reg_decode(®, kcontrol->private_value); uinfo->type = reg.mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; @@ -2013,11 +2008,10 @@ static int snd_cmipci_info_native_mixer(struct snd_kcontrol *kcontrol, } -static int snd_cmipci_get_native_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_get_native_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); - struct cmipci_sb_reg reg; + cmipci_t *cm = snd_kcontrol_chip(kcontrol); + cmipci_sb_reg_t reg; unsigned char oreg, val; cmipci_sb_reg_decode(®, kcontrol->private_value); @@ -2037,11 +2031,10 @@ static int snd_cmipci_get_native_mixer(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_put_native_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_put_native_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); - struct cmipci_sb_reg reg; + cmipci_t *cm = snd_kcontrol_chip(kcontrol); + cmipci_sb_reg_t reg; unsigned char oreg, nreg, val; cmipci_sb_reg_decode(®, kcontrol->private_value); @@ -2067,17 +2060,15 @@ static int snd_cmipci_put_native_mixer(struct snd_kcontrol *kcontrol, /* * special case - check mixer sensitivity */ -static int snd_cmipci_get_native_mixer_sensitive(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_get_native_mixer_sensitive(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - //struct cmipci *cm = snd_kcontrol_chip(kcontrol); + //cmipci_t *cm = snd_kcontrol_chip(kcontrol); return snd_cmipci_get_native_mixer(kcontrol, ucontrol); } -static int snd_cmipci_put_native_mixer_sensitive(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_put_native_mixer_sensitive(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); if (cm->mixer_insensitive) { /* ignored */ return 0; @@ -2086,7 +2077,7 @@ static int snd_cmipci_put_native_mixer_sensitive(struct snd_kcontrol *kcontrol, } -static struct snd_kcontrol_new snd_cmipci_mixers[] __devinitdata = { +static snd_kcontrol_new_t snd_cmipci_mixers[] __devinitdata = { CMIPCI_SB_VOL_STEREO("Master Playback Volume", SB_DSP4_MASTER_DEV, 3, 31), CMIPCI_MIXER_SW_MONO("3D Control - Switch", CM_REG_MIXER1, CM_X3DEN_SHIFT, 0), CMIPCI_SB_VOL_STEREO("PCM Playback Volume", SB_DSP4_PCM_DEV, 3, 31), @@ -2128,18 +2119,15 @@ static struct snd_kcontrol_new snd_cmipci_mixers[] __devinitdata = { * other switches */ -struct cmipci_switch_args { +typedef struct snd_cmipci_switch_args { int reg; /* register index */ unsigned int mask; /* mask bits */ unsigned int mask_on; /* mask bits to turn on */ unsigned int is_byte: 1; /* byte access? */ - unsigned int ac3_sensitive: 1; /* access forbidden during - * non-audio operation? - */ -}; + unsigned int ac3_sensitive: 1; /* access forbidden during non-audio operation? */ +} snd_cmipci_switch_args_t; -static int snd_cmipci_uswitch_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_uswitch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2148,12 +2136,10 @@ static int snd_cmipci_uswitch_info(struct snd_kcontrol *kcontrol, return 0; } -static int _snd_cmipci_uswitch_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol, - struct cmipci_switch_args *args) +static int _snd_cmipci_uswitch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol, snd_cmipci_switch_args_t *args) { unsigned int val; - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&cm->reg_lock); if (args->ac3_sensitive && cm->mixer_insensitive) { @@ -2170,22 +2156,18 @@ static int _snd_cmipci_uswitch_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_uswitch_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_uswitch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct cmipci_switch_args *args; - args = (struct cmipci_switch_args *)kcontrol->private_value; + snd_cmipci_switch_args_t *args = (snd_cmipci_switch_args_t*)kcontrol->private_value; snd_assert(args != NULL, return -EINVAL); return _snd_cmipci_uswitch_get(kcontrol, ucontrol, args); } -static int _snd_cmipci_uswitch_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol, - struct cmipci_switch_args *args) +static int _snd_cmipci_uswitch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol, snd_cmipci_switch_args_t *args) { unsigned int val; int change; - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&cm->reg_lock); if (args->ac3_sensitive && cm->mixer_insensitive) { @@ -2213,17 +2195,15 @@ static int _snd_cmipci_uswitch_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_cmipci_uswitch_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_uswitch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct cmipci_switch_args *args; - args = (struct cmipci_switch_args *)kcontrol->private_value; + snd_cmipci_switch_args_t *args = (snd_cmipci_switch_args_t*)kcontrol->private_value; snd_assert(args != NULL, return -EINVAL); return _snd_cmipci_uswitch_put(kcontrol, ucontrol, args); } #define DEFINE_SWITCH_ARG(sname, xreg, xmask, xmask_on, xis_byte, xac3) \ -static struct cmipci_switch_args cmipci_switch_arg_##sname = { \ +static snd_cmipci_switch_args_t cmipci_switch_arg_##sname = { \ .reg = xreg, \ .mask = xmask, \ .mask_on = xmask_on, \ @@ -2280,8 +2260,7 @@ DEFINE_SWITCH_ARG(modem, CM_REG_MISC_CTRL, CM_FLINKON|CM_FLINKOFF, CM_FLINKON, 0 * callbacks for spdif output switch * needs toggle two registers.. */ -static int snd_cmipci_spdout_enable_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_spdout_enable_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int changed; changed = _snd_cmipci_uswitch_get(kcontrol, ucontrol, &cmipci_switch_arg_spdif_enable); @@ -2289,10 +2268,9 @@ static int snd_cmipci_spdout_enable_get(struct snd_kcontrol *kcontrol, return changed; } -static int snd_cmipci_spdout_enable_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_spdout_enable_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct cmipci *chip = snd_kcontrol_chip(kcontrol); + cmipci_t *chip = snd_kcontrol_chip(kcontrol); int changed; changed = _snd_cmipci_uswitch_put(kcontrol, ucontrol, &cmipci_switch_arg_spdif_enable); changed |= _snd_cmipci_uswitch_put(kcontrol, ucontrol, &cmipci_switch_arg_spdo2dac); @@ -2310,10 +2288,10 @@ static int snd_cmipci_spdout_enable_put(struct snd_kcontrol *kcontrol, } -static int snd_cmipci_line_in_mode_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_line_in_mode_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); static char *texts[3] = { "Line-In", "Rear Output", "Bass Output" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -2324,7 +2302,7 @@ static int snd_cmipci_line_in_mode_info(struct snd_kcontrol *kcontrol, return 0; } -static inline unsigned int get_line_in_mode(struct cmipci *cm) +static inline unsigned int get_line_in_mode(cmipci_t *cm) { unsigned int val; if (cm->chip_version >= 39) { @@ -2338,10 +2316,10 @@ static inline unsigned int get_line_in_mode(struct cmipci *cm) return 0; } -static int snd_cmipci_line_in_mode_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_line_in_mode_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&cm->reg_lock); ucontrol->value.enumerated.item[0] = get_line_in_mode(cm); @@ -2349,10 +2327,10 @@ static int snd_cmipci_line_in_mode_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_line_in_mode_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_line_in_mode_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); int change; spin_lock_irq(&cm->reg_lock); @@ -2368,8 +2346,8 @@ static int snd_cmipci_line_in_mode_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_cmipci_mic_in_mode_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cmipci_mic_in_mode_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { static char *texts[2] = { "Mic-In", "Center/LFE Output" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -2381,10 +2359,10 @@ static int snd_cmipci_mic_in_mode_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_mic_in_mode_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_mic_in_mode_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); /* same bit as spdi_phase */ spin_lock_irq(&cm->reg_lock); ucontrol->value.enumerated.item[0] = @@ -2393,10 +2371,10 @@ static int snd_cmipci_mic_in_mode_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cmipci_mic_in_mode_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cmipci_mic_in_mode_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct cmipci *cm = snd_kcontrol_chip(kcontrol); + cmipci_t *cm = snd_kcontrol_chip(kcontrol); int change; spin_lock_irq(&cm->reg_lock); @@ -2409,7 +2387,7 @@ static int snd_cmipci_mic_in_mode_put(struct snd_kcontrol *kcontrol, } /* both for CM8338/8738 */ -static struct snd_kcontrol_new snd_cmipci_mixer_switches[] __devinitdata = { +static snd_kcontrol_new_t snd_cmipci_mixer_switches[] __devinitdata = { DEFINE_MIXER_SWITCH("Four Channel Mode", fourch), { .name = "Line-In Mode", @@ -2421,11 +2399,11 @@ static struct snd_kcontrol_new snd_cmipci_mixer_switches[] __devinitdata = { }; /* for non-multichannel chips */ -static struct snd_kcontrol_new snd_cmipci_nomulti_switch __devinitdata = +static snd_kcontrol_new_t snd_cmipci_nomulti_switch __devinitdata = DEFINE_MIXER_SWITCH("Exchange DAC", exchange_dac); /* only for CM8738 */ -static struct snd_kcontrol_new snd_cmipci_8738_mixer_switches[] __devinitdata = { +static snd_kcontrol_new_t snd_cmipci_8738_mixer_switches[] __devinitdata = { #if 0 /* controlled in pcm device */ DEFINE_MIXER_SWITCH("IEC958 In Record", spdif_in), DEFINE_MIXER_SWITCH("IEC958 Out", spdif_out), @@ -2447,14 +2425,14 @@ static struct snd_kcontrol_new snd_cmipci_8738_mixer_switches[] __devinitdata = }; /* only for model 033/037 */ -static struct snd_kcontrol_new snd_cmipci_old_mixer_switches[] __devinitdata = { +static snd_kcontrol_new_t snd_cmipci_old_mixer_switches[] __devinitdata = { DEFINE_MIXER_SWITCH("IEC958 Mix Analog", spdif_dac_out), DEFINE_MIXER_SWITCH("IEC958 In Phase Inverse", spdi_phase), DEFINE_MIXER_SWITCH("IEC958 In Select", spdif_in_sel1), }; /* only for model 039 or later */ -static struct snd_kcontrol_new snd_cmipci_extra_mixer_switches[] __devinitdata = { +static snd_kcontrol_new_t snd_cmipci_extra_mixer_switches[] __devinitdata = { DEFINE_MIXER_SWITCH("IEC958 In Select", spdif_in_sel2), DEFINE_MIXER_SWITCH("IEC958 In Phase Inverse", spdi_phase2), { @@ -2467,17 +2445,17 @@ static struct snd_kcontrol_new snd_cmipci_extra_mixer_switches[] __devinitdata = }; /* card control switches */ -static struct snd_kcontrol_new snd_cmipci_control_switches[] __devinitdata = { +static snd_kcontrol_new_t snd_cmipci_control_switches[] __devinitdata = { // DEFINE_CARD_SWITCH("Joystick", joystick), /* now module option */ DEFINE_CARD_SWITCH("Modem", modem), }; -static int __devinit snd_cmipci_mixer_new(struct cmipci *cm, int pcm_spdif_device) +static int __devinit snd_cmipci_mixer_new(cmipci_t *cm, int pcm_spdif_device) { - struct snd_card *card; - struct snd_kcontrol_new *sw; - struct snd_kcontrol *kctl; + snd_card_t *card; + snd_kcontrol_new_t *sw; + snd_kcontrol_t *kctl; unsigned int idx; int err; @@ -2559,8 +2537,8 @@ static int __devinit snd_cmipci_mixer_new(struct cmipci *cm, int pcm_spdif_devic } for (idx = 0; idx < CM_SAVED_MIXERS; idx++) { - struct snd_ctl_elem_id id; - struct snd_kcontrol *ctl; + snd_ctl_elem_id_t id; + snd_kcontrol_t *ctl; memset(&id, 0, sizeof(id)); id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; strcpy(id.name, cm_saved_mixer[idx].name); @@ -2577,10 +2555,10 @@ static int __devinit snd_cmipci_mixer_new(struct cmipci *cm, int pcm_spdif_devic */ #ifdef CONFIG_PROC_FS -static void snd_cmipci_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_cmipci_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t *buffer) { - struct cmipci *cm = entry->private_data; + cmipci_t *cm = entry->private_data; int i; snd_iprintf(buffer, "%s\n\n", cm->card->longname); @@ -2596,15 +2574,15 @@ static void snd_cmipci_proc_read(struct snd_info_entry *entry, } } -static void __devinit snd_cmipci_proc_init(struct cmipci *cm) +static void __devinit snd_cmipci_proc_init(cmipci_t *cm) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(cm->card, "cmipci", &entry)) snd_info_set_text_ops(entry, cm, 1024, snd_cmipci_proc_read); } #else /* !CONFIG_PROC_FS */ -static inline void snd_cmipci_proc_init(struct cmipci *cm) {} +static inline void snd_cmipci_proc_init(cmipci_t *cm) {} #endif @@ -2622,7 +2600,7 @@ static struct pci_device_id snd_cmipci_ids[] = { * check chip version and capabilities * driver name is modified according to the chip model */ -static void __devinit query_chip(struct cmipci *cm) +static void __devinit query_chip(cmipci_t *cm) { unsigned int detect; @@ -2675,7 +2653,7 @@ static void __devinit query_chip(struct cmipci *cm) } #ifdef SUPPORT_JOYSTICK -static int __devinit snd_cmipci_create_gameport(struct cmipci *cm, int dev) +static int __devinit snd_cmipci_create_gameport(cmipci_t *cm, int dev) { static int ports[] = { 0x201, 0x200, 0 }; /* FIXME: majority is 0x201? */ struct gameport *gp; @@ -2721,7 +2699,7 @@ static int __devinit snd_cmipci_create_gameport(struct cmipci *cm, int dev) return 0; } -static void snd_cmipci_free_gameport(struct cmipci *cm) +static void snd_cmipci_free_gameport(cmipci_t *cm) { if (cm->gameport) { struct resource *r = gameport_get_port_data(cm->gameport); @@ -2734,11 +2712,11 @@ static void snd_cmipci_free_gameport(struct cmipci *cm) } } #else -static inline int snd_cmipci_create_gameport(struct cmipci *cm, int dev) { return -ENOSYS; } -static inline void snd_cmipci_free_gameport(struct cmipci *cm) { } +static inline int snd_cmipci_create_gameport(cmipci_t *cm, int dev) { return -ENOSYS; } +static inline void snd_cmipci_free_gameport(cmipci_t *cm) { } #endif -static int snd_cmipci_free(struct cmipci *cm) +static int snd_cmipci_free(cmipci_t *cm) { if (cm->irq >= 0) { snd_cmipci_clear_bit(cm, CM_REG_MISC_CTRL, CM_FM_EN); @@ -2754,7 +2732,7 @@ static int snd_cmipci_free(struct cmipci *cm) synchronize_irq(cm->irq); - free_irq(cm->irq, cm); + free_irq(cm->irq, (void *)cm); } snd_cmipci_free_gameport(cm); @@ -2764,17 +2742,17 @@ static int snd_cmipci_free(struct cmipci *cm) return 0; } -static int snd_cmipci_dev_free(struct snd_device *device) +static int snd_cmipci_dev_free(snd_device_t *device) { - struct cmipci *cm = device->device_data; + cmipci_t *cm = device->device_data; return snd_cmipci_free(cm); } -static int __devinit snd_cmipci_create_fm(struct cmipci *cm, long fm_port) +static int __devinit snd_cmipci_create_fm(cmipci_t *cm, long fm_port) { long iosynth; unsigned int val; - struct snd_opl3 *opl3; + opl3_t *opl3; int err; /* first try FM regs in PCI port range */ @@ -2815,12 +2793,12 @@ static int __devinit snd_cmipci_create_fm(struct cmipci *cm, long fm_port) return 0; } -static int __devinit snd_cmipci_create(struct snd_card *card, struct pci_dev *pci, - int dev, struct cmipci **rcmipci) +static int __devinit snd_cmipci_create(snd_card_t *card, struct pci_dev *pci, + int dev, cmipci_t **rcmipci) { - struct cmipci *cm; + cmipci_t *cm; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_cmipci_dev_free, }; unsigned int val = 0; @@ -2860,8 +2838,7 @@ static int __devinit snd_cmipci_create(struct snd_card *card, struct pci_dev *pc } cm->iobase = pci_resource_start(pci, 0); - if (request_irq(pci->irq, snd_cmipci_interrupt, - SA_INTERRUPT|SA_SHIRQ, card->driver, cm)) { + if (request_irq(pci->irq, snd_cmipci_interrupt, SA_INTERRUPT|SA_SHIRQ, card->driver, (void *)cm)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_cmipci_free(cm); return -EBUSY; @@ -3014,8 +2991,8 @@ static int __devinit snd_cmipci_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct cmipci *cm; + snd_card_t *card; + cmipci_t *cm; int err; if (dev >= SNDRV_CARDS) @@ -3047,7 +3024,6 @@ static int __devinit snd_cmipci_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = cm; sprintf(card->shortname, "C-Media PCI %s", card->driver); sprintf(card->longname, "%s (model %d) at 0x%lx, irq %i", @@ -3075,93 +3051,11 @@ static void __devexit snd_cmipci_remove(struct pci_dev *pci) } -#ifdef CONFIG_PM -/* - * power management - */ -static unsigned char saved_regs[] = { - CM_REG_FUNCTRL1, CM_REG_CHFORMAT, CM_REG_LEGACY_CTRL, CM_REG_MISC_CTRL, - CM_REG_MIXER0, CM_REG_MIXER1, CM_REG_MIXER2, CM_REG_MIXER3, CM_REG_PLL, - CM_REG_CH0_FRAME1, CM_REG_CH0_FRAME2, - CM_REG_CH1_FRAME1, CM_REG_CH1_FRAME2, CM_REG_EXT_MISC, - CM_REG_INT_STATUS, CM_REG_INT_HLDCLR, CM_REG_FUNCTRL0, -}; - -static unsigned char saved_mixers[] = { - SB_DSP4_MASTER_DEV, SB_DSP4_MASTER_DEV + 1, - SB_DSP4_PCM_DEV, SB_DSP4_PCM_DEV + 1, - SB_DSP4_SYNTH_DEV, SB_DSP4_SYNTH_DEV + 1, - SB_DSP4_CD_DEV, SB_DSP4_CD_DEV + 1, - SB_DSP4_LINE_DEV, SB_DSP4_LINE_DEV + 1, - SB_DSP4_MIC_DEV, SB_DSP4_SPEAKER_DEV, - CM_REG_EXTENT_IND, SB_DSP4_OUTPUT_SW, - SB_DSP4_INPUT_LEFT, SB_DSP4_INPUT_RIGHT, -}; - -static int snd_cmipci_suspend(struct pci_dev *pci, pm_message_t state) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct cmipci *cm = card->private_data; - int i; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - - snd_pcm_suspend_all(cm->pcm); - snd_pcm_suspend_all(cm->pcm2); - snd_pcm_suspend_all(cm->pcm_spdif); - - /* save registers */ - for (i = 0; i < ARRAY_SIZE(saved_regs); i++) - cm->saved_regs[i] = snd_cmipci_read(cm, saved_regs[i]); - for (i = 0; i < ARRAY_SIZE(saved_mixers); i++) - cm->saved_mixers[i] = snd_cmipci_mixer_read(cm, saved_mixers[i]); - - /* disable ints */ - snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0); - - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); - return 0; -} - -static int snd_cmipci_resume(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct cmipci *cm = card->private_data; - int i; - - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); - - /* reset / initialize to a sane state */ - snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0); - snd_cmipci_ch_reset(cm, CM_CH_PLAY); - snd_cmipci_ch_reset(cm, CM_CH_CAPT); - snd_cmipci_mixer_write(cm, 0, 0); - - /* restore registers */ - for (i = 0; i < ARRAY_SIZE(saved_regs); i++) - snd_cmipci_write(cm, saved_regs[i], cm->saved_regs[i]); - for (i = 0; i < ARRAY_SIZE(saved_mixers); i++) - snd_cmipci_mixer_write(cm, saved_mixers[i], cm->saved_mixers[i]); - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif /* CONFIG_PM */ - static struct pci_driver driver = { .name = "C-Media PCI", .id_table = snd_cmipci_ids, .probe = snd_cmipci_probe, .remove = __devexit_p(snd_cmipci_remove), -#ifdef CONFIG_PM - .suspend = snd_cmipci_suspend, - .resume = snd_cmipci_resume, -#endif }; static int __init alsa_card_cmipci_init(void) diff --git a/trunk/sound/pci/cs4281.c b/trunk/sound/pci/cs4281.c index 4f65ec56bf35..034ff3755a3b 100644 --- a/trunk/sound/pci/cs4281.c +++ b/trunk/sound/pci/cs4281.c @@ -427,8 +427,11 @@ MODULE_PARM_DESC(dual_codec, "Secondary Codec ID (0 = disabled)."); * */ -struct cs4281_dma { - struct snd_pcm_substream *substream; +typedef struct snd_cs4281 cs4281_t; +typedef struct snd_cs4281_dma cs4281_dma_t; + +struct snd_cs4281_dma { + snd_pcm_substream_t *substream; unsigned int regDBA; /* offset to DBA register */ unsigned int regDCA; /* offset to DCA register */ unsigned int regDBC; /* offset to DBC register */ @@ -449,7 +452,7 @@ struct cs4281_dma { #define SUSPEND_REGISTERS 20 -struct cs4281 { +struct snd_cs4281 { int irq; void __iomem *ba0; /* virtual (accessible) address */ @@ -459,18 +462,18 @@ struct cs4281 { int dual_codec; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; - struct snd_ac97 *ac97_secondary; + ac97_bus_t *ac97_bus; + ac97_t *ac97; + ac97_t *ac97_secondary; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *midi_input; - struct snd_rawmidi_substream *midi_output; + snd_card_t *card; + snd_pcm_t *pcm; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *midi_input; + snd_rawmidi_substream_t *midi_output; - struct cs4281_dma dma[4]; + cs4281_dma_t dma[4]; unsigned char src_left_play_slot; unsigned char src_right_play_slot; @@ -511,18 +514,38 @@ MODULE_DEVICE_TABLE(pci, snd_cs4281_ids); * common I/O routines */ -static inline void snd_cs4281_pokeBA0(struct cs4281 *chip, unsigned long offset, - unsigned int val) +static void snd_cs4281_delay(unsigned int delay) +{ + if (delay > 999) { + unsigned long end_time; + delay = (delay * HZ) / 1000000; + if (delay < 1) + delay = 1; + end_time = jiffies + delay; + do { + schedule_timeout_uninterruptible(1); + } while (time_after_eq(end_time, jiffies)); + } else { + udelay(delay); + } +} + +static inline void snd_cs4281_delay_long(void) +{ + schedule_timeout_uninterruptible(1); +} + +static inline void snd_cs4281_pokeBA0(cs4281_t *chip, unsigned long offset, unsigned int val) { writel(val, chip->ba0 + offset); } -static inline unsigned int snd_cs4281_peekBA0(struct cs4281 *chip, unsigned long offset) +static inline unsigned int snd_cs4281_peekBA0(cs4281_t *chip, unsigned long offset) { return readl(chip->ba0 + offset); } -static void snd_cs4281_ac97_write(struct snd_ac97 *ac97, +static void snd_cs4281_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { /* @@ -532,7 +555,7 @@ static void snd_cs4281_ac97_write(struct snd_ac97 *ac97, * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h * 5. if DCV not cleared, break and return error */ - struct cs4281 *chip = ac97->private_data; + cs4281_t *chip = ac97->private_data; int count; /* @@ -567,15 +590,15 @@ static void snd_cs4281_ac97_write(struct snd_ac97 *ac97, snd_printk(KERN_ERR "AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val); } -static unsigned short snd_cs4281_ac97_read(struct snd_ac97 *ac97, +static unsigned short snd_cs4281_ac97_read(ac97_t *ac97, unsigned short reg) { - struct cs4281 *chip = ac97->private_data; + cs4281_t *chip = ac97->private_data; int count; unsigned short result; // FIXME: volatile is necessary in the following due to a bug of // some gcc versions - volatile int ac97_num = ((volatile struct snd_ac97 *)ac97)->num; + volatile int ac97_num = ((volatile ac97_t *)ac97)->num; /* * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address @@ -662,10 +685,10 @@ static unsigned short snd_cs4281_ac97_read(struct snd_ac97 *ac97, * PCM part */ -static int snd_cs4281_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_cs4281_trigger(snd_pcm_substream_t *substream, int cmd) { - struct cs4281_dma *dma = substream->runtime->private_data; - struct cs4281 *chip = snd_pcm_substream_chip(substream); + cs4281_dma_t *dma = (cs4281_dma_t *)substream->runtime->private_data; + cs4281_t *chip = snd_pcm_substream_chip(substream); spin_lock(&chip->reg_lock); switch (cmd) { @@ -728,9 +751,7 @@ static unsigned int snd_cs4281_rate(unsigned int rate, unsigned int *real_rate) return val; } -static void snd_cs4281_mode(struct cs4281 *chip, struct cs4281_dma *dma, - struct snd_pcm_runtime *runtime, - int capture, int src) +static void snd_cs4281_mode(cs4281_t *chip, cs4281_dma_t *dma, snd_pcm_runtime_t *runtime, int capture, int src) { int rec_mono; @@ -793,22 +814,22 @@ static void snd_cs4281_mode(struct cs4281 *chip, struct cs4281_dma *dma, snd_cs4281_pokeBA0(chip, dma->regFSIC, 0); } -static int snd_cs4281_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cs4281_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_cs4281_hw_free(struct snd_pcm_substream *substream) +static int snd_cs4281_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_cs4281_playback_prepare(struct snd_pcm_substream *substream) +static int snd_cs4281_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct cs4281_dma *dma = runtime->private_data; - struct cs4281 *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs4281_dma_t *dma = (cs4281_dma_t *)runtime->private_data; + cs4281_t *chip = snd_pcm_substream_chip(substream); spin_lock_irq(&chip->reg_lock); snd_cs4281_mode(chip, dma, runtime, 0, 1); @@ -816,11 +837,11 @@ static int snd_cs4281_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_cs4281_capture_prepare(struct snd_pcm_substream *substream) +static int snd_cs4281_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct cs4281_dma *dma = runtime->private_data; - struct cs4281 *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs4281_dma_t *dma = (cs4281_dma_t *)runtime->private_data; + cs4281_t *chip = snd_pcm_substream_chip(substream); spin_lock_irq(&chip->reg_lock); snd_cs4281_mode(chip, dma, runtime, 1, 1); @@ -828,18 +849,18 @@ static int snd_cs4281_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_cs4281_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs4281_pointer(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct cs4281_dma *dma = runtime->private_data; - struct cs4281 *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs4281_dma_t *dma = (cs4281_dma_t *)runtime->private_data; + cs4281_t *chip = snd_pcm_substream_chip(substream); // printk("DCC = 0x%x, buffer_size = 0x%x, jiffies = %li\n", snd_cs4281_peekBA0(chip, dma->regDCC), runtime->buffer_size, jiffies); return runtime->buffer_size - snd_cs4281_peekBA0(chip, dma->regDCC) - 1; } -static struct snd_pcm_hardware snd_cs4281_playback = +static snd_pcm_hardware_t snd_cs4281_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | @@ -865,7 +886,7 @@ static struct snd_pcm_hardware snd_cs4281_playback = .fifo_size = CS4281_FIFO_SIZE, }; -static struct snd_pcm_hardware snd_cs4281_capture = +static snd_pcm_hardware_t snd_cs4281_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | @@ -891,11 +912,11 @@ static struct snd_pcm_hardware snd_cs4281_capture = .fifo_size = CS4281_FIFO_SIZE, }; -static int snd_cs4281_playback_open(struct snd_pcm_substream *substream) +static int snd_cs4281_playback_open(snd_pcm_substream_t * substream) { - struct cs4281 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct cs4281_dma *dma; + cs4281_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs4281_dma_t *dma; dma = &chip->dma[0]; dma->substream = substream; @@ -911,11 +932,11 @@ static int snd_cs4281_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cs4281_capture_open(struct snd_pcm_substream *substream) +static int snd_cs4281_capture_open(snd_pcm_substream_t * substream) { - struct cs4281 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct cs4281_dma *dma; + cs4281_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs4281_dma_t *dma; dma = &chip->dma[1]; dma->substream = substream; @@ -931,23 +952,23 @@ static int snd_cs4281_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cs4281_playback_close(struct snd_pcm_substream *substream) +static int snd_cs4281_playback_close(snd_pcm_substream_t * substream) { - struct cs4281_dma *dma = substream->runtime->private_data; + cs4281_dma_t *dma = (cs4281_dma_t *)substream->runtime->private_data; dma->substream = NULL; return 0; } -static int snd_cs4281_capture_close(struct snd_pcm_substream *substream) +static int snd_cs4281_capture_close(snd_pcm_substream_t * substream) { - struct cs4281_dma *dma = substream->runtime->private_data; + cs4281_dma_t *dma = (cs4281_dma_t *)substream->runtime->private_data; dma->substream = NULL; return 0; } -static struct snd_pcm_ops snd_cs4281_playback_ops = { +static snd_pcm_ops_t snd_cs4281_playback_ops = { .open = snd_cs4281_playback_open, .close = snd_cs4281_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -958,7 +979,7 @@ static struct snd_pcm_ops snd_cs4281_playback_ops = { .pointer = snd_cs4281_pointer, }; -static struct snd_pcm_ops snd_cs4281_capture_ops = { +static snd_pcm_ops_t snd_cs4281_capture_ops = { .open = snd_cs4281_capture_open, .close = snd_cs4281_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -969,10 +990,16 @@ static struct snd_pcm_ops snd_cs4281_capture_ops = { .pointer = snd_cs4281_pointer, }; -static int __devinit snd_cs4281_pcm(struct cs4281 * chip, int device, - struct snd_pcm ** rpcm) +static void snd_cs4281_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + cs4281_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_cs4281_pcm(cs4281_t * chip, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -985,6 +1012,7 @@ static int __devinit snd_cs4281_pcm(struct cs4281 * chip, int device, snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cs4281_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_cs4281_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, "CS4281"); chip->pcm = pcm; @@ -1003,8 +1031,7 @@ static int __devinit snd_cs4281_pcm(struct cs4281 * chip, int device, #define CS_VOL_MASK 0x1f -static int snd_cs4281_info_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs4281_info_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1013,10 +1040,9 @@ static int snd_cs4281_info_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4281_get_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4281_get_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cs4281 *chip = snd_kcontrol_chip(kcontrol); + cs4281_t *chip = snd_kcontrol_chip(kcontrol); int regL = (kcontrol->private_value >> 16) & 0xffff; int regR = kcontrol->private_value & 0xffff; int volL, volR; @@ -1029,10 +1055,9 @@ static int snd_cs4281_get_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4281_put_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4281_put_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct cs4281 *chip = snd_kcontrol_chip(kcontrol); + cs4281_t *chip = snd_kcontrol_chip(kcontrol); int change = 0; int regL = (kcontrol->private_value >> 16) & 0xffff; int regR = kcontrol->private_value & 0xffff; @@ -1054,7 +1079,7 @@ static int snd_cs4281_put_volume(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_cs4281_fm_vol = +static snd_kcontrol_new_t snd_cs4281_fm_vol = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Synth Playback Volume", @@ -1064,7 +1089,7 @@ static struct snd_kcontrol_new snd_cs4281_fm_vol = .private_value = ((BA0_FMLVC << 16) | BA0_FMRVC), }; -static struct snd_kcontrol_new snd_cs4281_pcm_vol = +static snd_kcontrol_new_t snd_cs4281_pcm_vol = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Stream Playback Volume", @@ -1074,27 +1099,27 @@ static struct snd_kcontrol_new snd_cs4281_pcm_vol = .private_value = ((BA0_PPLVC << 16) | BA0_PPRVC), }; -static void snd_cs4281_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_cs4281_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct cs4281 *chip = bus->private_data; + cs4281_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_cs4281_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_cs4281_mixer_free_ac97(ac97_t *ac97) { - struct cs4281 *chip = ac97->private_data; + cs4281_t *chip = ac97->private_data; if (ac97->num) chip->ac97_secondary = NULL; else chip->ac97 = NULL; } -static int __devinit snd_cs4281_mixer(struct cs4281 * chip) +static int __devinit snd_cs4281_mixer(cs4281_t * chip) { - struct snd_card *card = chip->card; - struct snd_ac97_template ac97; + snd_card_t *card = chip->card; + ac97_template_t ac97; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_cs4281_ac97_write, .read = snd_cs4281_ac97_read, }; @@ -1125,23 +1150,22 @@ static int __devinit snd_cs4281_mixer(struct cs4281 * chip) * proc interface */ -static void snd_cs4281_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_cs4281_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct cs4281 *chip = entry->private_data; + cs4281_t *chip = entry->private_data; snd_iprintf(buffer, "Cirrus Logic CS4281\n\n"); snd_iprintf(buffer, "Spurious half IRQs : %u\n", chip->spurious_dhtc_irq); snd_iprintf(buffer, "Spurious end IRQs : %u\n", chip->spurious_dtc_irq); } -static long snd_cs4281_BA0_read(struct snd_info_entry *entry, - void *file_private_data, +static long snd_cs4281_BA0_read(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *buf, unsigned long count, unsigned long pos) { long size; - struct cs4281 *chip = entry->private_data; + cs4281_t *chip = entry->private_data; size = count; if (pos + size > CS4281_BA0_SIZE) @@ -1153,13 +1177,12 @@ static long snd_cs4281_BA0_read(struct snd_info_entry *entry, return size; } -static long snd_cs4281_BA1_read(struct snd_info_entry *entry, - void *file_private_data, +static long snd_cs4281_BA1_read(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *buf, unsigned long count, unsigned long pos) { long size; - struct cs4281 *chip = entry->private_data; + cs4281_t *chip = entry->private_data; size = count; if (pos + size > CS4281_BA1_SIZE) @@ -1179,9 +1202,9 @@ static struct snd_info_entry_ops snd_cs4281_proc_ops_BA1 = { .read = snd_cs4281_BA1_read, }; -static void __devinit snd_cs4281_proc_init(struct cs4281 * chip) +static void __devinit snd_cs4281_proc_init(cs4281_t * chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "cs4281", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_cs4281_proc_read); @@ -1207,7 +1230,7 @@ static void __devinit snd_cs4281_proc_init(struct cs4281 * chip) static void snd_cs4281_gameport_trigger(struct gameport *gameport) { - struct cs4281 *chip = gameport_get_port_data(gameport); + cs4281_t *chip = gameport_get_port_data(gameport); snd_assert(chip, return); snd_cs4281_pokeBA0(chip, BA0_JSPT, 0xff); @@ -1215,17 +1238,16 @@ static void snd_cs4281_gameport_trigger(struct gameport *gameport) static unsigned char snd_cs4281_gameport_read(struct gameport *gameport) { - struct cs4281 *chip = gameport_get_port_data(gameport); + cs4281_t *chip = gameport_get_port_data(gameport); snd_assert(chip, return 0); return snd_cs4281_peekBA0(chip, BA0_JSPT); } #ifdef COOKED_MODE -static int snd_cs4281_gameport_cooked_read(struct gameport *gameport, - int *axes, int *buttons) +static int snd_cs4281_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons) { - struct cs4281 *chip = gameport_get_port_data(gameport); + cs4281_t *chip = gameport_get_port_data(gameport); unsigned js1, js2, jst; snd_assert(chip, return 0); @@ -1264,7 +1286,7 @@ static int snd_cs4281_gameport_open(struct gameport *gameport, int mode) return 0; } -static int __devinit snd_cs4281_create_gameport(struct cs4281 *chip) +static int __devinit snd_cs4281_create_gameport(cs4281_t *chip) { struct gameport *gp; @@ -1291,7 +1313,7 @@ static int __devinit snd_cs4281_create_gameport(struct cs4281 *chip) return 0; } -static void snd_cs4281_free_gameport(struct cs4281 *chip) +static void snd_cs4281_free_gameport(cs4281_t *chip) { if (chip->gameport) { gameport_unregister_port(chip->gameport); @@ -1299,11 +1321,11 @@ static void snd_cs4281_free_gameport(struct cs4281 *chip) } } #else -static inline int snd_cs4281_create_gameport(struct cs4281 *chip) { return -ENOSYS; } -static inline void snd_cs4281_free_gameport(struct cs4281 *chip) { } +static inline int snd_cs4281_create_gameport(cs4281_t *chip) { return -ENOSYS; } +static inline void snd_cs4281_free_gameport(cs4281_t *chip) { } #endif /* CONFIG_GAMEPORT || (MODULE && CONFIG_GAMEPORT_MODULE) */ -static int snd_cs4281_free(struct cs4281 *chip) +static int snd_cs4281_free(cs4281_t *chip) { snd_cs4281_free_gameport(chip); @@ -1320,7 +1342,7 @@ static int snd_cs4281_free(struct cs4281 *chip) pci_set_power_state(chip->pci, 3); if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); if (chip->ba0) iounmap(chip->ba0); if (chip->ba1) @@ -1332,23 +1354,27 @@ static int snd_cs4281_free(struct cs4281 *chip) return 0; } -static int snd_cs4281_dev_free(struct snd_device *device) +static int snd_cs4281_dev_free(snd_device_t *device) { - struct cs4281 *chip = device->device_data; + cs4281_t *chip = device->device_data; return snd_cs4281_free(chip); } -static int snd_cs4281_chip_init(struct cs4281 *chip); /* defined below */ +static int snd_cs4281_chip_init(cs4281_t *chip); /* defined below */ +#ifdef CONFIG_PM +static int cs4281_suspend(snd_card_t *card, pm_message_t state); +static int cs4281_resume(snd_card_t *card); +#endif -static int __devinit snd_cs4281_create(struct snd_card *card, +static int __devinit snd_cs4281_create(snd_card_t * card, struct pci_dev *pci, - struct cs4281 ** rchip, + cs4281_t ** rchip, int dual_codec) { - struct cs4281 *chip; + cs4281_t *chip; unsigned int tmp; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_cs4281_dev_free, }; @@ -1379,8 +1405,7 @@ static int __devinit snd_cs4281_create(struct snd_card *card, chip->ba0_addr = pci_resource_start(pci, 0); chip->ba1_addr = pci_resource_start(pci, 1); - if (request_irq(pci->irq, snd_cs4281_interrupt, SA_INTERRUPT|SA_SHIRQ, - "CS4281", chip)) { + if (request_irq(pci->irq, snd_cs4281_interrupt, SA_INTERRUPT|SA_SHIRQ, "CS4281", (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_cs4281_free(chip); return -ENOMEM; @@ -1407,13 +1432,15 @@ static int __devinit snd_cs4281_create(struct snd_card *card, snd_cs4281_proc_init(chip); + snd_card_set_pm_callback(card, cs4281_suspend, cs4281_resume, chip); + snd_card_set_dev(card, &pci->dev); *rchip = chip; return 0; } -static int snd_cs4281_chip_init(struct cs4281 *chip) +static int snd_cs4281_chip_init(cs4281_t *chip) { unsigned int tmp; int timeout; @@ -1474,7 +1501,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) snd_cs4281_pokeBA0(chip, BA0_SPMC, 0); udelay(50); snd_cs4281_pokeBA0(chip, BA0_SPMC, BA0_SPMC_RSTN); - msleep(50); + snd_cs4281_delay(50000); if (chip->dual_codec) snd_cs4281_pokeBA0(chip, BA0_SPMC, BA0_SPMC_RSTN | BA0_SPMC_ASDI2E); @@ -1490,13 +1517,13 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) * Start the DLL Clock logic. */ snd_cs4281_pokeBA0(chip, BA0_CLKCR1, BA0_CLKCR1_DLLP); - msleep(50); + snd_cs4281_delay(50000); snd_cs4281_pokeBA0(chip, BA0_CLKCR1, BA0_CLKCR1_SWCE | BA0_CLKCR1_DLLP); /* * Wait for the DLL ready signal from the clock logic. */ - timeout = 100; + timeout = HZ; do { /* * Read the AC97 status register to see if we've seen a CODEC @@ -1504,7 +1531,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) */ if (snd_cs4281_peekBA0(chip, BA0_CLKCR1) & BA0_CLKCR1_DLLRDY) goto __ok0; - msleep(1); + snd_cs4281_delay_long(); } while (timeout-- > 0); snd_printk(KERN_ERR "DLLRDY not seen\n"); @@ -1522,7 +1549,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) /* * Wait for the codec ready signal from the AC97 codec. */ - timeout = 100; + timeout = HZ; do { /* * Read the AC97 status register to see if we've seen a CODEC @@ -1530,7 +1557,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) */ if (snd_cs4281_peekBA0(chip, BA0_ACSTS) & BA0_ACSTS_CRDY) goto __ok1; - msleep(1); + snd_cs4281_delay_long(); } while (timeout-- > 0); snd_printk(KERN_ERR "never read codec ready from AC'97 (0x%x)\n", snd_cs4281_peekBA0(chip, BA0_ACSTS)); @@ -1538,11 +1565,11 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) __ok1: if (chip->dual_codec) { - timeout = 100; + timeout = HZ; do { if (snd_cs4281_peekBA0(chip, BA0_ACSTS2) & BA0_ACSTS_CRDY) goto __codec2_ok; - msleep(1); + snd_cs4281_delay_long(); } while (timeout-- > 0); snd_printk(KERN_INFO "secondary codec doesn't respond. disable it...\n"); chip->dual_codec = 0; @@ -1561,7 +1588,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) * the codec is pumping ADC data across the AC-link. */ - timeout = 100; + timeout = HZ; do { /* * Read the input slot valid register and see if input slots 3 @@ -1569,7 +1596,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) */ if ((snd_cs4281_peekBA0(chip, BA0_ACISV) & (BA0_ACISV_SLV(3) | BA0_ACISV_SLV(4))) == (BA0_ACISV_SLV(3) | BA0_ACISV_SLV(4))) goto __ok2; - msleep(1); + snd_cs4281_delay_long(); } while (timeout-- > 0); if (--retry_count > 0) @@ -1589,7 +1616,7 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) * Initialize DMA structures */ for (tmp = 0; tmp < 4; tmp++) { - struct cs4281_dma *dma = &chip->dma[tmp]; + cs4281_dma_t *dma = &chip->dma[tmp]; dma->regDBA = BA0_DBA0 + (tmp * 0x10); dma->regDCA = BA0_DCA0 + (tmp * 0x10); dma->regDBC = BA0_DBC0 + (tmp * 0x10); @@ -1646,16 +1673,16 @@ static int snd_cs4281_chip_init(struct cs4281 *chip) * MIDI section */ -static void snd_cs4281_midi_reset(struct cs4281 *chip) +static void snd_cs4281_midi_reset(cs4281_t *chip) { snd_cs4281_pokeBA0(chip, BA0_MIDCR, chip->midcr | BA0_MIDCR_MRST); udelay(100); snd_cs4281_pokeBA0(chip, BA0_MIDCR, chip->midcr); } -static int snd_cs4281_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_cs4281_midi_input_open(snd_rawmidi_substream_t * substream) { - struct cs4281 *chip = substream->rmidi->private_data; + cs4281_t *chip = substream->rmidi->private_data; spin_lock_irq(&chip->reg_lock); chip->midcr |= BA0_MIDCR_RXE; @@ -1669,9 +1696,9 @@ static int snd_cs4281_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_cs4281_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_cs4281_midi_input_close(snd_rawmidi_substream_t * substream) { - struct cs4281 *chip = substream->rmidi->private_data; + cs4281_t *chip = substream->rmidi->private_data; spin_lock_irq(&chip->reg_lock); chip->midcr &= ~(BA0_MIDCR_RXE | BA0_MIDCR_RIE); @@ -1686,9 +1713,9 @@ static int snd_cs4281_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_cs4281_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_cs4281_midi_output_open(snd_rawmidi_substream_t * substream) { - struct cs4281 *chip = substream->rmidi->private_data; + cs4281_t *chip = substream->rmidi->private_data; spin_lock_irq(&chip->reg_lock); chip->uartm |= CS4281_MODE_OUTPUT; @@ -1703,9 +1730,9 @@ static int snd_cs4281_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_cs4281_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_cs4281_midi_output_close(snd_rawmidi_substream_t * substream) { - struct cs4281 *chip = substream->rmidi->private_data; + cs4281_t *chip = substream->rmidi->private_data; spin_lock_irq(&chip->reg_lock); chip->midcr &= ~(BA0_MIDCR_TXE | BA0_MIDCR_TIE); @@ -1720,10 +1747,10 @@ static int snd_cs4281_midi_output_close(struct snd_rawmidi_substream *substream) return 0; } -static void snd_cs4281_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_cs4281_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct cs4281 *chip = substream->rmidi->private_data; + cs4281_t *chip = substream->rmidi->private_data; spin_lock_irqsave(&chip->reg_lock, flags); if (up) { @@ -1740,10 +1767,10 @@ static void snd_cs4281_midi_input_trigger(struct snd_rawmidi_substream *substrea spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_cs4281_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_cs4281_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct cs4281 *chip = substream->rmidi->private_data; + cs4281_t *chip = substream->rmidi->private_data; unsigned char byte; spin_lock_irqsave(&chip->reg_lock, flags); @@ -1770,24 +1797,23 @@ static void snd_cs4281_midi_output_trigger(struct snd_rawmidi_substream *substre spin_unlock_irqrestore(&chip->reg_lock, flags); } -static struct snd_rawmidi_ops snd_cs4281_midi_output = +static snd_rawmidi_ops_t snd_cs4281_midi_output = { .open = snd_cs4281_midi_output_open, .close = snd_cs4281_midi_output_close, .trigger = snd_cs4281_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_cs4281_midi_input = +static snd_rawmidi_ops_t snd_cs4281_midi_input = { .open = snd_cs4281_midi_input_open, .close = snd_cs4281_midi_input_close, .trigger = snd_cs4281_midi_input_trigger, }; -static int __devinit snd_cs4281_midi(struct cs4281 * chip, int device, - struct snd_rawmidi **rrawmidi) +static int __devinit snd_cs4281_midi(cs4281_t * chip, int device, snd_rawmidi_t **rrawmidi) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if (rrawmidi) @@ -1811,9 +1837,9 @@ static int __devinit snd_cs4281_midi(struct cs4281 * chip, int device, static irqreturn_t snd_cs4281_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct cs4281 *chip = dev_id; + cs4281_t *chip = dev_id; unsigned int status, dma, val; - struct cs4281_dma *cdma; + cs4281_dma_t *cdma; if (chip == NULL) return IRQ_NONE; @@ -1883,11 +1909,10 @@ static irqreturn_t snd_cs4281_interrupt(int irq, void *dev_id, struct pt_regs *r /* * OPL3 command */ -static void snd_cs4281_opl3_command(struct snd_opl3 *opl3, unsigned short cmd, - unsigned char val) +static void snd_cs4281_opl3_command(opl3_t * opl3, unsigned short cmd, unsigned char val) { unsigned long flags; - struct cs4281 *chip = opl3->private_data; + cs4281_t *chip = opl3->private_data; void __iomem *port; if (cmd & OPL3_RIGHT) @@ -1910,9 +1935,9 @@ static int __devinit snd_cs4281_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct cs4281 *chip; - struct snd_opl3 *opl3; + snd_card_t *card; + cs4281_t *chip; + opl3_t *opl3; int err; if (dev >= SNDRV_CARDS) @@ -1930,7 +1955,6 @@ static int __devinit snd_cs4281_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = chip; if ((err = snd_cs4281_mixer(chip)) < 0) { snd_card_free(card); @@ -2002,18 +2026,18 @@ static int saved_regs[SUSPEND_REGISTERS] = { #define CLKCR1_CKRA 0x00010000L -static int cs4281_suspend(struct pci_dev *pci, pm_message_t state) +static int cs4281_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct cs4281 *chip = card->private_data; + cs4281_t *chip = card->pm_private_data; u32 ulCLK; unsigned int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); - snd_ac97_suspend(chip->ac97); - snd_ac97_suspend(chip->ac97_secondary); + if (chip->ac97) + snd_ac97_suspend(chip->ac97); + if (chip->ac97_secondary) + snd_ac97_suspend(chip->ac97_secondary); ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1); ulCLK |= CLKCR1_CKRA; @@ -2043,21 +2067,18 @@ static int cs4281_suspend(struct pci_dev *pci, pm_message_t state) ulCLK &= ~CLKCR1_CKRA; snd_cs4281_pokeBA0(chip, BA0_CLKCR1, ulCLK); - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -static int cs4281_resume(struct pci_dev *pci) +static int cs4281_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct cs4281 *chip = card->private_data; + cs4281_t *chip = card->pm_private_data; unsigned int i; u32 ulCLK; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_master(chip->pci); ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1); ulCLK |= CLKCR1_CKRA; @@ -2070,14 +2091,15 @@ static int cs4281_resume(struct pci_dev *pci) if (saved_regs[i]) snd_cs4281_pokeBA0(chip, saved_regs[i], chip->suspend_regs[i]); - snd_ac97_resume(chip->ac97); - snd_ac97_resume(chip->ac97_secondary); + if (chip->ac97) + snd_ac97_resume(chip->ac97); + if (chip->ac97_secondary) + snd_ac97_resume(chip->ac97_secondary); ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1); ulCLK &= ~CLKCR1_CKRA; snd_cs4281_pokeBA0(chip, BA0_CLKCR1, ulCLK); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ @@ -2087,10 +2109,7 @@ static struct pci_driver driver = { .id_table = snd_cs4281_ids, .probe = snd_cs4281_probe, .remove = __devexit_p(snd_cs4281_remove), -#ifdef CONFIG_PM - .suspend = cs4281_suspend, - .resume = cs4281_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_cs4281_init(void) diff --git a/trunk/sound/pci/cs46xx/cs46xx.c b/trunk/sound/pci/cs46xx/cs46xx.c index c590602e20cd..b9fff4ee6f9d 100644 --- a/trunk/sound/pci/cs46xx/cs46xx.c +++ b/trunk/sound/pci/cs46xx/cs46xx.c @@ -78,8 +78,8 @@ static int __devinit snd_card_cs46xx_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_cs46xx *chip; + snd_card_t *card; + cs46xx_t *chip; int err; if (dev >= SNDRV_CARDS) @@ -98,7 +98,6 @@ static int __devinit snd_card_cs46xx_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = chip; chip->accept_valid = mmap_valid[dev]; if ((err = snd_cs46xx_pcm(chip, 0, NULL)) < 0) { snd_card_free(card); @@ -167,10 +166,7 @@ static struct pci_driver driver = { .id_table = snd_cs46xx_ids, .probe = snd_card_cs46xx_probe, .remove = __devexit_p(snd_card_cs46xx_remove), -#ifdef CONFIG_PM - .suspend = snd_cs46xx_suspend, - .resume = snd_cs46xx_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_cs46xx_init(void) diff --git a/trunk/sound/pci/cs46xx/cs46xx_lib.c b/trunk/sound/pci/cs46xx/cs46xx_lib.c index 8fb275d6eb77..9b8af5bcbb04 100644 --- a/trunk/sound/pci/cs46xx/cs46xx_lib.c +++ b/trunk/sound/pci/cs46xx/cs46xx_lib.c @@ -66,23 +66,23 @@ #include "cs46xx_lib.h" #include "dsp_spos.h" -static void amp_voyetra(struct snd_cs46xx *chip, int change); +static void amp_voyetra(cs46xx_t *chip, int change); #ifdef CONFIG_SND_CS46XX_NEW_DSP -static struct snd_pcm_ops snd_cs46xx_playback_rear_ops; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_rear_ops; -static struct snd_pcm_ops snd_cs46xx_playback_clfe_ops; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_clfe_ops; -static struct snd_pcm_ops snd_cs46xx_playback_iec958_ops; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_iec958_ops; +static snd_pcm_ops_t snd_cs46xx_playback_rear_ops; +static snd_pcm_ops_t snd_cs46xx_playback_indirect_rear_ops; +static snd_pcm_ops_t snd_cs46xx_playback_clfe_ops; +static snd_pcm_ops_t snd_cs46xx_playback_indirect_clfe_ops; +static snd_pcm_ops_t snd_cs46xx_playback_iec958_ops; +static snd_pcm_ops_t snd_cs46xx_playback_indirect_iec958_ops; #endif -static struct snd_pcm_ops snd_cs46xx_playback_ops; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_ops; -static struct snd_pcm_ops snd_cs46xx_capture_ops; -static struct snd_pcm_ops snd_cs46xx_capture_indirect_ops; +static snd_pcm_ops_t snd_cs46xx_playback_ops; +static snd_pcm_ops_t snd_cs46xx_playback_indirect_ops; +static snd_pcm_ops_t snd_cs46xx_capture_ops; +static snd_pcm_ops_t snd_cs46xx_capture_indirect_ops; -static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip, +static unsigned short snd_cs46xx_codec_read(cs46xx_t *chip, unsigned short reg, int codec_index) { @@ -204,10 +204,10 @@ static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip, return result; } -static unsigned short snd_cs46xx_ac97_read(struct snd_ac97 * ac97, +static unsigned short snd_cs46xx_ac97_read(ac97_t * ac97, unsigned short reg) { - struct snd_cs46xx *chip = ac97->private_data; + cs46xx_t *chip = ac97->private_data; unsigned short val; int codec_index = ac97->num; @@ -221,7 +221,7 @@ static unsigned short snd_cs46xx_ac97_read(struct snd_ac97 * ac97, } -static void snd_cs46xx_codec_write(struct snd_cs46xx *chip, +static void snd_cs46xx_codec_write(cs46xx_t *chip, unsigned short reg, unsigned short val, int codec_index) @@ -286,11 +286,11 @@ static void snd_cs46xx_codec_write(struct snd_cs46xx *chip, chip->active_ctrl(chip, -1); } -static void snd_cs46xx_ac97_write(struct snd_ac97 *ac97, +static void snd_cs46xx_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct snd_cs46xx *chip = ac97->private_data; + cs46xx_t *chip = ac97->private_data; int codec_index = ac97->num; snd_assert(codec_index == CS46XX_PRIMARY_CODEC_INDEX || @@ -305,7 +305,7 @@ static void snd_cs46xx_ac97_write(struct snd_ac97 *ac97, * Chip initialization */ -int snd_cs46xx_download(struct snd_cs46xx *chip, +int snd_cs46xx_download(cs46xx_t *chip, u32 *src, unsigned long offset, unsigned long len) @@ -334,7 +334,7 @@ int snd_cs46xx_download(struct snd_cs46xx *chip, #include "imgs/cwcbinhack.h" #include "imgs/cwcdma.h" -int snd_cs46xx_clear_BA1(struct snd_cs46xx *chip, +int snd_cs46xx_clear_BA1(cs46xx_t *chip, unsigned long offset, unsigned long len) { @@ -358,7 +358,7 @@ int snd_cs46xx_clear_BA1(struct snd_cs46xx *chip, #include "cs46xx_image.h" -int snd_cs46xx_download_image(struct snd_cs46xx *chip) +int snd_cs46xx_download_image(cs46xx_t *chip) { int idx, err; unsigned long offset = 0; @@ -379,7 +379,7 @@ int snd_cs46xx_download_image(struct snd_cs46xx *chip) * Chip reset */ -static void snd_cs46xx_reset(struct snd_cs46xx *chip) +static void snd_cs46xx_reset(cs46xx_t *chip) { int idx; @@ -408,7 +408,7 @@ static void snd_cs46xx_reset(struct snd_cs46xx *chip) snd_cs46xx_poke(chip, BA1_FRMT, 0xadf); } -static int cs46xx_wait_for_fifo(struct snd_cs46xx * chip,int retry_timeout) +static int cs46xx_wait_for_fifo(cs46xx_t * chip,int retry_timeout) { u32 i, status = 0; /* @@ -432,7 +432,7 @@ static int cs46xx_wait_for_fifo(struct snd_cs46xx * chip,int retry_timeout) return 0; } -static void snd_cs46xx_clear_serial_FIFOs(struct snd_cs46xx *chip) +static void snd_cs46xx_clear_serial_FIFOs(cs46xx_t *chip) { int idx, powerdown = 0; unsigned int tmp; @@ -486,7 +486,7 @@ static void snd_cs46xx_clear_serial_FIFOs(struct snd_cs46xx *chip) snd_cs46xx_pokeBA0(chip, BA0_CLKCR1, tmp); } -static void snd_cs46xx_proc_start(struct snd_cs46xx *chip) +static void snd_cs46xx_proc_start(cs46xx_t *chip) { int cnt; @@ -513,7 +513,7 @@ static void snd_cs46xx_proc_start(struct snd_cs46xx *chip) snd_printk(KERN_ERR "SPCR_RUNFR never reset\n"); } -static void snd_cs46xx_proc_stop(struct snd_cs46xx *chip) +static void snd_cs46xx_proc_stop(cs46xx_t *chip) { /* * Turn off the run, run at frame, and DMA enable bits in the local copy of @@ -528,7 +528,7 @@ static void snd_cs46xx_proc_stop(struct snd_cs46xx *chip) #define GOF_PER_SEC 200 -static void snd_cs46xx_set_play_sample_rate(struct snd_cs46xx *chip, unsigned int rate) +static void snd_cs46xx_set_play_sample_rate(cs46xx_t *chip, unsigned int rate) { unsigned long flags; unsigned int tmp1, tmp2; @@ -574,7 +574,7 @@ static void snd_cs46xx_set_play_sample_rate(struct snd_cs46xx *chip, unsigned in spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_cs46xx_set_capture_sample_rate(struct snd_cs46xx *chip, unsigned int rate) +static void snd_cs46xx_set_capture_sample_rate(cs46xx_t *chip, unsigned int rate) { unsigned long flags; unsigned int phiIncr, coeffIncr, tmp1, tmp2; @@ -684,43 +684,43 @@ static void snd_cs46xx_set_capture_sample_rate(struct snd_cs46xx *chip, unsigned * PCM part */ -static void snd_cs46xx_pb_trans_copy(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, size_t bytes) +static void snd_cs46xx_pb_trans_copy(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, size_t bytes) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_cs46xx_pcm * cpcm = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t * cpcm = runtime->private_data; memcpy(cpcm->hw_buf.area + rec->hw_data, runtime->dma_area + rec->sw_data, bytes); } -static int snd_cs46xx_playback_transfer(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_transfer(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_cs46xx_pcm * cpcm = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t * cpcm = runtime->private_data; snd_pcm_indirect_playback_transfer(substream, &cpcm->pcm_rec, snd_cs46xx_pb_trans_copy); return 0; } -static void snd_cs46xx_cp_trans_copy(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, size_t bytes) +static void snd_cs46xx_cp_trans_copy(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, size_t bytes) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs46xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; memcpy(runtime->dma_area + rec->sw_data, chip->capt.hw_buf.area + rec->hw_data, bytes); } -static int snd_cs46xx_capture_transfer(struct snd_pcm_substream *substream) +static int snd_cs46xx_capture_transfer(snd_pcm_substream_t *substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); snd_pcm_indirect_capture_transfer(substream, &chip->capt.pcm_rec, snd_cs46xx_cp_trans_copy); return 0; } -static snd_pcm_uframes_t snd_cs46xx_playback_direct_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs46xx_playback_direct_pointer(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); size_t ptr; - struct snd_cs46xx_pcm *cpcm = substream->runtime->private_data; + cs46xx_pcm_t *cpcm = substream->runtime->private_data; snd_assert (cpcm->pcm_channel,return -ENXIO); #ifdef CONFIG_SND_CS46XX_NEW_DSP @@ -732,11 +732,11 @@ static snd_pcm_uframes_t snd_cs46xx_playback_direct_pointer(struct snd_pcm_subst return ptr >> cpcm->shift; } -static snd_pcm_uframes_t snd_cs46xx_playback_indirect_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs46xx_playback_indirect_pointer(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); size_t ptr; - struct snd_cs46xx_pcm *cpcm = substream->runtime->private_data; + cs46xx_pcm_t *cpcm = substream->runtime->private_data; #ifdef CONFIG_SND_CS46XX_NEW_DSP snd_assert (cpcm->pcm_channel,return -ENXIO); @@ -748,29 +748,29 @@ static snd_pcm_uframes_t snd_cs46xx_playback_indirect_pointer(struct snd_pcm_sub return snd_pcm_indirect_playback_pointer(substream, &cpcm->pcm_rec, ptr); } -static snd_pcm_uframes_t snd_cs46xx_capture_direct_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs46xx_capture_direct_pointer(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); size_t ptr = snd_cs46xx_peek(chip, BA1_CBA) - chip->capt.hw_buf.addr; return ptr >> chip->capt.shift; } -static snd_pcm_uframes_t snd_cs46xx_capture_indirect_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs46xx_capture_indirect_pointer(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); size_t ptr = snd_cs46xx_peek(chip, BA1_CBA) - chip->capt.hw_buf.addr; return snd_pcm_indirect_capture_pointer(substream, &chip->capt.pcm_rec, ptr); } -static int snd_cs46xx_playback_trigger(struct snd_pcm_substream *substream, +static int snd_cs46xx_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - /*struct snd_pcm_runtime *runtime = substream->runtime;*/ + cs46xx_t *chip = snd_pcm_substream_chip(substream); + /*snd_pcm_runtime_t *runtime = substream->runtime;*/ int result = 0; #ifdef CONFIG_SND_CS46XX_NEW_DSP - struct snd_cs46xx_pcm *cpcm = substream->runtime->private_data; + cs46xx_pcm_t *cpcm = substream->runtime->private_data; if (! cpcm->pcm_channel) { return -ENXIO; } @@ -827,10 +827,10 @@ static int snd_cs46xx_playback_trigger(struct snd_pcm_substream *substream, return result; } -static int snd_cs46xx_capture_trigger(struct snd_pcm_substream *substream, +static int snd_cs46xx_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); unsigned int tmp; int result = 0; @@ -858,7 +858,7 @@ static int snd_cs46xx_capture_trigger(struct snd_pcm_substream *substream, } #ifdef CONFIG_SND_CS46XX_NEW_DSP -static int _cs46xx_adjust_sample_rate (struct snd_cs46xx *chip, struct snd_cs46xx_pcm *cpcm, +static int _cs46xx_adjust_sample_rate (cs46xx_t *chip, cs46xx_pcm_t *cpcm, int sample_rate) { @@ -893,14 +893,14 @@ static int _cs46xx_adjust_sample_rate (struct snd_cs46xx *chip, struct snd_cs46x #endif -static int snd_cs46xx_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cs46xx_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_cs46xx_pcm *cpcm; + snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t *cpcm; int err; #ifdef CONFIG_SND_CS46XX_NEW_DSP - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); int sample_rate = params_rate(hw_params); int period_size = params_period_bytes(hw_params); #endif @@ -995,11 +995,11 @@ static int snd_cs46xx_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_cs46xx_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_hw_free(snd_pcm_substream_t * substream) { - /*struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);*/ - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_cs46xx_pcm *cpcm; + /*cs46xx_t *chip = snd_pcm_substream_chip(substream);*/ + snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t *cpcm; cpcm = runtime->private_data; @@ -1017,13 +1017,13 @@ static int snd_cs46xx_playback_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_cs46xx_playback_prepare(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_prepare(snd_pcm_substream_t * substream) { unsigned int tmp; unsigned int pfie; - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_cs46xx_pcm *cpcm; + cs46xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t *cpcm; cpcm = runtime->private_data; @@ -1087,11 +1087,11 @@ static int snd_cs46xx_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_cs46xx_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cs46xx_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs46xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; #ifdef CONFIG_SND_CS46XX_NEW_DSP @@ -1118,10 +1118,10 @@ static int snd_cs46xx_capture_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_cs46xx_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_cs46xx_capture_hw_free(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs46xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->dma_area != chip->capt.hw_buf.area) snd_pcm_lib_free_pages(substream); @@ -1132,10 +1132,10 @@ static int snd_cs46xx_capture_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_cs46xx_capture_prepare(struct snd_pcm_substream *substream) +static int snd_cs46xx_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs46xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_cs46xx_poke(chip, BA1_CBA, chip->capt.hw_buf.addr); chip->capt.shift = 2; @@ -1149,13 +1149,13 @@ static int snd_cs46xx_capture_prepare(struct snd_pcm_substream *substream) static irqreturn_t snd_cs46xx_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_cs46xx *chip = dev_id; + cs46xx_t *chip = dev_id; u32 status1; #ifdef CONFIG_SND_CS46XX_NEW_DSP - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; u32 status2; int i; - struct snd_cs46xx_pcm *cpcm = NULL; + cs46xx_pcm_t *cpcm = NULL; #endif /* @@ -1239,7 +1239,7 @@ static irqreturn_t snd_cs46xx_interrupt(int irq, void *dev_id, struct pt_regs *r return IRQ_HANDLED; } -static struct snd_pcm_hardware snd_cs46xx_playback = +static snd_pcm_hardware_t snd_cs46xx_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | @@ -1261,7 +1261,7 @@ static struct snd_pcm_hardware snd_cs46xx_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_cs46xx_capture = +static snd_pcm_hardware_t snd_cs46xx_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | @@ -1285,7 +1285,7 @@ static struct snd_pcm_hardware snd_cs46xx_capture = static unsigned int period_sizes[] = { 32, 64, 128, 256, 512, 1024, 2048 }; -static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes = { +static snd_pcm_hw_constraint_list_t hw_constraints_period_sizes = { .count = ARRAY_SIZE(period_sizes), .list = period_sizes, .mask = 0 @@ -1293,16 +1293,16 @@ static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes = { #endif -static void snd_cs46xx_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_cs46xx_pcm_free_substream(snd_pcm_runtime_t *runtime) { kfree(runtime->private_data); } -static int _cs46xx_playback_open_channel (struct snd_pcm_substream *substream,int pcm_channel_id) +static int _cs46xx_playback_open_channel (snd_pcm_substream_t * substream,int pcm_channel_id) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - struct snd_cs46xx_pcm * cpcm; - struct snd_pcm_runtime *runtime = substream->runtime; + cs46xx_t *chip = snd_pcm_substream_chip(substream); + cs46xx_pcm_t * cpcm; + snd_pcm_runtime_t *runtime = substream->runtime; cpcm = kzalloc(sizeof(*cpcm), GFP_KERNEL); if (cpcm == NULL) @@ -1340,30 +1340,30 @@ static int _cs46xx_playback_open_channel (struct snd_pcm_substream *substream,in return 0; } -static int snd_cs46xx_playback_open(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_open(snd_pcm_substream_t * substream) { snd_printdd("open front channel\n"); return _cs46xx_playback_open_channel(substream,DSP_PCM_MAIN_CHANNEL); } #ifdef CONFIG_SND_CS46XX_NEW_DSP -static int snd_cs46xx_playback_open_rear(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_open_rear(snd_pcm_substream_t * substream) { snd_printdd("open rear channel\n"); return _cs46xx_playback_open_channel(substream,DSP_PCM_REAR_CHANNEL); } -static int snd_cs46xx_playback_open_clfe(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_open_clfe(snd_pcm_substream_t * substream) { snd_printdd("open center - LFE channel\n"); return _cs46xx_playback_open_channel(substream,DSP_PCM_CENTER_LFE_CHANNEL); } -static int snd_cs46xx_playback_open_iec958(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_open_iec958(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); snd_printdd("open raw iec958 channel\n"); @@ -1374,12 +1374,12 @@ static int snd_cs46xx_playback_open_iec958(struct snd_pcm_substream *substream) return _cs46xx_playback_open_channel(substream,DSP_IEC958_CHANNEL); } -static int snd_cs46xx_playback_close(struct snd_pcm_substream *substream); +static int snd_cs46xx_playback_close(snd_pcm_substream_t * substream); -static int snd_cs46xx_playback_close_iec958(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_close_iec958(snd_pcm_substream_t * substream) { int err; - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); snd_printdd("close raw iec958 channel\n"); @@ -1393,9 +1393,9 @@ static int snd_cs46xx_playback_close_iec958(struct snd_pcm_substream *substream) } #endif -static int snd_cs46xx_capture_open(struct snd_pcm_substream *substream) +static int snd_cs46xx_capture_open(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci), PAGE_SIZE, &chip->capt.hw_buf) < 0) @@ -1416,11 +1416,11 @@ static int snd_cs46xx_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cs46xx_playback_close(struct snd_pcm_substream *substream) +static int snd_cs46xx_playback_close(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_cs46xx_pcm * cpcm; + cs46xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t * cpcm; cpcm = runtime->private_data; @@ -1445,9 +1445,9 @@ static int snd_cs46xx_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_cs46xx_capture_close(struct snd_pcm_substream *substream) +static int snd_cs46xx_capture_close(snd_pcm_substream_t * substream) { - struct snd_cs46xx *chip = snd_pcm_substream_chip(substream); + cs46xx_t *chip = snd_pcm_substream_chip(substream); chip->capt.substream = NULL; snd_dma_free_pages(&chip->capt.hw_buf); @@ -1457,7 +1457,7 @@ static int snd_cs46xx_capture_close(struct snd_pcm_substream *substream) } #ifdef CONFIG_SND_CS46XX_NEW_DSP -static struct snd_pcm_ops snd_cs46xx_playback_rear_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_rear_ops = { .open = snd_cs46xx_playback_open_rear, .close = snd_cs46xx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1468,7 +1468,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_rear_ops = { .pointer = snd_cs46xx_playback_direct_pointer, }; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_rear_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_indirect_rear_ops = { .open = snd_cs46xx_playback_open_rear, .close = snd_cs46xx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1480,7 +1480,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_indirect_rear_ops = { .ack = snd_cs46xx_playback_transfer, }; -static struct snd_pcm_ops snd_cs46xx_playback_clfe_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_clfe_ops = { .open = snd_cs46xx_playback_open_clfe, .close = snd_cs46xx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1491,7 +1491,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_clfe_ops = { .pointer = snd_cs46xx_playback_direct_pointer, }; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_clfe_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_indirect_clfe_ops = { .open = snd_cs46xx_playback_open_clfe, .close = snd_cs46xx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1503,7 +1503,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_indirect_clfe_ops = { .ack = snd_cs46xx_playback_transfer, }; -static struct snd_pcm_ops snd_cs46xx_playback_iec958_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_iec958_ops = { .open = snd_cs46xx_playback_open_iec958, .close = snd_cs46xx_playback_close_iec958, .ioctl = snd_pcm_lib_ioctl, @@ -1514,7 +1514,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_iec958_ops = { .pointer = snd_cs46xx_playback_direct_pointer, }; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_iec958_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_indirect_iec958_ops = { .open = snd_cs46xx_playback_open_iec958, .close = snd_cs46xx_playback_close_iec958, .ioctl = snd_pcm_lib_ioctl, @@ -1528,7 +1528,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_indirect_iec958_ops = { #endif -static struct snd_pcm_ops snd_cs46xx_playback_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_ops = { .open = snd_cs46xx_playback_open, .close = snd_cs46xx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1539,7 +1539,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_ops = { .pointer = snd_cs46xx_playback_direct_pointer, }; -static struct snd_pcm_ops snd_cs46xx_playback_indirect_ops = { +static snd_pcm_ops_t snd_cs46xx_playback_indirect_ops = { .open = snd_cs46xx_playback_open, .close = snd_cs46xx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1551,7 +1551,7 @@ static struct snd_pcm_ops snd_cs46xx_playback_indirect_ops = { .ack = snd_cs46xx_playback_transfer, }; -static struct snd_pcm_ops snd_cs46xx_capture_ops = { +static snd_pcm_ops_t snd_cs46xx_capture_ops = { .open = snd_cs46xx_capture_open, .close = snd_cs46xx_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1562,7 +1562,7 @@ static struct snd_pcm_ops snd_cs46xx_capture_ops = { .pointer = snd_cs46xx_capture_direct_pointer, }; -static struct snd_pcm_ops snd_cs46xx_capture_indirect_ops = { +static snd_pcm_ops_t snd_cs46xx_capture_indirect_ops = { .open = snd_cs46xx_capture_open, .close = snd_cs46xx_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1574,15 +1574,43 @@ static struct snd_pcm_ops snd_cs46xx_capture_indirect_ops = { .ack = snd_cs46xx_capture_transfer, }; +static void snd_cs46xx_pcm_free(snd_pcm_t *pcm) +{ + cs46xx_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + #ifdef CONFIG_SND_CS46XX_NEW_DSP +static void snd_cs46xx_pcm_rear_free(snd_pcm_t *pcm) +{ + cs46xx_t *chip = pcm->private_data; + chip->pcm_rear = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static void snd_cs46xx_pcm_center_lfe_free(snd_pcm_t *pcm) +{ + cs46xx_t *chip = pcm->private_data; + chip->pcm_center_lfe = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static void snd_cs46xx_pcm_iec958_free(snd_pcm_t *pcm) +{ + cs46xx_t *chip = pcm->private_data; + chip->pcm_iec958 = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + #define MAX_PLAYBACK_CHANNELS (DSP_MAX_PCM_CHANNELS - 1) #else #define MAX_PLAYBACK_CHANNELS 1 #endif -int __devinit snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm) +int __devinit snd_cs46xx_pcm(cs46xx_t *chip, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -1591,6 +1619,7 @@ int __devinit snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm return err; pcm->private_data = chip; + pcm->private_free = snd_cs46xx_pcm_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cs46xx_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cs46xx_capture_ops); @@ -1611,9 +1640,9 @@ int __devinit snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm #ifdef CONFIG_SND_CS46XX_NEW_DSP -int __devinit snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm) +int __devinit snd_cs46xx_pcm_rear(cs46xx_t *chip, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -1623,6 +1652,7 @@ int __devinit snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device, struct sn return err; pcm->private_data = chip; + pcm->private_free = snd_cs46xx_pcm_rear_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cs46xx_playback_rear_ops); @@ -1640,9 +1670,9 @@ int __devinit snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device, struct sn return 0; } -int __devinit snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm) +int __devinit snd_cs46xx_pcm_center_lfe(cs46xx_t *chip, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -1652,6 +1682,7 @@ int __devinit snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device, str return err; pcm->private_data = chip; + pcm->private_free = snd_cs46xx_pcm_center_lfe_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cs46xx_playback_clfe_ops); @@ -1669,9 +1700,9 @@ int __devinit snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device, str return 0; } -int __devinit snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm) +int __devinit snd_cs46xx_pcm_iec958(cs46xx_t *chip, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -1681,6 +1712,7 @@ int __devinit snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device, struct return err; pcm->private_data = chip; + pcm->private_free = snd_cs46xx_pcm_iec958_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cs46xx_playback_iec958_ops); @@ -1702,16 +1734,16 @@ int __devinit snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device, struct /* * Mixer routines */ -static void snd_cs46xx_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_cs46xx_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct snd_cs46xx *chip = bus->private_data; + cs46xx_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_cs46xx_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_cs46xx_mixer_free_ac97(ac97_t *ac97) { - struct snd_cs46xx *chip = ac97->private_data; + cs46xx_t *chip = ac97->private_data; snd_assert ((ac97 == chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]) || (ac97 == chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]), @@ -1725,8 +1757,8 @@ static void snd_cs46xx_mixer_free_ac97(struct snd_ac97 *ac97) chip->ac97[CS46XX_SECONDARY_CODEC_INDEX] = NULL; } -static int snd_cs46xx_vol_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs46xx_vol_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1735,9 +1767,9 @@ static int snd_cs46xx_vol_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_vol_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value; unsigned int val = snd_cs46xx_peek(chip, reg); ucontrol->value.integer.value[0] = 0xffff - (val >> 16); @@ -1745,9 +1777,9 @@ static int snd_cs46xx_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int snd_cs46xx_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_vol_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value; unsigned int val = ((0xffff - ucontrol->value.integer.value[0]) << 16 | (0xffff - ucontrol->value.integer.value[1])); @@ -1763,9 +1795,9 @@ static int snd_cs46xx_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem #ifdef CONFIG_SND_CS46XX_NEW_DSP -static int snd_cs46xx_vol_dac_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_vol_dac_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = chip->dsp_spos_instance->dac_volume_left; ucontrol->value.integer.value[1] = chip->dsp_spos_instance->dac_volume_right; @@ -1773,9 +1805,9 @@ static int snd_cs46xx_vol_dac_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_cs46xx_vol_dac_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_vol_dac_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int change = 0; if (chip->dsp_spos_instance->dac_volume_right != ucontrol->value.integer.value[0] || @@ -1790,18 +1822,18 @@ static int snd_cs46xx_vol_dac_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ } #if 0 -static int snd_cs46xx_vol_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_vol_iec958_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = chip->dsp_spos_instance->spdif_input_volume_left; ucontrol->value.integer.value[1] = chip->dsp_spos_instance->spdif_input_volume_right; return 0; } -static int snd_cs46xx_vol_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_vol_iec958_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int change = 0; if (chip->dsp_spos_instance->spdif_input_volume_left != ucontrol->value.integer.value[0] || @@ -1816,8 +1848,8 @@ static int snd_cs46xx_vol_iec958_put(struct snd_kcontrol *kcontrol, struct snd_c } #endif -static int snd_mixer_boolean_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_mixer_boolean_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1826,10 +1858,10 @@ static int snd_mixer_boolean_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_iec958_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_iec958_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value; if (reg == CS46XX_MIXER_SPDIF_OUTPUT_ELEMENT) @@ -1840,10 +1872,10 @@ static int snd_cs46xx_iec958_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_iec958_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_iec958_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int change, res; switch (kcontrol->private_value) { @@ -1877,11 +1909,11 @@ static int snd_cs46xx_iec958_put(struct snd_kcontrol *kcontrol, return res; } -static int snd_cs46xx_adc_capture_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_adc_capture_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; if (ins->adc_input != NULL) ucontrol->value.integer.value[0] = 1; @@ -1891,11 +1923,11 @@ static int snd_cs46xx_adc_capture_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_adc_capture_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_adc_capture_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int change = 0; if (ucontrol->value.integer.value[0] && !ins->adc_input) { @@ -1908,11 +1940,11 @@ static int snd_cs46xx_adc_capture_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_cs46xx_pcm_capture_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_pcm_capture_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; if (ins->pcm_input != NULL) ucontrol->value.integer.value[0] = 1; @@ -1923,11 +1955,11 @@ static int snd_cs46xx_pcm_capture_get(struct snd_kcontrol *kcontrol, } -static int snd_cs46xx_pcm_capture_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_pcm_capture_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int change = 0; if (ucontrol->value.integer.value[0] && !ins->pcm_input) { @@ -1941,10 +1973,10 @@ static int snd_cs46xx_pcm_capture_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_herc_spdif_select_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_herc_spdif_select_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int val1 = snd_cs46xx_peekBA0(chip, BA0_EGPIODR); @@ -1959,10 +1991,10 @@ static int snd_herc_spdif_select_get(struct snd_kcontrol *kcontrol, /* * Game Theatre XP card - EGPIO[0] is used to select SPDIF input optical or coaxial. */ -static int snd_herc_spdif_select_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_herc_spdif_select_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int val1 = snd_cs46xx_peekBA0(chip, BA0_EGPIODR); int val2 = snd_cs46xx_peekBA0(chip, BA0_EGPIOPTR); @@ -1984,18 +2016,18 @@ static int snd_herc_spdif_select_put(struct snd_kcontrol *kcontrol, } -static int snd_cs46xx_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_cs46xx_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_cs46xx_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_spdif_default_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; down (&chip->spos_mutex); ucontrol->value.iec958.status[0] = _wrap_all_bits((ins->spdif_csuv_default >> 24) & 0xff); @@ -2007,11 +2039,11 @@ static int snd_cs46xx_spdif_default_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_spdif_default_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx * chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t * chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; unsigned int val; int change; @@ -2034,8 +2066,8 @@ static int snd_cs46xx_spdif_default_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_cs46xx_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -2044,11 +2076,11 @@ static int snd_cs46xx_spdif_mask_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_spdif_stream_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; down (&chip->spos_mutex); ucontrol->value.iec958.status[0] = _wrap_all_bits((ins->spdif_csuv_stream >> 24) & 0xff); @@ -2060,11 +2092,11 @@ static int snd_cs46xx_spdif_stream_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_spdif_stream_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_cs46xx * chip = snd_kcontrol_chip(kcontrol); - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t * chip = snd_kcontrol_chip(kcontrol); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; unsigned int val; int change; @@ -2091,8 +2123,8 @@ static int snd_cs46xx_spdif_stream_put(struct snd_kcontrol *kcontrol, #ifdef CONFIG_SND_CS46XX_DEBUG_GPIO -static int snd_cs46xx_egpio_select_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs46xx_egpio_select_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -2101,19 +2133,19 @@ static int snd_cs46xx_egpio_select_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_egpio_select_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_egpio_select_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = chip->current_gpio; return 0; } -static int snd_cs46xx_egpio_select_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_egpio_select_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int change = (chip->current_gpio != ucontrol->value.integer.value[0]); chip->current_gpio = ucontrol->value.integer.value[0]; @@ -2121,10 +2153,10 @@ static int snd_cs46xx_egpio_select_put(struct snd_kcontrol *kcontrol, } -static int snd_cs46xx_egpio_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_egpio_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value; snd_printdd ("put: reg = %04x, gpio %02x\n",reg,chip->current_gpio); @@ -2134,10 +2166,10 @@ static int snd_cs46xx_egpio_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs46xx_egpio_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_egpio_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value; int val = snd_cs46xx_peekBA0(chip, reg); int oldval = val; @@ -2155,7 +2187,7 @@ static int snd_cs46xx_egpio_put(struct snd_kcontrol *kcontrol, } #endif /* CONFIG_SND_CS46XX_DEBUG_GPIO */ -static struct snd_kcontrol_new snd_cs46xx_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_cs46xx_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "DAC Volume", @@ -2285,26 +2317,26 @@ static struct snd_kcontrol_new snd_cs46xx_controls[] __devinitdata = { #ifdef CONFIG_SND_CS46XX_NEW_DSP /* set primary cs4294 codec into Extended Audio Mode */ -static int snd_cs46xx_front_dup_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_front_dup_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned short val; val = snd_ac97_read(chip->ac97[CS46XX_PRIMARY_CODEC_INDEX], AC97_CSR_ACMODE); ucontrol->value.integer.value[0] = (val & 0x200) ? 0 : 1; return 0; } -static int snd_cs46xx_front_dup_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs46xx_front_dup_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_cs46xx *chip = snd_kcontrol_chip(kcontrol); + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); return snd_ac97_update_bits(chip->ac97[CS46XX_PRIMARY_CODEC_INDEX], AC97_CSR_ACMODE, 0x200, ucontrol->value.integer.value[0] ? 0 : 0x200); } -static struct snd_kcontrol_new snd_cs46xx_front_dup_ctl = { +static snd_kcontrol_new_t snd_cs46xx_front_dup_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Duplicate Front", .info = snd_mixer_boolean_info, @@ -2315,7 +2347,7 @@ static struct snd_kcontrol_new snd_cs46xx_front_dup_ctl = { #ifdef CONFIG_SND_CS46XX_NEW_DSP /* Only available on the Hercules Game Theater XP soundcard */ -static struct snd_kcontrol_new snd_hercules_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_hercules_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Optical/Coaxial SPDIF Input Switch", @@ -2326,7 +2358,7 @@ static struct snd_kcontrol_new snd_hercules_controls[] __devinitdata = { }; -static void snd_cs46xx_codec_reset (struct snd_ac97 * ac97) +static void snd_cs46xx_codec_reset (ac97_t * ac97) { unsigned long end_time; int err; @@ -2375,10 +2407,10 @@ static void snd_cs46xx_codec_reset (struct snd_ac97 * ac97) } #endif -static int __devinit cs46xx_detect_codec(struct snd_cs46xx *chip, int codec) +static int __devinit cs46xx_detect_codec(cs46xx_t *chip, int codec) { int idx, err; - struct snd_ac97_template ac97; + ac97_template_t ac97; memset(&ac97, 0, sizeof(ac97)); ac97.private_data = chip; @@ -2408,13 +2440,13 @@ static int __devinit cs46xx_detect_codec(struct snd_cs46xx *chip, int codec) return -ENXIO; } -int __devinit snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device) +int __devinit snd_cs46xx_mixer(cs46xx_t *chip, int spdif_device) { - struct snd_card *card = chip->card; - struct snd_ctl_elem_id id; + snd_card_t *card = chip->card; + snd_ctl_elem_id_t id; int err; unsigned int idx; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { #ifdef CONFIG_SND_CS46XX_NEW_DSP .reset = snd_cs46xx_codec_reset, #endif @@ -2442,7 +2474,7 @@ int __devinit snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device) /* add cs4630 mixer controls */ for (idx = 0; idx < ARRAY_SIZE(snd_cs46xx_controls); idx++) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; kctl = snd_ctl_new1(&snd_cs46xx_controls[idx], chip); if (kctl && kctl->id.iface == SNDRV_CTL_ELEM_IFACE_PCM) kctl->id.device = spdif_device; @@ -2484,16 +2516,16 @@ int __devinit snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device) * RawMIDI interface */ -static void snd_cs46xx_midi_reset(struct snd_cs46xx *chip) +static void snd_cs46xx_midi_reset(cs46xx_t *chip) { snd_cs46xx_pokeBA0(chip, BA0_MIDCR, MIDCR_MRST); udelay(100); snd_cs46xx_pokeBA0(chip, BA0_MIDCR, chip->midcr); } -static int snd_cs46xx_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_cs46xx_midi_input_open(snd_rawmidi_substream_t * substream) { - struct snd_cs46xx *chip = substream->rmidi->private_data; + cs46xx_t *chip = substream->rmidi->private_data; chip->active_ctrl(chip, 1); spin_lock_irq(&chip->reg_lock); @@ -2509,9 +2541,9 @@ static int snd_cs46xx_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_cs46xx_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_cs46xx_midi_input_close(snd_rawmidi_substream_t * substream) { - struct snd_cs46xx *chip = substream->rmidi->private_data; + cs46xx_t *chip = substream->rmidi->private_data; spin_lock_irq(&chip->reg_lock); chip->midcr &= ~(MIDCR_RXE | MIDCR_RIE); @@ -2527,9 +2559,9 @@ static int snd_cs46xx_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_cs46xx_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_cs46xx_midi_output_open(snd_rawmidi_substream_t * substream) { - struct snd_cs46xx *chip = substream->rmidi->private_data; + cs46xx_t *chip = substream->rmidi->private_data; chip->active_ctrl(chip, 1); @@ -2546,9 +2578,9 @@ static int snd_cs46xx_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_cs46xx_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_cs46xx_midi_output_close(snd_rawmidi_substream_t * substream) { - struct snd_cs46xx *chip = substream->rmidi->private_data; + cs46xx_t *chip = substream->rmidi->private_data; spin_lock_irq(&chip->reg_lock); chip->midcr &= ~(MIDCR_TXE | MIDCR_TIE); @@ -2564,10 +2596,10 @@ static int snd_cs46xx_midi_output_close(struct snd_rawmidi_substream *substream) return 0; } -static void snd_cs46xx_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_cs46xx_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct snd_cs46xx *chip = substream->rmidi->private_data; + cs46xx_t *chip = substream->rmidi->private_data; spin_lock_irqsave(&chip->reg_lock, flags); if (up) { @@ -2584,10 +2616,10 @@ static void snd_cs46xx_midi_input_trigger(struct snd_rawmidi_substream *substrea spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_cs46xx_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_cs46xx_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct snd_cs46xx *chip = substream->rmidi->private_data; + cs46xx_t *chip = substream->rmidi->private_data; unsigned char byte; spin_lock_irqsave(&chip->reg_lock, flags); @@ -2614,23 +2646,23 @@ static void snd_cs46xx_midi_output_trigger(struct snd_rawmidi_substream *substre spin_unlock_irqrestore(&chip->reg_lock, flags); } -static struct snd_rawmidi_ops snd_cs46xx_midi_output = +static snd_rawmidi_ops_t snd_cs46xx_midi_output = { .open = snd_cs46xx_midi_output_open, .close = snd_cs46xx_midi_output_close, .trigger = snd_cs46xx_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_cs46xx_midi_input = +static snd_rawmidi_ops_t snd_cs46xx_midi_input = { .open = snd_cs46xx_midi_input_open, .close = snd_cs46xx_midi_input_close, .trigger = snd_cs46xx_midi_input_trigger, }; -int __devinit snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rrawmidi) +int __devinit snd_cs46xx_midi(cs46xx_t *chip, int device, snd_rawmidi_t **rrawmidi) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if (rrawmidi) @@ -2657,7 +2689,7 @@ int __devinit snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_ra static void snd_cs46xx_gameport_trigger(struct gameport *gameport) { - struct snd_cs46xx *chip = gameport_get_port_data(gameport); + cs46xx_t *chip = gameport_get_port_data(gameport); snd_assert(chip, return); snd_cs46xx_pokeBA0(chip, BA0_JSPT, 0xFF); //outb(gameport->io, 0xFF); @@ -2665,7 +2697,7 @@ static void snd_cs46xx_gameport_trigger(struct gameport *gameport) static unsigned char snd_cs46xx_gameport_read(struct gameport *gameport) { - struct snd_cs46xx *chip = gameport_get_port_data(gameport); + cs46xx_t *chip = gameport_get_port_data(gameport); snd_assert(chip, return 0); return snd_cs46xx_peekBA0(chip, BA0_JSPT); //inb(gameport->io); @@ -2673,7 +2705,7 @@ static unsigned char snd_cs46xx_gameport_read(struct gameport *gameport) static int snd_cs46xx_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons) { - struct snd_cs46xx *chip = gameport_get_port_data(gameport); + cs46xx_t *chip = gameport_get_port_data(gameport); unsigned js1, js2, jst; snd_assert(chip, return 0); @@ -2707,7 +2739,7 @@ static int snd_cs46xx_gameport_open(struct gameport *gameport, int mode) return 0; } -int __devinit snd_cs46xx_gameport(struct snd_cs46xx *chip) +int __devinit snd_cs46xx_gameport(cs46xx_t *chip) { struct gameport *gp; @@ -2735,7 +2767,7 @@ int __devinit snd_cs46xx_gameport(struct snd_cs46xx *chip) return 0; } -static inline void snd_cs46xx_remove_gameport(struct snd_cs46xx *chip) +static inline void snd_cs46xx_remove_gameport(cs46xx_t *chip) { if (chip->gameport) { gameport_unregister_port(chip->gameport); @@ -2743,21 +2775,20 @@ static inline void snd_cs46xx_remove_gameport(struct snd_cs46xx *chip) } } #else -int __devinit snd_cs46xx_gameport(struct snd_cs46xx *chip) { return -ENOSYS; } -static inline void snd_cs46xx_remove_gameport(struct snd_cs46xx *chip) { } +int __devinit snd_cs46xx_gameport(cs46xx_t *chip) { return -ENOSYS; } +static inline void snd_cs46xx_remove_gameport(cs46xx_t *chip) { } #endif /* CONFIG_GAMEPORT */ -#ifdef CONFIG_PROC_FS /* * proc interface */ -static long snd_cs46xx_io_read(struct snd_info_entry *entry, void *file_private_data, +static long snd_cs46xx_io_read(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *buf, unsigned long count, unsigned long pos) { long size; - struct snd_cs46xx_region *region = entry->private_data; + snd_cs46xx_region_t *region = (snd_cs46xx_region_t *)entry->private_data; size = count; if (pos + (size_t)size > region->size) @@ -2773,13 +2804,13 @@ static struct snd_info_entry_ops snd_cs46xx_proc_io_ops = { .read = snd_cs46xx_io_read, }; -static int __devinit snd_cs46xx_proc_init(struct snd_card *card, struct snd_cs46xx *chip) +static int __devinit snd_cs46xx_proc_init(snd_card_t * card, cs46xx_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; int idx; for (idx = 0; idx < 5; idx++) { - struct snd_cs46xx_region *region = &chip->region.idx[idx]; + snd_cs46xx_region_t *region = &chip->region.idx[idx]; if (! snd_card_proc_new(card, region->name, &entry)) { entry->content = SNDRV_INFO_CONTENT_DATA; entry->private_data = chip; @@ -2794,22 +2825,18 @@ static int __devinit snd_cs46xx_proc_init(struct snd_card *card, struct snd_cs46 return 0; } -static int snd_cs46xx_proc_done(struct snd_cs46xx *chip) +static int snd_cs46xx_proc_done(cs46xx_t *chip) { #ifdef CONFIG_SND_CS46XX_NEW_DSP cs46xx_dsp_proc_done(chip); #endif return 0; } -#else /* !CONFIG_PROC_FS */ -#define snd_cs46xx_proc_init(card, chip) -#define snd_cs46xx_proc_done(chip) -#endif /* * stop the h/w */ -static void snd_cs46xx_hw_stop(struct snd_cs46xx *chip) +static void snd_cs46xx_hw_stop(cs46xx_t *chip) { unsigned int tmp; @@ -2856,7 +2883,7 @@ static void snd_cs46xx_hw_stop(struct snd_cs46xx *chip) } -static int snd_cs46xx_free(struct snd_cs46xx *chip) +static int snd_cs46xx_free(cs46xx_t *chip) { int idx; @@ -2876,13 +2903,13 @@ static int snd_cs46xx_free(struct snd_cs46xx *chip) snd_cs46xx_hw_stop(chip); for (idx = 0; idx < 5; idx++) { - struct snd_cs46xx_region *region = &chip->region.idx[idx]; + snd_cs46xx_region_t *region = &chip->region.idx[idx]; if (region->remap_addr) iounmap(region->remap_addr); release_and_free_resource(region->resource); } if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); if (chip->active_ctrl) chip->active_ctrl(chip, -chip->amplifier); @@ -2899,16 +2926,16 @@ static int snd_cs46xx_free(struct snd_cs46xx *chip) return 0; } -static int snd_cs46xx_dev_free(struct snd_device *device) +static int snd_cs46xx_dev_free(snd_device_t *device) { - struct snd_cs46xx *chip = device->device_data; + cs46xx_t *chip = device->device_data; return snd_cs46xx_free(chip); } /* * initialize chip */ -static int snd_cs46xx_chip_init(struct snd_cs46xx *chip) +static int snd_cs46xx_chip_init(cs46xx_t *chip) { int timeout; @@ -3137,7 +3164,7 @@ static int snd_cs46xx_chip_init(struct snd_cs46xx *chip) /* * start and load DSP */ -int __devinit snd_cs46xx_start_dsp(struct snd_cs46xx *chip) +int __devinit snd_cs46xx_start_dsp(cs46xx_t *chip) { unsigned int tmp; /* @@ -3239,12 +3266,12 @@ int __devinit snd_cs46xx_start_dsp(struct snd_cs46xx *chip) * AMP control - null AMP */ -static void amp_none(struct snd_cs46xx *chip, int change) +static void amp_none(cs46xx_t *chip, int change) { } #ifdef CONFIG_SND_CS46XX_NEW_DSP -static int voyetra_setup_eapd_slot(struct snd_cs46xx *chip) +static int voyetra_setup_eapd_slot(cs46xx_t *chip) { u32 idx, valid_slots,tmp,powerdown = 0; @@ -3364,7 +3391,7 @@ static int voyetra_setup_eapd_slot(struct snd_cs46xx *chip) * Crystal EAPD mode */ -static void amp_voyetra(struct snd_cs46xx *chip, int change) +static void amp_voyetra(cs46xx_t *chip, int change) { /* Manage the EAPD bit on the Crystal 4297 and the Analog AD1885 */ @@ -3400,7 +3427,7 @@ static void amp_voyetra(struct snd_cs46xx *chip, int change) #endif } -static void hercules_init(struct snd_cs46xx *chip) +static void hercules_init(cs46xx_t *chip) { /* default: AMP off, and SPDIF input optical */ snd_cs46xx_pokeBA0(chip, BA0_EGPIODR, EGPIODR_GPOE0); @@ -3411,7 +3438,7 @@ static void hercules_init(struct snd_cs46xx *chip) /* * Game Theatre XP card - EGPIO[2] is used to enable the external amp. */ -static void amp_hercules(struct snd_cs46xx *chip, int change) +static void amp_hercules(cs46xx_t *chip, int change) { int old = chip->amplifier; int val1 = snd_cs46xx_peekBA0(chip, BA0_EGPIODR); @@ -3432,7 +3459,7 @@ static void amp_hercules(struct snd_cs46xx *chip, int change) } } -static void voyetra_mixer_init (struct snd_cs46xx *chip) +static void voyetra_mixer_init (cs46xx_t *chip) { snd_printdd ("initializing Voyetra mixer\n"); @@ -3441,12 +3468,12 @@ static void voyetra_mixer_init (struct snd_cs46xx *chip) snd_cs46xx_pokeBA0(chip, BA0_EGPIOPTR, EGPIODR_GPOE0); } -static void hercules_mixer_init (struct snd_cs46xx *chip) +static void hercules_mixer_init (cs46xx_t *chip) { #ifdef CONFIG_SND_CS46XX_NEW_DSP unsigned int idx; int err; - struct snd_card *card = chip->card; + snd_card_t *card = chip->card; #endif /* set EGPIO to default */ @@ -3456,7 +3483,7 @@ static void hercules_mixer_init (struct snd_cs46xx *chip) #ifdef CONFIG_SND_CS46XX_NEW_DSP for (idx = 0 ; idx < ARRAY_SIZE(snd_hercules_controls); idx++) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; kctl = snd_ctl_new1(&snd_hercules_controls[idx], chip); if ((err = snd_ctl_add(card, kctl)) < 0) { @@ -3473,7 +3500,7 @@ static void hercules_mixer_init (struct snd_cs46xx *chip) * Untested */ -static void amp_voyetra_4294(struct snd_cs46xx *chip, int change) +static void amp_voyetra_4294(cs46xx_t *chip, int change) { chip->amplifier += change; @@ -3503,7 +3530,7 @@ static void amp_voyetra_4294(struct snd_cs46xx *chip, int change) * enough to make them useful. */ -static void clkrun_hack(struct snd_cs46xx *chip, int change) +static void clkrun_hack(cs46xx_t *chip, int change) { u16 control, nval; @@ -3528,7 +3555,7 @@ static void clkrun_hack(struct snd_cs46xx *chip, int change) /* * detect intel piix4 */ -static void clkrun_init(struct snd_cs46xx *chip) +static void clkrun_init(cs46xx_t *chip) { struct pci_dev *pdev; u8 pp; @@ -3556,10 +3583,10 @@ struct cs_card_type u16 vendor; u16 id; char *name; - void (*init)(struct snd_cs46xx *); - void (*amp)(struct snd_cs46xx *, int); - void (*active)(struct snd_cs46xx *, int); - void (*mixer_init)(struct snd_cs46xx *); + void (*init)(cs46xx_t *); + void (*amp)(cs46xx_t *, int); + void (*active)(cs46xx_t *, int); + void (*mixer_init)(cs46xx_t *); }; static struct cs_card_type __devinitdata cards[] = { @@ -3659,19 +3686,18 @@ static struct cs_card_type __devinitdata cards[] = { * APM support */ #ifdef CONFIG_PM -int snd_cs46xx_suspend(struct pci_dev *pci, pm_message_t state) +static int snd_cs46xx_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_cs46xx *chip = card->private_data; + cs46xx_t *chip = card->pm_private_data; int amp_saved; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); // chip->ac97_powerdown = snd_cs46xx_codec_read(chip, AC97_POWER_CONTROL); // chip->ac97_general_purpose = snd_cs46xx_codec_read(chip, BA0_AC97_GENERAL_PURPOSE); snd_ac97_suspend(chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]); - snd_ac97_suspend(chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]); + if (chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]) + snd_ac97_suspend(chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]); amp_saved = chip->amplifier; /* turn off amp */ @@ -3680,20 +3706,17 @@ int snd_cs46xx_suspend(struct pci_dev *pci, pm_message_t state) /* disable CLKRUN */ chip->active_ctrl(chip, -chip->amplifier); chip->amplifier = amp_saved; /* restore the status */ - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -int snd_cs46xx_resume(struct pci_dev *pci) +static int snd_cs46xx_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_cs46xx *chip = card->private_data; + cs46xx_t *chip = card->pm_private_data; int amp_saved; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_master(chip->pci); amp_saved = chip->amplifier; chip->amplifier = 0; chip->active_ctrl(chip, 1); /* force to on */ @@ -3712,14 +3735,14 @@ int snd_cs46xx_resume(struct pci_dev *pci) #endif snd_ac97_resume(chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]); - snd_ac97_resume(chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]); + if (chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]) + snd_ac97_resume(chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]); if (amp_saved) chip->amplifier_ctrl(chip, 1); /* turn amp on */ else chip->active_ctrl(chip, -1); /* disable CLKRUN */ chip->amplifier = amp_saved; - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ @@ -3728,17 +3751,17 @@ int snd_cs46xx_resume(struct pci_dev *pci) /* */ -int __devinit snd_cs46xx_create(struct snd_card *card, +int __devinit snd_cs46xx_create(snd_card_t * card, struct pci_dev * pci, int external_amp, int thinkpad, - struct snd_cs46xx ** rchip) + cs46xx_t ** rchip) { - struct snd_cs46xx *chip; + cs46xx_t *chip; int err, idx; - struct snd_cs46xx_region *region; + snd_cs46xx_region_t *region; struct cs_card_type *cp; u16 ss_card, ss_vendor; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_cs46xx_dev_free, }; @@ -3764,8 +3787,7 @@ int __devinit snd_cs46xx_create(struct snd_card *card, chip->ba1_addr = pci_resource_start(pci, 1); if (chip->ba0_addr == 0 || chip->ba0_addr == (unsigned long)~0 || chip->ba1_addr == 0 || chip->ba1_addr == (unsigned long)~0) { - snd_printk(KERN_ERR "wrong address(es) - ba0 = 0x%lx, ba1 = 0x%lx\n", - chip->ba0_addr, chip->ba1_addr); + snd_printk(KERN_ERR "wrong address(es) - ba0 = 0x%lx, ba1 = 0x%lx\n", chip->ba0_addr, chip->ba1_addr); snd_cs46xx_free(chip); return -ENOMEM; } @@ -3835,10 +3857,8 @@ int __devinit snd_cs46xx_create(struct snd_card *card, for (idx = 0; idx < 5; idx++) { region = &chip->region.idx[idx]; - if ((region->resource = request_mem_region(region->base, region->size, - region->name)) == NULL) { - snd_printk(KERN_ERR "unable to request memory region 0x%lx-0x%lx\n", - region->base, region->base + region->size - 1); + if ((region->resource = request_mem_region(region->base, region->size, region->name)) == NULL) { + snd_printk(KERN_ERR "unable to request memory region 0x%lx-0x%lx\n", region->base, region->base + region->size - 1); snd_cs46xx_free(chip); return -EBUSY; } @@ -3850,8 +3870,7 @@ int __devinit snd_cs46xx_create(struct snd_card *card, } } - if (request_irq(pci->irq, snd_cs46xx_interrupt, SA_INTERRUPT|SA_SHIRQ, - "CS46XX", chip)) { + if (request_irq(pci->irq, snd_cs46xx_interrupt, SA_INTERRUPT|SA_SHIRQ, "CS46XX", (void *) chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_cs46xx_free(chip); return -EBUSY; @@ -3879,6 +3898,8 @@ int __devinit snd_cs46xx_create(struct snd_card *card, snd_cs46xx_proc_init(card, chip); + snd_card_set_pm_callback(card, snd_cs46xx_suspend, snd_cs46xx_resume, chip); + chip->active_ctrl(chip, -1); /* disable CLKRUN */ snd_card_set_dev(card, &pci->dev); diff --git a/trunk/sound/pci/cs46xx/cs46xx_lib.h b/trunk/sound/pci/cs46xx/cs46xx_lib.h index f75750c2bd24..d7bec096d247 100644 --- a/trunk/sound/pci/cs46xx/cs46xx_lib.h +++ b/trunk/sound/pci/cs46xx/cs46xx_lib.h @@ -57,7 +57,7 @@ * common I/O routines */ -static inline void snd_cs46xx_poke(struct snd_cs46xx *chip, unsigned long reg, unsigned int val) +static inline void snd_cs46xx_poke(cs46xx_t *chip, unsigned long reg, unsigned int val) { unsigned int bank = reg >> 16; unsigned int offset = reg & 0xffff; @@ -66,138 +66,117 @@ static inline void snd_cs46xx_poke(struct snd_cs46xx *chip, unsigned long reg, u writel(val, chip->region.idx[bank+1].remap_addr + offset); } -static inline unsigned int snd_cs46xx_peek(struct snd_cs46xx *chip, unsigned long reg) +static inline unsigned int snd_cs46xx_peek(cs46xx_t *chip, unsigned long reg) { unsigned int bank = reg >> 16; unsigned int offset = reg & 0xffff; return readl(chip->region.idx[bank+1].remap_addr + offset); } -static inline void snd_cs46xx_pokeBA0(struct snd_cs46xx *chip, unsigned long offset, unsigned int val) +static inline void snd_cs46xx_pokeBA0(cs46xx_t *chip, unsigned long offset, unsigned int val) { writel(val, chip->region.name.ba0.remap_addr + offset); } -static inline unsigned int snd_cs46xx_peekBA0(struct snd_cs46xx *chip, unsigned long offset) +static inline unsigned int snd_cs46xx_peekBA0(cs46xx_t *chip, unsigned long offset) { return readl(chip->region.name.ba0.remap_addr + offset); } -struct dsp_spos_instance *cs46xx_dsp_spos_create (struct snd_cs46xx * chip); -void cs46xx_dsp_spos_destroy (struct snd_cs46xx * chip); -int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * module); -struct dsp_symbol_entry *cs46xx_dsp_lookup_symbol (struct snd_cs46xx * chip, char * symbol_name, - int symbol_type); -#ifdef CONFIG_PROC_FS -int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip); -int cs46xx_dsp_proc_done (struct snd_cs46xx *chip); -#else -#define cs46xx_dsp_proc_init(card, chip) -#define cs46xx_dsp_proc_done(chip) -#endif -int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip); -int snd_cs46xx_download (struct snd_cs46xx *chip, u32 *src, unsigned long offset, - unsigned long len); -int snd_cs46xx_clear_BA1(struct snd_cs46xx *chip, unsigned long offset, unsigned long len); -int cs46xx_dsp_enable_spdif_out (struct snd_cs46xx *chip); -int cs46xx_dsp_enable_spdif_hw (struct snd_cs46xx *chip); -int cs46xx_dsp_disable_spdif_out (struct snd_cs46xx *chip); -int cs46xx_dsp_enable_spdif_in (struct snd_cs46xx *chip); -int cs46xx_dsp_disable_spdif_in (struct snd_cs46xx *chip); -int cs46xx_dsp_enable_pcm_capture (struct snd_cs46xx *chip); -int cs46xx_dsp_disable_pcm_capture (struct snd_cs46xx *chip); -int cs46xx_dsp_enable_adc_capture (struct snd_cs46xx *chip); -int cs46xx_dsp_disable_adc_capture (struct snd_cs46xx *chip); -int cs46xx_poke_via_dsp (struct snd_cs46xx *chip, u32 address, u32 data); -struct dsp_scb_descriptor * cs46xx_dsp_create_scb (struct snd_cs46xx *chip, char * name, - u32 * scb_data, u32 dest); -#ifdef CONFIG_PROC_FS -void cs46xx_dsp_proc_free_scb_desc (struct dsp_scb_descriptor * scb); -void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip, - struct dsp_scb_descriptor * scb); -#else -#define cs46xx_dsp_proc_free_scb_desc(scb) -#define cs46xx_dsp_proc_register_scb_desc(chip, scb) -#endif -struct dsp_scb_descriptor * cs46xx_dsp_create_timing_master_scb (struct snd_cs46xx *chip); -struct dsp_scb_descriptor * -cs46xx_dsp_create_codec_out_scb(struct snd_cs46xx * chip, - char * codec_name, u16 channel_disp, u16 fifo_addr, - u16 child_scb_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -struct dsp_scb_descriptor * -cs46xx_dsp_create_codec_in_scb(struct snd_cs46xx * chip, char * codec_name, - u16 channel_disp, u16 fifo_addr, - u16 sample_buffer_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -void cs46xx_dsp_remove_scb (struct snd_cs46xx *chip, - struct dsp_scb_descriptor * scb); -struct dsp_scb_descriptor * -cs46xx_dsp_create_codec_in_scb(struct snd_cs46xx * chip, char * codec_name, - u16 channel_disp, u16 fifo_addr, - u16 sample_buffer_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -struct dsp_scb_descriptor * -cs46xx_dsp_create_src_task_scb(struct snd_cs46xx * chip, char * scb_name, - int sample_rate, u16 src_buffer_addr, - u16 src_delay_buffer_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type, int pass_through); -struct dsp_scb_descriptor * -cs46xx_dsp_create_mix_only_scb(struct snd_cs46xx * chip, char * scb_name, - u16 mix_buffer_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); - -struct dsp_scb_descriptor * -cs46xx_dsp_create_vari_decimate_scb(struct snd_cs46xx * chip, char * scb_name, - u16 vari_buffer_addr0, u16 vari_buffer_addr1, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -struct dsp_scb_descriptor * -cs46xx_dsp_create_asynch_fg_rx_scb(struct snd_cs46xx * chip, char * scb_name, - u32 dest, u16 hfg_scb_address, u16 asynch_buffer_address, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -struct dsp_scb_descriptor * -cs46xx_dsp_create_spio_write_scb(struct snd_cs46xx * chip, char * scb_name, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -struct dsp_scb_descriptor * -cs46xx_dsp_create_mix_to_ostream_scb(struct snd_cs46xx * chip, char * scb_name, - u16 mix_buffer_addr, u16 writeback_spb, u32 dest, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -struct dsp_scb_descriptor * -cs46xx_dsp_create_magic_snoop_scb(struct snd_cs46xx * chip, char * scb_name, - u32 dest, u16 snoop_buffer_address, - struct dsp_scb_descriptor * snoop_scb, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type); -struct dsp_pcm_channel_descriptor * -cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip, u32 sample_rate, - void * private_data, u32 hw_dma_addr, - int pcm_channel_id); -void cs46xx_dsp_destroy_pcm_channel (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel); -int cs46xx_dsp_pcm_unlink (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel); -int cs46xx_dsp_pcm_link (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel); -struct dsp_scb_descriptor * -cs46xx_add_record_source (struct snd_cs46xx *chip, struct dsp_scb_descriptor * source, - u16 addr, char * scb_name); -int cs46xx_src_unlink(struct snd_cs46xx *chip, struct dsp_scb_descriptor * src); -int cs46xx_src_link(struct snd_cs46xx *chip, struct dsp_scb_descriptor * src); -int cs46xx_iec958_pre_open (struct snd_cs46xx *chip); -int cs46xx_iec958_post_close (struct snd_cs46xx *chip); -int cs46xx_dsp_pcm_channel_set_period (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel, - int period_size); -int cs46xx_dsp_pcm_ostream_set_period (struct snd_cs46xx * chip, int period_size); -int cs46xx_dsp_set_dac_volume (struct snd_cs46xx * chip, u16 left, u16 right); -int cs46xx_dsp_set_iec958_volume (struct snd_cs46xx * chip, u16 left, u16 right); +dsp_spos_instance_t * cs46xx_dsp_spos_create (cs46xx_t * chip); +void cs46xx_dsp_spos_destroy (cs46xx_t * chip); +int cs46xx_dsp_load_module (cs46xx_t * chip,dsp_module_desc_t * module); +symbol_entry_t * cs46xx_dsp_lookup_symbol (cs46xx_t * chip,char * symbol_name,int symbol_type); +int cs46xx_dsp_proc_init (snd_card_t * card, cs46xx_t *chip); +int cs46xx_dsp_proc_done (cs46xx_t *chip); +int cs46xx_dsp_scb_and_task_init (cs46xx_t *chip); +int snd_cs46xx_download (cs46xx_t *chip,u32 *src,unsigned long offset, + unsigned long len); +int snd_cs46xx_clear_BA1(cs46xx_t *chip,unsigned long offset,unsigned long len); +int cs46xx_dsp_enable_spdif_out (cs46xx_t *chip); +int cs46xx_dsp_enable_spdif_hw (cs46xx_t *chip); +int cs46xx_dsp_disable_spdif_out (cs46xx_t *chip); +int cs46xx_dsp_enable_spdif_in (cs46xx_t *chip); +int cs46xx_dsp_disable_spdif_in (cs46xx_t *chip); +int cs46xx_dsp_enable_pcm_capture (cs46xx_t *chip); +int cs46xx_dsp_disable_pcm_capture (cs46xx_t *chip); +int cs46xx_dsp_enable_adc_capture (cs46xx_t *chip); +int cs46xx_dsp_disable_adc_capture (cs46xx_t *chip); +int cs46xx_poke_via_dsp (cs46xx_t *chip,u32 address,u32 data); +dsp_scb_descriptor_t * cs46xx_dsp_create_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest); +void cs46xx_dsp_proc_free_scb_desc (dsp_scb_descriptor_t * scb); +void cs46xx_dsp_proc_register_scb_desc (cs46xx_t *chip,dsp_scb_descriptor_t * scb); +dsp_scb_descriptor_t * cs46xx_dsp_create_timing_master_scb (cs46xx_t *chip); +dsp_scb_descriptor_t * cs46xx_dsp_create_codec_out_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 child_scb_addr, + u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_codec_in_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 sample_buffer_addr, + u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +void cs46xx_dsp_remove_scb (cs46xx_t *chip,dsp_scb_descriptor_t * scb); +dsp_scb_descriptor_t * cs46xx_dsp_create_codec_in_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 sample_buffer_addr, + u32 dest,dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_src_task_scb(cs46xx_t * chip,char * scb_name, + int sample_rate, + u16 src_buffer_addr, + u16 src_delay_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type, + int pass_through); +dsp_scb_descriptor_t * cs46xx_dsp_create_mix_only_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); + +dsp_scb_descriptor_t * cs46xx_dsp_create_vari_decimate_scb(cs46xx_t * chip,char * scb_name, + u16 vari_buffer_addr0, + u16 vari_buffer_addr1, + u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_asynch_fg_rx_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 hfg_scb_address, + u16 asynch_buffer_address, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_spio_write_scb(cs46xx_t * chip,char * scb_name,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_mix_to_ostream_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u16 writeback_spb,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_magic_snoop_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 snoop_buffer_address, + dsp_scb_descriptor_t * snoop_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +pcm_channel_descriptor_t * cs46xx_dsp_create_pcm_channel (cs46xx_t * chip,u32 sample_rate, void * private_data, u32 hw_dma_addr, + int pcm_channel_id); +void cs46xx_dsp_destroy_pcm_channel (cs46xx_t * chip, + pcm_channel_descriptor_t * pcm_channel); +int cs46xx_dsp_pcm_unlink (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel); +int cs46xx_dsp_pcm_link (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel); +dsp_scb_descriptor_t * cs46xx_add_record_source (cs46xx_t *chip,dsp_scb_descriptor_t * source, + u16 addr,char * scb_name); +int cs46xx_src_unlink(cs46xx_t *chip,dsp_scb_descriptor_t * src); +int cs46xx_src_link(cs46xx_t *chip,dsp_scb_descriptor_t * src); +int cs46xx_iec958_pre_open (cs46xx_t *chip); +int cs46xx_iec958_post_close (cs46xx_t *chip); +int cs46xx_dsp_pcm_channel_set_period (cs46xx_t * chip, + pcm_channel_descriptor_t * pcm_channel, + int period_size); +int cs46xx_dsp_pcm_ostream_set_period (cs46xx_t * chip, + int period_size); +int cs46xx_dsp_set_dac_volume (cs46xx_t * chip,u16 left,u16 right); +int cs46xx_dsp_set_iec958_volume (cs46xx_t * chip,u16 left,u16 right); #endif /* __CS46XX_LIB_H__ */ diff --git a/trunk/sound/pci/cs46xx/dsp_spos.c b/trunk/sound/pci/cs46xx/dsp_spos.c index 445a448949e7..b66304fc4e4a 100644 --- a/trunk/sound/pci/cs46xx/dsp_spos.c +++ b/trunk/sound/pci/cs46xx/dsp_spos.c @@ -37,10 +37,9 @@ #include "cs46xx_lib.h" #include "dsp_spos.h" -static int cs46xx_dsp_async_init (struct snd_cs46xx *chip, - struct dsp_scb_descriptor * fg_entry); +static int cs46xx_dsp_async_init (cs46xx_t *chip, dsp_scb_descriptor_t * fg_entry); -static enum wide_opcode wide_opcodes[] = { +static wide_opcode_t wide_opcodes[] = { WIDE_FOR_BEGIN_LOOP, WIDE_FOR_BEGIN_LOOP2, WIDE_COND_GOTO_ADDR, @@ -55,13 +54,12 @@ static enum wide_opcode wide_opcodes[] = { WIDE_TBEQ_NCOND_CALL1_ADDR }; -static int shadow_and_reallocate_code (struct snd_cs46xx * chip, u32 * data, u32 size, - u32 overlay_begin_address) +static int shadow_and_reallocate_code (cs46xx_t * chip,u32 * data,u32 size, u32 overlay_begin_address) { unsigned int i = 0, j, nreallocated = 0; u32 hival,loval,address; u32 mop_operands,mop_type,wide_op; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert( ((size % 2) == 0), return -EINVAL); @@ -116,7 +114,7 @@ static int shadow_and_reallocate_code (struct snd_cs46xx * chip, u32 * data, u32 return nreallocated; } -static struct dsp_segment_desc * get_segment_desc (struct dsp_module_desc * module, int seg_type) +static segment_desc_t * get_segment_desc (dsp_module_desc_t * module, int seg_type) { int i; for (i = 0;i < module->nsegments; ++i) { @@ -128,7 +126,7 @@ static struct dsp_segment_desc * get_segment_desc (struct dsp_module_desc * modu return NULL; }; -static int find_free_symbol_index (struct dsp_spos_instance * ins) +static int find_free_symbol_index (dsp_spos_instance_t * ins) { int index = ins->symbol_table.nsymbols,i; @@ -142,10 +140,10 @@ static int find_free_symbol_index (struct dsp_spos_instance * ins) return index; } -static int add_symbols (struct snd_cs46xx * chip, struct dsp_module_desc * module) +static int add_symbols (cs46xx_t * chip, dsp_module_desc_t * module) { int i; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; if (module->symbol_table.nsymbols > 0) { if (!strcmp(module->symbol_table.symbols[0].symbol_name, "OVERLAYBEGINADDRESS") && @@ -183,11 +181,10 @@ static int add_symbols (struct snd_cs46xx * chip, struct dsp_module_desc * modul return 0; } -static struct dsp_symbol_entry * -add_symbol (struct snd_cs46xx * chip, char * symbol_name, u32 address, int type) +static symbol_entry_t * add_symbol (cs46xx_t * chip, char * symbol_name, u32 address, int type) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_symbol_entry * symbol = NULL; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + symbol_entry_t * symbol = NULL; int index; if (ins->symbol_table.nsymbols == (DSP_MAX_SYMBOLS - 1)) { @@ -220,17 +217,17 @@ add_symbol (struct snd_cs46xx * chip, char * symbol_name, u32 address, int type) return symbol; } -struct dsp_spos_instance *cs46xx_dsp_spos_create (struct snd_cs46xx * chip) +dsp_spos_instance_t * cs46xx_dsp_spos_create (cs46xx_t * chip) { - struct dsp_spos_instance * ins = kzalloc(sizeof(struct dsp_spos_instance), GFP_KERNEL); + dsp_spos_instance_t * ins = kmalloc(sizeof(dsp_spos_instance_t), GFP_KERNEL); if (ins == NULL) return NULL; + memset(ins, 0, sizeof(*ins)); /* better to use vmalloc for this big table */ ins->symbol_table.nsymbols = 0; - ins->symbol_table.symbols = vmalloc(sizeof(struct dsp_symbol_entry) * - DSP_MAX_SYMBOLS); + ins->symbol_table.symbols = vmalloc(sizeof(symbol_entry_t) * DSP_MAX_SYMBOLS); ins->symbol_table.highest_frag_index = 0; if (ins->symbol_table.symbols == NULL) { @@ -251,7 +248,7 @@ struct dsp_spos_instance *cs46xx_dsp_spos_create (struct snd_cs46xx * chip) ins->ntask = 0; ins->nmodules = 0; - ins->modules = kmalloc(sizeof(struct dsp_module_desc) * DSP_MAX_MODULES, GFP_KERNEL); + ins->modules = kmalloc(sizeof(dsp_module_desc_t) * DSP_MAX_MODULES, GFP_KERNEL); if (ins->modules == NULL) { cs46xx_dsp_spos_destroy(chip); @@ -280,10 +277,10 @@ struct dsp_spos_instance *cs46xx_dsp_spos_create (struct snd_cs46xx * chip) return ins; } -void cs46xx_dsp_spos_destroy (struct snd_cs46xx * chip) +void cs46xx_dsp_spos_destroy (cs46xx_t * chip) { int i; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert(ins != NULL, return); @@ -301,12 +298,12 @@ void cs46xx_dsp_spos_destroy (struct snd_cs46xx * chip) up(&chip->spos_mutex); } -int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * module) +int cs46xx_dsp_load_module (cs46xx_t * chip, dsp_module_desc_t * module) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_segment_desc * code = get_segment_desc (module,SEGTYPE_SP_PROGRAM); - struct dsp_segment_desc * parameter = get_segment_desc (module,SEGTYPE_SP_PARAMETER); - struct dsp_segment_desc * sample = get_segment_desc (module,SEGTYPE_SP_SAMPLE); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + segment_desc_t * code = get_segment_desc (module,SEGTYPE_SP_PROGRAM); + segment_desc_t * parameter = get_segment_desc (module,SEGTYPE_SP_PARAMETER); + segment_desc_t * sample = get_segment_desc (module,SEGTYPE_SP_SAMPLE); u32 doffset, dsize; if (ins->nmodules == DSP_MAX_MODULES - 1) { @@ -413,11 +410,10 @@ int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * m return 0; } -struct dsp_symbol_entry * -cs46xx_dsp_lookup_symbol (struct snd_cs46xx * chip, char * symbol_name, int symbol_type) +symbol_entry_t * cs46xx_dsp_lookup_symbol (cs46xx_t * chip, char * symbol_name, int symbol_type) { int i; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; for ( i = 0; i < ins->symbol_table.nsymbols; ++i ) { @@ -439,12 +435,10 @@ cs46xx_dsp_lookup_symbol (struct snd_cs46xx * chip, char * symbol_name, int symb } -#ifdef CONFIG_PROC_FS -static struct dsp_symbol_entry * -cs46xx_dsp_lookup_symbol_addr (struct snd_cs46xx * chip, u32 address, int symbol_type) +static symbol_entry_t * cs46xx_dsp_lookup_symbol_addr (cs46xx_t * chip, u32 address, int symbol_type) { int i; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; for ( i = 0; i < ins->symbol_table.nsymbols; ++i ) { @@ -462,11 +456,10 @@ cs46xx_dsp_lookup_symbol_addr (struct snd_cs46xx * chip, u32 address, int symbol } -static void cs46xx_dsp_proc_symbol_table_read (struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void cs46xx_dsp_proc_symbol_table_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_cs46xx *chip = entry->private_data; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = entry->private_data; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int i; snd_iprintf(buffer, "SYMBOLS:\n"); @@ -490,11 +483,10 @@ static void cs46xx_dsp_proc_symbol_table_read (struct snd_info_entry *entry, } -static void cs46xx_dsp_proc_modules_read (struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void cs46xx_dsp_proc_modules_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_cs46xx *chip = entry->private_data; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = entry->private_data; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int i,j; down(&chip->spos_mutex); @@ -505,7 +497,7 @@ static void cs46xx_dsp_proc_modules_read (struct snd_info_entry *entry, snd_iprintf(buffer, " %d fixups\n", ins->modules[i].nfixups); for (j = 0; j < ins->modules[i].nsegments; ++ j) { - struct dsp_segment_desc * desc = (ins->modules[i].segments + j); + segment_desc_t * desc = (ins->modules[i].segments + j); snd_iprintf(buffer, " segment %02x offset %08x size %08x\n", desc->segment_type,desc->offset, desc->size); } @@ -513,12 +505,11 @@ static void cs46xx_dsp_proc_modules_read (struct snd_info_entry *entry, up(&chip->spos_mutex); } -static void cs46xx_dsp_proc_task_tree_read (struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void cs46xx_dsp_proc_task_tree_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_cs46xx *chip = entry->private_data; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - int i, j, col; + cs46xx_t *chip = entry->private_data; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int i,j,col; void __iomem *dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET; down(&chip->spos_mutex); @@ -541,11 +532,10 @@ static void cs46xx_dsp_proc_task_tree_read (struct snd_info_entry *entry, up(&chip->spos_mutex); } -static void cs46xx_dsp_proc_scb_read (struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void cs46xx_dsp_proc_scb_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_cs46xx *chip = entry->private_data; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + cs46xx_t *chip = entry->private_data; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int i; down(&chip->spos_mutex); @@ -574,14 +564,13 @@ static void cs46xx_dsp_proc_scb_read (struct snd_info_entry *entry, up(&chip->spos_mutex); } -static void cs46xx_dsp_proc_parameter_dump_read (struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void cs46xx_dsp_proc_parameter_dump_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_cs46xx *chip = entry->private_data; - /*struct dsp_spos_instance * ins = chip->dsp_spos_instance; */ - unsigned int i, col = 0; + cs46xx_t *chip = entry->private_data; + /*dsp_spos_instance_t * ins = chip->dsp_spos_instance; */ + unsigned int i,col = 0; void __iomem *dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET; - struct dsp_symbol_entry * symbol; + symbol_entry_t * symbol; for (i = 0;i < DSP_PARAMETER_BYTE_SIZE; i += sizeof(u32),col ++) { if (col == 4) { @@ -602,10 +591,9 @@ static void cs46xx_dsp_proc_parameter_dump_read (struct snd_info_entry *entry, } } -static void cs46xx_dsp_proc_sample_dump_read (struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void cs46xx_dsp_proc_sample_dump_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct snd_cs46xx *chip = entry->private_data; + cs46xx_t *chip = entry->private_data; int i,col = 0; void __iomem *dst = chip->region.idx[2].remap_addr; @@ -750,10 +738,10 @@ static void cs46xx_dsp_proc_sample_dump_read (struct snd_info_entry *entry, snd_iprintf(buffer,"\n"); } -int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip) +int cs46xx_dsp_proc_init (snd_card_t * card, cs46xx_t *chip) { - struct snd_info_entry *entry; - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + snd_info_entry_t *entry; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int i; ins->snd_card = card; @@ -864,9 +852,9 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_proc_done (struct snd_cs46xx *chip) +int cs46xx_dsp_proc_done (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int i; if (ins->proc_sym_info_entry) { @@ -913,11 +901,9 @@ int cs46xx_dsp_proc_done (struct snd_cs46xx *chip) return 0; } -#endif /* CONFIG_PROC_FS */ static int debug_tree; -static void _dsp_create_task_tree (struct snd_cs46xx *chip, u32 * task_data, - u32 dest, int size) +static void _dsp_create_task_tree (cs46xx_t *chip,u32 * task_data, u32 dest, int size) { void __iomem *spdst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET + dest * sizeof(u32); @@ -931,7 +917,7 @@ static void _dsp_create_task_tree (struct snd_cs46xx *chip, u32 * task_data, } static int debug_scb; -static void _dsp_create_scb (struct snd_cs46xx *chip, u32 * scb_data, u32 dest) +static void _dsp_create_scb (cs46xx_t *chip,u32 * scb_data, u32 dest) { void __iomem *spdst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET + dest * sizeof(u32); @@ -944,7 +930,7 @@ static void _dsp_create_scb (struct snd_cs46xx *chip, u32 * scb_data, u32 dest) } } -static int find_free_scb_index (struct dsp_spos_instance * ins) +static int find_free_scb_index (dsp_spos_instance_t * ins) { int index = ins->nscb, i; @@ -958,10 +944,10 @@ static int find_free_scb_index (struct dsp_spos_instance * ins) return index; } -static struct dsp_scb_descriptor * _map_scb (struct snd_cs46xx *chip, char * name, u32 dest) +static dsp_scb_descriptor_t * _map_scb (cs46xx_t *chip,char * name,u32 dest) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * desc = NULL; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * desc = NULL; int index; if (ins->nscb == DSP_MAX_SCB_DESC - 1) { @@ -991,11 +977,10 @@ static struct dsp_scb_descriptor * _map_scb (struct snd_cs46xx *chip, char * nam return desc; } -static struct dsp_task_descriptor * -_map_task_tree (struct snd_cs46xx *chip, char * name, u32 dest, u32 size) +static dsp_task_descriptor_t * _map_task_tree (cs46xx_t *chip,char * name,u32 dest,u32 size) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_task_descriptor * desc = NULL; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_task_descriptor_t * desc = NULL; if (ins->ntask == DSP_MAX_TASK_DESC - 1) { snd_printk(KERN_ERR "dsp_spos: got no place for other TASK\n"); @@ -1015,10 +1000,9 @@ _map_task_tree (struct snd_cs46xx *chip, char * name, u32 dest, u32 size) return desc; } -struct dsp_scb_descriptor * -cs46xx_dsp_create_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u32 dest) +dsp_scb_descriptor_t * cs46xx_dsp_create_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest) { - struct dsp_scb_descriptor * desc; + dsp_scb_descriptor_t * desc; desc = _map_scb (chip,name,dest); if (desc) { @@ -1031,11 +1015,9 @@ cs46xx_dsp_create_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u32 } -static struct dsp_task_descriptor * -cs46xx_dsp_create_task_tree (struct snd_cs46xx *chip, char * name, u32 * task_data, - u32 dest, int size) +static dsp_task_descriptor_t * cs46xx_dsp_create_task_tree (cs46xx_t *chip,char * name, u32 * task_data,u32 dest,int size) { - struct dsp_task_descriptor * desc; + dsp_task_descriptor_t * desc; desc = _map_task_tree (chip,name,dest,size); if (desc) { @@ -1047,31 +1029,31 @@ cs46xx_dsp_create_task_tree (struct snd_cs46xx *chip, char * name, u32 * task_da return desc; } -int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip) +int cs46xx_dsp_scb_and_task_init (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_symbol_entry * fg_task_tree_header_code; - struct dsp_symbol_entry * task_tree_header_code; - struct dsp_symbol_entry * task_tree_thread; - struct dsp_symbol_entry * null_algorithm; - struct dsp_symbol_entry * magic_snoop_task; - - struct dsp_scb_descriptor * timing_master_scb; - struct dsp_scb_descriptor * codec_out_scb; - struct dsp_scb_descriptor * codec_in_scb; - struct dsp_scb_descriptor * src_task_scb; - struct dsp_scb_descriptor * master_mix_scb; - struct dsp_scb_descriptor * rear_mix_scb; - struct dsp_scb_descriptor * record_mix_scb; - struct dsp_scb_descriptor * write_back_scb; - struct dsp_scb_descriptor * vari_decimate_scb; - struct dsp_scb_descriptor * rear_codec_out_scb; - struct dsp_scb_descriptor * clfe_codec_out_scb; - struct dsp_scb_descriptor * magic_snoop_scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + symbol_entry_t * fg_task_tree_header_code; + symbol_entry_t * task_tree_header_code; + symbol_entry_t * task_tree_thread; + symbol_entry_t * null_algorithm; + symbol_entry_t * magic_snoop_task; + + dsp_scb_descriptor_t * timing_master_scb; + dsp_scb_descriptor_t * codec_out_scb; + dsp_scb_descriptor_t * codec_in_scb; + dsp_scb_descriptor_t * src_task_scb; + dsp_scb_descriptor_t * master_mix_scb; + dsp_scb_descriptor_t * rear_mix_scb; + dsp_scb_descriptor_t * record_mix_scb; + dsp_scb_descriptor_t * write_back_scb; + dsp_scb_descriptor_t * vari_decimate_scb; + dsp_scb_descriptor_t * rear_codec_out_scb; + dsp_scb_descriptor_t * clfe_codec_out_scb; + dsp_scb_descriptor_t * magic_snoop_scb; - int fifo_addr, fifo_span, valid_slots; + int fifo_addr,fifo_span,valid_slots; - static struct dsp_spos_control_block sposcb = { + static spos_control_block_t sposcb = { /* 0 */ HFG_TREE_SCB,HFG_STACK, /* 1 */ SPOSCB_ADDR,BG_TREE_SCB_ADDR, /* 2 */ DSP_SPOS_DC,0, @@ -1124,7 +1106,7 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip) { /* create the null SCB */ - static struct dsp_generic_scb null_scb = { + static generic_scb_t null_scb = { { 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, NULL_SCB_ADDR, NULL_SCB_ADDR, @@ -1146,7 +1128,7 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip) { /* setup foreground task tree */ - static struct dsp_task_tree_control_block fg_task_tree_hdr = { + static task_tree_control_block_t fg_task_tree_hdr = { { FG_TASK_HEADER_ADDR | (DSP_SPOS_DC << 0x10), DSP_SPOS_DC_DC, DSP_SPOS_DC_DC, @@ -1222,7 +1204,7 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip) { /* setup foreground task tree */ - static struct dsp_task_tree_control_block bg_task_tree_hdr = { + static task_tree_control_block_t bg_task_tree_hdr = { { DSP_SPOS_DC_DC, DSP_SPOS_DC_DC, DSP_SPOS_DC_DC, @@ -1331,7 +1313,7 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip) if (!write_back_scb) goto _fail_end; { - static struct dsp_mix2_ostream_spb mix2_ostream_spb = { + static mix2_ostream_spb_t mix2_ostream_spb = { 0x00020000, 0x0000ffff }; @@ -1466,14 +1448,13 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip) return -EINVAL; } -static int cs46xx_dsp_async_init (struct snd_cs46xx *chip, - struct dsp_scb_descriptor * fg_entry) +static int cs46xx_dsp_async_init (cs46xx_t *chip, dsp_scb_descriptor_t * fg_entry) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_symbol_entry * s16_async_codec_input_task; - struct dsp_symbol_entry * spdifo_task; - struct dsp_symbol_entry * spdifi_task; - struct dsp_scb_descriptor * spdifi_scb_desc, * spdifo_scb_desc, * async_codec_scb_desc; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + symbol_entry_t * s16_async_codec_input_task; + symbol_entry_t * spdifo_task; + symbol_entry_t * spdifi_task; + dsp_scb_descriptor_t * spdifi_scb_desc,* spdifo_scb_desc,* async_codec_scb_desc; s16_async_codec_input_task = cs46xx_dsp_lookup_symbol(chip, "S16_ASYNCCODECINPUTTASK", SYMBOL_CODE); if (s16_async_codec_input_task == NULL) { @@ -1494,7 +1475,7 @@ static int cs46xx_dsp_async_init (struct snd_cs46xx *chip, { /* 0xBC0 */ - struct dsp_spdifoscb spdifo_scb = { + spdifoscb_t spdifo_scb = { /* 0 */ DSP_SPOS_UUUU, { /* 1 */ 0xb0, @@ -1523,7 +1504,7 @@ static int cs46xx_dsp_async_init (struct snd_cs46xx *chip, }; /* 0xBB0 */ - struct dsp_spdifiscb spdifi_scb = { + spdifiscb_t spdifi_scb = { /* 0 */ DSP_SPOS_UULO,DSP_SPOS_UUHI, /* 1 */ 0, /* 2 */ 0, @@ -1548,7 +1529,7 @@ static int cs46xx_dsp_async_init (struct snd_cs46xx *chip, }; /* 0xBA0 */ - struct dsp_async_codec_input_scb async_codec_input_scb = { + async_codec_input_scb_t async_codec_input_scb = { /* 0 */ DSP_SPOS_UUUU, /* 1 */ 0, /* 2 */ 0, @@ -1639,9 +1620,9 @@ static int cs46xx_dsp_async_init (struct snd_cs46xx *chip, } -static void cs46xx_dsp_disable_spdif_hw (struct snd_cs46xx *chip) +static void cs46xx_dsp_disable_spdif_hw (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; /* set SPDIF output FIFO slot */ snd_cs46xx_pokeBA0(chip, BA0_ASER_FADDR, 0); @@ -1660,9 +1641,9 @@ static void cs46xx_dsp_disable_spdif_hw (struct snd_cs46xx *chip) ins->spdif_status_out &= ~DSP_SPDIF_STATUS_HW_ENABLED; } -int cs46xx_dsp_enable_spdif_hw (struct snd_cs46xx *chip) +int cs46xx_dsp_enable_spdif_hw (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; /* if hw-ctrl already enabled, turn off to reset logic ... */ cs46xx_dsp_disable_spdif_hw (chip); @@ -1683,9 +1664,9 @@ int cs46xx_dsp_enable_spdif_hw (struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_enable_spdif_in (struct snd_cs46xx *chip) +int cs46xx_dsp_enable_spdif_in (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; /* turn on amplifier */ chip->active_ctrl(chip, 1); @@ -1743,9 +1724,9 @@ int cs46xx_dsp_enable_spdif_in (struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_disable_spdif_in (struct snd_cs46xx *chip) +int cs46xx_dsp_disable_spdif_in (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert (ins->asynch_rx_scb != NULL, return -EINVAL); snd_assert (ins->spdif_in_src != NULL,return -EINVAL); @@ -1769,9 +1750,9 @@ int cs46xx_dsp_disable_spdif_in (struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_enable_pcm_capture (struct snd_cs46xx *chip) +int cs46xx_dsp_enable_pcm_capture (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert (ins->pcm_input == NULL,return -EINVAL); snd_assert (ins->ref_snoop_scb != NULL,return -EINVAL); @@ -1784,9 +1765,9 @@ int cs46xx_dsp_enable_pcm_capture (struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_disable_pcm_capture (struct snd_cs46xx *chip) +int cs46xx_dsp_disable_pcm_capture (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert (ins->pcm_input != NULL,return -EINVAL); @@ -1798,9 +1779,9 @@ int cs46xx_dsp_disable_pcm_capture (struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_enable_adc_capture (struct snd_cs46xx *chip) +int cs46xx_dsp_enable_adc_capture (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert (ins->adc_input == NULL,return -EINVAL); snd_assert (ins->codec_in_scb != NULL,return -EINVAL); @@ -1813,9 +1794,9 @@ int cs46xx_dsp_enable_adc_capture (struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_disable_adc_capture (struct snd_cs46xx *chip) +int cs46xx_dsp_disable_adc_capture (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert (ins->adc_input != NULL,return -EINVAL); @@ -1827,7 +1808,7 @@ int cs46xx_dsp_disable_adc_capture (struct snd_cs46xx *chip) return 0; } -int cs46xx_poke_via_dsp (struct snd_cs46xx *chip, u32 address, u32 data) +int cs46xx_poke_via_dsp (cs46xx_t *chip,u32 address,u32 data) { u32 temp; int i; @@ -1864,10 +1845,10 @@ int cs46xx_poke_via_dsp (struct snd_cs46xx *chip, u32 address, u32 data) return 0; } -int cs46xx_dsp_set_dac_volume (struct snd_cs46xx * chip, u16 left, u16 right) +int cs46xx_dsp_set_dac_volume (cs46xx_t * chip,u16 left,u16 right) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; down(&chip->spos_mutex); @@ -1893,9 +1874,8 @@ int cs46xx_dsp_set_dac_volume (struct snd_cs46xx * chip, u16 left, u16 right) return 0; } -int cs46xx_dsp_set_iec958_volume (struct snd_cs46xx * chip, u16 left, u16 right) -{ - struct dsp_spos_instance * ins = chip->dsp_spos_instance; +int cs46xx_dsp_set_iec958_volume (cs46xx_t * chip,u16 left,u16 right) { + dsp_spos_instance_t * ins = chip->dsp_spos_instance; down(&chip->spos_mutex); diff --git a/trunk/sound/pci/cs46xx/dsp_spos.h b/trunk/sound/pci/cs46xx/dsp_spos.h index 0d246bca4184..90871bf9762f 100644 --- a/trunk/sound/pci/cs46xx/dsp_spos.h +++ b/trunk/sound/pci/cs46xx/dsp_spos.h @@ -43,7 +43,7 @@ /* this instruction types needs to be reallocated when load code into DSP */ -enum wide_opcode { +typedef enum { WIDE_FOR_BEGIN_LOOP = 0x20, WIDE_FOR_BEGIN_LOOP2, @@ -58,7 +58,7 @@ enum wide_opcode { WIDE_TBEQ_COND_CALL1_ADDR, WIDE_TBEQ_NCOND_GOTOI_ADDR, WIDE_TBEQ_NCOND_CALL1_ADDR, -}; +} wide_opcode_t; /* SAMPLE segment */ #define VARI_DECIMATE_BUF1 0x0000 @@ -186,8 +186,7 @@ enum wide_opcode { #define SP_SPDOUT_CONTROL 0x804D #define SP_SPDOUT_CSUV 0x808E -static inline u8 _wrap_all_bits (u8 val) -{ +static inline u8 _wrap_all_bits (u8 val) { u8 wrapped; /* wrap all 8 bits */ @@ -202,10 +201,11 @@ static inline u8 _wrap_all_bits (u8 val) ((val & 0x80) >> 7); return wrapped; + } -static inline void cs46xx_dsp_spos_update_scb (struct snd_cs46xx * chip, - struct dsp_scb_descriptor * scb) + +static inline void cs46xx_dsp_spos_update_scb (cs46xx_t * chip,dsp_scb_descriptor_t * scb) { /* update nextSCB and subListPtr in SCB */ snd_cs46xx_poke(chip, @@ -214,10 +214,8 @@ static inline void cs46xx_dsp_spos_update_scb (struct snd_cs46xx * chip, (scb->next_scb_ptr->address)); } -static inline void cs46xx_dsp_scb_set_volume (struct snd_cs46xx * chip, - struct dsp_scb_descriptor * scb, - u16 left, u16 right) -{ +static inline void cs46xx_dsp_scb_set_volume (cs46xx_t * chip,dsp_scb_descriptor_t * scb, + u16 left,u16 right) { unsigned int val = ((0xffff - left) << 16 | (0xffff - right)); snd_cs46xx_poke(chip, (scb->address + SCBVolumeCtrl) << 2, val); diff --git a/trunk/sound/pci/cs46xx/dsp_spos_scb_lib.c b/trunk/sound/pci/cs46xx/dsp_spos_scb_lib.c index 509aa2b63331..92849e1340bb 100644 --- a/trunk/sound/pci/cs46xx/dsp_spos_scb_lib.c +++ b/trunk/sound/pci/cs46xx/dsp_spos_scb_lib.c @@ -36,14 +36,14 @@ #include "cs46xx_lib.h" #include "dsp_spos.h" -struct proc_scb_info { - struct dsp_scb_descriptor * scb_desc; - struct snd_cs46xx *chip; -}; +typedef struct _proc_scb_info_t { + dsp_scb_descriptor_t * scb_desc; + cs46xx_t *chip; +} proc_scb_info_t; -static void remove_symbol (struct snd_cs46xx * chip, struct dsp_symbol_entry * symbol) +static void remove_symbol (cs46xx_t * chip,symbol_entry_t * symbol) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; int symbol_index = (int)(symbol - ins->symbol_table.symbols); snd_assert(ins->symbol_table.nsymbols > 0,return); @@ -64,14 +64,12 @@ static void remove_symbol (struct snd_cs46xx * chip, struct dsp_symbol_entry * s } -#ifdef CONFIG_PROC_FS -static void cs46xx_dsp_proc_scb_info_read (struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void cs46xx_dsp_proc_scb_info_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) { - struct proc_scb_info * scb_info = entry->private_data; - struct dsp_scb_descriptor * scb = scb_info->scb_desc; - struct dsp_spos_instance * ins; - struct snd_cs46xx *chip = scb_info->chip; + proc_scb_info_t * scb_info = (proc_scb_info_t *)entry->private_data; + dsp_scb_descriptor_t * scb = scb_info->scb_desc; + dsp_spos_instance_t * ins; + cs46xx_t *chip = scb_info->chip; int j,col; void __iomem *dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET; @@ -107,11 +105,10 @@ static void cs46xx_dsp_proc_scb_info_read (struct snd_info_entry *entry, snd_iprintf(buffer,"index [%d] ref_count [%d]\n",scb->index,scb->ref_count); up(&chip->spos_mutex); } -#endif -static void _dsp_unlink_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor * scb) +static void _dsp_unlink_scb (cs46xx_t *chip,dsp_scb_descriptor_t * scb) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; unsigned long flags; if ( scb->parent_scb_ptr ) { @@ -163,8 +160,7 @@ static void _dsp_unlink_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor } } -static void _dsp_clear_sample_buffer (struct snd_cs46xx *chip, u32 sample_buffer_addr, - int dword_count) +static void _dsp_clear_sample_buffer (cs46xx_t *chip, u32 sample_buffer_addr, int dword_count) { void __iomem *dst = chip->region.idx[2].remap_addr + sample_buffer_addr; int i; @@ -175,9 +171,9 @@ static void _dsp_clear_sample_buffer (struct snd_cs46xx *chip, u32 sample_buffer } } -void cs46xx_dsp_remove_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor * scb) +void cs46xx_dsp_remove_scb (cs46xx_t *chip, dsp_scb_descriptor_t * scb) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; /* check integrety */ snd_assert ( (scb->index >= 0 && @@ -222,11 +218,10 @@ void cs46xx_dsp_remove_scb (struct snd_cs46xx *chip, struct dsp_scb_descriptor * } -#ifdef CONFIG_PROC_FS -void cs46xx_dsp_proc_free_scb_desc (struct dsp_scb_descriptor * scb) +void cs46xx_dsp_proc_free_scb_desc (dsp_scb_descriptor_t * scb) { if (scb->proc_info) { - struct proc_scb_info * scb_info = scb->proc_info->private_data; + proc_scb_info_t * scb_info = (proc_scb_info_t *)scb->proc_info->private_data; snd_printdd("cs46xx_dsp_proc_free_scb_desc: freeing %s\n",scb->scb_name); @@ -238,12 +233,11 @@ void cs46xx_dsp_proc_free_scb_desc (struct dsp_scb_descriptor * scb) } } -void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip, - struct dsp_scb_descriptor * scb) +void cs46xx_dsp_proc_register_scb_desc (cs46xx_t *chip,dsp_scb_descriptor_t * scb) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct snd_info_entry * entry; - struct proc_scb_info * scb_info; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + snd_info_entry_t * entry; + proc_scb_info_t * scb_info; /* register to proc */ if (ins->snd_card != NULL && ins->proc_dsp_dir != NULL && @@ -251,7 +245,7 @@ void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip, if ((entry = snd_info_create_card_entry(ins->snd_card, scb->scb_name, ins->proc_dsp_dir)) != NULL) { - scb_info = kmalloc(sizeof(struct proc_scb_info), GFP_KERNEL); + scb_info = kmalloc(sizeof(proc_scb_info_t), GFP_KERNEL); if (!scb_info) { snd_info_free_entry(entry); entry = NULL; @@ -278,16 +272,15 @@ void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip, scb->proc_info = entry; } } -#endif /* CONFIG_PROC_FS */ -static struct dsp_scb_descriptor * -_dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u32 dest, - struct dsp_symbol_entry * task_entry, - struct dsp_scb_descriptor * parent_scb, +static dsp_scb_descriptor_t * +_dsp_create_generic_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest, + symbol_entry_t * task_entry, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; unsigned long flags; @@ -349,13 +342,13 @@ _dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, u return scb; } -static struct dsp_scb_descriptor * -cs46xx_dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, - u32 dest, char * task_entry_name, - struct dsp_scb_descriptor * parent_scb, +static dsp_scb_descriptor_t * +cs46xx_dsp_create_generic_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest, + char * task_entry_name, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_symbol_entry * task_entry; + symbol_entry_t * task_entry; task_entry = cs46xx_dsp_lookup_symbol (chip,task_entry_name, SYMBOL_CODE); @@ -369,12 +362,12 @@ cs46xx_dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_d parent_scb,scb_child_type); } -struct dsp_scb_descriptor * -cs46xx_dsp_create_timing_master_scb (struct snd_cs46xx *chip) +dsp_scb_descriptor_t * +cs46xx_dsp_create_timing_master_scb (cs46xx_t *chip) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_timing_master_scb timing_master_scb = { + timing_master_scb_t timing_master_scb = { { 0, 0, 0, @@ -403,15 +396,16 @@ cs46xx_dsp_create_timing_master_scb (struct snd_cs46xx *chip) } -struct dsp_scb_descriptor * -cs46xx_dsp_create_codec_out_scb(struct snd_cs46xx * chip, char * codec_name, - u16 channel_disp, u16 fifo_addr, u16 child_scb_addr, - u32 dest, struct dsp_scb_descriptor * parent_scb, +dsp_scb_descriptor_t * +cs46xx_dsp_create_codec_out_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 child_scb_addr, + u32 dest,dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_codec_output_scb codec_out_scb = { + codec_output_scb_t codec_out_scb = { { 0, 0, 0, @@ -441,15 +435,16 @@ cs46xx_dsp_create_codec_out_scb(struct snd_cs46xx * chip, char * codec_name, return scb; } -struct dsp_scb_descriptor * -cs46xx_dsp_create_codec_in_scb(struct snd_cs46xx * chip, char * codec_name, - u16 channel_disp, u16 fifo_addr, u16 sample_buffer_addr, - u32 dest, struct dsp_scb_descriptor * parent_scb, - int scb_child_type) +dsp_scb_descriptor_t * +cs46xx_dsp_create_codec_in_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 sample_buffer_addr, + u32 dest,dsp_scb_descriptor_t * parent_scb, + int scb_child_type) { - struct dsp_scb_descriptor * scb; - struct dsp_codec_input_scb codec_input_scb = { + dsp_scb_descriptor_t * scb; + codec_input_scb_t codec_input_scb = { { 0, 0, 0, @@ -486,17 +481,17 @@ cs46xx_dsp_create_codec_in_scb(struct snd_cs46xx * chip, char * codec_name, } -static struct dsp_scb_descriptor * -cs46xx_dsp_create_pcm_reader_scb(struct snd_cs46xx * chip, char * scb_name, - u16 sample_buffer_addr, u32 dest, +static dsp_scb_descriptor_t * +cs46xx_dsp_create_pcm_reader_scb(cs46xx_t * chip,char * scb_name, + u16 sample_buffer_addr,u32 dest, int virtual_channel, u32 playback_hw_addr, - struct dsp_scb_descriptor * parent_scb, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; - struct dsp_generic_scb pcm_reader_scb = { + generic_scb_t pcm_reader_scb = { /* Play DMA Task xfers data from host buffer to SP buffer @@ -589,18 +584,18 @@ cs46xx_dsp_create_pcm_reader_scb(struct snd_cs46xx * chip, char * scb_name, #define GOF_PER_SEC 200 -struct dsp_scb_descriptor * -cs46xx_dsp_create_src_task_scb(struct snd_cs46xx * chip, char * scb_name, +dsp_scb_descriptor_t * +cs46xx_dsp_create_src_task_scb(cs46xx_t * chip,char * scb_name, int rate, u16 src_buffer_addr, - u16 src_delay_buffer_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, + u16 src_delay_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, int scb_child_type, int pass_through) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; unsigned int tmp1, tmp2; unsigned int phiIncr; unsigned int correctionPerGOF, correctionPerSec; @@ -637,7 +632,7 @@ cs46xx_dsp_create_src_task_scb(struct snd_cs46xx * chip, char * scb_name, correctionPerSec = tmp1; { - struct dsp_src_task_scb src_task_scb = { + src_task_scb_t src_task_scb = { 0x0028,0x00c8, 0x5555,0x0000, 0x0000,0x0000, @@ -693,14 +688,14 @@ cs46xx_dsp_create_src_task_scb(struct snd_cs46xx * chip, char * scb_name, } #if 0 /* not used */ -struct dsp_scb_descriptor * -cs46xx_dsp_create_filter_scb(struct snd_cs46xx * chip, char * scb_name, - u16 buffer_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, +dsp_scb_descriptor_t * +cs46xx_dsp_create_filter_scb(cs46xx_t * chip,char * scb_name, + u16 buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_filter_scb filter_scb = { + filter_scb_t filter_scb = { .a0_right = 0x41a9, .a0_left = 0x41a9, .a1_right = 0xb8e4, @@ -743,15 +738,15 @@ cs46xx_dsp_create_filter_scb(struct snd_cs46xx * chip, char * scb_name, } #endif /* not used */ -struct dsp_scb_descriptor * -cs46xx_dsp_create_mix_only_scb(struct snd_cs46xx * chip, char * scb_name, - u16 mix_buffer_addr, u32 dest, - struct dsp_scb_descriptor * parent_scb, +dsp_scb_descriptor_t * +cs46xx_dsp_create_mix_only_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_mix_only_scb master_mix_scb = { + mix_only_scb_t master_mix_scb = { /* 0 */ { 0, /* 1 */ 0, /* 2 */ mix_buffer_addr, @@ -783,15 +778,15 @@ cs46xx_dsp_create_mix_only_scb(struct snd_cs46xx * chip, char * scb_name, } -struct dsp_scb_descriptor * -cs46xx_dsp_create_mix_to_ostream_scb(struct snd_cs46xx * chip, char * scb_name, - u16 mix_buffer_addr, u16 writeback_spb, u32 dest, - struct dsp_scb_descriptor * parent_scb, +dsp_scb_descriptor_t * +cs46xx_dsp_create_mix_to_ostream_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u16 writeback_spb,u32 dest, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_mix2_ostream_scb mix2_ostream_scb = { + mix2_ostream_scb_t mix2_ostream_scb = { /* Basic (non scatter/gather) DMA requestor (4 ints) */ { DMA_RQ_C1_SOURCE_MOD64 + @@ -837,18 +832,18 @@ cs46xx_dsp_create_mix_to_ostream_scb(struct snd_cs46xx * chip, char * scb_name, } -struct dsp_scb_descriptor * -cs46xx_dsp_create_vari_decimate_scb(struct snd_cs46xx * chip,char * scb_name, +dsp_scb_descriptor_t * +cs46xx_dsp_create_vari_decimate_scb(cs46xx_t * chip,char * scb_name, u16 vari_buffer_addr0, u16 vari_buffer_addr1, u32 dest, - struct dsp_scb_descriptor * parent_scb, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_vari_decimate_scb vari_decimate_scb = { + vari_decimate_scb_t vari_decimate_scb = { 0x0028,0x00c8, 0x5555,0x0000, 0x0000,0x0000, @@ -881,17 +876,17 @@ cs46xx_dsp_create_vari_decimate_scb(struct snd_cs46xx * chip,char * scb_name, } -static struct dsp_scb_descriptor * -cs46xx_dsp_create_pcm_serial_input_scb(struct snd_cs46xx * chip, char * scb_name, u32 dest, - struct dsp_scb_descriptor * input_scb, - struct dsp_scb_descriptor * parent_scb, +static dsp_scb_descriptor_t * +cs46xx_dsp_create_pcm_serial_input_scb(cs46xx_t * chip,char * scb_name,u32 dest, + dsp_scb_descriptor_t * input_scb, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_pcm_serial_input_scb pcm_serial_input_scb = { + pcm_serial_input_scb_t pcm_serial_input_scb = { { 0, 0, 0, @@ -924,17 +919,17 @@ cs46xx_dsp_create_pcm_serial_input_scb(struct snd_cs46xx * chip, char * scb_name } -static struct dsp_scb_descriptor * -cs46xx_dsp_create_asynch_fg_tx_scb(struct snd_cs46xx * chip, char * scb_name, u32 dest, +static dsp_scb_descriptor_t * +cs46xx_dsp_create_asynch_fg_tx_scb(cs46xx_t * chip,char * scb_name,u32 dest, u16 hfg_scb_address, u16 asynch_buffer_address, - struct dsp_scb_descriptor * parent_scb, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_asynch_fg_tx_scb asynch_fg_tx_scb = { + asynch_fg_tx_scb_t asynch_fg_tx_scb = { 0xfc00,0x03ff, /* Prototype sample buffer size of 256 dwords */ 0x0058,0x0028, /* Min Delta 7 dwords == 28 bytes */ /* : Max delta 25 dwords == 100 bytes */ @@ -971,17 +966,17 @@ cs46xx_dsp_create_asynch_fg_tx_scb(struct snd_cs46xx * chip, char * scb_name, u3 } -struct dsp_scb_descriptor * -cs46xx_dsp_create_asynch_fg_rx_scb(struct snd_cs46xx * chip, char * scb_name, u32 dest, +dsp_scb_descriptor_t * +cs46xx_dsp_create_asynch_fg_rx_scb(cs46xx_t * chip,char * scb_name,u32 dest, u16 hfg_scb_address, u16 asynch_buffer_address, - struct dsp_scb_descriptor * parent_scb, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; - struct dsp_asynch_fg_rx_scb asynch_fg_rx_scb = { + asynch_fg_rx_scb_t asynch_fg_rx_scb = { 0xfe00,0x01ff, /* Prototype sample buffer size of 128 dwords */ 0x0064,0x001c, /* Min Delta 7 dwords == 28 bytes */ /* : Max delta 25 dwords == 100 bytes */ @@ -1021,17 +1016,17 @@ cs46xx_dsp_create_asynch_fg_rx_scb(struct snd_cs46xx * chip, char * scb_name, u3 #if 0 /* not used */ -struct dsp_scb_descriptor * -cs46xx_dsp_create_output_snoop_scb(struct snd_cs46xx * chip, char * scb_name, u32 dest, +dsp_scb_descriptor_t * +cs46xx_dsp_create_output_snoop_scb(cs46xx_t * chip,char * scb_name,u32 dest, u16 snoop_buffer_address, - struct dsp_scb_descriptor * snoop_scb, - struct dsp_scb_descriptor * parent_scb, + dsp_scb_descriptor_t * snoop_scb, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_output_snoop_scb output_snoop_scb = { + output_snoop_scb_t output_snoop_scb = { { 0, /* not used. Zero */ 0, 0, @@ -1063,14 +1058,14 @@ cs46xx_dsp_create_output_snoop_scb(struct snd_cs46xx * chip, char * scb_name, u3 #endif /* not used */ -struct dsp_scb_descriptor * -cs46xx_dsp_create_spio_write_scb(struct snd_cs46xx * chip, char * scb_name, u32 dest, - struct dsp_scb_descriptor * parent_scb, +dsp_scb_descriptor_t * +cs46xx_dsp_create_spio_write_scb(cs46xx_t * chip,char * scb_name,u32 dest, + dsp_scb_descriptor_t * parent_scb, int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_spio_write_scb spio_write_scb = { + spio_write_scb_t spio_write_scb = { 0,0, /* SPIOWAddress2:SPIOWAddress1; */ 0, /* SPIOWData1; */ 0, /* SPIOWData2; */ @@ -1099,16 +1094,15 @@ cs46xx_dsp_create_spio_write_scb(struct snd_cs46xx * chip, char * scb_name, u32 return scb; } -struct dsp_scb_descriptor * -cs46xx_dsp_create_magic_snoop_scb(struct snd_cs46xx * chip, char * scb_name, u32 dest, - u16 snoop_buffer_address, - struct dsp_scb_descriptor * snoop_scb, - struct dsp_scb_descriptor * parent_scb, - int scb_child_type) +dsp_scb_descriptor_t * cs46xx_dsp_create_magic_snoop_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 snoop_buffer_address, + dsp_scb_descriptor_t * snoop_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) { - struct dsp_scb_descriptor * scb; + dsp_scb_descriptor_t * scb; - struct dsp_magic_snoop_task magic_snoop_scb = { + magic_snoop_task_t magic_snoop_scb = { /* 0 */ 0, /* i0 */ /* 1 */ 0, /* i1 */ /* 2 */ snoop_buffer_address << 0x10, @@ -1135,11 +1129,10 @@ cs46xx_dsp_create_magic_snoop_scb(struct snd_cs46xx * chip, char * scb_name, u32 return scb; } -static struct dsp_scb_descriptor * -find_next_free_scb (struct snd_cs46xx * chip, struct dsp_scb_descriptor * from) +static dsp_scb_descriptor_t * find_next_free_scb (cs46xx_t * chip,dsp_scb_descriptor_t * from) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * scb = from; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb = from; while (scb->next_scb_ptr != ins->the_null_scb) { snd_assert (scb->next_scb_ptr != NULL, return NULL); @@ -1219,19 +1212,18 @@ static u32 src_delay_buffer_addr[DSP_MAX_SRC_NR] = { 0x2B00 }; -struct dsp_pcm_channel_descriptor * -cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip, - u32 sample_rate, void * private_data, - u32 hw_dma_addr, - int pcm_channel_id) +pcm_channel_descriptor_t * cs46xx_dsp_create_pcm_channel (cs46xx_t * chip, + u32 sample_rate, void * private_data, + u32 hw_dma_addr, + int pcm_channel_id) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * src_scb = NULL, * pcm_scb, * mixer_scb = NULL; - struct dsp_scb_descriptor * src_parent_scb = NULL; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * src_scb = NULL,* pcm_scb, * mixer_scb = NULL; + dsp_scb_descriptor_t * src_parent_scb = NULL; - /* struct dsp_scb_descriptor * pcm_parent_scb; */ + /* dsp_scb_descriptor_t * pcm_parent_scb; */ char scb_name[DSP_MAX_SCB_NAME]; - int i, pcm_index = -1, insert_point, src_index = -1, pass_through = 0; + int i,pcm_index = -1, insert_point, src_index = -1,pass_through = 0; unsigned long flags; switch (pcm_channel_id) { @@ -1379,8 +1371,8 @@ cs46xx_dsp_create_pcm_channel (struct snd_cs46xx * chip, return (ins->pcm_channels + pcm_index); } -int cs46xx_dsp_pcm_channel_set_period (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel, +int cs46xx_dsp_pcm_channel_set_period (cs46xx_t * chip, + pcm_channel_descriptor_t * pcm_channel, int period_size) { u32 temp = snd_cs46xx_peek (chip,pcm_channel->pcm_reader_scb->address << 2); @@ -1418,7 +1410,7 @@ int cs46xx_dsp_pcm_channel_set_period (struct snd_cs46xx * chip, return 0; } -int cs46xx_dsp_pcm_ostream_set_period (struct snd_cs46xx * chip, +int cs46xx_dsp_pcm_ostream_set_period (cs46xx_t * chip, int period_size) { u32 temp = snd_cs46xx_peek (chip,WRITEBACK_SCB_ADDR << 2); @@ -1456,10 +1448,9 @@ int cs46xx_dsp_pcm_ostream_set_period (struct snd_cs46xx * chip, return 0; } -void cs46xx_dsp_destroy_pcm_channel (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel) +void cs46xx_dsp_destroy_pcm_channel (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; unsigned long flags; snd_assert(pcm_channel->active, return ); @@ -1487,10 +1478,9 @@ void cs46xx_dsp_destroy_pcm_channel (struct snd_cs46xx * chip, } } -int cs46xx_dsp_pcm_unlink (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel) +int cs46xx_dsp_pcm_unlink (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; unsigned long flags; snd_assert(pcm_channel->active,return -EIO); @@ -1513,12 +1503,11 @@ int cs46xx_dsp_pcm_unlink (struct snd_cs46xx * chip, return 0; } -int cs46xx_dsp_pcm_link (struct snd_cs46xx * chip, - struct dsp_pcm_channel_descriptor * pcm_channel) +int cs46xx_dsp_pcm_link (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * parent_scb; - struct dsp_scb_descriptor * src_scb = pcm_channel->src_scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * parent_scb; + dsp_scb_descriptor_t * src_scb = pcm_channel->src_scb; unsigned long flags; spin_lock(&pcm_channel->src_scb->lock); @@ -1555,13 +1544,12 @@ int cs46xx_dsp_pcm_link (struct snd_cs46xx * chip, return 0; } -struct dsp_scb_descriptor * -cs46xx_add_record_source (struct snd_cs46xx *chip, struct dsp_scb_descriptor * source, - u16 addr, char * scb_name) +dsp_scb_descriptor_t * cs46xx_add_record_source (cs46xx_t *chip,dsp_scb_descriptor_t * source, + u16 addr,char * scb_name) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * parent; - struct dsp_scb_descriptor * pcm_input; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * parent; + dsp_scb_descriptor_t * pcm_input; int insert_point; snd_assert (ins->record_mixer_scb != NULL,return NULL); @@ -1581,7 +1569,7 @@ cs46xx_add_record_source (struct snd_cs46xx *chip, struct dsp_scb_descriptor * s return pcm_input; } -int cs46xx_src_unlink(struct snd_cs46xx *chip, struct dsp_scb_descriptor * src) +int cs46xx_src_unlink(cs46xx_t *chip,dsp_scb_descriptor_t * src) { snd_assert (src->parent_scb_ptr != NULL, return -EINVAL ); @@ -1593,10 +1581,10 @@ int cs46xx_src_unlink(struct snd_cs46xx *chip, struct dsp_scb_descriptor * src) return 0; } -int cs46xx_src_link(struct snd_cs46xx *chip, struct dsp_scb_descriptor * src) +int cs46xx_src_link(cs46xx_t *chip,dsp_scb_descriptor_t * src) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; - struct dsp_scb_descriptor * parent_scb; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * parent_scb; snd_assert (src->parent_scb_ptr == NULL, return -EINVAL ); snd_assert(ins->master_mix_scb !=NULL, return -EINVAL ); @@ -1617,9 +1605,9 @@ int cs46xx_src_link(struct snd_cs46xx *chip, struct dsp_scb_descriptor * src) return 0; } -int cs46xx_dsp_enable_spdif_out (struct snd_cs46xx *chip) +int cs46xx_dsp_enable_spdif_out (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; if ( ! (ins->spdif_status_out & DSP_SPDIF_STATUS_HW_ENABLED) ) { cs46xx_dsp_enable_spdif_hw (chip); @@ -1665,9 +1653,9 @@ int cs46xx_dsp_enable_spdif_out (struct snd_cs46xx *chip) return 0; } -int cs46xx_dsp_disable_spdif_out (struct snd_cs46xx *chip) +int cs46xx_dsp_disable_spdif_out (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; /* dont touch anything if SPDIF is open */ if ( ins->spdif_status_out & DSP_SPDIF_STATUS_PLAYBACK_OPEN) { @@ -1697,9 +1685,9 @@ int cs46xx_dsp_disable_spdif_out (struct snd_cs46xx *chip) return 0; } -int cs46xx_iec958_pre_open (struct snd_cs46xx *chip) +int cs46xx_iec958_pre_open (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; if ( ins->spdif_status_out & DSP_SPDIF_STATUS_OUTPUT_ENABLED ) { /* remove AsynchFGTxSCB and and PCMSerialInput_II */ @@ -1730,9 +1718,9 @@ int cs46xx_iec958_pre_open (struct snd_cs46xx *chip) return 0; } -int cs46xx_iec958_post_close (struct snd_cs46xx *chip) +int cs46xx_iec958_post_close (cs46xx_t *chip) { - struct dsp_spos_instance * ins = chip->dsp_spos_instance; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; snd_assert (ins->asynch_tx_scb != NULL, return -EINVAL); diff --git a/trunk/sound/pci/cs46xx/imgs/cwc4630.h b/trunk/sound/pci/cs46xx/imgs/cwc4630.h index 37c4f1318dc5..8bed07f9996e 100644 --- a/trunk/sound/pci/cs46xx/imgs/cwc4630.h +++ b/trunk/sound/pci/cs46xx/imgs/cwc4630.h @@ -3,7 +3,7 @@ #ifndef __HEADER_cwc4630_H__ #define __HEADER_cwc4630_H__ -static struct dsp_symbol_entry cwc4630_symbols[] = { +static symbol_entry_t cwc4630_symbols[] = { { 0x0000, "BEGINADDRESS",0x00 }, { 0x8000, "EXECCHILD",0x03 }, { 0x8001, "EXECCHILD_98",0x03 }, @@ -302,12 +302,12 @@ static u32 cwc4630_parameter[] = { }; /* #PARAMETER_END */ -static struct dsp_segment_desc cwc4630_segments[] = { +static segment_desc_t cwc4630_segments[] = { { SEGTYPE_SP_PROGRAM, 0x00000000, 0x00000328, cwc4630_code }, { SEGTYPE_SP_PARAMETER, 0x00000000, 0x00000080, cwc4630_parameter }, }; -static struct dsp_module_desc cwc4630_module = { +static dsp_module_desc_t cwc4630_module = { "cwc4630", { 38, diff --git a/trunk/sound/pci/cs46xx/imgs/cwcasync.h b/trunk/sound/pci/cs46xx/imgs/cwcasync.h index 70e63e13c2b3..e01a7b66c4ff 100644 --- a/trunk/sound/pci/cs46xx/imgs/cwcasync.h +++ b/trunk/sound/pci/cs46xx/imgs/cwcasync.h @@ -3,7 +3,7 @@ #ifndef __HEADER_cwcasync_H__ #define __HEADER_cwcasync_H__ -static struct dsp_symbol_entry cwcasync_symbols[] = { +static symbol_entry_t cwcasync_symbols[] = { { 0x8000, "EXECCHILD",0x03 }, { 0x8001, "EXECCHILD_98",0x03 }, { 0x8003, "EXECCHILD_PUSH1IND",0x03 }, @@ -159,11 +159,11 @@ static u32 cwcasync_code[] = { }; /* #CODE_END */ -static struct dsp_segment_desc cwcasync_segments[] = { +static segment_desc_t cwcasync_segments[] = { { SEGTYPE_SP_PROGRAM, 0x00000000, 0x000001b6, cwcasync_code }, }; -static struct dsp_module_desc cwcasync_module = { +static dsp_module_desc_t cwcasync_module = { "cwcasync", { 32, diff --git a/trunk/sound/pci/cs46xx/imgs/cwcbinhack.h b/trunk/sound/pci/cs46xx/imgs/cwcbinhack.h index f4d93689cd49..436b38bd246c 100644 --- a/trunk/sound/pci/cs46xx/imgs/cwcbinhack.h +++ b/trunk/sound/pci/cs46xx/imgs/cwcbinhack.h @@ -4,7 +4,7 @@ #ifndef __HEADER_cwcbinhack_H__ #define __HEADER_cwcbinhack_H__ -static struct dsp_symbol_entry cwcbinhack_symbols[] = { +static symbol_entry_t cwcbinhack_symbols[] = { { 0x02c8, "OVERLAYBEGINADDRESS",0x00 }, { 0x02c8, "MAGICSNOOPTASK",0x03 }, { 0x0308, "#CODE_END",0x00 }, @@ -31,11 +31,11 @@ static u32 cwcbinhack_code[] = { }; /* #CODE_END */ -static struct dsp_segment_desc cwcbinhack_segments[] = { +static segment_desc_t cwcbinhack_segments[] = { { SEGTYPE_SP_PROGRAM, 0x00000000, 64, cwcbinhack_code }, }; -static struct dsp_module_desc cwcbinhack_module = { +static dsp_module_desc_t cwcbinhack_module = { "cwcbinhack", { 3, diff --git a/trunk/sound/pci/cs46xx/imgs/cwcdma.h b/trunk/sound/pci/cs46xx/imgs/cwcdma.h index 7ff0d4587161..92860435beed 100644 --- a/trunk/sound/pci/cs46xx/imgs/cwcdma.h +++ b/trunk/sound/pci/cs46xx/imgs/cwcdma.h @@ -3,7 +3,7 @@ #ifndef __HEADER_cwcdma_H__ #define __HEADER_cwcdma_H__ -static struct dsp_symbol_entry cwcdma_symbols[] = { +static symbol_entry_t cwcdma_symbols[] = { { 0x8000, "EXECCHILD",0x03 }, { 0x8001, "EXECCHILD_98",0x03 }, { 0x8003, "EXECCHILD_PUSH1IND",0x03 }, @@ -51,11 +51,11 @@ static u32 cwcdma_code[] = { /* #CODE_END */ -static struct dsp_segment_desc cwcdma_segments[] = { +static segment_desc_t cwcdma_segments[] = { { SEGTYPE_SP_PROGRAM, 0x00000000, 0x00000030, cwcdma_code }, }; -static struct dsp_module_desc cwcdma_module = { +static dsp_module_desc_t cwcdma_module = { "cwcdma", { 27, diff --git a/trunk/sound/pci/cs46xx/imgs/cwcemb80.h b/trunk/sound/pci/cs46xx/imgs/cwcemb80.h index a64c6ff9983a..4b13551eae41 100644 --- a/trunk/sound/pci/cs46xx/imgs/cwcemb80.h +++ b/trunk/sound/pci/cs46xx/imgs/cwcemb80.h @@ -3,7 +3,7 @@ #ifndef __HEADER_cwcemb80_H__ #define __HEADER_cwcemb80_H__ -static struct dsp_symbol_entry cwcemb80_symbols[] = { +static symbol_entry_t cwcemb80_symbols[] = { { 0x0000, "BEGINADDRESS",0x00 }, { 0x8000, "EXECCHILD",0x03 }, { 0x8001, "EXECCHILD_98",0x03 }, @@ -1588,13 +1588,13 @@ static u32 cwcemb80_sample[] = { }; /* #SAMPLE_END */ -static struct dsp_segment_desc cwcemb80_segments[] = { +static segment_desc_t cwcemb80_segments[] = { { SEGTYPE_SP_PROGRAM, 0x00000000, 0x0000031c, cwcemb80_code }, { SEGTYPE_SP_PARAMETER, 0x00000000, 0x00000697, cwcemb80_parameter }, { SEGTYPE_SP_SAMPLE, 0x00000000, 0x00000e00, cwcemb80_sample }, }; -static struct dsp_module_desc cwcemb80_module = { +static dsp_module_desc_t cwcemb80_module = { "cwcemb80", { 38, diff --git a/trunk/sound/pci/cs46xx/imgs/cwcsnoop.h b/trunk/sound/pci/cs46xx/imgs/cwcsnoop.h index 6929d0a5a3f3..be1162bbcb45 100644 --- a/trunk/sound/pci/cs46xx/imgs/cwcsnoop.h +++ b/trunk/sound/pci/cs46xx/imgs/cwcsnoop.h @@ -3,7 +3,7 @@ #ifndef __HEADER_cwcsnoop_H__ #define __HEADER_cwcsnoop_H__ -static struct dsp_symbol_entry cwcsnoop_symbols[] = { +static symbol_entry_t cwcsnoop_symbols[] = { { 0x0500, "OVERLAYBEGINADDRESS",0x00 }, { 0x0500, "OUTPUTSNOOP",0x03 }, { 0x051f, "#CODE_END",0x00 }, @@ -29,11 +29,11 @@ static u32 cwcsnoop_code[] = { }; /* #CODE_END */ -static struct dsp_segment_desc cwcsnoop_segments[] = { +static segment_desc_t cwcsnoop_segments[] = { { SEGTYPE_SP_PROGRAM, 0x00000000, 0x0000003e, cwcsnoop_code }, }; -static struct dsp_module_desc cwcsnoop_module = { +static dsp_module_desc_t cwcsnoop_module = { "cwcsnoop", { 3, diff --git a/trunk/sound/pci/cs5535audio/Makefile b/trunk/sound/pci/cs5535audio/Makefile deleted file mode 100644 index 08d8ee6547d3..000000000000 --- a/trunk/sound/pci/cs5535audio/Makefile +++ /dev/null @@ -1,8 +0,0 @@ -# -# Makefile for cs5535audio -# - -snd-cs5535audio-objs := cs5535audio.o cs5535audio_pcm.o - -# Toplevel Module Dependency -obj-$(CONFIG_SND_CS5535AUDIO) += snd-cs5535audio.o diff --git a/trunk/sound/pci/cs5535audio/cs5535audio.c b/trunk/sound/pci/cs5535audio/cs5535audio.c deleted file mode 100644 index 202c7cf3e328..000000000000 --- a/trunk/sound/pci/cs5535audio/cs5535audio.c +++ /dev/null @@ -1,402 +0,0 @@ -/* - * Driver for audio on multifunction CS5535 companion device - * Copyright (C) Jaya Kumar - * - * Based on Jaroslav Kysela and Takashi Iwai's examples. - * This work was sponsored by CIS(M) Sdn Bhd. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ - -#include <sound/driver.h> -#include <linux/delay.h> -#include <linux/interrupt.h> -#include <linux/init.h> -#include <linux/pci.h> -#include <linux/slab.h> -#include <linux/moduleparam.h> -#include <asm/io.h> -#include <sound/core.h> -#include <sound/control.h> -#include <sound/pcm.h> -#include <sound/rawmidi.h> -#include <sound/ac97_codec.h> -#include <sound/initval.h> -#include <sound/asoundef.h> -#include "cs5535audio.h" - -#define DRIVER_NAME "cs5535audio" - - -static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; -static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; -static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; - -static struct pci_device_id snd_cs5535audio_ids[] = { - { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO, PCI_ANY_ID, - PCI_ANY_ID, 0, 0, 0, }, - {} -}; - -MODULE_DEVICE_TABLE(pci, snd_cs5535audio_ids); - -static void wait_till_cmd_acked(struct cs5535audio *cs5535au, unsigned long timeout) -{ - unsigned int tmp; - do { - tmp = cs_readl(cs5535au, ACC_CODEC_CNTL); - if (!(tmp & CMD_NEW)) - break; - msleep(10); - } while (--timeout); - if (!timeout) - snd_printk(KERN_ERR "Failure writing to cs5535 codec\n"); -} - -static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au, - unsigned short reg) -{ - unsigned int regdata; - unsigned int timeout; - unsigned int val; - - regdata = ((unsigned int) reg) << 24; - regdata |= ACC_CODEC_CNTL_RD_CMD; - regdata |= CMD_NEW; - - cs_writel(cs5535au, ACC_CODEC_CNTL, regdata); - wait_till_cmd_acked(cs5535au, 500); - - timeout = 50; - do { - val = cs_readl(cs5535au, ACC_CODEC_STATUS); - if ((val & STS_NEW) && reg == (val >> 24)) - break; - msleep(10); - } while (--timeout); - if (!timeout) - snd_printk(KERN_ERR "Failure reading cs5535 codec\n"); - - return (unsigned short) val; -} - -static void snd_cs5535audio_codec_write(struct cs5535audio *cs5535au, - unsigned short reg, unsigned short val) -{ - unsigned int regdata; - - regdata = ((unsigned int) reg) << 24; - regdata |= val; - regdata &= CMD_MASK; - regdata |= CMD_NEW; - regdata &= ACC_CODEC_CNTL_WR_CMD; - - cs_writel(cs5535au, ACC_CODEC_CNTL, regdata); - wait_till_cmd_acked(cs5535au, 50); -} - -static void snd_cs5535audio_ac97_codec_write(struct snd_ac97 *ac97, - unsigned short reg, unsigned short val) -{ - struct cs5535audio *cs5535au = ac97->private_data; - snd_cs5535audio_codec_write(cs5535au, reg, val); -} - -static unsigned short snd_cs5535audio_ac97_codec_read(struct snd_ac97 *ac97, - unsigned short reg) -{ - struct cs5535audio *cs5535au = ac97->private_data; - return snd_cs5535audio_codec_read(cs5535au, reg); -} - -static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au) -{ - struct snd_card *card = cs5535au->card; - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; - int err; - static struct snd_ac97_bus_ops ops = { - .write = snd_cs5535audio_ac97_codec_write, - .read = snd_cs5535audio_ac97_codec_read, - }; - - if ((err = snd_ac97_bus(card, 0, &ops, NULL, &pbus)) < 0) - return err; - - memset(&ac97, 0, sizeof(ac97)); - ac97.scaps = AC97_SCAP_AUDIO|AC97_SCAP_SKIP_MODEM; - ac97.private_data = cs5535au; - ac97.pci = cs5535au->pci; - - if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) { - snd_printk(KERN_ERR "mixer failed\n"); - return err; - } - - return 0; -} - -static void process_bm0_irq(struct cs5535audio *cs5535au) -{ - u8 bm_stat; - spin_lock(&cs5535au->reg_lock); - bm_stat = cs_readb(cs5535au, ACC_BM0_STATUS); - spin_unlock(&cs5535au->reg_lock); - if (bm_stat & EOP) { - struct cs5535audio_dma *dma; - dma = cs5535au->playback_substream->runtime->private_data; - snd_pcm_period_elapsed(cs5535au->playback_substream); - } else { - snd_printk(KERN_ERR "unexpected bm0 irq src, bm_stat=%x\n", - bm_stat); - } -} - -static void process_bm1_irq(struct cs5535audio *cs5535au) -{ - u8 bm_stat; - spin_lock(&cs5535au->reg_lock); - bm_stat = cs_readb(cs5535au, ACC_BM1_STATUS); - spin_unlock(&cs5535au->reg_lock); - if (bm_stat & EOP) { - struct cs5535audio_dma *dma; - dma = cs5535au->capture_substream->runtime->private_data; - snd_pcm_period_elapsed(cs5535au->capture_substream); - } -} - -static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id, - struct pt_regs *regs) -{ - u16 acc_irq_stat; - u8 bm_stat; - unsigned char count; - struct cs5535audio *cs5535au = dev_id; - - if (cs5535au == NULL) - return IRQ_NONE; - - acc_irq_stat = cs_readw(cs5535au, ACC_IRQ_STATUS); - - if (!acc_irq_stat) - return IRQ_NONE; - for (count = 0; count < 10; count++) { - if (acc_irq_stat & (1 << count)) { - switch (count) { - case IRQ_STS: - cs_readl(cs5535au, ACC_GPIO_STATUS); - break; - case WU_IRQ_STS: - cs_readl(cs5535au, ACC_GPIO_STATUS); - break; - case BM0_IRQ_STS: - process_bm0_irq(cs5535au); - break; - case BM1_IRQ_STS: - process_bm1_irq(cs5535au); - break; - case BM2_IRQ_STS: - bm_stat = cs_readb(cs5535au, ACC_BM2_STATUS); - break; - case BM3_IRQ_STS: - bm_stat = cs_readb(cs5535au, ACC_BM3_STATUS); - break; - case BM4_IRQ_STS: - bm_stat = cs_readb(cs5535au, ACC_BM4_STATUS); - break; - case BM5_IRQ_STS: - bm_stat = cs_readb(cs5535au, ACC_BM5_STATUS); - break; - case BM6_IRQ_STS: - bm_stat = cs_readb(cs5535au, ACC_BM6_STATUS); - break; - case BM7_IRQ_STS: - bm_stat = cs_readb(cs5535au, ACC_BM7_STATUS); - break; - default: - snd_printk(KERN_ERR "Unexpected irq src\n"); - break; - } - } - } - return IRQ_HANDLED; -} - -static int snd_cs5535audio_free(struct cs5535audio *cs5535au) -{ - synchronize_irq(cs5535au->irq); - pci_set_power_state(cs5535au->pci, 3); - - if (cs5535au->irq >= 0) - free_irq(cs5535au->irq, cs5535au); - - pci_release_regions(cs5535au->pci); - pci_disable_device(cs5535au->pci); - kfree(cs5535au); - return 0; -} - -static int snd_cs5535audio_dev_free(struct snd_device *device) -{ - struct cs5535audio *cs5535au = device->device_data; - return snd_cs5535audio_free(cs5535au); -} - -static int __devinit snd_cs5535audio_create(struct snd_card *card, - struct pci_dev *pci, - struct cs5535audio **rcs5535au) -{ - struct cs5535audio *cs5535au; - - int err; - static struct snd_device_ops ops = { - .dev_free = snd_cs5535audio_dev_free, - }; - - *rcs5535au = NULL; - if ((err = pci_enable_device(pci)) < 0) - return err; - - if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 || - pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) { - printk(KERN_WARNING "unable to get 32bit dma\n"); - err = -ENXIO; - goto pcifail; - } - - cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL); - if (cs5535au == NULL) { - err = -ENOMEM; - goto pcifail; - } - - spin_lock_init(&cs5535au->reg_lock); - cs5535au->card = card; - cs5535au->pci = pci; - cs5535au->irq = -1; - - if ((err = pci_request_regions(pci, "CS5535 Audio")) < 0) { - kfree(cs5535au); - goto pcifail; - } - - cs5535au->port = pci_resource_start(pci, 0); - - if (request_irq(pci->irq, snd_cs5535audio_interrupt, - SA_INTERRUPT|SA_SHIRQ, "CS5535 Audio", cs5535au)) { - snd_printk("unable to grab IRQ %d\n", pci->irq); - err = -EBUSY; - goto sndfail; - } - - cs5535au->irq = pci->irq; - pci_set_master(pci); - - if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, - cs5535au, &ops)) < 0) - goto sndfail; - - snd_card_set_dev(card, &pci->dev); - - *rcs5535au = cs5535au; - return 0; - -sndfail: /* leave the device alive, just kill the snd */ - snd_cs5535audio_free(cs5535au); - return err; - -pcifail: - pci_disable_device(pci); - return err; -} - -static int __devinit snd_cs5535audio_probe(struct pci_dev *pci, - const struct pci_device_id *pci_id) -{ - static int dev; - struct snd_card *card; - struct cs5535audio *cs5535au; - int err; - - if (dev >= SNDRV_CARDS) - return -ENODEV; - if (!enable[dev]) { - dev++; - return -ENOENT; - } - - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); - if (card == NULL) - return -ENOMEM; - - if ((err = snd_cs5535audio_create(card, pci, &cs5535au)) < 0) - goto probefail_out; - - if ((err = snd_cs5535audio_mixer(cs5535au)) < 0) - goto probefail_out; - - if ((err = snd_cs5535audio_pcm(cs5535au)) < 0) - goto probefail_out; - - strcpy(card->driver, DRIVER_NAME); - - strcpy(card->shortname, "CS5535 Audio"); - sprintf(card->longname, "%s %s at 0x%lx, irq %i", - card->shortname, card->driver, - cs5535au->port, cs5535au->irq); - - if ((err = snd_card_register(card)) < 0) - goto probefail_out; - - pci_set_drvdata(pci, card); - dev++; - return 0; - -probefail_out: - snd_card_free(card); - return err; -} - -static void __devexit snd_cs5535audio_remove(struct pci_dev *pci) -{ - snd_card_free(pci_get_drvdata(pci)); - pci_set_drvdata(pci, NULL); -} - -static struct pci_driver driver = { - .name = DRIVER_NAME, - .id_table = snd_cs5535audio_ids, - .probe = snd_cs5535audio_probe, - .remove = __devexit_p(snd_cs5535audio_remove), -}; - -static int __init alsa_card_cs5535audio_init(void) -{ - return pci_module_init(&driver); -} - -static void __exit alsa_card_cs5535audio_exit(void) -{ - pci_unregister_driver(&driver); -} - -module_init(alsa_card_cs5535audio_init) -module_exit(alsa_card_cs5535audio_exit) - -MODULE_AUTHOR("Jaya Kumar"); -MODULE_LICENSE("GPL"); -MODULE_DESCRIPTION("CS5535 Audio"); -MODULE_SUPPORTED_DEVICE("CS5535 Audio"); diff --git a/trunk/sound/pci/cs5535audio/cs5535audio.h b/trunk/sound/pci/cs5535audio/cs5535audio.h deleted file mode 100644 index 5e55a1a1ed65..000000000000 --- a/trunk/sound/pci/cs5535audio/cs5535audio.h +++ /dev/null @@ -1,123 +0,0 @@ -#ifndef __SOUND_CS5535AUDIO_H -#define __SOUND_CS5535AUDIO_H - -#define cs_writel(cs5535au, reg, val) outl(val, (cs5535au)->port + reg) -#define cs_writeb(cs5535au, reg, val) outb(val, (cs5535au)->port + reg) -#define cs_readl(cs5535au, reg) inl((cs5535au)->port + reg) -#define cs_readw(cs5535au, reg) inw((cs5535au)->port + reg) -#define cs_readb(cs5535au, reg) inb((cs5535au)->port + reg) - -#define CS5535AUDIO_MAX_DESCRIPTORS 128 - -/* acc_codec bar0 reg addrs */ -#define ACC_GPIO_STATUS 0x00 -#define ACC_CODEC_STATUS 0x08 -#define ACC_CODEC_CNTL 0x0C -#define ACC_IRQ_STATUS 0x12 -#define ACC_BM0_CMD 0x20 -#define ACC_BM1_CMD 0x28 -#define ACC_BM2_CMD 0x30 -#define ACC_BM3_CMD 0x38 -#define ACC_BM4_CMD 0x40 -#define ACC_BM5_CMD 0x48 -#define ACC_BM6_CMD 0x50 -#define ACC_BM7_CMD 0x58 -#define ACC_BM0_PRD 0x24 -#define ACC_BM1_PRD 0x2C -#define ACC_BM2_PRD 0x34 -#define ACC_BM3_PRD 0x3C -#define ACC_BM4_PRD 0x44 -#define ACC_BM5_PRD 0x4C -#define ACC_BM6_PRD 0x54 -#define ACC_BM7_PRD 0x5C -#define ACC_BM0_STATUS 0x21 -#define ACC_BM1_STATUS 0x29 -#define ACC_BM2_STATUS 0x31 -#define ACC_BM3_STATUS 0x39 -#define ACC_BM4_STATUS 0x41 -#define ACC_BM5_STATUS 0x49 -#define ACC_BM6_STATUS 0x51 -#define ACC_BM7_STATUS 0x59 -#define ACC_BM0_PNTR 0x60 -#define ACC_BM1_PNTR 0x64 -#define ACC_BM2_PNTR 0x68 -#define ACC_BM3_PNTR 0x6C -#define ACC_BM4_PNTR 0x70 -#define ACC_BM5_PNTR 0x74 -#define ACC_BM6_PNTR 0x78 -#define ACC_BM7_PNTR 0x7C -/* acc_codec bar0 reg bits */ -/* ACC_IRQ_STATUS */ -#define IRQ_STS 0 -#define WU_IRQ_STS 1 -#define BM0_IRQ_STS 2 -#define BM1_IRQ_STS 3 -#define BM2_IRQ_STS 4 -#define BM3_IRQ_STS 5 -#define BM4_IRQ_STS 6 -#define BM5_IRQ_STS 7 -#define BM6_IRQ_STS 8 -#define BM7_IRQ_STS 9 -/* ACC_BMX_STATUS */ -#define EOP (1<<0) -#define BM_EOP_ERR (1<<1) -/* ACC_BMX_CTL */ -#define BM_CTL_EN 0x00000001 -#define BM_CTL_PAUSE 0x00000011 -#define BM_CTL_DIS 0x00000000 -#define BM_CTL_BYTE_ORD_LE 0x00000000 -#define BM_CTL_BYTE_ORD_BE 0x00000100 -/* cs5535 specific ac97 codec register defines */ -#define CMD_MASK 0xFF00FFFF -#define CMD_NEW 0x00010000 -#define STS_NEW 0x00020000 -#define PRM_RDY_STS 0x00800000 -#define ACC_CODEC_CNTL_WR_CMD (~0x80000000) -#define ACC_CODEC_CNTL_RD_CMD 0x80000000 -#define PRD_JMP 0x2000 -#define PRD_EOP 0x4000 -#define PRD_EOT 0x8000 - -enum { CS5535AUDIO_DMA_PLAYBACK, CS5535AUDIO_DMA_CAPTURE, NUM_CS5535AUDIO_DMAS }; - -struct cs5535audio; - -struct cs5535audio_dma_ops { - int type; - void (*enable_dma)(struct cs5535audio *cs5535au); - void (*disable_dma)(struct cs5535audio *cs5535au); - void (*pause_dma)(struct cs5535audio *cs5535au); - void (*setup_prd)(struct cs5535audio *cs5535au, u32 prd_addr); - u32 (*read_dma_pntr)(struct cs5535audio *cs5535au); -}; - -struct cs5535audio_dma_desc { - u32 addr; - u16 size; - u16 ctlreserved; -}; - -struct cs5535audio_dma { - const struct cs5535audio_dma_ops *ops; - struct snd_dma_buffer desc_buf; - struct snd_pcm_substream *substream; - unsigned int buf_addr, buf_bytes; - unsigned int period_bytes, periods; -}; - -struct cs5535audio { - struct snd_card *card; - struct snd_ac97 *ac97; - int irq; - struct pci_dev *pci; - unsigned long port; - spinlock_t reg_lock; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; - struct cs5535audio_dma dmas[NUM_CS5535AUDIO_DMAS]; -}; - -int __devinit snd_cs5535audio_pcm(struct cs5535audio *cs5535audio); - -#endif /* __SOUND_CS5535AUDIO_H */ - diff --git a/trunk/sound/pci/cs5535audio/cs5535audio_pcm.c b/trunk/sound/pci/cs5535audio/cs5535audio_pcm.c deleted file mode 100644 index 60bb82b2ff47..000000000000 --- a/trunk/sound/pci/cs5535audio/cs5535audio_pcm.c +++ /dev/null @@ -1,419 +0,0 @@ -/* - * Driver for audio on multifunction CS5535 companion device - * Copyright (C) Jaya Kumar - * - * Based on Jaroslav Kysela and Takashi Iwai's examples. - * This work was sponsored by CIS(M) Sdn Bhd. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - * todo: add be fmt support, spdif, pm - */ - -#include <linux/init.h> -#include <linux/slab.h> -#include <linux/pci.h> -#include <sound/driver.h> -#include <sound/core.h> -#include <sound/control.h> -#include <sound/initval.h> -#include <sound/asoundef.h> -#include <sound/pcm.h> -#include <sound/pcm_params.h> -#include <sound/ac97_codec.h> -#include "cs5535audio.h" - -static struct snd_pcm_hardware snd_cs5535audio_playback = -{ - .info = ( - SNDRV_PCM_INFO_MMAP | - SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_MMAP_VALID | - SNDRV_PCM_INFO_PAUSE | - SNDRV_PCM_INFO_SYNC_START - ), - .formats = ( - SNDRV_PCM_FMTBIT_S16_LE - ), - .rates = ( - SNDRV_PCM_RATE_CONTINUOUS | - SNDRV_PCM_RATE_8000_48000 - ), - .rate_min = 4000, - .rate_max = 48000, - .channels_min = 2, - .channels_max = 2, - .buffer_bytes_max = (128*1024), - .period_bytes_min = 64, - .period_bytes_max = (64*1024 - 16), - .periods_min = 1, - .periods_max = CS5535AUDIO_MAX_DESCRIPTORS, - .fifo_size = 0, -}; - -static struct snd_pcm_hardware snd_cs5535audio_capture = -{ - .info = ( - SNDRV_PCM_INFO_MMAP | - SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_MMAP_VALID | - SNDRV_PCM_INFO_SYNC_START - ), - .formats = ( - SNDRV_PCM_FMTBIT_S16_LE - ), - .rates = ( - SNDRV_PCM_RATE_CONTINUOUS | - SNDRV_PCM_RATE_8000_48000 - ), - .rate_min = 4000, - .rate_max = 48000, - .channels_min = 2, - .channels_max = 2, - .buffer_bytes_max = (128*1024), - .period_bytes_min = 64, - .period_bytes_max = (64*1024 - 16), - .periods_min = 1, - .periods_max = CS5535AUDIO_MAX_DESCRIPTORS, - .fifo_size = 0, -}; - -static int snd_cs5535audio_playback_open(struct snd_pcm_substream *substream) -{ - int err; - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - - runtime->hw = snd_cs5535audio_playback; - cs5535au->playback_substream = substream; - runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK]); - snd_pcm_set_sync(substream); - if ((err = snd_pcm_hw_constraint_integer(runtime, - SNDRV_PCM_HW_PARAM_PERIODS)) < 0) - return err; - - return 0; -} - -static int snd_cs5535audio_playback_close(struct snd_pcm_substream *substream) -{ - return 0; -} - -#define CS5535AUDIO_DESC_LIST_SIZE \ - PAGE_ALIGN(CS5535AUDIO_MAX_DESCRIPTORS * sizeof(struct cs5535audio_dma_desc)) - -static int cs5535audio_build_dma_packets(struct cs5535audio *cs5535au, - struct cs5535audio_dma *dma, - struct snd_pcm_substream *substream, - unsigned int periods, - unsigned int period_bytes) -{ - unsigned int i; - u32 addr, desc_addr, jmpprd_addr; - struct cs5535audio_dma_desc *lastdesc; - - if (periods > CS5535AUDIO_MAX_DESCRIPTORS) - return -ENOMEM; - - if (dma->desc_buf.area == NULL) { - if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(cs5535au->pci), - CS5535AUDIO_DESC_LIST_SIZE+1, - &dma->desc_buf) < 0) - return -ENOMEM; - dma->period_bytes = dma->periods = 0; - } - - if (dma->periods == periods && dma->period_bytes == period_bytes) - return 0; - - /* the u32 cast is okay because in snd*create we succesfully told - pci alloc that we're only 32 bit capable so the uppper will be 0 */ - addr = (u32) substream->runtime->dma_addr; - desc_addr = (u32) dma->desc_buf.addr; - for (i = 0; i < periods; i++) { - struct cs5535audio_dma_desc *desc = - &((struct cs5535audio_dma_desc *) dma->desc_buf.area)[i]; - desc->addr = cpu_to_le32(addr); - desc->size = cpu_to_le32(period_bytes); - desc->ctlreserved = cpu_to_le32(PRD_EOP); - desc_addr += sizeof(struct cs5535audio_dma_desc); - addr += period_bytes; - } - /* we reserved one dummy descriptor at the end to do the PRD jump */ - lastdesc = &((struct cs5535audio_dma_desc *) dma->desc_buf.area)[periods]; - lastdesc->addr = cpu_to_le32((u32) dma->desc_buf.addr); - lastdesc->size = 0; - lastdesc->ctlreserved = cpu_to_le32(PRD_JMP); - jmpprd_addr = cpu_to_le32(lastdesc->addr + - (sizeof(struct cs5535audio_dma_desc)*periods)); - - dma->period_bytes = period_bytes; - dma->periods = periods; - spin_lock_irq(&cs5535au->reg_lock); - dma->ops->disable_dma(cs5535au); - dma->ops->setup_prd(cs5535au, jmpprd_addr); - spin_unlock_irq(&cs5535au->reg_lock); - return 0; -} - -static void cs5535audio_playback_enable_dma(struct cs5535audio *cs5535au) -{ - cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_EN); -} - -static void cs5535audio_playback_disable_dma(struct cs5535audio *cs5535au) -{ - cs_writeb(cs5535au, ACC_BM0_CMD, 0); -} - -static void cs5535audio_playback_pause_dma(struct cs5535audio *cs5535au) -{ - cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_PAUSE); -} - -static void cs5535audio_playback_setup_prd(struct cs5535audio *cs5535au, - u32 prd_addr) -{ - cs_writel(cs5535au, ACC_BM0_PRD, prd_addr); -} - -static u32 cs5535audio_playback_read_dma_pntr(struct cs5535audio *cs5535au) -{ - return cs_readl(cs5535au, ACC_BM0_PNTR); -} - -static void cs5535audio_capture_enable_dma(struct cs5535audio *cs5535au) -{ - cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_EN); -} - -static void cs5535audio_capture_disable_dma(struct cs5535audio *cs5535au) -{ - cs_writeb(cs5535au, ACC_BM1_CMD, 0); -} - -static void cs5535audio_capture_pause_dma(struct cs5535audio *cs5535au) -{ - cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_PAUSE); -} - -static void cs5535audio_capture_setup_prd(struct cs5535audio *cs5535au, - u32 prd_addr) -{ - cs_writel(cs5535au, ACC_BM1_PRD, prd_addr); -} - -static u32 cs5535audio_capture_read_dma_pntr(struct cs5535audio *cs5535au) -{ - return cs_readl(cs5535au, ACC_BM1_PNTR); -} - -static void cs5535audio_clear_dma_packets(struct cs5535audio *cs5535au, - struct cs5535audio_dma *dma, - struct snd_pcm_substream *substream) -{ - snd_dma_free_pages(&dma->desc_buf); - dma->desc_buf.area = NULL; -} - -static int snd_cs5535audio_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) -{ - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - struct cs5535audio_dma *dma = substream->runtime->private_data; - int err; - - err = snd_pcm_lib_malloc_pages(substream, - params_buffer_bytes(hw_params)); - if (err < 0) - return err; - dma->buf_addr = substream->runtime->dma_addr; - dma->buf_bytes = params_buffer_bytes(hw_params); - - err = cs5535audio_build_dma_packets(cs5535au, dma, substream, - params_periods(hw_params), - params_period_bytes(hw_params)); - return err; -} - -static int snd_cs5535audio_hw_free(struct snd_pcm_substream *substream) -{ - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - struct cs5535audio_dma *dma = substream->runtime->private_data; - - cs5535audio_clear_dma_packets(cs5535au, dma, substream); - return snd_pcm_lib_free_pages(substream); -} - -static int snd_cs5535audio_playback_prepare(struct snd_pcm_substream *substream) -{ - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_FRONT_DAC_RATE, - substream->runtime->rate); -} - -static int snd_cs5535audio_trigger(struct snd_pcm_substream *substream, int cmd) -{ - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - struct cs5535audio_dma *dma = substream->runtime->private_data; - int err = 0; - - spin_lock(&cs5535au->reg_lock); - switch (cmd) { - case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - dma->ops->pause_dma(cs5535au); - break; - case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - dma->ops->enable_dma(cs5535au); - break; - case SNDRV_PCM_TRIGGER_START: - dma->ops->enable_dma(cs5535au); - break; - case SNDRV_PCM_TRIGGER_STOP: - dma->ops->disable_dma(cs5535au); - break; - default: - snd_printk(KERN_ERR "unhandled trigger\n"); - err = -EINVAL; - break; - } - spin_unlock(&cs5535au->reg_lock); - return err; -} - -static snd_pcm_uframes_t snd_cs5535audio_pcm_pointer(struct snd_pcm_substream - *substream) -{ - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - u32 curdma; - struct cs5535audio_dma *dma; - - dma = substream->runtime->private_data; - curdma = dma->ops->read_dma_pntr(cs5535au); - if (curdma < dma->buf_addr) { - snd_printk(KERN_ERR "curdma=%x < %x bufaddr.\n", - curdma, dma->buf_addr); - return 0; - } - curdma -= dma->buf_addr; - if (curdma >= dma->buf_bytes) { - snd_printk(KERN_ERR "diff=%x >= %x buf_bytes.\n", - curdma, dma->buf_bytes); - return 0; - } - return bytes_to_frames(substream->runtime, curdma); -} - -static int snd_cs5535audio_capture_open(struct snd_pcm_substream *substream) -{ - int err; - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - - runtime->hw = snd_cs5535audio_capture; - cs5535au->capture_substream = substream; - runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE]); - snd_pcm_set_sync(substream); - if ((err = snd_pcm_hw_constraint_integer(runtime, - SNDRV_PCM_HW_PARAM_PERIODS)) < 0) - return err; - return 0; -} - -static int snd_cs5535audio_capture_close(struct snd_pcm_substream *substream) -{ - return 0; -} - -static int snd_cs5535audio_capture_prepare(struct snd_pcm_substream *substream) -{ - struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream); - return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_LR_ADC_RATE, - substream->runtime->rate); -} - -static struct snd_pcm_ops snd_cs5535audio_playback_ops = { - .open = snd_cs5535audio_playback_open, - .close = snd_cs5535audio_playback_close, - .ioctl = snd_pcm_lib_ioctl, - .hw_params = snd_cs5535audio_hw_params, - .hw_free = snd_cs5535audio_hw_free, - .prepare = snd_cs5535audio_playback_prepare, - .trigger = snd_cs5535audio_trigger, - .pointer = snd_cs5535audio_pcm_pointer, -}; - -static struct snd_pcm_ops snd_cs5535audio_capture_ops = { - .open = snd_cs5535audio_capture_open, - .close = snd_cs5535audio_capture_close, - .ioctl = snd_pcm_lib_ioctl, - .hw_params = snd_cs5535audio_hw_params, - .hw_free = snd_cs5535audio_hw_free, - .prepare = snd_cs5535audio_capture_prepare, - .trigger = snd_cs5535audio_trigger, - .pointer = snd_cs5535audio_pcm_pointer, -}; - -static struct cs5535audio_dma_ops snd_cs5535audio_playback_dma_ops = { - .type = CS5535AUDIO_DMA_PLAYBACK, - .enable_dma = cs5535audio_playback_enable_dma, - .disable_dma = cs5535audio_playback_disable_dma, - .setup_prd = cs5535audio_playback_setup_prd, - .pause_dma = cs5535audio_playback_pause_dma, - .read_dma_pntr = cs5535audio_playback_read_dma_pntr, -}; - -static struct cs5535audio_dma_ops snd_cs5535audio_capture_dma_ops = { - .type = CS5535AUDIO_DMA_CAPTURE, - .enable_dma = cs5535audio_capture_enable_dma, - .disable_dma = cs5535audio_capture_disable_dma, - .setup_prd = cs5535audio_capture_setup_prd, - .pause_dma = cs5535audio_capture_pause_dma, - .read_dma_pntr = cs5535audio_capture_read_dma_pntr, -}; - -int __devinit snd_cs5535audio_pcm(struct cs5535audio *cs5535au) -{ - struct snd_pcm *pcm; - int err; - - err = snd_pcm_new(cs5535au->card, "CS5535 Audio", 0, 1, 1, &pcm); - if (err < 0) - return err; - - cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK].ops = - &snd_cs5535audio_playback_dma_ops; - cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE].ops = - &snd_cs5535audio_capture_dma_ops; - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, - &snd_cs5535audio_playback_ops); - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, - &snd_cs5535audio_capture_ops); - - pcm->private_data = cs5535au; - pcm->info_flags = 0; - strcpy(pcm->name, "CS5535 Audio"); - - snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(cs5535au->pci), - 64*1024, 128*1024); - - return 0; -} - diff --git a/trunk/sound/pci/emu10k1/emu10k1.c b/trunk/sound/pci/emu10k1/emu10k1.c index 2dfa932f7825..78270f8710ff 100644 --- a/trunk/sound/pci/emu10k1/emu10k1.c +++ b/trunk/sound/pci/emu10k1/emu10k1.c @@ -101,10 +101,10 @@ static int __devinit snd_card_emu10k1_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_emu10k1 *emu; + snd_card_t *card; + emu10k1_t *emu; #ifdef ENABLE_SYNTH - struct snd_seq_device *wave = NULL; + snd_seq_device_t *wave = NULL; #endif int err; @@ -125,50 +125,72 @@ static int __devinit snd_card_emu10k1_probe(struct pci_dev *pci, if ((err = snd_emu10k1_create(card, pci, extin[dev], extout[dev], (long)max_buffer_size[dev] * 1024 * 1024, enable_ir[dev], subsystem[dev], - &emu)) < 0) - goto error; - card->private_data = emu; - if ((err = snd_emu10k1_pcm(emu, 0, NULL)) < 0) - goto error; - if ((err = snd_emu10k1_pcm_mic(emu, 1, NULL)) < 0) - goto error; - if ((err = snd_emu10k1_pcm_efx(emu, 2, NULL)) < 0) - goto error; + &emu)) < 0) { + snd_card_free(card); + return err; + } + if ((err = snd_emu10k1_pcm(emu, 0, NULL)) < 0) { + snd_card_free(card); + return err; + } + if ((err = snd_emu10k1_pcm_mic(emu, 1, NULL)) < 0) { + snd_card_free(card); + return err; + } + if ((err = snd_emu10k1_pcm_efx(emu, 2, NULL)) < 0) { + snd_card_free(card); + return err; + } /* This stores the periods table. */ if (emu->card_capabilities->ca0151_chip) { /* P16V */ - if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), - 1024, &emu->p16v_buffer)) < 0) - goto error; + if(snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 1024, &emu->p16v_buffer) < 0) { + snd_p16v_free(emu); + return -ENOMEM; + } } - if ((err = snd_emu10k1_mixer(emu, 0, 3)) < 0) - goto error; + if ((err = snd_emu10k1_mixer(emu, 0, 3)) < 0) { + snd_card_free(card); + return err; + } - if ((err = snd_emu10k1_timer(emu, 0)) < 0) - goto error; + if ((err = snd_emu10k1_timer(emu, 0)) < 0) { + snd_card_free(card); + return err; + } - if ((err = snd_emu10k1_pcm_multi(emu, 3, NULL)) < 0) - goto error; - if (emu->card_capabilities->ca0151_chip) { /* P16V */ - if ((err = snd_p16v_pcm(emu, 4, NULL)) < 0) - goto error; + if ((err = snd_emu10k1_pcm_multi(emu, 3, NULL)) < 0) { + snd_card_free(card); + return err; + } + if (emu->card_capabilities->ca0151_chip) { /* P16V */ + if ((err = snd_p16v_pcm(emu, 4, NULL)) < 0) { + snd_card_free(card); + return err; + } } if (emu->audigy) { - if ((err = snd_emu10k1_audigy_midi(emu)) < 0) - goto error; + if ((err = snd_emu10k1_audigy_midi(emu)) < 0) { + snd_card_free(card); + return err; + } } else { - if ((err = snd_emu10k1_midi(emu)) < 0) - goto error; + if ((err = snd_emu10k1_midi(emu)) < 0) { + snd_card_free(card); + return err; + } + } + if ((err = snd_emu10k1_fx8010_new(emu, 0, NULL)) < 0) { + snd_card_free(card); + return err; } - if ((err = snd_emu10k1_fx8010_new(emu, 0, NULL)) < 0) - goto error; #ifdef ENABLE_SYNTH if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH, - sizeof(struct snd_emu10k1_synth_arg), &wave) < 0 || + sizeof(snd_emu10k1_synth_arg_t), &wave) < 0 || wave == NULL) { snd_printk(KERN_WARNING "can't initialize Emu10k1 wavetable synth\n"); } else { - struct snd_emu10k1_synth_arg *arg; + snd_emu10k1_synth_arg_t *arg; arg = SNDRV_SEQ_DEVICE_ARGPTR(wave); strcpy(wave->name, "Emu-10k1 Synth"); arg->hwptr = emu; @@ -184,16 +206,13 @@ static int __devinit snd_card_emu10k1_probe(struct pci_dev *pci, "%s (rev.%d, serial:0x%x) at 0x%lx, irq %i", card->shortname, emu->revision, emu->serial, emu->port, emu->irq); - if ((err = snd_card_register(card)) < 0) - goto error; - + if ((err = snd_card_register(card)) < 0) { + snd_card_free(card); + return err; + } pci_set_drvdata(pci, card); dev++; return 0; - - error: - snd_card_free(card); - return err; } static void __devexit snd_card_emu10k1_remove(struct pci_dev *pci) @@ -202,68 +221,11 @@ static void __devexit snd_card_emu10k1_remove(struct pci_dev *pci) pci_set_drvdata(pci, NULL); } - -#ifdef CONFIG_PM -static int snd_emu10k1_suspend(struct pci_dev *pci, pm_message_t state) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_emu10k1 *emu = card->private_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - - snd_pcm_suspend_all(emu->pcm); - snd_pcm_suspend_all(emu->pcm_mic); - snd_pcm_suspend_all(emu->pcm_efx); - snd_pcm_suspend_all(emu->pcm_multi); - snd_pcm_suspend_all(emu->pcm_p16v); - - snd_ac97_suspend(emu->ac97); - - snd_emu10k1_efx_suspend(emu); - snd_emu10k1_suspend_regs(emu); - if (emu->card_capabilities->ca0151_chip) - snd_p16v_suspend(emu); - - snd_emu10k1_done(emu); - - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); - return 0; -} - -int snd_emu10k1_resume(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_emu10k1 *emu = card->private_data; - - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); - - snd_emu10k1_resume_init(emu); - snd_emu10k1_efx_resume(emu); - snd_ac97_resume(emu->ac97); - snd_emu10k1_resume_regs(emu); - - if (emu->card_capabilities->ca0151_chip) - snd_p16v_resume(emu); - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - static struct pci_driver driver = { .name = "EMU10K1_Audigy", .id_table = snd_emu10k1_ids, .probe = snd_card_emu10k1_probe, .remove = __devexit_p(snd_card_emu10k1_remove), -#ifdef CONFIG_PM - .suspend = snd_emu10k1_suspend, - .resume = snd_emu10k1_resume, -#endif }; static int __init alsa_card_emu10k1_init(void) diff --git a/trunk/sound/pci/emu10k1/emu10k1_callback.c b/trunk/sound/pci/emu10k1/emu10k1_callback.c index 01965bd99966..6589bf24abcd 100644 --- a/trunk/sound/pci/emu10k1/emu10k1_callback.c +++ b/trunk/sound/pci/emu10k1/emu10k1_callback.c @@ -27,28 +27,26 @@ enum { }; /* Keeps track of what we are finding */ -struct best_voice { +typedef struct best_voice { unsigned int time; int voice; -}; +} best_voice_t; /* * prototypes */ -static void lookup_voices(struct snd_emux *emu, struct snd_emu10k1 *hw, - struct best_voice *best, int active_only); -static struct snd_emux_voice *get_voice(struct snd_emux *emu, - struct snd_emux_port *port); -static int start_voice(struct snd_emux_voice *vp); -static void trigger_voice(struct snd_emux_voice *vp); -static void release_voice(struct snd_emux_voice *vp); -static void update_voice(struct snd_emux_voice *vp, int update); -static void terminate_voice(struct snd_emux_voice *vp); -static void free_voice(struct snd_emux_voice *vp); - -static void set_fmmod(struct snd_emu10k1 *hw, struct snd_emux_voice *vp); -static void set_fm2frq2(struct snd_emu10k1 *hw, struct snd_emux_voice *vp); -static void set_filterQ(struct snd_emu10k1 *hw, struct snd_emux_voice *vp); +static void lookup_voices(snd_emux_t *emu, emu10k1_t *hw, best_voice_t *best, int active_only); +static snd_emux_voice_t *get_voice(snd_emux_t *emu, snd_emux_port_t *port); +static int start_voice(snd_emux_voice_t *vp); +static void trigger_voice(snd_emux_voice_t *vp); +static void release_voice(snd_emux_voice_t *vp); +static void update_voice(snd_emux_voice_t *vp, int update); +static void terminate_voice(snd_emux_voice_t *vp); +static void free_voice(snd_emux_voice_t *vp); + +static void set_fmmod(emu10k1_t *hw, snd_emux_voice_t *vp); +static void set_fm2frq2(emu10k1_t *hw, snd_emux_voice_t *vp); +static void set_filterQ(emu10k1_t *hw, snd_emux_voice_t *vp); /* * Ensure a value is between two points @@ -61,7 +59,7 @@ static void set_filterQ(struct snd_emu10k1 *hw, struct snd_emux_voice *vp); /* * set up operators */ -static struct snd_emux_operators emu10k1_ops = { +static snd_emux_operators_t emu10k1_ops = { .owner = THIS_MODULE, .get_voice = get_voice, .prepare = start_voice, @@ -75,7 +73,7 @@ static struct snd_emux_operators emu10k1_ops = { }; void -snd_emu10k1_ops_setup(struct snd_emux *emu) +snd_emu10k1_ops_setup(snd_emux_t *emu) { emu->ops = emu10k1_ops; } @@ -87,11 +85,11 @@ snd_emu10k1_ops_setup(struct snd_emux *emu) * terminate most inactive voice and give it as a pcm voice. */ int -snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw) +snd_emu10k1_synth_get_voice(emu10k1_t *hw) { - struct snd_emux *emu; - struct snd_emux_voice *vp; - struct best_voice best[V_END]; + snd_emux_t *emu; + snd_emux_voice_t *vp; + best_voice_t best[V_END]; unsigned long flags; int i; @@ -125,10 +123,10 @@ snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw) * turn off the voice (not terminated) */ static void -release_voice(struct snd_emux_voice *vp) +release_voice(snd_emux_voice_t *vp) { int dcysusv; - struct snd_emu10k1 *hw; + emu10k1_t *hw; hw = vp->hw; dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease; @@ -142,16 +140,16 @@ release_voice(struct snd_emux_voice *vp) * terminate the voice */ static void -terminate_voice(struct snd_emux_voice *vp) +terminate_voice(snd_emux_voice_t *vp) { - struct snd_emu10k1 *hw; + emu10k1_t *hw; snd_assert(vp, return); hw = vp->hw; snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f | DCYSUSV_CHANNELENABLE_MASK); if (vp->block) { - struct snd_emu10k1_memblk *emem; - emem = (struct snd_emu10k1_memblk *)vp->block; + emu10k1_memblk_t *emem; + emem = (emu10k1_memblk_t *)vp->block; if (emem->map_locked > 0) emem->map_locked--; } @@ -161,9 +159,9 @@ terminate_voice(struct snd_emux_voice *vp) * release the voice to system */ static void -free_voice(struct snd_emux_voice *vp) +free_voice(snd_emux_voice_t *vp) { - struct snd_emu10k1 *hw; + emu10k1_t *hw; hw = vp->hw; if (vp->ch >= 0) { @@ -183,9 +181,9 @@ free_voice(struct snd_emux_voice *vp) * update registers */ static void -update_voice(struct snd_emux_voice *vp, int update) +update_voice(snd_emux_voice_t *vp, int update) { - struct snd_emu10k1 *hw; + emu10k1_t *hw; hw = vp->hw; if (update & SNDRV_EMUX_UPDATE_VOLUME) @@ -212,11 +210,10 @@ update_voice(struct snd_emux_voice *vp, int update) */ /* spinlock held! */ static void -lookup_voices(struct snd_emux *emu, struct snd_emu10k1 *hw, - struct best_voice *best, int active_only) +lookup_voices(snd_emux_t *emu, emu10k1_t *hw, best_voice_t *best, int active_only) { - struct snd_emux_voice *vp; - struct best_voice *bp; + snd_emux_voice_t *vp; + best_voice_t *bp; int i; for (i = 0; i < V_END; i++) { @@ -277,12 +274,12 @@ lookup_voices(struct snd_emux *emu, struct snd_emu10k1 *hw, * * emu->voice_lock is already held. */ -static struct snd_emux_voice * -get_voice(struct snd_emux *emu, struct snd_emux_port *port) +static snd_emux_voice_t * +get_voice(snd_emux_t *emu, snd_emux_port_t *port) { - struct snd_emu10k1 *hw; - struct snd_emux_voice *vp; - struct best_voice best[V_END]; + emu10k1_t *hw; + snd_emux_voice_t *vp; + best_voice_t best[V_END]; int i; hw = emu->hw; @@ -293,7 +290,7 @@ get_voice(struct snd_emux *emu, struct snd_emux_port *port) vp = &emu->voices[best[i].voice]; if (vp->ch < 0) { /* allocate a voice */ - struct snd_emu10k1_voice *hwvoice; + emu10k1_voice_t *hwvoice; if (snd_emu10k1_voice_alloc(hw, EMU10K1_SYNTH, 1, &hwvoice) < 0 || hwvoice == NULL) continue; vp->ch = hwvoice->number; @@ -311,21 +308,21 @@ get_voice(struct snd_emux *emu, struct snd_emux_port *port) * prepare envelopes and LFOs */ static int -start_voice(struct snd_emux_voice *vp) +start_voice(snd_emux_voice_t *vp) { unsigned int temp; int ch; unsigned int addr, mapped_offset; - struct snd_midi_channel *chan; - struct snd_emu10k1 *hw; - struct snd_emu10k1_memblk *emem; + snd_midi_channel_t *chan; + emu10k1_t *hw; + emu10k1_memblk_t *emem; hw = vp->hw; ch = vp->ch; snd_assert(ch >= 0, return -EINVAL); chan = vp->chan; - emem = (struct snd_emu10k1_memblk *)vp->block; + emem = (emu10k1_memblk_t *)vp->block; if (emem == NULL) return -EINVAL; emem->map_locked++; @@ -466,15 +463,15 @@ start_voice(struct snd_emux_voice *vp) * Start envelope */ static void -trigger_voice(struct snd_emux_voice *vp) +trigger_voice(snd_emux_voice_t *vp) { unsigned int temp, ptarget; - struct snd_emu10k1 *hw; - struct snd_emu10k1_memblk *emem; + emu10k1_t *hw; + emu10k1_memblk_t *emem; hw = vp->hw; - emem = (struct snd_emu10k1_memblk *)vp->block; + emem = (emu10k1_memblk_t *)vp->block; if (! emem || emem->mapped_page < 0) return; /* not mapped */ @@ -498,7 +495,7 @@ trigger_voice(struct snd_emux_voice *vp) /* set lfo1 modulation height and cutoff */ static void -set_fmmod(struct snd_emu10k1 *hw, struct snd_emux_voice *vp) +set_fmmod(emu10k1_t *hw, snd_emux_voice_t *vp) { unsigned short fmmod; short pitch; @@ -516,7 +513,7 @@ set_fmmod(struct snd_emu10k1 *hw, struct snd_emux_voice *vp) /* set lfo2 pitch & frequency */ static void -set_fm2frq2(struct snd_emu10k1 *hw, struct snd_emux_voice *vp) +set_fm2frq2(emu10k1_t *hw, snd_emux_voice_t *vp) { unsigned short fm2frq2; short pitch; @@ -534,7 +531,7 @@ set_fm2frq2(struct snd_emu10k1 *hw, struct snd_emux_voice *vp) /* set filterQ */ static void -set_filterQ(struct snd_emu10k1 *hw, struct snd_emux_voice *vp) +set_filterQ(emu10k1_t *hw, snd_emux_voice_t *vp) { unsigned int val; val = snd_emu10k1_ptr_read(hw, CCCA, vp->ch) & ~CCCA_RESONANCE; diff --git a/trunk/sound/pci/emu10k1/emu10k1_main.c b/trunk/sound/pci/emu10k1/emu10k1_main.c index 3c7043b7d4c9..53aeff0b783a 100644 --- a/trunk/sound/pci/emu10k1/emu10k1_main.c +++ b/trunk/sound/pci/emu10k1/emu10k1_main.c @@ -40,14 +40,18 @@ #include <sound/core.h> #include <sound/emu10k1.h> #include "p16v.h" -#include "tina2.h" +#if 0 +MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Creative Labs, Inc."); +MODULE_DESCRIPTION("Routines for control of EMU10K1 chips"); +MODULE_LICENSE("GPL"); +#endif /************************************************************************* * EMU10K1 init / done *************************************************************************/ -void snd_emu10k1_voice_init(struct snd_emu10k1 * emu, int ch) +void snd_emu10k1_voice_init(emu10k1_t * emu, int ch) { snd_emu10k1_ptr_write(emu, DCYSUSV, ch, 0); snd_emu10k1_ptr_write(emu, IP, ch, 0); @@ -92,38 +96,17 @@ void snd_emu10k1_voice_init(struct snd_emu10k1 * emu, int ch) } } -static unsigned int spi_dac_init[] = { - 0x00ff, - 0x02ff, - 0x0400, - 0x0520, - 0x0600, - 0x08ff, - 0x0aff, - 0x0cff, - 0x0eff, - 0x10ff, - 0x1200, - 0x1400, - 0x1480, - 0x1800, - 0x1aff, - 0x1cff, - 0x1e00, - 0x0530, - 0x0602, - 0x0622, - 0x1400, -}; - -static int snd_emu10k1_init(struct snd_emu10k1 *emu, int enable_ir, int resume) +static int __devinit snd_emu10k1_init(emu10k1_t * emu, int enable_ir) { + int ch, idx, err; unsigned int silent_page; - int ch; + + emu->fx8010.itram_size = (16 * 1024)/2; + emu->fx8010.etram_pages.area = NULL; + emu->fx8010.etram_pages.bytes = 0; /* disable audio and lock cache */ - outl(HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE, - emu->port + HCFG); + outl(HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE, emu->port + HCFG); /* reset recording buffers */ snd_emu10k1_ptr_write(emu, MICBS, 0, ADCBS_BUFSIZE_NONE); @@ -144,17 +127,48 @@ static int snd_emu10k1_init(struct snd_emu10k1 *emu, int enable_ir, int resume) /* set SPDIF bypass mode */ snd_emu10k1_ptr_write(emu, SPBYPASS, 0, SPBYPASS_FORMAT); /* enable rear left + rear right AC97 slots */ - snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_REAR_RIGHT | - AC97SLOT_REAR_LEFT); + snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_REAR_RIGHT | AC97SLOT_REAR_LEFT); } /* init envelope engine */ - for (ch = 0; ch < NUM_G; ch++) + for (ch = 0; ch < NUM_G; ch++) { + emu->voices[ch].emu = emu; + emu->voices[ch].number = ch; snd_emu10k1_voice_init(emu, ch); + } - snd_emu10k1_ptr_write(emu, SPCS0, 0, emu->spdif_bits[0]); - snd_emu10k1_ptr_write(emu, SPCS1, 0, emu->spdif_bits[1]); - snd_emu10k1_ptr_write(emu, SPCS2, 0, emu->spdif_bits[2]); + /* + * Init to 0x02109204 : + * Clock accuracy = 0 (1000ppm) + * Sample Rate = 2 (48kHz) + * Audio Channel = 1 (Left of 2) + * Source Number = 0 (Unspecified) + * Generation Status = 1 (Original for Cat Code 12) + * Cat Code = 12 (Digital Signal Mixer) + * Mode = 0 (Mode 0) + * Emphasis = 0 (None) + * CP = 1 (Copyright unasserted) + * AN = 0 (Audio data) + * P = 0 (Consumer) + */ + snd_emu10k1_ptr_write(emu, SPCS0, 0, + emu->spdif_bits[0] = + SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | + SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | + SPCS_GENERATIONSTATUS | 0x00001200 | + 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT); + snd_emu10k1_ptr_write(emu, SPCS1, 0, + emu->spdif_bits[1] = + SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | + SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | + SPCS_GENERATIONSTATUS | 0x00001200 | + 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT); + snd_emu10k1_ptr_write(emu, SPCS2, 0, + emu->spdif_bits[2] = + SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | + SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | + SPCS_GENERATIONSTATUS | 0x00001200 | + 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT); if (emu->card_capabilities->ca0151_chip) { /* audigy2 */ /* Hacks for Alice3 to work independent of haP16V driver */ @@ -181,7 +195,7 @@ static int snd_emu10k1_init(struct snd_emu10k1 *emu, int enable_ir, int resume) /* Hacks for Alice3 to work independent of haP16V driver */ u32 tmp; - snd_printk(KERN_INFO "Audigy2 value: Special config.\n"); + snd_printk(KERN_ERR "Audigy2 value:Special config.\n"); //Setup SRCMulti_I2S SamplingRate tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, 0); tmp &= 0xfffff1ff; @@ -205,28 +219,15 @@ static int snd_emu10k1_init(struct snd_emu10k1 *emu, int enable_ir, int resume) tmp = inl(emu->port + A_IOCFG) & ~0x8; /* Clear bit 3 */ outl(tmp, emu->port + A_IOCFG); } - if (emu->card_capabilities->spi_dac) { /* Audigy 2 ZS Notebook with DAC Wolfson WM8768/WM8568 */ - int size, n; - - size = ARRAY_SIZE(spi_dac_init); - for (n=0; n < size; n++) - snd_emu10k1_spi_write(emu, spi_dac_init[n]); - - snd_emu10k1_ptr20_write(emu, 0x60, 0, 0x10); - /* Enable GPIOs - * GPIO0: Unknown - * GPIO1: Speakers-enabled. - * GPIO2: Unknown - * GPIO3: Unknown - * GPIO4: IEC958 Output on. - * GPIO5: Unknown - * GPIO6: Unknown - * GPIO7: Unknown - */ - outl(0x76, emu->port + A_IOCFG); /* Windows uses 0x3f76 */ - } - + + /* + * Clear page with silence & setup all pointers to this page + */ + memset(emu->silent_page.area, 0, PAGE_SIZE); + silent_page = emu->silent_page.addr << 1; + for (idx = 0; idx < MAXPAGES; idx++) + ((u32 *)emu->ptb_pages.area)[idx] = cpu_to_le32(silent_page | idx); snd_emu10k1_ptr_write(emu, PTB, 0, emu->ptb_pages.addr); snd_emu10k1_ptr_write(emu, TCB, 0, 0); /* taken from original driver */ snd_emu10k1_ptr_write(emu, TCBS, 0, 4); /* taken from original driver */ @@ -263,9 +264,7 @@ static int snd_emu10k1_init(struct snd_emu10k1 *emu, int enable_ir, int resume) outl(HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE | HCFG_JOYENABLE, emu->port + HCFG); if (enable_ir) { /* enable IR for SB Live */ - if ( emu->card_capabilities->emu1212m) { - ; /* Disable all access to A_IOCFG for the emu1212m */ - } else if (emu->audigy) { + if (emu->audigy) { unsigned int reg = inl(emu->port + A_IOCFG); outl(reg | A_IOCFG_GPOUT2, emu->port + A_IOCFG); udelay(500); @@ -282,27 +281,24 @@ static int snd_emu10k1_init(struct snd_emu10k1 *emu, int enable_ir, int resume) } } - if ( emu->card_capabilities->emu1212m) { - ; /* Disable all access to A_IOCFG for the emu1212m */ - } else if (emu->audigy) { /* enable analog output */ + if (emu->audigy) { /* enable analog output */ unsigned int reg = inl(emu->port + A_IOCFG); outl(reg | A_IOCFG_GPOUT0, emu->port + A_IOCFG); } - return 0; -} + /* + * Initialize the effect engine + */ + if ((err = snd_emu10k1_init_efx(emu)) < 0) + return err; -static void snd_emu10k1_audio_enable(struct snd_emu10k1 *emu) -{ /* * Enable the audio bit */ outl(inl(emu->port + HCFG) | HCFG_AUDIOENABLE, emu->port + HCFG); /* Enable analog/digital outs on audigy */ - if ( emu->card_capabilities->emu1212m) { - ; /* Disable all access to A_IOCFG for the emu1212m */ - } else if (emu->audigy) { + if (emu->audigy) { outl(inl(emu->port + A_IOCFG) & ~0x44, emu->port + A_IOCFG); if (emu->card_capabilities->ca0151_chip) { /* audigy2 */ @@ -338,9 +334,15 @@ static void snd_emu10k1_audio_enable(struct snd_emu10k1 *emu) #endif snd_emu10k1_intr_enable(emu, INTE_PCIERRORENABLE); + + emu->reserved_page = (emu10k1_memblk_t *)snd_emu10k1_synth_alloc(emu, 4096); + if (emu->reserved_page) + emu->reserved_page->map_locked = 1; + + return 0; } -int snd_emu10k1_done(struct snd_emu10k1 * emu) +static int snd_emu10k1_done(emu10k1_t * emu) { int ch; @@ -379,10 +381,18 @@ int snd_emu10k1_done(struct snd_emu10k1 * emu) snd_emu10k1_ptr_write(emu, SOLEL, 0, 0); snd_emu10k1_ptr_write(emu, SOLEH, 0, 0); + /* remove reserved page */ + if (emu->reserved_page != NULL) { + snd_emu10k1_synth_free(emu, (snd_util_memblk_t *)emu->reserved_page); + emu->reserved_page = NULL; + } + /* disable audio and lock cache */ outl(HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE, emu->port + HCFG); snd_emu10k1_ptr_write(emu, PTB, 0, 0); + snd_emu10k1_free_efx(emu); + return 0; } @@ -463,7 +473,7 @@ int snd_emu10k1_done(struct snd_emu10k1 * emu) * register. */ -static void snd_emu10k1_ecard_write(struct snd_emu10k1 * emu, unsigned int value) +static void snd_emu10k1_ecard_write(emu10k1_t * emu, unsigned int value) { unsigned short count; unsigned int data; @@ -501,7 +511,7 @@ static void snd_emu10k1_ecard_write(struct snd_emu10k1 * emu, unsigned int value * channel. */ -static void snd_emu10k1_ecard_setadcgain(struct snd_emu10k1 * emu, +static void snd_emu10k1_ecard_setadcgain(emu10k1_t * emu, unsigned short gain) { unsigned int bit; @@ -529,7 +539,7 @@ static void snd_emu10k1_ecard_setadcgain(struct snd_emu10k1 * emu, snd_emu10k1_ecard_write(emu, emu->ecard_ctrl); } -static int __devinit snd_emu10k1_ecard_init(struct snd_emu10k1 * emu) +static int __devinit snd_emu10k1_ecard_init(emu10k1_t * emu) { unsigned int hc_value; @@ -569,7 +579,7 @@ static int __devinit snd_emu10k1_ecard_init(struct snd_emu10k1 * emu) return 0; } -static int __devinit snd_emu10k1_cardbus_init(struct snd_emu10k1 * emu) +static int __devinit snd_emu10k1_cardbus_init(emu10k1_t * emu) { unsigned long special_port; unsigned int value; @@ -590,160 +600,18 @@ static int __devinit snd_emu10k1_cardbus_init(struct snd_emu10k1 * emu) outl(0x0090007f, special_port); value = inl(special_port); - snd_emu10k1_ptr20_write(emu, TINA2_VOLUME, 0, 0xfefefefe); /* Defaults to 0x30303030 */ - return 0; -} - -static int snd_emu1212m_fpga_write(struct snd_emu10k1 * emu, int reg, int value) -{ - if (reg<0 || reg>0x3f) - return 1; - reg+=0x40; /* 0x40 upwards are registers. */ - if (value<0 || value>0x3f) /* 0 to 0x3f are values */ - return 1; - outl(reg, emu->port + A_IOCFG); - outl(reg | 0x80, emu->port + A_IOCFG); /* High bit clocks the value into the fpga. */ - outl(value, emu->port + A_IOCFG); - outl(value | 0x80 , emu->port + A_IOCFG); /* High bit clocks the value into the fpga. */ - return 0; } -static int snd_emu1212m_fpga_read(struct snd_emu10k1 * emu, int reg, int *value) -{ - if (reg<0 || reg>0x3f) - return 1; - reg+=0x40; /* 0x40 upwards are registers. */ - outl(reg, emu->port + A_IOCFG); - outl(reg | 0x80, emu->port + A_IOCFG); /* High bit clocks the value into the fpga. */ - *value = inl(emu->port + A_IOCFG); - - return 0; -} - -static int snd_emu1212m_fpga_netlist_write(struct snd_emu10k1 * emu, int reg, int value) -{ - snd_emu1212m_fpga_write(emu, 0x00, ((reg >> 8) & 0x3f) ); - snd_emu1212m_fpga_write(emu, 0x01, (reg & 0x3f) ); - snd_emu1212m_fpga_write(emu, 0x02, ((value >> 8) & 0x3f) ); - snd_emu1212m_fpga_write(emu, 0x03, (value & 0x3f) ); - - return 0; -} - -static int __devinit snd_emu10k1_emu1212m_init(struct snd_emu10k1 * emu) -{ - unsigned int i; - int tmp; - - snd_printk(KERN_ERR "emu1212m: Special config.\n"); - outl(0x0005a00c, emu->port + HCFG); - outl(0x0005a004, emu->port + HCFG); - outl(0x0005a000, emu->port + HCFG); - outl(0x0005a000, emu->port + HCFG); - - snd_emu1212m_fpga_read(emu, 0x22, &tmp ); - snd_emu1212m_fpga_read(emu, 0x23, &tmp ); - snd_emu1212m_fpga_read(emu, 0x24, &tmp ); - snd_emu1212m_fpga_write(emu, 0x04, 0x01 ); - snd_emu1212m_fpga_read(emu, 0x0b, &tmp ); - snd_emu1212m_fpga_write(emu, 0x0b, 0x01 ); - snd_emu1212m_fpga_read(emu, 0x10, &tmp ); - snd_emu1212m_fpga_write(emu, 0x10, 0x00 ); - snd_emu1212m_fpga_read(emu, 0x11, &tmp ); - snd_emu1212m_fpga_write(emu, 0x11, 0x30 ); - snd_emu1212m_fpga_read(emu, 0x13, &tmp ); - snd_emu1212m_fpga_write(emu, 0x13, 0x0f ); - snd_emu1212m_fpga_read(emu, 0x11, &tmp ); - snd_emu1212m_fpga_write(emu, 0x11, 0x30 ); - snd_emu1212m_fpga_read(emu, 0x0a, &tmp ); - snd_emu1212m_fpga_write(emu, 0x0a, 0x10 ); - snd_emu1212m_fpga_write(emu, 0x0c, 0x19 ); - snd_emu1212m_fpga_write(emu, 0x12, 0x0c ); - snd_emu1212m_fpga_write(emu, 0x09, 0x0f ); - snd_emu1212m_fpga_write(emu, 0x06, 0x00 ); - snd_emu1212m_fpga_write(emu, 0x05, 0x00 ); - snd_emu1212m_fpga_write(emu, 0x0e, 0x12 ); - snd_emu1212m_fpga_netlist_write(emu, 0x0000, 0x0200); - snd_emu1212m_fpga_netlist_write(emu, 0x0001, 0x0201); - snd_emu1212m_fpga_netlist_write(emu, 0x0002, 0x0500); - snd_emu1212m_fpga_netlist_write(emu, 0x0003, 0x0501); - snd_emu1212m_fpga_netlist_write(emu, 0x0004, 0x0400); - snd_emu1212m_fpga_netlist_write(emu, 0x0005, 0x0401); - snd_emu1212m_fpga_netlist_write(emu, 0x0006, 0x0402); - snd_emu1212m_fpga_netlist_write(emu, 0x0007, 0x0403); - snd_emu1212m_fpga_netlist_write(emu, 0x0008, 0x0404); - snd_emu1212m_fpga_netlist_write(emu, 0x0009, 0x0405); - snd_emu1212m_fpga_netlist_write(emu, 0x000a, 0x0406); - snd_emu1212m_fpga_netlist_write(emu, 0x000b, 0x0407); - snd_emu1212m_fpga_netlist_write(emu, 0x000c, 0x0100); - snd_emu1212m_fpga_netlist_write(emu, 0x000d, 0x0104); - snd_emu1212m_fpga_netlist_write(emu, 0x000e, 0x0200); - snd_emu1212m_fpga_netlist_write(emu, 0x000f, 0x0201); - for (i=0;i < 0x20;i++) { - snd_emu1212m_fpga_netlist_write(emu, 0x0100+i, 0x0000); - } - for (i=0;i < 4;i++) { - snd_emu1212m_fpga_netlist_write(emu, 0x0200+i, 0x0000); - } - for (i=0;i < 7;i++) { - snd_emu1212m_fpga_netlist_write(emu, 0x0300+i, 0x0000); - } - for (i=0;i < 7;i++) { - snd_emu1212m_fpga_netlist_write(emu, 0x0400+i, 0x0000); - } - snd_emu1212m_fpga_netlist_write(emu, 0x0500, 0x0108); - snd_emu1212m_fpga_netlist_write(emu, 0x0501, 0x010c); - snd_emu1212m_fpga_netlist_write(emu, 0x0600, 0x0110); - snd_emu1212m_fpga_netlist_write(emu, 0x0601, 0x0114); - snd_emu1212m_fpga_netlist_write(emu, 0x0700, 0x0118); - snd_emu1212m_fpga_netlist_write(emu, 0x0701, 0x011c); - snd_emu1212m_fpga_write(emu, 0x07, 0x01 ); - - snd_emu1212m_fpga_read(emu, 0x21, &tmp ); - - outl(0x0000a000, emu->port + HCFG); - outl(0x0000a001, emu->port + HCFG); - /* Initial boot complete. Now patches */ - - snd_emu1212m_fpga_read(emu, 0x21, &tmp ); - snd_emu1212m_fpga_write(emu, 0x0c, 0x19 ); - snd_emu1212m_fpga_write(emu, 0x12, 0x0c ); - snd_emu1212m_fpga_write(emu, 0x0c, 0x19 ); - snd_emu1212m_fpga_write(emu, 0x12, 0x0c ); - snd_emu1212m_fpga_read(emu, 0x0a, &tmp ); - snd_emu1212m_fpga_write(emu, 0x0a, 0x10 ); - - snd_emu1212m_fpga_read(emu, 0x20, &tmp ); - snd_emu1212m_fpga_read(emu, 0x21, &tmp ); - - snd_emu1212m_fpga_netlist_write(emu, 0x0300, 0x0312); - snd_emu1212m_fpga_netlist_write(emu, 0x0301, 0x0313); - snd_emu1212m_fpga_netlist_write(emu, 0x0200, 0x0302); - snd_emu1212m_fpga_netlist_write(emu, 0x0201, 0x0303); - - return 0; -} /* * Create the EMU10K1 instance */ -#ifdef CONFIG_PM -static int alloc_pm_buffer(struct snd_emu10k1 *emu); -static void free_pm_buffer(struct snd_emu10k1 *emu); -#endif - -static int snd_emu10k1_free(struct snd_emu10k1 *emu) +static int snd_emu10k1_free(emu10k1_t *emu) { if (emu->port) { /* avoid access to already used hardware */ snd_emu10k1_fx8010_tram_setup(emu, 0); snd_emu10k1_done(emu); - /* remove reserved page */ - if (emu->reserved_page) { - snd_emu10k1_synth_free(emu, (struct snd_util_memblk *)emu->reserved_page); - emu->reserved_page = NULL; - } - snd_emu10k1_free_efx(emu); } if (emu->memhdr) snd_util_memhdr_free(emu->memhdr); @@ -753,35 +621,26 @@ static int snd_emu10k1_free(struct snd_emu10k1 *emu) snd_dma_free_pages(&emu->ptb_pages); vfree(emu->page_ptr_table); vfree(emu->page_addr_table); -#ifdef CONFIG_PM - free_pm_buffer(emu); -#endif if (emu->irq >= 0) free_irq(emu->irq, (void *)emu); if (emu->port) pci_release_regions(emu->pci); + pci_disable_device(emu->pci); if (emu->card_capabilities->ca0151_chip) /* P16V */ snd_p16v_free(emu); - pci_disable_device(emu->pci); kfree(emu); return 0; } -static int snd_emu10k1_dev_free(struct snd_device *device) +static int snd_emu10k1_dev_free(snd_device_t *device) { - struct snd_emu10k1 *emu = device->device_data; + emu10k1_t *emu = device->device_data; return snd_emu10k1_free(emu); } -static struct snd_emu_chip_details emu_chip_details[] = { +static emu_chip_details_t emu_chip_details[] = { /* Audigy 2 Value AC3 out does not work yet. Need to find out how to turn off interpolators.*/ /* Tested by James@superbug.co.uk 3rd July 2005 */ - /* DSP: CA0108-IAT - * DAC: CS4382-KQ - * ADC: Philips 1361T - * AC97: STAC9750 - * CA0151: None - */ {.vendor = 0x1102, .device = 0x0008, .subsystem = 0x10011102, .driver = "Audigy2", .name = "Audigy 2 Value [SB0400]", .id = "Audigy2", @@ -790,24 +649,14 @@ static struct snd_emu_chip_details emu_chip_details[] = { .spk71 = 1, .ac97_chip = 1} , /* Audigy 2 ZS Notebook Cardbus card.*/ - /* Tested by James@superbug.co.uk 22th December 2005 */ - /* Audio output 7.1/Headphones working. - * Digital output working. (AC3 not checked, only PCM) - * Audio inputs not tested. - */ - /* DSP: Tiny2 - * DAC: Wolfson WM8768/WM8568 - * ADC: Wolfson WM8775 - * AC97: None - * CA0151: None - */ + /* Tested by James@superbug.co.uk 30th October 2005 */ + /* Not working yet, but progressing. */ {.vendor = 0x1102, .device = 0x0008, .subsystem = 0x20011102, .driver = "Audigy2", .name = "Audigy 2 ZS Notebook [SB0530]", .id = "Audigy2", .emu10k2_chip = 1, .ca0108_chip = 1, .ca_cardbus_chip = 1, - .spi_dac = 1, .spk71 = 1} , {.vendor = 0x1102, .device = 0x0008, .driver = "Audigy2", .name = "Audigy 2 Value [Unknown]", @@ -821,7 +670,7 @@ static struct snd_emu_chip_details emu_chip_details[] = { .id = "EMU1212m", .emu10k2_chip = 1, .ca0102_chip = 1, - .emu1212m = 1} , + .ecard = 1} , /* Tested by James@superbug.co.uk 3rd July 2005 */ {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x20071102, .driver = "Audigy2", .name = "Audigy 4 PRO [SB0380]", @@ -832,16 +681,6 @@ static struct snd_emu_chip_details emu_chip_details[] = { .spk71 = 1, .spdif_bug = 1, .ac97_chip = 1} , - /* Tested by shane-alsa@cm.nu 5th Nov 2005 */ - {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x20061102, - .driver = "Audigy2", .name = "Audigy 2 [2006]", - .id = "Audigy2", - .emu10k2_chip = 1, - .ca0102_chip = 1, - .ca0151_chip = 1, - .spk71 = 1, - .spdif_bug = 1, - .ac97_chip = 1} , {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x20021102, .driver = "Audigy2", .name = "Audigy 2 ZS [SB0350]", .id = "Audigy2", @@ -860,14 +699,6 @@ static struct snd_emu_chip_details emu_chip_details[] = { .spk71 = 1, .spdif_bug = 1, .ac97_chip = 1} , - /* Audigy 2 */ - /* Tested by James@superbug.co.uk 3rd July 2005 */ - /* DSP: CA0102-IAT - * DAC: CS4382-KQ - * ADC: Philips 1361T - * AC97: STAC9721 - * CA0151: Yes - */ {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x10071102, .driver = "Audigy2", .name = "Audigy 2 [SB0240]", .id = "Audigy2", @@ -883,7 +714,6 @@ static struct snd_emu_chip_details emu_chip_details[] = { .emu10k2_chip = 1, .ca0102_chip = 1, .ca0151_chip = 1, - .spk71 = 1, .spdif_bug = 1} , {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x10021102, .driver = "Audigy2", .name = "Audigy 2 Platinum [SB0240P]", @@ -945,14 +775,6 @@ static struct snd_emu_chip_details emu_chip_details[] = { .emu10k1_chip = 1, .ac97_chip = 1, .sblive51 = 1} , - /* Tested by ALSA bug#1680 26th December 2005 */ - /* note: It really has SB0220 written on the card. */ - {.vendor = 0x1102, .device = 0x0002, .subsystem = 0x80661102, - .driver = "EMU10K1", .name = "SB Live 5.1 Dell OEM [SB0220]", - .id = "Live", - .emu10k1_chip = 1, - .ac97_chip = 1, - .sblive51 = 1} , /* Tested by Thomas Zehetbauer 27th Aug 2005 */ {.vendor = 0x1102, .device = 0x0002, .subsystem = 0x80651102, .driver = "EMU10K1", .name = "SB Live 5.1 [SB0220]", @@ -960,12 +782,6 @@ static struct snd_emu_chip_details emu_chip_details[] = { .emu10k1_chip = 1, .ac97_chip = 1, .sblive51 = 1} , - {.vendor = 0x1102, .device = 0x0002, .subsystem = 0x100a1102, - .driver = "EMU10K1", .name = "SB Live 5.1 [SB0220]", - .id = "Live", - .emu10k1_chip = 1, - .ac97_chip = 1, - .sblive51 = 1} , {.vendor = 0x1102, .device = 0x0002, .subsystem = 0x80641102, .driver = "EMU10K1", .name = "SB Live 5.1", .id = "Live", @@ -1061,22 +877,21 @@ static struct snd_emu_chip_details emu_chip_details[] = { { } /* terminator */ }; -int __devinit snd_emu10k1_create(struct snd_card *card, +int __devinit snd_emu10k1_create(snd_card_t * card, struct pci_dev * pci, unsigned short extin_mask, unsigned short extout_mask, long max_cache_bytes, int enable_ir, uint subsystem, - struct snd_emu10k1 ** remu) + emu10k1_t ** remu) { - struct snd_emu10k1 *emu; - int idx, err; + emu10k1_t *emu; + int err; int is_audigy; unsigned char revision; - unsigned int silent_page; - const struct snd_emu_chip_details *c; - static struct snd_device_ops ops = { + const emu_chip_details_t *c; + static snd_device_ops_t ops = { .dev_free = snd_emu10k1_dev_free, }; @@ -1184,37 +999,36 @@ int __devinit snd_emu10k1_create(struct snd_card *card, emu->port = pci_resource_start(pci, 0); if (request_irq(pci->irq, snd_emu10k1_interrupt, SA_INTERRUPT|SA_SHIRQ, "EMU10K1", (void *)emu)) { - err = -EBUSY; - goto error; + snd_emu10k1_free(emu); + return -EBUSY; } emu->irq = pci->irq; emu->max_cache_pages = max_cache_bytes >> PAGE_SHIFT; if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 32 * 1024, &emu->ptb_pages) < 0) { - err = -ENOMEM; - goto error; + snd_emu10k1_free(emu); + return -ENOMEM; } emu->page_ptr_table = (void **)vmalloc(emu->max_cache_pages * sizeof(void*)); emu->page_addr_table = (unsigned long*)vmalloc(emu->max_cache_pages * sizeof(unsigned long)); if (emu->page_ptr_table == NULL || emu->page_addr_table == NULL) { - err = -ENOMEM; - goto error; + snd_emu10k1_free(emu); + return -ENOMEM; } if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), EMUPAGESIZE, &emu->silent_page) < 0) { - err = -ENOMEM; - goto error; + snd_emu10k1_free(emu); + return -ENOMEM; } emu->memhdr = snd_util_memhdr_new(emu->max_cache_pages * PAGE_SIZE); if (emu->memhdr == NULL) { - err = -ENOMEM; - goto error; + snd_emu10k1_free(emu); + return -ENOMEM; } - emu->memhdr->block_extra_size = sizeof(struct snd_emu10k1_memblk) - - sizeof(struct snd_util_memblk); + emu->memhdr->block_extra_size = sizeof(emu10k1_memblk_t) - sizeof(snd_util_memblk_t); pci_set_master(pci); @@ -1225,191 +1039,40 @@ int __devinit snd_emu10k1_create(struct snd_card *card, extout_mask = 0x7fff; emu->fx8010.extin_mask = extin_mask; emu->fx8010.extout_mask = extout_mask; - emu->enable_ir = enable_ir; if (emu->card_capabilities->ecard) { - if ((err = snd_emu10k1_ecard_init(emu)) < 0) - goto error; + if ((err = snd_emu10k1_ecard_init(emu)) < 0) { + snd_emu10k1_free(emu); + return err; + } } else if (emu->card_capabilities->ca_cardbus_chip) { - if ((err = snd_emu10k1_cardbus_init(emu)) < 0) - goto error; - } else if (emu->card_capabilities->emu1212m) { - if ((err = snd_emu10k1_emu1212m_init(emu)) < 0) { - snd_emu10k1_free(emu); - return err; - } + if ((err = snd_emu10k1_cardbus_init(emu)) < 0) { + snd_emu10k1_free(emu); + return err; + } } else { /* 5.1: Enable the additional AC97 Slots. If the emu10k1 version does not support this, it shouldn't do any harm */ snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE); } - /* initialize TRAM setup */ - emu->fx8010.itram_size = (16 * 1024)/2; - emu->fx8010.etram_pages.area = NULL; - emu->fx8010.etram_pages.bytes = 0; - - /* - * Init to 0x02109204 : - * Clock accuracy = 0 (1000ppm) - * Sample Rate = 2 (48kHz) - * Audio Channel = 1 (Left of 2) - * Source Number = 0 (Unspecified) - * Generation Status = 1 (Original for Cat Code 12) - * Cat Code = 12 (Digital Signal Mixer) - * Mode = 0 (Mode 0) - * Emphasis = 0 (None) - * CP = 1 (Copyright unasserted) - * AN = 0 (Audio data) - * P = 0 (Consumer) - */ - emu->spdif_bits[0] = emu->spdif_bits[1] = - emu->spdif_bits[2] = SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 | - SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | - SPCS_GENERATIONSTATUS | 0x00001200 | - 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT; - - emu->reserved_page = (struct snd_emu10k1_memblk *) - snd_emu10k1_synth_alloc(emu, 4096); - if (emu->reserved_page) - emu->reserved_page->map_locked = 1; - - /* Clear silent pages and set up pointers */ - memset(emu->silent_page.area, 0, PAGE_SIZE); - silent_page = emu->silent_page.addr << 1; - for (idx = 0; idx < MAXPAGES; idx++) - ((u32 *)emu->ptb_pages.area)[idx] = cpu_to_le32(silent_page | idx); - - /* set up voice indices */ - for (idx = 0; idx < NUM_G; idx++) { - emu->voices[idx].emu = emu; - emu->voices[idx].number = idx; + if ((err = snd_emu10k1_init(emu, enable_ir)) < 0) { + snd_emu10k1_free(emu); + return err; } - if ((err = snd_emu10k1_init(emu, enable_ir, 0)) < 0) - goto error; -#ifdef CONFIG_PM - if ((err = alloc_pm_buffer(emu)) < 0) - goto error; -#endif - - /* Initialize the effect engine */ - if ((err = snd_emu10k1_init_efx(emu)) < 0) - goto error; - snd_emu10k1_audio_enable(emu); - - if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, emu, &ops)) < 0) - goto error; + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, emu, &ops)) < 0) { + snd_emu10k1_free(emu); + return err; + } -#ifdef CONFIG_PROC_FS snd_emu10k1_proc_init(emu); -#endif snd_card_set_dev(card, &pci->dev); *remu = emu; return 0; - - error: - snd_emu10k1_free(emu); - return err; } -#ifdef CONFIG_PM -static unsigned char saved_regs[] = { - CPF, PTRX, CVCF, VTFT, Z1, Z2, PSST, DSL, CCCA, CCR, CLP, - FXRT, MAPA, MAPB, ENVVOL, ATKHLDV, DCYSUSV, LFOVAL1, ENVVAL, - ATKHLDM, DCYSUSM, LFOVAL2, IP, IFATN, PEFE, FMMOD, TREMFRQ, FM2FRQ2, - TEMPENV, ADCCR, FXWC, MICBA, ADCBA, FXBA, - MICBS, ADCBS, FXBS, CDCS, GPSCS, SPCS0, SPCS1, SPCS2, - SPBYPASS, AC97SLOT, CDSRCS, GPSRCS, ZVSRCS, MICIDX, ADCIDX, FXIDX, - 0xff /* end */ -}; -static unsigned char saved_regs_audigy[] = { - A_ADCIDX, A_MICIDX, A_FXWC1, A_FXWC2, A_SAMPLE_RATE, - A_FXRT2, A_SENDAMOUNTS, A_FXRT1, - 0xff /* end */ -}; - -static int __devinit alloc_pm_buffer(struct snd_emu10k1 *emu) -{ - int size; - - size = ARRAY_SIZE(saved_regs); - if (emu->audigy) - size += ARRAY_SIZE(saved_regs_audigy); - emu->saved_ptr = vmalloc(4 * NUM_G * size); - if (! emu->saved_ptr) - return -ENOMEM; - if (snd_emu10k1_efx_alloc_pm_buffer(emu) < 0) - return -ENOMEM; - if (emu->card_capabilities->ca0151_chip && - snd_p16v_alloc_pm_buffer(emu) < 0) - return -ENOMEM; - return 0; -} - -static void free_pm_buffer(struct snd_emu10k1 *emu) -{ - vfree(emu->saved_ptr); - snd_emu10k1_efx_free_pm_buffer(emu); - if (emu->card_capabilities->ca0151_chip) - snd_p16v_free_pm_buffer(emu); -} - -void snd_emu10k1_suspend_regs(struct snd_emu10k1 *emu) -{ - int i; - unsigned char *reg; - unsigned int *val; - - val = emu->saved_ptr; - for (reg = saved_regs; *reg != 0xff; reg++) - for (i = 0; i < NUM_G; i++, val++) - *val = snd_emu10k1_ptr_read(emu, *reg, i); - if (emu->audigy) { - for (reg = saved_regs_audigy; *reg != 0xff; reg++) - for (i = 0; i < NUM_G; i++, val++) - *val = snd_emu10k1_ptr_read(emu, *reg, i); - } - if (emu->audigy) - emu->saved_a_iocfg = inl(emu->port + A_IOCFG); - emu->saved_hcfg = inl(emu->port + HCFG); -} - -void snd_emu10k1_resume_init(struct snd_emu10k1 *emu) -{ - if (emu->card_capabilities->ecard) - snd_emu10k1_ecard_init(emu); - else - snd_emu10k1_ptr_write(emu, AC97SLOT, 0, AC97SLOT_CNTR|AC97SLOT_LFE); - snd_emu10k1_init(emu, emu->enable_ir, 1); -} - -void snd_emu10k1_resume_regs(struct snd_emu10k1 *emu) -{ - int i; - unsigned char *reg; - unsigned int *val; - - snd_emu10k1_audio_enable(emu); - - /* resore for spdif */ - if (emu->audigy) - outl(emu->port + A_IOCFG, emu->saved_a_iocfg); - outl(emu->port + HCFG, emu->saved_hcfg); - - val = emu->saved_ptr; - for (reg = saved_regs; *reg != 0xff; reg++) - for (i = 0; i < NUM_G; i++, val++) - snd_emu10k1_ptr_write(emu, *reg, i, *val); - if (emu->audigy) { - for (reg = saved_regs_audigy; *reg != 0xff; reg++) - for (i = 0; i < NUM_G; i++, val++) - snd_emu10k1_ptr_write(emu, *reg, i, *val); - } -} -#endif - /* memory.c */ EXPORT_SYMBOL(snd_emu10k1_synth_alloc); EXPORT_SYMBOL(snd_emu10k1_synth_free); diff --git a/trunk/sound/pci/emu10k1/emu10k1_patch.c b/trunk/sound/pci/emu10k1/emu10k1_patch.c index 42bae6f7e9a4..4df668eb32b4 100644 --- a/trunk/sound/pci/emu10k1/emu10k1_patch.c +++ b/trunk/sound/pci/emu10k1/emu10k1_patch.c @@ -35,15 +35,14 @@ * allocate a sample block and copy data from userspace */ int -snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr, - const void __user *data, long count) +snd_emu10k1_sample_new(snd_emux_t *rec, snd_sf_sample_t *sp, + snd_util_memhdr_t *hdr, const void __user *data, long count) { int offset; int truesize, size, loopsize, blocksize; int loopend, sampleend; unsigned int start_addr; - struct snd_emu10k1 *emu; + emu10k1_t *emu; emu = rec->hw; snd_assert(sp != NULL, return -EINVAL); @@ -206,10 +205,10 @@ snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp, * free a sample block */ int -snd_emu10k1_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr) +snd_emu10k1_sample_free(snd_emux_t *rec, snd_sf_sample_t *sp, + snd_util_memhdr_t *hdr) { - struct snd_emu10k1 *emu; + emu10k1_t *emu; emu = rec->hw; snd_assert(sp != NULL, return -EINVAL); diff --git a/trunk/sound/pci/emu10k1/emu10k1_synth.c b/trunk/sound/pci/emu10k1/emu10k1_synth.c index 1fa393f22a99..8bd58d1dcc26 100644 --- a/trunk/sound/pci/emu10k1/emu10k1_synth.c +++ b/trunk/sound/pci/emu10k1/emu10k1_synth.c @@ -28,11 +28,11 @@ MODULE_LICENSE("GPL"); /* * create a new hardware dependent device for Emu10k1 */ -static int snd_emu10k1_synth_new_device(struct snd_seq_device *dev) +static int snd_emu10k1_synth_new_device(snd_seq_device_t *dev) { - struct snd_emux *emu; - struct snd_emu10k1 *hw; - struct snd_emu10k1_synth_arg *arg; + snd_emux_t *emu; + emu10k1_t *hw; + snd_emu10k1_synth_arg_t *arg; unsigned long flags; arg = SNDRV_SEQ_DEVICE_ARGPTR(dev); @@ -76,10 +76,10 @@ static int snd_emu10k1_synth_new_device(struct snd_seq_device *dev) return 0; } -static int snd_emu10k1_synth_delete_device(struct snd_seq_device *dev) +static int snd_emu10k1_synth_delete_device(snd_seq_device_t *dev) { - struct snd_emux *emu; - struct snd_emu10k1 *hw; + snd_emux_t *emu; + emu10k1_t *hw; unsigned long flags; if (dev->driver_data == NULL) @@ -104,12 +104,11 @@ static int snd_emu10k1_synth_delete_device(struct snd_seq_device *dev) static int __init alsa_emu10k1_synth_init(void) { - static struct snd_seq_dev_ops ops = { + static snd_seq_dev_ops_t ops = { snd_emu10k1_synth_new_device, snd_emu10k1_synth_delete_device, }; - return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH, &ops, - sizeof(struct snd_emu10k1_synth_arg)); + return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH, &ops, sizeof(snd_emu10k1_synth_arg_t)); } static void __exit alsa_emu10k1_synth_exit(void) diff --git a/trunk/sound/pci/emu10k1/emu10k1_synth_local.h b/trunk/sound/pci/emu10k1/emu10k1_synth_local.h index 308ddc84bb4d..7f50b01ddb76 100644 --- a/trunk/sound/pci/emu10k1/emu10k1_synth_local.h +++ b/trunk/sound/pci/emu10k1/emu10k1_synth_local.h @@ -26,18 +26,13 @@ #include <sound/emu10k1_synth.h> /* emu10k1_patch.c */ -int snd_emu10k1_sample_new(struct snd_emux *private_data, - struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr, - const void __user *_data, long count); -int snd_emu10k1_sample_free(struct snd_emux *private_data, - struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr); -int snd_emu10k1_memhdr_init(struct snd_emux *emu); +int snd_emu10k1_sample_new(snd_emux_t *private_data, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr, const void __user *_data, long count); +int snd_emu10k1_sample_free(snd_emux_t *private_data, snd_sf_sample_t *sp, snd_util_memhdr_t *hdr); +int snd_emu10k1_memhdr_init(snd_emux_t *emu); /* emu10k1_callback.c */ -void snd_emu10k1_ops_setup(struct snd_emux *emu); -int snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw); +void snd_emu10k1_ops_setup(snd_emux_t *emu); +int snd_emu10k1_synth_get_voice(emu10k1_t *hw); #endif /* __EMU10K1_SYNTH_LOCAL_H */ diff --git a/trunk/sound/pci/emu10k1/emu10k1x.c b/trunk/sound/pci/emu10k1/emu10k1x.c index 1107c8ec7f78..795577716a5d 100644 --- a/trunk/sound/pci/emu10k1/emu10k1x.c +++ b/trunk/sound/pci/emu10k1/emu10k1x.c @@ -195,26 +195,30 @@ MODULE_PARM_DESC(enable, "Enable the EMU10K1X soundcard."); * playback. */ -struct emu10k1x_voice { - struct emu10k1x *emu; +typedef struct snd_emu10k1x_voice emu10k1x_voice_t; +typedef struct snd_emu10k1x emu10k1x_t; +typedef struct snd_emu10k1x_pcm emu10k1x_pcm_t; + +struct snd_emu10k1x_voice { + emu10k1x_t *emu; int number; int use; - struct emu10k1x_pcm *epcm; + emu10k1x_pcm_t *epcm; }; -struct emu10k1x_pcm { - struct emu10k1x *emu; - struct snd_pcm_substream *substream; - struct emu10k1x_voice *voice; +struct snd_emu10k1x_pcm { + emu10k1x_t *emu; + snd_pcm_substream_t *substream; + emu10k1x_voice_t *voice; unsigned short running; }; -struct emu10k1x_midi { - struct emu10k1x *emu; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *substream_input; - struct snd_rawmidi_substream *substream_output; +typedef struct { + struct snd_emu10k1x *emu; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *substream_input; + snd_rawmidi_substream_t *substream_output; unsigned int midi_mode; spinlock_t input_lock; spinlock_t output_lock; @@ -222,12 +226,12 @@ struct emu10k1x_midi { int tx_enable, rx_enable; int port; int ipr_tx, ipr_rx; - void (*interrupt)(struct emu10k1x *emu, unsigned int status); -}; + void (*interrupt)(emu10k1x_t *emu, unsigned int status); +} emu10k1x_midi_t; // definition of the chip-specific record -struct emu10k1x { - struct snd_card *card; +struct snd_emu10k1x { + snd_card_t *card; struct pci_dev *pci; unsigned long port; @@ -241,20 +245,20 @@ struct emu10k1x { spinlock_t emu_lock; spinlock_t voice_lock; - struct snd_ac97 *ac97; - struct snd_pcm *pcm; + ac97_t *ac97; + snd_pcm_t *pcm; - struct emu10k1x_voice voices[3]; - struct emu10k1x_voice capture_voice; + emu10k1x_voice_t voices[3]; + emu10k1x_voice_t capture_voice; u32 spdif_bits[3]; // SPDIF out setup struct snd_dma_buffer dma_buffer; - struct emu10k1x_midi midi; + emu10k1x_midi_t midi; }; /* hardware definition */ -static struct snd_pcm_hardware snd_emu10k1x_playback_hw = { +static snd_pcm_hardware_t snd_emu10k1x_playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -273,7 +277,7 @@ static struct snd_pcm_hardware snd_emu10k1x_playback_hw = { .fifo_size = 0, }; -static struct snd_pcm_hardware snd_emu10k1x_capture_hw = { +static snd_pcm_hardware_t snd_emu10k1x_capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -292,7 +296,7 @@ static struct snd_pcm_hardware snd_emu10k1x_capture_hw = { .fifo_size = 0, }; -static unsigned int snd_emu10k1x_ptr_read(struct emu10k1x * emu, +static unsigned int snd_emu10k1x_ptr_read(emu10k1x_t * emu, unsigned int reg, unsigned int chn) { @@ -308,7 +312,7 @@ static unsigned int snd_emu10k1x_ptr_read(struct emu10k1x * emu, return val; } -static void snd_emu10k1x_ptr_write(struct emu10k1x *emu, +static void snd_emu10k1x_ptr_write(emu10k1x_t *emu, unsigned int reg, unsigned int chn, unsigned int data) @@ -324,7 +328,7 @@ static void snd_emu10k1x_ptr_write(struct emu10k1x *emu, spin_unlock_irqrestore(&emu->emu_lock, flags); } -static void snd_emu10k1x_intr_enable(struct emu10k1x *emu, unsigned int intrenb) +static void snd_emu10k1x_intr_enable(emu10k1x_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int enable; @@ -335,7 +339,7 @@ static void snd_emu10k1x_intr_enable(struct emu10k1x *emu, unsigned int intrenb) spin_unlock_irqrestore(&emu->emu_lock, flags); } -static void snd_emu10k1x_intr_disable(struct emu10k1x *emu, unsigned int intrenb) +static void snd_emu10k1x_intr_disable(emu10k1x_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int enable; @@ -346,7 +350,7 @@ static void snd_emu10k1x_intr_disable(struct emu10k1x *emu, unsigned int intrenb spin_unlock_irqrestore(&emu->emu_lock, flags); } -static void snd_emu10k1x_gpio_write(struct emu10k1x *emu, unsigned int value) +static void snd_emu10k1x_gpio_write(emu10k1x_t *emu, unsigned int value) { unsigned long flags; @@ -355,14 +359,14 @@ static void snd_emu10k1x_gpio_write(struct emu10k1x *emu, unsigned int value) spin_unlock_irqrestore(&emu->emu_lock, flags); } -static void snd_emu10k1x_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_emu10k1x_pcm_free_substream(snd_pcm_runtime_t *runtime) { kfree(runtime->private_data); } -static void snd_emu10k1x_pcm_interrupt(struct emu10k1x *emu, struct emu10k1x_voice *voice) +static void snd_emu10k1x_pcm_interrupt(emu10k1x_t *emu, emu10k1x_voice_t *voice) { - struct emu10k1x_pcm *epcm; + emu10k1x_pcm_t *epcm; if ((epcm = voice->epcm) == NULL) return; @@ -378,11 +382,11 @@ static void snd_emu10k1x_pcm_interrupt(struct emu10k1x *emu, struct emu10k1x_voi } /* open callback */ -static int snd_emu10k1x_playback_open(struct snd_pcm_substream *substream) +static int snd_emu10k1x_playback_open(snd_pcm_substream_t *substream) { - struct emu10k1x *chip = snd_pcm_substream_chip(substream); - struct emu10k1x_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1x_t *chip = snd_pcm_substream_chip(substream); + emu10k1x_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) { @@ -406,17 +410,17 @@ static int snd_emu10k1x_playback_open(struct snd_pcm_substream *substream) } /* close callback */ -static int snd_emu10k1x_playback_close(struct snd_pcm_substream *substream) +static int snd_emu10k1x_playback_close(snd_pcm_substream_t *substream) { return 0; } /* hw_params callback */ -static int snd_emu10k1x_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_emu10k1x_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm = runtime->private_data; if (! epcm->voice) { epcm->voice = &epcm->emu->voices[substream->pcm->device]; @@ -429,10 +433,10 @@ static int snd_emu10k1x_pcm_hw_params(struct snd_pcm_substream *substream, } /* hw_free callback */ -static int snd_emu10k1x_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_emu10k1x_pcm_hw_free(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm; if (runtime->private_data == NULL) return 0; @@ -449,11 +453,11 @@ static int snd_emu10k1x_pcm_hw_free(struct snd_pcm_substream *substream) } /* prepare callback */ -static int snd_emu10k1x_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_emu10k1x_pcm_prepare(snd_pcm_substream_t *substream) { - struct emu10k1x *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm = runtime->private_data; + emu10k1x_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm = runtime->private_data; int voice = epcm->voice->number; u32 *table_base = (u32 *)(emu->dma_buffer.area+1024*voice); u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size); @@ -478,12 +482,12 @@ static int snd_emu10k1x_pcm_prepare(struct snd_pcm_substream *substream) } /* trigger callback */ -static int snd_emu10k1x_pcm_trigger(struct snd_pcm_substream *substream, +static int snd_emu10k1x_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct emu10k1x *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm = runtime->private_data; + emu10k1x_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm = runtime->private_data; int channel = epcm->voice->number; int result = 0; @@ -512,11 +516,11 @@ static int snd_emu10k1x_pcm_trigger(struct snd_pcm_substream *substream, /* pointer callback */ static snd_pcm_uframes_t -snd_emu10k1x_pcm_pointer(struct snd_pcm_substream *substream) +snd_emu10k1x_pcm_pointer(snd_pcm_substream_t *substream) { - struct emu10k1x *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm = runtime->private_data; + emu10k1x_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm = runtime->private_data; int channel = epcm->voice->number; snd_pcm_uframes_t ptr = 0, ptr1 = 0, ptr2= 0,ptr3 = 0,ptr4 = 0; @@ -543,7 +547,7 @@ snd_emu10k1x_pcm_pointer(struct snd_pcm_substream *substream) } /* operators */ -static struct snd_pcm_ops snd_emu10k1x_playback_ops = { +static snd_pcm_ops_t snd_emu10k1x_playback_ops = { .open = snd_emu10k1x_playback_open, .close = snd_emu10k1x_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -555,11 +559,11 @@ static struct snd_pcm_ops snd_emu10k1x_playback_ops = { }; /* open_capture callback */ -static int snd_emu10k1x_pcm_open_capture(struct snd_pcm_substream *substream) +static int snd_emu10k1x_pcm_open_capture(snd_pcm_substream_t *substream) { - struct emu10k1x *chip = snd_pcm_substream_chip(substream); - struct emu10k1x_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1x_t *chip = snd_pcm_substream_chip(substream); + emu10k1x_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; int err; if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) @@ -583,17 +587,17 @@ static int snd_emu10k1x_pcm_open_capture(struct snd_pcm_substream *substream) } /* close callback */ -static int snd_emu10k1x_pcm_close_capture(struct snd_pcm_substream *substream) +static int snd_emu10k1x_pcm_close_capture(snd_pcm_substream_t *substream) { return 0; } /* hw_params callback */ -static int snd_emu10k1x_pcm_hw_params_capture(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_emu10k1x_pcm_hw_params_capture(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm = runtime->private_data; if (! epcm->voice) { if (epcm->emu->capture_voice.use) @@ -608,11 +612,11 @@ static int snd_emu10k1x_pcm_hw_params_capture(struct snd_pcm_substream *substrea } /* hw_free callback */ -static int snd_emu10k1x_pcm_hw_free_capture(struct snd_pcm_substream *substream) +static int snd_emu10k1x_pcm_hw_free_capture(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; - struct emu10k1x_pcm *epcm; + emu10k1x_pcm_t *epcm; if (runtime->private_data == NULL) return 0; @@ -628,10 +632,10 @@ static int snd_emu10k1x_pcm_hw_free_capture(struct snd_pcm_substream *substream) } /* prepare capture callback */ -static int snd_emu10k1x_pcm_prepare_capture(struct snd_pcm_substream *substream) +static int snd_emu10k1x_pcm_prepare_capture(snd_pcm_substream_t *substream) { - struct emu10k1x *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1x_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_emu10k1x_ptr_write(emu, CAPTURE_DMA_ADDR, 0, runtime->dma_addr); snd_emu10k1x_ptr_write(emu, CAPTURE_BUFFER_SIZE, 0, frames_to_bytes(runtime, runtime->buffer_size)<<16); // buffer size in bytes @@ -642,12 +646,12 @@ static int snd_emu10k1x_pcm_prepare_capture(struct snd_pcm_substream *substream) } /* trigger_capture callback */ -static int snd_emu10k1x_pcm_trigger_capture(struct snd_pcm_substream *substream, +static int snd_emu10k1x_pcm_trigger_capture(snd_pcm_substream_t *substream, int cmd) { - struct emu10k1x *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm = runtime->private_data; + emu10k1x_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm = runtime->private_data; int result = 0; switch (cmd) { @@ -672,11 +676,11 @@ static int snd_emu10k1x_pcm_trigger_capture(struct snd_pcm_substream *substream, /* pointer_capture callback */ static snd_pcm_uframes_t -snd_emu10k1x_pcm_pointer_capture(struct snd_pcm_substream *substream) +snd_emu10k1x_pcm_pointer_capture(snd_pcm_substream_t *substream) { - struct emu10k1x *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct emu10k1x_pcm *epcm = runtime->private_data; + emu10k1x_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1x_pcm_t *epcm = runtime->private_data; snd_pcm_uframes_t ptr; if (!epcm->running) @@ -689,7 +693,7 @@ snd_emu10k1x_pcm_pointer_capture(struct snd_pcm_substream *substream) return ptr; } -static struct snd_pcm_ops snd_emu10k1x_capture_ops = { +static snd_pcm_ops_t snd_emu10k1x_capture_ops = { .open = snd_emu10k1x_pcm_open_capture, .close = snd_emu10k1x_pcm_close_capture, .ioctl = snd_pcm_lib_ioctl, @@ -700,10 +704,10 @@ static struct snd_pcm_ops snd_emu10k1x_capture_ops = { .pointer = snd_emu10k1x_pcm_pointer_capture, }; -static unsigned short snd_emu10k1x_ac97_read(struct snd_ac97 *ac97, +static unsigned short snd_emu10k1x_ac97_read(ac97_t *ac97, unsigned short reg) { - struct emu10k1x *emu = ac97->private_data; + emu10k1x_t *emu = ac97->private_data; unsigned long flags; unsigned short val; @@ -714,10 +718,10 @@ static unsigned short snd_emu10k1x_ac97_read(struct snd_ac97 *ac97, return val; } -static void snd_emu10k1x_ac97_write(struct snd_ac97 *ac97, +static void snd_emu10k1x_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct emu10k1x *emu = ac97->private_data; + emu10k1x_t *emu = ac97->private_data; unsigned long flags; spin_lock_irqsave(&emu->emu_lock, flags); @@ -726,12 +730,12 @@ static void snd_emu10k1x_ac97_write(struct snd_ac97 *ac97, spin_unlock_irqrestore(&emu->emu_lock, flags); } -static int snd_emu10k1x_ac97(struct emu10k1x *chip) +static int snd_emu10k1x_ac97(emu10k1x_t *chip) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + ac97_bus_t *pbus; + ac97_template_t ac97; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_emu10k1x_ac97_write, .read = snd_emu10k1x_ac97_read, }; @@ -746,7 +750,7 @@ static int snd_emu10k1x_ac97(struct emu10k1x *chip) return snd_ac97_mixer(pbus, &ac97, &chip->ac97); } -static int snd_emu10k1x_free(struct emu10k1x *chip) +static int snd_emu10k1x_free(emu10k1x_t *chip) { snd_emu10k1x_ptr_write(chip, TRIGGER_CHANNEL, 0, 0); // disable interrupts @@ -773,9 +777,9 @@ static int snd_emu10k1x_free(struct emu10k1x *chip) return 0; } -static int snd_emu10k1x_dev_free(struct snd_device *device) +static int snd_emu10k1x_dev_free(snd_device_t *device) { - struct emu10k1x *chip = device->device_data; + emu10k1x_t *chip = device->device_data; return snd_emu10k1x_free(chip); } @@ -784,56 +788,64 @@ static irqreturn_t snd_emu10k1x_interrupt(int irq, void *dev_id, { unsigned int status; - struct emu10k1x *chip = dev_id; - struct emu10k1x_voice *pvoice = chip->voices; + emu10k1x_t *chip = dev_id; + emu10k1x_voice_t *pvoice = chip->voices; int i; int mask; status = inl(chip->port + IPR); - if (! status) - return IRQ_NONE; - - // capture interrupt - if (status & (IPR_CAP_0_LOOP | IPR_CAP_0_HALF_LOOP)) { - struct emu10k1x_voice *pvoice = &chip->capture_voice; - if (pvoice->use) - snd_emu10k1x_pcm_interrupt(chip, pvoice); - else - snd_emu10k1x_intr_disable(chip, - INTE_CAP_0_LOOP | - INTE_CAP_0_HALF_LOOP); - } - - mask = IPR_CH_0_LOOP|IPR_CH_0_HALF_LOOP; - for (i = 0; i < 3; i++) { - if (status & mask) { - if (pvoice->use) + if(status) { + // capture interrupt + if(status & (IPR_CAP_0_LOOP | IPR_CAP_0_HALF_LOOP)) { + emu10k1x_voice_t *pvoice = &chip->capture_voice; + if(pvoice->use) snd_emu10k1x_pcm_interrupt(chip, pvoice); - else - snd_emu10k1x_intr_disable(chip, mask); + else + snd_emu10k1x_intr_disable(chip, + INTE_CAP_0_LOOP | + INTE_CAP_0_HALF_LOOP); } - pvoice++; - mask <<= 1; - } - if (status & (IPR_MIDITRANSBUFEMPTY|IPR_MIDIRECVBUFEMPTY)) { - if (chip->midi.interrupt) - chip->midi.interrupt(chip, status); - else - snd_emu10k1x_intr_disable(chip, INTE_MIDITXENABLE|INTE_MIDIRXENABLE); - } + mask = IPR_CH_0_LOOP|IPR_CH_0_HALF_LOOP; + for(i = 0; i < 3; i++) { + if(status & mask) { + if(pvoice->use) + snd_emu10k1x_pcm_interrupt(chip, pvoice); + else + snd_emu10k1x_intr_disable(chip, mask); + } + pvoice++; + mask <<= 1; + } - // acknowledge the interrupt if necessary - outl(status, chip->port + IPR); + if (status & (IPR_MIDITRANSBUFEMPTY|IPR_MIDIRECVBUFEMPTY)) { + if (chip->midi.interrupt) + chip->midi.interrupt(chip, status); + else + snd_emu10k1x_intr_disable(chip, INTE_MIDITXENABLE|INTE_MIDIRXENABLE); + } + + // acknowledge the interrupt if necessary + if(status) + outl(status, chip->port+IPR); + +// snd_printk(KERN_INFO "interrupt %08x\n", status); + } - // snd_printk(KERN_INFO "interrupt %08x\n", status); return IRQ_HANDLED; } -static int __devinit snd_emu10k1x_pcm(struct emu10k1x *emu, int device, struct snd_pcm **rpcm) +static void snd_emu10k1x_pcm_free(snd_pcm_t *pcm) +{ + emu10k1x_t *emu = pcm->private_data; + emu->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_emu10k1x_pcm(emu10k1x_t *emu, int device, snd_pcm_t **rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; int capture = 0; @@ -846,6 +858,7 @@ static int __devinit snd_emu10k1x_pcm(struct emu10k1x *emu, int device, struct s return err; pcm->private_data = emu; + pcm->private_free = snd_emu10k1x_pcm_free; switch(device) { case 0: @@ -883,14 +896,14 @@ static int __devinit snd_emu10k1x_pcm(struct emu10k1x *emu, int device, struct s return 0; } -static int __devinit snd_emu10k1x_create(struct snd_card *card, +static int __devinit snd_emu10k1x_create(snd_card_t *card, struct pci_dev *pci, - struct emu10k1x **rchip) + emu10k1x_t **rchip) { - struct emu10k1x *chip; + emu10k1x_t *chip; int err; int ch; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_emu10k1x_dev_free, }; @@ -1004,10 +1017,10 @@ static int __devinit snd_emu10k1x_create(struct snd_card *card, return 0; } -static void snd_emu10k1x_proc_reg_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu10k1x_proc_reg_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct emu10k1x *emu = entry->private_data; + emu10k1x_t *emu = entry->private_data; unsigned long value,value1,value2; unsigned long flags; int i; @@ -1032,10 +1045,10 @@ static void snd_emu10k1x_proc_reg_read(struct snd_info_entry *entry, } } -static void snd_emu10k1x_proc_reg_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu10k1x_proc_reg_write(snd_info_entry_t *entry, + snd_info_buffer_t *buffer) { - struct emu10k1x *emu = entry->private_data; + emu10k1x_t *emu = entry->private_data; char line[64]; unsigned int reg, channel_id , val; @@ -1049,9 +1062,9 @@ static void snd_emu10k1x_proc_reg_write(struct snd_info_entry *entry, } } -static int __devinit snd_emu10k1x_proc_init(struct emu10k1x * emu) +static int __devinit snd_emu10k1x_proc_init(emu10k1x_t * emu) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if(! snd_card_proc_new(emu->card, "emu10k1x_regs", &entry)) { snd_info_set_text_ops(entry, emu, 1024, snd_emu10k1x_proc_reg_read); @@ -1064,7 +1077,7 @@ static int __devinit snd_emu10k1x_proc_init(struct emu10k1x * emu) return 0; } -static int snd_emu10k1x_shared_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1x_shared_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1073,20 +1086,20 @@ static int snd_emu10k1x_shared_spdif_info(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_emu10k1x_shared_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1x_shared_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct emu10k1x *emu = snd_kcontrol_chip(kcontrol); + emu10k1x_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (snd_emu10k1x_ptr_read(emu, SPDIF_SELECT, 0) == 0x700) ? 0 : 1; return 0; } -static int snd_emu10k1x_shared_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1x_shared_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct emu10k1x *emu = snd_kcontrol_chip(kcontrol); + emu10k1x_t *emu = snd_kcontrol_chip(kcontrol); unsigned int val; int change = 0; @@ -1106,7 +1119,7 @@ static int snd_emu10k1x_shared_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1x_shared_spdif __devinitdata = +static snd_kcontrol_new_t snd_emu10k1x_shared_spdif __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog/Digital Output Jack", @@ -1115,17 +1128,17 @@ static struct snd_kcontrol_new snd_emu10k1x_shared_spdif __devinitdata = .put = snd_emu10k1x_shared_spdif_put }; -static int snd_emu10k1x_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1x_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_emu10k1x_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1x_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct emu10k1x *emu = snd_kcontrol_chip(kcontrol); + emu10k1x_t *emu = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); ucontrol->value.iec958.status[0] = (emu->spdif_bits[idx] >> 0) & 0xff; @@ -1135,8 +1148,8 @@ static int snd_emu10k1x_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1x_spdif_get_mask(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1x_spdif_get_mask(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -1145,10 +1158,10 @@ static int snd_emu10k1x_spdif_get_mask(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1x_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1x_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct emu10k1x *emu = snd_kcontrol_chip(kcontrol); + emu10k1x_t *emu = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); int change; unsigned int val; @@ -1165,7 +1178,7 @@ static int snd_emu10k1x_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1x_spdif_mask_control = +static snd_kcontrol_new_t snd_emu10k1x_spdif_mask_control = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1175,7 +1188,7 @@ static struct snd_kcontrol_new snd_emu10k1x_spdif_mask_control = .get = snd_emu10k1x_spdif_get_mask }; -static struct snd_kcontrol_new snd_emu10k1x_spdif_control = +static snd_kcontrol_new_t snd_emu10k1x_spdif_control = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -1185,11 +1198,11 @@ static struct snd_kcontrol_new snd_emu10k1x_spdif_control = .put = snd_emu10k1x_spdif_put }; -static int __devinit snd_emu10k1x_mixer(struct emu10k1x *emu) +static int __devinit snd_emu10k1x_mixer(emu10k1x_t *emu) { int err; - struct snd_kcontrol *kctl; - struct snd_card *card = emu->card; + snd_kcontrol_t *kctl; + snd_card_t *card = emu->card; if ((kctl = snd_ctl_new1(&snd_emu10k1x_spdif_mask_control, emu)) == NULL) return -ENOMEM; @@ -1210,12 +1223,12 @@ static int __devinit snd_emu10k1x_mixer(struct emu10k1x *emu) #define EMU10K1X_MIDI_MODE_INPUT (1<<0) #define EMU10K1X_MIDI_MODE_OUTPUT (1<<1) -static inline unsigned char mpu401_read(struct emu10k1x *emu, struct emu10k1x_midi *mpu, int idx) +static inline unsigned char mpu401_read(emu10k1x_t *emu, emu10k1x_midi_t *mpu, int idx) { return (unsigned char)snd_emu10k1x_ptr_read(emu, mpu->port + idx, 0); } -static inline void mpu401_write(struct emu10k1x *emu, struct emu10k1x_midi *mpu, int data, int idx) +static inline void mpu401_write(emu10k1x_t *emu, emu10k1x_midi_t *mpu, int data, int idx) { snd_emu10k1x_ptr_write(emu, mpu->port + idx, 0, data); } @@ -1232,7 +1245,7 @@ static inline void mpu401_write(struct emu10k1x *emu, struct emu10k1x_midi *mpu, #define MPU401_ENTER_UART 0x3f #define MPU401_ACK 0xfe -static void mpu401_clear_rx(struct emu10k1x *emu, struct emu10k1x_midi *mpu) +static void mpu401_clear_rx(emu10k1x_t *emu, emu10k1x_midi_t *mpu) { int timeout = 100000; for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--) @@ -1247,8 +1260,7 @@ static void mpu401_clear_rx(struct emu10k1x *emu, struct emu10k1x_midi *mpu) */ -static void do_emu10k1x_midi_interrupt(struct emu10k1x *emu, - struct emu10k1x_midi *midi, unsigned int status) +static void do_emu10k1x_midi_interrupt(emu10k1x_t *emu, emu10k1x_midi_t *midi, unsigned int status) { unsigned char byte; @@ -1281,13 +1293,12 @@ static void do_emu10k1x_midi_interrupt(struct emu10k1x *emu, spin_unlock(&midi->output_lock); } -static void snd_emu10k1x_midi_interrupt(struct emu10k1x *emu, unsigned int status) +static void snd_emu10k1x_midi_interrupt(emu10k1x_t *emu, unsigned int status) { do_emu10k1x_midi_interrupt(emu, &emu->midi, status); } -static void snd_emu10k1x_midi_cmd(struct emu10k1x * emu, - struct emu10k1x_midi *midi, unsigned char cmd, int ack) +static void snd_emu10k1x_midi_cmd(emu10k1x_t * emu, emu10k1x_midi_t *midi, unsigned char cmd, int ack) { unsigned long flags; int timeout, ok; @@ -1319,10 +1330,10 @@ static void snd_emu10k1x_midi_cmd(struct emu10k1x * emu, mpu401_read_data(emu, midi)); } -static int snd_emu10k1x_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_emu10k1x_midi_input_open(snd_rawmidi_substream_t * substream) { - struct emu10k1x *emu; - struct emu10k1x_midi *midi = substream->rmidi->private_data; + emu10k1x_t *emu; + emu10k1x_midi_t *midi = (emu10k1x_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -1340,10 +1351,10 @@ static int snd_emu10k1x_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_emu10k1x_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_emu10k1x_midi_output_open(snd_rawmidi_substream_t * substream) { - struct emu10k1x *emu; - struct emu10k1x_midi *midi = substream->rmidi->private_data; + emu10k1x_t *emu; + emu10k1x_midi_t *midi = (emu10k1x_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -1361,10 +1372,10 @@ static int snd_emu10k1x_midi_output_open(struct snd_rawmidi_substream *substream return 0; } -static int snd_emu10k1x_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_emu10k1x_midi_input_close(snd_rawmidi_substream_t * substream) { - struct emu10k1x *emu; - struct emu10k1x_midi *midi = substream->rmidi->private_data; + emu10k1x_t *emu; + emu10k1x_midi_t *midi = (emu10k1x_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -1382,10 +1393,10 @@ static int snd_emu10k1x_midi_input_close(struct snd_rawmidi_substream *substream return 0; } -static int snd_emu10k1x_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_emu10k1x_midi_output_close(snd_rawmidi_substream_t * substream) { - struct emu10k1x *emu; - struct emu10k1x_midi *midi = substream->rmidi->private_data; + emu10k1x_t *emu; + emu10k1x_midi_t *midi = (emu10k1x_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -1403,10 +1414,10 @@ static int snd_emu10k1x_midi_output_close(struct snd_rawmidi_substream *substrea return 0; } -static void snd_emu10k1x_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_emu10k1x_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct emu10k1x *emu; - struct emu10k1x_midi *midi = substream->rmidi->private_data; + emu10k1x_t *emu; + emu10k1x_midi_t *midi = (emu10k1x_midi_t *)substream->rmidi->private_data; emu = midi->emu; snd_assert(emu, return); @@ -1416,10 +1427,10 @@ static void snd_emu10k1x_midi_input_trigger(struct snd_rawmidi_substream *substr snd_emu10k1x_intr_disable(emu, midi->rx_enable); } -static void snd_emu10k1x_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_emu10k1x_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { - struct emu10k1x *emu; - struct emu10k1x_midi *midi = substream->rmidi->private_data; + emu10k1x_t *emu; + emu10k1x_midi_t *midi = (emu10k1x_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -1456,31 +1467,30 @@ static void snd_emu10k1x_midi_output_trigger(struct snd_rawmidi_substream *subst */ -static struct snd_rawmidi_ops snd_emu10k1x_midi_output = +static snd_rawmidi_ops_t snd_emu10k1x_midi_output = { .open = snd_emu10k1x_midi_output_open, .close = snd_emu10k1x_midi_output_close, .trigger = snd_emu10k1x_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_emu10k1x_midi_input = +static snd_rawmidi_ops_t snd_emu10k1x_midi_input = { .open = snd_emu10k1x_midi_input_open, .close = snd_emu10k1x_midi_input_close, .trigger = snd_emu10k1x_midi_input_trigger, }; -static void snd_emu10k1x_midi_free(struct snd_rawmidi *rmidi) +static void snd_emu10k1x_midi_free(snd_rawmidi_t *rmidi) { - struct emu10k1x_midi *midi = rmidi->private_data; + emu10k1x_midi_t *midi = (emu10k1x_midi_t *)rmidi->private_data; midi->interrupt = NULL; midi->rmidi = NULL; } -static int __devinit emu10k1x_midi_init(struct emu10k1x *emu, - struct emu10k1x_midi *midi, int device, char *name) +static int __devinit emu10k1x_midi_init(emu10k1x_t *emu, emu10k1x_midi_t *midi, int device, char *name) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if ((err = snd_rawmidi_new(emu->card, name, device, 1, 1, &rmidi)) < 0) @@ -1501,9 +1511,9 @@ static int __devinit emu10k1x_midi_init(struct emu10k1x *emu, return 0; } -static int __devinit snd_emu10k1x_midi(struct emu10k1x *emu) +static int __devinit snd_emu10k1x_midi(emu10k1x_t *emu) { - struct emu10k1x_midi *midi = &emu->midi; + emu10k1x_midi_t *midi = &emu->midi; int err; if ((err = emu10k1x_midi_init(emu, midi, 0, "EMU10K1X MPU-401 (UART)")) < 0) @@ -1522,8 +1532,8 @@ static int __devinit snd_emu10k1x_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct emu10k1x *chip; + snd_card_t *card; + emu10k1x_t *chip; int err; if (dev >= SNDRV_CARDS) diff --git a/trunk/sound/pci/emu10k1/emufx.c b/trunk/sound/pci/emu10k1/emufx.c index 1a903390ad6d..03e8c1678952 100644 --- a/trunk/sound/pci/emu10k1/emufx.c +++ b/trunk/sound/pci/emu10k1/emufx.c @@ -29,7 +29,6 @@ #include <linux/pci.h> #include <linux/delay.h> #include <linux/slab.h> -#include <linux/vmalloc.h> #include <linux/init.h> #include <sound/core.h> #include <sound/emu10k1.h> @@ -310,10 +309,9 @@ static inline void snd_leave_user(mm_segment_t fs) * controls */ -static int snd_emu10k1_gpr_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_gpr_ctl_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_emu10k1_fx8010_ctl *ctl = - (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value; + snd_emu10k1_fx8010_ctl_t *ctl = (snd_emu10k1_fx8010_ctl_t *)kcontrol->private_value; if (ctl->min == 0 && ctl->max == 1) uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; @@ -325,11 +323,10 @@ static int snd_emu10k1_gpr_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_emu10k1_gpr_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_gpr_ctl_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_fx8010_ctl *ctl = - (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + snd_emu10k1_fx8010_ctl_t *ctl = (snd_emu10k1_fx8010_ctl_t *)kcontrol->private_value; unsigned long flags; unsigned int i; @@ -340,11 +337,10 @@ static int snd_emu10k1_gpr_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_emu10k1_gpr_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_gpr_ctl_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_fx8010_ctl *ctl = - (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + snd_emu10k1_fx8010_ctl_t *ctl = (snd_emu10k1_fx8010_ctl_t *)kcontrol->private_value; unsigned long flags; unsigned int nval, val; unsigned int i, j; @@ -397,9 +393,9 @@ static int snd_emu10k1_gpr_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl * Interrupt handler */ -static void snd_emu10k1_fx8010_interrupt(struct snd_emu10k1 *emu) +static void snd_emu10k1_fx8010_interrupt(emu10k1_t *emu) { - struct snd_emu10k1_fx8010_irq *irq, *nirq; + snd_emu10k1_fx8010_irq_t *irq, *nirq; irq = emu->fx8010.irq_handlers; while (irq) { @@ -413,13 +409,13 @@ static void snd_emu10k1_fx8010_interrupt(struct snd_emu10k1 *emu) } } -int snd_emu10k1_fx8010_register_irq_handler(struct snd_emu10k1 *emu, - snd_fx8010_irq_handler_t *handler, - unsigned char gpr_running, - void *private_data, - struct snd_emu10k1_fx8010_irq **r_irq) +int snd_emu10k1_fx8010_register_irq_handler(emu10k1_t *emu, + snd_fx8010_irq_handler_t *handler, + unsigned char gpr_running, + void *private_data, + snd_emu10k1_fx8010_irq_t **r_irq) { - struct snd_emu10k1_fx8010_irq *irq; + snd_emu10k1_fx8010_irq_t *irq; unsigned long flags; irq = kmalloc(sizeof(*irq), GFP_ATOMIC); @@ -444,10 +440,10 @@ int snd_emu10k1_fx8010_register_irq_handler(struct snd_emu10k1 *emu, return 0; } -int snd_emu10k1_fx8010_unregister_irq_handler(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_irq *irq) +int snd_emu10k1_fx8010_unregister_irq_handler(emu10k1_t *emu, + snd_emu10k1_fx8010_irq_t *irq) { - struct snd_emu10k1_fx8010_irq *tmp; + snd_emu10k1_fx8010_irq_t *tmp; unsigned long flags; spin_lock_irqsave(&emu->fx8010.irq_lock, flags); @@ -472,8 +468,7 @@ int snd_emu10k1_fx8010_unregister_irq_handler(struct snd_emu10k1 *emu, * EMU10K1 effect manager *************************************************************************/ -static void snd_emu10k1_write_op(struct snd_emu10k1_fx8010_code *icode, - unsigned int *ptr, +static void snd_emu10k1_write_op(emu10k1_fx8010_code_t *icode, unsigned int *ptr, u32 op, u32 r, u32 a, u32 x, u32 y) { u_int32_t *code; @@ -488,8 +483,7 @@ static void snd_emu10k1_write_op(struct snd_emu10k1_fx8010_code *icode, #define OP(icode, ptr, op, r, a, x, y) \ snd_emu10k1_write_op(icode, ptr, op, r, a, x, y) -static void snd_emu10k1_audigy_write_op(struct snd_emu10k1_fx8010_code *icode, - unsigned int *ptr, +static void snd_emu10k1_audigy_write_op(emu10k1_fx8010_code_t *icode, unsigned int *ptr, u32 op, u32 r, u32 a, u32 x, u32 y) { u_int32_t *code; @@ -504,20 +498,19 @@ static void snd_emu10k1_audigy_write_op(struct snd_emu10k1_fx8010_code *icode, #define A_OP(icode, ptr, op, r, a, x, y) \ snd_emu10k1_audigy_write_op(icode, ptr, op, r, a, x, y) -static void snd_emu10k1_efx_write(struct snd_emu10k1 *emu, unsigned int pc, unsigned int data) +static void snd_emu10k1_efx_write(emu10k1_t *emu, unsigned int pc, unsigned int data) { pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE; snd_emu10k1_ptr_write(emu, pc, 0, data); } -unsigned int snd_emu10k1_efx_read(struct snd_emu10k1 *emu, unsigned int pc) +unsigned int snd_emu10k1_efx_read(emu10k1_t *emu, unsigned int pc) { pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE; return snd_emu10k1_ptr_read(emu, pc, 0); } -static int snd_emu10k1_gpr_poke(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_gpr_poke(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { int gpr; u32 val; @@ -532,8 +525,7 @@ static int snd_emu10k1_gpr_poke(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_gpr_peek(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_gpr_peek(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { int gpr; u32 val; @@ -547,8 +539,7 @@ static int snd_emu10k1_gpr_peek(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_tram_poke(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_tram_poke(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { int tram; u32 addr, val; @@ -570,8 +561,7 @@ static int snd_emu10k1_tram_poke(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_tram_peek(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_tram_peek(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { int tram; u32 val, addr; @@ -593,8 +583,7 @@ static int snd_emu10k1_tram_peek(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_code_poke(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_code_poke(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { u32 pc, lo, hi; @@ -610,8 +599,7 @@ static int snd_emu10k1_code_poke(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_code_peek(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_code_peek(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { u32 pc; @@ -626,11 +614,10 @@ static int snd_emu10k1_code_peek(struct snd_emu10k1 *emu, return 0; } -static struct snd_emu10k1_fx8010_ctl * -snd_emu10k1_look_for_ctl(struct snd_emu10k1 *emu, struct snd_ctl_elem_id *id) +static snd_emu10k1_fx8010_ctl_t *snd_emu10k1_look_for_ctl(emu10k1_t *emu, snd_ctl_elem_id_t *id) { - struct snd_emu10k1_fx8010_ctl *ctl; - struct snd_kcontrol *kcontrol; + snd_emu10k1_fx8010_ctl_t *ctl; + snd_kcontrol_t *kcontrol; struct list_head *list; list_for_each(list, &emu->fx8010.gpr_ctl) { @@ -644,14 +631,13 @@ snd_emu10k1_look_for_ctl(struct snd_emu10k1 *emu, struct snd_ctl_elem_id *id) return NULL; } -static int snd_emu10k1_verify_controls(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_verify_controls(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { unsigned int i; - struct snd_ctl_elem_id __user *_id; - struct snd_ctl_elem_id id; - struct snd_emu10k1_fx8010_control_gpr __user *_gctl; - struct snd_emu10k1_fx8010_control_gpr *gctl; + snd_ctl_elem_id_t __user *_id; + snd_ctl_elem_id_t id; + emu10k1_fx8010_control_gpr_t __user *_gctl; + emu10k1_fx8010_control_gpr_t *gctl; int err; for (i = 0, _id = icode->gpr_del_controls; @@ -699,29 +685,28 @@ static int snd_emu10k1_verify_controls(struct snd_emu10k1 *emu, return err; } -static void snd_emu10k1_ctl_private_free(struct snd_kcontrol *kctl) +static void snd_emu10k1_ctl_private_free(snd_kcontrol_t *kctl) { - struct snd_emu10k1_fx8010_ctl *ctl; + snd_emu10k1_fx8010_ctl_t *ctl; - ctl = (struct snd_emu10k1_fx8010_ctl *) kctl->private_value; + ctl = (snd_emu10k1_fx8010_ctl_t *)kctl->private_value; kctl->private_value = 0; list_del(&ctl->list); kfree(ctl); } -static int snd_emu10k1_add_controls(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_add_controls(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { unsigned int i, j; - struct snd_emu10k1_fx8010_control_gpr __user *_gctl; - struct snd_emu10k1_fx8010_control_gpr *gctl; - struct snd_emu10k1_fx8010_ctl *ctl, *nctl; - struct snd_kcontrol_new knew; - struct snd_kcontrol *kctl; - struct snd_ctl_elem_value *val; + emu10k1_fx8010_control_gpr_t __user *_gctl; + emu10k1_fx8010_control_gpr_t *gctl; + snd_emu10k1_fx8010_ctl_t *ctl, *nctl; + snd_kcontrol_new_t knew; + snd_kcontrol_t *kctl; + snd_ctl_elem_value_t *val; int err = 0; - val = kmalloc(sizeof(*val), GFP_KERNEL); + val = (snd_ctl_elem_value_t *)kmalloc(sizeof(*val), GFP_KERNEL); gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); nctl = kmalloc(sizeof(*nctl), GFP_KERNEL); if (!val || !gctl || !nctl) { @@ -766,7 +751,7 @@ static int snd_emu10k1_add_controls(struct snd_emu10k1 *emu, nctl->max = gctl->max; nctl->translation = gctl->translation; if (ctl == NULL) { - ctl = kmalloc(sizeof(*ctl), GFP_KERNEL); + ctl = (snd_emu10k1_fx8010_ctl_t *)kmalloc(sizeof(*ctl), GFP_KERNEL); if (ctl == NULL) { err = -ENOMEM; goto __error; @@ -797,14 +782,13 @@ static int snd_emu10k1_add_controls(struct snd_emu10k1 *emu, return err; } -static int snd_emu10k1_del_controls(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_del_controls(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { unsigned int i; - struct snd_ctl_elem_id id; - struct snd_ctl_elem_id __user *_id; - struct snd_emu10k1_fx8010_ctl *ctl; - struct snd_card *card = emu->card; + snd_ctl_elem_id_t id; + snd_ctl_elem_id_t __user *_id; + snd_emu10k1_fx8010_ctl_t *ctl; + snd_card_t *card = emu->card; for (i = 0, _id = icode->gpr_del_controls; i < icode->gpr_del_control_count; i++, _id++) { @@ -819,15 +803,14 @@ static int snd_emu10k1_del_controls(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_list_controls(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_list_controls(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { unsigned int i = 0, j; unsigned int total = 0; - struct snd_emu10k1_fx8010_control_gpr *gctl; - struct snd_emu10k1_fx8010_control_gpr __user *_gctl; - struct snd_emu10k1_fx8010_ctl *ctl; - struct snd_ctl_elem_id *id; + emu10k1_fx8010_control_gpr_t *gctl; + emu10k1_fx8010_control_gpr_t __user *_gctl; + snd_emu10k1_fx8010_ctl_t *ctl; + snd_ctl_elem_id_t *id; struct list_head *list; gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); @@ -868,8 +851,7 @@ static int snd_emu10k1_list_controls(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_icode_poke(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_icode_poke(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { int err = 0; @@ -900,8 +882,7 @@ static int snd_emu10k1_icode_poke(struct snd_emu10k1 *emu, return err; } -static int snd_emu10k1_icode_peek(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_code *icode) +static int snd_emu10k1_icode_peek(emu10k1_t *emu, emu10k1_fx8010_code_t *icode) { int err; @@ -919,12 +900,11 @@ static int snd_emu10k1_icode_peek(struct snd_emu10k1 *emu, return err; } -static int snd_emu10k1_ipcm_poke(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_pcm_rec *ipcm) +static int snd_emu10k1_ipcm_poke(emu10k1_t *emu, emu10k1_fx8010_pcm_t *ipcm) { unsigned int i; int err = 0; - struct snd_emu10k1_fx8010_pcm *pcm; + snd_emu10k1_fx8010_pcm_t *pcm; if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT) return -EINVAL; @@ -965,12 +945,11 @@ static int snd_emu10k1_ipcm_poke(struct snd_emu10k1 *emu, return err; } -static int snd_emu10k1_ipcm_peek(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_pcm_rec *ipcm) +static int snd_emu10k1_ipcm_peek(emu10k1_t *emu, emu10k1_fx8010_pcm_t *ipcm) { unsigned int i; int err = 0; - struct snd_emu10k1_fx8010_pcm *pcm; + snd_emu10k1_fx8010_pcm_t *pcm; if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT) return -EINVAL; @@ -1000,9 +979,7 @@ static int snd_emu10k1_ipcm_peek(struct snd_emu10k1 *emu, #define SND_EMU10K1_PLAYBACK_CHANNELS 8 #define SND_EMU10K1_CAPTURE_CHANNELS 4 -static void __devinit -snd_emu10k1_init_mono_control(struct snd_emu10k1_fx8010_control_gpr *ctl, - const char *name, int gpr, int defval) +static void __devinit snd_emu10k1_init_mono_control(emu10k1_fx8010_control_gpr_t *ctl, const char *name, int gpr, int defval) { ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; strcpy(ctl->id.name, name); @@ -1013,9 +990,7 @@ snd_emu10k1_init_mono_control(struct snd_emu10k1_fx8010_control_gpr *ctl, ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100; } -static void __devinit -snd_emu10k1_init_stereo_control(struct snd_emu10k1_fx8010_control_gpr *ctl, - const char *name, int gpr, int defval) +static void __devinit snd_emu10k1_init_stereo_control(emu10k1_fx8010_control_gpr_t *ctl, const char *name, int gpr, int defval) { ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; strcpy(ctl->id.name, name); @@ -1027,9 +1002,7 @@ snd_emu10k1_init_stereo_control(struct snd_emu10k1_fx8010_control_gpr *ctl, ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100; } -static void __devinit -snd_emu10k1_init_mono_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl, - const char *name, int gpr, int defval) +static void __devinit snd_emu10k1_init_mono_onoff_control(emu10k1_fx8010_control_gpr_t *ctl, const char *name, int gpr, int defval) { ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; strcpy(ctl->id.name, name); @@ -1040,9 +1013,7 @@ snd_emu10k1_init_mono_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl, ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF; } -static void __devinit -snd_emu10k1_init_stereo_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl, - const char *name, int gpr, int defval) +static void __devinit snd_emu10k1_init_stereo_onoff_control(emu10k1_fx8010_control_gpr_t *ctl, const char *name, int gpr, int defval) { ctl->id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; strcpy(ctl->id.name, name); @@ -1059,7 +1030,7 @@ snd_emu10k1_init_stereo_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl * initial DSP configuration for Audigy */ -static int __devinit _snd_emu10k1_audigy_init_efx(struct snd_emu10k1 *emu) +static int __devinit _snd_emu10k1_audigy_init_efx(emu10k1_t *emu) { int err, i, z, gpr, nctl; const int playback = 10; @@ -1067,17 +1038,17 @@ static int __devinit _snd_emu10k1_audigy_init_efx(struct snd_emu10k1 *emu) const int stereo_mix = capture + 2; const int tmp = 0x88; u32 ptr; - struct snd_emu10k1_fx8010_code *icode = NULL; - struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl; + emu10k1_fx8010_code_t *icode = NULL; + emu10k1_fx8010_control_gpr_t *controls = NULL, *ctl; u32 *gpr_map; mm_segment_t seg; + spin_lock_init(&emu->fx8010.irq_lock); + INIT_LIST_HEAD(&emu->fx8010.gpr_ctl); + if ((icode = kzalloc(sizeof(*icode), GFP_KERNEL)) == NULL || - (icode->gpr_map = (u_int32_t __user *) - kcalloc(512 + 256 + 256 + 2 * 1024, sizeof(u_int32_t), - GFP_KERNEL)) == NULL || - (controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, - sizeof(*controls), GFP_KERNEL)) == NULL) { + (icode->gpr_map = (u_int32_t __user *)kcalloc(512 + 256 + 256 + 2 * 1024, sizeof(u_int32_t), GFP_KERNEL)) == NULL || + (controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, sizeof(*controls), GFP_KERNEL)) == NULL) { err = -ENOMEM; goto __err; } @@ -1103,14 +1074,6 @@ static int __devinit _snd_emu10k1_audigy_init_efx(struct snd_emu10k1 *emu) /* stop FX processor */ snd_emu10k1_ptr_write(emu, A_DBG, 0, (emu->fx8010.dbg = 0) | A_DBG_SINGLE_STEP); -#if 0 - /* FIX: jcd test */ - for (z = 0; z < 80; z=z+2) { - A_OP(icode, &ptr, iACC3, A_EXTOUT(z), A_FXBUS(FXBUS_PCM_LEFT_FRONT), A_C_00000000, A_C_00000000); /* left */ - A_OP(icode, &ptr, iACC3, A_EXTOUT(z+1), A_FXBUS(FXBUS_PCM_RIGHT_FRONT), A_C_00000000, A_C_00000000); /* right */ - } -#endif /* jcd test */ -#if 1 /* PCM front Playback Volume (independent from stereo mix) */ A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_FRONT)); A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_FRONT)); @@ -1456,7 +1419,6 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input)) A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_EXTIN(z)); } -#endif /* JCD test */ /* * ok, set up done.. */ @@ -1472,7 +1434,7 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input)) seg = snd_enter_user(); icode->gpr_add_control_count = nctl; - icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls; + icode->gpr_add_controls = (emu10k1_fx8010_control_gpr_t __user *)controls; err = snd_emu10k1_icode_poke(emu, icode); snd_leave_user(seg); @@ -1492,14 +1454,14 @@ A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input)) /* when volume = max, then copy only to avoid volume modification */ /* with iMAC0 (negative values) */ -static void __devinit _volume(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) +static void __devinit _volume(emu10k1_fx8010_code_t *icode, u32 *ptr, u32 dst, u32 src, u32 vol) { OP(icode, ptr, iMAC0, dst, C_00000000, src, vol); OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000001); OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000); } -static void __devinit _volume_add(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) +static void __devinit _volume_add(emu10k1_fx8010_code_t *icode, u32 *ptr, u32 dst, u32 src, u32 vol) { OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); @@ -1507,7 +1469,7 @@ static void __devinit _volume_add(struct snd_emu10k1_fx8010_code *icode, u32 *pt OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001); OP(icode, ptr, iMAC0, dst, dst, src, vol); } -static void __devinit _volume_out(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) +static void __devinit _volume_out(emu10k1_fx8010_code_t *icode, u32 *ptr, u32 dst, u32 src, u32 vol) { OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); @@ -1538,24 +1500,23 @@ static void __devinit _volume_out(struct snd_emu10k1_fx8010_code *icode, u32 *pt _SWITCH_NEG(icode, ptr, GPR(dst), GPR(src)) -static int __devinit _snd_emu10k1_init_efx(struct snd_emu10k1 *emu) +static int __devinit _snd_emu10k1_init_efx(emu10k1_t *emu) { int err, i, z, gpr, tmp, playback, capture; u32 ptr; - struct snd_emu10k1_fx8010_code *icode; - struct snd_emu10k1_fx8010_pcm_rec *ipcm = NULL; - struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl; + emu10k1_fx8010_code_t *icode; + emu10k1_fx8010_pcm_t *ipcm = NULL; + emu10k1_fx8010_control_gpr_t *controls = NULL, *ctl; u32 *gpr_map; mm_segment_t seg; + spin_lock_init(&emu->fx8010.irq_lock); + INIT_LIST_HEAD(&emu->fx8010.gpr_ctl); + if ((icode = kzalloc(sizeof(*icode), GFP_KERNEL)) == NULL) return -ENOMEM; - if ((icode->gpr_map = (u_int32_t __user *) - kcalloc(256 + 160 + 160 + 2 * 512, sizeof(u_int32_t), - GFP_KERNEL)) == NULL || - (controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, - sizeof(struct snd_emu10k1_fx8010_control_gpr), - GFP_KERNEL)) == NULL || + if ((icode->gpr_map = (u_int32_t __user *)kcalloc(256 + 160 + 160 + 2 * 512, sizeof(u_int32_t), GFP_KERNEL)) == NULL || + (controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, sizeof(emu10k1_fx8010_control_gpr_t), GFP_KERNEL)) == NULL || (ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL)) == NULL) { err = -ENOMEM; goto __err; @@ -2089,7 +2050,7 @@ static int __devinit _snd_emu10k1_init_efx(struct snd_emu10k1 *emu) goto __err; seg = snd_enter_user(); icode->gpr_add_control_count = i; - icode->gpr_add_controls = (struct snd_emu10k1_fx8010_control_gpr __user *)controls; + icode->gpr_add_controls = (emu10k1_fx8010_control_gpr_t __user *)controls; err = snd_emu10k1_icode_poke(emu, icode); snd_leave_user(seg); if (err >= 0) @@ -2104,17 +2065,15 @@ static int __devinit _snd_emu10k1_init_efx(struct snd_emu10k1 *emu) return err; } -int __devinit snd_emu10k1_init_efx(struct snd_emu10k1 *emu) +int __devinit snd_emu10k1_init_efx(emu10k1_t *emu) { - spin_lock_init(&emu->fx8010.irq_lock); - INIT_LIST_HEAD(&emu->fx8010.gpr_ctl); if (emu->audigy) return _snd_emu10k1_audigy_init_efx(emu); else return _snd_emu10k1_init_efx(emu); } -void snd_emu10k1_free_efx(struct snd_emu10k1 *emu) +void snd_emu10k1_free_efx(emu10k1_t *emu) { /* stop processor */ if (emu->audigy) @@ -2124,7 +2083,7 @@ void snd_emu10k1_free_efx(struct snd_emu10k1 *emu) } #if 0 // FIXME: who use them? -int snd_emu10k1_fx8010_tone_control_activate(struct snd_emu10k1 *emu, int output) +int snd_emu10k1_fx8010_tone_control_activate(emu10k1_t *emu, int output) { if (output < 0 || output >= 6) return -EINVAL; @@ -2132,7 +2091,7 @@ int snd_emu10k1_fx8010_tone_control_activate(struct snd_emu10k1 *emu, int output return 0; } -int snd_emu10k1_fx8010_tone_control_deactivate(struct snd_emu10k1 *emu, int output) +int snd_emu10k1_fx8010_tone_control_deactivate(emu10k1_t *emu, int output) { if (output < 0 || output >= 6) return -EINVAL; @@ -2141,7 +2100,7 @@ int snd_emu10k1_fx8010_tone_control_deactivate(struct snd_emu10k1 *emu, int outp } #endif -int snd_emu10k1_fx8010_tram_setup(struct snd_emu10k1 *emu, u32 size) +int snd_emu10k1_fx8010_tram_setup(emu10k1_t *emu, u32 size) { u8 size_reg = 0; @@ -2177,13 +2136,13 @@ int snd_emu10k1_fx8010_tram_setup(struct snd_emu10k1 *emu, u32 size) snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg); spin_lock_irq(&emu->emu_lock); outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG); - spin_unlock_irq(&emu->emu_lock); + spin_unlock_irq(&emu->emu_lock); } return 0; } -static int snd_emu10k1_fx8010_open(struct snd_hwdep * hw, struct file *file) +static int snd_emu10k1_fx8010_open(snd_hwdep_t * hw, struct file *file) { return 0; } @@ -2196,8 +2155,7 @@ static void copy_string(char *dst, char *src, char *null, int idx) strcpy(dst, src); } -static int snd_emu10k1_fx8010_info(struct snd_emu10k1 *emu, - struct snd_emu10k1_fx8010_info *info) +static int snd_emu10k1_fx8010_info(emu10k1_t *emu, emu10k1_fx8010_info_t *info) { char **fxbus, **extin, **extout; unsigned short fxbus_mask, extin_mask, extout_mask; @@ -2223,19 +2181,19 @@ static int snd_emu10k1_fx8010_info(struct snd_emu10k1 *emu, return 0; } -static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg) +static int snd_emu10k1_fx8010_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_emu10k1 *emu = hw->private_data; - struct snd_emu10k1_fx8010_info *info; - struct snd_emu10k1_fx8010_code *icode; - struct snd_emu10k1_fx8010_pcm_rec *ipcm; + emu10k1_t *emu = hw->private_data; + emu10k1_fx8010_info_t *info; + emu10k1_fx8010_code_t *icode; + emu10k1_fx8010_pcm_t *ipcm; unsigned int addr; void __user *argp = (void __user *)arg; int res; switch (cmd) { case SNDRV_EMU10K1_IOCTL_INFO: - info = kmalloc(sizeof(*info), GFP_KERNEL); + info = (emu10k1_fx8010_info_t *)kmalloc(sizeof(*info), GFP_KERNEL); if (!info) return -ENOMEM; if ((res = snd_emu10k1_fx8010_info(emu, info)) < 0) { @@ -2251,7 +2209,7 @@ static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, un case SNDRV_EMU10K1_IOCTL_CODE_POKE: if (!capable(CAP_SYS_ADMIN)) return -EPERM; - icode = kmalloc(sizeof(*icode), GFP_KERNEL); + icode = (emu10k1_fx8010_code_t *)kmalloc(sizeof(*icode), GFP_KERNEL); if (icode == NULL) return -ENOMEM; if (copy_from_user(icode, argp, sizeof(*icode))) { @@ -2262,7 +2220,7 @@ static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, un kfree(icode); return res; case SNDRV_EMU10K1_IOCTL_CODE_PEEK: - icode = kmalloc(sizeof(*icode), GFP_KERNEL); + icode = (emu10k1_fx8010_code_t *)kmalloc(sizeof(*icode), GFP_KERNEL); if (icode == NULL) return -ENOMEM; if (copy_from_user(icode, argp, sizeof(*icode))) { @@ -2277,7 +2235,7 @@ static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, un kfree(icode); return res; case SNDRV_EMU10K1_IOCTL_PCM_POKE: - ipcm = kmalloc(sizeof(*ipcm), GFP_KERNEL); + ipcm = (emu10k1_fx8010_pcm_t *)kmalloc(sizeof(*ipcm), GFP_KERNEL); if (ipcm == NULL) return -ENOMEM; if (copy_from_user(ipcm, argp, sizeof(*ipcm))) { @@ -2369,14 +2327,14 @@ static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, un return -ENOTTY; } -static int snd_emu10k1_fx8010_release(struct snd_hwdep * hw, struct file *file) +static int snd_emu10k1_fx8010_release(snd_hwdep_t * hw, struct file *file) { return 0; } -int __devinit snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device, struct snd_hwdep ** rhwdep) +int __devinit snd_emu10k1_fx8010_new(emu10k1_t *emu, int device, snd_hwdep_t ** rhwdep) { - struct snd_hwdep *hw; + snd_hwdep_t *hw; int err; if (rhwdep) @@ -2393,114 +2351,3 @@ int __devinit snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device, struct *rhwdep = hw; return 0; } - -#ifdef CONFIG_PM -int __devinit snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu) -{ - int len; - - len = emu->audigy ? 0x200 : 0x100; - emu->saved_gpr = kmalloc(len * 4, GFP_KERNEL); - if (! emu->saved_gpr) - return -ENOMEM; - len = emu->audigy ? 0x100 : 0xa0; - emu->tram_val_saved = kmalloc(len * 4, GFP_KERNEL); - emu->tram_addr_saved = kmalloc(len * 4, GFP_KERNEL); - if (! emu->tram_val_saved || ! emu->tram_addr_saved) - return -ENOMEM; - len = emu->audigy ? 2 * 1024 : 2 * 512; - emu->saved_icode = vmalloc(len * 4); - if (! emu->saved_icode) - return -ENOMEM; - return 0; -} - -void snd_emu10k1_efx_free_pm_buffer(struct snd_emu10k1 *emu) -{ - kfree(emu->saved_gpr); - kfree(emu->tram_val_saved); - kfree(emu->tram_addr_saved); - vfree(emu->saved_icode); -} - -/* - * save/restore GPR, TRAM and codes - */ -void snd_emu10k1_efx_suspend(struct snd_emu10k1 *emu) -{ - int i, len; - - len = emu->audigy ? 0x200 : 0x100; - for (i = 0; i < len; i++) - emu->saved_gpr[i] = snd_emu10k1_ptr_read(emu, emu->gpr_base + i, 0); - - len = emu->audigy ? 0x100 : 0xa0; - for (i = 0; i < len; i++) { - emu->tram_val_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + i, 0); - emu->tram_addr_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + i, 0); - if (emu->audigy) { - emu->tram_addr_saved[i] >>= 12; - emu->tram_addr_saved[i] |= - snd_emu10k1_ptr_read(emu, A_TANKMEMCTLREGBASE + i, 0) << 20; - } - } - - len = emu->audigy ? 2 * 1024 : 2 * 512; - for (i = 0; i < len; i++) - emu->saved_icode[i] = snd_emu10k1_efx_read(emu, i); -} - -void snd_emu10k1_efx_resume(struct snd_emu10k1 *emu) -{ - int i, len; - - /* set up TRAM */ - if (emu->fx8010.etram_pages.bytes > 0) { - unsigned size, size_reg = 0; - size = emu->fx8010.etram_pages.bytes / 2; - size = (size - 1) >> 13; - while (size) { - size >>= 1; - size_reg++; - } - outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG); - snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr); - snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg); - outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG); - } - - if (emu->audigy) - snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP); - else - snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP); - - len = emu->audigy ? 0x200 : 0x100; - for (i = 0; i < len; i++) - snd_emu10k1_ptr_write(emu, emu->gpr_base + i, 0, emu->saved_gpr[i]); - - len = emu->audigy ? 0x100 : 0xa0; - for (i = 0; i < len; i++) { - snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + i, 0, - emu->tram_val_saved[i]); - if (! emu->audigy) - snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, - emu->tram_addr_saved[i]); - else { - snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, - emu->tram_addr_saved[i] << 12); - snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, - emu->tram_addr_saved[i] >> 20); - } - } - - len = emu->audigy ? 2 * 1024 : 2 * 512; - for (i = 0; i < len; i++) - snd_emu10k1_efx_write(emu, i, emu->saved_icode[i]); - - /* start FX processor when the DSP code is updated */ - if (emu->audigy) - snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg); - else - snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg); -} -#endif diff --git a/trunk/sound/pci/emu10k1/emumixer.c b/trunk/sound/pci/emu10k1/emumixer.c index 2e86a901a0a4..7cc831ccd0cb 100644 --- a/trunk/sound/pci/emu10k1/emumixer.c +++ b/trunk/sound/pci/emu10k1/emumixer.c @@ -35,17 +35,17 @@ #define AC97_ID_STAC9758 0x83847658 -static int snd_emu10k1_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_emu10k1_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned long flags; @@ -58,8 +58,8 @@ static int snd_emu10k1_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_spdif_get_mask(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_spdif_get_mask(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -69,7 +69,7 @@ static int snd_emu10k1_spdif_get_mask(struct snd_kcontrol *kcontrol, } #if 0 -static int snd_audigy_spdif_output_rate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_audigy_spdif_output_rate_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"44100", "48000", "96000"}; @@ -82,10 +82,10 @@ static int snd_audigy_spdif_output_rate_info(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_audigy_spdif_output_rate_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_audigy_spdif_output_rate_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); unsigned int tmp; unsigned long flags; @@ -109,10 +109,10 @@ static int snd_audigy_spdif_output_rate_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_audigy_spdif_output_rate_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_audigy_spdif_output_rate_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); int change; unsigned int reg, val, tmp; unsigned long flags; @@ -143,7 +143,7 @@ static int snd_audigy_spdif_output_rate_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_audigy_spdif_output_rate = +static snd_kcontrol_new_t snd_audigy_spdif_output_rate = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .iface = SNDRV_CTL_ELEM_IFACE_MIXER, @@ -155,10 +155,10 @@ static struct snd_kcontrol_new snd_audigy_spdif_output_rate = }; #endif -static int snd_emu10k1_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); int change; unsigned int val; @@ -178,7 +178,7 @@ static int snd_emu10k1_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1_spdif_mask_control = +static snd_kcontrol_new_t snd_emu10k1_spdif_mask_control = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -188,7 +188,7 @@ static struct snd_kcontrol_new snd_emu10k1_spdif_mask_control = .get = snd_emu10k1_spdif_get_mask }; -static struct snd_kcontrol_new snd_emu10k1_spdif_control = +static snd_kcontrol_new_t snd_emu10k1_spdif_control = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -199,7 +199,7 @@ static struct snd_kcontrol_new snd_emu10k1_spdif_control = }; -static void update_emu10k1_fxrt(struct snd_emu10k1 *emu, int voice, unsigned char *route) +static void update_emu10k1_fxrt(emu10k1_t *emu, int voice, unsigned char *route) { if (emu->audigy) { snd_emu10k1_ptr_write(emu, A_FXRT1, voice, @@ -212,7 +212,7 @@ static void update_emu10k1_fxrt(struct snd_emu10k1 *emu, int voice, unsigned cha } } -static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsigned char *volume) +static void update_emu10k1_send_volume(emu10k1_t *emu, int voice, unsigned char *volume) { snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_A, voice, volume[0]); snd_emu10k1_ptr_write(emu, PTRX_FXSENDAMOUNT_B, voice, volume[1]); @@ -229,9 +229,9 @@ static void update_emu10k1_send_volume(struct snd_emu10k1 *emu, int voice, unsig /* PCM stream controls */ -static int snd_emu10k1_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_send_routing_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = emu->audigy ? 3*8 : 3*4; uinfo->value.integer.min = 0; @@ -239,13 +239,12 @@ static int snd_emu10k1_send_routing_info(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_emu10k1_send_routing_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_send_routing_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; int voice, idx; int num_efx = emu->audigy ? 8 : 4; int mask = emu->audigy ? 0x3f : 0x0f; @@ -259,13 +258,12 @@ static int snd_emu10k1_send_routing_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_send_routing_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_send_routing_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; int change = 0, voice, idx, val; int num_efx = emu->audigy ? 8 : 4; int mask = emu->audigy ? 0x3f : 0x0f; @@ -294,7 +292,7 @@ static int snd_emu10k1_send_routing_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1_send_routing_control = +static snd_kcontrol_new_t snd_emu10k1_send_routing_control = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -305,9 +303,9 @@ static struct snd_kcontrol_new snd_emu10k1_send_routing_control = .put = snd_emu10k1_send_routing_put }; -static int snd_emu10k1_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_send_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = emu->audigy ? 3*8 : 3*4; uinfo->value.integer.min = 0; @@ -315,13 +313,12 @@ static int snd_emu10k1_send_volume_info(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_emu10k1_send_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_send_volume_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; int idx; int num_efx = emu->audigy ? 8 : 4; @@ -332,13 +329,12 @@ static int snd_emu10k1_send_volume_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_send_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_send_volume_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; int change = 0, idx, val; int num_efx = emu->audigy ? 8 : 4; @@ -365,7 +361,7 @@ static int snd_emu10k1_send_volume_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1_send_volume_control = +static snd_kcontrol_new_t snd_emu10k1_send_volume_control = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -376,7 +372,7 @@ static struct snd_kcontrol_new snd_emu10k1_send_volume_control = .put = snd_emu10k1_send_volume_put }; -static int snd_emu10k1_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_attn_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 3; @@ -385,12 +381,11 @@ static int snd_emu10k1_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_emu10k1_attn_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_attn_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; unsigned long flags; int idx; @@ -401,13 +396,12 @@ static int snd_emu10k1_attn_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_attn_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_attn_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; int change = 0, idx, val; spin_lock_irqsave(&emu->reg_lock, flags); @@ -430,7 +424,7 @@ static int snd_emu10k1_attn_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1_attn_control = +static snd_kcontrol_new_t snd_emu10k1_attn_control = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -443,9 +437,9 @@ static struct snd_kcontrol_new snd_emu10k1_attn_control = /* Mutichannel PCM stream controls */ -static int snd_emu10k1_efx_send_routing_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_efx_send_routing_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = emu->audigy ? 8 : 4; uinfo->value.integer.min = 0; @@ -453,13 +447,12 @@ static int snd_emu10k1_efx_send_routing_info(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_emu10k1_efx_send_routing_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_efx_send_routing_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; int idx; int num_efx = emu->audigy ? 8 : 4; int mask = emu->audigy ? 0x3f : 0x0f; @@ -472,13 +465,13 @@ static int snd_emu10k1_efx_send_routing_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_efx_send_routing_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_efx_send_routing_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); - struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch]; + emu10k1_pcm_mixer_t *mix = &emu->efx_pcm_mixer[ch]; int change = 0, idx, val; int num_efx = emu->audigy ? 8 : 4; int mask = emu->audigy ? 0x3f : 0x0f; @@ -502,7 +495,7 @@ static int snd_emu10k1_efx_send_routing_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1_efx_send_routing_control = +static snd_kcontrol_new_t snd_emu10k1_efx_send_routing_control = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -513,9 +506,9 @@ static struct snd_kcontrol_new snd_emu10k1_efx_send_routing_control = .put = snd_emu10k1_efx_send_routing_put }; -static int snd_emu10k1_efx_send_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_efx_send_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = emu->audigy ? 8 : 4; uinfo->value.integer.min = 0; @@ -523,13 +516,12 @@ static int snd_emu10k1_efx_send_volume_info(struct snd_kcontrol *kcontrol, struc return 0; } -static int snd_emu10k1_efx_send_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_efx_send_volume_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; int idx; int num_efx = emu->audigy ? 8 : 4; @@ -540,13 +532,13 @@ static int snd_emu10k1_efx_send_volume_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_efx_send_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_efx_send_volume_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); - struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch]; + emu10k1_pcm_mixer_t *mix = &emu->efx_pcm_mixer[ch]; int change = 0, idx, val; int num_efx = emu->audigy ? 8 : 4; @@ -569,7 +561,7 @@ static int snd_emu10k1_efx_send_volume_put(struct snd_kcontrol *kcontrol, } -static struct snd_kcontrol_new snd_emu10k1_efx_send_volume_control = +static snd_kcontrol_new_t snd_emu10k1_efx_send_volume_control = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -580,7 +572,7 @@ static struct snd_kcontrol_new snd_emu10k1_efx_send_volume_control = .put = snd_emu10k1_efx_send_volume_put }; -static int snd_emu10k1_efx_attn_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_efx_attn_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -589,12 +581,11 @@ static int snd_emu10k1_efx_attn_info(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_emu10k1_efx_attn_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_efx_attn_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - struct snd_emu10k1_pcm_mixer *mix = - &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + emu10k1_pcm_mixer_t *mix = &emu->efx_pcm_mixer[snd_ctl_get_ioffidx(kcontrol, &ucontrol->id)]; unsigned long flags; spin_lock_irqsave(&emu->reg_lock, flags); @@ -603,13 +594,13 @@ static int snd_emu10k1_efx_attn_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_efx_attn_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_efx_attn_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); int ch = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); - struct snd_emu10k1_pcm_mixer *mix = &emu->efx_pcm_mixer[ch]; + emu10k1_pcm_mixer_t *mix = &emu->efx_pcm_mixer[ch]; int change = 0, val; spin_lock_irqsave(&emu->reg_lock, flags); @@ -627,7 +618,7 @@ static int snd_emu10k1_efx_attn_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1_efx_attn_control = +static snd_kcontrol_new_t snd_emu10k1_efx_attn_control = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -638,7 +629,7 @@ static struct snd_kcontrol_new snd_emu10k1_efx_attn_control = .put = snd_emu10k1_efx_attn_put }; -static int snd_emu10k1_shared_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_shared_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -647,10 +638,10 @@ static int snd_emu10k1_shared_spdif_info(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_emu10k1_shared_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_shared_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); if (emu->audigy) ucontrol->value.integer.value[0] = inl(emu->port + A_IOCFG) & A_IOCFG_GPOUT0 ? 1 : 0; @@ -659,11 +650,11 @@ static int snd_emu10k1_shared_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_emu10k1_shared_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_shared_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { unsigned long flags; - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); unsigned int reg, val; int change = 0; @@ -690,7 +681,7 @@ static int snd_emu10k1_shared_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_emu10k1_shared_spdif __devinitdata = +static snd_kcontrol_new_t snd_emu10k1_shared_spdif __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "SB Live Analog/Digital Output Jack", @@ -699,7 +690,7 @@ static struct snd_kcontrol_new snd_emu10k1_shared_spdif __devinitdata = .put = snd_emu10k1_shared_spdif_put }; -static struct snd_kcontrol_new snd_audigy_shared_spdif __devinitdata = +static snd_kcontrol_new_t snd_audigy_shared_spdif __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Audigy Analog/Digital Output Jack", @@ -710,35 +701,35 @@ static struct snd_kcontrol_new snd_audigy_shared_spdif __devinitdata = /* */ -static void snd_emu10k1_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_emu10k1_mixer_free_ac97(ac97_t *ac97) { - struct snd_emu10k1 *emu = ac97->private_data; + emu10k1_t *emu = ac97->private_data; emu->ac97 = NULL; } /* */ -static int remove_ctl(struct snd_card *card, const char *name) +static int remove_ctl(snd_card_t *card, const char *name) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; memset(&id, 0, sizeof(id)); strcpy(id.name, name); id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; return snd_ctl_remove_id(card, &id); } -static struct snd_kcontrol *ctl_find(struct snd_card *card, const char *name) +static snd_kcontrol_t *ctl_find(snd_card_t *card, const char *name) { - struct snd_ctl_elem_id sid; + snd_ctl_elem_id_t sid; memset(&sid, 0, sizeof(sid)); strcpy(sid.name, name); sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; return snd_ctl_find_id(card, &sid); } -static int rename_ctl(struct snd_card *card, const char *src, const char *dst) +static int rename_ctl(snd_card_t *card, const char *src, const char *dst) { - struct snd_kcontrol *kctl = ctl_find(card, src); + snd_kcontrol_t *kctl = ctl_find(card, src); if (kctl) { strcpy(kctl->id.name, dst); return 0; @@ -746,12 +737,12 @@ static int rename_ctl(struct snd_card *card, const char *src, const char *dst) return -ENOENT; } -int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu, +int __devinit snd_emu10k1_mixer(emu10k1_t *emu, int pcm_device, int multi_device) { int err, pcm; - struct snd_kcontrol *kctl; - struct snd_card *card = emu->card; + snd_kcontrol_t *kctl; + snd_card_t *card = emu->card; char **c; static char *emu10k1_remove_ctls[] = { /* no AC97 mono, surround, center/lfe */ @@ -804,9 +795,9 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu, }; if (emu->card_capabilities->ac97_chip) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; - static struct snd_ac97_bus_ops ops = { + ac97_bus_t *pbus; + ac97_template_t ac97; + static ac97_bus_ops_t ops = { .write = snd_emu10k1_ac97_write, .read = snd_emu10k1_ac97_read, }; @@ -866,17 +857,7 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu, c = emu10k1_rename_ctls; for (; *c; c += 2) rename_ctl(card, c[0], c[1]); - if (emu->card_capabilities->subsystem == 0x20071102) { /* Audigy 4 Pro */ - rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume"); - rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume"); - rename_ctl(card, "Aux2 Capture Volume", "Line3 Capture Volume"); - rename_ctl(card, "Mic Capture Volume", "Unknown1 Capture Volume"); - remove_ctl(card, "Headphone Playback Switch"); - remove_ctl(card, "Headphone Playback Volume"); - remove_ctl(card, "3D Control - Center"); - remove_ctl(card, "3D Control - Depth"); - remove_ctl(card, "3D Control - Switch"); - } + if ((kctl = emu->ctl_send_routing = snd_ctl_new1(&snd_emu10k1_send_routing_control, emu)) == NULL) return -ENOMEM; kctl->id.device = pcm_device; @@ -913,7 +894,7 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu, /* initialize the routing and volume table for each pcm playback stream */ for (pcm = 0; pcm < 32; pcm++) { - struct snd_emu10k1_pcm_mixer *mix; + emu10k1_pcm_mixer_t *mix; int v; mix = &emu->pcm_mixer[pcm]; @@ -933,7 +914,7 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu, /* initialize the routing and volume table for the multichannel playback stream */ for (pcm = 0; pcm < NUM_EFX_PLAYBACK; pcm++) { - struct snd_emu10k1_pcm_mixer *mix; + emu10k1_pcm_mixer_t *mix; int v; mix = &emu->efx_pcm_mixer[pcm]; @@ -969,9 +950,7 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu, return err; } - if ( emu->card_capabilities->emu1212m) { - ; /* Disable the snd_audigy_spdif_shared_spdif */ - } else if (emu->audigy) { + if (emu->audigy) { if ((kctl = snd_ctl_new1(&snd_audigy_shared_spdif, emu)) == NULL) return -ENOMEM; if ((err = snd_ctl_add(card, kctl))) diff --git a/trunk/sound/pci/emu10k1/emumpu401.c b/trunk/sound/pci/emu10k1/emumpu401.c index d96eb455103f..eb57458a9665 100644 --- a/trunk/sound/pci/emu10k1/emumpu401.c +++ b/trunk/sound/pci/emu10k1/emumpu401.c @@ -28,8 +28,7 @@ #define EMU10K1_MIDI_MODE_INPUT (1<<0) #define EMU10K1_MIDI_MODE_OUTPUT (1<<1) -static inline unsigned char mpu401_read(struct snd_emu10k1 *emu, - struct snd_emu10k1_midi *mpu, int idx) +static inline unsigned char mpu401_read(emu10k1_t *emu, emu10k1_midi_t *mpu, int idx) { if (emu->audigy) return (unsigned char)snd_emu10k1_ptr_read(emu, mpu->port + idx, 0); @@ -37,8 +36,7 @@ static inline unsigned char mpu401_read(struct snd_emu10k1 *emu, return inb(emu->port + mpu->port + idx); } -static inline void mpu401_write(struct snd_emu10k1 *emu, - struct snd_emu10k1_midi *mpu, int data, int idx) +static inline void mpu401_write(emu10k1_t *emu, emu10k1_midi_t *mpu, int data, int idx) { if (emu->audigy) snd_emu10k1_ptr_write(emu, mpu->port + idx, 0, data); @@ -58,7 +56,7 @@ static inline void mpu401_write(struct snd_emu10k1 *emu, #define MPU401_ENTER_UART 0x3f #define MPU401_ACK 0xfe -static void mpu401_clear_rx(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mpu) +static void mpu401_clear_rx(emu10k1_t *emu, emu10k1_midi_t *mpu) { int timeout = 100000; for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--) @@ -73,7 +71,7 @@ static void mpu401_clear_rx(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mp */ -static void do_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, unsigned int status) +static void do_emu10k1_midi_interrupt(emu10k1_t *emu, emu10k1_midi_t *midi, unsigned int status) { unsigned char byte; @@ -106,17 +104,17 @@ static void do_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, struct snd_emu10k spin_unlock(&midi->output_lock); } -static void snd_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, unsigned int status) +static void snd_emu10k1_midi_interrupt(emu10k1_t *emu, unsigned int status) { do_emu10k1_midi_interrupt(emu, &emu->midi, status); } -static void snd_emu10k1_midi_interrupt2(struct snd_emu10k1 *emu, unsigned int status) +static void snd_emu10k1_midi_interrupt2(emu10k1_t *emu, unsigned int status) { do_emu10k1_midi_interrupt(emu, &emu->midi2, status); } -static void snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_midi *midi, unsigned char cmd, int ack) +static void snd_emu10k1_midi_cmd(emu10k1_t * emu, emu10k1_midi_t *midi, unsigned char cmd, int ack) { unsigned long flags; int timeout, ok; @@ -148,10 +146,10 @@ static void snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_mi mpu401_read_data(emu, midi)); } -static int snd_emu10k1_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_emu10k1_midi_input_open(snd_rawmidi_substream_t * substream) { - struct snd_emu10k1 *emu; - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; + emu10k1_t *emu; + emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -169,10 +167,10 @@ static int snd_emu10k1_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_emu10k1_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_emu10k1_midi_output_open(snd_rawmidi_substream_t * substream) { - struct snd_emu10k1 *emu; - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; + emu10k1_t *emu; + emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -190,10 +188,10 @@ static int snd_emu10k1_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_emu10k1_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_emu10k1_midi_input_close(snd_rawmidi_substream_t * substream) { - struct snd_emu10k1 *emu; - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; + emu10k1_t *emu; + emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -211,10 +209,10 @@ static int snd_emu10k1_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_emu10k1_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_emu10k1_midi_output_close(snd_rawmidi_substream_t * substream) { - struct snd_emu10k1 *emu; - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; + emu10k1_t *emu; + emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -232,10 +230,10 @@ static int snd_emu10k1_midi_output_close(struct snd_rawmidi_substream *substream return 0; } -static void snd_emu10k1_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_emu10k1_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct snd_emu10k1 *emu; - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; + emu10k1_t *emu; + emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data; emu = midi->emu; snd_assert(emu, return); @@ -245,10 +243,10 @@ static void snd_emu10k1_midi_input_trigger(struct snd_rawmidi_substream *substre snd_emu10k1_intr_disable(emu, midi->rx_enable); } -static void snd_emu10k1_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_emu10k1_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { - struct snd_emu10k1 *emu; - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; + emu10k1_t *emu; + emu10k1_midi_t *midi = (emu10k1_midi_t *)substream->rmidi->private_data; unsigned long flags; emu = midi->emu; @@ -285,30 +283,30 @@ static void snd_emu10k1_midi_output_trigger(struct snd_rawmidi_substream *substr */ -static struct snd_rawmidi_ops snd_emu10k1_midi_output = +static snd_rawmidi_ops_t snd_emu10k1_midi_output = { .open = snd_emu10k1_midi_output_open, .close = snd_emu10k1_midi_output_close, .trigger = snd_emu10k1_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_emu10k1_midi_input = +static snd_rawmidi_ops_t snd_emu10k1_midi_input = { .open = snd_emu10k1_midi_input_open, .close = snd_emu10k1_midi_input_close, .trigger = snd_emu10k1_midi_input_trigger, }; -static void snd_emu10k1_midi_free(struct snd_rawmidi *rmidi) +static void snd_emu10k1_midi_free(snd_rawmidi_t *rmidi) { - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)rmidi->private_data; + emu10k1_midi_t *midi = (emu10k1_midi_t *)rmidi->private_data; midi->interrupt = NULL; midi->rmidi = NULL; } -static int __devinit emu10k1_midi_init(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, int device, char *name) +static int __devinit emu10k1_midi_init(emu10k1_t *emu, emu10k1_midi_t *midi, int device, char *name) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if ((err = snd_rawmidi_new(emu->card, name, device, 1, 1, &rmidi)) < 0) @@ -329,9 +327,9 @@ static int __devinit emu10k1_midi_init(struct snd_emu10k1 *emu, struct snd_emu10 return 0; } -int __devinit snd_emu10k1_midi(struct snd_emu10k1 *emu) +int __devinit snd_emu10k1_midi(emu10k1_t *emu) { - struct snd_emu10k1_midi *midi = &emu->midi; + emu10k1_midi_t *midi = &emu->midi; int err; if ((err = emu10k1_midi_init(emu, midi, 0, "EMU10K1 MPU-401 (UART)")) < 0) @@ -346,9 +344,9 @@ int __devinit snd_emu10k1_midi(struct snd_emu10k1 *emu) return 0; } -int __devinit snd_emu10k1_audigy_midi(struct snd_emu10k1 *emu) +int __devinit snd_emu10k1_audigy_midi(emu10k1_t *emu) { - struct snd_emu10k1_midi *midi; + emu10k1_midi_t *midi; int err; midi = &emu->midi; diff --git a/trunk/sound/pci/emu10k1/emupcm.c b/trunk/sound/pci/emu10k1/emupcm.c index 717e92ec9e0a..bf7490dae09b 100644 --- a/trunk/sound/pci/emu10k1/emupcm.c +++ b/trunk/sound/pci/emu10k1/emupcm.c @@ -35,10 +35,9 @@ #include <sound/core.h> #include <sound/emu10k1.h> -static void snd_emu10k1_pcm_interrupt(struct snd_emu10k1 *emu, - struct snd_emu10k1_voice *voice) +static void snd_emu10k1_pcm_interrupt(emu10k1_t *emu, emu10k1_voice_t *voice) { - struct snd_emu10k1_pcm *epcm; + emu10k1_pcm_t *epcm; if ((epcm = voice->epcm) == NULL) return; @@ -53,8 +52,7 @@ static void snd_emu10k1_pcm_interrupt(struct snd_emu10k1 *emu, snd_pcm_period_elapsed(epcm->substream); } -static void snd_emu10k1_pcm_ac97adc_interrupt(struct snd_emu10k1 *emu, - unsigned int status) +static void snd_emu10k1_pcm_ac97adc_interrupt(emu10k1_t *emu, unsigned int status) { #if 0 if (status & IPR_ADCBUFHALFFULL) { @@ -65,8 +63,7 @@ static void snd_emu10k1_pcm_ac97adc_interrupt(struct snd_emu10k1 *emu, snd_pcm_period_elapsed(emu->pcm_capture_substream); } -static void snd_emu10k1_pcm_ac97mic_interrupt(struct snd_emu10k1 *emu, - unsigned int status) +static void snd_emu10k1_pcm_ac97mic_interrupt(emu10k1_t *emu, unsigned int status) { #if 0 if (status & IPR_MICBUFHALFFULL) { @@ -77,8 +74,7 @@ static void snd_emu10k1_pcm_ac97mic_interrupt(struct snd_emu10k1 *emu, snd_pcm_period_elapsed(emu->pcm_capture_mic_substream); } -static void snd_emu10k1_pcm_efx_interrupt(struct snd_emu10k1 *emu, - unsigned int status) +static void snd_emu10k1_pcm_efx_interrupt(emu10k1_t *emu, unsigned int status) { #if 0 if (status & IPR_EFXBUFHALFFULL) { @@ -89,11 +85,11 @@ static void snd_emu10k1_pcm_efx_interrupt(struct snd_emu10k1 *emu, snd_pcm_period_elapsed(emu->pcm_capture_efx_substream); } -static snd_pcm_uframes_t snd_emu10k1_efx_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_emu10k1_efx_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; unsigned int ptr; if (!epcm->running) @@ -106,7 +102,7 @@ static snd_pcm_uframes_t snd_emu10k1_efx_playback_pointer(struct snd_pcm_substre return ptr; } -static int snd_emu10k1_pcm_channel_alloc(struct snd_emu10k1_pcm * epcm, int voices) +static int snd_emu10k1_pcm_channel_alloc(emu10k1_pcm_t * epcm, int voices) { int err, i; @@ -171,7 +167,7 @@ static unsigned int capture_period_sizes[31] = { 384*128,448*128,512*128 }; -static struct snd_pcm_hw_constraint_list hw_constraints_capture_period_sizes = { +static snd_pcm_hw_constraint_list_t hw_constraints_capture_period_sizes = { .count = 31, .list = capture_period_sizes, .mask = 0 @@ -181,7 +177,7 @@ static unsigned int capture_rates[8] = { 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000 }; -static struct snd_pcm_hw_constraint_list hw_constraints_capture_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_capture_rates = { .count = 8, .list = capture_rates, .mask = 0 @@ -275,15 +271,15 @@ static inline int emu10k1_ccis(int stereo, int w_16) } } -static void snd_emu10k1_pcm_init_voice(struct snd_emu10k1 *emu, +static void snd_emu10k1_pcm_init_voice(emu10k1_t *emu, int master, int extra, - struct snd_emu10k1_voice *evoice, + emu10k1_voice_t *evoice, unsigned int start_addr, unsigned int end_addr, - struct snd_emu10k1_pcm_mixer *mix) + emu10k1_pcm_mixer_t *mix) { - struct snd_pcm_substream *substream = evoice->epcm->substream; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_substream_t *substream = evoice->epcm->substream; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int silent_page, tmp; int voice, stereo, w_16; unsigned char attn, send_amount[8]; @@ -396,12 +392,12 @@ static void snd_emu10k1_pcm_init_voice(struct snd_emu10k1 *emu, spin_unlock_irqrestore(&emu->reg_lock, flags); } -static int snd_emu10k1_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_emu10k1_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; int err; if ((err = snd_emu10k1_pcm_channel_alloc(epcm, params_channels(hw_params))) < 0) @@ -409,26 +405,24 @@ static int snd_emu10k1_playback_hw_params(struct snd_pcm_substream *substream, if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) return err; if (err > 0) { /* change */ - int mapped; + snd_util_memblk_t *memblk; if (epcm->memblk != NULL) snd_emu10k1_free_pages(emu, epcm->memblk); - epcm->memblk = snd_emu10k1_alloc_pages(emu, substream); - epcm->start_addr = 0; - if (! epcm->memblk) - return -ENOMEM; - mapped = ((struct snd_emu10k1_memblk *)epcm->memblk)->mapped_page; - if (mapped < 0) + memblk = snd_emu10k1_alloc_pages(emu, substream); + if ((epcm->memblk = memblk) == NULL || ((emu10k1_memblk_t *)memblk)->mapped_page < 0) { + epcm->start_addr = 0; return -ENOMEM; - epcm->start_addr = mapped << PAGE_SHIFT; + } + epcm->start_addr = ((emu10k1_memblk_t *)memblk)->mapped_page << PAGE_SHIFT; } return 0; } -static int snd_emu10k1_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_emu10k1_playback_hw_free(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm; if (runtime->private_data == NULL) return 0; @@ -454,11 +448,11 @@ static int snd_emu10k1_playback_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_efx_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_emu10k1_efx_playback_hw_free(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm; int i; if (runtime->private_data == NULL) @@ -483,11 +477,11 @@ static int snd_emu10k1_efx_playback_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_playback_prepare(struct snd_pcm_substream *substream) +static int snd_emu10k1_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; unsigned int start_addr, end_addr; start_addr = epcm->start_addr; @@ -511,11 +505,11 @@ static int snd_emu10k1_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_efx_playback_prepare(struct snd_pcm_substream *substream) +static int snd_emu10k1_efx_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; unsigned int start_addr, end_addr; unsigned int channel_size; int i; @@ -547,11 +541,10 @@ static int snd_emu10k1_efx_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_hardware snd_emu10k1_efx_playback = +static snd_pcm_hardware_t snd_emu10k1_efx_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_NONINTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_48000, @@ -567,22 +560,22 @@ static struct snd_pcm_hardware snd_emu10k1_efx_playback = .fifo_size = 0, }; -static int snd_emu10k1_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_emu10k1_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_emu10k1_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_emu10k1_capture_prepare(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; int idx; /* zeroing the buffer size will stop capture */ @@ -625,9 +618,9 @@ static int snd_emu10k1_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static void snd_emu10k1_playback_invalidate_cache(struct snd_emu10k1 *emu, int extra, struct snd_emu10k1_voice *evoice) +static void snd_emu10k1_playback_invalidate_cache(emu10k1_t *emu, int extra, emu10k1_voice_t *evoice) { - struct snd_pcm_runtime *runtime; + snd_pcm_runtime_t *runtime; unsigned int voice, stereo, i, ccis, cra = 64, cs, sample; if (evoice == NULL) @@ -660,12 +653,12 @@ static void snd_emu10k1_playback_invalidate_cache(struct snd_emu10k1 *emu, int e } } -static void snd_emu10k1_playback_prepare_voice(struct snd_emu10k1 *emu, struct snd_emu10k1_voice *evoice, +static void snd_emu10k1_playback_prepare_voice(emu10k1_t *emu, emu10k1_voice_t *evoice, int master, int extra, - struct snd_emu10k1_pcm_mixer *mix) + emu10k1_pcm_mixer_t *mix) { - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; unsigned int attn, vattn; unsigned int voice, tmp; @@ -685,10 +678,10 @@ static void snd_emu10k1_playback_prepare_voice(struct snd_emu10k1 *emu, struct s snd_emu10k1_voice_clear_loop_stop(emu, voice); } -static void snd_emu10k1_playback_trigger_voice(struct snd_emu10k1 *emu, struct snd_emu10k1_voice *evoice, int master, int extra) +static void snd_emu10k1_playback_trigger_voice(emu10k1_t *emu, emu10k1_voice_t *evoice, int master, int extra) { - struct snd_pcm_substream *substream; - struct snd_pcm_runtime *runtime; + snd_pcm_substream_t *substream; + snd_pcm_runtime_t *runtime; unsigned int voice, pitch, pitch_target; if (evoice == NULL) /* skip second voice for mono */ @@ -707,7 +700,7 @@ static void snd_emu10k1_playback_trigger_voice(struct snd_emu10k1 *emu, struct s snd_emu10k1_voice_intr_enable(emu, voice); } -static void snd_emu10k1_playback_stop_voice(struct snd_emu10k1 *emu, struct snd_emu10k1_voice *evoice) +static void snd_emu10k1_playback_stop_voice(emu10k1_t *emu, emu10k1_voice_t *evoice) { unsigned int voice; @@ -723,13 +716,13 @@ static void snd_emu10k1_playback_stop_voice(struct snd_emu10k1 *emu, struct snd_ snd_emu10k1_ptr_write(emu, IP, voice, 0); } -static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream, +static int snd_emu10k1_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; - struct snd_emu10k1_pcm_mixer *mix; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; + emu10k1_pcm_mixer_t *mix; int result = 0; // printk("trigger - emu10k1 = 0x%x, cmd = %i, pointer = %i\n", (int)emu, cmd, substream->ops->pointer(substream)); @@ -740,7 +733,6 @@ static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream, snd_emu10k1_playback_invalidate_cache(emu, 0, epcm->voices[0]); /* follow thru */ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - case SNDRV_PCM_TRIGGER_RESUME: mix = &emu->pcm_mixer[substream->number]; snd_emu10k1_playback_prepare_voice(emu, epcm->voices[0], 1, 0, mix); snd_emu10k1_playback_prepare_voice(emu, epcm->voices[1], 0, 0, mix); @@ -752,7 +744,6 @@ static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream, break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - case SNDRV_PCM_TRIGGER_SUSPEND: epcm->running = 0; snd_emu10k1_playback_stop_voice(emu, epcm->voices[0]); snd_emu10k1_playback_stop_voice(emu, epcm->voices[1]); @@ -766,18 +757,17 @@ static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream, return result; } -static int snd_emu10k1_capture_trigger(struct snd_pcm_substream *substream, +static int snd_emu10k1_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; int result = 0; spin_lock(&emu->reg_lock); switch (cmd) { case SNDRV_PCM_TRIGGER_START: - case SNDRV_PCM_TRIGGER_RESUME: // hmm this should cause full and half full interrupt to be raised? outl(epcm->capture_ipr, emu->port + IPR); snd_emu10k1_intr_enable(emu, epcm->capture_inte); @@ -801,7 +791,6 @@ static int snd_emu10k1_capture_trigger(struct snd_pcm_substream *substream, epcm->first_ptr = 1; break; case SNDRV_PCM_TRIGGER_STOP: - case SNDRV_PCM_TRIGGER_SUSPEND: epcm->running = 0; snd_emu10k1_intr_disable(emu, epcm->capture_inte); outl(epcm->capture_ipr, emu->port + IPR); @@ -828,11 +817,11 @@ static int snd_emu10k1_capture_trigger(struct snd_pcm_substream *substream, return result; } -static snd_pcm_uframes_t snd_emu10k1_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_emu10k1_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; unsigned int ptr; if (!epcm->running) @@ -856,12 +845,12 @@ static snd_pcm_uframes_t snd_emu10k1_playback_pointer(struct snd_pcm_substream * } -static int snd_emu10k1_efx_playback_trigger(struct snd_pcm_substream *substream, +static int snd_emu10k1_efx_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; int i; int result = 0; @@ -876,7 +865,6 @@ static int snd_emu10k1_efx_playback_trigger(struct snd_pcm_substream *substream, /* follow thru */ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - case SNDRV_PCM_TRIGGER_RESUME: snd_emu10k1_playback_prepare_voice(emu, epcm->extra, 1, 1, NULL); snd_emu10k1_playback_prepare_voice(emu, epcm->voices[0], 0, 0, &emu->efx_pcm_mixer[0]); @@ -889,7 +877,6 @@ static int snd_emu10k1_efx_playback_trigger(struct snd_pcm_substream *substream, snd_emu10k1_playback_trigger_voice(emu, epcm->voices[i], 0, 0); epcm->running = 1; break; - case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: epcm->running = 0; @@ -907,11 +894,11 @@ static int snd_emu10k1_efx_playback_trigger(struct snd_pcm_substream *substream, } -static snd_pcm_uframes_t snd_emu10k1_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_emu10k1_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; unsigned int ptr; if (!epcm->running) @@ -928,11 +915,10 @@ static snd_pcm_uframes_t snd_emu10k1_capture_pointer(struct snd_pcm_substream *s * Playback support device description */ -static struct snd_pcm_hardware snd_emu10k1_playback = +static snd_pcm_hardware_t snd_emu10k1_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE), .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_96000, @@ -952,11 +938,10 @@ static struct snd_pcm_hardware snd_emu10k1_playback = * Capture support device description */ -static struct snd_pcm_hardware snd_emu10k1_capture = +static snd_pcm_hardware_t snd_emu10k1_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_8000_48000, @@ -976,9 +961,9 @@ static struct snd_pcm_hardware snd_emu10k1_capture = * */ -static void snd_emu10k1_pcm_mixer_notify1(struct snd_emu10k1 *emu, struct snd_kcontrol *kctl, int idx, int activate) +static void snd_emu10k1_pcm_mixer_notify1(emu10k1_t *emu, snd_kcontrol_t *kctl, int idx, int activate) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; if (! kctl) return; @@ -991,29 +976,29 @@ static void snd_emu10k1_pcm_mixer_notify1(struct snd_emu10k1 *emu, struct snd_kc snd_ctl_build_ioff(&id, kctl, idx)); } -static void snd_emu10k1_pcm_mixer_notify(struct snd_emu10k1 *emu, int idx, int activate) +static void snd_emu10k1_pcm_mixer_notify(emu10k1_t *emu, int idx, int activate) { snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_send_routing, idx, activate); snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_send_volume, idx, activate); snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_attn, idx, activate); } -static void snd_emu10k1_pcm_efx_mixer_notify(struct snd_emu10k1 *emu, int idx, int activate) +static void snd_emu10k1_pcm_efx_mixer_notify(emu10k1_t *emu, int idx, int activate) { snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_efx_send_routing, idx, activate); snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_efx_send_volume, idx, activate); snd_emu10k1_pcm_mixer_notify1(emu, emu->ctl_efx_attn, idx, activate); } -static void snd_emu10k1_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_emu10k1_pcm_free_substream(snd_pcm_runtime_t *runtime) { kfree(runtime->private_data); } -static int snd_emu10k1_efx_playback_close(struct snd_pcm_substream *substream) +static int snd_emu10k1_efx_playback_close(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_pcm_mixer *mix; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_pcm_mixer_t *mix; int i; for (i=0; i < NUM_EFX_PLAYBACK; i++) { @@ -1024,12 +1009,12 @@ static int snd_emu10k1_efx_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_efx_playback_open(struct snd_pcm_substream *substream) +static int snd_emu10k1_efx_playback_open(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_pcm *epcm; - struct snd_emu10k1_pcm_mixer *mix; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_pcm_t *epcm; + emu10k1_pcm_mixer_t *mix; + snd_pcm_runtime_t *runtime = substream->runtime; int i; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); @@ -1057,12 +1042,12 @@ static int snd_emu10k1_efx_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_playback_open(struct snd_pcm_substream *substream) +static int snd_emu10k1_playback_open(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_pcm *epcm; - struct snd_emu10k1_pcm_mixer *mix; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_pcm_t *epcm; + emu10k1_pcm_mixer_t *mix; + snd_pcm_runtime_t *runtime = substream->runtime; int i, err; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); @@ -1094,21 +1079,21 @@ static int snd_emu10k1_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_playback_close(struct snd_pcm_substream *substream) +static int snd_emu10k1_playback_close(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_pcm_mixer *mix = &emu->pcm_mixer[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_pcm_mixer_t *mix = &emu->pcm_mixer[substream->number]; mix->epcm = NULL; snd_emu10k1_pcm_mixer_notify(emu, substream->number, 0); return 0; } -static int snd_emu10k1_capture_open(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_open(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); if (epcm == NULL) @@ -1131,20 +1116,20 @@ static int snd_emu10k1_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_capture_close(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_close(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); + emu10k1_t *emu = snd_pcm_substream_chip(substream); emu->capture_interrupt = NULL; emu->pcm_capture_substream = NULL; return 0; } -static int snd_emu10k1_capture_mic_open(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_mic_open(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); if (epcm == NULL) @@ -1169,20 +1154,20 @@ static int snd_emu10k1_capture_mic_open(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_capture_mic_close(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_mic_close(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); + emu10k1_t *emu = snd_pcm_substream_chip(substream); emu->capture_interrupt = NULL; emu->pcm_capture_mic_substream = NULL; return 0; } -static int snd_emu10k1_capture_efx_open(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_efx_open(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; int nefx = emu->audigy ? 64 : 32; int idx; @@ -1219,16 +1204,16 @@ static int snd_emu10k1_capture_efx_open(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_capture_efx_close(struct snd_pcm_substream *substream) +static int snd_emu10k1_capture_efx_close(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); + emu10k1_t *emu = snd_pcm_substream_chip(substream); emu->capture_interrupt = NULL; emu->pcm_capture_efx_substream = NULL; return 0; } -static struct snd_pcm_ops snd_emu10k1_playback_ops = { +static snd_pcm_ops_t snd_emu10k1_playback_ops = { .open = snd_emu10k1_playback_open, .close = snd_emu10k1_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1240,7 +1225,7 @@ static struct snd_pcm_ops snd_emu10k1_playback_ops = { .page = snd_pcm_sgbuf_ops_page, }; -static struct snd_pcm_ops snd_emu10k1_capture_ops = { +static snd_pcm_ops_t snd_emu10k1_capture_ops = { .open = snd_emu10k1_capture_open, .close = snd_emu10k1_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1252,7 +1237,7 @@ static struct snd_pcm_ops snd_emu10k1_capture_ops = { }; /* EFX playback */ -static struct snd_pcm_ops snd_emu10k1_efx_playback_ops = { +static snd_pcm_ops_t snd_emu10k1_efx_playback_ops = { .open = snd_emu10k1_efx_playback_open, .close = snd_emu10k1_efx_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1264,10 +1249,17 @@ static struct snd_pcm_ops snd_emu10k1_efx_playback_ops = { .page = snd_pcm_sgbuf_ops_page, }; -int __devinit snd_emu10k1_pcm(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm) +static void snd_emu10k1_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; - struct snd_pcm_substream *substream; + emu10k1_t *emu = pcm->private_data; + emu->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __devinit snd_emu10k1_pcm(emu10k1_t * emu, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; + snd_pcm_substream_t *substream; int err; if (rpcm) @@ -1277,6 +1269,7 @@ int __devinit snd_emu10k1_pcm(struct snd_emu10k1 * emu, int device, struct snd_p return err; pcm->private_data = emu; + pcm->private_free = snd_emu10k1_pcm_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_emu10k1_capture_ops); @@ -1299,10 +1292,10 @@ int __devinit snd_emu10k1_pcm(struct snd_emu10k1 * emu, int device, struct snd_p return 0; } -int __devinit snd_emu10k1_pcm_multi(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm) +int __devinit snd_emu10k1_pcm_multi(emu10k1_t * emu, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; - struct snd_pcm_substream *substream; + snd_pcm_t *pcm; + snd_pcm_substream_t *substream; int err; if (rpcm) @@ -1312,13 +1305,14 @@ int __devinit snd_emu10k1_pcm_multi(struct snd_emu10k1 * emu, int device, struct return err; pcm->private_data = emu; + pcm->private_free = snd_emu10k1_pcm_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_efx_playback_ops); pcm->info_flags = 0; pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX; strcpy(pcm->name, "Multichannel Playback"); - emu->pcm_multi = pcm; + emu->pcm = pcm; for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) if ((err = snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG, snd_dma_pci_data(emu->pci), 64*1024, 64*1024)) < 0) @@ -1331,7 +1325,7 @@ int __devinit snd_emu10k1_pcm_multi(struct snd_emu10k1 * emu, int device, struct } -static struct snd_pcm_ops snd_emu10k1_capture_mic_ops = { +static snd_pcm_ops_t snd_emu10k1_capture_mic_ops = { .open = snd_emu10k1_capture_mic_open, .close = snd_emu10k1_capture_mic_close, .ioctl = snd_pcm_lib_ioctl, @@ -1342,9 +1336,16 @@ static struct snd_pcm_ops snd_emu10k1_capture_mic_ops = { .pointer = snd_emu10k1_capture_pointer, }; -int __devinit snd_emu10k1_pcm_mic(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm) +static void snd_emu10k1_pcm_mic_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + emu10k1_t *emu = pcm->private_data; + emu->pcm_mic = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __devinit snd_emu10k1_pcm_mic(emu10k1_t * emu, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -1354,6 +1355,7 @@ int __devinit snd_emu10k1_pcm_mic(struct snd_emu10k1 * emu, int device, struct s return err; pcm->private_data = emu; + pcm->private_free = snd_emu10k1_pcm_mic_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_emu10k1_capture_mic_ops); @@ -1368,9 +1370,9 @@ int __devinit snd_emu10k1_pcm_mic(struct snd_emu10k1 * emu, int device, struct s return 0; } -static int snd_emu10k1_pcm_efx_voices_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_emu10k1_pcm_efx_voices_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); int nefx = emu->audigy ? 64 : 32; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = nefx; @@ -1379,9 +1381,9 @@ static int snd_emu10k1_pcm_efx_voices_mask_info(struct snd_kcontrol *kcontrol, s return 0; } -static int snd_emu10k1_pcm_efx_voices_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_pcm_efx_voices_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); int nefx = emu->audigy ? 64 : 32; int idx; @@ -1392,9 +1394,9 @@ static int snd_emu10k1_pcm_efx_voices_mask_get(struct snd_kcontrol *kcontrol, st return 0; } -static int snd_emu10k1_pcm_efx_voices_mask_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_emu10k1_pcm_efx_voices_mask_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); unsigned int nval[2], bits; int nefx = emu->audigy ? 64 : 32; int nefxb = emu->audigy ? 7 : 6; @@ -1423,7 +1425,7 @@ static int snd_emu10k1_pcm_efx_voices_mask_put(struct snd_kcontrol *kcontrol, st return change; } -static struct snd_kcontrol_new snd_emu10k1_pcm_efx_voices_mask = { +static snd_kcontrol_new_t snd_emu10k1_pcm_efx_voices_mask = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = "Captured FX8010 Outputs", .info = snd_emu10k1_pcm_efx_voices_mask_info, @@ -1431,7 +1433,7 @@ static struct snd_kcontrol_new snd_emu10k1_pcm_efx_voices_mask = { .put = snd_emu10k1_pcm_efx_voices_mask_put }; -static struct snd_pcm_ops snd_emu10k1_capture_efx_ops = { +static snd_pcm_ops_t snd_emu10k1_capture_efx_ops = { .open = snd_emu10k1_capture_efx_open, .close = snd_emu10k1_capture_efx_close, .ioctl = snd_pcm_lib_ioctl, @@ -1448,9 +1450,9 @@ static struct snd_pcm_ops snd_emu10k1_capture_efx_ops = { #define INITIAL_TRAM_SHIFT 14 #define INITIAL_TRAM_POS(size) ((((size) / 2) - INITIAL_TRAM_SHIFT) - 1) -static void snd_emu10k1_fx8010_playback_irq(struct snd_emu10k1 *emu, void *private_data) +static void snd_emu10k1_fx8010_playback_irq(emu10k1_t *emu, void *private_data) { - struct snd_pcm_substream *substream = private_data; + snd_pcm_substream_t *substream = private_data; snd_pcm_period_elapsed(substream); } @@ -1474,11 +1476,11 @@ static void snd_emu10k1_fx8010_playback_tram_poke1(unsigned short *dst_left, } } -static void fx8010_pb_trans_copy(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, size_t bytes) +static void fx8010_pb_trans_copy(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, size_t bytes) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; unsigned int tram_size = pcm->buffer_size; unsigned short *src = (unsigned short *)(substream->runtime->dma_area + rec->sw_data); unsigned int frames = bytes >> 2, count; @@ -1503,25 +1505,25 @@ static void fx8010_pb_trans_copy(struct snd_pcm_substream *substream, pcm->tram_shift = tram_shift; } -static int snd_emu10k1_fx8010_playback_transfer(struct snd_pcm_substream *substream) +static int snd_emu10k1_fx8010_playback_transfer(snd_pcm_substream_t *substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; snd_pcm_indirect_playback_transfer(substream, &pcm->pcm_rec, fx8010_pb_trans_copy); return 0; } -static int snd_emu10k1_fx8010_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_emu10k1_fx8010_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_emu10k1_fx8010_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_emu10k1_fx8010_playback_hw_free(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; unsigned int i; for (i = 0; i < pcm->channels; i++) @@ -1530,11 +1532,11 @@ static int snd_emu10k1_fx8010_playback_hw_free(struct snd_pcm_substream *substre return 0; } -static int snd_emu10k1_fx8010_playback_prepare(struct snd_pcm_substream *substream) +static int snd_emu10k1_fx8010_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; unsigned int i; // printk("prepare: etram_pages = 0x%p, dma_area = 0x%x, buffer_size = 0x%x (0x%x)\n", emu->fx8010.etram_pages, runtime->dma_area, runtime->buffer_size, runtime->buffer_size << 2); @@ -1554,10 +1556,10 @@ static int snd_emu10k1_fx8010_playback_prepare(struct snd_pcm_substream *substre return 0; } -static int snd_emu10k1_fx8010_playback_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_emu10k1_fx8010_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; int result = 0; spin_lock(&emu->reg_lock); @@ -1565,7 +1567,6 @@ static int snd_emu10k1_fx8010_playback_trigger(struct snd_pcm_substream *substre case SNDRV_PCM_TRIGGER_START: /* follow thru */ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - case SNDRV_PCM_TRIGGER_RESUME: #ifdef EMU10K1_SET_AC3_IEC958 { int i; @@ -1586,7 +1587,6 @@ static int snd_emu10k1_fx8010_playback_trigger(struct snd_pcm_substream *substre break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - case SNDRV_PCM_TRIGGER_SUSPEND: snd_emu10k1_fx8010_unregister_irq_handler(emu, pcm->irq); pcm->irq = NULL; snd_emu10k1_ptr_write(emu, emu->gpr_base + pcm->gpr_trigger, 0, 0); pcm->tram_pos = INITIAL_TRAM_POS(pcm->buffer_size); @@ -1601,10 +1601,10 @@ static int snd_emu10k1_fx8010_playback_trigger(struct snd_pcm_substream *substre return result; } -static snd_pcm_uframes_t snd_emu10k1_fx8010_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_emu10k1_fx8010_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; size_t ptr; /* byte pointer */ if (!snd_emu10k1_ptr_read(emu, emu->gpr_base + pcm->gpr_trigger, 0)) @@ -1613,10 +1613,9 @@ static snd_pcm_uframes_t snd_emu10k1_fx8010_playback_pointer(struct snd_pcm_subs return snd_pcm_indirect_playback_pointer(substream, &pcm->pcm_rec, ptr); } -static struct snd_pcm_hardware snd_emu10k1_fx8010_playback = +static snd_pcm_hardware_t snd_emu10k1_fx8010_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_RESUME | /* SNDRV_PCM_INFO_MMAP_VALID | */ SNDRV_PCM_INFO_PAUSE), .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_48000, @@ -1632,11 +1631,11 @@ static struct snd_pcm_hardware snd_emu10k1_fx8010_playback = .fifo_size = 0, }; -static int snd_emu10k1_fx8010_playback_open(struct snd_pcm_substream *substream) +static int snd_emu10k1_fx8010_playback_open(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; runtime->hw = snd_emu10k1_fx8010_playback; runtime->hw.channels_min = runtime->hw.channels_max = pcm->channels; @@ -1651,10 +1650,10 @@ static int snd_emu10k1_fx8010_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_emu10k1_fx8010_playback_close(struct snd_pcm_substream *substream) +static int snd_emu10k1_fx8010_playback_close(snd_pcm_substream_t * substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_fx8010_pcm *pcm = &emu->fx8010.pcm[substream->number]; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_emu10k1_fx8010_pcm_t *pcm = &emu->fx8010.pcm[substream->number]; spin_lock_irq(&emu->reg_lock); pcm->opened = 0; @@ -1662,7 +1661,7 @@ static int snd_emu10k1_fx8010_playback_close(struct snd_pcm_substream *substream return 0; } -static struct snd_pcm_ops snd_emu10k1_fx8010_playback_ops = { +static snd_pcm_ops_t snd_emu10k1_fx8010_playback_ops = { .open = snd_emu10k1_fx8010_playback_open, .close = snd_emu10k1_fx8010_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1674,10 +1673,17 @@ static struct snd_pcm_ops snd_emu10k1_fx8010_playback_ops = { .ack = snd_emu10k1_fx8010_playback_transfer, }; -int __devinit snd_emu10k1_pcm_efx(struct snd_emu10k1 * emu, int device, struct snd_pcm ** rpcm) +static void snd_emu10k1_pcm_efx_free(snd_pcm_t *pcm) +{ + emu10k1_t *emu = pcm->private_data; + emu->pcm_efx = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __devinit snd_emu10k1_pcm_efx(emu10k1_t * emu, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; - struct snd_kcontrol *kctl; + snd_pcm_t *pcm; + snd_kcontrol_t *kctl; int err; if (rpcm) @@ -1687,6 +1693,7 @@ int __devinit snd_emu10k1_pcm_efx(struct snd_emu10k1 * emu, int device, struct s return err; pcm->private_data = emu; + pcm->private_free = snd_emu10k1_pcm_efx_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_emu10k1_fx8010_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_emu10k1_capture_efx_ops); diff --git a/trunk/sound/pci/emu10k1/emuproc.c b/trunk/sound/pci/emu10k1/emuproc.c index 90f1c52703a1..cc22707c91fa 100644 --- a/trunk/sound/pci/emu10k1/emuproc.c +++ b/trunk/sound/pci/emu10k1/emuproc.c @@ -32,9 +32,8 @@ #include <sound/emu10k1.h> #include "p16v.h" -#ifdef CONFIG_PROC_FS -static void snd_emu10k1_proc_spdif_status(struct snd_emu10k1 * emu, - struct snd_info_buffer *buffer, +static void snd_emu10k1_proc_spdif_status(emu10k1_t * emu, + snd_info_buffer_t * buffer, char *title, int status_reg, int rate_reg) @@ -76,8 +75,8 @@ static void snd_emu10k1_proc_spdif_status(struct snd_emu10k1 * emu, } -static void snd_emu10k1_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu10k1_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { /* FIXME - output names are in emufx.c too */ static char *creative_outs[32] = { @@ -182,7 +181,7 @@ static void snd_emu10k1_proc_read(struct snd_info_entry *entry, /* 63 */ "FXBUS2_31" }; - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; unsigned int val, val1; int nefx = emu->audigy ? 64 : 32; char **outputs = emu->audigy ? audigy_outs : creative_outs; @@ -233,10 +232,10 @@ static void snd_emu10k1_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, " Output %02i [%s]\n", idx, outputs[idx]); } -static void snd_emu10k1_proc_spdif_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu10k1_proc_spdif_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; snd_emu10k1_proc_spdif_status(emu, buffer, "CD-ROM S/PDIF In", CDCS, CDSRCS); snd_emu10k1_proc_spdif_status(emu, buffer, "Optical or Coax S/PDIF In", GPSCS, GPSRCS); #if 0 @@ -247,11 +246,11 @@ static void snd_emu10k1_proc_spdif_read(struct snd_info_entry *entry, #endif } -static void snd_emu10k1_proc_rates_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu10k1_proc_rates_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { static int samplerate[8] = { 44100, 48000, 96000, 192000, 4, 5, 6, 7 }; - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; unsigned int val, tmp, n; val = snd_emu10k1_ptr20_read(emu, CAPTURE_RATE_STATUS, 0); tmp = (val >> 16) & 0x8; @@ -262,11 +261,11 @@ static void snd_emu10k1_proc_rates_read(struct snd_info_entry *entry, } } -static void snd_emu10k1_proc_acode_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu10k1_proc_acode_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { u32 pc; - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; snd_iprintf(buffer, "FX8010 Instruction List '%s'\n", emu->fx8010.name); snd_iprintf(buffer, " Code dump :\n"); @@ -305,13 +304,12 @@ static void snd_emu10k1_proc_acode_read(struct snd_info_entry *entry, #define TOTAL_SIZE_CODE (0x200*8) #define A_TOTAL_SIZE_CODE (0x400*8) -static long snd_emu10k1_fx8010_read(struct snd_info_entry *entry, - void *file_private_data, +static long snd_emu10k1_fx8010_read(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *buf, unsigned long count, unsigned long pos) { long size; - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; unsigned int offset; int tram_addr = 0; @@ -351,11 +349,11 @@ static long snd_emu10k1_fx8010_read(struct snd_info_entry *entry, return 0; } -static void snd_emu10k1_proc_voices_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu10k1_proc_voices_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_emu10k1 *emu = entry->private_data; - struct snd_emu10k1_voice *voice; + emu10k1_t *emu = entry->private_data; + emu10k1_voice_t *voice; int idx; snd_iprintf(buffer, "ch\tuse\tpcm\tefx\tsynth\tmidi\n"); @@ -372,10 +370,10 @@ static void snd_emu10k1_proc_voices_read(struct snd_info_entry *entry, } #ifdef CONFIG_SND_DEBUG -static void snd_emu_proc_io_reg_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_io_reg_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; unsigned long value; unsigned long flags; int i; @@ -388,10 +386,10 @@ static void snd_emu_proc_io_reg_read(struct snd_info_entry *entry, } } -static void snd_emu_proc_io_reg_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_io_reg_write(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; unsigned long flags; char line[64]; u32 reg, val; @@ -406,7 +404,7 @@ static void snd_emu_proc_io_reg_write(struct snd_info_entry *entry, } } -static unsigned int snd_ptr_read(struct snd_emu10k1 * emu, +static unsigned int snd_ptr_read(emu10k1_t * emu, unsigned int iobase, unsigned int reg, unsigned int chn) @@ -423,7 +421,7 @@ static unsigned int snd_ptr_read(struct snd_emu10k1 * emu, return val; } -static void snd_ptr_write(struct snd_emu10k1 *emu, +static void snd_ptr_write(emu10k1_t *emu, unsigned int iobase, unsigned int reg, unsigned int chn, @@ -441,13 +439,13 @@ static void snd_ptr_write(struct snd_emu10k1 *emu, } -static void snd_emu_proc_ptr_reg_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer, int iobase, int offset, int length, int voices) +static void snd_emu_proc_ptr_reg_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer, int iobase, int offset, int length, int voices) { - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; unsigned long value; int i,j; - if (offset+length > 0xa0) { + if (offset+length > 0x80) { snd_iprintf(buffer, "Input values out of range\n"); return; } @@ -465,71 +463,65 @@ static void snd_emu_proc_ptr_reg_read(struct snd_info_entry *entry, } } -static void snd_emu_proc_ptr_reg_write(struct snd_info_entry *entry, - struct snd_info_buffer *buffer, int iobase) +static void snd_emu_proc_ptr_reg_write(snd_info_entry_t *entry, + snd_info_buffer_t * buffer, int iobase) { - struct snd_emu10k1 *emu = entry->private_data; + emu10k1_t *emu = entry->private_data; char line[64]; unsigned int reg, channel_id , val; while (!snd_info_get_line(buffer, line, sizeof(line))) { if (sscanf(line, "%x %x %x", ®, &channel_id, &val) != 3) continue; - if ((reg < 0xa0) && (reg >=0) && (val <= 0xffffffff) && (channel_id >=0) && (channel_id <= 3) ) + if ((reg < 0x80) && (reg >=0) && (val <= 0xffffffff) && (channel_id >=0) && (channel_id <= 3) ) snd_ptr_write(emu, iobase, reg, channel_id, val); } } -static void snd_emu_proc_ptr_reg_write00(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_ptr_reg_write00(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { snd_emu_proc_ptr_reg_write(entry, buffer, 0); } -static void snd_emu_proc_ptr_reg_write20(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_ptr_reg_write20(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { snd_emu_proc_ptr_reg_write(entry, buffer, 0x20); } -static void snd_emu_proc_ptr_reg_read00a(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_ptr_reg_read00a(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { snd_emu_proc_ptr_reg_read(entry, buffer, 0, 0, 0x40, 64); } -static void snd_emu_proc_ptr_reg_read00b(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_ptr_reg_read00b(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { snd_emu_proc_ptr_reg_read(entry, buffer, 0, 0x40, 0x40, 64); } -static void snd_emu_proc_ptr_reg_read20a(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_ptr_reg_read20a(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0, 0x40, 4); } -static void snd_emu_proc_ptr_reg_read20b(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_emu_proc_ptr_reg_read20b(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0x40, 0x40, 4); } - -static void snd_emu_proc_ptr_reg_read20c(struct snd_info_entry *entry, - struct snd_info_buffer * buffer) -{ - snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0x80, 0x20, 4); -} #endif static struct snd_info_entry_ops snd_emu10k1_proc_ops_fx8010 = { .read = snd_emu10k1_fx8010_read, }; -int __devinit snd_emu10k1_proc_init(struct snd_emu10k1 * emu) +int __devinit snd_emu10k1_proc_init(emu10k1_t * emu) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; #ifdef CONFIG_SND_DEBUG if (! snd_card_proc_new(emu->card, "io_regs", &entry)) { snd_info_set_text_ops(entry, emu, 1024, snd_emu_proc_io_reg_read); @@ -561,12 +553,6 @@ int __devinit snd_emu10k1_proc_init(struct snd_emu10k1 * emu) entry->c.text.write = snd_emu_proc_ptr_reg_write20; entry->mode |= S_IWUSR; } - if (! snd_card_proc_new(emu->card, "ptr_regs20c", &entry)) { - snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read20c); - entry->c.text.write_size = 64; - entry->c.text.write = snd_emu_proc_ptr_reg_write20; - entry->mode |= S_IWUSR; - } #endif if (! snd_card_proc_new(emu->card, "emu10k1", &entry)) @@ -621,4 +607,3 @@ int __devinit snd_emu10k1_proc_init(struct snd_emu10k1 * emu) } return 0; } -#endif /* CONFIG_PROC_FS */ diff --git a/trunk/sound/pci/emu10k1/io.c b/trunk/sound/pci/emu10k1/io.c index ef5304df8c11..b9d3ae0dcab7 100644 --- a/trunk/sound/pci/emu10k1/io.c +++ b/trunk/sound/pci/emu10k1/io.c @@ -29,9 +29,8 @@ #include <linux/time.h> #include <sound/core.h> #include <sound/emu10k1.h> -#include <linux/delay.h> -unsigned int snd_emu10k1_ptr_read(struct snd_emu10k1 * emu, unsigned int reg, unsigned int chn) +unsigned int snd_emu10k1_ptr_read(emu10k1_t * emu, unsigned int reg, unsigned int chn) { unsigned long flags; unsigned int regptr, val; @@ -62,7 +61,7 @@ unsigned int snd_emu10k1_ptr_read(struct snd_emu10k1 * emu, unsigned int reg, un } } -void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned int chn, unsigned int data) +void snd_emu10k1_ptr_write(emu10k1_t *emu, unsigned int reg, unsigned int chn, unsigned int data) { unsigned int regptr; unsigned long flags; @@ -92,7 +91,7 @@ void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned i } } -unsigned int snd_emu10k1_ptr20_read(struct snd_emu10k1 * emu, +unsigned int snd_emu10k1_ptr20_read(emu10k1_t * emu, unsigned int reg, unsigned int chn) { @@ -108,7 +107,7 @@ unsigned int snd_emu10k1_ptr20_read(struct snd_emu10k1 * emu, return val; } -void snd_emu10k1_ptr20_write(struct snd_emu10k1 *emu, +void snd_emu10k1_ptr20_write(emu10k1_t *emu, unsigned int reg, unsigned int chn, unsigned int data) @@ -124,46 +123,7 @@ void snd_emu10k1_ptr20_write(struct snd_emu10k1 *emu, spin_unlock_irqrestore(&emu->emu_lock, flags); } -int snd_emu10k1_spi_write(struct snd_emu10k1 * emu, - unsigned int data) -{ - unsigned int reset, set; - unsigned int reg, tmp; - int n, result; - if (emu->card_capabilities->ca0108_chip) - reg = 0x3c; /* PTR20, reg 0x3c */ - else { - /* For other chip types the SPI register - * is currently unknown. */ - return 1; - } - if (data > 0xffff) /* Only 16bit values allowed */ - return 1; - - tmp = snd_emu10k1_ptr20_read(emu, reg, 0); - reset = (tmp & ~0x3ffff) | 0x20000; /* Set xxx20000 */ - set = reset | 0x10000; /* Set xxx1xxxx */ - snd_emu10k1_ptr20_write(emu, reg, 0, reset | data); - tmp = snd_emu10k1_ptr20_read(emu, reg, 0); /* write post */ - snd_emu10k1_ptr20_write(emu, reg, 0, set | data); - result = 1; - /* Wait for status bit to return to 0 */ - for (n = 0; n < 100; n++) { - udelay(10); - tmp = snd_emu10k1_ptr20_read(emu, reg, 0); - if (!(tmp & 0x10000)) { - result = 0; - break; - } - } - if (result) /* Timed out */ - return 1; - snd_emu10k1_ptr20_write(emu, reg, 0, reset | data); - tmp = snd_emu10k1_ptr20_read(emu, reg, 0); /* Write post */ - return 0; -} - -void snd_emu10k1_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb) +void snd_emu10k1_intr_enable(emu10k1_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int enable; @@ -174,7 +134,7 @@ void snd_emu10k1_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb) spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb) +void snd_emu10k1_intr_disable(emu10k1_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int enable; @@ -185,7 +145,7 @@ void snd_emu10k1_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb) spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_intr_enable(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; unsigned int val; @@ -205,7 +165,7 @@ void snd_emu10k1_voice_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenu spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_intr_disable(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; unsigned int val; @@ -225,7 +185,7 @@ void snd_emu10k1_voice_intr_disable(struct snd_emu10k1 *emu, unsigned int voicen spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_intr_ack(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; @@ -242,7 +202,7 @@ void snd_emu10k1_voice_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum) spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_half_loop_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_half_loop_intr_enable(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; unsigned int val; @@ -262,7 +222,7 @@ void snd_emu10k1_voice_half_loop_intr_enable(struct snd_emu10k1 *emu, unsigned i spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_half_loop_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_half_loop_intr_disable(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; unsigned int val; @@ -282,7 +242,7 @@ void snd_emu10k1_voice_half_loop_intr_disable(struct snd_emu10k1 *emu, unsigned spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_half_loop_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_half_loop_intr_ack(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; @@ -299,7 +259,7 @@ void snd_emu10k1_voice_half_loop_intr_ack(struct snd_emu10k1 *emu, unsigned int spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_set_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_set_loop_stop(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; unsigned int sol; @@ -319,7 +279,7 @@ void snd_emu10k1_voice_set_loop_stop(struct snd_emu10k1 *emu, unsigned int voice spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_voice_clear_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum) +void snd_emu10k1_voice_clear_loop_stop(emu10k1_t *emu, unsigned int voicenum) { unsigned long flags; unsigned int sol; @@ -339,7 +299,7 @@ void snd_emu10k1_voice_clear_loop_stop(struct snd_emu10k1 *emu, unsigned int voi spin_unlock_irqrestore(&emu->emu_lock, flags); } -void snd_emu10k1_wait(struct snd_emu10k1 *emu, unsigned int wait) +void snd_emu10k1_wait(emu10k1_t *emu, unsigned int wait) { volatile unsigned count; unsigned int newtime = 0, curtime; @@ -358,9 +318,9 @@ void snd_emu10k1_wait(struct snd_emu10k1 *emu, unsigned int wait) } } -unsigned short snd_emu10k1_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +unsigned short snd_emu10k1_ac97_read(ac97_t *ac97, unsigned short reg) { - struct snd_emu10k1 *emu = ac97->private_data; + emu10k1_t *emu = ac97->private_data; unsigned long flags; unsigned short val; @@ -371,9 +331,9 @@ unsigned short snd_emu10k1_ac97_read(struct snd_ac97 *ac97, unsigned short reg) return val; } -void snd_emu10k1_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short data) +void snd_emu10k1_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short data) { - struct snd_emu10k1 *emu = ac97->private_data; + emu10k1_t *emu = ac97->private_data; unsigned long flags; spin_lock_irqsave(&emu->emu_lock, flags); diff --git a/trunk/sound/pci/emu10k1/irq.c b/trunk/sound/pci/emu10k1/irq.c index a8b31286b6db..594ea063b140 100644 --- a/trunk/sound/pci/emu10k1/irq.c +++ b/trunk/sound/pci/emu10k1/irq.c @@ -32,7 +32,7 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_emu10k1 *emu = dev_id; + emu10k1_t *emu = dev_id; unsigned int status, status2, orig_status, orig_status2; int handled = 0; @@ -56,7 +56,7 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs) int voice; int voice_max = status & IPR_CHANNELNUMBERMASK; u32 val; - struct snd_emu10k1_voice *pvoice = emu->voices; + emu10k1_voice_t *pvoice = emu->voices; val = snd_emu10k1_ptr_read(emu, CLIPL, 0); for (voice = 0; voice <= voice_max; voice++) { @@ -150,8 +150,8 @@ irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs) if (status & IPR_P16V) { while ((status2 = inl(emu->port + IPR2)) != 0) { u32 mask = INTE2_PLAYBACK_CH_0_LOOP; /* Full Loop */ - struct snd_emu10k1_voice *pvoice = &(emu->p16v_voices[0]); - struct snd_emu10k1_voice *cvoice = &(emu->p16v_capture_voice); + emu10k1_voice_t *pvoice = &(emu->p16v_voices[0]); + emu10k1_voice_t *cvoice = &(emu->p16v_capture_voice); //printk(KERN_INFO "status2=0x%x\n", status2); orig_status2 = status2; diff --git a/trunk/sound/pci/emu10k1/memory.c b/trunk/sound/pci/emu10k1/memory.c index 68c795c03109..d42e4aeaa73a 100644 --- a/trunk/sound/pci/emu10k1/memory.c +++ b/trunk/sound/pci/emu10k1/memory.c @@ -48,7 +48,7 @@ #define set_silent_ptb(emu,page) __set_ptb_entry(emu,page,emu->silent_page.addr) #else /* fill PTB entries -- we need to fill UNIT_PAGES entries */ -static inline void set_ptb_entry(struct snd_emu10k1 *emu, int page, dma_addr_t addr) +static inline void set_ptb_entry(emu10k1_t *emu, int page, dma_addr_t addr) { int i; page *= UNIT_PAGES; @@ -57,7 +57,7 @@ static inline void set_ptb_entry(struct snd_emu10k1 *emu, int page, dma_addr_t a addr += EMUPAGESIZE; } } -static inline void set_silent_ptb(struct snd_emu10k1 *emu, int page) +static inline void set_silent_ptb(emu10k1_t *emu, int page) { int i; page *= UNIT_PAGES; @@ -70,14 +70,14 @@ static inline void set_silent_ptb(struct snd_emu10k1 *emu, int page) /* */ -static int synth_alloc_pages(struct snd_emu10k1 *hw, struct snd_emu10k1_memblk *blk); -static int synth_free_pages(struct snd_emu10k1 *hw, struct snd_emu10k1_memblk *blk); +static int synth_alloc_pages(emu10k1_t *hw, emu10k1_memblk_t *blk); +static int synth_free_pages(emu10k1_t *hw, emu10k1_memblk_t *blk); -#define get_emu10k1_memblk(l,member) list_entry(l, struct snd_emu10k1_memblk, member) +#define get_emu10k1_memblk(l,member) list_entry(l, emu10k1_memblk_t, member) /* initialize emu10k1 part */ -static void emu10k1_memblk_init(struct snd_emu10k1_memblk *blk) +static void emu10k1_memblk_init(emu10k1_memblk_t *blk) { blk->mapped_page = -1; INIT_LIST_HEAD(&blk->mapped_link); @@ -96,7 +96,7 @@ static void emu10k1_memblk_init(struct snd_emu10k1_memblk *blk) * in nextp * if not found, return a negative error code. */ -static int search_empty_map_area(struct snd_emu10k1 *emu, int npages, struct list_head **nextp) +static int search_empty_map_area(emu10k1_t *emu, int npages, struct list_head **nextp) { int page = 0, found_page = -ENOMEM; int max_size = npages; @@ -105,7 +105,7 @@ static int search_empty_map_area(struct snd_emu10k1 *emu, int npages, struct lis struct list_head *pos; list_for_each (pos, &emu->mapped_link_head) { - struct snd_emu10k1_memblk *blk = get_emu10k1_memblk(pos, mapped_link); + emu10k1_memblk_t *blk = get_emu10k1_memblk(pos, mapped_link); snd_assert(blk->mapped_page >= 0, continue); size = blk->mapped_page - page; if (size == npages) { @@ -134,7 +134,7 @@ static int search_empty_map_area(struct snd_emu10k1 *emu, int npages, struct lis * * call with memblk_lock held */ -static int map_memblk(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk) +static int map_memblk(emu10k1_t *emu, emu10k1_memblk_t *blk) { int page, pg; struct list_head *next; @@ -161,11 +161,11 @@ static int map_memblk(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk) * * call with memblk_lock held */ -static int unmap_memblk(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk) +static int unmap_memblk(emu10k1_t *emu, emu10k1_memblk_t *blk) { int start_page, end_page, mpage, pg; struct list_head *p; - struct snd_emu10k1_memblk *q; + emu10k1_memblk_t *q; /* calculate the expected size of empty region */ if ((p = blk->mapped_link.prev) != &emu->mapped_link_head) { @@ -197,11 +197,11 @@ static int unmap_memblk(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk) * * unlike synth_alloc the memory block is aligned to the page start */ -static struct snd_emu10k1_memblk * -search_empty(struct snd_emu10k1 *emu, int size) +static emu10k1_memblk_t * +search_empty(emu10k1_t *emu, int size) { struct list_head *p; - struct snd_emu10k1_memblk *blk; + emu10k1_memblk_t *blk; int page, psize; psize = get_aligned_page(size + PAGE_SIZE -1); @@ -217,7 +217,7 @@ search_empty(struct snd_emu10k1 *emu, int size) __found_pages: /* create a new memory block */ - blk = (struct snd_emu10k1_memblk *)__snd_util_memblk_new(emu->memhdr, psize << PAGE_SHIFT, p->prev); + blk = (emu10k1_memblk_t *)__snd_util_memblk_new(emu->memhdr, psize << PAGE_SHIFT, p->prev); if (blk == NULL) return NULL; blk->mem.offset = aligned_page_offset(page); /* set aligned offset */ @@ -229,7 +229,7 @@ search_empty(struct snd_emu10k1 *emu, int size) /* * check if the given pointer is valid for pages */ -static int is_valid_page(struct snd_emu10k1 *emu, dma_addr_t addr) +static int is_valid_page(emu10k1_t *emu, dma_addr_t addr) { if (addr & ~emu->dma_mask) { snd_printk(KERN_ERR "max memory size is 0x%lx (addr = 0x%lx)!!\n", emu->dma_mask, (unsigned long)addr); @@ -248,12 +248,12 @@ static int is_valid_page(struct snd_emu10k1 *emu, dma_addr_t addr) * if no empty pages are found, tries to release unsed memory blocks * and retry the mapping. */ -int snd_emu10k1_memblk_map(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk) +int snd_emu10k1_memblk_map(emu10k1_t *emu, emu10k1_memblk_t *blk) { int err; int size; struct list_head *p, *nextp; - struct snd_emu10k1_memblk *deleted; + emu10k1_memblk_t *deleted; unsigned long flags; spin_lock_irqsave(&emu->memblk_lock, flags); @@ -288,13 +288,13 @@ int snd_emu10k1_memblk_map(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *b /* * page allocation for DMA */ -struct snd_util_memblk * -snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *substream) +snd_util_memblk_t * +snd_emu10k1_alloc_pages(emu10k1_t *emu, snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); - struct snd_util_memhdr *hdr; - struct snd_emu10k1_memblk *blk; + snd_util_memhdr_t *hdr; + emu10k1_memblk_t *blk; int page, err, idx; snd_assert(emu, return NULL); @@ -336,19 +336,19 @@ snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *subst blk->map_locked = 1; /* do not unmap this block! */ err = snd_emu10k1_memblk_map(emu, blk); if (err < 0) { - __snd_util_mem_free(hdr, (struct snd_util_memblk *)blk); + __snd_util_mem_free(hdr, (snd_util_memblk_t *)blk); up(&hdr->block_mutex); return NULL; } up(&hdr->block_mutex); - return (struct snd_util_memblk *)blk; + return (snd_util_memblk_t *)blk; } /* * release DMA buffer from page table */ -int snd_emu10k1_free_pages(struct snd_emu10k1 *emu, struct snd_util_memblk *blk) +int snd_emu10k1_free_pages(emu10k1_t *emu, snd_util_memblk_t *blk) { snd_assert(emu && blk, return -EINVAL); return snd_emu10k1_synth_free(emu, blk); @@ -363,26 +363,26 @@ int snd_emu10k1_free_pages(struct snd_emu10k1 *emu, struct snd_util_memblk *blk) /* * allocate a synth sample area */ -struct snd_util_memblk * -snd_emu10k1_synth_alloc(struct snd_emu10k1 *hw, unsigned int size) +snd_util_memblk_t * +snd_emu10k1_synth_alloc(emu10k1_t *hw, unsigned int size) { - struct snd_emu10k1_memblk *blk; - struct snd_util_memhdr *hdr = hw->memhdr; + emu10k1_memblk_t *blk; + snd_util_memhdr_t *hdr = hw->memhdr; down(&hdr->block_mutex); - blk = (struct snd_emu10k1_memblk *)__snd_util_mem_alloc(hdr, size); + blk = (emu10k1_memblk_t *)__snd_util_mem_alloc(hdr, size); if (blk == NULL) { up(&hdr->block_mutex); return NULL; } if (synth_alloc_pages(hw, blk)) { - __snd_util_mem_free(hdr, (struct snd_util_memblk *)blk); + __snd_util_mem_free(hdr, (snd_util_memblk_t *)blk); up(&hdr->block_mutex); return NULL; } snd_emu10k1_memblk_map(hw, blk); up(&hdr->block_mutex); - return (struct snd_util_memblk *)blk; + return (snd_util_memblk_t *)blk; } @@ -390,10 +390,10 @@ snd_emu10k1_synth_alloc(struct snd_emu10k1 *hw, unsigned int size) * free a synth sample area */ int -snd_emu10k1_synth_free(struct snd_emu10k1 *emu, struct snd_util_memblk *memblk) +snd_emu10k1_synth_free(emu10k1_t *emu, snd_util_memblk_t *memblk) { - struct snd_util_memhdr *hdr = emu->memhdr; - struct snd_emu10k1_memblk *blk = (struct snd_emu10k1_memblk *)memblk; + snd_util_memhdr_t *hdr = emu->memhdr; + emu10k1_memblk_t *blk = (emu10k1_memblk_t *)memblk; unsigned long flags; down(&hdr->block_mutex); @@ -409,12 +409,10 @@ snd_emu10k1_synth_free(struct snd_emu10k1 *emu, struct snd_util_memblk *memblk) /* check new allocation range */ -static void get_single_page_range(struct snd_util_memhdr *hdr, - struct snd_emu10k1_memblk *blk, - int *first_page_ret, int *last_page_ret) +static void get_single_page_range(snd_util_memhdr_t *hdr, emu10k1_memblk_t *blk, int *first_page_ret, int *last_page_ret) { struct list_head *p; - struct snd_emu10k1_memblk *q; + emu10k1_memblk_t *q; int first_page, last_page; first_page = blk->first_page; if ((p = blk->mem.list.prev) != &hdr->block) { @@ -435,7 +433,7 @@ static void get_single_page_range(struct snd_util_memhdr *hdr, /* * allocate kernel pages */ -static int synth_alloc_pages(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk) +static int synth_alloc_pages(emu10k1_t *emu, emu10k1_memblk_t *blk) { int page, first_page, last_page; struct snd_dma_buffer dmab; @@ -474,7 +472,7 @@ static int synth_alloc_pages(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk /* * free pages */ -static int synth_free_pages(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *blk) +static int synth_free_pages(emu10k1_t *emu, emu10k1_memblk_t *blk) { int page, first_page, last_page; struct snd_dma_buffer dmab; @@ -497,7 +495,7 @@ static int synth_free_pages(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk * } /* calculate buffer pointer from offset address */ -static inline void *offset_ptr(struct snd_emu10k1 *emu, int page, int offset) +static inline void *offset_ptr(emu10k1_t *emu, int page, int offset) { char *ptr; snd_assert(page >= 0 && page < emu->max_cache_pages, return NULL); @@ -513,12 +511,11 @@ static inline void *offset_ptr(struct snd_emu10k1 *emu, int page, int offset) /* * bzero(blk + offset, size) */ -int snd_emu10k1_synth_bzero(struct snd_emu10k1 *emu, struct snd_util_memblk *blk, - int offset, int size) +int snd_emu10k1_synth_bzero(emu10k1_t *emu, snd_util_memblk_t *blk, int offset, int size) { int page, nextofs, end_offset, temp, temp1; void *ptr; - struct snd_emu10k1_memblk *p = (struct snd_emu10k1_memblk *)blk; + emu10k1_memblk_t *p = (emu10k1_memblk_t *)blk; offset += blk->offset & (PAGE_SIZE - 1); end_offset = offset + size; @@ -541,12 +538,11 @@ int snd_emu10k1_synth_bzero(struct snd_emu10k1 *emu, struct snd_util_memblk *blk /* * copy_from_user(blk + offset, data, size) */ -int snd_emu10k1_synth_copy_from_user(struct snd_emu10k1 *emu, struct snd_util_memblk *blk, - int offset, const char __user *data, int size) +int snd_emu10k1_synth_copy_from_user(emu10k1_t *emu, snd_util_memblk_t *blk, int offset, const char __user *data, int size) { int page, nextofs, end_offset, temp, temp1; void *ptr; - struct snd_emu10k1_memblk *p = (struct snd_emu10k1_memblk *)blk; + emu10k1_memblk_t *p = (emu10k1_memblk_t *)blk; offset += blk->offset & (PAGE_SIZE - 1); end_offset = offset + size; diff --git a/trunk/sound/pci/emu10k1/p16v.c b/trunk/sound/pci/emu10k1/p16v.c index 9905651935fb..e27ebb9bb74a 100644 --- a/trunk/sound/pci/emu10k1/p16v.c +++ b/trunk/sound/pci/emu10k1/p16v.c @@ -93,7 +93,6 @@ #include <linux/interrupt.h> #include <linux/pci.h> #include <linux/slab.h> -#include <linux/vmalloc.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/initval.h> @@ -107,11 +106,11 @@ #define PCM_FRONT_CHANNEL 0 #define PCM_REAR_CHANNEL 1 #define PCM_CENTER_LFE_CHANNEL 2 -#define PCM_SIDE_CHANNEL 3 +#define PCM_UNKNOWN_CHANNEL 3 #define CONTROL_FRONT_CHANNEL 0 #define CONTROL_REAR_CHANNEL 3 #define CONTROL_CENTER_LFE_CHANNEL 1 -#define CONTROL_SIDE_CHANNEL 2 +#define CONTROL_UNKNOWN_CHANNEL 2 /* Card IDs: * Class 0401: 1102:0004 (rev 04) Subsystem: 1102:2002 -> Audigy2 ZS 7.1 Model:SB0350 @@ -122,11 +121,10 @@ */ /* hardware definition */ -static struct snd_pcm_hardware snd_p16v_playback_hw = { +static snd_pcm_hardware_t snd_p16v_playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S32_LE, /* Only supports 24-bit samples padded to 32 bits. */ .rates = SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100, @@ -142,11 +140,10 @@ static struct snd_pcm_hardware snd_p16v_playback_hw = { .fifo_size = 0, }; -static struct snd_pcm_hardware snd_p16v_capture_hw = { +static snd_pcm_hardware_t snd_p16v_capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S32_LE, .rates = SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100, @@ -162,9 +159,9 @@ static struct snd_pcm_hardware snd_p16v_capture_hw = { .fifo_size = 0, }; -static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_p16v_pcm_free_substream(snd_pcm_runtime_t *runtime) { - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_pcm_t *epcm = runtime->private_data; if (epcm) { //snd_printk("epcm free: %p\n", epcm); @@ -173,12 +170,12 @@ static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime) } /* open_playback callback */ -static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substream, int channel_id) +static int snd_p16v_pcm_open_playback_channel(snd_pcm_substream_t *substream, int channel_id) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_voice *channel = &(emu->p16v_voices[channel_id]); - struct snd_emu10k1_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_voice_t *channel = &(emu->p16v_voices[channel_id]); + emu10k1_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; int err; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); @@ -209,12 +206,12 @@ static int snd_p16v_pcm_open_playback_channel(struct snd_pcm_substream *substrea return 0; } /* open_capture callback */ -static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream, int channel_id) +static int snd_p16v_pcm_open_capture_channel(snd_pcm_substream_t *substream, int channel_id) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_emu10k1_voice *channel = &(emu->p16v_capture_voice); - struct snd_emu10k1_pcm *epcm; - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + emu10k1_voice_t *channel = &(emu->p16v_capture_voice); + emu10k1_pcm_t *epcm; + snd_pcm_runtime_t *runtime = substream->runtime; int err; epcm = kzalloc(sizeof(*epcm), GFP_KERNEL); @@ -247,41 +244,41 @@ static int snd_p16v_pcm_open_capture_channel(struct snd_pcm_substream *substream /* close callback */ -static int snd_p16v_pcm_close_playback(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_close_playback(snd_pcm_substream_t *substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - //struct snd_pcm_runtime *runtime = substream->runtime; - //struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + //snd_pcm_runtime_t *runtime = substream->runtime; + //emu10k1_pcm_t *epcm = runtime->private_data; emu->p16v_voices[substream->pcm->device - emu->p16v_device_offset].use=0; /* FIXME: maybe zero others */ return 0; } /* close callback */ -static int snd_p16v_pcm_close_capture(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_close_capture(snd_pcm_substream_t *substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - //struct snd_pcm_runtime *runtime = substream->runtime; - //struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + //snd_pcm_runtime_t *runtime = substream->runtime; + //emu10k1_pcm_t *epcm = runtime->private_data; emu->p16v_capture_voice.use=0; /* FIXME: maybe zero others */ return 0; } -static int snd_p16v_pcm_open_playback_front(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_open_playback_front(snd_pcm_substream_t *substream) { return snd_p16v_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL); } -static int snd_p16v_pcm_open_capture(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_open_capture(snd_pcm_substream_t *substream) { // Only using channel 0 for now, but the card has 2 channels. return snd_p16v_pcm_open_capture_channel(substream, 0); } /* hw_params callback */ -static int snd_p16v_pcm_hw_params_playback(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_p16v_pcm_hw_params_playback(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { int result; result = snd_pcm_lib_malloc_pages(substream, @@ -290,8 +287,8 @@ static int snd_p16v_pcm_hw_params_playback(struct snd_pcm_substream *substream, } /* hw_params callback */ -static int snd_p16v_pcm_hw_params_capture(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_p16v_pcm_hw_params_capture(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { int result; result = snd_pcm_lib_malloc_pages(substream, @@ -301,7 +298,7 @@ static int snd_p16v_pcm_hw_params_capture(struct snd_pcm_substream *substream, /* hw_free callback */ -static int snd_p16v_pcm_hw_free_playback(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_hw_free_playback(snd_pcm_substream_t *substream) { int result; result = snd_pcm_lib_free_pages(substream); @@ -309,7 +306,7 @@ static int snd_p16v_pcm_hw_free_playback(struct snd_pcm_substream *substream) } /* hw_free callback */ -static int snd_p16v_pcm_hw_free_capture(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_hw_free_capture(snd_pcm_substream_t *substream) { int result; result = snd_pcm_lib_free_pages(substream); @@ -318,10 +315,10 @@ static int snd_p16v_pcm_hw_free_capture(struct snd_pcm_substream *substream) /* prepare playback callback */ -static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_prepare_playback(snd_pcm_substream_t *substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int channel = substream->pcm->device - emu->p16v_device_offset; u32 *table_base = (u32 *)(emu->p16v_buffer.area+(8*16*channel)); u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size); @@ -367,10 +364,10 @@ static int snd_p16v_pcm_prepare_playback(struct snd_pcm_substream *substream) } /* prepare capture callback */ -static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream *substream) +static int snd_p16v_pcm_prepare_capture(snd_pcm_substream_t *substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int channel = substream->pcm->device - emu->p16v_device_offset; u32 tmp; //printk("prepare capture:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, frames_to_bytes(runtime, 1)); @@ -401,7 +398,7 @@ static int snd_p16v_pcm_prepare_capture(struct snd_pcm_substream *substream) return 0; } -static void snd_p16v_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb) +static void snd_p16v_intr_enable(emu10k1_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int enable; @@ -412,7 +409,7 @@ static void snd_p16v_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb) spin_unlock_irqrestore(&emu->emu_lock, flags); } -static void snd_p16v_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb) +static void snd_p16v_intr_disable(emu10k1_t *emu, unsigned int intrenb) { unsigned long flags; unsigned int disable; @@ -424,16 +421,16 @@ static void snd_p16v_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb) } /* trigger_playback callback */ -static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream *substream, +static int snd_p16v_pcm_trigger_playback(snd_pcm_substream_t *substream, int cmd) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime; - struct snd_emu10k1_pcm *epcm; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime; + emu10k1_pcm_t *epcm; int channel; int result = 0; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; u32 basic = 0; u32 inte = 0; int running=0; @@ -477,12 +474,12 @@ static int snd_p16v_pcm_trigger_playback(struct snd_pcm_substream *substream, } /* trigger_capture callback */ -static int snd_p16v_pcm_trigger_capture(struct snd_pcm_substream *substream, +static int snd_p16v_pcm_trigger_capture(snd_pcm_substream_t *substream, int cmd) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; int channel = 0; int result = 0; u32 inte = INTE2_CAPTURE_CH_0_LOOP | INTE2_CAPTURE_CH_0_HALF_LOOP; @@ -508,11 +505,11 @@ static int snd_p16v_pcm_trigger_capture(struct snd_pcm_substream *substream, /* pointer_playback callback */ static snd_pcm_uframes_t -snd_p16v_pcm_pointer_playback(struct snd_pcm_substream *substream) +snd_p16v_pcm_pointer_playback(snd_pcm_substream_t *substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0; int channel = substream->pcm->device - emu->p16v_device_offset; if (!epcm->running) @@ -533,11 +530,11 @@ snd_p16v_pcm_pointer_playback(struct snd_pcm_substream *substream) /* pointer_capture callback */ static snd_pcm_uframes_t -snd_p16v_pcm_pointer_capture(struct snd_pcm_substream *substream) +snd_p16v_pcm_pointer_capture(snd_pcm_substream_t *substream) { - struct snd_emu10k1 *emu = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_emu10k1_pcm *epcm = runtime->private_data; + emu10k1_t *emu = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + emu10k1_pcm_t *epcm = runtime->private_data; snd_pcm_uframes_t ptr, ptr1, ptr2 = 0; int channel = 0; @@ -557,7 +554,7 @@ snd_p16v_pcm_pointer_capture(struct snd_pcm_substream *substream) } /* operators */ -static struct snd_pcm_ops snd_p16v_playback_front_ops = { +static snd_pcm_ops_t snd_p16v_playback_front_ops = { .open = snd_p16v_pcm_open_playback_front, .close = snd_p16v_pcm_close_playback, .ioctl = snd_pcm_lib_ioctl, @@ -568,7 +565,7 @@ static struct snd_pcm_ops snd_p16v_playback_front_ops = { .pointer = snd_p16v_pcm_pointer_playback, }; -static struct snd_pcm_ops snd_p16v_capture_ops = { +static snd_pcm_ops_t snd_p16v_capture_ops = { .open = snd_p16v_pcm_open_capture, .close = snd_p16v_pcm_close_capture, .ioctl = snd_pcm_lib_ioctl, @@ -580,7 +577,7 @@ static struct snd_pcm_ops snd_p16v_capture_ops = { }; -int snd_p16v_free(struct snd_emu10k1 *chip) +int snd_p16v_free(emu10k1_t *chip) { // release the data if (chip->p16v_buffer.area) { @@ -590,10 +587,18 @@ int snd_p16v_free(struct snd_emu10k1 *chip) return 0; } -int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm) +static void snd_p16v_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; - struct snd_pcm_substream *substream; + emu10k1_t *emu = pcm->private_data; + //snd_printk("snd_p16v_pcm_free pcm: called\n"); + snd_pcm_lib_preallocate_free_for_all(pcm); + emu->pcm = NULL; +} + +int snd_p16v_pcm(emu10k1_t *emu, int device, snd_pcm_t **rpcm) +{ + snd_pcm_t *pcm; + snd_pcm_substream_t *substream; int err; int capture=1; @@ -606,6 +611,7 @@ int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm * return err; pcm->private_data = emu; + pcm->private_free = snd_p16v_pcm_free; // Single playback 8 channel device. // Single capture 2 channel device. snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_p16v_playback_front_ops); @@ -614,7 +620,7 @@ int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm * pcm->info_flags = 0; pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX; strcpy(pcm->name, "p16v"); - emu->pcm_p16v = pcm; + emu->pcm = pcm; for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; @@ -644,8 +650,7 @@ int __devinit snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm * return 0; } -static int snd_p16v_volume_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_p16v_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -654,57 +659,241 @@ static int snd_p16v_volume_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_p16v_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_p16v_volume_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol, int reg, int high_low) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - int high_low = (kcontrol->private_value >> 8) & 0xff; - int reg = kcontrol->private_value & 0xff; - u32 value; + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + u32 value; - value = snd_emu10k1_ptr20_read(emu, reg, high_low); - if (high_low) { - ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */ - ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */ + value = snd_emu10k1_ptr20_read(emu, reg, high_low); + if (high_low == 1) { + ucontrol->value.integer.value[0] = 0xff - ((value >> 24) & 0xff); /* Left */ + ucontrol->value.integer.value[1] = 0xff - ((value >> 16) & 0xff); /* Right */ } else { - ucontrol->value.integer.value[0] = 0xff - ((value >> 8) & 0xff); /* Left */ - ucontrol->value.integer.value[1] = 0xff - ((value >> 0) & 0xff); /* Right */ + ucontrol->value.integer.value[0] = 0xff - ((value >> 8) & 0xff); /* Left */ + ucontrol->value.integer.value[1] = 0xff - ((value >> 0) & 0xff); /* Right */ } - return 0; + return 0; +} + +static int snd_p16v_volume_get_spdif_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER7; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_get_spdif_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER7; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); +} +static int snd_p16v_volume_get_spdif_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER8; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); +} +static int snd_p16v_volume_get_spdif_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER8; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_get_analog_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER9; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_get_analog_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER9; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); +} +static int snd_p16v_volume_get_analog_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER10; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); } -static int snd_p16v_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_p16v_volume_get_analog_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); - int high_low = (kcontrol->private_value >> 8) & 0xff; - int reg = kcontrol->private_value & 0xff; - u32 value, oval; + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER10; + return snd_p16v_volume_get(kcontrol, ucontrol, reg, high_low); +} - oval = value = snd_emu10k1_ptr20_read(emu, reg, 0); +static int snd_p16v_volume_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol, int reg, int high_low) +{ + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); + u32 value; + value = snd_emu10k1_ptr20_read(emu, reg, 0); + //value = value & 0xffff; if (high_low == 1) { value &= 0xffff; - value |= ((0xff - ucontrol->value.integer.value[0]) << 24) | - ((0xff - ucontrol->value.integer.value[1]) << 16); + value = value | ((0xff - ucontrol->value.integer.value[0]) << 24) | ((0xff - ucontrol->value.integer.value[1]) << 16); } else { value &= 0xffff0000; - value |= ((0xff - ucontrol->value.integer.value[0]) << 8) | - ((0xff - ucontrol->value.integer.value[1]) ); - } - if (value != oval) { - snd_emu10k1_ptr20_write(emu, reg, 0, value); - return 1; + value = value | ((0xff - ucontrol->value.integer.value[0]) << 8) | ((0xff - ucontrol->value.integer.value[1]) ); } - return 0; + snd_emu10k1_ptr20_write(emu, reg, 0, value); + return 1; } -static int snd_p16v_capture_source_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_p16v_volume_put_spdif_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - static char *texts[8] = { - "SPDIF", "I2S", "SRC48", "SRCMulti_SPDIF", "SRCMulti_I2S", - "CDIF", "FX", "AC97" - }; + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER7; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_put_spdif_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER7; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_put_spdif_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER8; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_put_spdif_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER8; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_put_analog_front(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER9; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_put_analog_center_lfe(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER9; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_put_analog_rear(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 1; + int reg = PLAYBACK_VOLUME_MIXER10; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static int snd_p16v_volume_put_analog_unknown(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) +{ + int high_low = 0; + int reg = PLAYBACK_VOLUME_MIXER10; + return snd_p16v_volume_put(kcontrol, ucontrol, reg, high_low); +} + +static snd_kcontrol_new_t snd_p16v_volume_control_analog_front = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD Analog Front Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_analog_front, + .put = snd_p16v_volume_put_analog_front +}; + +static snd_kcontrol_new_t snd_p16v_volume_control_analog_center_lfe = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD Analog Center/LFE Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_analog_center_lfe, + .put = snd_p16v_volume_put_analog_center_lfe +}; + +static snd_kcontrol_new_t snd_p16v_volume_control_analog_unknown = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD Analog Unknown Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_analog_unknown, + .put = snd_p16v_volume_put_analog_unknown +}; + +static snd_kcontrol_new_t snd_p16v_volume_control_analog_rear = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD Analog Rear Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_analog_rear, + .put = snd_p16v_volume_put_analog_rear +}; + +static snd_kcontrol_new_t snd_p16v_volume_control_spdif_front = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD SPDIF Front Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_spdif_front, + .put = snd_p16v_volume_put_spdif_front +}; + +static snd_kcontrol_new_t snd_p16v_volume_control_spdif_center_lfe = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD SPDIF Center/LFE Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_spdif_center_lfe, + .put = snd_p16v_volume_put_spdif_center_lfe +}; + +static snd_kcontrol_new_t snd_p16v_volume_control_spdif_unknown = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD SPDIF Unknown Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_spdif_unknown, + .put = snd_p16v_volume_put_spdif_unknown +}; + +static snd_kcontrol_new_t snd_p16v_volume_control_spdif_rear = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD SPDIF Rear Playback Volume", + .info = snd_p16v_volume_info, + .get = snd_p16v_volume_get_spdif_rear, + .put = snd_p16v_volume_put_spdif_rear +}; + +static int snd_p16v_capture_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) +{ + static char *texts[8] = { "SPDIF", "I2S", "SRC48", "SRCMulti_SPDIF", "SRCMulti_I2S", "CDIF", "FX", "AC97" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -715,19 +904,19 @@ static int snd_p16v_capture_source_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_p16v_capture_source_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_p16v_capture_source_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = emu->p16v_capture_source; return 0; } -static int snd_p16v_capture_source_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_p16v_capture_source_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); unsigned int val; int change = 0; u32 mask; @@ -744,8 +933,16 @@ static int snd_p16v_capture_source_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_p16v_capture_channel_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static snd_kcontrol_new_t snd_p16v_capture_source __devinitdata = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD source Capture", + .info = snd_p16v_capture_source_info, + .get = snd_p16v_capture_source_get, + .put = snd_p16v_capture_source_put +}; + +static int snd_p16v_capture_channel_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = { "0", "1", "2", "3", }; @@ -758,19 +955,19 @@ static int snd_p16v_capture_channel_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_p16v_capture_channel_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_p16v_capture_channel_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = emu->p16v_capture_channel; return 0; } -static int snd_p16v_capture_channel_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_p16v_capture_channel_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); + emu10k1_t *emu = snd_kcontrol_chip(kcontrol); unsigned int val; int change = 0; u32 tmp; @@ -785,89 +982,60 @@ static int snd_p16v_capture_channel_put(struct snd_kcontrol *kcontrol, return change; } -#define P16V_VOL(xname,xreg,xhl) { \ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ - .info = snd_p16v_volume_info, \ - .get = snd_p16v_volume_get, \ - .put = snd_p16v_volume_put, \ - .private_value = ((xreg) | ((xhl) << 8)) \ -} - -static struct snd_kcontrol_new p16v_mixer_controls[] __devinitdata = { - P16V_VOL("HD Analog Front Playback Volume", PLAYBACK_VOLUME_MIXER9, 0), - P16V_VOL("HD Analog Rear Playback Volume", PLAYBACK_VOLUME_MIXER10, 1), - P16V_VOL("HD Analog Center/LFE Playback Volume", PLAYBACK_VOLUME_MIXER9, 1), - P16V_VOL("HD Analog Side Playback Volume", PLAYBACK_VOLUME_MIXER10, 0), - P16V_VOL("HD SPDIF Front Playback Volume", PLAYBACK_VOLUME_MIXER7, 0), - P16V_VOL("HD SPDIF Rear Playback Volume", PLAYBACK_VOLUME_MIXER8, 1), - P16V_VOL("HD SPDIF Center/LFE Playback Volume", PLAYBACK_VOLUME_MIXER7, 1), - P16V_VOL("HD SPDIF Side Playback Volume", PLAYBACK_VOLUME_MIXER8, 0), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "HD source Capture", - .info = snd_p16v_capture_source_info, - .get = snd_p16v_capture_source_get, - .put = snd_p16v_capture_source_put - }, - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "HD channel Capture", - .info = snd_p16v_capture_channel_info, - .get = snd_p16v_capture_channel_get, - .put = snd_p16v_capture_channel_put - }, +static snd_kcontrol_new_t snd_p16v_capture_channel __devinitdata = +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "HD channel Capture", + .info = snd_p16v_capture_channel_info, + .get = snd_p16v_capture_channel_get, + .put = snd_p16v_capture_channel_put }; - -int __devinit snd_p16v_mixer(struct snd_emu10k1 *emu) +int snd_p16v_mixer(emu10k1_t *emu) { - int i, err; - struct snd_card *card = emu->card; - - for (i = 0; i < ARRAY_SIZE(p16v_mixer_controls); i++) { - if ((err = snd_ctl_add(card, snd_ctl_new1(&p16v_mixer_controls[i], - emu))) < 0) - return err; - } + int err; + snd_kcontrol_t *kctl; + snd_card_t *card = emu->card; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_front, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_rear, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_center_lfe, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_analog_unknown, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_front, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_rear, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_center_lfe, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_volume_control_spdif_unknown, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_capture_source, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; + if ((kctl = snd_ctl_new1(&snd_p16v_capture_channel, emu)) == NULL) + return -ENOMEM; + if ((err = snd_ctl_add(card, kctl))) + return err; return 0; } -#ifdef CONFIG_PM - -#define NUM_CHS 1 /* up to 4, but only first channel is used */ - -int __devinit snd_p16v_alloc_pm_buffer(struct snd_emu10k1 *emu) -{ - emu->p16v_saved = vmalloc(NUM_CHS * 4 * 0x80); - if (! emu->p16v_saved) - return -ENOMEM; - return 0; -} - -void snd_p16v_free_pm_buffer(struct snd_emu10k1 *emu) -{ - vfree(emu->p16v_saved); -} - -void snd_p16v_suspend(struct snd_emu10k1 *emu) -{ - int i, ch; - unsigned int *val; - - val = emu->p16v_saved; - for (ch = 0; ch < NUM_CHS; ch++) - for (i = 0; i < 0x80; i++, val++) - *val = snd_emu10k1_ptr20_read(emu, i, ch); -} - -void snd_p16v_resume(struct snd_emu10k1 *emu) -{ - int i, ch; - unsigned int *val; - - val = emu->p16v_saved; - for (ch = 0; ch < NUM_CHS; ch++) - for (i = 0; i < 0x80; i++, val++) - snd_emu10k1_ptr20_write(emu, i, ch, *val); -} -#endif diff --git a/trunk/sound/pci/emu10k1/timer.c b/trunk/sound/pci/emu10k1/timer.c index 6295b2dca785..d2e364607c1d 100644 --- a/trunk/sound/pci/emu10k1/timer.c +++ b/trunk/sound/pci/emu10k1/timer.c @@ -30,9 +30,9 @@ #include <sound/core.h> #include <sound/emu10k1.h> -static int snd_emu10k1_timer_start(struct snd_timer *timer) +static int snd_emu10k1_timer_start(snd_timer_t *timer) { - struct snd_emu10k1 *emu; + emu10k1_t *emu; unsigned long flags; unsigned int delay; @@ -47,9 +47,9 @@ static int snd_emu10k1_timer_start(struct snd_timer *timer) return 0; } -static int snd_emu10k1_timer_stop(struct snd_timer *timer) +static int snd_emu10k1_timer_stop(snd_timer_t *timer) { - struct snd_emu10k1 *emu; + emu10k1_t *emu; unsigned long flags; emu = snd_timer_chip(timer); @@ -59,7 +59,7 @@ static int snd_emu10k1_timer_stop(struct snd_timer *timer) return 0; } -static int snd_emu10k1_timer_precise_resolution(struct snd_timer *timer, +static int snd_emu10k1_timer_precise_resolution(snd_timer_t *timer, unsigned long *num, unsigned long *den) { *num = 1; @@ -67,7 +67,7 @@ static int snd_emu10k1_timer_precise_resolution(struct snd_timer *timer, return 0; } -static struct snd_timer_hardware snd_emu10k1_timer_hw = { +static struct _snd_timer_hardware snd_emu10k1_timer_hw = { .flags = SNDRV_TIMER_HW_AUTO, .resolution = 20833, /* 1 sample @ 48KHZ = 20.833...us */ .ticks = 1024, @@ -76,10 +76,10 @@ static struct snd_timer_hardware snd_emu10k1_timer_hw = { .precise_resolution = snd_emu10k1_timer_precise_resolution, }; -int __devinit snd_emu10k1_timer(struct snd_emu10k1 *emu, int device) +int __devinit snd_emu10k1_timer(emu10k1_t *emu, int device) { - struct snd_timer *timer = NULL; - struct snd_timer_id tid; + snd_timer_t *timer = NULL; + snd_timer_id_t tid; int err; tid.dev_class = SNDRV_TIMER_CLASS_CARD; diff --git a/trunk/sound/pci/emu10k1/tina2.h b/trunk/sound/pci/emu10k1/tina2.h deleted file mode 100644 index 5c43abf03e89..000000000000 --- a/trunk/sound/pci/emu10k1/tina2.h +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk> - * Driver p16v chips - * Version: 0.21 - * - * - * This code was initally based on code from ALSA's emu10k1x.c which is: - * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ - -/********************************************************************************************************/ -/* Audigy2 Tina2 (notebook) pointer-offset register set, accessed through the PTR2 and DATA2 registers */ -/********************************************************************************************************/ - -#define TINA2_VOLUME 0x71 /* Attenuate playback volume to prevent distortion. */ - /* The windows driver does not use this register, - * so it must use some other attenuation method. - * Without this, the output is 12dB too loud, - * resulting in distortion. - */ - diff --git a/trunk/sound/pci/emu10k1/voice.c b/trunk/sound/pci/emu10k1/voice.c index 56ffb7dc3ee2..d251d3440eec 100644 --- a/trunk/sound/pci/emu10k1/voice.c +++ b/trunk/sound/pci/emu10k1/voice.c @@ -45,10 +45,9 @@ * --rlrevell */ -static int voice_alloc(struct snd_emu10k1 *emu, int type, int number, - struct snd_emu10k1_voice **rvoice) +static int voice_alloc(emu10k1_t *emu, emu10k1_voice_type_t type, int number, emu10k1_voice_t **rvoice) { - struct snd_emu10k1_voice *voice; + emu10k1_voice_t *voice; int i, j, k, first_voice, last_voice, skip; *rvoice = NULL; @@ -106,8 +105,7 @@ static int voice_alloc(struct snd_emu10k1 *emu, int type, int number, return 0; } -int snd_emu10k1_voice_alloc(struct snd_emu10k1 *emu, int type, int number, - struct snd_emu10k1_voice **rvoice) +int snd_emu10k1_voice_alloc(emu10k1_t *emu, emu10k1_voice_type_t type, int number, emu10k1_voice_t **rvoice) { unsigned long flags; int result; @@ -125,7 +123,7 @@ int snd_emu10k1_voice_alloc(struct snd_emu10k1 *emu, int type, int number, if (emu->get_synth_voice) { result = emu->get_synth_voice(emu); if (result >= 0) { - struct snd_emu10k1_voice *pvoice = &emu->voices[result]; + emu10k1_voice_t *pvoice = &emu->voices[result]; pvoice->interrupt = NULL; pvoice->use = pvoice->pcm = pvoice->synth = pvoice->midi = pvoice->efx = 0; pvoice->epcm = NULL; @@ -139,8 +137,7 @@ int snd_emu10k1_voice_alloc(struct snd_emu10k1 *emu, int type, int number, return result; } -int snd_emu10k1_voice_free(struct snd_emu10k1 *emu, - struct snd_emu10k1_voice *pvoice) +int snd_emu10k1_voice_free(emu10k1_t *emu, emu10k1_voice_t *pvoice) { unsigned long flags; diff --git a/trunk/sound/pci/ens1370.c b/trunk/sound/pci/ens1370.c index 55aaf110331a..2daa575f43ff 100644 --- a/trunk/sound/pci/ens1370.c +++ b/trunk/sound/pci/ens1370.c @@ -19,13 +19,6 @@ * */ -/* Power-Management-Code ( CONFIG_PM ) - * for ens1371 only ( FIXME ) - * derived from cs4281.c, atiixp.c and via82xx.c - * using http://www.alsa-project.org/~iwai/writing-an-alsa-driver/c1540.htm - * by Kurt J. Bosch - */ - #include <sound/driver.h> #include <asm/io.h> #include <linux/delay.h> @@ -90,10 +83,6 @@ static int joystick_port[SNDRV_CARDS]; static int joystick[SNDRV_CARDS]; #endif #endif -#ifdef CHIP1371 -static int spdif[SNDRV_CARDS]; -static int lineio[SNDRV_CARDS]; -#endif module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for Ensoniq AudioPCI soundcard."); @@ -110,12 +99,6 @@ module_param_array(joystick, bool, NULL, 0444); MODULE_PARM_DESC(joystick, "Enable joystick."); #endif #endif /* SUPPORT_JOYSTICK */ -#ifdef CHIP1371 -module_param_array(spdif, int, NULL, 0444); -MODULE_PARM_DESC(spdif, "S/PDIF output (-1 = none, 0 = auto, 1 = force)."); -module_param_array(lineio, int, NULL, 0444); -MODULE_PARM_DESC(lineio, "Line In to Rear Out (0 = auto, 1 = force)."); -#endif /* ES1371 chip ID */ /* This is a little confusing because all ES1371 compatible chips have the @@ -377,7 +360,9 @@ MODULE_PARM_DESC(lineio, "Line In to Rear Out (0 = auto, 1 = force)."); */ -struct ensoniq { +typedef struct _snd_ensoniq ensoniq_t; + +struct _snd_ensoniq { spinlock_t reg_lock; struct semaphore src_mutex; @@ -400,12 +385,12 @@ struct ensoniq { union { #ifdef CHIP1371 struct { - struct snd_ac97 *ac97; + ac97_t *ac97; } es1371; #else struct { int pclkdiv_lock; - struct snd_ak4531 *ak4531; + ak4531_t *ak4531; } es1370; #endif } u; @@ -413,21 +398,21 @@ struct ensoniq { struct pci_dev *pci; unsigned short subsystem_vendor_id; unsigned short subsystem_device_id; - struct snd_card *card; - struct snd_pcm *pcm1; /* DAC1/ADC PCM */ - struct snd_pcm *pcm2; /* DAC2 PCM */ - struct snd_pcm_substream *playback1_substream; - struct snd_pcm_substream *playback2_substream; - struct snd_pcm_substream *capture_substream; + snd_card_t *card; + snd_pcm_t *pcm1; /* DAC1/ADC PCM */ + snd_pcm_t *pcm2; /* DAC2 PCM */ + snd_pcm_substream_t *playback1_substream; + snd_pcm_substream_t *playback2_substream; + snd_pcm_substream_t *capture_substream; unsigned int p1_dma_size; unsigned int p2_dma_size; unsigned int c_dma_size; unsigned int p1_period_size; unsigned int p2_period_size; unsigned int c_period_size; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *midi_input; - struct snd_rawmidi_substream *midi_output; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *midi_input; + snd_rawmidi_substream_t *midi_output; unsigned int spdif; unsigned int spdif_default; @@ -467,39 +452,39 @@ MODULE_DEVICE_TABLE(pci, snd_audiopci_ids); #ifdef CHIP1370 static unsigned int snd_es1370_fixed_rates[] = {5512, 11025, 22050, 44100}; -static struct snd_pcm_hw_constraint_list snd_es1370_hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t snd_es1370_hw_constraints_rates = { .count = 4, .list = snd_es1370_fixed_rates, .mask = 0, }; -static struct snd_ratnum es1370_clock = { +static ratnum_t es1370_clock = { .num = ES_1370_SRCLOCK, .den_min = 29, .den_max = 353, .den_step = 1, }; -static struct snd_pcm_hw_constraint_ratnums snd_es1370_hw_constraints_clock = { +static snd_pcm_hw_constraint_ratnums_t snd_es1370_hw_constraints_clock = { .nrats = 1, .rats = &es1370_clock, }; #else -static struct snd_ratden es1371_dac_clock = { +static ratden_t es1371_dac_clock = { .num_min = 3000 * (1 << 15), .num_max = 48000 * (1 << 15), .num_step = 3000, .den = 1 << 15, }; -static struct snd_pcm_hw_constraint_ratdens snd_es1371_hw_constraints_dac_clock = { +static snd_pcm_hw_constraint_ratdens_t snd_es1371_hw_constraints_dac_clock = { .nrats = 1, .rats = &es1371_dac_clock, }; -static struct snd_ratnum es1371_adc_clock = { +static ratnum_t es1371_adc_clock = { .num = 48000 << 15, .den_min = 32768, .den_max = 393216, .den_step = 1, }; -static struct snd_pcm_hw_constraint_ratnums snd_es1371_hw_constraints_adc_clock = { +static snd_pcm_hw_constraint_ratnums_t snd_es1371_hw_constraints_adc_clock = { .nrats = 1, .rats = &es1371_adc_clock, }; @@ -513,7 +498,7 @@ static const unsigned int snd_ensoniq_sample_shift[] = #ifdef CHIP1371 -static unsigned int snd_es1371_wait_src_ready(struct ensoniq * ensoniq) +static unsigned int snd_es1371_wait_src_ready(ensoniq_t * ensoniq) { unsigned int t, r = 0; @@ -523,12 +508,11 @@ static unsigned int snd_es1371_wait_src_ready(struct ensoniq * ensoniq) return r; cond_resched(); } - snd_printk(KERN_ERR "wait source ready timeout 0x%lx [0x%x]\n", - ES_REG(ensoniq, 1371_SMPRATE), r); + snd_printk(KERN_ERR "wait source ready timeout 0x%lx [0x%x]\n", ES_REG(ensoniq, 1371_SMPRATE), r); return 0; } -static unsigned int snd_es1371_src_read(struct ensoniq * ensoniq, unsigned short reg) +static unsigned int snd_es1371_src_read(ensoniq_t * ensoniq, unsigned short reg) { unsigned int temp, i, orig, r; @@ -562,7 +546,7 @@ static unsigned int snd_es1371_src_read(struct ensoniq * ensoniq, unsigned short return temp; } -static void snd_es1371_src_write(struct ensoniq * ensoniq, +static void snd_es1371_src_write(ensoniq_t * ensoniq, unsigned short reg, unsigned short data) { unsigned int r; @@ -578,15 +562,14 @@ static void snd_es1371_src_write(struct ensoniq * ensoniq, #ifdef CHIP1370 -static void snd_es1370_codec_write(struct snd_ak4531 *ak4531, +static void snd_es1370_codec_write(ak4531_t *ak4531, unsigned short reg, unsigned short val) { - struct ensoniq *ensoniq = ak4531->private_data; + ensoniq_t *ensoniq = ak4531->private_data; unsigned long end_time = jiffies + HZ / 10; #if 0 - printk("CODEC WRITE: reg = 0x%x, val = 0x%x (0x%x), creg = 0x%x\n", - reg, val, ES_1370_CODEC_WRITE(reg, val), ES_REG(ensoniq, 1370_CODEC)); + printk("CODEC WRITE: reg = 0x%x, val = 0x%x (0x%x), creg = 0x%x\n", reg, val, ES_1370_CODEC_WRITE(reg, val), ES_REG(ensoniq, 1370_CODEC)); #endif do { if (!(inl(ES_REG(ensoniq, STATUS)) & ES_1370_CSTAT)) { @@ -595,18 +578,17 @@ static void snd_es1370_codec_write(struct snd_ak4531 *ak4531, } schedule_timeout_uninterruptible(1); } while (time_after(end_time, jiffies)); - snd_printk(KERN_ERR "codec write timeout, status = 0x%x\n", - inl(ES_REG(ensoniq, STATUS))); + snd_printk(KERN_ERR "codec write timeout, status = 0x%x\n", inl(ES_REG(ensoniq, STATUS))); } #endif /* CHIP1370 */ #ifdef CHIP1371 -static void snd_es1371_codec_write(struct snd_ac97 *ac97, +static void snd_es1371_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct ensoniq *ensoniq = ac97->private_data; + ensoniq_t *ensoniq = ac97->private_data; unsigned int t, x; down(&ensoniq->src_mutex); @@ -620,14 +602,12 @@ static void snd_es1371_codec_write(struct snd_ac97 *ac97, /* wait for not busy (state 0) first to avoid transition states */ for (t = 0; t < POLL_COUNT; t++) { - if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == - 0x00000000) + if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == 0x00000000) break; } /* wait for a SAFE time to write addr/data and then do it, dammit */ for (t = 0; t < POLL_COUNT; t++) { - if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == - 0x00010000) + if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == 0x00010000) break; } outl(ES_1371_CODEC_WRITE(reg, val), ES_REG(ensoniq, 1371_CODEC)); @@ -639,14 +619,13 @@ static void snd_es1371_codec_write(struct snd_ac97 *ac97, } } up(&ensoniq->src_mutex); - snd_printk(KERN_ERR "codec write timeout at 0x%lx [0x%x]\n", - ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC))); + snd_printk(KERN_ERR "codec write timeout at 0x%lx [0x%x]\n", ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC))); } -static unsigned short snd_es1371_codec_read(struct snd_ac97 *ac97, +static unsigned short snd_es1371_codec_read(ac97_t *ac97, unsigned short reg) { - struct ensoniq *ensoniq = ac97->private_data; + ensoniq_t *ensoniq = ac97->private_data; unsigned int t, x, fail = 0; __again: @@ -661,14 +640,12 @@ static unsigned short snd_es1371_codec_read(struct snd_ac97 *ac97, /* wait for not busy (state 0) first to avoid transition states */ for (t = 0; t < POLL_COUNT; t++) { - if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == - 0x00000000) + if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == 0x00000000) break; } /* wait for a SAFE time to write addr/data and then do it, dammit */ for (t = 0; t < POLL_COUNT; t++) { - if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == - 0x00010000) + if ((inl(ES_REG(ensoniq, 1371_SMPRATE)) & 0x00870000) == 0x00010000) break; } outl(ES_1371_CODEC_READS(reg), ES_REG(ensoniq, 1371_CODEC)); @@ -689,22 +666,18 @@ static unsigned short snd_es1371_codec_read(struct snd_ac97 *ac97, } up(&ensoniq->src_mutex); if (++fail > 10) { - snd_printk(KERN_ERR "codec read timeout (final) " - "at 0x%lx, reg = 0x%x [0x%x]\n", - ES_REG(ensoniq, 1371_CODEC), reg, - inl(ES_REG(ensoniq, 1371_CODEC))); + snd_printk(KERN_ERR "codec read timeout (final) at 0x%lx, reg = 0x%x [0x%x]\n", ES_REG(ensoniq, 1371_CODEC), reg, inl(ES_REG(ensoniq, 1371_CODEC))); return 0; } goto __again; } } up(&ensoniq->src_mutex); - snd_printk(KERN_ERR "es1371: codec read timeout at 0x%lx [0x%x]\n", - ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC))); + snd_printk(KERN_ERR "es1371: codec read timeout at 0x%lx [0x%x]\n", ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC))); return 0; } -static void snd_es1371_codec_wait(struct snd_ac97 *ac97) +static void snd_es1371_codec_wait(ac97_t *ac97) { msleep(750); snd_es1371_codec_read(ac97, AC97_RESET); @@ -713,7 +686,7 @@ static void snd_es1371_codec_wait(struct snd_ac97 *ac97) msleep(50); } -static void snd_es1371_adc_rate(struct ensoniq * ensoniq, unsigned int rate) +static void snd_es1371_adc_rate(ensoniq_t * ensoniq, unsigned int rate) { unsigned int n, truncm, freq, result; @@ -736,70 +709,60 @@ static void snd_es1371_adc_rate(struct ensoniq * ensoniq, unsigned int rate) 0x8000 | (((119 - truncm) >> 1) << 9) | (n << 4)); } snd_es1371_src_write(ensoniq, ES_SMPREG_ADC + ES_SMPREG_INT_REGS, - (snd_es1371_src_read(ensoniq, ES_SMPREG_ADC + - ES_SMPREG_INT_REGS) & 0x00ff) | - ((freq >> 5) & 0xfc00)); + (snd_es1371_src_read(ensoniq, ES_SMPREG_ADC + ES_SMPREG_INT_REGS) & 0x00ff) | + ((freq >> 5) & 0xfc00)); snd_es1371_src_write(ensoniq, ES_SMPREG_ADC + ES_SMPREG_VFREQ_FRAC, freq & 0x7fff); snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_ADC, n << 8); snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_ADC + 1, n << 8); up(&ensoniq->src_mutex); } -static void snd_es1371_dac1_rate(struct ensoniq * ensoniq, unsigned int rate) +static void snd_es1371_dac1_rate(ensoniq_t * ensoniq, unsigned int rate) { unsigned int freq, r; down(&ensoniq->src_mutex); freq = ((rate << 15) + 1500) / 3000; - r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | - ES_1371_DIS_P2 | ES_1371_DIS_R1)) | - ES_1371_DIS_P1; + r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | ES_1371_DIS_P2 | ES_1371_DIS_R1)) | ES_1371_DIS_P1; outl(r, ES_REG(ensoniq, 1371_SMPRATE)); snd_es1371_src_write(ensoniq, ES_SMPREG_DAC1 + ES_SMPREG_INT_REGS, - (snd_es1371_src_read(ensoniq, ES_SMPREG_DAC1 + - ES_SMPREG_INT_REGS) & 0x00ff) | + (snd_es1371_src_read(ensoniq, ES_SMPREG_DAC1 + ES_SMPREG_INT_REGS) & 0x00ff) | ((freq >> 5) & 0xfc00)); snd_es1371_src_write(ensoniq, ES_SMPREG_DAC1 + ES_SMPREG_VFREQ_FRAC, freq & 0x7fff); - r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | - ES_1371_DIS_P2 | ES_1371_DIS_R1)); + r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | ES_1371_DIS_P2 | ES_1371_DIS_R1)); outl(r, ES_REG(ensoniq, 1371_SMPRATE)); up(&ensoniq->src_mutex); } -static void snd_es1371_dac2_rate(struct ensoniq * ensoniq, unsigned int rate) +static void snd_es1371_dac2_rate(ensoniq_t * ensoniq, unsigned int rate) { unsigned int freq, r; down(&ensoniq->src_mutex); freq = ((rate << 15) + 1500) / 3000; - r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | - ES_1371_DIS_P1 | ES_1371_DIS_R1)) | - ES_1371_DIS_P2; + r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | ES_1371_DIS_P1 | ES_1371_DIS_R1)) | ES_1371_DIS_P2; outl(r, ES_REG(ensoniq, 1371_SMPRATE)); snd_es1371_src_write(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_INT_REGS, - (snd_es1371_src_read(ensoniq, ES_SMPREG_DAC2 + - ES_SMPREG_INT_REGS) & 0x00ff) | + (snd_es1371_src_read(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_INT_REGS) & 0x00ff) | ((freq >> 5) & 0xfc00)); - snd_es1371_src_write(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_VFREQ_FRAC, - freq & 0x7fff); - r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | - ES_1371_DIS_P1 | ES_1371_DIS_R1)); + snd_es1371_src_write(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_VFREQ_FRAC, freq & 0x7fff); + r = (snd_es1371_wait_src_ready(ensoniq) & (ES_1371_SRC_DISABLE | ES_1371_DIS_P1 | ES_1371_DIS_R1)); outl(r, ES_REG(ensoniq, 1371_SMPRATE)); up(&ensoniq->src_mutex); } #endif /* CHIP1371 */ -static int snd_ensoniq_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_ensoniq_trigger(snd_pcm_substream_t *substream, int cmd) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: { unsigned int what = 0; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == ensoniq->playback1_substream) { @@ -825,7 +788,7 @@ static int snd_ensoniq_trigger(struct snd_pcm_substream *substream, int cmd) { unsigned int what = 0; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == ensoniq->playback1_substream) { @@ -858,21 +821,21 @@ static int snd_ensoniq_trigger(struct snd_pcm_substream *substream, int cmd) * PCM part */ -static int snd_ensoniq_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ensoniq_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_ensoniq_hw_free(struct snd_pcm_substream *substream) +static int snd_ensoniq_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_ensoniq_playback1_prepare(struct snd_pcm_substream *substream) +static int snd_ensoniq_playback1_prepare(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int mode = 0; ensoniq->p1_dma_size = snd_pcm_lib_buffer_bytes(substream); @@ -897,8 +860,7 @@ static int snd_ensoniq_playback1_prepare(struct snd_pcm_substream *substream) ensoniq->sctrl &= ~(ES_P1_LOOP_SEL | ES_P1_PAUSE | ES_P1_SCT_RLD | ES_P1_MODEM); ensoniq->sctrl |= ES_P1_INT_EN | ES_P1_MODEO(mode); outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL)); - outl((ensoniq->p1_period_size >> snd_ensoniq_sample_shift[mode]) - 1, - ES_REG(ensoniq, DAC1_COUNT)); + outl((ensoniq->p1_period_size >> snd_ensoniq_sample_shift[mode]) - 1, ES_REG(ensoniq, DAC1_COUNT)); #ifdef CHIP1370 ensoniq->ctrl &= ~ES_1370_WTSRSELM; switch (runtime->rate) { @@ -917,10 +879,10 @@ static int snd_ensoniq_playback1_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ensoniq_playback2_prepare(struct snd_pcm_substream *substream) +static int snd_ensoniq_playback2_prepare(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int mode = 0; ensoniq->p2_dma_size = snd_pcm_lib_buffer_bytes(substream); @@ -940,8 +902,7 @@ static int snd_ensoniq_playback2_prepare(struct snd_pcm_substream *substream) ensoniq->sctrl |= ES_P2_INT_EN | ES_P2_MODEO(mode) | ES_P2_END_INCO(mode & 2 ? 2 : 1) | ES_P2_ST_INCO(0); outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL)); - outl((ensoniq->p2_period_size >> snd_ensoniq_sample_shift[mode]) - 1, - ES_REG(ensoniq, DAC2_COUNT)); + outl((ensoniq->p2_period_size >> snd_ensoniq_sample_shift[mode]) - 1, ES_REG(ensoniq, DAC2_COUNT)); #ifdef CHIP1370 if (!(ensoniq->u.es1370.pclkdiv_lock & ES_MODE_CAPTURE)) { ensoniq->ctrl &= ~ES_1370_PCLKDIVM; @@ -957,10 +918,10 @@ static int snd_ensoniq_playback2_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ensoniq_capture_prepare(struct snd_pcm_substream *substream) +static int snd_ensoniq_capture_prepare(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int mode = 0; ensoniq->c_dma_size = snd_pcm_lib_buffer_bytes(substream); @@ -978,8 +939,7 @@ static int snd_ensoniq_capture_prepare(struct snd_pcm_substream *substream) ensoniq->sctrl &= ~(ES_R1_LOOP_SEL | ES_R1_MODEM); ensoniq->sctrl |= ES_R1_INT_EN | ES_R1_MODEO(mode); outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL)); - outl((ensoniq->c_period_size >> snd_ensoniq_sample_shift[mode]) - 1, - ES_REG(ensoniq, ADC_COUNT)); + outl((ensoniq->c_period_size >> snd_ensoniq_sample_shift[mode]) - 1, ES_REG(ensoniq, ADC_COUNT)); #ifdef CHIP1370 if (!(ensoniq->u.es1370.pclkdiv_lock & ES_MODE_PLAY2)) { ensoniq->ctrl &= ~ES_1370_PCLKDIVM; @@ -995,9 +955,9 @@ static int snd_ensoniq_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_ensoniq_playback1_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ensoniq_playback1_pointer(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); size_t ptr; spin_lock(&ensoniq->reg_lock); @@ -1012,9 +972,9 @@ static snd_pcm_uframes_t snd_ensoniq_playback1_pointer(struct snd_pcm_substream return ptr; } -static snd_pcm_uframes_t snd_ensoniq_playback2_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ensoniq_playback2_pointer(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); size_t ptr; spin_lock(&ensoniq->reg_lock); @@ -1029,9 +989,9 @@ static snd_pcm_uframes_t snd_ensoniq_playback2_pointer(struct snd_pcm_substream return ptr; } -static snd_pcm_uframes_t snd_ensoniq_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ensoniq_capture_pointer(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); size_t ptr; spin_lock(&ensoniq->reg_lock); @@ -1046,7 +1006,7 @@ static snd_pcm_uframes_t snd_ensoniq_capture_pointer(struct snd_pcm_substream *s return ptr; } -static struct snd_pcm_hardware snd_ensoniq_playback1 = +static snd_pcm_hardware_t snd_ensoniq_playback1 = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1073,7 +1033,7 @@ static struct snd_pcm_hardware snd_ensoniq_playback1 = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ensoniq_playback2 = +static snd_pcm_hardware_t snd_ensoniq_playback2 = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1093,7 +1053,7 @@ static struct snd_pcm_hardware snd_ensoniq_playback2 = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ensoniq_capture = +static snd_pcm_hardware_t snd_ensoniq_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1112,10 +1072,10 @@ static struct snd_pcm_hardware snd_ensoniq_capture = .fifo_size = 0, }; -static int snd_ensoniq_playback1_open(struct snd_pcm_substream *substream) +static int snd_ensoniq_playback1_open(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; ensoniq->mode |= ES_MODE_PLAY1; ensoniq->playback1_substream = substream; @@ -1135,10 +1095,10 @@ static int snd_ensoniq_playback1_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ensoniq_playback2_open(struct snd_pcm_substream *substream) +static int snd_ensoniq_playback2_open(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; ensoniq->mode |= ES_MODE_PLAY2; ensoniq->playback2_substream = substream; @@ -1158,10 +1118,10 @@ static int snd_ensoniq_playback2_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ensoniq_capture_open(struct snd_pcm_substream *substream) +static int snd_ensoniq_capture_open(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; ensoniq->mode |= ES_MODE_CAPTURE; ensoniq->capture_substream = substream; @@ -1177,18 +1137,18 @@ static int snd_ensoniq_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ensoniq_playback1_close(struct snd_pcm_substream *substream) +static int snd_ensoniq_playback1_close(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); ensoniq->playback1_substream = NULL; ensoniq->mode &= ~ES_MODE_PLAY1; return 0; } -static int snd_ensoniq_playback2_close(struct snd_pcm_substream *substream) +static int snd_ensoniq_playback2_close(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); ensoniq->playback2_substream = NULL; spin_lock_irq(&ensoniq->reg_lock); @@ -1200,9 +1160,9 @@ static int snd_ensoniq_playback2_close(struct snd_pcm_substream *substream) return 0; } -static int snd_ensoniq_capture_close(struct snd_pcm_substream *substream) +static int snd_ensoniq_capture_close(snd_pcm_substream_t * substream) { - struct ensoniq *ensoniq = snd_pcm_substream_chip(substream); + ensoniq_t *ensoniq = snd_pcm_substream_chip(substream); ensoniq->capture_substream = NULL; spin_lock_irq(&ensoniq->reg_lock); @@ -1214,7 +1174,7 @@ static int snd_ensoniq_capture_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_ensoniq_playback1_ops = { +static snd_pcm_ops_t snd_ensoniq_playback1_ops = { .open = snd_ensoniq_playback1_open, .close = snd_ensoniq_playback1_close, .ioctl = snd_pcm_lib_ioctl, @@ -1225,7 +1185,7 @@ static struct snd_pcm_ops snd_ensoniq_playback1_ops = { .pointer = snd_ensoniq_playback1_pointer, }; -static struct snd_pcm_ops snd_ensoniq_playback2_ops = { +static snd_pcm_ops_t snd_ensoniq_playback2_ops = { .open = snd_ensoniq_playback2_open, .close = snd_ensoniq_playback2_close, .ioctl = snd_pcm_lib_ioctl, @@ -1236,7 +1196,7 @@ static struct snd_pcm_ops snd_ensoniq_playback2_ops = { .pointer = snd_ensoniq_playback2_pointer, }; -static struct snd_pcm_ops snd_ensoniq_capture_ops = { +static snd_pcm_ops_t snd_ensoniq_capture_ops = { .open = snd_ensoniq_capture_open, .close = snd_ensoniq_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1247,10 +1207,16 @@ static struct snd_pcm_ops snd_ensoniq_capture_ops = { .pointer = snd_ensoniq_capture_pointer, }; -static int __devinit snd_ensoniq_pcm(struct ensoniq * ensoniq, int device, - struct snd_pcm ** rpcm) +static void snd_ensoniq_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + ensoniq_t *ensoniq = pcm->private_data; + ensoniq->pcm1 = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_ensoniq_pcm(ensoniq_t * ensoniq, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -1271,6 +1237,7 @@ static int __devinit snd_ensoniq_pcm(struct ensoniq * ensoniq, int device, snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ensoniq_capture_ops); pcm->private_data = ensoniq; + pcm->private_free = snd_ensoniq_pcm_free; pcm->info_flags = 0; #ifdef CHIP1370 strcpy(pcm->name, "ES1370 DAC2/ADC"); @@ -1287,10 +1254,16 @@ static int __devinit snd_ensoniq_pcm(struct ensoniq * ensoniq, int device, return 0; } -static int __devinit snd_ensoniq_pcm2(struct ensoniq * ensoniq, int device, - struct snd_pcm ** rpcm) +static void snd_ensoniq_pcm_free2(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + ensoniq_t *ensoniq = pcm->private_data; + ensoniq->pcm2 = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_ensoniq_pcm2(ensoniq_t * ensoniq, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -1309,6 +1282,7 @@ static int __devinit snd_ensoniq_pcm2(struct ensoniq * ensoniq, int device, snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ensoniq_playback2_ops); #endif pcm->private_data = ensoniq; + pcm->private_free = snd_ensoniq_pcm_free2; pcm->info_flags = 0; #ifdef CHIP1370 strcpy(pcm->name, "ES1370 DAC1"); @@ -1333,18 +1307,17 @@ static int __devinit snd_ensoniq_pcm2(struct ensoniq * ensoniq, int device, * ENS1371 mixer (including SPDIF interface) */ #ifdef CHIP1371 -static int snd_ens1373_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ens1373_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ens1373_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ens1373_spdif_default_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); spin_lock_irq(&ensoniq->reg_lock); ucontrol->value.iec958.status[0] = (ensoniq->spdif_default >> 0) & 0xff; ucontrol->value.iec958.status[1] = (ensoniq->spdif_default >> 8) & 0xff; @@ -1354,10 +1327,10 @@ static int snd_ens1373_spdif_default_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ens1373_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ens1373_spdif_default_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -1368,15 +1341,14 @@ static int snd_ens1373_spdif_default_put(struct snd_kcontrol *kcontrol, spin_lock_irq(&ensoniq->reg_lock); change = ensoniq->spdif_default != val; ensoniq->spdif_default = val; - if (change && ensoniq->playback1_substream == NULL && - ensoniq->playback2_substream == NULL) + if (change && ensoniq->playback1_substream == NULL && ensoniq->playback2_substream == NULL) outl(val, ES_REG(ensoniq, CHANNEL_STATUS)); spin_unlock_irq(&ensoniq->reg_lock); return change; } -static int snd_ens1373_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ens1373_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -1385,10 +1357,10 @@ static int snd_ens1373_spdif_mask_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ens1373_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ens1373_spdif_stream_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); spin_lock_irq(&ensoniq->reg_lock); ucontrol->value.iec958.status[0] = (ensoniq->spdif_stream >> 0) & 0xff; ucontrol->value.iec958.status[1] = (ensoniq->spdif_stream >> 8) & 0xff; @@ -1398,10 +1370,10 @@ static int snd_ens1373_spdif_stream_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ens1373_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ens1373_spdif_stream_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -1412,8 +1384,7 @@ static int snd_ens1373_spdif_stream_put(struct snd_kcontrol *kcontrol, spin_lock_irq(&ensoniq->reg_lock); change = ensoniq->spdif_stream != val; ensoniq->spdif_stream = val; - if (change && (ensoniq->playback1_substream != NULL || - ensoniq->playback2_substream != NULL)) + if (change && (ensoniq->playback1_substream != NULL || ensoniq->playback2_substream != NULL)) outl(val, ES_REG(ensoniq, CHANNEL_STATUS)); spin_unlock_irq(&ensoniq->reg_lock); return change; @@ -1423,8 +1394,7 @@ static int snd_ens1373_spdif_stream_put(struct snd_kcontrol *kcontrol, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_es1371_spdif_info, \ .get = snd_es1371_spdif_get, .put = snd_es1371_spdif_put } -static int snd_es1371_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1371_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1433,10 +1403,9 @@ static int snd_es1371_spdif_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1371_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1371_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); spin_lock_irq(&ensoniq->reg_lock); ucontrol->value.integer.value[0] = ensoniq->ctrl & ES_1373_SPDIF_THRU ? 1 : 0; @@ -1444,10 +1413,9 @@ static int snd_es1371_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1371_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1371_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); unsigned int nval1, nval2; int change; @@ -1467,7 +1435,7 @@ static int snd_es1371_spdif_put(struct snd_kcontrol *kcontrol, /* spdif controls */ -static struct snd_kcontrol_new snd_es1371_mixer_spdif[] __devinitdata = { +static snd_kcontrol_new_t snd_es1371_mixer_spdif[] __devinitdata = { ES1371_SPDIF(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH)), { .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1493,8 +1461,7 @@ static struct snd_kcontrol_new snd_es1371_mixer_spdif[] __devinitdata = { }; -static int snd_es1373_rear_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1373_rear_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1503,33 +1470,28 @@ static int snd_es1373_rear_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1373_rear_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1373_rear_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); int val = 0; spin_lock_irq(&ensoniq->reg_lock); - if ((ensoniq->cssr & (ES_1373_REAR_BIT27|ES_1373_REAR_BIT26| - ES_1373_REAR_BIT24)) == ES_1373_REAR_BIT26) + if ((ensoniq->cssr & (ES_1373_REAR_BIT27|ES_1373_REAR_BIT26|ES_1373_REAR_BIT24)) == ES_1373_REAR_BIT26) val = 1; ucontrol->value.integer.value[0] = val; spin_unlock_irq(&ensoniq->reg_lock); return 0; } -static int snd_es1373_rear_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1373_rear_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); unsigned int nval1; int change; - nval1 = ucontrol->value.integer.value[0] ? - ES_1373_REAR_BIT26 : (ES_1373_REAR_BIT27|ES_1373_REAR_BIT24); + nval1 = ucontrol->value.integer.value[0] ? ES_1373_REAR_BIT26 : (ES_1373_REAR_BIT27|ES_1373_REAR_BIT24); spin_lock_irq(&ensoniq->reg_lock); - change = (ensoniq->cssr & (ES_1373_REAR_BIT27| - ES_1373_REAR_BIT26|ES_1373_REAR_BIT24)) != nval1; + change = (ensoniq->cssr & (ES_1373_REAR_BIT27|ES_1373_REAR_BIT26|ES_1373_REAR_BIT24)) != nval1; ensoniq->cssr &= ~(ES_1373_REAR_BIT27|ES_1373_REAR_BIT26|ES_1373_REAR_BIT24); ensoniq->cssr |= nval1; outl(ensoniq->cssr, ES_REG(ensoniq, STATUS)); @@ -1537,7 +1499,7 @@ static int snd_es1373_rear_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ens1373_rear __devinitdata = +static snd_kcontrol_new_t snd_ens1373_rear __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "AC97 2ch->4ch Copy Switch", @@ -1546,8 +1508,7 @@ static struct snd_kcontrol_new snd_ens1373_rear __devinitdata = .put = snd_es1373_rear_put, }; -static int snd_es1373_line_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1373_line_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1556,10 +1517,9 @@ static int snd_es1373_line_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1373_line_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1373_line_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); int val = 0; spin_lock_irq(&ensoniq->reg_lock); @@ -1570,10 +1530,9 @@ static int snd_es1373_line_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1373_line_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1373_line_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); int changed; unsigned int ctrl; @@ -1590,7 +1549,7 @@ static int snd_es1373_line_put(struct snd_kcontrol *kcontrol, return changed; } -static struct snd_kcontrol_new snd_ens1373_line __devinitdata = +static snd_kcontrol_new_t snd_ens1373_line __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line In->Rear Out Switch", @@ -1599,9 +1558,9 @@ static struct snd_kcontrol_new snd_ens1373_line __devinitdata = .put = snd_es1373_line_put, }; -static void snd_ensoniq_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_ensoniq_mixer_free_ac97(ac97_t *ac97) { - struct ensoniq *ensoniq = ac97->private_data; + ensoniq_t *ensoniq = ac97->private_data; ensoniq->u.es1371.ac97 = NULL; } @@ -1618,13 +1577,13 @@ static struct { { .vid = PCI_ANY_ID, .did = PCI_ANY_ID } }; -static int snd_ensoniq_1371_mixer(struct ensoniq * ensoniq, int has_spdif, int has_line) +static int snd_ensoniq_1371_mixer(ensoniq_t * ensoniq) { - struct snd_card *card = ensoniq->card; - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + snd_card_t *card = ensoniq->card; + ac97_bus_t *pbus; + ac97_template_t ac97; int err, idx; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_es1371_codec_write, .read = snd_es1371_codec_read, .wait = snd_es1371_codec_wait, @@ -1640,17 +1599,13 @@ static int snd_ensoniq_1371_mixer(struct ensoniq * ensoniq, int has_spdif, int h if ((err = snd_ac97_mixer(pbus, &ac97, &ensoniq->u.es1371.ac97)) < 0) return err; for (idx = 0; es1371_spdif_present[idx].vid != (unsigned short)PCI_ANY_ID; idx++) - if ((ensoniq->pci->vendor == es1371_spdif_present[idx].vid && - ensoniq->pci->device == es1371_spdif_present[idx].did && - ensoniq->rev == es1371_spdif_present[idx].rev) || has_spdif > 0) { - struct snd_kcontrol *kctl; + if (ensoniq->pci->vendor == es1371_spdif_present[idx].vid && + ensoniq->pci->device == es1371_spdif_present[idx].did && + ensoniq->rev == es1371_spdif_present[idx].rev) { + snd_kcontrol_t *kctl; int i, index = 0; - if (has_spdif < 0) - break; - - ensoniq->spdif_default = ensoniq->spdif_stream = - SNDRV_PCM_DEFAULT_CON_SPDIF; + ensoniq->spdif_default = ensoniq->spdif_stream = SNDRV_PCM_DEFAULT_CON_SPDIF; outl(ensoniq->spdif_default, ES_REG(ensoniq, CHANNEL_STATUS)); if (ensoniq->u.es1371.ac97->ext_id & AC97_EI_SPDIF) @@ -1677,8 +1632,7 @@ static int snd_ensoniq_1371_mixer(struct ensoniq * ensoniq, int has_spdif, int h if (((ensoniq->subsystem_vendor_id == 0x1274) && (ensoniq->subsystem_device_id == 0x2000)) || /* GA-7DXR */ ((ensoniq->subsystem_vendor_id == 0x1458) && - (ensoniq->subsystem_device_id == 0xa000)) || /* GA-8IEXP */ - has_line > 0) { + (ensoniq->subsystem_device_id == 0xa000))) { /* GA-8IEXP */ err = snd_ctl_add(card, snd_ctl_new1(&snd_ens1373_line, ensoniq)); if (err < 0) return err; @@ -1696,8 +1650,7 @@ static int snd_ensoniq_1371_mixer(struct ensoniq * ensoniq, int has_spdif, int h .get = snd_ensoniq_control_get, .put = snd_ensoniq_control_put, \ .private_value = mask } -static int snd_ensoniq_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ensoniq_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1706,10 +1659,9 @@ static int snd_ensoniq_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ensoniq_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ensoniq_control_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); int mask = kcontrol->private_value; spin_lock_irq(&ensoniq->reg_lock); @@ -1718,10 +1670,9 @@ static int snd_ensoniq_control_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ensoniq_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ensoniq_control_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct ensoniq *ensoniq = snd_kcontrol_chip(kcontrol); + ensoniq_t *ensoniq = snd_kcontrol_chip(kcontrol); int mask = kcontrol->private_value; unsigned int nval; int change; @@ -1740,23 +1691,23 @@ static int snd_ensoniq_control_put(struct snd_kcontrol *kcontrol, * ENS1370 mixer */ -static struct snd_kcontrol_new snd_es1370_controls[2] __devinitdata = { +static snd_kcontrol_new_t snd_es1370_controls[2] __devinitdata = { ENSONIQ_CONTROL("PCM 0 Output also on Line-In Jack", ES_1370_XCTL0), ENSONIQ_CONTROL("Mic +5V bias", ES_1370_XCTL1) }; #define ES1370_CONTROLS ARRAY_SIZE(snd_es1370_controls) -static void snd_ensoniq_mixer_free_ak4531(struct snd_ak4531 *ak4531) +static void snd_ensoniq_mixer_free_ak4531(ak4531_t *ak4531) { - struct ensoniq *ensoniq = ak4531->private_data; + ensoniq_t *ensoniq = ak4531->private_data; ensoniq->u.es1370.ak4531 = NULL; } -static int __devinit snd_ensoniq_1370_mixer(struct ensoniq * ensoniq) +static int __devinit snd_ensoniq_1370_mixer(ensoniq_t * ensoniq) { - struct snd_card *card = ensoniq->card; - struct snd_ak4531 ak4531; + snd_card_t *card = ensoniq->card; + ak4531_t ak4531; unsigned int idx; int err; @@ -1810,7 +1761,7 @@ static inline int snd_ensoniq_get_joystick_port(int dev) } #endif -static int __devinit snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int dev) +static int __devinit snd_ensoniq_create_gameport(ensoniq_t *ensoniq, int dev) { struct gameport *gp; int io_port; @@ -1833,8 +1784,7 @@ static int __devinit snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int de default: if (!request_region(io_port, 8, "ens137x: gameport")) { - printk(KERN_WARNING "ens137x: gameport io port 0x%#x in use\n", - io_port); + printk(KERN_WARNING "ens137x: gameport io port 0x%#x in use\n", io_port); return -EBUSY; } break; @@ -1864,7 +1814,7 @@ static int __devinit snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int de return 0; } -static void snd_ensoniq_free_gameport(struct ensoniq *ensoniq) +static void snd_ensoniq_free_gameport(ensoniq_t *ensoniq) { if (ensoniq->gameport) { int port = ensoniq->gameport->io; @@ -1877,40 +1827,36 @@ static void snd_ensoniq_free_gameport(struct ensoniq *ensoniq) } } #else -static inline int snd_ensoniq_create_gameport(struct ensoniq *ensoniq, long port) { return -ENOSYS; } -static inline void snd_ensoniq_free_gameport(struct ensoniq *ensoniq) { } +static inline int snd_ensoniq_create_gameport(ensoniq_t *ensoniq, long port) { return -ENOSYS; } +static inline void snd_ensoniq_free_gameport(ensoniq_t *ensoniq) { } #endif /* SUPPORT_JOYSTICK */ /* */ -static void snd_ensoniq_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ensoniq_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct ensoniq *ensoniq = entry->private_data; + ensoniq_t *ensoniq = entry->private_data; #ifdef CHIP1370 snd_iprintf(buffer, "Ensoniq AudioPCI ES1370\n\n"); #else snd_iprintf(buffer, "Ensoniq AudioPCI ES1371\n\n"); #endif - snd_iprintf(buffer, "Joystick enable : %s\n", - ensoniq->ctrl & ES_JYSTK_EN ? "on" : "off"); + snd_iprintf(buffer, "Joystick enable : %s\n", ensoniq->ctrl & ES_JYSTK_EN ? "on" : "off"); #ifdef CHIP1370 - snd_iprintf(buffer, "MIC +5V bias : %s\n", - ensoniq->ctrl & ES_1370_XCTL1 ? "on" : "off"); - snd_iprintf(buffer, "Line In to AOUT : %s\n", - ensoniq->ctrl & ES_1370_XCTL0 ? "on" : "off"); + snd_iprintf(buffer, "MIC +5V bias : %s\n", ensoniq->ctrl & ES_1370_XCTL1 ? "on" : "off"); + snd_iprintf(buffer, "Line In to AOUT : %s\n", ensoniq->ctrl & ES_1370_XCTL0 ? "on" : "off"); #else - snd_iprintf(buffer, "Joystick port : 0x%x\n", - (ES_1371_JOY_ASELI(ensoniq->ctrl) * 8) + 0x200); + snd_iprintf(buffer, "Joystick port : 0x%x\n", (ES_1371_JOY_ASELI(ensoniq->ctrl) * 8) + 0x200); #endif } -static void __devinit snd_ensoniq_proc_init(struct ensoniq * ensoniq) +static void __devinit snd_ensoniq_proc_init(ensoniq_t * ensoniq) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(ensoniq->card, "audiopci", &entry)) snd_info_set_text_ops(entry, ensoniq, 1024, snd_ensoniq_proc_read); @@ -1920,7 +1866,7 @@ static void __devinit snd_ensoniq_proc_init(struct ensoniq * ensoniq) */ -static int snd_ensoniq_free(struct ensoniq *ensoniq) +static int snd_ensoniq_free(ensoniq_t *ensoniq) { snd_ensoniq_free_gameport(ensoniq); if (ensoniq->irq < 0) @@ -1940,16 +1886,16 @@ static int snd_ensoniq_free(struct ensoniq *ensoniq) snd_dma_free_pages(&ensoniq->dma_bug); #endif if (ensoniq->irq >= 0) - free_irq(ensoniq->irq, ensoniq); + free_irq(ensoniq->irq, (void *)ensoniq); pci_release_regions(ensoniq->pci); pci_disable_device(ensoniq->pci); kfree(ensoniq); return 0; } -static int snd_ensoniq_dev_free(struct snd_device *device) +static int snd_ensoniq_dev_free(snd_device_t *device) { - struct ensoniq *ensoniq = device->device_data; + ensoniq_t *ensoniq = device->device_data; return snd_ensoniq_free(ensoniq); } @@ -1978,132 +1924,18 @@ static struct { }; #endif -static void snd_ensoniq_chip_init(struct ensoniq *ensoniq) -{ -#ifdef CHIP1371 - int idx; - struct pci_dev *pci = ensoniq->pci; -#endif - /* this code was part of snd_ensoniq_create before intruduction - * of suspend/resume - */ -#ifdef CHIP1370 - outl(ensoniq->ctrl, ES_REG(ensoniq, CONTROL)); - outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL)); - outl(ES_MEM_PAGEO(ES_PAGE_ADC), ES_REG(ensoniq, MEM_PAGE)); - outl(ensoniq->dma_bug.addr, ES_REG(ensoniq, PHANTOM_FRAME)); - outl(0, ES_REG(ensoniq, PHANTOM_COUNT)); -#else - outl(ensoniq->ctrl, ES_REG(ensoniq, CONTROL)); - outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL)); - outl(0, ES_REG(ensoniq, 1371_LEGACY)); - for (idx = 0; es1371_ac97_reset_hack[idx].vid != (unsigned short)PCI_ANY_ID; idx++) - if (pci->vendor == es1371_ac97_reset_hack[idx].vid && - pci->device == es1371_ac97_reset_hack[idx].did && - ensoniq->rev == es1371_ac97_reset_hack[idx].rev) { - outl(ensoniq->cssr, ES_REG(ensoniq, STATUS)); - /* need to delay around 20ms(bleech) to give - some CODECs enough time to wakeup */ - msleep(20); - break; - } - /* AC'97 warm reset to start the bitclk */ - outl(ensoniq->ctrl | ES_1371_SYNC_RES, ES_REG(ensoniq, CONTROL)); - inl(ES_REG(ensoniq, CONTROL)); - udelay(20); - outl(ensoniq->ctrl, ES_REG(ensoniq, CONTROL)); - /* Init the sample rate converter */ - snd_es1371_wait_src_ready(ensoniq); - outl(ES_1371_SRC_DISABLE, ES_REG(ensoniq, 1371_SMPRATE)); - for (idx = 0; idx < 0x80; idx++) - snd_es1371_src_write(ensoniq, idx, 0); - snd_es1371_src_write(ensoniq, ES_SMPREG_DAC1 + ES_SMPREG_TRUNC_N, 16 << 4); - snd_es1371_src_write(ensoniq, ES_SMPREG_DAC1 + ES_SMPREG_INT_REGS, 16 << 10); - snd_es1371_src_write(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_TRUNC_N, 16 << 4); - snd_es1371_src_write(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_INT_REGS, 16 << 10); - snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_ADC, 1 << 12); - snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_ADC + 1, 1 << 12); - snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC1, 1 << 12); - snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC1 + 1, 1 << 12); - snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC2, 1 << 12); - snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC2 + 1, 1 << 12); - snd_es1371_adc_rate(ensoniq, 22050); - snd_es1371_dac1_rate(ensoniq, 22050); - snd_es1371_dac2_rate(ensoniq, 22050); - /* WARNING: - * enabling the sample rate converter without properly programming - * its parameters causes the chip to lock up (the SRC busy bit will - * be stuck high, and I've found no way to rectify this other than - * power cycle) - Thomas Sailer - */ - snd_es1371_wait_src_ready(ensoniq); - outl(0, ES_REG(ensoniq, 1371_SMPRATE)); - /* try reset codec directly */ - outl(ES_1371_CODEC_WRITE(0, 0), ES_REG(ensoniq, 1371_CODEC)); -#endif - outb(ensoniq->uartc = 0x00, ES_REG(ensoniq, UART_CONTROL)); - outb(0x00, ES_REG(ensoniq, UART_RES)); - outl(ensoniq->cssr, ES_REG(ensoniq, STATUS)); - synchronize_irq(ensoniq->irq); -} - -#ifdef CONFIG_PM -static int snd_ensoniq_suspend(struct pci_dev *pci, pm_message_t state) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct ensoniq *ensoniq = card->private_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - - snd_pcm_suspend_all(ensoniq->pcm1); - snd_pcm_suspend_all(ensoniq->pcm2); - -#ifdef CHIP1371 - snd_ac97_suspend(ensoniq->u.es1371.ac97); -#else - snd_ak4531_suspend(ensoniq->u.es1370.ak4531); -#endif - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); - return 0; -} - -static int snd_ensoniq_resume(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct ensoniq *ensoniq = card->private_data; - - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); - - snd_ensoniq_chip_init(ensoniq); - -#ifdef CHIP1371 - snd_ac97_resume(ensoniq->u.es1371.ac97); -#else - snd_ak4531_resume(ensoniq->u.es1370.ak4531); -#endif - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif /* CONFIG_PM */ - - -static int __devinit snd_ensoniq_create(struct snd_card *card, +static int __devinit snd_ensoniq_create(snd_card_t * card, struct pci_dev *pci, - struct ensoniq ** rensoniq) + ensoniq_t ** rensoniq) { - struct ensoniq *ensoniq; + ensoniq_t *ensoniq; unsigned short cmdw; unsigned char cmdb; #ifdef CHIP1371 int idx; #endif int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ensoniq_dev_free, }; @@ -2126,8 +1958,7 @@ static int __devinit snd_ensoniq_create(struct snd_card *card, return err; } ensoniq->port = pci_resource_start(pci, 0); - if (request_irq(pci->irq, snd_audiopci_interrupt, SA_INTERRUPT|SA_SHIRQ, - "Ensoniq AudioPCI", ensoniq)) { + if (request_irq(pci->irq, snd_audiopci_interrupt, SA_INTERRUPT|SA_SHIRQ, "Ensoniq AudioPCI", (void *)ensoniq)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_ensoniq_free(ensoniq); return -EBUSY; @@ -2150,12 +1981,17 @@ static int __devinit snd_ensoniq_create(struct snd_card *card, ensoniq->subsystem_device_id = cmdw; #ifdef CHIP1370 #if 0 - ensoniq->ctrl = ES_1370_CDC_EN | ES_1370_SERR_DISABLE | - ES_1370_PCLKDIVO(ES_1370_SRTODIV(8000)); + ensoniq->ctrl = ES_1370_CDC_EN | ES_1370_SERR_DISABLE | ES_1370_PCLKDIVO(ES_1370_SRTODIV(8000)); #else /* get microphone working */ ensoniq->ctrl = ES_1370_CDC_EN | ES_1370_PCLKDIVO(ES_1370_SRTODIV(8000)); #endif ensoniq->sctrl = 0; + /* initialize the chips */ + outl(ensoniq->ctrl, ES_REG(ensoniq, CONTROL)); + outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL)); + outl(ES_MEM_PAGEO(ES_PAGE_ADC), ES_REG(ensoniq, MEM_PAGE)); + outl(ensoniq->dma_bug.addr, ES_REG(ensoniq, PHANTOM_FRAME)); + outl(0, ES_REG(ensoniq, PHANTOM_COUNT)); #else ensoniq->ctrl = 0; ensoniq->sctrl = 0; @@ -2166,16 +2002,59 @@ static int __devinit snd_ensoniq_create(struct snd_card *card, ensoniq->ctrl |= ES_1371_GPIO_OUT(1); /* turn amplifier on */ break; } + /* initialize the chips */ + outl(ensoniq->ctrl, ES_REG(ensoniq, CONTROL)); + outl(ensoniq->sctrl, ES_REG(ensoniq, SERIAL)); + outl(0, ES_REG(ensoniq, 1371_LEGACY)); for (idx = 0; es1371_ac97_reset_hack[idx].vid != (unsigned short)PCI_ANY_ID; idx++) if (pci->vendor == es1371_ac97_reset_hack[idx].vid && pci->device == es1371_ac97_reset_hack[idx].did && ensoniq->rev == es1371_ac97_reset_hack[idx].rev) { ensoniq->cssr |= ES_1371_ST_AC97_RST; + outl(ensoniq->cssr, ES_REG(ensoniq, STATUS)); + /* need to delay around 20ms(bleech) to give + some CODECs enough time to wakeup */ + msleep(20); break; } + /* AC'97 warm reset to start the bitclk */ + outl(ensoniq->ctrl | ES_1371_SYNC_RES, ES_REG(ensoniq, CONTROL)); + inl(ES_REG(ensoniq, CONTROL)); + udelay(20); + outl(ensoniq->ctrl, ES_REG(ensoniq, CONTROL)); + /* Init the sample rate converter */ + snd_es1371_wait_src_ready(ensoniq); + outl(ES_1371_SRC_DISABLE, ES_REG(ensoniq, 1371_SMPRATE)); + for (idx = 0; idx < 0x80; idx++) + snd_es1371_src_write(ensoniq, idx, 0); + snd_es1371_src_write(ensoniq, ES_SMPREG_DAC1 + ES_SMPREG_TRUNC_N, 16 << 4); + snd_es1371_src_write(ensoniq, ES_SMPREG_DAC1 + ES_SMPREG_INT_REGS, 16 << 10); + snd_es1371_src_write(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_TRUNC_N, 16 << 4); + snd_es1371_src_write(ensoniq, ES_SMPREG_DAC2 + ES_SMPREG_INT_REGS, 16 << 10); + snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_ADC, 1 << 12); + snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_ADC + 1, 1 << 12); + snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC1, 1 << 12); + snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC1 + 1, 1 << 12); + snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC2, 1 << 12); + snd_es1371_src_write(ensoniq, ES_SMPREG_VOL_DAC2 + 1, 1 << 12); + snd_es1371_adc_rate(ensoniq, 22050); + snd_es1371_dac1_rate(ensoniq, 22050); + snd_es1371_dac2_rate(ensoniq, 22050); + /* WARNING: + * enabling the sample rate converter without properly programming + * its parameters causes the chip to lock up (the SRC busy bit will + * be stuck high, and I've found no way to rectify this other than + * power cycle) - Thomas Sailer + */ + snd_es1371_wait_src_ready(ensoniq); + outl(0, ES_REG(ensoniq, 1371_SMPRATE)); + /* try reset codec directly */ + outl(ES_1371_CODEC_WRITE(0, 0), ES_REG(ensoniq, 1371_CODEC)); #endif - - snd_ensoniq_chip_init(ensoniq); + outb(ensoniq->uartc = 0x00, ES_REG(ensoniq, UART_CONTROL)); + outb(0x00, ES_REG(ensoniq, UART_RES)); + outl(ensoniq->cssr, ES_REG(ensoniq, STATUS)); + synchronize_irq(ensoniq->irq); if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ensoniq, &ops)) < 0) { snd_ensoniq_free(ensoniq); @@ -2194,9 +2073,9 @@ static int __devinit snd_ensoniq_create(struct snd_card *card, * MIDI section */ -static void snd_ensoniq_midi_interrupt(struct ensoniq * ensoniq) +static void snd_ensoniq_midi_interrupt(ensoniq_t * ensoniq) { - struct snd_rawmidi *rmidi = ensoniq->rmidi; + snd_rawmidi_t * rmidi = ensoniq->rmidi; unsigned char status, mask, byte; if (rmidi == NULL) @@ -2231,9 +2110,9 @@ static void snd_ensoniq_midi_interrupt(struct ensoniq * ensoniq) spin_unlock(&ensoniq->reg_lock); } -static int snd_ensoniq_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_ensoniq_midi_input_open(snd_rawmidi_substream_t * substream) { - struct ensoniq *ensoniq = substream->rmidi->private_data; + ensoniq_t *ensoniq = substream->rmidi->private_data; spin_lock_irq(&ensoniq->reg_lock); ensoniq->uartm |= ES_MODE_INPUT; @@ -2247,9 +2126,9 @@ static int snd_ensoniq_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_ensoniq_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_ensoniq_midi_input_close(snd_rawmidi_substream_t * substream) { - struct ensoniq *ensoniq = substream->rmidi->private_data; + ensoniq_t *ensoniq = substream->rmidi->private_data; spin_lock_irq(&ensoniq->reg_lock); if (!(ensoniq->uartm & ES_MODE_OUTPUT)) { @@ -2264,9 +2143,9 @@ static int snd_ensoniq_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_ensoniq_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_ensoniq_midi_output_open(snd_rawmidi_substream_t * substream) { - struct ensoniq *ensoniq = substream->rmidi->private_data; + ensoniq_t *ensoniq = substream->rmidi->private_data; spin_lock_irq(&ensoniq->reg_lock); ensoniq->uartm |= ES_MODE_OUTPUT; @@ -2280,9 +2159,9 @@ static int snd_ensoniq_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_ensoniq_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_ensoniq_midi_output_close(snd_rawmidi_substream_t * substream) { - struct ensoniq *ensoniq = substream->rmidi->private_data; + ensoniq_t *ensoniq = substream->rmidi->private_data; spin_lock_irq(&ensoniq->reg_lock); if (!(ensoniq->uartm & ES_MODE_INPUT)) { @@ -2297,10 +2176,10 @@ static int snd_ensoniq_midi_output_close(struct snd_rawmidi_substream *substream return 0; } -static void snd_ensoniq_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_ensoniq_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct ensoniq *ensoniq = substream->rmidi->private_data; + ensoniq_t *ensoniq = substream->rmidi->private_data; int idx; spin_lock_irqsave(&ensoniq->reg_lock, flags); @@ -2321,10 +2200,10 @@ static void snd_ensoniq_midi_input_trigger(struct snd_rawmidi_substream *substre spin_unlock_irqrestore(&ensoniq->reg_lock, flags); } -static void snd_ensoniq_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_ensoniq_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { unsigned long flags; - struct ensoniq *ensoniq = substream->rmidi->private_data; + ensoniq_t *ensoniq = substream->rmidi->private_data; unsigned char byte; spin_lock_irqsave(&ensoniq->reg_lock, flags); @@ -2351,24 +2230,23 @@ static void snd_ensoniq_midi_output_trigger(struct snd_rawmidi_substream *substr spin_unlock_irqrestore(&ensoniq->reg_lock, flags); } -static struct snd_rawmidi_ops snd_ensoniq_midi_output = +static snd_rawmidi_ops_t snd_ensoniq_midi_output = { .open = snd_ensoniq_midi_output_open, .close = snd_ensoniq_midi_output_close, .trigger = snd_ensoniq_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_ensoniq_midi_input = +static snd_rawmidi_ops_t snd_ensoniq_midi_input = { .open = snd_ensoniq_midi_input_open, .close = snd_ensoniq_midi_input_close, .trigger = snd_ensoniq_midi_input_trigger, }; -static int __devinit snd_ensoniq_midi(struct ensoniq * ensoniq, int device, - struct snd_rawmidi **rrawmidi) +static int __devinit snd_ensoniq_midi(ensoniq_t * ensoniq, int device, snd_rawmidi_t **rrawmidi) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; int err; if (rrawmidi) @@ -2382,8 +2260,7 @@ static int __devinit snd_ensoniq_midi(struct ensoniq * ensoniq, int device, #endif snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_ensoniq_midi_output); snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_ensoniq_midi_input); - rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | - SNDRV_RAWMIDI_INFO_DUPLEX; + rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; rmidi->private_data = ensoniq; ensoniq->rmidi = rmidi; if (rrawmidi) @@ -2397,7 +2274,7 @@ static int __devinit snd_ensoniq_midi(struct ensoniq * ensoniq, int device, static irqreturn_t snd_audiopci_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct ensoniq *ensoniq = dev_id; + ensoniq_t *ensoniq = dev_id; unsigned int status, sctrl; if (ensoniq == NULL) @@ -2434,8 +2311,8 @@ static int __devinit snd_audiopci_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct ensoniq *ensoniq; + snd_card_t *card; + ensoniq_t *ensoniq; int err, pcm_devs[2]; if (dev >= SNDRV_CARDS) @@ -2453,7 +2330,6 @@ static int __devinit snd_audiopci_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = ensoniq; pcm_devs[0] = 0; pcm_devs[1] = 1; #ifdef CHIP1370 @@ -2463,7 +2339,7 @@ static int __devinit snd_audiopci_probe(struct pci_dev *pci, } #endif #ifdef CHIP1371 - if ((err = snd_ensoniq_1371_mixer(ensoniq, spdif[dev], lineio[dev])) < 0) { + if ((err = snd_ensoniq_1371_mixer(ensoniq)) < 0) { snd_card_free(card); return err; } @@ -2513,10 +2389,6 @@ static struct pci_driver driver = { .id_table = snd_audiopci_ids, .probe = snd_audiopci_probe, .remove = __devexit_p(snd_audiopci_remove), -#ifdef CONFIG_PM - .suspend = snd_ensoniq_suspend, - .resume = snd_ensoniq_resume, -#endif }; static int __init alsa_card_ens137x_init(void) diff --git a/trunk/sound/pci/es1938.c b/trunk/sound/pci/es1938.c index 0d556b09ad04..c134f48152b0 100644 --- a/trunk/sound/pci/es1938.c +++ b/trunk/sound/pci/es1938.c @@ -191,9 +191,11 @@ MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard."); */ +typedef struct _snd_es1938 es1938_t; + #define SAVED_REG_SIZE 32 /* max. number of registers to save */ -struct es1938 { +struct _snd_es1938 { int irq; unsigned long io_port; @@ -206,18 +208,19 @@ struct es1938 { unsigned char irqmask; unsigned char revision; - struct snd_kcontrol *hw_volume; - struct snd_kcontrol *hw_switch; - struct snd_kcontrol *master_volume; - struct snd_kcontrol *master_switch; + snd_kcontrol_t *hw_volume; + snd_kcontrol_t *hw_switch; + snd_kcontrol_t *master_volume; + snd_kcontrol_t *master_switch; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *capture_substream; - struct snd_pcm_substream *playback1_substream; - struct snd_pcm_substream *playback2_substream; - struct snd_rawmidi *rmidi; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *capture_substream; + snd_pcm_substream_t *playback1_substream; + snd_pcm_substream_t *playback2_substream; + snd_kmixer_t *mixer; + snd_rawmidi_t *rmidi; unsigned int dma1_size; unsigned int dma2_size; @@ -229,7 +232,7 @@ struct es1938 { spinlock_t reg_lock; spinlock_t mixer_lock; - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; #ifdef SUPPORT_JOYSTICK struct gameport *gameport; @@ -256,7 +259,7 @@ MODULE_DEVICE_TABLE(pci, snd_es1938_ids); /* ----------------------------------------------------------------- * Write to a mixer register * -----------------------------------------------------------------*/ -static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsigned char val) +static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val) { unsigned long flags; spin_lock_irqsave(&chip->mixer_lock, flags); @@ -271,7 +274,7 @@ static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsig /* ----------------------------------------------------------------- * Read from a mixer register * -----------------------------------------------------------------*/ -static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg) +static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg) { int data; unsigned long flags; @@ -288,8 +291,7 @@ static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg) /* ----------------------------------------------------------------- * Write to some bits of a mixer register (return old value) * -----------------------------------------------------------------*/ -static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg, - unsigned char mask, unsigned char val) +static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { unsigned long flags; unsigned char old, new, oval; @@ -312,7 +314,7 @@ static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg, /* ----------------------------------------------------------------- * Write command to Controller Registers * -----------------------------------------------------------------*/ -static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd) +static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd) { int i; unsigned char v; @@ -328,7 +330,7 @@ static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd) /* ----------------------------------------------------------------- * Read the Read Data Buffer * -----------------------------------------------------------------*/ -static int snd_es1938_get_byte(struct es1938 *chip) +static int snd_es1938_get_byte(es1938_t *chip) { int i; unsigned char v; @@ -342,7 +344,7 @@ static int snd_es1938_get_byte(struct es1938 *chip) /* ----------------------------------------------------------------- * Write value cmd register * -----------------------------------------------------------------*/ -static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned char val) +static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val) { unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -357,7 +359,7 @@ static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned ch /* ----------------------------------------------------------------- * Read data from cmd register and return it * -----------------------------------------------------------------*/ -static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg) +static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg) { unsigned char val; unsigned long flags; @@ -375,8 +377,7 @@ static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg) /* ----------------------------------------------------------------- * Write data to cmd register and return old value * -----------------------------------------------------------------*/ -static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char mask, - unsigned char val) +static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { unsigned long flags; unsigned char old, new, oval; @@ -401,7 +402,7 @@ static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char /* -------------------------------------------------------------------- * Reset the chip * --------------------------------------------------------------------*/ -static void snd_es1938_reset(struct es1938 *chip) +static void snd_es1938_reset(es1938_t *chip) { int i; @@ -440,13 +441,13 @@ static void snd_es1938_reset(struct es1938 *chip) /* -------------------------------------------------------------------- * Reset the FIFOs * --------------------------------------------------------------------*/ -static void snd_es1938_reset_fifo(struct es1938 *chip) +static void snd_es1938_reset_fifo(es1938_t *chip) { outb(2, SLSB_REG(chip, RESET)); outb(0, SLSB_REG(chip, RESET)); } -static struct snd_ratnum clocks[2] = { +static ratnum_t clocks[2] = { { .num = 793800, .den_min = 1, @@ -461,18 +462,18 @@ static struct snd_ratnum clocks[2] = { } }; -static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = { +static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = { .nrats = 2, .rats = clocks, }; -static void snd_es1938_rate_set(struct es1938 *chip, - struct snd_pcm_substream *substream, +static void snd_es1938_rate_set(es1938_t *chip, + snd_pcm_substream_t *substream, int mode) { unsigned int bits, div0; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (runtime->rate_num == clocks[0].num) bits = 128 - runtime->rate_den; else @@ -494,7 +495,7 @@ static void snd_es1938_rate_set(struct es1938 *chip, * Configure Solo1 builtin DMA Controller * --------------------------------------------------------------------*/ -static void snd_es1938_playback1_setdma(struct es1938 *chip) +static void snd_es1938_playback1_setdma(es1938_t *chip) { outb(0x00, SLIO_REG(chip, AUDIO2MODE)); outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR)); @@ -502,7 +503,7 @@ static void snd_es1938_playback1_setdma(struct es1938 *chip) outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT)); } -static void snd_es1938_playback2_setdma(struct es1938 *chip) +static void snd_es1938_playback2_setdma(es1938_t *chip) { /* Enable DMA controller */ outb(0xc4, SLDM_REG(chip, DMACOMMAND)); @@ -517,7 +518,7 @@ static void snd_es1938_playback2_setdma(struct es1938 *chip) outb(0, SLDM_REG(chip, DMAMASK)); } -static void snd_es1938_capture_setdma(struct es1938 *chip) +static void snd_es1938_capture_setdma(es1938_t *chip) { /* Enable DMA controller */ outb(0xc4, SLDM_REG(chip, DMACOMMAND)); @@ -537,10 +538,10 @@ static void snd_es1938_capture_setdma(struct es1938 *chip) * *** PCM part *** */ -static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream, +static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); int val; switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -560,10 +561,10 @@ static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream, +static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream, int cmd) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_RESUME: @@ -590,10 +591,10 @@ static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream, +static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream, int cmd) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); int val; switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -613,7 +614,7 @@ static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream, +static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream, int cmd) { switch (substream->number) { @@ -629,10 +630,10 @@ static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream, /* -------------------------------------------------------------------- * First channel for Extended Mode Audio 1 ADC Operation * --------------------------------------------------------------------*/ -static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream) +static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1938_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int u, is8, mono; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -677,10 +678,10 @@ static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream) /* ------------------------------------------------------------------------------ * Second Audio channel DAC Operation * ------------------------------------------------------------------------------*/ -static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream) +static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1938_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int u, is8, mono; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -705,8 +706,7 @@ static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream) snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8); /* initialize and configure Audio 2 DAC */ - snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | - (mono ? 0 : 2) | (is8 ? 0 : 1)); + snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (mono ? 0 : 2) | (is8 ? 0 : 1)); /* program DMA */ snd_es1938_playback1_setdma(chip); @@ -714,10 +714,10 @@ static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_es1938_playback2_prepare(struct snd_pcm_substream *substream) +static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1938_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int u, is8, mono; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -756,7 +756,7 @@ static int snd_es1938_playback2_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_es1938_playback_prepare(struct snd_pcm_substream *substream) +static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream) { switch (substream->number) { case 0: @@ -768,9 +768,9 @@ static int snd_es1938_playback_prepare(struct snd_pcm_substream *substream) return -EINVAL; } -static snd_pcm_uframes_t snd_es1938_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); size_t ptr; size_t old, new; #if 1 @@ -785,9 +785,9 @@ static snd_pcm_uframes_t snd_es1938_capture_pointer(struct snd_pcm_substream *su return ptr >> chip->dma1_shift; } -static snd_pcm_uframes_t snd_es1938_playback1_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); size_t ptr; #if 1 ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT)); @@ -797,9 +797,9 @@ static snd_pcm_uframes_t snd_es1938_playback1_pointer(struct snd_pcm_substream * return ptr >> chip->dma2_shift; } -static snd_pcm_uframes_t snd_es1938_playback2_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); size_t ptr; size_t old, new; #if 1 @@ -814,7 +814,7 @@ static snd_pcm_uframes_t snd_es1938_playback2_pointer(struct snd_pcm_substream * return ptr >> chip->dma1_shift; } -static snd_pcm_uframes_t snd_es1938_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substream) { switch (substream->number) { case 0: @@ -826,14 +826,14 @@ static snd_pcm_uframes_t snd_es1938_playback_pointer(struct snd_pcm_substream *s return -EINVAL; } -static int snd_es1938_capture_copy(struct snd_pcm_substream *substream, +static int snd_es1938_capture_copy(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct es1938 *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + es1938_t *chip = snd_pcm_substream_chip(substream); pos <<= chip->dma1_shift; count <<= chip->dma1_shift; snd_assert(pos + count <= chip->dma1_size, return -EINVAL); @@ -852,8 +852,8 @@ static int snd_es1938_capture_copy(struct snd_pcm_substream *substream, /* * buffer management */ -static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t * hw_params) { int err; @@ -863,7 +863,7 @@ static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream) { return snd_pcm_lib_free_pages(substream); } @@ -871,12 +871,11 @@ static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream) /* ---------------------------------------------------------------------- * Audio1 Capture (ADC) * ----------------------------------------------------------------------*/ -static struct snd_pcm_hardware snd_es1938_capture = +static snd_pcm_hardware_t snd_es1938_capture = { .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER), - .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | - SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), + .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE, .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, .rate_min = 6000, .rate_max = 48000, @@ -893,13 +892,12 @@ static struct snd_pcm_hardware snd_es1938_capture = /* ----------------------------------------------------------------------- * Audio2 Playback (DAC) * -----------------------------------------------------------------------*/ -static struct snd_pcm_hardware snd_es1938_playback = +static snd_pcm_hardware_t snd_es1938_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), - .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | - SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), + .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE, .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, .rate_min = 6000, .rate_max = 48000, @@ -913,10 +911,10 @@ static struct snd_pcm_hardware snd_es1938_playback = .fifo_size = 256, }; -static int snd_es1938_capture_open(struct snd_pcm_substream *substream) +static int snd_es1938_capture_open(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1938_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (chip->playback2_substream) return -EAGAIN; @@ -928,10 +926,10 @@ static int snd_es1938_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es1938_playback_open(struct snd_pcm_substream *substream) +static int snd_es1938_playback_open(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + es1938_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; switch (substream->number) { case 0: @@ -953,17 +951,17 @@ static int snd_es1938_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es1938_capture_close(struct snd_pcm_substream *substream) +static int snd_es1938_capture_close(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); chip->capture_substream = NULL; return 0; } -static int snd_es1938_playback_close(struct snd_pcm_substream *substream) +static int snd_es1938_playback_close(snd_pcm_substream_t * substream) { - struct es1938 *chip = snd_pcm_substream_chip(substream); + es1938_t *chip = snd_pcm_substream_chip(substream); switch (substream->number) { case 0: @@ -979,7 +977,7 @@ static int snd_es1938_playback_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_es1938_playback_ops = { +static snd_pcm_ops_t snd_es1938_playback_ops = { .open = snd_es1938_playback_open, .close = snd_es1938_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -990,7 +988,7 @@ static struct snd_pcm_ops snd_es1938_playback_ops = { .pointer = snd_es1938_playback_pointer, }; -static struct snd_pcm_ops snd_es1938_capture_ops = { +static snd_pcm_ops_t snd_es1938_capture_ops = { .open = snd_es1938_capture_open, .close = snd_es1938_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1002,9 +1000,14 @@ static struct snd_pcm_ops snd_es1938_capture_ops = { .copy = snd_es1938_capture_copy, }; -static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device) +static void snd_es1938_free_pcm(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device) +{ + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0) @@ -1013,6 +1016,7 @@ static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_es1938_free_pcm; pcm->info_flags = 0; strcpy(pcm->name, "ESS Solo-1"); @@ -1028,8 +1032,7 @@ static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device) * *** Mixer part *** */ -static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[8] = { "Mic", "Mic Master", "CD", "AOUT", @@ -1045,18 +1048,16 @@ static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07; return 0; } -static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); unsigned char val = ucontrol->value.enumerated.item[0]; if (val > 7) @@ -1064,8 +1065,7 @@ static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol, return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val; } -static int snd_es1938_info_spatializer_enable(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1074,19 +1074,17 @@ static int snd_es1938_info_spatializer_enable(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_get_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); unsigned char val = snd_es1938_mixer_read(chip, 0x50); ucontrol->value.integer.value[0] = !!(val & 8); return 0; } -static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); unsigned char oval, nval; int change; nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04; @@ -1099,8 +1097,7 @@ static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol, return change; } -static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1109,17 +1106,15 @@ static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f; ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f; return 0; } -static int snd_es1938_info_hw_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -1128,25 +1123,24 @@ static int snd_es1938_info_hw_switch(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40); ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40); return 0; } -static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol) +static void snd_es1938_hwv_free(snd_kcontrol_t *kcontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); chip->master_volume = NULL; chip->master_switch = NULL; chip->hw_volume = NULL; chip->hw_switch = NULL; } -static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg, +static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val) { if (reg < 0xa0) @@ -1155,7 +1149,7 @@ static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg, return snd_es1938_bits(chip, reg, mask, val); } -static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg) +static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg) { if (reg < 0xa0) return snd_es1938_mixer_read(chip, reg); @@ -1169,8 +1163,7 @@ static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg) .get = snd_es1938_get_single, .put = snd_es1938_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_es1938_info_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1181,10 +1174,9 @@ static int snd_es1938_info_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_get_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1198,10 +1190,9 @@ static int snd_es1938_get_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_put_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1222,8 +1213,7 @@ static int snd_es1938_put_single(struct snd_kcontrol *kcontrol, .get = snd_es1938_get_double, .put = snd_es1938_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static int snd_es1938_info_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -1234,10 +1224,9 @@ static int snd_es1938_info_double(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_get_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; @@ -1260,10 +1249,9 @@ static int snd_es1938_get_double(struct snd_kcontrol *kcontrol, return 0; } -static int snd_es1938_put_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct es1938 *chip = snd_kcontrol_chip(kcontrol); + es1938_t *chip = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; @@ -1296,7 +1284,7 @@ static int snd_es1938_put_double(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_es1938_controls[] = { +static snd_kcontrol_new_t snd_es1938_controls[] = { ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0), ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1), { @@ -1359,7 +1347,7 @@ ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0) /* * initialize the chip - used by resume callback, too */ -static void snd_es1938_chip_init(struct es1938 *chip) +static void snd_es1938_chip_init(es1938_t *chip) { /* reset chip */ snd_es1938_reset(chip); @@ -1398,13 +1386,11 @@ static unsigned char saved_regs[SAVED_REG_SIZE+1] = { }; -static int es1938_suspend(struct pci_dev *pci, pm_message_t state) +static int es1938_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct es1938 *chip = card->private_data; + es1938_t *chip = card->pm_private_data; unsigned char *s, *d; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); /* save mixer-related registers */ @@ -1413,23 +1399,20 @@ static int es1938_suspend(struct pci_dev *pci, pm_message_t state) outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */ if (chip->irq >= 0) - free_irq(chip->irq, chip); - pci_disable_device(pci); - pci_save_state(pci); + free_irq(chip->irq, (void *)chip); + pci_disable_device(chip->pci); return 0; } -static int es1938_resume(struct pci_dev *pci) +static int es1938_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct es1938 *chip = card->private_data; + es1938_t *chip = card->pm_private_data; unsigned char *s, *d; - pci_restore_state(pci); - pci_enable_device(pci); - request_irq(pci->irq, snd_es1938_interrupt, - SA_INTERRUPT|SA_SHIRQ, "ES1938", chip); - chip->irq = pci->irq; + pci_enable_device(chip->pci); + request_irq(chip->pci->irq, snd_es1938_interrupt, + SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip); + chip->irq = chip->pci->irq; snd_es1938_chip_init(chip); /* restore mixer-related registers */ @@ -1440,13 +1423,12 @@ static int es1938_resume(struct pci_dev *pci) snd_es1938_write(chip, *s, *d); } - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ #ifdef SUPPORT_JOYSTICK -static int __devinit snd_es1938_create_gameport(struct es1938 *chip) +static int __devinit snd_es1938_create_gameport(es1938_t *chip) { struct gameport *gp; @@ -1466,7 +1448,7 @@ static int __devinit snd_es1938_create_gameport(struct es1938 *chip) return 0; } -static void snd_es1938_free_gameport(struct es1938 *chip) +static void snd_es1938_free_gameport(es1938_t *chip) { if (chip->gameport) { gameport_unregister_port(chip->gameport); @@ -1474,11 +1456,11 @@ static void snd_es1938_free_gameport(struct es1938 *chip) } } #else -static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; } -static inline void snd_es1938_free_gameport(struct es1938 *chip) { } +static inline int snd_es1938_create_gameport(es1938_t *chip) { return -ENOSYS; } +static inline void snd_es1938_free_gameport(es1938_t *chip) { } #endif /* SUPPORT_JOYSTICK */ -static int snd_es1938_free(struct es1938 *chip) +static int snd_es1938_free(es1938_t *chip) { /* disable irqs */ outb(0x00, SLIO_REG(chip, IRQCONTROL)); @@ -1488,26 +1470,26 @@ static int snd_es1938_free(struct es1938 *chip) snd_es1938_free_gameport(chip); if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); pci_release_regions(chip->pci); pci_disable_device(chip->pci); kfree(chip); return 0; } -static int snd_es1938_dev_free(struct snd_device *device) +static int snd_es1938_dev_free(snd_device_t *device) { - struct es1938 *chip = device->device_data; + es1938_t *chip = device->device_data; return snd_es1938_free(chip); } -static int __devinit snd_es1938_create(struct snd_card *card, +static int __devinit snd_es1938_create(snd_card_t * card, struct pci_dev * pci, - struct es1938 ** rchip) + es1938_t ** rchip) { - struct es1938 *chip; + es1938_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_es1938_dev_free, }; @@ -1543,8 +1525,7 @@ static int __devinit snd_es1938_create(struct snd_card *card, chip->vc_port = pci_resource_start(pci, 2); chip->mpu_port = pci_resource_start(pci, 3); chip->game_port = pci_resource_start(pci, 4); - if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, - "ES1938", chip)) { + if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_es1938_free(chip); return -EBUSY; @@ -1559,6 +1540,8 @@ static int __devinit snd_es1938_create(struct snd_card *card, snd_es1938_chip_init(chip); + snd_card_set_pm_callback(card, es1938_suspend, es1938_resume, chip); + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { snd_es1938_free(chip); return err; @@ -1575,7 +1558,7 @@ static int __devinit snd_es1938_create(struct snd_card *card, * -------------------------------------------------------------------- */ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct es1938 *chip = dev_id; + es1938_t *chip = dev_id; unsigned char status, audiostatus; int handled = 0; @@ -1588,12 +1571,9 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r if (status & 0x10) { #if 0 printk("Es1938debug - AUDIO channel 1 interrupt\n"); - printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", - inw(SLDM_REG(chip, DMACOUNT))); - printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", - inl(SLDM_REG(chip, DMAADDR))); - printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", - inl(SLDM_REG(chip, DMASTATUS))); + printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", inw(SLDM_REG(chip, DMACOUNT))); + printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", inl(SLDM_REG(chip, DMAADDR))); + printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS))); #endif /* clear irq */ handled = 1; @@ -1608,10 +1588,8 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r if (status & 0x20) { #if 0 printk("Es1938debug - AUDIO channel 2 interrupt\n"); - printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", - inw(SLIO_REG(chip, AUDIO2DMACOUNT))); - printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", - inl(SLIO_REG(chip, AUDIO2DMAADDR))); + printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", inw(SLIO_REG(chip, AUDIO2DMACOUNT))); + printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", inl(SLIO_REG(chip, AUDIO2DMAADDR))); #endif /* clear irq */ @@ -1628,10 +1606,8 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id); snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id); if (!split) { - snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, - &chip->master_switch->id); - snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, - &chip->master_volume->id); + snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id); + snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id); } /* ack interrupt */ snd_es1938_mixer_write(chip, 0x66, 0x00); @@ -1653,9 +1629,9 @@ static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *r #define ES1938_DMA_SIZE 64 -static int __devinit snd_es1938_mixer(struct es1938 *chip) +static int __devinit snd_es1938_mixer(es1938_t *chip) { - struct snd_card *card; + snd_card_t *card; unsigned int idx; int err; @@ -1664,7 +1640,7 @@ static int __devinit snd_es1938_mixer(struct es1938 *chip) strcpy(card->mixername, "ESS Solo-1"); for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip); switch (idx) { case 0: @@ -1695,9 +1671,9 @@ static int __devinit snd_es1938_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct es1938 *chip; - struct snd_opl3 *opl3; + snd_card_t *card; + es1938_t *chip; + opl3_t *opl3; int idx, err; if (dev >= SNDRV_CARDS) @@ -1721,7 +1697,6 @@ static int __devinit snd_es1938_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = chip; strcpy(card->driver, "ES1938"); strcpy(card->shortname, "ESS ES1938 (Solo-1)"); @@ -1786,10 +1761,7 @@ static struct pci_driver driver = { .id_table = snd_es1938_ids, .probe = snd_es1938_probe, .remove = __devexit_p(snd_es1938_remove), -#ifdef CONFIG_PM - .suspend = es1938_suspend, - .resume = es1938_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_es1938_init(void) diff --git a/trunk/sound/pci/es1968.c b/trunk/sound/pci/es1968.c index 9ffb600321cb..50079dc90743 100644 --- a/trunk/sound/pci/es1968.c +++ b/trunk/sound/pci/es1968.c @@ -176,7 +176,7 @@ MODULE_PARM_DESC(joystick, "Enable joystick."); /* Values for the ESM_LEGACY_AUDIO_CONTROL */ -#define ESS_DISABLE_AUDIO 0x8000 +#define ESS_ENABLE_AUDIO 0x8000 #define ESS_ENABLE_SERIAL_IRQ 0x4000 #define IO_ADRESS_ALIAS 0x0020 #define MPU401_IRQ_ENABLE 0x0010 @@ -195,7 +195,7 @@ MODULE_PARM_DESC(joystick, "Enable joystick."); #define DMA_TDMA 0x0100 #define DMA_PCPCI 0x0200 #define POST_WRITE 0x0080 -#define PCI_TIMING 0x0040 +#define ISA_TIMING 0x0040 #define SWAP_LR 0x0020 #define SUBTR_DECODE 0x0002 @@ -470,6 +470,10 @@ static u16 acpi_state_mask[] = { }; +typedef struct snd_es1968 es1968_t; +typedef struct snd_esschan esschan_t; +typedef struct snd_esm_memory esm_memory_t; + /* APU use in the driver */ enum snd_enum_apu_type { ESM_APU_PCM_PLAY, @@ -484,23 +488,23 @@ enum { }; /* DMA Hack! */ -struct esm_memory { +struct snd_esm_memory { struct snd_dma_buffer buf; int empty; /* status */ struct list_head list; }; /* Playback Channel */ -struct esschan { +struct snd_esschan { int running; u8 apu[4]; u8 apu_mode[4]; /* playback/capture pcm buffer */ - struct esm_memory *memory; + esm_memory_t *memory; /* capture mixer buffer */ - struct esm_memory *mixbuf; + esm_memory_t *mixbuf; unsigned int hwptr; /* current hw pointer in bytes */ unsigned int count; /* sample counter in bytes */ @@ -515,7 +519,7 @@ struct esschan { int bob_freq; /* required timer frequency */ - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; /* linked list */ struct list_head list; @@ -525,7 +529,7 @@ struct esschan { #endif }; -struct es1968 { +struct snd_es1968 { /* Module Config */ int total_bufsize; /* in bytes */ @@ -546,19 +550,19 @@ struct es1968 { unsigned long io_port; int type; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; + snd_card_t *card; + snd_pcm_t *pcm; int do_pm; /* power-management enabled */ /* DMA memory block */ struct list_head buf_list; /* ALSA Stuff */ - struct snd_ac97 *ac97; - struct snd_kcontrol *master_switch; /* for h/w volume control */ - struct snd_kcontrol *master_volume; + ac97_t *ac97; + snd_kcontrol_t *master_switch; /* for h/w volume control */ + snd_kcontrol_t *master_volume; - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; spinlock_t reg_lock; spinlock_t ac97_lock; @@ -606,14 +610,14 @@ MODULE_DEVICE_TABLE(pci, snd_es1968_ids); *********************/ /* no spinlock */ -static void __maestro_write(struct es1968 *chip, u16 reg, u16 data) +static void __maestro_write(es1968_t *chip, u16 reg, u16 data) { outw(reg, chip->io_port + ESM_INDEX); outw(data, chip->io_port + ESM_DATA); chip->maestro_map[reg] = data; } -static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data) +static inline void maestro_write(es1968_t *chip, u16 reg, u16 data) { unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -622,7 +626,7 @@ static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data) } /* no spinlock */ -static u16 __maestro_read(struct es1968 *chip, u16 reg) +static u16 __maestro_read(es1968_t *chip, u16 reg) { if (READABLE_MAP & (1 << reg)) { outw(reg, chip->io_port + ESM_INDEX); @@ -631,7 +635,7 @@ static u16 __maestro_read(struct es1968 *chip, u16 reg) return chip->maestro_map[reg]; } -static inline u16 maestro_read(struct es1968 *chip, u16 reg) +static inline u16 maestro_read(es1968_t *chip, u16 reg) { unsigned long flags; u16 result; @@ -642,7 +646,7 @@ static inline u16 maestro_read(struct es1968 *chip, u16 reg) } /* Wait for the codec bus to be free */ -static int snd_es1968_ac97_wait(struct es1968 *chip) +static int snd_es1968_ac97_wait(es1968_t *chip) { int timeout = 100000; @@ -655,9 +659,9 @@ static int snd_es1968_ac97_wait(struct es1968 *chip) return 1; /* timeout */ } -static void snd_es1968_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) +static void snd_es1968_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct es1968 *chip = ac97->private_data; + es1968_t *chip = ac97->private_data; unsigned long flags; snd_es1968_ac97_wait(chip); @@ -671,10 +675,10 @@ static void snd_es1968_ac97_write(struct snd_ac97 *ac97, unsigned short reg, uns spin_unlock_irqrestore(&chip->ac97_lock, flags); } -static unsigned short snd_es1968_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_es1968_ac97_read(ac97_t *ac97, unsigned short reg) { u16 data = 0; - struct es1968 *chip = ac97->private_data; + es1968_t *chip = ac97->private_data; unsigned long flags; snd_es1968_ac97_wait(chip); @@ -693,7 +697,7 @@ static unsigned short snd_es1968_ac97_read(struct snd_ac97 *ac97, unsigned short } /* no spinlock */ -static void apu_index_set(struct es1968 *chip, u16 index) +static void apu_index_set(es1968_t *chip, u16 index) { int i; __maestro_write(chip, IDR1_CRAM_POINTER, index); @@ -704,7 +708,7 @@ static void apu_index_set(struct es1968 *chip, u16 index) } /* no spinlock */ -static void apu_data_set(struct es1968 *chip, u16 data) +static void apu_data_set(es1968_t *chip, u16 data) { int i; for (i = 0; i < 1000; i++) { @@ -716,7 +720,7 @@ static void apu_data_set(struct es1968 *chip, u16 data) } /* no spinlock */ -static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data) +static void __apu_set_register(es1968_t *chip, u16 channel, u8 reg, u16 data) { snd_assert(channel < NR_APUS, return); #ifdef CONFIG_PM @@ -727,7 +731,7 @@ static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 dat apu_data_set(chip, data); } -static inline void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data) +static inline void apu_set_register(es1968_t *chip, u16 channel, u8 reg, u16 data) { unsigned long flags; spin_lock_irqsave(&chip->reg_lock, flags); @@ -735,7 +739,7 @@ static inline void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u1 spin_unlock_irqrestore(&chip->reg_lock, flags); } -static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg) +static u16 __apu_get_register(es1968_t *chip, u16 channel, u8 reg) { snd_assert(channel < NR_APUS, return 0); reg |= (channel << 4); @@ -743,7 +747,7 @@ static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg) return __maestro_read(chip, IDR0_DATA_PORT); } -static inline u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg) +static inline u16 apu_get_register(es1968_t *chip, u16 channel, u8 reg) { unsigned long flags; u16 v; @@ -755,7 +759,7 @@ static inline u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg) #if 0 /* ASSP is not supported */ -static void assp_set_register(struct es1968 *chip, u32 reg, u32 value) +static void assp_set_register(es1968_t *chip, u32 reg, u32 value) { unsigned long flags; @@ -765,7 +769,7 @@ static void assp_set_register(struct es1968 *chip, u32 reg, u32 value) spin_unlock_irqrestore(&chip->reg_lock, flags); } -static u32 assp_get_register(struct es1968 *chip, u32 reg) +static u32 assp_get_register(es1968_t *chip, u32 reg) { unsigned long flags; u32 value; @@ -780,7 +784,7 @@ static u32 assp_get_register(struct es1968 *chip, u32 reg) #endif -static void wave_set_register(struct es1968 *chip, u16 reg, u16 value) +static void wave_set_register(es1968_t *chip, u16 reg, u16 value) { unsigned long flags; @@ -790,7 +794,7 @@ static void wave_set_register(struct es1968 *chip, u16 reg, u16 value) spin_unlock_irqrestore(&chip->reg_lock, flags); } -static u16 wave_get_register(struct es1968 *chip, u16 reg) +static u16 wave_get_register(es1968_t *chip, u16 reg) { unsigned long flags; u16 value; @@ -807,7 +811,7 @@ static u16 wave_get_register(struct es1968 *chip, u16 reg) * Bob the Timer! * *******************/ -static void snd_es1968_bob_stop(struct es1968 *chip) +static void snd_es1968_bob_stop(es1968_t *chip) { u16 reg; @@ -819,7 +823,7 @@ static void snd_es1968_bob_stop(struct es1968 *chip) __maestro_write(chip, 0x17, reg); } -static void snd_es1968_bob_start(struct es1968 *chip) +static void snd_es1968_bob_start(es1968_t *chip) { int prescale; int divide; @@ -859,7 +863,7 @@ static void snd_es1968_bob_start(struct es1968 *chip) } /* call with substream spinlock */ -static void snd_es1968_bob_inc(struct es1968 *chip, int freq) +static void snd_es1968_bob_inc(es1968_t *chip, int freq) { chip->bobclient++; if (chip->bobclient == 1) { @@ -873,7 +877,7 @@ static void snd_es1968_bob_inc(struct es1968 *chip, int freq) } /* call with substream spinlock */ -static void snd_es1968_bob_dec(struct es1968 *chip) +static void snd_es1968_bob_dec(es1968_t *chip) { chip->bobclient--; if (chip->bobclient <= 0) @@ -883,7 +887,7 @@ static void snd_es1968_bob_dec(struct es1968 *chip) struct list_head *p; int max_freq = ESM_BOB_FREQ; list_for_each(p, &chip->substream_list) { - struct esschan *es = list_entry(p, struct esschan, list); + esschan_t *es = list_entry(p, esschan_t, list); if (max_freq < es->bob_freq) max_freq = es->bob_freq; } @@ -896,8 +900,8 @@ static void snd_es1968_bob_dec(struct es1968 *chip) } static int -snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es, - struct snd_pcm_runtime *runtime) +snd_es1968_calc_bob_rate(es1968_t *chip, esschan_t *es, + snd_pcm_runtime_t *runtime) { /* we acquire 4 interrupts per period for precise control.. */ int freq = runtime->rate * 4; @@ -918,7 +922,7 @@ snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es, * PCM Part * *************/ -static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq) +static u32 snd_es1968_compute_rate(es1968_t *chip, u32 freq) { u32 rate = (freq << 16) / chip->clock; #if 0 /* XXX: do we need this? */ @@ -930,7 +934,7 @@ static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq) /* get current pointer */ static inline unsigned int -snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es) +snd_es1968_get_dma_ptr(es1968_t *chip, esschan_t *es) { unsigned int offset; @@ -941,7 +945,7 @@ snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es) return (offset & 0xFFFE); /* hardware is in words */ } -static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq) +static void snd_es1968_apu_set_freq(es1968_t *chip, int apu, int freq) { apu_set_register(chip, apu, 2, (apu_get_register(chip, apu, 2) & 0x00FF) | @@ -950,7 +954,7 @@ static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq) } /* spin lock held */ -static inline void snd_es1968_trigger_apu(struct es1968 *esm, int apu, int mode) +static inline void snd_es1968_trigger_apu(es1968_t *esm, int apu, int mode) { /* set the APU mode */ __apu_set_register(esm, apu, 0, @@ -958,7 +962,7 @@ static inline void snd_es1968_trigger_apu(struct es1968 *esm, int apu, int mode) (mode << 4)); } -static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es) +static void snd_es1968_pcm_start(es1968_t *chip, esschan_t *es) { spin_lock(&chip->reg_lock); __apu_set_register(chip, es->apu[0], 5, es->base[0]); @@ -978,7 +982,7 @@ static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es) spin_unlock(&chip->reg_lock); } -static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es) +static void snd_es1968_pcm_stop(es1968_t *chip, esschan_t *es) { spin_lock(&chip->reg_lock); snd_es1968_trigger_apu(chip, es->apu[0], 0); @@ -991,7 +995,7 @@ static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es) } /* set the wavecache control reg */ -static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es, +static void snd_es1968_program_wavecache(es1968_t *chip, esschan_t *es, int channel, u32 addr, int capture) { u32 tmpval = (addr - 0x10) & 0xFFF8; @@ -1012,8 +1016,8 @@ static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es } -static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es, - struct snd_pcm_runtime *runtime) +static void snd_es1968_playback_setup(es1968_t *chip, esschan_t *es, + snd_pcm_runtime_t *runtime) { u32 pa; int high_apu = 0; @@ -1115,7 +1119,7 @@ static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es, } -static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel, +static void init_capture_apu(es1968_t *chip, esschan_t *es, int channel, unsigned int pa, unsigned int bsize, int mode, int route) { @@ -1160,8 +1164,8 @@ static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channe apu_set_register(chip, apu, 0, 0x400F); } -static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es, - struct snd_pcm_runtime *runtime) +static void snd_es1968_capture_setup(es1968_t *chip, esschan_t *es, + snd_pcm_runtime_t *runtime) { int size; u32 freq; @@ -1229,11 +1233,11 @@ static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es, * ALSA Interface * *******************/ -static int snd_es1968_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_es1968_pcm_prepare(snd_pcm_substream_t *substream) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct esschan *es = runtime->private_data; + es1968_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + esschan_t *es = runtime->private_data; es->dma_size = snd_pcm_lib_buffer_bytes(substream); es->frag_size = snd_pcm_lib_period_bytes(substream); @@ -1261,10 +1265,10 @@ static int snd_es1968_pcm_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_es1968_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_es1968_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct esschan *es = substream->runtime->private_data; + es1968_t *chip = snd_pcm_substream_chip(substream); + esschan_t *es = substream->runtime->private_data; spin_lock(&chip->substream_lock); switch (cmd) { @@ -1291,10 +1295,10 @@ static int snd_es1968_pcm_trigger(struct snd_pcm_substream *substream, int cmd) return 0; } -static snd_pcm_uframes_t snd_es1968_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_es1968_pcm_pointer(snd_pcm_substream_t *substream) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct esschan *es = substream->runtime->private_data; + es1968_t *chip = snd_pcm_substream_chip(substream); + esschan_t *es = substream->runtime->private_data; unsigned int ptr; ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift; @@ -1302,7 +1306,7 @@ static snd_pcm_uframes_t snd_es1968_pcm_pointer(struct snd_pcm_substream *substr return bytes_to_frames(substream->runtime, ptr % es->dma_size); } -static struct snd_pcm_hardware snd_es1968_playback = { +static snd_pcm_hardware_t snd_es1968_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | @@ -1323,7 +1327,7 @@ static struct snd_pcm_hardware snd_es1968_playback = { .fifo_size = 0, }; -static struct snd_pcm_hardware snd_es1968_capture = { +static snd_pcm_hardware_t snd_es1968_capture = { .info = (SNDRV_PCM_INFO_NONINTERLEAVED | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -1351,14 +1355,14 @@ static struct snd_pcm_hardware snd_es1968_capture = { /* Because the Maestro can only take addresses relative to the PCM base address register :( */ -static int calc_available_memory_size(struct es1968 *chip) +static int calc_available_memory_size(es1968_t *chip) { struct list_head *p; int max_size = 0; down(&chip->memory_mutex); list_for_each(p, &chip->buf_list) { - struct esm_memory *buf = list_entry(p, struct esm_memory, list); + esm_memory_t *buf = list_entry(p, esm_memory_t, list); if (buf->empty && buf->buf.bytes > max_size) max_size = buf->buf.bytes; } @@ -1369,15 +1373,15 @@ static int calc_available_memory_size(struct es1968 *chip) } /* allocate a new memory chunk with the specified size */ -static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size) +static esm_memory_t *snd_es1968_new_memory(es1968_t *chip, int size) { - struct esm_memory *buf; + esm_memory_t *buf; struct list_head *p; size = ((size + ESM_MEM_ALIGN - 1) / ESM_MEM_ALIGN) * ESM_MEM_ALIGN; down(&chip->memory_mutex); list_for_each(p, &chip->buf_list) { - buf = list_entry(p, struct esm_memory, list); + buf = list_entry(p, esm_memory_t, list); if (buf->empty && buf->buf.bytes >= size) goto __found; } @@ -1386,7 +1390,7 @@ static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size) __found: if (buf->buf.bytes > size) { - struct esm_memory *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL); + esm_memory_t *chunk = kmalloc(sizeof(*chunk), GFP_KERNEL); if (chunk == NULL) { up(&chip->memory_mutex); return NULL; @@ -1405,14 +1409,14 @@ static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size) } /* free a memory chunk */ -static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf) +static void snd_es1968_free_memory(es1968_t *chip, esm_memory_t *buf) { - struct esm_memory *chunk; + esm_memory_t *chunk; down(&chip->memory_mutex); buf->empty = 1; if (buf->list.prev != &chip->buf_list) { - chunk = list_entry(buf->list.prev, struct esm_memory, list); + chunk = list_entry(buf->list.prev, esm_memory_t, list); if (chunk->empty) { chunk->buf.bytes += buf->buf.bytes; list_del(&buf->list); @@ -1421,7 +1425,7 @@ static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf) } } if (buf->list.next != &chip->buf_list) { - chunk = list_entry(buf->list.next, struct esm_memory, list); + chunk = list_entry(buf->list.next, esm_memory_t, list); if (chunk->empty) { buf->buf.bytes += chunk->buf.bytes; list_del(&chunk->list); @@ -1431,7 +1435,7 @@ static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf) up(&chip->memory_mutex); } -static void snd_es1968_free_dmabuf(struct es1968 *chip) +static void snd_es1968_free_dmabuf(es1968_t *chip) { struct list_head *p; @@ -1439,17 +1443,17 @@ static void snd_es1968_free_dmabuf(struct es1968 *chip) return; snd_dma_reserve_buf(&chip->dma, snd_dma_pci_buf_id(chip->pci)); while ((p = chip->buf_list.next) != &chip->buf_list) { - struct esm_memory *chunk = list_entry(p, struct esm_memory, list); + esm_memory_t *chunk = list_entry(p, esm_memory_t, list); list_del(p); kfree(chunk); } } static int __devinit -snd_es1968_init_dmabuf(struct es1968 *chip) +snd_es1968_init_dmabuf(es1968_t *chip) { int err; - struct esm_memory *chunk; + esm_memory_t *chunk; chip->dma.dev.type = SNDRV_DMA_TYPE_DEV; chip->dma.dev.dev = snd_dma_pci_data(chip->pci); @@ -1489,12 +1493,12 @@ snd_es1968_init_dmabuf(struct es1968 *chip) /* setup the dma_areas */ /* buffer is extracted from the pre-allocated memory chunk */ -static int snd_es1968_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_es1968_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct esschan *chan = runtime->private_data; + es1968_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + esschan_t *chan = runtime->private_data; int size = params_buffer_bytes(hw_params); if (chan->memory) { @@ -1514,11 +1518,11 @@ static int snd_es1968_hw_params(struct snd_pcm_substream *substream, } /* remove dma areas if allocated */ -static int snd_es1968_hw_free(struct snd_pcm_substream *substream) +static int snd_es1968_hw_free(snd_pcm_substream_t * substream) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct esschan *chan; + es1968_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + esschan_t *chan; if (runtime->private_data == NULL) return 0; @@ -1534,7 +1538,7 @@ static int snd_es1968_hw_free(struct snd_pcm_substream *substream) /* * allocate APU pair */ -static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type) +static int snd_es1968_alloc_apu_pair(es1968_t *chip, int type) { int apu; @@ -1551,7 +1555,7 @@ static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type) /* * release APU pair */ -static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu) +static void snd_es1968_free_apu_pair(es1968_t *chip, int apu) { chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE; } @@ -1561,11 +1565,11 @@ static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu) * PCM open/close * ******************/ -static int snd_es1968_playback_open(struct snd_pcm_substream *substream) +static int snd_es1968_playback_open(snd_pcm_substream_t *substream) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct esschan *es; + es1968_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + esschan_t *es; int apu1; /* search 2 APUs */ @@ -1602,11 +1606,11 @@ static int snd_es1968_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es1968_capture_open(struct snd_pcm_substream *substream) +static int snd_es1968_capture_open(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct esschan *es; + snd_pcm_runtime_t *runtime = substream->runtime; + es1968_t *chip = snd_pcm_substream_chip(substream); + esschan_t *es; int apu1, apu2; apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE); @@ -1661,10 +1665,10 @@ static int snd_es1968_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_es1968_playback_close(struct snd_pcm_substream *substream) +static int snd_es1968_playback_close(snd_pcm_substream_t * substream) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct esschan *es; + es1968_t *chip = snd_pcm_substream_chip(substream); + esschan_t *es; if (substream->runtime->private_data == NULL) return 0; @@ -1678,10 +1682,10 @@ static int snd_es1968_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_es1968_capture_close(struct snd_pcm_substream *substream) +static int snd_es1968_capture_close(snd_pcm_substream_t * substream) { - struct es1968 *chip = snd_pcm_substream_chip(substream); - struct esschan *es; + es1968_t *chip = snd_pcm_substream_chip(substream); + esschan_t *es; if (substream->runtime->private_data == NULL) return 0; @@ -1697,7 +1701,7 @@ static int snd_es1968_capture_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_es1968_playback_ops = { +static snd_pcm_ops_t snd_es1968_playback_ops = { .open = snd_es1968_playback_open, .close = snd_es1968_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1708,7 +1712,7 @@ static struct snd_pcm_ops snd_es1968_playback_ops = { .pointer = snd_es1968_pcm_pointer, }; -static struct snd_pcm_ops snd_es1968_capture_ops = { +static snd_pcm_ops_t snd_es1968_capture_ops = { .open = snd_es1968_capture_open, .close = snd_es1968_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1725,11 +1729,11 @@ static struct snd_pcm_ops snd_es1968_capture_ops = { */ #define CLOCK_MEASURE_BUFSIZE 16768 /* enough large for a single shot */ -static void __devinit es1968_measure_clock(struct es1968 *chip) +static void __devinit es1968_measure_clock(es1968_t *chip) { int i, apu; unsigned int pa, offset, t; - struct esm_memory *memory; + esm_memory_t *memory; struct timeval start_time, stop_time; if (chip->clock == 0) @@ -1820,17 +1824,17 @@ static void __devinit es1968_measure_clock(struct es1968 *chip) /* */ -static void snd_es1968_pcm_free(struct snd_pcm *pcm) +static void snd_es1968_pcm_free(snd_pcm_t *pcm) { - struct es1968 *esm = pcm->private_data; + es1968_t *esm = pcm->private_data; snd_es1968_free_dmabuf(esm); esm->pcm = NULL; } static int __devinit -snd_es1968_pcm(struct es1968 *chip, int device) +snd_es1968_pcm(es1968_t *chip, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; /* get DMA buffer */ @@ -1866,11 +1870,11 @@ snd_es1968_pcm(struct es1968 *chip, int device) /* * update pointer */ -static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es) +static void snd_es1968_update_pcm(es1968_t *chip, esschan_t *es) { unsigned int hwptr; unsigned int diff; - struct snd_pcm_substream *subs = es->substream; + snd_pcm_substream_t *subs = es->substream; if (subs == NULL || !es->running) return; @@ -1895,7 +1899,7 @@ static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es) */ static void es1968_update_hw_volume(unsigned long private_data) { - struct es1968 *chip = (struct es1968 *) private_data; + es1968_t *chip = (es1968_t *) private_data; int x, val; unsigned long flags; @@ -1955,7 +1959,7 @@ static void es1968_update_hw_volume(unsigned long private_data) */ static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct es1968 *chip = dev_id; + es1968_t *chip = dev_id; u32 event; if (!(event = inb(chip->io_port + 0x1A))) @@ -1977,7 +1981,7 @@ static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *r struct list_head *p; spin_lock(&chip->substream_lock); list_for_each(p, &chip->substream_list) { - struct esschan *es = list_entry(p, struct esschan, list); + esschan_t *es = list_entry(p, esschan_t, list); if (es->running) snd_es1968_update_pcm(chip, es); } @@ -1998,13 +2002,13 @@ static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *r */ static int __devinit -snd_es1968_mixer(struct es1968 *chip) +snd_es1968_mixer(es1968_t *chip) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; - struct snd_ctl_elem_id id; + ac97_bus_t *pbus; + ac97_template_t ac97; + snd_ctl_elem_id_t id; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_es1968_ac97_write, .read = snd_es1968_ac97_read, }; @@ -2035,7 +2039,7 @@ snd_es1968_mixer(struct es1968 *chip) * reset ac97 codec */ -static void snd_es1968_ac97_reset(struct es1968 *chip) +static void snd_es1968_ac97_reset(es1968_t *chip) { unsigned long ioaddr = chip->io_port; @@ -2140,7 +2144,7 @@ static void snd_es1968_ac97_reset(struct es1968 *chip) outb(0x3f, ioaddr+0xd0); } -static void snd_es1968_reset(struct es1968 *chip) +static void snd_es1968_reset(es1968_t *chip) { /* Reset */ outw(ESM_RESET_MAESTRO | ESM_RESET_DIRECTSOUND, @@ -2153,7 +2157,7 @@ static void snd_es1968_reset(struct es1968 *chip) /* * power management */ -static void snd_es1968_set_acpi(struct es1968 *chip, int state) +static void snd_es1968_set_acpi(es1968_t *chip, int state) { u16 active_mask = acpi_state_mask[state]; @@ -2168,7 +2172,7 @@ static void snd_es1968_set_acpi(struct es1968 *chip, int state) /* * initialize maestro chip */ -static void snd_es1968_chip_init(struct es1968 *chip) +static void snd_es1968_chip_init(es1968_t *chip) { struct pci_dev *pci = chip->pci; int i; @@ -2193,11 +2197,14 @@ static void snd_es1968_chip_init(struct es1968 *chip) /* Config Reg A */ pci_read_config_word(pci, ESM_CONFIG_A, &w); + /* Use TDMA for now. TDMA works on all boards, so while its + * not the most efficient its the simplest. */ w &= ~DMA_CLEAR; /* Clear DMA bits */ + w |= DMA_TDMA; /* TDMA on */ w &= ~(PIC_SNOOP1 | PIC_SNOOP2); /* Clear Pic Snoop Mode Bits */ w &= ~SAFEGUARD; /* Safeguard off */ w |= POST_WRITE; /* Posted write */ - w |= PCI_TIMING; /* PCI timing on */ + w |= ISA_TIMING; /* ISA timing on */ /* XXX huh? claims to be reserved.. */ w &= ~SWAP_LR; /* swap left/right seems to only have effect on SB @@ -2238,7 +2245,7 @@ static void snd_es1968_chip_init(struct es1968 *chip) pci_read_config_word(pci, ESM_LEGACY_AUDIO_CONTROL, &w); - w |= ESS_DISABLE_AUDIO; /* Disable Legacy Audio */ + w &= ~ESS_ENABLE_AUDIO; /* Disable Legacy Audio */ w &= ~ESS_ENABLE_SERIAL_IRQ; /* Disable SIRQ */ w &= ~(0x1f); /* disable mpu irq/io, game port, fm, SB */ @@ -2362,7 +2369,7 @@ static void snd_es1968_chip_init(struct es1968 *chip) } /* Enable IRQ's */ -static void snd_es1968_start_irq(struct es1968 *chip) +static void snd_es1968_start_irq(es1968_t *chip) { unsigned short w; w = ESM_HIRQ_DSIE | ESM_HIRQ_HW_VOLUME; @@ -2375,38 +2382,33 @@ static void snd_es1968_start_irq(struct es1968 *chip) /* * PM support */ -static int es1968_suspend(struct pci_dev *pci, pm_message_t state) +static int es1968_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct es1968 *chip = card->private_data; + es1968_t *chip = card->pm_private_data; if (! chip->do_pm) return 0; chip->in_suspend = 1; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); snd_ac97_suspend(chip->ac97); snd_es1968_bob_stop(chip); snd_es1968_set_acpi(chip, ACPI_D3); - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -static int es1968_resume(struct pci_dev *pci) +static int es1968_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct es1968 *chip = card->private_data; + es1968_t *chip = card->pm_private_data; struct list_head *p; if (! chip->do_pm) return 0; /* restore all our config */ - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_master(chip->pci); snd_es1968_chip_init(chip); /* need to restore the base pointers.. */ @@ -2421,7 +2423,7 @@ static int es1968_resume(struct pci_dev *pci) snd_ac97_resume(chip->ac97); list_for_each(p, &chip->substream_list) { - struct esschan *es = list_entry(p, struct esschan, list); + esschan_t *es = list_entry(p, esschan_t, list); switch (es->mode) { case ESM_MODE_PLAY: snd_es1968_playback_setup(chip, es, es->substream->runtime); @@ -2436,7 +2438,6 @@ static int es1968_resume(struct pci_dev *pci) if (chip->bobclient) snd_es1968_bob_start(chip); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); chip->in_suspend = 0; return 0; } @@ -2444,7 +2445,7 @@ static int es1968_resume(struct pci_dev *pci) #ifdef SUPPORT_JOYSTICK #define JOYSTICK_ADDR 0x200 -static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev) +static int __devinit snd_es1968_create_gameport(es1968_t *chip, int dev) { struct gameport *gp; struct resource *r; @@ -2478,7 +2479,7 @@ static int __devinit snd_es1968_create_gameport(struct es1968 *chip, int dev) return 0; } -static void snd_es1968_free_gameport(struct es1968 *chip) +static void snd_es1968_free_gameport(es1968_t *chip) { if (chip->gameport) { struct resource *r = gameport_get_port_data(chip->gameport); @@ -2490,11 +2491,11 @@ static void snd_es1968_free_gameport(struct es1968 *chip) } } #else -static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; } -static inline void snd_es1968_free_gameport(struct es1968 *chip) { } +static inline int snd_es1968_create_gameport(es1968_t *chip, int dev) { return -ENOSYS; } +static inline void snd_es1968_free_gameport(es1968_t *chip) { } #endif -static int snd_es1968_free(struct es1968 *chip) +static int snd_es1968_free(es1968_t *chip) { if (chip->io_port) { synchronize_irq(chip->irq); @@ -2514,9 +2515,9 @@ static int snd_es1968_free(struct es1968 *chip) return 0; } -static int snd_es1968_dev_free(struct snd_device *device) +static int snd_es1968_dev_free(snd_device_t *device) { - struct es1968 *chip = device->device_data; + es1968_t *chip = device->device_data; return snd_es1968_free(chip); } @@ -2538,19 +2539,19 @@ static struct ess_device_list mpu_blacklist[] __devinitdata = { { TYPE_MAESTRO2, 0x125d }, }; -static int __devinit snd_es1968_create(struct snd_card *card, +static int __devinit snd_es1968_create(snd_card_t * card, struct pci_dev *pci, int total_bufsize, int play_streams, int capt_streams, int chip_type, int do_pm, - struct es1968 **chip_ret) + es1968_t **chip_ret) { - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_es1968_dev_free, }; - struct es1968 *chip; + es1968_t *chip; int i, err; *chip_ret = NULL; @@ -2634,6 +2635,9 @@ static int __devinit snd_es1968_create(struct snd_card *card, snd_es1968_chip_init(chip); + if (chip->do_pm) + snd_card_set_pm_callback(card, es1968_suspend, es1968_resume, chip); + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { snd_es1968_free(chip); return err; @@ -2653,8 +2657,8 @@ static int __devinit snd_es1968_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct es1968 *chip; + snd_card_t *card; + es1968_t *chip; unsigned int i; int err; @@ -2683,7 +2687,6 @@ static int __devinit snd_es1968_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = chip; switch (chip->type) { case TYPE_MAESTRO2E: @@ -2761,10 +2764,7 @@ static struct pci_driver driver = { .id_table = snd_es1968_ids, .probe = snd_es1968_probe, .remove = __devexit_p(snd_es1968_remove), -#ifdef CONFIG_PM - .suspend = es1968_suspend, - .resume = es1968_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_es1968_init(void) diff --git a/trunk/sound/pci/fm801.c b/trunk/sound/pci/fm801.c index 6ab4aefbccf8..4e1d3434888d 100644 --- a/trunk/sound/pci/fm801.c +++ b/trunk/sound/pci/fm801.c @@ -103,11 +103,7 @@ MODULE_PARM_DESC(tea575x_tuner, "Enable TEA575x tuner."); #define FM801_OPL3_DATA1 0x6b /* OPL3 Bank 1 Write */ #define FM801_POWERDOWN 0x70 /* Blocks Power Down Control */ -/* codec access */ -#define FM801_AC97_READ (1<<7) /* read=1, write=0 */ -#define FM801_AC97_VALID (1<<8) /* port valid=1 */ -#define FM801_AC97_BUSY (1<<9) /* busy=1 */ -#define FM801_AC97_ADDR_SHIFT 10 /* codec id (2bit) */ +#define FM801_AC97_ADDR_SHIFT 10 /* playback and record control register bits */ #define FM801_BUF1_LAST (1<<1) @@ -151,7 +147,9 @@ MODULE_PARM_DESC(tea575x_tuner, "Enable TEA575x tuner."); */ -struct fm801 { +typedef struct _snd_fm801 fm801_t; + +struct _snd_fm801 { int irq; unsigned long port; /* I/O port number */ @@ -174,28 +172,24 @@ struct fm801 { unsigned int cap_size; unsigned int cap_pos; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; - struct snd_ac97 *ac97_sec; + ac97_bus_t *ac97_bus; + ac97_t *ac97; + ac97_t *ac97_sec; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_rawmidi *rmidi; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_rawmidi_t *rmidi; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; unsigned int p_dma_size; unsigned int c_dma_size; spinlock_t reg_lock; - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; #ifdef TEA575X_RADIO - struct snd_tea575x tea; -#endif - -#ifdef CONFIG_PM - u16 saved_regs[0x20]; + tea575x_t tea; #endif }; @@ -211,7 +205,7 @@ MODULE_DEVICE_TABLE(pci, snd_fm801_ids); * common I/O routines */ -static int snd_fm801_update_bits(struct fm801 *chip, unsigned short reg, +static int snd_fm801_update_bits(fm801_t *chip, unsigned short reg, unsigned short mask, unsigned short value) { int change; @@ -228,18 +222,18 @@ static int snd_fm801_update_bits(struct fm801 *chip, unsigned short reg, return change; } -static void snd_fm801_codec_write(struct snd_ac97 *ac97, +static void snd_fm801_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct fm801 *chip = ac97->private_data; + fm801_t *chip = ac97->private_data; int idx; /* * Wait until the codec interface is not ready.. */ for (idx = 0; idx < 100; idx++) { - if (!(inw(FM801_REG(chip, AC97_CMD)) & FM801_AC97_BUSY)) + if (!(inw(FM801_REG(chip, AC97_CMD)) & (1<<9))) goto ok1; udelay(10); } @@ -254,23 +248,23 @@ static void snd_fm801_codec_write(struct snd_ac97 *ac97, * Wait until the write command is not completed.. */ for (idx = 0; idx < 1000; idx++) { - if (!(inw(FM801_REG(chip, AC97_CMD)) & FM801_AC97_BUSY)) + if (!(inw(FM801_REG(chip, AC97_CMD)) & (1<<9))) return; udelay(10); } snd_printk(KERN_ERR "AC'97 interface #%d is busy (2)\n", ac97->num); } -static unsigned short snd_fm801_codec_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_fm801_codec_read(ac97_t *ac97, unsigned short reg) { - struct fm801 *chip = ac97->private_data; + fm801_t *chip = ac97->private_data; int idx; /* * Wait until the codec interface is not ready.. */ for (idx = 0; idx < 100; idx++) { - if (!(inw(FM801_REG(chip, AC97_CMD)) & FM801_AC97_BUSY)) + if (!(inw(FM801_REG(chip, AC97_CMD)) & (1<<9))) goto ok1; udelay(10); } @@ -279,10 +273,9 @@ static unsigned short snd_fm801_codec_read(struct snd_ac97 *ac97, unsigned short ok1: /* read command */ - outw(reg | (ac97->addr << FM801_AC97_ADDR_SHIFT) | FM801_AC97_READ, - FM801_REG(chip, AC97_CMD)); + outw(reg | (ac97->addr << FM801_AC97_ADDR_SHIFT) | (1<<7), FM801_REG(chip, AC97_CMD)); for (idx = 0; idx < 100; idx++) { - if (!(inw(FM801_REG(chip, AC97_CMD)) & FM801_AC97_BUSY)) + if (!(inw(FM801_REG(chip, AC97_CMD)) & (1<<9))) goto ok2; udelay(10); } @@ -291,7 +284,7 @@ static unsigned short snd_fm801_codec_read(struct snd_ac97 *ac97, unsigned short ok2: for (idx = 0; idx < 1000; idx++) { - if (inw(FM801_REG(chip, AC97_CMD)) & FM801_AC97_VALID) + if (inw(FM801_REG(chip, AC97_CMD)) & (1<<8)) goto ok3; udelay(10); } @@ -308,7 +301,7 @@ static unsigned int rates[] = { 38400, 44100, 48000 }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, @@ -320,7 +313,7 @@ static unsigned int channels[] = { #define CHANNELS sizeof(channels) / sizeof(channels[0]) -static struct snd_pcm_hw_constraint_list hw_constraints_channels = { +static snd_pcm_hw_constraint_list_t hw_constraints_channels = { .count = CHANNELS, .list = channels, .mask = 0, @@ -345,10 +338,10 @@ static unsigned short snd_fm801_rate_bits(unsigned int rate) * PCM part */ -static int snd_fm801_playback_trigger(struct snd_pcm_substream *substream, +static int snd_fm801_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct fm801 *chip = snd_pcm_substream_chip(substream); + fm801_t *chip = snd_pcm_substream_chip(substream); spin_lock(&chip->reg_lock); switch (cmd) { @@ -363,11 +356,9 @@ static int snd_fm801_playback_trigger(struct snd_pcm_substream *substream, chip->ply_ctrl &= ~(FM801_START | FM801_PAUSE); break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - case SNDRV_PCM_TRIGGER_SUSPEND: chip->ply_ctrl |= FM801_PAUSE; break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - case SNDRV_PCM_TRIGGER_RESUME: chip->ply_ctrl &= ~FM801_PAUSE; break; default: @@ -380,10 +371,10 @@ static int snd_fm801_playback_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_fm801_capture_trigger(struct snd_pcm_substream *substream, +static int snd_fm801_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct fm801 *chip = snd_pcm_substream_chip(substream); + fm801_t *chip = snd_pcm_substream_chip(substream); spin_lock(&chip->reg_lock); switch (cmd) { @@ -398,11 +389,9 @@ static int snd_fm801_capture_trigger(struct snd_pcm_substream *substream, chip->cap_ctrl &= ~(FM801_START | FM801_PAUSE); break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - case SNDRV_PCM_TRIGGER_SUSPEND: chip->cap_ctrl |= FM801_PAUSE; break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - case SNDRV_PCM_TRIGGER_RESUME: chip->cap_ctrl &= ~FM801_PAUSE; break; default: @@ -415,21 +404,21 @@ static int snd_fm801_capture_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_fm801_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_fm801_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_fm801_hw_free(struct snd_pcm_substream *substream) +static int snd_fm801_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_fm801_playback_prepare(struct snd_pcm_substream *substream) +static int snd_fm801_playback_prepare(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + fm801_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; chip->ply_size = snd_pcm_lib_buffer_bytes(substream); chip->ply_count = snd_pcm_lib_period_bytes(substream); @@ -458,10 +447,10 @@ static int snd_fm801_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_fm801_capture_prepare(struct snd_pcm_substream *substream) +static int snd_fm801_capture_prepare(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + fm801_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; chip->cap_size = snd_pcm_lib_buffer_bytes(substream); chip->cap_count = snd_pcm_lib_period_bytes(substream); @@ -484,9 +473,9 @@ static int snd_fm801_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_fm801_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_fm801_playback_pointer(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); + fm801_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->ply_ctrl & FM801_START)) @@ -501,9 +490,9 @@ static snd_pcm_uframes_t snd_fm801_playback_pointer(struct snd_pcm_substream *su return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_fm801_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_fm801_capture_pointer(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); + fm801_t *chip = snd_pcm_substream_chip(substream); size_t ptr; if (!(chip->cap_ctrl & FM801_START)) @@ -520,7 +509,7 @@ static snd_pcm_uframes_t snd_fm801_capture_pointer(struct snd_pcm_substream *sub static irqreturn_t snd_fm801_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct fm801 *chip = dev_id; + fm801_t *chip = dev_id; unsigned short status; unsigned int tmp; @@ -566,11 +555,11 @@ static irqreturn_t snd_fm801_interrupt(int irq, void *dev_id, struct pt_regs *re return IRQ_HANDLED; } -static struct snd_pcm_hardware snd_fm801_playback = +static snd_pcm_hardware_t snd_fm801_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME | + SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000, @@ -586,11 +575,11 @@ static struct snd_pcm_hardware snd_fm801_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_fm801_capture = +static snd_pcm_hardware_t snd_fm801_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | - SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME | + SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000, @@ -606,59 +595,55 @@ static struct snd_pcm_hardware snd_fm801_capture = .fifo_size = 0, }; -static int snd_fm801_playback_open(struct snd_pcm_substream *substream) +static int snd_fm801_playback_open(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + fm801_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; chip->playback_substream = substream; runtime->hw = snd_fm801_playback; - snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates); + snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates); if (chip->multichannel) { runtime->hw.channels_max = 6; - snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_CHANNELS, - &hw_constraints_channels); + snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, &hw_constraints_channels); } if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) return err; return 0; } -static int snd_fm801_capture_open(struct snd_pcm_substream *substream) +static int snd_fm801_capture_open(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + fm801_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; chip->capture_substream = substream; runtime->hw = snd_fm801_capture; - snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates); + snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates); if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) return err; return 0; } -static int snd_fm801_playback_close(struct snd_pcm_substream *substream) +static int snd_fm801_playback_close(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); + fm801_t *chip = snd_pcm_substream_chip(substream); chip->playback_substream = NULL; return 0; } -static int snd_fm801_capture_close(struct snd_pcm_substream *substream) +static int snd_fm801_capture_close(snd_pcm_substream_t * substream) { - struct fm801 *chip = snd_pcm_substream_chip(substream); + fm801_t *chip = snd_pcm_substream_chip(substream); chip->capture_substream = NULL; return 0; } -static struct snd_pcm_ops snd_fm801_playback_ops = { +static snd_pcm_ops_t snd_fm801_playback_ops = { .open = snd_fm801_playback_open, .close = snd_fm801_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -669,7 +654,7 @@ static struct snd_pcm_ops snd_fm801_playback_ops = { .pointer = snd_fm801_playback_pointer, }; -static struct snd_pcm_ops snd_fm801_capture_ops = { +static snd_pcm_ops_t snd_fm801_capture_ops = { .open = snd_fm801_capture_open, .close = snd_fm801_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -680,9 +665,16 @@ static struct snd_pcm_ops snd_fm801_capture_ops = { .pointer = snd_fm801_capture_pointer, }; -static int __devinit snd_fm801_pcm(struct fm801 *chip, int device, struct snd_pcm ** rpcm) +static void snd_fm801_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + fm801_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_fm801_pcm(fm801_t *chip, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -694,6 +686,7 @@ static int __devinit snd_fm801_pcm(struct fm801 *chip, int device, struct snd_pc snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_fm801_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_fm801_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, "FM801"); chip->pcm = pcm; @@ -718,9 +711,9 @@ static int __devinit snd_fm801_pcm(struct fm801 *chip, int device, struct snd_pc #define TEA_256PCS_WRITE_ENABLE 2 /* inverted */ #define TEA_256PCS_BUS_CLOCK 3 -static void snd_fm801_tea575x_256pcs_write(struct snd_tea575x *tea, unsigned int val) +static void snd_fm801_tea575x_256pcs_write(tea575x_t *tea, unsigned int val) { - struct fm801 *chip = tea->private_data; + fm801_t *chip = tea->private_data; unsigned short reg; int i = 25; @@ -762,9 +755,9 @@ static void snd_fm801_tea575x_256pcs_write(struct snd_tea575x *tea, unsigned int spin_unlock_irq(&chip->reg_lock); } -static unsigned int snd_fm801_tea575x_256pcs_read(struct snd_tea575x *tea) +static unsigned int snd_fm801_tea575x_256pcs_read(tea575x_t *tea) { - struct fm801 *chip = tea->private_data; + fm801_t *chip = tea->private_data; unsigned short reg; unsigned int val = 0; int i; @@ -806,9 +799,9 @@ static unsigned int snd_fm801_tea575x_256pcs_read(struct snd_tea575x *tea) #define TEA_256PCPR_DATA 1 #define TEA_256PCPR_WRITE_ENABLE 2 /* inverted */ -static void snd_fm801_tea575x_256pcpr_write(struct snd_tea575x *tea, unsigned int val) +static void snd_fm801_tea575x_256pcpr_write(tea575x_t *tea, unsigned int val) { - struct fm801 *chip = tea->private_data; + fm801_t *chip = tea->private_data; unsigned short reg; int i = 25; @@ -850,9 +843,9 @@ static void snd_fm801_tea575x_256pcpr_write(struct snd_tea575x *tea, unsigned in spin_unlock_irq(&chip->reg_lock); } -static unsigned int snd_fm801_tea575x_256pcpr_read(struct snd_tea575x *tea) +static unsigned int snd_fm801_tea575x_256pcpr_read(tea575x_t *tea) { - struct fm801 *chip = tea->private_data; + fm801_t *chip = tea->private_data; unsigned short reg; unsigned int val = 0; int i; @@ -894,9 +887,9 @@ static unsigned int snd_fm801_tea575x_256pcpr_read(struct snd_tea575x *tea) #define TEA_64PCR_WRITE_ENABLE 1 /* inverted */ #define TEA_64PCR_DATA 2 -static void snd_fm801_tea575x_64pcr_write(struct snd_tea575x *tea, unsigned int val) +static void snd_fm801_tea575x_64pcr_write(tea575x_t *tea, unsigned int val) { - struct fm801 *chip = tea->private_data; + fm801_t *chip = tea->private_data; unsigned short reg; int i = 25; @@ -938,9 +931,9 @@ static void snd_fm801_tea575x_64pcr_write(struct snd_tea575x *tea, unsigned int spin_unlock_irq(&chip->reg_lock); } -static unsigned int snd_fm801_tea575x_64pcr_read(struct snd_tea575x *tea) +static unsigned int snd_fm801_tea575x_64pcr_read(tea575x_t *tea) { - struct fm801 *chip = tea->private_data; + fm801_t *chip = tea->private_data; unsigned short reg; unsigned int val = 0; int i; @@ -1005,8 +998,7 @@ static struct snd_tea575x_ops snd_fm801_tea_ops[3] = { .get = snd_fm801_get_single, .put = snd_fm801_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_fm801_info_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_fm801_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1017,10 +1009,9 @@ static int snd_fm801_info_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_fm801_get_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_fm801_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct fm801 *chip = snd_kcontrol_chip(kcontrol); + fm801_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1032,10 +1023,9 @@ static int snd_fm801_get_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_fm801_put_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_fm801_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct fm801 *chip = snd_kcontrol_chip(kcontrol); + fm801_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1053,8 +1043,7 @@ static int snd_fm801_put_single(struct snd_kcontrol *kcontrol, .get = snd_fm801_get_double, .put = snd_fm801_put_double, \ .private_value = reg | (shift_left << 8) | (shift_right << 12) | (mask << 16) | (invert << 24) } -static int snd_fm801_info_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_fm801_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1065,10 +1054,9 @@ static int snd_fm801_info_double(struct snd_kcontrol *kcontrol, return 0; } -static int snd_fm801_get_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_fm801_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct fm801 *chip = snd_kcontrol_chip(kcontrol); + fm801_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift_left = (kcontrol->private_value >> 8) & 0x0f; int shift_right = (kcontrol->private_value >> 12) & 0x0f; @@ -1086,10 +1074,9 @@ static int snd_fm801_get_double(struct snd_kcontrol *kcontrol, return 0; } -static int snd_fm801_put_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_fm801_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct fm801 *chip = snd_kcontrol_chip(kcontrol); + fm801_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift_left = (kcontrol->private_value >> 8) & 0x0f; int shift_right = (kcontrol->private_value >> 12) & 0x0f; @@ -1108,8 +1095,7 @@ static int snd_fm801_put_double(struct snd_kcontrol *kcontrol, (val1 << shift_left ) | (val2 << shift_right)); } -static int snd_fm801_info_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_fm801_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[5] = { "AC97 Primary", "FM", "I2S", "PCM", "AC97 Secondary" @@ -1124,10 +1110,9 @@ static int snd_fm801_info_mux(struct snd_kcontrol *kcontrol, return 0; } -static int snd_fm801_get_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_fm801_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct fm801 *chip = snd_kcontrol_chip(kcontrol); + fm801_t *chip = snd_kcontrol_chip(kcontrol); unsigned short val; val = inw(FM801_REG(chip, REC_SRC)) & 7; @@ -1137,10 +1122,9 @@ static int snd_fm801_get_mux(struct snd_kcontrol *kcontrol, return 0; } -static int snd_fm801_put_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_fm801_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct fm801 *chip = snd_kcontrol_chip(kcontrol); + fm801_t *chip = snd_kcontrol_chip(kcontrol); unsigned short val; if ((val = ucontrol->value.enumerated.item[0]) > 4) @@ -1148,9 +1132,9 @@ static int snd_fm801_put_mux(struct snd_kcontrol *kcontrol, return snd_fm801_update_bits(chip, FM801_REC_SRC, 7, val); } -#define FM801_CONTROLS ARRAY_SIZE(snd_fm801_controls) +#define FM801_CONTROLS (sizeof(snd_fm801_controls)/sizeof(snd_kcontrol_new_t)) -static struct snd_kcontrol_new snd_fm801_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_fm801_controls[] __devinitdata = { FM801_DOUBLE("Wave Playback Volume", FM801_PCM_VOL, 0, 8, 31, 1), FM801_SINGLE("Wave Playback Switch", FM801_PCM_VOL, 15, 1, 1), FM801_DOUBLE("I2S Playback Volume", FM801_I2S_VOL, 0, 8, 31, 1), @@ -1166,9 +1150,9 @@ FM801_SINGLE("FM Playback Switch", FM801_FM_VOL, 15, 1, 1), } }; -#define FM801_CONTROLS_MULTI ARRAY_SIZE(snd_fm801_controls_multi) +#define FM801_CONTROLS_MULTI (sizeof(snd_fm801_controls_multi)/sizeof(snd_kcontrol_new_t)) -static struct snd_kcontrol_new snd_fm801_controls_multi[] __devinitdata = { +static snd_kcontrol_new_t snd_fm801_controls_multi[] __devinitdata = { FM801_SINGLE("AC97 2ch->4ch Copy Switch", FM801_CODEC_CTRL, 7, 1, 0), FM801_SINGLE("AC97 18-bit Switch", FM801_CODEC_CTRL, 10, 1, 0), FM801_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), FM801_I2S_MODE, 8, 1, 0), @@ -1177,15 +1161,15 @@ FM801_SINGLE(SNDRV_CTL_NAME_IEC958("Raw Data ",CAPTURE,SWITCH), FM801_I2S_MODE, FM801_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), FM801_GEN_CTRL, 2, 1, 0), }; -static void snd_fm801_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_fm801_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct fm801 *chip = bus->private_data; + fm801_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_fm801_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_fm801_mixer_free_ac97(ac97_t *ac97) { - struct fm801 *chip = ac97->private_data; + fm801_t *chip = ac97->private_data; if (ac97->num == 0) { chip->ac97 = NULL; } else { @@ -1193,12 +1177,12 @@ static void snd_fm801_mixer_free_ac97(struct snd_ac97 *ac97) } } -static int __devinit snd_fm801_mixer(struct fm801 *chip) +static int __devinit snd_fm801_mixer(fm801_t *chip) { - struct snd_ac97_template ac97; + ac97_template_t ac97; unsigned int i; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_fm801_codec_write, .read = snd_fm801_codec_read, }; @@ -1231,86 +1215,7 @@ static int __devinit snd_fm801_mixer(struct fm801 *chip) * initialization routines */ -static int wait_for_codec(struct fm801 *chip, unsigned int codec_id, - unsigned short reg, unsigned long waits) -{ - unsigned long timeout = jiffies + waits; - - outw(FM801_AC97_READ | (codec_id << FM801_AC97_ADDR_SHIFT) | reg, - FM801_REG(chip, AC97_CMD)); - udelay(5); - do { - if ((inw(FM801_REG(chip, AC97_CMD)) & (FM801_AC97_VALID|FM801_AC97_BUSY)) - == FM801_AC97_VALID) - return 0; - schedule_timeout_uninterruptible(1); - } while (time_after(timeout, jiffies)); - return -EIO; -} - -static int snd_fm801_chip_init(struct fm801 *chip, int resume) -{ - int id; - unsigned short cmdw; - - /* codec cold reset + AC'97 warm reset */ - outw((1<<5) | (1<<6), FM801_REG(chip, CODEC_CTRL)); - inw(FM801_REG(chip, CODEC_CTRL)); /* flush posting data */ - udelay(100); - outw(0, FM801_REG(chip, CODEC_CTRL)); - - if (wait_for_codec(chip, 0, AC97_RESET, msecs_to_jiffies(750)) < 0) { - snd_printk(KERN_ERR "Primary AC'97 codec not found\n"); - if (! resume) - return -EIO; - } - - if (chip->multichannel) { - if (chip->secondary_addr) { - wait_for_codec(chip, chip->secondary_addr, - AC97_VENDOR_ID1, msecs_to_jiffies(50)); - } else { - /* my card has the secondary codec */ - /* at address #3, so the loop is inverted */ - for (id = 3; id > 0; id--) { - if (! wait_for_codec(chip, id, AC97_VENDOR_ID1, - msecs_to_jiffies(50))) { - cmdw = inw(FM801_REG(chip, AC97_DATA)); - if (cmdw != 0xffff && cmdw != 0) { - chip->secondary = 1; - chip->secondary_addr = id; - break; - } - } - } - } - - /* the recovery phase, it seems that probing for non-existing codec might */ - /* cause timeout problems */ - wait_for_codec(chip, 0, AC97_VENDOR_ID1, msecs_to_jiffies(750)); - } - - /* init volume */ - outw(0x0808, FM801_REG(chip, PCM_VOL)); - outw(0x9f1f, FM801_REG(chip, FM_VOL)); - outw(0x8808, FM801_REG(chip, I2S_VOL)); - - /* I2S control - I2S mode */ - outw(0x0003, FM801_REG(chip, I2S_MODE)); - - /* interrupt setup - unmask MPU, PLAYBACK & CAPTURE */ - cmdw = inw(FM801_REG(chip, IRQ_MASK)); - cmdw &= ~0x0083; - outw(cmdw, FM801_REG(chip, IRQ_MASK)); - - /* interrupt clear */ - outw(FM801_IRQ_PLAYBACK|FM801_IRQ_CAPTURE|FM801_IRQ_MPU, FM801_REG(chip, IRQ_STATUS)); - - return 0; -} - - -static int snd_fm801_free(struct fm801 *chip) +static int snd_fm801_free(fm801_t *chip) { unsigned short cmdw; @@ -1327,7 +1232,7 @@ static int snd_fm801_free(struct fm801 *chip) snd_tea575x_exit(&chip->tea); #endif if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); pci_release_regions(chip->pci); pci_disable_device(chip->pci); @@ -1335,21 +1240,23 @@ static int snd_fm801_free(struct fm801 *chip) return 0; } -static int snd_fm801_dev_free(struct snd_device *device) +static int snd_fm801_dev_free(snd_device_t *device) { - struct fm801 *chip = device->device_data; + fm801_t *chip = device->device_data; return snd_fm801_free(chip); } -static int __devinit snd_fm801_create(struct snd_card *card, +static int __devinit snd_fm801_create(snd_card_t * card, struct pci_dev * pci, int tea575x_tuner, - struct fm801 ** rchip) + fm801_t ** rchip) { - struct fm801 *chip; - unsigned char rev; + fm801_t *chip; + unsigned char rev, id; + unsigned short cmdw; + unsigned long timeout; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_fm801_dev_free, }; @@ -1371,8 +1278,7 @@ static int __devinit snd_fm801_create(struct snd_card *card, return err; } chip->port = pci_resource_start(pci, 0); - if (request_irq(pci->irq, snd_fm801_interrupt, SA_INTERRUPT|SA_SHIRQ, - "FM801", chip)) { + if (request_irq(pci->irq, snd_fm801_interrupt, SA_INTERRUPT|SA_SHIRQ, "FM801", (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->irq); snd_fm801_free(chip); return -EBUSY; @@ -1384,7 +1290,80 @@ static int __devinit snd_fm801_create(struct snd_card *card, if (rev >= 0xb1) /* FM801-AU */ chip->multichannel = 1; - snd_fm801_chip_init(chip, 0); + /* codec cold reset + AC'97 warm reset */ + outw((1<<5)|(1<<6), FM801_REG(chip, CODEC_CTRL)); + inw(FM801_REG(chip, CODEC_CTRL)); /* flush posting data */ + udelay(100); + outw(0, FM801_REG(chip, CODEC_CTRL)); + + timeout = (jiffies + (3 * HZ) / 4) + 1; /* min 750ms */ + + outw((1<<7) | (0 << FM801_AC97_ADDR_SHIFT), FM801_REG(chip, AC97_CMD)); + udelay(5); + do { + if ((inw(FM801_REG(chip, AC97_CMD)) & (3<<8)) == (1<<8)) + goto __ac97_secondary; + schedule_timeout_uninterruptible(1); + } while (time_after(timeout, jiffies)); + snd_printk(KERN_ERR "Primary AC'97 codec not found\n"); + snd_fm801_free(chip); + return -EIO; + + __ac97_secondary: + if (!chip->multichannel) /* lookup is not required */ + goto __ac97_ok; + for (id = 3; id > 0; id--) { /* my card has the secondary codec */ + /* at address #3, so the loop is inverted */ + + timeout = jiffies + HZ / 20; + + outw((1<<7) | (id << FM801_AC97_ADDR_SHIFT) | AC97_VENDOR_ID1, FM801_REG(chip, AC97_CMD)); + udelay(5); + do { + if ((inw(FM801_REG(chip, AC97_CMD)) & (3<<8)) == (1<<8)) { + cmdw = inw(FM801_REG(chip, AC97_DATA)); + if (cmdw != 0xffff && cmdw != 0) { + chip->secondary = 1; + chip->secondary_addr = id; + goto __ac97_ok; + } + } + schedule_timeout_uninterruptible(1); + } while (time_after(timeout, jiffies)); + } + + /* the recovery phase, it seems that probing for non-existing codec might */ + /* cause timeout problems */ + timeout = (jiffies + (3 * HZ) / 4) + 1; /* min 750ms */ + + outw((1<<7) | (0 << FM801_AC97_ADDR_SHIFT), FM801_REG(chip, AC97_CMD)); + udelay(5); + do { + if ((inw(FM801_REG(chip, AC97_CMD)) & (3<<8)) == (1<<8)) + goto __ac97_ok; + schedule_timeout_uninterruptible(1); + } while (time_after(timeout, jiffies)); + snd_printk(KERN_ERR "Primary AC'97 codec not responding\n"); + snd_fm801_free(chip); + return -EIO; + + __ac97_ok: + + /* init volume */ + outw(0x0808, FM801_REG(chip, PCM_VOL)); + outw(0x9f1f, FM801_REG(chip, FM_VOL)); + outw(0x8808, FM801_REG(chip, I2S_VOL)); + + /* I2S control - I2S mode */ + outw(0x0003, FM801_REG(chip, I2S_MODE)); + + /* interrupt setup - unmask MPU, PLAYBACK & CAPTURE */ + cmdw = inw(FM801_REG(chip, IRQ_MASK)); + cmdw &= ~0x0083; + outw(cmdw, FM801_REG(chip, IRQ_MASK)); + + /* interrupt clear */ + outw(FM801_IRQ_PLAYBACK|FM801_IRQ_CAPTURE|FM801_IRQ_MPU, FM801_REG(chip, IRQ_STATUS)); if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { snd_fm801_free(chip); @@ -1412,9 +1391,9 @@ static int __devinit snd_card_fm801_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct fm801 *chip; - struct snd_opl3 *opl3; + snd_card_t *card; + fm801_t *chip; + opl3_t *opl3; int err; if (dev >= SNDRV_CARDS) @@ -1431,7 +1410,6 @@ static int __devinit snd_card_fm801_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = chip; strcpy(card->driver, "FM801"); strcpy(card->shortname, "ForteMedia FM801-"); @@ -1479,65 +1457,11 @@ static void __devexit snd_card_fm801_remove(struct pci_dev *pci) pci_set_drvdata(pci, NULL); } -#ifdef CONFIG_PM -static unsigned char saved_regs[] = { - FM801_PCM_VOL, FM801_I2S_VOL, FM801_FM_VOL, FM801_REC_SRC, - FM801_PLY_CTRL, FM801_PLY_COUNT, FM801_PLY_BUF1, FM801_PLY_BUF2, - FM801_CAP_CTRL, FM801_CAP_COUNT, FM801_CAP_BUF1, FM801_CAP_BUF2, - FM801_CODEC_CTRL, FM801_I2S_MODE, FM801_VOLUME, FM801_GEN_CTRL, -}; - -static int snd_fm801_suspend(struct pci_dev *pci, pm_message_t state) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct fm801 *chip = card->private_data; - int i; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - snd_pcm_suspend_all(chip->pcm); - snd_ac97_suspend(chip->ac97); - snd_ac97_suspend(chip->ac97_sec); - for (i = 0; i < ARRAY_SIZE(saved_regs); i++) - chip->saved_regs[i] = inw(chip->port + saved_regs[i]); - /* FIXME: tea575x suspend */ - - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); - return 0; -} - -static int snd_fm801_resume(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct fm801 *chip = card->private_data; - int i; - - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); - - snd_fm801_chip_init(chip, 1); - snd_ac97_resume(chip->ac97); - snd_ac97_resume(chip->ac97_sec); - for (i = 0; i < ARRAY_SIZE(saved_regs); i++) - outw(chip->saved_regs[i], chip->port + saved_regs[i]); - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - static struct pci_driver driver = { .name = "FM801", .id_table = snd_fm801_ids, .probe = snd_card_fm801_probe, .remove = __devexit_p(snd_card_fm801_remove), -#ifdef CONFIG_PM - .suspend = snd_fm801_suspend, - .resume = snd_fm801_resume, -#endif }; static int __init alsa_card_fm801_init(void) diff --git a/trunk/sound/pci/hda/hda_codec.c b/trunk/sound/pci/hda/hda_codec.c index 4a6dd97deba6..0dbeeaf6113a 100644 --- a/trunk/sound/pci/hda/hda_codec.c +++ b/trunk/sound/pci/hda/hda_codec.c @@ -155,9 +155,8 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, hda_nid_t *conn_list, int max_conns) { unsigned int parm; - int i, conn_len, conns; + int i, j, conn_len, num_tupples, conns; unsigned int shift, num_elems, mask; - hda_nid_t prev_nid; snd_assert(conn_list && max_conns > 0, return -EINVAL); @@ -172,6 +171,7 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, num_elems = 4; } conn_len = parm & AC_CLIST_LENGTH; + num_tupples = num_elems / 2; mask = (1 << (shift-1)) - 1; if (! conn_len) @@ -186,38 +186,40 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid, /* multi connection */ conns = 0; - prev_nid = 0; - for (i = 0; i < conn_len; i++) { - int range_val; - hda_nid_t val, n; - - if (i % num_elems == 0) - parm = snd_hda_codec_read(codec, nid, 0, - AC_VERB_GET_CONNECT_LIST, i); - range_val = !! (parm & (1 << (shift-1))); /* ranges */ - val = parm & mask; - parm >>= shift; - if (range_val) { - /* ranges between the previous and this one */ - if (! prev_nid || prev_nid >= val) { - snd_printk(KERN_WARNING "hda_codec: invalid dep_range_val %x:%x\n", prev_nid, val); - continue; - } - for (n = prev_nid + 1; n <= val; n++) { - if (conns >= max_conns) { - snd_printk(KERN_ERR "Too many connections\n"); - return -EINVAL; + for (i = 0; i < conn_len; i += num_elems) { + parm = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_LIST, i); + for (j = 0; j < num_tupples; j++) { + int range_val; + hda_nid_t val1, val2, n; + range_val = parm & (1 << (shift-1)); /* ranges */ + val1 = parm & mask; + parm >>= shift; + val2 = parm & mask; + parm >>= shift; + if (range_val) { + /* ranges between val1 and val2 */ + if (val1 > val2) { + snd_printk(KERN_WARNING "hda_codec: invalid dep_range_val %x:%x\n", val1, val2); + continue; } - conn_list[conns++] = n; - } - } else { - if (conns >= max_conns) { - snd_printk(KERN_ERR "Too many connections\n"); - return -EINVAL; + for (n = val1; n <= val2; n++) { + if (conns >= max_conns) + return -EINVAL; + conn_list[conns++] = n; + } + } else { + if (! val1) + break; + if (conns >= max_conns) + return -EINVAL; + conn_list[conns++] = val1; + if (! val2) + break; + if (conns >= max_conns) + return -EINVAL; + conn_list[conns++] = val2; } - conn_list[conns++] = val; } - prev_nid = val; } return conns; } @@ -286,9 +288,6 @@ static int init_unsol_queue(struct hda_bus *bus) { struct hda_bus_unsolicited *unsol; - if (bus->unsol) /* already initialized */ - return 0; - unsol = kzalloc(sizeof(*unsol), GFP_KERNEL); if (! unsol) { snd_printk(KERN_ERR "hda_codec: can't allocate unsolicited queue\n"); @@ -330,7 +329,7 @@ static int snd_hda_bus_free(struct hda_bus *bus) return 0; } -static int snd_hda_bus_dev_free(struct snd_device *device) +static int snd_hda_bus_dev_free(snd_device_t *device) { struct hda_bus *bus = device->device_data; return snd_hda_bus_free(bus); @@ -344,12 +343,12 @@ static int snd_hda_bus_dev_free(struct snd_device *device) * * Returns 0 if successful, or a negative error code. */ -int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp, +int snd_hda_bus_new(snd_card_t *card, const struct hda_bus_template *temp, struct hda_bus **busp) { struct hda_bus *bus; int err; - static struct snd_device_ops dev_ops = { + static snd_device_ops_t dev_ops = { .dev_free = snd_hda_bus_dev_free, }; @@ -374,6 +373,8 @@ int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp, init_MUTEX(&bus->cmd_mutex); INIT_LIST_HEAD(&bus->codec_list); + init_unsol_queue(bus); + if ((err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops)) < 0) { snd_hda_bus_free(bus); return err; @@ -453,27 +454,6 @@ static void setup_fg_nodes(struct hda_codec *codec) } } -/* - * read widget caps for each widget and store in cache - */ -static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node) -{ - int i; - hda_nid_t nid; - - codec->num_nodes = snd_hda_get_sub_nodes(codec, fg_node, - &codec->start_nid); - codec->wcaps = kmalloc(codec->num_nodes * 4, GFP_KERNEL); - if (! codec->wcaps) - return -ENOMEM; - nid = codec->start_nid; - for (i = 0; i < codec->num_nodes; i++, nid++) - codec->wcaps[i] = snd_hda_param_read(codec, nid, - AC_PAR_AUDIO_WIDGET_CAP); - return 0; -} - - /* * codec destructor */ @@ -485,8 +465,6 @@ static void snd_hda_codec_free(struct hda_codec *codec) codec->bus->caddr_tbl[codec->addr] = NULL; if (codec->patch_ops.free) codec->patch_ops.free(codec); - kfree(codec->amp_info); - kfree(codec->wcaps); kfree(codec); } @@ -540,12 +518,6 @@ int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr, return -ENODEV; } - if (read_widget_caps(codec, codec->afg ? codec->afg : codec->mfg) < 0) { - snd_printk(KERN_ERR "hda_codec: cannot malloc\n"); - snd_hda_codec_free(codec); - return -ENOMEM; - } - if (! codec->subsystem_id) { hda_nid_t nid = codec->afg ? codec->afg : codec->mfg; codec->subsystem_id = snd_hda_codec_read(codec, nid, 0, @@ -567,9 +539,6 @@ int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr, return err; } - if (codec->patch_ops.unsol_event) - init_unsol_queue(bus); - snd_hda_codec_proc_new(codec); sprintf(component, "HDA:%08x", codec->vendor_id); @@ -617,8 +586,6 @@ static void init_amp_hash(struct hda_codec *codec) { memset(codec->amp_hash, 0xff, sizeof(codec->amp_hash)); codec->num_amp_entries = 0; - codec->amp_info_size = 0; - codec->amp_info = NULL; } /* query the hash. allocate an entry if not found. */ @@ -636,22 +603,9 @@ static struct hda_amp_info *get_alloc_amp_hash(struct hda_codec *codec, u32 key) } /* add a new hash entry */ - if (codec->num_amp_entries >= codec->amp_info_size) { - /* reallocate the array */ - int new_size = codec->amp_info_size + 64; - struct hda_amp_info *new_info = kcalloc(new_size, sizeof(struct hda_amp_info), - GFP_KERNEL); - if (! new_info) { - snd_printk(KERN_ERR "hda_codec: can't malloc amp_info\n"); - return NULL; - } - if (codec->amp_info) { - memcpy(new_info, codec->amp_info, - codec->amp_info_size * sizeof(struct hda_amp_info)); - kfree(codec->amp_info); - } - codec->amp_info_size = new_size; - codec->amp_info = new_info; + if (codec->num_amp_entries >= ARRAY_SIZE(codec->amp_info)) { + snd_printk(KERN_ERR "hda_codec: Tooooo many amps!\n"); + return NULL; } cur = codec->num_amp_entries++; info = &codec->amp_info[cur]; @@ -673,7 +627,7 @@ static u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction) if (! info) return 0; if (! (info->status & INFO_AMP_CAPS)) { - if (! (get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD)) + if (!(snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP) & AC_WCAP_AMP_OVRD)) nid = codec->afg; info->amp_caps = snd_hda_param_read(codec, nid, direction == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP); @@ -758,7 +712,7 @@ static int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid, int #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) /* volume */ -int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +int snd_hda_mixer_amp_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); u16 nid = get_amp_nid(kcontrol); @@ -779,7 +733,7 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_hda_mixer_amp_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = get_amp_nid(kcontrol); @@ -795,7 +749,7 @@ int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_hda_mixer_amp_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = get_amp_nid(kcontrol); @@ -817,7 +771,7 @@ int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e } /* switch */ -int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +int snd_hda_mixer_amp_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { int chs = get_amp_channels(kcontrol); @@ -828,7 +782,7 @@ int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_hda_mixer_amp_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = get_amp_nid(kcontrol); @@ -844,7 +798,7 @@ int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_hda_mixer_amp_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = get_amp_nid(kcontrol); @@ -875,7 +829,7 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e #define AMP_VAL_IDX_SHIFT 19 #define AMP_VAL_IDX_MASK (0x0f<<19) -int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_hda_mixer_bind_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); unsigned long pval; @@ -890,7 +844,7 @@ int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ return err; } -int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +int snd_hda_mixer_bind_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); unsigned long pval; @@ -915,14 +869,14 @@ int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ * SPDIF out controls */ -static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hda_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_cmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | IEC958_AES0_NONAUDIO | @@ -933,7 +887,7 @@ static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_pmask_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL | IEC958_AES0_NONAUDIO | @@ -941,7 +895,7 @@ static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_default_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); @@ -1004,7 +958,7 @@ static unsigned int convert_to_spdif_status(unsigned short val) return sbits; } -static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_default_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = kcontrol->private_value; @@ -1030,7 +984,7 @@ static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_c return change; } -static int snd_hda_spdif_out_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hda_spdif_out_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1039,7 +993,7 @@ static int snd_hda_spdif_out_switch_info(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_out_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); @@ -1047,7 +1001,7 @@ static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_out_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = kcontrol->private_value; @@ -1070,7 +1024,7 @@ static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol, struct sn return change; } -static struct snd_kcontrol_new dig_mixes[] = { +static snd_kcontrol_new_t dig_mixes[] = { { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_MIXER, @@ -1115,8 +1069,8 @@ static struct snd_kcontrol_new dig_mixes[] = { int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid) { int err; - struct snd_kcontrol *kctl; - struct snd_kcontrol_new *dig_mix; + snd_kcontrol_t *kctl; + snd_kcontrol_new_t *dig_mix; for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) { kctl = snd_ctl_new1(dig_mix, codec); @@ -1135,7 +1089,7 @@ int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid) #define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info -static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_in_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); @@ -1143,7 +1097,7 @@ static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_in_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = kcontrol->private_value; @@ -1160,7 +1114,7 @@ static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol, struct snd return change; } -static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hda_spdif_in_status_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = kcontrol->private_value; @@ -1176,7 +1130,7 @@ static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol, struct snd return 0; } -static struct snd_kcontrol_new dig_in_ctls[] = { +static snd_kcontrol_new_t dig_in_ctls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), @@ -1207,8 +1161,8 @@ static struct snd_kcontrol_new dig_in_ctls[] = { int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid) { int err; - struct snd_kcontrol *kctl; - struct snd_kcontrol_new *dig_mix; + snd_kcontrol_t *kctl; + snd_kcontrol_new_t *dig_mix; for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) { kctl = snd_ctl_new1(dig_mix, codec); @@ -1221,31 +1175,6 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid) } -/* - * set power state of the codec - */ -static void hda_set_power_state(struct hda_codec *codec, hda_nid_t fg, - unsigned int power_state) -{ - hda_nid_t nid, nid_start; - int nodes; - - snd_hda_codec_write(codec, fg, 0, AC_VERB_SET_POWER_STATE, - power_state); - - nodes = snd_hda_get_sub_nodes(codec, fg, &nid_start); - for (nid = nid_start; nid < nodes + nid_start; nid++) { - if (get_wcaps(codec, nid) & AC_WCAP_POWER) - snd_hda_codec_write(codec, nid, 0, - AC_VERB_SET_POWER_STATE, - power_state); - } - - if (power_state == AC_PWRST_D0) - msleep(10); -} - - /** * snd_hda_build_controls - build mixer controls * @bus: the BUS @@ -1273,9 +1202,6 @@ int snd_hda_build_controls(struct hda_bus *bus) list_for_each(p, &bus->codec_list) { struct hda_codec *codec = list_entry(p, struct hda_codec, list); int err; - hda_set_power_state(codec, - codec->afg ? codec->afg : codec->mfg, - AC_PWRST_D0); if (! codec->patch_ops.init) continue; err = codec->patch_ops.init(codec); @@ -1394,7 +1320,7 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, val = 0; if (nid != codec->afg && - (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) { + snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP) & AC_WCAP_FORMAT_OVRD) { val = snd_hda_param_read(codec, nid, AC_PAR_PCM); if (val == -1) return -EIO; @@ -1416,7 +1342,7 @@ int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid, unsigned int bps; unsigned int wcaps; - wcaps = get_wcaps(codec, nid); + wcaps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP); streams = snd_hda_param_read(codec, nid, AC_PAR_STREAM); if (streams == -1) return -EIO; @@ -1486,7 +1412,7 @@ int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, unsigned int val = 0, rate, stream; if (nid != codec->afg && - (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD)) { + snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP) & AC_WCAP_FORMAT_OVRD) { val = snd_hda_param_read(codec, nid, AC_PAR_PCM); if (val == -1) return 0; @@ -1552,7 +1478,7 @@ int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid, */ static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { return 0; } @@ -1561,7 +1487,7 @@ static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); return 0; @@ -1569,7 +1495,7 @@ static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo, static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { snd_hda_codec_setup_stream(codec, hinfo->nid, 0, 0, 0); return 0; @@ -1700,90 +1626,30 @@ int snd_hda_check_board_config(struct hda_codec *codec, const struct hda_board_c /** * snd_hda_add_new_ctls - create controls from the array * @codec: the HDA codec - * @knew: the array of struct snd_kcontrol_new + * @knew: the array of snd_kcontrol_new_t * * This helper function creates and add new controls in the given array. * The array must be terminated with an empty entry as terminator. * * Returns 0 if successful, or a negative error code. */ -int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) +int snd_hda_add_new_ctls(struct hda_codec *codec, snd_kcontrol_new_t *knew) { int err; for (; knew->name; knew++) { - struct snd_kcontrol *kctl; - kctl = snd_ctl_new1(knew, codec); - if (! kctl) - return -ENOMEM; - err = snd_ctl_add(codec->bus->card, kctl); - if (err < 0) { - if (! codec->addr) - return err; - kctl = snd_ctl_new1(knew, codec); - if (! kctl) - return -ENOMEM; - kctl->id.device = codec->addr; - if ((err = snd_ctl_add(codec->bus->card, kctl)) < 0) - return err; - } - } - return 0; -} - - -/* - * Channel mode helper - */ -int snd_hda_ch_mode_info(struct hda_codec *codec, struct snd_ctl_elem_info *uinfo, - const struct hda_channel_mode *chmode, int num_chmodes) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; - uinfo->count = 1; - uinfo->value.enumerated.items = num_chmodes; - if (uinfo->value.enumerated.item >= num_chmodes) - uinfo->value.enumerated.item = num_chmodes - 1; - sprintf(uinfo->value.enumerated.name, "%dch", - chmode[uinfo->value.enumerated.item].channels); - return 0; -} - -int snd_hda_ch_mode_get(struct hda_codec *codec, struct snd_ctl_elem_value *ucontrol, - const struct hda_channel_mode *chmode, int num_chmodes, - int max_channels) -{ - int i; - - for (i = 0; i < num_chmodes; i++) { - if (max_channels == chmode[i].channels) { - ucontrol->value.enumerated.item[0] = i; - break; - } + err = snd_ctl_add(codec->bus->card, snd_ctl_new1(knew, codec)); + if (err < 0) + return err; } return 0; } -int snd_hda_ch_mode_put(struct hda_codec *codec, struct snd_ctl_elem_value *ucontrol, - const struct hda_channel_mode *chmode, int num_chmodes, - int *max_channelsp) -{ - unsigned int mode; - - mode = ucontrol->value.enumerated.item[0]; - snd_assert(mode < num_chmodes, return -EINVAL); - if (*max_channelsp == chmode[mode].channels && ! codec->in_resume) - return 0; - /* change the current channel setting */ - *max_channelsp = chmode[mode].channels; - if (chmode[mode].sequence) - snd_hda_sequence_write(codec, chmode[mode].sequence); - return 1; -} /* * input MUX helper */ -int snd_hda_input_mux_info(const struct hda_input_mux *imux, struct snd_ctl_elem_info *uinfo) +int snd_hda_input_mux_info(const struct hda_input_mux *imux, snd_ctl_elem_info_t *uinfo) { unsigned int index; @@ -1798,7 +1664,7 @@ int snd_hda_input_mux_info(const struct hda_input_mux *imux, struct snd_ctl_elem } int snd_hda_input_mux_put(struct hda_codec *codec, const struct hda_input_mux *imux, - struct snd_ctl_elem_value *ucontrol, hda_nid_t nid, + snd_ctl_elem_value_t *ucontrol, hda_nid_t nid, unsigned int *cur_val) { unsigned int idx; @@ -1849,7 +1715,7 @@ int snd_hda_multi_out_dig_close(struct hda_codec *codec, struct hda_multi_out *m * set up more restrictions for analog out */ int snd_hda_multi_out_analog_open(struct hda_codec *codec, struct hda_multi_out *mout, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { substream->runtime->hw.channels_max = mout->max_channels; return snd_pcm_hw_constraint_step(substream->runtime, 0, @@ -1863,7 +1729,7 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec, struct hda_multi_out int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, struct hda_multi_out *mout, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { hda_nid_t *nids = mout->dac_nids; int chs = substream->runtime->channels; @@ -1926,18 +1792,8 @@ int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, struct hda_multi_o /* * Helper for automatic ping configuration */ - -static int is_in_nid_list(hda_nid_t nid, hda_nid_t *list) -{ - for (; *list; list++) - if (*list == nid) - return 1; - return 0; -} - /* parse all pin widgets and store the useful pin nids to cfg */ -int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *cfg, - hda_nid_t *ignore_nids) +int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *cfg) { hda_nid_t nid, nid_start; int i, j, nodes; @@ -1950,7 +1806,8 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *c nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid_start); for (nid = nid_start; nid < nodes + nid_start; nid++) { - unsigned int wid_caps = get_wcaps(codec, nid); + unsigned int wid_caps = snd_hda_param_read(codec, nid, + AC_PAR_AUDIO_WIDGET_CAP); unsigned int wid_type = (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; unsigned int def_conf; short assoc, loc; @@ -1958,16 +1815,13 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *c /* read all default configuration for pin complex */ if (wid_type != AC_WID_PIN) continue; - /* ignore the given nids (e.g. pc-beep returns error) */ - if (ignore_nids && is_in_nid_list(nid, ignore_nids)) - continue; - def_conf = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONFIG_DEFAULT, 0); if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) continue; loc = get_defcfg_location(def_conf); switch (get_defcfg_device(def_conf)) { case AC_JACK_LINE_OUT: + case AC_JACK_SPEAKER: seq = get_defcfg_sequence(def_conf); assoc = get_defcfg_association(def_conf); if (! assoc) @@ -1982,9 +1836,6 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *c sequences[cfg->line_outs] = seq; cfg->line_outs++; break; - case AC_JACK_SPEAKER: - cfg->speaker_pin = nid; - break; case AC_JACK_HP_OUT: cfg->hp_pin = nid; break; @@ -2051,12 +1902,6 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *c return 0; } -/* labels for input pins */ -const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" -}; - - #ifdef CONFIG_PM /* * power management @@ -2078,9 +1923,6 @@ int snd_hda_suspend(struct hda_bus *bus, pm_message_t state) struct hda_codec *codec = list_entry(p, struct hda_codec, list); if (codec->patch_ops.suspend) codec->patch_ops.suspend(codec, state); - hda_set_power_state(codec, - codec->afg ? codec->afg : codec->mfg, - AC_PWRST_D3); } return 0; } @@ -2098,9 +1940,6 @@ int snd_hda_resume(struct hda_bus *bus) list_for_each(p, &bus->codec_list) { struct hda_codec *codec = list_entry(p, struct hda_codec, list); - hda_set_power_state(codec, - codec->afg ? codec->afg : codec->mfg, - AC_PWRST_D0); if (codec->patch_ops.resume) codec->patch_ops.resume(codec); } @@ -2110,15 +1949,15 @@ int snd_hda_resume(struct hda_bus *bus) /** * snd_hda_resume_ctls - resume controls in the new control list * @codec: the HDA codec - * @knew: the array of struct snd_kcontrol_new + * @knew: the array of snd_kcontrol_new_t * - * This function resumes the mixer controls in the struct snd_kcontrol_new array, + * This function resumes the mixer controls in the snd_kcontrol_new_t array, * originally for snd_hda_add_new_ctls(). * The array must be terminated with an empty entry as terminator. */ -int snd_hda_resume_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew) +int snd_hda_resume_ctls(struct hda_codec *codec, snd_kcontrol_new_t *knew) { - struct snd_ctl_elem_value *val; + snd_ctl_elem_value_t *val; val = kmalloc(sizeof(*val), GFP_KERNEL); if (! val) diff --git a/trunk/sound/pci/hda/hda_codec.h b/trunk/sound/pci/hda/hda_codec.h index 63e26c7a2b7a..1179d6cfa82a 100644 --- a/trunk/sound/pci/hda/hda_codec.h +++ b/trunk/sound/pci/hda/hda_codec.h @@ -98,7 +98,7 @@ enum { #define AC_VERB_SET_UNSOLICITED_ENABLE 0x708 #define AC_VERB_SET_PIN_SENSE 0x709 #define AC_VERB_SET_BEEP_CONTROL 0x70a -#define AC_VERB_SET_EAPD_BTLENABLE 0x70c +#define AC_VERB_SET_EAPD_BTLENALBE 0x70c #define AC_VERB_SET_DIGI_CONVERT_1 0x70d #define AC_VERB_SET_DIGI_CONVERT_2 0x70e #define AC_VERB_SET_VOLUME_KNOB_CONTROL 0x70f @@ -214,12 +214,6 @@ enum { #define AC_PWRST_D2SUP (1<<2) #define AC_PWRST_D3SUP (1<<3) -/* Power state values */ -#define AC_PWRST_D0 0x00 -#define AC_PWRST_D1 0x01 -#define AC_PWRST_D2 0x02 -#define AC_PWRST_D3 0x03 - /* Processing capabilies */ #define AC_PCAP_BENIGN (1<<0) #define AC_PCAP_NUM_COEF (0xff<<8) @@ -382,7 +376,7 @@ enum { }; /* max. connections to a widget */ -#define HDA_MAX_CONNECTIONS 32 +#define HDA_MAX_CONNECTIONS 16 /* max. codec address */ #define HDA_MAX_CODEC_ADDRESS 0x0f @@ -426,7 +420,7 @@ struct hda_bus_template { * A hda_bus contains several codecs in the list codec_list. */ struct hda_bus { - struct snd_card *card; + snd_card_t *card; /* copied from template */ void *private_data; @@ -443,7 +437,7 @@ struct hda_bus { /* unsolicited event queue */ struct hda_bus_unsolicited *unsol; - struct snd_info_entry *proc; + snd_info_entry_t *proc; }; /* @@ -487,14 +481,14 @@ struct hda_amp_info { /* PCM callbacks */ struct hda_pcm_ops { int (*open)(struct hda_pcm_stream *info, struct hda_codec *codec, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int (*close)(struct hda_pcm_stream *info, struct hda_codec *codec, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int (*prepare)(struct hda_pcm_stream *info, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int (*cleanup)(struct hda_pcm_stream *info, struct hda_codec *codec, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); }; /* PCM information for each substream */ @@ -548,16 +542,10 @@ struct hda_codec { /* codec specific info */ void *spec; - /* widget capabilities cache */ - unsigned int num_nodes; - hda_nid_t start_nid; - u32 *wcaps; - /* hash for amp access */ u16 amp_hash[32]; int num_amp_entries; - int amp_info_size; - struct hda_amp_info *amp_info; + struct hda_amp_info amp_info[128]; /* big enough? */ struct semaphore spdif_mutex; unsigned int spdif_status; /* IEC958 status bits */ @@ -574,7 +562,7 @@ enum { /* * constructors */ -int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp, +int snd_hda_bus_new(snd_card_t *card, const struct hda_bus_template *temp, struct hda_bus **busp); int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr, struct hda_codec **codecp); diff --git a/trunk/sound/pci/hda/hda_generic.c b/trunk/sound/pci/hda/hda_generic.c index 39edfcfd3abd..d0eb9f2250aa 100644 --- a/trunk/sound/pci/hda/hda_generic.c +++ b/trunk/sound/pci/hda/hda_generic.c @@ -32,8 +32,7 @@ struct hda_gnode { hda_nid_t nid; /* NID of this widget */ unsigned short nconns; /* number of input connections */ - hda_nid_t *conn_list; - hda_nid_t slist[2]; /* temporay list */ + hda_nid_t conn_list[HDA_MAX_CONNECTIONS]; /* input connections */ unsigned int wid_caps; /* widget capabilities */ unsigned char type; /* widget type */ unsigned char pin_ctl; /* pin controls */ @@ -85,8 +84,6 @@ static void snd_hda_generic_free(struct hda_codec *codec) /* free all widgets */ list_for_each_safe(p, n, &spec->nid_list) { struct hda_gnode *node = list_entry(p, struct hda_gnode, list); - if (node->conn_list != node->slist) - kfree(node->conn_list); kfree(node); } kfree(spec); @@ -100,32 +97,18 @@ static int add_new_node(struct hda_codec *codec, struct hda_gspec *spec, hda_nid { struct hda_gnode *node; int nconns; - hda_nid_t conn_list[HDA_MAX_CONNECTIONS]; node = kzalloc(sizeof(*node), GFP_KERNEL); if (node == NULL) return -ENOMEM; node->nid = nid; - nconns = snd_hda_get_connections(codec, nid, conn_list, - HDA_MAX_CONNECTIONS); + nconns = snd_hda_get_connections(codec, nid, node->conn_list, HDA_MAX_CONNECTIONS); if (nconns < 0) { kfree(node); return nconns; } - if (nconns <= ARRAY_SIZE(node->slist)) - node->conn_list = node->slist; - else { - node->conn_list = kmalloc(sizeof(hda_nid_t) * nconns, - GFP_KERNEL); - if (! node->conn_list) { - snd_printk(KERN_ERR "hda-generic: cannot malloc\n"); - kfree(node); - return -ENOMEM; - } - } - memcpy(node->conn_list, conn_list, nconns); node->nconns = nconns; - node->wid_caps = get_wcaps(codec, nid); + node->wid_caps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP); node->type = (node->wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; if (node->type == AC_WID_PIN) { @@ -406,14 +389,14 @@ static int parse_output(struct hda_codec *codec) */ /* control callbacks */ -static int capture_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int capture_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct hda_gspec *spec = codec->spec; return snd_hda_input_mux_info(&spec->input_mux, uinfo); } -static int capture_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int capture_source_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct hda_gspec *spec = codec->spec; @@ -422,7 +405,7 @@ static int capture_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int capture_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int capture_source_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct hda_gspec *spec = codec->spec; @@ -634,7 +617,7 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, char name[32]; int err; int created = 0; - struct snd_kcontrol_new knew; + snd_kcontrol_new_t knew; if (type) sprintf(name, "%s %s Switch", type, dir_sfx); @@ -642,14 +625,14 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, sprintf(name, "%s Switch", dir_sfx); if ((node->wid_caps & AC_WCAP_IN_AMP) && (node->amp_in_caps & AC_AMPCAP_MUTE)) { - knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, index, HDA_INPUT); + knew = (snd_kcontrol_new_t)HDA_CODEC_MUTE(name, node->nid, index, HDA_INPUT); snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index); if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0) return err; created = 1; } else if ((node->wid_caps & AC_WCAP_OUT_AMP) && (node->amp_out_caps & AC_AMPCAP_MUTE)) { - knew = (struct snd_kcontrol_new)HDA_CODEC_MUTE(name, node->nid, 0, HDA_OUTPUT); + knew = (snd_kcontrol_new_t)HDA_CODEC_MUTE(name, node->nid, 0, HDA_OUTPUT); snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid); if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0) return err; @@ -662,14 +645,14 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, sprintf(name, "%s Volume", dir_sfx); if ((node->wid_caps & AC_WCAP_IN_AMP) && (node->amp_in_caps & AC_AMPCAP_NUM_STEPS)) { - knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT); + knew = (snd_kcontrol_new_t)HDA_CODEC_VOLUME(name, node->nid, index, HDA_INPUT); snd_printdd("[%s] NID=0x%x, DIR=IN, IDX=0x%x\n", name, node->nid, index); if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0) return err; created = 1; } else if ((node->wid_caps & AC_WCAP_OUT_AMP) && (node->amp_out_caps & AC_AMPCAP_NUM_STEPS)) { - knew = (struct snd_kcontrol_new)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT); + knew = (snd_kcontrol_new_t)HDA_CODEC_VOLUME(name, node->nid, 0, HDA_OUTPUT); snd_printdd("[%s] NID=0x%x, DIR=OUT\n", name, node->nid); if ((err = snd_ctl_add(codec->bus->card, snd_ctl_new1(&knew, codec))) < 0) return err; @@ -684,7 +667,7 @@ static int create_mixer(struct hda_codec *codec, struct hda_gnode *node, */ static int check_existing_control(struct hda_codec *codec, const char *type, const char *dir) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; memset(&id, 0, sizeof(id)); sprintf(id.name, "%s %s Volume", type, dir); id.iface = SNDRV_CTL_ELEM_IFACE_MIXER; @@ -727,7 +710,7 @@ static int build_input_controls(struct hda_codec *codec) /* create input MUX if multiple sources are available */ if (spec->input_mux.num_items > 1) { - static struct snd_kcontrol_new cap_sel = { + static snd_kcontrol_new_t cap_sel = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Source", .info = capture_source_info, diff --git a/trunk/sound/pci/hda/hda_intel.c b/trunk/sound/pci/hda/hda_intel.c index a983deba4025..ed525c03c996 100644 --- a/trunk/sound/pci/hda/hda_intel.c +++ b/trunk/sound/pci/hda/hda_intel.c @@ -37,7 +37,6 @@ #include <asm/io.h> #include <linux/delay.h> #include <linux/interrupt.h> -#include <linux/kernel.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/init.h> @@ -52,7 +51,6 @@ static int index = SNDRV_DEFAULT_IDX1; static char *id = SNDRV_DEFAULT_STR1; static char *model; static int position_fix; -static int probe_mask = -1; module_param(index, int, 0444); MODULE_PARM_DESC(index, "Index value for Intel HD audio interface."); @@ -62,9 +60,6 @@ module_param(model, charp, 0444); MODULE_PARM_DESC(model, "Use the given board model."); module_param(position_fix, int, 0444); MODULE_PARM_DESC(position_fix, "Fix DMA pointer (0 = auto, 1 = none, 2 = POSBUF, 3 = FIFO size)."); -module_param(probe_mask, int, 0444); -MODULE_PARM_DESC(probe_mask, "Bitmask to probe codecs (default = -1)."); - /* just for backward compatibility */ static int enable; @@ -242,7 +237,11 @@ enum { /* */ -struct azx_dev { +typedef struct snd_azx azx_t; +typedef struct snd_azx_rb azx_rb_t; +typedef struct snd_azx_dev azx_dev_t; + +struct snd_azx_dev { u32 *bdl; /* virtual address of the BDL */ dma_addr_t bdl_addr; /* physical address of the BDL */ volatile u32 *posbuf; /* position buffer pointer */ @@ -258,7 +257,7 @@ struct azx_dev { u32 sd_int_sta_mask; /* stream int status mask */ /* pcm support */ - struct snd_pcm_substream *substream; /* assigned substream, set in PCM open */ + snd_pcm_substream_t *substream; /* assigned substream, set in PCM open */ unsigned int format_val; /* format value to be set in the controller and the codec */ unsigned char stream_tag; /* assigned stream */ unsigned char index; /* stream index */ @@ -269,7 +268,7 @@ struct azx_dev { }; /* CORB/RIRB */ -struct azx_rb { +struct snd_azx_rb { u32 *buf; /* CORB/RIRB buffer * Each CORB entry is 4byte, RIRB is 8byte */ @@ -280,8 +279,8 @@ struct azx_rb { u32 res; /* last read value */ }; -struct azx { - struct snd_card *card; +struct snd_azx { + snd_card_t *card; struct pci_dev *pci; /* chip type specific */ @@ -302,19 +301,19 @@ struct azx { struct semaphore open_mutex; /* streams (x num_streams) */ - struct azx_dev *azx_dev; + azx_dev_t *azx_dev; /* PCM */ unsigned int pcm_devs; - struct snd_pcm *pcm[AZX_MAX_PCMS]; + snd_pcm_t *pcm[AZX_MAX_PCMS]; /* HD codec */ unsigned short codec_mask; struct hda_bus *bus; /* CORB/RIRB */ - struct azx_rb corb; - struct azx_rb rirb; + azx_rb_t corb; + azx_rb_t rirb; /* BDL, CORB/RIRB and position buffers */ struct snd_dma_buffer bdl; @@ -375,7 +374,7 @@ static char *driver_short_names[] __devinitdata = { readb((dev)->sd_addr + ICH6_REG_##reg) /* for pcm support */ -#define get_azx_dev(substream) (substream->runtime->private_data) +#define get_azx_dev(substream) (azx_dev_t*)(substream->runtime->private_data) /* Get the upper 32bit of the given dma_addr_t * Compiler should optimize and eliminate the code if dma_addr_t is 32bit @@ -391,7 +390,7 @@ static char *driver_short_names[] __devinitdata = { /* * CORB / RIRB interface */ -static int azx_alloc_cmd_io(struct azx *chip) +static int azx_alloc_cmd_io(azx_t *chip) { int err; @@ -405,7 +404,7 @@ static int azx_alloc_cmd_io(struct azx *chip) return 0; } -static void azx_init_cmd_io(struct azx *chip) +static void azx_init_cmd_io(azx_t *chip) { /* CORB set up */ chip->corb.addr = chip->rb.addr; @@ -443,7 +442,7 @@ static void azx_init_cmd_io(struct azx *chip) chip->rirb.rp = chip->rirb.cmds = 0; } -static void azx_free_cmd_io(struct azx *chip) +static void azx_free_cmd_io(azx_t *chip) { /* disable ringbuffer DMAs */ azx_writeb(chip, RIRBCTL, 0); @@ -454,7 +453,7 @@ static void azx_free_cmd_io(struct azx *chip) static int azx_send_cmd(struct hda_codec *codec, hda_nid_t nid, int direct, unsigned int verb, unsigned int para) { - struct azx *chip = codec->bus->private_data; + azx_t *chip = codec->bus->private_data; unsigned int wp; u32 val; @@ -481,7 +480,7 @@ static int azx_send_cmd(struct hda_codec *codec, hda_nid_t nid, int direct, #define ICH6_RIRB_EX_UNSOL_EV (1<<4) /* retrieve RIRB entry - called from interrupt handler */ -static void azx_update_rirb(struct azx *chip) +static void azx_update_rirb(azx_t *chip) { unsigned int rp, wp; u32 res, res_ex; @@ -510,14 +509,12 @@ static void azx_update_rirb(struct azx *chip) /* receive a response */ static unsigned int azx_get_response(struct hda_codec *codec) { - struct azx *chip = codec->bus->private_data; + azx_t *chip = codec->bus->private_data; int timeout = 50; while (chip->rirb.cmds) { if (! --timeout) { - if (printk_ratelimit()) - snd_printk(KERN_ERR - "azx_get_response timeout\n"); + snd_printk(KERN_ERR "azx_get_response timeout\n"); chip->rirb.rp = azx_readb(chip, RIRBWP); chip->rirb.cmds = 0; return -1; @@ -546,7 +543,7 @@ static unsigned int azx_get_response(struct hda_codec *codec) static int azx_send_cmd(struct hda_codec *codec, hda_nid_t nid, int direct, unsigned int verb, unsigned int para) { - struct azx *chip = codec->bus->private_data; + azx_t *chip = codec->bus->private_data; u32 val; int timeout = 50; @@ -574,7 +571,7 @@ static int azx_send_cmd(struct hda_codec *codec, hda_nid_t nid, int direct, /* receive a response */ static unsigned int azx_get_response(struct hda_codec *codec) { - struct azx *chip = codec->bus->private_data; + azx_t *chip = codec->bus->private_data; int timeout = 50; while (timeout--) { @@ -592,7 +589,7 @@ static unsigned int azx_get_response(struct hda_codec *codec) #endif /* USE_CORB_RIRB */ /* reset codec link */ -static int azx_reset(struct azx *chip) +static int azx_reset(azx_t *chip) { int count; @@ -642,7 +639,7 @@ static int azx_reset(struct azx *chip) */ /* enable interrupts */ -static void azx_int_enable(struct azx *chip) +static void azx_int_enable(azx_t *chip) { /* enable controller CIE and GIE */ azx_writel(chip, INTCTL, azx_readl(chip, INTCTL) | @@ -650,13 +647,13 @@ static void azx_int_enable(struct azx *chip) } /* disable interrupts */ -static void azx_int_disable(struct azx *chip) +static void azx_int_disable(azx_t *chip) { int i; /* disable interrupts in stream descriptor */ for (i = 0; i < chip->num_streams; i++) { - struct azx_dev *azx_dev = &chip->azx_dev[i]; + azx_dev_t *azx_dev = &chip->azx_dev[i]; azx_sd_writeb(azx_dev, SD_CTL, azx_sd_readb(azx_dev, SD_CTL) & ~SD_INT_MASK); } @@ -670,13 +667,13 @@ static void azx_int_disable(struct azx *chip) } /* clear interrupts */ -static void azx_int_clear(struct azx *chip) +static void azx_int_clear(azx_t *chip) { int i; /* clear stream status */ for (i = 0; i < chip->num_streams; i++) { - struct azx_dev *azx_dev = &chip->azx_dev[i]; + azx_dev_t *azx_dev = &chip->azx_dev[i]; azx_sd_writeb(azx_dev, SD_STS, SD_INT_MASK); } @@ -691,7 +688,7 @@ static void azx_int_clear(struct azx *chip) } /* start a stream */ -static void azx_stream_start(struct azx *chip, struct azx_dev *azx_dev) +static void azx_stream_start(azx_t *chip, azx_dev_t *azx_dev) { /* enable SIE */ azx_writeb(chip, INTCTL, @@ -702,7 +699,7 @@ static void azx_stream_start(struct azx *chip, struct azx_dev *azx_dev) } /* stop a stream */ -static void azx_stream_stop(struct azx *chip, struct azx_dev *azx_dev) +static void azx_stream_stop(azx_t *chip, azx_dev_t *azx_dev) { /* stop DMA */ azx_sd_writeb(azx_dev, SD_CTL, azx_sd_readb(azx_dev, SD_CTL) & @@ -717,7 +714,7 @@ static void azx_stream_stop(struct azx *chip, struct azx_dev *azx_dev) /* * initialize the chip */ -static void azx_init_chip(struct azx *chip) +static void azx_init_chip(azx_t *chip) { unsigned char reg; @@ -765,8 +762,8 @@ static void azx_init_chip(struct azx *chip) */ static irqreturn_t azx_interrupt(int irq, void* dev_id, struct pt_regs *regs) { - struct azx *chip = dev_id; - struct azx_dev *azx_dev; + azx_t *chip = dev_id; + azx_dev_t *azx_dev; u32 status; int i; @@ -814,7 +811,7 @@ static irqreturn_t azx_interrupt(int irq, void* dev_id, struct pt_regs *regs) /* * set up BDL entries */ -static void azx_setup_periods(struct azx_dev *azx_dev) +static void azx_setup_periods(azx_dev_t *azx_dev) { u32 *bdl = azx_dev->bdl; dma_addr_t dma_addr = azx_dev->substream->runtime->dma_addr; @@ -843,7 +840,7 @@ static void azx_setup_periods(struct azx_dev *azx_dev) /* * set up the SD for streaming */ -static int azx_setup_controller(struct azx *chip, struct azx_dev *azx_dev) +static int azx_setup_controller(azx_t *chip, azx_dev_t *azx_dev) { unsigned char val; int timeout; @@ -903,7 +900,7 @@ static int azx_setup_controller(struct azx *chip, struct azx_dev *azx_dev) * Codec initialization */ -static int __devinit azx_codec_create(struct azx *chip, const char *model) +static int __devinit azx_codec_create(azx_t *chip, const char *model) { struct hda_bus_template bus_temp; int c, codecs, err; @@ -920,7 +917,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model) codecs = 0; for (c = 0; c < AZX_MAX_CODECS; c++) { - if ((chip->codec_mask & (1 << c)) & probe_mask) { + if (chip->codec_mask & (1 << c)) { err = snd_hda_codec_new(chip->bus, c, NULL); if (err < 0) continue; @@ -941,7 +938,7 @@ static int __devinit azx_codec_create(struct azx *chip, const char *model) */ /* assign a stream for the PCM */ -static inline struct azx_dev *azx_assign_device(struct azx *chip, int stream) +static inline azx_dev_t *azx_assign_device(azx_t *chip, int stream) { int dev, i, nums; if (stream == SNDRV_PCM_STREAM_PLAYBACK) { @@ -960,12 +957,12 @@ static inline struct azx_dev *azx_assign_device(struct azx *chip, int stream) } /* release the assigned stream */ -static inline void azx_release_device(struct azx_dev *azx_dev) +static inline void azx_release_device(azx_dev_t *azx_dev) { azx_dev->opened = 0; } -static struct snd_pcm_hardware azx_pcm_hw = { +static snd_pcm_hardware_t azx_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | @@ -986,18 +983,18 @@ static struct snd_pcm_hardware azx_pcm_hw = { }; struct azx_pcm { - struct azx *chip; + azx_t *chip; struct hda_codec *codec; struct hda_pcm_stream *hinfo[2]; }; -static int azx_pcm_open(struct snd_pcm_substream *substream) +static int azx_pcm_open(snd_pcm_substream_t *substream) { struct azx_pcm *apcm = snd_pcm_substream_chip(substream); struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; - struct azx *chip = apcm->chip; - struct azx_dev *azx_dev; - struct snd_pcm_runtime *runtime = substream->runtime; + azx_t *chip = apcm->chip; + azx_dev_t *azx_dev; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; int err; @@ -1029,12 +1026,12 @@ static int azx_pcm_open(struct snd_pcm_substream *substream) return 0; } -static int azx_pcm_close(struct snd_pcm_substream *substream) +static int azx_pcm_close(snd_pcm_substream_t *substream) { struct azx_pcm *apcm = snd_pcm_substream_chip(substream); struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; - struct azx *chip = apcm->chip; - struct azx_dev *azx_dev = get_azx_dev(substream); + azx_t *chip = apcm->chip; + azx_dev_t *azx_dev = get_azx_dev(substream); unsigned long flags; down(&chip->open_mutex); @@ -1048,15 +1045,15 @@ static int azx_pcm_close(struct snd_pcm_substream *substream) return 0; } -static int azx_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) +static int azx_pcm_hw_params(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int azx_pcm_hw_free(struct snd_pcm_substream *substream) +static int azx_pcm_hw_free(snd_pcm_substream_t *substream) { struct azx_pcm *apcm = snd_pcm_substream_chip(substream); - struct azx_dev *azx_dev = get_azx_dev(substream); + azx_dev_t *azx_dev = get_azx_dev(substream); struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; /* reset BDL address */ @@ -1069,13 +1066,13 @@ static int azx_pcm_hw_free(struct snd_pcm_substream *substream) return snd_pcm_lib_free_pages(substream); } -static int azx_pcm_prepare(struct snd_pcm_substream *substream) +static int azx_pcm_prepare(snd_pcm_substream_t *substream) { struct azx_pcm *apcm = snd_pcm_substream_chip(substream); - struct azx *chip = apcm->chip; - struct azx_dev *azx_dev = get_azx_dev(substream); + azx_t *chip = apcm->chip; + azx_dev_t *azx_dev = get_azx_dev(substream); struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; azx_dev->bufsize = snd_pcm_lib_buffer_bytes(substream); azx_dev->fragsize = snd_pcm_lib_period_bytes(substream); @@ -1104,11 +1101,11 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream) azx_dev->format_val, substream); } -static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int azx_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { struct azx_pcm *apcm = snd_pcm_substream_chip(substream); - struct azx_dev *azx_dev = get_azx_dev(substream); - struct azx *chip = apcm->chip; + azx_dev_t *azx_dev = get_azx_dev(substream); + azx_t *chip = apcm->chip; int err = 0; spin_lock(&chip->reg_lock); @@ -1139,11 +1136,11 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) return err; } -static snd_pcm_uframes_t azx_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t azx_pcm_pointer(snd_pcm_substream_t *substream) { struct azx_pcm *apcm = snd_pcm_substream_chip(substream); - struct azx *chip = apcm->chip; - struct azx_dev *azx_dev = get_azx_dev(substream); + azx_t *chip = apcm->chip; + azx_dev_t *azx_dev = get_azx_dev(substream); unsigned int pos; if (chip->position_fix == POS_FIX_POSBUF) { @@ -1154,13 +1151,38 @@ static snd_pcm_uframes_t azx_pcm_pointer(struct snd_pcm_substream *substream) pos = azx_sd_readl(azx_dev, SD_LPIB); if (chip->position_fix == POS_FIX_FIFO) pos += azx_dev->fifo_size; +#if 0 /* disabled temprarily, auto-correction doesn't work well... */ + else if (chip->position_fix == POS_FIX_AUTO && azx_dev->period_updating) { + /* check the validity of DMA position */ + unsigned int diff = 0; + azx_dev->last_pos += azx_dev->fragsize; + if (azx_dev->last_pos > pos) + diff = azx_dev->last_pos - pos; + if (azx_dev->last_pos >= azx_dev->bufsize) { + if (pos < azx_dev->fragsize) + diff = 0; + azx_dev->last_pos = 0; + } + if (diff > 0 && diff <= azx_dev->fifo_size) + pos += azx_dev->fifo_size; + else { + snd_printdd(KERN_INFO "hda_intel: DMA position fix %d, switching to posbuf\n", diff); + chip->position_fix = POS_FIX_POSBUF; + pos = *azx_dev->posbuf; + } + azx_dev->period_updating = 0; + } +#else + else if (chip->position_fix == POS_FIX_AUTO) + pos += azx_dev->fifo_size; +#endif } if (pos >= azx_dev->bufsize) pos = 0; return bytes_to_frames(substream->runtime, pos); } -static struct snd_pcm_ops azx_pcm_ops = { +static snd_pcm_ops_t azx_pcm_ops = { .open = azx_pcm_open, .close = azx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -1171,16 +1193,16 @@ static struct snd_pcm_ops azx_pcm_ops = { .pointer = azx_pcm_pointer, }; -static void azx_pcm_free(struct snd_pcm *pcm) +static void azx_pcm_free(snd_pcm_t *pcm) { kfree(pcm->private_data); } -static int __devinit create_codec_pcm(struct azx *chip, struct hda_codec *codec, +static int __devinit create_codec_pcm(azx_t *chip, struct hda_codec *codec, struct hda_pcm *cpcm, int pcm_dev) { int err; - struct snd_pcm *pcm; + snd_pcm_t *pcm; struct azx_pcm *apcm; snd_assert(cpcm->stream[0].substreams || cpcm->stream[1].substreams, return -EINVAL); @@ -1214,7 +1236,7 @@ static int __devinit create_codec_pcm(struct azx *chip, struct hda_codec *codec, return 0; } -static int __devinit azx_pcm_create(struct azx *chip) +static int __devinit azx_pcm_create(azx_t *chip) { struct list_head *p; struct hda_codec *codec; @@ -1266,7 +1288,7 @@ static int __devinit azx_pcm_create(struct azx *chip) /* * mixer creation - all stuff is implemented in hda module */ -static int __devinit azx_mixer_create(struct azx *chip) +static int __devinit azx_mixer_create(azx_t *chip) { return snd_hda_build_controls(chip->bus); } @@ -1275,7 +1297,7 @@ static int __devinit azx_mixer_create(struct azx *chip) /* * initialize SD streams */ -static int __devinit azx_init_stream(struct azx *chip) +static int __devinit azx_init_stream(azx_t *chip) { int i; @@ -1284,7 +1306,7 @@ static int __devinit azx_init_stream(struct azx *chip) */ for (i = 0; i < chip->num_streams; i++) { unsigned int off = sizeof(u32) * (i * AZX_MAX_FRAG * 4); - struct azx_dev *azx_dev = &chip->azx_dev[i]; + azx_dev_t *azx_dev = &chip->azx_dev[i]; azx_dev->bdl = (u32 *)(chip->bdl.area + off); azx_dev->bdl_addr = chip->bdl.addr + off; azx_dev->posbuf = (volatile u32 *)(chip->posbuf.area + i * 8); @@ -1305,33 +1327,28 @@ static int __devinit azx_init_stream(struct azx *chip) /* * power management */ -static int azx_suspend(struct pci_dev *pci, pm_message_t state) +static int azx_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct azx *chip = card->private_data; + azx_t *chip = card->pm_private_data; int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < chip->pcm_devs; i++) - snd_pcm_suspend_all(chip->pcm[i]); + if (chip->pcm[i]) + snd_pcm_suspend_all(chip->pcm[i]); snd_hda_suspend(chip->bus, state); azx_free_cmd_io(chip); - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -static int azx_resume(struct pci_dev *pci) +static int azx_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct azx *chip = card->private_data; + azx_t *chip = card->pm_private_data; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_master(chip->pci); azx_init_chip(chip); snd_hda_resume(chip->bus); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ @@ -1340,7 +1357,7 @@ static int azx_resume(struct pci_dev *pci) /* * destructor */ -static int azx_free(struct azx *chip) +static int azx_free(azx_t *chip) { if (chip->initialized) { int i; @@ -1382,7 +1399,7 @@ static int azx_free(struct azx *chip) return 0; } -static int azx_dev_free(struct snd_device *device) +static int azx_dev_free(snd_device_t *device) { return azx_free(device->device_data); } @@ -1390,13 +1407,13 @@ static int azx_dev_free(struct snd_device *device) /* * constructor */ -static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci, - int driver_type, - struct azx **rchip) +static int __devinit azx_create(snd_card_t *card, struct pci_dev *pci, + int posfix, int driver_type, + azx_t **rchip) { - struct azx *chip; + azx_t *chip; int err = 0; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = azx_dev_free, }; @@ -1420,7 +1437,7 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci, chip->irq = -1; chip->driver_type = driver_type; - chip->position_fix = position_fix ? position_fix : POS_FIX_POSBUF; + chip->position_fix = posfix; #if BITS_PER_LONG != 64 /* Fix up base address on ULI M5461 */ @@ -1528,8 +1545,8 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci, static int __devinit azx_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct azx *chip; + snd_card_t *card; + azx_t *chip; int err = 0; card = snd_card_new(index, id, THIS_MODULE, 0); @@ -1538,12 +1555,11 @@ static int __devinit azx_probe(struct pci_dev *pci, const struct pci_device_id * return -ENOMEM; } - if ((err = azx_create(card, pci, pci_id->driver_data, + if ((err = azx_create(card, pci, position_fix, pci_id->driver_data, &chip)) < 0) { snd_card_free(card); return err; } - card->private_data = chip; /* create codec instances */ if ((err = azx_codec_create(chip, model)) < 0) { @@ -1563,6 +1579,7 @@ static int __devinit azx_probe(struct pci_dev *pci, const struct pci_device_id * return err; } + snd_card_set_pm_callback(card, azx_suspend, azx_resume, chip); snd_card_set_dev(card, &pci->dev); if ((err = snd_card_register(card)) < 0) { @@ -1602,10 +1619,7 @@ static struct pci_driver driver = { .id_table = azx_ids, .probe = azx_probe, .remove = __devexit_p(azx_remove), -#ifdef CONFIG_PM - .suspend = azx_suspend, - .resume = azx_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_azx_init(void) diff --git a/trunk/sound/pci/hda/hda_local.h b/trunk/sound/pci/hda/hda_local.h index c82d2a72d13e..f51a56f813c8 100644 --- a/trunk/sound/pci/hda/hda_local.h +++ b/trunk/sound/pci/hda/hda_local.h @@ -60,12 +60,12 @@ #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \ HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction) -int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); +int snd_hda_mixer_amp_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo); +int snd_hda_mixer_amp_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol); +int snd_hda_mixer_amp_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol); +int snd_hda_mixer_amp_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo); +int snd_hda_mixer_amp_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol); +int snd_hda_mixer_amp_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol); /* mono switch binding multiple inputs */ #define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \ @@ -78,8 +78,8 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e /* stereo switch binding multiple inputs */ #define HDA_BIND_MUTE(xname,nid,indices,dir) HDA_BIND_MUTE_MONO(xname,nid,3,indices,dir) -int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); +int snd_hda_mixer_bind_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol); +int snd_hda_mixer_bind_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol); int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid); int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); @@ -87,7 +87,7 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); /* * input MUX helper */ -#define HDA_MAX_NUM_INPUTS 16 +#define HDA_MAX_NUM_INPUTS 8 struct hda_input_mux_item { const char *label; unsigned int index; @@ -97,28 +97,11 @@ struct hda_input_mux { struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS]; }; -int snd_hda_input_mux_info(const struct hda_input_mux *imux, struct snd_ctl_elem_info *uinfo); +int snd_hda_input_mux_info(const struct hda_input_mux *imux, snd_ctl_elem_info_t *uinfo); int snd_hda_input_mux_put(struct hda_codec *codec, const struct hda_input_mux *imux, - struct snd_ctl_elem_value *ucontrol, hda_nid_t nid, + snd_ctl_elem_value_t *ucontrol, hda_nid_t nid, unsigned int *cur_val); -/* - * Channel mode helper - */ -struct hda_channel_mode { - int channels; - const struct hda_verb *sequence; -}; - -int snd_hda_ch_mode_info(struct hda_codec *codec, struct snd_ctl_elem_info *uinfo, - const struct hda_channel_mode *chmode, int num_chmodes); -int snd_hda_ch_mode_get(struct hda_codec *codec, struct snd_ctl_elem_value *ucontrol, - const struct hda_channel_mode *chmode, int num_chmodes, - int max_channels); -int snd_hda_ch_mode_put(struct hda_codec *codec, struct snd_ctl_elem_value *ucontrol, - const struct hda_channel_mode *chmode, int num_chmodes, - int *max_channelsp); - /* * Multi-channel / digital-out PCM helper */ @@ -138,11 +121,11 @@ struct hda_multi_out { int snd_hda_multi_out_dig_open(struct hda_codec *codec, struct hda_multi_out *mout); int snd_hda_multi_out_dig_close(struct hda_codec *codec, struct hda_multi_out *mout); int snd_hda_multi_out_analog_open(struct hda_codec *codec, struct hda_multi_out *mout, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int snd_hda_multi_out_analog_prepare(struct hda_codec *codec, struct hda_multi_out *mout, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream); + snd_pcm_substream_t *substream); int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec, struct hda_multi_out *mout); /* @@ -170,13 +153,13 @@ struct hda_board_config { }; int snd_hda_check_board_config(struct hda_codec *codec, const struct hda_board_config *tbl); -int snd_hda_add_new_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew); +int snd_hda_add_new_ctls(struct hda_codec *codec, snd_kcontrol_new_t *knew); /* * power management */ #ifdef CONFIG_PM -int snd_hda_resume_ctls(struct hda_codec *codec, struct snd_kcontrol_new *knew); +int snd_hda_resume_ctls(struct hda_codec *codec, snd_kcontrol_new_t *knew); int snd_hda_resume_spdif_out(struct hda_codec *codec); int snd_hda_resume_spdif_in(struct hda_codec *codec); #endif @@ -211,12 +194,9 @@ enum { AUTO_PIN_LAST }; -extern const char *auto_pin_cfg_labels[AUTO_PIN_LAST]; - struct auto_pin_cfg { int line_outs; - hda_nid_t line_out_pins[5]; /* sorted in the order of Front/Surr/CLFE/Side */ - hda_nid_t speaker_pin; + hda_nid_t line_out_pins[4]; /* sorted in the order of Front/Surr/CLFE/Side */ hda_nid_t hp_pin; hda_nid_t input_pins[AUTO_PIN_LAST]; hda_nid_t dig_out_pin; @@ -229,33 +209,6 @@ struct auto_pin_cfg { #define get_defcfg_sequence(cfg) (cfg & AC_DEFCFG_SEQUENCE) #define get_defcfg_device(cfg) ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT) -int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *cfg, - hda_nid_t *ignore_nids); - -/* amp values */ -#define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) -#define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) -#define AMP_OUT_MUTE 0xb080 -#define AMP_OUT_UNMUTE 0xb000 -#define AMP_OUT_ZERO 0xb000 -/* pinctl values */ -#define PIN_IN 0x20 -#define PIN_VREF80 0x24 -#define PIN_VREF50 0x21 -#define PIN_OUT 0x40 -#define PIN_HP 0xc0 -#define PIN_HP_AMP 0x80 - -/* - * get widget capabilities - */ -static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid) -{ - if (nid < codec->start_nid || - nid >= codec->start_nid + codec->num_nodes) - return snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP); - return codec->wcaps[nid - codec->start_nid]; -} - +int snd_hda_parse_pin_def_config(struct hda_codec *codec, struct auto_pin_cfg *cfg); #endif /* __SOUND_HDA_LOCAL_H */ diff --git a/trunk/sound/pci/hda/hda_proc.c b/trunk/sound/pci/hda/hda_proc.c index ca514a6a5875..39ddf1cd9019 100644 --- a/trunk/sound/pci/hda/hda_proc.c +++ b/trunk/sound/pci/hda/hda_proc.c @@ -26,7 +26,6 @@ #include <linux/pci.h> #include <sound/core.h> #include "hda_codec.h" -#include "hda_local.h" static const char *get_wid_type_name(unsigned int wid_value) { @@ -48,7 +47,7 @@ static const char *get_wid_type_name(unsigned int wid_value) return "UNKOWN Widget"; } -static void print_amp_caps(struct snd_info_buffer *buffer, +static void print_amp_caps(snd_info_buffer_t *buffer, struct hda_codec *codec, hda_nid_t nid, int dir) { unsigned int caps; @@ -67,7 +66,7 @@ static void print_amp_caps(struct snd_info_buffer *buffer, (caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT); } -static void print_amp_vals(struct snd_info_buffer *buffer, +static void print_amp_vals(snd_info_buffer_t *buffer, struct hda_codec *codec, hda_nid_t nid, int dir, int stereo, int indices) { @@ -92,7 +91,7 @@ static void print_amp_vals(struct snd_info_buffer *buffer, snd_iprintf(buffer, "\n"); } -static void print_pcm_caps(struct snd_info_buffer *buffer, +static void print_pcm_caps(snd_info_buffer_t *buffer, struct hda_codec *codec, hda_nid_t nid) { unsigned int pcm = snd_hda_param_read(codec, nid, AC_PAR_PCM); @@ -161,7 +160,7 @@ static const char *get_jack_color(u32 cfg) return "UNKNOWN"; } -static void print_pin_caps(struct snd_info_buffer *buffer, +static void print_pin_caps(snd_info_buffer_t *buffer, struct hda_codec *codec, hda_nid_t nid) { static char *jack_conns[4] = { "Jack", "N/A", "Fixed", "Both" }; @@ -195,7 +194,7 @@ static void print_pin_caps(struct snd_info_buffer *buffer, } -static void print_codec_info(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void print_codec_info(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { struct hda_codec *codec = entry->private_data; char buf[32]; @@ -310,7 +309,7 @@ static void print_codec_info(struct snd_info_entry *entry, struct snd_info_buffe int snd_hda_codec_proc_new(struct hda_codec *codec) { char name[32]; - struct snd_info_entry *entry; + snd_info_entry_t *entry; int err; snprintf(name, sizeof(name), "codec#%d", codec->addr); diff --git a/trunk/sound/pci/hda/patch_analog.c b/trunk/sound/pci/hda/patch_analog.c index 1ada1b075c9a..d7d636decef8 100644 --- a/trunk/sound/pci/hda/patch_analog.c +++ b/trunk/sound/pci/hda/patch_analog.c @@ -1,5 +1,5 @@ /* - * HD audio interface patch for AD1981HD, AD1983, AD1986A, AD1988 + * HD audio interface patch for AD1981HD, AD1983, AD1986A * * Copyright (c) 2005 Takashi Iwai <tiwai@suse.de> * @@ -28,10 +28,10 @@ #include "hda_local.h" struct ad198x_spec { - struct snd_kcontrol_new *mixers[5]; + snd_kcontrol_new_t *mixers[5]; int num_mixers; - const struct hda_verb *init_verbs[5]; /* initialization verbs + const struct hda_verb *init_verbs[3]; /* initialization verbs * don't forget NULL termination! */ unsigned int num_init_verbs; @@ -41,7 +41,6 @@ struct ad198x_spec { * max_channels, dacs must be set * dig_out_nid and hp_nid are optional */ - unsigned int cur_eapd; /* capture */ unsigned int num_adc_nids; @@ -50,11 +49,10 @@ struct ad198x_spec { /* capture source */ const struct hda_input_mux *input_mux; - hda_nid_t *capsrc_nids; unsigned int cur_mux[3]; /* channel model */ - const struct hda_channel_mode *channel_mode; + const struct alc_channel_mode *channel_mode; int num_channel_mode; /* PCM information */ @@ -62,19 +60,12 @@ struct ad198x_spec { struct semaphore amp_mutex; /* PCM volume/mute control mutex */ unsigned int spdif_route; - - /* dynamic controls, init_verbs and input_mux */ - struct auto_pin_cfg autocfg; - unsigned int num_kctl_alloc, num_kctl_used; - struct snd_kcontrol_new *kctl_alloc; - struct hda_input_mux private_imux; - hda_nid_t private_dac_nids[4]; }; /* * input MUX handling (common part) */ -static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int ad198x_mux_enum_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *spec = codec->spec; @@ -82,7 +73,7 @@ static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_el return snd_hda_input_mux_info(spec->input_mux, uinfo); } -static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad198x_mux_enum_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *spec = codec->spec; @@ -92,15 +83,14 @@ static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad198x_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *spec = codec->spec; unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, - spec->capsrc_nids[adc_idx], - &spec->cur_mux[adc_idx]); + spec->adc_nids[adc_idx], &spec->cur_mux[adc_idx]); } /* @@ -145,7 +135,7 @@ static int ad198x_build_controls(struct hda_codec *codec) */ static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct ad198x_spec *spec = codec->spec; return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream); @@ -155,7 +145,7 @@ static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct ad198x_spec *spec = codec->spec; return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, @@ -164,7 +154,7 @@ static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo, static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct ad198x_spec *spec = codec->spec; return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); @@ -175,7 +165,7 @@ static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, */ static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct ad198x_spec *spec = codec->spec; return snd_hda_multi_out_dig_open(codec, &spec->multiout); @@ -183,7 +173,7 @@ static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct ad198x_spec *spec = codec->spec; return snd_hda_multi_out_dig_close(codec, &spec->multiout); @@ -196,7 +186,7 @@ static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct ad198x_spec *spec = codec->spec; snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], @@ -206,7 +196,7 @@ static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo, static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct ad198x_spec *spec = codec->spec; snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], @@ -291,14 +281,6 @@ static int ad198x_build_pcms(struct hda_codec *codec) static void ad198x_free(struct hda_codec *codec) { - struct ad198x_spec *spec = codec->spec; - unsigned int i; - - if (spec->kctl_alloc) { - for (i = 0; i < spec->num_kctl_used; i++) - kfree(spec->kctl_alloc[i].name); - kfree(spec->kctl_alloc); - } kfree(codec->spec); } @@ -366,7 +348,7 @@ static struct hda_input_mux ad1986a_capture_source = { #define ad1986a_pcm_amp_vol_info snd_hda_mixer_amp_volume_info -static int ad1986a_pcm_amp_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad1986a_pcm_amp_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *ad = codec->spec; @@ -377,7 +359,7 @@ static int ad1986a_pcm_amp_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int ad1986a_pcm_amp_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad1986a_pcm_amp_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *ad = codec->spec; @@ -395,7 +377,7 @@ static int ad1986a_pcm_amp_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl #define ad1986a_pcm_amp_sw_info snd_hda_mixer_amp_switch_info -static int ad1986a_pcm_amp_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad1986a_pcm_amp_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *ad = codec->spec; @@ -406,7 +388,7 @@ static int ad1986a_pcm_amp_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int ad1986a_pcm_amp_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad1986a_pcm_amp_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *ad = codec->spec; @@ -425,7 +407,7 @@ static int ad1986a_pcm_amp_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ /* * mixers */ -static struct snd_kcontrol_new ad1986a_mixers[] = { +static snd_kcontrol_new_t ad1986a_mixers[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Volume", @@ -553,7 +535,6 @@ static int patch_ad1986a(struct hda_codec *codec) spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT; spec->num_adc_nids = 1; spec->adc_nids = ad1986a_adc_nids; - spec->capsrc_nids = ad1986a_adc_nids; spec->input_mux = &ad1986a_capture_source; spec->num_mixers = 1; spec->mixers[0] = ad1986a_mixers; @@ -589,7 +570,7 @@ static struct hda_input_mux ad1983_capture_source = { /* * SPDIF playback route */ -static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int ad1983_spdif_route_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[] = { "PCM", "ADC" }; @@ -602,7 +583,7 @@ static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad1983_spdif_route_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *spec = codec->spec; @@ -611,7 +592,7 @@ static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int ad1983_spdif_route_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct ad198x_spec *spec = codec->spec; @@ -625,7 +606,7 @@ static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static struct snd_kcontrol_new ad1983_mixers[] = { +static snd_kcontrol_new_t ad1983_mixers[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT), HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT), HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT), @@ -717,7 +698,6 @@ static int patch_ad1983(struct hda_codec *codec) spec->multiout.dig_out_nid = AD1983_SPDIF_OUT; spec->num_adc_nids = 1; spec->adc_nids = ad1983_adc_nids; - spec->capsrc_nids = ad1983_adc_nids; spec->input_mux = &ad1983_capture_source; spec->num_mixers = 1; spec->mixers[0] = ad1983_mixers; @@ -756,7 +736,7 @@ static struct hda_input_mux ad1981_capture_source = { }, }; -static struct snd_kcontrol_new ad1981_mixers[] = { +static snd_kcontrol_new_t ad1981_mixers[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT), HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT), HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT), @@ -863,7 +843,6 @@ static int patch_ad1981(struct hda_codec *codec) spec->multiout.dig_out_nid = AD1981_SPDIF_OUT; spec->num_adc_nids = 1; spec->adc_nids = ad1981_adc_nids; - spec->capsrc_nids = ad1981_adc_nids; spec->input_mux = &ad1981_capture_source; spec->num_mixers = 1; spec->mixers[0] = ad1981_mixers; @@ -877,1272 +856,6 @@ static int patch_ad1981(struct hda_codec *codec) } -/* - * AD1988 - * - * Output pins and routes - * - * Pin Mix Sel DAC (*) - * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06 - * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06 - * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a - * port-D 0x12 (mute/hp) <- 0x29 <- 04 - * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a - * port-F 0x16 (mute) <- 0x2a <- 06 - * port-G 0x24 (mute) <- 0x27 <- 05 - * port-H 0x25 (mute) <- 0x28 <- 0a - * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06 - * - * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah - * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug. - * - * Input pins and routes - * - * pin boost mix input # / adc input # - * port-A 0x11 -> 0x38 -> mix 2, ADC 0 - * port-B 0x14 -> 0x39 -> mix 0, ADC 1 - * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2 - * port-D 0x12 -> 0x3d -> mix 3, ADC 8 - * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4 - * port-F 0x16 -> 0x3b -> mix 5, ADC 3 - * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6 - * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7 - * - * - * DAC assignment - * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03 - * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03 - * - * Inputs of Analog Mix (0x20) - * 0:Port-B (front mic) - * 1:Port-C/G/H (line-in) - * 2:Port-A - * 3:Port-D (line-in/2) - * 4:Port-E/G/H (mic-in) - * 5:Port-F (mic2-in) - * 6:CD - * 7:Beep - * - * ADC selection - * 0:Port-A - * 1:Port-B (front mic-in) - * 2:Port-C (line-in) - * 3:Port-F (mic2-in) - * 4:Port-E (mic-in) - * 5:CD - * 6:Port-G - * 7:Port-H - * 8:Port-D (line-in/2) - * 9:Mix - * - * Proposed pin assignments by the datasheet - * - * 6-stack - * Port-A front headphone - * B front mic-in - * C rear line-in - * D rear front-out - * E rear mic-in - * F rear surround - * G rear CLFE - * H rear side - * - * 3-stack - * Port-A front headphone - * B front mic - * C rear line-in/surround - * D rear front-out - * E rear mic-in/CLFE - * - * laptop - * Port-A headphone - * B mic-in - * C docking station - * D internal speaker (with EAPD) - * E/F quad mic array - */ - - -/* models */ -enum { - AD1988_6STACK, - AD1988_6STACK_DIG, - AD1988_3STACK, - AD1988_3STACK_DIG, - AD1988_LAPTOP, - AD1988_LAPTOP_DIG, - AD1988_AUTO, - AD1988_MODEL_LAST, -}; - -/* reivision id to check workarounds */ -#define AD1988A_REV2 0x100200 - - -/* - * mixers - */ - -static hda_nid_t ad1988_6stack_dac_nids[4] = { - 0x04, 0x06, 0x05, 0x0a -}; - -static hda_nid_t ad1988_3stack_dac_nids[3] = { - 0x04, 0x05, 0x0a -}; - -/* for AD1988A revision-2, DAC2-4 are swapped */ -static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = { - 0x04, 0x05, 0x0a, 0x06 -}; - -static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = { - 0x04, 0x0a, 0x06 -}; - -static hda_nid_t ad1988_adc_nids[3] = { - 0x08, 0x09, 0x0f -}; - -static hda_nid_t ad1988_capsrc_nids[3] = { - 0x0c, 0x0d, 0x0e -}; - -#define AD1988_SPDIF_OUT 0x02 -#define AD1988_SPDIF_IN 0x07 - -static struct hda_input_mux ad1988_6stack_capture_source = { - .num_items = 5, - .items = { - { "Front Mic", 0x0 }, - { "Line", 0x1 }, - { "Mic", 0x4 }, - { "CD", 0x5 }, - { "Mix", 0x9 }, - }, -}; - -static struct hda_input_mux ad1988_laptop_capture_source = { - .num_items = 3, - .items = { - { "Mic/Line", 0x0 }, - { "CD", 0x5 }, - { "Mix", 0x9 }, - }, -}; - -/* - */ -static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - struct ad198x_spec *spec = codec->spec; - return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, - spec->num_channel_mode); -} - -static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - struct ad198x_spec *spec = codec->spec; - return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, - spec->num_channel_mode, spec->multiout.max_channels); -} - -static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - struct ad198x_spec *spec = codec->spec; - return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, - spec->num_channel_mode, &spec->multiout.max_channels); -} - -/* - * EAPD control - */ -static int ad1988_eapd_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; - uinfo->count = 1; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 1; - return 0; -} - -static int ad1988_eapd_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - struct ad198x_spec *spec = codec->spec; - ucontrol->value.enumerated.item[0] = ! spec->cur_eapd; - return 0; -} - -static int ad1988_eapd_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - struct ad198x_spec *spec = codec->spec; - unsigned int eapd; - eapd = ! ucontrol->value.enumerated.item[0]; - if (eapd == spec->cur_eapd && ! codec->in_resume) - return 0; - spec->cur_eapd = eapd; - snd_hda_codec_write(codec, 0x12 /* port-D */, - 0, AC_VERB_SET_EAPD_BTLENABLE, - eapd ? 0x02 : 0x00); - return 0; -} - -/* 6-stack mode */ -static struct snd_kcontrol_new ad1988_6stack_mixers1[] = { - HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT), -}; - -static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = { - HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT), -}; - -static struct snd_kcontrol_new ad1988_6stack_mixers2[] = { - HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT), - HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT), - HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT), - HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT), - HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT), - HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT), - HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), - - HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), - HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), - HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), - HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), - HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT), - HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT), - - HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT), - - HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), - - HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), - - { } /* end */ -}; - -/* 3-stack mode */ -static struct snd_kcontrol_new ad1988_3stack_mixers1[] = { - HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), -}; - -static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = { - HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT), -}; - -static struct snd_kcontrol_new ad1988_3stack_mixers2[] = { - HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT), - HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT), - HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT), - HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT), - HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT), - HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), - - HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), - HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), - HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), - HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), - HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT), - HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT), - - HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT), - - HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), - - HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Channel Mode", - .info = ad198x_ch_mode_info, - .get = ad198x_ch_mode_get, - .put = ad198x_ch_mode_put, - }, - - { } /* end */ -}; - -/* laptop mode */ -static struct snd_kcontrol_new ad1988_laptop_mixers[] = { - HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT), - HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), - - HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), - HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), - HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), - HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), - - HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT), - - HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), - - HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT), - - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "External Amplifier", - .info = ad1988_eapd_info, - .get = ad1988_eapd_get, - .put = ad1988_eapd_put, - }, - - { } /* end */ -}; - -/* capture */ -static struct snd_kcontrol_new ad1988_capture_mixers[] = { - HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* The multiple "Capture Source" controls confuse alsamixer - * So call somewhat different.. - * FIXME: the controls appear in the "playback" view! - */ - /* .name = "Capture Source", */ - .name = "Input Source", - .count = 3, - .info = ad198x_mux_enum_info, - .get = ad198x_mux_enum_get, - .put = ad198x_mux_enum_put, - }, - { } /* end */ -}; - -static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - static char *texts[] = { - "PCM", "ADC1", "ADC2", "ADC3" - }; - uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; - uinfo->count = 1; - uinfo->value.enumerated.items = 4; - if (uinfo->value.enumerated.item >= 4) - uinfo->value.enumerated.item = 3; - strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); - return 0; -} - -static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - unsigned int sel; - - sel = snd_hda_codec_read(codec, 0x02, 0, AC_VERB_GET_CONNECT_SEL, 0); - if (sel > 0) { - sel = snd_hda_codec_read(codec, 0x0b, 0, AC_VERB_GET_CONNECT_SEL, 0); - if (sel <= 3) - sel++; - else - sel = 0; - } - ucontrol->value.enumerated.item[0] = sel; - return 0; -} - -static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - unsigned int sel; - int change; - - sel = snd_hda_codec_read(codec, 0x02, 0, AC_VERB_GET_CONNECT_SEL, 0); - if (! ucontrol->value.enumerated.item[0]) { - change = sel != 0; - if (change) - snd_hda_codec_write(codec, 0x02, 0, AC_VERB_SET_CONNECT_SEL, 0); - } else { - change = sel == 0; - if (change) - snd_hda_codec_write(codec, 0x02, 0, AC_VERB_SET_CONNECT_SEL, 1); - sel = snd_hda_codec_read(codec, 0x0b, 0, AC_VERB_GET_CONNECT_SEL, 0) + 1; - change |= sel == ucontrol->value.enumerated.item[0]; - if (change) - snd_hda_codec_write(codec, 0x02, 0, AC_VERB_SET_CONNECT_SEL, - ucontrol->value.enumerated.item[0] - 1); - } - return change; -} - -static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = { - HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "IEC958 Playback Source", - .info = ad1988_spdif_playback_source_info, - .get = ad1988_spdif_playback_source_get, - .put = ad1988_spdif_playback_source_put, - }, - { } /* end */ -}; - -static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = { - HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT), - { } /* end */ -}; - - -/* - * initialization verbs - */ - -/* - * for 6-stack (+dig) - */ -static struct hda_verb ad1988_6stack_init_verbs[] = { - /* Front, Surround, CLFE, side DAC; unmute as default */ - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* Port-A front headphon path */ - {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, - /* Port-D line-out path */ - {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - /* Port-F surround path */ - {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - /* Port-G CLFE path */ - {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - /* Port-H side path */ - {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - /* Mono out path */ - {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ - {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ - /* Port-B front mic-in path */ - {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, - {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - /* Port-C line-in path */ - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, - {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, - /* Port-E mic-in path */ - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, - {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x34, AC_VERB_SET_CONNECT_SEL, 0x0}, - - { } -}; - -static struct hda_verb ad1988_capture_init_verbs[] = { - /* mute analog mix */ - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, - /* select ADCs - front-mic */ - {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, - {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, - {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, - /* ADCs; muted */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - - { } -}; - -static struct hda_verb ad1988_spdif_init_verbs[] = { - /* SPDIF out sel */ - {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */ - {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */ - {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - /* SPDIF out pin */ - {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ - {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x17}, /* 0dB */ - - { } -}; - -/* - * verbs for 3stack (+dig) - */ -static struct hda_verb ad1988_3stack_ch2_init[] = { - /* set port-C to line-in */ - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, - { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, - /* set port-E to mic-in */ - { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, - { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, - { } /* end */ -}; - -static struct hda_verb ad1988_3stack_ch6_init[] = { - /* set port-C to surround out */ - { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, - /* set port-E to CLFE out */ - { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, - { } /* end */ -}; - -static struct hda_channel_mode ad1988_3stack_modes[2] = { - { 2, ad1988_3stack_ch2_init }, - { 6, ad1988_3stack_ch6_init }, -}; - -static struct hda_verb ad1988_3stack_init_verbs[] = { - /* Front, Surround, CLFE, side DAC; unmute as default */ - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* Port-A front headphon path */ - {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, - /* Port-D line-out path */ - {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - /* Mono out path */ - {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ - {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ - /* Port-B front mic-in path */ - {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, - {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - /* Port-C line-in/surround path - 6ch mode as default */ - {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */ - {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, - /* Port-E mic-in/CLFE path - 6ch mode as default */ - {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */ - {0x34, AC_VERB_SET_CONNECT_SEL, 0x0}, - /* mute analog mix */ - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, - /* select ADCs - front-mic */ - {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, - {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, - {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, - /* ADCs; muted */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - { } -}; - -/* - * verbs for laptop mode (+dig) - */ -static struct hda_verb ad1988_laptop_hp_on[] = { - /* unmute port-A and mute port-D */ - { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, - { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, - { } /* end */ -}; -static struct hda_verb ad1988_laptop_hp_off[] = { - /* mute port-A and unmute port-D */ - { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, - { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, - { } /* end */ -}; - -#define AD1988_HP_EVENT 0x01 - -static struct hda_verb ad1988_laptop_init_verbs[] = { - /* Front, Surround, CLFE, side DAC; unmute as default */ - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* Port-A front headphon path */ - {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, - /* unsolicited event for pin-sense */ - {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT }, - /* Port-D line-out path + EAPD */ - {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */ - /* Mono out path */ - {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ - {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ - /* Port-B mic-in path */ - {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, - {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - /* Port-C docking station - try to output */ - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, - /* mute analog mix */ - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, - {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, - /* select ADCs - mic */ - {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, - {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, - {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, - /* ADCs; muted */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - { } -}; - -static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res) -{ - if ((res >> 26) != AD1988_HP_EVENT) - return; - if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31)) - snd_hda_sequence_write(codec, ad1988_laptop_hp_on); - else - snd_hda_sequence_write(codec, ad1988_laptop_hp_off); -} - - -/* - * Automatic parse of I/O pins from the BIOS configuration - */ - -#define NUM_CONTROL_ALLOC 32 -#define NUM_VERB_ALLOC 32 - -enum { - AD_CTL_WIDGET_VOL, - AD_CTL_WIDGET_MUTE, - AD_CTL_BIND_MUTE, -}; -static struct snd_kcontrol_new ad1988_control_templates[] = { - HDA_CODEC_VOLUME(NULL, 0, 0, 0), - HDA_CODEC_MUTE(NULL, 0, 0, 0), - HDA_BIND_MUTE(NULL, 0, 0, 0), -}; - -/* add dynamic controls */ -static int add_control(struct ad198x_spec *spec, int type, const char *name, - unsigned long val) -{ - struct snd_kcontrol_new *knew; - - if (spec->num_kctl_used >= spec->num_kctl_alloc) { - int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; - - knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */ - if (! knew) - return -ENOMEM; - if (spec->kctl_alloc) { - memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc); - kfree(spec->kctl_alloc); - } - spec->kctl_alloc = knew; - spec->num_kctl_alloc = num; - } - - knew = &spec->kctl_alloc[spec->num_kctl_used]; - *knew = ad1988_control_templates[type]; - knew->name = kstrdup(name, GFP_KERNEL); - if (! knew->name) - return -ENOMEM; - knew->private_value = val; - spec->num_kctl_used++; - return 0; -} - -#define AD1988_PIN_CD_NID 0x18 -#define AD1988_PIN_BEEP_NID 0x10 - -static hda_nid_t ad1988_mixer_nids[8] = { - /* A B C D E F G H */ - 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28 -}; - -static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx) -{ - static hda_nid_t idx_to_dac[8] = { - /* A B C D E F G H */ - 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a - }; - static hda_nid_t idx_to_dac_rev2[8] = { - /* A B C D E F G H */ - 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06 - }; - if (codec->revision_id == AD1988A_REV2) - return idx_to_dac_rev2[idx]; - else - return idx_to_dac[idx]; -} - -static hda_nid_t ad1988_boost_nids[8] = { - 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0 -}; - -static int ad1988_pin_idx(hda_nid_t nid) -{ - static hda_nid_t ad1988_io_pins[8] = { - 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25 - }; - int i; - for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++) - if (ad1988_io_pins[i] == nid) - return i; - return 0; /* should be -1 */ -} - -static int ad1988_pin_to_loopback_idx(hda_nid_t nid) -{ - static int loopback_idx[8] = { - 2, 0, 1, 3, 4, 5, 1, 4 - }; - switch (nid) { - case AD1988_PIN_CD_NID: - return 6; - default: - return loopback_idx[ad1988_pin_idx(nid)]; - } -} - -static int ad1988_pin_to_adc_idx(hda_nid_t nid) -{ - static int adc_idx[8] = { - 0, 1, 2, 8, 4, 3, 6, 7 - }; - switch (nid) { - case AD1988_PIN_CD_NID: - return 5; - default: - return adc_idx[ad1988_pin_idx(nid)]; - } -} - -/* fill in the dac_nids table from the parsed pin configuration */ -static int ad1988_auto_fill_dac_nids(struct hda_codec *codec, - const struct auto_pin_cfg *cfg) -{ - struct ad198x_spec *spec = codec->spec; - int i, idx; - - spec->multiout.dac_nids = spec->private_dac_nids; - - /* check the pins hardwired to audio widget */ - for (i = 0; i < cfg->line_outs; i++) { - idx = ad1988_pin_idx(cfg->line_out_pins[i]); - spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx); - } - spec->multiout.num_dacs = cfg->line_outs; - return 0; -} - -/* add playback controls from the parsed DAC table */ -static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec, - const struct auto_pin_cfg *cfg) -{ - char name[32]; - static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" }; - hda_nid_t nid; - int i, err; - - for (i = 0; i < cfg->line_outs; i++) { - hda_nid_t dac = spec->multiout.dac_nids[i]; - if (! dac) - continue; - nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])]; - if (i == 2) { - /* Center/LFE */ - err = add_control(spec, AD_CTL_WIDGET_VOL, - "Center Playback Volume", - HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT)); - if (err < 0) - return err; - err = add_control(spec, AD_CTL_WIDGET_VOL, - "LFE Playback Volume", - HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT)); - if (err < 0) - return err; - err = add_control(spec, AD_CTL_BIND_MUTE, - "Center Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT)); - if (err < 0) - return err; - err = add_control(spec, AD_CTL_BIND_MUTE, - "LFE Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT)); - if (err < 0) - return err; - } else { - sprintf(name, "%s Playback Volume", chname[i]); - err = add_control(spec, AD_CTL_WIDGET_VOL, name, - HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT)); - if (err < 0) - return err; - sprintf(name, "%s Playback Switch", chname[i]); - err = add_control(spec, AD_CTL_BIND_MUTE, name, - HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); - if (err < 0) - return err; - } - } - return 0; -} - -/* add playback controls for speaker and HP outputs */ -static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, - const char *pfx) -{ - struct ad198x_spec *spec = codec->spec; - hda_nid_t nid; - int idx, err; - char name[32]; - - if (! pin) - return 0; - - idx = ad1988_pin_idx(pin); - nid = ad1988_idx_to_dac(codec, idx); - if (! spec->multiout.dac_nids[0]) { - /* use this as the primary output */ - spec->multiout.dac_nids[0] = nid; - if (! spec->multiout.num_dacs) - spec->multiout.num_dacs = 1; - } else - /* specify the DAC as the extra output */ - spec->multiout.hp_nid = nid; - /* control HP volume/switch on the output mixer amp */ - sprintf(name, "%s Playback Volume", pfx); - if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name, - HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) - return err; - nid = ad1988_mixer_nids[idx]; - sprintf(name, "%s Playback Switch", pfx); - if ((err = add_control(spec, AD_CTL_BIND_MUTE, name, - HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0) - return err; - return 0; -} - -/* create input playback/capture controls for the given pin */ -static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin, - const char *ctlname, int boost) -{ - char name[32]; - int err, idx; - - sprintf(name, "%s Playback Volume", ctlname); - idx = ad1988_pin_to_loopback_idx(pin); - if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name, - HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0) - return err; - sprintf(name, "%s Playback Switch", ctlname); - if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name, - HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0) - return err; - if (boost) { - hda_nid_t bnid; - idx = ad1988_pin_idx(pin); - bnid = ad1988_boost_nids[idx]; - if (bnid) { - sprintf(name, "%s Boost", ctlname); - return add_control(spec, AD_CTL_WIDGET_VOL, name, - HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT)); - - } - } - return 0; -} - -/* create playback/capture controls for input pins */ -static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec, - const struct auto_pin_cfg *cfg) -{ - struct hda_input_mux *imux = &spec->private_imux; - int i, err; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - err = new_analog_input(spec, cfg->input_pins[i], - auto_pin_cfg_labels[i], - i <= AUTO_PIN_FRONT_MIC); - if (err < 0) - return err; - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; - imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]); - imux->num_items++; - } - imux->items[imux->num_items].label = "Mix"; - imux->items[imux->num_items].index = 9; - imux->num_items++; - - if ((err = add_control(spec, AD_CTL_WIDGET_VOL, - "Analog Mix Playback Volume", - HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0) - return err; - if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, - "Analog Mix Playback Switch", - HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0) - return err; - - return 0; -} - -static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec, - hda_nid_t nid, int pin_type, - int dac_idx) -{ - /* set as output */ - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); - switch (nid) { - case 0x11: /* port-A - DAC 04 */ - snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01); - break; - case 0x14: /* port-B - DAC 06 */ - snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02); - break; - case 0x15: /* port-C - DAC 05 */ - snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00); - break; - case 0x17: /* port-E - DAC 0a */ - snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01); - break; - case 0x13: /* mono - DAC 04 */ - snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01); - break; - } -} - -static void ad1988_auto_init_multi_out(struct hda_codec *codec) -{ - struct ad198x_spec *spec = codec->spec; - int i; - - for (i = 0; i < spec->autocfg.line_outs; i++) { - hda_nid_t nid = spec->autocfg.line_out_pins[i]; - ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); - } -} - -static void ad1988_auto_init_extra_out(struct hda_codec *codec) -{ - struct ad198x_spec *spec = codec->spec; - hda_nid_t pin; - - pin = spec->autocfg.speaker_pin; - if (pin) /* connect to front */ - ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); - pin = spec->autocfg.hp_pin; - if (pin) /* connect to front */ - ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); -} - -static void ad1988_auto_init_analog_input(struct hda_codec *codec) -{ - struct ad198x_spec *spec = codec->spec; - int i, idx; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if (! nid) - continue; - switch (nid) { - case 0x15: /* port-C */ - snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0); - break; - case 0x17: /* port-E */ - snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0); - break; - } - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, - i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN); - if (nid != AD1988_PIN_CD_NID) - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, - AMP_OUT_MUTE); - idx = ad1988_pin_idx(nid); - if (ad1988_boost_nids[idx]) - snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0, - AC_VERB_SET_AMP_GAIN_MUTE, - AMP_OUT_ZERO); - } -} - -/* parse the BIOS configuration and set up the alc_spec */ -/* return 1 if successful, 0 if the proper config is not found, or a negative error code */ -static int ad1988_parse_auto_config(struct hda_codec *codec) -{ - struct ad198x_spec *spec = codec->spec; - int err; - - if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) - return err; - if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0) - return err; - if (! spec->autocfg.line_outs && ! spec->autocfg.speaker_pin && - ! spec->autocfg.hp_pin) - return 0; /* can't find valid BIOS pin config */ - if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || - (err = ad1988_auto_create_extra_out(codec, spec->autocfg.speaker_pin, - "Speaker")) < 0 || - (err = ad1988_auto_create_extra_out(codec, spec->autocfg.speaker_pin, - "Headphone")) < 0 || - (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) - return err; - - spec->multiout.max_channels = spec->multiout.num_dacs * 2; - - if (spec->autocfg.dig_out_pin) - spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; - if (spec->autocfg.dig_in_pin) - spec->dig_in_nid = AD1988_SPDIF_IN; - - if (spec->kctl_alloc) - spec->mixers[spec->num_mixers++] = spec->kctl_alloc; - - spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs; - - spec->input_mux = &spec->private_imux; - - return 1; -} - -/* init callback for auto-configuration model -- overriding the default init */ -static int ad1988_auto_init(struct hda_codec *codec) -{ - ad198x_init(codec); - ad1988_auto_init_multi_out(codec); - ad1988_auto_init_extra_out(codec); - ad1988_auto_init_analog_input(codec); - return 0; -} - - -/* - */ - -static struct hda_board_config ad1988_cfg_tbl[] = { - { .modelname = "6stack", .config = AD1988_6STACK }, - { .modelname = "6stack-dig", .config = AD1988_6STACK_DIG }, - { .modelname = "3stack", .config = AD1988_3STACK }, - { .modelname = "3stack-dig", .config = AD1988_3STACK_DIG }, - { .modelname = "laptop", .config = AD1988_LAPTOP }, - { .modelname = "laptop-dig", .config = AD1988_LAPTOP_DIG }, - { .modelname = "auto", .config = AD1988_AUTO }, - {} -}; - -static int patch_ad1988(struct hda_codec *codec) -{ - struct ad198x_spec *spec; - int board_config; - - spec = kzalloc(sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - init_MUTEX(&spec->amp_mutex); - codec->spec = spec; - - if (codec->revision_id == AD1988A_REV2) - snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n"); - - board_config = snd_hda_check_board_config(codec, ad1988_cfg_tbl); - if (board_config < 0 || board_config >= AD1988_MODEL_LAST) { - printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n"); - board_config = AD1988_AUTO; - } - - if (board_config == AD1988_AUTO) { - /* automatic parse from the BIOS config */ - int err = ad1988_parse_auto_config(codec); - if (err < 0) { - ad198x_free(codec); - return err; - } else if (! err) { - printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n"); - board_config = AD1988_6STACK; - } - } - - switch (board_config) { - case AD1988_6STACK: - case AD1988_6STACK_DIG: - spec->multiout.max_channels = 8; - spec->multiout.num_dacs = 4; - if (codec->revision_id == AD1988A_REV2) - spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2; - else - spec->multiout.dac_nids = ad1988_6stack_dac_nids; - spec->input_mux = &ad1988_6stack_capture_source; - spec->num_mixers = 2; - if (codec->revision_id == AD1988A_REV2) - spec->mixers[0] = ad1988_6stack_mixers1_rev2; - else - spec->mixers[0] = ad1988_6stack_mixers1; - spec->mixers[1] = ad1988_6stack_mixers2; - spec->num_init_verbs = 1; - spec->init_verbs[0] = ad1988_6stack_init_verbs; - if (board_config == AD1988_6STACK_DIG) { - spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; - spec->dig_in_nid = AD1988_SPDIF_IN; - } - break; - case AD1988_3STACK: - case AD1988_3STACK_DIG: - spec->multiout.max_channels = 6; - spec->multiout.num_dacs = 3; - if (codec->revision_id == AD1988A_REV2) - spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2; - else - spec->multiout.dac_nids = ad1988_3stack_dac_nids; - spec->input_mux = &ad1988_6stack_capture_source; - spec->channel_mode = ad1988_3stack_modes; - spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes); - spec->num_mixers = 2; - if (codec->revision_id == AD1988A_REV2) - spec->mixers[0] = ad1988_3stack_mixers1_rev2; - else - spec->mixers[0] = ad1988_3stack_mixers1; - spec->mixers[1] = ad1988_3stack_mixers2; - spec->num_init_verbs = 1; - spec->init_verbs[0] = ad1988_3stack_init_verbs; - if (board_config == AD1988_3STACK_DIG) - spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; - break; - case AD1988_LAPTOP: - case AD1988_LAPTOP_DIG: - spec->multiout.max_channels = 2; - spec->multiout.num_dacs = 1; - spec->multiout.dac_nids = ad1988_3stack_dac_nids; - spec->input_mux = &ad1988_laptop_capture_source; - spec->num_mixers = 1; - spec->mixers[0] = ad1988_laptop_mixers; - spec->num_init_verbs = 1; - spec->init_verbs[0] = ad1988_laptop_init_verbs; - if (board_config == AD1988_LAPTOP_DIG) - spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; - break; - } - - spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids); - spec->adc_nids = ad1988_adc_nids; - spec->capsrc_nids = ad1988_capsrc_nids; - spec->mixers[spec->num_mixers++] = ad1988_capture_mixers; - spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs; - if (spec->multiout.dig_out_nid) { - spec->mixers[spec->num_mixers++] = ad1988_spdif_out_mixers; - spec->init_verbs[spec->num_init_verbs++] = ad1988_spdif_init_verbs; - } - if (spec->dig_in_nid) - spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers; - - codec->patch_ops = ad198x_patch_ops; - switch (board_config) { - case AD1988_AUTO: - codec->patch_ops.init = ad1988_auto_init; - break; - case AD1988_LAPTOP: - case AD1988_LAPTOP_DIG: - codec->patch_ops.unsol_event = ad1988_laptop_unsol_event; - break; - } - - return 0; -} - - /* * patch entries */ @@ -2150,6 +863,5 @@ struct hda_codec_preset snd_hda_preset_analog[] = { { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 }, { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 }, { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a }, - { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 }, {} /* terminator */ }; diff --git a/trunk/sound/pci/hda/patch_cmedia.c b/trunk/sound/pci/hda/patch_cmedia.c index d38ce22507ae..523c362ec44d 100644 --- a/trunk/sound/pci/hda/patch_cmedia.c +++ b/trunk/sound/pci/hda/patch_cmedia.c @@ -44,6 +44,7 @@ enum { struct cmi_spec { int board_config; + unsigned int surr_switch: 1; /* switchable line,mic */ unsigned int no_line_in: 1; /* no line-in (5-jack) */ unsigned int front_panel: 1; /* has front-panel 2-jack */ @@ -61,8 +62,9 @@ struct cmi_spec { unsigned int cur_mux[2]; /* channel mode */ - int num_channel_modes; - const struct hda_channel_mode *channel_modes; + unsigned int num_ch_modes; + unsigned int cur_ch_mode; + const struct cmi_channel_mode *channel_modes; struct hda_pcm pcm_rec[2]; /* PCM information */ @@ -76,17 +78,30 @@ struct cmi_spec { struct hda_verb multi_init[9]; /* 2 verbs for each pin + terminator */ }; +/* amp values */ +#define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) +#define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) +#define AMP_OUT_MUTE 0xb080 +#define AMP_OUT_UNMUTE 0xb000 +#define AMP_OUT_ZERO 0xb000 +/* pinctl values */ +#define PIN_IN 0x20 +#define PIN_VREF80 0x24 +#define PIN_VREF50 0x21 +#define PIN_OUT 0x40 +#define PIN_HP 0xc0 + /* * input MUX */ -static int cmi_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int cmi_mux_enum_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct cmi_spec *spec = codec->spec; return snd_hda_input_mux_info(spec->input_mux, uinfo); } -static int cmi_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cmi_mux_enum_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct cmi_spec *spec = codec->spec; @@ -96,7 +111,7 @@ static int cmi_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return 0; } -static int cmi_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cmi_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct cmi_spec *spec = codec->spec; @@ -143,39 +158,63 @@ static struct hda_verb cmi9880_ch8_init[] = { {} }; -static struct hda_channel_mode cmi9880_channel_modes[3] = { +struct cmi_channel_mode { + unsigned int channels; + const struct hda_verb *sequence; +}; + +static struct cmi_channel_mode cmi9880_channel_modes[3] = { { 2, cmi9880_ch2_init }, { 6, cmi9880_ch6_init }, { 8, cmi9880_ch8_init }, }; -static int cmi_ch_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int cmi_ch_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct cmi_spec *spec = codec->spec; - return snd_hda_ch_mode_info(codec, uinfo, spec->channel_modes, - spec->num_channel_modes); + + snd_assert(spec->channel_modes, return -EINVAL); + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; + uinfo->count = 1; + uinfo->value.enumerated.items = spec->num_ch_modes; + if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) + uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; + sprintf(uinfo->value.enumerated.name, "%dch", + spec->channel_modes[uinfo->value.enumerated.item].channels); + return 0; } -static int cmi_ch_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cmi_ch_mode_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct cmi_spec *spec = codec->spec; - return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_modes, - spec->num_channel_modes, spec->multiout.max_channels); + + ucontrol->value.enumerated.item[0] = spec->cur_ch_mode; + return 0; } -static int cmi_ch_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cmi_ch_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct cmi_spec *spec = codec->spec; - return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_modes, - spec->num_channel_modes, &spec->multiout.max_channels); + + snd_assert(spec->channel_modes, return -EINVAL); + if (ucontrol->value.enumerated.item[0] >= spec->num_ch_modes) + ucontrol->value.enumerated.item[0] = spec->num_ch_modes; + if (ucontrol->value.enumerated.item[0] == spec->cur_ch_mode && + ! codec->in_resume) + return 0; + + spec->cur_ch_mode = ucontrol->value.enumerated.item[0]; + snd_hda_sequence_write(codec, spec->channel_modes[spec->cur_ch_mode].sequence); + spec->multiout.max_channels = spec->channel_modes[spec->cur_ch_mode].channels; + return 1; } /* */ -static struct snd_kcontrol_new cmi9880_basic_mixer[] = { +static snd_kcontrol_new_t cmi9880_basic_mixer[] = { /* CMI9880 has no playback volumes! */ HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT), /* front */ HDA_CODEC_MUTE("Surround Playback Switch", 0x04, 0x0, HDA_OUTPUT), @@ -207,7 +246,7 @@ static struct snd_kcontrol_new cmi9880_basic_mixer[] = { /* * shared I/O pins */ -static struct snd_kcontrol_new cmi9880_ch_mode_mixer[] = { +static snd_kcontrol_new_t cmi9880_ch_mode_mixer[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Channel Mode", @@ -322,7 +361,7 @@ static int cmi9880_build_controls(struct hda_codec *codec) err = snd_hda_add_new_ctls(codec, cmi9880_basic_mixer); if (err < 0) return err; - if (spec->channel_modes) { + if (spec->surr_switch) { err = snd_hda_add_new_ctls(codec, cmi9880_ch_mode_mixer); if (err < 0) return err; @@ -436,7 +475,7 @@ static int cmi9880_resume(struct hda_codec *codec) cmi9880_init(codec); snd_hda_resume_ctls(codec, cmi9880_basic_mixer); - if (spec->channel_modes) + if (spec->surr_switch) snd_hda_resume_ctls(codec, cmi9880_ch_mode_mixer); if (spec->multiout.dig_out_nid) snd_hda_resume_spdif_out(codec); @@ -452,7 +491,7 @@ static int cmi9880_resume(struct hda_codec *codec) */ static int cmi9880_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct cmi_spec *spec = codec->spec; return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream); @@ -462,7 +501,7 @@ static int cmi9880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct cmi_spec *spec = codec->spec; return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, @@ -471,7 +510,7 @@ static int cmi9880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, static int cmi9880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct cmi_spec *spec = codec->spec; return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); @@ -482,7 +521,7 @@ static int cmi9880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, */ static int cmi9880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct cmi_spec *spec = codec->spec; return snd_hda_multi_out_dig_open(codec, &spec->multiout); @@ -490,7 +529,7 @@ static int cmi9880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, static int cmi9880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct cmi_spec *spec = codec->spec; return snd_hda_multi_out_dig_close(codec, &spec->multiout); @@ -503,7 +542,7 @@ static int cmi9880_capture_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct cmi_spec *spec = codec->spec; @@ -514,7 +553,7 @@ static int cmi9880_capture_pcm_prepare(struct hda_pcm_stream *hinfo, static int cmi9880_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct cmi_spec *spec = codec->spec; @@ -646,13 +685,14 @@ static int patch_cmi9880(struct hda_codec *codec) switch (spec->board_config) { case CMI_MINIMAL: case CMI_MIN_FP: - spec->channel_modes = cmi9880_channel_modes; + spec->surr_switch = 1; if (spec->board_config == CMI_MINIMAL) - spec->num_channel_modes = 2; + spec->num_ch_modes = 2; else { spec->front_panel = 1; - spec->num_channel_modes = 3; + spec->num_ch_modes = 3; } + spec->channel_modes = cmi9880_channel_modes; spec->multiout.max_channels = cmi9880_channel_modes[0].channels; spec->input_mux = &cmi9880_basic_mux; break; @@ -687,18 +727,19 @@ static int patch_cmi9880(struct hda_codec *codec) get_defcfg_connect(port_f) == AC_JACK_PORT_NONE) { port_g = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_CONFIG_DEFAULT, 0); port_h = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_CONFIG_DEFAULT, 0); - spec->channel_modes = cmi9880_channel_modes; + spec->surr_switch = 1; /* no front panel */ if (get_defcfg_connect(port_g) == AC_JACK_PORT_NONE || get_defcfg_connect(port_h) == AC_JACK_PORT_NONE) { /* no optional rear panel */ spec->board_config = CMI_MINIMAL; spec->front_panel = 0; - spec->num_channel_modes = 2; + spec->num_ch_modes = 2; } else { spec->board_config = CMI_MIN_FP; - spec->num_channel_modes = 3; + spec->num_ch_modes = 3; } + spec->channel_modes = cmi9880_channel_modes; spec->input_mux = &cmi9880_basic_mux; spec->multiout.max_channels = cmi9880_channel_modes[0].channels; } else { @@ -711,7 +752,7 @@ static int patch_cmi9880(struct hda_codec *codec) spec->dig_in_nid = CMI_DIG_IN_NID; spec->multiout.max_channels = 8; } - snd_hda_parse_pin_def_config(codec, &cfg, NULL); + snd_hda_parse_pin_def_config(codec, &cfg); if (cfg.line_outs) { spec->multiout.max_channels = cfg.line_outs * 2; cmi9880_fill_multi_dac_nids(codec, &cfg); diff --git a/trunk/sound/pci/hda/patch_realtek.c b/trunk/sound/pci/hda/patch_realtek.c index ad9e501a9818..cffb83fdcff7 100644 --- a/trunk/sound/pci/hda/patch_realtek.c +++ b/trunk/sound/pci/hda/patch_realtek.c @@ -3,8 +3,7 @@ * * HD audio interface patch for ALC 260/880/882 codecs * - * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw> - * PeiSen Hou <pshou@realtek.com.tw> + * Copyright (c) 2004 PeiSen Hou <pshou@realtek.com.tw> * Takashi Iwai <tiwai@suse.de> * * This driver is free software; you can redistribute it and/or modify @@ -40,20 +39,17 @@ enum { ALC880_5ST_DIG, ALC880_W810, ALC880_Z71V, + ALC880_AUTO, ALC880_6ST, ALC880_6ST_DIG, ALC880_F1734, ALC880_ASUS, ALC880_ASUS_DIG, ALC880_ASUS_W1V, - ALC880_ASUS_DIG2, ALC880_UNIWILL_DIG, - ALC880_CLEVO, - ALC880_TCL_S700, #ifdef CONFIG_SND_DEBUG ALC880_TEST, #endif - ALC880_AUTO, ALC880_MODEL_LAST /* last tag */ }; @@ -61,45 +57,30 @@ enum { enum { ALC260_BASIC, ALC260_HP, - ALC260_HP_3013, - ALC260_FUJITSU_S702X, - ALC260_AUTO, + ALC260_FUJITSU_S702x, ALC260_MODEL_LAST /* last tag */ }; -/* ALC262 models */ -enum { - ALC262_BASIC, - ALC262_AUTO, - ALC262_MODEL_LAST /* last tag */ -}; - -/* ALC861 models */ -enum { - ALC861_3ST, - ALC861_3ST_DIG, - ALC861_6ST_DIG, - ALC861_AUTO, - ALC861_MODEL_LAST, -}; - -/* ALC882 models */ -enum { - ALC882_3ST_DIG, - ALC882_6ST_DIG, - ALC882_AUTO, - ALC882_MODEL_LAST, -}; - -/* for GPIO Poll */ -#define GPIO_MASK 0x03 +/* amp values */ +#define AMP_IN_MUTE(idx) (0x7080 | ((idx)<<8)) +#define AMP_IN_UNMUTE(idx) (0x7000 | ((idx)<<8)) +#define AMP_OUT_MUTE 0xb080 +#define AMP_OUT_UNMUTE 0xb000 +#define AMP_OUT_ZERO 0xb000 +/* pinctl values */ +#define PIN_IN 0x20 +#define PIN_VREF80 0x24 +#define PIN_VREF50 0x21 +#define PIN_OUT 0x40 +#define PIN_HP 0xc0 +#define PIN_HP_AMP 0x80 struct alc_spec { /* codec parameterization */ - struct snd_kcontrol_new *mixers[5]; /* mixer arrays */ + snd_kcontrol_new_t *mixers[3]; /* mixer arrays */ unsigned int num_mixers; - const struct hda_verb *init_verbs[5]; /* initialization verbs + const struct hda_verb *init_verbs[3]; /* initialization verbs * don't forget NULL termination! */ unsigned int num_init_verbs; @@ -128,7 +109,7 @@ struct alc_spec { unsigned int cur_mux[3]; /* channel model */ - const struct hda_channel_mode *channel_mode; + const struct alc_channel_mode *channel_mode; int num_channel_mode; /* PCM information */ @@ -137,41 +118,23 @@ struct alc_spec { /* dynamic controls, init_verbs and input_mux */ struct auto_pin_cfg autocfg; unsigned int num_kctl_alloc, num_kctl_used; - struct snd_kcontrol_new *kctl_alloc; + snd_kcontrol_new_t *kctl_alloc; struct hda_input_mux private_imux; - hda_nid_t private_dac_nids[5]; -}; - -/* - * configuration template - to be copied to the spec instance - */ -struct alc_config_preset { - struct snd_kcontrol_new *mixers[5]; /* should be identical size with spec */ - const struct hda_verb *init_verbs[5]; - unsigned int num_dacs; - hda_nid_t *dac_nids; - hda_nid_t dig_out_nid; /* optional */ - hda_nid_t hp_nid; /* optional */ - unsigned int num_adc_nids; - hda_nid_t *adc_nids; - hda_nid_t dig_in_nid; - unsigned int num_channel_mode; - const struct hda_channel_mode *channel_mode; - const struct hda_input_mux *input_mux; + hda_nid_t private_dac_nids[4]; }; /* * input MUX handling */ -static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int alc_mux_enum_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct alc_spec *spec = codec->spec; return snd_hda_input_mux_info(spec->input_mux, uinfo); } -static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_mux_enum_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct alc_spec *spec = codec->spec; @@ -181,7 +144,7 @@ static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return 0; } -static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct alc_spec *spec = codec->spec; @@ -194,28 +157,63 @@ static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v /* * channel mode setting */ -static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +struct alc_channel_mode { + int channels; + const struct hda_verb *sequence; +}; + +static int alc880_ch_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct alc_spec *spec = codec->spec; - return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, - spec->num_channel_mode); + int items = kcontrol->private_value ? (int)kcontrol->private_value : 2; + + snd_assert(spec->channel_mode, return -ENXIO); + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; + uinfo->count = 1; + uinfo->value.enumerated.items = items; + if (uinfo->value.enumerated.item >= items) + uinfo->value.enumerated.item = items - 1; + sprintf(uinfo->value.enumerated.name, "%dch", + spec->channel_mode[uinfo->value.enumerated.item].channels); + return 0; } -static int alc_ch_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc880_ch_mode_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct alc_spec *spec = codec->spec; - return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, - spec->num_channel_mode, spec->multiout.max_channels); + int items = kcontrol->private_value ? (int)kcontrol->private_value : 2; + int i; + + snd_assert(spec->channel_mode, return -ENXIO); + for (i = 0; i < items; i++) { + if (spec->multiout.max_channels == spec->channel_mode[i].channels) { + ucontrol->value.enumerated.item[0] = i; + break; + } + } + return 0; } -static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc880_ch_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct alc_spec *spec = codec->spec; - return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, - spec->num_channel_mode, &spec->multiout.max_channels); + int mode; + + snd_assert(spec->channel_mode, return -ENXIO); + mode = ucontrol->value.enumerated.item[0] ? 1 : 0; + if (spec->multiout.max_channels == spec->channel_mode[mode].channels && + ! codec->in_resume) + return 0; + + /* change the current channel setting */ + spec->multiout.max_channels = spec->channel_mode[mode].channels; + if (spec->channel_mode[mode].sequence) + snd_hda_sequence_write(codec, spec->channel_mode[mode].sequence); + + return 1; } @@ -224,7 +222,7 @@ static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va * supported, so VrefEn can't be controlled using these functions as they * stand. */ -static int alc_pinctl_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int alc_pinctl_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -233,7 +231,7 @@ static int alc_pinctl_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int alc_pinctl_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_pinctl_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = kcontrol->private_value & 0xffff; @@ -246,7 +244,7 @@ static int alc_pinctl_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int alc_pinctl_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_pinctl_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = kcontrol->private_value & 0xffff; @@ -268,36 +266,6 @@ static int alc_pinctl_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e .put = alc_pinctl_switch_put, \ .private_value = (nid) | (mask<<16) } - -/* - * set up from the preset table - */ -static void setup_preset(struct alc_spec *spec, const struct alc_config_preset *preset) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++) - spec->mixers[spec->num_mixers++] = preset->mixers[i]; - for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; i++) - spec->init_verbs[spec->num_init_verbs++] = preset->init_verbs[i]; - - spec->channel_mode = preset->channel_mode; - spec->num_channel_mode = preset->num_channel_mode; - - spec->multiout.max_channels = spec->channel_mode[0].channels; - - spec->multiout.num_dacs = preset->num_dacs; - spec->multiout.dac_nids = preset->dac_nids; - spec->multiout.dig_out_nid = preset->dig_out_nid; - spec->multiout.hp_nid = preset->hp_nid; - - spec->input_mux = preset->input_mux; - - spec->num_adc_nids = preset->num_adc_nids; - spec->adc_nids = preset->adc_nids; - spec->dig_in_nid = preset->dig_in_nid; -} - /* * ALC880 3-stack model * @@ -318,7 +286,6 @@ static hda_nid_t alc880_adc_nids[3] = { /* The datasheet says the node 0x07 is connected from inputs, * but it shows zero connection in the real implementation on some devices. - * Note: this is a 915GAV bug, fixed on 915GLV */ static hda_nid_t alc880_adc_nids_alt[2] = { /* ADC1-2 */ @@ -361,12 +328,12 @@ static struct hda_verb alc880_threestack_ch6_init[] = { { } /* end */ }; -static struct hda_channel_mode alc880_threestack_modes[2] = { +static struct alc_channel_mode alc880_threestack_modes[2] = { { 2, alc880_threestack_ch2_init }, { 6, alc880_threestack_ch6_init }, }; -static struct snd_kcontrol_new alc880_three_stack_mixer[] = { +static snd_kcontrol_new_t alc880_three_stack_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT), @@ -389,15 +356,15 @@ static struct snd_kcontrol_new alc880_three_stack_mixer[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Channel Mode", - .info = alc_ch_mode_info, - .get = alc_ch_mode_get, - .put = alc_ch_mode_put, + .info = alc880_ch_mode_info, + .get = alc880_ch_mode_get, + .put = alc880_ch_mode_put, }, { } /* end */ }; /* capture mixer elements */ -static struct snd_kcontrol_new alc880_capture_mixer[] = { +static snd_kcontrol_new_t alc880_capture_mixer[] = { HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT), @@ -421,7 +388,7 @@ static struct snd_kcontrol_new alc880_capture_mixer[] = { }; /* capture mixer elements (in case NID 0x07 not available) */ -static struct snd_kcontrol_new alc880_capture_alt_mixer[] = { +static snd_kcontrol_new_t alc880_capture_alt_mixer[] = { HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), @@ -453,7 +420,7 @@ static struct snd_kcontrol_new alc880_capture_alt_mixer[] = { */ /* additional mixers to alc880_three_stack_mixer */ -static struct snd_kcontrol_new alc880_five_stack_mixer[] = { +static snd_kcontrol_new_t alc880_five_stack_mixer[] = { HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT), { } /* end */ @@ -476,7 +443,7 @@ static struct hda_verb alc880_fivestack_ch8_init[] = { { } /* end */ }; -static struct hda_channel_mode alc880_fivestack_modes[2] = { +static struct alc_channel_mode alc880_fivestack_modes[2] = { { 6, alc880_fivestack_ch6_init }, { 8, alc880_fivestack_ch8_init }, }; @@ -506,11 +473,11 @@ static struct hda_input_mux alc880_6stack_capture_source = { }; /* fixed 8-channels */ -static struct hda_channel_mode alc880_sixstack_modes[1] = { +static struct alc_channel_mode alc880_sixstack_modes[1] = { { 8, NULL }, }; -static struct snd_kcontrol_new alc880_six_stack_mixer[] = { +static snd_kcontrol_new_t alc880_six_stack_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), @@ -534,9 +501,9 @@ static struct snd_kcontrol_new alc880_six_stack_mixer[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Channel Mode", - .info = alc_ch_mode_info, - .get = alc_ch_mode_get, - .put = alc_ch_mode_put, + .info = alc880_ch_mode_info, + .get = alc880_ch_mode_get, + .put = alc880_ch_mode_put, }, { } /* end */ }; @@ -573,12 +540,12 @@ static hda_nid_t alc880_w810_dac_nids[3] = { }; /* fixed 6 channels */ -static struct hda_channel_mode alc880_w810_modes[1] = { +static struct alc_channel_mode alc880_w810_modes[1] = { { 6, NULL } }; /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */ -static struct snd_kcontrol_new alc880_w810_base_mixer[] = { +static snd_kcontrol_new_t alc880_w810_base_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), @@ -605,11 +572,11 @@ static hda_nid_t alc880_z71v_dac_nids[1] = { #define ALC880_Z71V_HP_DAC 0x03 /* fixed 2 channels */ -static struct hda_channel_mode alc880_2_jack_modes[1] = { +static struct alc_channel_mode alc880_2_jack_modes[1] = { { 2, NULL } }; -static struct snd_kcontrol_new alc880_z71v_mixer[] = { +static snd_kcontrol_new_t alc880_z71v_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT), @@ -635,7 +602,7 @@ static hda_nid_t alc880_f1734_dac_nids[1] = { }; #define ALC880_F1734_HP_DAC 0x02 -static struct snd_kcontrol_new alc880_f1734_mixer[] = { +static snd_kcontrol_new_t alc880_f1734_mixer[] = { HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT), HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT), @@ -660,7 +627,7 @@ static struct snd_kcontrol_new alc880_f1734_mixer[] = { #define alc880_asus_dac_nids alc880_w810_dac_nids /* identical with w810 */ #define alc880_asus_modes alc880_threestack_modes /* 2/6 channel mode */ -static struct snd_kcontrol_new alc880_asus_mixer[] = { +static snd_kcontrol_new_t alc880_asus_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), @@ -678,9 +645,9 @@ static struct snd_kcontrol_new alc880_asus_mixer[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Channel Mode", - .info = alc_ch_mode_info, - .get = alc_ch_mode_get, - .put = alc_ch_mode_put, + .info = alc880_ch_mode_info, + .get = alc880_ch_mode_get, + .put = alc880_ch_mode_put, }, { } /* end */ }; @@ -695,46 +662,19 @@ static struct snd_kcontrol_new alc880_asus_mixer[] = { */ /* additional mixers to alc880_asus_mixer */ -static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = { +static snd_kcontrol_new_t alc880_asus_w1v_mixer[] = { HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT), HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT), { } /* end */ }; /* additional mixers to alc880_asus_mixer */ -static struct snd_kcontrol_new alc880_pcbeep_mixer[] = { +static snd_kcontrol_new_t alc880_pcbeep_mixer[] = { HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT), HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT), { } /* end */ }; -/* TCL S700 */ -static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = { - HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT), - HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT), - HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* The multiple "Capture Source" controls confuse alsamixer - * So call somewhat different.. - * FIXME: the controls appear in the "playback" view! - */ - /* .name = "Capture Source", */ - .name = "Input Source", - .count = 1, - .info = alc_mux_enum_info, - .get = alc_mux_enum_get, - .put = alc_mux_enum_put, - }, - { } /* end */ -}; - /* * build control elements */ @@ -1034,8 +974,6 @@ static struct hda_verb alc880_gpio1_init_verbs[] = { {0x01, AC_VERB_SET_GPIO_MASK, 0x01}, {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, - - { } }; /* Enable GPIO mask and set output */ @@ -1043,59 +981,8 @@ static struct hda_verb alc880_gpio2_init_verbs[] = { {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, - - { } -}; - -/* Clevo m520g init */ -static struct hda_verb alc880_pin_clevo_init_verbs[] = { - /* headphone output */ - {0x11, AC_VERB_SET_CONNECT_SEL, 0x01}, - /* line-out */ - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* Line-in */ - {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* CD */ - {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, - {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* Mic1 (rear panel) */ - {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* Mic2 (front panel) */ - {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, - {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* headphone */ - {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, - {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - /* change to EAPD mode */ - {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, - {0x20, AC_VERB_SET_PROC_COEF, 0x3060}, - - { } }; -static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = { - /* Headphone output */ - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, - /* Front output*/ - {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, - {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, - - /* Line In pin widget for input */ - {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, - /* CD pin widget for input */ - {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, - /* Mic1 (rear panel) pin widget for input and vref at 80% */ - {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, - - /* change to EAPD mode */ - {0x20, AC_VERB_SET_COEF_INDEX, 0x07}, - {0x20, AC_VERB_SET_PROC_COEF, 0x3070}, - - { } -}; /* */ @@ -1136,7 +1023,7 @@ static int alc_resume(struct hda_codec *codec) */ static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct alc_spec *spec = codec->spec; return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream); @@ -1146,7 +1033,7 @@ static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct alc_spec *spec = codec->spec; return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, @@ -1155,7 +1042,7 @@ static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo, static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct alc_spec *spec = codec->spec; return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); @@ -1166,7 +1053,7 @@ static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, */ static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct alc_spec *spec = codec->spec; return snd_hda_multi_out_dig_open(codec, &spec->multiout); @@ -1174,7 +1061,7 @@ static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct alc_spec *spec = codec->spec; return snd_hda_multi_out_dig_close(codec, &spec->multiout); @@ -1187,7 +1074,7 @@ static int alc880_capture_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct alc_spec *spec = codec->spec; @@ -1198,7 +1085,7 @@ static int alc880_capture_pcm_prepare(struct hda_pcm_stream *hinfo, static int alc880_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct alc_spec *spec = codec->spec; @@ -1260,23 +1147,15 @@ static int alc_build_pcms(struct hda_codec *codec) codec->pcm_info = info; info->name = spec->stream_name_analog; - if (spec->stream_analog_playback) { - snd_assert(spec->multiout.dac_nids, return -EINVAL); - info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); - info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; - } - if (spec->stream_analog_capture) { - snd_assert(spec->adc_nids, return -EINVAL); - info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); - info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; - } - - if (spec->channel_mode) { - info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; - for (i = 0; i < spec->num_channel_mode; i++) { - if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { - info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; - } + info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback); + info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; + info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture); + info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; + + info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0; + for (i = 0; i < spec->num_channel_mode; i++) { + if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) { + info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels; } } @@ -1284,13 +1163,11 @@ static int alc_build_pcms(struct hda_codec *codec) codec->num_pcms++; info++; info->name = spec->stream_name_digital; - if (spec->multiout.dig_out_nid && - spec->stream_digital_playback) { + if (spec->multiout.dig_out_nid) { info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback); info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; } - if (spec->dig_in_nid && - spec->stream_digital_capture) { + if (spec->dig_in_nid) { info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture); info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; } @@ -1350,14 +1227,14 @@ static struct hda_input_mux alc880_test_capture_source = { }, }; -static struct hda_channel_mode alc880_test_modes[4] = { +static struct alc_channel_mode alc880_test_modes[4] = { { 2, NULL }, { 4, NULL }, { 6, NULL }, { 8, NULL }, }; -static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int alc_test_pin_ctl_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[] = { "N/A", "Line Out", "HP Out", @@ -1372,7 +1249,7 @@ static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_test_pin_ctl_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = (hda_nid_t)kcontrol->private_value; @@ -1398,7 +1275,7 @@ static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_test_pin_ctl_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = (hda_nid_t)kcontrol->private_value; @@ -1424,7 +1301,7 @@ static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int alc_test_pin_src_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[] = { "Front", "Surround", "CLFE", "Side" @@ -1438,7 +1315,7 @@ static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_test_pin_src_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = (hda_nid_t)kcontrol->private_value; @@ -1449,7 +1326,7 @@ static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc_test_pin_src_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); hda_nid_t nid = (hda_nid_t)kcontrol->private_value; @@ -1482,7 +1359,7 @@ static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el .private_value = nid \ } -static struct snd_kcontrol_new alc880_test_mixer[] = { +static snd_kcontrol_new_t alc880_test_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT), @@ -1516,9 +1393,9 @@ static struct snd_kcontrol_new alc880_test_mixer[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Channel Mode", - .info = alc_ch_mode_info, - .get = alc_ch_mode_get, - .put = alc_ch_mode_put, + .info = alc880_ch_mode_info, + .get = alc880_ch_mode_get, + .put = alc880_ch_mode_put, }, { } /* end */ }; @@ -1614,8 +1491,6 @@ static struct hda_board_config alc880_cfg_tbl[] = { { .pci_subvendor = 0x107b, .pci_subdevice = 0x4038, .config = ALC880_3ST }, { .pci_subvendor = 0x107b, .pci_subdevice = 0x4040, .config = ALC880_3ST }, { .pci_subvendor = 0x107b, .pci_subdevice = 0x4041, .config = ALC880_3ST }, - /* TCL S700 */ - { .pci_subvendor = 0x19db, .pci_subdevice = 0x4188, .config = ALC880_TCL_S700 }, /* Back 3 jack, front 2 jack (Internal add Aux-In) */ { .pci_subvendor = 0x1025, .pci_subdevice = 0xe310, .config = ALC880_3ST }, @@ -1626,8 +1501,6 @@ static struct hda_board_config alc880_cfg_tbl[] = { { .modelname = "3stack-digout", .config = ALC880_3ST_DIG }, { .pci_subvendor = 0x8086, .pci_subdevice = 0xe308, .config = ALC880_3ST_DIG }, { .pci_subvendor = 0x1025, .pci_subdevice = 0x0070, .config = ALC880_3ST_DIG }, - /* Clevo m520G NB */ - { .pci_subvendor = 0x1558, .pci_subdevice = 0x0520, .config = ALC880_CLEVO }, /* Back 3 jack plus 1 SPDIF out jack, front 2 jack (Internal add Aux-In)*/ { .pci_subvendor = 0x8086, .pci_subdevice = 0xe305, .config = ALC880_3ST_DIG }, @@ -1665,8 +1538,6 @@ static struct hda_board_config alc880_cfg_tbl[] = { { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_Z71V }, { .modelname = "6stack", .config = ALC880_6ST }, - { .pci_subvendor = 0x1043, .pci_subdevice = 0x8196, .config = ALC880_6ST }, /* ASUS P5GD1-HVM */ - { .pci_subvendor = 0x1043, .pci_subdevice = 0x81b4, .config = ALC880_6ST }, { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_6ST }, /* Acer APFV */ { .modelname = "6stack-digout", .config = ALC880_6ST_DIG }, @@ -1674,11 +1545,6 @@ static struct hda_board_config alc880_cfg_tbl[] = { { .pci_subvendor = 0x8086, .pci_subdevice = 0x2668, .config = ALC880_6ST_DIG }, { .pci_subvendor = 0x1462, .pci_subdevice = 0x1150, .config = ALC880_6ST_DIG }, { .pci_subvendor = 0xe803, .pci_subdevice = 0x1019, .config = ALC880_6ST_DIG }, - { .pci_subvendor = 0x1039, .pci_subdevice = 0x1234, .config = ALC880_6ST_DIG }, - { .pci_subvendor = 0x1025, .pci_subdevice = 0x0077, .config = ALC880_6ST_DIG }, - { .pci_subvendor = 0x1025, .pci_subdevice = 0x0078, .config = ALC880_6ST_DIG }, - { .pci_subvendor = 0x1025, .pci_subdevice = 0x0087, .config = ALC880_6ST_DIG }, - { .pci_subvendor = 0x1297, .pci_subdevice = 0xc790, .config = ALC880_6ST_DIG }, /* Shuttle ST20G5 */ { .modelname = "asus", .config = ALC880_ASUS }, { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_ASUS_DIG }, @@ -1692,26 +1558,37 @@ static struct hda_board_config alc880_cfg_tbl[] = { { .pci_subvendor = 0x1043, .pci_subdevice = 0x1123, .config = ALC880_ASUS_DIG }, { .pci_subvendor = 0x1043, .pci_subdevice = 0x1143, .config = ALC880_ASUS }, { .pci_subvendor = 0x1043, .pci_subdevice = 0x10b3, .config = ALC880_ASUS_W1V }, - { .pci_subvendor = 0x1558, .pci_subdevice = 0x5401, .config = ALC880_ASUS_DIG2 }, { .modelname = "uniwill", .config = ALC880_UNIWILL_DIG }, { .pci_subvendor = 0x1584, .pci_subdevice = 0x9050, .config = ALC880_UNIWILL_DIG }, { .modelname = "F1734", .config = ALC880_F1734 }, { .pci_subvendor = 0x1734, .pci_subdevice = 0x107c, .config = ALC880_F1734 }, - { .pci_subvendor = 0x1584, .pci_subdevice = 0x9054, .config = ALC880_F1734 }, #ifdef CONFIG_SND_DEBUG { .modelname = "test", .config = ALC880_TEST }, #endif - { .modelname = "auto", .config = ALC880_AUTO }, {} }; /* - * ALC880 codec presets + * configuration template - to be copied to the spec instance */ +struct alc_config_preset { + snd_kcontrol_new_t *mixers[4]; + const struct hda_verb *init_verbs[4]; + unsigned int num_dacs; + hda_nid_t *dac_nids; + hda_nid_t dig_out_nid; /* optional */ + hda_nid_t hp_nid; /* optional */ + unsigned int num_adc_nids; + hda_nid_t *adc_nids; + unsigned int num_channel_mode; + const struct alc_channel_mode *channel_mode; + const struct hda_input_mux *input_mux; +}; + static struct alc_config_preset alc880_presets[] = { [ALC880_3ST] = { .mixers = { alc880_three_stack_mixer }, @@ -1732,18 +1609,6 @@ static struct alc_config_preset alc880_presets[] = { .channel_mode = alc880_threestack_modes, .input_mux = &alc880_capture_source, }, - [ALC880_TCL_S700] = { - .mixers = { alc880_tcl_s700_mixer }, - .init_verbs = { alc880_volume_init_verbs, - alc880_pin_tcl_S700_init_verbs, - alc880_gpio2_init_verbs }, - .num_dacs = ARRAY_SIZE(alc880_dac_nids), - .dac_nids = alc880_dac_nids, - .hp_nid = 0x03, - .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes), - .channel_mode = alc880_2_jack_modes, - .input_mux = &alc880_capture_source, - }, [ALC880_5ST] = { .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer}, .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs }, @@ -1835,17 +1700,6 @@ static struct alc_config_preset alc880_presets[] = { .channel_mode = alc880_asus_modes, .input_mux = &alc880_capture_source, }, - [ALC880_ASUS_DIG2] = { - .mixers = { alc880_asus_mixer }, - .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs, - alc880_gpio2_init_verbs }, /* use GPIO2 */ - .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids), - .dac_nids = alc880_asus_dac_nids, - .dig_out_nid = ALC880_DIGOUT_NID, - .num_channel_mode = ARRAY_SIZE(alc880_asus_modes), - .channel_mode = alc880_asus_modes, - .input_mux = &alc880_capture_source, - }, [ALC880_ASUS_W1V] = { .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer }, .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs, @@ -1867,17 +1721,6 @@ static struct alc_config_preset alc880_presets[] = { .channel_mode = alc880_asus_modes, .input_mux = &alc880_capture_source, }, - [ALC880_CLEVO] = { - .mixers = { alc880_three_stack_mixer }, - .init_verbs = { alc880_volume_init_verbs, - alc880_pin_clevo_init_verbs }, - .num_dacs = ARRAY_SIZE(alc880_dac_nids), - .dac_nids = alc880_dac_nids, - .hp_nid = 0x03, - .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes), - .channel_mode = alc880_threestack_modes, - .input_mux = &alc880_capture_source, - }, #ifdef CONFIG_SND_DEBUG [ALC880_TEST] = { .mixers = { alc880_test_mixer }, @@ -1904,7 +1747,7 @@ enum { ALC_CTL_WIDGET_MUTE, ALC_CTL_BIND_MUTE, }; -static struct snd_kcontrol_new alc880_control_templates[] = { +static snd_kcontrol_new_t alc880_control_templates[] = { HDA_CODEC_VOLUME(NULL, 0, 0, 0), HDA_CODEC_MUTE(NULL, 0, 0, 0), HDA_BIND_MUTE(NULL, 0, 0, 0), @@ -1913,7 +1756,7 @@ static struct snd_kcontrol_new alc880_control_templates[] = { /* add dynamic controls */ static int add_control(struct alc_spec *spec, int type, const char *name, unsigned long val) { - struct snd_kcontrol_new *knew; + snd_kcontrol_new_t *knew; if (spec->num_kctl_used >= spec->num_kctl_alloc) { int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; @@ -1966,7 +1809,7 @@ static int alc880_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pi nid = cfg->line_out_pins[i]; if (alc880_is_fixed_pin(nid)) { int idx = alc880_fixed_pin_idx(nid); - spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx); + spec->multiout.dac_nids[i] = alc880_dac_to_idx(idx); assigned[idx] = 1; } } @@ -1989,8 +1832,7 @@ static int alc880_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pi } /* add playback controls from the parsed DAC table */ -static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, - const struct auto_pin_cfg *cfg) +static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg) { char name[32]; static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" }; @@ -2026,16 +1868,15 @@ static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec, return err; } } + return 0; } -/* add playback controls for speaker and HP outputs */ -static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, - const char *pfx) +/* add playback controls for HP output */ +static int alc880_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin) { hda_nid_t nid; int err; - char name[32]; if (! pin) return 0; @@ -2048,16 +1889,14 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, if (! spec->multiout.num_dacs) spec->multiout.num_dacs = 1; } else - /* specify the DAC as the extra output */ + /* specify the DAC as the extra HP output */ spec->multiout.hp_nid = nid; /* control HP volume/switch on the output mixer amp */ nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin)); - sprintf(name, "%s Playback Volume", pfx); - if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, + if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume", HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) return err; - sprintf(name, "%s Playback Switch", pfx); - if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name, + if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Headphone Playback Switch", HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0) return err; } else if (alc880_is_multi_pin(pin)) { @@ -2069,8 +1908,7 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, spec->multiout.num_dacs = 1; } /* we have only a switch on HP-out PIN */ - sprintf(name, "%s Playback Switch", pfx); - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, + if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch", HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT))) < 0) return err; } @@ -2078,39 +1916,38 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, } /* create input playback/capture controls for the given pin */ -static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, const char *ctlname, - int idx, hda_nid_t mix_nid) +static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, const char *ctlname) { char name[32]; - int err; + int err, idx; sprintf(name, "%s Playback Volume", ctlname); + idx = alc880_input_pin_idx(pin); if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, - HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0) + HDA_COMPOSE_AMP_VAL(0x0b, 3, idx, HDA_INPUT))) < 0) return err; sprintf(name, "%s Playback Switch", ctlname); if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, - HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0) + HDA_COMPOSE_AMP_VAL(0x0b, 3, idx, HDA_INPUT))) < 0) return err; return 0; } /* create playback/capture controls for input pins */ -static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec, - const struct auto_pin_cfg *cfg) +static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg) { + static char *labels[AUTO_PIN_LAST] = { + "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" + }; struct hda_input_mux *imux = &spec->private_imux; - int i, err, idx; + int i, err; for (i = 0; i < AUTO_PIN_LAST; i++) { if (alc880_is_input_pin(cfg->input_pins[i])) { - idx = alc880_input_pin_idx(cfg->input_pins[i]); - err = new_analog_input(spec, cfg->input_pins[i], - auto_pin_cfg_labels[i], - idx, 0x0b); + err = new_analog_input(spec, cfg->input_pins[i], labels[i]); if (err < 0) return err; - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; + imux->items[imux->num_items].label = labels[i]; imux->items[imux->num_items].index = alc880_input_pin_idx(cfg->input_pins[i]); imux->num_items++; } @@ -2118,8 +1955,7 @@ static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec, return 0; } -static void alc880_auto_set_output_and_unmute(struct hda_codec *codec, - hda_nid_t nid, int pin_type, +static void alc880_auto_set_output_and_unmute(struct hda_codec *codec, hda_nid_t nid, int pin_type, int dac_idx) { /* set as output */ @@ -2146,14 +1982,11 @@ static void alc880_auto_init_multi_out(struct hda_codec *codec) } } -static void alc880_auto_init_extra_out(struct hda_codec *codec) +static void alc880_auto_init_hp_out(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; hda_nid_t pin; - pin = spec->autocfg.speaker_pin; - if (pin) /* connect to front */ - alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); pin = spec->autocfg.hp_pin; if (pin) /* connect to front */ alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); @@ -2182,21 +2015,15 @@ static int alc880_parse_auto_config(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; int err; - static hda_nid_t alc880_ignore[] = { 0x1d, 0 }; - if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, - alc880_ignore)) < 0) + if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg)) < 0) return err; - if (! spec->autocfg.line_outs && ! spec->autocfg.speaker_pin && - ! spec->autocfg.hp_pin) + if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0) + return err; + if (! spec->autocfg.line_outs && ! spec->autocfg.hp_pin) return 0; /* can't find valid BIOS pin config */ - - if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 || - (err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || - (err = alc880_auto_create_extra_out(spec, spec->autocfg.speaker_pin, - "Speaker")) < 0 || - (err = alc880_auto_create_extra_out(spec, spec->autocfg.speaker_pin, - "Headphone")) < 0 || + if ((err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || + (err = alc880_auto_create_hp_ctls(spec, spec->autocfg.hp_pin)) < 0 || (err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) return err; @@ -2222,7 +2049,7 @@ static int alc880_auto_init(struct hda_codec *codec) { alc_init(codec); alc880_auto_init_multi_out(codec); - alc880_auto_init_extra_out(codec); + alc880_auto_init_hp_out(codec); alc880_auto_init_analog_input(codec); return 0; } @@ -2235,7 +2062,7 @@ static int patch_alc880(struct hda_codec *codec) { struct alc_spec *spec; int board_config; - int err; + int i, err; spec = kzalloc(sizeof(*spec), GFP_KERNEL); if (spec == NULL) @@ -2261,8 +2088,36 @@ static int patch_alc880(struct hda_codec *codec) } } - if (board_config != ALC880_AUTO) - setup_preset(spec, &alc880_presets[board_config]); + if (board_config != ALC880_AUTO) { + /* set up from the preset table */ + const struct alc_config_preset *preset; + + preset = &alc880_presets[board_config]; + + for (i = 0; preset->mixers[i]; i++) { + snd_assert(spec->num_mixers < ARRAY_SIZE(spec->mixers), break); + spec->mixers[spec->num_mixers++] = preset->mixers[i]; + } + for (i = 0; preset->init_verbs[i]; i++) { + snd_assert(spec->num_init_verbs < ARRAY_SIZE(spec->init_verbs), break); + spec->init_verbs[spec->num_init_verbs++] = preset->init_verbs[i]; + } + + spec->channel_mode = preset->channel_mode; + spec->num_channel_mode = preset->num_channel_mode; + + spec->multiout.max_channels = spec->channel_mode[0].channels; + + spec->multiout.num_dacs = preset->num_dacs; + spec->multiout.dac_nids = preset->dac_nids; + spec->multiout.dig_out_nid = preset->dig_out_nid; + spec->multiout.hp_nid = preset->hp_nid; + + spec->input_mux = preset->input_mux; + + spec->num_adc_nids = preset->num_adc_nids; + spec->adc_nids = preset->adc_nids; + } spec->stream_name_analog = "ALC880 Analog"; spec->stream_analog_playback = &alc880_pcm_analog_playback; @@ -2274,7 +2129,8 @@ static int patch_alc880(struct hda_codec *codec) if (! spec->adc_nids && spec->input_mux) { /* check whether NID 0x07 is valid */ - unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]); + unsigned int wcap = snd_hda_param_read(codec, alc880_adc_nids[0], + AC_PAR_AUDIO_WIDGET_CAP); wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */ if (wcap != AC_WID_AUD_IN) { spec->adc_nids = alc880_adc_nids_alt; @@ -2311,16 +2167,11 @@ static hda_nid_t alc260_adc_nids[1] = { 0x04, }; -static hda_nid_t alc260_adc_nids_alt[1] = { +static hda_nid_t alc260_hp_adc_nids[1] = { /* ADC1 */ 0x05, }; -static hda_nid_t alc260_hp_adc_nids[2] = { - /* ADC1, 0 */ - 0x05, 0x04 -}; - #define ALC260_DIGOUT_NID 0x03 #define ALC260_DIGIN_NID 0x06 @@ -2351,30 +2202,42 @@ static struct hda_input_mux alc260_fujitsu_capture_source = { * element which allows changing the channel mode, so the verb list is * never used. */ -static struct hda_channel_mode alc260_modes[1] = { +static struct alc_channel_mode alc260_modes[1] = { { 2, NULL }, }; - -/* Mixer combinations - * - * basic: base_output + input + pc_beep + capture - * HP: base_output + input + capture_alt - * HP_3013: hp_3013 + input + capture - * fujitsu: fujitsu + capture - */ - -static struct snd_kcontrol_new alc260_base_output_mixer[] = { +static snd_kcontrol_new_t alc260_base_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), + HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), + HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), + HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), + HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT), + HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT), + HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), + HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT), + HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT), + HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT), + HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT), HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), + HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT), + HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT), + { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Capture Source", + .info = alc_mux_enum_info, + .get = alc_mux_enum_get, + .put = alc_mux_enum_put, + }, { } /* end */ -}; +}; -static struct snd_kcontrol_new alc260_input_mixer[] = { +static snd_kcontrol_new_t alc260_hp_mixer[] = { + HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT), + HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT), HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT), HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT), HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT), @@ -2383,28 +2246,23 @@ static struct snd_kcontrol_new alc260_input_mixer[] = { HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT), HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT), HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT), + HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT), + HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT), + HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), + HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT), + HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT), + HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT), + { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Capture Source", + .info = alc_mux_enum_info, + .get = alc_mux_enum_get, + .put = alc_mux_enum_put, + }, { } /* end */ }; -static struct snd_kcontrol_new alc260_pc_beep_mixer[] = { - HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT), - HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT), - { } /* end */ -}; - -static struct snd_kcontrol_new alc260_hp_3013_mixer[] = { - HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT), - HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT), - HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("iSpeaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_MONO("iSpeaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT), - { } /* end */ -}; - -static struct snd_kcontrol_new alc260_fujitsu_mixer[] = { +static snd_kcontrol_new_t alc260_fujitsu_mixer[] = { HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT), ALC_PINCTL_SWITCH("Headphone Amp Switch", 0x14, PIN_HP_AMP), @@ -2416,43 +2274,11 @@ static struct snd_kcontrol_new alc260_fujitsu_mixer[] = { HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT), HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT), - { } /* end */ -}; - -/* capture mixer elements */ -static struct snd_kcontrol_new alc260_capture_mixer[] = { HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT), HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* The multiple "Capture Source" controls confuse alsamixer - * So call somewhat different.. - * FIXME: the controls appear in the "playback" view! - */ - /* .name = "Capture Source", */ - .name = "Input Source", - .count = 2, - .info = alc_mux_enum_info, - .get = alc_mux_enum_get, - .put = alc_mux_enum_put, - }, - { } /* end */ -}; - -static struct snd_kcontrol_new alc260_capture_alt_mixer[] = { - HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT), { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* The multiple "Capture Source" controls confuse alsamixer - * So call somewhat different.. - * FIXME: the controls appear in the "playback" view! - */ - /* .name = "Capture Source", */ - .name = "Input Source", - .count = 1, + .name = "Capture Source", .info = alc_mux_enum_info, .get = alc_mux_enum_get, .put = alc_mux_enum_put, @@ -2460,9 +2286,6 @@ static struct snd_kcontrol_new alc260_capture_alt_mixer[] = { { } /* end */ }; -/* - * initialization verbs - */ static struct hda_verb alc260_init_verbs[] = { /* Line In pin widget for input */ {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, @@ -2524,100 +2347,6 @@ static struct hda_verb alc260_init_verbs[] = { { } }; -static struct hda_verb alc260_hp_init_verbs[] = { - /* Headphone and output */ - {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, - /* mono output */ - {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - /* Mic1 (rear panel) pin widget for input and vref at 80% */ - {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, - /* Mic2 (front panel) pin widget for input and vref at 80% */ - {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, - /* Line In pin widget for input */ - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, - /* Line-2 pin widget for output */ - {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - /* CD pin widget for input */ - {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, - /* unmute amp left and right */ - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, - /* set connection select to line in (default select for this ADC) */ - {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, - /* unmute Line-Out mixer amp left and right (volume = 0) */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, - /* mute pin widget amp left and right (no gain on this amp) */ - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - /* unmute HP mixer amp left and right (volume = 0) */ - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, - /* mute pin widget amp left and right (no gain on this amp) */ - {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */ - /* unmute CD */ - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, - /* unmute Line In */ - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, - /* unmute Mic */ - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ - /* Unmute Front out path */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, - /* Unmute Headphone out path */ - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, - /* Unmute Mono out path */ - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, - { } -}; - -static struct hda_verb alc260_hp_3013_init_verbs[] = { - /* Line out and output */ - {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - /* mono output */ - {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - /* Mic1 (rear panel) pin widget for input and vref at 80% */ - {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, - /* Mic2 (front panel) pin widget for input and vref at 80% */ - {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, - /* Line In pin widget for input */ - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, - /* Headphone pin widget for output */ - {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, - /* CD pin widget for input */ - {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, - /* unmute amp left and right */ - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000}, - /* set connection select to line in (default select for this ADC) */ - {0x04, AC_VERB_SET_CONNECT_SEL, 0x02}, - /* unmute Line-Out mixer amp left and right (volume = 0) */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, - /* mute pin widget amp left and right (no gain on this amp) */ - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - /* unmute HP mixer amp left and right (volume = 0) */ - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, - /* mute pin widget amp left and right (no gain on this amp) */ - {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */ - /* unmute CD */ - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, - /* unmute Line In */ - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, - /* unmute Mic */ - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */ - /* Unmute Front out path */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, - /* Unmute Headphone out path */ - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, - /* Unmute Mono out path */ - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, - { } -}; - /* Initialisation sequence for ALC260 as configured in Fujitsu S702x * laptops. */ @@ -2670,8 +2399,6 @@ static struct hda_verb alc260_fujitsu_init_verbs[] = { {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ - - { } }; static struct hda_pcm_stream alc260_pcm_analog_playback = { @@ -2686,338 +2413,18 @@ static struct hda_pcm_stream alc260_pcm_analog_capture = { .channels_max = 2, }; -#define alc260_pcm_digital_playback alc880_pcm_digital_playback -#define alc260_pcm_digital_capture alc880_pcm_digital_capture - -/* - * for BIOS auto-configuration - */ - -static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid, - const char *pfx) -{ - hda_nid_t nid_vol; - unsigned long vol_val, sw_val; - char name[32]; - int err; - - if (nid >= 0x0f && nid < 0x11) { - nid_vol = nid - 0x7; - vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); - sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); - } else if (nid == 0x11) { - nid_vol = nid - 0x7; - vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT); - sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); - } else if (nid >= 0x12 && nid <= 0x15) { - nid_vol = 0x08; - vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT); - sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); - } else - return 0; /* N/A */ - - snprintf(name, sizeof(name), "%s Playback Volume", pfx); - if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val)) < 0) - return err; - snprintf(name, sizeof(name), "%s Playback Switch", pfx); - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val)) < 0) - return err; - return 1; -} - -/* add playback controls from the parsed DAC table */ -static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec, - const struct auto_pin_cfg *cfg) -{ - hda_nid_t nid; - int err; - - spec->multiout.num_dacs = 1; - spec->multiout.dac_nids = spec->private_dac_nids; - spec->multiout.dac_nids[0] = 0x02; - - nid = cfg->line_out_pins[0]; - if (nid) { - err = alc260_add_playback_controls(spec, nid, "Front"); - if (err < 0) - return err; - } - - nid = cfg->speaker_pin; - if (nid) { - err = alc260_add_playback_controls(spec, nid, "Speaker"); - if (err < 0) - return err; - } - - nid = cfg->hp_pin; - if (nid) { - err = alc260_add_playback_controls(spec, nid, "Headphone"); - if (err < 0) - return err; - } - return 0; -} - -/* create playback/capture controls for input pins */ -static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec, - const struct auto_pin_cfg *cfg) -{ - struct hda_input_mux *imux = &spec->private_imux; - int i, err, idx; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (cfg->input_pins[i] >= 0x12) { - idx = cfg->input_pins[i] - 0x12; - err = new_analog_input(spec, cfg->input_pins[i], - auto_pin_cfg_labels[i], idx, 0x07); - if (err < 0) - return err; - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; - imux->items[imux->num_items].index = idx; - imux->num_items++; - } - if ((cfg->input_pins[i] >= 0x0f) && (cfg->input_pins[i] <= 0x10)){ - idx = cfg->input_pins[i] - 0x09; - err = new_analog_input(spec, cfg->input_pins[i], - auto_pin_cfg_labels[i], idx, 0x07); - if (err < 0) - return err; - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; - imux->items[imux->num_items].index = idx; - imux->num_items++; - } - } - return 0; -} - -static void alc260_auto_set_output_and_unmute(struct hda_codec *codec, - hda_nid_t nid, int pin_type, - int sel_idx) -{ - /* set as output */ - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); - /* need the manual connection? */ - if (nid >= 0x12) { - int idx = nid - 0x12; - snd_hda_codec_write(codec, idx + 0x0b, 0, - AC_VERB_SET_CONNECT_SEL, sel_idx); - - } -} - -static void alc260_auto_init_multi_out(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - hda_nid_t nid; - - nid = spec->autocfg.line_out_pins[0]; - if (nid) - alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); - - nid = spec->autocfg.speaker_pin; - if (nid) - alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); - - nid = spec->autocfg.hp_pin; - if (nid) - alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0); -} - -#define ALC260_PIN_CD_NID 0x16 -static void alc260_auto_init_analog_input(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int i; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if (nid >= 0x12) { - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, - i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN); - if (nid != ALC260_PIN_CD_NID) - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, - AMP_OUT_MUTE); - } - } -} - -/* - * generic initialization of ADC, input mixers and output mixers - */ -static struct hda_verb alc260_volume_init_verbs[] = { - /* - * Unmute ADC0-1 and set the default input to mic-in - */ - {0x04, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x05, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - - /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback - * mixer widget - * Note: PASD motherboards uses the Line In 2 as the input for front panel - * mic (mic 2) - */ - /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, - - /* - * Set up output mixers (0x08 - 0x0a) - */ - /* set vol=0 to output mixers */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - /* set up input amps for analog loopback */ - /* Amp Indices: DAC = 0, mixer = 1 */ - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - - { } -}; - -static int alc260_parse_auto_config(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - unsigned int wcap; - int err; - static hda_nid_t alc260_ignore[] = { 0x17, 0 }; - - if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, - alc260_ignore)) < 0) - return err; - if ((err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0) - return err; - if (! spec->kctl_alloc) - return 0; /* can't find valid BIOS pin config */ - if ((err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) - return err; - - spec->multiout.max_channels = 2; - - if (spec->autocfg.dig_out_pin) - spec->multiout.dig_out_nid = ALC260_DIGOUT_NID; - if (spec->kctl_alloc) - spec->mixers[spec->num_mixers++] = spec->kctl_alloc; - - spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs; - - spec->input_mux = &spec->private_imux; - - /* check whether NID 0x04 is valid */ - wcap = get_wcaps(codec, 0x04); - wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */ - if (wcap != AC_WID_AUD_IN) { - spec->adc_nids = alc260_adc_nids_alt; - spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt); - spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer; - } else { - spec->adc_nids = alc260_adc_nids; - spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids); - spec->mixers[spec->num_mixers] = alc260_capture_mixer; - } - spec->num_mixers++; - - return 1; -} - -/* init callback for auto-configuration model -- overriding the default init */ -static int alc260_auto_init(struct hda_codec *codec) -{ - alc_init(codec); - alc260_auto_init_multi_out(codec); - alc260_auto_init_analog_input(codec); - return 0; -} - -/* - * ALC260 configurations - */ static struct hda_board_config alc260_cfg_tbl[] = { - { .modelname = "basic", .config = ALC260_BASIC }, { .modelname = "hp", .config = ALC260_HP }, - { .pci_subvendor = 0x103c, .pci_subdevice = 0x3010, .config = ALC260_HP }, - { .pci_subvendor = 0x103c, .pci_subdevice = 0x3011, .config = ALC260_HP }, - { .pci_subvendor = 0x103c, .pci_subdevice = 0x3012, .config = ALC260_HP }, - { .pci_subvendor = 0x103c, .pci_subdevice = 0x3013, .config = ALC260_HP_3013 }, - { .pci_subvendor = 0x103c, .pci_subdevice = 0x3014, .config = ALC260_HP }, - { .pci_subvendor = 0x103c, .pci_subdevice = 0x3015, .config = ALC260_HP }, - { .pci_subvendor = 0x103c, .pci_subdevice = 0x3016, .config = ALC260_HP }, - { .modelname = "fujitsu", .config = ALC260_FUJITSU_S702X }, - { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1326, .config = ALC260_FUJITSU_S702X }, - { .modelname = "auto", .config = ALC260_AUTO }, + { .pci_subvendor = 0x103c, .config = ALC260_HP }, + { .modelname = "fujitsu", .config = ALC260_FUJITSU_S702x }, + { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1326, .config = ALC260_FUJITSU_S702x }, {} }; -static struct alc_config_preset alc260_presets[] = { - [ALC260_BASIC] = { - .mixers = { alc260_base_output_mixer, - alc260_input_mixer, - alc260_pc_beep_mixer, - alc260_capture_mixer }, - .init_verbs = { alc260_init_verbs }, - .num_dacs = ARRAY_SIZE(alc260_dac_nids), - .dac_nids = alc260_dac_nids, - .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), - .adc_nids = alc260_adc_nids, - .num_channel_mode = ARRAY_SIZE(alc260_modes), - .channel_mode = alc260_modes, - .input_mux = &alc260_capture_source, - }, - [ALC260_HP] = { - .mixers = { alc260_base_output_mixer, - alc260_input_mixer, - alc260_capture_alt_mixer }, - .init_verbs = { alc260_hp_init_verbs }, - .num_dacs = ARRAY_SIZE(alc260_dac_nids), - .dac_nids = alc260_dac_nids, - .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids), - .adc_nids = alc260_hp_adc_nids, - .num_channel_mode = ARRAY_SIZE(alc260_modes), - .channel_mode = alc260_modes, - .input_mux = &alc260_capture_source, - }, - [ALC260_HP_3013] = { - .mixers = { alc260_hp_3013_mixer, - alc260_input_mixer, - alc260_capture_alt_mixer }, - .init_verbs = { alc260_hp_3013_init_verbs }, - .num_dacs = ARRAY_SIZE(alc260_dac_nids), - .dac_nids = alc260_dac_nids, - .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids), - .adc_nids = alc260_hp_adc_nids, - .num_channel_mode = ARRAY_SIZE(alc260_modes), - .channel_mode = alc260_modes, - .input_mux = &alc260_capture_source, - }, - [ALC260_FUJITSU_S702X] = { - .mixers = { alc260_fujitsu_mixer, - alc260_capture_mixer }, - .init_verbs = { alc260_fujitsu_init_verbs }, - .num_dacs = ARRAY_SIZE(alc260_dac_nids), - .dac_nids = alc260_dac_nids, - .num_adc_nids = ARRAY_SIZE(alc260_adc_nids), - .adc_nids = alc260_adc_nids, - .num_channel_mode = ARRAY_SIZE(alc260_modes), - .channel_mode = alc260_modes, - .input_mux = &alc260_fujitsu_capture_source, - }, -}; - static int patch_alc260(struct hda_codec *codec) { struct alc_spec *spec; - int err, board_config; + int board_config; spec = kzalloc(sizeof(*spec), GFP_KERNEL); if (spec == NULL) @@ -3028,35 +2435,60 @@ static int patch_alc260(struct hda_codec *codec) board_config = snd_hda_check_board_config(codec, alc260_cfg_tbl); if (board_config < 0 || board_config >= ALC260_MODEL_LAST) { snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260\n"); - board_config = ALC260_AUTO; + board_config = ALC260_BASIC; } - if (board_config == ALC260_AUTO) { - /* automatic parse from the BIOS config */ - err = alc260_parse_auto_config(codec); - if (err < 0) { - alc_free(codec); - return err; - } else if (! err) { - printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using base mode...\n"); - board_config = ALC260_BASIC; - } + switch (board_config) { + case ALC260_HP: + spec->mixers[spec->num_mixers] = alc260_hp_mixer; + spec->num_mixers++; + break; + case ALC260_FUJITSU_S702x: + spec->mixers[spec->num_mixers] = alc260_fujitsu_mixer; + spec->num_mixers++; + break; + default: + spec->mixers[spec->num_mixers] = alc260_base_mixer; + spec->num_mixers++; + break; } - if (board_config != ALC260_AUTO) - setup_preset(spec, &alc260_presets[board_config]); + if (board_config != ALC260_FUJITSU_S702x) { + spec->init_verbs[0] = alc260_init_verbs; + spec->num_init_verbs = 1; + } else { + spec->init_verbs[0] = alc260_fujitsu_init_verbs; + spec->num_init_verbs = 1; + } + + spec->channel_mode = alc260_modes; + spec->num_channel_mode = ARRAY_SIZE(alc260_modes); spec->stream_name_analog = "ALC260 Analog"; spec->stream_analog_playback = &alc260_pcm_analog_playback; spec->stream_analog_capture = &alc260_pcm_analog_capture; - spec->stream_name_digital = "ALC260 Digital"; - spec->stream_digital_playback = &alc260_pcm_digital_playback; - spec->stream_digital_capture = &alc260_pcm_digital_capture; + spec->multiout.max_channels = spec->channel_mode[0].channels; + spec->multiout.num_dacs = ARRAY_SIZE(alc260_dac_nids); + spec->multiout.dac_nids = alc260_dac_nids; + + if (board_config != ALC260_FUJITSU_S702x) { + spec->input_mux = &alc260_capture_source; + } else { + spec->input_mux = &alc260_fujitsu_capture_source; + } + switch (board_config) { + case ALC260_HP: + spec->num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids); + spec->adc_nids = alc260_hp_adc_nids; + break; + default: + spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids); + spec->adc_nids = alc260_adc_nids; + break; + } codec->patch_ops = alc_patch_ops; - if (board_config == ALC260_AUTO) - codec->patch_ops.init = alc260_auto_init; return 0; } @@ -3073,10 +2505,8 @@ static int patch_alc260(struct hda_codec *codec) * In addition, an independent DAC for the multi-playback (not used in this * driver yet). */ -#define ALC882_DIGOUT_NID 0x06 -#define ALC882_DIGIN_NID 0x0a -static struct hda_channel_mode alc882_ch_modes[1] = { +static struct alc_channel_mode alc882_ch_modes[1] = { { 8, NULL } }; @@ -3085,9 +2515,10 @@ static hda_nid_t alc882_dac_nids[4] = { 0x02, 0x03, 0x04, 0x05 }; -/* identical with ALC880 */ -#define alc882_adc_nids alc880_adc_nids -#define alc882_adc_nids_alt alc880_adc_nids_alt +static hda_nid_t alc882_adc_nids[3] = { + /* ADC0-2 */ + 0x07, 0x08, 0x09, +}; /* input MUX */ /* FIXME: should be a matrix-type input source selection */ @@ -3105,7 +2536,7 @@ static struct hda_input_mux alc882_capture_source = { #define alc882_mux_enum_info alc_mux_enum_info #define alc882_mux_enum_get alc_mux_enum_get -static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int alc882_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct alc_spec *spec = codec->spec; @@ -3130,37 +2561,10 @@ static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 1; } -/* - * 6ch mode - */ -static struct hda_verb alc882_sixstack_ch6_init[] = { - { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, - { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { } /* end */ -}; - -/* - * 8ch mode - */ -static struct hda_verb alc882_sixstack_ch8_init[] = { - { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - { } /* end */ -}; - -static struct hda_channel_mode alc882_sixstack_modes[2] = { - { 6, alc882_sixstack_ch6_init }, - { 8, alc882_sixstack_ch8_init }, -}; - /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17 * Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b */ -static struct snd_kcontrol_new alc882_base_mixer[] = { +static snd_kcontrol_new_t alc882_base_mixer[] = { HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT), HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT), @@ -3200,17 +2604,6 @@ static struct snd_kcontrol_new alc882_base_mixer[] = { { } /* end */ }; -static struct snd_kcontrol_new alc882_chmode_mixer[] = { - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Channel Mode", - .info = alc_ch_mode_info, - .get = alc_ch_mode_get, - .put = alc_ch_mode_put, - }, - { } /* end */ -}; - static struct hda_verb alc882_init_verbs[] = { /* Front mixer: unmute input/output amp left and right (volume = 0) */ {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, @@ -3291,1399 +2684,45 @@ static struct hda_verb alc882_init_verbs[] = { { } }; -/* - * generic initialization of ADC, input mixers and output mixers - */ -static struct hda_verb alc882_auto_init_verbs[] = { - /* - * Unmute ADC0-2 and set the default input to mic-in - */ - {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, +static int patch_alc882(struct hda_codec *codec) +{ + struct alc_spec *spec; - /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback - * mixer widget - * Note: PASD motherboards uses the Line In 2 as the input for front panel - * mic (mic 2) - */ - /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, + spec = kzalloc(sizeof(*spec), GFP_KERNEL); + if (spec == NULL) + return -ENOMEM; - /* - * Set up output mixers (0x0c - 0x0f) - */ - /* set vol=0 to output mixers */ - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - /* set up input amps for analog loopback */ - /* Amp Indices: DAC = 0, mixer = 1 */ - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, + codec->spec = spec; - /* FIXME: use matrix-type input source selection */ - /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ - /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - /* Input mixer2 */ - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - /* Input mixer3 */ - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - - { } -}; - -/* capture mixer elements */ -static struct snd_kcontrol_new alc882_capture_alt_mixer[] = { - HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* The multiple "Capture Source" controls confuse alsamixer - * So call somewhat different.. - * FIXME: the controls appear in the "playback" view! - */ - /* .name = "Capture Source", */ - .name = "Input Source", - .count = 2, - .info = alc882_mux_enum_info, - .get = alc882_mux_enum_get, - .put = alc882_mux_enum_put, - }, - { } /* end */ -}; - -static struct snd_kcontrol_new alc882_capture_mixer[] = { - HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* The multiple "Capture Source" controls confuse alsamixer - * So call somewhat different.. - * FIXME: the controls appear in the "playback" view! - */ - /* .name = "Capture Source", */ - .name = "Input Source", - .count = 3, - .info = alc882_mux_enum_info, - .get = alc882_mux_enum_get, - .put = alc882_mux_enum_put, - }, - { } /* end */ -}; - -/* pcm configuration: identiacal with ALC880 */ -#define alc882_pcm_analog_playback alc880_pcm_analog_playback -#define alc882_pcm_analog_capture alc880_pcm_analog_capture -#define alc882_pcm_digital_playback alc880_pcm_digital_playback -#define alc882_pcm_digital_capture alc880_pcm_digital_capture - -/* - * configuration and preset - */ -static struct hda_board_config alc882_cfg_tbl[] = { - { .modelname = "3stack-dig", .config = ALC861_3ST_DIG }, - { .modelname = "6stack-dig", .config = ALC861_6ST_DIG }, - { .pci_subvendor = 0x1462, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* MSI */ - { .pci_subvendor = 0x105b, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* Foxconn */ - { .pci_subvendor = 0x1019, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* ECS */ - { .modelname = "auto", .config = ALC861_AUTO }, - {} -}; - -static struct alc_config_preset alc882_presets[] = { - [ALC882_3ST_DIG] = { - .mixers = { alc882_base_mixer }, - .init_verbs = { alc882_init_verbs }, - .num_dacs = ARRAY_SIZE(alc882_dac_nids), - .dac_nids = alc882_dac_nids, - .dig_out_nid = ALC882_DIGOUT_NID, - .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), - .adc_nids = alc882_adc_nids, - .dig_in_nid = ALC882_DIGIN_NID, - .num_channel_mode = ARRAY_SIZE(alc882_ch_modes), - .channel_mode = alc882_ch_modes, - .input_mux = &alc882_capture_source, - }, - [ALC882_6ST_DIG] = { - .mixers = { alc882_base_mixer, alc882_chmode_mixer }, - .init_verbs = { alc882_init_verbs }, - .num_dacs = ARRAY_SIZE(alc882_dac_nids), - .dac_nids = alc882_dac_nids, - .dig_out_nid = ALC882_DIGOUT_NID, - .num_adc_nids = ARRAY_SIZE(alc882_adc_nids), - .adc_nids = alc882_adc_nids, - .dig_in_nid = ALC882_DIGIN_NID, - .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes), - .channel_mode = alc882_sixstack_modes, - .input_mux = &alc882_capture_source, - }, -}; - - -/* - * BIOS auto configuration - */ -static void alc882_auto_set_output_and_unmute(struct hda_codec *codec, - hda_nid_t nid, int pin_type, - int dac_idx) -{ - /* set as output */ - struct alc_spec *spec = codec->spec; - int idx; - - if (spec->multiout.dac_nids[dac_idx] == 0x25) - idx = 4; - else - idx = spec->multiout.dac_nids[dac_idx] - 2; - - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx); - -} - -static void alc882_auto_init_multi_out(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int i; - - for (i = 0; i <= HDA_SIDE; i++) { - hda_nid_t nid = spec->autocfg.line_out_pins[i]; - if (nid) - alc882_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); - } -} - -static void alc882_auto_init_hp_out(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - hda_nid_t pin; - - pin = spec->autocfg.hp_pin; - if (pin) /* connect to front */ - alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); /* use dac 0 */ -} - -#define alc882_is_input_pin(nid) alc880_is_input_pin(nid) -#define ALC882_PIN_CD_NID ALC880_PIN_CD_NID - -static void alc882_auto_init_analog_input(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int i; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if (alc882_is_input_pin(nid)) { - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, - i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN); - if (nid != ALC882_PIN_CD_NID) - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, - AMP_OUT_MUTE); - } - } -} - -/* almost identical with ALC880 parser... */ -static int alc882_parse_auto_config(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int err = alc880_parse_auto_config(codec); - - if (err < 0) - return err; - else if (err > 0) - /* hack - override the init verbs */ - spec->init_verbs[0] = alc882_auto_init_verbs; - return err; -} - -/* init callback for auto-configuration model -- overriding the default init */ -static int alc882_auto_init(struct hda_codec *codec) -{ - alc_init(codec); - alc882_auto_init_multi_out(codec); - alc882_auto_init_hp_out(codec); - alc882_auto_init_analog_input(codec); - return 0; -} - -/* - * ALC882 Headphone poll in 3.5.1a or 3.5.2 - */ - -static int patch_alc882(struct hda_codec *codec) -{ - struct alc_spec *spec; - int err, board_config; - - spec = kzalloc(sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; - - board_config = snd_hda_check_board_config(codec, alc882_cfg_tbl); - - if (board_config < 0 || board_config >= ALC882_MODEL_LAST) { - printk(KERN_INFO "hda_codec: Unknown model for ALC882, trying auto-probe from BIOS...\n"); - board_config = ALC882_AUTO; - } + spec->mixers[spec->num_mixers] = alc882_base_mixer; + spec->num_mixers++; - if (board_config == ALC882_AUTO) { - /* automatic parse from the BIOS config */ - err = alc882_parse_auto_config(codec); - if (err < 0) { - alc_free(codec); - return err; - } else if (! err) { - printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using base mode...\n"); - board_config = ALC882_3ST_DIG; - } - } + spec->multiout.dig_out_nid = ALC880_DIGOUT_NID; + spec->dig_in_nid = ALC880_DIGIN_NID; + spec->init_verbs[0] = alc882_init_verbs; + spec->num_init_verbs = 1; - if (board_config != ALC882_AUTO) - setup_preset(spec, &alc882_presets[board_config]); + spec->channel_mode = alc882_ch_modes; + spec->num_channel_mode = ARRAY_SIZE(alc882_ch_modes); spec->stream_name_analog = "ALC882 Analog"; - spec->stream_analog_playback = &alc882_pcm_analog_playback; - spec->stream_analog_capture = &alc882_pcm_analog_capture; + spec->stream_analog_playback = &alc880_pcm_analog_playback; + spec->stream_analog_capture = &alc880_pcm_analog_capture; spec->stream_name_digital = "ALC882 Digital"; - spec->stream_digital_playback = &alc882_pcm_digital_playback; - spec->stream_digital_capture = &alc882_pcm_digital_capture; - - if (! spec->adc_nids && spec->input_mux) { - /* check whether NID 0x07 is valid */ - unsigned int wcap = get_wcaps(codec, 0x07); - wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */ - if (wcap != AC_WID_AUD_IN) { - spec->adc_nids = alc882_adc_nids_alt; - spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt); - spec->mixers[spec->num_mixers] = alc882_capture_alt_mixer; - spec->num_mixers++; - } else { - spec->adc_nids = alc882_adc_nids; - spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids); - spec->mixers[spec->num_mixers] = alc882_capture_mixer; - spec->num_mixers++; - } - } - - codec->patch_ops = alc_patch_ops; - if (board_config == ALC882_AUTO) - codec->patch_ops.init = alc882_auto_init; - - return 0; -} - -/* - * ALC262 support - */ - -#define ALC262_DIGOUT_NID ALC880_DIGOUT_NID -#define ALC262_DIGIN_NID ALC880_DIGIN_NID - -#define alc262_dac_nids alc260_dac_nids -#define alc262_adc_nids alc882_adc_nids -#define alc262_adc_nids_alt alc882_adc_nids_alt - -#define alc262_modes alc260_modes -#define alc262_capture_source alc882_capture_source - -static struct snd_kcontrol_new alc262_base_mixer[] = { - HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT), - HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT), - HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT), - HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT), - HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT), - HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT), - /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT), - HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */ - HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT), - HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Capture Source", - .count = 1, - .info = alc882_mux_enum_info, - .get = alc882_mux_enum_get, - .put = alc882_mux_enum_put, - }, - { } /* end */ -}; - -#define alc262_capture_mixer alc882_capture_mixer -#define alc262_capture_alt_mixer alc882_capture_alt_mixer - -/* - * generic initialization of ADC, input mixers and output mixers - */ -static struct hda_verb alc262_init_verbs[] = { - /* - * Unmute ADC0-2 and set the default input to mic-in - */ - {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - - /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback - * mixer widget - * Note: PASD motherboards uses the Line In 2 as the input for front panel - * mic (mic 2) - */ - /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, - - /* - * Set up output mixers (0x0c - 0x0e) - */ - /* set vol=0 to output mixers */ - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - /* set up input amps for analog loopback */ - /* Amp Indices: DAC = 0, mixer = 1 */ - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, - {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, - {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, - {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, - - {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000}, - - {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, - - /* FIXME: use matrix-type input source selection */ - /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ - /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - /* Input mixer2 */ - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - /* Input mixer3 */ - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - - { } -}; + spec->stream_digital_playback = &alc880_pcm_digital_playback; + spec->stream_digital_capture = &alc880_pcm_digital_capture; -/* add playback controls from the parsed DAC table */ -static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg) -{ - hda_nid_t nid; - int err; + spec->multiout.max_channels = spec->channel_mode[0].channels; + spec->multiout.num_dacs = ARRAY_SIZE(alc882_dac_nids); + spec->multiout.dac_nids = alc882_dac_nids; - spec->multiout.num_dacs = 1; /* only use one dac */ - spec->multiout.dac_nids = spec->private_dac_nids; - spec->multiout.dac_nids[0] = 2; + spec->input_mux = &alc882_capture_source; + spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids); + spec->adc_nids = alc882_adc_nids; - nid = cfg->line_out_pins[0]; - if (nid) { - if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Front Playback Volume", - HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0) - return err; - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Front Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) - return err; - } + codec->patch_ops = alc_patch_ops; - nid = cfg->speaker_pin; - if (nid) { - if (nid == 0x16) { - if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Speaker Playback Volume", - HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0) - return err; - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0) - return err; - } else { - if (! cfg->line_out_pins[0]) - if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Speaker Playback Volume", - HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0) - return err; - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) - return err; - } - } - nid = cfg->hp_pin; - if (nid) { - /* spec->multiout.hp_nid = 2; */ - if (nid == 0x16) { - if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume", - HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0) - return err; - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0) - return err; - } else { - if (! cfg->line_out_pins[0]) - if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume", - HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0) - return err; - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) - return err; - } - } - return 0; -} - -/* identical with ALC880 */ -#define alc262_auto_create_analog_input_ctls alc880_auto_create_analog_input_ctls - -/* - * generic initialization of ADC, input mixers and output mixers - */ -static struct hda_verb alc262_volume_init_verbs[] = { - /* - * Unmute ADC0-2 and set the default input to mic-in - */ - {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x09, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - - /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback - * mixer widget - * Note: PASD motherboards uses the Line In 2 as the input for front panel - * mic (mic 2) - */ - /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */ - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, - {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, - - /* - * Set up output mixers (0x0c - 0x0f) - */ - /* set vol=0 to output mixers */ - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - - /* set up input amps for analog loopback */ - /* Amp Indices: DAC = 0, mixer = 1 */ - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - - /* FIXME: use matrix-type input source selection */ - /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */ - /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */ - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - /* Input mixer2 */ - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - /* Input mixer3 */ - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))}, - {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))}, - - { } -}; - -/* pcm configuration: identiacal with ALC880 */ -#define alc262_pcm_analog_playback alc880_pcm_analog_playback -#define alc262_pcm_analog_capture alc880_pcm_analog_capture -#define alc262_pcm_digital_playback alc880_pcm_digital_playback -#define alc262_pcm_digital_capture alc880_pcm_digital_capture - -/* - * BIOS auto configuration - */ -static int alc262_parse_auto_config(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int err; - static hda_nid_t alc262_ignore[] = { 0x1d, 0 }; - - if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, - alc262_ignore)) < 0) - return err; - if (! spec->autocfg.line_outs && ! spec->autocfg.speaker_pin && - ! spec->autocfg.hp_pin) - return 0; /* can't find valid BIOS pin config */ - if ((err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || - (err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) - return err; - - spec->multiout.max_channels = spec->multiout.num_dacs * 2; - - if (spec->autocfg.dig_out_pin) - spec->multiout.dig_out_nid = ALC262_DIGOUT_NID; - if (spec->autocfg.dig_in_pin) - spec->dig_in_nid = ALC262_DIGIN_NID; - - if (spec->kctl_alloc) - spec->mixers[spec->num_mixers++] = spec->kctl_alloc; - - spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs; - spec->input_mux = &spec->private_imux; - - return 1; -} - -#define alc262_auto_init_multi_out alc882_auto_init_multi_out -#define alc262_auto_init_hp_out alc882_auto_init_hp_out -#define alc262_auto_init_analog_input alc882_auto_init_analog_input - - -/* init callback for auto-configuration model -- overriding the default init */ -static int alc262_auto_init(struct hda_codec *codec) -{ - alc_init(codec); - alc262_auto_init_multi_out(codec); - alc262_auto_init_hp_out(codec); - alc262_auto_init_analog_input(codec); - return 0; -} - -/* - * configuration and preset - */ -static struct hda_board_config alc262_cfg_tbl[] = { - { .modelname = "basic", .config = ALC262_BASIC }, - { .modelname = "auto", .config = ALC262_AUTO }, - {} -}; - -static struct alc_config_preset alc262_presets[] = { - [ALC262_BASIC] = { - .mixers = { alc262_base_mixer }, - .init_verbs = { alc262_init_verbs }, - .num_dacs = ARRAY_SIZE(alc262_dac_nids), - .dac_nids = alc262_dac_nids, - .hp_nid = 0x03, - .num_channel_mode = ARRAY_SIZE(alc262_modes), - .channel_mode = alc262_modes, - .input_mux = &alc262_capture_source, - }, -}; - -static int patch_alc262(struct hda_codec *codec) -{ - struct alc_spec *spec; - int board_config; - int err; - - spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; -#if 0 - /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is under-run */ - { - int tmp; - snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); - tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0); - snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7); - snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80); - } -#endif - - board_config = snd_hda_check_board_config(codec, alc262_cfg_tbl); - if (board_config < 0 || board_config >= ALC262_MODEL_LAST) { - printk(KERN_INFO "hda_codec: Unknown model for ALC262, trying auto-probe from BIOS...\n"); - board_config = ALC262_AUTO; - } - - if (board_config == ALC262_AUTO) { - /* automatic parse from the BIOS config */ - err = alc262_parse_auto_config(codec); - if (err < 0) { - alc_free(codec); - return err; - } else if (! err) { - printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using base mode...\n"); - board_config = ALC262_BASIC; - } - } - - if (board_config != ALC262_AUTO) - setup_preset(spec, &alc262_presets[board_config]); - - spec->stream_name_analog = "ALC262 Analog"; - spec->stream_analog_playback = &alc262_pcm_analog_playback; - spec->stream_analog_capture = &alc262_pcm_analog_capture; - - spec->stream_name_digital = "ALC262 Digital"; - spec->stream_digital_playback = &alc262_pcm_digital_playback; - spec->stream_digital_capture = &alc262_pcm_digital_capture; - - if (! spec->adc_nids && spec->input_mux) { - /* check whether NID 0x07 is valid */ - unsigned int wcap = get_wcaps(codec, 0x07); - - wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */ - if (wcap != AC_WID_AUD_IN) { - spec->adc_nids = alc262_adc_nids_alt; - spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt); - spec->mixers[spec->num_mixers] = alc262_capture_alt_mixer; - spec->num_mixers++; - } else { - spec->adc_nids = alc262_adc_nids; - spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids); - spec->mixers[spec->num_mixers] = alc262_capture_mixer; - spec->num_mixers++; - } - } - - codec->patch_ops = alc_patch_ops; - if (board_config == ALC262_AUTO) - codec->patch_ops.init = alc262_auto_init; - - return 0; -} - - -/* - * ALC861 channel source setting (2/6 channel selection for 3-stack) - */ - -/* - * set the path ways for 2 channel output - * need to set the codec line out and mic 1 pin widgets to inputs - */ -static struct hda_verb alc861_threestack_ch2_init[] = { - /* set pin widget 1Ah (line in) for input */ - { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, - /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */ - { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, - - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, //mic - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, //line in - { } /* end */ -}; -/* - * 6ch mode - * need to set the codec line out and mic 1 pin widgets to outputs - */ -static struct hda_verb alc861_threestack_ch6_init[] = { - /* set pin widget 1Ah (line in) for output (Back Surround)*/ - { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, - /* set pin widget 18h (mic1) for output (CLFE)*/ - { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, - - { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 }, - { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 }, - - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, //mic - { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, //line in - { } /* end */ -}; - -static struct hda_channel_mode alc861_threestack_modes[2] = { - { 2, alc861_threestack_ch2_init }, - { 6, alc861_threestack_ch6_init }, -}; - -/* patch-ALC861 */ - -static struct snd_kcontrol_new alc861_base_mixer[] = { - /* output mixer control */ - HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), - - /*Input mixer control */ - /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ - HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), - HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), - HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), - HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), - HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), - HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), - - /* Capture mixer control */ - HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Capture Source", - .count = 1, - .info = alc_mux_enum_info, - .get = alc_mux_enum_get, - .put = alc_mux_enum_put, - }, - { } /* end */ -}; - -static struct snd_kcontrol_new alc861_3ST_mixer[] = { - /* output mixer control */ - HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT), - /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */ - - /* Input mixer control */ - /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT), - HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */ - HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT), - HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT), - HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT), - HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT), - HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT), - HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT), - - /* Capture mixer control */ - HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Capture Source", - .count = 1, - .info = alc_mux_enum_info, - .get = alc_mux_enum_get, - .put = alc_mux_enum_put, - }, - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Channel Mode", - .info = alc_ch_mode_info, - .get = alc_ch_mode_get, - .put = alc_ch_mode_put, - .private_value = ARRAY_SIZE(alc861_threestack_modes), - }, - { } /* end */ -}; - -/* - * generic initialization of ADC, input mixers and output mixers - */ -static struct hda_verb alc861_base_init_verbs[] = { - /* - * Unmute ADC0 and set the default input to mic-in - */ - /* port-A for surround (rear panel) */ - { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, - { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 }, - /* port-B for mic-in (rear panel) with vref */ - { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, - /* port-C for line-in (rear panel) */ - { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, - /* port-D for Front */ - { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, - { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, - /* port-E for HP out (front panel) */ - { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, - /* route front PCM to HP */ - { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 }, - /* port-F for mic-in (front panel) with vref */ - { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, - /* port-G for CLFE (rear panel) */ - { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, - { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 }, - /* port-H for side (rear panel) */ - { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, - { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 }, - /* CD-in */ - { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, - /* route front mic to ADC1*/ - {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - - /* Unmute DAC0~3 & spdif out*/ - {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - - /* Unmute Mixer 14 (mic) 1c (Line in)*/ - {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - - /* Unmute Stereo Mixer 15 */ - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, //Output 0~12 step - - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front) - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - - { } -}; - -static struct hda_verb alc861_threestack_init_verbs[] = { - /* - * Unmute ADC0 and set the default input to mic-in - */ - /* port-A for surround (rear panel) */ - { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, - /* port-B for mic-in (rear panel) with vref */ - { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, - /* port-C for line-in (rear panel) */ - { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, - /* port-D for Front */ - { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, - { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 }, - /* port-E for HP out (front panel) */ - { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, - /* route front PCM to HP */ - { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 }, - /* port-F for mic-in (front panel) with vref */ - { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, - /* port-G for CLFE (rear panel) */ - { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, - /* port-H for side (rear panel) */ - { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 }, - /* CD-in */ - { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, - /* route front mic to ADC1*/ - {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - /* Unmute DAC0~3 & spdif out*/ - {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - - /* Unmute Mixer 14 (mic) 1c (Line in)*/ - {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - - /* Unmute Stereo Mixer 15 */ - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c }, //Output 0~12 step - - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front) - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - { } -}; -/* - * generic initialization of ADC, input mixers and output mixers - */ -static struct hda_verb alc861_auto_init_verbs[] = { - /* - * Unmute ADC0 and set the default input to mic-in - */ -// {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, - {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - - /* Unmute DAC0~3 & spdif out*/ - {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, - {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - - /* Unmute Mixer 14 (mic) 1c (Line in)*/ - {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - - /* Unmute Stereo Mixer 15 */ - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, - - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, - {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, - - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, - {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, - {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, - {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)}, - {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, - - {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, // set Mic 1 - - { } -}; - -/* pcm configuration: identiacal with ALC880 */ -#define alc861_pcm_analog_playback alc880_pcm_analog_playback -#define alc861_pcm_analog_capture alc880_pcm_analog_capture -#define alc861_pcm_digital_playback alc880_pcm_digital_playback -#define alc861_pcm_digital_capture alc880_pcm_digital_capture - - -#define ALC861_DIGOUT_NID 0x07 - -static struct hda_channel_mode alc861_8ch_modes[1] = { - { 8, NULL } -}; - -static hda_nid_t alc861_dac_nids[4] = { - /* front, surround, clfe, side */ - 0x03, 0x06, 0x05, 0x04 -}; - -static hda_nid_t alc861_adc_nids[1] = { - /* ADC0-2 */ - 0x08, -}; - -static struct hda_input_mux alc861_capture_source = { - .num_items = 5, - .items = { - { "Mic", 0x0 }, - { "Front Mic", 0x3 }, - { "Line", 0x1 }, - { "CD", 0x4 }, - { "Mixer", 0x5 }, - }, -}; - -/* fill in the dac_nids table from the parsed pin configuration */ -static int alc861_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg) -{ - int i; - hda_nid_t nid; - - spec->multiout.dac_nids = spec->private_dac_nids; - for (i = 0; i < cfg->line_outs; i++) { - nid = cfg->line_out_pins[i]; - if (nid) { - if (i >= ARRAY_SIZE(alc861_dac_nids)) - continue; - spec->multiout.dac_nids[i] = alc861_dac_nids[i]; - } - } - spec->multiout.num_dacs = cfg->line_outs; - return 0; -} - -/* add playback controls from the parsed DAC table */ -static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec, - const struct auto_pin_cfg *cfg) -{ - char name[32]; - static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" }; - hda_nid_t nid; - int i, idx, err; - - for (i = 0; i < cfg->line_outs; i++) { - nid = spec->multiout.dac_nids[i]; - if (! nid) - continue; - if (nid == 0x05) { - /* Center/LFE */ - if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0) - return err; - if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0) - return err; - } else { - for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; idx++) - if (nid == alc861_dac_nids[idx]) - break; - sprintf(name, "%s Playback Switch", chname[idx]); - if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name, - HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) - return err; - } - } - return 0; -} - -static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin) -{ - int err; - hda_nid_t nid; - - if (! pin) - return 0; - - if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) { - nid = 0x03; - if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch", - HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) - return err; - spec->multiout.hp_nid = nid; - } - return 0; -} - -/* create playback/capture controls for input pins */ -static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg) -{ - struct hda_input_mux *imux = &spec->private_imux; - int i, err, idx, idx1; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - switch(cfg->input_pins[i]) { - case 0x0c: - idx1 = 1; - idx = 2; // Line In - break; - case 0x0f: - idx1 = 2; - idx = 2; // Line In - break; - case 0x0d: - idx1 = 0; - idx = 1; // Mic In - break; - case 0x10: - idx1 = 3; - idx = 1; // Mic In - break; - case 0x11: - idx1 = 4; - idx = 0; // CD - break; - default: - continue; - } - - err = new_analog_input(spec, cfg->input_pins[i], - auto_pin_cfg_labels[i], idx, 0x15); - if (err < 0) - return err; - - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; - imux->items[imux->num_items].index = idx1; - imux->num_items++; - } - return 0; -} - -static struct snd_kcontrol_new alc861_capture_mixer[] = { - HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT), - - { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* The multiple "Capture Source" controls confuse alsamixer - * So call somewhat different.. - *FIXME: the controls appear in the "playback" view! - */ - /* .name = "Capture Source", */ - .name = "Input Source", - .count = 1, - .info = alc_mux_enum_info, - .get = alc_mux_enum_get, - .put = alc_mux_enum_put, - }, - { } /* end */ -}; - -static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, hda_nid_t nid, - int pin_type, int dac_idx) -{ - /* set as output */ - - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); - snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); - -} - -static void alc861_auto_init_multi_out(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int i; - - for (i = 0; i < spec->autocfg.line_outs; i++) { - hda_nid_t nid = spec->autocfg.line_out_pins[i]; - if (nid) - alc861_auto_set_output_and_unmute(codec, nid, PIN_OUT, spec->multiout.dac_nids[i]); - } -} - -static void alc861_auto_init_hp_out(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - hda_nid_t pin; - - pin = spec->autocfg.hp_pin; - if (pin) /* connect to front */ - alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, spec->multiout.dac_nids[0]); -} - -static void alc861_auto_init_analog_input(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int i; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if ((nid>=0x0c) && (nid <=0x11)) { - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, - i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN); - } - } -} - -/* parse the BIOS configuration and set up the alc_spec */ -/* return 1 if successful, 0 if the proper config is not found, or a negative error code */ -static int alc861_parse_auto_config(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - int err; - static hda_nid_t alc861_ignore[] = { 0x1d, 0 }; - - if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, - alc861_ignore)) < 0) - return err; - if (! spec->autocfg.line_outs && ! spec->autocfg.speaker_pin && - ! spec->autocfg.hp_pin) - return 0; /* can't find valid BIOS pin config */ - - if ((err = alc861_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 || - (err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || - (err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pin)) < 0 || - (err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) - return err; - - spec->multiout.max_channels = spec->multiout.num_dacs * 2; - - if (spec->autocfg.dig_out_pin) - spec->multiout.dig_out_nid = ALC861_DIGOUT_NID; - - if (spec->kctl_alloc) - spec->mixers[spec->num_mixers++] = spec->kctl_alloc; - - spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs; - - spec->input_mux = &spec->private_imux; - - spec->adc_nids = alc861_adc_nids; - spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids); - spec->mixers[spec->num_mixers] = alc861_capture_mixer; - spec->num_mixers++; - - return 1; -} - -/* init callback for auto-configuration model -- overriding the default init */ -static int alc861_auto_init(struct hda_codec *codec) -{ - alc_init(codec); - alc861_auto_init_multi_out(codec); - alc861_auto_init_hp_out(codec); - alc861_auto_init_analog_input(codec); - - return 0; -} - - -/* - * configuration and preset - */ -static struct hda_board_config alc861_cfg_tbl[] = { - { .modelname = "3stack", .config = ALC861_3ST }, - { .pci_subvendor = 0x8086, .pci_subdevice = 0xd600, .config = ALC861_3ST }, - { .modelname = "3stack-dig", .config = ALC861_3ST_DIG }, - { .modelname = "6stack-dig", .config = ALC861_6ST_DIG }, - { .modelname = "auto", .config = ALC861_AUTO }, - {} -}; - -static struct alc_config_preset alc861_presets[] = { - [ALC861_3ST] = { - .mixers = { alc861_3ST_mixer }, - .init_verbs = { alc861_threestack_init_verbs }, - .num_dacs = ARRAY_SIZE(alc861_dac_nids), - .dac_nids = alc861_dac_nids, - .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), - .channel_mode = alc861_threestack_modes, - .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), - .adc_nids = alc861_adc_nids, - .input_mux = &alc861_capture_source, - }, - [ALC861_3ST_DIG] = { - .mixers = { alc861_base_mixer }, - .init_verbs = { alc861_threestack_init_verbs }, - .num_dacs = ARRAY_SIZE(alc861_dac_nids), - .dac_nids = alc861_dac_nids, - .dig_out_nid = ALC861_DIGOUT_NID, - .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes), - .channel_mode = alc861_threestack_modes, - .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), - .adc_nids = alc861_adc_nids, - .input_mux = &alc861_capture_source, - }, - [ALC861_6ST_DIG] = { - .mixers = { alc861_base_mixer }, - .init_verbs = { alc861_base_init_verbs }, - .num_dacs = ARRAY_SIZE(alc861_dac_nids), - .dac_nids = alc861_dac_nids, - .dig_out_nid = ALC861_DIGOUT_NID, - .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes), - .channel_mode = alc861_8ch_modes, - .num_adc_nids = ARRAY_SIZE(alc861_adc_nids), - .adc_nids = alc861_adc_nids, - .input_mux = &alc861_capture_source, - }, -}; - - -static int patch_alc861(struct hda_codec *codec) -{ - struct alc_spec *spec; - int board_config; - int err; - - spec = kcalloc(1, sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; - - board_config = snd_hda_check_board_config(codec, alc861_cfg_tbl); - if (board_config < 0 || board_config >= ALC861_MODEL_LAST) { - printk(KERN_INFO "hda_codec: Unknown model for ALC861, trying auto-probe from BIOS...\n"); - board_config = ALC861_AUTO; - } - - if (board_config == ALC861_AUTO) { - /* automatic parse from the BIOS config */ - err = alc861_parse_auto_config(codec); - if (err < 0) { - alc_free(codec); - return err; - } else if (! err) { - printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using base mode...\n"); - board_config = ALC861_3ST_DIG; - } - } - - if (board_config != ALC861_AUTO) - setup_preset(spec, &alc861_presets[board_config]); - - spec->stream_name_analog = "ALC861 Analog"; - spec->stream_analog_playback = &alc861_pcm_analog_playback; - spec->stream_analog_capture = &alc861_pcm_analog_capture; - - spec->stream_name_digital = "ALC861 Digital"; - spec->stream_digital_playback = &alc861_pcm_digital_playback; - spec->stream_digital_capture = &alc861_pcm_digital_capture; - - codec->patch_ops = alc_patch_ops; - if (board_config == ALC861_AUTO) - codec->patch_ops.init = alc861_auto_init; - return 0; } @@ -4692,11 +2731,7 @@ static int patch_alc861(struct hda_codec *codec) */ struct hda_codec_preset snd_hda_preset_realtek[] = { { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 }, - { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 }, { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 }, { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 }, - { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 }, - { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 }, - { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 }, {} /* terminator */ }; diff --git a/trunk/sound/pci/hda/patch_si3054.c b/trunk/sound/pci/hda/patch_si3054.c index 8f8840e6002b..9c7fe0b3200a 100644 --- a/trunk/sound/pci/hda/patch_si3054.c +++ b/trunk/sound/pci/hda/patch_si3054.c @@ -95,8 +95,8 @@ struct si3054_spec { #define PRIVATE_REG(val) ((val>>16)&0xffff) #define PRIVATE_MASK(val) (val&0xffff) -static int si3054_switch_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int si3054_switch_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -105,8 +105,8 @@ static int si3054_switch_info(struct snd_kcontrol *kcontrol, return 0; } -static int si3054_switch_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *uvalue) +static int si3054_switch_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *uvalue) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); u16 reg = PRIVATE_REG(kcontrol->private_value); @@ -115,8 +115,8 @@ static int si3054_switch_get(struct snd_kcontrol *kcontrol, return 0; } -static int si3054_switch_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *uvalue) +static int si3054_switch_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *uvalue) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); u16 reg = PRIVATE_REG(kcontrol->private_value); @@ -138,7 +138,7 @@ static int si3054_switch_put(struct snd_kcontrol *kcontrol, } -static struct snd_kcontrol_new si3054_modem_mixer[] = { +static snd_kcontrol_new_t si3054_modem_mixer[] = { SI3054_KCONTROL("Off-hook Switch", SI3054_GPIO_CONTROL, SI3054_GPIO_OH), SI3054_KCONTROL("Caller ID Switch", SI3054_GPIO_CONTROL, SI3054_GPIO_CID), {} @@ -158,7 +158,7 @@ static int si3054_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { u16 val; @@ -175,10 +175,10 @@ static int si3054_pcm_prepare(struct hda_pcm_stream *hinfo, static int si3054_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { static unsigned int rates[] = { 8000, 9600, 16000 }; - static struct snd_pcm_hw_constraint_list hw_constraints_rates = { + static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, @@ -295,7 +295,6 @@ static int patch_si3054(struct hda_codec *codec) * patch entries */ struct hda_codec_preset snd_hda_preset_si3054[] = { - { .id = 0x163c3055, .name = "Si3054", .patch = patch_si3054 }, { .id = 0x163c3155, .name = "Si3054", .patch = patch_si3054 }, {} }; diff --git a/trunk/sound/pci/hda/patch_sigmatel.c b/trunk/sound/pci/hda/patch_sigmatel.c index 61903848cd43..33a8adaea768 100644 --- a/trunk/sound/pci/hda/patch_sigmatel.c +++ b/trunk/sound/pci/hda/patch_sigmatel.c @@ -4,7 +4,7 @@ * HD audio interface patch for SigmaTel STAC92xx * * Copyright (c) 2005 Embedded Alley Solutions, Inc. - * Matt Porter <mporter@embeddedalley.com> + * <matt@embeddedalley.com> * * Based on patch_cmedia.c and patch_realtek.c * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> @@ -34,22 +34,17 @@ #include "hda_codec.h" #include "hda_local.h" +#undef STAC_TEST + #define NUM_CONTROL_ALLOC 32 #define STAC_HP_EVENT 0x37 #define STAC_UNSOL_ENABLE (AC_USRSP_EN | STAC_HP_EVENT) -#define STAC_REF 0 -#define STAC_D945GTP3 1 -#define STAC_D945GTP5 2 - struct sigmatel_spec { - struct snd_kcontrol_new *mixers[4]; + snd_kcontrol_new_t *mixers[4]; unsigned int num_mixers; - int board_config; unsigned int surr_switch: 1; - unsigned int line_switch: 1; - unsigned int mic_switch: 1; /* playback */ struct hda_multi_out multiout; @@ -62,28 +57,31 @@ struct sigmatel_spec { unsigned int num_muxes; hda_nid_t dig_in_nid; +#ifdef STAC_TEST /* pin widgets */ hda_nid_t *pin_nids; unsigned int num_pins; unsigned int *pin_configs; +#endif /* codec specific stuff */ struct hda_verb *init; - struct snd_kcontrol_new *mixer; + snd_kcontrol_new_t *mixer; /* capture source */ struct hda_input_mux *input_mux; unsigned int cur_mux[2]; - /* i/o switches */ - unsigned int io_switch[2]; + /* channel mode */ + unsigned int num_ch_modes; + unsigned int cur_ch_mode; struct hda_pcm pcm_rec[2]; /* PCM information */ /* dynamic controls and input_mux */ struct auto_pin_cfg autocfg; unsigned int num_kctl_alloc, num_kctl_used; - struct snd_kcontrol_new *kctl_alloc; + snd_kcontrol_new_t *kctl_alloc; struct hda_input_mux private_imux; }; @@ -107,6 +105,7 @@ static hda_nid_t stac922x_mux_nids[2] = { 0x12, 0x13, }; +#ifdef STAC_TEST static hda_nid_t stac9200_pin_nids[8] = { 0x08, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, }; @@ -115,15 +114,16 @@ static hda_nid_t stac922x_pin_nids[10] = { 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x15, 0x1b, }; +#endif -static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int stac92xx_mux_enum_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct sigmatel_spec *spec = codec->spec; return snd_hda_input_mux_info(spec->input_mux, uinfo); } -static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac92xx_mux_enum_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct sigmatel_spec *spec = codec->spec; @@ -133,7 +133,7 @@ static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac92xx_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct sigmatel_spec *spec = codec->spec; @@ -155,7 +155,50 @@ static struct hda_verb stac922x_core_init[] = { {} }; -static struct snd_kcontrol_new stac9200_mixer[] = { +static int stac922x_channel_modes[3] = {2, 6, 8}; + +static int stac922x_ch_mode_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) +{ + struct hda_codec *codec = snd_kcontrol_chip(kcontrol); + struct sigmatel_spec *spec = codec->spec; + + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; + uinfo->count = 1; + uinfo->value.enumerated.items = spec->num_ch_modes; + if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) + uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; + sprintf(uinfo->value.enumerated.name, "%dch", + stac922x_channel_modes[uinfo->value.enumerated.item]); + return 0; +} + +static int stac922x_ch_mode_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) +{ + struct hda_codec *codec = snd_kcontrol_chip(kcontrol); + struct sigmatel_spec *spec = codec->spec; + + ucontrol->value.enumerated.item[0] = spec->cur_ch_mode; + return 0; +} + +static int stac922x_ch_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) +{ + struct hda_codec *codec = snd_kcontrol_chip(kcontrol); + struct sigmatel_spec *spec = codec->spec; + + if (ucontrol->value.enumerated.item[0] >= spec->num_ch_modes) + ucontrol->value.enumerated.item[0] = spec->num_ch_modes; + if (ucontrol->value.enumerated.item[0] == spec->cur_ch_mode && + ! codec->in_resume) + return 0; + + spec->cur_ch_mode = ucontrol->value.enumerated.item[0]; + spec->multiout.max_channels = stac922x_channel_modes[spec->cur_ch_mode]; + + return 1; +} + +static snd_kcontrol_new_t stac9200_mixer[] = { HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT), HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT), { @@ -173,7 +216,7 @@ static struct snd_kcontrol_new stac9200_mixer[] = { }; /* This needs to be generated dynamically based on sequence */ -static struct snd_kcontrol_new stac922x_mixer[] = { +static snd_kcontrol_new_t stac922x_mixer[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Input Source", @@ -183,10 +226,22 @@ static struct snd_kcontrol_new stac922x_mixer[] = { .put = stac92xx_mux_enum_put, }, HDA_CODEC_VOLUME("Capture Volume", 0x17, 0x0, HDA_INPUT), + HDA_CODEC_MUTE("Capture Switch", 0x17, 0x0, HDA_INPUT), HDA_CODEC_VOLUME("Mux Capture Volume", 0x12, 0x0, HDA_OUTPUT), { } /* end */ }; +static snd_kcontrol_new_t stac922x_ch_mode_mixer[] = { + { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Channel Mode", + .info = stac922x_ch_mode_info, + .get = stac922x_ch_mode_get, + .put = stac922x_ch_mode_put, + }, + { } /* end */ +}; + static int stac92xx_build_controls(struct hda_codec *codec) { struct sigmatel_spec *spec = codec->spec; @@ -203,6 +258,11 @@ static int stac92xx_build_controls(struct hda_codec *codec) return err; } + if (spec->surr_switch) { + err = snd_hda_add_new_ctls(codec, stac922x_ch_mode_mixer); + if (err < 0) + return err; + } if (spec->multiout.dig_out_nid) { err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); if (err < 0) @@ -216,67 +276,18 @@ static int stac92xx_build_controls(struct hda_codec *codec) return 0; } -static unsigned int ref9200_pin_configs[8] = { +#ifdef STAC_TEST +static unsigned int stac9200_pin_configs[8] = { 0x01c47010, 0x01447010, 0x0221401f, 0x01114010, 0x02a19020, 0x01a19021, 0x90100140, 0x01813122, }; -static unsigned int *stac9200_brd_tbl[] = { - ref9200_pin_configs, -}; - -static struct hda_board_config stac9200_cfg_tbl[] = { - { .modelname = "ref", - .pci_subvendor = PCI_VENDOR_ID_INTEL, - .pci_subdevice = 0x2668, /* DFI LanParty */ - .config = STAC_REF }, - {} /* terminator */ -}; - -static unsigned int ref922x_pin_configs[10] = { - 0x01014010, 0x01016011, 0x01012012, 0x0221401f, - 0x01813122, 0x01011014, 0x01441030, 0x01c41030, +static unsigned int stac922x_pin_configs[10] = { + 0x01014010, 0x01014011, 0x01014012, 0x0221401f, + 0x01813122, 0x01014014, 0x01441030, 0x01c41030, 0x40000100, 0x40000100, }; -static unsigned int d945gtp3_pin_configs[10] = { - 0x0221401f, 0x01a19022, 0x01813021, 0x01114010, - 0x40000100, 0x40000100, 0x40000100, 0x40000100, - 0x02a19120, 0x40000100, -}; - -static unsigned int d945gtp5_pin_configs[10] = { - 0x0221401f, 0x01111012, 0x01813024, 0x01114010, - 0x01a19021, 0x01116011, 0x01452130, 0x40000100, - 0x02a19320, 0x40000100, -}; - -static unsigned int *stac922x_brd_tbl[] = { - ref922x_pin_configs, - d945gtp3_pin_configs, - d945gtp5_pin_configs, -}; - -static struct hda_board_config stac922x_cfg_tbl[] = { - { .modelname = "ref", - .pci_subvendor = PCI_VENDOR_ID_INTEL, - .pci_subdevice = 0x2668, /* DFI LanParty */ - .config = STAC_REF }, /* SigmaTel reference board */ - { .pci_subvendor = PCI_VENDOR_ID_INTEL, - .pci_subdevice = 0x0101, - .config = STAC_D945GTP3 }, /* Intel D945GTP - 3 Stack */ - { .pci_subvendor = PCI_VENDOR_ID_INTEL, - .pci_subdevice = 0x0404, - .config = STAC_D945GTP5 }, /* Intel D945GTP - 5 Stack */ - { .pci_subvendor = PCI_VENDOR_ID_INTEL, - .pci_subdevice = 0x0303, - .config = STAC_D945GTP5 }, /* Intel D945GNT - 5 Stack */ - { .pci_subvendor = PCI_VENDOR_ID_INTEL, - .pci_subdevice = 0x0013, - .config = STAC_D945GTP5 }, /* Intel D955XBK - 5 Stack */ - {} /* terminator */ -}; - static void stac92xx_set_config_regs(struct hda_codec *codec) { int i; @@ -299,34 +310,86 @@ static void stac92xx_set_config_regs(struct hda_codec *codec) pin_cfg = snd_hda_codec_read(codec, spec->pin_nids[i], 0, AC_VERB_GET_CONFIG_DEFAULT, 0x00); - snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n", spec->pin_nids[i], pin_cfg); + printk("pin nid %2.2x pin config %8.8x\n", spec->pin_nids[i], pin_cfg); } } +#endif /* * Analog playback callbacks */ static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct sigmatel_spec *spec = codec->spec; return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream); } +/* + * set up the i/o for analog out + * when the digital out is available, copy the front out to digital out, too. + */ +static int stac92xx_multi_out_analog_prepare(struct hda_codec *codec, struct hda_multi_out *mout, + unsigned int stream_tag, + unsigned int format, + snd_pcm_substream_t *substream) +{ + hda_nid_t *nids = mout->dac_nids; + int chs = substream->runtime->channels; + int i; + + down(&codec->spdif_mutex); + if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) { + if (chs == 2 && + snd_hda_is_supported_format(codec, mout->dig_out_nid, format) && + ! (codec->spdif_status & IEC958_AES0_NONAUDIO)) { + mout->dig_out_used = HDA_DIG_ANALOG_DUP; + /* setup digital receiver */ + snd_hda_codec_setup_stream(codec, mout->dig_out_nid, + stream_tag, 0, format); + } else { + mout->dig_out_used = 0; + snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 0, 0, 0); + } + } + up(&codec->spdif_mutex); + + /* front */ + snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 0, format); + if (mout->hp_nid) + /* headphone out will just decode front left/right (stereo) */ + snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 0, format); + /* surrounds */ + if (mout->max_channels > 2) + for (i = 1; i < mout->num_dacs; i++) { + if ((mout->max_channels == 6) && (i == 3)) + break; + if (chs >= (i + 1) * 2) /* independent out */ + snd_hda_codec_setup_stream(codec, nids[i], stream_tag, i * 2, + format); + else /* copy front */ + snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 0, + format); + } + return 0; +} + + static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct sigmatel_spec *spec = codec->spec; - return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream); + return stac92xx_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, + format, substream); } static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct sigmatel_spec *spec = codec->spec; return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); @@ -337,7 +400,7 @@ static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, */ static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct sigmatel_spec *spec = codec->spec; return snd_hda_multi_out_dig_open(codec, &spec->multiout); @@ -345,7 +408,7 @@ static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct sigmatel_spec *spec = codec->spec; return snd_hda_multi_out_dig_close(codec, &spec->multiout); @@ -359,7 +422,7 @@ static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, unsigned int format, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct sigmatel_spec *spec = codec->spec; @@ -370,7 +433,7 @@ static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo, static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, struct hda_codec *codec, - struct snd_pcm_substream *substream) + snd_pcm_substream_t *substream) { struct sigmatel_spec *spec = codec->spec; @@ -448,76 +511,20 @@ static int stac92xx_build_pcms(struct hda_codec *codec) return 0; } -static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type) - -{ - snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); -} - -static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; - uinfo->count = 1; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 1; - return 0; -} - -static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - struct sigmatel_spec *spec = codec->spec; - int io_idx = kcontrol-> private_value & 0xff; - - ucontrol->value.integer.value[0] = spec->io_switch[io_idx]; - return 0; -} - -static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) -{ - struct hda_codec *codec = snd_kcontrol_chip(kcontrol); - struct sigmatel_spec *spec = codec->spec; - hda_nid_t nid = kcontrol->private_value >> 8; - int io_idx = kcontrol-> private_value & 0xff; - unsigned short val = ucontrol->value.integer.value[0]; - - spec->io_switch[io_idx] = val; - - if (val) - stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); - else - stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_IN_EN); - - return 1; -} - -#define STAC_CODEC_IO_SWITCH(xname, xpval) \ - { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ - .name = xname, \ - .index = 0, \ - .info = stac92xx_io_switch_info, \ - .get = stac92xx_io_switch_get, \ - .put = stac92xx_io_switch_put, \ - .private_value = xpval, \ - } - - enum { STAC_CTL_WIDGET_VOL, STAC_CTL_WIDGET_MUTE, - STAC_CTL_WIDGET_IO_SWITCH, }; -static struct snd_kcontrol_new stac92xx_control_templates[] = { +static snd_kcontrol_new_t stac92xx_control_templates[] = { HDA_CODEC_VOLUME(NULL, 0, 0, 0), HDA_CODEC_MUTE(NULL, 0, 0, 0), - STAC_CODEC_IO_SWITCH(NULL, 0), }; /* add dynamic controls */ static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val) { - struct snd_kcontrol_new *knew; + snd_kcontrol_new_t *knew; if (spec->num_kctl_used >= spec->num_kctl_alloc) { int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; @@ -543,51 +550,6 @@ static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char return 0; } -/* flag inputs as additional dynamic lineouts */ -static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg) -{ - struct sigmatel_spec *spec = codec->spec; - - switch (cfg->line_outs) { - case 3: - /* add line-in as side */ - if (cfg->input_pins[AUTO_PIN_LINE]) { - cfg->line_out_pins[3] = cfg->input_pins[AUTO_PIN_LINE]; - spec->line_switch = 1; - cfg->line_outs++; - } - break; - case 2: - /* add line-in as clfe and mic as side */ - if (cfg->input_pins[AUTO_PIN_LINE]) { - cfg->line_out_pins[2] = cfg->input_pins[AUTO_PIN_LINE]; - spec->line_switch = 1; - cfg->line_outs++; - } - if (cfg->input_pins[AUTO_PIN_MIC]) { - cfg->line_out_pins[3] = cfg->input_pins[AUTO_PIN_MIC]; - spec->mic_switch = 1; - cfg->line_outs++; - } - break; - case 1: - /* add line-in as surr and mic as clfe */ - if (cfg->input_pins[AUTO_PIN_LINE]) { - cfg->line_out_pins[1] = cfg->input_pins[AUTO_PIN_LINE]; - spec->line_switch = 1; - cfg->line_outs++; - } - if (cfg->input_pins[AUTO_PIN_MIC]) { - cfg->line_out_pins[2] = cfg->input_pins[AUTO_PIN_MIC]; - spec->mic_switch = 1; - cfg->line_outs++; - } - break; - } - - return 0; -} - /* fill in the dac_nids table from the parsed pin configuration */ static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { @@ -616,7 +578,7 @@ static int stac92xx_auto_create_multi_out_ctls(struct sigmatel_spec *spec, const int i, err; for (i = 0; i < cfg->line_outs; i++) { - if (!spec->multiout.dac_nids[i]) + if (! spec->multiout.dac_nids[i]) continue; nid = spec->multiout.dac_nids[i]; @@ -647,14 +609,6 @@ static int stac92xx_auto_create_multi_out_ctls(struct sigmatel_spec *spec, const } } - if (spec->line_switch) - if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0) - return err; - - if (spec->mic_switch) - if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0) - return err; - return 0; } @@ -670,7 +624,7 @@ static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec, struct auto_pin if (! pin) return 0; - wid_caps = get_wcaps(codec, pin); + wid_caps = snd_hda_param_read(codec, pin, AC_PAR_AUDIO_WIDGET_CAP); if (wid_caps & AC_WCAP_UNSOL_CAP) /* Enable unsolicited responses on the HP widget */ snd_hda_codec_write(codec, pin, 0, @@ -702,6 +656,9 @@ static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec, struct auto_pin static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { struct sigmatel_spec *spec = codec->spec; + static char *labels[AUTO_PIN_LAST] = { + "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" + }; struct hda_input_mux *imux = &spec->private_imux; hda_nid_t con_lst[HDA_MAX_NUM_INPUTS]; int i, j, k; @@ -709,10 +666,7 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const for (i = 0; i < AUTO_PIN_LAST; i++) { int index = -1; if (cfg->input_pins[i]) { - /* Enable active pin widget as an input */ - stac92xx_auto_set_pinctl(codec, cfg->input_pins[i], AC_PINCTL_IN_EN); - - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; + imux->items[imux->num_items].label = labels[i]; for (j=0; j<spec->num_muxes; j++) { int num_cons = snd_hda_get_connections(codec, spec->mux_nids[j], con_lst, HDA_MAX_NUM_INPUTS); @@ -732,6 +686,12 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const return 0; } +static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type) + +{ + snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); +} + static void stac92xx_auto_init_multi_out(struct hda_codec *codec) { struct sigmatel_spec *spec = codec->spec; @@ -758,9 +718,7 @@ static int stac922x_parse_auto_config(struct hda_codec *codec) struct sigmatel_spec *spec = codec->spec; int err; - if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) - return err; - if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0) + if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg)) < 0) return err; if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0) return err; @@ -773,8 +731,15 @@ static int stac922x_parse_auto_config(struct hda_codec *codec) return err; spec->multiout.max_channels = spec->multiout.num_dacs * 2; - if (spec->multiout.max_channels > 2) + if (spec->multiout.max_channels > 2) { spec->surr_switch = 1; + spec->cur_ch_mode = 1; + spec->num_ch_modes = 2; + if (spec->multiout.max_channels == 8) { + spec->cur_ch_mode++; + spec->num_ch_modes++; + } + } if (spec->autocfg.dig_out_pin) { spec->multiout.dig_out_nid = 0x08; @@ -798,7 +763,7 @@ static int stac9200_parse_auto_config(struct hda_codec *codec) struct sigmatel_spec *spec = codec->spec; int err; - if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) + if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg)) < 0) return err; if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0) @@ -821,10 +786,33 @@ static int stac9200_parse_auto_config(struct hda_codec *codec) return 1; } +static int stac92xx_init_pstate(struct hda_codec *codec) +{ + hda_nid_t nid, nid_start; + int nodes; + + snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_POWER_STATE, 0x00); + + nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid_start); + for (nid = nid_start; nid < nodes + nid_start; nid++) { + unsigned int wid_caps = snd_hda_param_read(codec, nid, + AC_PAR_AUDIO_WIDGET_CAP); + if (wid_caps & AC_WCAP_POWER) + snd_hda_codec_write(codec, nid, 0, + AC_VERB_SET_POWER_STATE, 0x00); + } + + mdelay(100); + + return 0; +} + static int stac92xx_init(struct hda_codec *codec) { struct sigmatel_spec *spec = codec->spec; + stac92xx_init_pstate(codec); + snd_hda_sequence_write(codec, spec->init); stac92xx_auto_init_multi_out(codec); @@ -936,16 +924,13 @@ static int patch_stac9200(struct hda_codec *codec) return -ENOMEM; codec->spec = spec; - spec->board_config = snd_hda_check_board_config(codec, stac9200_cfg_tbl); - if (spec->board_config < 0) - snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n"); - else { - spec->num_pins = 8; - spec->pin_nids = stac9200_pin_nids; - spec->pin_configs = stac9200_brd_tbl[spec->board_config]; - stac92xx_set_config_regs(codec); - } +#ifdef STAC_TEST + spec->pin_nids = stac9200_pin_nids; + spec->num_pins = 8; + spec->pin_configs = stac9200_pin_configs; + stac92xx_set_config_regs(codec); +#endif spec->multiout.max_channels = 2; spec->multiout.num_dacs = 1; spec->multiout.dac_nids = stac9200_dac_nids; @@ -977,16 +962,13 @@ static int patch_stac922x(struct hda_codec *codec) return -ENOMEM; codec->spec = spec; - spec->board_config = snd_hda_check_board_config(codec, stac922x_cfg_tbl); - if (spec->board_config < 0) - snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, using BIOS defaults\n"); - else { - spec->num_pins = 10; - spec->pin_nids = stac922x_pin_nids; - spec->pin_configs = stac922x_brd_tbl[spec->board_config]; - stac92xx_set_config_regs(codec); - } +#ifdef STAC_TEST + spec->num_pins = 10; + spec->pin_nids = stac922x_pin_nids; + spec->pin_configs = stac922x_pin_configs; + stac92xx_set_config_regs(codec); +#endif spec->adc_nids = stac922x_adc_nids; spec->mux_nids = stac922x_mux_nids; spec->num_muxes = 2; diff --git a/trunk/sound/pci/ice1712/ak4xxx.c b/trunk/sound/pci/ice1712/ak4xxx.c index ab00cce2c39f..ae9dc029ba0d 100644 --- a/trunk/sound/pci/ice1712/ak4xxx.c +++ b/trunk/sound/pci/ice1712/ak4xxx.c @@ -34,16 +34,16 @@ MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); MODULE_DESCRIPTION("ICEnsemble ICE17xx <-> AK4xxx AD/DA chip interface"); MODULE_LICENSE("GPL"); -static void snd_ice1712_akm4xxx_lock(struct snd_akm4xxx *ak, int chip) +static void snd_ice1712_akm4xxx_lock(akm4xxx_t *ak, int chip) { - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_ice1712_save_gpio_status(ice); } -static void snd_ice1712_akm4xxx_unlock(struct snd_akm4xxx *ak, int chip) +static void snd_ice1712_akm4xxx_unlock(akm4xxx_t *ak, int chip) { - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_ice1712_restore_gpio_status(ice); } @@ -51,14 +51,14 @@ static void snd_ice1712_akm4xxx_unlock(struct snd_akm4xxx *ak, int chip) /* * write AK4xxx register */ -static void snd_ice1712_akm4xxx_write(struct snd_akm4xxx *ak, int chip, +static void snd_ice1712_akm4xxx_write(akm4xxx_t *ak, int chip, unsigned char addr, unsigned char data) { unsigned int tmp; int idx; unsigned int addrdata; struct snd_ak4xxx_private *priv = (void *)ak->private_value[0]; - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_assert(chip >= 0 && chip < 4, return); @@ -119,10 +119,10 @@ static void snd_ice1712_akm4xxx_write(struct snd_akm4xxx *ak, int chip, } /* - * initialize the struct snd_akm4xxx record with the template + * initialize the akm4xxx_t record with the template */ -int snd_ice1712_akm4xxx_init(struct snd_akm4xxx *ak, const struct snd_akm4xxx *temp, - const struct snd_ak4xxx_private *_priv, struct snd_ice1712 *ice) +int snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *temp, + const struct snd_ak4xxx_private *_priv, ice1712_t *ice) { struct snd_ak4xxx_private *priv; @@ -148,13 +148,13 @@ int snd_ice1712_akm4xxx_init(struct snd_akm4xxx *ak, const struct snd_akm4xxx *t return 0; } -void snd_ice1712_akm4xxx_free(struct snd_ice1712 *ice) +void snd_ice1712_akm4xxx_free(ice1712_t *ice) { unsigned int akidx; if (ice->akm == NULL) return; for (akidx = 0; akidx < ice->akm_codecs; akidx++) { - struct snd_akm4xxx *ak = &ice->akm[akidx]; + akm4xxx_t *ak = &ice->akm[akidx]; kfree((void*)ak->private_value[0]); } kfree(ice->akm); @@ -163,13 +163,13 @@ void snd_ice1712_akm4xxx_free(struct snd_ice1712 *ice) /* * build AK4xxx controls */ -int snd_ice1712_akm4xxx_build_controls(struct snd_ice1712 *ice) +int snd_ice1712_akm4xxx_build_controls(ice1712_t *ice) { unsigned int akidx; int err; for (akidx = 0; akidx < ice->akm_codecs; akidx++) { - struct snd_akm4xxx *ak = &ice->akm[akidx]; + akm4xxx_t *ak = &ice->akm[akidx]; err = snd_akm4xxx_build_controls(ak); if (err < 0) return err; diff --git a/trunk/sound/pci/ice1712/amp.c b/trunk/sound/pci/ice1712/amp.c index 59c4078ad331..289b0b5711e4 100644 --- a/trunk/sound/pci/ice1712/amp.c +++ b/trunk/sound/pci/ice1712/amp.c @@ -33,14 +33,14 @@ #include "envy24ht.h" #include "amp.h" -static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) +static void wm_put(ice1712_t *ice, int reg, unsigned short val) { unsigned short cval; cval = (reg << 9) | val; snd_vt1724_write_i2c(ice, WM_DEV, cval >> 8, cval & 0xff); } -static int __devinit snd_vt1724_amp_init(struct snd_ice1712 *ice) +static int __devinit snd_vt1724_amp_init(ice1712_t *ice) { static unsigned short wm_inits[] = { WM_ATTEN_L, 0x0000, /* 0 db */ @@ -66,7 +66,7 @@ static int __devinit snd_vt1724_amp_init(struct snd_ice1712 *ice) return 0; } -static int __devinit snd_vt1724_amp_add_controls(struct snd_ice1712 *ice) +static int __devinit snd_vt1724_amp_add_controls(ice1712_t *ice) { /* we use pins 39 and 41 of the VT1616 for left and right read outputs */ snd_ac97_write_cache(ice->ac97, 0x5a, snd_ac97_read(ice->ac97, 0x5a) & ~0x8000); diff --git a/trunk/sound/pci/ice1712/aureon.c b/trunk/sound/pci/ice1712/aureon.c index 8809812a1c22..db12b038286b 100644 --- a/trunk/sound/pci/ice1712/aureon.c +++ b/trunk/sound/pci/ice1712/aureon.c @@ -22,7 +22,7 @@ * * NOTES: * - * - we reuse the struct snd_akm4xxx record for storing the wm8770 codec data. + * - we reuse the akm4xxx_t record for storing the wm8770 codec data. * both wm and akm codecs are pretty similar, so we can integrate * both controls in the future, once if wm codecs are reused in * many boards. @@ -85,7 +85,7 @@ #define CS8415_C_BUFFER 0x20 #define CS8415_ID 0x7F -static void aureon_ac97_write(struct snd_ice1712 *ice, unsigned short reg, unsigned short val) { +static void aureon_ac97_write(ice1712_t *ice, unsigned short reg, unsigned short val) { unsigned int tmp; /* Send address to XILINX chip */ @@ -136,7 +136,7 @@ static void aureon_ac97_write(struct snd_ice1712 *ice, unsigned short reg, unsig ice->spec.aureon.stac9744[(reg & 0x7F) >> 1] = val; } -static unsigned short aureon_ac97_read(struct snd_ice1712 *ice, unsigned short reg) +static unsigned short aureon_ac97_read(ice1712_t *ice, unsigned short reg) { return ice->spec.aureon.stac9744[(reg & 0x7F) >> 1]; } @@ -144,7 +144,7 @@ static unsigned short aureon_ac97_read(struct snd_ice1712 *ice, unsigned short r /* * Initialize STAC9744 chip */ -static int aureon_ac97_init (struct snd_ice1712 *ice) { +static int aureon_ac97_init (ice1712_t *ice) { int i; static unsigned short ac97_defaults[] = { 0x00, 0x9640, @@ -196,7 +196,7 @@ static int aureon_ac97_init (struct snd_ice1712 *ice) { /* * AC'97 volume controls */ -static int aureon_ac97_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int aureon_ac97_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = kcontrol->private_value & AUREON_AC97_STEREO ? 2 : 1; @@ -205,9 +205,9 @@ static int aureon_ac97_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int aureon_ac97_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_ac97_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short vol; down(&ice->gpio_mutex); @@ -221,9 +221,9 @@ static int aureon_ac97_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int aureon_ac97_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_ac97_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short ovol, nvol; int change; @@ -248,9 +248,9 @@ static int aureon_ac97_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ele */ #define aureon_ac97_mute_info aureon_mono_bool_info -static int aureon_ac97_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_ac97_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); @@ -260,9 +260,9 @@ static int aureon_ac97_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int aureon_ac97_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_ac97_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short ovol, nvol; int change; @@ -284,9 +284,9 @@ static int aureon_ac97_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el */ #define aureon_ac97_micboost_info aureon_mono_bool_info -static int aureon_ac97_micboost_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_ac97_micboost_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); @@ -296,9 +296,9 @@ static int aureon_ac97_micboost_get(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int aureon_ac97_micboost_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_ac97_micboost_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short ovol, nvol; int change; @@ -318,7 +318,7 @@ static int aureon_ac97_micboost_put(struct snd_kcontrol *kcontrol, struct snd_ct /* * write data in the SPI mode */ -static void aureon_spi_write(struct snd_ice1712 *ice, unsigned int cs, unsigned int data, int bits) +static void aureon_spi_write(ice1712_t *ice, unsigned int cs, unsigned int data, int bits) { unsigned int tmp; int i; @@ -359,7 +359,7 @@ static void aureon_spi_write(struct snd_ice1712 *ice, unsigned int cs, unsigned /* * Read data in SPI mode */ -static void aureon_spi_read(struct snd_ice1712 *ice, unsigned int cs, unsigned int data, int bits, unsigned char *buffer, int size) { +static void aureon_spi_read(ice1712_t *ice, unsigned int cs, unsigned int data, int bits, unsigned char *buffer, int size) { int i, j; unsigned int tmp; @@ -409,26 +409,26 @@ static void aureon_spi_read(struct snd_ice1712 *ice, unsigned int cs, unsigned i snd_ice1712_gpio_write(ice, tmp); } -static unsigned char aureon_cs8415_get(struct snd_ice1712 *ice, int reg) { +static unsigned char aureon_cs8415_get(ice1712_t *ice, int reg) { unsigned char val; aureon_spi_write(ice, AUREON_CS8415_CS, 0x2000 | reg, 16); aureon_spi_read(ice, AUREON_CS8415_CS, 0x21, 8, &val, 1); return val; } -static void aureon_cs8415_read(struct snd_ice1712 *ice, int reg, unsigned char *buffer, int size) { +static void aureon_cs8415_read(ice1712_t *ice, int reg, unsigned char *buffer, int size) { aureon_spi_write(ice, AUREON_CS8415_CS, 0x2000 | reg, 16); aureon_spi_read(ice, AUREON_CS8415_CS, 0x21, 8, buffer, size); } -static void aureon_cs8415_put(struct snd_ice1712 *ice, int reg, unsigned char val) { +static void aureon_cs8415_put(ice1712_t *ice, int reg, unsigned char val) { aureon_spi_write(ice, AUREON_CS8415_CS, 0x200000 | (reg << 8) | val, 24); } /* * get the current register value of WM codec */ -static unsigned short wm_get(struct snd_ice1712 *ice, int reg) +static unsigned short wm_get(ice1712_t *ice, int reg) { reg <<= 1; return ((unsigned short)ice->akm[0].images[reg] << 8) | @@ -438,7 +438,7 @@ static unsigned short wm_get(struct snd_ice1712 *ice, int reg) /* * set the register value of WM codec */ -static void wm_put_nocache(struct snd_ice1712 *ice, int reg, unsigned short val) +static void wm_put_nocache(ice1712_t *ice, int reg, unsigned short val) { aureon_spi_write(ice, AUREON_WM_CS, (reg << 9) | (val & 0x1ff), 16); } @@ -446,7 +446,7 @@ static void wm_put_nocache(struct snd_ice1712 *ice, int reg, unsigned short val) /* * set the register value of WM codec and remember it */ -static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) +static void wm_put(ice1712_t *ice, int reg, unsigned short val) { wm_put_nocache(ice, reg, val); reg <<= 1; @@ -456,7 +456,7 @@ static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) /* */ -static int aureon_mono_bool_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *uinfo) +static int aureon_mono_bool_info(snd_kcontrol_t *k, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -470,9 +470,9 @@ static int aureon_mono_bool_info(struct snd_kcontrol *k, struct snd_ctl_elem_inf */ #define aureon_ac97_mmute_info aureon_mono_bool_info -static int aureon_ac97_mmute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_ac97_mmute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); @@ -482,8 +482,8 @@ static int aureon_ac97_mmute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int aureon_ac97_mmute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); +static int aureon_ac97_mmute_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short ovol, nvol; int change; @@ -521,7 +521,7 @@ static unsigned char wm_vol[256] = { #define WM_VOL_MAX (sizeof(wm_vol) - 1) #define WM_VOL_MUTE 0x8000 -static void wm_set_vol(struct snd_ice1712 *ice, unsigned int index, unsigned short vol, unsigned short master) +static void wm_set_vol(ice1712_t *ice, unsigned int index, unsigned short vol, unsigned short master) { unsigned char nvol; @@ -539,9 +539,9 @@ static void wm_set_vol(struct snd_ice1712 *ice, unsigned int index, unsigned sho */ #define wm_pcm_mute_info aureon_mono_bool_info -static int wm_pcm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); ucontrol->value.integer.value[0] = (wm_get(ice, WM_MUTE) & 0x10) ? 0 : 1; @@ -549,9 +549,9 @@ static int wm_pcm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va return 0; } -static int wm_pcm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short nval, oval; int change; @@ -568,7 +568,7 @@ static int wm_pcm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va /* * Master volume attenuation mixer control */ -static int wm_master_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_master_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -577,18 +577,18 @@ static int wm_master_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int wm_master_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i; for (i=0; i<2; i++) ucontrol->value.integer.value[i] = ice->spec.aureon.master[i] & ~WM_VOL_MUTE; return 0; } -static int wm_master_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int ch, change = 0; snd_ice1712_save_gpio_status(ice); @@ -611,7 +611,7 @@ static int wm_master_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ /* * DAC volume attenuation mixer control */ -static int wm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { int voices = kcontrol->private_value >> 8; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; @@ -621,9 +621,9 @@ static int wm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info * return 0; } -static int wm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, ofs, voices; voices = kcontrol->private_value >> 8; @@ -633,9 +633,9 @@ static int wm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value * return 0; } -static int wm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, idx, ofs, voices; int change = 0; @@ -659,7 +659,7 @@ static int wm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value * /* * WM8770 mute control */ -static int wm_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { +static int wm_mute_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = kcontrol->private_value >> 8; uinfo->value.integer.min = 0; @@ -667,9 +667,9 @@ static int wm_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info return 0; } -static int wm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int voices, ofs, i; voices = kcontrol->private_value >> 8; @@ -680,9 +680,9 @@ static int wm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value return 0; } -static int wm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, voices, ofs, i; voices = kcontrol->private_value >> 8; @@ -708,7 +708,7 @@ static int wm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value /* * WM8770 master mute control */ -static int wm_master_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { +static int wm_master_mute_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; uinfo->value.integer.min = 0; @@ -716,18 +716,18 @@ static int wm_master_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int wm_master_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (ice->spec.aureon.master[0] & WM_VOL_MUTE) ? 0 : 1; ucontrol->value.integer.value[1] = (ice->spec.aureon.master[1] & WM_VOL_MUTE) ? 0 : 1; return 0; } -static int wm_master_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, i; snd_ice1712_save_gpio_status(ice); @@ -754,7 +754,7 @@ static int wm_master_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem #define PCM_0dB 0xff #define PCM_RES 128 /* -64dB */ #define PCM_MIN (PCM_0dB - PCM_RES) -static int wm_pcm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_pcm_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -763,9 +763,9 @@ static int wm_pcm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -static int wm_pcm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val; down(&ice->gpio_mutex); @@ -776,9 +776,9 @@ static int wm_pcm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -static int wm_pcm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short ovol, nvol; int change = 0; @@ -798,7 +798,7 @@ static int wm_pcm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val /* * ADC mute control */ -static int wm_adc_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_adc_mute_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -807,9 +807,9 @@ static int wm_adc_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_i return 0; } -static int wm_adc_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val; int i; @@ -822,9 +822,9 @@ static int wm_adc_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va return 0; } -static int wm_adc_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short new, old; int i, change = 0; @@ -845,7 +845,7 @@ static int wm_adc_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va /* * ADC gain mixer control */ -static int wm_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_adc_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -854,9 +854,9 @@ static int wm_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -static int wm_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, idx; unsigned short vol; @@ -870,9 +870,9 @@ static int wm_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -static int wm_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, idx; unsigned short ovol, nvol; int change = 0; @@ -894,7 +894,7 @@ static int wm_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val /* * ADC input mux mixer control */ -static int wm_adc_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_adc_mux_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[] = { "CD", //AIN1 @@ -913,7 +913,7 @@ static int wm_adc_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in "Aux3", //AIN7 "AC97" //AIN8 }; - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 2; @@ -932,9 +932,9 @@ static int wm_adc_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -static int wm_adc_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_mux_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val; down(&ice->gpio_mutex); @@ -945,9 +945,9 @@ static int wm_adc_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -static int wm_adc_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_mux_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short oval, nval; int change; @@ -966,9 +966,9 @@ static int wm_adc_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val /* * CS8415 Input mux */ -static int aureon_cs8415_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int aureon_cs8415_mux_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); static char *aureon_texts[] = { "CD", //RXP0 "Optical" //RXP1 @@ -989,9 +989,9 @@ static int aureon_cs8415_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int aureon_cs8415_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_cs8415_mux_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); //snd_ice1712_save_gpio_status(ice); //val = aureon_cs8415_get(ice, CS8415_CTRL2); @@ -1000,9 +1000,9 @@ static int aureon_cs8415_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int aureon_cs8415_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_cs8415_mux_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short oval, nval; int change; @@ -1018,7 +1018,7 @@ static int aureon_cs8415_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e return change; } -static int aureon_cs8415_rate_info (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int aureon_cs8415_rate_info (snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -1027,9 +1027,9 @@ static int aureon_cs8415_rate_info (struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int aureon_cs8415_rate_get (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_cs8415_rate_get (snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char ratio; ratio = aureon_cs8415_get(ice, CS8415_RATIO); ucontrol->value.integer.value[0] = (int)((unsigned int)ratio * 750); @@ -1039,25 +1039,25 @@ static int aureon_cs8415_rate_get (struct snd_kcontrol *kcontrol, struct snd_ctl /* * CS8415A Mute */ -static int aureon_cs8415_mute_info (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int aureon_cs8415_mute_info (snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; return 0; } -static int aureon_cs8415_mute_get (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_cs8415_mute_get (snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); snd_ice1712_save_gpio_status(ice); ucontrol->value.integer.value[0] = (aureon_cs8415_get(ice, CS8415_CTRL1) & 0x20) ? 0 : 1; snd_ice1712_restore_gpio_status(ice); return 0; } -static int aureon_cs8415_mute_put (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_cs8415_mute_put (snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char oval, nval; int change; snd_ice1712_save_gpio_status(ice); @@ -1075,14 +1075,14 @@ static int aureon_cs8415_mute_put (struct snd_kcontrol *kcontrol, struct snd_ctl /* * CS8415A Q-Sub info */ -static int aureon_cs8415_qsub_info (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { +static int aureon_cs8415_qsub_info (snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; uinfo->count = 10; return 0; } -static int aureon_cs8415_qsub_get (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); +static int aureon_cs8415_qsub_get (snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { + ice1712_t *ice = snd_kcontrol_chip(kcontrol); snd_ice1712_save_gpio_status(ice); aureon_cs8415_read(ice, CS8415_QSUB, ucontrol->value.bytes.data, 10); @@ -1091,19 +1091,19 @@ static int aureon_cs8415_qsub_get (struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int aureon_cs8415_spdif_info (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { +static int aureon_cs8415_spdif_info (snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int aureon_cs8415_mask_get (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { +static int aureon_cs8415_mask_get (snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { memset(ucontrol->value.iec958.status, 0xFF, 24); return 0; } -static int aureon_cs8415_spdif_get (struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); +static int aureon_cs8415_spdif_get (snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { + ice1712_t *ice = snd_kcontrol_chip(kcontrol); snd_ice1712_save_gpio_status(ice); aureon_cs8415_read(ice, CS8415_C_BUFFER, ucontrol->value.iec958.status, 24); @@ -1114,7 +1114,7 @@ static int aureon_cs8415_spdif_get (struct snd_kcontrol *kcontrol, struct snd_ct /* * Headphone Amplifier */ -static int aureon_set_headphone_amp(struct snd_ice1712 *ice, int enable) +static int aureon_set_headphone_amp(ice1712_t *ice, int enable) { unsigned int tmp, tmp2; @@ -1130,7 +1130,7 @@ static int aureon_set_headphone_amp(struct snd_ice1712 *ice, int enable) return 0; } -static int aureon_get_headphone_amp(struct snd_ice1712 *ice) +static int aureon_get_headphone_amp(ice1712_t *ice) { unsigned int tmp = snd_ice1712_gpio_read(ice); @@ -1139,18 +1139,18 @@ static int aureon_get_headphone_amp(struct snd_ice1712 *ice) #define aureon_hpamp_info aureon_mono_bool_info -static int aureon_hpamp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_hpamp_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = aureon_get_headphone_amp(ice); return 0; } -static int aureon_hpamp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_hpamp_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); return aureon_set_headphone_amp(ice,ucontrol->value.integer.value[0]); } @@ -1161,16 +1161,16 @@ static int aureon_hpamp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v #define aureon_deemp_info aureon_mono_bool_info -static int aureon_deemp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_deemp_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (wm_get(ice, WM_DAC_CTRL2) & 0xf) == 0xf; return 0; } -static int aureon_deemp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_deemp_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int temp, temp2; temp2 = temp = wm_get(ice, WM_DAC_CTRL2); if (ucontrol->value.integer.value[0]) @@ -1187,7 +1187,7 @@ static int aureon_deemp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v /* * ADC Oversampling */ -static int aureon_oversampling_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *uinfo) +static int aureon_oversampling_info(snd_kcontrol_t *k, snd_ctl_elem_info_t *uinfo) { static char *texts[2] = { "128x", "64x" }; @@ -1202,17 +1202,17 @@ static int aureon_oversampling_info(struct snd_kcontrol *k, struct snd_ctl_elem_ return 0; } -static int aureon_oversampling_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_oversampling_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = (wm_get(ice, WM_MASTER) & 0x8) == 0x8; return 0; } -static int aureon_oversampling_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_oversampling_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int temp, temp2; - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); temp2 = temp = wm_get(ice, WM_MASTER); @@ -1232,7 +1232,7 @@ static int aureon_oversampling_put(struct snd_kcontrol *kcontrol, struct snd_ctl * mixers */ -static struct snd_kcontrol_new aureon_dac_controls[] __devinitdata = { +static snd_kcontrol_new_t aureon_dac_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Switch", @@ -1329,7 +1329,7 @@ static struct snd_kcontrol_new aureon_dac_controls[] __devinitdata = { } }; -static struct snd_kcontrol_new wm_controls[] __devinitdata = { +static snd_kcontrol_new_t wm_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Switch", @@ -1389,7 +1389,7 @@ static struct snd_kcontrol_new wm_controls[] __devinitdata = { } }; -static struct snd_kcontrol_new ac97_controls[] __devinitdata = { +static snd_kcontrol_new_t ac97_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "AC97 Playback Switch", @@ -1479,7 +1479,7 @@ static struct snd_kcontrol_new ac97_controls[] __devinitdata = { } }; -static struct snd_kcontrol_new universe_ac97_controls[] __devinitdata = { +static snd_kcontrol_new_t universe_ac97_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "AC97 Playback Switch", @@ -1586,7 +1586,7 @@ static struct snd_kcontrol_new universe_ac97_controls[] __devinitdata = { }; -static struct snd_kcontrol_new cs8415_controls[] __devinitdata = { +static snd_kcontrol_new_t cs8415_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), @@ -1632,7 +1632,7 @@ static struct snd_kcontrol_new cs8415_controls[] __devinitdata = { }; -static int __devinit aureon_add_controls(struct snd_ice1712 *ice) +static int __devinit aureon_add_controls(ice1712_t *ice) { unsigned int i, counts; int err; @@ -1677,7 +1677,7 @@ static int __devinit aureon_add_controls(struct snd_ice1712 *ice) snd_printk(KERN_INFO "Detected unsupported CS8415 rev. (%c)\n", (char)((id & 0x0F) + 'A' - 1)); else { for (i = 0; i< ARRAY_SIZE(cs8415_controls); i++) { - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; err = snd_ctl_add(ice->card, (kctl = snd_ctl_new1(&cs8415_controls[i], ice))); if (err < 0) return err; @@ -1695,7 +1695,7 @@ static int __devinit aureon_add_controls(struct snd_ice1712 *ice) /* * initialize the chip */ -static int __devinit aureon_init(struct snd_ice1712 *ice) +static int __devinit aureon_init(ice1712_t *ice) { static unsigned short wm_inits_aureon[] = { /* These come first to reduce init pop noise */ @@ -1796,7 +1796,7 @@ static int __devinit aureon_init(struct snd_ice1712 *ice) } /* to remeber the register values of CS8415 */ - ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ice->akm = kzalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (! ice->akm) return -ENOMEM; ice->akm_codecs = 1; diff --git a/trunk/sound/pci/ice1712/delta.c b/trunk/sound/pci/ice1712/delta.c index 9a51d34e6817..576f69d482c9 100644 --- a/trunk/sound/pci/ice1712/delta.c +++ b/trunk/sound/pci/ice1712/delta.c @@ -44,7 +44,7 @@ */ /* send 8 bits */ -static void ap_cs8427_write_byte(struct snd_ice1712 *ice, unsigned char data, unsigned char tmp) +static void ap_cs8427_write_byte(ice1712_t *ice, unsigned char data, unsigned char tmp) { int idx; @@ -61,7 +61,7 @@ static void ap_cs8427_write_byte(struct snd_ice1712 *ice, unsigned char data, un } /* read 8 bits */ -static unsigned char ap_cs8427_read_byte(struct snd_ice1712 *ice, unsigned char tmp) +static unsigned char ap_cs8427_read_byte(ice1712_t *ice, unsigned char tmp) { unsigned char data = 0; int idx; @@ -80,7 +80,7 @@ static unsigned char ap_cs8427_read_byte(struct snd_ice1712 *ice, unsigned char } /* assert chip select */ -static unsigned char ap_cs8427_codec_select(struct snd_ice1712 *ice) +static unsigned char ap_cs8427_codec_select(ice1712_t *ice) { unsigned char tmp; tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA); @@ -105,7 +105,7 @@ static unsigned char ap_cs8427_codec_select(struct snd_ice1712 *ice) } /* deassert chip select */ -static void ap_cs8427_codec_deassert(struct snd_ice1712 *ice, unsigned char tmp) +static void ap_cs8427_codec_deassert(ice1712_t *ice, unsigned char tmp) { switch (ice->eeprom.subvendor) { case ICE1712_SUBDEVICE_DELTA1010LT: @@ -124,9 +124,9 @@ static void ap_cs8427_codec_deassert(struct snd_ice1712 *ice, unsigned char tmp) } /* sequential write */ -static int ap_cs8427_sendbytes(struct snd_i2c_device *device, unsigned char *bytes, int count) +static int ap_cs8427_sendbytes(snd_i2c_device_t *device, unsigned char *bytes, int count) { - struct snd_ice1712 *ice = device->bus->private_data; + ice1712_t *ice = device->bus->private_data; int res = count; unsigned char tmp; @@ -141,9 +141,9 @@ static int ap_cs8427_sendbytes(struct snd_i2c_device *device, unsigned char *byt } /* sequential read */ -static int ap_cs8427_readbytes(struct snd_i2c_device *device, unsigned char *bytes, int count) +static int ap_cs8427_readbytes(snd_i2c_device_t *device, unsigned char *bytes, int count) { - struct snd_ice1712 *ice = device->bus->private_data; + ice1712_t *ice = device->bus->private_data; int res = count; unsigned char tmp; @@ -157,14 +157,14 @@ static int ap_cs8427_readbytes(struct snd_i2c_device *device, unsigned char *byt return res; } -static int ap_cs8427_probeaddr(struct snd_i2c_bus *bus, unsigned short addr) +static int ap_cs8427_probeaddr(snd_i2c_bus_t *bus, unsigned short addr) { if (addr == 0x10) return 1; return -ENOENT; } -static struct snd_i2c_ops ap_cs8427_i2c_ops = { +static snd_i2c_ops_t ap_cs8427_i2c_ops = { .sendbytes = ap_cs8427_sendbytes, .readbytes = ap_cs8427_readbytes, .probeaddr = ap_cs8427_probeaddr, @@ -173,7 +173,7 @@ static struct snd_i2c_ops ap_cs8427_i2c_ops = { /* */ -static void snd_ice1712_delta_cs8403_spdif_write(struct snd_ice1712 *ice, unsigned char bits) +static void snd_ice1712_delta_cs8403_spdif_write(ice1712_t *ice, unsigned char bits) { unsigned char tmp, mask1, mask2; int idx; @@ -198,12 +198,12 @@ static void snd_ice1712_delta_cs8403_spdif_write(struct snd_ice1712 *ice, unsign } -static void delta_spdif_default_get(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static void delta_spdif_default_get(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { snd_cs8403_decode_spdif_bits(&ucontrol->value.iec958, ice->spdif.cs8403_bits); } -static int delta_spdif_default_put(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static int delta_spdif_default_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { unsigned int val; int change; @@ -221,12 +221,12 @@ static int delta_spdif_default_put(struct snd_ice1712 *ice, struct snd_ctl_elem_ return change; } -static void delta_spdif_stream_get(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static void delta_spdif_stream_get(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { snd_cs8403_decode_spdif_bits(&ucontrol->value.iec958, ice->spdif.cs8403_stream_bits); } -static int delta_spdif_stream_put(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static int delta_spdif_stream_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { unsigned int val; int change; @@ -248,10 +248,10 @@ static int delta_spdif_stream_put(struct snd_ice1712 *ice, struct snd_ctl_elem_v /* * AK4524 on Delta 44 and 66 to choose the chip mask */ -static void delta_ak4524_lock(struct snd_akm4xxx *ak, int chip) +static void delta_ak4524_lock(akm4xxx_t *ak, int chip) { struct snd_ak4xxx_private *priv = (void *)ak->private_value[0]; - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_ice1712_save_gpio_status(ice); priv->cs_mask = @@ -262,10 +262,10 @@ static void delta_ak4524_lock(struct snd_akm4xxx *ak, int chip) /* * AK4524 on Delta1010LT to choose the chip address */ -static void delta1010lt_ak4524_lock(struct snd_akm4xxx *ak, int chip) +static void delta1010lt_ak4524_lock(akm4xxx_t *ak, int chip) { struct snd_ak4xxx_private *priv = (void *)ak->private_value[0]; - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_ice1712_save_gpio_status(ice); priv->cs_mask = ICE1712_DELTA_1010LT_CS; @@ -275,10 +275,10 @@ static void delta1010lt_ak4524_lock(struct snd_akm4xxx *ak, int chip) /* * AK4528 on VX442 to choose the chip mask */ -static void vx442_ak4524_lock(struct snd_akm4xxx *ak, int chip) +static void vx442_ak4524_lock(akm4xxx_t *ak, int chip) { struct snd_ak4xxx_private *priv = (void *)ak->private_value[0]; - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_ice1712_save_gpio_status(ice); priv->cs_mask = @@ -289,7 +289,7 @@ static void vx442_ak4524_lock(struct snd_akm4xxx *ak, int chip) /* * change the DFS bit according rate for Delta1010 */ -static void delta_1010_set_rate_val(struct snd_ice1712 *ice, unsigned int rate) +static void delta_1010_set_rate_val(ice1712_t *ice, unsigned int rate) { unsigned char tmp, tmp2; @@ -309,10 +309,10 @@ static void delta_1010_set_rate_val(struct snd_ice1712 *ice, unsigned int rate) /* * change the rate of AK4524 on Delta 44/66, AP, 1010LT */ -static void delta_ak4524_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) +static void delta_ak4524_set_rate_val(akm4xxx_t *ak, unsigned int rate) { unsigned char tmp, tmp2; - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; if (rate == 0) /* no hint - S/PDIF input is master, simply return */ return; @@ -341,7 +341,7 @@ static void delta_ak4524_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) /* * change the rate of AK4524 on VX442 */ -static void vx442_ak4524_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) +static void vx442_ak4524_set_rate_val(akm4xxx_t *ak, unsigned int rate) { unsigned char val; @@ -361,13 +361,13 @@ static void vx442_ak4524_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) */ /* open callback */ -static void delta_open_spdif(struct snd_ice1712 *ice, struct snd_pcm_substream *substream) +static void delta_open_spdif(ice1712_t *ice, snd_pcm_substream_t * substream) { ice->spdif.cs8403_stream_bits = ice->spdif.cs8403_bits; } /* set up */ -static void delta_setup_spdif(struct snd_ice1712 *ice, int rate) +static void delta_setup_spdif(ice1712_t *ice, int rate) { unsigned long flags; unsigned int tmp; @@ -396,7 +396,7 @@ static void delta_setup_spdif(struct snd_ice1712 *ice, int rate) * initialize the chips on M-Audio cards */ -static struct snd_akm4xxx akm_audiophile __devinitdata = { +static akm4xxx_t akm_audiophile __devinitdata = { .type = SND_AK4528, .num_adcs = 2, .num_dacs = 2, @@ -417,7 +417,7 @@ static struct snd_ak4xxx_private akm_audiophile_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_delta410 __devinitdata = { +static akm4xxx_t akm_delta410 __devinitdata = { .type = SND_AK4529, .num_adcs = 2, .num_dacs = 8, @@ -438,7 +438,7 @@ static struct snd_ak4xxx_private akm_delta410_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_delta1010lt __devinitdata = { +static akm4xxx_t akm_delta1010lt __devinitdata = { .type = SND_AK4524, .num_adcs = 8, .num_dacs = 8, @@ -460,7 +460,7 @@ static struct snd_ak4xxx_private akm_delta1010lt_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_delta44 __devinitdata = { +static akm4xxx_t akm_delta44 __devinitdata = { .type = SND_AK4524, .num_adcs = 4, .num_dacs = 4, @@ -482,7 +482,7 @@ static struct snd_ak4xxx_private akm_delta44_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_vx442 __devinitdata = { +static akm4xxx_t akm_vx442 __devinitdata = { .type = SND_AK4524, .num_adcs = 4, .num_dacs = 4, @@ -504,10 +504,10 @@ static struct snd_ak4xxx_private akm_vx442_priv __devinitdata = { .mask_flags = 0, }; -static int __devinit snd_ice1712_delta_init(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_delta_init(ice1712_t *ice) { int err; - struct snd_akm4xxx *ak; + akm4xxx_t *ak; /* determine I2C, DACs and ADCs */ switch (ice->eeprom.subvendor) { @@ -582,7 +582,7 @@ static int __devinit snd_ice1712_delta_init(struct snd_ice1712 *ice) } /* second stage of initialization, analog parts and others */ - ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ak = ice->akm = kmalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (! ak) return -ENOMEM; ice->akm_codecs = 1; @@ -617,19 +617,19 @@ static int __devinit snd_ice1712_delta_init(struct snd_ice1712 *ice) * additional controls for M-Audio cards */ -static struct snd_kcontrol_new snd_ice1712_delta1010_wordclock_select __devinitdata = +static snd_kcontrol_new_t snd_ice1712_delta1010_wordclock_select __devinitdata = ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_MIXER, "Word Clock Sync", 0, ICE1712_DELTA_WORD_CLOCK_SELECT, 1, 0); -static struct snd_kcontrol_new snd_ice1712_delta1010lt_wordclock_select __devinitdata = +static snd_kcontrol_new_t snd_ice1712_delta1010lt_wordclock_select __devinitdata = ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_MIXER, "Word Clock Sync", 0, ICE1712_DELTA_1010LT_WORDCLOCK, 1, 0); -static struct snd_kcontrol_new snd_ice1712_delta1010_wordclock_status __devinitdata = +static snd_kcontrol_new_t snd_ice1712_delta1010_wordclock_status __devinitdata = ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_MIXER, "Word Clock Status", 0, ICE1712_DELTA_WORD_CLOCK_STATUS, 1, SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE); -static struct snd_kcontrol_new snd_ice1712_deltadio2496_spdif_in_select __devinitdata = +static snd_kcontrol_new_t snd_ice1712_deltadio2496_spdif_in_select __devinitdata = ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_MIXER, "IEC958 Input Optical", 0, ICE1712_DELTA_SPDIF_INPUT_SELECT, 0, 0); -static struct snd_kcontrol_new snd_ice1712_delta_spdif_in_status __devinitdata = +static snd_kcontrol_new_t snd_ice1712_delta_spdif_in_status __devinitdata = ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_MIXER, "Delta IEC958 Input Status", 0, ICE1712_DELTA_SPDIF_IN_STAT, 1, SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE); -static int __devinit snd_ice1712_delta_add_controls(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_delta_add_controls(ice1712_t *ice) { int err; diff --git a/trunk/sound/pci/ice1712/envy24ht.h b/trunk/sound/pci/ice1712/envy24ht.h index b58afcda9ed6..f7878020eaa3 100644 --- a/trunk/sound/pci/ice1712/envy24ht.h +++ b/trunk/sound/pci/ice1712/envy24ht.h @@ -209,7 +209,7 @@ enum { #define VT1724_MT_PDMA1_COUNT 0x76 /* word */ -unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice, unsigned char dev, unsigned char addr); -void snd_vt1724_write_i2c(struct snd_ice1712 *ice, unsigned char dev, unsigned char addr, unsigned char data); +unsigned char snd_vt1724_read_i2c(ice1712_t *ice, unsigned char dev, unsigned char addr); +void snd_vt1724_write_i2c(ice1712_t *ice, unsigned char dev, unsigned char addr, unsigned char data); #endif /* __SOUND_VT1724_H */ diff --git a/trunk/sound/pci/ice1712/ews.c b/trunk/sound/pci/ice1712/ews.c index 2c529e741384..c8ec5cac3c17 100644 --- a/trunk/sound/pci/ice1712/ews.c +++ b/trunk/sound/pci/ice1712/ews.c @@ -50,9 +50,9 @@ enum { */ /* send SDA and SCL */ -static void ewx_i2c_setlines(struct snd_i2c_bus *bus, int clk, int data) +static void ewx_i2c_setlines(snd_i2c_bus_t *bus, int clk, int data) { - struct snd_ice1712 *ice = bus->private_data; + ice1712_t *ice = bus->private_data; unsigned char tmp = 0; if (clk) tmp |= ICE1712_EWX2496_SERIAL_CLOCK; @@ -62,15 +62,15 @@ static void ewx_i2c_setlines(struct snd_i2c_bus *bus, int clk, int data) udelay(5); } -static int ewx_i2c_getclock(struct snd_i2c_bus *bus) +static int ewx_i2c_getclock(snd_i2c_bus_t *bus) { - struct snd_ice1712 *ice = bus->private_data; + ice1712_t *ice = bus->private_data; return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ICE1712_EWX2496_SERIAL_CLOCK ? 1 : 0; } -static int ewx_i2c_getdata(struct snd_i2c_bus *bus, int ack) +static int ewx_i2c_getdata(snd_i2c_bus_t *bus, int ack) { - struct snd_ice1712 *ice = bus->private_data; + ice1712_t *ice = bus->private_data; int bit; /* set RW pin to low */ snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~ICE1712_EWX2496_RW); @@ -85,9 +85,9 @@ static int ewx_i2c_getdata(struct snd_i2c_bus *bus, int ack) return bit; } -static void ewx_i2c_start(struct snd_i2c_bus *bus) +static void ewx_i2c_start(snd_i2c_bus_t *bus) { - struct snd_ice1712 *ice = bus->private_data; + ice1712_t *ice = bus->private_data; unsigned char mask; snd_ice1712_save_gpio_status(ice); @@ -104,15 +104,15 @@ static void ewx_i2c_start(struct snd_i2c_bus *bus) snd_ice1712_gpio_write_bits(ice, mask, mask); } -static void ewx_i2c_stop(struct snd_i2c_bus *bus) +static void ewx_i2c_stop(snd_i2c_bus_t *bus) { - struct snd_ice1712 *ice = bus->private_data; + ice1712_t *ice = bus->private_data; snd_ice1712_restore_gpio_status(ice); } -static void ewx_i2c_direction(struct snd_i2c_bus *bus, int clock, int data) +static void ewx_i2c_direction(snd_i2c_bus_t *bus, int clock, int data) { - struct snd_ice1712 *ice = bus->private_data; + ice1712_t *ice = bus->private_data; unsigned char mask = 0; if (clock) @@ -125,7 +125,7 @@ static void ewx_i2c_direction(struct snd_i2c_bus *bus, int clock, int data) snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~mask); } -static struct snd_i2c_bit_ops snd_ice1712_ewx_cs8427_bit_ops = { +static snd_i2c_bit_ops_t snd_ice1712_ewx_cs8427_bit_ops = { .start = ewx_i2c_start, .stop = ewx_i2c_stop, .direction = ewx_i2c_direction, @@ -140,7 +140,7 @@ static struct snd_i2c_bit_ops snd_ice1712_ewx_cs8427_bit_ops = { */ /* AK4524 chip select; address 0x48 bit 0-3 */ -static int snd_ice1712_ews88mt_chip_select(struct snd_ice1712 *ice, int chip_mask) +static int snd_ice1712_ews88mt_chip_select(ice1712_t *ice, int chip_mask) { unsigned char data, ndata; @@ -162,9 +162,9 @@ static int snd_ice1712_ews88mt_chip_select(struct snd_ice1712 *ice, int chip_mas } /* start callback for EWS88MT, needs to select a certain chip mask */ -static void ews88mt_ak4524_lock(struct snd_akm4xxx *ak, int chip) +static void ews88mt_ak4524_lock(akm4xxx_t *ak, int chip) { - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; unsigned char tmp; /* assert AK4524 CS */ if (snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f) < 0) @@ -179,18 +179,18 @@ static void ews88mt_ak4524_lock(struct snd_akm4xxx *ak, int chip) } /* stop callback for EWS88MT, needs to deselect chip mask */ -static void ews88mt_ak4524_unlock(struct snd_akm4xxx *ak, int chip) +static void ews88mt_ak4524_unlock(akm4xxx_t *ak, int chip) { - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_ice1712_restore_gpio_status(ice); udelay(1); snd_ice1712_ews88mt_chip_select(ice, 0x0f); } /* start callback for EWX24/96 */ -static void ewx2496_ak4524_lock(struct snd_akm4xxx *ak, int chip) +static void ewx2496_ak4524_lock(akm4xxx_t *ak, int chip) { - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; unsigned char tmp; snd_ice1712_save_gpio_status(ice); tmp = ICE1712_EWX2496_SERIAL_DATA | @@ -203,10 +203,10 @@ static void ewx2496_ak4524_lock(struct snd_akm4xxx *ak, int chip) } /* start callback for DMX 6fire */ -static void dmx6fire_ak4524_lock(struct snd_akm4xxx *ak, int chip) +static void dmx6fire_ak4524_lock(akm4xxx_t *ak, int chip) { struct snd_ak4xxx_private *priv = (void *)ak->private_value[0]; - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; unsigned char tmp; snd_ice1712_save_gpio_status(ice); tmp = priv->cs_mask = priv->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK; @@ -222,7 +222,7 @@ static void dmx6fire_ak4524_lock(struct snd_akm4xxx *ak, int chip) * CS8404 interface on EWS88MT/D */ -static void snd_ice1712_ews_cs8404_spdif_write(struct snd_ice1712 *ice, unsigned char bits) +static void snd_ice1712_ews_cs8404_spdif_write(ice1712_t *ice, unsigned char bits) { unsigned char bytes[2]; @@ -251,12 +251,12 @@ static void snd_ice1712_ews_cs8404_spdif_write(struct snd_ice1712 *ice, unsigned /* */ -static void ews88_spdif_default_get(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static void ews88_spdif_default_get(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { snd_cs8404_decode_spdif_bits(&ucontrol->value.iec958, ice->spdif.cs8403_bits); } -static int ews88_spdif_default_put(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static int ews88_spdif_default_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { unsigned int val; int change; @@ -274,12 +274,12 @@ static int ews88_spdif_default_put(struct snd_ice1712 *ice, struct snd_ctl_elem_ return change; } -static void ews88_spdif_stream_get(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static void ews88_spdif_stream_get(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { snd_cs8404_decode_spdif_bits(&ucontrol->value.iec958, ice->spdif.cs8403_stream_bits); } -static int ews88_spdif_stream_put(struct snd_ice1712 *ice, struct snd_ctl_elem_value *ucontrol) +static int ews88_spdif_stream_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol) { unsigned int val; int change; @@ -299,13 +299,13 @@ static int ews88_spdif_stream_put(struct snd_ice1712 *ice, struct snd_ctl_elem_v /* open callback */ -static void ews88_open_spdif(struct snd_ice1712 *ice, struct snd_pcm_substream *substream) +static void ews88_open_spdif(ice1712_t *ice, snd_pcm_substream_t * substream) { ice->spdif.cs8403_stream_bits = ice->spdif.cs8403_bits; } /* set up SPDIF for EWS88MT / EWS88D */ -static void ews88_setup_spdif(struct snd_ice1712 *ice, int rate) +static void ews88_setup_spdif(ice1712_t *ice, int rate) { unsigned long flags; unsigned char tmp; @@ -332,7 +332,7 @@ static void ews88_setup_spdif(struct snd_ice1712 *ice, int rate) /* */ -static struct snd_akm4xxx akm_ews88mt __devinitdata = { +static akm4xxx_t akm_ews88mt __devinitdata = { .num_adcs = 8, .num_dacs = 8, .type = SND_AK4524, @@ -354,7 +354,7 @@ static struct snd_ak4xxx_private akm_ews88mt_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_ewx2496 __devinitdata = { +static akm4xxx_t akm_ewx2496 __devinitdata = { .num_adcs = 2, .num_dacs = 2, .type = SND_AK4524, @@ -375,7 +375,7 @@ static struct snd_ak4xxx_private akm_ewx2496_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_6fire __devinitdata = { +static akm4xxx_t akm_6fire __devinitdata = { .num_adcs = 6, .num_dacs = 6, .type = SND_AK4524, @@ -406,12 +406,12 @@ static struct snd_ak4xxx_private akm_6fire_priv __devinitdata = { #define PCF9554_REG_POLARITY 2 #define PCF9554_REG_CONFIG 3 -static int snd_ice1712_6fire_write_pca(struct snd_ice1712 *ice, unsigned char reg, unsigned char data); +static int snd_ice1712_6fire_write_pca(ice1712_t *ice, unsigned char reg, unsigned char data); -static int __devinit snd_ice1712_ews_init(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_ews_init(ice1712_t *ice) { int err; - struct snd_akm4xxx *ak; + akm4xxx_t *ak; /* set the analog DACs */ switch (ice->eeprom.subvendor) { @@ -507,7 +507,7 @@ static int __devinit snd_ice1712_ews_init(struct snd_ice1712 *ice) } /* analog section */ - ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ak = ice->akm = kmalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (! ak) return -ENOMEM; ice->akm_codecs = 1; @@ -536,7 +536,7 @@ static int __devinit snd_ice1712_ews_init(struct snd_ice1712 *ice) */ /* i/o sensitivity - this callback is shared among other devices, too */ -static int snd_ice1712_ewx_io_sense_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo){ +static int snd_ice1712_ewx_io_sense_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo){ static char *texts[2] = { "+4dBu", "-10dBV", @@ -550,9 +550,9 @@ static int snd_ice1712_ewx_io_sense_info(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_ice1712_ewx_io_sense_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ewx_io_sense_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char mask = kcontrol->private_value & 0xff; snd_ice1712_save_gpio_status(ice); @@ -561,9 +561,9 @@ static int snd_ice1712_ewx_io_sense_get(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_ice1712_ewx_io_sense_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ewx_io_sense_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char mask = kcontrol->private_value & 0xff; int val, nval; @@ -578,7 +578,7 @@ static int snd_ice1712_ewx_io_sense_put(struct snd_kcontrol *kcontrol, struct sn return val != nval; } -static struct snd_kcontrol_new snd_ice1712_ewx2496_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_ewx2496_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Input Sensitivity Switch", @@ -602,9 +602,9 @@ static struct snd_kcontrol_new snd_ice1712_ewx2496_controls[] __devinitdata = { * EWS88MT specific controls */ /* analog output sensitivity;; address 0x48 bit 6 */ -static int snd_ice1712_ews88mt_output_sense_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ews88mt_output_sense_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char data; snd_i2c_lock(ice->i2c); @@ -618,9 +618,9 @@ static int snd_ice1712_ews88mt_output_sense_get(struct snd_kcontrol *kcontrol, s } /* analog output sensitivity;; address 0x48 bit 6 */ -static int snd_ice1712_ews88mt_output_sense_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ews88mt_output_sense_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char data, ndata; snd_i2c_lock(ice->i2c); @@ -638,9 +638,9 @@ static int snd_ice1712_ews88mt_output_sense_put(struct snd_kcontrol *kcontrol, s } /* analog input sensitivity; address 0x46 */ -static int snd_ice1712_ews88mt_input_sense_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ews88mt_input_sense_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned char data; @@ -657,9 +657,9 @@ static int snd_ice1712_ews88mt_input_sense_get(struct snd_kcontrol *kcontrol, st } /* analog output sensitivity; address 0x46 */ -static int snd_ice1712_ews88mt_input_sense_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ews88mt_input_sense_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned char data, ndata; @@ -678,7 +678,7 @@ static int snd_ice1712_ews88mt_input_sense_put(struct snd_kcontrol *kcontrol, st return ndata != data; } -static struct snd_kcontrol_new snd_ice1712_ews88mt_input_sense __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_ews88mt_input_sense __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Input Sensitivity Switch", .info = snd_ice1712_ewx_io_sense_info, @@ -687,7 +687,7 @@ static struct snd_kcontrol_new snd_ice1712_ews88mt_input_sense __devinitdata = { .count = 8, }; -static struct snd_kcontrol_new snd_ice1712_ews88mt_output_sense __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_ews88mt_output_sense __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Output Sensitivity Switch", .info = snd_ice1712_ewx_io_sense_info, @@ -700,7 +700,7 @@ static struct snd_kcontrol_new snd_ice1712_ews88mt_output_sense __devinitdata = * EWS88D specific controls */ -static int snd_ice1712_ews88d_control_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_ews88d_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -709,9 +709,9 @@ static int snd_ice1712_ews88d_control_info(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_ice1712_ews88d_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ews88d_control_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value >> 8) & 1; unsigned char data[2]; @@ -729,9 +729,9 @@ static int snd_ice1712_ews88d_control_get(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_ice1712_ews88d_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_ews88d_control_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value >> 8) & 1; unsigned char data[2], ndata[2]; @@ -769,7 +769,7 @@ static int snd_ice1712_ews88d_control_put(struct snd_kcontrol *kcontrol, struct .private_value = xshift | (xinvert << 8),\ } -static struct snd_kcontrol_new snd_ice1712_ews88d_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_ews88d_controls[] __devinitdata = { EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "IEC958 Input Optical", 0, 1, 0), /* inverted */ EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT Output Optical", 1, 0, 0), EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT External Master Clock", 2, 0, 0), @@ -782,7 +782,7 @@ static struct snd_kcontrol_new snd_ice1712_ews88d_controls[] __devinitdata = { * DMX 6Fire specific controls */ -static int snd_ice1712_6fire_read_pca(struct snd_ice1712 *ice, unsigned char reg) +static int snd_ice1712_6fire_read_pca(ice1712_t *ice, unsigned char reg) { unsigned char byte; snd_i2c_lock(ice->i2c); @@ -798,7 +798,7 @@ static int snd_ice1712_6fire_read_pca(struct snd_ice1712 *ice, unsigned char reg return byte; } -static int snd_ice1712_6fire_write_pca(struct snd_ice1712 *ice, unsigned char reg, unsigned char data) +static int snd_ice1712_6fire_write_pca(ice1712_t *ice, unsigned char reg, unsigned char data) { unsigned char bytes[2]; snd_i2c_lock(ice->i2c); @@ -812,7 +812,7 @@ static int snd_ice1712_6fire_write_pca(struct snd_ice1712 *ice, unsigned char re return 0; } -static int snd_ice1712_6fire_control_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_6fire_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -821,9 +821,9 @@ static int snd_ice1712_6fire_control_info(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_ice1712_6fire_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_6fire_control_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value >> 8) & 1; int data; @@ -837,9 +837,9 @@ static int snd_ice1712_6fire_control_get(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_ice1712_6fire_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_6fire_control_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value >> 8) & 1; int data, ndata; @@ -858,7 +858,7 @@ static int snd_ice1712_6fire_control_put(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_ice1712_6fire_select_input_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_6fire_select_input_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[4] = { "Internal", "Front Input", "Rear Input", "Wave Table" @@ -872,9 +872,9 @@ static int snd_ice1712_6fire_select_input_info(struct snd_kcontrol *kcontrol, st return 0; } -static int snd_ice1712_6fire_select_input_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_6fire_select_input_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int data; if ((data = snd_ice1712_6fire_read_pca(ice, PCF9554_REG_OUTPUT)) < 0) @@ -883,9 +883,9 @@ static int snd_ice1712_6fire_select_input_get(struct snd_kcontrol *kcontrol, str return 0; } -static int snd_ice1712_6fire_select_input_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_6fire_select_input_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int data, ndata; if ((data = snd_ice1712_6fire_read_pca(ice, PCF9554_REG_OUTPUT)) < 0) @@ -909,7 +909,7 @@ static int snd_ice1712_6fire_select_input_put(struct snd_kcontrol *kcontrol, str .private_value = xshift | (xinvert << 8),\ } -static struct snd_kcontrol_new snd_ice1712_6fire_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_6fire_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Input Select", @@ -917,7 +917,7 @@ static struct snd_kcontrol_new snd_ice1712_6fire_controls[] __devinitdata = { .get = snd_ice1712_6fire_select_input_get, .put = snd_ice1712_6fire_select_input_put, }, - DMX6FIRE_CONTROL("Front Digital Input Switch", 2, 1), + DMX6FIRE_CONTROL("Front Digital Input Switch", 2, 0), // DMX6FIRE_CONTROL("Master Clock Select", 3, 0), DMX6FIRE_CONTROL("Optical Digital Input Switch", 4, 0), DMX6FIRE_CONTROL("Phono Analog Input Switch", 5, 0), @@ -925,7 +925,7 @@ static struct snd_kcontrol_new snd_ice1712_6fire_controls[] __devinitdata = { }; -static int __devinit snd_ice1712_ews_add_controls(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_ews_add_controls(ice1712_t *ice) { unsigned int idx; int err; diff --git a/trunk/sound/pci/ice1712/hoontech.c b/trunk/sound/pci/ice1712/hoontech.c index 3f2f918536f5..ab5fbd0bdfad 100644 --- a/trunk/sound/pci/ice1712/hoontech.c +++ b/trunk/sound/pci/ice1712/hoontech.c @@ -33,7 +33,7 @@ #include "hoontech.h" -static void __devinit snd_ice1712_stdsp24_gpio_write(struct snd_ice1712 *ice, unsigned char byte) +static void __devinit snd_ice1712_stdsp24_gpio_write(ice1712_t *ice, unsigned char byte) { byte |= ICE1712_STDSP24_CLOCK_BIT; udelay(100); @@ -46,7 +46,7 @@ static void __devinit snd_ice1712_stdsp24_gpio_write(struct snd_ice1712 *ice, un snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, byte); } -static void __devinit snd_ice1712_stdsp24_darear(struct snd_ice1712 *ice, int activate) +static void __devinit snd_ice1712_stdsp24_darear(ice1712_t *ice, int activate) { down(&ice->gpio_mutex); ICE1712_STDSP24_0_DAREAR(ice->spec.hoontech.boxbits, activate); @@ -54,7 +54,7 @@ static void __devinit snd_ice1712_stdsp24_darear(struct snd_ice1712 *ice, int ac up(&ice->gpio_mutex); } -static void __devinit snd_ice1712_stdsp24_mute(struct snd_ice1712 *ice, int activate) +static void __devinit snd_ice1712_stdsp24_mute(ice1712_t *ice, int activate) { down(&ice->gpio_mutex); ICE1712_STDSP24_3_MUTE(ice->spec.hoontech.boxbits, activate); @@ -62,7 +62,7 @@ static void __devinit snd_ice1712_stdsp24_mute(struct snd_ice1712 *ice, int acti up(&ice->gpio_mutex); } -static void __devinit snd_ice1712_stdsp24_insel(struct snd_ice1712 *ice, int activate) +static void __devinit snd_ice1712_stdsp24_insel(ice1712_t *ice, int activate) { down(&ice->gpio_mutex); ICE1712_STDSP24_3_INSEL(ice->spec.hoontech.boxbits, activate); @@ -70,7 +70,7 @@ static void __devinit snd_ice1712_stdsp24_insel(struct snd_ice1712 *ice, int act up(&ice->gpio_mutex); } -static void __devinit snd_ice1712_stdsp24_box_channel(struct snd_ice1712 *ice, int box, int chn, int activate) +static void __devinit snd_ice1712_stdsp24_box_channel(ice1712_t *ice, int box, int chn, int activate) { down(&ice->gpio_mutex); @@ -118,7 +118,7 @@ static void __devinit snd_ice1712_stdsp24_box_channel(struct snd_ice1712 *ice, i up(&ice->gpio_mutex); } -static void __devinit snd_ice1712_stdsp24_box_midi(struct snd_ice1712 *ice, int box, int master) +static void __devinit snd_ice1712_stdsp24_box_midi(ice1712_t *ice, int box, int master) { down(&ice->gpio_mutex); @@ -144,7 +144,7 @@ static void __devinit snd_ice1712_stdsp24_box_midi(struct snd_ice1712 *ice, int up(&ice->gpio_mutex); } -static void __devinit snd_ice1712_stdsp24_midi2(struct snd_ice1712 *ice, int activate) +static void __devinit snd_ice1712_stdsp24_midi2(ice1712_t *ice, int activate) { down(&ice->gpio_mutex); ICE1712_STDSP24_3_MIDI2(ice->spec.hoontech.boxbits, activate); @@ -152,7 +152,7 @@ static void __devinit snd_ice1712_stdsp24_midi2(struct snd_ice1712 *ice, int act up(&ice->gpio_mutex); } -static int __devinit snd_ice1712_hoontech_init(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_hoontech_init(ice1712_t *ice) { int box, chn; @@ -221,9 +221,9 @@ static int __devinit snd_ice1712_hoontech_init(struct snd_ice1712 *ice) */ /* start callback for STDSP24 with modified hardware */ -static void stdsp24_ak4524_lock(struct snd_akm4xxx *ak, int chip) +static void stdsp24_ak4524_lock(akm4xxx_t *ak, int chip) { - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; unsigned char tmp; snd_ice1712_save_gpio_status(ice); tmp = ICE1712_STDSP24_SERIAL_DATA | @@ -234,10 +234,10 @@ static void stdsp24_ak4524_lock(struct snd_akm4xxx *ak, int chip) snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp); } -static int __devinit snd_ice1712_value_init(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_value_init(ice1712_t *ice) { /* Hoontech STDSP24 with modified hardware */ - static struct snd_akm4xxx akm_stdsp24_mv __devinitdata = { + static akm4xxx_t akm_stdsp24_mv __devinitdata = { .num_adcs = 2, .num_dacs = 2, .type = SND_AK4524, @@ -258,7 +258,7 @@ static int __devinit snd_ice1712_value_init(struct snd_ice1712 *ice) }; int err; - struct snd_akm4xxx *ak; + akm4xxx_t *ak; /* set the analog DACs */ ice->num_total_dacs = 2; @@ -267,7 +267,7 @@ static int __devinit snd_ice1712_value_init(struct snd_ice1712 *ice) ice->num_total_adcs = 2; /* analog section */ - ak = ice->akm = kmalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ak = ice->akm = kmalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (! ak) return -ENOMEM; ice->akm_codecs = 1; @@ -284,7 +284,7 @@ static int __devinit snd_ice1712_value_init(struct snd_ice1712 *ice) return 0; } -static int __devinit snd_ice1712_ez8_init(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_ez8_init(ice1712_t *ice) { ice->gpio.write_mask = ice->eeprom.gpiomask; ice->gpio.direction = ice->eeprom.gpiodir; diff --git a/trunk/sound/pci/ice1712/ice1712.c b/trunk/sound/pci/ice1712/ice1712.c index ef6f18558c95..bd71bf424549 100644 --- a/trunk/sound/pci/ice1712/ice1712.c +++ b/trunk/sound/pci/ice1712/ice1712.c @@ -108,8 +108,8 @@ static struct pci_device_id snd_ice1712_ids[] = { MODULE_DEVICE_TABLE(pci, snd_ice1712_ids); -static int snd_ice1712_build_pro_mixer(struct snd_ice1712 *ice); -static int snd_ice1712_build_controls(struct snd_ice1712 *ice); +static int snd_ice1712_build_pro_mixer(ice1712_t *ice); +static int snd_ice1712_build_controls(ice1712_t *ice); static int PRO_RATE_LOCKED; static int PRO_RATE_RESET = 1; @@ -120,33 +120,33 @@ static unsigned int PRO_RATE_DEFAULT = 44100; */ /* check whether the clock mode is spdif-in */ -static inline int is_spdif_master(struct snd_ice1712 *ice) +static inline int is_spdif_master(ice1712_t *ice) { return (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER) ? 1 : 0; } -static inline int is_pro_rate_locked(struct snd_ice1712 *ice) +static inline int is_pro_rate_locked(ice1712_t *ice) { return is_spdif_master(ice) || PRO_RATE_LOCKED; } -static inline void snd_ice1712_ds_write(struct snd_ice1712 * ice, u8 channel, u8 addr, u32 data) +static inline void snd_ice1712_ds_write(ice1712_t * ice, u8 channel, u8 addr, u32 data) { outb((channel << 4) | addr, ICEDS(ice, INDEX)); outl(data, ICEDS(ice, DATA)); } -static inline u32 snd_ice1712_ds_read(struct snd_ice1712 * ice, u8 channel, u8 addr) +static inline u32 snd_ice1712_ds_read(ice1712_t * ice, u8 channel, u8 addr) { outb((channel << 4) | addr, ICEDS(ice, INDEX)); return inl(ICEDS(ice, DATA)); } -static void snd_ice1712_ac97_write(struct snd_ac97 *ac97, +static void snd_ice1712_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct snd_ice1712 *ice = ac97->private_data; + ice1712_t *ice = (ice1712_t *)ac97->private_data; int tm; unsigned char old_cmd = 0; @@ -167,10 +167,10 @@ static void snd_ice1712_ac97_write(struct snd_ac97 *ac97, break; } -static unsigned short snd_ice1712_ac97_read(struct snd_ac97 *ac97, +static unsigned short snd_ice1712_ac97_read(ac97_t *ac97, unsigned short reg) { - struct snd_ice1712 *ice = ac97->private_data; + ice1712_t *ice = (ice1712_t *)ac97->private_data; int tm; unsigned char old_cmd = 0; @@ -196,11 +196,11 @@ static unsigned short snd_ice1712_ac97_read(struct snd_ac97 *ac97, * pro ac97 section */ -static void snd_ice1712_pro_ac97_write(struct snd_ac97 *ac97, +static void snd_ice1712_pro_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct snd_ice1712 *ice = ac97->private_data; + ice1712_t *ice = (ice1712_t *)ac97->private_data; int tm; unsigned char old_cmd = 0; @@ -222,10 +222,10 @@ static void snd_ice1712_pro_ac97_write(struct snd_ac97 *ac97, } -static unsigned short snd_ice1712_pro_ac97_read(struct snd_ac97 *ac97, +static unsigned short snd_ice1712_pro_ac97_read(ac97_t *ac97, unsigned short reg) { - struct snd_ice1712 *ice = ac97->private_data; + ice1712_t *ice = (ice1712_t *)ac97->private_data; int tm; unsigned char old_cmd = 0; @@ -250,7 +250,7 @@ static unsigned short snd_ice1712_pro_ac97_read(struct snd_ac97 *ac97, /* * consumer ac97 digital mix */ -static int snd_ice1712_digmix_route_ac97_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_digmix_route_ac97_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -259,17 +259,17 @@ static int snd_ice1712_digmix_route_ac97_info(struct snd_kcontrol *kcontrol, str return 0; } -static int snd_ice1712_digmix_route_ac97_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_digmix_route_ac97_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_ROUTECTRL)) & ICE1712_ROUTE_AC97 ? 1 : 0; return 0; } -static int snd_ice1712_digmix_route_ac97_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_digmix_route_ac97_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char val, nval; spin_lock_irq(&ice->reg_lock); @@ -281,7 +281,7 @@ static int snd_ice1712_digmix_route_ac97_put(struct snd_kcontrol *kcontrol, stru return val != nval; } -static struct snd_kcontrol_new snd_ice1712_mixer_digmix_route_ac97 __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_mixer_digmix_route_ac97 __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Digital Mixer To AC97", .info = snd_ice1712_digmix_route_ac97_info, @@ -293,24 +293,24 @@ static struct snd_kcontrol_new snd_ice1712_mixer_digmix_route_ac97 __devinitdata /* * gpio operations */ -static void snd_ice1712_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data) +static void snd_ice1712_set_gpio_dir(ice1712_t *ice, unsigned int data) { snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, data); inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */ } -static void snd_ice1712_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) +static void snd_ice1712_set_gpio_mask(ice1712_t *ice, unsigned int data) { snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, data); inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */ } -static unsigned int snd_ice1712_get_gpio_data(struct snd_ice1712 *ice) +static unsigned int snd_ice1712_get_gpio_data(ice1712_t *ice) { return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA); } -static void snd_ice1712_set_gpio_data(struct snd_ice1712 *ice, unsigned int val) +static void snd_ice1712_set_gpio_data(ice1712_t *ice, unsigned int val) { snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, val); inb(ICEREG(ice, DATA)); /* dummy read for pci-posting */ @@ -327,7 +327,7 @@ static void snd_ice1712_set_gpio_data(struct snd_ice1712 *ice, unsigned int val) * change the input clock selection * spdif_clock = 1 - IEC958 input, 0 - Envy24 */ -static int snd_ice1712_cs8427_set_input_clock(struct snd_ice1712 *ice, int spdif_clock) +static int snd_ice1712_cs8427_set_input_clock(ice1712_t *ice, int spdif_clock) { unsigned char reg[2] = { 0x80 | 4, 0 }; /* CS8427 auto increment | register number 4 + data */ unsigned char val, nval; @@ -362,17 +362,17 @@ static int snd_ice1712_cs8427_set_input_clock(struct snd_ice1712 *ice, int spdif /* * spdif callbacks */ -static void open_cs8427(struct snd_ice1712 *ice, struct snd_pcm_substream *substream) +static void open_cs8427(ice1712_t *ice, snd_pcm_substream_t * substream) { snd_cs8427_iec958_active(ice->cs8427, 1); } -static void close_cs8427(struct snd_ice1712 *ice, struct snd_pcm_substream *substream) +static void close_cs8427(ice1712_t *ice, snd_pcm_substream_t * substream) { snd_cs8427_iec958_active(ice->cs8427, 0); } -static void setup_cs8427(struct snd_ice1712 *ice, int rate) +static void setup_cs8427(ice1712_t *ice, int rate) { snd_cs8427_iec958_pcm(ice->cs8427, rate); } @@ -380,7 +380,7 @@ static void setup_cs8427(struct snd_ice1712 *ice, int rate) /* * create and initialize callbacks for cs8427 interface */ -int __devinit snd_ice1712_init_cs8427(struct snd_ice1712 *ice, int addr) +int __devinit snd_ice1712_init_cs8427(ice1712_t *ice, int addr) { int err; @@ -403,7 +403,7 @@ int __devinit snd_ice1712_init_cs8427(struct snd_ice1712 *ice, int addr) static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_ice1712 *ice = dev_id; + ice1712_t *ice = dev_id; unsigned char status; int handled = 0; @@ -444,7 +444,7 @@ static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs * if (status & ICE1712_IRQ_PBKDS) { u32 idx; u16 pbkstatus; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; pbkstatus = inw(ICEDS(ice, INTSTAT)); //printk("pbkstatus = 0x%x\n", pbkstatus); for (idx = 0; idx < 6; idx++) { @@ -475,13 +475,13 @@ static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs * * PCM part - misc */ -static int snd_ice1712_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ice1712_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_ice1712_hw_free(struct snd_pcm_substream *substream) +static int snd_ice1712_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } @@ -490,10 +490,10 @@ static int snd_ice1712_hw_free(struct snd_pcm_substream *substream) * PCM part - consumer I/O */ -static int snd_ice1712_playback_trigger(struct snd_pcm_substream *substream, +static int snd_ice1712_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); int result = 0; u32 tmp; @@ -515,10 +515,10 @@ static int snd_ice1712_playback_trigger(struct snd_pcm_substream *substream, return result; } -static int snd_ice1712_playback_ds_trigger(struct snd_pcm_substream *substream, +static int snd_ice1712_playback_ds_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); int result = 0; u32 tmp; @@ -540,10 +540,10 @@ static int snd_ice1712_playback_ds_trigger(struct snd_pcm_substream *substream, return result; } -static int snd_ice1712_capture_trigger(struct snd_pcm_substream *substream, +static int snd_ice1712_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); int result = 0; u8 tmp; @@ -561,10 +561,10 @@ static int snd_ice1712_capture_trigger(struct snd_pcm_substream *substream, return result; } -static int snd_ice1712_playback_prepare(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; u32 period_size, buf_size, rate, tmp; period_size = (snd_pcm_lib_period_bytes(substream) >> 2) - 1; @@ -594,10 +594,10 @@ static int snd_ice1712_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_playback_ds_prepare(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_ds_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; u32 period_size, buf_size, rate, tmp, chn; period_size = snd_pcm_lib_period_bytes(substream) - 1; @@ -629,10 +629,10 @@ static int snd_ice1712_playback_ds_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_capture_prepare(struct snd_pcm_substream *substream) +static int snd_ice1712_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; u32 period_size, buf_size; u8 tmp; @@ -654,10 +654,10 @@ static int snd_ice1712_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_ice1712_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ice1712_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; size_t ptr; if (!(snd_ice1712_read(ice, ICE1712_IREG_PBK_CTRL) & 1)) @@ -668,9 +668,9 @@ static snd_pcm_uframes_t snd_ice1712_playback_pointer(struct snd_pcm_substream * return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_ice1712_playback_ds_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ice1712_playback_ds_pointer(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); u8 addr; size_t ptr; @@ -687,9 +687,9 @@ static snd_pcm_uframes_t snd_ice1712_playback_ds_pointer(struct snd_pcm_substrea return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_ice1712_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ice1712_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); size_t ptr; if (!(snd_ice1712_read(ice, ICE1712_IREG_CAP_CTRL) & 1)) @@ -700,7 +700,7 @@ static snd_pcm_uframes_t snd_ice1712_capture_pointer(struct snd_pcm_substream *s return bytes_to_frames(substream->runtime, ptr); } -static struct snd_pcm_hardware snd_ice1712_playback = +static snd_pcm_hardware_t snd_ice1712_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -720,7 +720,7 @@ static struct snd_pcm_hardware snd_ice1712_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ice1712_playback_ds = +static snd_pcm_hardware_t snd_ice1712_playback_ds = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -740,7 +740,7 @@ static struct snd_pcm_hardware snd_ice1712_playback_ds = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ice1712_capture = +static snd_pcm_hardware_t snd_ice1712_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -759,20 +759,20 @@ static struct snd_pcm_hardware snd_ice1712_capture = .fifo_size = 0, }; -static int snd_ice1712_playback_open(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); ice->playback_con_substream = substream; runtime->hw = snd_ice1712_playback; return 0; } -static int snd_ice1712_playback_ds_open(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_ds_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); u32 tmp; ice->playback_con_substream_ds[substream->number] = substream; @@ -784,10 +784,10 @@ static int snd_ice1712_playback_ds_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_capture_open(struct snd_pcm_substream *substream) +static int snd_ice1712_capture_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); ice->capture_con_substream = substream; runtime->hw = snd_ice1712_capture; @@ -797,17 +797,17 @@ static int snd_ice1712_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_playback_close(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); ice->playback_con_substream = NULL; return 0; } -static int snd_ice1712_playback_ds_close(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_ds_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); u32 tmp; spin_lock_irq(&ice->reg_lock); @@ -818,15 +818,15 @@ static int snd_ice1712_playback_ds_close(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_capture_close(struct snd_pcm_substream *substream) +static int snd_ice1712_capture_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); ice->capture_con_substream = NULL; return 0; } -static struct snd_pcm_ops snd_ice1712_playback_ops = { +static snd_pcm_ops_t snd_ice1712_playback_ops = { .open = snd_ice1712_playback_open, .close = snd_ice1712_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -837,7 +837,7 @@ static struct snd_pcm_ops snd_ice1712_playback_ops = { .pointer = snd_ice1712_playback_pointer, }; -static struct snd_pcm_ops snd_ice1712_playback_ds_ops = { +static snd_pcm_ops_t snd_ice1712_playback_ds_ops = { .open = snd_ice1712_playback_ds_open, .close = snd_ice1712_playback_ds_close, .ioctl = snd_pcm_lib_ioctl, @@ -848,7 +848,7 @@ static struct snd_pcm_ops snd_ice1712_playback_ds_ops = { .pointer = snd_ice1712_playback_ds_pointer, }; -static struct snd_pcm_ops snd_ice1712_capture_ops = { +static snd_pcm_ops_t snd_ice1712_capture_ops = { .open = snd_ice1712_capture_open, .close = snd_ice1712_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -859,9 +859,16 @@ static struct snd_pcm_ops snd_ice1712_capture_ops = { .pointer = snd_ice1712_capture_pointer, }; -static int __devinit snd_ice1712_pcm(struct snd_ice1712 * ice, int device, struct snd_pcm ** rpcm) +static void snd_ice1712_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + ice1712_t *ice = pcm->private_data; + ice->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_ice1712_pcm(ice1712_t * ice, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -874,6 +881,7 @@ static int __devinit snd_ice1712_pcm(struct snd_ice1712 * ice, int device, struc snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ice1712_capture_ops); pcm->private_data = ice; + pcm->private_free = snd_ice1712_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, "ICE1712 consumer"); ice->pcm = pcm; @@ -889,9 +897,16 @@ static int __devinit snd_ice1712_pcm(struct snd_ice1712 * ice, int device, struc return 0; } -static int __devinit snd_ice1712_pcm_ds(struct snd_ice1712 * ice, int device, struct snd_pcm ** rpcm) +static void snd_ice1712_pcm_free_ds(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + ice1712_t *ice = pcm->private_data; + ice->pcm_ds = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_ice1712_pcm_ds(ice1712_t * ice, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -903,6 +918,7 @@ static int __devinit snd_ice1712_pcm_ds(struct snd_ice1712 * ice, int device, st snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ice1712_playback_ds_ops); pcm->private_data = ice; + pcm->private_free = snd_ice1712_pcm_free_ds; pcm->info_flags = 0; strcpy(pcm->name, "ICE1712 consumer (DS)"); ice->pcm_ds = pcm; @@ -923,16 +939,16 @@ static int __devinit snd_ice1712_pcm_ds(struct snd_ice1712 * ice, int device, st static unsigned int rates[] = { 8000, 9600, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000 }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, }; -static int snd_ice1712_pro_trigger(struct snd_pcm_substream *substream, +static int snd_ice1712_pro_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: @@ -959,7 +975,7 @@ static int snd_ice1712_pro_trigger(struct snd_pcm_substream *substream, unsigned int what = 0; unsigned int old; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); @@ -989,7 +1005,7 @@ static int snd_ice1712_pro_trigger(struct snd_pcm_substream *substream, /* */ -static void snd_ice1712_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate, int force) +static void snd_ice1712_set_pro_rate(ice1712_t *ice, unsigned int rate, int force) { unsigned long flags; unsigned char val, old; @@ -1043,9 +1059,9 @@ static void snd_ice1712_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate, ice->spdif.ops.setup_rate(ice, rate); } -static int snd_ice1712_playback_pro_prepare(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_pro_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); ice->playback_pro_size = snd_pcm_lib_buffer_bytes(substream); spin_lock_irq(&ice->reg_lock); @@ -1057,18 +1073,18 @@ static int snd_ice1712_playback_pro_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_playback_pro_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ice1712_playback_pro_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); snd_ice1712_set_pro_rate(ice, params_rate(hw_params), 0); return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_ice1712_capture_pro_prepare(struct snd_pcm_substream *substream) +static int snd_ice1712_capture_pro_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); ice->capture_pro_size = snd_pcm_lib_buffer_bytes(substream); spin_lock_irq(&ice->reg_lock); @@ -1079,18 +1095,18 @@ static int snd_ice1712_capture_pro_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_capture_pro_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ice1712_capture_pro_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); snd_ice1712_set_pro_rate(ice, params_rate(hw_params), 0); return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static snd_pcm_uframes_t snd_ice1712_playback_pro_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ice1712_playback_pro_pointer(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); size_t ptr; if (!(inl(ICEMT(ice, PLAYBACK_CONTROL)) & ICE1712_PLAYBACK_START)) @@ -1101,9 +1117,9 @@ static snd_pcm_uframes_t snd_ice1712_playback_pro_pointer(struct snd_pcm_substre return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_ice1712_capture_pro_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ice1712_capture_pro_pointer(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); size_t ptr; if (!(inl(ICEMT(ice, PLAYBACK_CONTROL)) & ICE1712_CAPTURE_START_SHADOW)) @@ -1114,7 +1130,7 @@ static snd_pcm_uframes_t snd_ice1712_capture_pro_pointer(struct snd_pcm_substrea return bytes_to_frames(substream->runtime, ptr); } -static struct snd_pcm_hardware snd_ice1712_playback_pro = +static snd_pcm_hardware_t snd_ice1712_playback_pro = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1134,7 +1150,7 @@ static struct snd_pcm_hardware snd_ice1712_playback_pro = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ice1712_capture_pro = +static snd_pcm_hardware_t snd_ice1712_capture_pro = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1154,10 +1170,10 @@ static struct snd_pcm_hardware snd_ice1712_capture_pro = .fifo_size = 0, }; -static int snd_ice1712_playback_pro_open(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_pro_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); ice->playback_pro_substream = substream; runtime->hw = snd_ice1712_playback_pro; @@ -1171,10 +1187,10 @@ static int snd_ice1712_playback_pro_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_capture_pro_open(struct snd_pcm_substream *substream) +static int snd_ice1712_capture_pro_open(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; ice->capture_pro_substream = substream; runtime->hw = snd_ice1712_capture_pro; @@ -1184,9 +1200,9 @@ static int snd_ice1712_capture_pro_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_playback_pro_close(struct snd_pcm_substream *substream) +static int snd_ice1712_playback_pro_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (PRO_RATE_RESET) snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 0); @@ -1197,9 +1213,9 @@ static int snd_ice1712_playback_pro_close(struct snd_pcm_substream *substream) return 0; } -static int snd_ice1712_capture_pro_close(struct snd_pcm_substream *substream) +static int snd_ice1712_capture_pro_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (PRO_RATE_RESET) snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 0); @@ -1207,7 +1223,14 @@ static int snd_ice1712_capture_pro_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_ice1712_playback_pro_ops = { +static void snd_ice1712_pcm_profi_free(snd_pcm_t *pcm) +{ + ice1712_t *ice = pcm->private_data; + ice->pcm_pro = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static snd_pcm_ops_t snd_ice1712_playback_pro_ops = { .open = snd_ice1712_playback_pro_open, .close = snd_ice1712_playback_pro_close, .ioctl = snd_pcm_lib_ioctl, @@ -1218,7 +1241,7 @@ static struct snd_pcm_ops snd_ice1712_playback_pro_ops = { .pointer = snd_ice1712_playback_pro_pointer, }; -static struct snd_pcm_ops snd_ice1712_capture_pro_ops = { +static snd_pcm_ops_t snd_ice1712_capture_pro_ops = { .open = snd_ice1712_capture_pro_open, .close = snd_ice1712_capture_pro_close, .ioctl = snd_pcm_lib_ioctl, @@ -1229,9 +1252,9 @@ static struct snd_pcm_ops snd_ice1712_capture_pro_ops = { .pointer = snd_ice1712_capture_pro_pointer, }; -static int __devinit snd_ice1712_pcm_profi(struct snd_ice1712 * ice, int device, struct snd_pcm ** rpcm) +static int __devinit snd_ice1712_pcm_profi(ice1712_t * ice, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -1244,6 +1267,7 @@ static int __devinit snd_ice1712_pcm_profi(struct snd_ice1712 * ice, int device, snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ice1712_capture_pro_ops); pcm->private_data = ice; + pcm->private_free = snd_ice1712_pcm_profi_free; pcm->info_flags = 0; strcpy(pcm->name, "ICE1712 multi"); @@ -1272,7 +1296,7 @@ static int __devinit snd_ice1712_pcm_profi(struct snd_ice1712 * ice, int device, * Mixer section */ -static void snd_ice1712_update_volume(struct snd_ice1712 *ice, int index) +static void snd_ice1712_update_volume(ice1712_t *ice, int index) { unsigned int vol = ice->pro_volumes[index]; unsigned short val = 0; @@ -1283,7 +1307,7 @@ static void snd_ice1712_update_volume(struct snd_ice1712 *ice, int index) outw(val, ICEMT(ice, MONITOR_VOLUME)); } -static int snd_ice1712_pro_mixer_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_mixer_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -1292,9 +1316,9 @@ static int snd_ice1712_pro_mixer_switch_info(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_ice1712_pro_mixer_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_mixer_switch_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value; spin_lock_irq(&ice->reg_lock); @@ -1304,9 +1328,9 @@ static int snd_ice1712_pro_mixer_switch_get(struct snd_kcontrol *kcontrol, struc return 0; } -static int snd_ice1712_pro_mixer_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_mixer_switch_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value; unsigned int nval, change; @@ -1321,7 +1345,7 @@ static int snd_ice1712_pro_mixer_switch_put(struct snd_kcontrol *kcontrol, struc return change; } -static int snd_ice1712_pro_mixer_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_mixer_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1330,9 +1354,9 @@ static int snd_ice1712_pro_mixer_volume_info(struct snd_kcontrol *kcontrol, stru return 0; } -static int snd_ice1712_pro_mixer_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_mixer_volume_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value; spin_lock_irq(&ice->reg_lock); @@ -1342,9 +1366,9 @@ static int snd_ice1712_pro_mixer_volume_get(struct snd_kcontrol *kcontrol, struc return 0; } -static int snd_ice1712_pro_mixer_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_mixer_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value; unsigned int nval, change; @@ -1360,7 +1384,7 @@ static int snd_ice1712_pro_mixer_volume_put(struct snd_kcontrol *kcontrol, struc } -static struct snd_kcontrol_new snd_ice1712_multi_playback_ctrls[] __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_multi_playback_ctrls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Playback Switch", @@ -1381,7 +1405,7 @@ static struct snd_kcontrol_new snd_ice1712_multi_playback_ctrls[] __devinitdata }, }; -static struct snd_kcontrol_new snd_ice1712_multi_capture_analog_switch __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_multi_capture_analog_switch __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "H/W Multi Capture Switch", .info = snd_ice1712_pro_mixer_switch_info, @@ -1390,7 +1414,7 @@ static struct snd_kcontrol_new snd_ice1712_multi_capture_analog_switch __devinit .private_value = 10, }; -static struct snd_kcontrol_new snd_ice1712_multi_capture_spdif_switch __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_multi_capture_spdif_switch __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("Multi ",CAPTURE,SWITCH), .info = snd_ice1712_pro_mixer_switch_info, @@ -1400,7 +1424,7 @@ static struct snd_kcontrol_new snd_ice1712_multi_capture_spdif_switch __devinitd .count = 2, }; -static struct snd_kcontrol_new snd_ice1712_multi_capture_analog_volume __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_multi_capture_analog_volume __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "H/W Multi Capture Volume", .info = snd_ice1712_pro_mixer_volume_info, @@ -1409,7 +1433,7 @@ static struct snd_kcontrol_new snd_ice1712_multi_capture_analog_volume __devinit .private_value = 10, }; -static struct snd_kcontrol_new snd_ice1712_multi_capture_spdif_volume __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_multi_capture_spdif_volume __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("Multi ",CAPTURE,VOLUME), .info = snd_ice1712_pro_mixer_volume_info, @@ -1419,9 +1443,9 @@ static struct snd_kcontrol_new snd_ice1712_multi_capture_spdif_volume __devinitd .count = 2, }; -static int __devinit snd_ice1712_build_pro_mixer(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_build_pro_mixer(ice1712_t *ice) { - struct snd_card *card = ice->card; + snd_card_t * card = ice->card; unsigned int idx; int err; @@ -1433,7 +1457,7 @@ static int __devinit snd_ice1712_build_pro_mixer(struct snd_ice1712 *ice) } if (ice->num_total_adcs > 0) { - struct snd_kcontrol_new tmp = snd_ice1712_multi_capture_analog_switch; + snd_kcontrol_new_t tmp = snd_ice1712_multi_capture_analog_switch; tmp.count = ice->num_total_adcs; err = snd_ctl_add(card, snd_ctl_new1(&tmp, ice)); if (err < 0) @@ -1445,7 +1469,7 @@ static int __devinit snd_ice1712_build_pro_mixer(struct snd_ice1712 *ice) return err; if (ice->num_total_adcs > 0) { - struct snd_kcontrol_new tmp = snd_ice1712_multi_capture_analog_volume; + snd_kcontrol_new_t tmp = snd_ice1712_multi_capture_analog_volume; tmp.count = ice->num_total_adcs; err = snd_ctl_add(card, snd_ctl_new1(&tmp, ice)); if (err < 0) @@ -1472,22 +1496,22 @@ static int __devinit snd_ice1712_build_pro_mixer(struct snd_ice1712 *ice) return 0; } -static void snd_ice1712_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_ice1712_mixer_free_ac97(ac97_t *ac97) { - struct snd_ice1712 *ice = ac97->private_data; + ice1712_t *ice = ac97->private_data; ice->ac97 = NULL; } -static int __devinit snd_ice1712_ac97_mixer(struct snd_ice1712 * ice) +static int __devinit snd_ice1712_ac97_mixer(ice1712_t * ice) { int err, bus_num = 0; - struct snd_ac97_template ac97; - struct snd_ac97_bus *pbus; - static struct snd_ac97_bus_ops con_ops = { + ac97_template_t ac97; + ac97_bus_t *pbus; + static ac97_bus_ops_t con_ops = { .write = snd_ice1712_ac97_write, .read = snd_ice1712_ac97_read, }; - static struct snd_ac97_bus_ops pro_ops = { + static ac97_bus_ops_t pro_ops = { .write = snd_ice1712_pro_ac97_write, .read = snd_ice1712_pro_ac97_read, }; @@ -1527,15 +1551,15 @@ static int __devinit snd_ice1712_ac97_mixer(struct snd_ice1712 * ice) * */ -static inline unsigned int eeprom_double(struct snd_ice1712 *ice, int idx) +static inline unsigned int eeprom_double(ice1712_t *ice, int idx) { return (unsigned int)ice->eeprom.data[idx] | ((unsigned int)ice->eeprom.data[idx + 1] << 8); } -static void snd_ice1712_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ice1712_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ice1712 *ice = entry->private_data; + ice1712_t *ice = entry->private_data; unsigned int idx; snd_iprintf(buffer, "%s\n\n", ice->card->longname); @@ -1569,9 +1593,9 @@ static void snd_ice1712_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, " RATE : 0x%02x\n", (unsigned)inb(ICEMT(ice, RATE))); } -static void __devinit snd_ice1712_proc_init(struct snd_ice1712 * ice) +static void __devinit snd_ice1712_proc_init(ice1712_t * ice) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(ice->card, "ice1712", &entry)) snd_info_set_text_ops(entry, ice, 1024, snd_ice1712_proc_read); @@ -1581,24 +1605,22 @@ static void __devinit snd_ice1712_proc_init(struct snd_ice1712 * ice) * */ -static int snd_ice1712_eeprom_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_eeprom_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; - uinfo->count = sizeof(struct snd_ice1712_eeprom); + uinfo->count = sizeof(ice1712_eeprom_t); return 0; } -static int snd_ice1712_eeprom_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_eeprom_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); memcpy(ucontrol->value.bytes.data, &ice->eeprom, sizeof(ice->eeprom)); return 0; } -static struct snd_kcontrol_new snd_ice1712_eeprom __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_eeprom __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = "ICE1712 EEPROM", .access = SNDRV_CTL_ELEM_ACCESS_READ, @@ -1608,33 +1630,32 @@ static struct snd_kcontrol_new snd_ice1712_eeprom __devinitdata = { /* */ -static int snd_ice1712_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ice1712_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_spdif_default_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); if (ice->spdif.ops.default_get) ice->spdif.ops.default_get(ice, ucontrol); return 0; } -static int snd_ice1712_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_spdif_default_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); if (ice->spdif.ops.default_put) return ice->spdif.ops.default_put(ice, ucontrol); return 0; } -static struct snd_kcontrol_new snd_ice1712_spdif_default __devinitdata = +static snd_kcontrol_new_t snd_ice1712_spdif_default __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -1643,10 +1664,10 @@ static struct snd_kcontrol_new snd_ice1712_spdif_default __devinitdata = .put = snd_ice1712_spdif_default_put }; -static int snd_ice1712_spdif_maskc_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_spdif_maskc_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); if (ice->spdif.ops.default_get) { ucontrol->value.iec958.status[0] = IEC958_AES0_NONAUDIO | IEC958_AES0_PROFESSIONAL | @@ -1665,10 +1686,10 @@ static int snd_ice1712_spdif_maskc_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_spdif_maskp_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_spdif_maskp_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); if (ice->spdif.ops.default_get) { ucontrol->value.iec958.status[0] = IEC958_AES0_NONAUDIO | IEC958_AES0_PROFESSIONAL | @@ -1685,7 +1706,7 @@ static int snd_ice1712_spdif_maskp_get(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_ice1712_spdif_maskc __devinitdata = +static snd_kcontrol_new_t snd_ice1712_spdif_maskc __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1694,7 +1715,7 @@ static struct snd_kcontrol_new snd_ice1712_spdif_maskc __devinitdata = .get = snd_ice1712_spdif_maskc_get, }; -static struct snd_kcontrol_new snd_ice1712_spdif_maskp __devinitdata = +static snd_kcontrol_new_t snd_ice1712_spdif_maskp __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1703,28 +1724,27 @@ static struct snd_kcontrol_new snd_ice1712_spdif_maskp __devinitdata = .get = snd_ice1712_spdif_maskp_get, }; -static int snd_ice1712_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_spdif_stream_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); if (ice->spdif.ops.stream_get) ice->spdif.ops.stream_get(ice, ucontrol); return 0; } -static int snd_ice1712_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_spdif_stream_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); if (ice->spdif.ops.stream_put) return ice->spdif.ops.stream_put(ice, ucontrol); return 0; } -static struct snd_kcontrol_new snd_ice1712_spdif_stream __devinitdata = +static snd_kcontrol_new_t snd_ice1712_spdif_stream __devinitdata = { - .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | - SNDRV_CTL_ELEM_ACCESS_INACTIVE), + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM), .info = snd_ice1712_spdif_info, @@ -1732,8 +1752,7 @@ static struct snd_kcontrol_new snd_ice1712_spdif_stream __devinitdata = .put = snd_ice1712_spdif_stream_put }; -int snd_ice1712_gpio_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +int snd_ice1712_gpio_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1742,24 +1761,21 @@ int snd_ice1712_gpio_info(struct snd_kcontrol *kcontrol, return 0; } -int snd_ice1712_gpio_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_ice1712_gpio_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char mask = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0; snd_ice1712_save_gpio_status(ice); - ucontrol->value.integer.value[0] = - (snd_ice1712_gpio_read(ice) & mask ? 1 : 0) ^ invert; + ucontrol->value.integer.value[0] = (snd_ice1712_gpio_read(ice) & mask ? 1 : 0) ^ invert; snd_ice1712_restore_gpio_status(ice); return 0; } -int snd_ice1712_gpio_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_ice1712_gpio_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char mask = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value & (1<<24)) ? mask : 0; unsigned int val, nval; @@ -1779,8 +1795,7 @@ int snd_ice1712_gpio_put(struct snd_kcontrol *kcontrol, /* * rate */ -static int snd_ice1712_pro_internal_clock_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_internal_clock_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "8000", /* 0: 6 */ @@ -1807,10 +1822,9 @@ static int snd_ice1712_pro_internal_clock_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_internal_clock_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_internal_clock_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); static unsigned char xlate[16] = { 9, 6, 3, 1, 7, 4, 0, 12, 8, 5, 2, 11, 255, 255, 255, 10 }; @@ -1831,10 +1845,9 @@ static int snd_ice1712_pro_internal_clock_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_internal_clock_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_internal_clock_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); static unsigned int xrate[13] = { 8000, 9600, 11025, 12000, 1600, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000 @@ -1855,8 +1868,7 @@ static int snd_ice1712_pro_internal_clock_put(struct snd_kcontrol *kcontrol, change = inb(ICEMT(ice, RATE)) != oval; spin_unlock_irq(&ice->reg_lock); - if ((oval & ICE1712_SPDIF_MASTER) != - (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) { + if ((oval & ICE1712_SPDIF_MASTER) != (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) { /* change CS8427 clock source too */ if (ice->cs8427) { snd_ice1712_cs8427_set_input_clock(ice, is_spdif_master(ice)); @@ -1874,7 +1886,7 @@ static int snd_ice1712_pro_internal_clock_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ice1712_pro_internal_clock __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_pro_internal_clock __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Internal Clock", .info = snd_ice1712_pro_internal_clock_info, @@ -1882,8 +1894,7 @@ static struct snd_kcontrol_new snd_ice1712_pro_internal_clock __devinitdata = { .put = snd_ice1712_pro_internal_clock_put }; -static int snd_ice1712_pro_internal_clock_default_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_internal_clock_default_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "8000", /* 0: 6 */ @@ -1910,8 +1921,7 @@ static int snd_ice1712_pro_internal_clock_default_info(struct snd_kcontrol *kcon return 0; } -static int snd_ice1712_pro_internal_clock_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_internal_clock_default_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { int val; static unsigned int xrate[13] = { @@ -1928,8 +1938,7 @@ static int snd_ice1712_pro_internal_clock_default_get(struct snd_kcontrol *kcont return 0; } -static int snd_ice1712_pro_internal_clock_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_internal_clock_default_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { static unsigned int xrate[13] = { 8000, 9600, 11025, 12000, 1600, 22050, 24000, @@ -1945,7 +1954,7 @@ static int snd_ice1712_pro_internal_clock_default_put(struct snd_kcontrol *kcont return change; } -static struct snd_kcontrol_new snd_ice1712_pro_internal_clock_default __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_pro_internal_clock_default __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Internal Clock Default", .info = snd_ice1712_pro_internal_clock_default_info, @@ -1953,8 +1962,7 @@ static struct snd_kcontrol_new snd_ice1712_pro_internal_clock_default __devinitd .put = snd_ice1712_pro_internal_clock_default_put }; -static int snd_ice1712_pro_rate_locking_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_rate_locking_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1963,17 +1971,15 @@ static int snd_ice1712_pro_rate_locking_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_rate_locking_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_rate_locking_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.integer.value[0] = PRO_RATE_LOCKED; return 0; } -static int snd_ice1712_pro_rate_locking_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_rate_locking_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, nval; nval = ucontrol->value.integer.value[0] ? 1 : 0; @@ -1984,7 +1990,7 @@ static int snd_ice1712_pro_rate_locking_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ice1712_pro_rate_locking __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_pro_rate_locking __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Rate Locking", .info = snd_ice1712_pro_rate_locking_info, @@ -1992,8 +1998,7 @@ static struct snd_kcontrol_new snd_ice1712_pro_rate_locking __devinitdata = { .put = snd_ice1712_pro_rate_locking_put }; -static int snd_ice1712_pro_rate_reset_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_rate_reset_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2002,17 +2007,15 @@ static int snd_ice1712_pro_rate_reset_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_rate_reset_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_rate_reset_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.integer.value[0] = PRO_RATE_RESET; return 0; } -static int snd_ice1712_pro_rate_reset_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_rate_reset_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, nval; nval = ucontrol->value.integer.value[0] ? 1 : 0; @@ -2023,7 +2026,7 @@ static int snd_ice1712_pro_rate_reset_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ice1712_pro_rate_reset __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_pro_rate_reset __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Rate Reset", .info = snd_ice1712_pro_rate_reset_info, @@ -2034,8 +2037,7 @@ static struct snd_kcontrol_new snd_ice1712_pro_rate_reset __devinitdata = { /* * routing */ -static int snd_ice1712_pro_route_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_route_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "PCM Out", /* 0 */ @@ -2047,18 +2049,16 @@ static int snd_ice1712_pro_route_info(struct snd_kcontrol *kcontrol, uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; - uinfo->value.enumerated.items = - snd_ctl_get_ioffidx(kcontrol, &uinfo->id) < 2 ? 12 : 11; + uinfo->value.enumerated.items = snd_ctl_get_ioffidx(kcontrol, &uinfo->id) < 2 ? 12 : 11; if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); return 0; } -static int snd_ice1712_pro_route_analog_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_route_analog_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned int val, cval; @@ -2081,10 +2081,9 @@ static int snd_ice1712_pro_route_analog_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_route_analog_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_route_analog_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change, shift; int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned int val, old_val, nval; @@ -2131,10 +2130,9 @@ static int snd_ice1712_pro_route_analog_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_ice1712_pro_route_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_route_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned int val, cval; val = inw(ICEMT(ice, ROUTE_SPDOUT)); @@ -2151,10 +2149,9 @@ static int snd_ice1712_pro_route_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_route_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_route_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change, shift; int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); unsigned int val, old_val, nval; @@ -2190,7 +2187,7 @@ static int snd_ice1712_pro_route_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ice1712_mixer_pro_analog_route __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_mixer_pro_analog_route __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "H/W Playback Route", .info = snd_ice1712_pro_route_info, @@ -2198,7 +2195,7 @@ static struct snd_kcontrol_new snd_ice1712_mixer_pro_analog_route __devinitdata .put = snd_ice1712_pro_route_analog_put, }; -static struct snd_kcontrol_new snd_ice1712_mixer_pro_spdif_route __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_mixer_pro_spdif_route __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Route", .info = snd_ice1712_pro_route_info, @@ -2208,8 +2205,7 @@ static struct snd_kcontrol_new snd_ice1712_mixer_pro_spdif_route __devinitdata = }; -static int snd_ice1712_pro_volume_rate_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_volume_rate_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -2218,19 +2214,17 @@ static int snd_ice1712_pro_volume_rate_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_volume_rate_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_volume_rate_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_RATE)); return 0; } -static int snd_ice1712_pro_volume_rate_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_volume_rate_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change; spin_lock_irq(&ice->reg_lock); @@ -2240,7 +2234,7 @@ static int snd_ice1712_pro_volume_rate_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ice1712_mixer_pro_volume_rate __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_mixer_pro_volume_rate __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Volume Rate", .info = snd_ice1712_pro_volume_rate_info, @@ -2248,8 +2242,7 @@ static struct snd_kcontrol_new snd_ice1712_mixer_pro_volume_rate __devinitdata = .put = snd_ice1712_pro_volume_rate_put }; -static int snd_ice1712_pro_peak_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ice1712_pro_peak_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 22; @@ -2258,10 +2251,9 @@ static int snd_ice1712_pro_peak_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ice1712_pro_peak_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ice1712_pro_peak_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx; spin_lock_irq(&ice->reg_lock); @@ -2273,7 +2265,7 @@ static int snd_ice1712_pro_peak_get(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_ice1712_mixer_pro_peak __devinitdata = { +static snd_kcontrol_new_t snd_ice1712_mixer_pro_peak __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Peak", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, @@ -2295,7 +2287,7 @@ static struct snd_ice1712_card_info *card_tables[] __devinitdata = { NULL, }; -static unsigned char __devinit snd_ice1712_read_i2c(struct snd_ice1712 *ice, +static unsigned char __devinit snd_ice1712_read_i2c(ice1712_t *ice, unsigned char dev, unsigned char addr) { @@ -2307,8 +2299,7 @@ static unsigned char __devinit snd_ice1712_read_i2c(struct snd_ice1712 *ice, return inb(ICEREG(ice, I2C_DATA)); } -static int __devinit snd_ice1712_read_eeprom(struct snd_ice1712 *ice, - const char *modelname) +static int __devinit snd_ice1712_read_eeprom(ice1712_t *ice, const char *modelname) { int dev = 0xa0; /* EEPROM device address */ unsigned int i, size; @@ -2321,8 +2312,7 @@ static int __devinit snd_ice1712_read_eeprom(struct snd_ice1712 *ice, (snd_ice1712_read_i2c(ice, dev, 0x01) << 8) | (snd_ice1712_read_i2c(ice, dev, 0x02) << 16) | (snd_ice1712_read_i2c(ice, dev, 0x03) << 24); - if (ice->eeprom.subvendor == 0 || - ice->eeprom.subvendor == (unsigned int)-1) { + if (ice->eeprom.subvendor == 0 || ice->eeprom.subvendor == (unsigned int)-1) { /* invalid subvendor from EEPROM, try the PCI subststem ID instead */ u16 vendor, device; pci_read_config_word(ice->pci, PCI_SUBSYSTEM_VENDOR_ID, &vendor); @@ -2351,8 +2341,7 @@ static int __devinit snd_ice1712_read_eeprom(struct snd_ice1712 *ice, goto read_skipped; } } - printk(KERN_WARNING "ice1712: No matching model found for ID 0x%x\n", - ice->eeprom.subvendor); + printk(KERN_WARNING "ice1712: No matching model found for ID 0x%x\n", ice->eeprom.subvendor); found: ice->eeprom.size = snd_ice1712_read_i2c(ice, dev, 0x04); @@ -2364,8 +2353,7 @@ static int __devinit snd_ice1712_read_eeprom(struct snd_ice1712 *ice, } ice->eeprom.version = snd_ice1712_read_i2c(ice, dev, 0x05); if (ice->eeprom.version != 1) { - snd_printk(KERN_ERR "invalid EEPROM version %i\n", - ice->eeprom.version); + snd_printk(KERN_ERR "invalid EEPROM version %i\n", ice->eeprom.version); /* return -EIO; */ } size = ice->eeprom.size - 6; @@ -2382,7 +2370,7 @@ static int __devinit snd_ice1712_read_eeprom(struct snd_ice1712 *ice, -static int __devinit snd_ice1712_chip_init(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_chip_init(ice1712_t *ice) { outb(ICE1712_RESET | ICE1712_NATIVE, ICEREG(ice, CONTROL)); udelay(200); @@ -2395,19 +2383,15 @@ static int __devinit snd_ice1712_chip_init(struct snd_ice1712 *ice) if (ice->eeprom.subvendor != ICE1712_SUBDEVICE_STDSP24) { ice->gpio.write_mask = ice->eeprom.gpiomask; ice->gpio.direction = ice->eeprom.gpiodir; - snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, - ice->eeprom.gpiomask); - snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, - ice->eeprom.gpiodir); - snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, - ice->eeprom.gpiostate); + snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ice->eeprom.gpiomask); + snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->eeprom.gpiodir); + snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ice->eeprom.gpiostate); } else { ice->gpio.write_mask = 0xc0; ice->gpio.direction = 0xff; snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, 0xc0); snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, 0xff); - snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, - ICE1712_STDSP24_CLOCK_BIT); + snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ICE1712_STDSP24_CLOCK_BIT); } snd_ice1712_write(ice, ICE1712_IREG_PRO_POWERDOWN, 0); if (!(ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97)) { @@ -2422,10 +2406,10 @@ static int __devinit snd_ice1712_chip_init(struct snd_ice1712 *ice) return 0; } -int __devinit snd_ice1712_spdif_build_controls(struct snd_ice1712 *ice) +int __devinit snd_ice1712_spdif_build_controls(ice1712_t *ice) { int err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; snd_assert(ice->pcm_pro != NULL, return -EIO); err = snd_ctl_add(ice->card, kctl = snd_ctl_new1(&snd_ice1712_spdif_default, ice)); @@ -2449,7 +2433,7 @@ int __devinit snd_ice1712_spdif_build_controls(struct snd_ice1712 *ice) } -static int __devinit snd_ice1712_build_controls(struct snd_ice1712 *ice) +static int __devinit snd_ice1712_build_controls(ice1712_t *ice) { int err; @@ -2471,7 +2455,7 @@ static int __devinit snd_ice1712_build_controls(struct snd_ice1712 *ice) return err; if (ice->num_total_dacs > 0) { - struct snd_kcontrol_new tmp = snd_ice1712_mixer_pro_analog_route; + snd_kcontrol_new_t tmp = snd_ice1712_mixer_pro_analog_route; tmp.count = ice->num_total_dacs; err = snd_ctl_add(ice->card, snd_ctl_new1(&tmp, ice)); if (err < 0) @@ -2492,7 +2476,7 @@ static int __devinit snd_ice1712_build_controls(struct snd_ice1712 *ice) return 0; } -static int snd_ice1712_free(struct snd_ice1712 *ice) +static int snd_ice1712_free(ice1712_t *ice) { if (! ice->port) goto __hw_end; @@ -2503,7 +2487,7 @@ static int snd_ice1712_free(struct snd_ice1712 *ice) __hw_end: if (ice->irq >= 0) { synchronize_irq(ice->irq); - free_irq(ice->irq, ice); + free_irq(ice->irq, (void *) ice); } if (ice->port) pci_release_regions(ice->pci); @@ -2513,22 +2497,22 @@ static int snd_ice1712_free(struct snd_ice1712 *ice) return 0; } -static int snd_ice1712_dev_free(struct snd_device *device) +static int snd_ice1712_dev_free(snd_device_t *device) { - struct snd_ice1712 *ice = device->device_data; + ice1712_t *ice = device->device_data; return snd_ice1712_free(ice); } -static int __devinit snd_ice1712_create(struct snd_card *card, +static int __devinit snd_ice1712_create(snd_card_t * card, struct pci_dev *pci, const char *modelname, int omni, int cs8427_timeout, - struct snd_ice1712 ** r_ice1712) + ice1712_t ** r_ice1712) { - struct snd_ice1712 *ice; + ice1712_t *ice; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ice1712_dev_free, }; @@ -2588,8 +2572,7 @@ static int __devinit snd_ice1712_create(struct snd_card *card, ice->dmapath_port = pci_resource_start(pci, 2); ice->profi_port = pci_resource_start(pci, 3); - if (request_irq(pci->irq, snd_ice1712_interrupt, SA_INTERRUPT|SA_SHIRQ, - "ICE1712", ice)) { + if (request_irq(pci->irq, snd_ice1712_interrupt, SA_INTERRUPT|SA_SHIRQ, "ICE1712", (void *) ice)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_ice1712_free(ice); return -EIO; @@ -2607,10 +2590,8 @@ static int __devinit snd_ice1712_create(struct snd_card *card, } /* unmask used interrupts */ - outb(((ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401) == 0 ? - ICE1712_IRQ_MPU2 : 0) | - ((ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97) ? - ICE1712_IRQ_PBKDS | ICE1712_IRQ_CONCAP | ICE1712_IRQ_CONPBK : 0), + outb((ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401) == 0 ? ICE1712_IRQ_MPU2 : 0 | + (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97) ? ICE1712_IRQ_PBKDS | ICE1712_IRQ_CONCAP | ICE1712_IRQ_CONPBK : 0, ICEREG(ice, IRQMASK)); outb(0x00, ICEMT(ice, IRQ)); @@ -2638,8 +2619,8 @@ static int __devinit snd_ice1712_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_ice1712 *ice; + snd_card_t *card; + ice1712_t *ice; int pcm_dev = 0, err; struct snd_ice1712_card_info **tbl, *c; @@ -2657,8 +2638,7 @@ static int __devinit snd_ice1712_probe(struct pci_dev *pci, strcpy(card->driver, "ICE1712"); strcpy(card->shortname, "ICEnsemble ICE1712"); - if ((err = snd_ice1712_create(card, pci, model[dev], omni[dev], - cs8427_timeout[dev], &ice)) < 0) { + if ((err = snd_ice1712_create(card, pci, model[dev], omni[dev], cs8427_timeout[dev], &ice)) < 0) { snd_card_free(card); return err; } diff --git a/trunk/sound/pci/ice1712/ice1712.h b/trunk/sound/pci/ice1712/ice1712.h index ce96b3bb6531..5ad4728daa7b 100644 --- a/trunk/sound/pci/ice1712/ice1712.h +++ b/trunk/sound/pci/ice1712/ice1712.h @@ -215,9 +215,9 @@ * */ -struct snd_ice1712; +typedef struct _snd_ice1712 ice1712_t; -struct snd_ice1712_eeprom { +typedef struct { unsigned int subvendor; /* PCI[2c-2f] */ unsigned char size; /* size of EEPROM image in bytes */ unsigned char version; /* must be 1 (or 2 for vt1724) */ @@ -225,7 +225,7 @@ struct snd_ice1712_eeprom { unsigned int gpiomask; unsigned int gpiostate; unsigned int gpiodir; -}; +} ice1712_eeprom_t; enum { ICE_EEP1_CODEC = 0, /* 06 */ @@ -266,28 +266,28 @@ struct snd_ak4xxx_private { unsigned int add_flags; /* additional bits at init */ unsigned int mask_flags; /* total mask bits */ struct snd_akm4xxx_ops { - void (*set_rate_val)(struct snd_akm4xxx *ak, unsigned int rate); + void (*set_rate_val)(akm4xxx_t *ak, unsigned int rate); } ops; }; struct snd_ice1712_spdif { unsigned char cs8403_bits; unsigned char cs8403_stream_bits; - struct snd_kcontrol *stream_ctl; + snd_kcontrol_t *stream_ctl; struct snd_ice1712_spdif_ops { - void (*open)(struct snd_ice1712 *, struct snd_pcm_substream *); - void (*setup_rate)(struct snd_ice1712 *, int rate); - void (*close)(struct snd_ice1712 *, struct snd_pcm_substream *); - void (*default_get)(struct snd_ice1712 *, struct snd_ctl_elem_value *ucontrol); - int (*default_put)(struct snd_ice1712 *, struct snd_ctl_elem_value *ucontrol); - void (*stream_get)(struct snd_ice1712 *, struct snd_ctl_elem_value *ucontrol); - int (*stream_put)(struct snd_ice1712 *, struct snd_ctl_elem_value *ucontrol); + void (*open)(ice1712_t *, snd_pcm_substream_t *); + void (*setup_rate)(ice1712_t *, int rate); + void (*close)(ice1712_t *, snd_pcm_substream_t *); + void (*default_get)(ice1712_t *, snd_ctl_elem_value_t * ucontrol); + int (*default_put)(ice1712_t *, snd_ctl_elem_value_t * ucontrol); + void (*stream_get)(ice1712_t *, snd_ctl_elem_value_t * ucontrol); + int (*stream_put)(ice1712_t *, snd_ctl_elem_value_t * ucontrol); } ops; }; -struct snd_ice1712 { +struct _snd_ice1712 { unsigned long conp_dma_size; unsigned long conc_dma_size; unsigned long prop_dma_size; @@ -300,28 +300,28 @@ struct snd_ice1712 { unsigned long profi_port; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm *pcm_ds; - struct snd_pcm *pcm_pro; - struct snd_pcm_substream *playback_con_substream; - struct snd_pcm_substream *playback_con_substream_ds[6]; - struct snd_pcm_substream *capture_con_substream; - struct snd_pcm_substream *playback_pro_substream; - struct snd_pcm_substream *capture_pro_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_t *pcm_ds; + snd_pcm_t *pcm_pro; + snd_pcm_substream_t *playback_con_substream; + snd_pcm_substream_t *playback_con_substream_ds[6]; + snd_pcm_substream_t *capture_con_substream; + snd_pcm_substream_t *playback_pro_substream; + snd_pcm_substream_t *capture_pro_substream; unsigned int playback_pro_size; unsigned int capture_pro_size; unsigned int playback_con_virt_addr[6]; unsigned int playback_con_active_buf[6]; unsigned int capture_con_virt_addr; unsigned int ac97_ext_id; - struct snd_ac97 *ac97; - struct snd_rawmidi *rmidi[2]; + ac97_t *ac97; + snd_rawmidi_t *rmidi[2]; spinlock_t reg_lock; - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; - struct snd_ice1712_eeprom eeprom; + ice1712_eeprom_t eeprom; unsigned int pro_volumes[20]; unsigned int omni: 1; /* Delta Omni I/O */ @@ -335,16 +335,16 @@ struct snd_ice1712 { unsigned int cur_rate; /* current rate */ struct semaphore open_mutex; - struct snd_pcm_substream *pcm_reserved[4]; - struct snd_pcm_hw_constraint_list *hw_rates; /* card-specific rate constraints */ + snd_pcm_substream_t *pcm_reserved[4]; + snd_pcm_hw_constraint_list_t *hw_rates; /* card-specific rate constraints */ unsigned int akm_codecs; - struct snd_akm4xxx *akm; + akm4xxx_t *akm; struct snd_ice1712_spdif spdif; struct semaphore i2c_mutex; /* I2C mutex for ICE1724 registers */ - struct snd_i2c_bus *i2c; /* I2C bus */ - struct snd_i2c_device *cs8427; /* CS8427 I2C device */ + snd_i2c_bus_t *i2c; /* I2C bus */ + snd_i2c_device_t *cs8427; /* CS8427 I2C device */ unsigned int cs8427_timeout; /* CS8427 reset timeout in HZ/100 */ struct ice1712_gpio { @@ -352,20 +352,20 @@ struct snd_ice1712 { unsigned int write_mask; /* current mask bits */ unsigned int saved[2]; /* for ewx_i2c */ /* operators */ - void (*set_mask)(struct snd_ice1712 *ice, unsigned int data); - void (*set_dir)(struct snd_ice1712 *ice, unsigned int data); - void (*set_data)(struct snd_ice1712 *ice, unsigned int data); - unsigned int (*get_data)(struct snd_ice1712 *ice); + void (*set_mask)(ice1712_t *ice, unsigned int data); + void (*set_dir)(ice1712_t *ice, unsigned int data); + void (*set_data)(ice1712_t *ice, unsigned int data); + unsigned int (*get_data)(ice1712_t *ice); /* misc operators - move to another place? */ - void (*set_pro_rate)(struct snd_ice1712 *ice, unsigned int rate); - void (*i2s_mclk_changed)(struct snd_ice1712 *ice); + void (*set_pro_rate)(ice1712_t *ice, unsigned int rate); + void (*i2s_mclk_changed)(ice1712_t *ice); } gpio; struct semaphore gpio_mutex; /* other board-specific data */ union { /* additional i2c devices for EWS boards */ - struct snd_i2c_device *i2cdevs[3]; + snd_i2c_device_t *i2cdevs[3]; /* AC97 register cache for Aureon */ struct aureon_spec { unsigned short stac9744[64]; @@ -385,7 +385,7 @@ struct snd_ice1712 { unsigned short boxconfig[4]; } hoontech; struct { - struct ak4114 *ak4114; + ak4114_t *ak4114; unsigned int analog: 1; } juli; } spec; @@ -396,22 +396,22 @@ struct snd_ice1712 { /* * gpio access functions */ -static inline void snd_ice1712_gpio_set_dir(struct snd_ice1712 *ice, unsigned int bits) +static inline void snd_ice1712_gpio_set_dir(ice1712_t *ice, unsigned int bits) { ice->gpio.set_dir(ice, bits); } -static inline void snd_ice1712_gpio_set_mask(struct snd_ice1712 *ice, unsigned int bits) +static inline void snd_ice1712_gpio_set_mask(ice1712_t *ice, unsigned int bits) { ice->gpio.set_mask(ice, bits); } -static inline void snd_ice1712_gpio_write(struct snd_ice1712 *ice, unsigned int val) +static inline void snd_ice1712_gpio_write(ice1712_t *ice, unsigned int val) { ice->gpio.set_data(ice, val); } -static inline unsigned int snd_ice1712_gpio_read(struct snd_ice1712 *ice) +static inline unsigned int snd_ice1712_gpio_read(ice1712_t *ice) { return ice->gpio.get_data(ice); } @@ -421,14 +421,14 @@ static inline unsigned int snd_ice1712_gpio_read(struct snd_ice1712 *ice) * The access to gpio will be protected by mutex, so don't forget to * restore! */ -static inline void snd_ice1712_save_gpio_status(struct snd_ice1712 *ice) +static inline void snd_ice1712_save_gpio_status(ice1712_t *ice) { down(&ice->gpio_mutex); ice->gpio.saved[0] = ice->gpio.direction; ice->gpio.saved[1] = ice->gpio.write_mask; } -static inline void snd_ice1712_restore_gpio_status(struct snd_ice1712 *ice) +static inline void snd_ice1712_restore_gpio_status(ice1712_t *ice) { ice->gpio.set_dir(ice, ice->gpio.saved[0]); ice->gpio.set_mask(ice, ice->gpio.saved[1]); @@ -443,15 +443,14 @@ static inline void snd_ice1712_restore_gpio_status(struct snd_ice1712 *ice) .get = snd_ice1712_gpio_get, .put = snd_ice1712_gpio_put, \ .private_value = mask | (invert << 24) } -int snd_ice1712_gpio_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_ice1712_gpio_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); -int snd_ice1712_gpio_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol); +int snd_ice1712_gpio_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo); +int snd_ice1712_gpio_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); +int snd_ice1712_gpio_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol); /* * set gpio direction, write mask and data */ -static inline void snd_ice1712_gpio_write_bits(struct snd_ice1712 *ice, - unsigned int mask, unsigned int bits) +static inline void snd_ice1712_gpio_write_bits(ice1712_t *ice, unsigned int mask, unsigned int bits) { ice->gpio.direction |= mask; snd_ice1712_gpio_set_dir(ice, ice->gpio.direction); @@ -459,22 +458,21 @@ static inline void snd_ice1712_gpio_write_bits(struct snd_ice1712 *ice, snd_ice1712_gpio_write(ice, mask & bits); } -int snd_ice1712_spdif_build_controls(struct snd_ice1712 *ice); +int snd_ice1712_spdif_build_controls(ice1712_t *ice); -int snd_ice1712_akm4xxx_init(struct snd_akm4xxx *ak, const struct snd_akm4xxx *template, - const struct snd_ak4xxx_private *priv, struct snd_ice1712 *ice); -void snd_ice1712_akm4xxx_free(struct snd_ice1712 *ice); -int snd_ice1712_akm4xxx_build_controls(struct snd_ice1712 *ice); +int snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *template, const struct snd_ak4xxx_private *priv, ice1712_t *ice); +void snd_ice1712_akm4xxx_free(ice1712_t *ice); +int snd_ice1712_akm4xxx_build_controls(ice1712_t *ice); -int snd_ice1712_init_cs8427(struct snd_ice1712 *ice, int addr); +int snd_ice1712_init_cs8427(ice1712_t *ice, int addr); -static inline void snd_ice1712_write(struct snd_ice1712 * ice, u8 addr, u8 data) +static inline void snd_ice1712_write(ice1712_t * ice, u8 addr, u8 data) { outb(addr, ICEREG(ice, INDEX)); outb(data, ICEREG(ice, DATA)); } -static inline u8 snd_ice1712_read(struct snd_ice1712 * ice, u8 addr) +static inline u8 snd_ice1712_read(ice1712_t * ice, u8 addr) { outb(addr, ICEREG(ice, INDEX)); return inb(ICEREG(ice, DATA)); @@ -490,8 +488,8 @@ struct snd_ice1712_card_info { char *name; char *model; char *driver; - int (*chip_init)(struct snd_ice1712 *); - int (*build_controls)(struct snd_ice1712 *); + int (*chip_init)(ice1712_t *); + int (*build_controls)(ice1712_t *); unsigned int no_mpu401: 1; unsigned int eeprom_size; unsigned char *eeprom_data; diff --git a/trunk/sound/pci/ice1712/ice1724.c b/trunk/sound/pci/ice1712/ice1724.c index 71f08c036019..0b5389ee26d5 100644 --- a/trunk/sound/pci/ice1712/ice1724.c +++ b/trunk/sound/pci/ice1712/ice1724.c @@ -102,12 +102,12 @@ static unsigned int PRO_RATE_DEFAULT = 44100; */ /* check whether the clock mode is spdif-in */ -static inline int is_spdif_master(struct snd_ice1712 *ice) +static inline int is_spdif_master(ice1712_t *ice) { return (inb(ICEMT1724(ice, RATE)) & VT1724_SPDIF_MASTER) ? 1 : 0; } -static inline int is_pro_rate_locked(struct snd_ice1712 *ice) +static inline int is_pro_rate_locked(ice1712_t *ice) { return is_spdif_master(ice) || PRO_RATE_LOCKED; } @@ -116,7 +116,7 @@ static inline int is_pro_rate_locked(struct snd_ice1712 *ice) * ac97 section */ -static unsigned char snd_vt1724_ac97_ready(struct snd_ice1712 *ice) +static unsigned char snd_vt1724_ac97_ready(ice1712_t *ice) { unsigned char old_cmd; int tm; @@ -132,7 +132,7 @@ static unsigned char snd_vt1724_ac97_ready(struct snd_ice1712 *ice) return old_cmd; } -static int snd_vt1724_ac97_wait_bit(struct snd_ice1712 *ice, unsigned char bit) +static int snd_vt1724_ac97_wait_bit(ice1712_t *ice, unsigned char bit) { int tm; for (tm = 0; tm < 0x10000; tm++) @@ -142,11 +142,11 @@ static int snd_vt1724_ac97_wait_bit(struct snd_ice1712 *ice, unsigned char bit) return -EIO; } -static void snd_vt1724_ac97_write(struct snd_ac97 *ac97, +static void snd_vt1724_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct snd_ice1712 *ice = ac97->private_data; + ice1712_t *ice = (ice1712_t *)ac97->private_data; unsigned char old_cmd; old_cmd = snd_vt1724_ac97_ready(ice); @@ -158,9 +158,9 @@ static void snd_vt1724_ac97_write(struct snd_ac97 *ac97, snd_vt1724_ac97_wait_bit(ice, VT1724_AC97_WRITE); } -static unsigned short snd_vt1724_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_vt1724_ac97_read(ac97_t *ac97, unsigned short reg) { - struct snd_ice1712 *ice = ac97->private_data; + ice1712_t *ice = (ice1712_t *)ac97->private_data; unsigned char old_cmd; old_cmd = snd_vt1724_ac97_ready(ice); @@ -179,14 +179,14 @@ static unsigned short snd_vt1724_ac97_read(struct snd_ac97 *ac97, unsigned short */ /* set gpio direction 0 = read, 1 = write */ -static void snd_vt1724_set_gpio_dir(struct snd_ice1712 *ice, unsigned int data) +static void snd_vt1724_set_gpio_dir(ice1712_t *ice, unsigned int data) { outl(data, ICEREG1724(ice, GPIO_DIRECTION)); inw(ICEREG1724(ice, GPIO_DIRECTION)); /* dummy read for pci-posting */ } /* set the gpio mask (0 = writable) */ -static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) +static void snd_vt1724_set_gpio_mask(ice1712_t *ice, unsigned int data) { outw(data, ICEREG1724(ice, GPIO_WRITE_MASK)); if (! ice->vt1720) /* VT1720 supports only 16 GPIO bits */ @@ -194,7 +194,7 @@ static void snd_vt1724_set_gpio_mask(struct snd_ice1712 *ice, unsigned int data) inw(ICEREG1724(ice, GPIO_WRITE_MASK)); /* dummy read for pci-posting */ } -static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data) +static void snd_vt1724_set_gpio_data(ice1712_t *ice, unsigned int data) { outw(data, ICEREG1724(ice, GPIO_DATA)); if (! ice->vt1720) @@ -202,7 +202,7 @@ static void snd_vt1724_set_gpio_data(struct snd_ice1712 *ice, unsigned int data) inw(ICEREG1724(ice, GPIO_DATA)); /* dummy read for pci-posting */ } -static unsigned int snd_vt1724_get_gpio_data(struct snd_ice1712 *ice) +static unsigned int snd_vt1724_get_gpio_data(ice1712_t *ice) { unsigned int data; if (! ice->vt1720) @@ -219,7 +219,7 @@ static unsigned int snd_vt1724_get_gpio_data(struct snd_ice1712 *ice) static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_ice1712 *ice = dev_id; + ice1712_t *ice = dev_id; unsigned char status; int handled = 0; @@ -229,10 +229,8 @@ static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *r break; handled = 1; - /* these should probably be separated at some point, - * but as we don't currently have MPU support on the board - * I will leave it - */ + /* these should probably be separated at some point, + but as we don't currently have MPU support on the board I will leave it */ if ((status & VT1724_IRQ_MPU_RX)||(status & VT1724_IRQ_MPU_TX)) { if (ice->rmidi[0]) snd_mpu401_uart_interrupt(irq, ice->rmidi[0]->private_data, regs); @@ -305,19 +303,19 @@ static unsigned int rates[] = { 176400, 192000, }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates_96 = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates_96 = { .count = ARRAY_SIZE(rates) - 2, /* up to 96000 */ .list = rates, .mask = 0, }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates_48 = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates_48 = { .count = ARRAY_SIZE(rates) - 5, /* up to 48000 */ .list = rates, .mask = 0, }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates_192 = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates_192 = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, @@ -330,13 +328,13 @@ struct vt1724_pcm_reg { unsigned int start; /* start & pause bit */ }; -static int snd_vt1724_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_vt1724_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); unsigned char what; unsigned char old; struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; what = 0; snd_pcm_group_for_each(pos, substream) { @@ -386,7 +384,7 @@ static int snd_vt1724_pcm_trigger(struct snd_pcm_substream *substream, int cmd) #define DMA_PAUSES (VT1724_RDMA0_PAUSE|VT1724_PDMA0_PAUSE|VT1724_RDMA1_PAUSE|\ VT1724_PDMA1_PAUSE|VT1724_PDMA2_PAUSE|VT1724_PDMA3_PAUSE|VT1724_PDMA4_PAUSE) -static int get_max_rate(struct snd_ice1712 *ice) +static int get_max_rate(ice1712_t *ice) { if (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S) { if ((ice->eeprom.data[ICE_EEP2_I2S] & 0x08) && !ice->vt1720) @@ -397,8 +395,7 @@ static int get_max_rate(struct snd_ice1712 *ice) return 48000; } -static void snd_vt1724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate, - int force) +static void snd_vt1724_set_pro_rate(ice1712_t *ice, unsigned int rate, int force) { unsigned long flags; unsigned char val, old; @@ -480,10 +477,10 @@ static void snd_vt1724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate, ice->spdif.ops.setup_rate(ice, rate); } -static int snd_vt1724_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_vt1724_pcm_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); int i, chs; chs = params_channels(hw_params); @@ -493,8 +490,7 @@ static int snd_vt1724_pcm_hw_params(struct snd_pcm_substream *substream, /* PDMA0 can be multi-channel up to 8 */ chs = chs / 2 - 1; for (i = 0; i < chs; i++) { - if (ice->pcm_reserved[i] && - ice->pcm_reserved[i] != substream) { + if (ice->pcm_reserved[i] && ice->pcm_reserved[i] != substream) { up(&ice->open_mutex); return -EBUSY; } @@ -508,8 +504,7 @@ static int snd_vt1724_pcm_hw_params(struct snd_pcm_substream *substream, for (i = 0; i < 3; i++) { /* check individual playback stream */ if (ice->playback_con_substream_ds[i] == substream) { - if (ice->pcm_reserved[i] && - ice->pcm_reserved[i] != substream) { + if (ice->pcm_reserved[i] && ice->pcm_reserved[i] != substream) { up(&ice->open_mutex); return -EBUSY; } @@ -523,9 +518,9 @@ static int snd_vt1724_pcm_hw_params(struct snd_pcm_substream *substream, return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_vt1724_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_vt1724_pcm_hw_free(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); int i; down(&ice->open_mutex); @@ -537,9 +532,9 @@ static int snd_vt1724_pcm_hw_free(struct snd_pcm_substream *substream) return snd_pcm_lib_free_pages(substream); } -static int snd_vt1724_playback_pro_prepare(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_pro_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); unsigned char val; unsigned int size; @@ -564,9 +559,9 @@ static int snd_vt1724_playback_pro_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); size_t ptr; if (!(inl(ICEMT1724(ice, DMA_CONTROL)) & VT1724_PDMA0_START)) @@ -580,8 +575,7 @@ static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(struct snd_pcm_substrea ptr -= substream->runtime->dma_addr; ptr = bytes_to_frames(substream->runtime, ptr); if (ptr >= substream->runtime->buffer_size) { - snd_printd("ice1724: invalid ptr %d (size=%d)\n", - (int)ptr, (int)substream->runtime->period_size); + snd_printd("ice1724: invalid ptr %d (size=%d)\n", (int)ptr, (int)substream->runtime->period_size); return 0; } #else /* read PLAYBACK_SIZE */ @@ -593,32 +587,29 @@ static snd_pcm_uframes_t snd_vt1724_playback_pro_pointer(struct snd_pcm_substrea else if (ptr <= substream->runtime->buffer_size) ptr = substream->runtime->buffer_size - ptr; else { - snd_printd("ice1724: invalid ptr %d (size=%d)\n", - (int)ptr, (int)substream->runtime->buffer_size); + snd_printd("ice1724: invalid ptr %d (size=%d)\n", (int)ptr, (int)substream->runtime->buffer_size); ptr = 0; } #endif return ptr; } -static int snd_vt1724_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_vt1724_pcm_prepare(snd_pcm_substream_t *substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); struct vt1724_pcm_reg *reg = substream->runtime->private_data; spin_lock_irq(&ice->reg_lock); outl(substream->runtime->dma_addr, ice->profi_port + reg->addr); - outw((snd_pcm_lib_buffer_bytes(substream) >> 2) - 1, - ice->profi_port + reg->size); - outw((snd_pcm_lib_period_bytes(substream) >> 2) - 1, - ice->profi_port + reg->count); + outw((snd_pcm_lib_buffer_bytes(substream) >> 2) - 1, ice->profi_port + reg->size); + outw((snd_pcm_lib_period_bytes(substream) >> 2) - 1, ice->profi_port + reg->count); spin_unlock_irq(&ice->reg_lock); return 0; } -static snd_pcm_uframes_t snd_vt1724_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_vt1724_pcm_pointer(snd_pcm_substream_t *substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); struct vt1724_pcm_reg *reg = substream->runtime->private_data; size_t ptr; @@ -637,8 +628,7 @@ static snd_pcm_uframes_t snd_vt1724_pcm_pointer(struct snd_pcm_substream *substr else if (ptr <= substream->runtime->buffer_size) ptr = substream->runtime->buffer_size - ptr; else { - snd_printd("ice1724: invalid ptr %d (size=%d)\n", - (int)ptr, (int)substream->runtime->buffer_size); + snd_printd("ice1724: invalid ptr %d (size=%d)\n", (int)ptr, (int)substream->runtime->buffer_size); ptr = 0; } return ptr; @@ -659,7 +649,7 @@ static struct vt1724_pcm_reg vt1724_capture_pro_reg = { .start = VT1724_RDMA0_START, }; -static struct snd_pcm_hardware snd_vt1724_playback_pro = +static snd_pcm_hardware_t snd_vt1724_playback_pro = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -678,7 +668,7 @@ static struct snd_pcm_hardware snd_vt1724_playback_pro = .periods_max = 1024, }; -static struct snd_pcm_hardware snd_vt1724_spdif = +static snd_pcm_hardware_t snd_vt1724_spdif = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -700,7 +690,7 @@ static struct snd_pcm_hardware snd_vt1724_spdif = .periods_max = 1024, }; -static struct snd_pcm_hardware snd_vt1724_2ch_stereo = +static snd_pcm_hardware_t snd_vt1724_2ch_stereo = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -722,41 +712,31 @@ static struct snd_pcm_hardware snd_vt1724_2ch_stereo = /* * set rate constraints */ -static int set_rate_constraints(struct snd_ice1712 *ice, - struct snd_pcm_substream *substream) +static int set_rate_constraints(ice1712_t *ice, snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (ice->hw_rates) { /* hardware specific */ runtime->hw.rate_min = ice->hw_rates->list[0]; runtime->hw.rate_max = ice->hw_rates->list[ice->hw_rates->count - 1]; runtime->hw.rates = SNDRV_PCM_RATE_KNOT; - return snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_RATE, - ice->hw_rates); + return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, ice->hw_rates); } if (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S) { /* I2S */ /* VT1720 doesn't support more than 96kHz */ if ((ice->eeprom.data[ICE_EEP2_I2S] & 0x08) && !ice->vt1720) - return snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates_192); + return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates_192); else { - runtime->hw.rates = SNDRV_PCM_RATE_KNOT | - SNDRV_PCM_RATE_8000_96000; + runtime->hw.rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_96000; runtime->hw.rate_max = 96000; - return snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates_96); + return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates_96); } } else if (ice->ac97) { /* ACLINK */ runtime->hw.rate_max = 48000; runtime->hw.rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000; - return snd_pcm_hw_constraint_list(runtime, 0, - SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates_48); + return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates_48); } return 0; } @@ -766,10 +746,10 @@ static int set_rate_constraints(struct snd_ice1712 *ice, */ #define VT1724_BUFFER_ALIGN 0x20 -static int snd_vt1724_playback_pro_open(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_pro_open(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); int chs; runtime->private_data = &vt1724_playback_pro_reg; @@ -796,10 +776,10 @@ static int snd_vt1724_playback_pro_open(struct snd_pcm_substream *substream) return 0; } -static int snd_vt1724_capture_pro_open(struct snd_pcm_substream *substream) +static int snd_vt1724_capture_pro_open(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; runtime->private_data = &vt1724_capture_pro_reg; ice->capture_pro_substream = substream; @@ -814,9 +794,9 @@ static int snd_vt1724_capture_pro_open(struct snd_pcm_substream *substream) return 0; } -static int snd_vt1724_playback_pro_close(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_pro_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (PRO_RATE_RESET) snd_vt1724_set_pro_rate(ice, PRO_RATE_DEFAULT, 0); @@ -825,9 +805,9 @@ static int snd_vt1724_playback_pro_close(struct snd_pcm_substream *substream) return 0; } -static int snd_vt1724_capture_pro_close(struct snd_pcm_substream *substream) +static int snd_vt1724_capture_pro_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (PRO_RATE_RESET) snd_vt1724_set_pro_rate(ice, PRO_RATE_DEFAULT, 0); @@ -835,7 +815,7 @@ static int snd_vt1724_capture_pro_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_vt1724_playback_pro_ops = { +static snd_pcm_ops_t snd_vt1724_playback_pro_ops = { .open = snd_vt1724_playback_pro_open, .close = snd_vt1724_playback_pro_close, .ioctl = snd_pcm_lib_ioctl, @@ -846,7 +826,7 @@ static struct snd_pcm_ops snd_vt1724_playback_pro_ops = { .pointer = snd_vt1724_playback_pro_pointer, }; -static struct snd_pcm_ops snd_vt1724_capture_pro_ops = { +static snd_pcm_ops_t snd_vt1724_capture_pro_ops = { .open = snd_vt1724_capture_pro_open, .close = snd_vt1724_capture_pro_close, .ioctl = snd_pcm_lib_ioctl, @@ -857,9 +837,9 @@ static struct snd_pcm_ops snd_vt1724_capture_pro_ops = { .pointer = snd_vt1724_pcm_pointer, }; -static int __devinit snd_vt1724_pcm_profi(struct snd_ice1712 * ice, int device) +static int __devinit snd_vt1724_pcm_profi(ice1712_t * ice, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; err = snd_pcm_new(ice->card, "ICE1724", device, 1, 1, &pcm); @@ -874,8 +854,7 @@ static int __devinit snd_vt1724_pcm_profi(struct snd_ice1712 * ice, int device) strcpy(pcm->name, "ICE1724"); snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(ice->pci), - 256*1024, 256*1024); + snd_dma_pci_data(ice->pci), 256*1024, 256*1024); ice->pcm_pro = pcm; @@ -902,7 +881,7 @@ static struct vt1724_pcm_reg vt1724_capture_spdif_reg = { }; /* update spdif control bits; call with reg_lock */ -static void update_spdif_bits(struct snd_ice1712 *ice, unsigned int val) +static void update_spdif_bits(ice1712_t *ice, unsigned int val) { unsigned char cbit, disabled; @@ -917,7 +896,7 @@ static void update_spdif_bits(struct snd_ice1712 *ice, unsigned int val) } /* update SPDIF control bits according to the given rate */ -static void update_spdif_rate(struct snd_ice1712 *ice, unsigned int rate) +static void update_spdif_rate(ice1712_t *ice, unsigned int rate) { unsigned int val, nval; unsigned long flags; @@ -939,18 +918,18 @@ static void update_spdif_rate(struct snd_ice1712 *ice, unsigned int rate) spin_unlock_irqrestore(&ice->reg_lock, flags); } -static int snd_vt1724_playback_spdif_prepare(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_spdif_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (! ice->force_pdma4) update_spdif_rate(ice, substream->runtime->rate); return snd_vt1724_pcm_prepare(substream); } -static int snd_vt1724_playback_spdif_open(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_spdif_open(snd_pcm_substream_t *substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; runtime->private_data = &vt1724_playback_spdif_reg; ice->playback_con_substream = substream; @@ -968,9 +947,9 @@ static int snd_vt1724_playback_spdif_open(struct snd_pcm_substream *substream) return 0; } -static int snd_vt1724_playback_spdif_close(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_spdif_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (PRO_RATE_RESET) snd_vt1724_set_pro_rate(ice, PRO_RATE_DEFAULT, 0); @@ -979,10 +958,10 @@ static int snd_vt1724_playback_spdif_close(struct snd_pcm_substream *substream) return 0; } -static int snd_vt1724_capture_spdif_open(struct snd_pcm_substream *substream) +static int snd_vt1724_capture_spdif_open(snd_pcm_substream_t *substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; runtime->private_data = &vt1724_capture_spdif_reg; ice->capture_con_substream = substream; @@ -1000,9 +979,9 @@ static int snd_vt1724_capture_spdif_open(struct snd_pcm_substream *substream) return 0; } -static int snd_vt1724_capture_spdif_close(struct snd_pcm_substream *substream) +static int snd_vt1724_capture_spdif_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (PRO_RATE_RESET) snd_vt1724_set_pro_rate(ice, PRO_RATE_DEFAULT, 0); @@ -1011,7 +990,7 @@ static int snd_vt1724_capture_spdif_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_vt1724_playback_spdif_ops = { +static snd_pcm_ops_t snd_vt1724_playback_spdif_ops = { .open = snd_vt1724_playback_spdif_open, .close = snd_vt1724_playback_spdif_close, .ioctl = snd_pcm_lib_ioctl, @@ -1022,7 +1001,7 @@ static struct snd_pcm_ops snd_vt1724_playback_spdif_ops = { .pointer = snd_vt1724_pcm_pointer, }; -static struct snd_pcm_ops snd_vt1724_capture_spdif_ops = { +static snd_pcm_ops_t snd_vt1724_capture_spdif_ops = { .open = snd_vt1724_capture_spdif_open, .close = snd_vt1724_capture_spdif_close, .ioctl = snd_pcm_lib_ioctl, @@ -1034,10 +1013,10 @@ static struct snd_pcm_ops snd_vt1724_capture_spdif_ops = { }; -static int __devinit snd_vt1724_pcm_spdif(struct snd_ice1712 * ice, int device) +static int __devinit snd_vt1724_pcm_spdif(ice1712_t * ice, int device) { char *name; - struct snd_pcm *pcm; + snd_pcm_t *pcm; int play, capt; int err; @@ -1076,8 +1055,7 @@ static int __devinit snd_vt1724_pcm_spdif(struct snd_ice1712 * ice, int device) strcpy(pcm->name, name); snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(ice->pci), - 64*1024, 64*1024); + snd_dma_pci_data(ice->pci), 64*1024, 64*1024); ice->pcm = pcm; @@ -1110,9 +1088,9 @@ static struct vt1724_pcm_reg vt1724_playback_dma_regs[3] = { }, }; -static int snd_vt1724_playback_indep_prepare(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_indep_prepare(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); unsigned char val; spin_lock_irq(&ice->reg_lock); @@ -1123,10 +1101,10 @@ static int snd_vt1724_playback_indep_prepare(struct snd_pcm_substream *substream return snd_vt1724_pcm_prepare(substream); } -static int snd_vt1724_playback_indep_open(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_indep_open(snd_pcm_substream_t *substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + ice1712_t *ice = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; down(&ice->open_mutex); /* already used by PDMA0? */ @@ -1144,9 +1122,9 @@ static int snd_vt1724_playback_indep_open(struct snd_pcm_substream *substream) return 0; } -static int snd_vt1724_playback_indep_close(struct snd_pcm_substream *substream) +static int snd_vt1724_playback_indep_close(snd_pcm_substream_t * substream) { - struct snd_ice1712 *ice = snd_pcm_substream_chip(substream); + ice1712_t *ice = snd_pcm_substream_chip(substream); if (PRO_RATE_RESET) snd_vt1724_set_pro_rate(ice, PRO_RATE_DEFAULT, 0); @@ -1156,7 +1134,7 @@ static int snd_vt1724_playback_indep_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_vt1724_playback_indep_ops = { +static snd_pcm_ops_t snd_vt1724_playback_indep_ops = { .open = snd_vt1724_playback_indep_open, .close = snd_vt1724_playback_indep_close, .ioctl = snd_pcm_lib_ioctl, @@ -1168,9 +1146,9 @@ static struct snd_pcm_ops snd_vt1724_playback_indep_ops = { }; -static int __devinit snd_vt1724_pcm_indep(struct snd_ice1712 * ice, int device) +static int __devinit snd_vt1724_pcm_indep(ice1712_t * ice, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int play; int err; @@ -1190,8 +1168,7 @@ static int __devinit snd_vt1724_pcm_indep(struct snd_ice1712 * ice, int device) strcpy(pcm->name, "ICE1724 Surround PCM"); snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(ice->pci), - 64*1024, 64*1024); + snd_dma_pci_data(ice->pci), 64*1024, 64*1024); ice->pcm_ds = pcm; @@ -1203,14 +1180,14 @@ static int __devinit snd_vt1724_pcm_indep(struct snd_ice1712 * ice, int device) * Mixer section */ -static int __devinit snd_vt1724_ac97_mixer(struct snd_ice1712 * ice) +static int __devinit snd_vt1724_ac97_mixer(ice1712_t * ice) { int err; if (! (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S)) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; - static struct snd_ac97_bus_ops ops = { + ac97_bus_t *pbus; + ac97_template_t ac97; + static ac97_bus_ops_t ops = { .write = snd_vt1724_ac97_write, .read = snd_vt1724_ac97_read, }; @@ -1238,17 +1215,17 @@ static int __devinit snd_vt1724_ac97_mixer(struct snd_ice1712 * ice) * */ -static inline unsigned int eeprom_triple(struct snd_ice1712 *ice, int idx) +static inline unsigned int eeprom_triple(ice1712_t *ice, int idx) { return (unsigned int)ice->eeprom.data[idx] | \ ((unsigned int)ice->eeprom.data[idx + 1] << 8) | \ ((unsigned int)ice->eeprom.data[idx + 2] << 16); } -static void snd_vt1724_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_vt1724_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ice1712 *ice = entry->private_data; + ice1712_t *ice = entry->private_data; unsigned int idx; snd_iprintf(buffer, "%s\n\n", ice->card->longname); @@ -1257,39 +1234,28 @@ static void snd_vt1724_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, " Subvendor : 0x%x\n", ice->eeprom.subvendor); snd_iprintf(buffer, " Size : %i bytes\n", ice->eeprom.size); snd_iprintf(buffer, " Version : %i\n", ice->eeprom.version); - snd_iprintf(buffer, " System Config : 0x%x\n", - ice->eeprom.data[ICE_EEP2_SYSCONF]); - snd_iprintf(buffer, " ACLink : 0x%x\n", - ice->eeprom.data[ICE_EEP2_ACLINK]); - snd_iprintf(buffer, " I2S : 0x%x\n", - ice->eeprom.data[ICE_EEP2_I2S]); - snd_iprintf(buffer, " S/PDIF : 0x%x\n", - ice->eeprom.data[ICE_EEP2_SPDIF]); - snd_iprintf(buffer, " GPIO direction : 0x%x\n", - ice->eeprom.gpiodir); - snd_iprintf(buffer, " GPIO mask : 0x%x\n", - ice->eeprom.gpiomask); - snd_iprintf(buffer, " GPIO state : 0x%x\n", - ice->eeprom.gpiostate); + snd_iprintf(buffer, " System Config : 0x%x\n", ice->eeprom.data[ICE_EEP2_SYSCONF]); + snd_iprintf(buffer, " ACLink : 0x%x\n", ice->eeprom.data[ICE_EEP2_ACLINK]); + snd_iprintf(buffer, " I2S : 0x%x\n", ice->eeprom.data[ICE_EEP2_I2S]); + snd_iprintf(buffer, " S/PDIF : 0x%x\n", ice->eeprom.data[ICE_EEP2_SPDIF]); + snd_iprintf(buffer, " GPIO direction : 0x%x\n", ice->eeprom.gpiodir); + snd_iprintf(buffer, " GPIO mask : 0x%x\n", ice->eeprom.gpiomask); + snd_iprintf(buffer, " GPIO state : 0x%x\n", ice->eeprom.gpiostate); for (idx = 0x12; idx < ice->eeprom.size; idx++) - snd_iprintf(buffer, " Extra #%02i : 0x%x\n", - idx, ice->eeprom.data[idx]); + snd_iprintf(buffer, " Extra #%02i : 0x%x\n", idx, ice->eeprom.data[idx]); snd_iprintf(buffer, "\nRegisters:\n"); - snd_iprintf(buffer, " PSDOUT03 : 0x%08x\n", - (unsigned)inl(ICEMT1724(ice, ROUTE_PLAYBACK))); + snd_iprintf(buffer, " PSDOUT03 : 0x%08x\n", (unsigned)inl(ICEMT1724(ice, ROUTE_PLAYBACK))); for (idx = 0x0; idx < 0x20 ; idx++) - snd_iprintf(buffer, " CCS%02x : 0x%02x\n", - idx, inb(ice->port+idx)); + snd_iprintf(buffer, " CCS%02x : 0x%02x\n", idx, inb(ice->port+idx)); for (idx = 0x0; idx < 0x30 ; idx++) - snd_iprintf(buffer, " MT%02x : 0x%02x\n", - idx, inb(ice->profi_port+idx)); + snd_iprintf(buffer, " MT%02x : 0x%02x\n", idx, inb(ice->profi_port+idx)); } -static void __devinit snd_vt1724_proc_init(struct snd_ice1712 * ice) +static void __devinit snd_vt1724_proc_init(ice1712_t * ice) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(ice->card, "ice1724", &entry)) snd_info_set_text_ops(entry, ice, 1024, snd_vt1724_proc_read); @@ -1299,24 +1265,22 @@ static void __devinit snd_vt1724_proc_init(struct snd_ice1712 * ice) * */ -static int snd_vt1724_eeprom_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_eeprom_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; - uinfo->count = sizeof(struct snd_ice1712_eeprom); + uinfo->count = sizeof(ice1712_eeprom_t); return 0; } -static int snd_vt1724_eeprom_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_eeprom_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); memcpy(ucontrol->value.bytes.data, &ice->eeprom, sizeof(ice->eeprom)); return 0; } -static struct snd_kcontrol_new snd_vt1724_eeprom __devinitdata = { +static snd_kcontrol_new_t snd_vt1724_eeprom __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = "ICE1724 EEPROM", .access = SNDRV_CTL_ELEM_ACCESS_READ, @@ -1326,23 +1290,21 @@ static struct snd_kcontrol_new snd_vt1724_eeprom __devinitdata = { /* */ -static int snd_vt1724_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static unsigned int encode_spdif_bits(struct snd_aes_iec958 *diga) +static unsigned int encode_spdif_bits(snd_aes_iec958_t *diga) { unsigned int val, rbits; val = diga->status[0] & 0x03; /* professional, non-audio */ if (val & 0x01) { /* professional */ - if ((diga->status[0] & IEC958_AES0_PRO_EMPHASIS) == - IEC958_AES0_PRO_EMPHASIS_5015) + if ((diga->status[0] & IEC958_AES0_PRO_EMPHASIS) == IEC958_AES0_PRO_EMPHASIS_5015) val |= 1U << 3; rbits = (diga->status[4] >> 3) & 0x0f; if (rbits) { @@ -1367,8 +1329,7 @@ static unsigned int encode_spdif_bits(struct snd_aes_iec958 *diga) } else { /* consumer */ val |= diga->status[1] & 0x04; /* copyright */ - if ((diga->status[0] & IEC958_AES0_CON_EMPHASIS) == - IEC958_AES0_CON_EMPHASIS_5015) + if ((diga->status[0] & IEC958_AES0_CON_EMPHASIS)== IEC958_AES0_CON_EMPHASIS_5015) val |= 1U << 3; val |= (unsigned int)(diga->status[1] & 0x3f) << 4; /* category */ val |= (unsigned int)(diga->status[3] & IEC958_AES3_CON_FS) << 12; /* fs */ @@ -1376,7 +1337,7 @@ static unsigned int encode_spdif_bits(struct snd_aes_iec958 *diga) return val; } -static void decode_spdif_bits(struct snd_aes_iec958 *diga, unsigned int val) +static void decode_spdif_bits(snd_aes_iec958_t *diga, unsigned int val) { memset(diga->status, 0, sizeof(diga->status)); diga->status[0] = val & 0x03; /* professional, non-audio */ @@ -1404,20 +1365,20 @@ static void decode_spdif_bits(struct snd_aes_iec958 *diga, unsigned int val) } } -static int snd_vt1724_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_spdif_default_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned int val; val = inw(ICEMT1724(ice, SPDIF_CTRL)); decode_spdif_bits(&ucontrol->value.iec958, val); return 0; } -static int snd_vt1724_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_spdif_default_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned int val, old; val = encode_spdif_bits(&ucontrol->value.iec958); @@ -1429,7 +1390,7 @@ static int snd_vt1724_spdif_default_put(struct snd_kcontrol *kcontrol, return (val != old); } -static struct snd_kcontrol_new snd_vt1724_spdif_default __devinitdata = +static snd_kcontrol_new_t snd_vt1724_spdif_default __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -1438,8 +1399,8 @@ static struct snd_kcontrol_new snd_vt1724_spdif_default __devinitdata = .put = snd_vt1724_spdif_default_put }; -static int snd_vt1724_spdif_maskc_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_spdif_maskc_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = IEC958_AES0_NONAUDIO | IEC958_AES0_PROFESSIONAL | @@ -1451,8 +1412,8 @@ static int snd_vt1724_spdif_maskc_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_vt1724_spdif_maskp_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_spdif_maskp_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = IEC958_AES0_NONAUDIO | IEC958_AES0_PROFESSIONAL | @@ -1461,7 +1422,7 @@ static int snd_vt1724_spdif_maskp_get(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_vt1724_spdif_maskc __devinitdata = +static snd_kcontrol_new_t snd_vt1724_spdif_maskc __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1470,7 +1431,7 @@ static struct snd_kcontrol_new snd_vt1724_spdif_maskc __devinitdata = .get = snd_vt1724_spdif_maskc_get, }; -static struct snd_kcontrol_new snd_vt1724_spdif_maskp __devinitdata = +static snd_kcontrol_new_t snd_vt1724_spdif_maskp __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1479,8 +1440,7 @@ static struct snd_kcontrol_new snd_vt1724_spdif_maskp __devinitdata = .get = snd_vt1724_spdif_maskp_get, }; -static int snd_vt1724_spdif_sw_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_spdif_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1489,19 +1449,16 @@ static int snd_vt1724_spdif_sw_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_vt1724_spdif_sw_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_spdif_sw_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); - ucontrol->value.integer.value[0] = inb(ICEREG1724(ice, SPDIF_CFG)) & - VT1724_CFG_SPDIF_OUT_EN ? 1 : 0; + ice1712_t *ice = snd_kcontrol_chip(kcontrol); + ucontrol->value.integer.value[0] = inb(ICEREG1724(ice, SPDIF_CFG)) & VT1724_CFG_SPDIF_OUT_EN ? 1 : 0; return 0; } -static int snd_vt1724_spdif_sw_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_spdif_sw_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char old, val; spin_lock_irq(&ice->reg_lock); @@ -1515,7 +1472,7 @@ static int snd_vt1724_spdif_sw_put(struct snd_kcontrol *kcontrol, return old != val; } -static struct snd_kcontrol_new snd_vt1724_spdif_switch __devinitdata = +static snd_kcontrol_new_t snd_vt1724_spdif_switch __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, /* FIXME: the following conflict with IEC958 Playback Route */ @@ -1532,8 +1489,7 @@ static struct snd_kcontrol_new snd_vt1724_spdif_switch __devinitdata = * GPIO access from extern */ -int snd_vt1724_gpio_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +int snd_vt1724_gpio_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1542,24 +1498,21 @@ int snd_vt1724_gpio_info(struct snd_kcontrol *kcontrol, return 0; } -int snd_vt1724_gpio_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_vt1724_gpio_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0; snd_ice1712_save_gpio_status(ice); - ucontrol->value.integer.value[0] = - (snd_ice1712_gpio_read(ice) & (1 << shift) ? 1 : 0) ^ invert; + ucontrol->value.integer.value[0] = (snd_ice1712_gpio_read(ice) & (1 << shift) ? 1 : 0) ^ invert; snd_ice1712_restore_gpio_status(ice); return 0; } -int snd_ice1712_gpio_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_ice1712_gpio_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int shift = kcontrol->private_value & 0xff; int invert = (kcontrol->private_value & (1<<24)) ? mask : 0; unsigned int val, nval; @@ -1580,8 +1533,7 @@ int snd_ice1712_gpio_put(struct snd_kcontrol *kcontrol, /* * rate */ -static int snd_vt1724_pro_internal_clock_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_pro_internal_clock_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts_1724[] = { "8000", /* 0: 6 */ @@ -1617,7 +1569,7 @@ static int snd_vt1724_pro_internal_clock_info(struct snd_kcontrol *kcontrol, "96000", /* 12: 7 */ "IEC958 Input", /* 13: -- */ }; - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -1630,10 +1582,9 @@ static int snd_vt1724_pro_internal_clock_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_internal_clock_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); static unsigned char xlate[16] = { 9, 6, 3, 1, 7, 4, 0, 12, 8, 5, 2, 11, 13, 255, 14, 10 }; @@ -1654,10 +1605,9 @@ static int snd_vt1724_pro_internal_clock_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_internal_clock_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char oval; int rate; int change = 0; @@ -1679,8 +1629,7 @@ static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol, change = inb(ICEMT1724(ice, RATE)) != oval; spin_unlock_irq(&ice->reg_lock); - if ((oval & VT1724_SPDIF_MASTER) != - (inb(ICEMT1724(ice, RATE)) & VT1724_SPDIF_MASTER)) { + if ((oval & VT1724_SPDIF_MASTER) != (inb(ICEMT1724(ice, RATE)) & VT1724_SPDIF_MASTER)) { /* notify akm chips as well */ if (is_spdif_master(ice)) { unsigned int i; @@ -1693,7 +1642,7 @@ static int snd_vt1724_pro_internal_clock_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_vt1724_pro_internal_clock __devinitdata = { +static snd_kcontrol_new_t snd_vt1724_pro_internal_clock __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Internal Clock", .info = snd_vt1724_pro_internal_clock_info, @@ -1701,8 +1650,7 @@ static struct snd_kcontrol_new snd_vt1724_pro_internal_clock __devinitdata = { .put = snd_vt1724_pro_internal_clock_put }; -static int snd_vt1724_pro_rate_locking_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_pro_rate_locking_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1711,17 +1659,15 @@ static int snd_vt1724_pro_rate_locking_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_vt1724_pro_rate_locking_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_rate_locking_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.integer.value[0] = PRO_RATE_LOCKED; return 0; } -static int snd_vt1724_pro_rate_locking_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_rate_locking_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, nval; nval = ucontrol->value.integer.value[0] ? 1 : 0; @@ -1732,7 +1678,7 @@ static int snd_vt1724_pro_rate_locking_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_vt1724_pro_rate_locking __devinitdata = { +static snd_kcontrol_new_t snd_vt1724_pro_rate_locking __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Rate Locking", .info = snd_vt1724_pro_rate_locking_info, @@ -1740,8 +1686,7 @@ static struct snd_kcontrol_new snd_vt1724_pro_rate_locking __devinitdata = { .put = snd_vt1724_pro_rate_locking_put }; -static int snd_vt1724_pro_rate_reset_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_pro_rate_reset_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1750,17 +1695,15 @@ static int snd_vt1724_pro_rate_reset_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_vt1724_pro_rate_reset_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_rate_reset_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.integer.value[0] = PRO_RATE_RESET ? 1 : 0; return 0; } -static int snd_vt1724_pro_rate_reset_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_rate_reset_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, nval; nval = ucontrol->value.integer.value[0] ? 1 : 0; @@ -1771,7 +1714,7 @@ static int snd_vt1724_pro_rate_reset_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_vt1724_pro_rate_reset __devinitdata = { +static snd_kcontrol_new_t snd_vt1724_pro_rate_reset __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Rate Reset", .info = snd_vt1724_pro_rate_reset_info, @@ -1783,8 +1726,7 @@ static struct snd_kcontrol_new snd_vt1724_pro_rate_reset __devinitdata = { /* * routing */ -static int snd_vt1724_pro_route_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_pro_route_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "PCM Out", /* 0 */ @@ -1811,7 +1753,7 @@ static inline int digital_route_shift(int idx) return idx * 3; } -static int get_route_val(struct snd_ice1712 *ice, int shift) +static int get_route_val(ice1712_t *ice, int shift) { unsigned long val; unsigned char eitem; @@ -1830,7 +1772,7 @@ static int get_route_val(struct snd_ice1712 *ice, int shift) return eitem; } -static int put_route_val(struct snd_ice1712 *ice, unsigned int val, int shift) +static int put_route_val(ice1712_t *ice, unsigned int val, int shift) { unsigned int old_val, nval; int change; @@ -1852,45 +1794,39 @@ static int put_route_val(struct snd_ice1712 *ice, unsigned int val, int shift) return change; } -static int snd_vt1724_pro_route_analog_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_route_analog_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); - ucontrol->value.enumerated.item[0] = - get_route_val(ice, analog_route_shift(idx)); + ucontrol->value.enumerated.item[0] = get_route_val(ice, analog_route_shift(idx)); return 0; } -static int snd_vt1724_pro_route_analog_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_route_analog_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); return put_route_val(ice, ucontrol->value.enumerated.item[0], analog_route_shift(idx)); } -static int snd_vt1724_pro_route_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_route_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); - ucontrol->value.enumerated.item[0] = - get_route_val(ice, digital_route_shift(idx)); + ucontrol->value.enumerated.item[0] = get_route_val(ice, digital_route_shift(idx)); return 0; } -static int snd_vt1724_pro_route_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_route_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); return put_route_val(ice, ucontrol->value.enumerated.item[0], digital_route_shift(idx)); } -static struct snd_kcontrol_new snd_vt1724_mixer_pro_analog_route __devinitdata = { +static snd_kcontrol_new_t snd_vt1724_mixer_pro_analog_route __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "H/W Playback Route", .info = snd_vt1724_pro_route_info, @@ -1898,7 +1834,7 @@ static struct snd_kcontrol_new snd_vt1724_mixer_pro_analog_route __devinitdata = .put = snd_vt1724_pro_route_analog_put, }; -static struct snd_kcontrol_new snd_vt1724_mixer_pro_spdif_route __devinitdata = { +static snd_kcontrol_new_t snd_vt1724_mixer_pro_spdif_route __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Route", .info = snd_vt1724_pro_route_info, @@ -1908,8 +1844,7 @@ static struct snd_kcontrol_new snd_vt1724_mixer_pro_spdif_route __devinitdata = }; -static int snd_vt1724_pro_peak_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_vt1724_pro_peak_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 22; /* FIXME: for compatibility with ice1712... */ @@ -1918,23 +1853,21 @@ static int snd_vt1724_pro_peak_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_vt1724_pro_peak_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_vt1724_pro_peak_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx; spin_lock_irq(&ice->reg_lock); for (idx = 0; idx < 22; idx++) { outb(idx, ICEMT1724(ice, MONITOR_PEAKINDEX)); - ucontrol->value.integer.value[idx] = - inb(ICEMT1724(ice, MONITOR_PEAKDATA)); + ucontrol->value.integer.value[idx] = inb(ICEMT1724(ice, MONITOR_PEAKDATA)); } spin_unlock_irq(&ice->reg_lock); return 0; } -static struct snd_kcontrol_new snd_vt1724_mixer_pro_peak __devinitdata = { +static snd_kcontrol_new_t snd_vt1724_mixer_pro_peak __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Multi Track Peak", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, @@ -1964,7 +1897,7 @@ static struct snd_ice1712_card_info *card_tables[] __devinitdata = { /* */ -static void wait_i2c_busy(struct snd_ice1712 *ice) +static void wait_i2c_busy(ice1712_t *ice) { int t = 0x10000; while ((inb(ICEREG1724(ice, I2C_CTRL)) & VT1724_I2C_BUSY) && t--) @@ -1973,8 +1906,7 @@ static void wait_i2c_busy(struct snd_ice1712 *ice) printk(KERN_ERR "ice1724: i2c busy timeout\n"); } -unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice, - unsigned char dev, unsigned char addr) +unsigned char snd_vt1724_read_i2c(ice1712_t *ice, unsigned char dev, unsigned char addr) { unsigned char val; @@ -1988,8 +1920,7 @@ unsigned char snd_vt1724_read_i2c(struct snd_ice1712 *ice, return val; } -void snd_vt1724_write_i2c(struct snd_ice1712 *ice, - unsigned char dev, unsigned char addr, unsigned char data) +void snd_vt1724_write_i2c(ice1712_t *ice, unsigned char dev, unsigned char addr, unsigned char data) { down(&ice->i2c_mutex); wait_i2c_busy(ice); @@ -2001,8 +1932,7 @@ void snd_vt1724_write_i2c(struct snd_ice1712 *ice, up(&ice->i2c_mutex); } -static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, - const char *modelname) +static int __devinit snd_vt1724_read_eeprom(ice1712_t *ice, const char *modelname) { const int dev = 0xa0; /* EEPROM device address */ unsigned int i, size; @@ -2016,19 +1946,13 @@ static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, (snd_vt1724_read_i2c(ice, dev, 0x01) << 8) | (snd_vt1724_read_i2c(ice, dev, 0x02) << 16) | (snd_vt1724_read_i2c(ice, dev, 0x03) << 24); - if (ice->eeprom.subvendor == 0 || - ice->eeprom.subvendor == (unsigned int)-1) { - /* invalid subvendor from EEPROM, try the PCI - * subststem ID instead - */ + if (ice->eeprom.subvendor == 0 || ice->eeprom.subvendor == (unsigned int)-1) { + /* invalid subvendor from EEPROM, try the PCI subststem ID instead */ u16 vendor, device; - pci_read_config_word(ice->pci, PCI_SUBSYSTEM_VENDOR_ID, - &vendor); + pci_read_config_word(ice->pci, PCI_SUBSYSTEM_VENDOR_ID, &vendor); pci_read_config_word(ice->pci, PCI_SUBSYSTEM_ID, &device); - ice->eeprom.subvendor = - ((unsigned int)swab16(vendor) << 16) | swab16(device); - if (ice->eeprom.subvendor == 0 || - ice->eeprom.subvendor == (unsigned int)-1) { + ice->eeprom.subvendor = ((unsigned int)swab16(vendor) << 16) | swab16(device); + if (ice->eeprom.subvendor == 0 || ice->eeprom.subvendor == (unsigned int)-1) { printk(KERN_ERR "ice1724: No valid ID is found\n"); return -ENXIO; } @@ -2036,10 +1960,8 @@ static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, } for (tbl = card_tables; *tbl; tbl++) { for (c = *tbl; c->subvendor; c++) { - if (modelname && c->model && - ! strcmp(modelname, c->model)) { - printk(KERN_INFO "ice1724: Using board model %s\n", - c->name); + if (modelname && c->model && ! strcmp(modelname, c->model)) { + printk(KERN_INFO "ice1724: Using board model %s\n", c->name); ice->eeprom.subvendor = c->subvendor; } else if (c->subvendor != ice->eeprom.subvendor) continue; @@ -2053,22 +1975,19 @@ static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, goto read_skipped; } } - printk(KERN_WARNING "ice1724: No matching model found for ID 0x%x\n", - ice->eeprom.subvendor); + printk(KERN_WARNING "ice1724: No matching model found for ID 0x%x\n", ice->eeprom.subvendor); found: ice->eeprom.size = snd_vt1724_read_i2c(ice, dev, 0x04); if (ice->eeprom.size < 6) ice->eeprom.size = 32; else if (ice->eeprom.size > 32) { - printk(KERN_ERR "ice1724: Invalid EEPROM (size = %i)\n", - ice->eeprom.size); + printk(KERN_ERR "ice1724: Invalid EEPROM (size = %i)\n", ice->eeprom.size); return -EIO; } ice->eeprom.version = snd_vt1724_read_i2c(ice, dev, 0x05); if (ice->eeprom.version != 2) - printk(KERN_WARNING "ice1724: Invalid EEPROM version %i\n", - ice->eeprom.version); + printk(KERN_WARNING "ice1724: Invalid EEPROM version %i\n", ice->eeprom.version); size = ice->eeprom.size - 6; for (i = 0; i < size; i++) ice->eeprom.data[i] = snd_vt1724_read_i2c(ice, dev, i + 6); @@ -2083,7 +2002,7 @@ static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, -static int __devinit snd_vt1724_chip_init(struct snd_ice1712 *ice) +static int __devinit snd_vt1724_chip_init(ice1712_t *ice) { outb(VT1724_RESET , ICEREG1724(ice, CONTROL)); udelay(200); @@ -2105,10 +2024,10 @@ static int __devinit snd_vt1724_chip_init(struct snd_ice1712 *ice) return 0; } -static int __devinit snd_vt1724_spdif_build_controls(struct snd_ice1712 *ice) +static int __devinit snd_vt1724_spdif_build_controls(ice1712_t *ice) { int err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; snd_assert(ice->pcm != NULL, return -EIO); @@ -2143,7 +2062,7 @@ static int __devinit snd_vt1724_spdif_build_controls(struct snd_ice1712 *ice) } -static int __devinit snd_vt1724_build_controls(struct snd_ice1712 *ice) +static int __devinit snd_vt1724_build_controls(ice1712_t *ice) { int err; @@ -2162,7 +2081,7 @@ static int __devinit snd_vt1724_build_controls(struct snd_ice1712 *ice) return err; if (ice->num_total_dacs > 0) { - struct snd_kcontrol_new tmp = snd_vt1724_mixer_pro_analog_route; + snd_kcontrol_new_t tmp = snd_vt1724_mixer_pro_analog_route; tmp.count = ice->num_total_dacs; if (ice->vt1720 && tmp.count > 2) tmp.count = 2; @@ -2178,7 +2097,7 @@ static int __devinit snd_vt1724_build_controls(struct snd_ice1712 *ice) return 0; } -static int snd_vt1724_free(struct snd_ice1712 *ice) +static int snd_vt1724_free(ice1712_t *ice) { if (! ice->port) goto __hw_end; @@ -2189,7 +2108,7 @@ static int snd_vt1724_free(struct snd_ice1712 *ice) __hw_end: if (ice->irq >= 0) { synchronize_irq(ice->irq); - free_irq(ice->irq, ice); + free_irq(ice->irq, (void *) ice); } pci_release_regions(ice->pci); snd_ice1712_akm4xxx_free(ice); @@ -2198,21 +2117,21 @@ static int snd_vt1724_free(struct snd_ice1712 *ice) return 0; } -static int snd_vt1724_dev_free(struct snd_device *device) +static int snd_vt1724_dev_free(snd_device_t *device) { - struct snd_ice1712 *ice = device->device_data; + ice1712_t *ice = device->device_data; return snd_vt1724_free(ice); } -static int __devinit snd_vt1724_create(struct snd_card *card, +static int __devinit snd_vt1724_create(snd_card_t * card, struct pci_dev *pci, const char *modelname, - struct snd_ice1712 ** r_ice1712) + ice1712_t ** r_ice1712) { - struct snd_ice1712 *ice; + ice1712_t *ice; int err; unsigned char mask; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_vt1724_dev_free, }; @@ -2251,8 +2170,7 @@ static int __devinit snd_vt1724_create(struct snd_card *card, ice->port = pci_resource_start(pci, 0); ice->profi_port = pci_resource_start(pci, 1); - if (request_irq(pci->irq, snd_vt1724_interrupt, - SA_INTERRUPT|SA_SHIRQ, "ICE1724", ice)) { + if (request_irq(pci->irq, snd_vt1724_interrupt, SA_INTERRUPT|SA_SHIRQ, "ICE1724", (void *) ice)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_vt1724_free(ice); return -EIO; @@ -2275,9 +2193,7 @@ static int __devinit snd_vt1724_create(struct snd_card *card, else mask = 0; outb(mask, ICEREG1724(ice, IRQMASK)); - /* don't handle FIFO overrun/underruns (just yet), - * since they cause machine lockups - */ + /* don't handle FIFO overrun/underruns (just yet), since they cause machine lockups */ outb(VT1724_MULTI_FIFO_ERR, ICEMT1724(ice, DMA_INT_MASK)); if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, ice, &ops)) < 0) { @@ -2302,8 +2218,8 @@ static int __devinit snd_vt1724_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_ice1712 *ice; + snd_card_t *card; + ice1712_t *ice; int pcm_dev = 0, err; struct snd_ice1712_card_info **tbl, *c; diff --git a/trunk/sound/pci/ice1712/juli.c b/trunk/sound/pci/ice1712/juli.c index 5176b41ea9d3..2437876a44e4 100644 --- a/trunk/sound/pci/ice1712/juli.c +++ b/trunk/sound/pci/ice1712/juli.c @@ -65,30 +65,30 @@ static void juli_ak4114_write(void *private_data, unsigned char reg, unsigned char val) { - snd_vt1724_write_i2c((struct snd_ice1712 *)private_data, AK4114_ADDR, reg, val); + snd_vt1724_write_i2c((ice1712_t *)private_data, AK4114_ADDR, reg, val); } static unsigned char juli_ak4114_read(void *private_data, unsigned char reg) { - return snd_vt1724_read_i2c((struct snd_ice1712 *)private_data, AK4114_ADDR, reg); + return snd_vt1724_read_i2c((ice1712_t *)private_data, AK4114_ADDR, reg); } /* * AK4358 section */ -static void juli_akm_lock(struct snd_akm4xxx *ak, int chip) +static void juli_akm_lock(akm4xxx_t *ak, int chip) { } -static void juli_akm_unlock(struct snd_akm4xxx *ak, int chip) +static void juli_akm_unlock(akm4xxx_t *ak, int chip) { } -static void juli_akm_write(struct snd_akm4xxx *ak, int chip, +static void juli_akm_write(akm4xxx_t *ak, int chip, unsigned char addr, unsigned char data) { - struct snd_ice1712 *ice = ak->private_data[0]; + ice1712_t *ice = ak->private_data[0]; snd_assert(chip == 0, return); snd_vt1724_write_i2c(ice, AK4358_ADDR, addr, data); @@ -97,7 +97,7 @@ static void juli_akm_write(struct snd_akm4xxx *ak, int chip, /* * change the rate of envy24HT, AK4358 */ -static void juli_akm_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) +static void juli_akm_set_rate_val(akm4xxx_t *ak, unsigned int rate) { unsigned char old, tmp, dfs; @@ -125,7 +125,7 @@ static void juli_akm_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) snd_akm4xxx_reset(ak, 0); } -static struct snd_akm4xxx akm_juli_dac __devinitdata = { +static akm4xxx_t akm_juli_dac __devinitdata = { .type = SND_AK4358, .num_dacs = 2, .ops = { @@ -136,7 +136,7 @@ static struct snd_akm4xxx akm_juli_dac __devinitdata = { } }; -static int __devinit juli_add_controls(struct snd_ice1712 *ice) +static int __devinit juli_add_controls(ice1712_t *ice) { return snd_ice1712_akm4xxx_build_controls(ice); } @@ -144,7 +144,7 @@ static int __devinit juli_add_controls(struct snd_ice1712 *ice) /* * initialize the chip */ -static int __devinit juli_init(struct snd_ice1712 *ice) +static int __devinit juli_init(ice1712_t *ice) { static unsigned char ak4114_init_vals[] = { /* AK4117_REG_PWRDN */ AK4114_RST | AK4114_PWN | AK4114_OCKS0 | AK4114_OCKS1, @@ -158,7 +158,7 @@ static int __devinit juli_init(struct snd_ice1712 *ice) 0x41, 0x02, 0x2c, 0x00, 0x00 }; int err; - struct snd_akm4xxx *ak; + akm4xxx_t *ak; #if 0 for (err = 0; err < 0x20; err++) @@ -175,21 +175,14 @@ static int __devinit juli_init(struct snd_ice1712 *ice) if (err < 0) return err; -#if 0 - /* it seems that the analog doughter board detection does not work - reliably, so force the analog flag; it should be very rare - to use Juli@ without the analog doughter board */ - ice->spec.juli.analog = (ice->gpio.get_data(ice) & GPIO_ANALOG_PRESENT) ? 0 : 1; -#else - ice->spec.juli.analog = 1; -#endif + ice->spec.juli.analog = ice->gpio.get_data(ice) & GPIO_ANALOG_PRESENT; if (ice->spec.juli.analog) { printk(KERN_INFO "juli@: analog I/O detected\n"); ice->num_total_dacs = 2; ice->num_total_adcs = 2; - ak = ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ak = ice->akm = kzalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (! ak) return -ENOMEM; ice->akm_codecs = 1; diff --git a/trunk/sound/pci/ice1712/phase.c b/trunk/sound/pci/ice1712/phase.c index ec3757834b93..dcf1e8ca3f66 100644 --- a/trunk/sound/pci/ice1712/phase.c +++ b/trunk/sound/pci/ice1712/phase.c @@ -86,7 +86,7 @@ static unsigned char wm_vol[256] = { #define WM_VOL_MAX (sizeof(wm_vol) - 1) #define WM_VOL_MUTE 0x8000 -static struct snd_akm4xxx akm_phase22 __devinitdata = { +static akm4xxx_t akm_phase22 __devinitdata = { .type = SND_AK4524, .num_dacs = 2, .num_adcs = 2, @@ -104,9 +104,9 @@ static struct snd_ak4xxx_private akm_phase22_priv __devinitdata = { .mask_flags = 0, }; -static int __devinit phase22_init(struct snd_ice1712 *ice) +static int __devinit phase22_init(ice1712_t *ice) { - struct snd_akm4xxx *ak; + akm4xxx_t *ak; int err; // Configure DAC/ADC description for generic part of ice1724 @@ -122,7 +122,7 @@ static int __devinit phase22_init(struct snd_ice1712 *ice) } // Initialize analog chips - ak = ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ak = ice->akm = kzalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (! ak) return -ENOMEM; ice->akm_codecs = 1; @@ -136,7 +136,7 @@ static int __devinit phase22_init(struct snd_ice1712 *ice) return 0; } -static int __devinit phase22_add_controls(struct snd_ice1712 *ice) +static int __devinit phase22_add_controls(ice1712_t *ice) { int err = 0; @@ -184,7 +184,7 @@ static unsigned char phase28_eeprom[] __devinitdata = { /* * write data in the SPI mode */ -static void phase28_spi_write(struct snd_ice1712 *ice, unsigned int cs, unsigned int data, int bits) +static void phase28_spi_write(ice1712_t *ice, unsigned int cs, unsigned int data, int bits) { unsigned int tmp; int i; @@ -225,7 +225,7 @@ static void phase28_spi_write(struct snd_ice1712 *ice, unsigned int cs, unsigned /* * get the current register value of WM codec */ -static unsigned short wm_get(struct snd_ice1712 *ice, int reg) +static unsigned short wm_get(ice1712_t *ice, int reg) { reg <<= 1; return ((unsigned short)ice->akm[0].images[reg] << 8) | @@ -235,7 +235,7 @@ static unsigned short wm_get(struct snd_ice1712 *ice, int reg) /* * set the register value of WM codec */ -static void wm_put_nocache(struct snd_ice1712 *ice, int reg, unsigned short val) +static void wm_put_nocache(ice1712_t *ice, int reg, unsigned short val) { phase28_spi_write(ice, PHASE28_WM_CS, (reg << 9) | (val & 0x1ff), 16); } @@ -243,7 +243,7 @@ static void wm_put_nocache(struct snd_ice1712 *ice, int reg, unsigned short val) /* * set the register value of WM codec and remember it */ -static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) +static void wm_put(ice1712_t *ice, int reg, unsigned short val) { wm_put_nocache(ice, reg, val); reg <<= 1; @@ -251,7 +251,7 @@ static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) ice->akm[0].images[reg + 1] = val; } -static void wm_set_vol(struct snd_ice1712 *ice, unsigned int index, unsigned short vol, unsigned short master) +static void wm_set_vol(ice1712_t *ice, unsigned int index, unsigned short vol, unsigned short master) { unsigned char nvol; @@ -269,9 +269,9 @@ static void wm_set_vol(struct snd_ice1712 *ice, unsigned int index, unsigned sho */ #define wm_pcm_mute_info phase28_mono_bool_info -static int wm_pcm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); ucontrol->value.integer.value[0] = (wm_get(ice, WM_MUTE) & 0x10) ? 0 : 1; @@ -279,9 +279,9 @@ static int wm_pcm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va return 0; } -static int wm_pcm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short nval, oval; int change; @@ -298,7 +298,7 @@ static int wm_pcm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_va /* * Master volume attenuation mixer control */ -static int wm_master_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_master_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -307,18 +307,18 @@ static int wm_master_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int wm_master_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i; for (i=0; i<2; i++) ucontrol->value.integer.value[i] = ice->spec.phase28.master[i] & ~WM_VOL_MUTE; return 0; } -static int wm_master_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int ch, change = 0; snd_ice1712_save_gpio_status(ice); @@ -338,7 +338,7 @@ static int wm_master_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return change; } -static int __devinit phase28_init(struct snd_ice1712 *ice) +static int __devinit phase28_init(ice1712_t *ice) { static unsigned short wm_inits_phase28[] = { /* These come first to reduce init pop noise */ @@ -378,7 +378,7 @@ static int __devinit phase28_init(struct snd_ice1712 *ice) }; unsigned int tmp; - struct snd_akm4xxx *ak; + akm4xxx_t *ak; unsigned short *p; int i; @@ -386,7 +386,7 @@ static int __devinit phase28_init(struct snd_ice1712 *ice) ice->num_total_adcs = 2; // Initialize analog chips - ak = ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ak = ice->akm = kzalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (!ak) return -ENOMEM; ice->akm_codecs = 1; @@ -427,7 +427,7 @@ static int __devinit phase28_init(struct snd_ice1712 *ice) /* * DAC volume attenuation mixer control */ -static int wm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { int voices = kcontrol->private_value >> 8; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; @@ -437,9 +437,9 @@ static int wm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info * return 0; } -static int wm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, ofs, voices; voices = kcontrol->private_value >> 8; @@ -449,9 +449,9 @@ static int wm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value * return 0; } -static int wm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, idx, ofs, voices; int change = 0; @@ -475,7 +475,7 @@ static int wm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value * /* * WM8770 mute control */ -static int wm_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { +static int wm_mute_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = kcontrol->private_value >> 8; uinfo->value.integer.min = 0; @@ -483,9 +483,9 @@ static int wm_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info return 0; } -static int wm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int voices, ofs, i; voices = kcontrol->private_value >> 8; @@ -496,9 +496,9 @@ static int wm_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value return 0; } -static int wm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, voices, ofs, i; voices = kcontrol->private_value >> 8; @@ -524,7 +524,7 @@ static int wm_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value /* * WM8770 master mute control */ -static int wm_master_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { +static int wm_master_mute_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; uinfo->value.integer.min = 0; @@ -532,18 +532,18 @@ static int wm_master_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int wm_master_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (ice->spec.phase28.master[0] & WM_VOL_MUTE) ? 0 : 1; ucontrol->value.integer.value[1] = (ice->spec.phase28.master[1] & WM_VOL_MUTE) ? 0 : 1; return 0; } -static int wm_master_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_master_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int change = 0, i; snd_ice1712_save_gpio_status(ice); @@ -570,7 +570,7 @@ static int wm_master_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem #define PCM_0dB 0xff #define PCM_RES 128 /* -64dB */ #define PCM_MIN (PCM_0dB - PCM_RES) -static int wm_pcm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_pcm_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -579,9 +579,9 @@ static int wm_pcm_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -static int wm_pcm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val; down(&ice->gpio_mutex); @@ -592,9 +592,9 @@ static int wm_pcm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -static int wm_pcm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_pcm_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short ovol, nvol; int change = 0; @@ -613,7 +613,7 @@ static int wm_pcm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val /* */ -static int phase28_mono_bool_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *uinfo) +static int phase28_mono_bool_info(snd_kcontrol_t *k, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -627,16 +627,16 @@ static int phase28_mono_bool_info(struct snd_kcontrol *k, struct snd_ctl_elem_in */ #define phase28_deemp_info phase28_mono_bool_info -static int phase28_deemp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int phase28_deemp_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (wm_get(ice, WM_DAC_CTRL2) & 0xf) == 0xf; return 0; } -static int phase28_deemp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int phase28_deemp_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int temp, temp2; temp2 = temp = wm_get(ice, WM_DAC_CTRL2); if (ucontrol->value.integer.value[0]) @@ -653,7 +653,7 @@ static int phase28_deemp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ /* * ADC Oversampling */ -static int phase28_oversampling_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *uinfo) +static int phase28_oversampling_info(snd_kcontrol_t *k, snd_ctl_elem_info_t *uinfo) { static char *texts[2] = { "128x", "64x" }; @@ -668,17 +668,17 @@ static int phase28_oversampling_info(struct snd_kcontrol *k, struct snd_ctl_elem return 0; } -static int phase28_oversampling_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int phase28_oversampling_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = (wm_get(ice, WM_MASTER) & 0x8) == 0x8; return 0; } -static int phase28_oversampling_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int phase28_oversampling_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int temp, temp2; - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); temp2 = temp = wm_get(ice, WM_MASTER); @@ -694,7 +694,7 @@ static int phase28_oversampling_put(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static struct snd_kcontrol_new phase28_dac_controls[] __devinitdata = { +static snd_kcontrol_new_t phase28_dac_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Switch", @@ -791,7 +791,7 @@ static struct snd_kcontrol_new phase28_dac_controls[] __devinitdata = { } }; -static struct snd_kcontrol_new wm_controls[] __devinitdata = { +static snd_kcontrol_new_t wm_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Switch", @@ -822,7 +822,7 @@ static struct snd_kcontrol_new wm_controls[] __devinitdata = { } }; -static int __devinit phase28_add_controls(struct snd_ice1712 *ice) +static int __devinit phase28_add_controls(ice1712_t *ice) { unsigned int i, counts; int err; diff --git a/trunk/sound/pci/ice1712/pontis.c b/trunk/sound/pci/ice1712/pontis.c index 0dccd7707a4b..773a1ecb75ce 100644 --- a/trunk/sound/pci/ice1712/pontis.c +++ b/trunk/sound/pci/ice1712/pontis.c @@ -76,7 +76,7 @@ /* * get the current register value of WM codec */ -static unsigned short wm_get(struct snd_ice1712 *ice, int reg) +static unsigned short wm_get(ice1712_t *ice, int reg) { reg <<= 1; return ((unsigned short)ice->akm[0].images[reg] << 8) | @@ -86,14 +86,14 @@ static unsigned short wm_get(struct snd_ice1712 *ice, int reg) /* * set the register value of WM codec and remember it */ -static void wm_put_nocache(struct snd_ice1712 *ice, int reg, unsigned short val) +static void wm_put_nocache(ice1712_t *ice, int reg, unsigned short val) { unsigned short cval; cval = (reg << 9) | val; snd_vt1724_write_i2c(ice, WM_DEV, cval >> 8, cval & 0xff); } -static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) +static void wm_put(ice1712_t *ice, int reg, unsigned short val) { wm_put_nocache(ice, reg, val); reg <<= 1; @@ -109,7 +109,7 @@ static void wm_put(struct snd_ice1712 *ice, int reg, unsigned short val) #define DAC_RES 128 #define DAC_MIN (DAC_0dB - DAC_RES) -static int wm_dac_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_dac_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -118,9 +118,9 @@ static int wm_dac_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -static int wm_dac_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_dac_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val; int i; @@ -134,9 +134,9 @@ static int wm_dac_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -static int wm_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_dac_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short oval, nval; int i, idx, change = 0; @@ -164,7 +164,7 @@ static int wm_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val #define ADC_RES 128 #define ADC_MIN (ADC_0dB - ADC_RES) -static int wm_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_adc_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -173,9 +173,9 @@ static int wm_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -static int wm_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val; int i; @@ -189,9 +189,9 @@ static int wm_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -static int wm_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short ovol, nvol; int i, idx, change = 0; @@ -213,7 +213,7 @@ static int wm_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val /* * ADC input mux mixer control */ -static int wm_adc_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_adc_mux_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -222,9 +222,9 @@ static int wm_adc_mux_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_in return 0; } -static int wm_adc_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_mux_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int bit = kcontrol->private_value; down(&ice->gpio_mutex); @@ -233,9 +233,9 @@ static int wm_adc_mux_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val return 0; } -static int wm_adc_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_adc_mux_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int bit = kcontrol->private_value; unsigned short oval, nval; int change; @@ -257,7 +257,7 @@ static int wm_adc_mux_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_val /* * Analog bypass (In -> Out) */ -static int wm_bypass_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_bypass_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -266,9 +266,9 @@ static int wm_bypass_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_inf return 0; } -static int wm_bypass_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_bypass_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); ucontrol->value.integer.value[0] = (wm_get(ice, WM_OUT_MUX) & 0x04) ? 1 : 0; @@ -276,9 +276,9 @@ static int wm_bypass_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu return 0; } -static int wm_bypass_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_bypass_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val, oval; int change = 0; @@ -299,7 +299,7 @@ static int wm_bypass_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu /* * Left/Right swap */ -static int wm_chswap_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int wm_chswap_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -308,9 +308,9 @@ static int wm_chswap_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_inf return 0; } -static int wm_chswap_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_chswap_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); ucontrol->value.integer.value[0] = (wm_get(ice, WM_DAC_CTRL1) & 0xf0) != 0x90; @@ -318,9 +318,9 @@ static int wm_chswap_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu return 0; } -static int wm_chswap_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int wm_chswap_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned short val, oval; int change = 0; @@ -343,7 +343,7 @@ static int wm_chswap_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu /* * write data in the SPI mode */ -static void set_gpio_bit(struct snd_ice1712 *ice, unsigned int bit, int val) +static void set_gpio_bit(ice1712_t *ice, unsigned int bit, int val) { unsigned int tmp = snd_ice1712_gpio_read(ice); if (val) @@ -353,7 +353,7 @@ static void set_gpio_bit(struct snd_ice1712 *ice, unsigned int bit, int val) snd_ice1712_gpio_write(ice, tmp); } -static void spi_send_byte(struct snd_ice1712 *ice, unsigned char data) +static void spi_send_byte(ice1712_t *ice, unsigned char data) { int i; for (i = 0; i < 8; i++) { @@ -367,7 +367,7 @@ static void spi_send_byte(struct snd_ice1712 *ice, unsigned char data) } } -static unsigned int spi_read_byte(struct snd_ice1712 *ice) +static unsigned int spi_read_byte(ice1712_t *ice) { int i; unsigned int val = 0; @@ -386,7 +386,7 @@ static unsigned int spi_read_byte(struct snd_ice1712 *ice) } -static void spi_write(struct snd_ice1712 *ice, unsigned int dev, unsigned int reg, unsigned int data) +static void spi_write(ice1712_t *ice, unsigned int dev, unsigned int reg, unsigned int data) { snd_ice1712_gpio_set_dir(ice, PONTIS_CS_CS|PONTIS_CS_WDATA|PONTIS_CS_CLK); snd_ice1712_gpio_set_mask(ice, ~(PONTIS_CS_CS|PONTIS_CS_WDATA|PONTIS_CS_CLK)); @@ -402,7 +402,7 @@ static void spi_write(struct snd_ice1712 *ice, unsigned int dev, unsigned int re snd_ice1712_gpio_set_dir(ice, ice->gpio.direction); } -static unsigned int spi_read(struct snd_ice1712 *ice, unsigned int dev, unsigned int reg) +static unsigned int spi_read(ice1712_t *ice, unsigned int dev, unsigned int reg) { unsigned int val; snd_ice1712_gpio_set_dir(ice, PONTIS_CS_CS|PONTIS_CS_WDATA|PONTIS_CS_CLK); @@ -429,7 +429,7 @@ static unsigned int spi_read(struct snd_ice1712 *ice, unsigned int dev, unsigned /* * SPDIF input source */ -static int cs_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int cs_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[] = { "Coax", /* RXP0 */ @@ -445,9 +445,9 @@ static int cs_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_inf return 0; } -static int cs_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cs_source_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); ucontrol->value.enumerated.item[0] = ice->gpio.saved[0]; @@ -455,9 +455,9 @@ static int cs_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu return 0; } -static int cs_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int cs_source_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char val; int change = 0; @@ -476,7 +476,7 @@ static int cs_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu /* * GPIO controls */ -static int pontis_gpio_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int pontis_gpio_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -485,9 +485,9 @@ static int pontis_gpio_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int pontis_gpio_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int pontis_gpio_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); /* 4-7 reserved */ ucontrol->value.integer.value[0] = (~ice->gpio.write_mask & 0xffff) | 0x00f0; @@ -495,9 +495,9 @@ static int pontis_gpio_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int pontis_gpio_mask_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int pontis_gpio_mask_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned int val; int changed; down(&ice->gpio_mutex); @@ -509,9 +509,9 @@ static int pontis_gpio_mask_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el return changed; } -static int pontis_gpio_dir_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int pontis_gpio_dir_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); /* 4-7 reserved */ ucontrol->value.integer.value[0] = ice->gpio.direction & 0xff0f; @@ -519,9 +519,9 @@ static int pontis_gpio_dir_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int pontis_gpio_dir_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int pontis_gpio_dir_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned int val; int changed; down(&ice->gpio_mutex); @@ -533,9 +533,9 @@ static int pontis_gpio_dir_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return changed; } -static int pontis_gpio_data_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int pontis_gpio_data_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); down(&ice->gpio_mutex); snd_ice1712_gpio_set_dir(ice, ice->gpio.direction); snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask); @@ -544,9 +544,9 @@ static int pontis_gpio_data_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int pontis_gpio_data_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int pontis_gpio_data_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned int val, nval; int changed = 0; down(&ice->gpio_mutex); @@ -566,7 +566,7 @@ static int pontis_gpio_data_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el * mixers */ -static struct snd_kcontrol_new pontis_controls[] __devinitdata = { +static snd_kcontrol_new_t pontis_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Volume", @@ -646,9 +646,9 @@ static struct snd_kcontrol_new pontis_controls[] __devinitdata = { /* * WM codec registers */ -static void wm_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void wm_proc_regs_write(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; + ice1712_t *ice = (ice1712_t *)entry->private_data; char line[64]; unsigned int reg, val; down(&ice->gpio_mutex); @@ -661,9 +661,9 @@ static void wm_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buf up(&ice->gpio_mutex); } -static void wm_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void wm_proc_regs_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; + ice1712_t *ice = (ice1712_t *)entry->private_data; int reg, val; down(&ice->gpio_mutex); @@ -674,9 +674,9 @@ static void wm_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buff up(&ice->gpio_mutex); } -static void wm_proc_init(struct snd_ice1712 *ice) +static void wm_proc_init(ice1712_t *ice) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(ice->card, "wm_codec", &entry)) { snd_info_set_text_ops(entry, ice, 1024, wm_proc_regs_read); entry->mode |= S_IWUSR; @@ -685,9 +685,9 @@ static void wm_proc_init(struct snd_ice1712 *ice) } } -static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void cs_proc_regs_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; + ice1712_t *ice = (ice1712_t *)entry->private_data; int reg, val; down(&ice->gpio_mutex); @@ -700,16 +700,16 @@ static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buff up(&ice->gpio_mutex); } -static void cs_proc_init(struct snd_ice1712 *ice) +static void cs_proc_init(ice1712_t *ice) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(ice->card, "cs_codec", &entry)) { snd_info_set_text_ops(entry, ice, 1024, cs_proc_regs_read); } } -static int __devinit pontis_add_controls(struct snd_ice1712 *ice) +static int __devinit pontis_add_controls(ice1712_t *ice) { unsigned int i; int err; @@ -730,7 +730,7 @@ static int __devinit pontis_add_controls(struct snd_ice1712 *ice) /* * initialize the chip */ -static int __devinit pontis_init(struct snd_ice1712 *ice) +static int __devinit pontis_init(ice1712_t *ice) { static unsigned short wm_inits[] = { /* These come first to reduce init pop noise */ @@ -781,7 +781,7 @@ static int __devinit pontis_init(struct snd_ice1712 *ice) ice->num_total_adcs = 2; /* to remeber the register values */ - ice->akm = kzalloc(sizeof(struct snd_akm4xxx), GFP_KERNEL); + ice->akm = kzalloc(sizeof(akm4xxx_t), GFP_KERNEL); if (! ice->akm) return -ENOMEM; ice->akm_codecs = 1; diff --git a/trunk/sound/pci/ice1712/prodigy192.c b/trunk/sound/pci/ice1712/prodigy192.c index fdb5cb8fac97..d2c5963795d7 100644 --- a/trunk/sound/pci/ice1712/prodigy192.c +++ b/trunk/sound/pci/ice1712/prodigy192.c @@ -36,12 +36,12 @@ #include "prodigy192.h" #include "stac946x.h" -static inline void stac9460_put(struct snd_ice1712 *ice, int reg, unsigned char val) +static inline void stac9460_put(ice1712_t *ice, int reg, unsigned char val) { snd_vt1724_write_i2c(ice, PRODIGY192_STAC9460_ADDR, reg, val); } -static inline unsigned char stac9460_get(struct snd_ice1712 *ice, int reg) +static inline unsigned char stac9460_get(ice1712_t *ice, int reg) { return snd_vt1724_read_i2c(ice, PRODIGY192_STAC9460_ADDR, reg); } @@ -49,7 +49,7 @@ static inline unsigned char stac9460_get(struct snd_ice1712 *ice, int reg) /* * DAC mute control */ -static int stac9460_dac_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int stac9460_dac_mute_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -58,9 +58,9 @@ static int stac9460_dac_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_dac_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char val; int idx; @@ -73,9 +73,9 @@ static int stac9460_dac_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_dac_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char new, old; int idx; int change; @@ -96,7 +96,7 @@ static int stac9460_dac_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e /* * DAC volume attenuation mixer control */ -static int stac9460_dac_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int stac9460_dac_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -105,9 +105,9 @@ static int stac9460_dac_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int stac9460_dac_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_dac_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx; unsigned char vol; @@ -121,9 +121,9 @@ static int stac9460_dac_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_dac_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int idx; unsigned char tmp, ovol, nvol; int change; @@ -145,7 +145,7 @@ static int stac9460_dac_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el /* * ADC mute control */ -static int stac9460_adc_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int stac9460_adc_mute_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -154,9 +154,9 @@ static int stac9460_adc_mute_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int stac9460_adc_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_adc_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char val; int i; @@ -168,9 +168,9 @@ static int stac9460_adc_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_adc_mute_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); unsigned char new, old; int i, reg; int change; @@ -190,7 +190,7 @@ static int stac9460_adc_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e /* * ADC gain mixer control */ -static int stac9460_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int stac9460_adc_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -199,9 +199,9 @@ static int stac9460_adc_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int stac9460_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_adc_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, reg; unsigned char vol; @@ -214,9 +214,9 @@ static int stac9460_adc_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int stac9460_adc_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int i, reg; unsigned char ovol, nvol; int change; @@ -237,7 +237,7 @@ static int stac9460_adc_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_el /* * Headphone Amplifier */ -static int aureon_set_headphone_amp(struct snd_ice1712 *ice, int enable) +static int aureon_set_headphone_amp(ice1712_t *ice, int enable) { unsigned int tmp, tmp2; @@ -253,14 +253,14 @@ static int aureon_set_headphone_amp(struct snd_ice1712 *ice, int enable) return 0; } -static int aureon_get_headphone_amp(struct snd_ice1712 *ice) +static int aureon_get_headphone_amp(ice1712_t *ice) { unsigned int tmp = snd_ice1712_gpio_read(ice); return ( tmp & AUREON_HP_SEL )!= 0; } -static int aureon_bool_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *uinfo) +static int aureon_bool_info(snd_kcontrol_t *k, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -269,18 +269,18 @@ static int aureon_bool_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *ui return 0; } -static int aureon_hpamp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_hpamp_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = aureon_get_headphone_amp(ice); return 0; } -static int aureon_hpamp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_hpamp_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); return aureon_set_headphone_amp(ice,ucontrol->value.integer.value[0]); } @@ -288,16 +288,16 @@ static int aureon_hpamp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v /* * Deemphasis */ -static int aureon_deemp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_deemp_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (wm_get(ice, WM_DAC_CTRL2) & 0xf) == 0xf; return 0; } -static int aureon_deemp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_deemp_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); int temp, temp2; temp2 = temp = wm_get(ice, WM_DAC_CTRL2); if (ucontrol->value.integer.value[0]) @@ -314,7 +314,7 @@ static int aureon_deemp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v /* * ADC Oversampling */ -static int aureon_oversampling_info(struct snd_kcontrol *k, struct snd_ctl_elem_info *uinfo) +static int aureon_oversampling_info(snd_kcontrol_t *k, snd_ctl_elem_info_t *uinfo) { static char *texts[2] = { "128x", "64x" }; @@ -329,17 +329,17 @@ static int aureon_oversampling_info(struct snd_kcontrol *k, struct snd_ctl_elem_ return 0; } -static int aureon_oversampling_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_oversampling_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = (wm_get(ice, WM_MASTER) & 0x8) == 0x8; return 0; } -static int aureon_oversampling_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int aureon_oversampling_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int temp, temp2; - struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol); + ice1712_t *ice = snd_kcontrol_chip(kcontrol); temp2 = temp = wm_get(ice, WM_MASTER); @@ -360,7 +360,7 @@ static int aureon_oversampling_put(struct snd_kcontrol *kcontrol, struct snd_ctl * mixers */ -static struct snd_kcontrol_new stac_controls[] __devinitdata = { +static snd_kcontrol_new_t stac_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Switch", @@ -442,7 +442,7 @@ static struct snd_kcontrol_new stac_controls[] __devinitdata = { #endif }; -static int __devinit prodigy192_add_controls(struct snd_ice1712 *ice) +static int __devinit prodigy192_add_controls(ice1712_t *ice) { unsigned int i; int err; @@ -459,7 +459,7 @@ static int __devinit prodigy192_add_controls(struct snd_ice1712 *ice) /* * initialize the chip */ -static int __devinit prodigy192_init(struct snd_ice1712 *ice) +static int __devinit prodigy192_init(ice1712_t *ice) { static unsigned short stac_inits_prodigy[] = { STAC946X_RESET, 0, diff --git a/trunk/sound/pci/ice1712/revo.c b/trunk/sound/pci/ice1712/revo.c index b5754b32b802..1fe21009ca84 100644 --- a/trunk/sound/pci/ice1712/revo.c +++ b/trunk/sound/pci/ice1712/revo.c @@ -33,7 +33,7 @@ #include "envy24ht.h" #include "revo.h" -static void revo_i2s_mclk_changed(struct snd_ice1712 *ice) +static void revo_i2s_mclk_changed(ice1712_t *ice) { /* assert PRST# to converters; MT05 bit 7 */ outb(inb(ICEMT1724(ice, AC97_CMD)) | 0x80, ICEMT1724(ice, AC97_CMD)); @@ -45,7 +45,7 @@ static void revo_i2s_mclk_changed(struct snd_ice1712 *ice) /* * change the rate of envy24HT, AK4355 and AK4381 */ -static void revo_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) +static void revo_set_rate_val(akm4xxx_t *ak, unsigned int rate) { unsigned char old, tmp, dfs; int reg, shift; @@ -61,7 +61,7 @@ static void revo_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) else dfs = 0; - if (ak->type == SND_AK4355 || ak->type == SND_AK4358) { + if (ak->type == SND_AK4355) { reg = 2; shift = 4; } else { @@ -87,7 +87,7 @@ static void revo_set_rate_val(struct snd_akm4xxx *ak, unsigned int rate) * initialize the chips on M-Audio Revolution cards */ -static struct snd_akm4xxx akm_revo_front __devinitdata = { +static akm4xxx_t akm_revo_front __devinitdata = { .type = SND_AK4381, .num_dacs = 2, .ops = { @@ -107,7 +107,7 @@ static struct snd_ak4xxx_private akm_revo_front_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_revo_surround __devinitdata = { +static akm4xxx_t akm_revo_surround __devinitdata = { .type = SND_AK4355, .idx_offset = 1, .num_dacs = 6, @@ -128,29 +128,9 @@ static struct snd_ak4xxx_private akm_revo_surround_priv __devinitdata = { .mask_flags = 0, }; -static struct snd_akm4xxx akm_revo51 __devinitdata = { - .type = SND_AK4358, - .num_dacs = 6, - .ops = { - .set_rate_val = revo_set_rate_val - } -}; - -static struct snd_ak4xxx_private akm_revo51_priv __devinitdata = { - .caddr = 2, - .cif = 0, - .data_mask = VT1724_REVO_CDOUT, - .clk_mask = VT1724_REVO_CCLK, - .cs_mask = VT1724_REVO_CS0 | VT1724_REVO_CS1 | VT1724_REVO_CS2, - .cs_addr = 0, - .cs_none = VT1724_REVO_CS0 | VT1724_REVO_CS1 | VT1724_REVO_CS2, - .add_flags = VT1724_REVO_CCLK, /* high at init */ - .mask_flags = 0, -}; - -static int __devinit revo_init(struct snd_ice1712 *ice) +static int __devinit revo_init(ice1712_t *ice) { - struct snd_akm4xxx *ak; + akm4xxx_t *ak; int err; /* determine I2C, DACs and ADCs */ @@ -158,25 +138,21 @@ static int __devinit revo_init(struct snd_ice1712 *ice) case VT1724_SUBDEVICE_REVOLUTION71: ice->num_total_dacs = 8; ice->num_total_adcs = 2; - ice->gpio.i2s_mclk_changed = revo_i2s_mclk_changed; - break; - case VT1724_SUBDEVICE_REVOLUTION51: - ice->num_total_dacs = 6; - ice->num_total_adcs = 2; break; default: snd_BUG(); return -EINVAL; } + ice->gpio.i2s_mclk_changed = revo_i2s_mclk_changed; + /* second stage of initialization, analog parts and others */ - ak = ice->akm = kcalloc(2, sizeof(struct snd_akm4xxx), GFP_KERNEL); + ak = ice->akm = kcalloc(2, sizeof(akm4xxx_t), GFP_KERNEL); if (! ak) return -ENOMEM; ice->akm_codecs = 2; switch (ice->eeprom.subvendor) { case VT1724_SUBDEVICE_REVOLUTION71: - ice->akm_codecs = 2; if ((err = snd_ice1712_akm4xxx_init(ak, &akm_revo_front, &akm_revo_front_priv, ice)) < 0) return err; if ((err = snd_ice1712_akm4xxx_init(ak + 1, &akm_revo_surround, &akm_revo_surround_priv, ice)) < 0) @@ -184,26 +160,18 @@ static int __devinit revo_init(struct snd_ice1712 *ice) /* unmute all codecs */ snd_ice1712_gpio_write_bits(ice, VT1724_REVO_MUTE, VT1724_REVO_MUTE); break; - case VT1724_SUBDEVICE_REVOLUTION51: - ice->akm_codecs = 1; - if ((err = snd_ice1712_akm4xxx_init(ak, &akm_revo51, &akm_revo51_priv, ice)) < 0) - return err; - /* unmute all codecs - needed! */ - snd_ice1712_gpio_write_bits(ice, VT1724_REVO_MUTE, VT1724_REVO_MUTE); - break; } return 0; } -static int __devinit revo_add_controls(struct snd_ice1712 *ice) +static int __devinit revo_add_controls(ice1712_t *ice) { int err; switch (ice->eeprom.subvendor) { case VT1724_SUBDEVICE_REVOLUTION71: - case VT1724_SUBDEVICE_REVOLUTION51: err = snd_ice1712_akm4xxx_build_controls(ice); if (err < 0) return err; @@ -220,12 +188,5 @@ struct snd_ice1712_card_info snd_vt1724_revo_cards[] __devinitdata = { .chip_init = revo_init, .build_controls = revo_add_controls, }, - { - .subvendor = VT1724_SUBDEVICE_REVOLUTION51, - .name = "M Audio Revolution-5.1", - .model = "revo51", - .chip_init = revo_init, - .build_controls = revo_add_controls, - }, { } /* terminator */ }; diff --git a/trunk/sound/pci/ice1712/revo.h b/trunk/sound/pci/ice1712/revo.h index dea52ea219df..ca4420b5e3ec 100644 --- a/trunk/sound/pci/ice1712/revo.h +++ b/trunk/sound/pci/ice1712/revo.h @@ -25,11 +25,9 @@ */ #define REVO_DEVICE_DESC \ - "{MidiMan M Audio,Revolution 7.1},"\ - "{MidiMan M Audio,Revolution 5.1}," + "{MidiMan M Audio,Revolution 7.1}," #define VT1724_SUBDEVICE_REVOLUTION71 0x12143036 -#define VT1724_SUBDEVICE_REVOLUTION51 0x12143136 /* entry point */ extern struct snd_ice1712_card_info snd_vt1724_revo_cards[]; diff --git a/trunk/sound/pci/ice1712/vt1720_mobo.c b/trunk/sound/pci/ice1712/vt1720_mobo.c index 7ca263c13091..90c85cd95479 100644 --- a/trunk/sound/pci/ice1712/vt1720_mobo.c +++ b/trunk/sound/pci/ice1712/vt1720_mobo.c @@ -33,7 +33,7 @@ #include "vt1720_mobo.h" -static int __devinit k8x800_init(struct snd_ice1712 *ice) +static int __devinit k8x800_init(ice1712_t *ice) { ice->vt1720 = 1; @@ -47,7 +47,7 @@ static int __devinit k8x800_init(struct snd_ice1712 *ice) return 0; } -static int __devinit k8x800_add_controls(struct snd_ice1712 *ice) +static int __devinit k8x800_add_controls(ice1712_t *ice) { /* FIXME: needs some quirks for VT1616? */ return 0; diff --git a/trunk/sound/pci/intel8x0.c b/trunk/sound/pci/intel8x0.c index 5466b1fa0cd5..cf7801d2dd10 100644 --- a/trunk/sound/pci/intel8x0.c +++ b/trunk/sound/pci/intel8x0.c @@ -272,8 +272,7 @@ enum { #define ALI_INT_CPRAIS (1<<7) /* command port available */ #define ALI_INT_SPRAIS (1<<5) /* status port available */ #define ALI_INT_GPIO (1<<1) -#define ALI_INT_MASK (ALI_INT_SPDIFOUT|ALI_INT_CODECSPDIFOUT|\ - ALI_INT_MICIN|ALI_INT_PCMOUT|ALI_INT_PCMIN) +#define ALI_INT_MASK (ALI_INT_SPDIFOUT|ALI_INT_CODECSPDIFOUT|ALI_INT_MICIN|ALI_INT_PCMOUT|ALI_INT_PCMIN) #define ICH_ALI_SC_RESET (1<<31) /* master reset */ #define ICH_ALI_SC_AC97_DBL (1<<30) @@ -304,40 +303,18 @@ enum { * */ -enum { - ICHD_PCMIN, - ICHD_PCMOUT, - ICHD_MIC, - ICHD_MIC2, - ICHD_PCM2IN, - ICHD_SPBAR, - ICHD_LAST = ICHD_SPBAR -}; -enum { - NVD_PCMIN, - NVD_PCMOUT, - NVD_MIC, - NVD_SPBAR, - NVD_LAST = NVD_SPBAR -}; -enum { - ALID_PCMIN, - ALID_PCMOUT, - ALID_MIC, - ALID_AC97SPDIFOUT, - ALID_SPDIFIN, - ALID_SPDIFOUT, - ALID_LAST = ALID_SPDIFOUT -}; +enum { ICHD_PCMIN, ICHD_PCMOUT, ICHD_MIC, ICHD_MIC2, ICHD_PCM2IN, ICHD_SPBAR, ICHD_LAST = ICHD_SPBAR }; +enum { NVD_PCMIN, NVD_PCMOUT, NVD_MIC, NVD_SPBAR, NVD_LAST = NVD_SPBAR }; +enum { ALID_PCMIN, ALID_PCMOUT, ALID_MIC, ALID_AC97SPDIFOUT, ALID_SPDIFIN, ALID_SPDIFOUT, ALID_LAST = ALID_SPDIFOUT }; -#define get_ichdev(substream) (substream->runtime->private_data) +#define get_ichdev(substream) (ichdev_t *)(substream->runtime->private_data) -struct ichdev { +typedef struct { unsigned int ichd; /* ich device number */ unsigned long reg_offset; /* offset to bmaddr */ u32 *bdbar; /* CPU address (32bit) */ unsigned int bdbar_addr; /* PCI bus address (32bit) */ - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; unsigned int physbuf; /* physical address (32bit) */ unsigned int size; unsigned int fragsize; @@ -359,9 +336,11 @@ struct ichdev { int pcm_open_flag; unsigned int page_attr_changed: 1; unsigned int suspended: 1; -}; +} ichdev_t; + +typedef struct _snd_intel8x0 intel8x0_t; -struct intel8x0 { +struct _snd_intel8x0 { unsigned int device_type; int irq; @@ -374,11 +353,11 @@ struct intel8x0 { void __iomem *remap_bmaddr; struct pci_dev *pci; - struct snd_card *card; + snd_card_t *card; int pcm_devs; - struct snd_pcm *pcm[6]; - struct ichdev ichd[6]; + snd_pcm_t *pcm[6]; + ichdev_t ichd[6]; unsigned multi4: 1, multi6: 1, @@ -395,8 +374,8 @@ struct intel8x0 { int spdif_idx; /* SPDIF BAR index; *_SPBAR or -1 if use PCMOUT */ unsigned int sdm_saved; /* SDM reg value */ - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97[3]; + ac97_bus_t *ac97_bus; + ac97_t *ac97[3]; unsigned int ac97_sdin[3]; spinlock_t reg_lock; @@ -439,7 +418,7 @@ MODULE_DEVICE_TABLE(pci, snd_intel8x0_ids); * Lowlevel I/O - busmaster */ -static u8 igetbyte(struct intel8x0 *chip, u32 offset) +static u8 igetbyte(intel8x0_t *chip, u32 offset) { if (chip->bm_mmio) return readb(chip->remap_bmaddr + offset); @@ -447,7 +426,7 @@ static u8 igetbyte(struct intel8x0 *chip, u32 offset) return inb(chip->bmaddr + offset); } -static u16 igetword(struct intel8x0 *chip, u32 offset) +static u16 igetword(intel8x0_t *chip, u32 offset) { if (chip->bm_mmio) return readw(chip->remap_bmaddr + offset); @@ -455,7 +434,7 @@ static u16 igetword(struct intel8x0 *chip, u32 offset) return inw(chip->bmaddr + offset); } -static u32 igetdword(struct intel8x0 *chip, u32 offset) +static u32 igetdword(intel8x0_t *chip, u32 offset) { if (chip->bm_mmio) return readl(chip->remap_bmaddr + offset); @@ -463,7 +442,7 @@ static u32 igetdword(struct intel8x0 *chip, u32 offset) return inl(chip->bmaddr + offset); } -static void iputbyte(struct intel8x0 *chip, u32 offset, u8 val) +static void iputbyte(intel8x0_t *chip, u32 offset, u8 val) { if (chip->bm_mmio) writeb(val, chip->remap_bmaddr + offset); @@ -471,7 +450,7 @@ static void iputbyte(struct intel8x0 *chip, u32 offset, u8 val) outb(val, chip->bmaddr + offset); } -static void iputword(struct intel8x0 *chip, u32 offset, u16 val) +static void iputword(intel8x0_t *chip, u32 offset, u16 val) { if (chip->bm_mmio) writew(val, chip->remap_bmaddr + offset); @@ -479,7 +458,7 @@ static void iputword(struct intel8x0 *chip, u32 offset, u16 val) outw(val, chip->bmaddr + offset); } -static void iputdword(struct intel8x0 *chip, u32 offset, u32 val) +static void iputdword(intel8x0_t *chip, u32 offset, u32 val) { if (chip->bm_mmio) writel(val, chip->remap_bmaddr + offset); @@ -491,7 +470,7 @@ static void iputdword(struct intel8x0 *chip, u32 offset, u32 val) * Lowlevel I/O - AC'97 registers */ -static u16 iagetword(struct intel8x0 *chip, u32 offset) +static u16 iagetword(intel8x0_t *chip, u32 offset) { if (chip->mmio) return readw(chip->remap_addr + offset); @@ -499,7 +478,7 @@ static u16 iagetword(struct intel8x0 *chip, u32 offset) return inw(chip->addr + offset); } -static void iaputword(struct intel8x0 *chip, u32 offset, u16 val) +static void iaputword(intel8x0_t *chip, u32 offset, u16 val) { if (chip->mmio) writew(val, chip->remap_addr + offset); @@ -516,7 +495,7 @@ static void iaputword(struct intel8x0 *chip, u32 offset, u16 val) */ /* return the GLOB_STA bit for the corresponding codec */ -static unsigned int get_ich_codec_bit(struct intel8x0 *chip, unsigned int codec) +static unsigned int get_ich_codec_bit(intel8x0_t *chip, unsigned int codec) { static unsigned int codec_bit[3] = { ICH_PCR, ICH_SCR, ICH_TCR @@ -527,7 +506,7 @@ static unsigned int get_ich_codec_bit(struct intel8x0 *chip, unsigned int codec) return codec_bit[codec]; } -static int snd_intel8x0_codec_semaphore(struct intel8x0 *chip, unsigned int codec) +static int snd_intel8x0_codec_semaphore(intel8x0_t *chip, unsigned int codec) { int time; @@ -566,11 +545,11 @@ static int snd_intel8x0_codec_semaphore(struct intel8x0 *chip, unsigned int code return -EBUSY; } -static void snd_intel8x0_codec_write(struct snd_ac97 *ac97, +static void snd_intel8x0_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct intel8x0 *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; if (snd_intel8x0_codec_semaphore(chip, ac97->num) < 0) { if (! chip->in_ac97_init) @@ -579,10 +558,10 @@ static void snd_intel8x0_codec_write(struct snd_ac97 *ac97, iaputword(chip, reg + ac97->num * 0x80, val); } -static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97, +static unsigned short snd_intel8x0_codec_read(ac97_t *ac97, unsigned short reg) { - struct intel8x0 *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; unsigned short res; unsigned int tmp; @@ -594,8 +573,7 @@ static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97, res = iagetword(chip, reg + ac97->num * 0x80); if ((tmp = igetdword(chip, ICHREG(GLOB_STA))) & ICH_RCS) { /* reset RCS and preserve other R/WC bits */ - iputdword(chip, ICHREG(GLOB_STA), tmp & - ~(ICH_SRI|ICH_PRI|ICH_TRI|ICH_GSCI)); + iputdword(chip, ICHREG(GLOB_STA), tmp & ~(ICH_SRI|ICH_PRI|ICH_TRI|ICH_GSCI)); if (! chip->in_ac97_init) snd_printk(KERN_ERR "codec_read %d: read timeout for register 0x%x\n", ac97->num, reg); res = 0xffff; @@ -604,7 +582,7 @@ static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97, return res; } -static void snd_intel8x0_codec_read_test(struct intel8x0 *chip, unsigned int codec) +static void snd_intel8x0_codec_read_test(intel8x0_t *chip, unsigned int codec) { unsigned int tmp; @@ -612,8 +590,7 @@ static void snd_intel8x0_codec_read_test(struct intel8x0 *chip, unsigned int cod iagetword(chip, codec * 0x80); if ((tmp = igetdword(chip, ICHREG(GLOB_STA))) & ICH_RCS) { /* reset RCS and preserve other R/WC bits */ - iputdword(chip, ICHREG(GLOB_STA), tmp & - ~(ICH_SRI|ICH_PRI|ICH_TRI|ICH_GSCI)); + iputdword(chip, ICHREG(GLOB_STA), tmp & ~(ICH_SRI|ICH_PRI|ICH_TRI|ICH_GSCI)); } } } @@ -621,7 +598,7 @@ static void snd_intel8x0_codec_read_test(struct intel8x0 *chip, unsigned int cod /* * access to AC97 for Ali5455 */ -static int snd_intel8x0_ali_codec_ready(struct intel8x0 *chip, int mask) +static int snd_intel8x0_ali_codec_ready(intel8x0_t *chip, int mask) { int count = 0; for (count = 0; count < 0x7f; count++) { @@ -634,7 +611,7 @@ static int snd_intel8x0_ali_codec_ready(struct intel8x0 *chip, int mask) return -EBUSY; } -static int snd_intel8x0_ali_codec_semaphore(struct intel8x0 *chip) +static int snd_intel8x0_ali_codec_semaphore(intel8x0_t *chip) { int time = 100; if (chip->buggy_semaphore) @@ -646,9 +623,9 @@ static int snd_intel8x0_ali_codec_semaphore(struct intel8x0 *chip) return snd_intel8x0_ali_codec_ready(chip, ALI_CSPSR_CODEC_READY); } -static unsigned short snd_intel8x0_ali_codec_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_intel8x0_ali_codec_read(ac97_t *ac97, unsigned short reg) { - struct intel8x0 *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; unsigned short data = 0xffff; if (snd_intel8x0_ali_codec_semaphore(chip)) @@ -664,10 +641,9 @@ static unsigned short snd_intel8x0_ali_codec_read(struct snd_ac97 *ac97, unsigne return data; } -static void snd_intel8x0_ali_codec_write(struct snd_ac97 *ac97, unsigned short reg, - unsigned short val) +static void snd_intel8x0_ali_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct intel8x0 *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; if (snd_intel8x0_ali_codec_semaphore(chip)) return; @@ -682,7 +658,7 @@ static void snd_intel8x0_ali_codec_write(struct snd_ac97 *ac97, unsigned short r /* * DMA I/O */ -static void snd_intel8x0_setup_periods(struct intel8x0 *chip, struct ichdev *ichdev) +static void snd_intel8x0_setup_periods(intel8x0_t *chip, ichdev_t *ichdev) { int idx; u32 *bdbar = ichdev->bdbar; @@ -705,15 +681,10 @@ static void snd_intel8x0_setup_periods(struct intel8x0 *chip, struct ichdev *ich ichdev->ack_reload = ichdev->ack = 1; ichdev->fragsize1 = ichdev->fragsize; for (idx = 0; idx < (ICH_REG_LVI_MASK + 1) * 2; idx += 2) { - bdbar[idx + 0] = cpu_to_le32(ichdev->physbuf + - (((idx >> 1) * ichdev->fragsize) % - ichdev->size)); + bdbar[idx + 0] = cpu_to_le32(ichdev->physbuf + (((idx >> 1) * ichdev->fragsize) % ichdev->size)); bdbar[idx + 1] = cpu_to_le32(0x80000000 | /* interrupt on completion */ ichdev->fragsize >> ichdev->pos_shift); -#if 0 - printk("bdbar[%i] = 0x%x [0x%x]\n", - idx + 0, bdbar[idx + 0], bdbar[idx + 1]); -#endif + // printk("bdbar[%i] = 0x%x [0x%x]\n", idx + 0, bdbar[idx + 0], bdbar[idx + 1]); } ichdev->frags = ichdev->size / ichdev->fragsize; } @@ -751,7 +722,7 @@ static void fill_nocache(void *buf, int size, int nocache) * Interrupt handler */ -static inline void snd_intel8x0_update(struct intel8x0 *chip, struct ichdev *ichdev) +static inline void snd_intel8x0_update(intel8x0_t *chip, ichdev_t *ichdev) { unsigned long port = ichdev->reg_offset; int status, civ, i, step; @@ -786,12 +757,7 @@ static inline void snd_intel8x0_update(struct intel8x0 *chip, struct ichdev *ich ichdev->lvi_frag++; ichdev->lvi_frag %= ichdev->frags; ichdev->bdbar[ichdev->lvi * 2] = cpu_to_le32(ichdev->physbuf + ichdev->lvi_frag * ichdev->fragsize1); -#if 0 - printk("new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n", - ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2], - ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port), - inl(port + 4), inb(port + ICH_REG_OFF_CR)); -#endif + // printk("new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n", ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2], ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port), inl(port + 4), inb(port + ICH_REG_OFF_CR)); if (--ichdev->ack == 0) { ichdev->ack = ichdev->ack_reload; ack = 1; @@ -807,8 +773,8 @@ static inline void snd_intel8x0_update(struct intel8x0 *chip, struct ichdev *ich static irqreturn_t snd_intel8x0_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct intel8x0 *chip = dev_id; - struct ichdev *ichdev; + intel8x0_t *chip = dev_id; + ichdev_t *ichdev; unsigned int status; unsigned int i; @@ -842,10 +808,10 @@ static irqreturn_t snd_intel8x0_interrupt(int irq, void *dev_id, struct pt_regs * PCM part */ -static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_intel8x0_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + ichdev_t *ichdev = get_ichdev(substream); unsigned char val = 0; unsigned long port = ichdev->reg_offset; @@ -881,14 +847,12 @@ static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd return 0; } -static int snd_intel8x0_ali_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_intel8x0_ali_trigger(snd_pcm_substream_t *substream, int cmd) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + ichdev_t *ichdev = get_ichdev(substream); unsigned long port = ichdev->reg_offset; - static int fiforeg[] = { - ICHREG(ALI_FIFOCR1), ICHREG(ALI_FIFOCR2), ICHREG(ALI_FIFOCR3) - }; + static int fiforeg[] = { ICHREG(ALI_FIFOCR1), ICHREG(ALI_FIFOCR2), ICHREG(ALI_FIFOCR3) }; unsigned int val, fifo; val = igetdword(chip, ICHREG(ALI_DMACR)); @@ -907,16 +871,14 @@ static int snd_intel8x0_ali_trigger(struct snd_pcm_substream *substream, int cmd } iputbyte(chip, port + ICH_REG_OFF_CR, ICH_IOCE); val &= ~(1 << (ichdev->ali_slot + 16)); /* clear PAUSE flag */ - /* start DMA */ - iputdword(chip, ICHREG(ALI_DMACR), val | (1 << ichdev->ali_slot)); + iputdword(chip, ICHREG(ALI_DMACR), val | (1 << ichdev->ali_slot)); /* start DMA */ break; case SNDRV_PCM_TRIGGER_SUSPEND: ichdev->suspended = 1; /* fallthru */ case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - /* pause */ - iputdword(chip, ICHREG(ALI_DMACR), val | (1 << (ichdev->ali_slot + 16))); + iputdword(chip, ICHREG(ALI_DMACR), val | (1 << (ichdev->ali_slot + 16))); /* pause */ iputbyte(chip, port + ICH_REG_OFF_CR, 0); while (igetbyte(chip, port + ICH_REG_OFF_CR)) ; @@ -925,8 +887,7 @@ static int snd_intel8x0_ali_trigger(struct snd_pcm_substream *substream, int cmd /* reset whole DMA things */ iputbyte(chip, port + ICH_REG_OFF_CR, ICH_RESETREGS); /* clear interrupts */ - iputbyte(chip, port + ICH_REG_OFF_SR, - igetbyte(chip, port + ICH_REG_OFF_SR) | 0x1e); + iputbyte(chip, port + ICH_REG_OFF_SR, igetbyte(chip, port + ICH_REG_OFF_SR) | 0x1e); iputdword(chip, ICHREG(ALI_INTERRUPTSR), igetdword(chip, ICHREG(ALI_INTERRUPTSR)) & ichdev->int_sta_mask); break; @@ -936,12 +897,12 @@ static int snd_intel8x0_ali_trigger(struct snd_pcm_substream *substream, int cmd return 0; } -static int snd_intel8x0_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_intel8x0_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct ichdev *ichdev = get_ichdev(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + intel8x0_t *chip = snd_pcm_substream_chip(substream); + ichdev_t *ichdev = get_ichdev(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int dbl = params_rate(hw_params) > 48000; int err; @@ -969,16 +930,15 @@ static int snd_intel8x0_hw_params(struct snd_pcm_substream *substream, ichdev->pcm_open_flag = 1; /* Force SPDIF setting */ if (ichdev->ichd == ICHD_PCMOUT && chip->spdif_idx < 0) - snd_ac97_set_rate(ichdev->pcm->r[0].codec[0], AC97_SPDIF, - params_rate(hw_params)); + snd_ac97_set_rate(ichdev->pcm->r[0].codec[0], AC97_SPDIF, params_rate(hw_params)); } return err; } -static int snd_intel8x0_hw_free(struct snd_pcm_substream *substream) +static int snd_intel8x0_hw_free(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + ichdev_t *ichdev = get_ichdev(substream); if (ichdev->pcm_open_flag) { snd_ac97_pcm_close(ichdev->pcm); @@ -991,8 +951,8 @@ static int snd_intel8x0_hw_free(struct snd_pcm_substream *substream) return snd_pcm_lib_free_pages(substream); } -static void snd_intel8x0_setup_pcm_out(struct intel8x0 *chip, - struct snd_pcm_runtime *runtime) +static void snd_intel8x0_setup_pcm_out(intel8x0_t *chip, + snd_pcm_runtime_t *runtime) { unsigned int cnt; int dbl = runtime->rate > 48000; @@ -1044,11 +1004,11 @@ static void snd_intel8x0_setup_pcm_out(struct intel8x0 *chip, spin_unlock_irq(&chip->reg_lock); } -static int snd_intel8x0_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_intel8x0_pcm_prepare(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ichdev_t *ichdev = get_ichdev(substream); ichdev->physbuf = runtime->dma_addr; ichdev->size = snd_pcm_lib_buffer_bytes(substream); @@ -1062,10 +1022,10 @@ static int snd_intel8x0_pcm_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + ichdev_t *ichdev = get_ichdev(substream); size_t ptr1, ptr; int civ, timeout = 100; unsigned int position; @@ -1092,7 +1052,7 @@ static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *subs return bytes_to_frames(substream->runtime, ptr); } -static struct snd_pcm_hardware snd_intel8x0_stream = +static snd_pcm_hardware_t snd_intel8x0_stream = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1117,7 +1077,7 @@ static unsigned int channels4[] = { 2, 4, }; -static struct snd_pcm_hw_constraint_list hw_constraints_channels4 = { +static snd_pcm_hw_constraint_list_t hw_constraints_channels4 = { .count = ARRAY_SIZE(channels4), .list = channels4, .mask = 0, @@ -1127,16 +1087,16 @@ static unsigned int channels6[] = { 2, 4, 6, }; -static struct snd_pcm_hw_constraint_list hw_constraints_channels6 = { +static snd_pcm_hw_constraint_list_t hw_constraints_channels6 = { .count = ARRAY_SIZE(channels6), .list = channels6, .mask = 0, }; -static int snd_intel8x0_pcm_open(struct snd_pcm_substream *substream, struct ichdev *ichdev) +static int snd_intel8x0_pcm_open(snd_pcm_substream_t * substream, ichdev_t *ichdev) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + intel8x0_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; ichdev->substream = substream; @@ -1153,10 +1113,10 @@ static int snd_intel8x0_pcm_open(struct snd_pcm_substream *substream, struct ich return 0; } -static int snd_intel8x0_playback_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_playback_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + intel8x0_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; err = snd_intel8x0_pcm_open(substream, &chip->ichd[ICHD_PCMOUT]); @@ -1165,12 +1125,10 @@ static int snd_intel8x0_playback_open(struct snd_pcm_substream *substream) if (chip->multi6) { runtime->hw.channels_max = 6; - snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, - &hw_constraints_channels6); + snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, &hw_constraints_channels6); } else if (chip->multi4) { runtime->hw.channels_max = 4; - snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, - &hw_constraints_channels4); + snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, &hw_constraints_channels4); } if (chip->dra) { snd_ac97_pcm_double_rate_rules(runtime); @@ -1182,94 +1140,94 @@ static int snd_intel8x0_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_intel8x0_playback_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_playback_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ICHD_PCMOUT].substream = NULL; return 0; } -static int snd_intel8x0_capture_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_capture_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0_pcm_open(substream, &chip->ichd[ICHD_PCMIN]); } -static int snd_intel8x0_capture_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_capture_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ICHD_PCMIN].substream = NULL; return 0; } -static int snd_intel8x0_mic_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_mic_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0_pcm_open(substream, &chip->ichd[ICHD_MIC]); } -static int snd_intel8x0_mic_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_mic_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ICHD_MIC].substream = NULL; return 0; } -static int snd_intel8x0_mic2_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_mic2_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0_pcm_open(substream, &chip->ichd[ICHD_MIC2]); } -static int snd_intel8x0_mic2_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_mic2_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ICHD_MIC2].substream = NULL; return 0; } -static int snd_intel8x0_capture2_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_capture2_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0_pcm_open(substream, &chip->ichd[ICHD_PCM2IN]); } -static int snd_intel8x0_capture2_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_capture2_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ICHD_PCM2IN].substream = NULL; return 0; } -static int snd_intel8x0_spdif_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_spdif_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); int idx = chip->device_type == DEVICE_NFORCE ? NVD_SPBAR : ICHD_SPBAR; return snd_intel8x0_pcm_open(substream, &chip->ichd[idx]); } -static int snd_intel8x0_spdif_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_spdif_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); int idx = chip->device_type == DEVICE_NFORCE ? NVD_SPBAR : ICHD_SPBAR; chip->ichd[idx].substream = NULL; return 0; } -static int snd_intel8x0_ali_ac97spdifout_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_ali_ac97spdifout_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); unsigned int val; spin_lock_irq(&chip->reg_lock); @@ -1282,9 +1240,9 @@ static int snd_intel8x0_ali_ac97spdifout_open(struct snd_pcm_substream *substrea return snd_intel8x0_pcm_open(substream, &chip->ichd[ALID_AC97SPDIFOUT]); } -static int snd_intel8x0_ali_ac97spdifout_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_ali_ac97spdifout_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); unsigned int val; chip->ichd[ALID_AC97SPDIFOUT].substream = NULL; @@ -1297,39 +1255,39 @@ static int snd_intel8x0_ali_ac97spdifout_close(struct snd_pcm_substream *substre return 0; } -static int snd_intel8x0_ali_spdifin_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_ali_spdifin_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0_pcm_open(substream, &chip->ichd[ALID_SPDIFIN]); } -static int snd_intel8x0_ali_spdifin_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_ali_spdifin_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ALID_SPDIFIN].substream = NULL; return 0; } #if 0 // NYI -static int snd_intel8x0_ali_spdifout_open(struct snd_pcm_substream *substream) +static int snd_intel8x0_ali_spdifout_open(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0_pcm_open(substream, &chip->ichd[ALID_SPDIFOUT]); } -static int snd_intel8x0_ali_spdifout_close(struct snd_pcm_substream *substream) +static int snd_intel8x0_ali_spdifout_close(snd_pcm_substream_t * substream) { - struct intel8x0 *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ALID_SPDIFOUT].substream = NULL; return 0; } #endif -static struct snd_pcm_ops snd_intel8x0_playback_ops = { +static snd_pcm_ops_t snd_intel8x0_playback_ops = { .open = snd_intel8x0_playback_open, .close = snd_intel8x0_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1340,7 +1298,7 @@ static struct snd_pcm_ops snd_intel8x0_playback_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_capture_ops = { +static snd_pcm_ops_t snd_intel8x0_capture_ops = { .open = snd_intel8x0_capture_open, .close = snd_intel8x0_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1351,7 +1309,7 @@ static struct snd_pcm_ops snd_intel8x0_capture_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_capture_mic_ops = { +static snd_pcm_ops_t snd_intel8x0_capture_mic_ops = { .open = snd_intel8x0_mic_open, .close = snd_intel8x0_mic_close, .ioctl = snd_pcm_lib_ioctl, @@ -1362,7 +1320,7 @@ static struct snd_pcm_ops snd_intel8x0_capture_mic_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_capture_mic2_ops = { +static snd_pcm_ops_t snd_intel8x0_capture_mic2_ops = { .open = snd_intel8x0_mic2_open, .close = snd_intel8x0_mic2_close, .ioctl = snd_pcm_lib_ioctl, @@ -1373,7 +1331,7 @@ static struct snd_pcm_ops snd_intel8x0_capture_mic2_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_capture2_ops = { +static snd_pcm_ops_t snd_intel8x0_capture2_ops = { .open = snd_intel8x0_capture2_open, .close = snd_intel8x0_capture2_close, .ioctl = snd_pcm_lib_ioctl, @@ -1384,7 +1342,7 @@ static struct snd_pcm_ops snd_intel8x0_capture2_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_spdif_ops = { +static snd_pcm_ops_t snd_intel8x0_spdif_ops = { .open = snd_intel8x0_spdif_open, .close = snd_intel8x0_spdif_close, .ioctl = snd_pcm_lib_ioctl, @@ -1395,7 +1353,7 @@ static struct snd_pcm_ops snd_intel8x0_spdif_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_ali_playback_ops = { +static snd_pcm_ops_t snd_intel8x0_ali_playback_ops = { .open = snd_intel8x0_playback_open, .close = snd_intel8x0_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1406,7 +1364,7 @@ static struct snd_pcm_ops snd_intel8x0_ali_playback_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_ali_capture_ops = { +static snd_pcm_ops_t snd_intel8x0_ali_capture_ops = { .open = snd_intel8x0_capture_open, .close = snd_intel8x0_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1417,7 +1375,7 @@ static struct snd_pcm_ops snd_intel8x0_ali_capture_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_ali_capture_mic_ops = { +static snd_pcm_ops_t snd_intel8x0_ali_capture_mic_ops = { .open = snd_intel8x0_mic_open, .close = snd_intel8x0_mic_close, .ioctl = snd_pcm_lib_ioctl, @@ -1428,7 +1386,7 @@ static struct snd_pcm_ops snd_intel8x0_ali_capture_mic_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_ali_ac97spdifout_ops = { +static snd_pcm_ops_t snd_intel8x0_ali_ac97spdifout_ops = { .open = snd_intel8x0_ali_ac97spdifout_open, .close = snd_intel8x0_ali_ac97spdifout_close, .ioctl = snd_pcm_lib_ioctl, @@ -1439,7 +1397,7 @@ static struct snd_pcm_ops snd_intel8x0_ali_ac97spdifout_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0_ali_spdifin_ops = { +static snd_pcm_ops_t snd_intel8x0_ali_spdifin_ops = { .open = snd_intel8x0_ali_spdifin_open, .close = snd_intel8x0_ali_spdifin_close, .ioctl = snd_pcm_lib_ioctl, @@ -1451,7 +1409,7 @@ static struct snd_pcm_ops snd_intel8x0_ali_spdifin_ops = { }; #if 0 // NYI -static struct snd_pcm_ops snd_intel8x0_ali_spdifout_ops = { +static snd_pcm_ops_t snd_intel8x0_ali_spdifout_ops = { .open = snd_intel8x0_ali_spdifout_open, .close = snd_intel8x0_ali_spdifout_close, .ioctl = snd_pcm_lib_ioctl, @@ -1465,17 +1423,16 @@ static struct snd_pcm_ops snd_intel8x0_ali_spdifout_ops = { struct ich_pcm_table { char *suffix; - struct snd_pcm_ops *playback_ops; - struct snd_pcm_ops *capture_ops; + snd_pcm_ops_t *playback_ops; + snd_pcm_ops_t *capture_ops; size_t prealloc_size; size_t prealloc_max_size; int ac97_idx; }; -static int __devinit snd_intel8x0_pcm1(struct intel8x0 *chip, int device, - struct ich_pcm_table *rec) +static int __devinit snd_intel8x0_pcm1(intel8x0_t *chip, int device, struct ich_pcm_table *rec) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; char name[32]; @@ -1502,8 +1459,7 @@ static int __devinit snd_intel8x0_pcm1(struct intel8x0 *chip, int device, strcpy(pcm->name, chip->card->shortname); chip->pcm[device] = pcm; - snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(chip->pci), + snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci), rec->prealloc_size, rec->prealloc_max_size); return 0; @@ -1601,7 +1557,7 @@ static struct ich_pcm_table ali_pcms[] __devinitdata = { #endif }; -static int __devinit snd_intel8x0_pcm(struct intel8x0 *chip) +static int __devinit snd_intel8x0_pcm(intel8x0_t *chip) { int i, tblsize, device, err; struct ich_pcm_table *tbl, *rec; @@ -1648,15 +1604,15 @@ static int __devinit snd_intel8x0_pcm(struct intel8x0 *chip) * Mixer part */ -static void snd_intel8x0_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_intel8x0_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct intel8x0 *chip = bus->private_data; + intel8x0_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_intel8x0_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_intel8x0_mixer_free_ac97(ac97_t *ac97) { - struct intel8x0 *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; chip->ac97[ac97->num] = NULL; } @@ -1857,30 +1813,6 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = { .name = "HP xw8000", .type = AC97_TUNE_HP_ONLY }, - { - .subvendor = 0x103c, - .subdevice = 0x0938, - .name = "HP nc4200", - .type = AC97_TUNE_HP_MUTE_LED - }, - { - .subvendor = 0x103c, - .subdevice = 0x099c, - .name = "HP nc6120", - .type = AC97_TUNE_HP_MUTE_LED - }, - { - .subvendor = 0x103c, - .subdevice = 0x0944, - .name = "HP nc6220", - .type = AC97_TUNE_HP_MUTE_LED - }, - { - .subvendor = 0x103c, - .subdevice = 0x0934, - .name = "HP nc8220", - .type = AC97_TUNE_HP_MUTE_LED - }, { .subvendor = 0x103c, .subdevice = 0x12f1, @@ -1935,12 +1867,6 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = { .name = "Fujitsu-Siemens 4010", .type = AC97_TUNE_HP_ONLY }, - { - .subvendor = 0x10cf, - .subdevice = 0x12f2, - .name = "Fujitsu-Siemens Celsius H320", - .type = AC97_TUNE_SWAP_HP - }, { .subvendor = 0x10f1, .subdevice = 0x2665, @@ -2035,20 +1961,19 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = { { } /* terminator */ }; -static int __devinit snd_intel8x0_mixer(struct intel8x0 *chip, int ac97_clock, - const char *quirk_override) +static int __devinit snd_intel8x0_mixer(intel8x0_t *chip, int ac97_clock, const char *quirk_override) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + ac97_bus_t *pbus; + ac97_template_t ac97; int err; unsigned int i, codecs; unsigned int glob_sta = 0; - struct snd_ac97_bus_ops *ops; - static struct snd_ac97_bus_ops standard_bus_ops = { + ac97_bus_ops_t *ops; + static ac97_bus_ops_t standard_bus_ops = { .write = snd_intel8x0_codec_write, .read = snd_intel8x0_codec_read, }; - static struct snd_ac97_bus_ops ali_bus_ops = { + static ac97_bus_ops_t ali_bus_ops = { .write = snd_intel8x0_ali_codec_write, .read = snd_intel8x0_ali_codec_read, }; @@ -2203,8 +2128,7 @@ static int __devinit snd_intel8x0_mixer(struct intel8x0 *chip, int ac97_clock, __err: /* clear the cold-reset bit for the next chance */ if (chip->device_type != DEVICE_ALI) - iputdword(chip, ICHREG(GLOB_CNT), - igetdword(chip, ICHREG(GLOB_CNT)) & ~ICH_AC97COLD); + iputdword(chip, ICHREG(GLOB_CNT), igetdword(chip, ICHREG(GLOB_CNT)) & ~ICH_AC97COLD); return err; } @@ -2213,7 +2137,7 @@ static int __devinit snd_intel8x0_mixer(struct intel8x0 *chip, int ac97_clock, * */ -static void do_ali_reset(struct intel8x0 *chip) +static void do_ali_reset(intel8x0_t *chip) { iputdword(chip, ICHREG(ALI_SCR), ICH_ALI_SC_RESET); iputdword(chip, ICHREG(ALI_FIFOCR1), 0x83838383); @@ -2225,7 +2149,11 @@ static void do_ali_reset(struct intel8x0 *chip) iputdword(chip, ICHREG(ALI_INTERRUPTSR), 0x00000000); } -static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing) +#define do_delay(chip) do {\ + schedule_timeout_uninterruptible(1);\ +} while (0) + +static int snd_intel8x0_ich_chip_init(intel8x0_t *chip, int probing) { unsigned long end_time; unsigned int cnt, status, nstatus; @@ -2248,10 +2176,9 @@ static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing) do { if ((igetdword(chip, ICHREG(GLOB_CNT)) & ICH_AC97WARM) == 0) goto __ok; - schedule_timeout_uninterruptible(1); + do_delay(chip); } while (time_after_eq(end_time, jiffies)); - snd_printk(KERN_ERR "AC'97 warm reset still in progress? [0x%x]\n", - igetdword(chip, ICHREG(GLOB_CNT))); + snd_printk(KERN_ERR "AC'97 warm reset still in progress? [0x%x]\n", igetdword(chip, ICHREG(GLOB_CNT))); return -EIO; __ok: @@ -2262,16 +2189,14 @@ static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing) */ end_time = jiffies + HZ; do { - status = igetdword(chip, ICHREG(GLOB_STA)) & - (ICH_PCR | ICH_SCR | ICH_TCR); + status = igetdword(chip, ICHREG(GLOB_STA)) & (ICH_PCR | ICH_SCR | ICH_TCR); if (status) break; - schedule_timeout_uninterruptible(1); + do_delay(chip); } while (time_after_eq(end_time, jiffies)); if (! status) { /* no codec is found */ - snd_printk(KERN_ERR "codec_ready: codec is not ready [0x%x]\n", - igetdword(chip, ICHREG(GLOB_STA))); + snd_printk(KERN_ERR "codec_ready: codec is not ready [0x%x]\n", igetdword(chip, ICHREG(GLOB_STA))); return -EIO; } @@ -2285,7 +2210,7 @@ static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing) /* wait for other codecs ready status. */ end_time = jiffies + HZ / 4; while (status != nstatus && time_after_eq(end_time, jiffies)) { - schedule_timeout_uninterruptible(1); + do_delay(chip); status |= igetdword(chip, ICHREG(GLOB_STA)) & nstatus; } @@ -2299,11 +2224,10 @@ static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing) /* wait until all the probed codecs are ready */ end_time = jiffies + HZ; do { - nstatus = igetdword(chip, ICHREG(GLOB_STA)) & - (ICH_PCR | ICH_SCR | ICH_TCR); + nstatus = igetdword(chip, ICHREG(GLOB_STA)) & (ICH_PCR | ICH_SCR | ICH_TCR); if (status == nstatus) break; - schedule_timeout_uninterruptible(1); + do_delay(chip); } while (time_after_eq(end_time, jiffies)); } @@ -2321,7 +2245,7 @@ static int snd_intel8x0_ich_chip_init(struct intel8x0 *chip, int probing) return 0; } -static int snd_intel8x0_ali_chip_init(struct intel8x0 *chip, int probing) +static int snd_intel8x0_ali_chip_init(intel8x0_t *chip, int probing) { u32 reg; int i = 0; @@ -2337,7 +2261,7 @@ static int snd_intel8x0_ali_chip_init(struct intel8x0 *chip, int probing) for (i = 0; i < HZ / 2; i++) { if (! (igetdword(chip, ICHREG(ALI_INTERRUPTSR)) & ALI_INT_GPIO)) goto __ok; - schedule_timeout_uninterruptible(1); + do_delay(chip); } snd_printk(KERN_ERR "AC'97 reset failed.\n"); if (probing) @@ -2349,14 +2273,14 @@ static int snd_intel8x0_ali_chip_init(struct intel8x0 *chip, int probing) if (reg & 0x80) /* primary codec */ break; iputdword(chip, ICHREG(ALI_RTSR), reg | 0x80); - schedule_timeout_uninterruptible(1); + do_delay(chip); } do_ali_reset(chip); return 0; } -static int snd_intel8x0_chip_init(struct intel8x0 *chip, int probing) +static int snd_intel8x0_chip_init(intel8x0_t *chip, int probing) { unsigned int i; int err; @@ -2378,12 +2302,11 @@ static int snd_intel8x0_chip_init(struct intel8x0 *chip, int probing) iputbyte(chip, ICH_REG_OFF_CR + chip->ichd[i].reg_offset, ICH_RESETREGS); /* initialize Buffer Descriptor Lists */ for (i = 0; i < chip->bdbars_count; i++) - iputdword(chip, ICH_REG_OFF_BDBAR + chip->ichd[i].reg_offset, - chip->ichd[i].bdbar_addr); + iputdword(chip, ICH_REG_OFF_BDBAR + chip->ichd[i].reg_offset, chip->ichd[i].bdbar_addr); return 0; } -static int snd_intel8x0_free(struct intel8x0 *chip) +static int snd_intel8x0_free(intel8x0_t *chip) { unsigned int i; @@ -2406,7 +2329,7 @@ static int snd_intel8x0_free(struct intel8x0 *chip) synchronize_irq(chip->irq); __hw_end: if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); if (chip->bdbars.area) { if (chip->fix_nocache) fill_nocache(chip->bdbars.area, chip->bdbars.bytes, 0); @@ -2426,50 +2349,44 @@ static int snd_intel8x0_free(struct intel8x0 *chip) /* * power management */ -static int intel8x0_suspend(struct pci_dev *pci, pm_message_t state) +static int intel8x0_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct intel8x0 *chip = card->private_data; + intel8x0_t *chip = card->pm_private_data; int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < chip->pcm_devs; i++) snd_pcm_suspend_all(chip->pcm[i]); /* clear nocache */ if (chip->fix_nocache) { for (i = 0; i < chip->bdbars_count; i++) { - struct ichdev *ichdev = &chip->ichd[i]; + ichdev_t *ichdev = &chip->ichd[i]; if (ichdev->substream && ichdev->page_attr_changed) { - struct snd_pcm_runtime *runtime = ichdev->substream->runtime; + snd_pcm_runtime_t *runtime = ichdev->substream->runtime; if (runtime->dma_area) fill_nocache(runtime->dma_area, runtime->dma_bytes, 0); } } } for (i = 0; i < 3; i++) - snd_ac97_suspend(chip->ac97[i]); + if (chip->ac97[i]) + snd_ac97_suspend(chip->ac97[i]); if (chip->device_type == DEVICE_INTEL_ICH4) chip->sdm_saved = igetbyte(chip, ICHREG(SDM)); if (chip->irq >= 0) - free_irq(chip->irq, chip); - pci_disable_device(pci); - pci_save_state(pci); + free_irq(chip->irq, (void *)chip); + pci_disable_device(chip->pci); return 0; } -static int intel8x0_resume(struct pci_dev *pci) +static int intel8x0_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct intel8x0 *chip = card->private_data; + intel8x0_t *chip = card->pm_private_data; int i; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); - request_irq(pci->irq, snd_intel8x0_interrupt, SA_INTERRUPT|SA_SHIRQ, - card->shortname, chip); - chip->irq = pci->irq; + pci_enable_device(chip->pci); + pci_set_master(chip->pci); + request_irq(chip->irq, snd_intel8x0_interrupt, SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip); synchronize_irq(chip->irq); snd_intel8x0_chip_init(chip, 1); @@ -2488,14 +2405,15 @@ static int intel8x0_resume(struct pci_dev *pci) fill_nocache(chip->bdbars.area, chip->bdbars.bytes, 1); for (i = 0; i < 3; i++) - snd_ac97_resume(chip->ac97[i]); + if (chip->ac97[i]) + snd_ac97_resume(chip->ac97[i]); /* refill nocache */ if (chip->fix_nocache) { for (i = 0; i < chip->bdbars_count; i++) { - struct ichdev *ichdev = &chip->ichd[i]; + ichdev_t *ichdev = &chip->ichd[i]; if (ichdev->substream && ichdev->page_attr_changed) { - struct snd_pcm_runtime *runtime = ichdev->substream->runtime; + snd_pcm_runtime_t *runtime = ichdev->substream->runtime; if (runtime->dma_area) fill_nocache(runtime->dma_area, runtime->dma_bytes, 1); } @@ -2504,7 +2422,7 @@ static int intel8x0_resume(struct pci_dev *pci) /* resume status */ for (i = 0; i < chip->bdbars_count; i++) { - struct ichdev *ichdev = &chip->ichd[i]; + ichdev_t *ichdev = &chip->ichd[i]; unsigned long port = ichdev->reg_offset; if (! ichdev->substream || ! ichdev->suspended) continue; @@ -2516,17 +2434,16 @@ static int intel8x0_resume(struct pci_dev *pci) iputbyte(chip, port + ichdev->roff_sr, ICH_FIFOE | ICH_BCIS | ICH_LVBCI); } - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ #define INTEL8X0_TESTBUF_SIZE 32768 /* enough large for one shot */ -static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip) +static void __devinit intel8x0_measure_ac97_clock(intel8x0_t *chip) { - struct snd_pcm_substream *subs; - struct ichdev *ichdev; + snd_pcm_substream_t *subs; + ichdev_t *ichdev; unsigned long port; unsigned long pos, t; struct timeval start_time, stop_time; @@ -2603,11 +2520,10 @@ static void __devinit intel8x0_measure_ac97_clock(struct intel8x0 *chip) printk(KERN_INFO "intel8x0: clocking to %d\n", chip->ac97_bus->clock); } -#ifdef CONFIG_PROC_FS -static void snd_intel8x0_proc_read(struct snd_info_entry * entry, - struct snd_info_buffer *buffer) +static void snd_intel8x0_proc_read(snd_info_entry_t * entry, + snd_info_buffer_t * buffer) { - struct intel8x0 *chip = entry->private_data; + intel8x0_t *chip = entry->private_data; unsigned int tmp; snd_iprintf(buffer, "Intel8x0\n\n"); @@ -2630,20 +2546,17 @@ static void snd_intel8x0_proc_read(struct snd_info_entry * entry, chip->ac97_sdin[2]); } -static void __devinit snd_intel8x0_proc_init(struct intel8x0 * chip) +static void __devinit snd_intel8x0_proc_init(intel8x0_t * chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "intel8x0", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_intel8x0_proc_read); } -#else -#define snd_intel8x0_proc_init(x) -#endif -static int snd_intel8x0_dev_free(struct snd_device *device) +static int snd_intel8x0_dev_free(snd_device_t *device) { - struct intel8x0 *chip = device->device_data; + intel8x0_t *chip = device->device_data; return snd_intel8x0_free(chip); } @@ -2652,17 +2565,17 @@ struct ich_reg_info { unsigned int offset; }; -static int __devinit snd_intel8x0_create(struct snd_card *card, +static int __devinit snd_intel8x0_create(snd_card_t * card, struct pci_dev *pci, unsigned long device_type, - struct intel8x0 ** r_intel8x0) + intel8x0_t ** r_intel8x0) { - struct intel8x0 *chip; + intel8x0_t *chip; int err; unsigned int i; unsigned int int_sta_masks; - struct ichdev *ichdev; - static struct snd_device_ops ops = { + ichdev_t *ichdev; + static snd_device_ops_t ops = { .dev_free = snd_intel8x0_dev_free, }; @@ -2825,7 +2738,7 @@ static int __devinit snd_intel8x0_create(struct snd_card *card, /* request irq after initializaing int_sta_mask, etc */ if (request_irq(pci->irq, snd_intel8x0_interrupt, - SA_INTERRUPT|SA_SHIRQ, card->shortname, chip)) { + SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_intel8x0_free(chip); return -EBUSY; @@ -2839,6 +2752,8 @@ static int __devinit snd_intel8x0_create(struct snd_card *card, return err; } + snd_card_set_pm_callback(card, intel8x0_suspend, intel8x0_resume, chip); + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { snd_intel8x0_free(chip); return err; @@ -2882,8 +2797,8 @@ static struct shortname_table { static int __devinit snd_intel8x0_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct intel8x0 *chip; + snd_card_t *card; + intel8x0_t *chip; int err; struct shortname_table *name; @@ -2926,7 +2841,6 @@ static int __devinit snd_intel8x0_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = chip; if ((err = snd_intel8x0_mixer(chip, ac97_clock, ac97_quirk)) < 0) { snd_card_free(card); @@ -2965,10 +2879,7 @@ static struct pci_driver driver = { .id_table = snd_intel8x0_ids, .probe = snd_intel8x0_probe, .remove = __devexit_p(snd_intel8x0_remove), -#ifdef CONFIG_PM - .suspend = intel8x0_suspend, - .resume = intel8x0_resume, -#endif + SND_PCI_PM_CALLBACKS }; diff --git a/trunk/sound/pci/intel8x0m.c b/trunk/sound/pci/intel8x0m.c index 47e26aaa9ad7..a42091860da7 100644 --- a/trunk/sound/pci/intel8x0m.c +++ b/trunk/sound/pci/intel8x0m.c @@ -38,8 +38,7 @@ #include <sound/initval.h> MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); -MODULE_DESCRIPTION("Intel 82801AA,82901AB,i810,i820,i830,i840,i845,MX440; " - "SiS 7013; NVidia MCP/2/2S/3 modems"); +MODULE_DESCRIPTION("Intel 82801AA,82901AB,i810,i820,i830,i840,i845,MX440; SiS 7013; NVidia MCP/2/2S/3 modems"); MODULE_LICENSE("GPL"); MODULE_SUPPORTED_DEVICE("{{Intel,82801AA-ICH}," "{Intel,82901AB-ICH0}," @@ -164,14 +163,14 @@ DEFINE_REGSET(OFF, 0); /* offset */ enum { ICHD_MDMIN, ICHD_MDMOUT, ICHD_MDMLAST = ICHD_MDMOUT }; enum { ALID_MDMIN, ALID_MDMOUT, ALID_MDMLAST = ALID_MDMOUT }; -#define get_ichdev(substream) (substream->runtime->private_data) +#define get_ichdev(substream) (ichdev_t *)(substream->runtime->private_data) -struct ichdev { +typedef struct { unsigned int ichd; /* ich device number */ unsigned long reg_offset; /* offset to bmaddr */ u32 *bdbar; /* CPU address (32bit) */ unsigned int bdbar_addr; /* PCI bus address (32bit) */ - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; unsigned int physbuf; /* physical address (32bit) */ unsigned int size; unsigned int fragsize; @@ -188,10 +187,12 @@ struct ichdev { unsigned int roff_picb; unsigned int int_sta_mask; /* interrupt status mask */ unsigned int ali_slot; /* ALI DMA slot */ - struct snd_ac97 *ac97; -}; + ac97_t *ac97; +} ichdev_t; + +typedef struct _snd_intel8x0m intel8x0_t; -struct intel8x0m { +struct _snd_intel8x0m { unsigned int device_type; int irq; @@ -204,16 +205,16 @@ struct intel8x0m { void __iomem *remap_bmaddr; struct pci_dev *pci; - struct snd_card *card; + snd_card_t *card; int pcm_devs; - struct snd_pcm *pcm[2]; - struct ichdev ichd[2]; + snd_pcm_t *pcm[2]; + ichdev_t ichd[2]; unsigned int in_ac97_init: 1; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; + ac97_bus_t *ac97_bus; + ac97_t *ac97; spinlock_t reg_lock; @@ -253,7 +254,7 @@ MODULE_DEVICE_TABLE(pci, snd_intel8x0m_ids); * Lowlevel I/O - busmaster */ -static u8 igetbyte(struct intel8x0m *chip, u32 offset) +static u8 igetbyte(intel8x0_t *chip, u32 offset) { if (chip->bm_mmio) return readb(chip->remap_bmaddr + offset); @@ -261,7 +262,7 @@ static u8 igetbyte(struct intel8x0m *chip, u32 offset) return inb(chip->bmaddr + offset); } -static u16 igetword(struct intel8x0m *chip, u32 offset) +static u16 igetword(intel8x0_t *chip, u32 offset) { if (chip->bm_mmio) return readw(chip->remap_bmaddr + offset); @@ -269,7 +270,7 @@ static u16 igetword(struct intel8x0m *chip, u32 offset) return inw(chip->bmaddr + offset); } -static u32 igetdword(struct intel8x0m *chip, u32 offset) +static u32 igetdword(intel8x0_t *chip, u32 offset) { if (chip->bm_mmio) return readl(chip->remap_bmaddr + offset); @@ -277,7 +278,7 @@ static u32 igetdword(struct intel8x0m *chip, u32 offset) return inl(chip->bmaddr + offset); } -static void iputbyte(struct intel8x0m *chip, u32 offset, u8 val) +static void iputbyte(intel8x0_t *chip, u32 offset, u8 val) { if (chip->bm_mmio) writeb(val, chip->remap_bmaddr + offset); @@ -285,7 +286,7 @@ static void iputbyte(struct intel8x0m *chip, u32 offset, u8 val) outb(val, chip->bmaddr + offset); } -static void iputword(struct intel8x0m *chip, u32 offset, u16 val) +static void iputword(intel8x0_t *chip, u32 offset, u16 val) { if (chip->bm_mmio) writew(val, chip->remap_bmaddr + offset); @@ -293,7 +294,7 @@ static void iputword(struct intel8x0m *chip, u32 offset, u16 val) outw(val, chip->bmaddr + offset); } -static void iputdword(struct intel8x0m *chip, u32 offset, u32 val) +static void iputdword(intel8x0_t *chip, u32 offset, u32 val) { if (chip->bm_mmio) writel(val, chip->remap_bmaddr + offset); @@ -305,7 +306,7 @@ static void iputdword(struct intel8x0m *chip, u32 offset, u32 val) * Lowlevel I/O - AC'97 registers */ -static u16 iagetword(struct intel8x0m *chip, u32 offset) +static u16 iagetword(intel8x0_t *chip, u32 offset) { if (chip->mmio) return readw(chip->remap_addr + offset); @@ -313,7 +314,7 @@ static u16 iagetword(struct intel8x0m *chip, u32 offset) return inw(chip->addr + offset); } -static void iaputword(struct intel8x0m *chip, u32 offset, u16 val) +static void iaputword(intel8x0_t *chip, u32 offset, u16 val) { if (chip->mmio) writew(val, chip->remap_addr + offset); @@ -330,7 +331,7 @@ static void iaputword(struct intel8x0m *chip, u32 offset, u16 val) */ /* return the GLOB_STA bit for the corresponding codec */ -static unsigned int get_ich_codec_bit(struct intel8x0m *chip, unsigned int codec) +static unsigned int get_ich_codec_bit(intel8x0_t *chip, unsigned int codec) { static unsigned int codec_bit[3] = { ICH_PCR, ICH_SCR, ICH_TCR @@ -339,7 +340,7 @@ static unsigned int get_ich_codec_bit(struct intel8x0m *chip, unsigned int codec return codec_bit[codec]; } -static int snd_intel8x0m_codec_semaphore(struct intel8x0m *chip, unsigned int codec) +static int snd_intel8x0m_codec_semaphore(intel8x0_t *chip, unsigned int codec) { int time; @@ -369,11 +370,11 @@ static int snd_intel8x0m_codec_semaphore(struct intel8x0m *chip, unsigned int co return -EBUSY; } -static void snd_intel8x0_codec_write(struct snd_ac97 *ac97, +static void snd_intel8x0_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct intel8x0m *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; if (snd_intel8x0m_codec_semaphore(chip, ac97->num) < 0) { if (! chip->in_ac97_init) @@ -382,10 +383,10 @@ static void snd_intel8x0_codec_write(struct snd_ac97 *ac97, iaputword(chip, reg + ac97->num * 0x80, val); } -static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97, +static unsigned short snd_intel8x0_codec_read(ac97_t *ac97, unsigned short reg) { - struct intel8x0m *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; unsigned short res; unsigned int tmp; @@ -397,8 +398,7 @@ static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97, res = iagetword(chip, reg + ac97->num * 0x80); if ((tmp = igetdword(chip, ICHREG(GLOB_STA))) & ICH_RCS) { /* reset RCS and preserve other R/WC bits */ - iputdword(chip, ICHREG(GLOB_STA), - tmp & ~(ICH_SRI|ICH_PRI|ICH_TRI|ICH_GSCI)); + iputdword(chip, ICHREG(GLOB_STA), tmp & ~(ICH_SRI|ICH_PRI|ICH_TRI|ICH_GSCI)); if (! chip->in_ac97_init) snd_printk(KERN_ERR "codec_read %d: read timeout for register 0x%x\n", ac97->num, reg); res = 0xffff; @@ -413,7 +413,7 @@ static unsigned short snd_intel8x0_codec_read(struct snd_ac97 *ac97, /* * DMA I/O */ -static void snd_intel8x0_setup_periods(struct intel8x0m *chip, struct ichdev *ichdev) +static void snd_intel8x0_setup_periods(intel8x0_t *chip, ichdev_t *ichdev) { int idx; u32 *bdbar = ichdev->bdbar; @@ -460,7 +460,7 @@ static void snd_intel8x0_setup_periods(struct intel8x0m *chip, struct ichdev *ic * Interrupt handler */ -static inline void snd_intel8x0_update(struct intel8x0m *chip, struct ichdev *ichdev) +static inline void snd_intel8x0_update(intel8x0_t *chip, ichdev_t *ichdev) { unsigned long port = ichdev->reg_offset; int civ, i, step; @@ -489,15 +489,8 @@ static inline void snd_intel8x0_update(struct intel8x0m *chip, struct ichdev *ic for (i = 0; i < step; i++) { ichdev->lvi_frag++; ichdev->lvi_frag %= ichdev->frags; - ichdev->bdbar[ichdev->lvi * 2] = cpu_to_le32(ichdev->physbuf + - ichdev->lvi_frag * - ichdev->fragsize1); -#if 0 - printk("new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n", - ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2], - ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port), - inl(port + 4), inb(port + ICH_REG_OFF_CR)); -#endif + ichdev->bdbar[ichdev->lvi * 2] = cpu_to_le32(ichdev->physbuf + ichdev->lvi_frag * ichdev->fragsize1); + // printk("new: bdbar[%i] = 0x%x [0x%x], prefetch = %i, all = 0x%x, 0x%x\n", ichdev->lvi * 2, ichdev->bdbar[ichdev->lvi * 2], ichdev->bdbar[ichdev->lvi * 2 + 1], inb(ICH_REG_OFF_PIV + port), inl(port + 4), inb(port + ICH_REG_OFF_CR)); if (--ichdev->ack == 0) { ichdev->ack = ichdev->ack_reload; ack = 1; @@ -513,8 +506,8 @@ static inline void snd_intel8x0_update(struct intel8x0m *chip, struct ichdev *ic static irqreturn_t snd_intel8x0_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct intel8x0m *chip = dev_id; - struct ichdev *ichdev; + intel8x0_t *chip = dev_id; + ichdev_t *ichdev; unsigned int status; unsigned int i; @@ -548,10 +541,10 @@ static irqreturn_t snd_intel8x0_interrupt(int irq, void *dev_id, struct pt_regs * PCM part */ -static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_intel8x0_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct intel8x0m *chip = snd_pcm_substream_chip(substream); - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + ichdev_t *ichdev = get_ichdev(substream); unsigned char val = 0; unsigned long port = ichdev->reg_offset; @@ -583,21 +576,21 @@ static int snd_intel8x0_pcm_trigger(struct snd_pcm_substream *substream, int cmd return 0; } -static int snd_intel8x0_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_intel8x0_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_intel8x0_hw_free(struct snd_pcm_substream *substream) +static int snd_intel8x0_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(snd_pcm_substream_t * substream) { - struct intel8x0m *chip = snd_pcm_substream_chip(substream); - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + ichdev_t *ichdev = get_ichdev(substream); size_t ptr1, ptr; ptr1 = igetword(chip, ichdev->reg_offset + ichdev->roff_picb) << chip->pcm_pos_shift; @@ -611,11 +604,11 @@ static snd_pcm_uframes_t snd_intel8x0_pcm_pointer(struct snd_pcm_substream *subs return bytes_to_frames(substream->runtime, ptr); } -static int snd_intel8x0m_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_intel8x0m_pcm_prepare(snd_pcm_substream_t * substream) { - struct intel8x0m *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct ichdev *ichdev = get_ichdev(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ichdev_t *ichdev = get_ichdev(substream); ichdev->physbuf = runtime->dma_addr; ichdev->size = snd_pcm_lib_buffer_bytes(substream); @@ -626,7 +619,7 @@ static int snd_intel8x0m_pcm_prepare(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_hardware snd_intel8x0m_stream = +static snd_pcm_hardware_t snd_intel8x0m_stream = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -648,59 +641,58 @@ static struct snd_pcm_hardware snd_intel8x0m_stream = }; -static int snd_intel8x0m_pcm_open(struct snd_pcm_substream *substream, struct ichdev *ichdev) +static int snd_intel8x0m_pcm_open(snd_pcm_substream_t * substream, ichdev_t *ichdev) { static unsigned int rates[] = { 8000, 9600, 12000, 16000 }; - static struct snd_pcm_hw_constraint_list hw_constraints_rates = { + static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, }; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; ichdev->substream = substream; runtime->hw = snd_intel8x0m_stream; - err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates); + err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates); if ( err < 0 ) return err; runtime->private_data = ichdev; return 0; } -static int snd_intel8x0m_playback_open(struct snd_pcm_substream *substream) +static int snd_intel8x0m_playback_open(snd_pcm_substream_t * substream) { - struct intel8x0m *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0m_pcm_open(substream, &chip->ichd[ICHD_MDMOUT]); } -static int snd_intel8x0m_playback_close(struct snd_pcm_substream *substream) +static int snd_intel8x0m_playback_close(snd_pcm_substream_t * substream) { - struct intel8x0m *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ICHD_MDMOUT].substream = NULL; return 0; } -static int snd_intel8x0m_capture_open(struct snd_pcm_substream *substream) +static int snd_intel8x0m_capture_open(snd_pcm_substream_t * substream) { - struct intel8x0m *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); return snd_intel8x0m_pcm_open(substream, &chip->ichd[ICHD_MDMIN]); } -static int snd_intel8x0m_capture_close(struct snd_pcm_substream *substream) +static int snd_intel8x0m_capture_close(snd_pcm_substream_t * substream) { - struct intel8x0m *chip = snd_pcm_substream_chip(substream); + intel8x0_t *chip = snd_pcm_substream_chip(substream); chip->ichd[ICHD_MDMIN].substream = NULL; return 0; } -static struct snd_pcm_ops snd_intel8x0m_playback_ops = { +static snd_pcm_ops_t snd_intel8x0m_playback_ops = { .open = snd_intel8x0m_playback_open, .close = snd_intel8x0m_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -711,7 +703,7 @@ static struct snd_pcm_ops snd_intel8x0m_playback_ops = { .pointer = snd_intel8x0_pcm_pointer, }; -static struct snd_pcm_ops snd_intel8x0m_capture_ops = { +static snd_pcm_ops_t snd_intel8x0m_capture_ops = { .open = snd_intel8x0m_capture_open, .close = snd_intel8x0m_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -725,17 +717,16 @@ static struct snd_pcm_ops snd_intel8x0m_capture_ops = { struct ich_pcm_table { char *suffix; - struct snd_pcm_ops *playback_ops; - struct snd_pcm_ops *capture_ops; + snd_pcm_ops_t *playback_ops; + snd_pcm_ops_t *capture_ops; size_t prealloc_size; size_t prealloc_max_size; int ac97_idx; }; -static int __devinit snd_intel8x0_pcm1(struct intel8x0m *chip, int device, - struct ich_pcm_table *rec) +static int __devinit snd_intel8x0_pcm1(intel8x0_t *chip, int device, struct ich_pcm_table *rec) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; char name[32]; @@ -781,7 +772,7 @@ static struct ich_pcm_table intel_pcms[] __devinitdata = { }, }; -static int __devinit snd_intel8x0_pcm(struct intel8x0m *chip) +static int __devinit snd_intel8x0_pcm(intel8x0_t *chip) { int i, tblsize, device, err; struct ich_pcm_table *tbl, *rec; @@ -828,27 +819,27 @@ static int __devinit snd_intel8x0_pcm(struct intel8x0m *chip) * Mixer part */ -static void snd_intel8x0_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_intel8x0_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct intel8x0m *chip = bus->private_data; + intel8x0_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_intel8x0_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_intel8x0_mixer_free_ac97(ac97_t *ac97) { - struct intel8x0m *chip = ac97->private_data; + intel8x0_t *chip = ac97->private_data; chip->ac97 = NULL; } -static int __devinit snd_intel8x0_mixer(struct intel8x0m *chip, int ac97_clock) +static int __devinit snd_intel8x0_mixer(intel8x0_t *chip, int ac97_clock) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; - struct snd_ac97 *x97; + ac97_bus_t *pbus; + ac97_template_t ac97; + ac97_t *x97; int err; unsigned int glob_sta = 0; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_intel8x0_codec_write, .read = snd_intel8x0_codec_read, }; @@ -889,8 +880,7 @@ static int __devinit snd_intel8x0_mixer(struct intel8x0m *chip, int ac97_clock) __err: /* clear the cold-reset bit for the next chance */ if (chip->device_type != DEVICE_ALI) - iputdword(chip, ICHREG(GLOB_CNT), - igetdword(chip, ICHREG(GLOB_CNT)) & ~ICH_AC97COLD); + iputdword(chip, ICHREG(GLOB_CNT), igetdword(chip, ICHREG(GLOB_CNT)) & ~ICH_AC97COLD); return err; } @@ -899,7 +889,11 @@ static int __devinit snd_intel8x0_mixer(struct intel8x0m *chip, int ac97_clock) * */ -static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing) +#define do_delay(chip) do {\ + schedule_timeout_uninterruptible(1);\ +} while (0) + +static int snd_intel8x0m_ich_chip_init(intel8x0_t *chip, int probing) { unsigned long end_time; unsigned int cnt, status, nstatus; @@ -920,10 +914,9 @@ static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing) do { if ((igetdword(chip, ICHREG(GLOB_CNT)) & ICH_AC97WARM) == 0) goto __ok; - schedule_timeout_uninterruptible(1); + do_delay(chip); } while (time_after_eq(end_time, jiffies)); - snd_printk(KERN_ERR "AC'97 warm reset still in progress? [0x%x]\n", - igetdword(chip, ICHREG(GLOB_CNT))); + snd_printk(KERN_ERR "AC'97 warm reset still in progress? [0x%x]\n", igetdword(chip, ICHREG(GLOB_CNT))); return -EIO; __ok: @@ -934,16 +927,14 @@ static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing) */ end_time = jiffies + HZ; do { - status = igetdword(chip, ICHREG(GLOB_STA)) & - (ICH_PCR | ICH_SCR | ICH_TCR); + status = igetdword(chip, ICHREG(GLOB_STA)) & (ICH_PCR | ICH_SCR | ICH_TCR); if (status) break; - schedule_timeout_uninterruptible(1); + do_delay(chip); } while (time_after_eq(end_time, jiffies)); if (! status) { /* no codec is found */ - snd_printk(KERN_ERR "codec_ready: codec is not ready [0x%x]\n", - igetdword(chip, ICHREG(GLOB_STA))); + snd_printk(KERN_ERR "codec_ready: codec is not ready [0x%x]\n", igetdword(chip, ICHREG(GLOB_STA))); return -EIO; } @@ -953,7 +944,7 @@ static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing) /* wait for other codecs ready status. */ end_time = jiffies + HZ / 4; while (status != nstatus && time_after_eq(end_time, jiffies)) { - schedule_timeout_uninterruptible(1); + do_delay(chip); status |= igetdword(chip, ICHREG(GLOB_STA)) & nstatus; } @@ -965,11 +956,10 @@ static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing) /* wait until all the probed codecs are ready */ end_time = jiffies + HZ; do { - nstatus = igetdword(chip, ICHREG(GLOB_STA)) & - (ICH_PCR | ICH_SCR | ICH_TCR); + nstatus = igetdword(chip, ICHREG(GLOB_STA)) & (ICH_PCR | ICH_SCR | ICH_TCR); if (status == nstatus) break; - schedule_timeout_uninterruptible(1); + do_delay(chip); } while (time_after_eq(end_time, jiffies)); } @@ -981,7 +971,7 @@ static int snd_intel8x0m_ich_chip_init(struct intel8x0m *chip, int probing) return 0; } -static int snd_intel8x0_chip_init(struct intel8x0m *chip, int probing) +static int snd_intel8x0_chip_init(intel8x0_t *chip, int probing) { unsigned int i; int err; @@ -1002,7 +992,7 @@ static int snd_intel8x0_chip_init(struct intel8x0m *chip, int probing) return 0; } -static int snd_intel8x0_free(struct intel8x0m *chip) +static int snd_intel8x0_free(intel8x0_t *chip) { unsigned int i; @@ -1024,7 +1014,7 @@ static int snd_intel8x0_free(struct intel8x0m *chip) if (chip->remap_bmaddr) iounmap(chip->remap_bmaddr); if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); pci_release_regions(chip->pci); pci_disable_device(chip->pci); kfree(chip); @@ -1035,50 +1025,43 @@ static int snd_intel8x0_free(struct intel8x0m *chip) /* * power management */ -static int intel8x0m_suspend(struct pci_dev *pci, pm_message_t state) +static int intel8x0m_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct intel8x0m *chip = card->private_data; + intel8x0_t *chip = card->pm_private_data; int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < chip->pcm_devs; i++) snd_pcm_suspend_all(chip->pcm[i]); - snd_ac97_suspend(chip->ac97); - pci_disable_device(pci); - pci_save_state(pci); + if (chip->ac97) + snd_ac97_suspend(chip->ac97); + pci_disable_device(chip->pci); return 0; } -static int intel8x0m_resume(struct pci_dev *pci) +static int intel8x0m_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct intel8x0m *chip = card->private_data; - - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); + intel8x0_t *chip = card->pm_private_data; + pci_enable_device(chip->pci); + pci_set_master(chip->pci); snd_intel8x0_chip_init(chip, 0); - snd_ac97_resume(chip->ac97); + if (chip->ac97) + snd_ac97_resume(chip->ac97); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -#ifdef CONFIG_PROC_FS -static void snd_intel8x0m_proc_read(struct snd_info_entry * entry, - struct snd_info_buffer *buffer) +static void snd_intel8x0m_proc_read(snd_info_entry_t * entry, + snd_info_buffer_t * buffer) { - struct intel8x0m *chip = entry->private_data; + intel8x0_t *chip = entry->private_data; unsigned int tmp; snd_iprintf(buffer, "Intel8x0m\n\n"); if (chip->device_type == DEVICE_ALI) return; tmp = igetdword(chip, ICHREG(GLOB_STA)); - snd_iprintf(buffer, "Global control : 0x%08x\n", - igetdword(chip, ICHREG(GLOB_CNT))); + snd_iprintf(buffer, "Global control : 0x%08x\n", igetdword(chip, ICHREG(GLOB_CNT))); snd_iprintf(buffer, "Global status : 0x%08x\n", tmp); snd_iprintf(buffer, "AC'97 codecs ready :%s%s%s%s\n", tmp & ICH_PCR ? " primary" : "", @@ -1087,21 +1070,17 @@ static void snd_intel8x0m_proc_read(struct snd_info_entry * entry, (tmp & (ICH_PCR | ICH_SCR | ICH_TCR)) == 0 ? " none" : ""); } -static void __devinit snd_intel8x0m_proc_init(struct intel8x0m * chip) +static void __devinit snd_intel8x0m_proc_init(intel8x0_t * chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "intel8x0m", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_intel8x0m_proc_read); } -#else /* !CONFIG_PROC_FS */ -#define snd_intel8x0m_proc_init(chip) -#endif /* CONFIG_PROC_FS */ - -static int snd_intel8x0_dev_free(struct snd_device *device) +static int snd_intel8x0_dev_free(snd_device_t *device) { - struct intel8x0m *chip = device->device_data; + intel8x0_t *chip = device->device_data; return snd_intel8x0_free(chip); } @@ -1110,17 +1089,17 @@ struct ich_reg_info { unsigned int offset; }; -static int __devinit snd_intel8x0m_create(struct snd_card *card, +static int __devinit snd_intel8x0m_create(snd_card_t * card, struct pci_dev *pci, unsigned long device_type, - struct intel8x0m ** r_intel8x0) + intel8x0_t ** r_intel8x0) { - struct intel8x0m *chip; + intel8x0_t *chip; int err; unsigned int i; unsigned int int_sta_masks; - struct ichdev *ichdev; - static struct snd_device_ops ops = { + ichdev_t *ichdev; + static snd_device_ops_t ops = { .dev_free = snd_intel8x0_dev_free, }; static struct ich_reg_info intel_regs[2] = { @@ -1185,8 +1164,7 @@ static int __devinit snd_intel8x0m_create(struct snd_card *card, } port_inited: - if (request_irq(pci->irq, snd_intel8x0_interrupt, SA_INTERRUPT|SA_SHIRQ, - card->shortname, chip)) { + if (request_irq(pci->irq, snd_intel8x0_interrupt, SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_intel8x0_free(chip); return -EBUSY; @@ -1243,6 +1221,8 @@ static int __devinit snd_intel8x0m_create(struct snd_card *card, return err; } + snd_card_set_pm_callback(card, intel8x0m_suspend, intel8x0m_resume, chip); + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { snd_intel8x0_free(chip); return err; @@ -1283,8 +1263,8 @@ static struct shortname_table { static int __devinit snd_intel8x0m_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct intel8x0m *chip; + snd_card_t *card; + intel8x0_t *chip; int err; struct shortname_table *name; @@ -1306,7 +1286,6 @@ static int __devinit snd_intel8x0m_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = chip; if ((err = snd_intel8x0_mixer(chip, ac97_clock)) < 0) { snd_card_free(card); @@ -1341,10 +1320,7 @@ static struct pci_driver driver = { .id_table = snd_intel8x0m_ids, .probe = snd_intel8x0m_probe, .remove = __devexit_p(snd_intel8x0m_remove), -#ifdef CONFIG_PM - .suspend = intel8x0m_suspend, - .resume = intel8x0m_resume, -#endif + SND_PCI_PM_CALLBACKS }; diff --git a/trunk/sound/pci/korg1212/korg1212.c b/trunk/sound/pci/korg1212/korg1212.c index 4eddb512c12f..a110d664f626 100644 --- a/trunk/sound/pci/korg1212/korg1212.c +++ b/trunk/sound/pci/korg1212/korg1212.c @@ -41,16 +41,8 @@ // Debug Stuff // ---------------------------------------------------------------------------- #define K1212_DEBUG_LEVEL 0 -#if K1212_DEBUG_LEVEL > 0 -#define K1212_DEBUG_PRINTK(fmt,args...) printk(KERN_DEBUG fmt,##args) -#else -#define K1212_DEBUG_PRINTK(fmt,...) -#endif -#if K1212_DEBUG_LEVEL > 1 -#define K1212_DEBUG_PRINTK_VERBOSE(fmt,args...) printk(KERN_DEBUG fmt,##args) -#else -#define K1212_DEBUG_PRINTK_VERBOSE(fmt,...) -#endif +#define K1212_DEBUG_PRINTK printk +//#define K1212_DEBUG_PRINTK(x...) printk("<0>" x) // ---------------------------------------------------------------------------- // Record/Play Buffer Allocation Method. If K1212_LARGEALLOC is defined all @@ -61,7 +53,7 @@ // ---------------------------------------------------------------------------- // Valid states of the Korg 1212 I/O card. // ---------------------------------------------------------------------------- -enum CardState { +typedef enum { K1212_STATE_NONEXISTENT, // there is no card here K1212_STATE_UNINITIALIZED, // the card is awaiting DSP download K1212_STATE_DSP_IN_PROCESS, // the card is currently downloading its DSP code @@ -77,13 +69,13 @@ enum CardState { K1212_STATE_ERRORSTOP, // the card has stopped itself because of an error and we // are in the process of cleaning things up. K1212_STATE_MAX_STATE // state values of this and beyond are invalid -}; +} CardState; // ---------------------------------------------------------------------------- // The following enumeration defines the constants written to the card's // host-to-card doorbell to initiate a command. // ---------------------------------------------------------------------------- -enum korg1212_dbcnst { +typedef enum { K1212_DB_RequestForData = 0, // sent by the card to request a buffer fill. K1212_DB_TriggerPlay = 1, // starts playback/record on the card. K1212_DB_SelectPlayMode = 2, // select monitor, playback setup, or stop. @@ -101,14 +93,14 @@ enum korg1212_dbcnst { K1212_DB_DSPDownloadDone = 0xAE, // sent by the card to indicate the download has // completed. K1212_DB_StartDSPDownload = 0xAF // tells the card to download its DSP firmware. -}; +} korg1212_dbcnst_t; // ---------------------------------------------------------------------------- // The following enumeration defines return codes // to the Korg 1212 I/O driver. // ---------------------------------------------------------------------------- -enum snd_korg1212rc { +typedef enum { K1212_CMDRET_Success = 0, // command was successfully placed K1212_CMDRET_DIOCFailure, // the DeviceIoControl call failed K1212_CMDRET_PMFailure, // the protected mode call failed @@ -126,27 +118,27 @@ enum snd_korg1212rc { K1212_CMDRET_BadDevice, // the specified wave device was out of range K1212_CMDRET_BadFormat // the specified wave format is unsupported -}; +} snd_korg1212rc; // ---------------------------------------------------------------------------- // The following enumeration defines the constants used to select the play // mode for the card in the SelectPlayMode command. // ---------------------------------------------------------------------------- -enum PlayModeSelector { +typedef enum { K1212_MODE_SetupPlay = 0x00000001, // provides card with pre-play information K1212_MODE_MonitorOn = 0x00000002, // tells card to turn on monitor mode K1212_MODE_MonitorOff = 0x00000004, // tells card to turn off monitor mode K1212_MODE_StopPlay = 0x00000008 // stops playback on the card -}; +} PlayModeSelector; // ---------------------------------------------------------------------------- // The following enumeration defines the constants used to select the monitor // mode for the card in the SetMonitorMode command. // ---------------------------------------------------------------------------- -enum MonitorModeSelector { +typedef enum { K1212_MONMODE_Off = 0, // tells card to turn off monitor mode K1212_MONMODE_On // tells card to turn on monitor mode -}; +} MonitorModeSelector; #define MAILBOX0_OFFSET 0x40 // location of mailbox 0 relative to base address #define MAILBOX1_OFFSET 0x44 // location of mailbox 1 relative to base address @@ -188,7 +180,7 @@ enum MonitorModeSelector { #define K1212_CHANNELS (K1212_ADAT_CHANNELS + K1212_ANALOG_CHANNELS) #define K1212_MIN_CHANNELS 1 #define K1212_MAX_CHANNELS K1212_CHANNELS -#define K1212_FRAME_SIZE (sizeof(struct KorgAudioFrame)) +#define K1212_FRAME_SIZE (sizeof(KorgAudioFrame)) #define K1212_MAX_SAMPLES (kPlayBufferFrames*kNumBuffers) #define K1212_PERIODS (kNumBuffers) #define K1212_PERIOD_BYTES (K1212_FRAME_SIZE*kPlayBufferFrames) @@ -264,7 +256,14 @@ enum MonitorModeSelector { #include "korg1212-firmware.h" -enum ClockSourceIndex { +typedef struct _snd_korg1212 korg1212_t; + +typedef u16 K1212Sample; // channels 0-9 use 16 bit samples +typedef u32 K1212SpdifSample; // channels 10-11 use 32 bits - only 20 are sent + // across S/PDIF. +typedef u32 K1212TimeCodeSample; // holds the ADAT timecode value + +typedef enum { K1212_CLKIDX_AdatAt44_1K = 0, // selects source as ADAT at 44.1 kHz K1212_CLKIDX_AdatAt48K, // selects source as ADAT at 48 kHz K1212_CLKIDX_WordAt44_1K, // selects source as S/PDIF at 44.1 kHz @@ -272,36 +271,36 @@ enum ClockSourceIndex { K1212_CLKIDX_LocalAt44_1K, // selects source as local clock at 44.1 kHz K1212_CLKIDX_LocalAt48K, // selects source as local clock at 48 kHz K1212_CLKIDX_Invalid // used to check validity of the index -}; +} ClockSourceIndex; -enum ClockSourceType { +typedef enum { K1212_CLKIDX_Adat = 0, // selects source as ADAT K1212_CLKIDX_Word, // selects source as S/PDIF K1212_CLKIDX_Local // selects source as local clock -}; +} ClockSourceType; -struct KorgAudioFrame { - u16 frameData16[k16BitChannels]; /* channels 0-9 use 16 bit samples */ - u32 frameData32[k32BitChannels]; /* channels 10-11 use 32 bits - only 20 are sent across S/PDIF */ - u32 timeCodeVal; /* holds the ADAT timecode value */ -}; +typedef struct KorgAudioFrame { + K1212Sample frameData16[k16BitChannels]; + K1212SpdifSample frameData32[k32BitChannels]; + K1212TimeCodeSample timeCodeVal; +} KorgAudioFrame; -struct KorgAudioBuffer { - struct KorgAudioFrame bufferData[kPlayBufferFrames]; /* buffer definition */ -}; +typedef struct KorgAudioBuffer { + KorgAudioFrame bufferData[kPlayBufferFrames]; /* buffer definition */ +} KorgAudioBuffer; -struct KorgSharedBuffer { +typedef struct KorgSharedBuffer { #ifdef K1212_LARGEALLOC - struct KorgAudioBuffer playDataBufs[kNumBuffers]; - struct KorgAudioBuffer recordDataBufs[kNumBuffers]; + KorgAudioBuffer playDataBufs[kNumBuffers]; + KorgAudioBuffer recordDataBufs[kNumBuffers]; #endif short volumeData[kAudioChannels]; u32 cardCommand; u16 routeData [kAudioChannels]; u32 AdatTimeCode; // ADAT timecode value -}; +} KorgSharedBuffer; -struct SensBits { +typedef struct SensBits { union { struct { unsigned int leftChanVal:8; @@ -316,12 +315,12 @@ struct SensBits { } v; u16 rightSensBits; } r; -}; +} SensBits; -struct snd_korg1212 { - struct snd_card *card; +struct _snd_korg1212 { + snd_card_t *card; struct pci_dev *pci; - struct snd_pcm *pcm; + snd_pcm_t *pcm; int irq; spinlock_t lock; @@ -348,10 +347,10 @@ struct snd_korg1212 { u32 DataBufsSize; - struct KorgAudioBuffer * playDataBufsPtr; - struct KorgAudioBuffer * recordDataBufsPtr; + KorgAudioBuffer * playDataBufsPtr; + KorgAudioBuffer * recordDataBufsPtr; - struct KorgSharedBuffer * sharedBufferPtr; + KorgSharedBuffer * sharedBufferPtr; u32 RecDataPhy; u32 PlayDataPhy; @@ -375,20 +374,20 @@ struct snd_korg1212 { int channels; int currentBuffer; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; pid_t capture_pid; pid_t playback_pid; - enum CardState cardState; + CardState cardState; int running; int idleMonitorOn; // indicates whether the card is in idle monitor mode. u32 cmdRetryCount; // tracks how many times we have retried sending to the card. - enum ClockSourceIndex clkSrcRate; // sample rate and clock source + ClockSourceIndex clkSrcRate; // sample rate and clock source - enum ClockSourceType clkSource; // clock source + ClockSourceType clkSource; // clock source int clkRate; // clock rate int volumePhase[kAudioChannels]; @@ -433,58 +432,60 @@ static struct pci_device_id snd_korg1212_ids[] = { { 0, }, }; -MODULE_DEVICE_TABLE(pci, snd_korg1212_ids); - -static char *stateName[] = { - "Non-existent", - "Uninitialized", - "DSP download in process", - "DSP download complete", - "Ready", - "Open", - "Setup for play", - "Playing", - "Monitor mode on", - "Calibrating", - "Invalid" +static char* stateName[] = { + "Non-existent", + "Uninitialized", + "DSP download in process", + "DSP download complete", + "Ready", + "Open", + "Setup for play", + "Playing", + "Monitor mode on", + "Calibrating", + "Invalid" }; -static char *clockSourceTypeName[] = { "ADAT", "S/PDIF", "local" }; +static char* clockSourceTypeName[] = { "ADAT", "S/PDIF", "local" }; -static char *clockSourceName[] = { - "ADAT at 44.1 kHz", - "ADAT at 48 kHz", - "S/PDIF at 44.1 kHz", - "S/PDIF at 48 kHz", - "local clock at 44.1 kHz", - "local clock at 48 kHz" +static char* clockSourceName[] = { + "ADAT at 44.1 kHz", + "ADAT at 48 kHz", + "S/PDIF at 44.1 kHz", + "S/PDIF at 48 kHz", + "local clock at 44.1 kHz", + "local clock at 48 kHz" }; -static char *channelName[] = { - "ADAT-1", - "ADAT-2", - "ADAT-3", - "ADAT-4", - "ADAT-5", - "ADAT-6", - "ADAT-7", - "ADAT-8", - "Analog-L", - "Analog-R", - "SPDIF-L", - "SPDIF-R", +static char* channelName[] = { + "ADAT-1", + "ADAT-2", + "ADAT-3", + "ADAT-4", + "ADAT-5", + "ADAT-6", + "ADAT-7", + "ADAT-8", + "Analog-L", + "Analog-R", + "SPDIF-L", + "SPDIF-R", }; -static u16 ClockSourceSelector[] = { - 0x8000, // selects source as ADAT at 44.1 kHz - 0x0000, // selects source as ADAT at 48 kHz - 0x8001, // selects source as S/PDIF at 44.1 kHz - 0x0001, // selects source as S/PDIF at 48 kHz - 0x8002, // selects source as local clock at 44.1 kHz - 0x0002 // selects source as local clock at 48 kHz -}; +static u16 ClockSourceSelector[] = + {0x8000, // selects source as ADAT at 44.1 kHz + 0x0000, // selects source as ADAT at 48 kHz + 0x8001, // selects source as S/PDIF at 44.1 kHz + 0x0001, // selects source as S/PDIF at 48 kHz + 0x8002, // selects source as local clock at 44.1 kHz + 0x0002 // selects source as local clock at 48 kHz + }; + +static snd_korg1212rc rc; + +MODULE_DEVICE_TABLE(pci, snd_korg1212_ids); -union swap_u32 { unsigned char c[4]; u32 i; }; +typedef union swap_u32 { unsigned char c[4]; u32 i; } swap_u32; #ifdef SNDRV_BIG_ENDIAN static u32 LowerWordSwap(u32 swappee) @@ -492,7 +493,7 @@ static u32 LowerWordSwap(u32 swappee) static u32 UpperWordSwap(u32 swappee) #endif { - union swap_u32 retVal, swapper; + swap_u32 retVal, swapper; swapper.i = swappee; retVal.c[2] = swapper.c[3]; @@ -509,7 +510,7 @@ static u32 UpperWordSwap(u32 swappee) static u32 LowerWordSwap(u32 swappee) #endif { - union swap_u32 retVal, swapper; + swap_u32 retVal, swapper; swapper.i = swappee; retVal.c[2] = swapper.c[2]; @@ -520,27 +521,45 @@ static u32 LowerWordSwap(u32 swappee) return retVal.i; } +#if 0 /* not used */ + +static u32 EndianSwap(u32 swappee) +{ + swap_u32 retVal, swapper; + + swapper.i = swappee; + retVal.c[0] = swapper.c[3]; + retVal.c[1] = swapper.c[2]; + retVal.c[2] = swapper.c[1]; + retVal.c[3] = swapper.c[0]; + + return retVal.i; +} + +#endif /* not used */ + #define SetBitInWord(theWord,bitPosition) (*theWord) |= (0x0001 << bitPosition) #define SetBitInDWord(theWord,bitPosition) (*theWord) |= (0x00000001 << bitPosition) #define ClearBitInWord(theWord,bitPosition) (*theWord) &= ~(0x0001 << bitPosition) #define ClearBitInDWord(theWord,bitPosition) (*theWord) &= ~(0x00000001 << bitPosition) -static int snd_korg1212_Send1212Command(struct snd_korg1212 *korg1212, - enum korg1212_dbcnst doorbellVal, - u32 mailBox0Val, u32 mailBox1Val, - u32 mailBox2Val, u32 mailBox3Val) +static snd_korg1212rc snd_korg1212_Send1212Command(korg1212_t *korg1212, korg1212_dbcnst_t doorbellVal, + u32 mailBox0Val, u32 mailBox1Val, u32 mailBox2Val, u32 mailBox3Val) { u32 retryCount; u16 mailBox3Lo; - int rc = K1212_CMDRET_Success; + snd_korg1212rc rc = K1212_CMDRET_Success; if (!korg1212->outDoorbellPtr) { - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: CardUninitialized\n"); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: CardUninitialized\n"); +#endif return K1212_CMDRET_CardUninitialized; } - K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n", - doorbellVal, mailBox0Val, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n", doorbellVal, mailBox0Val, stateName[korg1212->cardState]); +#endif for (retryCount = 0; retryCount < MAX_COMMAND_RETRIES; retryCount++) { writel(mailBox3Val, korg1212->mailbox3Ptr); writel(mailBox2Val, korg1212->mailbox2Ptr); @@ -567,7 +586,9 @@ static int snd_korg1212_Send1212Command(struct snd_korg1212 *korg1212, mailBox3Lo = readl(korg1212->mailbox3Ptr); if (mailBox3Lo & COMMAND_ACK_MASK) { if ((mailBox3Lo & DOORBELL_VAL_MASK) == (doorbellVal & DOORBELL_VAL_MASK)) { - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- Success\n"); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- Success\n"); +#endif rc = K1212_CMDRET_Success; break; } @@ -576,7 +597,9 @@ static int snd_korg1212_Send1212Command(struct snd_korg1212 *korg1212, korg1212->cmdRetryCount += retryCount; if (retryCount >= MAX_COMMAND_RETRIES) { - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Card <- NoAckFromCard\n"); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- NoAckFromCard\n"); +#endif rc = K1212_CMDRET_NoAckFromCard; } @@ -584,7 +607,7 @@ static int snd_korg1212_Send1212Command(struct snd_korg1212 *korg1212, } /* spinlock already held */ -static void snd_korg1212_SendStop(struct snd_korg1212 *korg1212) +static void snd_korg1212_SendStop(korg1212_t *korg1212) { if (! korg1212->stop_pending_cnt) { korg1212->sharedBufferPtr->cardCommand = 0xffffffff; @@ -595,7 +618,7 @@ static void snd_korg1212_SendStop(struct snd_korg1212 *korg1212) } } -static void snd_korg1212_SendStopAndWait(struct snd_korg1212 *korg1212) +static void snd_korg1212_SendStopAndWait(korg1212_t *korg1212) { unsigned long flags; spin_lock_irqsave(&korg1212->lock, flags); @@ -608,17 +631,17 @@ static void snd_korg1212_SendStopAndWait(struct snd_korg1212 *korg1212) /* timer callback for checking the ack of stop request */ static void snd_korg1212_timer_func(unsigned long data) { - struct snd_korg1212 *korg1212 = (struct snd_korg1212 *) data; - unsigned long flags; + korg1212_t *korg1212 = (korg1212_t *) data; - spin_lock_irqsave(&korg1212->lock, flags); + spin_lock(&korg1212->lock); if (korg1212->sharedBufferPtr->cardCommand == 0) { /* ack'ed */ korg1212->stop_pending_cnt = 0; korg1212->dsp_stop_is_processed = 1; wake_up(&korg1212->wait); - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: Stop ack'ed [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: Stop ack'ed [%s]\n", stateName[korg1212->cardState]); +#endif } else { if (--korg1212->stop_pending_cnt > 0) { /* reprogram timer */ @@ -629,17 +652,17 @@ static void snd_korg1212_timer_func(unsigned long data) korg1212->sharedBufferPtr->cardCommand = 0; korg1212->dsp_stop_is_processed = 1; wake_up(&korg1212->wait); - K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n", stateName[korg1212->cardState]); +#endif } } - spin_unlock_irqrestore(&korg1212->lock, flags); + spin_unlock(&korg1212->lock); } -static int snd_korg1212_TurnOnIdleMonitor(struct snd_korg1212 *korg1212) +static void snd_korg1212_TurnOnIdleMonitor(korg1212_t *korg1212) { unsigned long flags; - int rc; udelay(INTERCOMMAND_DELAY); spin_lock_irqsave(&korg1212->lock, flags); @@ -647,10 +670,9 @@ static int snd_korg1212_TurnOnIdleMonitor(struct snd_korg1212 *korg1212) rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, K1212_MODE_MonitorOn, 0, 0, 0); spin_unlock_irqrestore(&korg1212->lock, flags); - return rc; } -static void snd_korg1212_TurnOffIdleMonitor(struct snd_korg1212 *korg1212) +static void snd_korg1212_TurnOffIdleMonitor(korg1212_t *korg1212) { if (korg1212->idleMonitorOn) { snd_korg1212_SendStopAndWait(korg1212); @@ -658,15 +680,16 @@ static void snd_korg1212_TurnOffIdleMonitor(struct snd_korg1212 *korg1212) } } -static inline void snd_korg1212_setCardState(struct snd_korg1212 * korg1212, enum CardState csState) +static inline void snd_korg1212_setCardState(korg1212_t * korg1212, CardState csState) { korg1212->cardState = csState; } -static int snd_korg1212_OpenCard(struct snd_korg1212 * korg1212) +static int snd_korg1212_OpenCard(korg1212_t * korg1212) { - K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n", - stateName[korg1212->cardState], korg1212->opencnt); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt); +#endif down(&korg1212->open_mutex); if (korg1212->opencnt++ == 0) { snd_korg1212_TurnOffIdleMonitor(korg1212); @@ -677,10 +700,11 @@ static int snd_korg1212_OpenCard(struct snd_korg1212 * korg1212) return 1; } -static int snd_korg1212_CloseCard(struct snd_korg1212 * korg1212) +static int snd_korg1212_CloseCard(korg1212_t * korg1212) { - K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n", - stateName[korg1212->cardState], korg1212->opencnt); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt); +#endif down(&korg1212->open_mutex); if (--(korg1212->opencnt)) { @@ -689,11 +713,12 @@ static int snd_korg1212_CloseCard(struct snd_korg1212 * korg1212) } if (korg1212->cardState == K1212_STATE_SETUP) { - int rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, + rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, K1212_MODE_StopPlay, 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif + if (rc != K1212_CMDRET_Success) { up(&korg1212->open_mutex); return 0; @@ -712,12 +737,11 @@ static int snd_korg1212_CloseCard(struct snd_korg1212 * korg1212) } /* spinlock already held */ -static int snd_korg1212_SetupForPlay(struct snd_korg1212 * korg1212) +static int snd_korg1212_SetupForPlay(korg1212_t * korg1212) { - int rc; - - K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n", - stateName[korg1212->cardState], korg1212->setcnt); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->setcnt); +#endif if (korg1212->setcnt++) return 0; @@ -725,9 +749,10 @@ static int snd_korg1212_SetupForPlay(struct snd_korg1212 * korg1212) snd_korg1212_setCardState(korg1212, K1212_STATE_SETUP); rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, K1212_MODE_SetupPlay, 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); + +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif if (rc != K1212_CMDRET_Success) { return 1; } @@ -735,21 +760,22 @@ static int snd_korg1212_SetupForPlay(struct snd_korg1212 * korg1212) } /* spinlock already held */ -static int snd_korg1212_TriggerPlay(struct snd_korg1212 * korg1212) +static int snd_korg1212_TriggerPlay(korg1212_t * korg1212) { - int rc; - - K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n", - stateName[korg1212->cardState], korg1212->playcnt); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt); +#endif if (korg1212->playcnt++) return 0; snd_korg1212_setCardState(korg1212, K1212_STATE_PLAYING); rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_TriggerPlay, 0, 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); + +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif + if (rc != K1212_CMDRET_Success) { return 1; } @@ -757,10 +783,11 @@ static int snd_korg1212_TriggerPlay(struct snd_korg1212 * korg1212) } /* spinlock already held */ -static int snd_korg1212_StopPlay(struct snd_korg1212 * korg1212) +static int snd_korg1212_StopPlay(korg1212_t * korg1212) { - K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n", - stateName[korg1212->cardState], korg1212->playcnt); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt); +#endif if (--(korg1212->playcnt)) return 0; @@ -774,7 +801,7 @@ static int snd_korg1212_StopPlay(struct snd_korg1212 * korg1212) return 0; } -static void snd_korg1212_EnableCardInterrupts(struct snd_korg1212 * korg1212) +static void snd_korg1212_EnableCardInterrupts(korg1212_t * korg1212) { writel(PCI_INT_ENABLE_BIT | PCI_DOORBELL_INT_ENABLE_BIT | @@ -786,37 +813,37 @@ static void snd_korg1212_EnableCardInterrupts(struct snd_korg1212 * korg1212) #if 0 /* not used */ -static int snd_korg1212_SetMonitorMode(struct snd_korg1212 *korg1212, - enum MonitorModeSelector mode) +static int snd_korg1212_SetMonitorMode(korg1212_t *korg1212, MonitorModeSelector mode) { - K1212_DEBUG_PRINTK("K1212_DEBUG: SetMonitorMode [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: SetMonitorMode [%s]\n", stateName[korg1212->cardState]); +#endif switch (mode) { - case K1212_MONMODE_Off: - if (korg1212->cardState != K1212_STATE_MONITOR) - return 0; - else { - snd_korg1212_SendStopAndWait(korg1212); - snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN); - } - break; - - case K1212_MONMODE_On: - if (korg1212->cardState != K1212_STATE_OPEN) - return 0; - else { - int rc; - snd_korg1212_setCardState(korg1212, K1212_STATE_MONITOR); - rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, - K1212_MODE_MonitorOn, 0, 0, 0); - if (rc != K1212_CMDRET_Success) - return 0; - } - break; + case K1212_MONMODE_Off: + if (korg1212->cardState != K1212_STATE_MONITOR) { + return 0; + } else { + snd_korg1212_SendStopAndWait(korg1212); + snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN); + } + break; - default: - return 0; + case K1212_MONMODE_On: + if (korg1212->cardState != K1212_STATE_OPEN) { + return 0; + } else { + snd_korg1212_setCardState(korg1212, K1212_STATE_MONITOR); + rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, + K1212_MODE_MonitorOn, 0, 0, 0); + if (rc != K1212_CMDRET_Success) { + return 0; + } + } + break; + + default: + return 0; } return 1; @@ -824,44 +851,44 @@ static int snd_korg1212_SetMonitorMode(struct snd_korg1212 *korg1212, #endif /* not used */ -static inline int snd_korg1212_use_is_exclusive(struct snd_korg1212 *korg1212) +static inline int snd_korg1212_use_is_exclusive(korg1212_t *korg1212) { - if (korg1212->playback_pid != korg1212->capture_pid && - korg1212->playback_pid >= 0 && korg1212->capture_pid >= 0) - return 0; + int ret = 1; - return 1; + if ((korg1212->playback_pid != korg1212->capture_pid) && + (korg1212->playback_pid >= 0) && (korg1212->capture_pid >= 0)) { + ret = 0; + } + return ret; } -static int snd_korg1212_SetRate(struct snd_korg1212 *korg1212, int rate) +static int snd_korg1212_SetRate(korg1212_t *korg1212, int rate) { - static enum ClockSourceIndex s44[] = { - K1212_CLKIDX_AdatAt44_1K, - K1212_CLKIDX_WordAt44_1K, - K1212_CLKIDX_LocalAt44_1K - }; - static enum ClockSourceIndex s48[] = { - K1212_CLKIDX_AdatAt48K, - K1212_CLKIDX_WordAt48K, - K1212_CLKIDX_LocalAt48K - }; - int parm, rc; + static ClockSourceIndex s44[] = { K1212_CLKIDX_AdatAt44_1K, + K1212_CLKIDX_WordAt44_1K, + K1212_CLKIDX_LocalAt44_1K }; + static ClockSourceIndex s48[] = { + K1212_CLKIDX_AdatAt48K, + K1212_CLKIDX_WordAt48K, + K1212_CLKIDX_LocalAt48K }; + int parm; - if (!snd_korg1212_use_is_exclusive (korg1212)) - return -EBUSY; + if (!snd_korg1212_use_is_exclusive (korg1212)) { + return -EBUSY; + } - switch (rate) { - case 44100: - parm = s44[korg1212->clkSource]; - break; + switch(rate) { + case 44100: + parm = s44[korg1212->clkSource]; + break; - case 48000: - parm = s48[korg1212->clkSource]; - break; + case 48000: + parm = s48[korg1212->clkSource]; + break; - default: - return -EINVAL; - } + default: + return -EINVAL; + } korg1212->clkSrcRate = parm; korg1212->clkRate = rate; @@ -870,18 +897,19 @@ static int snd_korg1212_SetRate(struct snd_korg1212 *korg1212, int rate) rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate, ClockSourceSelector[korg1212->clkSrcRate], 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); + +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif return 0; } -static int snd_korg1212_SetClockSource(struct snd_korg1212 *korg1212, int source) +static int snd_korg1212_SetClockSource(korg1212_t *korg1212, int source) { - if (source < 0 || source > 2) - return -EINVAL; + if (source<0 || source >2) + return -EINVAL; korg1212->clkSource = source; @@ -890,14 +918,14 @@ static int snd_korg1212_SetClockSource(struct snd_korg1212 *korg1212, int source return 0; } -static void snd_korg1212_DisableCardInterrupts(struct snd_korg1212 *korg1212) +static void snd_korg1212_DisableCardInterrupts(korg1212_t *korg1212) { writel(0, korg1212->statusRegPtr); } -static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212 *korg1212) +static int snd_korg1212_WriteADCSensitivity(korg1212_t *korg1212) { - struct SensBits sensVals; + SensBits sensVals; int bitPosition; int channel; int clkIs48K; @@ -907,8 +935,9 @@ static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212 *korg1212) u16 count; unsigned long flags; - K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity [%s]\n", stateName[korg1212->cardState]); +#endif // ---------------------------------------------------------------------------- // initialize things. The local init bit is always set when writing to the @@ -977,17 +1006,19 @@ static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212 *korg1212) udelay(LOADSHIFT_DELAY); for (bitPosition = 15; bitPosition >= 0; bitPosition--) { // for all the bits - if (channel == 0) { - if (sensVals.l.leftSensBits & (0x0001 << bitPosition)) + if (channel == 0) { + if (sensVals.l.leftSensBits & (0x0001 << bitPosition)) { SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set high - else - ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low - } else { - if (sensVals.r.rightSensBits & (0x0001 << bitPosition)) - SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set high - else - ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low - } + } else { + ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low + } + } else { + if (sensVals.r.rightSensBits & (0x0001 << bitPosition)) { + SetBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set high + } else { + ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS); // data bit set low + } + } ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS); writew(controlValue, korg1212->sensRegPtr); // clock goes low @@ -1028,11 +1059,12 @@ static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212 *korg1212) udelay(SENSCLKPULSE_WIDTH); if (monModeSet) { - int rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, + rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode, K1212_MODE_MonitorOn, 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: WriteADCSensivity - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif + } spin_unlock_irqrestore(&korg1212->lock, flags); @@ -1040,22 +1072,23 @@ static int snd_korg1212_WriteADCSensitivity(struct snd_korg1212 *korg1212) return 1; } -static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212 *korg1212) +static void snd_korg1212_OnDSPDownloadComplete(korg1212_t *korg1212) { - int channel, rc; + int channel; - K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is complete. [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is complete. [%s]\n", stateName[korg1212->cardState]); +#endif // ---------------------------------------------------- // tell the card to boot // ---------------------------------------------------- rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_BootFromDSPPage4, 0, 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Boot from Page 4 - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); - msleep(DSP_BOOT_DELAY_IN_MS); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Boot from Page 4 - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif + mdelay(DSP_BOOT_DELAY_IN_MS); // -------------------------------------------------------------------------------- // Let the card know where all the buffers are. @@ -1069,9 +1102,9 @@ static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212 *korg1212) 0 ); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Buffer Memory - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Buffer Memory - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif udelay(INTERCOMMAND_DELAY); @@ -1083,9 +1116,10 @@ static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212 *korg1212) 0 ); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Misc Memory - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Configure Misc Memory - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif + // -------------------------------------------------------------------------------- // Initialize the routing and volume tables, then update the card's state. @@ -1104,16 +1138,16 @@ static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212 *korg1212) rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate, ClockSourceSelector[korg1212->clkSrcRate], 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Set Clock Source Selector - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif - rc = snd_korg1212_TurnOnIdleMonitor(korg1212); + snd_korg1212_TurnOnIdleMonitor(korg1212); snd_korg1212_setCardState(korg1212, K1212_STATE_READY); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Set Monitor On - RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Set Monitor On - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE); } @@ -1121,7 +1155,7 @@ static void snd_korg1212_OnDSPDownloadComplete(struct snd_korg1212 *korg1212) static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs) { u32 doorbellValue; - struct snd_korg1212 *korg1212 = dev_id; + korg1212_t *korg1212 = dev_id; if(irq != korg1212->irq) return IRQ_NONE; @@ -1142,9 +1176,9 @@ static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs switch (doorbellValue) { case K1212_DB_DSPDownloadDone: - K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n", - korg1212->irqcount, doorbellValue, - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]); +#endif if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS) { korg1212->dsp_is_loaded = 1; wake_up(&korg1212->wait); @@ -1155,10 +1189,10 @@ static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs // an error occurred - stop the card // ------------------------------------------------------------------------ case K1212_DB_DMAERROR: - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DMAE count - %ld, %x, [%s].\n", - korg1212->irqcount, doorbellValue, - stateName[korg1212->cardState]); - snd_printk(KERN_ERR "korg1212: DMA Error\n"); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DMAE count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]); +#endif + snd_printk(KERN_ERR "korg1212: DMA Error\n"); korg1212->errorcnt++; korg1212->totalerrorcnt++; korg1212->sharedBufferPtr->cardCommand = 0; @@ -1170,16 +1204,17 @@ static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs // the semaphore in case someone is waiting for this. // ------------------------------------------------------------------------ case K1212_DB_CARDSTOPPED: - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n", - korg1212->irqcount, doorbellValue, - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]); +#endif korg1212->sharedBufferPtr->cardCommand = 0; break; default: - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n", - korg1212->irqcount, doorbellValue, - korg1212->currentBuffer, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 3 + K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n", korg1212->irqcount, doorbellValue, + korg1212->currentBuffer, stateName[korg1212->cardState]); +#endif if ((korg1212->cardState > K1212_STATE_SETUP) || korg1212->idleMonitorOn) { korg1212->currentBuffer++; @@ -1211,18 +1246,19 @@ static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs return IRQ_HANDLED; } -static int snd_korg1212_downloadDSPCode(struct snd_korg1212 *korg1212) +static int snd_korg1212_downloadDSPCode(korg1212_t *korg1212) { - int rc; - K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is starting... [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: DSP download is starting... [%s]\n", stateName[korg1212->cardState]); +#endif // --------------------------------------------------------------- // verify the state of the card before proceeding. // --------------------------------------------------------------- - if (korg1212->cardState >= K1212_STATE_DSP_IN_PROCESS) + if (korg1212->cardState >= K1212_STATE_DSP_IN_PROCESS) { return 1; + } snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_IN_PROCESS); @@ -1231,9 +1267,10 @@ static int snd_korg1212_downloadDSPCode(struct snd_korg1212 *korg1212) rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_StartDSPDownload, UpperWordSwap(korg1212->dma_dsp.addr), 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n", - rc, stateName[korg1212->cardState]); + +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Start DSP Download RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif korg1212->dsp_is_loaded = 0; wait_event_timeout(korg1212->wait, korg1212->dsp_is_loaded, HZ * CARD_BOOT_TIMEOUT); @@ -1245,7 +1282,7 @@ static int snd_korg1212_downloadDSPCode(struct snd_korg1212 *korg1212) return 0; } -static struct snd_pcm_hardware snd_korg1212_playback_info = +static snd_pcm_hardware_t snd_korg1212_playback_info = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -1265,7 +1302,7 @@ static struct snd_pcm_hardware snd_korg1212_playback_info = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_korg1212_capture_info = +static snd_pcm_hardware_t snd_korg1212_capture_info = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -1285,21 +1322,21 @@ static struct snd_pcm_hardware snd_korg1212_capture_info = .fifo_size = 0, }; -static int snd_korg1212_silence(struct snd_korg1212 *korg1212, int pos, int count, int offset, int size) +static int snd_korg1212_silence(korg1212_t *korg1212, int pos, int count, int offset, int size) { - struct KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos; + KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos; int i; - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n", - pos, offset, size, count); +#if K1212_DEBUG_LEVEL > 2 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n", pos, offset, size, count); +#endif snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL); for (i=0; i < count; i++) { #if K1212_DEBUG_LEVEL > 0 if ( (void *) dst < (void *) korg1212->playDataBufsPtr || (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) { - printk(KERN_DEBUG "K1212_DEBUG: snd_korg1212_silence KERNEL EFAULT dst=%p iter=%d\n", - dst, i); + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_silence KERNEL EFAULT dst=%p iter=%d\n", dst, i); return -EFAULT; } #endif @@ -1310,26 +1347,29 @@ static int snd_korg1212_silence(struct snd_korg1212 *korg1212, int pos, int coun return 0; } -static int snd_korg1212_copy_to(struct snd_korg1212 *korg1212, void __user *dst, int pos, int count, int offset, int size) +static int snd_korg1212_copy_to(korg1212_t *korg1212, void __user *dst, int pos, int count, int offset, int size) { - struct KorgAudioFrame * src = korg1212->recordDataBufsPtr[0].bufferData + pos; + KorgAudioFrame * src = korg1212->recordDataBufsPtr[0].bufferData + pos; int i, rc; - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_to pos=%d offset=%d size=%d\n", - pos, offset, size); +#if K1212_DEBUG_LEVEL > 2 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to pos=%d offset=%d size=%d\n", pos, offset, size); +#endif snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL); for (i=0; i < count; i++) { #if K1212_DEBUG_LEVEL > 0 if ( (void *) src < (void *) korg1212->recordDataBufsPtr || (void *) src > (void *) korg1212->recordDataBufsPtr[8].bufferData ) { - printk(KERN_DEBUG "K1212_DEBUG: snd_korg1212_copy_to KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i); + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i); return -EFAULT; } #endif rc = copy_to_user(dst + offset, src, size); if (rc) { +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i); +#endif return -EFAULT; } src++; @@ -1339,13 +1379,14 @@ static int snd_korg1212_copy_to(struct snd_korg1212 *korg1212, void __user *dst, return 0; } -static int snd_korg1212_copy_from(struct snd_korg1212 *korg1212, void __user *src, int pos, int count, int offset, int size) +static int snd_korg1212_copy_from(korg1212_t *korg1212, void __user *src, int pos, int count, int offset, int size) { - struct KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos; + KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos; int i, rc; - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_copy_from pos=%d offset=%d size=%d count=%d\n", - pos, offset, size, count); +#if K1212_DEBUG_LEVEL > 2 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from pos=%d offset=%d size=%d count=%d\n", pos, offset, size, count); +#endif snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL); @@ -1353,13 +1394,15 @@ static int snd_korg1212_copy_from(struct snd_korg1212 *korg1212, void __user *sr #if K1212_DEBUG_LEVEL > 0 if ( (void *) dst < (void *) korg1212->playDataBufsPtr || (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) { - printk(KERN_DEBUG "K1212_DEBUG: snd_korg1212_copy_from KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i); + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i); return -EFAULT; } #endif rc = copy_from_user((void*) dst + offset, src, size); if (rc) { +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i); +#endif return -EFAULT; } dst++; @@ -1369,24 +1412,26 @@ static int snd_korg1212_copy_from(struct snd_korg1212 *korg1212, void __user *sr return 0; } -static void snd_korg1212_free_pcm(struct snd_pcm *pcm) +static void snd_korg1212_free_pcm(snd_pcm_t *pcm) { - struct snd_korg1212 *korg1212 = pcm->private_data; + korg1212_t *korg1212 = (korg1212_t *) pcm->private_data; - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_free_pcm [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_free_pcm [%s]\n", stateName[korg1212->cardState]); +#endif korg1212->pcm = NULL; } -static int snd_korg1212_playback_open(struct snd_pcm_substream *substream) +static int snd_korg1212_playback_open(snd_pcm_substream_t *substream) { unsigned long flags; - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_open [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_open [%s]\n", stateName[korg1212->cardState]); +#endif snd_pcm_set_sync(substream); // ??? @@ -1410,14 +1455,15 @@ static int snd_korg1212_playback_open(struct snd_pcm_substream *substream) } -static int snd_korg1212_capture_open(struct snd_pcm_substream *substream) +static int snd_korg1212_capture_open(snd_pcm_substream_t *substream) { unsigned long flags; - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_open [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_open [%s]\n", stateName[korg1212->cardState]); +#endif snd_pcm_set_sync(substream); @@ -1435,18 +1481,18 @@ static int snd_korg1212_capture_open(struct snd_pcm_substream *substream) spin_unlock_irqrestore(&korg1212->lock, flags); - snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, - kPlayBufferFrames, kPlayBufferFrames); + snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, kPlayBufferFrames, kPlayBufferFrames); return 0; } -static int snd_korg1212_playback_close(struct snd_pcm_substream *substream) +static int snd_korg1212_playback_close(snd_pcm_substream_t *substream) { unsigned long flags; - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_close [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_close [%s]\n", stateName[korg1212->cardState]); +#endif snd_korg1212_silence(korg1212, 0, K1212_MAX_SAMPLES, 0, korg1212->channels * 2); @@ -1462,13 +1508,14 @@ static int snd_korg1212_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_korg1212_capture_close(struct snd_pcm_substream *substream) +static int snd_korg1212_capture_close(snd_pcm_substream_t *substream) { unsigned long flags; - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_close [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_close [%s]\n", stateName[korg1212->cardState]); +#endif spin_lock_irqsave(&korg1212->lock, flags); @@ -1482,34 +1529,39 @@ static int snd_korg1212_capture_close(struct snd_pcm_substream *substream) return 0; } -static int snd_korg1212_ioctl(struct snd_pcm_substream *substream, +static int snd_korg1212_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg) { - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd); +#endif if (cmd == SNDRV_PCM_IOCTL1_CHANNEL_INFO ) { - struct snd_pcm_channel_info *info = arg; + snd_pcm_channel_info_t *info = arg; info->offset = 0; info->first = info->channel * 16; info->step = 256; +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: channel_info %d:, offset=%ld, first=%d, step=%d\n", info->channel, info->offset, info->first, info->step); +#endif return 0; } return snd_pcm_lib_ioctl(substream, cmd, arg); } -static int snd_korg1212_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +static int snd_korg1212_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { unsigned long flags; - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); int err; pid_t this_pid; pid_t other_pid; - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_hw_params [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_hw_params [%s]\n", stateName[korg1212->cardState]); +#endif spin_lock_irqsave(&korg1212->lock, flags); @@ -1551,20 +1603,22 @@ static int snd_korg1212_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_korg1212_prepare(struct snd_pcm_substream *substream) +static int snd_korg1212_prepare(snd_pcm_substream_t *substream) { - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); int rc; - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare [%s]\n", stateName[korg1212->cardState]); +#endif spin_lock_irq(&korg1212->lock); /* FIXME: we should wait for ack! */ if (korg1212->stop_pending_cnt > 0) { - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n", stateName[korg1212->cardState]); +#endif spin_unlock_irq(&korg1212->lock); return -EAGAIN; /* @@ -1583,21 +1637,24 @@ static int snd_korg1212_prepare(struct snd_pcm_substream *substream) return rc ? -EINVAL : 0; } -static int snd_korg1212_trigger(struct snd_pcm_substream *substream, +static int snd_korg1212_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); int rc; - K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger [%s] cmd=%d\n", - stateName[korg1212->cardState], cmd); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger [%s] cmd=%d\n", stateName[korg1212->cardState], cmd); +#endif spin_lock(&korg1212->lock); switch (cmd) { case SNDRV_PCM_TRIGGER_START: /* if (korg1212->running) { - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already running?\n"); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger: Already running?\n"); +#endif break; } */ @@ -1608,7 +1665,9 @@ static int snd_korg1212_trigger(struct snd_pcm_substream *substream, case SNDRV_PCM_TRIGGER_STOP: /* if (!korg1212->running) { - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n"); +#if K1212_DEBUG_LEVEL > 1 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n"); +#endif break; } */ @@ -1624,75 +1683,82 @@ static int snd_korg1212_trigger(struct snd_pcm_substream *substream, return rc ? -EINVAL : 0; } -static snd_pcm_uframes_t snd_korg1212_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_korg1212_playback_pointer(snd_pcm_substream_t *substream) { - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); snd_pcm_uframes_t pos; pos = korg1212->currentBuffer * kPlayBufferFrames; - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n", - stateName[korg1212->cardState], pos); +#if K1212_DEBUG_LEVEL > 2 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n", + stateName[korg1212->cardState], pos); +#endif return pos; } -static snd_pcm_uframes_t snd_korg1212_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_korg1212_capture_pointer(snd_pcm_substream_t *substream) { - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); snd_pcm_uframes_t pos; pos = korg1212->currentBuffer * kPlayBufferFrames; - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n", - stateName[korg1212->cardState], pos); +#if K1212_DEBUG_LEVEL > 2 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n", + stateName[korg1212->cardState], pos); +#endif return pos; } -static int snd_korg1212_playback_copy(struct snd_pcm_substream *substream, +static int snd_korg1212_playback_copy(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n", - stateName[korg1212->cardState], pos, count); +#if K1212_DEBUG_LEVEL > 2 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n", stateName[korg1212->cardState], pos, count); +#endif return snd_korg1212_copy_from(korg1212, src, pos, count, 0, korg1212->channels * 2); } -static int snd_korg1212_playback_silence(struct snd_pcm_substream *substream, +static int snd_korg1212_playback_silence(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n", - stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n", stateName[korg1212->cardState]); +#endif return snd_korg1212_silence(korg1212, pos, count, 0, korg1212->channels * 2); } -static int snd_korg1212_capture_copy(struct snd_pcm_substream *substream, +static int snd_korg1212_capture_copy(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct snd_korg1212 *korg1212 = snd_pcm_substream_chip(substream); + korg1212_t *korg1212 = snd_pcm_substream_chip(substream); - K1212_DEBUG_PRINTK_VERBOSE("K1212_DEBUG: snd_korg1212_capture_copy [%s] %ld %ld\n", - stateName[korg1212->cardState], pos, count); +#if K1212_DEBUG_LEVEL > 2 + K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_copy [%s] %ld %ld\n", stateName[korg1212->cardState], pos, count); +#endif return snd_korg1212_copy_to(korg1212, dst, pos, count, 0, korg1212->channels * 2); } -static struct snd_pcm_ops snd_korg1212_playback_ops = { +static snd_pcm_ops_t snd_korg1212_playback_ops = { .open = snd_korg1212_playback_open, .close = snd_korg1212_playback_close, .ioctl = snd_korg1212_ioctl, @@ -1704,7 +1770,7 @@ static struct snd_pcm_ops snd_korg1212_playback_ops = { .silence = snd_korg1212_playback_silence, }; -static struct snd_pcm_ops snd_korg1212_capture_ops = { +static snd_pcm_ops_t snd_korg1212_capture_ops = { .open = snd_korg1212_capture_open, .close = snd_korg1212_capture_close, .ioctl = snd_korg1212_ioctl, @@ -1719,18 +1785,16 @@ static struct snd_pcm_ops snd_korg1212_capture_ops = { * Control Interface */ -static int snd_korg1212_control_phase_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_korg1212_control_phase_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1; return 0; } -static int snd_korg1212_control_phase_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_phase_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); int i = kcontrol->private_value; spin_lock_irq(&korg1212->lock); @@ -1745,10 +1809,9 @@ static int snd_korg1212_control_phase_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_phase_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_phase_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); int change = 0; int i, val; @@ -1783,8 +1846,7 @@ static int snd_korg1212_control_phase_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_korg1212_control_volume_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_korg1212_control_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1; @@ -1793,10 +1855,9 @@ static int snd_korg1212_control_volume_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); int i; spin_lock_irq(&korg1212->lock); @@ -1812,10 +1873,9 @@ static int snd_korg1212_control_volume_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); int change = 0; int i; int val; @@ -1845,8 +1905,7 @@ static int snd_korg1212_control_volume_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_korg1212_control_route_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_korg1212_control_route_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = (kcontrol->private_value >= 8) ? 2 : 1; @@ -1858,10 +1917,9 @@ static int snd_korg1212_control_route_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_route_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_route_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); int i; spin_lock_irq(&korg1212->lock); @@ -1877,10 +1935,9 @@ static int snd_korg1212_control_route_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_route_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_route_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); int change = 0, i; spin_lock_irq(&korg1212->lock); @@ -1904,8 +1961,7 @@ static int snd_korg1212_control_route_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_korg1212_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_korg1212_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1914,10 +1970,9 @@ static int snd_korg1212_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&korg1212->lock); @@ -1929,10 +1984,9 @@ static int snd_korg1212_control_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *u) +static int snd_korg1212_control_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); int change = 0; spin_lock_irq(&korg1212->lock); @@ -1954,8 +2008,7 @@ static int snd_korg1212_control_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_korg1212_control_sync_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_korg1212_control_sync_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -1967,10 +2020,9 @@ static int snd_korg1212_control_sync_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_sync_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_korg1212_control_sync_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&korg1212->lock); @@ -1980,10 +2032,9 @@ static int snd_korg1212_control_sync_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_korg1212_control_sync_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_korg1212_control_sync_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_korg1212 *korg1212 = snd_kcontrol_chip(kcontrol); + korg1212_t *korg1212 = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -2024,7 +2075,7 @@ static int snd_korg1212_control_sync_put(struct snd_kcontrol *kcontrol, .private_value = ord, \ } -static struct snd_kcontrol_new snd_korg1212_controls[] = { +static snd_kcontrol_new_t snd_korg1212_controls[] = { MON_MIXER(8, "Analog"), MON_MIXER(10, "SPDIF"), MON_MIXER(0, "ADAT-1"), MON_MIXER(1, "ADAT-2"), MON_MIXER(2, "ADAT-3"), MON_MIXER(3, "ADAT-4"), @@ -2051,11 +2102,10 @@ static struct snd_kcontrol_new snd_korg1212_controls[] = { * proc interface */ -static void snd_korg1212_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_korg1212_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { int n; - struct snd_korg1212 *korg1212 = entry->private_data; + korg1212_t *korg1212 = (korg1212_t *)entry->private_data; snd_iprintf(buffer, korg1212->card->longname); snd_iprintf(buffer, " (index #%d)\n", korg1212->card->number + 1); @@ -2079,23 +2129,23 @@ static void snd_korg1212_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, " Error count: %ld\n", korg1212->totalerrorcnt); } -static void __devinit snd_korg1212_proc_init(struct snd_korg1212 *korg1212) +static void __devinit snd_korg1212_proc_init(korg1212_t *korg1212) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(korg1212->card, "korg1212", &entry)) snd_info_set_text_ops(entry, korg1212, 1024, snd_korg1212_proc_read); } static int -snd_korg1212_free(struct snd_korg1212 *korg1212) +snd_korg1212_free(korg1212_t *korg1212) { snd_korg1212_TurnOffIdleMonitor(korg1212); if (korg1212->irq >= 0) { synchronize_irq(korg1212->irq); snd_korg1212_DisableCardInterrupts(korg1212); - free_irq(korg1212->irq, korg1212); + free_irq(korg1212->irq, (void *)korg1212); korg1212->irq = -1; } @@ -2144,23 +2194,25 @@ snd_korg1212_free(struct snd_korg1212 *korg1212) return 0; } -static int snd_korg1212_dev_free(struct snd_device *device) +static int snd_korg1212_dev_free(snd_device_t *device) { - struct snd_korg1212 *korg1212 = device->device_data; + korg1212_t *korg1212 = device->device_data; +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n"); +#endif return snd_korg1212_free(korg1212); } -static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev *pci, - struct snd_korg1212 ** rchip) +static int __devinit snd_korg1212_create(snd_card_t * card, struct pci_dev *pci, + korg1212_t ** rchip) { - int err, rc; + int err; unsigned int i; unsigned ioport_size, iomem_size, iomem2_size; - struct snd_korg1212 * korg1212; + korg1212_t * korg1212; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_korg1212_dev_free, }; @@ -2218,6 +2270,7 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * ioport_size = pci_resource_len(korg1212->pci, 1); iomem2_size = pci_resource_len(korg1212->pci, 2); +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: resources:\n" " iomem = 0x%lx (%d)\n" " ioport = 0x%lx (%d)\n" @@ -2227,6 +2280,7 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * korg1212->ioport, ioport_size, korg1212->iomem2, iomem2_size, stateName[korg1212->cardState]); +#endif if ((korg1212->iobase = ioremap(korg1212->iomem, iomem_size)) == NULL) { snd_printk(KERN_ERR "korg1212: unable to remap memory region 0x%lx-0x%lx\n", korg1212->iomem, @@ -2237,7 +2291,7 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * err = request_irq(pci->irq, snd_korg1212_interrupt, SA_INTERRUPT|SA_SHIRQ, - "korg1212", korg1212); + "korg1212", (void *) korg1212); if (err) { snd_printk(KERN_ERR "korg1212: unable to grab IRQ %d\n", pci->irq); @@ -2260,6 +2314,7 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * korg1212->sensRegPtr = (u16 __iomem *) (korg1212->iobase + SENS_CONTROL_OFFSET); korg1212->idRegPtr = (u32 __iomem *) (korg1212->iobase + DEV_VEND_ID_OFFSET); +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: card registers:\n" " Status register = 0x%p\n" " OutDoorbell = 0x%p\n" @@ -2283,21 +2338,24 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * korg1212->sensRegPtr, korg1212->idRegPtr, stateName[korg1212->cardState]); +#endif if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), - sizeof(struct KorgSharedBuffer), &korg1212->dma_shared) < 0) { - snd_printk(KERN_ERR "korg1212: can not allocate shared buffer memory (%Zd bytes)\n", sizeof(struct KorgSharedBuffer)); + sizeof(KorgSharedBuffer), &korg1212->dma_shared) < 0) { + snd_printk(KERN_ERR "korg1212: can not allocate shared buffer memory (%Zd bytes)\n", sizeof(KorgSharedBuffer)); snd_korg1212_free(korg1212); return -ENOMEM; } - korg1212->sharedBufferPtr = (struct KorgSharedBuffer *)korg1212->dma_shared.area; + korg1212->sharedBufferPtr = (KorgSharedBuffer *)korg1212->dma_shared.area; korg1212->sharedBufferPhy = korg1212->dma_shared.addr; - K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212->sharedBufferPtr, korg1212->sharedBufferPhy, sizeof(struct KorgSharedBuffer)); +#if K1212_DEBUG_LEVEL > 0 + K1212_DEBUG_PRINTK("K1212_DEBUG: Shared Buffer Area = 0x%p (0x%08lx), %d bytes\n", korg1212->sharedBufferPtr, korg1212->sharedBufferPhy, sizeof(KorgSharedBuffer)); +#endif #ifndef K1212_LARGEALLOC - korg1212->DataBufsSize = sizeof(struct KorgAudioBuffer) * kNumBuffers; + korg1212->DataBufsSize = sizeof(KorgAudioBuffer) * kNumBuffers; if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), korg1212->DataBufsSize, &korg1212->dma_play) < 0) { @@ -2305,11 +2363,13 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * snd_korg1212_free(korg1212); return -ENOMEM; } - korg1212->playDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_play.area; + korg1212->playDataBufsPtr = (KorgAudioBuffer *)korg1212->dma_play.area; korg1212->PlayDataPhy = korg1212->dma_play.addr; +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n", korg1212->playDataBufsPtr, korg1212->PlayDataPhy, korg1212->DataBufsSize); +#endif if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), korg1212->DataBufsSize, &korg1212->dma_rec) < 0) { @@ -2317,29 +2377,31 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * snd_korg1212_free(korg1212); return -ENOMEM; } - korg1212->recordDataBufsPtr = (struct KorgAudioBuffer *)korg1212->dma_rec.area; + korg1212->recordDataBufsPtr = (KorgAudioBuffer *)korg1212->dma_rec.area; korg1212->RecDataPhy = korg1212->dma_rec.addr; +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: Record Data Area = 0x%p (0x%08x), %d bytes\n", korg1212->recordDataBufsPtr, korg1212->RecDataPhy, korg1212->DataBufsSize); +#endif #else // K1212_LARGEALLOC korg1212->recordDataBufsPtr = korg1212->sharedBufferPtr->recordDataBufs; korg1212->playDataBufsPtr = korg1212->sharedBufferPtr->playDataBufs; - korg1212->PlayDataPhy = (u32) &((struct KorgSharedBuffer *) korg1212->sharedBufferPhy)->playDataBufs; - korg1212->RecDataPhy = (u32) &((struct KorgSharedBuffer *) korg1212->sharedBufferPhy)->recordDataBufs; + korg1212->PlayDataPhy = (u32) &((KorgSharedBuffer *) korg1212->sharedBufferPhy)->playDataBufs; + korg1212->RecDataPhy = (u32) &((KorgSharedBuffer *) korg1212->sharedBufferPhy)->recordDataBufs; #endif // K1212_LARGEALLOC korg1212->dspCodeSize = sizeof (dspCode); korg1212->VolumeTablePhy = korg1212->sharedBufferPhy + - offsetof(struct KorgSharedBuffer, volumeData); + offsetof(KorgSharedBuffer, volumeData); korg1212->RoutingTablePhy = korg1212->sharedBufferPhy + - offsetof(struct KorgSharedBuffer, routeData); + offsetof(KorgSharedBuffer, routeData); korg1212->AdatTimeCodePhy = korg1212->sharedBufferPhy + - offsetof(struct KorgSharedBuffer, AdatTimeCode); + offsetof(KorgSharedBuffer, AdatTimeCode); if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), korg1212->dspCodeSize, &korg1212->dma_dsp) < 0) { @@ -2348,14 +2410,17 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * return -ENOMEM; } +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: DSP Code area = 0x%p (0x%08x) %d bytes [%s]\n", korg1212->dma_dsp.area, korg1212->dma_dsp.addr, korg1212->dspCodeSize, stateName[korg1212->cardState]); +#endif rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_RebootCard, 0, 0, 0, 0); - if (rc) - K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#if K1212_DEBUG_LEVEL > 0 + if (rc) K1212_DEBUG_PRINTK("K1212_DEBUG: Reboot Card - RC = %d [%s]\n", rc, stateName[korg1212->cardState]); +#endif if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, korg1212, &ops)) < 0) { snd_korg1212_free(korg1212); @@ -2369,7 +2434,8 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * if (snd_korg1212_downloadDSPCode(korg1212)) return -EBUSY; - K1212_DEBUG_PRINTK("korg1212: dspMemPhy = %08x U[%08x], " + snd_printk(KERN_ERR + "korg1212: dspMemPhy = %08x U[%08x], " "PlayDataPhy = %08x L[%08x]\n" "korg1212: RecDataPhy = %08x L[%08x], " "VolumeTablePhy = %08x L[%08x]\n" @@ -2395,6 +2461,9 @@ static int __devinit snd_korg1212_create(struct snd_card *card, struct pci_dev * korg1212->pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; + //snd_pcm_lib_preallocate_pages_for_all(korg1212->pcm, + // K1212_MAX_BUF_SIZE, K1212_MAX_BUF_SIZE, GFP_KERNEL); + for (i = 0; i < ARRAY_SIZE(snd_korg1212_controls); i++) { err = snd_ctl_add(korg1212->card, snd_ctl_new1(&snd_korg1212_controls[i], korg1212)); if (err < 0) @@ -2419,8 +2488,8 @@ snd_korg1212_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_korg1212 *korg1212; - struct snd_card *card; + korg1212_t *korg1212; + snd_card_t *card; int err; if (dev >= SNDRV_CARDS) { @@ -2444,7 +2513,9 @@ snd_korg1212_probe(struct pci_dev *pci, sprintf(card->longname, "%s at 0x%lx, irq %d", card->shortname, korg1212->iomem, korg1212->irq); +#if K1212_DEBUG_LEVEL > 0 K1212_DEBUG_PRINTK("K1212_DEBUG: %s\n", card->longname); +#endif if ((err = snd_card_register(card)) < 0) { snd_card_free(card); diff --git a/trunk/sound/pci/maestro3.c b/trunk/sound/pci/maestro3.c index d3ef0cc6c4f9..ede7a75bfe08 100644 --- a/trunk/sound/pci/maestro3.c +++ b/trunk/sound/pci/maestro3.c @@ -767,6 +767,9 @@ MODULE_PARM_DESC(amp_gpio, "GPIO pin number for external amp. (default = -1)"); /* */ +typedef struct snd_m3_dma m3_dma_t; +typedef struct snd_m3 m3_t; + /* quirk lists */ struct m3_quirk { const char *name; /* device name */ @@ -788,10 +791,11 @@ struct m3_list { int max; }; -struct m3_dma { +struct snd_m3_dma { int number; - struct snd_pcm_substream *substream; + m3_t *chip; + snd_pcm_substream_t *substream; struct assp_instance { unsigned short code, data; @@ -817,16 +821,16 @@ struct m3_dma { struct snd_m3 { - struct snd_card *card; + snd_card_t *card; unsigned long iobase; int irq; unsigned int allegro_flag : 1; - struct snd_ac97 *ac97; + ac97_t *ac97; - struct snd_pcm *pcm; + snd_pcm_t *pcm; struct pci_dev *pci; struct m3_quirk *quirk; @@ -847,17 +851,17 @@ struct snd_m3 { int amp_gpio; /* midi */ - struct snd_rawmidi *rmidi; + snd_rawmidi_t *rmidi; /* pcm streams */ int num_substreams; - struct m3_dma *substreams; + m3_dma_t *substreams; spinlock_t reg_lock; spinlock_t ac97_lock; - struct snd_kcontrol *master_switch; - struct snd_kcontrol *master_volume; + snd_kcontrol_t *master_switch; + snd_kcontrol_t *master_volume; struct tasklet_struct hwvol_tq; #ifdef CONFIG_PM @@ -1017,22 +1021,22 @@ static struct m3_hv_quirk m3_hv_quirk_list[] = { * lowlevel functions */ -static inline void snd_m3_outw(struct snd_m3 *chip, u16 value, unsigned long reg) +static inline void snd_m3_outw(m3_t *chip, u16 value, unsigned long reg) { outw(value, chip->iobase + reg); } -static inline u16 snd_m3_inw(struct snd_m3 *chip, unsigned long reg) +static inline u16 snd_m3_inw(m3_t *chip, unsigned long reg) { return inw(chip->iobase + reg); } -static inline void snd_m3_outb(struct snd_m3 *chip, u8 value, unsigned long reg) +static inline void snd_m3_outb(m3_t *chip, u8 value, unsigned long reg) { outb(value, chip->iobase + reg); } -static inline u8 snd_m3_inb(struct snd_m3 *chip, unsigned long reg) +static inline u8 snd_m3_inb(m3_t *chip, unsigned long reg) { return inb(chip->iobase + reg); } @@ -1041,28 +1045,28 @@ static inline u8 snd_m3_inb(struct snd_m3 *chip, unsigned long reg) * access 16bit words to the code or data regions of the dsp's memory. * index addresses 16bit words. */ -static u16 snd_m3_assp_read(struct snd_m3 *chip, u16 region, u16 index) +static u16 snd_m3_assp_read(m3_t *chip, u16 region, u16 index) { snd_m3_outw(chip, region & MEMTYPE_MASK, DSP_PORT_MEMORY_TYPE); snd_m3_outw(chip, index, DSP_PORT_MEMORY_INDEX); return snd_m3_inw(chip, DSP_PORT_MEMORY_DATA); } -static void snd_m3_assp_write(struct snd_m3 *chip, u16 region, u16 index, u16 data) +static void snd_m3_assp_write(m3_t *chip, u16 region, u16 index, u16 data) { snd_m3_outw(chip, region & MEMTYPE_MASK, DSP_PORT_MEMORY_TYPE); snd_m3_outw(chip, index, DSP_PORT_MEMORY_INDEX); snd_m3_outw(chip, data, DSP_PORT_MEMORY_DATA); } -static void snd_m3_assp_halt(struct snd_m3 *chip) +static void snd_m3_assp_halt(m3_t *chip) { chip->reset_state = snd_m3_inb(chip, DSP_PORT_CONTROL_REG_B) & ~REGB_STOP_CLOCK; msleep(10); snd_m3_outb(chip, chip->reset_state & ~REGB_ENABLE_RESET, DSP_PORT_CONTROL_REG_B); } -static void snd_m3_assp_continue(struct snd_m3 *chip) +static void snd_m3_assp_continue(m3_t *chip) { snd_m3_outb(chip, chip->reset_state | REGB_ENABLE_RESET, DSP_PORT_CONTROL_REG_B); } @@ -1076,7 +1080,7 @@ static void snd_m3_assp_continue(struct snd_m3 *chip) * by the binary code images. */ -static int snd_m3_add_list(struct snd_m3 *chip, struct m3_list *list, u16 val) +static int snd_m3_add_list(m3_t *chip, struct m3_list *list, u16 val) { snd_m3_assp_write(chip, MEMTYPE_INTERNAL_DATA, list->mem_addr + list->curlen, @@ -1084,7 +1088,7 @@ static int snd_m3_add_list(struct snd_m3 *chip, struct m3_list *list, u16 val) return list->curlen++; } -static void snd_m3_remove_list(struct snd_m3 *chip, struct m3_list *list, int index) +static void snd_m3_remove_list(m3_t *chip, struct m3_list *list, int index) { u16 val; int lastindex = list->curlen - 1; @@ -1104,7 +1108,7 @@ static void snd_m3_remove_list(struct snd_m3 *chip, struct m3_list *list, int in list->curlen--; } -static void snd_m3_inc_timer_users(struct snd_m3 *chip) +static void snd_m3_inc_timer_users(m3_t *chip) { chip->timer_users++; if (chip->timer_users != 1) @@ -1123,7 +1127,7 @@ static void snd_m3_inc_timer_users(struct snd_m3 *chip) HOST_INT_CTRL); } -static void snd_m3_dec_timer_users(struct snd_m3 *chip) +static void snd_m3_dec_timer_users(m3_t *chip) { chip->timer_users--; if (chip->timer_users > 0) @@ -1147,8 +1151,7 @@ static void snd_m3_dec_timer_users(struct snd_m3 *chip) */ /* spinlock held! */ -static int snd_m3_pcm_start(struct snd_m3 *chip, struct m3_dma *s, - struct snd_pcm_substream *subs) +static int snd_m3_pcm_start(m3_t *chip, m3_dma_t *s, snd_pcm_substream_t *subs) { if (! s || ! subs) return -EINVAL; @@ -1164,7 +1167,7 @@ static int snd_m3_pcm_start(struct snd_m3 *chip, struct m3_dma *s, chip->dacs_active); break; case SNDRV_PCM_STREAM_CAPTURE: - snd_m3_assp_write(chip, MEMTYPE_INTERNAL_DATA, + snd_m3_assp_write(s->chip, MEMTYPE_INTERNAL_DATA, KDATA_ADC1_REQUEST, 1); snd_m3_assp_write(chip, MEMTYPE_INTERNAL_DATA, s->inst.data + CDATA_INSTANCE_READY, 1); @@ -1174,8 +1177,7 @@ static int snd_m3_pcm_start(struct snd_m3 *chip, struct m3_dma *s, } /* spinlock held! */ -static int snd_m3_pcm_stop(struct snd_m3 *chip, struct m3_dma *s, - struct snd_pcm_substream *subs) +static int snd_m3_pcm_stop(m3_t *chip, m3_dma_t *s, snd_pcm_substream_t *subs) { if (! s || ! subs) return -EINVAL; @@ -1199,10 +1201,10 @@ static int snd_m3_pcm_stop(struct snd_m3 *chip, struct m3_dma *s, } static int -snd_m3_pcm_trigger(struct snd_pcm_substream *subs, int cmd) +snd_m3_pcm_trigger(snd_pcm_substream_t *subs, int cmd) { - struct snd_m3 *chip = snd_pcm_substream_chip(subs); - struct m3_dma *s = subs->runtime->private_data; + m3_t *chip = snd_pcm_substream_chip(subs); + m3_dma_t *s = (m3_dma_t*)subs->runtime->private_data; int err = -EINVAL; snd_assert(s != NULL, return -ENXIO); @@ -1236,10 +1238,10 @@ snd_m3_pcm_trigger(struct snd_pcm_substream *subs, int cmd) * setup */ static void -snd_m3_pcm_setup1(struct snd_m3 *chip, struct m3_dma *s, struct snd_pcm_substream *subs) +snd_m3_pcm_setup1(m3_t *chip, m3_dma_t *s, snd_pcm_substream_t *subs) { int dsp_in_size, dsp_out_size, dsp_in_buffer, dsp_out_buffer; - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (subs->stream == SNDRV_PCM_STREAM_PLAYBACK) { dsp_in_size = MINISRC_IN_BUFFER_SIZE - (0x20 * 2); @@ -1321,8 +1323,7 @@ snd_m3_pcm_setup1(struct snd_m3 *chip, struct m3_dma *s, struct snd_pcm_substrea dsp_out_buffer); } -static void snd_m3_pcm_setup2(struct snd_m3 *chip, struct m3_dma *s, - struct snd_pcm_runtime *runtime) +static void snd_m3_pcm_setup2(m3_t *chip, m3_dma_t *s, snd_pcm_runtime_t *runtime) { u32 freq; @@ -1388,8 +1389,7 @@ static struct play_vals { /* the mode passed should be already shifted and masked */ static void -snd_m3_playback_setup(struct snd_m3 *chip, struct m3_dma *s, - struct snd_pcm_substream *subs) +snd_m3_playback_setup(m3_t *chip, m3_dma_t *s, snd_pcm_substream_t *subs) { unsigned int i; @@ -1455,7 +1455,7 @@ static struct rec_vals { }; static void -snd_m3_capture_setup(struct snd_m3 *chip, struct m3_dma *s, struct snd_pcm_substream *subs) +snd_m3_capture_setup(m3_t *chip, m3_dma_t *s, snd_pcm_substream_t *subs) { unsigned int i; @@ -1481,10 +1481,10 @@ snd_m3_capture_setup(struct snd_m3 *chip, struct m3_dma *s, struct snd_pcm_subst s->inst.data + rv[i].addr, rv[i].val); } -static int snd_m3_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_m3_pcm_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct m3_dma *s = substream->runtime->private_data; + m3_dma_t *s = (m3_dma_t*) substream->runtime->private_data; int err; if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) @@ -1498,24 +1498,24 @@ static int snd_m3_pcm_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_m3_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_m3_pcm_hw_free(snd_pcm_substream_t * substream) { - struct m3_dma *s; + m3_dma_t *s; if (substream->runtime->private_data == NULL) return 0; - s = substream->runtime->private_data; + s = (m3_dma_t*) substream->runtime->private_data; snd_pcm_lib_free_pages(substream); s->buffer_addr = 0; return 0; } static int -snd_m3_pcm_prepare(struct snd_pcm_substream *subs) +snd_m3_pcm_prepare(snd_pcm_substream_t *subs) { - struct snd_m3 *chip = snd_pcm_substream_chip(subs); - struct snd_pcm_runtime *runtime = subs->runtime; - struct m3_dma *s = runtime->private_data; + m3_t *chip = snd_pcm_substream_chip(subs); + snd_pcm_runtime_t *runtime = subs->runtime; + m3_dma_t *s = (m3_dma_t*)runtime->private_data; snd_assert(s != NULL, return -ENXIO); @@ -1546,7 +1546,7 @@ snd_m3_pcm_prepare(struct snd_pcm_substream *subs) * get current pointer */ static unsigned int -snd_m3_get_pointer(struct snd_m3 *chip, struct m3_dma *s, struct snd_pcm_substream *subs) +snd_m3_get_pointer(m3_t *chip, m3_dma_t *s, snd_pcm_substream_t *subs) { u16 hi = 0, lo = 0; int retry = 10; @@ -1571,11 +1571,11 @@ snd_m3_get_pointer(struct snd_m3 *chip, struct m3_dma *s, struct snd_pcm_substre } static snd_pcm_uframes_t -snd_m3_pcm_pointer(struct snd_pcm_substream *subs) +snd_m3_pcm_pointer(snd_pcm_substream_t * subs) { - struct snd_m3 *chip = snd_pcm_substream_chip(subs); + m3_t *chip = snd_pcm_substream_chip(subs); unsigned int ptr; - struct m3_dma *s = subs->runtime->private_data; + m3_dma_t *s = (m3_dma_t*)subs->runtime->private_data; snd_assert(s != NULL, return 0); spin_lock(&chip->reg_lock); @@ -1587,9 +1587,9 @@ snd_m3_pcm_pointer(struct snd_pcm_substream *subs) /* update pointer */ /* spinlock held! */ -static void snd_m3_update_ptr(struct snd_m3 *chip, struct m3_dma *s) +static void snd_m3_update_ptr(m3_t *chip, m3_dma_t *s) { - struct snd_pcm_substream *subs = s->substream; + snd_pcm_substream_t *subs = s->substream; unsigned int hwptr; int diff; @@ -1610,7 +1610,7 @@ static void snd_m3_update_ptr(struct snd_m3 *chip, struct m3_dma *s) static void snd_m3_update_hw_volume(unsigned long private_data) { - struct snd_m3 *chip = (struct snd_m3 *) private_data; + m3_t *chip = (m3_t *) private_data; int x, val; unsigned long flags; @@ -1673,7 +1673,7 @@ static void snd_m3_update_hw_volume(unsigned long private_data) static irqreturn_t snd_m3_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_m3 *chip = dev_id; + m3_t *chip = dev_id; u8 status; int i; @@ -1698,7 +1698,7 @@ snd_m3_interrupt(int irq, void *dev_id, struct pt_regs *regs) /* update adc/dac info if it was a timer int */ spin_lock(&chip->reg_lock); for (i = 0; i < chip->num_substreams; i++) { - struct m3_dma *s = &chip->substreams[i]; + m3_dma_t *s = &chip->substreams[i]; if (s->running) snd_m3_update_ptr(chip, s); } @@ -1722,7 +1722,7 @@ snd_m3_interrupt(int irq, void *dev_id, struct pt_regs *regs) /* */ -static struct snd_pcm_hardware snd_m3_playback = +static snd_pcm_hardware_t snd_m3_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | @@ -1743,7 +1743,7 @@ static struct snd_pcm_hardware snd_m3_playback = .periods_max = 1024, }; -static struct snd_pcm_hardware snd_m3_capture = +static snd_pcm_hardware_t snd_m3_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | @@ -1769,10 +1769,10 @@ static struct snd_pcm_hardware snd_m3_capture = */ static int -snd_m3_substream_open(struct snd_m3 *chip, struct snd_pcm_substream *subs) +snd_m3_substream_open(m3_t *chip, snd_pcm_substream_t *subs) { int i; - struct m3_dma *s; + m3_dma_t *s; spin_lock_irq(&chip->reg_lock); for (i = 0; i < chip->num_substreams; i++) { @@ -1802,9 +1802,9 @@ snd_m3_substream_open(struct snd_m3 *chip, struct snd_pcm_substream *subs) } static void -snd_m3_substream_close(struct snd_m3 *chip, struct snd_pcm_substream *subs) +snd_m3_substream_close(m3_t *chip, snd_pcm_substream_t *subs) { - struct m3_dma *s = subs->runtime->private_data; + m3_dma_t *s = (m3_dma_t*) subs->runtime->private_data; if (s == NULL) return; /* not opened properly */ @@ -1824,10 +1824,10 @@ snd_m3_substream_close(struct snd_m3 *chip, struct snd_pcm_substream *subs) } static int -snd_m3_playback_open(struct snd_pcm_substream *subs) +snd_m3_playback_open(snd_pcm_substream_t *subs) { - struct snd_m3 *chip = snd_pcm_substream_chip(subs); - struct snd_pcm_runtime *runtime = subs->runtime; + m3_t *chip = snd_pcm_substream_chip(subs); + snd_pcm_runtime_t *runtime = subs->runtime; int err; if ((err = snd_m3_substream_open(chip, subs)) < 0) @@ -1840,19 +1840,19 @@ snd_m3_playback_open(struct snd_pcm_substream *subs) } static int -snd_m3_playback_close(struct snd_pcm_substream *subs) +snd_m3_playback_close(snd_pcm_substream_t *subs) { - struct snd_m3 *chip = snd_pcm_substream_chip(subs); + m3_t *chip = snd_pcm_substream_chip(subs); snd_m3_substream_close(chip, subs); return 0; } static int -snd_m3_capture_open(struct snd_pcm_substream *subs) +snd_m3_capture_open(snd_pcm_substream_t *subs) { - struct snd_m3 *chip = snd_pcm_substream_chip(subs); - struct snd_pcm_runtime *runtime = subs->runtime; + m3_t *chip = snd_pcm_substream_chip(subs); + snd_pcm_runtime_t *runtime = subs->runtime; int err; if ((err = snd_m3_substream_open(chip, subs)) < 0) @@ -1865,9 +1865,9 @@ snd_m3_capture_open(struct snd_pcm_substream *subs) } static int -snd_m3_capture_close(struct snd_pcm_substream *subs) +snd_m3_capture_close(snd_pcm_substream_t *subs) { - struct snd_m3 *chip = snd_pcm_substream_chip(subs); + m3_t *chip = snd_pcm_substream_chip(subs); snd_m3_substream_close(chip, subs); return 0; @@ -1877,7 +1877,7 @@ snd_m3_capture_close(struct snd_pcm_substream *subs) * create pcm instance */ -static struct snd_pcm_ops snd_m3_playback_ops = { +static snd_pcm_ops_t snd_m3_playback_ops = { .open = snd_m3_playback_open, .close = snd_m3_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1888,7 +1888,7 @@ static struct snd_pcm_ops snd_m3_playback_ops = { .pointer = snd_m3_pcm_pointer, }; -static struct snd_pcm_ops snd_m3_capture_ops = { +static snd_pcm_ops_t snd_m3_capture_ops = { .open = snd_m3_capture_open, .close = snd_m3_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1900,9 +1900,9 @@ static struct snd_pcm_ops snd_m3_capture_ops = { }; static int __devinit -snd_m3_pcm(struct snd_m3 * chip, int device) +snd_m3_pcm(m3_t * chip, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; err = snd_pcm_new(chip->card, chip->card->driver, device, @@ -1933,7 +1933,7 @@ snd_m3_pcm(struct snd_m3 * chip, int device) * Wait for the ac97 serial bus to be free. * return nonzero if the bus is still busy. */ -static int snd_m3_ac97_wait(struct snd_m3 *chip) +static int snd_m3_ac97_wait(m3_t *chip) { int i = 10000; @@ -1947,9 +1947,9 @@ static int snd_m3_ac97_wait(struct snd_m3 *chip) } static unsigned short -snd_m3_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +snd_m3_ac97_read(ac97_t *ac97, unsigned short reg) { - struct snd_m3 *chip = ac97->private_data; + m3_t *chip = ac97->private_data; unsigned long flags; unsigned short data; @@ -1965,9 +1965,9 @@ snd_m3_ac97_read(struct snd_ac97 *ac97, unsigned short reg) } static void -snd_m3_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) +snd_m3_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct snd_m3 *chip = ac97->private_data; + m3_t *chip = ac97->private_data; unsigned long flags; if (snd_m3_ac97_wait(chip)) @@ -1994,7 +1994,7 @@ static void snd_m3_remote_codec_config(int io, int isremote) /* * hack, returns non zero on err */ -static int snd_m3_try_read_vendor(struct snd_m3 *chip) +static int snd_m3_try_read_vendor(m3_t *chip) { u16 ret; @@ -2011,7 +2011,7 @@ static int snd_m3_try_read_vendor(struct snd_m3 *chip) return (ret == 0) || (ret == 0xffff); } -static void snd_m3_ac97_reset(struct snd_m3 *chip) +static void snd_m3_ac97_reset(m3_t *chip) { u16 dir; int delay1 = 0, delay2 = 0, i; @@ -2078,13 +2078,13 @@ static void snd_m3_ac97_reset(struct snd_m3 *chip) #endif } -static int __devinit snd_m3_mixer(struct snd_m3 *chip) +static int __devinit snd_m3_mixer(m3_t *chip) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; - struct snd_ctl_elem_id id; + ac97_bus_t *pbus; + ac97_template_t ac97; + snd_ctl_elem_id_t id; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_m3_ac97_write, .read = snd_m3_ac97_read, }; @@ -2254,7 +2254,7 @@ static u16 minisrc_lpf[MINISRC_LPF_LEN] __devinitdata = { 0X1023, 0X1AA9, 0X0B60, 0XEFDD, 0X186F }; -static void __devinit snd_m3_assp_init(struct snd_m3 *chip) +static void __devinit snd_m3_assp_init(m3_t *chip) { unsigned int i; @@ -2343,7 +2343,7 @@ static void __devinit snd_m3_assp_init(struct snd_m3 *chip) } -static int __devinit snd_m3_assp_client_init(struct snd_m3 *chip, struct m3_dma *s, int index) +static int __devinit snd_m3_assp_client_init(m3_t *chip, m3_dma_t *s, int index) { int data_bytes = 2 * ( MINISRC_TMP_BUFFER_SIZE / 2 + MINISRC_IN_BUFFER_SIZE / 2 + @@ -2389,7 +2389,7 @@ static int __devinit snd_m3_assp_client_init(struct snd_m3 *chip, struct m3_dma * this needs more magic for 4 speaker, but.. */ static void -snd_m3_amp_enable(struct snd_m3 *chip, int enable) +snd_m3_amp_enable(m3_t *chip, int enable) { int io = chip->iobase; u16 gpo, polarity; @@ -2413,7 +2413,7 @@ snd_m3_amp_enable(struct snd_m3 *chip, int enable) } static int -snd_m3_chip_init(struct snd_m3 *chip) +snd_m3_chip_init(m3_t *chip) { struct pci_dev *pcidev = chip->pci; unsigned long io = chip->iobase; @@ -2486,7 +2486,7 @@ snd_m3_chip_init(struct snd_m3 *chip) } static void -snd_m3_enable_ints(struct snd_m3 *chip) +snd_m3_enable_ints(m3_t *chip) { unsigned long io = chip->iobase; unsigned short val; @@ -2504,9 +2504,9 @@ snd_m3_enable_ints(struct snd_m3 *chip) /* */ -static int snd_m3_free(struct snd_m3 *chip) +static int snd_m3_free(m3_t *chip) { - struct m3_dma *s; + m3_dma_t *s; int i; if (chip->substreams) { @@ -2530,7 +2530,7 @@ static int snd_m3_free(struct snd_m3 *chip) if (chip->irq >= 0) { synchronize_irq(chip->irq); - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); } if (chip->iobase) @@ -2546,16 +2546,14 @@ static int snd_m3_free(struct snd_m3 *chip) * APM support */ #ifdef CONFIG_PM -static int m3_suspend(struct pci_dev *pci, pm_message_t state) +static int m3_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_m3 *chip = card->private_data; + m3_t *chip = card->pm_private_data; int i, index; if (chip->suspend_mem == NULL) return 0; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); snd_ac97_suspend(chip->ac97); @@ -2576,23 +2574,20 @@ static int m3_suspend(struct pci_dev *pci, pm_message_t state) snd_m3_outw(chip, 0xffff, 0x54); snd_m3_outw(chip, 0xffff, 0x56); - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -static int m3_resume(struct pci_dev *pci) +static int m3_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_m3 *chip = card->private_data; + m3_t *chip = card->pm_private_data; int i, index; if (chip->suspend_mem == NULL) return 0; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_master(chip->pci); /* first lets just bring everything back. .*/ snd_m3_outw(chip, 0, 0x54); @@ -2622,7 +2617,6 @@ static int m3_resume(struct pci_dev *pci) snd_m3_enable_ints(chip); snd_m3_amp_enable(chip, 1); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ @@ -2631,23 +2625,23 @@ static int m3_resume(struct pci_dev *pci) /* */ -static int snd_m3_dev_free(struct snd_device *device) +static int snd_m3_dev_free(snd_device_t *device) { - struct snd_m3 *chip = device->device_data; + m3_t *chip = device->device_data; return snd_m3_free(chip); } static int __devinit -snd_m3_create(struct snd_card *card, struct pci_dev *pci, +snd_m3_create(snd_card_t *card, struct pci_dev *pci, int enable_amp, int amp_gpio, - struct snd_m3 **chip_ret) + m3_t **chip_ret) { - struct snd_m3 *chip; + m3_t *chip; int i, err; struct m3_quirk *quirk; struct m3_hv_quirk *hv_quirk; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_m3_dev_free, }; @@ -2716,13 +2710,13 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci, chip->amp_gpio = GPO_EXT_AMP_M3; chip->num_substreams = NR_DSPS; - chip->substreams = kcalloc(chip->num_substreams, sizeof(struct m3_dma), - GFP_KERNEL); + chip->substreams = kmalloc(sizeof(m3_dma_t) * chip->num_substreams, GFP_KERNEL); if (chip->substreams == NULL) { kfree(chip); pci_disable_device(pci); return -ENOMEM; } + memset(chip->substreams, 0, sizeof(m3_dma_t) * chip->num_substreams); if ((err = pci_request_regions(pci, card->driver)) < 0) { snd_m3_free(chip); @@ -2743,7 +2737,7 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci, tasklet_init(&chip->hwvol_tq, snd_m3_update_hw_volume, (unsigned long)chip); if (request_irq(pci->irq, snd_m3_interrupt, SA_INTERRUPT|SA_SHIRQ, - card->driver, chip)) { + card->driver, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_m3_free(chip); return -ENOMEM; @@ -2754,6 +2748,8 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci, chip->suspend_mem = vmalloc(sizeof(u16) * (REV_B_CODE_MEMORY_LENGTH + REV_B_DATA_MEMORY_LENGTH)); if (chip->suspend_mem == NULL) snd_printk(KERN_WARNING "can't allocate apm buffer\n"); + else + snd_card_set_pm_callback(card, m3_suspend, m3_resume, chip); #endif if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { @@ -2765,7 +2761,8 @@ snd_m3_create(struct snd_card *card, struct pci_dev *pci, return err; for (i = 0; i < chip->num_substreams; i++) { - struct m3_dma *s = &chip->substreams[i]; + m3_dma_t *s = &chip->substreams[i]; + s->chip = chip; if ((err = snd_m3_assp_client_init(chip, s, i)) < 0) return err; } @@ -2789,8 +2786,8 @@ static int __devinit snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_m3 *chip; + snd_card_t *card; + m3_t *chip; int err; /* don't pick up modems */ @@ -2829,7 +2826,6 @@ snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) snd_card_free(card); return err; } - card->private_data = chip; sprintf(card->shortname, "ESS %s PCI", card->driver); sprintf(card->longname, "%s at 0x%lx, irq %d", @@ -2865,10 +2861,7 @@ static struct pci_driver driver = { .id_table = snd_m3_ids, .probe = snd_m3_probe, .remove = __devexit_p(snd_m3_remove), -#ifdef CONFIG_PM - .suspend = m3_suspend, - .resume = m3_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_m3_init(void) diff --git a/trunk/sound/pci/mixart/mixart.c b/trunk/sound/pci/mixart/mixart.c index b218e1d20c78..b3090a13edab 100644 --- a/trunk/sound/pci/mixart/mixart.c +++ b/trunk/sound/pci/mixart/mixart.c @@ -66,12 +66,11 @@ static struct pci_device_id snd_mixart_ids[] = { MODULE_DEVICE_TABLE(pci, snd_mixart_ids); -static int mixart_set_pipe_state(struct mixart_mgr *mgr, - struct mixart_pipe *pipe, int start) +static int mixart_set_pipe_state(mixart_mgr_t *mgr, mixart_pipe_t* pipe, int start) { - struct mixart_group_state_req group_state; - struct mixart_group_state_resp group_state_resp; - struct mixart_msg request; + mixart_group_state_req_t group_state; + mixart_group_state_resp_t group_state_resp; + mixart_msg_t request; int err; u32 system_msg_uid; @@ -93,7 +92,7 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr, /* wait on the last MSG_SYSTEM_SEND_SYNCHRO_CMD command to be really finished */ request.message_id = MSG_SYSTEM_WAIT_SYNCHRO_CMD; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = &system_msg_uid; request.size = sizeof(system_msg_uid); @@ -114,7 +113,7 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr, else request.message_id = MSG_STREAM_STOP_STREAM_GRP_PACKET; - request.uid = pipe->group_uid; /*(struct mixart_uid){0,0};*/ + request.uid = pipe->group_uid; /*(mixart_uid_t){0,0};*/ request.data = &group_state; request.size = sizeof(group_state); @@ -138,7 +137,7 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr, /* in case of start send a synchro top */ request.message_id = MSG_SYSTEM_SEND_SYNCHRO_CMD; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = NULL; request.size = 0; @@ -157,12 +156,11 @@ static int mixart_set_pipe_state(struct mixart_mgr *mgr, } -static int mixart_set_clock(struct mixart_mgr *mgr, - struct mixart_pipe *pipe, unsigned int rate) +static int mixart_set_clock(mixart_mgr_t *mgr, mixart_pipe_t *pipe, unsigned int rate) { - struct mixart_msg request; - struct mixart_clock_properties clock_properties; - struct mixart_clock_properties_resp clock_prop_resp; + mixart_msg_t request; + mixart_clock_properties_t clock_properties; + mixart_clock_properties_resp_t clock_prop_resp; int err; switch(pipe->status) { @@ -210,13 +208,11 @@ static int mixart_set_clock(struct mixart_mgr *mgr, /* * Allocate or reference output pipe for analog IOs (pcmp0/1) */ -struct mixart_pipe * -snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, - int monitoring) +mixart_pipe_t* snd_mixart_add_ref_pipe( mixart_t *chip, int pcm_number, int capture, int monitoring) { int stream_count; - struct mixart_pipe *pipe; - struct mixart_msg request; + mixart_pipe_t *pipe; + mixart_msg_t request; if(capture) { if (pcm_number == MIXART_PCM_ANALOG) { @@ -245,8 +241,8 @@ snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, if( pipe->status == PIPE_UNDEFINED ) { int err, i; struct { - struct mixart_streaming_group_req sgroup_req; - struct mixart_streaming_group sgroup_resp; + mixart_streaming_group_req_t sgroup_req; + mixart_streaming_group_t sgroup_resp; } *buf; snd_printdd("add_ref_pipe audio chip(%d) pcm(%d)\n", chip->chip_idx, pcm_number); @@ -255,7 +251,7 @@ snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, if (!buf) return NULL; - request.uid = (struct mixart_uid){0,0}; /* should be StreamManagerUID, but zero is OK if there is only one ! */ + request.uid = (mixart_uid_t){0,0}; /* should be StreamManagerUID, but zero is OK if there is only one ! */ request.data = &buf->sgroup_req; request.size = sizeof(buf->sgroup_req); @@ -283,7 +279,7 @@ snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, buf->sgroup_req.flow_entry[i] = j; flowinfo = (struct mixart_flowinfo *)chip->mgr->flowinfo.area; - flowinfo[j].bufferinfo_array_phy_address = (u32)chip->mgr->bufferinfo.addr + (j * sizeof(struct mixart_bufferinfo)); + flowinfo[j].bufferinfo_array_phy_address = (u32)chip->mgr->bufferinfo.addr + (j * sizeof(mixart_bufferinfo_t)); flowinfo[j].bufferinfo_count = 1; /* 1 will set the miXart to ring-buffer mode ! */ bufferinfo = (struct mixart_bufferinfo *)chip->mgr->bufferinfo.area; @@ -319,8 +315,7 @@ snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, } -int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr, - struct mixart_pipe *pipe, int monitoring) +int snd_mixart_kill_ref_pipe( mixart_mgr_t *mgr, mixart_pipe_t *pipe, int monitoring) { int err = 0; @@ -334,8 +329,8 @@ int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr, if((pipe->references <= 0) && (pipe->monitoring == 0)) { - struct mixart_msg request; - struct mixart_delete_group_resp delete_resp; + mixart_msg_t request; + mixart_delete_group_resp_t delete_resp; /* release the clock */ err = mixart_set_clock( mgr, pipe, 0); @@ -350,7 +345,7 @@ int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr, } request.message_id = MSG_STREAM_DELETE_GROUP; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = &pipe->group_uid; /* the streaming group ! */ request.size = sizeof(pipe->group_uid); @@ -360,7 +355,7 @@ int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr, snd_printk(KERN_ERR "error MSG_STREAM_DELETE_GROUP err(%x), status(%x)\n", err, delete_resp.status); } - pipe->group_uid = (struct mixart_uid){0,0}; + pipe->group_uid = (mixart_uid_t){0,0}; pipe->stream_count = 0; pipe->status = PIPE_UNDEFINED; } @@ -368,11 +363,11 @@ int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr, return err; } -static int mixart_set_stream_state(struct mixart_stream *stream, int start) +static int mixart_set_stream_state(mixart_stream_t *stream, int start) { - struct snd_mixart *chip; - struct mixart_stream_state_req stream_state_req; - struct mixart_msg request; + mixart_t *chip; + mixart_stream_state_req_t stream_state_req; + mixart_msg_t request; if(!stream->substream) return -EINVAL; @@ -387,7 +382,7 @@ static int mixart_set_stream_state(struct mixart_stream *stream, int start) else request.message_id = start ? MSG_STREAM_START_OUTPUT_STAGE_PACKET : MSG_STREAM_STOP_OUTPUT_STAGE_PACKET; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = &stream_state_req; request.size = sizeof(stream_state_req); @@ -404,9 +399,9 @@ static int mixart_set_stream_state(struct mixart_stream *stream, int start) * Trigger callback */ -static int snd_mixart_trigger(struct snd_pcm_substream *subs, int cmd) +static int snd_mixart_trigger(snd_pcm_substream_t *subs, int cmd) { - struct mixart_stream *stream = subs->runtime->private_data; + mixart_stream_t *stream = (mixart_stream_t*)subs->runtime->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -448,7 +443,7 @@ static int snd_mixart_trigger(struct snd_pcm_substream *subs, int cmd) return 0; } -static int mixart_sync_nonblock_events(struct mixart_mgr *mgr) +static int mixart_sync_nonblock_events(mixart_mgr_t *mgr) { unsigned long timeout = jiffies + HZ; while (atomic_read(&mgr->msg_processed) > 0) { @@ -464,10 +459,10 @@ static int mixart_sync_nonblock_events(struct mixart_mgr *mgr) /* * prepare callback for all pcms */ -static int snd_mixart_prepare(struct snd_pcm_substream *subs) +static int snd_mixart_prepare(snd_pcm_substream_t *subs) { - struct snd_mixart *chip = snd_pcm_substream_chip(subs); - struct mixart_stream *stream = subs->runtime->private_data; + mixart_t *chip = snd_pcm_substream_chip(subs); + mixart_stream_t *stream = (mixart_stream_t*)subs->runtime->private_data; /* TODO de façon non bloquante, réappliquer les hw_params (rate, bits, codec) */ @@ -490,13 +485,13 @@ static int snd_mixart_prepare(struct snd_pcm_substream *subs) } -static int mixart_set_format(struct mixart_stream *stream, snd_pcm_format_t format) +static int mixart_set_format(mixart_stream_t *stream, snd_pcm_format_t format) { int err; - struct snd_mixart *chip; - struct mixart_msg request; - struct mixart_stream_param_desc stream_param; - struct mixart_return_uid resp; + mixart_t *chip; + mixart_msg_t request; + mixart_stream_param_desc_t stream_param; + mixart_return_uid_t resp; chip = snd_pcm_substream_chip(stream->substream); @@ -557,7 +552,7 @@ static int mixart_set_format(struct mixart_stream *stream, snd_pcm_format_t form stream_param.stream_desc[0].stream_idx = stream->substream->number; request.message_id = MSG_STREAM_SET_INPUT_STAGE_PARAM; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = &stream_param; request.size = sizeof(stream_param); @@ -573,12 +568,12 @@ static int mixart_set_format(struct mixart_stream *stream, snd_pcm_format_t form /* * HW_PARAMS callback for all pcms */ -static int snd_mixart_hw_params(struct snd_pcm_substream *subs, - struct snd_pcm_hw_params *hw) +static int snd_mixart_hw_params(snd_pcm_substream_t *subs, + snd_pcm_hw_params_t *hw) { - struct snd_mixart *chip = snd_pcm_substream_chip(subs); - struct mixart_mgr *mgr = chip->mgr; - struct mixart_stream *stream = subs->runtime->private_data; + mixart_t *chip = snd_pcm_substream_chip(subs); + mixart_mgr_t *mgr = chip->mgr; + mixart_stream_t *stream = (mixart_stream_t*)subs->runtime->private_data; snd_pcm_format_t format; int err; int channels; @@ -633,9 +628,9 @@ static int snd_mixart_hw_params(struct snd_pcm_substream *subs, return err; } -static int snd_mixart_hw_free(struct snd_pcm_substream *subs) +static int snd_mixart_hw_free(snd_pcm_substream_t *subs) { - struct snd_mixart *chip = snd_pcm_substream_chip(subs); + mixart_t *chip = snd_pcm_substream_chip(subs); snd_pcm_lib_free_pages(subs); mixart_sync_nonblock_events(chip->mgr); return 0; @@ -646,7 +641,7 @@ static int snd_mixart_hw_free(struct snd_pcm_substream *subs) /* * TODO CONFIGURATION SPACE for all pcms, mono pcm must update channels_max */ -static struct snd_pcm_hardware snd_mixart_analog_caps = +static snd_pcm_hardware_t snd_mixart_analog_caps = { .info = ( SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | @@ -667,7 +662,7 @@ static struct snd_pcm_hardware snd_mixart_analog_caps = .periods_max = (32*1024/256), }; -static struct snd_pcm_hardware snd_mixart_digital_caps = +static snd_pcm_hardware_t snd_mixart_digital_caps = { .info = ( SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | @@ -689,14 +684,14 @@ static struct snd_pcm_hardware snd_mixart_digital_caps = }; -static int snd_mixart_playback_open(struct snd_pcm_substream *subs) +static int snd_mixart_playback_open(snd_pcm_substream_t *subs) { - struct snd_mixart *chip = snd_pcm_substream_chip(subs); - struct mixart_mgr *mgr = chip->mgr; - struct snd_pcm_runtime *runtime = subs->runtime; - struct snd_pcm *pcm = subs->pcm; - struct mixart_stream *stream; - struct mixart_pipe *pipe; + mixart_t *chip = snd_pcm_substream_chip(subs); + mixart_mgr_t *mgr = chip->mgr; + snd_pcm_runtime_t *runtime = subs->runtime; + snd_pcm_t *pcm = subs->pcm; + mixart_stream_t *stream; + mixart_pipe_t *pipe; int err = 0; int pcm_number; @@ -764,14 +759,14 @@ static int snd_mixart_playback_open(struct snd_pcm_substream *subs) } -static int snd_mixart_capture_open(struct snd_pcm_substream *subs) +static int snd_mixart_capture_open(snd_pcm_substream_t *subs) { - struct snd_mixart *chip = snd_pcm_substream_chip(subs); - struct mixart_mgr *mgr = chip->mgr; - struct snd_pcm_runtime *runtime = subs->runtime; - struct snd_pcm *pcm = subs->pcm; - struct mixart_stream *stream; - struct mixart_pipe *pipe; + mixart_t *chip = snd_pcm_substream_chip(subs); + mixart_mgr_t *mgr = chip->mgr; + snd_pcm_runtime_t *runtime = subs->runtime; + snd_pcm_t *pcm = subs->pcm; + mixart_stream_t *stream; + mixart_pipe_t *pipe; int err = 0; int pcm_number; @@ -843,11 +838,11 @@ static int snd_mixart_capture_open(struct snd_pcm_substream *subs) -static int snd_mixart_close(struct snd_pcm_substream *subs) +static int snd_mixart_close(snd_pcm_substream_t *subs) { - struct snd_mixart *chip = snd_pcm_substream_chip(subs); - struct mixart_mgr *mgr = chip->mgr; - struct mixart_stream *stream = subs->runtime->private_data; + mixart_t *chip = snd_pcm_substream_chip(subs); + mixart_mgr_t *mgr = chip->mgr; + mixart_stream_t *stream = (mixart_stream_t*)subs->runtime->private_data; down(&mgr->setup_mutex); @@ -873,17 +868,17 @@ static int snd_mixart_close(struct snd_pcm_substream *subs) } -static snd_pcm_uframes_t snd_mixart_stream_pointer(struct snd_pcm_substream *subs) +static snd_pcm_uframes_t snd_mixart_stream_pointer(snd_pcm_substream_t * subs) { - struct snd_pcm_runtime *runtime = subs->runtime; - struct mixart_stream *stream = runtime->private_data; + snd_pcm_runtime_t *runtime = subs->runtime; + mixart_stream_t *stream = (mixart_stream_t*)runtime->private_data; return (snd_pcm_uframes_t)((stream->buf_periods * runtime->period_size) + stream->buf_period_frag); } -static struct snd_pcm_ops snd_mixart_playback_ops = { +static snd_pcm_ops_t snd_mixart_playback_ops = { .open = snd_mixart_playback_open, .close = snd_mixart_close, .ioctl = snd_pcm_lib_ioctl, @@ -894,7 +889,7 @@ static struct snd_pcm_ops snd_mixart_playback_ops = { .pointer = snd_mixart_stream_pointer, }; -static struct snd_pcm_ops snd_mixart_capture_ops = { +static snd_pcm_ops_t snd_mixart_capture_ops = { .open = snd_mixart_capture_open, .close = snd_mixart_close, .ioctl = snd_pcm_lib_ioctl, @@ -905,10 +900,10 @@ static struct snd_pcm_ops snd_mixart_capture_ops = { .pointer = snd_mixart_stream_pointer, }; -static void preallocate_buffers(struct snd_mixart *chip, struct snd_pcm *pcm) +static void preallocate_buffers(mixart_t *chip, snd_pcm_t *pcm) { #if 0 - struct snd_pcm_substream *subs; + snd_pcm_substream_t *subs; int stream; for (stream = 0; stream < 2; stream++) { @@ -926,10 +921,10 @@ static void preallocate_buffers(struct snd_mixart *chip, struct snd_pcm *pcm) /* */ -static int snd_mixart_pcm_analog(struct snd_mixart *chip) +static int snd_mixart_pcm_analog(mixart_t *chip) { int err; - struct snd_pcm *pcm; + snd_pcm_t *pcm; char name[32]; sprintf(name, "miXart analog %d", chip->chip_idx); @@ -957,10 +952,10 @@ static int snd_mixart_pcm_analog(struct snd_mixart *chip) /* */ -static int snd_mixart_pcm_digital(struct snd_mixart *chip) +static int snd_mixart_pcm_digital(mixart_t *chip) { int err; - struct snd_pcm *pcm; + snd_pcm_t *pcm; char name[32]; sprintf(name, "miXart AES/EBU %d", chip->chip_idx); @@ -985,26 +980,26 @@ static int snd_mixart_pcm_digital(struct snd_mixart *chip) return 0; } -static int snd_mixart_chip_free(struct snd_mixart *chip) +static int snd_mixart_chip_free(mixart_t *chip) { kfree(chip); return 0; } -static int snd_mixart_chip_dev_free(struct snd_device *device) +static int snd_mixart_chip_dev_free(snd_device_t *device) { - struct snd_mixart *chip = device->device_data; + mixart_t *chip = device->device_data; return snd_mixart_chip_free(chip); } /* */ -static int __devinit snd_mixart_create(struct mixart_mgr *mgr, struct snd_card *card, int idx) +static int __devinit snd_mixart_create(mixart_mgr_t *mgr, snd_card_t *card, int idx) { int err; - struct snd_mixart *chip; - static struct snd_device_ops ops = { + mixart_t *chip; + static snd_device_ops_t ops = { .dev_free = snd_mixart_chip_dev_free, }; @@ -1028,7 +1023,7 @@ static int __devinit snd_mixart_create(struct mixart_mgr *mgr, struct snd_card * return 0; } -int snd_mixart_create_pcm(struct snd_mixart* chip) +int snd_mixart_create_pcm(mixart_t* chip) { int err; @@ -1049,7 +1044,7 @@ int snd_mixart_create_pcm(struct snd_mixart* chip) /* * release all the cards assigned to a manager instance */ -static int snd_mixart_free(struct mixart_mgr *mgr) +static int snd_mixart_free(mixart_mgr_t *mgr) { unsigned int i; @@ -1097,7 +1092,7 @@ static int snd_mixart_free(struct mixart_mgr *mgr) /* * proc interface */ -static long long snd_mixart_BA0_llseek(struct snd_info_entry *entry, +static long long snd_mixart_BA0_llseek(snd_info_entry_t *entry, void *private_file_data, struct file *file, long long offset, @@ -1123,7 +1118,7 @@ static long long snd_mixart_BA0_llseek(struct snd_info_entry *entry, return file->f_pos; } -static long long snd_mixart_BA1_llseek(struct snd_info_entry *entry, +static long long snd_mixart_BA1_llseek(snd_info_entry_t *entry, void *private_file_data, struct file *file, long long offset, @@ -1152,11 +1147,11 @@ static long long snd_mixart_BA1_llseek(struct snd_info_entry *entry, /* mixart_BA0 proc interface for BAR 0 - read callback */ -static long snd_mixart_BA0_read(struct snd_info_entry *entry, void *file_private_data, +static long snd_mixart_BA0_read(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *buf, unsigned long count, unsigned long pos) { - struct mixart_mgr *mgr = entry->private_data; + mixart_mgr_t *mgr = entry->private_data; count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ if(count <= 0) @@ -1171,11 +1166,11 @@ static long snd_mixart_BA0_read(struct snd_info_entry *entry, void *file_private /* mixart_BA1 proc interface for BAR 1 - read callback */ -static long snd_mixart_BA1_read(struct snd_info_entry *entry, void *file_private_data, +static long snd_mixart_BA1_read(snd_info_entry_t *entry, void *file_private_data, struct file *file, char __user *buf, unsigned long count, unsigned long pos) { - struct mixart_mgr *mgr = entry->private_data; + mixart_mgr_t *mgr = entry->private_data; count = count & ~3; /* make sure the read size is a multiple of 4 bytes */ if(count <= 0) @@ -1198,10 +1193,10 @@ static struct snd_info_entry_ops snd_mixart_proc_ops_BA1 = { }; -static void snd_mixart_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_mixart_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_mixart *chip = entry->private_data; + mixart_t *chip = entry->private_data; u32 ref; snd_iprintf(buffer, "Digigram miXart (alsa card %d)\n\n", chip->chip_idx); @@ -1234,9 +1229,9 @@ static void snd_mixart_proc_read(struct snd_info_entry *entry, } /* endif elf loaded */ } -static void __devinit snd_mixart_proc_init(struct snd_mixart *chip) +static void __devinit snd_mixart_proc_init(mixart_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; /* text interface to read perf and temp meters */ if (! snd_card_proc_new(chip->card, "board_info", &entry)) { @@ -1268,7 +1263,7 @@ static int __devinit snd_mixart_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct mixart_mgr *mgr; + mixart_mgr_t *mgr; unsigned int i; int err; size_t size; @@ -1343,12 +1338,12 @@ static int __devinit snd_mixart_probe(struct pci_dev *pci, init_MUTEX(&mgr->setup_mutex); /* init message taslket */ - tasklet_init(&mgr->msg_taskq, snd_mixart_msg_tasklet, (unsigned long) mgr); + tasklet_init( &mgr->msg_taskq, snd_mixart_msg_tasklet, (unsigned long) mgr); /* card assignment */ mgr->num_cards = MIXART_MAX_CARDS; /* 4 FIXME: configurable? */ for (i = 0; i < mgr->num_cards; i++) { - struct snd_card *card; + snd_card_t *card; char tmpid[16]; int idx; @@ -1389,8 +1384,7 @@ static int __devinit snd_mixart_probe(struct pci_dev *pci, mgr->board_type = MIXART_DAUGHTER_TYPE_NONE; /* create array of streaminfo */ - size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS * - sizeof(struct mixart_flowinfo)) ); + size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS * sizeof(mixart_flowinfo_t)) ); if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), size, &mgr->flowinfo) < 0) { snd_mixart_free(mgr); @@ -1400,8 +1394,7 @@ static int __devinit snd_mixart_probe(struct pci_dev *pci, memset(mgr->flowinfo.area, 0, size); /* create array of bufferinfo */ - size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS * - sizeof(struct mixart_bufferinfo)) ); + size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS * sizeof(mixart_bufferinfo_t)) ); if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), size, &mgr->bufferinfo) < 0) { snd_mixart_free(mgr); diff --git a/trunk/sound/pci/mixart/mixart.h b/trunk/sound/pci/mixart/mixart.h index 3e84863ca02c..f87152f94c0e 100644 --- a/trunk/sound/pci/mixart/mixart.h +++ b/trunk/sound/pci/mixart/mixart.h @@ -32,7 +32,21 @@ /* */ -struct mixart_uid { +#define mixart_t_magic 0xa17a3e01 +#define mixart_mgr_t_magic 0xa17a3e02 + +typedef struct snd_mixart mixart_t; +typedef struct snd_mixart_mgr mixart_mgr_t; + +typedef struct snd_mixart_stream mixart_stream_t; +typedef struct snd_mixart_pipe mixart_pipe_t; + +typedef struct mixart_bufferinfo mixart_bufferinfo_t; +typedef struct mixart_flowinfo mixart_flowinfo_t; +typedef struct mixart_uid mixart_uid_t; + +struct mixart_uid +{ u32 object_id; u32 desc; }; @@ -44,6 +58,7 @@ struct mem_area { }; +typedef struct mixart_route mixart_route_t; struct mixart_route { unsigned char connected; unsigned char phase_inv; @@ -62,9 +77,9 @@ struct mixart_route { #define MIXART_MAX_PHYS_CONNECTORS (MIXART_MAX_CARDS * 2 * 2) /* 4 * stereo * (analog+digital) */ -struct mixart_mgr { +struct snd_mixart_mgr { unsigned int num_cards; - struct snd_mixart *chip[MIXART_MAX_CARDS]; + mixart_t *chip[MIXART_MAX_CARDS]; struct pci_dev *pci; @@ -103,7 +118,7 @@ struct mixart_mgr { struct snd_dma_buffer flowinfo; struct snd_dma_buffer bufferinfo; - struct mixart_uid uid_console_manager; + mixart_uid_t uid_console_manager; int sample_rate; int ref_count_rate; @@ -136,9 +151,9 @@ struct mixart_mgr { #define MIXART_NOTIFY_SUBS_MASK 0x007F -struct mixart_stream { - struct snd_pcm_substream *substream; - struct mixart_pipe *pipe; +struct snd_mixart_stream { + snd_pcm_substream_t *substream; + mixart_pipe_t *pipe; int pcm_number; int status; /* nothing, running, draining */ @@ -158,11 +173,11 @@ enum mixart_pipe_status { PIPE_CLOCK_SET }; -struct mixart_pipe { - struct mixart_uid group_uid; /* id of the pipe, as returned by embedded */ +struct snd_mixart_pipe { + mixart_uid_t group_uid; /* id of the pipe, as returned by embedded */ int stream_count; - struct mixart_uid uid_left_connector; /* UID's for the audio connectors */ - struct mixart_uid uid_right_connector; + mixart_uid_t uid_left_connector; /* UID's for the audio connectors */ + mixart_uid_t uid_right_connector; enum mixart_pipe_status status; int references; /* number of subs openned */ int monitoring; /* pipe used for monitoring issue */ @@ -170,28 +185,28 @@ struct mixart_pipe { struct snd_mixart { - struct snd_card *card; - struct mixart_mgr *mgr; + snd_card_t *card; + mixart_mgr_t *mgr; int chip_idx; /* zero based */ - struct snd_hwdep *hwdep; /* DSP loader, only for the first card */ + snd_hwdep_t *hwdep; /* DSP loader, only for the first card */ - struct snd_pcm *pcm; /* PCM analog i/o */ - struct snd_pcm *pcm_dig; /* PCM digital i/o */ + snd_pcm_t *pcm; /* PCM analog i/o */ + snd_pcm_t *pcm_dig; /* PCM digital i/o */ /* allocate stereo pipe for instance */ - struct mixart_pipe pipe_in_ana; - struct mixart_pipe pipe_out_ana; + mixart_pipe_t pipe_in_ana; + mixart_pipe_t pipe_out_ana; /* if AES/EBU daughter board is available, additional pipes possible on pcm_dig */ - struct mixart_pipe pipe_in_dig; - struct mixart_pipe pipe_out_dig; + mixart_pipe_t pipe_in_dig; + mixart_pipe_t pipe_out_dig; - struct mixart_stream playback_stream[MIXART_PCM_TOTAL][MIXART_PLAYBACK_STREAMS]; /* 0 = pcm, 1 = pcm_dig */ - struct mixart_stream capture_stream[MIXART_PCM_TOTAL]; /* 0 = pcm, 1 = pcm_dig */ + mixart_stream_t playback_stream[MIXART_PCM_TOTAL][MIXART_PLAYBACK_STREAMS]; /* 0 = pcm, 1 = pcm_dig */ + mixart_stream_t capture_stream[MIXART_PCM_TOTAL]; /* 0 = pcm, 1 = pcm_dig */ /* UID's for the physical io's */ - struct mixart_uid uid_out_analog_physio; - struct mixart_uid uid_in_analog_physio; + mixart_uid_t uid_out_analog_physio; + mixart_uid_t uid_in_analog_physio; int analog_playback_active[2]; /* Mixer : Master Playback active (!mute) */ int analog_playback_volume[2]; /* Mixer : Master Playback Volume */ @@ -220,8 +235,8 @@ struct mixart_flowinfo }; /* exported */ -int snd_mixart_create_pcm(struct snd_mixart * chip); -struct mixart_pipe *snd_mixart_add_ref_pipe(struct snd_mixart *chip, int pcm_number, int capture, int monitoring); -int snd_mixart_kill_ref_pipe(struct mixart_mgr *mgr, struct mixart_pipe *pipe, int monitoring); +int snd_mixart_create_pcm(mixart_t* chip); +mixart_pipe_t* snd_mixart_add_ref_pipe( mixart_t *chip, int pcm_number, int capture, int monitoring); +int snd_mixart_kill_ref_pipe( mixart_mgr_t *mgr, mixart_pipe_t *pipe, int monitoring); #endif /* __SOUND_MIXART_H */ diff --git a/trunk/sound/pci/mixart/mixart_core.c b/trunk/sound/pci/mixart/mixart_core.c index 07c707d7ebbf..ba0027f50944 100644 --- a/trunk/sound/pci/mixart/mixart_core.c +++ b/trunk/sound/pci/mixart/mixart_core.c @@ -44,7 +44,7 @@ #define MSG_CANCEL_NOTIFY_MASK 0x80000000 /* this bit is set for a notification that has been canceled */ -static int retrieve_msg_frame(struct mixart_mgr *mgr, u32 *msg_frame) +static int retrieve_msg_frame(mixart_mgr_t *mgr, u32 *msg_frame) { /* read the message frame fifo */ u32 headptr, tailptr; @@ -69,8 +69,7 @@ static int retrieve_msg_frame(struct mixart_mgr *mgr, u32 *msg_frame) return 1; } -static int get_msg(struct mixart_mgr *mgr, struct mixart_msg *resp, - u32 msg_frame_address ) +static int get_msg(mixart_mgr_t *mgr, mixart_msg_t *resp, u32 msg_frame_address ) { unsigned long flags; u32 headptr; @@ -138,8 +137,8 @@ static int get_msg(struct mixart_mgr *mgr, struct mixart_msg *resp, * send a message to miXart. return: the msg_frame used for this message */ /* call with mgr->msg_lock held! */ -static int send_msg( struct mixart_mgr *mgr, - struct mixart_msg *msg, +static int send_msg( mixart_mgr_t *mgr, + mixart_msg_t *msg, int max_answersize, int mark_pending, u32 *msg_event) @@ -231,9 +230,9 @@ static int send_msg( struct mixart_mgr *mgr, } -int snd_mixart_send_msg(struct mixart_mgr *mgr, struct mixart_msg *request, int max_resp_size, void *resp_data) +int snd_mixart_send_msg(mixart_mgr_t *mgr, mixart_msg_t *request, int max_resp_size, void *resp_data) { - struct mixart_msg resp; + mixart_msg_t resp; u32 msg_frame = 0; /* set to 0, so it's no notification to wait for, but the answer */ int err; wait_queue_t wait; @@ -265,9 +264,9 @@ int snd_mixart_send_msg(struct mixart_mgr *mgr, struct mixart_msg *request, int return -EIO; } - /* retrieve the answer into the same struct mixart_msg */ + /* retrieve the answer into the same mixart_msg_t */ resp.message_id = 0; - resp.uid = (struct mixart_uid){0,0}; + resp.uid = (mixart_uid_t){0,0}; resp.data = resp_data; resp.size = max_resp_size; @@ -281,8 +280,7 @@ int snd_mixart_send_msg(struct mixart_mgr *mgr, struct mixart_msg *request, int } -int snd_mixart_send_msg_wait_notif(struct mixart_mgr *mgr, - struct mixart_msg *request, u32 notif_event) +int snd_mixart_send_msg_wait_notif(mixart_mgr_t *mgr, mixart_msg_t *request, u32 notif_event) { int err; wait_queue_t wait; @@ -323,7 +321,7 @@ int snd_mixart_send_msg_wait_notif(struct mixart_mgr *mgr, } -int snd_mixart_send_msg_nonblock(struct mixart_mgr *mgr, struct mixart_msg *request) +int snd_mixart_send_msg_nonblock(mixart_mgr_t *mgr, mixart_msg_t *request) { u32 message_frame; unsigned long flags; @@ -334,7 +332,7 @@ int snd_mixart_send_msg_nonblock(struct mixart_mgr *mgr, struct mixart_msg *requ err = send_msg(mgr, request, MSG_DEFAULT_SIZE, 0, &message_frame); spin_unlock_irqrestore(&mgr->msg_lock, flags); - /* the answer will be handled by snd_struct mixart_msgasklet() */ + /* the answer will be handled by snd_mixart_msg_tasklet() */ atomic_inc(&mgr->msg_processed); return err; @@ -345,10 +343,10 @@ int snd_mixart_send_msg_nonblock(struct mixart_mgr *mgr, struct mixart_msg *requ static u32 mixart_msg_data[MSG_DEFAULT_SIZE / 4]; -void snd_mixart_msg_tasklet(unsigned long arg) +void snd_mixart_msg_tasklet( unsigned long arg) { - struct mixart_mgr *mgr = ( struct mixart_mgr*)(arg); - struct mixart_msg resp; + mixart_mgr_t *mgr = ( mixart_mgr_t*)(arg); + mixart_msg_t resp; u32 msg, addr, type; int err; @@ -408,9 +406,9 @@ void snd_mixart_msg_tasklet(unsigned long arg) irqreturn_t snd_mixart_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct mixart_mgr *mgr = dev_id; + mixart_mgr_t *mgr = dev_id; int err; - struct mixart_msg resp; + mixart_msg_t resp; u32 msg; u32 it_reg; @@ -450,8 +448,7 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id, struct pt_regs *regs) if(resp.message_id == MSG_SERVICES_TIMER_NOTIFY) { int i; - struct mixart_timer_notify *notify; - notify = (struct mixart_timer_notify *)mixart_msg_data; + mixart_timer_notify_t *notify = (mixart_timer_notify_t*)mixart_msg_data; for(i=0; i<notify->stream_count; i++) { @@ -461,8 +458,8 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id, struct pt_regs *regs) unsigned int sub_number = buffer_id & MIXART_NOTIFY_SUBS_MASK; /* 0 to MIXART_PLAYBACK_STREAMS */ unsigned int is_capture = ((buffer_id & MIXART_NOTIFY_CAPT_MASK) != 0); /* playback == 0 / capture == 1 */ - struct snd_mixart *chip = mgr->chip[chip_number]; - struct mixart_stream *stream; + mixart_t *chip = mgr->chip[chip_number]; + mixart_stream_t *stream; if ((chip_number >= mgr->num_cards) || (pcm_number >= MIXART_PCM_TOTAL) || (sub_number >= MIXART_PLAYBACK_STREAMS)) { snd_printk(KERN_ERR "error MSG_SERVICES_TIMER_NOTIFY buffer_id (%x) pos(%d)\n", @@ -476,7 +473,7 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id, struct pt_regs *regs) stream = &chip->playback_stream[pcm_number][sub_number]; if (stream->substream && (stream->status == MIXART_STREAM_STATUS_RUNNING)) { - struct snd_pcm_runtime *runtime = stream->substream->runtime; + snd_pcm_runtime_t *runtime = stream->substream->runtime; int elapsed = 0; u64 sample_count = ((u64)notify->streams[i].sample_pos_high_part) << 32; sample_count |= notify->streams[i].sample_pos_low_part; @@ -564,7 +561,7 @@ irqreturn_t snd_mixart_interrupt(int irq, void *dev_id, struct pt_regs *regs) } -void snd_mixart_init_mailbox(struct mixart_mgr *mgr) +void snd_mixart_init_mailbox(mixart_mgr_t *mgr) { writel( 0, MIXART_MEM( mgr, MSG_HOST_RSC_PROTECTION ) ); writel( 0, MIXART_MEM( mgr, MSG_AGENT_RSC_PROTECTION ) ); @@ -576,14 +573,14 @@ void snd_mixart_init_mailbox(struct mixart_mgr *mgr) return; } -void snd_mixart_exit_mailbox(struct mixart_mgr *mgr) +void snd_mixart_exit_mailbox(mixart_mgr_t *mgr) { /* no more interrupts on outbound messagebox */ writel_le( MIXART_HOST_ALL_INTERRUPT_MASKED, MIXART_REG( mgr, MIXART_PCI_OMIMR_OFFSET)); return; } -void snd_mixart_reset_board(struct mixart_mgr *mgr) +void snd_mixart_reset_board(mixart_mgr_t *mgr) { /* reset miXart */ writel_be( 1, MIXART_REG(mgr, MIXART_BA1_BRUTAL_RESET_OFFSET) ); diff --git a/trunk/sound/pci/mixart/mixart_core.h b/trunk/sound/pci/mixart/mixart_core.h index 1fe2bcfcc57c..99450eba15c0 100644 --- a/trunk/sound/pci/mixart/mixart_core.h +++ b/trunk/sound/pci/mixart/mixart_core.h @@ -63,23 +63,25 @@ enum mixart_message_id { }; +typedef struct mixart_msg mixart_msg_t; struct mixart_msg { u32 message_id; - struct mixart_uid uid; + mixart_uid_t uid; void* data; size_t size; }; /* structs used to communicate with miXart */ +typedef struct mixart_enum_connector_resp mixart_enum_connector_resp_t; struct mixart_enum_connector_resp { u32 error_code; u32 first_uid_offset; u32 uid_count; u32 current_uid_index; - struct mixart_uid uid[MIXART_MAX_PHYS_CONNECTORS]; + mixart_uid_t uid[MIXART_MAX_PHYS_CONNECTORS]; } __attribute__((packed)); @@ -88,6 +90,7 @@ struct mixart_enum_connector_resp #define MIXART_FLOAT_M_20_0_TO_HEX 0xc1a00000 /* -20.0f */ #define MIXART_FLOAT____0_0_TO_HEX 0x00000000 /* 0.0f */ +typedef struct mixart_audio_info_req mixart_audio_info_req_t; struct mixart_audio_info_req { u32 line_max_level; /* float */ @@ -95,6 +98,7 @@ struct mixart_audio_info_req u32 cd_max_level; /* float */ } __attribute__((packed)); +typedef struct mixart_analog_hw_info mixart_analog_hw_info_t; struct mixart_analog_hw_info { u32 is_present; @@ -107,6 +111,7 @@ struct mixart_analog_hw_info u32 zero_var; /* float */ } __attribute__((packed)); +typedef struct mixart_digital_hw_info mixart_digital_hw_info_t; struct mixart_digital_hw_info { u32 hw_connection_type; @@ -115,33 +120,37 @@ struct mixart_digital_hw_info u32 reserved; } __attribute__((packed)); +typedef struct mixart_analog_info mixart_analog_info_t; struct mixart_analog_info { u32 type_mask; - struct mixart_analog_hw_info micro_info; - struct mixart_analog_hw_info line_info; - struct mixart_analog_hw_info cd_info; + mixart_analog_hw_info_t micro_info; + mixart_analog_hw_info_t line_info; + mixart_analog_hw_info_t cd_info; u32 analog_level_present; } __attribute__((packed)); +typedef struct mixart_digital_info mixart_digital_info_t; struct mixart_digital_info { u32 type_mask; - struct mixart_digital_hw_info aes_info; - struct mixart_digital_hw_info adat_info; + mixart_digital_hw_info_t aes_info; + mixart_digital_hw_info_t adat_info; } __attribute__((packed)); +typedef struct mixart_audio_info mixart_audio_info_t; struct mixart_audio_info { u32 clock_type_mask; - struct mixart_analog_info analog_info; - struct mixart_digital_info digital_info; + mixart_analog_info_t analog_info; + mixart_digital_info_t digital_info; } __attribute__((packed)); +typedef struct mixart_audio_info_resp mixart_audio_info_resp_t; struct mixart_audio_info_resp { u32 txx_status; - struct mixart_audio_info info; + mixart_audio_info_t info; } __attribute__((packed)); @@ -149,6 +158,7 @@ struct mixart_audio_info_resp #define MIXART_FLOAT_P__4_0_TO_HEX 0x40800000 /* +4.0f */ #define MIXART_FLOAT_P__8_0_TO_HEX 0x41000000 /* +8.0f */ +typedef struct mixart_stream_info mixart_stream_info_t; struct mixart_stream_info { u32 size_max_byte_frame; @@ -159,6 +169,7 @@ struct mixart_stream_info /* MSG_STREAM_ADD_INPUT_GROUP */ /* MSG_STREAM_ADD_OUTPUT_GROUP */ +typedef struct mixart_streaming_group_req mixart_streaming_group_req_t; struct mixart_streaming_group_req { u32 stream_count; @@ -166,30 +177,33 @@ struct mixart_streaming_group_req u32 user_grp_number; u32 first_phys_audio; u32 latency; - struct mixart_stream_info stream_info[32]; - struct mixart_uid connector; + mixart_stream_info_t stream_info[32]; + mixart_uid_t connector; u32 flow_entry[32]; } __attribute__((packed)); +typedef struct mixart_stream_desc mixart_stream_desc_t; struct mixart_stream_desc { - struct mixart_uid stream_uid; + mixart_uid_t stream_uid; u32 stream_desc; } __attribute__((packed)); +typedef struct mixart_streaming_group mixart_streaming_group_t; struct mixart_streaming_group { u32 status; - struct mixart_uid group; + mixart_uid_t group; u32 pipe_desc; u32 stream_count; - struct mixart_stream_desc stream[32]; + mixart_stream_desc_t stream[32]; } __attribute__((packed)); /* MSG_STREAM_DELETE_GROUP */ /* request : mixart_uid_t group */ +typedef struct mixart_delete_group_resp mixart_delete_group_resp_t; struct mixart_delete_group_resp { u32 status; @@ -203,49 +217,55 @@ struct mixart_delete_group_resp MSG_STREAM_STOP_OUTPUT_STAGE_PACKET = 0x130000 + 11, */ +typedef struct mixart_fx_couple_uid mixart_fx_couple_uid_t; struct mixart_fx_couple_uid { - struct mixart_uid uid_fx_code; - struct mixart_uid uid_fx_data; + mixart_uid_t uid_fx_code; + mixart_uid_t uid_fx_data; } __attribute__((packed)); +typedef struct mixart_txx_stream_desc mixart_txx_stream_desc_t; struct mixart_txx_stream_desc { - struct mixart_uid uid_pipe; + mixart_uid_t uid_pipe; u32 stream_idx; u32 fx_number; - struct mixart_fx_couple_uid uid_fx[4]; + mixart_fx_couple_uid_t uid_fx[4]; } __attribute__((packed)); +typedef struct mixart_flow_info mixart_flow_info_t; struct mixart_flow_info { - struct mixart_txx_stream_desc stream_desc; + mixart_txx_stream_desc_t stream_desc; u32 flow_entry; u32 flow_phy_addr; } __attribute__((packed)); +typedef struct mixart_stream_state_req mixart_stream_state_req_t; struct mixart_stream_state_req { u32 delayed; u64 scheduler; u32 reserved4np[3]; u32 stream_count; /* set to 1 for instance */ - struct mixart_flow_info stream_info; /* could be an array[stream_count] */ + mixart_flow_info_t stream_info; /* could be an array[stream_count] */ } __attribute__((packed)); /* MSG_STREAM_START_STREAM_GRP_PACKET = 0x130000 + 6 MSG_STREAM_STOP_STREAM_GRP_PACKET = 0x130000 + 9 */ +typedef struct mixart_group_state_req mixart_group_state_req_t; struct mixart_group_state_req { u32 delayed; u64 scheduler; u32 reserved4np[2]; u32 pipe_count; /* set to 1 for instance */ - struct mixart_uid pipe_uid[1]; /* could be an array[pipe_count] */ + mixart_uid_t pipe_uid[1]; /* could be an array[pipe_count] */ } __attribute__((packed)); +typedef struct mixart_group_state_resp mixart_group_state_resp_t; struct mixart_group_state_resp { u32 txx_status; @@ -256,6 +276,7 @@ struct mixart_group_state_resp /* Structures used by the MSG_SERVICES_TIMER_NOTIFY command */ +typedef struct mixart_sample_pos mixart_sample_pos_t; struct mixart_sample_pos { u32 buffer_id; @@ -264,10 +285,11 @@ struct mixart_sample_pos u32 sample_pos_low_part; } __attribute__((packed)); +typedef struct mixart_timer_notify mixart_timer_notify_t; struct mixart_timer_notify { u32 stream_count; - struct mixart_sample_pos streams[MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS]; + mixart_sample_pos_t streams[MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS]; } __attribute__((packed)); @@ -276,10 +298,11 @@ struct mixart_timer_notify /* request is a uid with desc = MSG_CONSOLE_MANAGER | cardindex */ +typedef struct mixart_return_uid mixart_return_uid_t; struct mixart_return_uid { u32 error_code; - struct mixart_uid uid; + mixart_uid_t uid; } __attribute__((packed)); /* MSG_CLOCK_CHECK_PROPERTIES = 0x200001, @@ -304,6 +327,7 @@ enum mixart_clock_mode { }; +typedef struct mixart_clock_properties mixart_clock_properties_t; struct mixart_clock_properties { u32 error_code; @@ -312,16 +336,17 @@ struct mixart_clock_properties u32 reference_frequency; u32 clock_generic_type; u32 clock_mode; - struct mixart_uid uid_clock_source; - struct mixart_uid uid_event_source; + mixart_uid_t uid_clock_source; + mixart_uid_t uid_event_source; u32 event_mode; u32 synchro_signal_presence; u32 format; u32 board_mask; u32 nb_callers; /* set to 1 (see below) */ - struct mixart_uid uid_caller[1]; + mixart_uid_t uid_caller[1]; } __attribute__((packed)); +typedef struct mixart_clock_properties_resp mixart_clock_properties_resp_t; struct mixart_clock_properties_resp { u32 status; @@ -363,6 +388,7 @@ enum mixart_sample_type { ST_INTEGER_32LE }; +typedef struct mixart_stream_param_desc mixart_stream_param_desc_t; struct mixart_stream_param_desc { u32 coding_type; /* use enum mixart_coding_type */ @@ -406,7 +432,7 @@ struct mixart_stream_param_desc u32 reserved4np[3]; u32 pipe_count; /* set to 1 (array size !) */ u32 stream_count; /* set to 1 (array size !) */ - struct mixart_txx_stream_desc stream_desc[1]; /* only one stream per command, but this could be an array */ + mixart_txx_stream_desc_t stream_desc[1]; /* only one stream per command, but this could be an array */ } __attribute__((packed)); @@ -415,6 +441,7 @@ struct mixart_stream_param_desc */ +typedef struct mixart_get_out_audio_level mixart_get_out_audio_level_t; struct mixart_get_out_audio_level { u32 txx_status; @@ -438,6 +465,7 @@ struct mixart_get_out_audio_level #define MIXART_AUDIO_LEVEL_MUTE_M1_MASK 0x10 #define MIXART_AUDIO_LEVEL_MUTE_M2_MASK 0x20 +typedef struct mixart_set_out_audio_level mixart_set_out_audio_level_t; struct mixart_set_out_audio_level { u32 delayed; @@ -459,13 +487,14 @@ struct mixart_set_out_audio_level #define MIXART_MAX_PHYS_IO (MIXART_MAX_CARDS * 2 * 2) /* 4 * (analog+digital) * (playback+capture) */ +typedef struct mixart_uid_enumeration mixart_uid_enumeration_t; struct mixart_uid_enumeration { u32 error_code; u32 first_uid_offset; u32 nb_uid; u32 current_uid_index; - struct mixart_uid uid[MIXART_MAX_PHYS_IO]; + mixart_uid_t uid[MIXART_MAX_PHYS_IO]; } __attribute__((packed)); @@ -473,38 +502,42 @@ struct mixart_uid_enumeration MSG_PHYSICALIO_GET_LEVEL = 0x0F000C, */ +typedef struct mixart_io_channel_level mixart_io_channel_level_t; struct mixart_io_channel_level { u32 analog_level; /* float */ u32 unused[2]; } __attribute__((packed)); +typedef struct mixart_io_level mixart_io_level_t; struct mixart_io_level { s32 channel; /* 0=left, 1=right, -1=both, -2=both same */ - struct mixart_io_channel_level level[2]; + mixart_io_channel_level_t level[2]; } __attribute__((packed)); /* MSG_STREAM_SET_IN_AUDIO_LEVEL = 0x130015, */ +typedef struct mixart_in_audio_level_info mixart_in_audio_level_info_t; struct mixart_in_audio_level_info { - struct mixart_uid connector; + mixart_uid_t connector; u32 valid_mask1; u32 valid_mask2; u32 digital_level; u32 analog_level; } __attribute__((packed)); +typedef struct mixart_set_in_audio_level_req mixart_set_in_audio_level_req_t; struct mixart_set_in_audio_level_req { u32 delayed; u64 scheduler; u32 audio_count; /* set to <= 2 */ u32 reserved4np; - struct mixart_in_audio_level_info level[2]; + mixart_in_audio_level_info_t level[2]; } __attribute__((packed)); /* response is a 32 bit status */ @@ -523,6 +556,7 @@ struct mixart_set_in_audio_level_req #define MIXART_OUT_STREAM_SET_LEVEL_MUTE_1 0x40 #define MIXART_OUT_STREAM_SET_LEVEL_MUTE_2 0x80 +typedef struct mixart_out_stream_level_info mixart_out_stream_level_info_t; struct mixart_out_stream_level_info { u32 valid_mask1; @@ -537,35 +571,37 @@ struct mixart_out_stream_level_info u32 mute2; } __attribute__((packed)); +typedef struct mixart_set_out_stream_level mixart_set_out_stream_level_t; struct mixart_set_out_stream_level { - struct mixart_txx_stream_desc desc; - struct mixart_out_stream_level_info out_level; + mixart_txx_stream_desc_t desc; + mixart_out_stream_level_info_t out_level; } __attribute__((packed)); +typedef struct mixart_set_out_stream_level_req mixart_set_out_stream_level_req_t; struct mixart_set_out_stream_level_req { u32 delayed; u64 scheduler; u32 reserved4np[2]; u32 nb_of_stream; /* set to 1 */ - struct mixart_set_out_stream_level stream_level; /* could be an array */ + mixart_set_out_stream_level_t stream_level; /* could be an array */ } __attribute__((packed)); /* response to this request is a u32 status value */ /* exported */ -void snd_mixart_init_mailbox(struct mixart_mgr *mgr); -void snd_mixart_exit_mailbox(struct mixart_mgr *mgr); +void snd_mixart_init_mailbox(mixart_mgr_t *mgr); +void snd_mixart_exit_mailbox(mixart_mgr_t *mgr); -int snd_mixart_send_msg(struct mixart_mgr *mgr, struct mixart_msg *request, int max_resp_size, void *resp_data); -int snd_mixart_send_msg_wait_notif(struct mixart_mgr *mgr, struct mixart_msg *request, u32 notif_event); -int snd_mixart_send_msg_nonblock(struct mixart_mgr *mgr, struct mixart_msg *request); +int snd_mixart_send_msg(mixart_mgr_t *mgr, mixart_msg_t *request, int max_resp_size, void *resp_data); +int snd_mixart_send_msg_wait_notif(mixart_mgr_t *mgr, mixart_msg_t *request, u32 notif_event); +int snd_mixart_send_msg_nonblock(mixart_mgr_t *mgr, mixart_msg_t *request); irqreturn_t snd_mixart_interrupt(int irq, void *dev_id, struct pt_regs *regs); -void snd_mixart_msg_tasklet(unsigned long arg); +void snd_mixart_msg_tasklet( unsigned long arg); -void snd_mixart_reset_board(struct mixart_mgr *mgr); +void snd_mixart_reset_board(mixart_mgr_t *mgr); #endif /* __SOUND_MIXART_CORE_H */ diff --git a/trunk/sound/pci/mixart/mixart_hwdep.c b/trunk/sound/pci/mixart/mixart_hwdep.c index ca05075c67c6..edd1599fe45e 100644 --- a/trunk/sound/pci/mixart/mixart_hwdep.c +++ b/trunk/sound/pci/mixart/mixart_hwdep.c @@ -40,9 +40,7 @@ * @param value value * @param timeout timeout in centisenconds */ -static int mixart_wait_nice_for_register_value(struct mixart_mgr *mgr, - u32 offset, int is_egal, - u32 value, unsigned long timeout) +static int mixart_wait_nice_for_register_value(mixart_mgr_t *mgr, u32 offset, int is_egal, u32 value, unsigned long timeout) { unsigned long end_time = jiffies + (timeout * HZ / 100); u32 read; @@ -68,6 +66,8 @@ static int mixart_wait_nice_for_register_value(struct mixart_mgr *mgr, /* structures needed to upload elf code packets */ +typedef struct snd_mixart_elf32_ehdr snd_mixart_elf32_ehdr_t; + struct snd_mixart_elf32_ehdr { u8 e_ident[16]; u16 e_type; @@ -85,6 +85,8 @@ struct snd_mixart_elf32_ehdr { u16 e_shstrndx; }; +typedef struct snd_mixart_elf32_phdr snd_mixart_elf32_phdr_t; + struct snd_mixart_elf32_phdr { u32 p_type; u32 p_offset; @@ -96,19 +98,19 @@ struct snd_mixart_elf32_phdr { u32 p_align; }; -static int mixart_load_elf(struct mixart_mgr *mgr, const struct firmware *dsp ) +static int mixart_load_elf(mixart_mgr_t *mgr, const struct firmware *dsp ) { char elf32_magic_number[4] = {0x7f,'E','L','F'}; - struct snd_mixart_elf32_ehdr *elf_header; + snd_mixart_elf32_ehdr_t *elf_header; int i; - elf_header = (struct snd_mixart_elf32_ehdr *)dsp->data; + elf_header = (snd_mixart_elf32_ehdr_t *)dsp->data; for( i=0; i<4; i++ ) if ( elf32_magic_number[i] != elf_header->e_ident[i] ) return -EINVAL; if( elf_header->e_phoff != 0 ) { - struct snd_mixart_elf32_phdr elf_programheader; + snd_mixart_elf32_phdr_t elf_programheader; for( i=0; i < be16_to_cpu(elf_header->e_phnum); i++ ) { u32 pos = be32_to_cpu(elf_header->e_phoff) + (u32)(i * be16_to_cpu(elf_header->e_phentsize)); @@ -135,14 +137,14 @@ static int mixart_load_elf(struct mixart_mgr *mgr, const struct firmware *dsp ) #define MIXART_FIRST_ANA_AUDIO_ID 0 #define MIXART_FIRST_DIG_AUDIO_ID 8 -static int mixart_enum_connectors(struct mixart_mgr *mgr) +static int mixart_enum_connectors(mixart_mgr_t *mgr) { u32 k; int err; - struct mixart_msg request; - struct mixart_enum_connector_resp *connector; - struct mixart_audio_info_req *audio_info_req; - struct mixart_audio_info_resp *audio_info; + mixart_msg_t request; + mixart_enum_connector_resp_t *connector; + mixart_audio_info_req_t *audio_info_req; + mixart_audio_info_resp_t *audio_info; connector = kmalloc(sizeof(*connector), GFP_KERNEL); audio_info_req = kmalloc(sizeof(*audio_info_req), GFP_KERNEL); @@ -157,7 +159,7 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr) audio_info_req->cd_max_level = MIXART_FLOAT____0_0_TO_HEX; request.message_id = MSG_SYSTEM_ENUM_PLAY_CONNECTOR; - request.uid = (struct mixart_uid){0,0}; /* board num = 0 */ + request.uid = (mixart_uid_t){0,0}; /* board num = 0 */ request.data = NULL; request.size = 0; @@ -169,7 +171,7 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr) } for(k=0; k < connector->uid_count; k++) { - struct mixart_pipe *pipe; + mixart_pipe_t* pipe; if(k < MIXART_FIRST_DIG_AUDIO_ID) { pipe = &mgr->chip[k/2]->pipe_out_ana; @@ -199,7 +201,7 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr) } request.message_id = MSG_SYSTEM_ENUM_RECORD_CONNECTOR; - request.uid = (struct mixart_uid){0,0}; /* board num = 0 */ + request.uid = (mixart_uid_t){0,0}; /* board num = 0 */ request.data = NULL; request.size = 0; @@ -211,7 +213,7 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr) } for(k=0; k < connector->uid_count; k++) { - struct mixart_pipe *pipe; + mixart_pipe_t* pipe; if(k < MIXART_FIRST_DIG_AUDIO_ID) { pipe = &mgr->chip[k/2]->pipe_in_ana; @@ -249,14 +251,14 @@ static int mixart_enum_connectors(struct mixart_mgr *mgr) return err; } -static int mixart_enum_physio(struct mixart_mgr *mgr) +static int mixart_enum_physio(mixart_mgr_t *mgr) { u32 k; int err; - struct mixart_msg request; - struct mixart_uid get_console_mgr; - struct mixart_return_uid console_mgr; - struct mixart_uid_enumeration phys_io; + mixart_msg_t request; + mixart_uid_t get_console_mgr; + mixart_return_uid_t console_mgr; + mixart_uid_enumeration_t phys_io; /* get the uid for the console manager */ get_console_mgr.object_id = 0; @@ -278,7 +280,7 @@ static int mixart_enum_physio(struct mixart_mgr *mgr) mgr->uid_console_manager = console_mgr.uid; request.message_id = MSG_SYSTEM_ENUM_PHYSICAL_IO; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = &console_mgr.uid; request.size = sizeof(console_mgr.uid); @@ -299,11 +301,11 @@ static int mixart_enum_physio(struct mixart_mgr *mgr) } -static int mixart_first_init(struct mixart_mgr *mgr) +static int mixart_first_init(mixart_mgr_t *mgr) { u32 k; int err; - struct mixart_msg request; + mixart_msg_t request; if((err = mixart_enum_connectors(mgr)) < 0) return err; @@ -312,7 +314,7 @@ static int mixart_first_init(struct mixart_mgr *mgr) /* send a synchro command to card (necessary to do this before first MSG_STREAM_START_STREAM_GRP_PACKET) */ /* though why not here */ request.message_id = MSG_SYSTEM_SEND_SYNCHRO_CMD; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = NULL; request.size = 0; /* this command has no data. response is a 32 bit status */ @@ -329,7 +331,7 @@ static int mixart_first_init(struct mixart_mgr *mgr) /* firmware base addresses (when hard coded) */ #define MIXART_MOTHERBOARD_XLX_BASE_ADDRESS 0x00600000 -static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmware *dsp) +static int mixart_dsp_load(mixart_mgr_t* mgr, int index, const struct firmware *dsp) { int err, card_index; u32 status_xilinx, status_elf, status_daught; @@ -511,7 +513,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw /* create devices and mixer in accordance with HW options*/ for (card_index = 0; card_index < mgr->num_cards; card_index++) { - struct snd_mixart *chip = mgr->chip[card_index]; + mixart_t *chip = mgr->chip[card_index]; if ((err = snd_mixart_create_pcm(chip)) < 0) return err; @@ -539,7 +541,7 @@ static int mixart_dsp_load(struct mixart_mgr* mgr, int index, const struct firmw #ifdef SND_MIXART_FW_LOADER -int snd_mixart_setup_firmware(struct mixart_mgr *mgr) +int snd_mixart_setup_firmware(mixart_mgr_t *mgr) { static char *fw_files[3] = { "miXart8.xlx", "miXart8.elf", "miXart8AES.xlx" @@ -571,20 +573,19 @@ int snd_mixart_setup_firmware(struct mixart_mgr *mgr) /* miXart hwdep interface id string */ #define SND_MIXART_HWDEP_ID "miXart Loader" -static int mixart_hwdep_open(struct snd_hwdep *hw, struct file *file) +static int mixart_hwdep_open(snd_hwdep_t *hw, struct file *file) { return 0; } -static int mixart_hwdep_release(struct snd_hwdep *hw, struct file *file) +static int mixart_hwdep_release(snd_hwdep_t *hw, struct file *file) { return 0; } -static int mixart_hwdep_dsp_status(struct snd_hwdep *hw, - struct snd_hwdep_dsp_status *info) +static int mixart_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t *info) { - struct mixart_mgr *mgr = hw->private_data; + mixart_mgr_t *mgr = hw->private_data; strcpy(info->id, "miXart"); info->num_dsps = MIXART_HARDW_FILES_MAX_INDEX; @@ -596,10 +597,9 @@ static int mixart_hwdep_dsp_status(struct snd_hwdep *hw, return 0; } -static int mixart_hwdep_dsp_load(struct snd_hwdep *hw, - struct snd_hwdep_dsp_image *dsp) +static int mixart_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp) { - struct mixart_mgr* mgr = hw->private_data; + mixart_mgr_t* mgr = hw->private_data; struct firmware fw; int err; @@ -622,10 +622,10 @@ static int mixart_hwdep_dsp_load(struct snd_hwdep *hw, return err; } -int snd_mixart_setup_firmware(struct mixart_mgr *mgr) +int snd_mixart_setup_firmware(mixart_mgr_t *mgr) { int err; - struct snd_hwdep *hw; + snd_hwdep_t *hw; /* only create hwdep interface for first cardX (see "index" module parameter)*/ if ((err = snd_hwdep_new(mgr->chip[0]->card, SND_MIXART_HWDEP_ID, 0, &hw)) < 0) diff --git a/trunk/sound/pci/mixart/mixart_hwdep.h b/trunk/sound/pci/mixart/mixart_hwdep.h index a46f5083db99..25190cc88cf8 100644 --- a/trunk/sound/pci/mixart/mixart_hwdep.h +++ b/trunk/sound/pci/mixart/mixart_hwdep.h @@ -140,6 +140,6 @@ #define MIXART_OIDI 0x008 /* 0000 0000 1000 */ -int snd_mixart_setup_firmware(struct mixart_mgr *mgr); +int snd_mixart_setup_firmware(mixart_mgr_t *mgr); #endif /* __SOUND_MIXART_HWDEP_H */ diff --git a/trunk/sound/pci/mixart/mixart_mixer.c b/trunk/sound/pci/mixart/mixart_mixer.c index 36a7e9ddfb15..39c15416fc80 100644 --- a/trunk/sound/pci/mixart/mixart_mixer.c +++ b/trunk/sound/pci/mixart/mixart_mixer.c @@ -298,12 +298,12 @@ static u32 mixart_analog_level[256] = { #define MIXART_ANALOG_PLAYBACK_LEVEL_MAX 192 /* 0.0 dB + 1.5 dB = 1.5 dB */ #define MIXART_ANALOG_PLAYBACK_ZERO_LEVEL 189 /* -1.5 dB + 1.5 dB = 0.0 dB */ -static int mixart_update_analog_audio_level(struct snd_mixart* chip, int is_capture) +static int mixart_update_analog_audio_level(mixart_t* chip, int is_capture) { int i, err; - struct mixart_msg request; - struct mixart_io_level io_level; - struct mixart_return_uid resp; + mixart_msg_t request; + mixart_io_level_t io_level; + mixart_return_uid_t resp; memset(&io_level, 0, sizeof(io_level)); io_level.channel = -1; /* left and right */ @@ -336,7 +336,7 @@ static int mixart_update_analog_audio_level(struct snd_mixart* chip, int is_capt /* * analog level control */ -static int mixart_analog_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixart_analog_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -350,9 +350,9 @@ static int mixart_analog_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int mixart_analog_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_analog_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); down(&chip->mgr->mixer_mutex); if(kcontrol->private_value == 0) { /* playback */ ucontrol->value.integer.value[0] = chip->analog_playback_volume[0]; @@ -365,9 +365,9 @@ static int mixart_analog_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int mixart_analog_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_analog_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int changed = 0; int is_capture, i; @@ -386,7 +386,7 @@ static int mixart_analog_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e return changed; } -static struct snd_kcontrol_new mixart_control_analog_level = { +static snd_kcontrol_new_t mixart_control_analog_level = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, /* name will be filled later */ .info = mixart_analog_vol_info, @@ -395,7 +395,7 @@ static struct snd_kcontrol_new mixart_control_analog_level = { }; /* shared */ -static int mixart_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixart_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -404,9 +404,9 @@ static int mixart_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_inf return 0; } -static int mixart_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_audio_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); down(&chip->mgr->mixer_mutex); ucontrol->value.integer.value[0] = chip->analog_playback_active[0]; @@ -415,9 +415,9 @@ static int mixart_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int mixart_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_audio_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int i, changed = 0; down(&chip->mgr->mixer_mutex); for(i=0; i<2; i++) { @@ -431,7 +431,7 @@ static int mixart_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return changed; } -static struct snd_kcontrol_new mixart_control_output_switch = { +static snd_kcontrol_new_t mixart_control_output_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Switch", .info = mixart_sw_info, /* shared */ @@ -703,14 +703,14 @@ static u32 mixart_digital_level[256] = { #define MIXART_DIGITAL_ZERO_LEVEL 219 /* 0.0 dB */ -int mixart_update_playback_stream_level(struct snd_mixart* chip, int is_aes, int idx) +int mixart_update_playback_stream_level(mixart_t* chip, int is_aes, int idx) { int err, i; int volume[2]; - struct mixart_msg request; - struct mixart_set_out_stream_level_req set_level; + mixart_msg_t request; + mixart_set_out_stream_level_req_t set_level; u32 status; - struct mixart_pipe *pipe; + mixart_pipe_t *pipe; memset(&set_level, 0, sizeof(set_level)); set_level.nb_of_stream = 1; @@ -741,7 +741,7 @@ int mixart_update_playback_stream_level(struct snd_mixart* chip, int is_aes, int set_level.stream_level.out_level.right_to_out2_level = mixart_digital_level[volume[1]]; request.message_id = MSG_STREAM_SET_OUT_STREAM_LEVEL; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = &set_level; request.size = sizeof(set_level); @@ -753,12 +753,12 @@ int mixart_update_playback_stream_level(struct snd_mixart* chip, int is_aes, int return 0; } -int mixart_update_capture_stream_level(struct snd_mixart* chip, int is_aes) +int mixart_update_capture_stream_level(mixart_t* chip, int is_aes) { int err, i, idx; - struct mixart_pipe *pipe; - struct mixart_msg request; - struct mixart_set_in_audio_level_req set_level; + mixart_pipe_t* pipe; + mixart_msg_t request; + mixart_set_in_audio_level_req_t set_level; u32 status; if(is_aes) { @@ -784,7 +784,7 @@ int mixart_update_capture_stream_level(struct snd_mixart* chip, int is_aes) } request.message_id = MSG_STREAM_SET_IN_AUDIO_LEVEL; - request.uid = (struct mixart_uid){0,0}; + request.uid = (mixart_uid_t){0,0}; request.data = &set_level; request.size = sizeof(set_level); @@ -798,7 +798,7 @@ int mixart_update_capture_stream_level(struct snd_mixart* chip, int is_aes) /* shared */ -static int mixart_digital_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixart_digital_vol_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -810,9 +810,9 @@ static int mixart_digital_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl #define MIXART_VOL_REC_MASK 1 #define MIXART_VOL_AES_MASK 2 -static int mixart_pcm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_pcm_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ int *stored_volume; int is_capture = kcontrol->private_value & MIXART_VOL_REC_MASK; @@ -832,9 +832,9 @@ static int mixart_pcm_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int mixart_pcm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_pcm_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ int changed = 0; int is_capture = kcontrol->private_value & MIXART_VOL_REC_MASK; @@ -864,7 +864,7 @@ static int mixart_pcm_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return changed; } -static struct snd_kcontrol_new snd_mixart_pcm_vol = +static snd_kcontrol_new_t snd_mixart_pcm_vol = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, /* name will be filled later */ @@ -875,9 +875,9 @@ static struct snd_kcontrol_new snd_mixart_pcm_vol = }; -static int mixart_pcm_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_pcm_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ snd_assert ( idx < MIXART_PLAYBACK_STREAMS ); down(&chip->mgr->mixer_mutex); @@ -889,9 +889,9 @@ static int mixart_pcm_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int mixart_pcm_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_pcm_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int changed = 0; int is_aes = kcontrol->private_value & MIXART_VOL_AES_MASK; int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ @@ -911,7 +911,7 @@ static int mixart_pcm_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return changed; } -static struct snd_kcontrol_new mixart_control_pcm_switch = { +static snd_kcontrol_new_t mixart_control_pcm_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, /* name will be filled later */ .count = MIXART_PLAYBACK_STREAMS, @@ -920,11 +920,11 @@ static struct snd_kcontrol_new mixart_control_pcm_switch = { .put = mixart_pcm_sw_put }; -static int mixart_update_monitoring(struct snd_mixart* chip, int channel) +static int mixart_update_monitoring(mixart_t* chip, int channel) { int err; - struct mixart_msg request; - struct mixart_set_out_audio_level audio_level; + mixart_msg_t request; + mixart_set_out_audio_level_t audio_level; u32 resp; if(chip->pipe_out_ana.status == PIPE_UNDEFINED) @@ -953,9 +953,9 @@ static int mixart_update_monitoring(struct snd_mixart* chip, int channel) * monitoring level control */ -static int mixart_monitor_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_monitor_vol_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); down(&chip->mgr->mixer_mutex); ucontrol->value.integer.value[0] = chip->monitoring_volume[0]; ucontrol->value.integer.value[1] = chip->monitoring_volume[1]; @@ -963,9 +963,9 @@ static int mixart_monitor_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int mixart_monitor_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_monitor_vol_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int changed = 0; int i; down(&chip->mgr->mixer_mutex); @@ -980,7 +980,7 @@ static int mixart_monitor_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ return changed; } -static struct snd_kcontrol_new mixart_control_monitor_vol = { +static snd_kcontrol_new_t mixart_control_monitor_vol = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitoring Volume", .info = mixart_digital_vol_info, /* shared */ @@ -992,9 +992,9 @@ static struct snd_kcontrol_new mixart_control_monitor_vol = { * monitoring switch control */ -static int mixart_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_monitor_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); down(&chip->mgr->mixer_mutex); ucontrol->value.integer.value[0] = chip->monitoring_active[0]; ucontrol->value.integer.value[1] = chip->monitoring_active[1]; @@ -1002,9 +1002,9 @@ static int mixart_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int mixart_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixart_monitor_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_mixart *chip = snd_kcontrol_chip(kcontrol); + mixart_t *chip = snd_kcontrol_chip(kcontrol); int changed = 0; int i; down(&chip->mgr->mixer_mutex); @@ -1033,7 +1033,7 @@ static int mixart_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e return (changed != 0); } -static struct snd_kcontrol_new mixart_control_monitor_sw = { +static snd_kcontrol_new_t mixart_control_monitor_sw = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitoring Switch", .info = mixart_sw_info, /* shared */ @@ -1042,7 +1042,7 @@ static struct snd_kcontrol_new mixart_control_monitor_sw = { }; -static void mixart_reset_audio_levels(struct snd_mixart *chip) +static void mixart_reset_audio_levels(mixart_t *chip) { /* analog volumes can be set even if there is no pipe */ mixart_update_analog_audio_level(chip, 0); @@ -1054,15 +1054,15 @@ static void mixart_reset_audio_levels(struct snd_mixart *chip) } -int snd_mixart_create_mixer(struct mixart_mgr *mgr) +int snd_mixart_create_mixer(mixart_mgr_t *mgr) { - struct snd_mixart *chip; + mixart_t *chip; int err, i; init_MUTEX(&mgr->mixer_mutex); /* can be in another place */ for(i=0; i<mgr->num_cards; i++) { - struct snd_kcontrol_new temp; + snd_kcontrol_new_t temp; chip = mgr->chip[i]; /* analog output level control */ diff --git a/trunk/sound/pci/mixart/mixart_mixer.h b/trunk/sound/pci/mixart/mixart_mixer.h index 04aa24e35c3f..b4d9535087c4 100644 --- a/trunk/sound/pci/mixart/mixart_mixer.h +++ b/trunk/sound/pci/mixart/mixart_mixer.h @@ -24,8 +24,8 @@ #define __SOUND_MIXART_MIXER_H /* exported */ -int mixart_update_playback_stream_level(struct snd_mixart* chip, int is_aes, int idx); -int mixart_update_capture_stream_level(struct snd_mixart* chip, int is_aes); -int snd_mixart_create_mixer(struct mixart_mgr* mgr); +int mixart_update_playback_stream_level(mixart_t* chip, int is_aes, int idx); +int mixart_update_capture_stream_level(mixart_t* chip, int is_aes); +int snd_mixart_create_mixer(mixart_mgr_t* mgr); #endif /* __SOUND_MIXART_MIXER_H */ diff --git a/trunk/sound/pci/nm256/nm256.c b/trunk/sound/pci/nm256/nm256.c index 0d0ff54f0fc6..089d23b4a002 100644 --- a/trunk/sound/pci/nm256/nm256.c +++ b/trunk/sound/pci/nm256/nm256.c @@ -183,10 +183,17 @@ module_param(enable, bool, 0444); #define NM_PBUFFER_WMARK (NM_PLAYBACK_REG_OFFSET + 0xc) #define NM_PBUFFER_CURRP (NM_PLAYBACK_REG_OFFSET + 0x8) -struct nm256_stream { +/* + * type definitions + */ + +typedef struct snd_nm256 nm256_t; +typedef struct snd_nm256_stream nm256_stream_t; - struct nm256 *chip; - struct snd_pcm_substream *substream; +struct snd_nm256_stream { + + nm256_t *chip; + snd_pcm_substream_t *substream; int running; int suspended; @@ -203,9 +210,9 @@ struct nm256_stream { }; -struct nm256 { +struct snd_nm256 { - struct snd_card *card; + snd_card_t *card; void __iomem *cport; /* control port */ struct resource *res_cport; /* its resource */ @@ -237,11 +244,11 @@ struct nm256 { int badintrcount; /* counter to check bogus interrupts */ struct semaphore irq_mutex; - struct nm256_stream streams[2]; + nm256_stream_t streams[2]; - struct snd_ac97 *ac97; + ac97_t *ac97; - struct snd_pcm *pcm; + snd_pcm_t *pcm; struct pci_dev *pci; @@ -274,49 +281,48 @@ MODULE_DEVICE_TABLE(pci, snd_nm256_ids); */ static inline u8 -snd_nm256_readb(struct nm256 *chip, int offset) +snd_nm256_readb(nm256_t *chip, int offset) { return readb(chip->cport + offset); } static inline u16 -snd_nm256_readw(struct nm256 *chip, int offset) +snd_nm256_readw(nm256_t *chip, int offset) { return readw(chip->cport + offset); } static inline u32 -snd_nm256_readl(struct nm256 *chip, int offset) +snd_nm256_readl(nm256_t *chip, int offset) { return readl(chip->cport + offset); } static inline void -snd_nm256_writeb(struct nm256 *chip, int offset, u8 val) +snd_nm256_writeb(nm256_t *chip, int offset, u8 val) { writeb(val, chip->cport + offset); } static inline void -snd_nm256_writew(struct nm256 *chip, int offset, u16 val) +snd_nm256_writew(nm256_t *chip, int offset, u16 val) { writew(val, chip->cport + offset); } static inline void -snd_nm256_writel(struct nm256 *chip, int offset, u32 val) +snd_nm256_writel(nm256_t *chip, int offset, u32 val) { writel(val, chip->cport + offset); } static inline void -snd_nm256_write_buffer(struct nm256 *chip, void *src, int offset, int size) +snd_nm256_write_buffer(nm256_t *chip, void *src, int offset, int size) { offset -= chip->buffer_start; #ifdef CONFIG_SND_DEBUG if (offset < 0 || offset >= chip->buffer_size) { - snd_printk(KERN_ERR "write_buffer invalid offset = %d size = %d\n", - offset, size); + snd_printk(KERN_ERR "write_buffer invalid offset = %d size = %d\n", offset, size); return; } #endif @@ -337,7 +343,7 @@ snd_nm256_get_start_offset(int which) } static void -snd_nm256_load_one_coefficient(struct nm256 *chip, int stream, u32 port, int which) +snd_nm256_load_one_coefficient(nm256_t *chip, int stream, u32 port, int which) { u32 coeff_buf = chip->coeff_buf[stream]; u16 offset = snd_nm256_get_start_offset(which); @@ -352,15 +358,13 @@ snd_nm256_load_one_coefficient(struct nm256 *chip, int stream, u32 port, int whi } static void -snd_nm256_load_coefficient(struct nm256 *chip, int stream, int number) +snd_nm256_load_coefficient(nm256_t *chip, int stream, int number) { /* The enable register for the specified engine. */ - u32 poffset = (stream == SNDRV_PCM_STREAM_CAPTURE ? - NM_RECORD_ENABLE_REG : NM_PLAYBACK_ENABLE_REG); + u32 poffset = (stream == SNDRV_PCM_STREAM_CAPTURE ? NM_RECORD_ENABLE_REG : NM_PLAYBACK_ENABLE_REG); u32 addr = NM_COEFF_START_OFFSET; - addr += (stream == SNDRV_PCM_STREAM_CAPTURE ? - NM_RECORD_REG_OFFSET : NM_PLAYBACK_REG_OFFSET); + addr += (stream == SNDRV_PCM_STREAM_CAPTURE ? NM_RECORD_REG_OFFSET : NM_PLAYBACK_REG_OFFSET); if (snd_nm256_readb(chip, poffset) & 1) { snd_printd("NM256: Engine was enabled while loading coefficients!\n"); @@ -396,7 +400,7 @@ snd_nm256_load_coefficient(struct nm256 *chip, int stream, int number) static unsigned int samplerates[8] = { 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, }; -static struct snd_pcm_hw_constraint_list constraints_rates = { +static snd_pcm_hw_constraint_list_t constraints_rates = { .count = ARRAY_SIZE(samplerates), .list = samplerates, .mask = 0, @@ -421,10 +425,9 @@ snd_nm256_fixed_rate(unsigned int rate) * set sample rate and format */ static void -snd_nm256_set_format(struct nm256 *chip, struct nm256_stream *s, - struct snd_pcm_substream *substream) +snd_nm256_set_format(nm256_t *chip, nm256_stream_t *s, snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int rate_index = snd_nm256_fixed_rate(runtime->rate); unsigned char ratebits = (rate_index << 4) & NM_RATE_MASK; @@ -457,12 +460,12 @@ snd_nm256_set_format(struct nm256 *chip, struct nm256_stream *s, } /* acquire interrupt */ -static int snd_nm256_acquire_irq(struct nm256 *chip) +static int snd_nm256_acquire_irq(nm256_t *chip) { down(&chip->irq_mutex); if (chip->irq < 0) { if (request_irq(chip->pci->irq, chip->interrupt, SA_INTERRUPT|SA_SHIRQ, - chip->card->driver, chip)) { + chip->card->driver, (void*)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->pci->irq); up(&chip->irq_mutex); return -EBUSY; @@ -475,13 +478,13 @@ static int snd_nm256_acquire_irq(struct nm256 *chip) } /* release interrupt */ -static void snd_nm256_release_irq(struct nm256 *chip) +static void snd_nm256_release_irq(nm256_t *chip) { down(&chip->irq_mutex); if (chip->irq_acks > 0) chip->irq_acks--; if (chip->irq_acks == 0 && chip->irq >= 0) { - free_irq(chip->irq, chip); + free_irq(chip->irq, (void*)chip); chip->irq = -1; } up(&chip->irq_mutex); @@ -492,7 +495,7 @@ static void snd_nm256_release_irq(struct nm256 *chip) */ /* update the watermark (current period) */ -static void snd_nm256_pcm_mark(struct nm256 *chip, struct nm256_stream *s, int reg) +static void snd_nm256_pcm_mark(nm256_t *chip, nm256_stream_t *s, int reg) { s->cur_period++; s->cur_period %= s->periods; @@ -503,8 +506,7 @@ static void snd_nm256_pcm_mark(struct nm256 *chip, struct nm256_stream *s, int r #define snd_nm256_capture_mark(chip, s) snd_nm256_pcm_mark(chip, s, NM_RBUFFER_WMARK) static void -snd_nm256_playback_start(struct nm256 *chip, struct nm256_stream *s, - struct snd_pcm_substream *substream) +snd_nm256_playback_start(nm256_t *chip, nm256_stream_t *s, snd_pcm_substream_t *substream) { /* program buffer pointers */ snd_nm256_writel(chip, NM_PBUFFER_START, s->buf); @@ -520,8 +522,7 @@ snd_nm256_playback_start(struct nm256 *chip, struct nm256_stream *s, } static void -snd_nm256_capture_start(struct nm256 *chip, struct nm256_stream *s, - struct snd_pcm_substream *substream) +snd_nm256_capture_start(nm256_t *chip, nm256_stream_t *s, snd_pcm_substream_t *substream) { /* program buffer pointers */ snd_nm256_writel(chip, NM_RBUFFER_START, s->buf); @@ -536,7 +537,7 @@ snd_nm256_capture_start(struct nm256 *chip, struct nm256_stream *s, /* Stop the play engine. */ static void -snd_nm256_playback_stop(struct nm256 *chip) +snd_nm256_playback_stop(nm256_t *chip) { /* Shut off sound from both channels. */ snd_nm256_writew(chip, NM_AUDIO_MUTE_REG, @@ -546,17 +547,17 @@ snd_nm256_playback_stop(struct nm256 *chip) } static void -snd_nm256_capture_stop(struct nm256 *chip) +snd_nm256_capture_stop(nm256_t *chip) { /* Disable recording engine. */ snd_nm256_writeb(chip, NM_RECORD_ENABLE_REG, 0); } static int -snd_nm256_playback_trigger(struct snd_pcm_substream *substream, int cmd) +snd_nm256_playback_trigger(snd_pcm_substream_t *substream, int cmd) { - struct nm256 *chip = snd_pcm_substream_chip(substream); - struct nm256_stream *s = substream->runtime->private_data; + nm256_t *chip = snd_pcm_substream_chip(substream); + nm256_stream_t *s = (nm256_stream_t*)substream->runtime->private_data; int err = 0; snd_assert(s != NULL, return -ENXIO); @@ -590,10 +591,10 @@ snd_nm256_playback_trigger(struct snd_pcm_substream *substream, int cmd) } static int -snd_nm256_capture_trigger(struct snd_pcm_substream *substream, int cmd) +snd_nm256_capture_trigger(snd_pcm_substream_t *substream, int cmd) { - struct nm256 *chip = snd_pcm_substream_chip(substream); - struct nm256_stream *s = substream->runtime->private_data; + nm256_t *chip = snd_pcm_substream_chip(substream); + nm256_stream_t *s = (nm256_stream_t*)substream->runtime->private_data; int err = 0; snd_assert(s != NULL, return -ENXIO); @@ -626,11 +627,11 @@ snd_nm256_capture_trigger(struct snd_pcm_substream *substream, int cmd) /* * prepare playback/capture channel */ -static int snd_nm256_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_nm256_pcm_prepare(snd_pcm_substream_t *substream) { - struct nm256 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct nm256_stream *s = runtime->private_data; + nm256_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + nm256_stream_t *s = (nm256_stream_t*)runtime->private_data; snd_assert(s, return -ENXIO); s->dma_size = frames_to_bytes(runtime, substream->runtime->buffer_size); @@ -651,10 +652,10 @@ static int snd_nm256_pcm_prepare(struct snd_pcm_substream *substream) * get the current pointer */ static snd_pcm_uframes_t -snd_nm256_playback_pointer(struct snd_pcm_substream *substream) +snd_nm256_playback_pointer(snd_pcm_substream_t * substream) { - struct nm256 *chip = snd_pcm_substream_chip(substream); - struct nm256_stream *s = substream->runtime->private_data; + nm256_t *chip = snd_pcm_substream_chip(substream); + nm256_stream_t *s = (nm256_stream_t*)substream->runtime->private_data; unsigned long curp; snd_assert(s, return 0); @@ -664,10 +665,10 @@ snd_nm256_playback_pointer(struct snd_pcm_substream *substream) } static snd_pcm_uframes_t -snd_nm256_capture_pointer(struct snd_pcm_substream *substream) +snd_nm256_capture_pointer(snd_pcm_substream_t * substream) { - struct nm256 *chip = snd_pcm_substream_chip(substream); - struct nm256_stream *s = substream->runtime->private_data; + nm256_t *chip = snd_pcm_substream_chip(substream); + nm256_stream_t *s = (nm256_stream_t*)substream->runtime->private_data; unsigned long curp; snd_assert(s != NULL, return 0); @@ -683,13 +684,13 @@ snd_nm256_capture_pointer(struct snd_pcm_substream *substream) * silence / copy for playback */ static int -snd_nm256_playback_silence(struct snd_pcm_substream *substream, +snd_nm256_playback_silence(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct nm256_stream *s = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + nm256_stream_t *s = (nm256_stream_t*)runtime->private_data; count = frames_to_bytes(runtime, count); pos = frames_to_bytes(runtime, pos); memset_io(s->bufptr + pos, 0, count); @@ -697,14 +698,14 @@ snd_nm256_playback_silence(struct snd_pcm_substream *substream, } static int -snd_nm256_playback_copy(struct snd_pcm_substream *substream, +snd_nm256_playback_copy(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct nm256_stream *s = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + nm256_stream_t *s = (nm256_stream_t*)runtime->private_data; count = frames_to_bytes(runtime, count); pos = frames_to_bytes(runtime, pos); if (copy_from_user_toio(s->bufptr + pos, src, count)) @@ -716,14 +717,14 @@ snd_nm256_playback_copy(struct snd_pcm_substream *substream, * copy to user */ static int -snd_nm256_capture_copy(struct snd_pcm_substream *substream, +snd_nm256_capture_copy(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct nm256_stream *s = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + nm256_stream_t *s = (nm256_stream_t*)runtime->private_data; count = frames_to_bytes(runtime, count); pos = frames_to_bytes(runtime, pos); if (copy_to_user_fromio(dst, s->bufptr + pos, count)) @@ -740,9 +741,9 @@ snd_nm256_capture_copy(struct snd_pcm_substream *substream, /* spinlock held! */ static void -snd_nm256_playback_update(struct nm256 *chip) +snd_nm256_playback_update(nm256_t *chip) { - struct nm256_stream *s; + nm256_stream_t *s; s = &chip->streams[SNDRV_PCM_STREAM_PLAYBACK]; if (s->running && s->substream) { @@ -755,9 +756,9 @@ snd_nm256_playback_update(struct nm256 *chip) /* spinlock held! */ static void -snd_nm256_capture_update(struct nm256 *chip) +snd_nm256_capture_update(nm256_t *chip) { - struct nm256_stream *s; + nm256_stream_t *s; s = &chip->streams[SNDRV_PCM_STREAM_CAPTURE]; if (s->running && s->substream) { @@ -771,7 +772,7 @@ snd_nm256_capture_update(struct nm256 *chip) /* * hardware info */ -static struct snd_pcm_hardware snd_nm256_playback = +static snd_pcm_hardware_t snd_nm256_playback = { .info = SNDRV_PCM_INFO_MMAP_IOMEM |SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | @@ -790,7 +791,7 @@ static struct snd_pcm_hardware snd_nm256_playback = .period_bytes_max = 128 * 1024, }; -static struct snd_pcm_hardware snd_nm256_capture = +static snd_pcm_hardware_t snd_nm256_capture = { .info = SNDRV_PCM_INFO_MMAP_IOMEM | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | @@ -811,8 +812,7 @@ static struct snd_pcm_hardware snd_nm256_capture = /* set dma transfer size */ -static int snd_nm256_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_nm256_pcm_hw_params(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *hw_params) { /* area and addr are already set and unchanged */ substream->runtime->dma_bytes = params_buffer_bytes(hw_params); @@ -822,11 +822,11 @@ static int snd_nm256_pcm_hw_params(struct snd_pcm_substream *substream, /* * open */ -static void snd_nm256_setup_stream(struct nm256 *chip, struct nm256_stream *s, - struct snd_pcm_substream *substream, - struct snd_pcm_hardware *hw_ptr) +static void snd_nm256_setup_stream(nm256_t *chip, nm256_stream_t *s, + snd_pcm_substream_t *substream, + snd_pcm_hardware_t *hw_ptr) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; s->running = 0; runtime->hw = *hw_ptr; @@ -844,9 +844,9 @@ static void snd_nm256_setup_stream(struct nm256 *chip, struct nm256_stream *s, } static int -snd_nm256_playback_open(struct snd_pcm_substream *substream) +snd_nm256_playback_open(snd_pcm_substream_t *substream) { - struct nm256 *chip = snd_pcm_substream_chip(substream); + nm256_t *chip = snd_pcm_substream_chip(substream); if (snd_nm256_acquire_irq(chip) < 0) return -EBUSY; @@ -856,9 +856,9 @@ snd_nm256_playback_open(struct snd_pcm_substream *substream) } static int -snd_nm256_capture_open(struct snd_pcm_substream *substream) +snd_nm256_capture_open(snd_pcm_substream_t *substream) { - struct nm256 *chip = snd_pcm_substream_chip(substream); + nm256_t *chip = snd_pcm_substream_chip(substream); if (snd_nm256_acquire_irq(chip) < 0) return -EBUSY; @@ -871,9 +871,9 @@ snd_nm256_capture_open(struct snd_pcm_substream *substream) * close - we don't have to do special.. */ static int -snd_nm256_playback_close(struct snd_pcm_substream *substream) +snd_nm256_playback_close(snd_pcm_substream_t *substream) { - struct nm256 *chip = snd_pcm_substream_chip(substream); + nm256_t *chip = snd_pcm_substream_chip(substream); snd_nm256_release_irq(chip); return 0; @@ -881,9 +881,9 @@ snd_nm256_playback_close(struct snd_pcm_substream *substream) static int -snd_nm256_capture_close(struct snd_pcm_substream *substream) +snd_nm256_capture_close(snd_pcm_substream_t *substream) { - struct nm256 *chip = snd_pcm_substream_chip(substream); + nm256_t *chip = snd_pcm_substream_chip(substream); snd_nm256_release_irq(chip); return 0; @@ -892,7 +892,7 @@ snd_nm256_capture_close(struct snd_pcm_substream *substream) /* * create a pcm instance */ -static struct snd_pcm_ops snd_nm256_playback_ops = { +static snd_pcm_ops_t snd_nm256_playback_ops = { .open = snd_nm256_playback_open, .close = snd_nm256_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -907,7 +907,7 @@ static struct snd_pcm_ops snd_nm256_playback_ops = { .mmap = snd_pcm_lib_mmap_iomem, }; -static struct snd_pcm_ops snd_nm256_capture_ops = { +static snd_pcm_ops_t snd_nm256_capture_ops = { .open = snd_nm256_capture_open, .close = snd_nm256_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -922,13 +922,13 @@ static struct snd_pcm_ops snd_nm256_capture_ops = { }; static int __devinit -snd_nm256_pcm(struct nm256 *chip, int device) +snd_nm256_pcm(nm256_t *chip, int device) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int i, err; for (i = 0; i < 2; i++) { - struct nm256_stream *s = &chip->streams[i]; + nm256_stream_t *s = &chip->streams[i]; s->bufptr = chip->buffer + (s->buf - chip->buffer_start); s->bufptr_addr = chip->buffer_addr + (s->buf - chip->buffer_start); } @@ -953,7 +953,7 @@ snd_nm256_pcm(struct nm256 *chip, int device) * Initialize the hardware. */ static void -snd_nm256_init_chip(struct nm256 *chip) +snd_nm256_init_chip(nm256_t *chip) { /* Reset everything. */ snd_nm256_writeb(chip, 0x0, 0x11); @@ -965,7 +965,7 @@ snd_nm256_init_chip(struct nm256 *chip) static irqreturn_t -snd_nm256_intr_check(struct nm256 *chip) +snd_nm256_intr_check(nm256_t *chip) { if (chip->badintrcount++ > 1000) { /* @@ -1002,7 +1002,7 @@ snd_nm256_intr_check(struct nm256 *chip) static irqreturn_t snd_nm256_interrupt(int irq, void *dev_id, struct pt_regs *dummy) { - struct nm256 *chip = dev_id; + nm256_t *chip = dev_id; u16 status; u8 cbyte; @@ -1067,7 +1067,7 @@ snd_nm256_interrupt(int irq, void *dev_id, struct pt_regs *dummy) static irqreturn_t snd_nm256_interrupt_zx(int irq, void *dev_id, struct pt_regs *dummy) { - struct nm256 *chip = dev_id; + nm256_t *chip = dev_id; u32 status; u8 cbyte; @@ -1131,7 +1131,7 @@ snd_nm256_interrupt_zx(int irq, void *dev_id, struct pt_regs *dummy) * if it timed out. */ static int -snd_nm256_ac97_ready(struct nm256 *chip) +snd_nm256_ac97_ready(nm256_t *chip) { int timeout = 10; u32 testaddr; @@ -1154,9 +1154,9 @@ snd_nm256_ac97_ready(struct nm256 *chip) /* */ static unsigned short -snd_nm256_ac97_read(struct snd_ac97 *ac97, unsigned short reg) +snd_nm256_ac97_read(ac97_t *ac97, unsigned short reg) { - struct nm256 *chip = ac97->private_data; + nm256_t *chip = ac97->private_data; int res; if (reg >= 128) @@ -1173,10 +1173,10 @@ snd_nm256_ac97_read(struct snd_ac97 *ac97, unsigned short reg) /* */ static void -snd_nm256_ac97_write(struct snd_ac97 *ac97, +snd_nm256_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct nm256 *chip = ac97->private_data; + nm256_t *chip = ac97->private_data; int tries = 2; u32 base; @@ -1196,9 +1196,9 @@ snd_nm256_ac97_write(struct snd_ac97 *ac97, /* initialize the ac97 into a known state */ static void -snd_nm256_ac97_reset(struct snd_ac97 *ac97) +snd_nm256_ac97_reset(ac97_t *ac97) { - struct nm256 *chip = ac97->private_data; + nm256_t *chip = ac97->private_data; /* Reset the mixer. 'Tis magic! */ snd_nm256_writeb(chip, 0x6c0, 1); @@ -1215,12 +1215,12 @@ snd_nm256_ac97_reset(struct snd_ac97 *ac97) /* create an ac97 mixer interface */ static int __devinit -snd_nm256_mixer(struct nm256 *chip) +snd_nm256_mixer(nm256_t *chip) { - struct snd_ac97_bus *pbus; - struct snd_ac97_template ac97; + ac97_bus_t *pbus; + ac97_template_t ac97; int i, err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .reset = snd_nm256_ac97_reset, .write = snd_nm256_ac97_write, .read = snd_nm256_ac97_read, @@ -1263,7 +1263,7 @@ snd_nm256_mixer(struct nm256 *chip) */ static int __devinit -snd_nm256_peek_for_sig(struct nm256 *chip) +snd_nm256_peek_for_sig(nm256_t *chip) { /* The signature is located 1K below the end of video RAM. */ void __iomem *temp; @@ -1292,8 +1292,7 @@ snd_nm256_peek_for_sig(struct nm256 *chip) return -ENODEV; } else { pointer_found = pointer; - printk(KERN_INFO "nm256: found card signature in video RAM: 0x%x\n", - pointer); + printk(KERN_INFO "nm256: found card signature in video RAM: 0x%x\n", pointer); } } @@ -1308,36 +1307,31 @@ snd_nm256_peek_for_sig(struct nm256 *chip) * APM event handler, so the card is properly reinitialized after a power * event. */ -static int nm256_suspend(struct pci_dev *pci, pm_message_t state) +static int nm256_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct nm256 *chip = card->private_data; + nm256_t *chip = card->pm_private_data; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); snd_ac97_suspend(chip->ac97); chip->coeffs_current = 0; - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -static int nm256_resume(struct pci_dev *pci) +static int nm256_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct nm256 *chip = card->private_data; + nm256_t *chip = card->pm_private_data; int i; /* Perform a full reset on the hardware */ - pci_restore_state(pci); - pci_enable_device(pci); + pci_enable_device(chip->pci); snd_nm256_init_chip(chip); /* restore ac97 */ snd_ac97_resume(chip->ac97); for (i = 0; i < 2; i++) { - struct nm256_stream *s = &chip->streams[i]; + nm256_stream_t *s = &chip->streams[i]; if (s->substream && s->suspended) { spin_lock_irq(&chip->reg_lock); snd_nm256_set_format(chip, s, s->substream); @@ -1345,12 +1339,11 @@ static int nm256_resume(struct pci_dev *pci) } } - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -static int snd_nm256_free(struct nm256 *chip) +static int snd_nm256_free(nm256_t *chip) { if (chip->streams[SNDRV_PCM_STREAM_PLAYBACK].running) snd_nm256_playback_stop(chip); @@ -1367,26 +1360,30 @@ static int snd_nm256_free(struct nm256 *chip) release_and_free_resource(chip->res_cport); release_and_free_resource(chip->res_buffer); if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void*)chip); pci_disable_device(chip->pci); kfree(chip); return 0; } -static int snd_nm256_dev_free(struct snd_device *device) +static int snd_nm256_dev_free(snd_device_t *device) { - struct nm256 *chip = device->device_data; + nm256_t *chip = device->device_data; return snd_nm256_free(chip); } static int __devinit -snd_nm256_create(struct snd_card *card, struct pci_dev *pci, - struct nm256 **chip_ret) +snd_nm256_create(snd_card_t *card, struct pci_dev *pci, + int play_bufsize, int capt_bufsize, + int force_load, + u32 buffertop, + int usecache, + nm256_t **chip_ret) { - struct nm256 *chip; + nm256_t *chip; int err, pval; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_nm256_dev_free, }; u32 addr; @@ -1404,14 +1401,13 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci, chip->card = card; chip->pci = pci; - chip->use_cache = use_cache; + chip->use_cache = usecache; spin_lock_init(&chip->reg_lock); chip->irq = -1; init_MUTEX(&chip->irq_mutex); - /* store buffer sizes in bytes */ - chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize = playback_bufsize * 1024; - chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize = capture_bufsize * 1024; + chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize = play_bufsize; + chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize = capt_bufsize; /* * The NM256 has two memory ports. The first port is nothing @@ -1444,10 +1440,9 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci, /* Ok, try to see if this is a non-AC97 version of the hardware. */ pval = snd_nm256_readw(chip, NM_MIXER_PRESENCE); if ((pval & NM_PRESENCE_MASK) != NM_PRESENCE_VALUE) { - if (! force_ac97) { + if (! force_load) { printk(KERN_ERR "nm256: no ac97 is found!\n"); - printk(KERN_ERR " force the driver to load by " - "passing in the module parameter\n"); + printk(KERN_ERR " force the driver to load by passing in the module parameter\n"); printk(KERN_ERR " force_ac97=1\n"); printk(KERN_ERR " or try sb16 or cs423x drivers instead.\n"); err = -ENXIO; @@ -1470,15 +1465,14 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci, chip->mixer_status_mask = NM2_MIXER_READY_MASK; } - chip->buffer_size = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize + - chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize; + chip->buffer_size = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize + chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize; if (chip->use_cache) chip->buffer_size += NM_TOTAL_COEFF_COUNT * 4; else chip->buffer_size += NM_MAX_PLAYBACK_COEF_SIZE + NM_MAX_RECORD_COEF_SIZE; - if (buffer_top >= chip->buffer_size && buffer_top < chip->buffer_end) - chip->buffer_end = buffer_top; + if (buffertop >= chip->buffer_size && buffertop < chip->buffer_end) + chip->buffer_end = buffertop; else { /* get buffer end pointer from signature */ if ((err = snd_nm256_peek_for_sig(chip)) < 0) @@ -1530,6 +1524,8 @@ snd_nm256_create(struct snd_card *card, struct pci_dev *pci, // pci_set_master(pci); /* needed? */ + snd_card_set_pm_callback(card, nm256_suspend, nm256_resume, chip); + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) goto __error; @@ -1568,9 +1564,10 @@ static struct nm256_quirk nm256_quirks[] __devinitdata = { static int __devinit snd_nm256_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct nm256 *chip; + snd_card_t *card; + nm256_t *chip; int err; + unsigned int xbuffer_top; struct nm256_quirk *q; u16 subsystem_vendor, subsystem_device; @@ -1581,8 +1578,7 @@ static int __devinit snd_nm256_probe(struct pci_dev *pci, if (q->vendor == subsystem_vendor && q->device == subsystem_device) { switch (q->type) { case NM_BLACKLISTED: - printk(KERN_INFO "nm256: The device is blacklisted. " - "Loading stopped\n"); + printk(KERN_INFO "nm256: The device is blacklisted. Loading stopped\n"); return -ENODEV; case NM_RESET_WORKAROUND_2: reset_workaround_2 = 1; @@ -1615,7 +1611,9 @@ static int __devinit snd_nm256_probe(struct pci_dev *pci, } if (vaio_hack) - buffer_top = 0x25a800; /* this avoids conflicts with XFree86 server */ + xbuffer_top = 0x25a800; /* this avoids conflicts with XFree86 server */ + else + xbuffer_top = buffer_top; if (playback_bufsize < 4) playback_bufsize = 4; @@ -1625,11 +1623,16 @@ static int __devinit snd_nm256_probe(struct pci_dev *pci, capture_bufsize = 4; if (capture_bufsize > 128) capture_bufsize = 128; - if ((err = snd_nm256_create(card, pci, &chip)) < 0) { + if ((err = snd_nm256_create(card, pci, + playback_bufsize * 1024, /* in bytes */ + capture_bufsize * 1024, /* in bytes */ + force_ac97, + xbuffer_top, + use_cache, + &chip)) < 0) { snd_card_free(card); return err; } - card->private_data = chip; if (reset_workaround) { snd_printdd(KERN_INFO "nm256: reset_workaround activated\n"); @@ -1673,10 +1676,7 @@ static struct pci_driver driver = { .id_table = snd_nm256_ids, .probe = snd_nm256_probe, .remove = __devexit_p(snd_nm256_remove), -#ifdef CONFIG_PM - .suspend = nm256_suspend, - .resume = nm256_resume, -#endif + SND_PCI_PM_CALLBACKS }; diff --git a/trunk/sound/pci/pcxhr/Makefile b/trunk/sound/pci/pcxhr/Makefile deleted file mode 100644 index 10473c05918d..000000000000 --- a/trunk/sound/pci/pcxhr/Makefile +++ /dev/null @@ -1,2 +0,0 @@ -snd-pcxhr-objs := pcxhr.o pcxhr_hwdep.o pcxhr_mixer.o pcxhr_core.o -obj-$(CONFIG_SND_PCXHR) += snd-pcxhr.o diff --git a/trunk/sound/pci/pcxhr/pcxhr.c b/trunk/sound/pci/pcxhr/pcxhr.c deleted file mode 100644 index b8c0853a8278..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr.c +++ /dev/null @@ -1,1367 +0,0 @@ -/* - * Driver for Digigram pcxhr compatible soundcards - * - * main file with alsa callbacks - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - - -#include <sound/driver.h> -#include <linux/init.h> -#include <linux/interrupt.h> -#include <linux/slab.h> -#include <linux/pci.h> -#include <linux/delay.h> -#include <linux/moduleparam.h> -#include <sound/core.h> -#include <sound/initval.h> -#include <sound/info.h> -#include <sound/control.h> -#include <sound/pcm.h> -#include <sound/pcm_params.h> -#include "pcxhr.h" -#include "pcxhr_mixer.h" -#include "pcxhr_hwdep.h" -#include "pcxhr_core.h" - -#define DRIVER_NAME "pcxhr" - -MODULE_AUTHOR("Markus Bollinger <bollinger@digigram.com>"); -MODULE_DESCRIPTION("Digigram " DRIVER_NAME " " PCXHR_DRIVER_VERSION_STRING); -MODULE_LICENSE("GPL"); -MODULE_SUPPORTED_DEVICE("{{Digigram," DRIVER_NAME "}}"); - -static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ -static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ -static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ -static int mono[SNDRV_CARDS]; /* capture in mono only */ - -module_param_array(index, int, NULL, 0444); -MODULE_PARM_DESC(index, "Index value for Digigram " DRIVER_NAME " soundcard"); -module_param_array(id, charp, NULL, 0444); -MODULE_PARM_DESC(id, "ID string for Digigram " DRIVER_NAME " soundcard"); -module_param_array(enable, bool, NULL, 0444); -MODULE_PARM_DESC(enable, "Enable Digigram " DRIVER_NAME " soundcard"); -module_param_array(mono, bool, NULL, 0444); -MODULE_PARM_DESC(mono, "Mono capture mode (default is stereo)"); - -enum { - PCI_ID_VX882HR, - PCI_ID_PCX882HR, - PCI_ID_VX881HR, - PCI_ID_PCX881HR, - PCI_ID_PCX1222HR, - PCI_ID_PCX1221HR, - PCI_ID_LAST -}; - -static struct pci_device_id pcxhr_ids[] = { - { 0x10b5, 0x9656, 0x1369, 0xb001, 0, 0, PCI_ID_VX882HR, }, /* VX882HR */ - { 0x10b5, 0x9656, 0x1369, 0xb101, 0, 0, PCI_ID_PCX882HR, }, /* PCX882HR */ - { 0x10b5, 0x9656, 0x1369, 0xb201, 0, 0, PCI_ID_VX881HR, }, /* VX881HR */ - { 0x10b5, 0x9656, 0x1369, 0xb301, 0, 0, PCI_ID_PCX881HR, }, /* PCX881HR */ - { 0x10b5, 0x9656, 0x1369, 0xb501, 0, 0, PCI_ID_PCX1222HR, }, /* PCX1222HR */ - { 0x10b5, 0x9656, 0x1369, 0xb701, 0, 0, PCI_ID_PCX1221HR, }, /* PCX1221HR */ - { 0, } -}; - -MODULE_DEVICE_TABLE(pci, pcxhr_ids); - -struct board_parameters { - char* board_name; - short playback_chips; - short capture_chips; - short firmware_num; -}; -static struct board_parameters pcxhr_board_params[] = { -[PCI_ID_VX882HR] = { "VX882HR", 4, 4, 41, }, -[PCI_ID_PCX882HR] = { "PCX882HR", 4, 4, 41, }, -[PCI_ID_VX881HR] = { "VX881HR", 4, 4, 41, }, -[PCI_ID_PCX881HR] = { "PCX881HR", 4, 4, 41, }, -[PCI_ID_PCX1222HR] = { "PCX1222HR", 6, 1, 42, }, -[PCI_ID_PCX1221HR] = { "PCX1221HR", 6, 1, 42, }, -}; - - -static int pcxhr_pll_freq_register(unsigned int freq, unsigned int* pllreg, - unsigned int* realfreq) -{ - unsigned int reg; - - if (freq < 6900 || freq > 110250) - return -EINVAL; - reg = (28224000 * 10) / freq; - reg = (reg + 5) / 10; - if (reg < 0x200) - *pllreg = reg + 0x800; - else if (reg < 0x400) - *pllreg = reg & 0x1ff; - else if (reg < 0x800) { - *pllreg = ((reg >> 1) & 0x1ff) + 0x200; - reg &= ~1; - } else { - *pllreg = ((reg >> 2) & 0x1ff) + 0x400; - reg &= ~3; - } - if (realfreq) - *realfreq = ((28224000 * 10) / reg + 5) / 10; - return 0; -} - - -#define PCXHR_FREQ_REG_MASK 0x1f -#define PCXHR_FREQ_QUARTZ_48000 0x00 -#define PCXHR_FREQ_QUARTZ_24000 0x01 -#define PCXHR_FREQ_QUARTZ_12000 0x09 -#define PCXHR_FREQ_QUARTZ_32000 0x08 -#define PCXHR_FREQ_QUARTZ_16000 0x04 -#define PCXHR_FREQ_QUARTZ_8000 0x0c -#define PCXHR_FREQ_QUARTZ_44100 0x02 -#define PCXHR_FREQ_QUARTZ_22050 0x0a -#define PCXHR_FREQ_QUARTZ_11025 0x06 -#define PCXHR_FREQ_PLL 0x05 -#define PCXHR_FREQ_QUARTZ_192000 0x10 -#define PCXHR_FREQ_QUARTZ_96000 0x18 -#define PCXHR_FREQ_QUARTZ_176400 0x14 -#define PCXHR_FREQ_QUARTZ_88200 0x1c -#define PCXHR_FREQ_QUARTZ_128000 0x12 -#define PCXHR_FREQ_QUARTZ_64000 0x1a - -#define PCXHR_FREQ_WORD_CLOCK 0x0f -#define PCXHR_FREQ_SYNC_AES 0x0e -#define PCXHR_FREQ_AES_1 0x07 -#define PCXHR_FREQ_AES_2 0x0b -#define PCXHR_FREQ_AES_3 0x03 -#define PCXHR_FREQ_AES_4 0x0d - -#define PCXHR_MODIFY_CLOCK_S_BIT 0x04 - -#define PCXHR_IRQ_TIMER_FREQ 92000 -#define PCXHR_IRQ_TIMER_PERIOD 48 - -static int pcxhr_get_clock_reg(struct pcxhr_mgr *mgr, unsigned int rate, - unsigned int *reg, unsigned int *freq) -{ - unsigned int val, realfreq, pllreg; - struct pcxhr_rmh rmh; - int err; - - realfreq = rate; - switch (mgr->use_clock_type) { - case PCXHR_CLOCK_TYPE_INTERNAL : /* clock by quartz or pll */ - switch (rate) { - case 48000 : val = PCXHR_FREQ_QUARTZ_48000; break; - case 24000 : val = PCXHR_FREQ_QUARTZ_24000; break; - case 12000 : val = PCXHR_FREQ_QUARTZ_12000; break; - case 32000 : val = PCXHR_FREQ_QUARTZ_32000; break; - case 16000 : val = PCXHR_FREQ_QUARTZ_16000; break; - case 8000 : val = PCXHR_FREQ_QUARTZ_8000; break; - case 44100 : val = PCXHR_FREQ_QUARTZ_44100; break; - case 22050 : val = PCXHR_FREQ_QUARTZ_22050; break; - case 11025 : val = PCXHR_FREQ_QUARTZ_11025; break; - case 192000 : val = PCXHR_FREQ_QUARTZ_192000; break; - case 96000 : val = PCXHR_FREQ_QUARTZ_96000; break; - case 176400 : val = PCXHR_FREQ_QUARTZ_176400; break; - case 88200 : val = PCXHR_FREQ_QUARTZ_88200; break; - case 128000 : val = PCXHR_FREQ_QUARTZ_128000; break; - case 64000 : val = PCXHR_FREQ_QUARTZ_64000; break; - default : - val = PCXHR_FREQ_PLL; - /* get the value for the pll register */ - err = pcxhr_pll_freq_register(rate, &pllreg, &realfreq); - if (err) - return err; - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); - rmh.cmd[0] |= IO_NUM_REG_GENCLK; - rmh.cmd[1] = pllreg & MASK_DSP_WORD; - rmh.cmd[2] = pllreg >> 24; - rmh.cmd_len = 3; - err = pcxhr_send_msg(mgr, &rmh); - if (err < 0) { - snd_printk(KERN_ERR - "error CMD_ACCESS_IO_WRITE for PLL register : %x!\n", - err ); - return err; - } - } - break; - case PCXHR_CLOCK_TYPE_WORD_CLOCK : val = PCXHR_FREQ_WORD_CLOCK; break; - case PCXHR_CLOCK_TYPE_AES_SYNC : val = PCXHR_FREQ_SYNC_AES; break; - case PCXHR_CLOCK_TYPE_AES_1 : val = PCXHR_FREQ_AES_1; break; - case PCXHR_CLOCK_TYPE_AES_2 : val = PCXHR_FREQ_AES_2; break; - case PCXHR_CLOCK_TYPE_AES_3 : val = PCXHR_FREQ_AES_3; break; - case PCXHR_CLOCK_TYPE_AES_4 : val = PCXHR_FREQ_AES_4; break; - default : return -EINVAL; - } - *reg = val; - *freq = realfreq; - return 0; -} - - -int pcxhr_set_clock(struct pcxhr_mgr *mgr, unsigned int rate) -{ - unsigned int val, realfreq, speed; - struct pcxhr_rmh rmh; - int err, changed; - - if (rate == 0) - return 0; /* nothing to do */ - - err = pcxhr_get_clock_reg(mgr, rate, &val, &realfreq); - if (err) - return err; - - /* codec speed modes */ - if (rate < 55000) - speed = 0; /* single speed */ - else if (rate < 100000) - speed = 1; /* dual speed */ - else - speed = 2; /* quad speed */ - if (mgr->codec_speed != speed) { - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); /* mute outputs */ - rmh.cmd[0] |= IO_NUM_REG_MUTE_OUT; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); /* set speed ratio */ - rmh.cmd[0] |= IO_NUM_SPEED_RATIO; - rmh.cmd[1] = speed; - rmh.cmd_len = 2; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - } - /* set the new frequency */ - snd_printdd("clock register : set %x\n", val); - err = pcxhr_write_io_num_reg_cont(mgr, PCXHR_FREQ_REG_MASK, val, &changed); - if (err) - return err; - mgr->sample_rate_real = realfreq; - mgr->cur_clock_type = mgr->use_clock_type; - - /* unmute after codec speed modes */ - if (mgr->codec_speed != speed) { - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ); /* unmute outputs */ - rmh.cmd[0] |= IO_NUM_REG_MUTE_OUT; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - mgr->codec_speed = speed; /* save new codec speed */ - } - - if (changed) { - pcxhr_init_rmh(&rmh, CMD_MODIFY_CLOCK); - rmh.cmd[0] |= PCXHR_MODIFY_CLOCK_S_BIT; /* resync fifos */ - if (rate < PCXHR_IRQ_TIMER_FREQ) - rmh.cmd[1] = PCXHR_IRQ_TIMER_PERIOD; - else - rmh.cmd[1] = PCXHR_IRQ_TIMER_PERIOD * 2; - rmh.cmd[2] = rate; - rmh.cmd_len = 3; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - } - snd_printdd("pcxhr_set_clock to %dHz (realfreq=%d)\n", rate, realfreq); - return 0; -} - - -int pcxhr_get_external_clock(struct pcxhr_mgr *mgr, enum pcxhr_clock_type clock_type, - int *sample_rate) -{ - struct pcxhr_rmh rmh; - unsigned char reg; - int err, rate; - - switch (clock_type) { - case PCXHR_CLOCK_TYPE_WORD_CLOCK : reg = REG_STATUS_WORD_CLOCK; break; - case PCXHR_CLOCK_TYPE_AES_SYNC : reg = REG_STATUS_AES_SYNC; break; - case PCXHR_CLOCK_TYPE_AES_1 : reg = REG_STATUS_AES_1; break; - case PCXHR_CLOCK_TYPE_AES_2 : reg = REG_STATUS_AES_2; break; - case PCXHR_CLOCK_TYPE_AES_3 : reg = REG_STATUS_AES_3; break; - case PCXHR_CLOCK_TYPE_AES_4 : reg = REG_STATUS_AES_4; break; - default : return -EINVAL; - } - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ); - rmh.cmd_len = 2; - rmh.cmd[0] |= IO_NUM_REG_STATUS; - if (mgr->last_reg_stat != reg) { - rmh.cmd[1] = reg; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - udelay(100); /* wait minimum 2 sample_frames at 32kHz ! */ - mgr->last_reg_stat = reg; - } - rmh.cmd[1] = REG_STATUS_CURRENT; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - switch (rmh.stat[1] & 0x0f) { - case REG_STATUS_SYNC_32000 : rate = 32000; break; - case REG_STATUS_SYNC_44100 : rate = 44100; break; - case REG_STATUS_SYNC_48000 : rate = 48000; break; - case REG_STATUS_SYNC_64000 : rate = 64000; break; - case REG_STATUS_SYNC_88200 : rate = 88200; break; - case REG_STATUS_SYNC_96000 : rate = 96000; break; - case REG_STATUS_SYNC_128000 : rate = 128000; break; - case REG_STATUS_SYNC_176400 : rate = 176400; break; - case REG_STATUS_SYNC_192000 : rate = 192000; break; - default: rate = 0; - } - snd_printdd("External clock is at %d Hz\n", rate); - *sample_rate = rate; - return 0; -} - - -/* - * start or stop playback/capture substream - */ -static int pcxhr_set_stream_state(struct pcxhr_stream *stream) -{ - int err; - struct snd_pcxhr *chip; - struct pcxhr_rmh rmh; - int stream_mask, start; - - if (stream->status == PCXHR_STREAM_STATUS_SCHEDULE_RUN) - start = 1; - else { - if (stream->status != PCXHR_STREAM_STATUS_SCHEDULE_STOP) { - snd_printk(KERN_ERR "ERROR pcxhr_set_stream_state CANNOT be stopped\n"); - return -EINVAL; - } - start = 0; - } - if (!stream->substream) - return -EINVAL; - - stream->timer_abs_periods = 0; - stream->timer_period_frag = 0; /* reset theoretical stream pos */ - stream->timer_buf_periods = 0; - stream->timer_is_synced = 0; - - stream_mask = stream->pipe->is_capture ? 1 : 1<<stream->substream->number; - - pcxhr_init_rmh(&rmh, start ? CMD_START_STREAM : CMD_STOP_STREAM); - pcxhr_set_pipe_cmd_params(&rmh, stream->pipe->is_capture, - stream->pipe->first_audio, 0, stream_mask); - - chip = snd_pcm_substream_chip(stream->substream); - - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err) - snd_printk(KERN_ERR "ERROR pcxhr_set_stream_state err=%x;\n", err); - stream->status = start ? PCXHR_STREAM_STATUS_STARTED : PCXHR_STREAM_STATUS_STOPPED; - return err; -} - -#define HEADER_FMT_BASE_LIN 0xfed00000 -#define HEADER_FMT_BASE_FLOAT 0xfad00000 -#define HEADER_FMT_INTEL 0x00008000 -#define HEADER_FMT_24BITS 0x00004000 -#define HEADER_FMT_16BITS 0x00002000 -#define HEADER_FMT_UPTO11 0x00000200 -#define HEADER_FMT_UPTO32 0x00000100 -#define HEADER_FMT_MONO 0x00000080 - -static int pcxhr_set_format(struct pcxhr_stream *stream) -{ - int err, is_capture, sample_rate, stream_num; - struct snd_pcxhr *chip; - struct pcxhr_rmh rmh; - unsigned int header; - - switch (stream->format) { - case SNDRV_PCM_FORMAT_U8: - header = HEADER_FMT_BASE_LIN; - break; - case SNDRV_PCM_FORMAT_S16_LE: - header = HEADER_FMT_BASE_LIN | HEADER_FMT_16BITS | HEADER_FMT_INTEL; - break; - case SNDRV_PCM_FORMAT_S16_BE: - header = HEADER_FMT_BASE_LIN | HEADER_FMT_16BITS; - break; - case SNDRV_PCM_FORMAT_S24_3LE: - header = HEADER_FMT_BASE_LIN | HEADER_FMT_24BITS | HEADER_FMT_INTEL; - break; - case SNDRV_PCM_FORMAT_S24_3BE: - header = HEADER_FMT_BASE_LIN | HEADER_FMT_24BITS; - break; - case SNDRV_PCM_FORMAT_FLOAT_LE: - header = HEADER_FMT_BASE_FLOAT | HEADER_FMT_INTEL; - break; - default: - snd_printk(KERN_ERR "error pcxhr_set_format() : unknown format\n"); - return -EINVAL; - } - chip = snd_pcm_substream_chip(stream->substream); - - sample_rate = chip->mgr->sample_rate; - if (sample_rate <= 32000 && sample_rate !=0) { - if (sample_rate <= 11025) - header |= HEADER_FMT_UPTO11; - else - header |= HEADER_FMT_UPTO32; - } - if (stream->channels == 1) - header |= HEADER_FMT_MONO; - - is_capture = stream->pipe->is_capture; - stream_num = is_capture ? 0 : stream->substream->number; - - pcxhr_init_rmh(&rmh, is_capture ? CMD_FORMAT_STREAM_IN : CMD_FORMAT_STREAM_OUT); - pcxhr_set_pipe_cmd_params(&rmh, is_capture, stream->pipe->first_audio, stream_num, 0); - if (is_capture) - rmh.cmd[0] |= 1<<12; - rmh.cmd[1] = 0; - rmh.cmd[2] = header >> 8; - rmh.cmd[3] = (header & 0xff) << 16; - rmh.cmd_len = 4; - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err) - snd_printk(KERN_ERR "ERROR pcxhr_set_format err=%x;\n", err); - return err; -} - -static int pcxhr_update_r_buffer(struct pcxhr_stream *stream) -{ - int err, is_capture, stream_num; - struct pcxhr_rmh rmh; - struct snd_pcm_substream *subs = stream->substream; - struct snd_pcxhr *chip = snd_pcm_substream_chip(subs); - - is_capture = (subs->stream == SNDRV_PCM_STREAM_CAPTURE); - stream_num = is_capture ? 0 : subs->number; - - snd_printdd("pcxhr_update_r_buffer(pcm%c%d) : addr(%p) bytes(%x) subs(%d)\n", - is_capture ? 'c' : 'p', - chip->chip_idx, (void*)subs->runtime->dma_addr, - subs->runtime->dma_bytes, subs->number); - - pcxhr_init_rmh(&rmh, CMD_UPDATE_R_BUFFERS); - pcxhr_set_pipe_cmd_params(&rmh, is_capture, stream->pipe->first_audio, stream_num, 0); - - snd_assert(subs->runtime->dma_bytes < 0x200000); /* max buffer size is 2 MByte */ - rmh.cmd[1] = subs->runtime->dma_bytes * 8; /* size in bits */ - rmh.cmd[2] = subs->runtime->dma_addr >> 24; /* most significant byte */ - rmh.cmd[2] |= 1<<19; /* this is a circular buffer */ - rmh.cmd[3] = subs->runtime->dma_addr & MASK_DSP_WORD; /* least 3 significant bytes */ - rmh.cmd_len = 4; - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err) - snd_printk(KERN_ERR "ERROR CMD_UPDATE_R_BUFFERS err=%x;\n", err); - return err; -} - - -#if 0 -static int pcxhr_pipe_sample_count(struct pcxhr_stream *stream, snd_pcm_uframes_t *sample_count) -{ - struct pcxhr_rmh rmh; - int err; - pcxhr_t *chip = snd_pcm_substream_chip(stream->substream); - pcxhr_init_rmh(&rmh, CMD_PIPE_SAMPLE_COUNT); - pcxhr_set_pipe_cmd_params(&rmh, stream->pipe->is_capture, 0, 0, - 1<<stream->pipe->first_audio); - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err == 0) { - *sample_count = ((snd_pcm_uframes_t)rmh.stat[0]) << 24; - *sample_count += (snd_pcm_uframes_t)rmh.stat[1]; - } - snd_printdd("PIPE_SAMPLE_COUNT = %lx\n", *sample_count); - return err; -} -#endif - -static inline int pcxhr_stream_scheduled_get_pipe(struct pcxhr_stream *stream, - struct pcxhr_pipe **pipe) -{ - if (stream->status == PCXHR_STREAM_STATUS_SCHEDULE_RUN) { - *pipe = stream->pipe; - return 1; - } - return 0; -} - -static void pcxhr_trigger_tasklet(unsigned long arg) -{ - unsigned long flags; - int i, j, err; - struct pcxhr_pipe *pipe; - struct snd_pcxhr *chip; - struct pcxhr_mgr *mgr = (struct pcxhr_mgr*)(arg); - int capture_mask = 0; - int playback_mask = 0; - -#ifdef CONFIG_SND_DEBUG_DETECT - struct timeval my_tv1, my_tv2; - do_gettimeofday(&my_tv1); -#endif - down(&mgr->setup_mutex); - - /* check the pipes concerned and build pipe_array */ - for (i = 0; i < mgr->num_cards; i++) { - chip = mgr->chip[i]; - for (j = 0; j < chip->nb_streams_capt; j++) { - if (pcxhr_stream_scheduled_get_pipe(&chip->capture_stream[j], &pipe)) - capture_mask |= (1 << pipe->first_audio); - } - for (j = 0; j < chip->nb_streams_play; j++) { - if (pcxhr_stream_scheduled_get_pipe(&chip->playback_stream[j], &pipe)) { - playback_mask |= (1 << pipe->first_audio); - break; /* add only once, as all playback streams of - * one chip use the same pipe - */ - } - } - } - if (capture_mask == 0 && playback_mask == 0) { - up(&mgr->setup_mutex); - snd_printk(KERN_ERR "pcxhr_trigger_tasklet : no pipes\n"); - return; - } - - snd_printdd("pcxhr_trigger_tasklet : playback_mask=%x capture_mask=%x\n", - playback_mask, capture_mask); - - /* synchronous stop of all the pipes concerned */ - err = pcxhr_set_pipe_state(mgr, playback_mask, capture_mask, 0); - if (err) { - up(&mgr->setup_mutex); - snd_printk(KERN_ERR "pcxhr_trigger_tasklet : error stop pipes (P%x C%x)\n", - playback_mask, capture_mask); - return; - } - - /* unfortunately the dsp lost format and buffer info with the stop pipe */ - for (i = 0; i < mgr->num_cards; i++) { - struct pcxhr_stream *stream; - chip = mgr->chip[i]; - for (j = 0; j < chip->nb_streams_capt; j++) { - stream = &chip->capture_stream[j]; - if (pcxhr_stream_scheduled_get_pipe(stream, &pipe)) { - err = pcxhr_set_format(stream); - err = pcxhr_update_r_buffer(stream); - } - } - for (j = 0; j < chip->nb_streams_play; j++) { - stream = &chip->playback_stream[j]; - if (pcxhr_stream_scheduled_get_pipe(stream, &pipe)) { - err = pcxhr_set_format(stream); - err = pcxhr_update_r_buffer(stream); - } - } - } - /* start all the streams */ - for (i = 0; i < mgr->num_cards; i++) { - struct pcxhr_stream *stream; - chip = mgr->chip[i]; - for (j = 0; j < chip->nb_streams_capt; j++) { - stream = &chip->capture_stream[j]; - if (pcxhr_stream_scheduled_get_pipe(stream, &pipe)) - err = pcxhr_set_stream_state(stream); - } - for (j = 0; j < chip->nb_streams_play; j++) { - stream = &chip->playback_stream[j]; - if (pcxhr_stream_scheduled_get_pipe(stream, &pipe)) - err = pcxhr_set_stream_state(stream); - } - } - - /* synchronous start of all the pipes concerned */ - err = pcxhr_set_pipe_state(mgr, playback_mask, capture_mask, 1); - if (err) { - up(&mgr->setup_mutex); - snd_printk(KERN_ERR "pcxhr_trigger_tasklet : error start pipes (P%x C%x)\n", - playback_mask, capture_mask); - return; - } - - /* put the streams into the running state now (increment pointer by interrupt) */ - spin_lock_irqsave(&mgr->lock, flags); - for ( i =0; i < mgr->num_cards; i++) { - struct pcxhr_stream *stream; - chip = mgr->chip[i]; - for(j = 0; j < chip->nb_streams_capt; j++) { - stream = &chip->capture_stream[j]; - if(stream->status == PCXHR_STREAM_STATUS_STARTED) - stream->status = PCXHR_STREAM_STATUS_RUNNING; - } - for (j = 0; j < chip->nb_streams_play; j++) { - stream = &chip->playback_stream[j]; - if (stream->status == PCXHR_STREAM_STATUS_STARTED) { - /* playback will already have advanced ! */ - stream->timer_period_frag += PCXHR_GRANULARITY; - stream->status = PCXHR_STREAM_STATUS_RUNNING; - } - } - } - spin_unlock_irqrestore(&mgr->lock, flags); - - up(&mgr->setup_mutex); - -#ifdef CONFIG_SND_DEBUG_DETECT - do_gettimeofday(&my_tv2); - snd_printdd("***TRIGGER TASKLET*** TIME = %ld (err = %x)\n", - my_tv2.tv_usec - my_tv1.tv_usec, err); -#endif -} - - -/* - * trigger callback - */ -static int pcxhr_trigger(struct snd_pcm_substream *subs, int cmd) -{ - struct pcxhr_stream *stream; - struct list_head *pos; - struct snd_pcm_substream *s; - int i; - - switch (cmd) { - case SNDRV_PCM_TRIGGER_START: - snd_printdd("SNDRV_PCM_TRIGGER_START\n"); - i = 0; - snd_pcm_group_for_each(pos, subs) { - s = snd_pcm_group_substream_entry(pos); - stream = s->runtime->private_data; - stream->status = PCXHR_STREAM_STATUS_SCHEDULE_RUN; - snd_pcm_trigger_done(s, subs); - i++; - } - if (i==1) { - snd_printdd("Only one Substream %c %d\n", - stream->pipe->is_capture ? 'C' : 'P', - stream->pipe->first_audio); - if (pcxhr_set_format(stream)) - return -EINVAL; - if (pcxhr_update_r_buffer(stream)) - return -EINVAL; - - if (pcxhr_set_stream_state(stream)) - return -EINVAL; - stream->status = PCXHR_STREAM_STATUS_RUNNING; - } else { - struct snd_pcxhr *chip = snd_pcm_substream_chip(subs); - tasklet_hi_schedule(&chip->mgr->trigger_taskq); - } - break; - case SNDRV_PCM_TRIGGER_STOP: - snd_printdd("SNDRV_PCM_TRIGGER_STOP\n"); - snd_pcm_group_for_each(pos, subs) { - s = snd_pcm_group_substream_entry(pos); - stream = s->runtime->private_data; - stream->status = PCXHR_STREAM_STATUS_SCHEDULE_STOP; - if (pcxhr_set_stream_state(stream)) - return -EINVAL; - snd_pcm_trigger_done(s, subs); - } - break; - case SNDRV_PCM_TRIGGER_PAUSE_PUSH: - case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: - /* TODO */ - default: - return -EINVAL; - } - return 0; -} - - -static int pcxhr_hardware_timer(struct pcxhr_mgr *mgr, int start) -{ - struct pcxhr_rmh rmh; - int err; - - pcxhr_init_rmh(&rmh, CMD_SET_TIMER_INTERRUPT); - if (start) { - mgr->dsp_time_last = PCXHR_DSP_TIME_INVALID; /* last dsp time invalid */ - rmh.cmd[0] |= PCXHR_GRANULARITY; - } - err = pcxhr_send_msg(mgr, &rmh); - if (err < 0) - snd_printk(KERN_ERR "error pcxhr_hardware_timer err(%x)\n", err); - return err; -} - -/* - * prepare callback for all pcms - */ -static int pcxhr_prepare(struct snd_pcm_substream *subs) -{ - struct snd_pcxhr *chip = snd_pcm_substream_chip(subs); - struct pcxhr_mgr *mgr = chip->mgr; - /* - struct pcxhr_stream *stream = (pcxhr_stream_t*)subs->runtime->private_data; - */ - int err = 0; - - snd_printdd("pcxhr_prepare : period_size(%lx) periods(%x) buffer_size(%lx)\n", - subs->runtime->period_size, subs->runtime->periods, - subs->runtime->buffer_size); - - /* - if(subs->runtime->period_size <= PCXHR_GRANULARITY) { - snd_printk(KERN_ERR "pcxhr_prepare : error period_size too small (%x)\n", - (unsigned int)subs->runtime->period_size); - return -EINVAL; - } - */ - - down(&mgr->setup_mutex); - - do { - /* if the stream was stopped before, format and buffer were reset */ - /* - if(stream->status == PCXHR_STREAM_STATUS_STOPPED) { - err = pcxhr_set_format(stream); - if(err) break; - err = pcxhr_update_r_buffer(stream); - if(err) break; - } - */ - - /* only the first stream can choose the sample rate */ - /* the further opened streams will be limited to its frequency (see open) */ - /* set the clock only once (first stream) */ - if (mgr->sample_rate == 0) { - err = pcxhr_set_clock(mgr, subs->runtime->rate); - if (err) - break; - mgr->sample_rate = subs->runtime->rate; - - err = pcxhr_hardware_timer(mgr, 1); /* start the DSP-timer */ - } - } while(0); /* do only once (so we can use break instead of goto) */ - - up(&mgr->setup_mutex); - - return err; -} - - -/* - * HW_PARAMS callback for all pcms - */ -static int pcxhr_hw_params(struct snd_pcm_substream *subs, - struct snd_pcm_hw_params *hw) -{ - struct snd_pcxhr *chip = snd_pcm_substream_chip(subs); - struct pcxhr_mgr *mgr = chip->mgr; - struct pcxhr_stream *stream = subs->runtime->private_data; - snd_pcm_format_t format; - int err; - int channels; - - /* set up channels */ - channels = params_channels(hw); - - /* set up format for the stream */ - format = params_format(hw); - - down(&mgr->setup_mutex); - - stream->channels = channels; - stream->format = format; - - /* set the format to the board */ - /* - err = pcxhr_set_format(stream); - if(err) { - up(&mgr->setup_mutex); - return err; - } - */ - /* allocate buffer */ - err = snd_pcm_lib_malloc_pages(subs, params_buffer_bytes(hw)); - - /* - if (err > 0) { - err = pcxhr_update_r_buffer(stream); - } - */ - up(&mgr->setup_mutex); - - return err; -} - -static int pcxhr_hw_free(struct snd_pcm_substream *subs) -{ - snd_pcm_lib_free_pages(subs); - return 0; -} - - -/* - * CONFIGURATION SPACE for all pcms, mono pcm must update channels_max - */ -static struct snd_pcm_hardware pcxhr_caps = -{ - .info = ( SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | - SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START | - 0 /*SNDRV_PCM_INFO_PAUSE*/), - .formats = ( SNDRV_PCM_FMTBIT_U8 | - SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | - SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE | - SNDRV_PCM_FMTBIT_FLOAT_LE ), - .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_192000, - .rate_min = 8000, - .rate_max = 192000, - .channels_min = 1, - .channels_max = 2, - .buffer_bytes_max = (32*1024), - /* 1 byte == 1 frame U8 mono (PCXHR_GRANULARITY is frames!) */ - .period_bytes_min = (2*PCXHR_GRANULARITY), - .period_bytes_max = (16*1024), - .periods_min = 2, - .periods_max = (32*1024/PCXHR_GRANULARITY), -}; - - -static int pcxhr_open(struct snd_pcm_substream *subs) -{ - struct snd_pcxhr *chip = snd_pcm_substream_chip(subs); - struct pcxhr_mgr *mgr = chip->mgr; - struct snd_pcm_runtime *runtime = subs->runtime; - struct pcxhr_stream *stream; - int is_capture; - - down(&mgr->setup_mutex); - - /* copy the struct snd_pcm_hardware struct */ - runtime->hw = pcxhr_caps; - - if( subs->stream == SNDRV_PCM_STREAM_PLAYBACK ) { - snd_printdd("pcxhr_open playback chip%d subs%d\n", - chip->chip_idx, subs->number); - is_capture = 0; - stream = &chip->playback_stream[subs->number]; - } else { - snd_printdd("pcxhr_open capture chip%d subs%d\n", - chip->chip_idx, subs->number); - is_capture = 1; - if (mgr->mono_capture) - runtime->hw.channels_max = 1; - else - runtime->hw.channels_min = 2; - stream = &chip->capture_stream[subs->number]; - } - if (stream->status != PCXHR_STREAM_STATUS_FREE){ - /* streams in use */ - snd_printk(KERN_ERR "pcxhr_open chip%d subs%d in use\n", - chip->chip_idx, subs->number); - up(&mgr->setup_mutex); - return -EBUSY; - } - - /* if a sample rate is already used or fixed by external clock, - * the stream cannot change - */ - if (mgr->sample_rate) - runtime->hw.rate_min = runtime->hw.rate_max = mgr->sample_rate; - else { - if (mgr->use_clock_type != PCXHR_CLOCK_TYPE_INTERNAL) { - int external_rate; - if (pcxhr_get_external_clock(mgr, mgr->use_clock_type, - &external_rate) || - external_rate == 0) { - /* cannot detect the external clock rate */ - up(&mgr->setup_mutex); - return -EBUSY; - } - runtime->hw.rate_min = runtime->hw.rate_max = external_rate; - } - } - - stream->status = PCXHR_STREAM_STATUS_OPEN; - stream->substream = subs; - stream->channels = 0; /* not configured yet */ - - runtime->private_data = stream; - - snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4); - snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4); - - mgr->ref_count_rate++; - - up(&mgr->setup_mutex); - return 0; -} - - -static int pcxhr_close(struct snd_pcm_substream *subs) -{ - struct snd_pcxhr *chip = snd_pcm_substream_chip(subs); - struct pcxhr_mgr *mgr = chip->mgr; - struct pcxhr_stream *stream = subs->runtime->private_data; - - down(&mgr->setup_mutex); - - snd_printdd("pcxhr_close chip%d subs%d\n", chip->chip_idx, subs->number); - - /* sample rate released */ - if (--mgr->ref_count_rate == 0) { - mgr->sample_rate = 0; /* the sample rate is no more locked */ - pcxhr_hardware_timer(mgr, 0); /* stop the DSP-timer */ - } - - stream->status = PCXHR_STREAM_STATUS_FREE; - stream->substream = NULL; - - up(&mgr->setup_mutex); - - return 0; -} - - -static snd_pcm_uframes_t pcxhr_stream_pointer(struct snd_pcm_substream *subs) -{ - unsigned long flags; - u_int32_t timer_period_frag; - int timer_buf_periods; - struct snd_pcxhr *chip = snd_pcm_substream_chip(subs); - struct snd_pcm_runtime *runtime = subs->runtime; - struct pcxhr_stream *stream = runtime->private_data; - - spin_lock_irqsave(&chip->mgr->lock, flags); - - /* get the period fragment and the nb of periods in the buffer */ - timer_period_frag = stream->timer_period_frag; - timer_buf_periods = stream->timer_buf_periods; - - spin_unlock_irqrestore(&chip->mgr->lock, flags); - - return (snd_pcm_uframes_t)((timer_buf_periods * runtime->period_size) + - timer_period_frag); -} - - -static struct snd_pcm_ops pcxhr_ops = { - .open = pcxhr_open, - .close = pcxhr_close, - .ioctl = snd_pcm_lib_ioctl, - .prepare = pcxhr_prepare, - .hw_params = pcxhr_hw_params, - .hw_free = pcxhr_hw_free, - .trigger = pcxhr_trigger, - .pointer = pcxhr_stream_pointer, -}; - -/* - */ -int pcxhr_create_pcm(struct snd_pcxhr *chip) -{ - int err; - struct snd_pcm *pcm; - char name[32]; - - sprintf(name, "pcxhr %d", chip->chip_idx); - if ((err = snd_pcm_new(chip->card, name, 0, - chip->nb_streams_play, - chip->nb_streams_capt, &pcm)) < 0) { - snd_printk(KERN_ERR "cannot create pcm %s\n", name); - return err; - } - pcm->private_data = chip; - - if (chip->nb_streams_play) - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcxhr_ops); - if (chip->nb_streams_capt) - snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcxhr_ops); - - pcm->info_flags = 0; - strcpy(pcm->name, name); - - snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, - snd_dma_pci_data(chip->mgr->pci), - 32*1024, 32*1024); - chip->pcm = pcm; - return 0; -} - -static int pcxhr_chip_free(struct snd_pcxhr *chip) -{ - kfree(chip); - return 0; -} - -static int pcxhr_chip_dev_free(struct snd_device *device) -{ - struct snd_pcxhr *chip = device->device_data; - return pcxhr_chip_free(chip); -} - - -/* - */ -static int __devinit pcxhr_create(struct pcxhr_mgr *mgr, struct snd_card *card, int idx) -{ - int err; - struct snd_pcxhr *chip; - static struct snd_device_ops ops = { - .dev_free = pcxhr_chip_dev_free, - }; - - mgr->chip[idx] = chip = kzalloc(sizeof(*chip), GFP_KERNEL); - if (! chip) { - snd_printk(KERN_ERR "cannot allocate chip\n"); - return -ENOMEM; - } - - chip->card = card; - chip->chip_idx = idx; - chip->mgr = mgr; - - if (idx < mgr->playback_chips) - /* stereo or mono streams */ - chip->nb_streams_play = PCXHR_PLAYBACK_STREAMS; - - if (idx < mgr->capture_chips) { - if (mgr->mono_capture) - chip->nb_streams_capt = 2; /* 2 mono streams (left+right) */ - else - chip->nb_streams_capt = 1; /* or 1 stereo stream */ - } - - if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { - pcxhr_chip_free(chip); - return err; - } - - snd_card_set_dev(card, &mgr->pci->dev); - - return 0; -} - -/* proc interface */ -static void pcxhr_proc_info(struct snd_info_entry *entry, struct snd_info_buffer *buffer) -{ - struct snd_pcxhr *chip = entry->private_data; - struct pcxhr_mgr *mgr = chip->mgr; - - snd_iprintf(buffer, "\n%s\n", mgr->longname); - - /* stats available when embedded DSP is running */ - if (mgr->dsp_loaded & (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX)) { - struct pcxhr_rmh rmh; - short ver_maj = (mgr->dsp_version >> 16) & 0xff; - short ver_min = (mgr->dsp_version >> 8) & 0xff; - short ver_build = mgr->dsp_version & 0xff; - snd_iprintf(buffer, "module version %s\n", PCXHR_DRIVER_VERSION_STRING); - snd_iprintf(buffer, "dsp version %d.%d.%d\n", ver_maj, ver_min, ver_build); - if (mgr->board_has_analog) - snd_iprintf(buffer, "analog io available\n"); - else - snd_iprintf(buffer, "digital only board\n"); - - /* calc cpu load of the dsp */ - pcxhr_init_rmh(&rmh, CMD_GET_DSP_RESOURCES); - if( ! pcxhr_send_msg(mgr, &rmh) ) { - int cur = rmh.stat[0]; - int ref = rmh.stat[1]; - if (ref > 0) { - if (mgr->sample_rate_real != 0 && - mgr->sample_rate_real != 48000) { - ref = (ref * 48000) / mgr->sample_rate_real; - if (mgr->sample_rate_real >= PCXHR_IRQ_TIMER_FREQ) - ref *= 2; - } - cur = 100 - (100 * cur) / ref; - snd_iprintf(buffer, "cpu load %d%%\n", cur); - snd_iprintf(buffer, "buffer pool %d/%d kWords\n", - rmh.stat[2], rmh.stat[3]); - } - } - snd_iprintf(buffer, "dma granularity : %d\n", PCXHR_GRANULARITY); - snd_iprintf(buffer, "dsp time errors : %d\n", mgr->dsp_time_err); - snd_iprintf(buffer, "dsp async pipe xrun errors : %d\n", - mgr->async_err_pipe_xrun); - snd_iprintf(buffer, "dsp async stream xrun errors : %d\n", - mgr->async_err_stream_xrun); - snd_iprintf(buffer, "dsp async last other error : %x\n", - mgr->async_err_other_last); - /* debug zone dsp */ - rmh.cmd[0] = 0x4200 + PCXHR_SIZE_MAX_STATUS; - rmh.cmd_len = 1; - rmh.stat_len = PCXHR_SIZE_MAX_STATUS; - rmh.dsp_stat = 0; - rmh.cmd_idx = CMD_LAST_INDEX; - if( ! pcxhr_send_msg(mgr, &rmh) ) { - int i; - for (i = 0; i < rmh.stat_len; i++) - snd_iprintf(buffer, "debug[%02d] = %06x\n", i, rmh.stat[i]); - } - } else - snd_iprintf(buffer, "no firmware loaded\n"); - snd_iprintf(buffer, "\n"); -} -static void pcxhr_proc_sync(struct snd_info_entry *entry, struct snd_info_buffer *buffer) -{ - struct snd_pcxhr *chip = entry->private_data; - struct pcxhr_mgr *mgr = chip->mgr; - static char *texts[7] = { - "Internal", "Word", "AES Sync", "AES 1", "AES 2", "AES 3", "AES 4" - }; - - snd_iprintf(buffer, "\n%s\n", mgr->longname); - snd_iprintf(buffer, "Current Sample Clock\t: %s\n", texts[mgr->cur_clock_type]); - snd_iprintf(buffer, "Current Sample Rate\t= %d\n", mgr->sample_rate_real); - - /* commands available when embedded DSP is running */ - if (mgr->dsp_loaded & (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX)) { - int i, err, sample_rate; - for (i = PCXHR_CLOCK_TYPE_WORD_CLOCK; i< (3 + mgr->capture_chips); i++) { - err = pcxhr_get_external_clock(mgr, i, &sample_rate); - if (err) - break; - snd_iprintf(buffer, "%s Clock\t\t= %d\n", texts[i], sample_rate); - } - } else - snd_iprintf(buffer, "no firmware loaded\n"); - snd_iprintf(buffer, "\n"); -} - -static void __devinit pcxhr_proc_init(struct snd_pcxhr *chip) -{ - struct snd_info_entry *entry; - - if (! snd_card_proc_new(chip->card, "info", &entry)) - snd_info_set_text_ops(entry, chip, 1024, pcxhr_proc_info); - if (! snd_card_proc_new(chip->card, "sync", &entry)) - snd_info_set_text_ops(entry, chip, 1024, pcxhr_proc_sync); -} -/* end of proc interface */ - -/* - * release all the cards assigned to a manager instance - */ -static int pcxhr_free(struct pcxhr_mgr *mgr) -{ - unsigned int i; - - for (i = 0; i < mgr->num_cards; i++) { - if (mgr->chip[i]) - snd_card_free(mgr->chip[i]->card); - } - - /* reset board if some firmware was loaded */ - if(mgr->dsp_loaded) { - pcxhr_reset_board(mgr); - snd_printdd("reset pcxhr !\n"); - } - - /* release irq */ - if (mgr->irq >= 0) - free_irq(mgr->irq, mgr); - - pci_release_regions(mgr->pci); - - /* free hostport purgebuffer */ - if (mgr->hostport.area) { - snd_dma_free_pages(&mgr->hostport); - mgr->hostport.area = NULL; - } - - kfree(mgr->prmh); - - pci_disable_device(mgr->pci); - kfree(mgr); - return 0; -} - -/* - * probe function - creates the card manager - */ -static int __devinit pcxhr_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) -{ - static int dev; - struct pcxhr_mgr *mgr; - unsigned int i; - int err; - size_t size; - char *card_name; - - if (dev >= SNDRV_CARDS) - return -ENODEV; - if (! enable[dev]) { - dev++; - return -ENOENT; - } - - /* enable PCI device */ - if ((err = pci_enable_device(pci)) < 0) - return err; - pci_set_master(pci); - - /* check if we can restrict PCI DMA transfers to 32 bits */ - if (pci_set_dma_mask(pci, 0xffffffff) < 0) { - snd_printk(KERN_ERR "architecture does not support 32bit PCI busmaster DMA\n"); - pci_disable_device(pci); - return -ENXIO; - } - - /* alloc card manager */ - mgr = kzalloc(sizeof(*mgr), GFP_KERNEL); - if (! mgr) { - pci_disable_device(pci); - return -ENOMEM; - } - - snd_assert(pci_id->driver_data < PCI_ID_LAST, return -ENODEV); - card_name = pcxhr_board_params[pci_id->driver_data].board_name; - mgr->playback_chips = pcxhr_board_params[pci_id->driver_data].playback_chips; - mgr->capture_chips = pcxhr_board_params[pci_id->driver_data].capture_chips; - mgr->firmware_num = pcxhr_board_params[pci_id->driver_data].firmware_num; - mgr->mono_capture = mono[dev]; - - /* resource assignment */ - if ((err = pci_request_regions(pci, card_name)) < 0) { - kfree(mgr); - pci_disable_device(pci); - return err; - } - for (i = 0; i < 3; i++) - mgr->port[i] = pci_resource_start(pci, i); - - mgr->pci = pci; - mgr->irq = -1; - - if (request_irq(pci->irq, pcxhr_interrupt, SA_INTERRUPT|SA_SHIRQ, - card_name, mgr)) { - snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); - pcxhr_free(mgr); - return -EBUSY; - } - mgr->irq = pci->irq; - - sprintf(mgr->shortname, "Digigram %s", card_name); - sprintf(mgr->longname, "%s at 0x%lx & 0x%lx, 0x%lx irq %i", mgr->shortname, - mgr->port[0], mgr->port[1], mgr->port[2], mgr->irq); - - /* ISR spinlock */ - spin_lock_init(&mgr->lock); - spin_lock_init(&mgr->msg_lock); - - /* init setup mutex*/ - init_MUTEX(&mgr->setup_mutex); - - /* init taslket */ - tasklet_init(&mgr->msg_taskq, pcxhr_msg_tasklet, (unsigned long) mgr); - tasklet_init(&mgr->trigger_taskq, pcxhr_trigger_tasklet, (unsigned long) mgr); - mgr->prmh = kmalloc(sizeof(*mgr->prmh) + - sizeof(u32) * (PCXHR_SIZE_MAX_LONG_STATUS - PCXHR_SIZE_MAX_STATUS), - GFP_KERNEL); - if (! mgr->prmh) { - pcxhr_free(mgr); - return -ENOMEM; - } - - for (i=0; i < PCXHR_MAX_CARDS; i++) { - struct snd_card *card; - char tmpid[16]; - int idx; - - if (i >= max(mgr->playback_chips, mgr->capture_chips)) - break; - mgr->num_cards++; - - if (index[dev] < 0) - idx = index[dev]; - else - idx = index[dev] + i; - - snprintf(tmpid, sizeof(tmpid), "%s-%d", id[dev] ? id[dev] : card_name, i); - card = snd_card_new(idx, tmpid, THIS_MODULE, 0); - - if (! card) { - snd_printk(KERN_ERR "cannot allocate the card %d\n", i); - pcxhr_free(mgr); - return -ENOMEM; - } - - strcpy(card->driver, DRIVER_NAME); - sprintf(card->shortname, "%s [PCM #%d]", mgr->shortname, i); - sprintf(card->longname, "%s [PCM #%d]", mgr->longname, i); - - if ((err = pcxhr_create(mgr, card, i)) < 0) { - pcxhr_free(mgr); - return err; - } - - if (i == 0) - /* init proc interface only for chip0 */ - pcxhr_proc_init(mgr->chip[i]); - - if ((err = snd_card_register(card)) < 0) { - pcxhr_free(mgr); - return err; - } - } - - /* create hostport purgebuffer */ - size = PAGE_ALIGN(sizeof(struct pcxhr_hostport)); - if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), - size, &mgr->hostport) < 0) { - pcxhr_free(mgr); - return -ENOMEM; - } - /* init purgebuffer */ - memset(mgr->hostport.area, 0, size); - - /* create a DSP loader */ - err = pcxhr_setup_firmware(mgr); - if (err < 0) { - pcxhr_free(mgr); - return err; - } - - pci_set_drvdata(pci, mgr); - dev++; - return 0; -} - -static void __devexit pcxhr_remove(struct pci_dev *pci) -{ - pcxhr_free(pci_get_drvdata(pci)); - pci_set_drvdata(pci, NULL); -} - -static struct pci_driver driver = { - .name = "Digigram pcxhr", - .id_table = pcxhr_ids, - .probe = pcxhr_probe, - .remove = __devexit_p(pcxhr_remove), -}; - -static int __init pcxhr_module_init(void) -{ - return pci_register_driver(&driver); -} - -static void __exit pcxhr_module_exit(void) -{ - pci_unregister_driver(&driver); -} - -module_init(pcxhr_module_init) -module_exit(pcxhr_module_exit) diff --git a/trunk/sound/pci/pcxhr/pcxhr.h b/trunk/sound/pci/pcxhr/pcxhr.h deleted file mode 100644 index 049f2b3f2867..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr.h +++ /dev/null @@ -1,188 +0,0 @@ -/* - * Driver for Digigram pcxhr soundcards - * - * main header file - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __SOUND_PCXHR_H -#define __SOUND_PCXHR_H - -#include <linux/interrupt.h> -#include <sound/pcm.h> - -#define PCXHR_DRIVER_VERSION 0x000804 /* 0.8.4 */ -#define PCXHR_DRIVER_VERSION_STRING "0.8.4" /* 0.8.4 */ - - -#define PCXHR_MAX_CARDS 6 -#define PCXHR_PLAYBACK_STREAMS 4 - -#define PCXHR_GRANULARITY 96 /* transfer granularity (should be min 96 and multiple of 48) */ -#define PCXHR_GRANULARITY_MIN 96 /* transfer granularity of pipes and the dsp time (MBOX4) */ - -struct snd_pcxhr; -struct pcxhr_mgr; - -struct pcxhr_stream; -struct pcxhr_pipe; - -enum pcxhr_clock_type { - PCXHR_CLOCK_TYPE_INTERNAL = 0, - PCXHR_CLOCK_TYPE_WORD_CLOCK, - PCXHR_CLOCK_TYPE_AES_SYNC, - PCXHR_CLOCK_TYPE_AES_1, - PCXHR_CLOCK_TYPE_AES_2, - PCXHR_CLOCK_TYPE_AES_3, - PCXHR_CLOCK_TYPE_AES_4, -}; - -struct pcxhr_mgr { - unsigned int num_cards; - struct snd_pcxhr *chip[PCXHR_MAX_CARDS]; - - struct pci_dev *pci; - - int irq; - - /* card access with 1 mem bar and 2 io bar's */ - unsigned long port[3]; - - /* share the name */ - char shortname[32]; /* short name of this soundcard */ - char longname[96]; /* name of this soundcard */ - - /* message tasklet */ - struct tasklet_struct msg_taskq; - struct pcxhr_rmh *prmh; - /* trigger tasklet */ - struct tasklet_struct trigger_taskq; - - spinlock_t lock; /* interrupt spinlock */ - spinlock_t msg_lock; /* message spinlock */ - - struct semaphore setup_mutex; /* mutex used in hw_params, open and close */ - struct semaphore mixer_mutex; /* mutex for mixer */ - - /* hardware interface */ - unsigned int dsp_loaded; /* bit flags of loaded dsp indices */ - unsigned int dsp_version; /* read from embedded once firmware is loaded */ - int board_has_analog; /* if 0 the board is digital only */ - int mono_capture; /* if 1 the board does mono capture */ - int playback_chips; /* 4 or 6 */ - int capture_chips; /* 4 or 1 */ - int firmware_num; /* 41 or 42 */ - - struct snd_dma_buffer hostport; - - enum pcxhr_clock_type use_clock_type; /* clock type selected by mixer */ - enum pcxhr_clock_type cur_clock_type; /* current clock type synced */ - int sample_rate; - int ref_count_rate; - int timer_toggle; /* timer interrupt toggles between the two values 0x200 and 0x300 */ - int dsp_time_last; /* the last dsp time (read by interrupt) */ - int dsp_time_err; /* dsp time errors */ - unsigned int src_it_dsp; /* dsp interrupt source */ - unsigned int io_num_reg_cont; /* backup of IO_NUM_REG_CONT */ - unsigned int codec_speed; /* speed mode of the codecs */ - unsigned int sample_rate_real; /* current real sample rate */ - int last_reg_stat; - int async_err_stream_xrun; - int async_err_pipe_xrun; - int async_err_other_last; -}; - - -enum pcxhr_stream_status { - PCXHR_STREAM_STATUS_FREE, - PCXHR_STREAM_STATUS_OPEN, - PCXHR_STREAM_STATUS_SCHEDULE_RUN, - PCXHR_STREAM_STATUS_STARTED, - PCXHR_STREAM_STATUS_RUNNING, - PCXHR_STREAM_STATUS_SCHEDULE_STOP, - PCXHR_STREAM_STATUS_STOPPED, - PCXHR_STREAM_STATUS_PAUSED -}; - -struct pcxhr_stream { - struct snd_pcm_substream *substream; - snd_pcm_format_t format; - struct pcxhr_pipe *pipe; - - enum pcxhr_stream_status status; /* free, open, running, draining, pause */ - - u_int64_t timer_abs_periods; /* timer: samples elapsed since TRIGGER_START (multiple of period_size) */ - u_int32_t timer_period_frag; /* timer: samples elapsed since last call to snd_pcm_period_elapsed (0..period_size) */ - u_int32_t timer_buf_periods; /* nb of periods in the buffer that have already elapsed */ - int timer_is_synced; /* if(0) : timer needs to be resynced with real hardware pointer */ - - int channels; -}; - - -enum pcxhr_pipe_status { - PCXHR_PIPE_UNDEFINED, - PCXHR_PIPE_DEFINED -}; - -struct pcxhr_pipe { - enum pcxhr_pipe_status status; - int is_capture; /* this is a capture pipe */ - int first_audio; /* first audio num */ -}; - - -struct snd_pcxhr { - struct snd_card *card; - struct pcxhr_mgr *mgr; - int chip_idx; /* zero based */ - - struct snd_pcm *pcm; /* PCM */ - - struct pcxhr_pipe playback_pipe; /* 1 stereo pipe only */ - struct pcxhr_pipe capture_pipe[2]; /* 1 stereo pipe or 2 mono pipes */ - - struct pcxhr_stream playback_stream[PCXHR_PLAYBACK_STREAMS]; - struct pcxhr_stream capture_stream[2]; /* 1 stereo stream or 2 mono streams */ - int nb_streams_play; - int nb_streams_capt; - - int analog_playback_active[2]; /* Mixer : Master Playback active (!mute) */ - int analog_playback_volume[2]; /* Mixer : Master Playback Volume */ - int analog_capture_volume[2]; /* Mixer : Master Capture Volume */ - int digital_playback_active[PCXHR_PLAYBACK_STREAMS][2]; /* Mixer : Digital Playback Active [streams][stereo]*/ - int digital_playback_volume[PCXHR_PLAYBACK_STREAMS][2]; /* Mixer : Digital Playback Volume [streams][stereo]*/ - int digital_capture_volume[2]; /* Mixer : Digital Capture Volume [stereo] */ - int monitoring_active[2]; /* Mixer : Monitoring Active */ - int monitoring_volume[2]; /* Mixer : Monitoring Volume */ - int audio_capture_source; /* Mixer : Audio Capture Source */ - unsigned char aes_bits[5]; /* Mixer : IEC958_AES bits */ -}; - -struct pcxhr_hostport -{ - char purgebuffer[6]; - char reserved[2]; -}; - -/* exported */ -int pcxhr_create_pcm(struct snd_pcxhr *chip); -int pcxhr_set_clock(struct pcxhr_mgr *mgr, unsigned int rate); -int pcxhr_get_external_clock(struct pcxhr_mgr *mgr, enum pcxhr_clock_type clock_type, int *sample_rate); - -#endif /* __SOUND_PCXHR_H */ diff --git a/trunk/sound/pci/pcxhr/pcxhr_core.c b/trunk/sound/pci/pcxhr/pcxhr_core.c deleted file mode 100644 index fa0d27e2c79b..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr_core.c +++ /dev/null @@ -1,1214 +0,0 @@ -/* - * Driver for Digigram pcxhr compatible soundcards - * - * low level interface with interrupt and message handling implementation - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include <sound/driver.h> -#include <linux/delay.h> -#include <linux/firmware.h> -#include <linux/interrupt.h> -#include <asm/io.h> -#include <sound/core.h> -#include "pcxhr.h" -#include "pcxhr_mixer.h" -#include "pcxhr_hwdep.h" -#include "pcxhr_core.h" - - -/* registers used on the PLX (port 1) */ -#define PCXHR_PLX_OFFSET_MIN 0x40 -#define PCXHR_PLX_MBOX0 0x40 -#define PCXHR_PLX_MBOX1 0x44 -#define PCXHR_PLX_MBOX2 0x48 -#define PCXHR_PLX_MBOX3 0x4C -#define PCXHR_PLX_MBOX4 0x50 -#define PCXHR_PLX_MBOX5 0x54 -#define PCXHR_PLX_MBOX6 0x58 -#define PCXHR_PLX_MBOX7 0x5C -#define PCXHR_PLX_L2PCIDB 0x64 -#define PCXHR_PLX_IRQCS 0x68 -#define PCXHR_PLX_CHIPSC 0x6C - -/* registers used on the DSP (port 2) */ -#define PCXHR_DSP_ICR 0x00 -#define PCXHR_DSP_CVR 0x04 -#define PCXHR_DSP_ISR 0x08 -#define PCXHR_DSP_IVR 0x0C -#define PCXHR_DSP_RXH 0x14 -#define PCXHR_DSP_TXH 0x14 -#define PCXHR_DSP_RXM 0x18 -#define PCXHR_DSP_TXM 0x18 -#define PCXHR_DSP_RXL 0x1C -#define PCXHR_DSP_TXL 0x1C -#define PCXHR_DSP_RESET 0x20 -#define PCXHR_DSP_OFFSET_MAX 0x20 - -/* access to the card */ -#define PCXHR_PLX 1 -#define PCXHR_DSP 2 - -#if (PCXHR_DSP_OFFSET_MAX > PCXHR_PLX_OFFSET_MIN) -#undef PCXHR_REG_TO_PORT(x) -#else -#define PCXHR_REG_TO_PORT(x) ((x)>PCXHR_DSP_OFFSET_MAX ? PCXHR_PLX : PCXHR_DSP) -#endif -#define PCXHR_INPB(mgr,x) inb((mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) -#define PCXHR_INPL(mgr,x) inl((mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) -#define PCXHR_OUTPB(mgr,x,data) outb((data), (mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) -#define PCXHR_OUTPL(mgr,x,data) outl((data), (mgr)->port[PCXHR_REG_TO_PORT(x)] + (x)) -/* attention : access the PCXHR_DSP_* registers with inb and outb only ! */ - -/* params used with PCXHR_PLX_MBOX0 */ -#define PCXHR_MBOX0_HF5 (1 << 0) -#define PCXHR_MBOX0_HF4 (1 << 1) -#define PCXHR_MBOX0_BOOT_HERE (1 << 23) -/* params used with PCXHR_PLX_IRQCS */ -#define PCXHR_IRQCS_ENABLE_PCIIRQ (1 << 8) -#define PCXHR_IRQCS_ENABLE_PCIDB (1 << 9) -#define PCXHR_IRQCS_ACTIVE_PCIDB (1 << 13) -/* params used with PCXHR_PLX_CHIPSC */ -#define PCXHR_CHIPSC_INIT_VALUE 0x100D767E -#define PCXHR_CHIPSC_RESET_XILINX (1 << 16) -#define PCXHR_CHIPSC_GPI_USERI (1 << 17) -#define PCXHR_CHIPSC_DATA_CLK (1 << 24) -#define PCXHR_CHIPSC_DATA_IN (1 << 26) - -/* params used with PCXHR_DSP_ICR */ -#define PCXHR_ICR_HI08_RREQ 0x01 -#define PCXHR_ICR_HI08_TREQ 0x02 -#define PCXHR_ICR_HI08_HDRQ 0x04 -#define PCXHR_ICR_HI08_HF0 0x08 -#define PCXHR_ICR_HI08_HF1 0x10 -#define PCXHR_ICR_HI08_HLEND 0x20 -#define PCXHR_ICR_HI08_INIT 0x80 -/* params used with PCXHR_DSP_CVR */ -#define PCXHR_CVR_HI08_HC 0x80 -/* params used with PCXHR_DSP_ISR */ -#define PCXHR_ISR_HI08_RXDF 0x01 -#define PCXHR_ISR_HI08_TXDE 0x02 -#define PCXHR_ISR_HI08_TRDY 0x04 -#define PCXHR_ISR_HI08_ERR 0x08 -#define PCXHR_ISR_HI08_CHK 0x10 -#define PCXHR_ISR_HI08_HREQ 0x80 - - -/* constants used for delay in msec */ -#define PCXHR_WAIT_DEFAULT 2 -#define PCXHR_WAIT_IT 25 -#define PCXHR_WAIT_IT_EXTRA 65 - -/* - * pcxhr_check_reg_bit - wait for the specified bit is set/reset on a register - * @reg: register to check - * @mask: bit mask - * @bit: resultant bit to be checked - * @time: time-out of loop in msec - * - * returns zero if a bit matches, or a negative error code. - */ -static int pcxhr_check_reg_bit(struct pcxhr_mgr *mgr, unsigned int reg, - unsigned char mask, unsigned char bit, int time, - unsigned char* read) -{ - int i = 0; - unsigned long end_time = jiffies + (time * HZ + 999) / 1000; - do { - *read = PCXHR_INPB(mgr, reg); - if ((*read & mask) == bit) { - if (i > 100) - snd_printdd("ATTENTION! check_reg(%x) loopcount=%d\n", - reg, i); - return 0; - } - i++; - } while (time_after_eq(end_time, jiffies)); - snd_printk(KERN_ERR "pcxhr_check_reg_bit: timeout, reg=%x, mask=0x%x, val=0x%x\n", - reg, mask, *read); - return -EIO; -} - -/* constants used with pcxhr_check_reg_bit() */ -#define PCXHR_TIMEOUT_DSP 200 - - -#define PCXHR_MASK_EXTRA_INFO 0x0000FE -#define PCXHR_MASK_IT_HF0 0x000100 -#define PCXHR_MASK_IT_HF1 0x000200 -#define PCXHR_MASK_IT_NO_HF0_HF1 0x000400 -#define PCXHR_MASK_IT_MANAGE_HF5 0x000800 -#define PCXHR_MASK_IT_WAIT 0x010000 -#define PCXHR_MASK_IT_WAIT_EXTRA 0x020000 - -#define PCXHR_IT_SEND_BYTE_XILINX (0x0000003C | PCXHR_MASK_IT_HF0) -#define PCXHR_IT_TEST_XILINX (0x0000003C | PCXHR_MASK_IT_HF1 | \ - PCXHR_MASK_IT_MANAGE_HF5) -#define PCXHR_IT_DOWNLOAD_BOOT (0x0000000C | PCXHR_MASK_IT_HF1 | \ - PCXHR_MASK_IT_MANAGE_HF5 | PCXHR_MASK_IT_WAIT) -#define PCXHR_IT_RESET_BOARD_FUNC (0x0000000C | PCXHR_MASK_IT_HF0 | \ - PCXHR_MASK_IT_MANAGE_HF5 | PCXHR_MASK_IT_WAIT_EXTRA) -#define PCXHR_IT_DOWNLOAD_DSP (0x0000000C | \ - PCXHR_MASK_IT_MANAGE_HF5 | PCXHR_MASK_IT_WAIT) -#define PCXHR_IT_DEBUG (0x0000005A | PCXHR_MASK_IT_NO_HF0_HF1) -#define PCXHR_IT_RESET_SEMAPHORE (0x0000005C | PCXHR_MASK_IT_NO_HF0_HF1) -#define PCXHR_IT_MESSAGE (0x00000074 | PCXHR_MASK_IT_NO_HF0_HF1) -#define PCXHR_IT_RESET_CHK (0x00000076 | PCXHR_MASK_IT_NO_HF0_HF1) -#define PCXHR_IT_UPDATE_RBUFFER (0x00000078 | PCXHR_MASK_IT_NO_HF0_HF1) - -static int pcxhr_send_it_dsp(struct pcxhr_mgr *mgr, unsigned int itdsp, int atomic) -{ - int err; - unsigned char reg; - - if (itdsp & PCXHR_MASK_IT_MANAGE_HF5) { - /* clear hf5 bit */ - PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX0, - PCXHR_INPL(mgr, PCXHR_PLX_MBOX0) & ~PCXHR_MBOX0_HF5); - } - if ((itdsp & PCXHR_MASK_IT_NO_HF0_HF1) == 0) { - reg = PCXHR_ICR_HI08_RREQ | PCXHR_ICR_HI08_TREQ | PCXHR_ICR_HI08_HDRQ; - if (itdsp & PCXHR_MASK_IT_HF0) - reg |= PCXHR_ICR_HI08_HF0; - if (itdsp & PCXHR_MASK_IT_HF1) - reg |= PCXHR_ICR_HI08_HF1; - PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg); - } - reg = (unsigned char)(((itdsp & PCXHR_MASK_EXTRA_INFO) >> 1) | PCXHR_CVR_HI08_HC); - PCXHR_OUTPB(mgr, PCXHR_DSP_CVR, reg); - if (itdsp & PCXHR_MASK_IT_WAIT) { - if (atomic) - mdelay(PCXHR_WAIT_IT); - else - msleep(PCXHR_WAIT_IT); - } - if (itdsp & PCXHR_MASK_IT_WAIT_EXTRA) { - if (atomic) - mdelay(PCXHR_WAIT_IT_EXTRA); - else - msleep(PCXHR_WAIT_IT); - } - /* wait for CVR_HI08_HC == 0 */ - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_CVR, PCXHR_CVR_HI08_HC, 0, - PCXHR_TIMEOUT_DSP, ®); - if (err) { - snd_printk(KERN_ERR "pcxhr_send_it_dsp : TIMEOUT CVR\n"); - return err; - } - if (itdsp & PCXHR_MASK_IT_MANAGE_HF5) { - /* wait for hf5 bit */ - err = pcxhr_check_reg_bit(mgr, PCXHR_PLX_MBOX0, PCXHR_MBOX0_HF5, - PCXHR_MBOX0_HF5, PCXHR_TIMEOUT_DSP, ®); - if (err) { - snd_printk(KERN_ERR "pcxhr_send_it_dsp : TIMEOUT HF5\n"); - return err; - } - } - return 0; /* retry not handled here */ -} - -void pcxhr_reset_xilinx_com(struct pcxhr_mgr *mgr) -{ - /* reset second xilinx */ - PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, - PCXHR_CHIPSC_INIT_VALUE & ~PCXHR_CHIPSC_RESET_XILINX); -} - -static void pcxhr_enable_irq(struct pcxhr_mgr *mgr, int enable) -{ - unsigned int reg = PCXHR_INPL(mgr, PCXHR_PLX_IRQCS); - /* enable/disable interrupts */ - if (enable) - reg |= (PCXHR_IRQCS_ENABLE_PCIIRQ | PCXHR_IRQCS_ENABLE_PCIDB); - else - reg &= ~(PCXHR_IRQCS_ENABLE_PCIIRQ | PCXHR_IRQCS_ENABLE_PCIDB); - PCXHR_OUTPL(mgr, PCXHR_PLX_IRQCS, reg); -} - -void pcxhr_reset_dsp(struct pcxhr_mgr *mgr) -{ - /* disable interrupts */ - pcxhr_enable_irq(mgr, 0); - - /* let's reset the DSP */ - PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, 0); - msleep( PCXHR_WAIT_DEFAULT ); /* wait 2 msec */ - PCXHR_OUTPB(mgr, PCXHR_DSP_RESET, 3); - msleep( PCXHR_WAIT_DEFAULT ); /* wait 2 msec */ - - /* reset mailbox */ - PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX0, 0); -} - -void pcxhr_enable_dsp(struct pcxhr_mgr *mgr) -{ - /* enable interrupts */ - pcxhr_enable_irq(mgr, 1); -} - -/* - * load the xilinx image - */ -int pcxhr_load_xilinx_binary(struct pcxhr_mgr *mgr, const struct firmware *xilinx, int second) -{ - unsigned int i; - unsigned int chipsc; - unsigned char data; - unsigned char mask; - unsigned char *image; - - /* test first xilinx */ - chipsc = PCXHR_INPL(mgr, PCXHR_PLX_CHIPSC); - if (!second) { - if (chipsc & PCXHR_CHIPSC_GPI_USERI) { - snd_printdd("no need to load first xilinx\n"); - return 0; /* first xilinx is already present and cannot be reset */ - } - } else { - if ((chipsc & PCXHR_CHIPSC_GPI_USERI) == 0) { - snd_printk(KERN_ERR "error loading first xilinx\n"); - return -EINVAL; - } - /* activate second xilinx */ - chipsc |= PCXHR_CHIPSC_RESET_XILINX; - PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); - msleep( PCXHR_WAIT_DEFAULT ); /* wait 2 msec */ - } - image = xilinx->data; - for (i = 0; i < xilinx->size; i++, image++) { - data = *image; - mask = 0x80; - while (mask) { - chipsc &= ~(PCXHR_CHIPSC_DATA_CLK | PCXHR_CHIPSC_DATA_IN); - if (data & mask) - chipsc |= PCXHR_CHIPSC_DATA_IN; - PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); - chipsc |= PCXHR_CHIPSC_DATA_CLK; - PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); - mask >>= 1; - } - /* don't take too much time in this loop... */ - cond_resched(); - } - chipsc &= ~(PCXHR_CHIPSC_DATA_CLK | PCXHR_CHIPSC_DATA_IN); - PCXHR_OUTPL(mgr, PCXHR_PLX_CHIPSC, chipsc); - /* wait 2 msec (time to boot the xilinx before any access) */ - msleep( PCXHR_WAIT_DEFAULT ); - return 0; -} - -/* - * send an executable file to the DSP - */ -static int pcxhr_download_dsp(struct pcxhr_mgr *mgr, const struct firmware *dsp) -{ - int err; - unsigned int i; - unsigned int len; - unsigned char *data; - unsigned char dummy; - /* check the length of boot image */ - snd_assert(dsp->size > 0, return -EINVAL); - snd_assert(dsp->size % 3 == 0, return -EINVAL); - snd_assert(dsp->data, return -EINVAL); - /* transfert data buffer from PC to DSP */ - for (i = 0; i < dsp->size; i += 3) { - data = dsp->data + i; - if (i == 0) { - /* test data header consistency */ - len = (unsigned int)((data[0]<<16) + (data[1]<<8) + data[2]); - snd_assert((len==0) || (dsp->size == (len+2)*3), return -EINVAL); - } - /* wait DSP ready for new transfer */ - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_TRDY, - PCXHR_ISR_HI08_TRDY, PCXHR_TIMEOUT_DSP, &dummy); - if (err) { - snd_printk(KERN_ERR "dsp loading error at position %d\n", i); - return err; - } - /* send host data */ - PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, data[0]); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, data[1]); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, data[2]); - - /* don't take too much time in this loop... */ - cond_resched(); - } - /* give some time to boot the DSP */ - msleep(PCXHR_WAIT_DEFAULT); - return 0; -} - -/* - * load the eeprom image - */ -int pcxhr_load_eeprom_binary(struct pcxhr_mgr *mgr, const struct firmware *eeprom) -{ - int err; - unsigned char reg; - - /* init value of the ICR register */ - reg = PCXHR_ICR_HI08_RREQ | PCXHR_ICR_HI08_TREQ | PCXHR_ICR_HI08_HDRQ; - if (PCXHR_INPL(mgr, PCXHR_PLX_MBOX0) & PCXHR_MBOX0_BOOT_HERE) { - /* no need to load the eeprom binary, but init the HI08 interface */ - PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg | PCXHR_ICR_HI08_INIT); - msleep(PCXHR_WAIT_DEFAULT); - PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg); - msleep(PCXHR_WAIT_DEFAULT); - snd_printdd("no need to load eeprom boot\n"); - return 0; - } - PCXHR_OUTPB(mgr, PCXHR_DSP_ICR, reg); - - err = pcxhr_download_dsp(mgr, eeprom); - if (err) - return err; - /* wait for chk bit */ - return pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, - PCXHR_ISR_HI08_CHK, PCXHR_TIMEOUT_DSP, ®); -} - -/* - * load the boot image - */ -int pcxhr_load_boot_binary(struct pcxhr_mgr *mgr, const struct firmware *boot) -{ - int err; - unsigned int physaddr = mgr->hostport.addr; - unsigned char dummy; - - /* send the hostport address to the DSP (only the upper 24 bit !) */ - snd_assert((physaddr & 0xff) == 0, return -EINVAL); - PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX1, (physaddr >> 8)); - - err = pcxhr_send_it_dsp(mgr, PCXHR_IT_DOWNLOAD_BOOT, 0); - if (err) - return err; - /* clear hf5 bit */ - PCXHR_OUTPL(mgr, PCXHR_PLX_MBOX0, - PCXHR_INPL(mgr, PCXHR_PLX_MBOX0) & ~PCXHR_MBOX0_HF5); - - err = pcxhr_download_dsp(mgr, boot); - if (err) - return err; - /* wait for hf5 bit */ - return pcxhr_check_reg_bit(mgr, PCXHR_PLX_MBOX0, PCXHR_MBOX0_HF5, - PCXHR_MBOX0_HF5, PCXHR_TIMEOUT_DSP, &dummy); -} - -/* - * load the final dsp image - */ -int pcxhr_load_dsp_binary(struct pcxhr_mgr *mgr, const struct firmware *dsp) -{ - int err; - unsigned char dummy; - err = pcxhr_send_it_dsp(mgr, PCXHR_IT_RESET_BOARD_FUNC, 0); - if (err) - return err; - err = pcxhr_send_it_dsp(mgr, PCXHR_IT_DOWNLOAD_DSP, 0); - if (err) - return err; - err = pcxhr_download_dsp(mgr, dsp); - if (err) - return err; - /* wait for chk bit */ - return pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, - PCXHR_ISR_HI08_CHK, PCXHR_TIMEOUT_DSP, &dummy); -} - - -struct pcxhr_cmd_info { - u32 opcode; /* command word */ - u16 st_length; /* status length */ - u16 st_type; /* status type (RMH_SSIZE_XXX) */ -}; - -/* RMH status type */ -enum { - RMH_SSIZE_FIXED = 0, /* status size fix (st_length = 0..x) */ - RMH_SSIZE_ARG = 1, /* status size given in the LSB byte (used with st_length = 1) */ - RMH_SSIZE_MASK = 2, /* status size given in bitmask (used with st_length = 1) */ -}; - -/* - * Array of DSP commands - */ -static struct pcxhr_cmd_info pcxhr_dsp_cmds[] = { -[CMD_VERSION] = { 0x010000, 1, RMH_SSIZE_FIXED }, -[CMD_SUPPORTED] = { 0x020000, 4, RMH_SSIZE_FIXED }, -[CMD_TEST_IT] = { 0x040000, 1, RMH_SSIZE_FIXED }, -[CMD_SEND_IRQA] = { 0x070001, 0, RMH_SSIZE_FIXED }, -[CMD_ACCESS_IO_WRITE] = { 0x090000, 1, RMH_SSIZE_ARG }, -[CMD_ACCESS_IO_READ] = { 0x094000, 1, RMH_SSIZE_ARG }, -[CMD_ASYNC] = { 0x0a0000, 1, RMH_SSIZE_ARG }, -[CMD_MODIFY_CLOCK] = { 0x0d0000, 0, RMH_SSIZE_FIXED }, -[CMD_RESYNC_AUDIO_INPUTS] = { 0x0e0000, 0, RMH_SSIZE_FIXED }, -[CMD_GET_DSP_RESOURCES] = { 0x100000, 4, RMH_SSIZE_FIXED }, -[CMD_SET_TIMER_INTERRUPT] = { 0x110000, 0, RMH_SSIZE_FIXED }, -[CMD_RES_PIPE] = { 0x400000, 0, RMH_SSIZE_FIXED }, -[CMD_FREE_PIPE] = { 0x410000, 0, RMH_SSIZE_FIXED }, -[CMD_CONF_PIPE] = { 0x422101, 0, RMH_SSIZE_FIXED }, -[CMD_STOP_PIPE] = { 0x470004, 0, RMH_SSIZE_FIXED }, -[CMD_PIPE_SAMPLE_COUNT] = { 0x49a000, 2, RMH_SSIZE_FIXED }, -[CMD_CAN_START_PIPE] = { 0x4b0000, 1, RMH_SSIZE_FIXED }, -[CMD_START_STREAM] = { 0x802000, 0, RMH_SSIZE_FIXED }, -[CMD_STREAM_OUT_LEVEL_ADJUST] = { 0x822000, 0, RMH_SSIZE_FIXED }, -[CMD_STOP_STREAM] = { 0x832000, 0, RMH_SSIZE_FIXED }, -[CMD_UPDATE_R_BUFFERS] = { 0x840000, 0, RMH_SSIZE_FIXED }, -[CMD_FORMAT_STREAM_OUT] = { 0x860000, 0, RMH_SSIZE_FIXED }, -[CMD_FORMAT_STREAM_IN] = { 0x870000, 0, RMH_SSIZE_FIXED }, -[CMD_STREAM_SAMPLE_COUNT] = { 0x902000, 2, RMH_SSIZE_FIXED }, /* stat_len = nb_streams * 2 */ -[CMD_AUDIO_LEVEL_ADJUST] = { 0xc22000, 0, RMH_SSIZE_FIXED }, -}; - -#ifdef CONFIG_SND_DEBUG_DETECT -static char* cmd_names[] = { -[CMD_VERSION] = "CMD_VERSION", -[CMD_SUPPORTED] = "CMD_SUPPORTED", -[CMD_TEST_IT] = "CMD_TEST_IT", -[CMD_SEND_IRQA] = "CMD_SEND_IRQA", -[CMD_ACCESS_IO_WRITE] = "CMD_ACCESS_IO_WRITE", -[CMD_ACCESS_IO_READ] = "CMD_ACCESS_IO_READ", -[CMD_ASYNC] = "CMD_ASYNC", -[CMD_MODIFY_CLOCK] = "CMD_MODIFY_CLOCK", -[CMD_RESYNC_AUDIO_INPUTS] = "CMD_RESYNC_AUDIO_INPUTS", -[CMD_GET_DSP_RESOURCES] = "CMD_GET_DSP_RESOURCES", -[CMD_SET_TIMER_INTERRUPT] = "CMD_SET_TIMER_INTERRUPT", -[CMD_RES_PIPE] = "CMD_RES_PIPE", -[CMD_FREE_PIPE] = "CMD_FREE_PIPE", -[CMD_CONF_PIPE] = "CMD_CONF_PIPE", -[CMD_STOP_PIPE] = "CMD_STOP_PIPE", -[CMD_PIPE_SAMPLE_COUNT] = "CMD_PIPE_SAMPLE_COUNT", -[CMD_CAN_START_PIPE] = "CMD_CAN_START_PIPE", -[CMD_START_STREAM] = "CMD_START_STREAM", -[CMD_STREAM_OUT_LEVEL_ADJUST] = "CMD_STREAM_OUT_LEVEL_ADJUST", -[CMD_STOP_STREAM] = "CMD_STOP_STREAM", -[CMD_UPDATE_R_BUFFERS] = "CMD_UPDATE_R_BUFFERS", -[CMD_FORMAT_STREAM_OUT] = "CMD_FORMAT_STREAM_OUT", -[CMD_FORMAT_STREAM_IN] = "CMD_FORMAT_STREAM_IN", -[CMD_STREAM_SAMPLE_COUNT] = "CMD_STREAM_SAMPLE_COUNT", -[CMD_AUDIO_LEVEL_ADJUST] = "CMD_AUDIO_LEVEL_ADJUST", -}; -#endif - - -static int pcxhr_read_rmh_status(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh) -{ - int err; - int i; - u32 data; - u32 size_mask; - unsigned char reg; - int max_stat_len; - - if (rmh->stat_len < PCXHR_SIZE_MAX_STATUS) - max_stat_len = PCXHR_SIZE_MAX_STATUS; - else max_stat_len = rmh->stat_len; - - for (i = 0; i < rmh->stat_len; i++) { - /* wait for receiver full */ - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_RXDF, - PCXHR_ISR_HI08_RXDF, PCXHR_TIMEOUT_DSP, ®); - if (err) { - snd_printk(KERN_ERR "ERROR RMH stat: ISR:RXDF=1 (ISR = %x; i=%d )\n", - reg, i); - return err; - } - /* read data */ - data = PCXHR_INPB(mgr, PCXHR_DSP_TXH) << 16; - data |= PCXHR_INPB(mgr, PCXHR_DSP_TXM) << 8; - data |= PCXHR_INPB(mgr, PCXHR_DSP_TXL); - - /* need to update rmh->stat_len on the fly ?? */ - if (i==0) { - if (rmh->dsp_stat != RMH_SSIZE_FIXED) { - if (rmh->dsp_stat == RMH_SSIZE_ARG) { - rmh->stat_len = (u16)(data & 0x0000ff) + 1; - data &= 0xffff00; - } else { - /* rmh->dsp_stat == RMH_SSIZE_MASK */ - rmh->stat_len = 1; - size_mask = data; - while (size_mask) { - if (size_mask & 1) - rmh->stat_len++; - size_mask >>= 1; - } - } - } - } -#ifdef CONFIG_SND_DEBUG_DETECT - if (rmh->cmd_idx < CMD_LAST_INDEX) - snd_printdd(" stat[%d]=%x\n", i, data); -#endif - if (i < max_stat_len) - rmh->stat[i] = data; - } - if (rmh->stat_len > max_stat_len) { - snd_printdd("PCXHR : rmh->stat_len=%x too big\n", rmh->stat_len); - rmh->stat_len = max_stat_len; - } - return 0; -} - -static int pcxhr_send_msg_nolock(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh) -{ - int err; - int i; - u32 data; - unsigned char reg; - - snd_assert(rmh->cmd_len<PCXHR_SIZE_MAX_CMD, return -EINVAL); - err = pcxhr_send_it_dsp(mgr, PCXHR_IT_MESSAGE, 1); - if (err) { - snd_printk(KERN_ERR "pcxhr_send_message : ED_DSP_CRASHED\n"); - return err; - } - /* wait for chk bit */ - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, - PCXHR_ISR_HI08_CHK, PCXHR_TIMEOUT_DSP, ®); - if (err) - return err; - /* reset irq chk */ - err = pcxhr_send_it_dsp(mgr, PCXHR_IT_RESET_CHK, 1); - if (err) - return err; - /* wait for chk bit == 0*/ - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, 0, - PCXHR_TIMEOUT_DSP, ®); - if (err) - return err; - - data = rmh->cmd[0]; - - if (rmh->cmd_len > 1) - data |= 0x008000; /* MASK_MORE_THAN_1_WORD_COMMAND */ - else - data &= 0xff7fff; /* MASK_1_WORD_COMMAND */ -#ifdef CONFIG_SND_DEBUG_DETECT - if (rmh->cmd_idx < CMD_LAST_INDEX) - snd_printdd("MSG cmd[0]=%x (%s)\n", data, cmd_names[rmh->cmd_idx]); -#endif - - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_TRDY, - PCXHR_ISR_HI08_TRDY, PCXHR_TIMEOUT_DSP, ®); - if (err) - return err; - PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, (data>>16)&0xFF); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, (data>>8)&0xFF); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, (data&0xFF)); - - if (rmh->cmd_len > 1) { - /* send length */ - data = rmh->cmd_len - 1; - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_TRDY, - PCXHR_ISR_HI08_TRDY, PCXHR_TIMEOUT_DSP, ®); - if (err) - return err; - PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, (data>>16)&0xFF); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, (data>>8)&0xFF); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, (data&0xFF)); - - for (i=1; i < rmh->cmd_len; i++) { - /* send other words */ - data = rmh->cmd[i]; -#ifdef CONFIG_SND_DEBUG_DETECT - if (rmh->cmd_idx < CMD_LAST_INDEX) - snd_printdd(" cmd[%d]=%x\n", i, data); -#endif - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, - PCXHR_ISR_HI08_TRDY, - PCXHR_ISR_HI08_TRDY, - PCXHR_TIMEOUT_DSP, ®); - if (err) - return err; - PCXHR_OUTPB(mgr, PCXHR_DSP_TXH, (data>>16)&0xFF); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXM, (data>>8)&0xFF); - PCXHR_OUTPB(mgr, PCXHR_DSP_TXL, (data&0xFF)); - } - } - /* wait for chk bit */ - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_CHK, - PCXHR_ISR_HI08_CHK, PCXHR_TIMEOUT_DSP, ®); - if (err) - return err; - /* test status ISR */ - if (reg & PCXHR_ISR_HI08_ERR) { - /* ERROR, wait for receiver full */ - err = pcxhr_check_reg_bit(mgr, PCXHR_DSP_ISR, PCXHR_ISR_HI08_RXDF, - PCXHR_ISR_HI08_RXDF, PCXHR_TIMEOUT_DSP, ®); - if (err) { - snd_printk(KERN_ERR "ERROR RMH: ISR:RXDF=1 (ISR = %x)\n", reg); - return err; - } - /* read error code */ - data = PCXHR_INPB(mgr, PCXHR_DSP_TXH) << 16; - data |= PCXHR_INPB(mgr, PCXHR_DSP_TXM) << 8; - data |= PCXHR_INPB(mgr, PCXHR_DSP_TXL); - snd_printk(KERN_ERR "ERROR RMH(%d): 0x%x\n", rmh->cmd_idx, data); - err = -EINVAL; - } else { - /* read the response data */ - err = pcxhr_read_rmh_status(mgr, rmh); - } - /* reset semaphore */ - if (pcxhr_send_it_dsp(mgr, PCXHR_IT_RESET_SEMAPHORE, 1) < 0) - return -EIO; - return err; -} - - -/** - * pcxhr_init_rmh - initialize the RMH instance - * @rmh: the rmh pointer to be initialized - * @cmd: the rmh command to be set - */ -void pcxhr_init_rmh(struct pcxhr_rmh *rmh, int cmd) -{ - snd_assert(cmd < CMD_LAST_INDEX, return); - rmh->cmd[0] = pcxhr_dsp_cmds[cmd].opcode; - rmh->cmd_len = 1; - rmh->stat_len = pcxhr_dsp_cmds[cmd].st_length; - rmh->dsp_stat = pcxhr_dsp_cmds[cmd].st_type; - rmh->cmd_idx = cmd; -} - - -void pcxhr_set_pipe_cmd_params(struct pcxhr_rmh *rmh, int capture, - unsigned int param1, unsigned int param2, - unsigned int param3) -{ - snd_assert(param1 <= MASK_FIRST_FIELD); - if (capture) - rmh->cmd[0] |= 0x800; /* COMMAND_RECORD_MASK */ - if (param1) - rmh->cmd[0] |= (param1 << FIELD_SIZE); - if (param2) { - snd_assert(param2 <= MASK_FIRST_FIELD); - rmh->cmd[0] |= param2; - } - if(param3) { - snd_assert(param3 <= MASK_DSP_WORD); - rmh->cmd[1] = param3; - rmh->cmd_len = 2; - } -} - -/* - * pcxhr_send_msg - send a DSP message with spinlock - * @rmh: the rmh record to send and receive - * - * returns 0 if successful, or a negative error code. - */ -int pcxhr_send_msg(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh) -{ - unsigned long flags; - int err; - spin_lock_irqsave(&mgr->msg_lock, flags); - err = pcxhr_send_msg_nolock(mgr, rmh); - spin_unlock_irqrestore(&mgr->msg_lock, flags); - return err; -} - -static inline int pcxhr_pipes_running(struct pcxhr_mgr *mgr) -{ - int start_mask = PCXHR_INPL(mgr, PCXHR_PLX_MBOX2); - /* least segnificant 12 bits are the pipe states for the playback audios */ - /* next 12 bits are the pipe states for the capture audios - * (PCXHR_PIPE_STATE_CAPTURE_OFFSET) - */ - start_mask &= 0xffffff; - snd_printdd("CMD_PIPE_STATE MBOX2=0x%06x\n", start_mask); - return start_mask; -} - -#define PCXHR_PIPE_STATE_CAPTURE_OFFSET 12 -#define MAX_WAIT_FOR_DSP 20 - -static int pcxhr_prepair_pipe_start(struct pcxhr_mgr *mgr, int audio_mask, int *retry) -{ - struct pcxhr_rmh rmh; - int err; - int audio = 0; - - *retry = 0; - while (audio_mask) { - if (audio_mask & 1) { - pcxhr_init_rmh(&rmh, CMD_CAN_START_PIPE); - if (audio < PCXHR_PIPE_STATE_CAPTURE_OFFSET) { - /* can start playback pipe */ - pcxhr_set_pipe_cmd_params(&rmh, 0, audio, 0, 0); - } else { - /* can start capture pipe */ - pcxhr_set_pipe_cmd_params(&rmh, 1, audio - - PCXHR_PIPE_STATE_CAPTURE_OFFSET, - 0, 0); - } - err = pcxhr_send_msg(mgr, &rmh); - if (err) { - snd_printk(KERN_ERR - "error pipe start (CMD_CAN_START_PIPE) err=%x!\n", - err); - return err; - } - /* if the pipe couldn't be prepaired for start, retry it later */ - if (rmh.stat[0] == 0) - *retry |= (1<<audio); - } - audio_mask>>=1; - audio++; - } - return 0; -} - -static int pcxhr_stop_pipes(struct pcxhr_mgr *mgr, int audio_mask) -{ - struct pcxhr_rmh rmh; - int err; - int audio = 0; - - while (audio_mask) { - if (audio_mask & 1) { - pcxhr_init_rmh(&rmh, CMD_STOP_PIPE); - if (audio < PCXHR_PIPE_STATE_CAPTURE_OFFSET) { - /* stop playback pipe */ - pcxhr_set_pipe_cmd_params(&rmh, 0, audio, 0, 0); - } else { - /* stop capture pipe */ - pcxhr_set_pipe_cmd_params(&rmh, 1, audio - - PCXHR_PIPE_STATE_CAPTURE_OFFSET, - 0, 0); - } - err = pcxhr_send_msg(mgr, &rmh); - if (err) { - snd_printk(KERN_ERR - "error pipe stop (CMD_STOP_PIPE) err=%x!\n", - err); - return err; - } - } - audio_mask>>=1; - audio++; - } - return 0; -} - -static int pcxhr_toggle_pipes(struct pcxhr_mgr *mgr, int audio_mask) -{ - struct pcxhr_rmh rmh; - int err; - int audio = 0; - - while (audio_mask) { - if (audio_mask & 1) { - pcxhr_init_rmh(&rmh, CMD_CONF_PIPE); - if (audio < PCXHR_PIPE_STATE_CAPTURE_OFFSET) - pcxhr_set_pipe_cmd_params(&rmh, 0, 0, 0, 1 << audio); - else - pcxhr_set_pipe_cmd_params(&rmh, 1, 0, 0, - 1 << (audio - PCXHR_PIPE_STATE_CAPTURE_OFFSET)); - err = pcxhr_send_msg(mgr, &rmh); - if (err) { - snd_printk(KERN_ERR - "error pipe start (CMD_CONF_PIPE) err=%x!\n", - err); - return err; - } - } - audio_mask>>=1; - audio++; - } - /* now fire the interrupt on the card */ - pcxhr_init_rmh(&rmh, CMD_SEND_IRQA); - err = pcxhr_send_msg(mgr, &rmh); - if (err) { - snd_printk(KERN_ERR "error pipe start (CMD_SEND_IRQA) err=%x!\n", err ); - return err; - } - return 0; -} - - - -int pcxhr_set_pipe_state(struct pcxhr_mgr *mgr, int playback_mask, int capture_mask, int start) -{ - int state, i, err; - int audio_mask; - -#ifdef CONFIG_SND_DEBUG_DETECT - struct timeval my_tv1, my_tv2; - do_gettimeofday(&my_tv1); -#endif - audio_mask = (playback_mask | (capture_mask << PCXHR_PIPE_STATE_CAPTURE_OFFSET)); - /* current pipe state (playback + record) */ - state = pcxhr_pipes_running(mgr); - snd_printdd("pcxhr_set_pipe_state %s (mask %x current %x)\n", - start ? "START" : "STOP", audio_mask, state); - if (start) { - audio_mask &= ~state; /* start only pipes that are not yet started */ - state = audio_mask; - for (i = 0; i < MAX_WAIT_FOR_DSP; i++) { - err = pcxhr_prepair_pipe_start(mgr, state, &state); - if (err) - return err; - if (state == 0) - break; /* success, all pipes prepaired for start */ - mdelay(1); /* otherwise wait 1 millisecond and retry */ - } - } else { - audio_mask &= state; /* stop only pipes that are started */ - } - if (audio_mask == 0) - return 0; - - err = pcxhr_toggle_pipes(mgr, audio_mask); - if (err) - return err; - - i = 0; - while (1) { - state = pcxhr_pipes_running(mgr); - /* have all pipes the new state ? */ - if ((state & audio_mask) == (start ? audio_mask : 0)) - break; - if (++i >= MAX_WAIT_FOR_DSP * 100) { - snd_printk(KERN_ERR "error pipe start/stop (ED_NO_RESPONSE_AT_IRQA)\n"); - return -EBUSY; - } - udelay(10); /* wait 10 microseconds */ - } - if (!start) { - err = pcxhr_stop_pipes(mgr, audio_mask); - if (err) - return err; - } -#ifdef CONFIG_SND_DEBUG_DETECT - do_gettimeofday(&my_tv2); - snd_printdd("***SET PIPE STATE*** TIME = %ld (err = %x)\n", - my_tv2.tv_usec - my_tv1.tv_usec, err); -#endif - return 0; -} - -int pcxhr_write_io_num_reg_cont(struct pcxhr_mgr *mgr, unsigned int mask, - unsigned int value, int *changed) -{ - struct pcxhr_rmh rmh; - unsigned long flags; - int err; - - spin_lock_irqsave(&mgr->msg_lock, flags); - if ((mgr->io_num_reg_cont & mask) == value) { - snd_printdd("IO_NUM_REG_CONT mask %x already is set to %x\n", mask, value); - if (changed) - *changed = 0; - spin_unlock_irqrestore(&mgr->msg_lock, flags); - return 0; /* already programmed */ - } - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); - rmh.cmd[0] |= IO_NUM_REG_CONT; - rmh.cmd[1] = mask; - rmh.cmd[2] = value; - rmh.cmd_len = 3; - err = pcxhr_send_msg_nolock(mgr, &rmh); - if (err == 0) { - mgr->io_num_reg_cont &= ~mask; - mgr->io_num_reg_cont |= value; - if (changed) - *changed = 1; - } - spin_unlock_irqrestore(&mgr->msg_lock, flags); - return err; -} - -#define PCXHR_IRQ_TIMER 0x000300 -#define PCXHR_IRQ_FREQ_CHANGE 0x000800 -#define PCXHR_IRQ_TIME_CODE 0x001000 -#define PCXHR_IRQ_NOTIFY 0x002000 -#define PCXHR_IRQ_ASYNC 0x008000 -#define PCXHR_IRQ_MASK 0x00bb00 -#define PCXHR_FATAL_DSP_ERR 0xff0000 - -enum pcxhr_async_err_src { - PCXHR_ERR_PIPE, - PCXHR_ERR_STREAM, - PCXHR_ERR_AUDIO -}; - -static int pcxhr_handle_async_err(struct pcxhr_mgr *mgr, u32 err, - enum pcxhr_async_err_src err_src, int pipe, - int is_capture) -{ -#ifdef CONFIG_SND_DEBUG_DETECT - static char* err_src_name[] = { - [PCXHR_ERR_PIPE] = "Pipe", - [PCXHR_ERR_STREAM] = "Stream", - [PCXHR_ERR_AUDIO] = "Audio" - }; -#endif - if (err & 0xfff) - err &= 0xfff; - else - err = ((err >> 12) & 0xfff); - if (!err) - return 0; - snd_printdd("CMD_ASYNC : Error %s %s Pipe %d err=%x\n", err_src_name[err_src], - is_capture ? "Record" : "Play", pipe, err); - if (err == 0xe01) - mgr->async_err_stream_xrun++; - else if (err == 0xe10) - mgr->async_err_pipe_xrun++; - else - mgr->async_err_other_last = (int)err; - return 1; -} - - -void pcxhr_msg_tasklet(unsigned long arg) -{ - struct pcxhr_mgr *mgr = (struct pcxhr_mgr *)(arg); - struct pcxhr_rmh *prmh = mgr->prmh; - int err; - int i, j; - - if (mgr->src_it_dsp & PCXHR_IRQ_FREQ_CHANGE) - snd_printdd("TASKLET : PCXHR_IRQ_FREQ_CHANGE event occured\n"); - if (mgr->src_it_dsp & PCXHR_IRQ_TIME_CODE) - snd_printdd("TASKLET : PCXHR_IRQ_TIME_CODE event occured\n"); - if (mgr->src_it_dsp & PCXHR_IRQ_NOTIFY) - snd_printdd("TASKLET : PCXHR_IRQ_NOTIFY event occured\n"); - if (mgr->src_it_dsp & PCXHR_IRQ_ASYNC) { - snd_printdd("TASKLET : PCXHR_IRQ_ASYNC event occured\n"); - - pcxhr_init_rmh(prmh, CMD_ASYNC); - prmh->cmd[0] |= 1; /* add SEL_ASYNC_EVENTS */ - /* this is the only one extra long response command */ - prmh->stat_len = PCXHR_SIZE_MAX_LONG_STATUS; - err = pcxhr_send_msg(mgr, prmh); - if (err) - snd_printk(KERN_ERR "ERROR pcxhr_msg_tasklet=%x;\n", err); - i = 1; - while (i < prmh->stat_len) { - int nb_audio = (prmh->stat[i] >> FIELD_SIZE) & MASK_FIRST_FIELD; - int nb_stream = (prmh->stat[i] >> (2*FIELD_SIZE)) & MASK_FIRST_FIELD; - int pipe = prmh->stat[i] & MASK_FIRST_FIELD; - int is_capture = prmh->stat[i] & 0x400000; - u32 err; - - if (prmh->stat[i] & 0x800000) { /* if BIT_END */ - snd_printdd("TASKLET : End%sPipe %d\n", - is_capture ? "Record" : "Play", pipe); - } - i++; - err = prmh->stat[i] ? prmh->stat[i] : prmh->stat[i+1]; - if (err) - pcxhr_handle_async_err(mgr, err, PCXHR_ERR_PIPE, - pipe, is_capture); - i += 2; - for (j = 0; j < nb_stream; j++) { - err = prmh->stat[i] ? prmh->stat[i] : prmh->stat[i+1]; - if (err) - pcxhr_handle_async_err(mgr, err, PCXHR_ERR_STREAM, - pipe, is_capture); - i += 2; - } - for (j = 0; j < nb_audio; j++) { - err = prmh->stat[i] ? prmh->stat[i] : prmh->stat[i+1]; - if (err) - pcxhr_handle_async_err(mgr, err, PCXHR_ERR_AUDIO, - pipe, is_capture); - i += 2; - } - } - } -} - -static u_int64_t pcxhr_stream_read_position(struct pcxhr_mgr *mgr, - struct pcxhr_stream *stream) -{ - u_int64_t hw_sample_count; - struct pcxhr_rmh rmh; - int err, stream_mask; - - stream_mask = stream->pipe->is_capture ? 1 : 1<<stream->substream->number; - - /* get sample count for one stream */ - pcxhr_init_rmh(&rmh, CMD_STREAM_SAMPLE_COUNT); - pcxhr_set_pipe_cmd_params(&rmh, stream->pipe->is_capture, - stream->pipe->first_audio, 0, stream_mask); - /* rmh.stat_len = 2; */ /* 2 resp data for each stream of the pipe */ - - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return 0; - - hw_sample_count = ((u_int64_t)rmh.stat[0]) << 24; - hw_sample_count += (u_int64_t)rmh.stat[1]; - - snd_printdd("stream %c%d : abs samples real(%ld) timer(%ld)\n", - stream->pipe->is_capture ? 'C':'P', stream->substream->number, - (long unsigned int)hw_sample_count, - (long unsigned int)(stream->timer_abs_periods + - stream->timer_period_frag + PCXHR_GRANULARITY)); - - return hw_sample_count; -} - -static void pcxhr_update_timer_pos(struct pcxhr_mgr *mgr, - struct pcxhr_stream *stream, int samples_to_add) -{ - if (stream->substream && (stream->status == PCXHR_STREAM_STATUS_RUNNING)) { - u_int64_t new_sample_count; - int elapsed = 0; - int hardware_read = 0; - struct snd_pcm_runtime *runtime = stream->substream->runtime; - - if (samples_to_add < 0) { - stream->timer_is_synced = 0; - /* add default if no hardware_read possible */ - samples_to_add = PCXHR_GRANULARITY; - } - - if (!stream->timer_is_synced) { - if (stream->timer_abs_periods != 0 || - stream->timer_period_frag + PCXHR_GRANULARITY >= - runtime->period_size) { - new_sample_count = pcxhr_stream_read_position(mgr, stream); - hardware_read = 1; - if (new_sample_count >= PCXHR_GRANULARITY_MIN) { - /* sub security offset because of jitter and - * finer granularity of dsp time (MBOX4) - */ - new_sample_count -= PCXHR_GRANULARITY_MIN; - stream->timer_is_synced = 1; - } - } - } - if (!hardware_read) { - /* if we didn't try to sync the position, increment it - * by PCXHR_GRANULARITY every timer interrupt - */ - new_sample_count = stream->timer_abs_periods + - stream->timer_period_frag + samples_to_add; - } - while (1) { - u_int64_t new_elapse_pos = stream->timer_abs_periods + - runtime->period_size; - if (new_elapse_pos > new_sample_count) - break; - elapsed = 1; - stream->timer_buf_periods++; - if (stream->timer_buf_periods >= runtime->periods) - stream->timer_buf_periods = 0; - stream->timer_abs_periods = new_elapse_pos; - } - if (new_sample_count >= stream->timer_abs_periods) - stream->timer_period_frag = (u_int32_t)(new_sample_count - - stream->timer_abs_periods); - else - snd_printk(KERN_ERR "ERROR new_sample_count too small ??? %lx\n", - (long unsigned int)new_sample_count); - - if (elapsed) { - spin_unlock(&mgr->lock); - snd_pcm_period_elapsed(stream->substream); - spin_lock(&mgr->lock); - } - } -} - - -irqreturn_t pcxhr_interrupt(int irq, void *dev_id, struct pt_regs *regs) -{ - struct pcxhr_mgr *mgr = dev_id; - unsigned int reg; - int i, j; - struct snd_pcxhr *chip; - - spin_lock(&mgr->lock); - - reg = PCXHR_INPL(mgr, PCXHR_PLX_IRQCS); - if (! (reg & PCXHR_IRQCS_ACTIVE_PCIDB)) { - spin_unlock(&mgr->lock); - return IRQ_NONE; /* this device did not cause the interrupt */ - } - - /* clear interrupt */ - reg = PCXHR_INPL(mgr, PCXHR_PLX_L2PCIDB); - PCXHR_OUTPL(mgr, PCXHR_PLX_L2PCIDB, reg); - - /* timer irq occured */ - if (reg & PCXHR_IRQ_TIMER) { - int timer_toggle = reg & PCXHR_IRQ_TIMER; - /* is a 24 bit counter */ - int dsp_time_new = PCXHR_INPL(mgr, PCXHR_PLX_MBOX4) & PCXHR_DSP_TIME_MASK; - int dsp_time_diff = dsp_time_new - mgr->dsp_time_last; - - if (dsp_time_diff < 0 && mgr->dsp_time_last != PCXHR_DSP_TIME_INVALID) { - snd_printdd("ERROR DSP TIME old(%d) new(%d) -> " - "resynchronize all streams\n", - mgr->dsp_time_last, dsp_time_new); - mgr->dsp_time_err++; - } -#ifdef CONFIG_SND_DEBUG_DETECT - if (dsp_time_diff == 0) - snd_printdd("ERROR DSP TIME NO DIFF time(%d)\n", dsp_time_new); - else if (dsp_time_diff >= (2*PCXHR_GRANULARITY)) - snd_printdd("ERROR DSP TIME TOO BIG old(%d) add(%d)\n", - mgr->dsp_time_last, dsp_time_new - mgr->dsp_time_last); -#endif - mgr->dsp_time_last = dsp_time_new; - - if (timer_toggle == mgr->timer_toggle) - snd_printk(KERN_ERR "ERROR TIMER TOGGLE\n"); - mgr->timer_toggle = timer_toggle; - - reg &= ~PCXHR_IRQ_TIMER; - for (i = 0; i < mgr->num_cards; i++) { - chip = mgr->chip[i]; - for (j = 0; j < chip->nb_streams_capt; j++) - pcxhr_update_timer_pos(mgr, &chip->capture_stream[j], - dsp_time_diff); - } - for (i = 0; i < mgr->num_cards; i++) { - chip = mgr->chip[i]; - for (j = 0; j < chip->nb_streams_play; j++) - pcxhr_update_timer_pos(mgr, &chip->playback_stream[j], - dsp_time_diff); - } - } - /* other irq's handled in the tasklet */ - if (reg & PCXHR_IRQ_MASK) { - - /* as we didn't request any notifications, some kind of xrun error - * will probably occured - */ - /* better resynchronize all streams next interrupt : */ - mgr->dsp_time_last = PCXHR_DSP_TIME_INVALID; - - mgr->src_it_dsp = reg; - tasklet_hi_schedule(&mgr->msg_taskq); - } -#ifdef CONFIG_SND_DEBUG_DETECT - if (reg & PCXHR_FATAL_DSP_ERR) - snd_printdd("FATAL DSP ERROR : %x\n", reg); -#endif - spin_unlock(&mgr->lock); - return IRQ_HANDLED; /* this device caused the interrupt */ -} diff --git a/trunk/sound/pci/pcxhr/pcxhr_core.h b/trunk/sound/pci/pcxhr/pcxhr_core.h deleted file mode 100644 index e7415d6d1826..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr_core.h +++ /dev/null @@ -1,200 +0,0 @@ -/* - * Driver for Digigram pcxhr compatible soundcards - * - * low level interface with interrupt ans message handling - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __SOUND_PCXHR_CORE_H -#define __SOUND_PCXHR_CORE_H - -struct firmware; -struct pcxhr_mgr; - -/* init and firmware download commands */ -void pcxhr_reset_xilinx_com(struct pcxhr_mgr *mgr); -void pcxhr_reset_dsp(struct pcxhr_mgr *mgr); -void pcxhr_enable_dsp(struct pcxhr_mgr *mgr); -int pcxhr_load_xilinx_binary(struct pcxhr_mgr *mgr, const struct firmware *xilinx, int second); -int pcxhr_load_eeprom_binary(struct pcxhr_mgr *mgr, const struct firmware *eeprom); -int pcxhr_load_boot_binary(struct pcxhr_mgr *mgr, const struct firmware *boot); -int pcxhr_load_dsp_binary(struct pcxhr_mgr *mgr, const struct firmware *dsp); - -/* DSP time available on MailBox4 register : 24 bit time samples() */ -#define PCXHR_DSP_TIME_MASK 0x00ffffff -#define PCXHR_DSP_TIME_INVALID 0x10000000 - - -#define PCXHR_SIZE_MAX_CMD 8 -#define PCXHR_SIZE_MAX_STATUS 16 -#define PCXHR_SIZE_MAX_LONG_STATUS 256 - -struct pcxhr_rmh { - u16 cmd_len; /* length of the command to send (WORDs) */ - u16 stat_len; /* length of the status received (WORDs) */ - u16 dsp_stat; /* status type, RMP_SSIZE_XXX */ - u16 cmd_idx; /* index of the command */ - u32 cmd[PCXHR_SIZE_MAX_CMD]; - u32 stat[PCXHR_SIZE_MAX_STATUS]; -}; - -enum { - CMD_VERSION, /* cmd_len = 2 stat_len = 1 */ - CMD_SUPPORTED, /* cmd_len = 1 stat_len = 4 */ - CMD_TEST_IT, /* cmd_len = 1 stat_len = 1 */ - CMD_SEND_IRQA, /* cmd_len = 1 stat_len = 0 */ - CMD_ACCESS_IO_WRITE, /* cmd_len >= 1 stat_len >= 1 */ - CMD_ACCESS_IO_READ, /* cmd_len >= 1 stat_len >= 1 */ - CMD_ASYNC, /* cmd_len = 1 stat_len = 1 */ - CMD_MODIFY_CLOCK, /* cmd_len = 3 stat_len = 0 */ - CMD_RESYNC_AUDIO_INPUTS, /* cmd_len = 1 stat_len = 0 */ - CMD_GET_DSP_RESOURCES, /* cmd_len = 1 stat_len = 4 */ - CMD_SET_TIMER_INTERRUPT, /* cmd_len = 1 stat_len = 0 */ - CMD_RES_PIPE, /* cmd_len = 2 stat_len = 0 */ - CMD_FREE_PIPE, /* cmd_len = 1 stat_len = 0 */ - CMD_CONF_PIPE, /* cmd_len = 2 stat_len = 0 */ - CMD_STOP_PIPE, /* cmd_len = 1 stat_len = 0 */ - CMD_PIPE_SAMPLE_COUNT, /* cmd_len = 2 stat_len = 2 */ - CMD_CAN_START_PIPE, /* cmd_len >= 1 stat_len = 1 */ - CMD_START_STREAM, /* cmd_len = 2 stat_len = 0 */ - CMD_STREAM_OUT_LEVEL_ADJUST, /* cmd_len >= 1 stat_len = 0 */ - CMD_STOP_STREAM, /* cmd_len = 2 stat_len = 0 */ - CMD_UPDATE_R_BUFFERS, /* cmd_len = 4 stat_len = 0 */ - CMD_FORMAT_STREAM_OUT, /* cmd_len >= 2 stat_len = 0 */ - CMD_FORMAT_STREAM_IN, /* cmd_len >= 4 stat_len = 0 */ - CMD_STREAM_SAMPLE_COUNT, /* cmd_len = 2 stat_len = (2 * nb_stream) */ - CMD_AUDIO_LEVEL_ADJUST, /* cmd_len = 3 stat_len = 0 */ - CMD_LAST_INDEX -}; - -#define MASK_DSP_WORD 0x00ffffff -#define MASK_ALL_STREAM 0x00ffffff -#define MASK_DSP_WORD_LEVEL 0x000001ff -#define MASK_FIRST_FIELD 0x0000001f -#define FIELD_SIZE 5 - -/* - init the rmh struct; by default cmd_len is set to 1 - */ -void pcxhr_init_rmh(struct pcxhr_rmh *rmh, int cmd); - -void pcxhr_set_pipe_cmd_params(struct pcxhr_rmh* rmh, int capture, unsigned int param1, - unsigned int param2, unsigned int param3); - -/* - send the rmh - */ -int pcxhr_send_msg(struct pcxhr_mgr *mgr, struct pcxhr_rmh *rmh); - - -/* values used for CMD_ACCESS_IO_WRITE and CMD_ACCESS_IO_READ */ -#define IO_NUM_REG_CONT 0 -#define IO_NUM_REG_GENCLK 1 -#define IO_NUM_REG_MUTE_OUT 2 -#define IO_NUM_SPEED_RATIO 4 -#define IO_NUM_REG_STATUS 5 -#define IO_NUM_REG_CUER 10 -#define IO_NUM_UER_CHIP_REG 11 -#define IO_NUM_REG_OUT_ANA_LEVEL 20 -#define IO_NUM_REG_IN_ANA_LEVEL 21 - - -#define REG_CONT_UNMUTE_INPUTS 0x020000 - -/* parameters used with register IO_NUM_REG_STATUS */ -#define REG_STATUS_OPTIONS 0 -#define REG_STATUS_AES_SYNC 8 -#define REG_STATUS_AES_1 9 -#define REG_STATUS_AES_2 10 -#define REG_STATUS_AES_3 11 -#define REG_STATUS_AES_4 12 -#define REG_STATUS_WORD_CLOCK 13 -#define REG_STATUS_INTER_SYNC 14 -#define REG_STATUS_CURRENT 0x80 -/* results */ -#define REG_STATUS_OPT_NO_VIDEO_SIGNAL 0x01 -#define REG_STATUS_OPT_DAUGHTER_MASK 0x1c -#define REG_STATUS_OPT_ANALOG_BOARD 0x00 -#define REG_STATUS_OPT_NO_DAUGHTER 0x1c -#define REG_STATUS_OPT_COMPANION_MASK 0xe0 -#define REG_STATUS_OPT_NO_COMPANION 0xe0 -#define REG_STATUS_SYNC_32000 0x00 -#define REG_STATUS_SYNC_44100 0x01 -#define REG_STATUS_SYNC_48000 0x02 -#define REG_STATUS_SYNC_64000 0x03 -#define REG_STATUS_SYNC_88200 0x04 -#define REG_STATUS_SYNC_96000 0x05 -#define REG_STATUS_SYNC_128000 0x06 -#define REG_STATUS_SYNC_176400 0x07 -#define REG_STATUS_SYNC_192000 0x08 - -int pcxhr_set_pipe_state(struct pcxhr_mgr *mgr, int playback_mask, int capture_mask, int start); - -int pcxhr_write_io_num_reg_cont(struct pcxhr_mgr *mgr, unsigned int mask, - unsigned int value, int *changed); - -/* codec parameters */ -#define CS8416_RUN 0x200401 -#define CS8416_FORMAT_DETECT 0x200b00 -#define CS8416_CSB0 0x201900 -#define CS8416_CSB1 0x201a00 -#define CS8416_CSB2 0x201b00 -#define CS8416_CSB3 0x201c00 -#define CS8416_CSB4 0x201d00 -#define CS8416_VERSION 0x207f00 - -#define CS8420_DATA_FLOW_CTL 0x200301 -#define CS8420_CLOCK_SRC_CTL 0x200401 -#define CS8420_RECEIVER_ERRORS 0x201000 -#define CS8420_SRC_RATIO 0x201e00 -#define CS8420_CSB0 0x202000 -#define CS8420_CSB1 0x202100 -#define CS8420_CSB2 0x202200 -#define CS8420_CSB3 0x202300 -#define CS8420_CSB4 0x202400 -#define CS8420_VERSION 0x207f00 - -#define CS4271_MODE_CTL_1 0x200101 -#define CS4271_DAC_CTL 0x200201 -#define CS4271_VOLMIX 0x200301 -#define CS4271_VOLMUTE_LEFT 0x200401 -#define CS4271_VOLMUTE_RIGHT 0x200501 -#define CS4271_ADC_CTL 0x200601 -#define CS4271_MODE_CTL_2 0x200701 - -#define CHIP_SIG_AND_MAP_SPI 0xff7f00 - -/* codec selection */ -#define CS4271_01_CS 0x160018 -#define CS4271_23_CS 0x160019 -#define CS4271_45_CS 0x16001a -#define CS4271_67_CS 0x16001b -#define CS4271_89_CS 0x16001c -#define CS4271_AB_CS 0x16001d -#define CS8420_01_CS 0x080090 -#define CS8420_23_CS 0x080092 -#define CS8420_45_CS 0x080094 -#define CS8420_67_CS 0x080096 -#define CS8416_01_CS 0x080098 - - -/* interrupt handling */ -irqreturn_t pcxhr_interrupt(int irq, void *dev_id, struct pt_regs *regs); -void pcxhr_msg_tasklet(unsigned long arg); - -#endif /* __SOUND_PCXHR_CORE_H */ diff --git a/trunk/sound/pci/pcxhr/pcxhr_hwdep.c b/trunk/sound/pci/pcxhr/pcxhr_hwdep.c deleted file mode 100644 index 03517c10e99c..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr_hwdep.c +++ /dev/null @@ -1,438 +0,0 @@ -/* - * Driver for Digigram pcxhr compatible soundcards - * - * hwdep device manager - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include <sound/driver.h> -#include <linux/interrupt.h> -#include <linux/vmalloc.h> -#include <linux/firmware.h> -#include <linux/pci.h> -#include <asm/io.h> -#include <sound/core.h> -#include <sound/hwdep.h> -#include "pcxhr.h" -#include "pcxhr_mixer.h" -#include "pcxhr_hwdep.h" -#include "pcxhr_core.h" - - -#if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE) -#if !defined(CONFIG_USE_PCXHRLOADER) && !defined(CONFIG_SND_PCXHR) /* built-in kernel */ -#define SND_PCXHR_FW_LOADER /* use the standard firmware loader */ -#endif -#endif - - -/* - * get basic information and init pcxhr card - */ - -static int pcxhr_init_board(struct pcxhr_mgr *mgr) -{ - int err; - struct pcxhr_rmh rmh; - int card_streams; - - /* calc the number of all streams used */ - if (mgr->mono_capture) - card_streams = mgr->capture_chips * 2; - else - card_streams = mgr->capture_chips; - card_streams += mgr->playback_chips * PCXHR_PLAYBACK_STREAMS; - - /* enable interrupts */ - pcxhr_enable_dsp(mgr); - - pcxhr_init_rmh(&rmh, CMD_SUPPORTED); - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - /* test 8 or 12 phys out */ - snd_assert((rmh.stat[0] & MASK_FIRST_FIELD) == mgr->playback_chips*2, - return -EINVAL); - /* test 8 or 2 phys in */ - snd_assert(((rmh.stat[0] >> (2*FIELD_SIZE)) & MASK_FIRST_FIELD) == - mgr->capture_chips * 2, return -EINVAL); - /* test max nb substream per board */ - snd_assert((rmh.stat[1] & 0x5F) >= card_streams, return -EINVAL); - /* test max nb substream per pipe */ - snd_assert(((rmh.stat[1]>>7)&0x5F) >= PCXHR_PLAYBACK_STREAMS, return -EINVAL); - - pcxhr_init_rmh(&rmh, CMD_VERSION); - /* firmware num for DSP */ - rmh.cmd[0] |= mgr->firmware_num; - /* transfer granularity in samples (should be multiple of 48) */ - rmh.cmd[1] = (1<<23) + PCXHR_GRANULARITY; - rmh.cmd_len = 2; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - snd_printdd("PCXHR DSP version is %d.%d.%d\n", - (rmh.stat[0]>>16)&0xff, (rmh.stat[0]>>8)&0xff, rmh.stat[0]&0xff); - mgr->dsp_version = rmh.stat[0]; - - /* get options */ - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ); - rmh.cmd[0] |= IO_NUM_REG_STATUS; - rmh.cmd[1] = REG_STATUS_OPTIONS; - rmh.cmd_len = 2; - err = pcxhr_send_msg(mgr, &rmh); - if (err) - return err; - - if ((rmh.stat[1] & REG_STATUS_OPT_DAUGHTER_MASK) == REG_STATUS_OPT_ANALOG_BOARD) - mgr->board_has_analog = 1; /* analog addon board available */ - else - /* analog addon board not available -> no support for instance */ - return -EINVAL; - - /* unmute inputs */ - err = pcxhr_write_io_num_reg_cont(mgr, REG_CONT_UNMUTE_INPUTS, - REG_CONT_UNMUTE_INPUTS, NULL); - if (err) - return err; - /* unmute outputs */ - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ); /* a write to IO_NUM_REG_MUTE_OUT mutes! */ - rmh.cmd[0] |= IO_NUM_REG_MUTE_OUT; - err = pcxhr_send_msg(mgr, &rmh); - return err; -} - -void pcxhr_reset_board(struct pcxhr_mgr *mgr) -{ - struct pcxhr_rmh rmh; - - if (mgr->dsp_loaded & (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX)) { - /* mute outputs */ - /* a read to IO_NUM_REG_MUTE_OUT register unmutes! */ - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); - rmh.cmd[0] |= IO_NUM_REG_MUTE_OUT; - pcxhr_send_msg(mgr, &rmh); - /* mute inputs */ - pcxhr_write_io_num_reg_cont(mgr, REG_CONT_UNMUTE_INPUTS, 0, NULL); - } - /* reset pcxhr dsp */ - if (mgr->dsp_loaded & ( 1 << PCXHR_FIRMWARE_DSP_EPRM_INDEX)) - pcxhr_reset_dsp(mgr); - /* reset second xilinx */ - if (mgr->dsp_loaded & ( 1 << PCXHR_FIRMWARE_XLX_COM_INDEX)) - pcxhr_reset_xilinx_com(mgr); - return; -} - - -/* - * allocate a playback/capture pipe (pcmp0/pcmc0) - */ -static int pcxhr_dsp_allocate_pipe( struct pcxhr_mgr *mgr, struct pcxhr_pipe *pipe, - int is_capture, int pin) -{ - int stream_count, audio_count; - int err; - struct pcxhr_rmh rmh; - - if (is_capture) { - stream_count = 1; - if (mgr->mono_capture) - audio_count = 1; - else - audio_count = 2; - } else { - stream_count = PCXHR_PLAYBACK_STREAMS; - audio_count = 2; /* always stereo */ - } - snd_printdd("snd_add_ref_pipe pin(%d) pcm%c0\n", pin, is_capture ? 'c' : 'p'); - pipe->is_capture = is_capture; - pipe->first_audio = pin; - /* define pipe (P_PCM_ONLY_MASK (0x020000) is not necessary) */ - pcxhr_init_rmh(&rmh, CMD_RES_PIPE); - pcxhr_set_pipe_cmd_params(&rmh, is_capture, pin, audio_count, stream_count); - err = pcxhr_send_msg(mgr, &rmh); - if (err < 0) { - snd_printk(KERN_ERR "error pipe allocation (CMD_RES_PIPE) err=%x!\n", err ); - return err; - } - pipe->status = PCXHR_PIPE_DEFINED; - - return 0; -} - -/* - * free playback/capture pipe (pcmp0/pcmc0) - */ -#if 0 -static int pcxhr_dsp_free_pipe( struct pcxhr_mgr *mgr, struct pcxhr_pipe *pipe) -{ - struct pcxhr_rmh rmh; - int capture_mask = 0; - int playback_mask = 0; - int err = 0; - - if (pipe->is_capture) - capture_mask = (1 << pipe->first_audio); - else - playback_mask = (1 << pipe->first_audio); - - /* stop one pipe */ - err = pcxhr_set_pipe_state(mgr, playback_mask, capture_mask, 0); - if (err < 0) - snd_printk(KERN_ERR "error stopping pipe!\n"); - /* release the pipe */ - pcxhr_init_rmh(&rmh, CMD_FREE_PIPE); - pcxhr_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->first_audio, 0, 0); - err = pcxhr_send_msg(mgr, &rmh); - if (err < 0) - snd_printk(KERN_ERR "error pipe release (CMD_FREE_PIPE) err(%x)\n", err); - pipe->status = PCXHR_PIPE_UNDEFINED; - return err; -} -#endif - - -static int pcxhr_config_pipes(struct pcxhr_mgr *mgr) -{ - int err, i, j; - struct snd_pcxhr *chip; - struct pcxhr_pipe *pipe; - - /* allocate the pipes on the dsp */ - for (i = 0; i < mgr->num_cards; i++) { - chip = mgr->chip[i]; - if (chip->nb_streams_play) { - pipe = &chip->playback_pipe; - err = pcxhr_dsp_allocate_pipe( mgr, pipe, 0, i*2); - if (err) - return err; - for(j = 0; j < chip->nb_streams_play; j++) - chip->playback_stream[j].pipe = pipe; - } - for (j = 0; j < chip->nb_streams_capt; j++) { - pipe = &chip->capture_pipe[j]; - err = pcxhr_dsp_allocate_pipe(mgr, pipe, 1, i*2 + j); - if (err) - return err; - chip->capture_stream[j].pipe = pipe; - } - } - return 0; -} - -static int pcxhr_start_pipes(struct pcxhr_mgr *mgr) -{ - int i, j; - struct snd_pcxhr *chip; - int playback_mask = 0; - int capture_mask = 0; - - /* start all the pipes on the dsp */ - for (i = 0; i < mgr->num_cards; i++) { - chip = mgr->chip[i]; - if (chip->nb_streams_play) - playback_mask |= (1 << chip->playback_pipe.first_audio); - for (j = 0; j < chip->nb_streams_capt; j++) - capture_mask |= (1 << chip->capture_pipe[j].first_audio); - } - return pcxhr_set_pipe_state(mgr, playback_mask, capture_mask, 1); -} - - -static int pcxhr_dsp_load(struct pcxhr_mgr *mgr, int index, const struct firmware *dsp) -{ - int err, card_index; - - snd_printdd("loading dsp [%d] size = %Zd\n", index, dsp->size); - - switch (index) { - case PCXHR_FIRMWARE_XLX_INT_INDEX: - pcxhr_reset_xilinx_com(mgr); - return pcxhr_load_xilinx_binary(mgr, dsp, 0); - - case PCXHR_FIRMWARE_XLX_COM_INDEX: - pcxhr_reset_xilinx_com(mgr); - return pcxhr_load_xilinx_binary(mgr, dsp, 1); - - case PCXHR_FIRMWARE_DSP_EPRM_INDEX: - pcxhr_reset_dsp(mgr); - return pcxhr_load_eeprom_binary(mgr, dsp); - - case PCXHR_FIRMWARE_DSP_BOOT_INDEX: - return pcxhr_load_boot_binary(mgr, dsp); - - case PCXHR_FIRMWARE_DSP_MAIN_INDEX: - err = pcxhr_load_dsp_binary(mgr, dsp); - if (err) - return err; - break; /* continue with first init */ - default: - snd_printk(KERN_ERR "wrong file index\n"); - return -EFAULT; - } /* end of switch file index*/ - - /* first communication with embedded */ - err = pcxhr_init_board(mgr); - if (err < 0) { - snd_printk(KERN_ERR "pcxhr could not be set up\n"); - return err; - } - err = pcxhr_config_pipes(mgr); - if (err < 0) { - snd_printk(KERN_ERR "pcxhr pipes could not be set up\n"); - return err; - } - /* create devices and mixer in accordance with HW options*/ - for (card_index = 0; card_index < mgr->num_cards; card_index++) { - struct snd_pcxhr *chip = mgr->chip[card_index]; - - if ((err = pcxhr_create_pcm(chip)) < 0) - return err; - - if (card_index == 0) { - if ((err = pcxhr_create_mixer(chip->mgr)) < 0) - return err; - } - if ((err = snd_card_register(chip->card)) < 0) - return err; - } - err = pcxhr_start_pipes(mgr); - if (err < 0) { - snd_printk(KERN_ERR "pcxhr pipes could not be started\n"); - return err; - } - snd_printdd("pcxhr firmware downloaded and successfully set up\n"); - - return 0; -} - -/* - * fw loader entry - */ -#ifdef SND_PCXHR_FW_LOADER - -int pcxhr_setup_firmware(struct pcxhr_mgr *mgr) -{ - static char *fw_files[5] = { - "xi_1_882.dat", - "xc_1_882.dat", - "e321_512.e56", - "b321_512.b56", - "d321_512.d56" - }; - char path[32]; - - const struct firmware *fw_entry; - int i, err; - - for (i = 0; i < ARRAY_SIZE(fw_files); i++) { - sprintf(path, "pcxhr/%s", fw_files[i]); - if (request_firmware(&fw_entry, path, &mgr->pci->dev)) { - snd_printk(KERN_ERR "pcxhr: can't load firmware %s\n", path); - return -ENOENT; - } - /* fake hwdep dsp record */ - err = pcxhr_dsp_load(mgr, i, fw_entry); - release_firmware(fw_entry); - if (err < 0) - return err; - mgr->dsp_loaded |= 1 << i; - } - return 0; -} - -#else /* old style firmware loading */ - -/* pcxhr hwdep interface id string */ -#define PCXHR_HWDEP_ID "pcxhr loader" - - -static int pcxhr_hwdep_dsp_status(struct snd_hwdep *hw, - struct snd_hwdep_dsp_status *info) -{ - strcpy(info->id, "pcxhr"); - info->num_dsps = PCXHR_FIRMWARE_FILES_MAX_INDEX; - - if (hw->dsp_loaded & (1 << PCXHR_FIRMWARE_DSP_MAIN_INDEX)) - info->chip_ready = 1; - - info->version = PCXHR_DRIVER_VERSION; - return 0; -} - -static int pcxhr_hwdep_dsp_load(struct snd_hwdep *hw, - struct snd_hwdep_dsp_image *dsp) -{ - struct pcxhr_mgr *mgr = hw->private_data; - int err; - struct firmware fw; - - fw.size = dsp->length; - fw.data = vmalloc(fw.size); - if (! fw.data) { - snd_printk(KERN_ERR "pcxhr: cannot allocate dsp image (%d bytes)\n", - fw.size); - return -ENOMEM; - } - if (copy_from_user(fw.data, dsp->image, dsp->length)) { - vfree(fw.data); - return -EFAULT; - } - err = pcxhr_dsp_load(mgr, dsp->index, &fw); - vfree(fw.data); - if (err < 0) - return err; - mgr->dsp_loaded |= 1 << dsp->index; - return 0; -} - -static int pcxhr_hwdep_open(struct snd_hwdep *hw, struct file *file) -{ - return 0; -} - -static int pcxhr_hwdep_release(struct snd_hwdep *hw, struct file *file) -{ - return 0; -} - -int pcxhr_setup_firmware(struct pcxhr_mgr *mgr) -{ - int err; - struct snd_hwdep *hw; - - /* only create hwdep interface for first cardX (see "index" module parameter)*/ - if ((err = snd_hwdep_new(mgr->chip[0]->card, PCXHR_HWDEP_ID, 0, &hw)) < 0) - return err; - - hw->iface = SNDRV_HWDEP_IFACE_PCXHR; - hw->private_data = mgr; - hw->ops.open = pcxhr_hwdep_open; - hw->ops.release = pcxhr_hwdep_release; - hw->ops.dsp_status = pcxhr_hwdep_dsp_status; - hw->ops.dsp_load = pcxhr_hwdep_dsp_load; - hw->exclusive = 1; - mgr->dsp_loaded = 0; - sprintf(hw->name, PCXHR_HWDEP_ID); - - if ((err = snd_card_register(mgr->chip[0]->card)) < 0) - return err; - return 0; -} - -#endif /* SND_PCXHR_FW_LOADER */ diff --git a/trunk/sound/pci/pcxhr/pcxhr_hwdep.h b/trunk/sound/pci/pcxhr/pcxhr_hwdep.h deleted file mode 100644 index f561909dc05f..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr_hwdep.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Driver for Digigram pcxhr compatible soundcards - * - * definitions and makros for basic card access - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __SOUND_PCXHR_HWDEP_H -#define __SOUND_PCXHR_HWDEP_H - - -/* firmware status codes */ -#define PCXHR_FIRMWARE_XLX_INT_INDEX 0 -#define PCXHR_FIRMWARE_XLX_COM_INDEX 1 -#define PCXHR_FIRMWARE_DSP_EPRM_INDEX 2 -#define PCXHR_FIRMWARE_DSP_BOOT_INDEX 3 -#define PCXHR_FIRMWARE_DSP_MAIN_INDEX 4 -#define PCXHR_FIRMWARE_FILES_MAX_INDEX 5 - - -/* exported */ -int pcxhr_setup_firmware(struct pcxhr_mgr *mgr); -void pcxhr_reset_board(struct pcxhr_mgr *mgr); - -#endif /* __SOUND_PCXHR_HWDEP_H */ diff --git a/trunk/sound/pci/pcxhr/pcxhr_mixer.c b/trunk/sound/pci/pcxhr/pcxhr_mixer.c deleted file mode 100644 index 760e733ac25e..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr_mixer.c +++ /dev/null @@ -1,1020 +0,0 @@ -#define __NO_VERSION__ -/* - * Driver for Digigram pcxhr compatible soundcards - * - * mixer callbacks - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include <sound/driver.h> -#include <linux/time.h> -#include <linux/interrupt.h> -#include <linux/init.h> -#include <sound/core.h> -#include "pcxhr.h" -#include "pcxhr_hwdep.h" -#include "pcxhr_core.h" -#include <sound/control.h> -#include <sound/asoundef.h> -#include "pcxhr_mixer.h" - - -#define PCXHR_ANALOG_CAPTURE_LEVEL_MIN 0 /* -96.0 dB */ -#define PCXHR_ANALOG_CAPTURE_LEVEL_MAX 255 /* +31.5 dB */ -#define PCXHR_ANALOG_CAPTURE_ZERO_LEVEL 224 /* +16.0 dB ( +31.5 dB - fix level +15.5 dB ) */ - -#define PCXHR_ANALOG_PLAYBACK_LEVEL_MIN 0 /* -128.0 dB */ -#define PCXHR_ANALOG_PLAYBACK_LEVEL_MAX 128 /* 0.0 dB */ -#define PCXHR_ANALOG_PLAYBACK_ZERO_LEVEL 104 /* -24.0 dB ( 0.0 dB - fix level +24.0 dB ) */ - -static int pcxhr_update_analog_audio_level(struct snd_pcxhr *chip, int is_capture, int channel) -{ - int err, vol; - struct pcxhr_rmh rmh; - - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); - if (is_capture) { - rmh.cmd[0] |= IO_NUM_REG_IN_ANA_LEVEL; - rmh.cmd[2] = chip->analog_capture_volume[channel]; - } else { - rmh.cmd[0] |= IO_NUM_REG_OUT_ANA_LEVEL; - if (chip->analog_playback_active[channel]) - vol = chip->analog_playback_volume[channel]; - else - vol = PCXHR_ANALOG_PLAYBACK_LEVEL_MIN; - rmh.cmd[2] = PCXHR_ANALOG_PLAYBACK_LEVEL_MAX - vol; /* playback analog levels are inversed */ - } - rmh.cmd[1] = 1 << ((2 * chip->chip_idx) + channel); /* audio mask */ - rmh.cmd_len = 3; - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err < 0) { - snd_printk(KERN_DEBUG "error update_analog_audio_level card(%d) " - "is_capture(%d) err(%x)\n", chip->chip_idx, is_capture, err); - return -EINVAL; - } - return 0; -} - -/* - * analog level control - */ -static int pcxhr_analog_vol_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 2; - if (kcontrol->private_value == 0) { /* playback */ - uinfo->value.integer.min = PCXHR_ANALOG_PLAYBACK_LEVEL_MIN; /* -128 dB */ - uinfo->value.integer.max = PCXHR_ANALOG_PLAYBACK_LEVEL_MAX; /* 0 dB */ - } else { /* capture */ - uinfo->value.integer.min = PCXHR_ANALOG_CAPTURE_LEVEL_MIN; /* -96 dB */ - uinfo->value.integer.max = PCXHR_ANALOG_CAPTURE_LEVEL_MAX; /* 31.5 dB */ - } - return 0; -} - -static int pcxhr_analog_vol_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - down(&chip->mgr->mixer_mutex); - if (kcontrol->private_value == 0) { /* playback */ - ucontrol->value.integer.value[0] = chip->analog_playback_volume[0]; - ucontrol->value.integer.value[1] = chip->analog_playback_volume[1]; - } else { /* capture */ - ucontrol->value.integer.value[0] = chip->analog_capture_volume[0]; - ucontrol->value.integer.value[1] = chip->analog_capture_volume[1]; - } - up(&chip->mgr->mixer_mutex); - return 0; -} - -static int pcxhr_analog_vol_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int changed = 0; - int is_capture, i; - - down(&chip->mgr->mixer_mutex); - is_capture = (kcontrol->private_value != 0); - for (i = 0; i < 2; i++) { - int new_volume = ucontrol->value.integer.value[i]; - int* stored_volume = is_capture ? &chip->analog_capture_volume[i] : - &chip->analog_playback_volume[i]; - if (*stored_volume != new_volume) { - *stored_volume = new_volume; - changed = 1; - pcxhr_update_analog_audio_level(chip, is_capture, i); - } - } - up(&chip->mgr->mixer_mutex); - return changed; -} - -static struct snd_kcontrol_new pcxhr_control_analog_level = { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* name will be filled later */ - .info = pcxhr_analog_vol_info, - .get = pcxhr_analog_vol_get, - .put = pcxhr_analog_vol_put, -}; - -/* shared */ -static int pcxhr_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; - uinfo->count = 2; - uinfo->value.integer.min = 0; - uinfo->value.integer.max = 1; - return 0; -} - -static int pcxhr_audio_sw_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - - down(&chip->mgr->mixer_mutex); - ucontrol->value.integer.value[0] = chip->analog_playback_active[0]; - ucontrol->value.integer.value[1] = chip->analog_playback_active[1]; - up(&chip->mgr->mixer_mutex); - return 0; -} - -static int pcxhr_audio_sw_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int i, changed = 0; - down(&chip->mgr->mixer_mutex); - for(i = 0; i < 2; i++) { - if (chip->analog_playback_active[i] != ucontrol->value.integer.value[i]) { - chip->analog_playback_active[i] = ucontrol->value.integer.value[i]; - changed = 1; - pcxhr_update_analog_audio_level(chip, 0, i); /* update playback levels */ - } - } - up(&chip->mgr->mixer_mutex); - return changed; -} - -static struct snd_kcontrol_new pcxhr_control_output_switch = { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Master Playback Switch", - .info = pcxhr_sw_info, /* shared */ - .get = pcxhr_audio_sw_get, - .put = pcxhr_audio_sw_put -}; - - -#define PCXHR_DIGITAL_LEVEL_MIN 0x000 /* -110 dB */ -#define PCXHR_DIGITAL_LEVEL_MAX 0x1ff /* +18 dB */ -#define PCXHR_DIGITAL_ZERO_LEVEL 0x1b7 /* 0 dB */ - - -#define MORE_THAN_ONE_STREAM_LEVEL 0x000001 -#define VALID_STREAM_PAN_LEVEL_MASK 0x800000 -#define VALID_STREAM_LEVEL_MASK 0x400000 -#define VALID_STREAM_LEVEL_1_MASK 0x200000 -#define VALID_STREAM_LEVEL_2_MASK 0x100000 - -static int pcxhr_update_playback_stream_level(struct snd_pcxhr* chip, int idx) -{ - int err; - struct pcxhr_rmh rmh; - struct pcxhr_pipe *pipe = &chip->playback_pipe; - int left, right; - - if (chip->digital_playback_active[idx][0]) - left = chip->digital_playback_volume[idx][0]; - else - left = PCXHR_DIGITAL_LEVEL_MIN; - if (chip->digital_playback_active[idx][1]) - right = chip->digital_playback_volume[idx][1]; - else - right = PCXHR_DIGITAL_LEVEL_MIN; - - pcxhr_init_rmh(&rmh, CMD_STREAM_OUT_LEVEL_ADJUST); - /* add pipe and stream mask */ - pcxhr_set_pipe_cmd_params(&rmh, 0, pipe->first_audio, 0, 1<<idx); - /* volume left->left / right->right panoramic level */ - rmh.cmd[0] |= MORE_THAN_ONE_STREAM_LEVEL; - rmh.cmd[2] = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_1_MASK; - rmh.cmd[2] |= (left << 10); - rmh.cmd[3] = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_2_MASK; - rmh.cmd[3] |= right; - rmh.cmd_len = 4; - - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err < 0) { - snd_printk(KERN_DEBUG "error update_playback_stream_level " - "card(%d) err(%x)\n", chip->chip_idx, err); - return -EINVAL; - } - return 0; -} - -#define AUDIO_IO_HAS_MUTE_LEVEL 0x400000 -#define AUDIO_IO_HAS_MUTE_MONITOR_1 0x200000 -#define VALID_AUDIO_IO_DIGITAL_LEVEL 0x000001 -#define VALID_AUDIO_IO_MONITOR_LEVEL 0x000002 -#define VALID_AUDIO_IO_MUTE_LEVEL 0x000004 -#define VALID_AUDIO_IO_MUTE_MONITOR_1 0x000008 - -static int pcxhr_update_audio_pipe_level(struct snd_pcxhr* chip, int capture, int channel) -{ - int err; - struct pcxhr_rmh rmh; - struct pcxhr_pipe *pipe; - - if (capture) - pipe = &chip->capture_pipe[0]; - else - pipe = &chip->playback_pipe; - - pcxhr_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST); - /* add channel mask */ - pcxhr_set_pipe_cmd_params(&rmh, capture, 0, 0, 1 << (channel + pipe->first_audio)); - /* TODO : if mask (3 << pipe->first_audio) is used, left and right channel - * will be programmed to the same params - */ - if (capture) { - rmh.cmd[0] |= VALID_AUDIO_IO_DIGITAL_LEVEL; - /* VALID_AUDIO_IO_MUTE_LEVEL not yet handled (capture pipe level) */ - rmh.cmd[2] = chip->digital_capture_volume[channel]; - } else { - rmh.cmd[0] |= VALID_AUDIO_IO_MONITOR_LEVEL | VALID_AUDIO_IO_MUTE_MONITOR_1; - /* VALID_AUDIO_IO_DIGITAL_LEVEL and VALID_AUDIO_IO_MUTE_LEVEL not yet - * handled (playback pipe level) - */ - rmh.cmd[2] = chip->monitoring_volume[channel] << 10; - if (chip->monitoring_active[channel] == 0) - rmh.cmd[2] |= AUDIO_IO_HAS_MUTE_MONITOR_1; - } - rmh.cmd_len = 3; - - err = pcxhr_send_msg(chip->mgr, &rmh); - if(err<0) { - snd_printk(KERN_DEBUG "error update_audio_level card(%d) err(%x)\n", - chip->chip_idx, err); - return -EINVAL; - } - return 0; -} - - -/* shared */ -static int pcxhr_digital_vol_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 2; - uinfo->value.integer.min = PCXHR_DIGITAL_LEVEL_MIN; /* -109.5 dB */ - uinfo->value.integer.max = PCXHR_DIGITAL_LEVEL_MAX; /* 18.0 dB */ - return 0; -} - - -static int pcxhr_pcm_vol_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ - int *stored_volume; - int is_capture = kcontrol->private_value; - - down(&chip->mgr->mixer_mutex); - if (is_capture) - stored_volume = chip->digital_capture_volume; /* digital capture */ - else - stored_volume = chip->digital_playback_volume[idx]; /* digital playback */ - ucontrol->value.integer.value[0] = stored_volume[0]; - ucontrol->value.integer.value[1] = stored_volume[1]; - up(&chip->mgr->mixer_mutex); - return 0; -} - -static int pcxhr_pcm_vol_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ - int changed = 0; - int is_capture = kcontrol->private_value; - int *stored_volume; - int i; - - down(&chip->mgr->mixer_mutex); - if (is_capture) - stored_volume = chip->digital_capture_volume; /* digital capture */ - else - stored_volume = chip->digital_playback_volume[idx]; /* digital playback */ - for (i = 0; i < 2; i++) { - if (stored_volume[i] != ucontrol->value.integer.value[i]) { - stored_volume[i] = ucontrol->value.integer.value[i]; - changed = 1; - if (is_capture) /* update capture volume */ - pcxhr_update_audio_pipe_level(chip, 1, i); - } - } - if (! is_capture && changed) - pcxhr_update_playback_stream_level(chip, idx); /* update playback volume */ - up(&chip->mgr->mixer_mutex); - return changed; -} - -static struct snd_kcontrol_new snd_pcxhr_pcm_vol = -{ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - /* name will be filled later */ - /* count will be filled later */ - .info = pcxhr_digital_vol_info, /* shared */ - .get = pcxhr_pcm_vol_get, - .put = pcxhr_pcm_vol_put, -}; - - -static int pcxhr_pcm_sw_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ - - down(&chip->mgr->mixer_mutex); - ucontrol->value.integer.value[0] = chip->digital_playback_active[idx][0]; - ucontrol->value.integer.value[1] = chip->digital_playback_active[idx][1]; - up(&chip->mgr->mixer_mutex); - return 0; -} - -static int pcxhr_pcm_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int changed = 0; - int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */ - int i, j; - - down(&chip->mgr->mixer_mutex); - j = idx; - for (i = 0; i < 2; i++) { - if (chip->digital_playback_active[j][i] != ucontrol->value.integer.value[i]) { - chip->digital_playback_active[j][i] = ucontrol->value.integer.value[i]; - changed = 1; - } - } - if (changed) - pcxhr_update_playback_stream_level(chip, idx); - up(&chip->mgr->mixer_mutex); - return changed; -} - -static struct snd_kcontrol_new pcxhr_control_pcm_switch = { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "PCM Playback Switch", - .count = PCXHR_PLAYBACK_STREAMS, - .info = pcxhr_sw_info, /* shared */ - .get = pcxhr_pcm_sw_get, - .put = pcxhr_pcm_sw_put -}; - - -/* - * monitoring level control - */ - -static int pcxhr_monitor_vol_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - down(&chip->mgr->mixer_mutex); - ucontrol->value.integer.value[0] = chip->monitoring_volume[0]; - ucontrol->value.integer.value[1] = chip->monitoring_volume[1]; - up(&chip->mgr->mixer_mutex); - return 0; -} - -static int pcxhr_monitor_vol_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int changed = 0; - int i; - - down(&chip->mgr->mixer_mutex); - for (i = 0; i < 2; i++) { - if (chip->monitoring_volume[i] != ucontrol->value.integer.value[i]) { - chip->monitoring_volume[i] = ucontrol->value.integer.value[i]; - if(chip->monitoring_active[i]) /* do only when monitoring is unmuted */ - /* update monitoring volume and mute */ - pcxhr_update_audio_pipe_level(chip, 0, i); - changed = 1; - } - } - up(&chip->mgr->mixer_mutex); - return changed; -} - -static struct snd_kcontrol_new pcxhr_control_monitor_vol = { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Monitoring Volume", - .info = pcxhr_digital_vol_info, /* shared */ - .get = pcxhr_monitor_vol_get, - .put = pcxhr_monitor_vol_put, -}; - -/* - * monitoring switch control - */ - -static int pcxhr_monitor_sw_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - down(&chip->mgr->mixer_mutex); - ucontrol->value.integer.value[0] = chip->monitoring_active[0]; - ucontrol->value.integer.value[1] = chip->monitoring_active[1]; - up(&chip->mgr->mixer_mutex); - return 0; -} - -static int pcxhr_monitor_sw_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int changed = 0; - int i; - - down(&chip->mgr->mixer_mutex); - for (i = 0; i < 2; i++) { - if (chip->monitoring_active[i] != ucontrol->value.integer.value[i]) { - chip->monitoring_active[i] = ucontrol->value.integer.value[i]; - changed |= (1<<i); /* mask 0x01 and 0x02 */ - } - } - if(changed & 0x01) - /* update left monitoring volume and mute */ - pcxhr_update_audio_pipe_level(chip, 0, 0); - if(changed & 0x02) - /* update right monitoring volume and mute */ - pcxhr_update_audio_pipe_level(chip, 0, 1); - - up(&chip->mgr->mixer_mutex); - return (changed != 0); -} - -static struct snd_kcontrol_new pcxhr_control_monitor_sw = { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Monitoring Switch", - .info = pcxhr_sw_info, /* shared */ - .get = pcxhr_monitor_sw_get, - .put = pcxhr_monitor_sw_put -}; - - - -/* - * audio source select - */ -#define PCXHR_SOURCE_AUDIO01_UER 0x000100 -#define PCXHR_SOURCE_AUDIO01_SYNC 0x000200 -#define PCXHR_SOURCE_AUDIO23_UER 0x000400 -#define PCXHR_SOURCE_AUDIO45_UER 0x001000 -#define PCXHR_SOURCE_AUDIO67_UER 0x040000 - -static int pcxhr_set_audio_source(struct snd_pcxhr* chip) -{ - struct pcxhr_rmh rmh; - unsigned int mask, reg; - unsigned int codec; - int err, use_src, changed; - - switch (chip->chip_idx) { - case 0 : mask = PCXHR_SOURCE_AUDIO01_UER; codec = CS8420_01_CS; break; - case 1 : mask = PCXHR_SOURCE_AUDIO23_UER; codec = CS8420_23_CS; break; - case 2 : mask = PCXHR_SOURCE_AUDIO45_UER; codec = CS8420_45_CS; break; - case 3 : mask = PCXHR_SOURCE_AUDIO67_UER; codec = CS8420_67_CS; break; - default: return -EINVAL; - } - reg = 0; /* audio source from analog plug */ - use_src = 0; /* do not activate codec SRC */ - - if (chip->audio_capture_source != 0) { - reg = mask; /* audio source from digital plug */ - if (chip->audio_capture_source == 2) - use_src = 1; - } - /* set the input source */ - pcxhr_write_io_num_reg_cont(chip->mgr, mask, reg, &changed); - /* resync them (otherwise channel inversion possible) */ - if (changed) { - pcxhr_init_rmh(&rmh, CMD_RESYNC_AUDIO_INPUTS); - rmh.cmd[0] |= (1 << chip->chip_idx); - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err) - return err; - } - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); /* set codec SRC on off */ - rmh.cmd_len = 3; - rmh.cmd[0] |= IO_NUM_UER_CHIP_REG; - rmh.cmd[1] = codec; - rmh.cmd[2] = (CS8420_DATA_FLOW_CTL & CHIP_SIG_AND_MAP_SPI) | (use_src ? 0x41 : 0x54); - err = pcxhr_send_msg(chip->mgr, &rmh); - if(err) - return err; - rmh.cmd[2] = (CS8420_CLOCK_SRC_CTL & CHIP_SIG_AND_MAP_SPI) | (use_src ? 0x41 : 0x49); - err = pcxhr_send_msg(chip->mgr, &rmh); - return err; -} - -static int pcxhr_audio_src_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - static char *texts[3] = {"Analog", "Digital", "Digi+SRC"}; - - uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; - uinfo->count = 1; - uinfo->value.enumerated.items = 3; - if (uinfo->value.enumerated.item > 2) - uinfo->value.enumerated.item = 2; - strcpy(uinfo->value.enumerated.name, - texts[uinfo->value.enumerated.item]); - return 0; -} - -static int pcxhr_audio_src_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - ucontrol->value.enumerated.item[0] = chip->audio_capture_source; - return 0; -} - -static int pcxhr_audio_src_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int ret = 0; - - down(&chip->mgr->mixer_mutex); - if (chip->audio_capture_source != ucontrol->value.enumerated.item[0]) { - chip->audio_capture_source = ucontrol->value.enumerated.item[0]; - pcxhr_set_audio_source(chip); - ret = 1; - } - up(&chip->mgr->mixer_mutex); - return ret; -} - -static struct snd_kcontrol_new pcxhr_control_audio_src = { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Capture Source", - .info = pcxhr_audio_src_info, - .get = pcxhr_audio_src_get, - .put = pcxhr_audio_src_put, -}; - - -/* - * clock type selection - * enum pcxhr_clock_type { - * PCXHR_CLOCK_TYPE_INTERNAL = 0, - * PCXHR_CLOCK_TYPE_WORD_CLOCK, - * PCXHR_CLOCK_TYPE_AES_SYNC, - * PCXHR_CLOCK_TYPE_AES_1, - * PCXHR_CLOCK_TYPE_AES_2, - * PCXHR_CLOCK_TYPE_AES_3, - * PCXHR_CLOCK_TYPE_AES_4, - * }; - */ - -static int pcxhr_clock_type_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - static char *texts[7] = { - "Internal", "WordClock", "AES Sync", "AES 1", "AES 2", "AES 3", "AES 4" - }; - struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); - int clock_items = 3 + mgr->capture_chips; - - uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; - uinfo->count = 1; - uinfo->value.enumerated.items = clock_items; - if (uinfo->value.enumerated.item >= clock_items) - uinfo->value.enumerated.item = clock_items-1; - strcpy(uinfo->value.enumerated.name, - texts[uinfo->value.enumerated.item]); - return 0; -} - -static int pcxhr_clock_type_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); - ucontrol->value.enumerated.item[0] = mgr->use_clock_type; - return 0; -} - -static int pcxhr_clock_type_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); - int rate, ret = 0; - - down(&mgr->mixer_mutex); - if (mgr->use_clock_type != ucontrol->value.enumerated.item[0]) { - down(&mgr->setup_mutex); - mgr->use_clock_type = ucontrol->value.enumerated.item[0]; - if (mgr->use_clock_type) - pcxhr_get_external_clock(mgr, mgr->use_clock_type, &rate); - else - rate = mgr->sample_rate; - if (rate) { - pcxhr_set_clock(mgr, rate); - if (mgr->sample_rate) - mgr->sample_rate = rate; - } - up(&mgr->setup_mutex); - ret = 1; /* return 1 even if the set was not done. ok ? */ - } - up(&mgr->mixer_mutex); - return ret; -} - -static struct snd_kcontrol_new pcxhr_control_clock_type = { - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, - .name = "Clock Mode", - .info = pcxhr_clock_type_info, - .get = pcxhr_clock_type_get, - .put = pcxhr_clock_type_put, -}; - -/* - * clock rate control - * specific control that scans the sample rates on the external plugs - */ -static int pcxhr_clock_rate_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) -{ - struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); - uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; - uinfo->count = 3 + mgr->capture_chips; - uinfo->value.integer.min = 0; /* clock not present */ - uinfo->value.integer.max = 192000; /* max sample rate 192 kHz */ - return 0; -} - -static int pcxhr_clock_rate_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol); - int i, err, rate; - - down(&mgr->mixer_mutex); - for(i = 0; i < 3 + mgr->capture_chips; i++) { - if (i == PCXHR_CLOCK_TYPE_INTERNAL) - rate = mgr->sample_rate_real; - else { - err = pcxhr_get_external_clock(mgr, i, &rate); - if (err) - break; - } - ucontrol->value.integer.value[i] = rate; - } - up(&mgr->mixer_mutex); - return 0; -} - -static struct snd_kcontrol_new pcxhr_control_clock_rate = { - .access = SNDRV_CTL_ELEM_ACCESS_READ, - .iface = SNDRV_CTL_ELEM_IFACE_CARD, - .name = "Clock Rates", - .info = pcxhr_clock_rate_info, - .get = pcxhr_clock_rate_get, -}; - -/* - * IEC958 status bits - */ -static int pcxhr_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) -{ - uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; - uinfo->count = 1; - return 0; -} - -static int pcxhr_iec958_capture_byte(struct snd_pcxhr *chip, int aes_idx, unsigned char* aes_bits) -{ - int i, err; - unsigned char temp; - struct pcxhr_rmh rmh; - - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ); - rmh.cmd[0] |= IO_NUM_UER_CHIP_REG; - switch (chip->chip_idx) { - case 0: rmh.cmd[1] = CS8420_01_CS; break; /* use CS8416_01_CS for AES SYNC plug */ - case 1: rmh.cmd[1] = CS8420_23_CS; break; - case 2: rmh.cmd[1] = CS8420_45_CS; break; - case 3: rmh.cmd[1] = CS8420_67_CS; break; - default: return -EINVAL; - } - switch (aes_idx) { - case 0: rmh.cmd[2] = CS8420_CSB0; break; /* use CS8416_CSBx for AES SYNC plug */ - case 1: rmh.cmd[2] = CS8420_CSB1; break; - case 2: rmh.cmd[2] = CS8420_CSB2; break; - case 3: rmh.cmd[2] = CS8420_CSB3; break; - case 4: rmh.cmd[2] = CS8420_CSB4; break; - default: return -EINVAL; - } - rmh.cmd[1] &= 0x0fffff; /* size and code the chip id for the fpga */ - rmh.cmd[2] &= CHIP_SIG_AND_MAP_SPI; /* chip signature + map for spi read */ - rmh.cmd_len = 3; - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err) - return err; - temp = 0; - for (i = 0; i < 8; i++) { - /* attention : reversed bit order (not with CS8416_01_CS) */ - temp <<= 1; - if (rmh.stat[1] & (1 << i)) - temp |= 1; - } - snd_printdd("read iec958 AES %d byte %d = 0x%x\n", chip->chip_idx, aes_idx, temp); - *aes_bits = temp; - return 0; -} - -static int pcxhr_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - unsigned char aes_bits; - int i, err; - - down(&chip->mgr->mixer_mutex); - for(i = 0; i < 5; i++) { - if (kcontrol->private_value == 0) /* playback */ - aes_bits = chip->aes_bits[i]; - else { /* capture */ - err = pcxhr_iec958_capture_byte(chip, i, &aes_bits); - if (err) - break; - } - ucontrol->value.iec958.status[i] = aes_bits; - } - up(&chip->mgr->mixer_mutex); - return 0; -} - -static int pcxhr_iec958_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - int i; - for (i = 0; i < 5; i++) - ucontrol->value.iec958.status[i] = 0xff; - return 0; -} - -static int pcxhr_iec958_update_byte(struct snd_pcxhr *chip, int aes_idx, unsigned char aes_bits) -{ - int i, err, cmd; - unsigned char new_bits = aes_bits; - unsigned char old_bits = chip->aes_bits[aes_idx]; - struct pcxhr_rmh rmh; - - for (i = 0; i < 8; i++) { - if ((old_bits & 0x01) != (new_bits & 0x01)) { - cmd = chip->chip_idx & 0x03; /* chip index 0..3 */ - if(chip->chip_idx > 3) - /* new bit used if chip_idx>3 (PCX1222HR) */ - cmd |= 1 << 22; - cmd |= ((aes_idx << 3) + i) << 2; /* add bit offset */ - cmd |= (new_bits & 0x01) << 23; /* add bit value */ - pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE); - rmh.cmd[0] |= IO_NUM_REG_CUER; - rmh.cmd[1] = cmd; - rmh.cmd_len = 2; - snd_printdd("write iec958 AES %d byte %d bit %d (cmd %x)\n", - chip->chip_idx, aes_idx, i, cmd); - err = pcxhr_send_msg(chip->mgr, &rmh); - if (err) - return err; - } - old_bits >>= 1; - new_bits >>= 1; - } - chip->aes_bits[aes_idx] = aes_bits; - return 0; -} - -static int pcxhr_iec958_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol); - int i, changed = 0; - - /* playback */ - down(&chip->mgr->mixer_mutex); - for (i = 0; i < 5; i++) { - if (ucontrol->value.iec958.status[i] != chip->aes_bits[i]) { - pcxhr_iec958_update_byte(chip, i, ucontrol->value.iec958.status[i]); - changed = 1; - } - } - up(&chip->mgr->mixer_mutex); - return changed; -} - -static struct snd_kcontrol_new pcxhr_control_playback_iec958_mask = { - .access = SNDRV_CTL_ELEM_ACCESS_READ, - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), - .info = pcxhr_iec958_info, - .get = pcxhr_iec958_mask_get -}; -static struct snd_kcontrol_new pcxhr_control_playback_iec958 = { - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), - .info = pcxhr_iec958_info, - .get = pcxhr_iec958_get, - .put = pcxhr_iec958_put, - .private_value = 0 /* playback */ -}; - -static struct snd_kcontrol_new pcxhr_control_capture_iec958_mask = { - .access = SNDRV_CTL_ELEM_ACCESS_READ, - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,MASK), - .info = pcxhr_iec958_info, - .get = pcxhr_iec958_mask_get -}; -static struct snd_kcontrol_new pcxhr_control_capture_iec958 = { - .access = SNDRV_CTL_ELEM_ACCESS_READ, - .iface = SNDRV_CTL_ELEM_IFACE_PCM, - .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT), - .info = pcxhr_iec958_info, - .get = pcxhr_iec958_get, - .private_value = 1 /* capture */ -}; - -static void pcxhr_init_audio_levels(struct snd_pcxhr *chip) -{ - int i; - - for (i = 0; i < 2; i++) { - if (chip->nb_streams_play) { - int j; - /* at boot time the digital volumes are unmuted 0dB */ - for (j = 0; j < PCXHR_PLAYBACK_STREAMS; j++) { - chip->digital_playback_active[j][i] = 1; - chip->digital_playback_volume[j][i] = PCXHR_DIGITAL_ZERO_LEVEL; - } - /* after boot, only two bits are set on the uer interface */ - chip->aes_bits[0] = IEC958_AES0_PROFESSIONAL | IEC958_AES0_PRO_FS_48000; -/* only for test purpose, remove later */ -#ifdef CONFIG_SND_DEBUG - /* analog volumes for playback (is LEVEL_MIN after boot) */ - chip->analog_playback_active[i] = 1; - chip->analog_playback_volume[i] = PCXHR_ANALOG_PLAYBACK_ZERO_LEVEL; - pcxhr_update_analog_audio_level(chip, 0, i); -#endif -/* test end */ - } - if (chip->nb_streams_capt) { - /* at boot time the digital volumes are unmuted 0dB */ - chip->digital_capture_volume[i] = PCXHR_DIGITAL_ZERO_LEVEL; -/* only for test purpose, remove later */ -#ifdef CONFIG_SND_DEBUG - /* analog volumes for playback (is LEVEL_MIN after boot) */ - chip->analog_capture_volume[i] = PCXHR_ANALOG_CAPTURE_ZERO_LEVEL; - pcxhr_update_analog_audio_level(chip, 1, i); -#endif -/* test end */ - } - } - - return; -} - - -int pcxhr_create_mixer(struct pcxhr_mgr *mgr) -{ - struct snd_pcxhr *chip; - int err, i; - - init_MUTEX(&mgr->mixer_mutex); /* can be in another place */ - - for (i = 0; i < mgr->num_cards; i++) { - struct snd_kcontrol_new temp; - chip = mgr->chip[i]; - - if (chip->nb_streams_play) { - /* analog output level control */ - temp = pcxhr_control_analog_level; - temp.name = "Master Playback Volume"; - temp.private_value = 0; /* playback */ - if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) - return err; - /* output mute controls */ - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_output_switch, - chip))) < 0) - return err; - - temp = snd_pcxhr_pcm_vol; - temp.name = "PCM Playback Volume"; - temp.count = PCXHR_PLAYBACK_STREAMS; - temp.private_value = 0; /* playback */ - if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) - return err; - - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_pcm_switch, - chip))) < 0) - return err; - - /* IEC958 controls */ - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_playback_iec958_mask, - chip))) < 0) - return err; - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_playback_iec958, - chip))) < 0) - return err; - } - if (chip->nb_streams_capt) { - /* analog input level control only on first two chips !*/ - temp = pcxhr_control_analog_level; - temp.name = "Master Capture Volume"; - temp.private_value = 1; /* capture */ - if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) - return err; - - temp = snd_pcxhr_pcm_vol; - temp.name = "PCM Capture Volume"; - temp.count = 1; - temp.private_value = 1; /* capture */ - if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0) - return err; - /* Audio source */ - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_audio_src, - chip))) < 0) - return err; - /* IEC958 controls */ - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_capture_iec958_mask, - chip))) < 0) - return err; - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_capture_iec958, - chip))) < 0) - return err; - } - /* monitoring only if playback and capture device available */ - if (chip->nb_streams_capt > 0 && chip->nb_streams_play > 0) { - /* monitoring */ - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_monitor_vol, - chip))) < 0) - return err; - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_monitor_sw, - chip))) < 0) - return err; - } - - if (i == 0) { - /* clock mode only one control per pcxhr */ - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_clock_type, - mgr))) < 0) - return err; - /* non standard control used to scan the external clock presence/frequencies */ - if ((err = snd_ctl_add(chip->card, - snd_ctl_new1(&pcxhr_control_clock_rate, - mgr))) < 0) - return err; - } - - /* init values for the mixer data */ - pcxhr_init_audio_levels(chip); - } - - return 0; -} diff --git a/trunk/sound/pci/pcxhr/pcxhr_mixer.h b/trunk/sound/pci/pcxhr/pcxhr_mixer.h deleted file mode 100644 index 4348d0e55ba3..000000000000 --- a/trunk/sound/pci/pcxhr/pcxhr_mixer.h +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Driver for Digigram pcxhr compatible soundcards - * - * include file for mixer - * - * Copyright (c) 2004 by Digigram <alsa@digigram.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef __SOUND_PCXHR_MIXER_H -#define __SOUND_PCXHR_MIXER_H - -/* exported */ -int pcxhr_create_mixer(struct pcxhr_mgr *mgr); - -#endif /* __SOUND_PCXHR_MIXER_H */ diff --git a/trunk/sound/pci/rme32.c b/trunk/sound/pci/rme32.c index 0cbef5fe6c63..783df7625c1c 100644 --- a/trunk/sound/pci/rme32.c +++ b/trunk/sound/pci/rme32.c @@ -192,7 +192,7 @@ MODULE_SUPPORTED_DEVICE("{{RME,Digi32}," "{RME,Digi32/8}," "{RME,Digi32 PRO}}"); #define RME32_PRO_REVISION_WITH_8414 150 -struct rme32 { +typedef struct snd_rme32 { spinlock_t lock; int irq; unsigned long port; @@ -205,8 +205,8 @@ struct rme32 { u8 rev; /* card revision number */ - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; int playback_frlog; /* log2 of framesize */ int capture_frlog; @@ -217,15 +217,15 @@ struct rme32 { unsigned int fullduplex_mode; int running; - struct snd_pcm_indirect playback_pcm; - struct snd_pcm_indirect capture_pcm; + snd_pcm_indirect_t playback_pcm; + snd_pcm_indirect_t capture_pcm; - struct snd_card *card; - struct snd_pcm *spdif_pcm; - struct snd_pcm *adat_pcm; + snd_card_t *card; + snd_pcm_t *spdif_pcm; + snd_pcm_t *adat_pcm; struct pci_dev *pci; - struct snd_kcontrol *spdif_ctl; -}; + snd_kcontrol_t *spdif_ctl; +} rme32_t; static struct pci_device_id snd_rme32_ids[] = { {PCI_VENDOR_ID_XILINX_RME, PCI_DEVICE_ID_RME_DIGI32, @@ -242,17 +242,17 @@ MODULE_DEVICE_TABLE(pci, snd_rme32_ids); #define RME32_ISWORKING(rme32) ((rme32)->wcreg & RME32_WCR_START) #define RME32_PRO_WITH_8414(rme32) ((rme32)->pci->device == PCI_DEVICE_ID_RME_DIGI32_PRO && (rme32)->rev == RME32_PRO_REVISION_WITH_8414) -static int snd_rme32_playback_prepare(struct snd_pcm_substream *substream); +static int snd_rme32_playback_prepare(snd_pcm_substream_t * substream); -static int snd_rme32_capture_prepare(struct snd_pcm_substream *substream); +static int snd_rme32_capture_prepare(snd_pcm_substream_t * substream); -static int snd_rme32_pcm_trigger(struct snd_pcm_substream *substream, int cmd); +static int snd_rme32_pcm_trigger(snd_pcm_substream_t * substream, int cmd); -static void snd_rme32_proc_init(struct rme32 * rme32); +static void snd_rme32_proc_init(rme32_t * rme32); -static int snd_rme32_create_switches(struct snd_card *card, struct rme32 * rme32); +static int snd_rme32_create_switches(snd_card_t * card, rme32_t * rme32); -static inline unsigned int snd_rme32_pcm_byteptr(struct rme32 * rme32) +static inline unsigned int snd_rme32_pcm_byteptr(rme32_t * rme32) { return (readl(rme32->iobase + RME32_IO_GET_POS) & RME32_RCR_AUDIO_ADDR_MASK); @@ -272,11 +272,11 @@ static int snd_rme32_ratecode(int rate) } /* silence callback for halfduplex mode */ -static int snd_rme32_playback_silence(struct snd_pcm_substream *substream, int channel, /* not used (interleaved data) */ +static int snd_rme32_playback_silence(snd_pcm_substream_t * substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); count <<= rme32->playback_frlog; pos <<= rme32->playback_frlog; memset_io(rme32->iobase + RME32_IO_DATA_BUFFER + pos, 0, count); @@ -284,11 +284,11 @@ static int snd_rme32_playback_silence(struct snd_pcm_substream *substream, int c } /* copy callback for halfduplex mode */ -static int snd_rme32_playback_copy(struct snd_pcm_substream *substream, int channel, /* not used (interleaved data) */ +static int snd_rme32_playback_copy(snd_pcm_substream_t * substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); count <<= rme32->playback_frlog; pos <<= rme32->playback_frlog; if (copy_from_user_toio(rme32->iobase + RME32_IO_DATA_BUFFER + pos, @@ -298,11 +298,11 @@ static int snd_rme32_playback_copy(struct snd_pcm_substream *substream, int chan } /* copy callback for halfduplex mode */ -static int snd_rme32_capture_copy(struct snd_pcm_substream *substream, int channel, /* not used (interleaved data) */ +static int snd_rme32_capture_copy(snd_pcm_substream_t * substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); count <<= rme32->capture_frlog; pos <<= rme32->capture_frlog; if (copy_to_user_fromio(dst, @@ -315,7 +315,7 @@ static int snd_rme32_capture_copy(struct snd_pcm_substream *substream, int chann /* * SPDIF I/O capabilites (half-duplex mode) */ -static struct snd_pcm_hardware snd_rme32_spdif_info = { +static snd_pcm_hardware_t snd_rme32_spdif_info = { .info = (SNDRV_PCM_INFO_MMAP_IOMEM | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | @@ -341,7 +341,7 @@ static struct snd_pcm_hardware snd_rme32_spdif_info = { /* * ADAT I/O capabilites (half-duplex mode) */ -static struct snd_pcm_hardware snd_rme32_adat_info = +static snd_pcm_hardware_t snd_rme32_adat_info = { .info = (SNDRV_PCM_INFO_MMAP_IOMEM | SNDRV_PCM_INFO_MMAP_VALID | @@ -366,7 +366,7 @@ static struct snd_pcm_hardware snd_rme32_adat_info = /* * SPDIF I/O capabilites (full-duplex mode) */ -static struct snd_pcm_hardware snd_rme32_spdif_fd_info = { +static snd_pcm_hardware_t snd_rme32_spdif_fd_info = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | @@ -392,7 +392,7 @@ static struct snd_pcm_hardware snd_rme32_spdif_fd_info = { /* * ADAT I/O capabilites (full-duplex mode) */ -static struct snd_pcm_hardware snd_rme32_adat_fd_info = +static snd_pcm_hardware_t snd_rme32_adat_fd_info = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -414,14 +414,14 @@ static struct snd_pcm_hardware snd_rme32_adat_fd_info = .fifo_size = 0, }; -static void snd_rme32_reset_dac(struct rme32 *rme32) +static void snd_rme32_reset_dac(rme32_t *rme32) { writel(rme32->wcreg | RME32_WCR_PD, rme32->iobase + RME32_IO_CONTROL_REGISTER); writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER); } -static int snd_rme32_playback_getrate(struct rme32 * rme32) +static int snd_rme32_playback_getrate(rme32_t * rme32) { int rate; @@ -443,7 +443,7 @@ static int snd_rme32_playback_getrate(struct rme32 * rme32) return (rme32->wcreg & RME32_WCR_DS_BM) ? rate << 1 : rate; } -static int snd_rme32_capture_getrate(struct rme32 * rme32, int *is_adat) +static int snd_rme32_capture_getrate(rme32_t * rme32, int *is_adat) { int n; @@ -505,7 +505,7 @@ static int snd_rme32_capture_getrate(struct rme32 * rme32, int *is_adat) return -1; } -static int snd_rme32_playback_setrate(struct rme32 * rme32, int rate) +static int snd_rme32_playback_setrate(rme32_t * rme32, int rate) { int ds; @@ -561,7 +561,7 @@ static int snd_rme32_playback_setrate(struct rme32 * rme32, int rate) return 0; } -static int snd_rme32_setclockmode(struct rme32 * rme32, int mode) +static int snd_rme32_setclockmode(rme32_t * rme32, int mode) { switch (mode) { case RME32_CLOCKMODE_SLAVE: @@ -591,13 +591,13 @@ static int snd_rme32_setclockmode(struct rme32 * rme32, int mode) return 0; } -static int snd_rme32_getclockmode(struct rme32 * rme32) +static int snd_rme32_getclockmode(rme32_t * rme32) { return ((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_0) & 1) + (((rme32->wcreg >> RME32_WCR_BITPOS_FREQ_1) & 1) << 1); } -static int snd_rme32_setinputtype(struct rme32 * rme32, int type) +static int snd_rme32_setinputtype(rme32_t * rme32, int type) { switch (type) { case RME32_INPUT_OPTICAL: @@ -623,14 +623,14 @@ static int snd_rme32_setinputtype(struct rme32 * rme32, int type) return 0; } -static int snd_rme32_getinputtype(struct rme32 * rme32) +static int snd_rme32_getinputtype(rme32_t * rme32) { return ((rme32->wcreg >> RME32_WCR_BITPOS_INP_0) & 1) + (((rme32->wcreg >> RME32_WCR_BITPOS_INP_1) & 1) << 1); } static void -snd_rme32_setframelog(struct rme32 * rme32, int n_channels, int is_playback) +snd_rme32_setframelog(rme32_t * rme32, int n_channels, int is_playback) { int frlog; @@ -649,7 +649,7 @@ snd_rme32_setframelog(struct rme32 * rme32, int n_channels, int is_playback) } } -static int snd_rme32_setformat(struct rme32 * rme32, int format) +static int snd_rme32_setformat(rme32_t * rme32, int format) { switch (format) { case SNDRV_PCM_FORMAT_S16_LE: @@ -666,12 +666,12 @@ static int snd_rme32_setformat(struct rme32 * rme32, int format) } static int -snd_rme32_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +snd_rme32_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * params) { int err, rate, dummy; - struct rme32 *rme32 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme32_t *rme32 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (rme32->fullduplex_mode) { err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params)); @@ -721,12 +721,12 @@ snd_rme32_playback_hw_params(struct snd_pcm_substream *substream, } static int -snd_rme32_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +snd_rme32_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * params) { int err, isadat, rate; - struct rme32 *rme32 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme32_t *rme32 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (rme32->fullduplex_mode) { err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params)); @@ -782,15 +782,15 @@ snd_rme32_capture_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_rme32_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_rme32_pcm_hw_free(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); if (! rme32->fullduplex_mode) return 0; return snd_pcm_lib_free_pages(substream); } -static void snd_rme32_pcm_start(struct rme32 * rme32, int from_pause) +static void snd_rme32_pcm_start(rme32_t * rme32, int from_pause) { if (!from_pause) { writel(0, rme32->iobase + RME32_IO_RESET_POS); @@ -800,7 +800,7 @@ static void snd_rme32_pcm_start(struct rme32 * rme32, int from_pause) writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER); } -static void snd_rme32_pcm_stop(struct rme32 * rme32, int to_pause) +static void snd_rme32_pcm_stop(rme32_t * rme32, int to_pause) { /* * Check if there is an unconfirmed IRQ, if so confirm it, or else @@ -821,7 +821,7 @@ static void snd_rme32_pcm_stop(struct rme32 * rme32, int to_pause) static irqreturn_t snd_rme32_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct rme32 *rme32 = (struct rme32 *) dev_id; + rme32_t *rme32 = (rme32_t *) dev_id; rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER); if (!(rme32->rcreg & RME32_RCR_IRQ)) { @@ -841,13 +841,13 @@ snd_rme32_interrupt(int irq, void *dev_id, struct pt_regs *regs) static unsigned int period_bytes[] = { RME32_BLOCK_SIZE }; -static struct snd_pcm_hw_constraint_list hw_constraints_period_bytes = { +static snd_pcm_hw_constraint_list_t hw_constraints_period_bytes = { .count = ARRAY_SIZE(period_bytes), .list = period_bytes, .mask = 0 }; -static void snd_rme32_set_buffer_constraint(struct rme32 *rme32, struct snd_pcm_runtime *runtime) +static void snd_rme32_set_buffer_constraint(rme32_t *rme32, snd_pcm_runtime_t *runtime) { if (! rme32->fullduplex_mode) { snd_pcm_hw_constraint_minmax(runtime, @@ -859,11 +859,11 @@ static void snd_rme32_set_buffer_constraint(struct rme32 *rme32, struct snd_pcm_ } } -static int snd_rme32_playback_spdif_open(struct snd_pcm_substream *substream) +static int snd_rme32_playback_spdif_open(snd_pcm_substream_t * substream) { int rate, dummy; - struct rme32 *rme32 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme32_t *rme32 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_set_sync(substream); @@ -902,11 +902,11 @@ static int snd_rme32_playback_spdif_open(struct snd_pcm_substream *substream) return 0; } -static int snd_rme32_capture_spdif_open(struct snd_pcm_substream *substream) +static int snd_rme32_capture_spdif_open(snd_pcm_substream_t * substream) { int isadat, rate; - struct rme32 *rme32 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme32_t *rme32 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_set_sync(substream); @@ -941,11 +941,11 @@ static int snd_rme32_capture_spdif_open(struct snd_pcm_substream *substream) } static int -snd_rme32_playback_adat_open(struct snd_pcm_substream *substream) +snd_rme32_playback_adat_open(snd_pcm_substream_t *substream) { int rate, dummy; - struct rme32 *rme32 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme32_t *rme32 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_set_sync(substream); @@ -976,11 +976,11 @@ snd_rme32_playback_adat_open(struct snd_pcm_substream *substream) } static int -snd_rme32_capture_adat_open(struct snd_pcm_substream *substream) +snd_rme32_capture_adat_open(snd_pcm_substream_t *substream) { int isadat, rate; - struct rme32 *rme32 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme32_t *rme32 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (rme32->fullduplex_mode) runtime->hw = snd_rme32_adat_fd_info; @@ -1009,9 +1009,9 @@ snd_rme32_capture_adat_open(struct snd_pcm_substream *substream) return 0; } -static int snd_rme32_playback_close(struct snd_pcm_substream *substream) +static int snd_rme32_playback_close(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); int spdif = 0; spin_lock_irq(&rme32->lock); @@ -1028,9 +1028,9 @@ static int snd_rme32_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_rme32_capture_close(struct snd_pcm_substream *substream) +static int snd_rme32_capture_close(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme32->lock); rme32->capture_substream = NULL; @@ -1039,9 +1039,9 @@ static int snd_rme32_capture_close(struct snd_pcm_substream *substream) return 0; } -static int snd_rme32_playback_prepare(struct snd_pcm_substream *substream) +static int snd_rme32_playback_prepare(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme32->lock); if (rme32->fullduplex_mode) { @@ -1058,9 +1058,9 @@ static int snd_rme32_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_rme32_capture_prepare(struct snd_pcm_substream *substream) +static int snd_rme32_capture_prepare(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme32->lock); if (rme32->fullduplex_mode) { @@ -1076,11 +1076,11 @@ static int snd_rme32_capture_prepare(struct snd_pcm_substream *substream) } static int -snd_rme32_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +snd_rme32_pcm_trigger(snd_pcm_substream_t * substream, int cmd) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; spin_lock(&rme32->lock); snd_pcm_group_for_each(pos, substream) { @@ -1144,33 +1144,33 @@ snd_rme32_pcm_trigger(struct snd_pcm_substream *substream, int cmd) /* pointer callback for halfduplex mode */ static snd_pcm_uframes_t -snd_rme32_playback_pointer(struct snd_pcm_substream *substream) +snd_rme32_playback_pointer(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); return snd_rme32_pcm_byteptr(rme32) >> rme32->playback_frlog; } static snd_pcm_uframes_t -snd_rme32_capture_pointer(struct snd_pcm_substream *substream) +snd_rme32_capture_pointer(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); return snd_rme32_pcm_byteptr(rme32) >> rme32->capture_frlog; } /* ack and pointer callbacks for fullduplex mode */ -static void snd_rme32_pb_trans_copy(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, size_t bytes) +static void snd_rme32_pb_trans_copy(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, size_t bytes) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); memcpy_toio(rme32->iobase + RME32_IO_DATA_BUFFER + rec->hw_data, substream->runtime->dma_area + rec->sw_data, bytes); } -static int snd_rme32_playback_fd_ack(struct snd_pcm_substream *substream) +static int snd_rme32_playback_fd_ack(snd_pcm_substream_t *substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); - struct snd_pcm_indirect *rec, *cprec; + rme32_t *rme32 = snd_pcm_substream_chip(substream); + snd_pcm_indirect_t *rec, *cprec; rec = &rme32->playback_pcm; cprec = &rme32->capture_pcm; @@ -1184,41 +1184,41 @@ static int snd_rme32_playback_fd_ack(struct snd_pcm_substream *substream) return 0; } -static void snd_rme32_cp_trans_copy(struct snd_pcm_substream *substream, - struct snd_pcm_indirect *rec, size_t bytes) +static void snd_rme32_cp_trans_copy(snd_pcm_substream_t *substream, + snd_pcm_indirect_t *rec, size_t bytes) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); memcpy_fromio(substream->runtime->dma_area + rec->sw_data, rme32->iobase + RME32_IO_DATA_BUFFER + rec->hw_data, bytes); } -static int snd_rme32_capture_fd_ack(struct snd_pcm_substream *substream) +static int snd_rme32_capture_fd_ack(snd_pcm_substream_t *substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); snd_pcm_indirect_capture_transfer(substream, &rme32->capture_pcm, snd_rme32_cp_trans_copy); return 0; } static snd_pcm_uframes_t -snd_rme32_playback_fd_pointer(struct snd_pcm_substream *substream) +snd_rme32_playback_fd_pointer(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); return snd_pcm_indirect_playback_pointer(substream, &rme32->playback_pcm, snd_rme32_pcm_byteptr(rme32)); } static snd_pcm_uframes_t -snd_rme32_capture_fd_pointer(struct snd_pcm_substream *substream) +snd_rme32_capture_fd_pointer(snd_pcm_substream_t * substream) { - struct rme32 *rme32 = snd_pcm_substream_chip(substream); + rme32_t *rme32 = snd_pcm_substream_chip(substream); return snd_pcm_indirect_capture_pointer(substream, &rme32->capture_pcm, snd_rme32_pcm_byteptr(rme32)); } /* for halfduplex mode */ -static struct snd_pcm_ops snd_rme32_playback_spdif_ops = { +static snd_pcm_ops_t snd_rme32_playback_spdif_ops = { .open = snd_rme32_playback_spdif_open, .close = snd_rme32_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1232,7 +1232,7 @@ static struct snd_pcm_ops snd_rme32_playback_spdif_ops = { .mmap = snd_pcm_lib_mmap_iomem, }; -static struct snd_pcm_ops snd_rme32_capture_spdif_ops = { +static snd_pcm_ops_t snd_rme32_capture_spdif_ops = { .open = snd_rme32_capture_spdif_open, .close = snd_rme32_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1245,7 +1245,7 @@ static struct snd_pcm_ops snd_rme32_capture_spdif_ops = { .mmap = snd_pcm_lib_mmap_iomem, }; -static struct snd_pcm_ops snd_rme32_playback_adat_ops = { +static snd_pcm_ops_t snd_rme32_playback_adat_ops = { .open = snd_rme32_playback_adat_open, .close = snd_rme32_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1258,7 +1258,7 @@ static struct snd_pcm_ops snd_rme32_playback_adat_ops = { .mmap = snd_pcm_lib_mmap_iomem, }; -static struct snd_pcm_ops snd_rme32_capture_adat_ops = { +static snd_pcm_ops_t snd_rme32_capture_adat_ops = { .open = snd_rme32_capture_adat_open, .close = snd_rme32_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1271,7 +1271,7 @@ static struct snd_pcm_ops snd_rme32_capture_adat_ops = { }; /* for fullduplex mode */ -static struct snd_pcm_ops snd_rme32_playback_spdif_fd_ops = { +static snd_pcm_ops_t snd_rme32_playback_spdif_fd_ops = { .open = snd_rme32_playback_spdif_open, .close = snd_rme32_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1283,7 +1283,7 @@ static struct snd_pcm_ops snd_rme32_playback_spdif_fd_ops = { .ack = snd_rme32_playback_fd_ack, }; -static struct snd_pcm_ops snd_rme32_capture_spdif_fd_ops = { +static snd_pcm_ops_t snd_rme32_capture_spdif_fd_ops = { .open = snd_rme32_capture_spdif_open, .close = snd_rme32_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1295,7 +1295,7 @@ static struct snd_pcm_ops snd_rme32_capture_spdif_fd_ops = { .ack = snd_rme32_capture_fd_ack, }; -static struct snd_pcm_ops snd_rme32_playback_adat_fd_ops = { +static snd_pcm_ops_t snd_rme32_playback_adat_fd_ops = { .open = snd_rme32_playback_adat_open, .close = snd_rme32_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1306,7 +1306,7 @@ static struct snd_pcm_ops snd_rme32_playback_adat_fd_ops = { .ack = snd_rme32_playback_fd_ack, }; -static struct snd_pcm_ops snd_rme32_capture_adat_fd_ops = { +static snd_pcm_ops_t snd_rme32_capture_adat_fd_ops = { .open = snd_rme32_capture_adat_open, .close = snd_rme32_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1319,7 +1319,7 @@ static struct snd_pcm_ops snd_rme32_capture_adat_fd_ops = { static void snd_rme32_free(void *private_data) { - struct rme32 *rme32 = (struct rme32 *) private_data; + rme32_t *rme32 = (rme32_t *) private_data; if (rme32 == NULL) { return; @@ -1340,20 +1340,20 @@ static void snd_rme32_free(void *private_data) pci_disable_device(rme32->pci); } -static void snd_rme32_free_spdif_pcm(struct snd_pcm *pcm) +static void snd_rme32_free_spdif_pcm(snd_pcm_t * pcm) { - struct rme32 *rme32 = (struct rme32 *) pcm->private_data; + rme32_t *rme32 = (rme32_t *) pcm->private_data; rme32->spdif_pcm = NULL; } static void -snd_rme32_free_adat_pcm(struct snd_pcm *pcm) +snd_rme32_free_adat_pcm(snd_pcm_t *pcm) { - struct rme32 *rme32 = (struct rme32 *) pcm->private_data; + rme32_t *rme32 = (rme32_t *) pcm->private_data; rme32->adat_pcm = NULL; } -static int __devinit snd_rme32_create(struct rme32 * rme32) +static int __devinit snd_rme32_create(rme32_t * rme32) { struct pci_dev *pci = rme32->pci; int err; @@ -1479,10 +1479,10 @@ static int __devinit snd_rme32_create(struct rme32 * rme32) */ static void -snd_rme32_proc_read(struct snd_info_entry * entry, struct snd_info_buffer *buffer) +snd_rme32_proc_read(snd_info_entry_t * entry, snd_info_buffer_t * buffer) { int n; - struct rme32 *rme32 = (struct rme32 *) entry->private_data; + rme32_t *rme32 = (rme32_t *) entry->private_data; rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER); @@ -1573,9 +1573,9 @@ snd_rme32_proc_read(struct snd_info_entry * entry, struct snd_info_buffer *buffe } } -static void __devinit snd_rme32_proc_init(struct rme32 * rme32) +static void __devinit snd_rme32_proc_init(rme32_t * rme32) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(rme32->card, "rme32", &entry)) snd_info_set_text_ops(entry, rme32, 1024, snd_rme32_proc_read); @@ -1586,8 +1586,8 @@ static void __devinit snd_rme32_proc_init(struct rme32 * rme32) */ static int -snd_rme32_info_loopback_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +snd_rme32_info_loopback_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1596,10 +1596,10 @@ snd_rme32_info_loopback_control(struct snd_kcontrol *kcontrol, return 0; } static int -snd_rme32_get_loopback_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_rme32_get_loopback_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme32->lock); ucontrol->value.integer.value[0] = @@ -1608,10 +1608,10 @@ snd_rme32_get_loopback_control(struct snd_kcontrol *kcontrol, return 0; } static int -snd_rme32_put_loopback_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_rme32_put_loopback_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -1630,10 +1630,10 @@ snd_rme32_put_loopback_control(struct snd_kcontrol *kcontrol, } static int -snd_rme32_info_inputtype_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +snd_rme32_info_inputtype_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); static char *texts[4] = { "Optical", "Coaxial", "Internal", "XLR" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -1660,10 +1660,10 @@ snd_rme32_info_inputtype_control(struct snd_kcontrol *kcontrol, return 0; } static int -snd_rme32_get_inputtype_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_rme32_get_inputtype_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); unsigned int items = 3; spin_lock_irq(&rme32->lock); @@ -1689,10 +1689,10 @@ snd_rme32_get_inputtype_control(struct snd_kcontrol *kcontrol, return 0; } static int -snd_rme32_put_inputtype_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_rme32_put_inputtype_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); unsigned int val; int change, items = 3; @@ -1718,8 +1718,8 @@ snd_rme32_put_inputtype_control(struct snd_kcontrol *kcontrol, } static int -snd_rme32_info_clockmode_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +snd_rme32_info_clockmode_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[4] = { "AutoSync", "Internal 32.0kHz", @@ -1737,10 +1737,10 @@ snd_rme32_info_clockmode_control(struct snd_kcontrol *kcontrol, return 0; } static int -snd_rme32_get_clockmode_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_rme32_get_clockmode_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme32->lock); ucontrol->value.enumerated.item[0] = snd_rme32_getclockmode(rme32); @@ -1748,10 +1748,10 @@ snd_rme32_get_clockmode_control(struct snd_kcontrol *kcontrol, return 0; } static int -snd_rme32_put_clockmode_control(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +snd_rme32_put_clockmode_control(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -1763,7 +1763,7 @@ snd_rme32_put_clockmode_control(struct snd_kcontrol *kcontrol, return change; } -static u32 snd_rme32_convert_from_aes(struct snd_aes_iec958 * aes) +static u32 snd_rme32_convert_from_aes(snd_aes_iec958_t * aes) { u32 val = 0; val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? RME32_WCR_PRO : 0; @@ -1774,7 +1774,7 @@ static u32 snd_rme32_convert_from_aes(struct snd_aes_iec958 * aes) return val; } -static void snd_rme32_convert_to_aes(struct snd_aes_iec958 * aes, u32 val) +static void snd_rme32_convert_to_aes(snd_aes_iec958_t * aes, u32 val) { aes->status[0] = ((val & RME32_WCR_PRO) ? IEC958_AES0_PROFESSIONAL : 0); if (val & RME32_WCR_PRO) @@ -1783,28 +1783,28 @@ static void snd_rme32_convert_to_aes(struct snd_aes_iec958 * aes, u32 val) aes->status[0] |= (val & RME32_WCR_EMP) ? IEC958_AES0_CON_EMPHASIS_5015 : 0; } -static int snd_rme32_control_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_rme32_control_spdif_info(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme32_control_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_rme32_control_spdif_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); snd_rme32_convert_to_aes(&ucontrol->value.iec958, rme32->wcreg_spdif); return 0; } -static int snd_rme32_control_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_rme32_control_spdif_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -1816,30 +1816,30 @@ static int snd_rme32_control_spdif_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_rme32_control_spdif_stream_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_rme32_control_spdif_stream_info(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme32_control_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value * +static int snd_rme32_control_spdif_stream_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); snd_rme32_convert_to_aes(&ucontrol->value.iec958, rme32->wcreg_spdif_stream); return 0; } -static int snd_rme32_control_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value * +static int snd_rme32_control_spdif_stream_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct rme32 *rme32 = snd_kcontrol_chip(kcontrol); + rme32_t *rme32 = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -1854,23 +1854,23 @@ static int snd_rme32_control_spdif_stream_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_rme32_control_spdif_mask_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_rme32_control_spdif_mask_info(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme32_control_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value * +static int snd_rme32_control_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = kcontrol->private_value; return 0; } -static struct snd_kcontrol_new snd_rme32_controls[] = { +static snd_kcontrol_new_t snd_rme32_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), @@ -1925,10 +1925,10 @@ static struct snd_kcontrol_new snd_rme32_controls[] = { } }; -static int snd_rme32_create_switches(struct snd_card *card, struct rme32 * rme32) +static int snd_rme32_create_switches(snd_card_t * card, rme32_t * rme32) { int idx, err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; for (idx = 0; idx < (int)ARRAY_SIZE(snd_rme32_controls); idx++) { if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme32_controls[idx], rme32))) < 0) @@ -1944,7 +1944,7 @@ static int snd_rme32_create_switches(struct snd_card *card, struct rme32 * rme32 * Card initialisation */ -static void snd_rme32_card_free(struct snd_card *card) +static void snd_rme32_card_free(snd_card_t * card) { snd_rme32_free(card->private_data); } @@ -1953,8 +1953,8 @@ static int __devinit snd_rme32_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct rme32 *rme32; - struct snd_card *card; + rme32_t *rme32; + snd_card_t *card; int err; if (dev >= SNDRV_CARDS) { @@ -1966,10 +1966,10 @@ snd_rme32_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) } if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof(struct rme32))) == NULL) + sizeof(rme32_t))) == NULL) return -ENOMEM; card->private_free = snd_rme32_card_free; - rme32 = (struct rme32 *) card->private_data; + rme32 = (rme32_t *) card->private_data; rme32->card = card; rme32->pci = pci; snd_card_set_dev(card, &pci->dev); diff --git a/trunk/sound/pci/rme96.c b/trunk/sound/pci/rme96.c index 0e694b011dcc..6d422ef64999 100644 --- a/trunk/sound/pci/rme96.c +++ b/trunk/sound/pci/rme96.c @@ -201,7 +201,7 @@ MODULE_PARM_DESC(enable, "Enable RME Digi96 soundcard."); #define RME96_AD1855_VOL_BITS 10 -struct rme96 { +typedef struct snd_rme96 { spinlock_t lock; int irq; unsigned long port; @@ -216,8 +216,8 @@ struct rme96 { u8 rev; /* card revision number */ - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; int playback_frlog; /* log2 of framesize */ int capture_frlog; @@ -225,12 +225,12 @@ struct rme96 { size_t playback_periodsize; /* in bytes, zero if not used */ size_t capture_periodsize; /* in bytes, zero if not used */ - struct snd_card *card; - struct snd_pcm *spdif_pcm; - struct snd_pcm *adat_pcm; + snd_card_t *card; + snd_pcm_t *spdif_pcm; + snd_pcm_t *adat_pcm; struct pci_dev *pci; - struct snd_kcontrol *spdif_ctl; -}; + snd_kcontrol_t *spdif_ctl; +} rme96_t; static struct pci_device_id snd_rme96_ids[] = { { PCI_VENDOR_ID_XILINX, PCI_DEVICE_ID_RME_DIGI96, @@ -257,44 +257,44 @@ MODULE_DEVICE_TABLE(pci, snd_rme96_ids); #define RME96_185X_MAX_OUT(rme96) ((1 << (RME96_DAC_IS_1852(rme96) ? RME96_AD1852_VOL_BITS : RME96_AD1855_VOL_BITS)) - 1) static int -snd_rme96_playback_prepare(struct snd_pcm_substream *substream); +snd_rme96_playback_prepare(snd_pcm_substream_t *substream); static int -snd_rme96_capture_prepare(struct snd_pcm_substream *substream); +snd_rme96_capture_prepare(snd_pcm_substream_t *substream); static int -snd_rme96_playback_trigger(struct snd_pcm_substream *substream, +snd_rme96_playback_trigger(snd_pcm_substream_t *substream, int cmd); static int -snd_rme96_capture_trigger(struct snd_pcm_substream *substream, +snd_rme96_capture_trigger(snd_pcm_substream_t *substream, int cmd); static snd_pcm_uframes_t -snd_rme96_playback_pointer(struct snd_pcm_substream *substream); +snd_rme96_playback_pointer(snd_pcm_substream_t *substream); static snd_pcm_uframes_t -snd_rme96_capture_pointer(struct snd_pcm_substream *substream); +snd_rme96_capture_pointer(snd_pcm_substream_t *substream); static void __devinit -snd_rme96_proc_init(struct rme96 *rme96); +snd_rme96_proc_init(rme96_t *rme96); static int -snd_rme96_create_switches(struct snd_card *card, - struct rme96 *rme96); +snd_rme96_create_switches(snd_card_t *card, + rme96_t *rme96); static int -snd_rme96_getinputtype(struct rme96 *rme96); +snd_rme96_getinputtype(rme96_t *rme96); static inline unsigned int -snd_rme96_playback_ptr(struct rme96 *rme96) +snd_rme96_playback_ptr(rme96_t *rme96) { return (readl(rme96->iobase + RME96_IO_GET_PLAY_POS) & RME96_RCR_AUDIO_ADDR_MASK) >> rme96->playback_frlog; } static inline unsigned int -snd_rme96_capture_ptr(struct rme96 *rme96) +snd_rme96_capture_ptr(rme96_t *rme96) { return (readl(rme96->iobase + RME96_IO_GET_REC_POS) & RME96_RCR_AUDIO_ADDR_MASK) >> rme96->capture_frlog; @@ -315,12 +315,12 @@ snd_rme96_ratecode(int rate) } static int -snd_rme96_playback_silence(struct snd_pcm_substream *substream, +snd_rme96_playback_silence(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); count <<= rme96->playback_frlog; pos <<= rme96->playback_frlog; memset_io(rme96->iobase + RME96_IO_PLAY_BUFFER + pos, @@ -329,13 +329,13 @@ snd_rme96_playback_silence(struct snd_pcm_substream *substream, } static int -snd_rme96_playback_copy(struct snd_pcm_substream *substream, +snd_rme96_playback_copy(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); count <<= rme96->playback_frlog; pos <<= rme96->playback_frlog; copy_from_user_toio(rme96->iobase + RME96_IO_PLAY_BUFFER + pos, src, @@ -344,13 +344,13 @@ snd_rme96_playback_copy(struct snd_pcm_substream *substream, } static int -snd_rme96_capture_copy(struct snd_pcm_substream *substream, +snd_rme96_capture_copy(snd_pcm_substream_t *substream, int channel, /* not used (interleaved data) */ snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); count <<= rme96->capture_frlog; pos <<= rme96->capture_frlog; copy_to_user_fromio(dst, rme96->iobase + RME96_IO_REC_BUFFER + pos, @@ -361,7 +361,7 @@ snd_rme96_capture_copy(struct snd_pcm_substream *substream, /* * Digital output capabilites (S/PDIF) */ -static struct snd_pcm_hardware snd_rme96_playback_spdif_info = +static snd_pcm_hardware_t snd_rme96_playback_spdif_info = { .info = (SNDRV_PCM_INFO_MMAP_IOMEM | SNDRV_PCM_INFO_MMAP_VALID | @@ -390,7 +390,7 @@ static struct snd_pcm_hardware snd_rme96_playback_spdif_info = /* * Digital input capabilites (S/PDIF) */ -static struct snd_pcm_hardware snd_rme96_capture_spdif_info = +static snd_pcm_hardware_t snd_rme96_capture_spdif_info = { .info = (SNDRV_PCM_INFO_MMAP_IOMEM | SNDRV_PCM_INFO_MMAP_VALID | @@ -419,7 +419,7 @@ static struct snd_pcm_hardware snd_rme96_capture_spdif_info = /* * Digital output capabilites (ADAT) */ -static struct snd_pcm_hardware snd_rme96_playback_adat_info = +static snd_pcm_hardware_t snd_rme96_playback_adat_info = { .info = (SNDRV_PCM_INFO_MMAP_IOMEM | SNDRV_PCM_INFO_MMAP_VALID | @@ -444,7 +444,7 @@ static struct snd_pcm_hardware snd_rme96_playback_adat_info = /* * Digital input capabilites (ADAT) */ -static struct snd_pcm_hardware snd_rme96_capture_adat_info = +static snd_pcm_hardware_t snd_rme96_capture_adat_info = { .info = (SNDRV_PCM_INFO_MMAP_IOMEM | SNDRV_PCM_INFO_MMAP_VALID | @@ -479,7 +479,7 @@ static struct snd_pcm_hardware snd_rme96_capture_adat_info = * the volume. */ static void -snd_rme96_write_SPI(struct rme96 *rme96, u16 val) +snd_rme96_write_SPI(rme96_t *rme96, u16 val) { int i; @@ -506,7 +506,7 @@ snd_rme96_write_SPI(struct rme96 *rme96, u16 val) } static void -snd_rme96_apply_dac_volume(struct rme96 *rme96) +snd_rme96_apply_dac_volume(rme96_t *rme96) { if (RME96_DAC_IS_1852(rme96)) { snd_rme96_write_SPI(rme96, (rme96->vol[0] << 2) | 0x0); @@ -518,7 +518,7 @@ snd_rme96_apply_dac_volume(struct rme96 *rme96) } static void -snd_rme96_reset_dac(struct rme96 *rme96) +snd_rme96_reset_dac(rme96_t *rme96) { writel(rme96->wcreg | RME96_WCR_PD, rme96->iobase + RME96_IO_CONTROL_REGISTER); @@ -526,14 +526,14 @@ snd_rme96_reset_dac(struct rme96 *rme96) } static int -snd_rme96_getmontracks(struct rme96 *rme96) +snd_rme96_getmontracks(rme96_t *rme96) { return ((rme96->wcreg >> RME96_WCR_BITPOS_MONITOR_0) & 1) + (((rme96->wcreg >> RME96_WCR_BITPOS_MONITOR_1) & 1) << 1); } static int -snd_rme96_setmontracks(struct rme96 *rme96, +snd_rme96_setmontracks(rme96_t *rme96, int montracks) { if (montracks & 1) { @@ -551,14 +551,14 @@ snd_rme96_setmontracks(struct rme96 *rme96, } static int -snd_rme96_getattenuation(struct rme96 *rme96) +snd_rme96_getattenuation(rme96_t *rme96) { return ((rme96->wcreg >> RME96_WCR_BITPOS_GAIN_0) & 1) + (((rme96->wcreg >> RME96_WCR_BITPOS_GAIN_1) & 1) << 1); } static int -snd_rme96_setattenuation(struct rme96 *rme96, +snd_rme96_setattenuation(rme96_t *rme96, int attenuation) { switch (attenuation) { @@ -586,7 +586,7 @@ snd_rme96_setattenuation(struct rme96 *rme96, } static int -snd_rme96_capture_getrate(struct rme96 *rme96, +snd_rme96_capture_getrate(rme96_t *rme96, int *is_adat) { int n, rate; @@ -649,7 +649,7 @@ snd_rme96_capture_getrate(struct rme96 *rme96, } static int -snd_rme96_playback_getrate(struct rme96 *rme96) +snd_rme96_playback_getrate(rme96_t *rme96) { int rate, dummy; @@ -679,7 +679,7 @@ snd_rme96_playback_getrate(struct rme96 *rme96) } static int -snd_rme96_playback_setrate(struct rme96 *rme96, +snd_rme96_playback_setrate(rme96_t *rme96, int rate) { int ds; @@ -731,7 +731,7 @@ snd_rme96_playback_setrate(struct rme96 *rme96, } static int -snd_rme96_capture_analog_setrate(struct rme96 *rme96, +snd_rme96_capture_analog_setrate(rme96_t *rme96, int rate) { switch (rate) { @@ -773,7 +773,7 @@ snd_rme96_capture_analog_setrate(struct rme96 *rme96, } static int -snd_rme96_setclockmode(struct rme96 *rme96, +snd_rme96_setclockmode(rme96_t *rme96, int mode) { switch (mode) { @@ -801,7 +801,7 @@ snd_rme96_setclockmode(struct rme96 *rme96, } static int -snd_rme96_getclockmode(struct rme96 *rme96) +snd_rme96_getclockmode(rme96_t *rme96) { if (rme96->areg & RME96_AR_WSEL) { return RME96_CLOCKMODE_WORDCLOCK; @@ -811,7 +811,7 @@ snd_rme96_getclockmode(struct rme96 *rme96) } static int -snd_rme96_setinputtype(struct rme96 *rme96, +snd_rme96_setinputtype(rme96_t *rme96, int type) { int n; @@ -872,7 +872,7 @@ snd_rme96_setinputtype(struct rme96 *rme96, } static int -snd_rme96_getinputtype(struct rme96 *rme96) +snd_rme96_getinputtype(rme96_t *rme96) { if (rme96->areg & RME96_AR_ANALOG) { return RME96_INPUT_ANALOG; @@ -882,7 +882,7 @@ snd_rme96_getinputtype(struct rme96 *rme96) } static void -snd_rme96_setframelog(struct rme96 *rme96, +snd_rme96_setframelog(rme96_t *rme96, int n_channels, int is_playback) { @@ -904,7 +904,7 @@ snd_rme96_setframelog(struct rme96 *rme96, } static int -snd_rme96_playback_setformat(struct rme96 *rme96, +snd_rme96_playback_setformat(rme96_t *rme96, int format) { switch (format) { @@ -922,7 +922,7 @@ snd_rme96_playback_setformat(struct rme96 *rme96, } static int -snd_rme96_capture_setformat(struct rme96 *rme96, +snd_rme96_capture_setformat(rme96_t *rme96, int format) { switch (format) { @@ -940,7 +940,7 @@ snd_rme96_capture_setformat(struct rme96 *rme96, } static void -snd_rme96_set_period_properties(struct rme96 *rme96, +snd_rme96_set_period_properties(rme96_t *rme96, size_t period_bytes) { switch (period_bytes) { @@ -959,11 +959,11 @@ snd_rme96_set_period_properties(struct rme96 *rme96, } static int -snd_rme96_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +snd_rme96_playback_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme96_t *rme96 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err, rate, dummy; runtime->dma_area = (void __force *)(rme96->iobase + @@ -1012,11 +1012,11 @@ snd_rme96_playback_hw_params(struct snd_pcm_substream *substream, } static int -snd_rme96_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +snd_rme96_capture_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme96_t *rme96 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err, isadat, rate; runtime->dma_area = (void __force *)(rme96->iobase + @@ -1066,7 +1066,7 @@ snd_rme96_capture_hw_params(struct snd_pcm_substream *substream, } static void -snd_rme96_playback_start(struct rme96 *rme96, +snd_rme96_playback_start(rme96_t *rme96, int from_pause) { if (!from_pause) { @@ -1078,7 +1078,7 @@ snd_rme96_playback_start(struct rme96 *rme96, } static void -snd_rme96_capture_start(struct rme96 *rme96, +snd_rme96_capture_start(rme96_t *rme96, int from_pause) { if (!from_pause) { @@ -1090,7 +1090,7 @@ snd_rme96_capture_start(struct rme96 *rme96, } static void -snd_rme96_playback_stop(struct rme96 *rme96) +snd_rme96_playback_stop(rme96_t *rme96) { /* * Check if there is an unconfirmed IRQ, if so confirm it, or else @@ -1105,7 +1105,7 @@ snd_rme96_playback_stop(struct rme96 *rme96) } static void -snd_rme96_capture_stop(struct rme96 *rme96) +snd_rme96_capture_stop(rme96_t *rme96) { rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER); if (rme96->rcreg & RME96_RCR_IRQ_2) { @@ -1120,7 +1120,7 @@ snd_rme96_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct rme96 *rme96 = (struct rme96 *)dev_id; + rme96_t *rme96 = (rme96_t *)dev_id; rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER); /* fastpath out, to ease interrupt sharing */ @@ -1145,18 +1145,18 @@ snd_rme96_interrupt(int irq, static unsigned int period_bytes[] = { RME96_SMALL_BLOCK_SIZE, RME96_LARGE_BLOCK_SIZE }; -static struct snd_pcm_hw_constraint_list hw_constraints_period_bytes = { +static snd_pcm_hw_constraint_list_t hw_constraints_period_bytes = { .count = ARRAY_SIZE(period_bytes), .list = period_bytes, .mask = 0 }; static int -snd_rme96_playback_spdif_open(struct snd_pcm_substream *substream) +snd_rme96_playback_spdif_open(snd_pcm_substream_t *substream) { int rate, dummy; - struct rme96 *rme96 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme96_t *rme96 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_set_sync(substream); @@ -1191,11 +1191,11 @@ snd_rme96_playback_spdif_open(struct snd_pcm_substream *substream) } static int -snd_rme96_capture_spdif_open(struct snd_pcm_substream *substream) +snd_rme96_capture_spdif_open(snd_pcm_substream_t *substream) { int isadat, rate; - struct rme96 *rme96 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme96_t *rme96 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_set_sync(substream); @@ -1226,11 +1226,11 @@ snd_rme96_capture_spdif_open(struct snd_pcm_substream *substream) } static int -snd_rme96_playback_adat_open(struct snd_pcm_substream *substream) +snd_rme96_playback_adat_open(snd_pcm_substream_t *substream) { int rate, dummy; - struct rme96 *rme96 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme96_t *rme96 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_set_sync(substream); @@ -1260,11 +1260,11 @@ snd_rme96_playback_adat_open(struct snd_pcm_substream *substream) } static int -snd_rme96_capture_adat_open(struct snd_pcm_substream *substream) +snd_rme96_capture_adat_open(snd_pcm_substream_t *substream) { int isadat, rate; - struct rme96 *rme96 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme96_t *rme96 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_pcm_set_sync(substream); @@ -1297,9 +1297,9 @@ snd_rme96_capture_adat_open(struct snd_pcm_substream *substream) } static int -snd_rme96_playback_close(struct snd_pcm_substream *substream) +snd_rme96_playback_close(snd_pcm_substream_t *substream) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); int spdif = 0; spin_lock_irq(&rme96->lock); @@ -1319,9 +1319,9 @@ snd_rme96_playback_close(struct snd_pcm_substream *substream) } static int -snd_rme96_capture_close(struct snd_pcm_substream *substream) +snd_rme96_capture_close(snd_pcm_substream_t *substream) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme96->lock); if (RME96_ISRECORDING(rme96)) { @@ -1334,9 +1334,9 @@ snd_rme96_capture_close(struct snd_pcm_substream *substream) } static int -snd_rme96_playback_prepare(struct snd_pcm_substream *substream) +snd_rme96_playback_prepare(snd_pcm_substream_t *substream) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme96->lock); if (RME96_ISPLAYING(rme96)) { @@ -1348,9 +1348,9 @@ snd_rme96_playback_prepare(struct snd_pcm_substream *substream) } static int -snd_rme96_capture_prepare(struct snd_pcm_substream *substream) +snd_rme96_capture_prepare(snd_pcm_substream_t *substream) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme96->lock); if (RME96_ISRECORDING(rme96)) { @@ -1362,10 +1362,10 @@ snd_rme96_capture_prepare(struct snd_pcm_substream *substream) } static int -snd_rme96_playback_trigger(struct snd_pcm_substream *substream, +snd_rme96_playback_trigger(snd_pcm_substream_t *substream, int cmd) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -1405,10 +1405,10 @@ snd_rme96_playback_trigger(struct snd_pcm_substream *substream, } static int -snd_rme96_capture_trigger(struct snd_pcm_substream *substream, +snd_rme96_capture_trigger(snd_pcm_substream_t *substream, int cmd) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -1449,20 +1449,20 @@ snd_rme96_capture_trigger(struct snd_pcm_substream *substream, } static snd_pcm_uframes_t -snd_rme96_playback_pointer(struct snd_pcm_substream *substream) +snd_rme96_playback_pointer(snd_pcm_substream_t *substream) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); return snd_rme96_playback_ptr(rme96); } static snd_pcm_uframes_t -snd_rme96_capture_pointer(struct snd_pcm_substream *substream) +snd_rme96_capture_pointer(snd_pcm_substream_t *substream) { - struct rme96 *rme96 = snd_pcm_substream_chip(substream); + rme96_t *rme96 = snd_pcm_substream_chip(substream); return snd_rme96_capture_ptr(rme96); } -static struct snd_pcm_ops snd_rme96_playback_spdif_ops = { +static snd_pcm_ops_t snd_rme96_playback_spdif_ops = { .open = snd_rme96_playback_spdif_open, .close = snd_rme96_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1475,7 +1475,7 @@ static struct snd_pcm_ops snd_rme96_playback_spdif_ops = { .mmap = snd_pcm_lib_mmap_iomem, }; -static struct snd_pcm_ops snd_rme96_capture_spdif_ops = { +static snd_pcm_ops_t snd_rme96_capture_spdif_ops = { .open = snd_rme96_capture_spdif_open, .close = snd_rme96_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1487,7 +1487,7 @@ static struct snd_pcm_ops snd_rme96_capture_spdif_ops = { .mmap = snd_pcm_lib_mmap_iomem, }; -static struct snd_pcm_ops snd_rme96_playback_adat_ops = { +static snd_pcm_ops_t snd_rme96_playback_adat_ops = { .open = snd_rme96_playback_adat_open, .close = snd_rme96_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1500,7 +1500,7 @@ static struct snd_pcm_ops snd_rme96_playback_adat_ops = { .mmap = snd_pcm_lib_mmap_iomem, }; -static struct snd_pcm_ops snd_rme96_capture_adat_ops = { +static snd_pcm_ops_t snd_rme96_capture_adat_ops = { .open = snd_rme96_capture_adat_open, .close = snd_rme96_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1515,7 +1515,7 @@ static struct snd_pcm_ops snd_rme96_capture_adat_ops = { static void snd_rme96_free(void *private_data) { - struct rme96 *rme96 = (struct rme96 *)private_data; + rme96_t *rme96 = (rme96_t *)private_data; if (rme96 == NULL) { return; @@ -1540,21 +1540,21 @@ snd_rme96_free(void *private_data) } static void -snd_rme96_free_spdif_pcm(struct snd_pcm *pcm) +snd_rme96_free_spdif_pcm(snd_pcm_t *pcm) { - struct rme96 *rme96 = (struct rme96 *) pcm->private_data; + rme96_t *rme96 = (rme96_t *) pcm->private_data; rme96->spdif_pcm = NULL; } static void -snd_rme96_free_adat_pcm(struct snd_pcm *pcm) +snd_rme96_free_adat_pcm(snd_pcm_t *pcm) { - struct rme96 *rme96 = (struct rme96 *) pcm->private_data; + rme96_t *rme96 = (rme96_t *) pcm->private_data; rme96->adat_pcm = NULL; } static int __devinit -snd_rme96_create(struct rme96 *rme96) +snd_rme96_create(rme96_t *rme96) { struct pci_dev *pci = rme96->pci; int err; @@ -1671,10 +1671,10 @@ snd_rme96_create(struct rme96 *rme96) */ static void -snd_rme96_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +snd_rme96_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { int n; - struct rme96 *rme96 = (struct rme96 *)entry->private_data; + rme96_t *rme96 = (rme96_t *)entry->private_data; rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER); @@ -1800,9 +1800,9 @@ snd_rme96_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer } static void __devinit -snd_rme96_proc_init(struct rme96 *rme96) +snd_rme96_proc_init(rme96_t *rme96) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(rme96->card, "rme96", &entry)) snd_info_set_text_ops(entry, rme96, 1024, snd_rme96_proc_read); @@ -1813,7 +1813,7 @@ snd_rme96_proc_init(struct rme96 *rme96) */ static int -snd_rme96_info_loopback_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_rme96_info_loopback_control(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1822,9 +1822,9 @@ snd_rme96_info_loopback_control(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } static int -snd_rme96_get_loopback_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_get_loopback_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme96->lock); ucontrol->value.integer.value[0] = rme96->wcreg & RME96_WCR_SEL ? 0 : 1; @@ -1832,9 +1832,9 @@ snd_rme96_get_loopback_control(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } static int -snd_rme96_put_loopback_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_put_loopback_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -1849,10 +1849,10 @@ snd_rme96_put_loopback_control(struct snd_kcontrol *kcontrol, struct snd_ctl_ele } static int -snd_rme96_info_inputtype_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_rme96_info_inputtype_control(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *_texts[5] = { "Optical", "Coaxial", "Internal", "XLR", "Analog" }; - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); char *texts[5] = { _texts[0], _texts[1], _texts[2], _texts[3], _texts[4] }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -1886,9 +1886,9 @@ snd_rme96_info_inputtype_control(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } static int -snd_rme96_get_inputtype_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_get_inputtype_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); unsigned int items = 3; spin_lock_irq(&rme96->lock); @@ -1925,9 +1925,9 @@ snd_rme96_get_inputtype_control(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } static int -snd_rme96_put_inputtype_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_put_inputtype_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); unsigned int val; int change, items = 3; @@ -1967,7 +1967,7 @@ snd_rme96_put_inputtype_control(struct snd_kcontrol *kcontrol, struct snd_ctl_el } static int -snd_rme96_info_clockmode_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_rme96_info_clockmode_control(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[3] = { "AutoSync", "Internal", "Word" }; @@ -1981,9 +1981,9 @@ snd_rme96_info_clockmode_control(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } static int -snd_rme96_get_clockmode_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_get_clockmode_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme96->lock); ucontrol->value.enumerated.item[0] = snd_rme96_getclockmode(rme96); @@ -1991,9 +1991,9 @@ snd_rme96_get_clockmode_control(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } static int -snd_rme96_put_clockmode_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_put_clockmode_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -2006,7 +2006,7 @@ snd_rme96_put_clockmode_control(struct snd_kcontrol *kcontrol, struct snd_ctl_el } static int -snd_rme96_info_attenuation_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_rme96_info_attenuation_control(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = { "0 dB", "-6 dB", "-12 dB", "-18 dB" }; @@ -2020,9 +2020,9 @@ snd_rme96_info_attenuation_control(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } static int -snd_rme96_get_attenuation_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_get_attenuation_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme96->lock); ucontrol->value.enumerated.item[0] = snd_rme96_getattenuation(rme96); @@ -2030,9 +2030,9 @@ snd_rme96_get_attenuation_control(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } static int -snd_rme96_put_attenuation_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_put_attenuation_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -2046,7 +2046,7 @@ snd_rme96_put_attenuation_control(struct snd_kcontrol *kcontrol, struct snd_ctl_ } static int -snd_rme96_info_montracks_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_rme96_info_montracks_control(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = { "1+2", "3+4", "5+6", "7+8" }; @@ -2060,9 +2060,9 @@ snd_rme96_info_montracks_control(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } static int -snd_rme96_get_montracks_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_get_montracks_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme96->lock); ucontrol->value.enumerated.item[0] = snd_rme96_getmontracks(rme96); @@ -2070,9 +2070,9 @@ snd_rme96_get_montracks_control(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } static int -snd_rme96_put_montracks_control(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +snd_rme96_put_montracks_control(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -2084,7 +2084,7 @@ snd_rme96_put_montracks_control(struct snd_kcontrol *kcontrol, struct snd_ctl_el return change; } -static u32 snd_rme96_convert_from_aes(struct snd_aes_iec958 *aes) +static u32 snd_rme96_convert_from_aes(snd_aes_iec958_t *aes) { u32 val = 0; val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? RME96_WCR_PRO : 0; @@ -2096,7 +2096,7 @@ static u32 snd_rme96_convert_from_aes(struct snd_aes_iec958 *aes) return val; } -static void snd_rme96_convert_to_aes(struct snd_aes_iec958 *aes, u32 val) +static void snd_rme96_convert_to_aes(snd_aes_iec958_t *aes, u32 val) { aes->status[0] = ((val & RME96_WCR_PRO) ? IEC958_AES0_PROFESSIONAL : 0) | ((val & RME96_WCR_DOLBY) ? IEC958_AES0_NONAUDIO : 0); @@ -2106,24 +2106,24 @@ static void snd_rme96_convert_to_aes(struct snd_aes_iec958 *aes, u32 val) aes->status[0] |= (val & RME96_WCR_EMP) ? IEC958_AES0_CON_EMPHASIS_5015 : 0; } -static int snd_rme96_control_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme96_control_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme96_control_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme96_control_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); snd_rme96_convert_to_aes(&ucontrol->value.iec958, rme96->wcreg_spdif); return 0; } -static int snd_rme96_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme96_control_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -2135,24 +2135,24 @@ static int snd_rme96_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd return change; } -static int snd_rme96_control_spdif_stream_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme96_control_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme96_control_spdif_stream_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme96_control_spdif_stream_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); snd_rme96_convert_to_aes(&ucontrol->value.iec958, rme96->wcreg_spdif_stream); return 0; } -static int snd_rme96_control_spdif_stream_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme96_control_spdif_stream_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -2167,23 +2167,23 @@ static int snd_rme96_control_spdif_stream_put(struct snd_kcontrol *kcontrol, str return change; } -static int snd_rme96_control_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme96_control_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme96_control_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme96_control_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = kcontrol->private_value; return 0; } static int -snd_rme96_dac_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +snd_rme96_dac_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -2193,9 +2193,9 @@ snd_rme96_dac_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_inf } static int -snd_rme96_dac_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *u) +snd_rme96_dac_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme96->lock); u->value.integer.value[0] = rme96->vol[0]; @@ -2206,9 +2206,9 @@ snd_rme96_dac_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu } static int -snd_rme96_dac_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *u) +snd_rme96_dac_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u) { - struct rme96 *rme96 = snd_kcontrol_chip(kcontrol); + rme96_t *rme96 = snd_kcontrol_chip(kcontrol); int change = 0; if (!RME96_HAS_ANALOG_OUT(rme96)) { @@ -2231,7 +2231,7 @@ snd_rme96_dac_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_valu return change; } -static struct snd_kcontrol_new snd_rme96_controls[] = { +static snd_kcontrol_new_t snd_rme96_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -2312,11 +2312,11 @@ static struct snd_kcontrol_new snd_rme96_controls[] = { }; static int -snd_rme96_create_switches(struct snd_card *card, - struct rme96 *rme96) +snd_rme96_create_switches(snd_card_t *card, + rme96_t *rme96) { int idx, err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; for (idx = 0; idx < 7; idx++) { if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme96_controls[idx], rme96))) < 0) @@ -2338,7 +2338,7 @@ snd_rme96_create_switches(struct snd_card *card, * Card initialisation */ -static void snd_rme96_card_free(struct snd_card *card) +static void snd_rme96_card_free(snd_card_t *card) { snd_rme96_free(card->private_data); } @@ -2348,8 +2348,8 @@ snd_rme96_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct rme96 *rme96; - struct snd_card *card; + rme96_t *rme96; + snd_card_t *card; int err; u8 val; @@ -2361,10 +2361,10 @@ snd_rme96_probe(struct pci_dev *pci, return -ENOENT; } if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof(struct rme96))) == NULL) + sizeof(rme96_t))) == NULL) return -ENOMEM; card->private_free = snd_rme96_card_free; - rme96 = (struct rme96 *)card->private_data; + rme96 = (rme96_t *)card->private_data; rme96->card = card; rme96->pci = pci; snd_card_set_dev(card, &pci->dev); diff --git a/trunk/sound/pci/rme9652/hdsp.c b/trunk/sound/pci/rme9652/hdsp.c index ebf7a2b86c23..d15ffb3e9b0a 100644 --- a/trunk/sound/pci/rme9652/hdsp.c +++ b/trunk/sound/pci/rme9652/hdsp.c @@ -394,7 +394,11 @@ MODULE_SUPPORTED_DEVICE("{{RME Hammerfall-DSP}," #endif #endif -struct hdsp_9632_meters { +typedef struct _hdsp hdsp_t; +typedef struct _hdsp_midi hdsp_midi_t; +typedef struct _hdsp_9632_meters hdsp_9632_meters_t; + +struct _hdsp_9632_meters { u32 input_peak[16]; u32 playback_peak[16]; u32 output_peak[16]; @@ -410,23 +414,23 @@ struct hdsp_9632_meters { u32 xxx_rms_high[16]; }; -struct hdsp_midi { - struct hdsp *hdsp; +struct _hdsp_midi { + hdsp_t *hdsp; int id; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *input; - struct snd_rawmidi_substream *output; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *input; + snd_rawmidi_substream_t *output; char istimer; /* timer in use */ struct timer_list timer; spinlock_t lock; int pending; }; -struct hdsp { +struct _hdsp { spinlock_t lock; - struct snd_pcm_substream *capture_substream; - struct snd_pcm_substream *playback_substream; - struct hdsp_midi midi[2]; + snd_pcm_substream_t *capture_substream; + snd_pcm_substream_t *playback_substream; + hdsp_midi_t midi[2]; struct tasklet_struct midi_tasklet; int use_midi_tasklet; int precise_ptr; @@ -436,7 +440,7 @@ struct hdsp { u32 creg_spdif_stream; int clock_source_locked; char *card_name; /* digiface/multiface */ - enum HDSP_IO_Type io_type; /* ditto, but for code use */ + HDSP_IO_Type io_type; /* ditto, but for code use */ unsigned short firmware_rev; unsigned short state; /* stores state bits */ u32 firmware_cache[24413]; /* this helps recover from accidental iobox power failure */ @@ -463,11 +467,11 @@ struct hdsp { int irq; unsigned long port; void __iomem *iobase; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_hwdep *hwdep; + snd_card_t *card; + snd_pcm_t *pcm; + snd_hwdep_t *hwdep; struct pci_dev *pci; - struct snd_kcontrol *spdif_ctl; + snd_kcontrol_t *spdif_ctl; unsigned short mixer_matrix[HDSP_MATRIX_MIXER_SIZE]; }; @@ -581,17 +585,17 @@ static struct pci_device_id snd_hdsp_ids[] = { MODULE_DEVICE_TABLE(pci, snd_hdsp_ids); /* prototypes */ -static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp); -static int snd_hdsp_create_pcm(struct snd_card *card, struct hdsp *hdsp); -static int snd_hdsp_enable_io (struct hdsp *hdsp); -static void snd_hdsp_initialize_midi_flush (struct hdsp *hdsp); -static void snd_hdsp_initialize_channels (struct hdsp *hdsp); -static int hdsp_fifo_wait(struct hdsp *hdsp, int count, int timeout); -static int hdsp_autosync_ref(struct hdsp *hdsp); -static int snd_hdsp_set_defaults(struct hdsp *hdsp); -static void snd_hdsp_9652_enable_mixer (struct hdsp *hdsp); - -static int hdsp_playback_to_output_key (struct hdsp *hdsp, int in, int out) +static int snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp); +static int snd_hdsp_create_pcm(snd_card_t *card, hdsp_t *hdsp); +static int snd_hdsp_enable_io (hdsp_t *hdsp); +static void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp); +static void snd_hdsp_initialize_channels (hdsp_t *hdsp); +static int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout); +static int hdsp_autosync_ref(hdsp_t *hdsp); +static int snd_hdsp_set_defaults(hdsp_t *hdsp); +static void snd_hdsp_9652_enable_mixer (hdsp_t *hdsp); + +static int hdsp_playback_to_output_key (hdsp_t *hdsp, int in, int out) { switch (hdsp->firmware_rev) { case 0xa: @@ -604,7 +608,7 @@ static int hdsp_playback_to_output_key (struct hdsp *hdsp, int in, int out) } } -static int hdsp_input_to_output_key (struct hdsp *hdsp, int in, int out) +static int hdsp_input_to_output_key (hdsp_t *hdsp, int in, int out) { switch (hdsp->firmware_rev) { case 0xa: @@ -617,17 +621,17 @@ static int hdsp_input_to_output_key (struct hdsp *hdsp, int in, int out) } } -static void hdsp_write(struct hdsp *hdsp, int reg, int val) +static void hdsp_write(hdsp_t *hdsp, int reg, int val) { writel(val, hdsp->iobase + reg); } -static unsigned int hdsp_read(struct hdsp *hdsp, int reg) +static unsigned int hdsp_read(hdsp_t *hdsp, int reg) { return readl (hdsp->iobase + reg); } -static int hdsp_check_for_iobox (struct hdsp *hdsp) +static int hdsp_check_for_iobox (hdsp_t *hdsp) { if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0; @@ -640,7 +644,7 @@ static int hdsp_check_for_iobox (struct hdsp *hdsp) } -static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) { +static int snd_hdsp_load_firmware_from_cache(hdsp_t *hdsp) { int i; unsigned long flags; @@ -695,7 +699,7 @@ static int snd_hdsp_load_firmware_from_cache(struct hdsp *hdsp) { return 0; } -static int hdsp_get_iobox_version (struct hdsp *hdsp) +static int hdsp_get_iobox_version (hdsp_t *hdsp) { if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) { @@ -726,7 +730,7 @@ static int hdsp_get_iobox_version (struct hdsp *hdsp) } -static int hdsp_check_for_firmware (struct hdsp *hdsp, int show_err) +static int hdsp_check_for_firmware (hdsp_t *hdsp, int show_err) { if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0; if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) { @@ -747,7 +751,7 @@ static int hdsp_check_for_firmware (struct hdsp *hdsp, int show_err) } -static int hdsp_fifo_wait(struct hdsp *hdsp, int count, int timeout) +static int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout) { int i; @@ -772,7 +776,7 @@ static int hdsp_fifo_wait(struct hdsp *hdsp, int count, int timeout) return -1; } -static int hdsp_read_gain (struct hdsp *hdsp, unsigned int addr) +static int hdsp_read_gain (hdsp_t *hdsp, unsigned int addr) { if (addr >= HDSP_MATRIX_MIXER_SIZE) return 0; @@ -780,7 +784,7 @@ static int hdsp_read_gain (struct hdsp *hdsp, unsigned int addr) return hdsp->mixer_matrix[addr]; } -static int hdsp_write_gain(struct hdsp *hdsp, unsigned int addr, unsigned short data) +static int hdsp_write_gain(hdsp_t *hdsp, unsigned int addr, unsigned short data) { unsigned int ad; @@ -840,7 +844,7 @@ static int hdsp_write_gain(struct hdsp *hdsp, unsigned int addr, unsigned short return 0; } -static int snd_hdsp_use_is_exclusive(struct hdsp *hdsp) +static int snd_hdsp_use_is_exclusive(hdsp_t *hdsp) { unsigned long flags; int ret = 1; @@ -853,7 +857,7 @@ static int snd_hdsp_use_is_exclusive(struct hdsp *hdsp) return ret; } -static int hdsp_external_sample_rate (struct hdsp *hdsp) +static int hdsp_external_sample_rate (hdsp_t *hdsp) { unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register); unsigned int rate_bits = status2 & HDSP_systemFrequencyMask; @@ -870,7 +874,7 @@ static int hdsp_external_sample_rate (struct hdsp *hdsp) } } -static int hdsp_spdif_sample_rate(struct hdsp *hdsp) +static int hdsp_spdif_sample_rate(hdsp_t *hdsp) { unsigned int status = hdsp_read(hdsp, HDSP_statusRegister); unsigned int rate_bits = (status & HDSP_spdifFrequencyMask); @@ -901,12 +905,12 @@ static int hdsp_spdif_sample_rate(struct hdsp *hdsp) return 0; } -static void hdsp_compute_period_size(struct hdsp *hdsp) +static void hdsp_compute_period_size(hdsp_t *hdsp) { hdsp->period_bytes = 1 << ((hdsp_decode_latency(hdsp->control_register) + 8)); } -static snd_pcm_uframes_t hdsp_hw_pointer(struct hdsp *hdsp) +static snd_pcm_uframes_t hdsp_hw_pointer(hdsp_t *hdsp) { int position; @@ -921,29 +925,29 @@ static snd_pcm_uframes_t hdsp_hw_pointer(struct hdsp *hdsp) return position; } -static void hdsp_reset_hw_pointer(struct hdsp *hdsp) +static void hdsp_reset_hw_pointer(hdsp_t *hdsp) { hdsp_write (hdsp, HDSP_resetPointer, 0); } -static void hdsp_start_audio(struct hdsp *s) +static void hdsp_start_audio(hdsp_t *s) { s->control_register |= (HDSP_AudioInterruptEnable | HDSP_Start); hdsp_write(s, HDSP_controlRegister, s->control_register); } -static void hdsp_stop_audio(struct hdsp *s) +static void hdsp_stop_audio(hdsp_t *s) { s->control_register &= ~(HDSP_Start | HDSP_AudioInterruptEnable); hdsp_write(s, HDSP_controlRegister, s->control_register); } -static void hdsp_silence_playback(struct hdsp *hdsp) +static void hdsp_silence_playback(hdsp_t *hdsp) { memset(hdsp->playback_buffer, 0, HDSP_DMA_AREA_BYTES); } -static int hdsp_set_interrupt_interval(struct hdsp *s, unsigned int frames) +static int hdsp_set_interrupt_interval(hdsp_t *s, unsigned int frames) { int n; @@ -968,7 +972,7 @@ static int hdsp_set_interrupt_interval(struct hdsp *s, unsigned int frames) return 0; } -static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally) +static int hdsp_set_rate(hdsp_t *hdsp, int rate, int called_internally) { int reject_if_open = 0; int current_rate; @@ -1110,7 +1114,7 @@ static int hdsp_set_rate(struct hdsp *hdsp, int rate, int called_internally) MIDI ----------------------------------------------------------------------------*/ -static unsigned char snd_hdsp_midi_read_byte (struct hdsp *hdsp, int id) +static unsigned char snd_hdsp_midi_read_byte (hdsp_t *hdsp, int id) { /* the hardware already does the relevant bit-mask with 0xff */ if (id) @@ -1119,7 +1123,7 @@ static unsigned char snd_hdsp_midi_read_byte (struct hdsp *hdsp, int id) return hdsp_read(hdsp, HDSP_midiDataIn0); } -static void snd_hdsp_midi_write_byte (struct hdsp *hdsp, int id, int val) +static void snd_hdsp_midi_write_byte (hdsp_t *hdsp, int id, int val) { /* the hardware already does the relevant bit-mask with 0xff */ if (id) @@ -1128,7 +1132,7 @@ static void snd_hdsp_midi_write_byte (struct hdsp *hdsp, int id, int val) hdsp_write(hdsp, HDSP_midiDataOut0, val); } -static int snd_hdsp_midi_input_available (struct hdsp *hdsp, int id) +static int snd_hdsp_midi_input_available (hdsp_t *hdsp, int id) { if (id) return (hdsp_read(hdsp, HDSP_midiStatusIn1) & 0xff); @@ -1136,7 +1140,7 @@ static int snd_hdsp_midi_input_available (struct hdsp *hdsp, int id) return (hdsp_read(hdsp, HDSP_midiStatusIn0) & 0xff); } -static int snd_hdsp_midi_output_possible (struct hdsp *hdsp, int id) +static int snd_hdsp_midi_output_possible (hdsp_t *hdsp, int id) { int fifo_bytes_used; @@ -1151,13 +1155,13 @@ static int snd_hdsp_midi_output_possible (struct hdsp *hdsp, int id) return 0; } -static void snd_hdsp_flush_midi_input (struct hdsp *hdsp, int id) +static void snd_hdsp_flush_midi_input (hdsp_t *hdsp, int id) { while (snd_hdsp_midi_input_available (hdsp, id)) snd_hdsp_midi_read_byte (hdsp, id); } -static int snd_hdsp_midi_output_write (struct hdsp_midi *hmidi) +static int snd_hdsp_midi_output_write (hdsp_midi_t *hmidi) { unsigned long flags; int n_pending; @@ -1185,7 +1189,7 @@ static int snd_hdsp_midi_output_write (struct hdsp_midi *hmidi) return 0; } -static int snd_hdsp_midi_input_read (struct hdsp_midi *hmidi) +static int snd_hdsp_midi_input_read (hdsp_midi_t *hmidi) { unsigned char buf[128]; /* this buffer is designed to match the MIDI input FIFO size */ unsigned long flags; @@ -1217,14 +1221,14 @@ static int snd_hdsp_midi_input_read (struct hdsp_midi *hmidi) return snd_hdsp_midi_output_write (hmidi); } -static void snd_hdsp_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_hdsp_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct hdsp *hdsp; - struct hdsp_midi *hmidi; + hdsp_t *hdsp; + hdsp_midi_t *hmidi; unsigned long flags; u32 ie; - hmidi = (struct hdsp_midi *) substream->rmidi->private_data; + hmidi = (hdsp_midi_t *) substream->rmidi->private_data; hdsp = hmidi->hdsp; ie = hmidi->id ? HDSP_Midi1InterruptEnable : HDSP_Midi0InterruptEnable; spin_lock_irqsave (&hdsp->lock, flags); @@ -1244,7 +1248,7 @@ static void snd_hdsp_midi_input_trigger(struct snd_rawmidi_substream *substream, static void snd_hdsp_midi_output_timer(unsigned long data) { - struct hdsp_midi *hmidi = (struct hdsp_midi *) data; + hdsp_midi_t *hmidi = (hdsp_midi_t *) data; unsigned long flags; snd_hdsp_midi_output_write(hmidi); @@ -1264,12 +1268,12 @@ static void snd_hdsp_midi_output_timer(unsigned long data) spin_unlock_irqrestore (&hmidi->lock, flags); } -static void snd_hdsp_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_hdsp_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { - struct hdsp_midi *hmidi; + hdsp_midi_t *hmidi; unsigned long flags; - hmidi = (struct hdsp_midi *) substream->rmidi->private_data; + hmidi = (hdsp_midi_t *) substream->rmidi->private_data; spin_lock_irqsave (&hmidi->lock, flags); if (up) { if (!hmidi->istimer) { @@ -1289,11 +1293,11 @@ static void snd_hdsp_midi_output_trigger(struct snd_rawmidi_substream *substream snd_hdsp_midi_output_write(hmidi); } -static int snd_hdsp_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_hdsp_midi_input_open(snd_rawmidi_substream_t * substream) { - struct hdsp_midi *hmidi; + hdsp_midi_t *hmidi; - hmidi = (struct hdsp_midi *) substream->rmidi->private_data; + hmidi = (hdsp_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); snd_hdsp_flush_midi_input (hmidi->hdsp, hmidi->id); hmidi->input = substream; @@ -1302,11 +1306,11 @@ static int snd_hdsp_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_hdsp_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_hdsp_midi_output_open(snd_rawmidi_substream_t * substream) { - struct hdsp_midi *hmidi; + hdsp_midi_t *hmidi; - hmidi = (struct hdsp_midi *) substream->rmidi->private_data; + hmidi = (hdsp_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); hmidi->output = substream; spin_unlock_irq (&hmidi->lock); @@ -1314,13 +1318,13 @@ static int snd_hdsp_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_hdsp_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_hdsp_midi_input_close(snd_rawmidi_substream_t * substream) { - struct hdsp_midi *hmidi; + hdsp_midi_t *hmidi; snd_hdsp_midi_input_trigger (substream, 0); - hmidi = (struct hdsp_midi *) substream->rmidi->private_data; + hmidi = (hdsp_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); hmidi->input = NULL; spin_unlock_irq (&hmidi->lock); @@ -1328,13 +1332,13 @@ static int snd_hdsp_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_hdsp_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_hdsp_midi_output_close(snd_rawmidi_substream_t * substream) { - struct hdsp_midi *hmidi; + hdsp_midi_t *hmidi; snd_hdsp_midi_output_trigger (substream, 0); - hmidi = (struct hdsp_midi *) substream->rmidi->private_data; + hmidi = (hdsp_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); hmidi->output = NULL; spin_unlock_irq (&hmidi->lock); @@ -1342,21 +1346,21 @@ static int snd_hdsp_midi_output_close(struct snd_rawmidi_substream *substream) return 0; } -static struct snd_rawmidi_ops snd_hdsp_midi_output = +static snd_rawmidi_ops_t snd_hdsp_midi_output = { .open = snd_hdsp_midi_output_open, .close = snd_hdsp_midi_output_close, .trigger = snd_hdsp_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_hdsp_midi_input = +static snd_rawmidi_ops_t snd_hdsp_midi_input = { .open = snd_hdsp_midi_input_open, .close = snd_hdsp_midi_input_close, .trigger = snd_hdsp_midi_input_trigger, }; -static int __devinit snd_hdsp_create_midi (struct snd_card *card, struct hdsp *hdsp, int id) +static int __devinit snd_hdsp_create_midi (snd_card_t *card, hdsp_t *hdsp, int id) { char buf[32]; @@ -1390,7 +1394,7 @@ static int __devinit snd_hdsp_create_midi (struct snd_card *card, struct hdsp *h Control Interface ----------------------------------------------------------------------------*/ -static u32 snd_hdsp_convert_from_aes(struct snd_aes_iec958 *aes) +static u32 snd_hdsp_convert_from_aes(snd_aes_iec958_t *aes) { u32 val = 0; val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? HDSP_SPDIFProfessional : 0; @@ -1402,7 +1406,7 @@ static u32 snd_hdsp_convert_from_aes(struct snd_aes_iec958 *aes) return val; } -static void snd_hdsp_convert_to_aes(struct snd_aes_iec958 *aes, u32 val) +static void snd_hdsp_convert_to_aes(snd_aes_iec958_t *aes, u32 val) { aes->status[0] = ((val & HDSP_SPDIFProfessional) ? IEC958_AES0_PROFESSIONAL : 0) | ((val & HDSP_SPDIFNonAudio) ? IEC958_AES0_NONAUDIO : 0); @@ -1412,24 +1416,24 @@ static void snd_hdsp_convert_to_aes(struct snd_aes_iec958 *aes, u32 val) aes->status[0] |= (val & HDSP_SPDIFEmphasis) ? IEC958_AES0_CON_EMPHASIS_5015 : 0; } -static int snd_hdsp_control_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_control_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_hdsp_control_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_control_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif); return 0; } -static int snd_hdsp_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_control_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -1441,24 +1445,24 @@ static int snd_hdsp_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ return change; } -static int snd_hdsp_control_spdif_stream_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_control_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_hdsp_control_spdif_stream_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_control_spdif_stream_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); snd_hdsp_convert_to_aes(&ucontrol->value.iec958, hdsp->creg_spdif_stream); return 0; } -static int snd_hdsp_control_spdif_stream_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_control_spdif_stream_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -1472,14 +1476,14 @@ static int snd_hdsp_control_spdif_stream_put(struct snd_kcontrol *kcontrol, stru return change; } -static int snd_hdsp_control_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_control_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_hdsp_control_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_control_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = kcontrol->private_value; return 0; @@ -1493,12 +1497,12 @@ static int snd_hdsp_control_spdif_mask_get(struct snd_kcontrol *kcontrol, struct .get = snd_hdsp_get_spdif_in, \ .put = snd_hdsp_put_spdif_in } -static unsigned int hdsp_spdif_in(struct hdsp *hdsp) +static unsigned int hdsp_spdif_in(hdsp_t *hdsp) { return hdsp_decode_spdif_in(hdsp->control_register & HDSP_SPDIFInputMask); } -static int hdsp_set_spdif_input(struct hdsp *hdsp, int in) +static int hdsp_set_spdif_input(hdsp_t *hdsp, int in) { hdsp->control_register &= ~HDSP_SPDIFInputMask; hdsp->control_register |= hdsp_encode_spdif_in(in); @@ -1506,10 +1510,10 @@ static int hdsp_set_spdif_input(struct hdsp *hdsp, int in) return 0; } -static int snd_hdsp_info_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_spdif_in(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = {"Optical", "Coaxial", "Internal", "AES"}; - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -1520,17 +1524,17 @@ static int snd_hdsp_info_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_hdsp_get_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_spdif_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_spdif_in(hdsp); return 0; } -static int snd_hdsp_put_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_spdif_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1550,12 +1554,12 @@ static int snd_hdsp_put_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_e .info = snd_hdsp_info_spdif_bits, \ .get = snd_hdsp_get_spdif_out, .put = snd_hdsp_put_spdif_out } -static int hdsp_spdif_out(struct hdsp *hdsp) +static int hdsp_spdif_out(hdsp_t *hdsp) { return (hdsp->control_register & HDSP_SPDIFOpticalOut) ? 1 : 0; } -static int hdsp_set_spdif_output(struct hdsp *hdsp, int out) +static int hdsp_set_spdif_output(hdsp_t *hdsp, int out) { if (out) hdsp->control_register |= HDSP_SPDIFOpticalOut; @@ -1565,7 +1569,7 @@ static int hdsp_set_spdif_output(struct hdsp *hdsp, int out) return 0; } -static int snd_hdsp_info_spdif_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_spdif_bits(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1574,17 +1578,17 @@ static int snd_hdsp_info_spdif_bits(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_hdsp_get_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_spdif_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = hdsp_spdif_out(hdsp); return 0; } -static int snd_hdsp_put_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_spdif_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1603,12 +1607,12 @@ static int snd_hdsp_put_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_ .info = snd_hdsp_info_spdif_bits, \ .get = snd_hdsp_get_spdif_professional, .put = snd_hdsp_put_spdif_professional } -static int hdsp_spdif_professional(struct hdsp *hdsp) +static int hdsp_spdif_professional(hdsp_t *hdsp) { return (hdsp->control_register & HDSP_SPDIFProfessional) ? 1 : 0; } -static int hdsp_set_spdif_professional(struct hdsp *hdsp, int val) +static int hdsp_set_spdif_professional(hdsp_t *hdsp, int val) { if (val) hdsp->control_register |= HDSP_SPDIFProfessional; @@ -1618,17 +1622,17 @@ static int hdsp_set_spdif_professional(struct hdsp *hdsp, int val) return 0; } -static int snd_hdsp_get_spdif_professional(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = hdsp_spdif_professional(hdsp); return 0; } -static int snd_hdsp_put_spdif_professional(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1647,12 +1651,12 @@ static int snd_hdsp_put_spdif_professional(struct snd_kcontrol *kcontrol, struct .info = snd_hdsp_info_spdif_bits, \ .get = snd_hdsp_get_spdif_emphasis, .put = snd_hdsp_put_spdif_emphasis } -static int hdsp_spdif_emphasis(struct hdsp *hdsp) +static int hdsp_spdif_emphasis(hdsp_t *hdsp) { return (hdsp->control_register & HDSP_SPDIFEmphasis) ? 1 : 0; } -static int hdsp_set_spdif_emphasis(struct hdsp *hdsp, int val) +static int hdsp_set_spdif_emphasis(hdsp_t *hdsp, int val) { if (val) hdsp->control_register |= HDSP_SPDIFEmphasis; @@ -1662,17 +1666,17 @@ static int hdsp_set_spdif_emphasis(struct hdsp *hdsp, int val) return 0; } -static int snd_hdsp_get_spdif_emphasis(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = hdsp_spdif_emphasis(hdsp); return 0; } -static int snd_hdsp_put_spdif_emphasis(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1691,12 +1695,12 @@ static int snd_hdsp_put_spdif_emphasis(struct snd_kcontrol *kcontrol, struct snd .info = snd_hdsp_info_spdif_bits, \ .get = snd_hdsp_get_spdif_nonaudio, .put = snd_hdsp_put_spdif_nonaudio } -static int hdsp_spdif_nonaudio(struct hdsp *hdsp) +static int hdsp_spdif_nonaudio(hdsp_t *hdsp) { return (hdsp->control_register & HDSP_SPDIFNonAudio) ? 1 : 0; } -static int hdsp_set_spdif_nonaudio(struct hdsp *hdsp, int val) +static int hdsp_set_spdif_nonaudio(hdsp_t *hdsp, int val) { if (val) hdsp->control_register |= HDSP_SPDIFNonAudio; @@ -1706,17 +1710,17 @@ static int hdsp_set_spdif_nonaudio(struct hdsp *hdsp, int val) return 0; } -static int snd_hdsp_get_spdif_nonaudio(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = hdsp_spdif_nonaudio(hdsp); return 0; } -static int snd_hdsp_put_spdif_nonaudio(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1739,10 +1743,10 @@ static int snd_hdsp_put_spdif_nonaudio(struct snd_kcontrol *kcontrol, struct snd .get = snd_hdsp_get_spdif_sample_rate \ } -static int snd_hdsp_info_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_spdif_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"}; - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -1753,9 +1757,9 @@ static int snd_hdsp_info_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_hdsp_get_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_spdif_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); switch (hdsp_spdif_sample_rate(hdsp)) { case 32000: @@ -1800,16 +1804,16 @@ static int snd_hdsp_get_spdif_sample_rate(struct snd_kcontrol *kcontrol, struct .get = snd_hdsp_get_system_sample_rate \ } -static int snd_hdsp_info_system_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_system_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; return 0; } -static int snd_hdsp_get_system_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_system_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp->system_sample_rate; return 0; @@ -1824,9 +1828,9 @@ static int snd_hdsp_get_system_sample_rate(struct snd_kcontrol *kcontrol, struct .get = snd_hdsp_get_autosync_sample_rate \ } -static int snd_hdsp_info_autosync_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_autosync_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"}; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -1837,9 +1841,9 @@ static int snd_hdsp_info_autosync_sample_rate(struct snd_kcontrol *kcontrol, str return 0; } -static int snd_hdsp_get_autosync_sample_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_autosync_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); switch (hdsp_external_sample_rate(hdsp)) { case 32000: @@ -1884,7 +1888,7 @@ static int snd_hdsp_get_autosync_sample_rate(struct snd_kcontrol *kcontrol, stru .get = snd_hdsp_get_system_clock_mode \ } -static int hdsp_system_clock_mode(struct hdsp *hdsp) +static int hdsp_system_clock_mode(hdsp_t *hdsp) { if (hdsp->control_register & HDSP_ClockModeMaster) return 0; @@ -1893,7 +1897,7 @@ static int hdsp_system_clock_mode(struct hdsp *hdsp) return 1; } -static int snd_hdsp_info_system_clock_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_system_clock_mode(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"Master", "Slave" }; @@ -1906,9 +1910,9 @@ static int snd_hdsp_info_system_clock_mode(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_hdsp_get_system_clock_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_system_clock_mode(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_system_clock_mode(hdsp); return 0; @@ -1923,7 +1927,7 @@ static int snd_hdsp_get_system_clock_mode(struct snd_kcontrol *kcontrol, struct .put = snd_hdsp_put_clock_source \ } -static int hdsp_clock_source(struct hdsp *hdsp) +static int hdsp_clock_source(hdsp_t *hdsp) { if (hdsp->control_register & HDSP_ClockModeMaster) { switch (hdsp->system_sample_rate) { @@ -1953,7 +1957,7 @@ static int hdsp_clock_source(struct hdsp *hdsp) } } -static int hdsp_set_clock_source(struct hdsp *hdsp, int mode) +static int hdsp_set_clock_source(hdsp_t *hdsp, int mode) { int rate; switch (mode) { @@ -2002,10 +2006,10 @@ static int hdsp_set_clock_source(struct hdsp *hdsp, int mode) return 0; } -static int snd_hdsp_info_clock_source(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_clock_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"AutoSync", "Internal 32.0 kHz", "Internal 44.1 kHz", "Internal 48.0 kHz", "Internal 64.0 kHz", "Internal 88.2 kHz", "Internal 96.0 kHz", "Internal 128 kHz", "Internal 176.4 kHz", "Internal 192.0 KHz" }; - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -2019,17 +2023,17 @@ static int snd_hdsp_info_clock_source(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_hdsp_get_clock_source(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_clock_source(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_clock_source(hdsp); return 0; } -static int snd_hdsp_put_clock_source(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_clock_source(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; int val; @@ -2053,7 +2057,7 @@ static int snd_hdsp_put_clock_source(struct snd_kcontrol *kcontrol, struct snd_c return change; } -static int snd_hdsp_info_clock_source_lock(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_clock_source_lock(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2062,17 +2066,17 @@ static int snd_hdsp_info_clock_source_lock(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_hdsp_get_clock_source_lock(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_clock_source_lock(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = hdsp->clock_source_locked; return 0; } -static int snd_hdsp_put_clock_source_lock(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_clock_source_lock(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; change = (int)ucontrol->value.integer.value[0] != hdsp->clock_source_locked; @@ -2090,7 +2094,7 @@ static int snd_hdsp_put_clock_source_lock(struct snd_kcontrol *kcontrol, struct .put = snd_hdsp_put_da_gain \ } -static int hdsp_da_gain(struct hdsp *hdsp) +static int hdsp_da_gain(hdsp_t *hdsp) { switch (hdsp->control_register & HDSP_DAGainMask) { case HDSP_DAGainHighGain: @@ -2104,7 +2108,7 @@ static int hdsp_da_gain(struct hdsp *hdsp) } } -static int hdsp_set_da_gain(struct hdsp *hdsp, int mode) +static int hdsp_set_da_gain(hdsp_t *hdsp, int mode) { hdsp->control_register &= ~HDSP_DAGainMask; switch (mode) { @@ -2125,7 +2129,7 @@ static int hdsp_set_da_gain(struct hdsp *hdsp, int mode) return 0; } -static int snd_hdsp_info_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_da_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"Hi Gain", "+4 dBu", "-10 dbV"}; @@ -2138,17 +2142,17 @@ static int snd_hdsp_info_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_hdsp_get_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_da_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_da_gain(hdsp); return 0; } -static int snd_hdsp_put_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_da_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; int val; @@ -2175,7 +2179,7 @@ static int snd_hdsp_put_da_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_el .put = snd_hdsp_put_ad_gain \ } -static int hdsp_ad_gain(struct hdsp *hdsp) +static int hdsp_ad_gain(hdsp_t *hdsp) { switch (hdsp->control_register & HDSP_ADGainMask) { case HDSP_ADGainMinus10dBV: @@ -2189,7 +2193,7 @@ static int hdsp_ad_gain(struct hdsp *hdsp) } } -static int hdsp_set_ad_gain(struct hdsp *hdsp, int mode) +static int hdsp_set_ad_gain(hdsp_t *hdsp, int mode) { hdsp->control_register &= ~HDSP_ADGainMask; switch (mode) { @@ -2210,7 +2214,7 @@ static int hdsp_set_ad_gain(struct hdsp *hdsp, int mode) return 0; } -static int snd_hdsp_info_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_ad_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"-10 dBV", "+4 dBu", "Lo Gain"}; @@ -2223,17 +2227,17 @@ static int snd_hdsp_info_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_hdsp_get_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_ad_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_ad_gain(hdsp); return 0; } -static int snd_hdsp_put_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_ad_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; int val; @@ -2260,7 +2264,7 @@ static int snd_hdsp_put_ad_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_el .put = snd_hdsp_put_phone_gain \ } -static int hdsp_phone_gain(struct hdsp *hdsp) +static int hdsp_phone_gain(hdsp_t *hdsp) { switch (hdsp->control_register & HDSP_PhoneGainMask) { case HDSP_PhoneGain0dB: @@ -2274,7 +2278,7 @@ static int hdsp_phone_gain(struct hdsp *hdsp) } } -static int hdsp_set_phone_gain(struct hdsp *hdsp, int mode) +static int hdsp_set_phone_gain(hdsp_t *hdsp, int mode) { hdsp->control_register &= ~HDSP_PhoneGainMask; switch (mode) { @@ -2295,7 +2299,7 @@ static int hdsp_set_phone_gain(struct hdsp *hdsp, int mode) return 0; } -static int snd_hdsp_info_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_phone_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"0 dB", "-6 dB", "-12 dB"}; @@ -2308,17 +2312,17 @@ static int snd_hdsp_info_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_hdsp_get_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_phone_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_phone_gain(hdsp); return 0; } -static int snd_hdsp_put_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_phone_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; int val; @@ -2345,14 +2349,14 @@ static int snd_hdsp_put_phone_gain(struct snd_kcontrol *kcontrol, struct snd_ctl .put = snd_hdsp_put_xlr_breakout_cable \ } -static int hdsp_xlr_breakout_cable(struct hdsp *hdsp) +static int hdsp_xlr_breakout_cable(hdsp_t *hdsp) { if (hdsp->control_register & HDSP_XLRBreakoutCable) return 1; return 0; } -static int hdsp_set_xlr_breakout_cable(struct hdsp *hdsp, int mode) +static int hdsp_set_xlr_breakout_cable(hdsp_t *hdsp, int mode) { if (mode) hdsp->control_register |= HDSP_XLRBreakoutCable; @@ -2362,7 +2366,7 @@ static int hdsp_set_xlr_breakout_cable(struct hdsp *hdsp, int mode) return 0; } -static int snd_hdsp_info_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_xlr_breakout_cable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2371,17 +2375,17 @@ static int snd_hdsp_info_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struc return 0; } -static int snd_hdsp_get_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_xlr_breakout_cable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_xlr_breakout_cable(hdsp); return 0; } -static int snd_hdsp_put_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_xlr_breakout_cable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; int val; @@ -2408,14 +2412,14 @@ static int snd_hdsp_put_xlr_breakout_cable(struct snd_kcontrol *kcontrol, struct .put = snd_hdsp_put_aeb \ } -static int hdsp_aeb(struct hdsp *hdsp) +static int hdsp_aeb(hdsp_t *hdsp) { if (hdsp->control_register & HDSP_AnalogExtensionBoard) return 1; return 0; } -static int hdsp_set_aeb(struct hdsp *hdsp, int mode) +static int hdsp_set_aeb(hdsp_t *hdsp, int mode) { if (mode) hdsp->control_register |= HDSP_AnalogExtensionBoard; @@ -2425,7 +2429,7 @@ static int hdsp_set_aeb(struct hdsp *hdsp, int mode) return 0; } -static int snd_hdsp_info_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_aeb(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2434,17 +2438,17 @@ static int snd_hdsp_info_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int snd_hdsp_get_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_aeb(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_aeb(hdsp); return 0; } -static int snd_hdsp_put_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_aeb(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; int val; @@ -2467,7 +2471,7 @@ static int snd_hdsp_put_aeb(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v .put = snd_hdsp_put_pref_sync_ref \ } -static int hdsp_pref_sync_ref(struct hdsp *hdsp) +static int hdsp_pref_sync_ref(hdsp_t *hdsp) { /* Notice that this looks at the requested sync source, not the one actually in use. @@ -2492,7 +2496,7 @@ static int hdsp_pref_sync_ref(struct hdsp *hdsp) return 0; } -static int hdsp_set_pref_sync_ref(struct hdsp *hdsp, int pref) +static int hdsp_set_pref_sync_ref(hdsp_t *hdsp, int pref) { hdsp->control_register &= ~HDSP_SyncRefMask; switch (pref) { @@ -2521,10 +2525,10 @@ static int hdsp_set_pref_sync_ref(struct hdsp *hdsp, int pref) return 0; } -static int snd_hdsp_info_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_pref_sync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"Word", "IEC958", "ADAT1", "ADAT Sync", "ADAT2", "ADAT3" }; - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -2551,17 +2555,17 @@ static int snd_hdsp_info_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_hdsp_get_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp); return 0; } -static int snd_hdsp_put_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change, max; unsigned int val; @@ -2600,7 +2604,7 @@ static int snd_hdsp_put_pref_sync_ref(struct snd_kcontrol *kcontrol, struct snd_ .get = snd_hdsp_get_autosync_ref, \ } -static int hdsp_autosync_ref(struct hdsp *hdsp) +static int hdsp_autosync_ref(hdsp_t *hdsp) { /* This looks at the autosync selected sync reference */ unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register); @@ -2626,7 +2630,7 @@ static int hdsp_autosync_ref(struct hdsp *hdsp) return 0; } -static int snd_hdsp_info_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_autosync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"Word", "ADAT Sync", "IEC958", "None", "ADAT1", "ADAT2", "ADAT3" }; @@ -2639,9 +2643,9 @@ static int snd_hdsp_info_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_hdsp_get_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_autosync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_autosync_ref(hdsp); return 0; @@ -2656,12 +2660,12 @@ static int snd_hdsp_get_autosync_ref(struct snd_kcontrol *kcontrol, struct snd_c .put = snd_hdsp_put_line_out \ } -static int hdsp_line_out(struct hdsp *hdsp) +static int hdsp_line_out(hdsp_t *hdsp) { return (hdsp->control_register & HDSP_LineOut) ? 1 : 0; } -static int hdsp_set_line_output(struct hdsp *hdsp, int out) +static int hdsp_set_line_output(hdsp_t *hdsp, int out) { if (out) hdsp->control_register |= HDSP_LineOut; @@ -2671,7 +2675,7 @@ static int hdsp_set_line_output(struct hdsp *hdsp, int out) return 0; } -static int snd_hdsp_info_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_line_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2680,9 +2684,9 @@ static int snd_hdsp_info_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_hdsp_get_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_line_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdsp->lock); ucontrol->value.integer.value[0] = hdsp_line_out(hdsp); @@ -2690,9 +2694,9 @@ static int snd_hdsp_get_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_hdsp_put_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_line_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -2715,7 +2719,7 @@ static int snd_hdsp_put_line_out(struct snd_kcontrol *kcontrol, struct snd_ctl_e .put = snd_hdsp_put_precise_pointer \ } -static int hdsp_set_precise_pointer(struct hdsp *hdsp, int precise) +static int hdsp_set_precise_pointer(hdsp_t *hdsp, int precise) { if (precise) hdsp->precise_ptr = 1; @@ -2724,7 +2728,7 @@ static int hdsp_set_precise_pointer(struct hdsp *hdsp, int precise) return 0; } -static int snd_hdsp_info_precise_pointer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_precise_pointer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2733,9 +2737,9 @@ static int snd_hdsp_info_precise_pointer(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_hdsp_get_precise_pointer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_precise_pointer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdsp->lock); ucontrol->value.integer.value[0] = hdsp->precise_ptr; @@ -2743,9 +2747,9 @@ static int snd_hdsp_get_precise_pointer(struct snd_kcontrol *kcontrol, struct sn return 0; } -static int snd_hdsp_put_precise_pointer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_precise_pointer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -2768,7 +2772,7 @@ static int snd_hdsp_put_precise_pointer(struct snd_kcontrol *kcontrol, struct sn .put = snd_hdsp_put_use_midi_tasklet \ } -static int hdsp_set_use_midi_tasklet(struct hdsp *hdsp, int use_tasklet) +static int hdsp_set_use_midi_tasklet(hdsp_t *hdsp, int use_tasklet) { if (use_tasklet) hdsp->use_midi_tasklet = 1; @@ -2777,7 +2781,7 @@ static int hdsp_set_use_midi_tasklet(struct hdsp *hdsp, int use_tasklet) return 0; } -static int snd_hdsp_info_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_use_midi_tasklet(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2786,9 +2790,9 @@ static int snd_hdsp_info_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct return 0; } -static int snd_hdsp_get_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_use_midi_tasklet(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdsp->lock); ucontrol->value.integer.value[0] = hdsp->use_midi_tasklet; @@ -2796,9 +2800,9 @@ static int snd_hdsp_get_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct s return 0; } -static int snd_hdsp_put_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_use_midi_tasklet(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -2824,7 +2828,7 @@ static int snd_hdsp_put_use_midi_tasklet(struct snd_kcontrol *kcontrol, struct s .put = snd_hdsp_put_mixer \ } -static int snd_hdsp_info_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_mixer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 3; @@ -2834,9 +2838,9 @@ static int snd_hdsp_info_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int snd_hdsp_get_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int source; int destination; int addr; @@ -2855,9 +2859,9 @@ static int snd_hdsp_get_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int snd_hdsp_put_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_put_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); int change; int source; int destination; @@ -2894,7 +2898,7 @@ static int snd_hdsp_put_mixer(struct snd_kcontrol *kcontrol, struct snd_ctl_elem .get = snd_hdsp_get_wc_sync_check \ } -static int snd_hdsp_info_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_hdsp_info_sync_check(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[] = {"No Lock", "Lock", "Sync" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -2906,7 +2910,7 @@ static int snd_hdsp_info_sync_check(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int hdsp_wc_sync_check(struct hdsp *hdsp) +static int hdsp_wc_sync_check(hdsp_t *hdsp) { int status2 = hdsp_read(hdsp, HDSP_status2Register); if (status2 & HDSP_wc_lock) { @@ -2919,9 +2923,9 @@ static int hdsp_wc_sync_check(struct hdsp *hdsp) return 0; } -static int snd_hdsp_get_wc_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_wc_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_wc_sync_check(hdsp); return 0; @@ -2936,7 +2940,7 @@ static int snd_hdsp_get_wc_sync_check(struct snd_kcontrol *kcontrol, struct snd_ .get = snd_hdsp_get_spdif_sync_check \ } -static int hdsp_spdif_sync_check(struct hdsp *hdsp) +static int hdsp_spdif_sync_check(hdsp_t *hdsp) { int status = hdsp_read(hdsp, HDSP_statusRegister); if (status & HDSP_SPDIFErrorFlag) @@ -2950,9 +2954,9 @@ static int hdsp_spdif_sync_check(struct hdsp *hdsp) return 0; } -static int snd_hdsp_get_spdif_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_spdif_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_spdif_sync_check(hdsp); return 0; @@ -2967,7 +2971,7 @@ static int snd_hdsp_get_spdif_sync_check(struct snd_kcontrol *kcontrol, struct s .get = snd_hdsp_get_adatsync_sync_check \ } -static int hdsp_adatsync_sync_check(struct hdsp *hdsp) +static int hdsp_adatsync_sync_check(hdsp_t *hdsp) { int status = hdsp_read(hdsp, HDSP_statusRegister); if (status & HDSP_TimecodeLock) { @@ -2979,9 +2983,9 @@ static int hdsp_adatsync_sync_check(struct hdsp *hdsp) return 0; } -static int snd_hdsp_get_adatsync_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_adatsync_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdsp_adatsync_sync_check(hdsp); return 0; @@ -2994,7 +2998,7 @@ static int snd_hdsp_get_adatsync_sync_check(struct snd_kcontrol *kcontrol, struc .get = snd_hdsp_get_adat_sync_check \ } -static int hdsp_adat_sync_check(struct hdsp *hdsp, int idx) +static int hdsp_adat_sync_check(hdsp_t *hdsp, int idx) { int status = hdsp_read(hdsp, HDSP_statusRegister); @@ -3007,10 +3011,10 @@ static int hdsp_adat_sync_check(struct hdsp *hdsp, int idx) return 0; } -static int snd_hdsp_get_adat_sync_check(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_hdsp_get_adat_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { int offset; - struct hdsp *hdsp = snd_kcontrol_chip(kcontrol); + hdsp_t *hdsp = snd_kcontrol_chip(kcontrol); offset = ucontrol->id.index - 1; snd_assert(offset >= 0); @@ -3034,14 +3038,14 @@ static int snd_hdsp_get_adat_sync_check(struct snd_kcontrol *kcontrol, struct sn return 0; } -static struct snd_kcontrol_new snd_hdsp_9632_controls[] = { +static snd_kcontrol_new_t snd_hdsp_9632_controls[] = { HDSP_DA_GAIN("DA Gain", 0), HDSP_AD_GAIN("AD Gain", 0), HDSP_PHONE_GAIN("Phones Gain", 0), HDSP_XLR_BREAKOUT_CABLE("XLR Breakout Cable", 0) }; -static struct snd_kcontrol_new snd_hdsp_controls[] = { +static snd_kcontrol_new_t snd_hdsp_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -3107,14 +3111,14 @@ HDSP_PRECISE_POINTER("Precise Pointer", 0), HDSP_USE_MIDI_TASKLET("Use Midi Tasklet", 0), }; -static struct snd_kcontrol_new snd_hdsp_96xx_aeb = HDSP_AEB("Analog Extension Board", 0); -static struct snd_kcontrol_new snd_hdsp_adat_sync_check = HDSP_ADAT_SYNC_CHECK; +static snd_kcontrol_new_t snd_hdsp_96xx_aeb = HDSP_AEB("Analog Extension Board", 0); +static snd_kcontrol_new_t snd_hdsp_adat_sync_check = HDSP_ADAT_SYNC_CHECK; -static int snd_hdsp_create_controls(struct snd_card *card, struct hdsp *hdsp) +static int snd_hdsp_create_controls(snd_card_t *card, hdsp_t *hdsp) { unsigned int idx; int err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; for (idx = 0; idx < ARRAY_SIZE(snd_hdsp_controls); idx++) { if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_controls[idx], hdsp))) < 0) @@ -3158,9 +3162,9 @@ static int snd_hdsp_create_controls(struct snd_card *card, struct hdsp *hdsp) ------------------------------------------------------------*/ static void -snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +snd_hdsp_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct hdsp *hdsp = (struct hdsp *) entry->private_data; + hdsp_t *hdsp = (hdsp_t *) entry->private_data; unsigned int status; unsigned int status2; char *pref_sync_ref; @@ -3465,21 +3469,21 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) } -static void __devinit snd_hdsp_proc_init(struct hdsp *hdsp) +static void __devinit snd_hdsp_proc_init(hdsp_t *hdsp) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(hdsp->card, "hdsp", &entry)) snd_info_set_text_ops(entry, hdsp, 1024, snd_hdsp_proc_read); } -static void snd_hdsp_free_buffers(struct hdsp *hdsp) +static void snd_hdsp_free_buffers(hdsp_t *hdsp) { snd_hammerfall_free_buffer(&hdsp->capture_dma_buf, hdsp->pci); snd_hammerfall_free_buffer(&hdsp->playback_dma_buf, hdsp->pci); } -static int __devinit snd_hdsp_initialize_memory(struct hdsp *hdsp) +static int __devinit snd_hdsp_initialize_memory(hdsp_t *hdsp) { unsigned long pb_bus, cb_bus; @@ -3507,7 +3511,7 @@ static int __devinit snd_hdsp_initialize_memory(struct hdsp *hdsp) return 0; } -static int snd_hdsp_set_defaults(struct hdsp *hdsp) +static int snd_hdsp_set_defaults(hdsp_t *hdsp) { unsigned int i; @@ -3572,7 +3576,7 @@ static int snd_hdsp_set_defaults(struct hdsp *hdsp) static void hdsp_midi_tasklet(unsigned long arg) { - struct hdsp *hdsp = (struct hdsp *)arg; + hdsp_t *hdsp = (hdsp_t *)arg; if (hdsp->midi[0].pending) snd_hdsp_midi_input_read (&hdsp->midi[0]); @@ -3582,7 +3586,7 @@ static void hdsp_midi_tasklet(unsigned long arg) static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct hdsp *hdsp = (struct hdsp *) dev_id; + hdsp_t *hdsp = (hdsp_t *) dev_id; unsigned int status; int audio; int midi0; @@ -3640,13 +3644,13 @@ static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *reg return IRQ_HANDLED; } -static snd_pcm_uframes_t snd_hdsp_hw_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_hdsp_hw_pointer(snd_pcm_substream_t *substream) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); return hdsp_hw_pointer(hdsp); } -static char *hdsp_channel_buffer_location(struct hdsp *hdsp, +static char *hdsp_channel_buffer_location(hdsp_t *hdsp, int stream, int channel) @@ -3664,10 +3668,10 @@ static char *hdsp_channel_buffer_location(struct hdsp *hdsp, return hdsp->playback_buffer + (mapped_channel * HDSP_CHANNEL_BUFFER_BYTES); } -static int snd_hdsp_playback_copy(struct snd_pcm_substream *substream, int channel, +static int snd_hdsp_playback_copy(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); char *channel_buf; snd_assert(pos + count <= HDSP_CHANNEL_BUFFER_BYTES / 4, return -EINVAL); @@ -3679,10 +3683,10 @@ static int snd_hdsp_playback_copy(struct snd_pcm_substream *substream, int chann return count; } -static int snd_hdsp_capture_copy(struct snd_pcm_substream *substream, int channel, +static int snd_hdsp_capture_copy(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); char *channel_buf; snd_assert(pos + count <= HDSP_CHANNEL_BUFFER_BYTES / 4, return -EINVAL); @@ -3694,10 +3698,10 @@ static int snd_hdsp_capture_copy(struct snd_pcm_substream *substream, int channe return count; } -static int snd_hdsp_hw_silence(struct snd_pcm_substream *substream, int channel, +static int snd_hdsp_hw_silence(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); char *channel_buf; channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel); @@ -3706,11 +3710,11 @@ static int snd_hdsp_hw_silence(struct snd_pcm_substream *substream, int channel, return count; } -static int snd_hdsp_reset(struct snd_pcm_substream *substream) +static int snd_hdsp_reset(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct hdsp *hdsp = snd_pcm_substream_chip(substream); - struct snd_pcm_substream *other; + snd_pcm_runtime_t *runtime = substream->runtime; + hdsp_t *hdsp = snd_pcm_substream_chip(substream); + snd_pcm_substream_t *other; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) other = hdsp->capture_substream; else @@ -3721,8 +3725,8 @@ static int snd_hdsp_reset(struct snd_pcm_substream *substream) runtime->status->hw_ptr = 0; if (other) { struct list_head *pos; - struct snd_pcm_substream *s; - struct snd_pcm_runtime *oruntime = other->runtime; + snd_pcm_substream_t *s; + snd_pcm_runtime_t *oruntime = other->runtime; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == other) { @@ -3734,10 +3738,10 @@ static int snd_hdsp_reset(struct snd_pcm_substream *substream) return 0; } -static int snd_hdsp_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +static int snd_hdsp_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); int err; pid_t this_pid; pid_t other_pid; @@ -3809,10 +3813,10 @@ static int snd_hdsp_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_hdsp_channel_info(struct snd_pcm_substream *substream, - struct snd_pcm_channel_info *info) +static int snd_hdsp_channel_info(snd_pcm_substream_t *substream, + snd_pcm_channel_info_t *info) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); int mapped_channel; snd_assert(info->channel < hdsp->max_channels, return -EINVAL); @@ -3826,7 +3830,7 @@ static int snd_hdsp_channel_info(struct snd_pcm_substream *substream, return 0; } -static int snd_hdsp_ioctl(struct snd_pcm_substream *substream, +static int snd_hdsp_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg) { switch (cmd) { @@ -3841,10 +3845,10 @@ static int snd_hdsp_ioctl(struct snd_pcm_substream *substream, return snd_pcm_lib_ioctl(substream, cmd, arg); } -static int snd_hdsp_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_hdsp_trigger(snd_pcm_substream_t *substream, int cmd) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); - struct snd_pcm_substream *other; + hdsp_t *hdsp = snd_pcm_substream_chip(substream); + snd_pcm_substream_t *other; int running; if (hdsp_check_for_iobox (hdsp)) @@ -3874,7 +3878,7 @@ static int snd_hdsp_trigger(struct snd_pcm_substream *substream, int cmd) if (other) { struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == other) { @@ -3911,9 +3915,9 @@ static int snd_hdsp_trigger(struct snd_pcm_substream *substream, int cmd) return 0; } -static int snd_hdsp_prepare(struct snd_pcm_substream *substream) +static int snd_hdsp_prepare(snd_pcm_substream_t *substream) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); int result = 0; if (hdsp_check_for_iobox (hdsp)) @@ -3929,7 +3933,7 @@ static int snd_hdsp_prepare(struct snd_pcm_substream *substream) return result; } -static struct snd_pcm_hardware snd_hdsp_playback_subinfo = +static snd_pcm_hardware_t snd_hdsp_playback_subinfo = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -3959,7 +3963,7 @@ static struct snd_pcm_hardware snd_hdsp_playback_subinfo = .fifo_size = 0 }; -static struct snd_pcm_hardware snd_hdsp_capture_subinfo = +static snd_pcm_hardware_t snd_hdsp_capture_subinfo = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -3990,7 +3994,7 @@ static struct snd_pcm_hardware snd_hdsp_capture_subinfo = static unsigned int hdsp_period_sizes[] = { 64, 128, 256, 512, 1024, 2048, 4096, 8192 }; -static struct snd_pcm_hw_constraint_list hdsp_hw_constraints_period_sizes = { +static snd_pcm_hw_constraint_list_t hdsp_hw_constraints_period_sizes = { .count = ARRAY_SIZE(hdsp_period_sizes), .list = hdsp_period_sizes, .mask = 0 @@ -3998,17 +4002,17 @@ static struct snd_pcm_hw_constraint_list hdsp_hw_constraints_period_sizes = { static unsigned int hdsp_9632_sample_rates[] = { 32000, 44100, 48000, 64000, 88200, 96000, 128000, 176400, 192000 }; -static struct snd_pcm_hw_constraint_list hdsp_hw_constraints_9632_sample_rates = { +static snd_pcm_hw_constraint_list_t hdsp_hw_constraints_9632_sample_rates = { .count = ARRAY_SIZE(hdsp_9632_sample_rates), .list = hdsp_9632_sample_rates, .mask = 0 }; -static int snd_hdsp_hw_rule_in_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_hdsp_hw_rule_in_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct hdsp *hdsp = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + hdsp_t *hdsp = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); if (hdsp->io_type == H9632) { unsigned int list[3]; list[0] = hdsp->qs_in_channels; @@ -4023,12 +4027,12 @@ static int snd_hdsp_hw_rule_in_channels(struct snd_pcm_hw_params *params, } } -static int snd_hdsp_hw_rule_out_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_hdsp_hw_rule_out_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { unsigned int list[3]; - struct hdsp *hdsp = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + hdsp_t *hdsp = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); if (hdsp->io_type == H9632) { list[0] = hdsp->qs_out_channels; list[1] = hdsp->ds_out_channels; @@ -4041,28 +4045,28 @@ static int snd_hdsp_hw_rule_out_channels(struct snd_pcm_hw_params *params, return snd_interval_list(c, 2, list, 0); } -static int snd_hdsp_hw_rule_in_channels_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_hdsp_hw_rule_in_channels_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct hdsp *hdsp = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + hdsp_t *hdsp = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (r->min > 96000 && hdsp->io_type == H9632) { - struct snd_interval t = { + snd_interval_t t = { .min = hdsp->qs_in_channels, .max = hdsp->qs_in_channels, .integer = 1, }; return snd_interval_refine(c, &t); } else if (r->min > 48000 && r->max <= 96000) { - struct snd_interval t = { + snd_interval_t t = { .min = hdsp->ds_in_channels, .max = hdsp->ds_in_channels, .integer = 1, }; return snd_interval_refine(c, &t); } else if (r->max < 64000) { - struct snd_interval t = { + snd_interval_t t = { .min = hdsp->ss_in_channels, .max = hdsp->ss_in_channels, .integer = 1, @@ -4072,28 +4076,28 @@ static int snd_hdsp_hw_rule_in_channels_rate(struct snd_pcm_hw_params *params, return 0; } -static int snd_hdsp_hw_rule_out_channels_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_hdsp_hw_rule_out_channels_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct hdsp *hdsp = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + hdsp_t *hdsp = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (r->min > 96000 && hdsp->io_type == H9632) { - struct snd_interval t = { + snd_interval_t t = { .min = hdsp->qs_out_channels, .max = hdsp->qs_out_channels, .integer = 1, }; return snd_interval_refine(c, &t); } else if (r->min > 48000 && r->max <= 96000) { - struct snd_interval t = { + snd_interval_t t = { .min = hdsp->ds_out_channels, .max = hdsp->ds_out_channels, .integer = 1, }; return snd_interval_refine(c, &t); } else if (r->max < 64000) { - struct snd_interval t = { + snd_interval_t t = { .min = hdsp->ss_out_channels, .max = hdsp->ss_out_channels, .integer = 1, @@ -4103,28 +4107,28 @@ static int snd_hdsp_hw_rule_out_channels_rate(struct snd_pcm_hw_params *params, return 0; } -static int snd_hdsp_hw_rule_rate_out_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_hdsp_hw_rule_rate_out_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct hdsp *hdsp = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + hdsp_t *hdsp = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (c->min >= hdsp->ss_out_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 32000, .max = 48000, .integer = 1, }; return snd_interval_refine(r, &t); } else if (c->max <= hdsp->qs_out_channels && hdsp->io_type == H9632) { - struct snd_interval t = { + snd_interval_t t = { .min = 128000, .max = 192000, .integer = 1, }; return snd_interval_refine(r, &t); } else if (c->max <= hdsp->ds_out_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 64000, .max = 96000, .integer = 1, @@ -4134,28 +4138,28 @@ static int snd_hdsp_hw_rule_rate_out_channels(struct snd_pcm_hw_params *params, return 0; } -static int snd_hdsp_hw_rule_rate_in_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_hdsp_hw_rule_rate_in_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct hdsp *hdsp = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + hdsp_t *hdsp = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (c->min >= hdsp->ss_in_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 32000, .max = 48000, .integer = 1, }; return snd_interval_refine(r, &t); } else if (c->max <= hdsp->qs_in_channels && hdsp->io_type == H9632) { - struct snd_interval t = { + snd_interval_t t = { .min = 128000, .max = 192000, .integer = 1, }; return snd_interval_refine(r, &t); } else if (c->max <= hdsp->ds_in_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 64000, .max = 96000, .integer = 1, @@ -4165,10 +4169,10 @@ static int snd_hdsp_hw_rule_rate_in_channels(struct snd_pcm_hw_params *params, return 0; } -static int snd_hdsp_playback_open(struct snd_pcm_substream *substream) +static int snd_hdsp_playback_open(snd_pcm_substream_t *substream) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + hdsp_t *hdsp = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (hdsp_check_for_iobox (hdsp)) return -EIO; @@ -4220,9 +4224,9 @@ static int snd_hdsp_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_hdsp_playback_release(struct snd_pcm_substream *substream) +static int snd_hdsp_playback_release(snd_pcm_substream_t *substream) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); spin_lock_irq(&hdsp->lock); @@ -4238,10 +4242,10 @@ static int snd_hdsp_playback_release(struct snd_pcm_substream *substream) } -static int snd_hdsp_capture_open(struct snd_pcm_substream *substream) +static int snd_hdsp_capture_open(snd_pcm_substream_t *substream) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + hdsp_t *hdsp = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; if (hdsp_check_for_iobox (hdsp)) return -EIO; @@ -4283,9 +4287,9 @@ static int snd_hdsp_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_hdsp_capture_release(struct snd_pcm_substream *substream) +static int snd_hdsp_capture_release(snd_pcm_substream_t *substream) { - struct hdsp *hdsp = snd_pcm_substream_chip(substream); + hdsp_t *hdsp = snd_pcm_substream_chip(substream); spin_lock_irq(&hdsp->lock); @@ -4296,7 +4300,7 @@ static int snd_hdsp_capture_release(struct snd_pcm_substream *substream) return 0; } -static int snd_hdsp_hwdep_dummy_op(struct snd_hwdep *hw, struct file *file) +static int snd_hdsp_hwdep_dummy_op(snd_hwdep_t *hw, struct file *file) { /* we have nothing to initialize but the call is required */ return 0; @@ -4330,7 +4334,7 @@ static inline int copy_u48_le(void __user *dest, void __iomem *src_low, void __i return copy_to_user(dest, &rms, 8); } -static int hdsp_9652_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rms) +static int hdsp_9652_get_peak(hdsp_t *hdsp, hdsp_peak_rms_t __user *peak_rms) { int doublespeed = 0; int i, j, channels, ofs; @@ -4367,15 +4371,15 @@ static int hdsp_9652_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *pe return 0; } -static int hdsp_9632_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rms) +static int hdsp_9632_get_peak(hdsp_t *hdsp, hdsp_peak_rms_t __user *peak_rms) { int i, j; - struct hdsp_9632_meters __iomem *m; + hdsp_9632_meters_t __iomem *m; int doublespeed = 0; if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DoubleSpeedStatus) doublespeed = 1; - m = (struct hdsp_9632_meters __iomem *)(hdsp->iobase+HDSP_9632_metersBase); + m = (hdsp_9632_meters_t __iomem *)(hdsp->iobase+HDSP_9632_metersBase); for (i = 0, j = 0; i < 16; ++i, ++j) { if (copy_u32_le(&peak_rms->input_peaks[i], &m->input_peak[j])) return -EFAULT; @@ -4397,7 +4401,7 @@ static int hdsp_9632_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *pe return 0; } -static int hdsp_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rms) +static int hdsp_get_peak(hdsp_t *hdsp, hdsp_peak_rms_t __user *peak_rms) { int i; @@ -4427,14 +4431,14 @@ static int hdsp_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rm return 0; } -static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigned int cmd, unsigned long arg) +static int snd_hdsp_hwdep_ioctl(snd_hwdep_t *hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct hdsp *hdsp = (struct hdsp *)hw->private_data; + hdsp_t *hdsp = (hdsp_t *)hw->private_data; void __user *argp = (void __user *)arg; switch (cmd) { case SNDRV_HDSP_IOCTL_GET_PEAK_RMS: { - struct hdsp_peak_rms __user *peak_rms = (struct hdsp_peak_rms __user *)arg; + hdsp_peak_rms_t __user *peak_rms = (hdsp_peak_rms_t __user *)arg; if (!(hdsp->state & HDSP_FirmwareLoaded)) { snd_printk(KERN_ERR "Hammerfall-DSP: firmware needs to be uploaded to the card.\n"); @@ -4451,7 +4455,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne } } case SNDRV_HDSP_IOCTL_GET_CONFIG_INFO: { - struct hdsp_config_info info; + hdsp_config_info_t info; unsigned long flags; int i; @@ -4494,7 +4498,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne break; } case SNDRV_HDSP_IOCTL_GET_9632_AEB: { - struct hdsp_9632_aeb h9632_aeb; + hdsp_9632_aeb_t h9632_aeb; if (hdsp->io_type != H9632) return -EINVAL; h9632_aeb.aebi = hdsp->ss_in_channels - H9632_SS_CHANNELS; @@ -4504,7 +4508,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne break; } case SNDRV_HDSP_IOCTL_GET_VERSION: { - struct hdsp_version hdsp_version; + hdsp_version_t hdsp_version; int err; if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return -EINVAL; @@ -4519,7 +4523,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne break; } case SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE: { - struct hdsp_firmware __user *firmware; + hdsp_firmware_t __user *firmware; u32 __user *firmware_data; int err; @@ -4531,7 +4535,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne return -EBUSY; snd_printk(KERN_INFO "Hammerfall-DSP: initializing firmware upload\n"); - firmware = (struct hdsp_firmware __user *)argp; + firmware = (hdsp_firmware_t __user *)argp; if (get_user(firmware_data, &firmware->firmware_data)) return -EFAULT; @@ -4562,7 +4566,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne break; } case SNDRV_HDSP_IOCTL_GET_MIXER: { - struct hdsp_mixer __user *mixer = (struct hdsp_mixer __user *)argp; + hdsp_mixer_t __user *mixer = (hdsp_mixer_t __user *)argp; if (copy_to_user(mixer->matrix, hdsp->mixer_matrix, sizeof(unsigned short)*HDSP_MATRIX_MIXER_SIZE)) return -EFAULT; break; @@ -4573,7 +4577,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne return 0; } -static struct snd_pcm_ops snd_hdsp_playback_ops = { +static snd_pcm_ops_t snd_hdsp_playback_ops = { .open = snd_hdsp_playback_open, .close = snd_hdsp_playback_release, .ioctl = snd_hdsp_ioctl, @@ -4585,7 +4589,7 @@ static struct snd_pcm_ops snd_hdsp_playback_ops = { .silence = snd_hdsp_hw_silence, }; -static struct snd_pcm_ops snd_hdsp_capture_ops = { +static snd_pcm_ops_t snd_hdsp_capture_ops = { .open = snd_hdsp_capture_open, .close = snd_hdsp_capture_release, .ioctl = snd_hdsp_ioctl, @@ -4596,10 +4600,10 @@ static struct snd_pcm_ops snd_hdsp_capture_ops = { .copy = snd_hdsp_capture_copy, }; -static int __devinit snd_hdsp_create_hwdep(struct snd_card *card, - struct hdsp *hdsp) +static int __devinit snd_hdsp_create_hwdep(snd_card_t *card, + hdsp_t *hdsp) { - struct snd_hwdep *hw; + snd_hwdep_t *hw; int err; if ((err = snd_hwdep_new(card, "HDSP hwdep", 0, &hw)) < 0) @@ -4616,9 +4620,9 @@ static int __devinit snd_hdsp_create_hwdep(struct snd_card *card, return 0; } -static int snd_hdsp_create_pcm(struct snd_card *card, struct hdsp *hdsp) +static int snd_hdsp_create_pcm(snd_card_t *card, hdsp_t *hdsp) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(card, hdsp->card_name, 0, 1, 1, &pcm)) < 0) @@ -4636,13 +4640,13 @@ static int snd_hdsp_create_pcm(struct snd_card *card, struct hdsp *hdsp) return 0; } -static void snd_hdsp_9652_enable_mixer (struct hdsp *hdsp) +static void snd_hdsp_9652_enable_mixer (hdsp_t *hdsp) { hdsp->control2_register |= HDSP_9652_ENABLE_MIXER; hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register); } -static int snd_hdsp_enable_io (struct hdsp *hdsp) +static int snd_hdsp_enable_io (hdsp_t *hdsp) { int i; @@ -4659,7 +4663,7 @@ static int snd_hdsp_enable_io (struct hdsp *hdsp) return 0; } -static void snd_hdsp_initialize_channels(struct hdsp *hdsp) +static void snd_hdsp_initialize_channels(hdsp_t *hdsp) { int status, aebi_channels, aebo_channels; @@ -4702,13 +4706,13 @@ static void snd_hdsp_initialize_channels(struct hdsp *hdsp) } } -static void snd_hdsp_initialize_midi_flush (struct hdsp *hdsp) +static void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp) { snd_hdsp_flush_midi_input (hdsp, 0); snd_hdsp_flush_midi_input (hdsp, 1); } -static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp) +static int snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp) { int err; @@ -4765,7 +4769,7 @@ static int snd_hdsp_create_alsa_devices(struct snd_card *card, struct hdsp *hdsp #ifdef HDSP_FW_LOADER /* load firmware via hotplug fw loader */ -static int __devinit hdsp_request_fw_loader(struct hdsp *hdsp) +static int __devinit hdsp_request_fw_loader(hdsp_t *hdsp) { const char *fwfile; const struct firmware *fw; @@ -4838,8 +4842,8 @@ static int __devinit hdsp_request_fw_loader(struct hdsp *hdsp) } #endif -static int __devinit snd_hdsp_create(struct snd_card *card, - struct hdsp *hdsp) +static int __devinit snd_hdsp_create(snd_card_t *card, + hdsp_t *hdsp) { struct pci_dev *pci = hdsp->pci; int err; @@ -4976,7 +4980,7 @@ static int __devinit snd_hdsp_create(struct snd_card *card, return 0; } -static int snd_hdsp_free(struct hdsp *hdsp) +static int snd_hdsp_free(hdsp_t *hdsp) { if (hdsp->port) { /* stop the audio, and cancel all interrupts */ @@ -5000,9 +5004,9 @@ static int snd_hdsp_free(struct hdsp *hdsp) return 0; } -static void snd_hdsp_card_free(struct snd_card *card) +static void snd_hdsp_card_free(snd_card_t *card) { - struct hdsp *hdsp = (struct hdsp *) card->private_data; + hdsp_t *hdsp = (hdsp_t *) card->private_data; if (hdsp) snd_hdsp_free(hdsp); @@ -5012,8 +5016,8 @@ static int __devinit snd_hdsp_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct hdsp *hdsp; - struct snd_card *card; + hdsp_t *hdsp; + snd_card_t *card; int err; if (dev >= SNDRV_CARDS) @@ -5023,10 +5027,10 @@ static int __devinit snd_hdsp_probe(struct pci_dev *pci, return -ENOENT; } - if (!(card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct hdsp)))) + if (!(card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(hdsp_t)))) return -ENOMEM; - hdsp = (struct hdsp *) card->private_data; + hdsp = (hdsp_t *) card->private_data; card->private_free = snd_hdsp_card_free; hdsp->dev = dev; hdsp->pci = pci; diff --git a/trunk/sound/pci/rme9652/hdspm.c b/trunk/sound/pci/rme9652/hdspm.c index 3dec616bad6b..a1aef6f6767e 100644 --- a/trunk/sound/pci/rme9652/hdspm.c +++ b/trunk/sound/pci/rme9652/hdspm.c @@ -318,22 +318,25 @@ MODULE_SUPPORTED_DEVICE("{{RME HDSPM-MADI}}"); #define HDSPM_DMA_AREA_BYTES (HDSPM_MAX_CHANNELS * HDSPM_CHANNEL_BUFFER_BYTES) #define HDSPM_DMA_AREA_KILOBYTES (HDSPM_DMA_AREA_BYTES/1024) -struct hdspm_midi { - struct hdspm *hdspm; +typedef struct _hdspm hdspm_t; +typedef struct _hdspm_midi hdspm_midi_t; + +struct _hdspm_midi { + hdspm_t *hdspm; int id; - struct snd_rawmidi *rmidi; - struct snd_rawmidi_substream *input; - struct snd_rawmidi_substream *output; + snd_rawmidi_t *rmidi; + snd_rawmidi_substream_t *input; + snd_rawmidi_substream_t *output; char istimer; /* timer in use */ struct timer_list timer; spinlock_t lock; int pending; }; -struct hdspm { +struct _hdspm { spinlock_t lock; - struct snd_pcm_substream *capture_substream; /* only one playback */ - struct snd_pcm_substream *playback_substream; /* and/or capture stream */ + snd_pcm_substream_t *capture_substream; /* only one playback */ + snd_pcm_substream_t *playback_substream; /* and/or capture stream */ char *card_name; /* for procinfo */ unsigned short firmware_rev; /* dont know if relevant */ @@ -344,7 +347,7 @@ struct hdspm { u32 control_register; /* cached value */ u32 control2_register; /* cached value */ - struct hdspm_midi midi[2]; + hdspm_midi_t midi[2]; struct tasklet_struct midi_tasklet; size_t period_bytes; @@ -372,15 +375,15 @@ struct hdspm { int irq_count; /* for debug */ - struct snd_card *card; /* one card */ - struct snd_pcm *pcm; /* has one pcm */ - struct snd_hwdep *hwdep; /* and a hwdep for additional ioctl */ + snd_card_t *card; /* one card */ + snd_pcm_t *pcm; /* has one pcm */ + snd_hwdep_t *hwdep; /* and a hwdep for additional ioctl */ struct pci_dev *pci; /* and an pci info */ /* Mixer vars */ - struct snd_kcontrol *playback_mixer_ctls[HDSPM_MAX_CHANNELS]; /* fast alsa mixer */ - struct snd_kcontrol *input_mixer_ctls[HDSPM_MAX_CHANNELS]; /* but input to much, so not used */ - struct hdspm_mixer *mixer; /* full mixer accessable over mixer ioctl or hwdep-device */ + snd_kcontrol_t *playback_mixer_ctls[HDSPM_MAX_CHANNELS]; /* fast alsa mixer */ + snd_kcontrol_t *input_mixer_ctls[HDSPM_MAX_CHANNELS]; /* but input to much, so not used */ + hdspm_mixer_t *mixer; /* full mixer accessable over mixer ioctl or hwdep-device */ }; @@ -441,28 +444,28 @@ static struct pci_device_id snd_hdspm_ids[] = { MODULE_DEVICE_TABLE(pci, snd_hdspm_ids); /* prototypes */ -static int __devinit snd_hdspm_create_alsa_devices(struct snd_card *card, - struct hdspm * hdspm); -static int __devinit snd_hdspm_create_pcm(struct snd_card *card, - struct hdspm * hdspm); - -static inline void snd_hdspm_initialize_midi_flush(struct hdspm * hdspm); -static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm); -static int hdspm_autosync_ref(struct hdspm * hdspm); -static int snd_hdspm_set_defaults(struct hdspm * hdspm); -static void hdspm_set_sgbuf(struct hdspm * hdspm, struct snd_sg_buf *sgbuf, +static int __devinit snd_hdspm_create_alsa_devices(snd_card_t * card, + hdspm_t * hdspm); +static int __devinit snd_hdspm_create_pcm(snd_card_t * card, + hdspm_t * hdspm); + +static inline void snd_hdspm_initialize_midi_flush(hdspm_t * hdspm); +static int hdspm_update_simple_mixer_controls(hdspm_t * hdspm); +static int hdspm_autosync_ref(hdspm_t * hdspm); +static int snd_hdspm_set_defaults(hdspm_t * hdspm); +static void hdspm_set_sgbuf(hdspm_t * hdspm, struct snd_sg_buf *sgbuf, unsigned int reg, int channels); /* Write/read to/from HDSPM with Adresses in Bytes not words but only 32Bit writes are allowed */ -static inline void hdspm_write(struct hdspm * hdspm, unsigned int reg, +static inline void hdspm_write(hdspm_t * hdspm, unsigned int reg, unsigned int val) { writel(val, hdspm->iobase + reg); } -static inline unsigned int hdspm_read(struct hdspm * hdspm, unsigned int reg) +static inline unsigned int hdspm_read(hdspm_t * hdspm, unsigned int reg) { return readl(hdspm->iobase + reg); } @@ -471,7 +474,7 @@ static inline unsigned int hdspm_read(struct hdspm * hdspm, unsigned int reg) mixer is write only on hardware so we have to cache him for read each fader is a u32, but uses only the first 16 bit */ -static inline int hdspm_read_in_gain(struct hdspm * hdspm, unsigned int chan, +static inline int hdspm_read_in_gain(hdspm_t * hdspm, unsigned int chan, unsigned int in) { if (chan > HDSPM_MIXER_CHANNELS || in > HDSPM_MIXER_CHANNELS) @@ -480,7 +483,7 @@ static inline int hdspm_read_in_gain(struct hdspm * hdspm, unsigned int chan, return hdspm->mixer->ch[chan].in[in]; } -static inline int hdspm_read_pb_gain(struct hdspm * hdspm, unsigned int chan, +static inline int hdspm_read_pb_gain(hdspm_t * hdspm, unsigned int chan, unsigned int pb) { if (chan > HDSPM_MIXER_CHANNELS || pb > HDSPM_MIXER_CHANNELS) @@ -488,7 +491,7 @@ static inline int hdspm_read_pb_gain(struct hdspm * hdspm, unsigned int chan, return hdspm->mixer->ch[chan].pb[pb]; } -static inline int hdspm_write_in_gain(struct hdspm * hdspm, unsigned int chan, +static inline int hdspm_write_in_gain(hdspm_t * hdspm, unsigned int chan, unsigned int in, unsigned short data) { if (chan >= HDSPM_MIXER_CHANNELS || in >= HDSPM_MIXER_CHANNELS) @@ -501,7 +504,7 @@ static inline int hdspm_write_in_gain(struct hdspm * hdspm, unsigned int chan, return 0; } -static inline int hdspm_write_pb_gain(struct hdspm * hdspm, unsigned int chan, +static inline int hdspm_write_pb_gain(hdspm_t * hdspm, unsigned int chan, unsigned int pb, unsigned short data) { if (chan >= HDSPM_MIXER_CHANNELS || pb >= HDSPM_MIXER_CHANNELS) @@ -516,18 +519,18 @@ static inline int hdspm_write_pb_gain(struct hdspm * hdspm, unsigned int chan, /* enable DMA for specific channels, now available for DSP-MADI */ -static inline void snd_hdspm_enable_in(struct hdspm * hdspm, int i, int v) +static inline void snd_hdspm_enable_in(hdspm_t * hdspm, int i, int v) { hdspm_write(hdspm, HDSPM_inputEnableBase + (4 * i), v); } -static inline void snd_hdspm_enable_out(struct hdspm * hdspm, int i, int v) +static inline void snd_hdspm_enable_out(hdspm_t * hdspm, int i, int v) { hdspm_write(hdspm, HDSPM_outputEnableBase + (4 * i), v); } /* check if same process is writing and reading */ -static inline int snd_hdspm_use_is_exclusive(struct hdspm * hdspm) +static inline int snd_hdspm_use_is_exclusive(hdspm_t * hdspm) { unsigned long flags; int ret = 1; @@ -542,7 +545,7 @@ static inline int snd_hdspm_use_is_exclusive(struct hdspm * hdspm) } /* check for external sample rate */ -static inline int hdspm_external_sample_rate(struct hdspm * hdspm) +static inline int hdspm_external_sample_rate(hdspm_t * hdspm) { unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2); unsigned int status = hdspm_read(hdspm, HDSPM_statusRegister); @@ -627,13 +630,13 @@ static inline int hdspm_external_sample_rate(struct hdspm * hdspm) } /* Latency function */ -static inline void hdspm_compute_period_size(struct hdspm * hdspm) +static inline void hdspm_compute_period_size(hdspm_t * hdspm) { hdspm->period_bytes = 1 << ((hdspm_decode_latency(hdspm->control_register) + 8)); } -static snd_pcm_uframes_t hdspm_hw_pointer(struct hdspm * hdspm) +static snd_pcm_uframes_t hdspm_hw_pointer(hdspm_t * hdspm) { int position; @@ -657,20 +660,20 @@ static snd_pcm_uframes_t hdspm_hw_pointer(struct hdspm * hdspm) } -static inline void hdspm_start_audio(struct hdspm * s) +static inline void hdspm_start_audio(hdspm_t * s) { s->control_register |= (HDSPM_AudioInterruptEnable | HDSPM_Start); hdspm_write(s, HDSPM_controlRegister, s->control_register); } -static inline void hdspm_stop_audio(struct hdspm * s) +static inline void hdspm_stop_audio(hdspm_t * s) { s->control_register &= ~(HDSPM_Start | HDSPM_AudioInterruptEnable); hdspm_write(s, HDSPM_controlRegister, s->control_register); } /* should I silence all or only opened ones ? doit all for first even is 4MB*/ -static inline void hdspm_silence_playback(struct hdspm * hdspm) +static inline void hdspm_silence_playback(hdspm_t * hdspm) { int i; int n = hdspm->period_bytes; @@ -684,7 +687,7 @@ static inline void hdspm_silence_playback(struct hdspm * hdspm) } } -static int hdspm_set_interrupt_interval(struct hdspm * s, unsigned int frames) +static int hdspm_set_interrupt_interval(hdspm_t * s, unsigned int frames) { int n; @@ -710,7 +713,7 @@ static int hdspm_set_interrupt_interval(struct hdspm * s, unsigned int frames) /* dummy set rate lets see what happens */ -static int hdspm_set_rate(struct hdspm * hdspm, int rate, int called_internally) +static int hdspm_set_rate(hdspm_t * hdspm, int rate, int called_internally) { int reject_if_open = 0; int current_rate; @@ -835,7 +838,7 @@ static int hdspm_set_rate(struct hdspm * hdspm, int rate, int called_internally) } /* mainly for init to 0 on load */ -static void all_in_all_mixer(struct hdspm * hdspm, int sgain) +static void all_in_all_mixer(hdspm_t * hdspm, int sgain) { int i, j; unsigned int gain = @@ -852,7 +855,7 @@ static void all_in_all_mixer(struct hdspm * hdspm, int sgain) MIDI ----------------------------------------------------------------------------*/ -static inline unsigned char snd_hdspm_midi_read_byte (struct hdspm *hdspm, int id) +static inline unsigned char snd_hdspm_midi_read_byte (hdspm_t *hdspm, int id) { /* the hardware already does the relevant bit-mask with 0xff */ if (id) @@ -861,7 +864,7 @@ static inline unsigned char snd_hdspm_midi_read_byte (struct hdspm *hdspm, int i return hdspm_read(hdspm, HDSPM_midiDataIn0); } -static inline void snd_hdspm_midi_write_byte (struct hdspm *hdspm, int id, int val) +static inline void snd_hdspm_midi_write_byte (hdspm_t *hdspm, int id, int val) { /* the hardware already does the relevant bit-mask with 0xff */ if (id) @@ -870,7 +873,7 @@ static inline void snd_hdspm_midi_write_byte (struct hdspm *hdspm, int id, int v return hdspm_write(hdspm, HDSPM_midiDataOut0, val); } -static inline int snd_hdspm_midi_input_available (struct hdspm *hdspm, int id) +static inline int snd_hdspm_midi_input_available (hdspm_t *hdspm, int id) { if (id) return (hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xff); @@ -878,7 +881,7 @@ static inline int snd_hdspm_midi_input_available (struct hdspm *hdspm, int id) return (hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xff); } -static inline int snd_hdspm_midi_output_possible (struct hdspm *hdspm, int id) +static inline int snd_hdspm_midi_output_possible (hdspm_t *hdspm, int id) { int fifo_bytes_used; @@ -893,13 +896,13 @@ static inline int snd_hdspm_midi_output_possible (struct hdspm *hdspm, int id) return 0; } -static inline void snd_hdspm_flush_midi_input (struct hdspm *hdspm, int id) +static inline void snd_hdspm_flush_midi_input (hdspm_t *hdspm, int id) { while (snd_hdspm_midi_input_available (hdspm, id)) snd_hdspm_midi_read_byte (hdspm, id); } -static int snd_hdspm_midi_output_write (struct hdspm_midi *hmidi) +static int snd_hdspm_midi_output_write (hdspm_midi_t *hmidi) { unsigned long flags; int n_pending; @@ -927,7 +930,7 @@ static int snd_hdspm_midi_output_write (struct hdspm_midi *hmidi) return 0; } -static int snd_hdspm_midi_input_read (struct hdspm_midi *hmidi) +static int snd_hdspm_midi_input_read (hdspm_midi_t *hmidi) { unsigned char buf[128]; /* this buffer is designed to match the MIDI input FIFO size */ unsigned long flags; @@ -964,14 +967,14 @@ static int snd_hdspm_midi_input_read (struct hdspm_midi *hmidi) return snd_hdspm_midi_output_write (hmidi); } -static void snd_hdspm_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_hdspm_midi_input_trigger(snd_rawmidi_substream_t * substream, int up) { - struct hdspm *hdspm; - struct hdspm_midi *hmidi; + hdspm_t *hdspm; + hdspm_midi_t *hmidi; unsigned long flags; u32 ie; - hmidi = (struct hdspm_midi *) substream->rmidi->private_data; + hmidi = (hdspm_midi_t *) substream->rmidi->private_data; hdspm = hmidi->hdspm; ie = hmidi->id ? HDSPM_Midi1InterruptEnable : HDSPM_Midi0InterruptEnable; spin_lock_irqsave (&hdspm->lock, flags); @@ -990,7 +993,7 @@ static void snd_hdspm_midi_input_trigger(struct snd_rawmidi_substream *substream static void snd_hdspm_midi_output_timer(unsigned long data) { - struct hdspm_midi *hmidi = (struct hdspm_midi *) data; + hdspm_midi_t *hmidi = (hdspm_midi_t *) data; unsigned long flags; snd_hdspm_midi_output_write(hmidi); @@ -1010,12 +1013,12 @@ static void snd_hdspm_midi_output_timer(unsigned long data) spin_unlock_irqrestore (&hmidi->lock, flags); } -static void snd_hdspm_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_hdspm_midi_output_trigger(snd_rawmidi_substream_t * substream, int up) { - struct hdspm_midi *hmidi; + hdspm_midi_t *hmidi; unsigned long flags; - hmidi = (struct hdspm_midi *) substream->rmidi->private_data; + hmidi = (hdspm_midi_t *) substream->rmidi->private_data; spin_lock_irqsave (&hmidi->lock, flags); if (up) { if (!hmidi->istimer) { @@ -1036,11 +1039,11 @@ static void snd_hdspm_midi_output_trigger(struct snd_rawmidi_substream *substrea snd_hdspm_midi_output_write(hmidi); } -static int snd_hdspm_midi_input_open(struct snd_rawmidi_substream *substream) +static int snd_hdspm_midi_input_open(snd_rawmidi_substream_t * substream) { - struct hdspm_midi *hmidi; + hdspm_midi_t *hmidi; - hmidi = (struct hdspm_midi *) substream->rmidi->private_data; + hmidi = (hdspm_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); snd_hdspm_flush_midi_input (hmidi->hdspm, hmidi->id); hmidi->input = substream; @@ -1049,11 +1052,11 @@ static int snd_hdspm_midi_input_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_hdspm_midi_output_open(struct snd_rawmidi_substream *substream) +static int snd_hdspm_midi_output_open(snd_rawmidi_substream_t * substream) { - struct hdspm_midi *hmidi; + hdspm_midi_t *hmidi; - hmidi = (struct hdspm_midi *) substream->rmidi->private_data; + hmidi = (hdspm_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); hmidi->output = substream; spin_unlock_irq (&hmidi->lock); @@ -1061,13 +1064,13 @@ static int snd_hdspm_midi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_hdspm_midi_input_close(struct snd_rawmidi_substream *substream) +static int snd_hdspm_midi_input_close(snd_rawmidi_substream_t * substream) { - struct hdspm_midi *hmidi; + hdspm_midi_t *hmidi; snd_hdspm_midi_input_trigger (substream, 0); - hmidi = (struct hdspm_midi *) substream->rmidi->private_data; + hmidi = (hdspm_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); hmidi->input = NULL; spin_unlock_irq (&hmidi->lock); @@ -1075,13 +1078,13 @@ static int snd_hdspm_midi_input_close(struct snd_rawmidi_substream *substream) return 0; } -static int snd_hdspm_midi_output_close(struct snd_rawmidi_substream *substream) +static int snd_hdspm_midi_output_close(snd_rawmidi_substream_t * substream) { - struct hdspm_midi *hmidi; + hdspm_midi_t *hmidi; snd_hdspm_midi_output_trigger (substream, 0); - hmidi = (struct hdspm_midi *) substream->rmidi->private_data; + hmidi = (hdspm_midi_t *) substream->rmidi->private_data; spin_lock_irq (&hmidi->lock); hmidi->output = NULL; spin_unlock_irq (&hmidi->lock); @@ -1089,21 +1092,21 @@ static int snd_hdspm_midi_output_close(struct snd_rawmidi_substream *substream) return 0; } -static struct snd_rawmidi_ops snd_hdspm_midi_output = +static snd_rawmidi_ops_t snd_hdspm_midi_output = { .open = snd_hdspm_midi_output_open, .close = snd_hdspm_midi_output_close, .trigger = snd_hdspm_midi_output_trigger, }; -static struct snd_rawmidi_ops snd_hdspm_midi_input = +static snd_rawmidi_ops_t snd_hdspm_midi_input = { .open = snd_hdspm_midi_input_open, .close = snd_hdspm_midi_input_close, .trigger = snd_hdspm_midi_input_trigger, }; -static int __devinit snd_hdspm_create_midi (struct snd_card *card, struct hdspm *hdspm, int id) +static int __devinit snd_hdspm_create_midi (snd_card_t *card, hdspm_t *hdspm, int id) { int err; char buf[32]; @@ -1137,7 +1140,7 @@ static int __devinit snd_hdspm_create_midi (struct snd_card *card, struct hdspm static void hdspm_midi_tasklet(unsigned long arg) { - struct hdspm *hdspm = (struct hdspm *)arg; + hdspm_t *hdspm = (hdspm_t *)arg; if (hdspm->midi[0].pending) snd_hdspm_midi_input_read (&hdspm->midi[0]); @@ -1161,19 +1164,19 @@ static void hdspm_midi_tasklet(unsigned long arg) .get = snd_hdspm_get_system_sample_rate \ } -static int snd_hdspm_info_system_sample_rate(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_system_sample_rate(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; return 0; } -static int snd_hdspm_get_system_sample_rate(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value * +static int snd_hdspm_get_system_sample_rate(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdspm->system_sample_rate; return 0; @@ -1188,8 +1191,8 @@ static int snd_hdspm_get_system_sample_rate(struct snd_kcontrol *kcontrol, .get = snd_hdspm_get_autosync_sample_rate \ } -static int snd_hdspm_info_autosync_sample_rate(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_autosync_sample_rate(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "32000", "44100", "48000", "64000", "88200", "96000", @@ -1207,11 +1210,11 @@ static int snd_hdspm_info_autosync_sample_rate(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_autosync_sample_rate(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value * +static int snd_hdspm_get_autosync_sample_rate(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); switch (hdspm_external_sample_rate(hdspm)) { case 32000: @@ -1259,7 +1262,7 @@ static int snd_hdspm_get_autosync_sample_rate(struct snd_kcontrol *kcontrol, -static int hdspm_system_clock_mode(struct hdspm * hdspm) +static int hdspm_system_clock_mode(hdspm_t * hdspm) { /* Always reflect the hardware info, rme is never wrong !!!! */ @@ -1268,8 +1271,8 @@ static int hdspm_system_clock_mode(struct hdspm * hdspm) return 1; } -static int snd_hdspm_info_system_clock_mode(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_system_clock_mode(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "Master", "Slave" }; @@ -1284,10 +1287,10 @@ static int snd_hdspm_info_system_clock_mode(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_system_clock_mode(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_system_clock_mode(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdspm_system_clock_mode(hdspm); @@ -1303,7 +1306,7 @@ static int snd_hdspm_get_system_clock_mode(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_clock_source \ } -static int hdspm_clock_source(struct hdspm * hdspm) +static int hdspm_clock_source(hdspm_t * hdspm) { if (hdspm->control_register & HDSPM_ClockModeMaster) { switch (hdspm->system_sample_rate) { @@ -1333,7 +1336,7 @@ static int hdspm_clock_source(struct hdspm * hdspm) } } -static int hdspm_set_clock_source(struct hdspm * hdspm, int mode) +static int hdspm_set_clock_source(hdspm_t * hdspm, int mode) { int rate; switch (mode) { @@ -1383,8 +1386,8 @@ static int hdspm_set_clock_source(struct hdspm * hdspm, int mode) return 0; } -static int snd_hdspm_info_clock_source(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_clock_source(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "AutoSync", "Internal 32.0 kHz", "Internal 44.1 kHz", @@ -1409,19 +1412,19 @@ static int snd_hdspm_info_clock_source(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_clock_source(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_clock_source(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdspm_clock_source(hdspm); return 0; } -static int snd_hdspm_put_clock_source(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_clock_source(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; int val; @@ -1450,7 +1453,7 @@ static int snd_hdspm_put_clock_source(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_pref_sync_ref \ } -static int hdspm_pref_sync_ref(struct hdspm * hdspm) +static int hdspm_pref_sync_ref(hdspm_t * hdspm) { /* Notice that this looks at the requested sync source, not the one actually in use. @@ -1465,7 +1468,7 @@ static int hdspm_pref_sync_ref(struct hdspm * hdspm) return HDSPM_SYNC_FROM_WORD; } -static int hdspm_set_pref_sync_ref(struct hdspm * hdspm, int pref) +static int hdspm_set_pref_sync_ref(hdspm_t * hdspm, int pref) { hdspm->control_register &= ~HDSPM_SyncRefMask; @@ -1483,8 +1486,8 @@ static int hdspm_set_pref_sync_ref(struct hdspm * hdspm, int pref) return 0; } -static int snd_hdspm_info_pref_sync_ref(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_pref_sync_ref(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "Word", "MADI" }; @@ -1501,19 +1504,19 @@ static int snd_hdspm_info_pref_sync_ref(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_pref_sync_ref(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_pref_sync_ref(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdspm_pref_sync_ref(hdspm); return 0; } -static int snd_hdspm_put_pref_sync_ref(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_pref_sync_ref(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change, max; unsigned int val; @@ -1540,7 +1543,7 @@ static int snd_hdspm_put_pref_sync_ref(struct snd_kcontrol *kcontrol, .get = snd_hdspm_get_autosync_ref, \ } -static int hdspm_autosync_ref(struct hdspm * hdspm) +static int hdspm_autosync_ref(hdspm_t * hdspm) { /* This looks at the autosync selected sync reference */ unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2); @@ -1563,8 +1566,8 @@ static int hdspm_autosync_ref(struct hdspm * hdspm) return 0; } -static int snd_hdspm_info_autosync_ref(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_autosync_ref(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "WordClock", "MADI", "None" }; @@ -1579,10 +1582,10 @@ static int snd_hdspm_info_autosync_ref(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_autosync_ref(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_autosync_ref(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdspm_pref_sync_ref(hdspm); return 0; @@ -1597,13 +1600,13 @@ static int snd_hdspm_get_autosync_ref(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_line_out \ } -static int hdspm_line_out(struct hdspm * hdspm) +static int hdspm_line_out(hdspm_t * hdspm) { return (hdspm->control_register & HDSPM_LineOut) ? 1 : 0; } -static int hdspm_set_line_output(struct hdspm * hdspm, int out) +static int hdspm_set_line_output(hdspm_t * hdspm, int out) { if (out) hdspm->control_register |= HDSPM_LineOut; @@ -1614,8 +1617,8 @@ static int hdspm_set_line_output(struct hdspm * hdspm, int out) return 0; } -static int snd_hdspm_info_line_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_line_out(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1624,10 +1627,10 @@ static int snd_hdspm_info_line_out(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_line_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_line_out(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdspm->lock); ucontrol->value.integer.value[0] = hdspm_line_out(hdspm); @@ -1635,10 +1638,10 @@ static int snd_hdspm_get_line_out(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_put_line_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_line_out(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1661,12 +1664,12 @@ static int snd_hdspm_put_line_out(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_tx_64 \ } -static int hdspm_tx_64(struct hdspm * hdspm) +static int hdspm_tx_64(hdspm_t * hdspm) { return (hdspm->control_register & HDSPM_TX_64ch) ? 1 : 0; } -static int hdspm_set_tx_64(struct hdspm * hdspm, int out) +static int hdspm_set_tx_64(hdspm_t * hdspm, int out) { if (out) hdspm->control_register |= HDSPM_TX_64ch; @@ -1677,8 +1680,8 @@ static int hdspm_set_tx_64(struct hdspm * hdspm, int out) return 0; } -static int snd_hdspm_info_tx_64(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_tx_64(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1687,10 +1690,10 @@ static int snd_hdspm_info_tx_64(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_tx_64(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_tx_64(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdspm->lock); ucontrol->value.integer.value[0] = hdspm_tx_64(hdspm); @@ -1698,10 +1701,10 @@ static int snd_hdspm_get_tx_64(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_put_tx_64(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_tx_64(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1724,12 +1727,12 @@ static int snd_hdspm_put_tx_64(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_c_tms \ } -static int hdspm_c_tms(struct hdspm * hdspm) +static int hdspm_c_tms(hdspm_t * hdspm) { return (hdspm->control_register & HDSPM_clr_tms) ? 1 : 0; } -static int hdspm_set_c_tms(struct hdspm * hdspm, int out) +static int hdspm_set_c_tms(hdspm_t * hdspm, int out) { if (out) hdspm->control_register |= HDSPM_clr_tms; @@ -1740,8 +1743,8 @@ static int hdspm_set_c_tms(struct hdspm * hdspm, int out) return 0; } -static int snd_hdspm_info_c_tms(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_c_tms(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1750,10 +1753,10 @@ static int snd_hdspm_info_c_tms(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_c_tms(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_c_tms(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdspm->lock); ucontrol->value.integer.value[0] = hdspm_c_tms(hdspm); @@ -1761,10 +1764,10 @@ static int snd_hdspm_get_c_tms(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_put_c_tms(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_c_tms(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1787,12 +1790,12 @@ static int snd_hdspm_put_c_tms(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_safe_mode \ } -static int hdspm_safe_mode(struct hdspm * hdspm) +static int hdspm_safe_mode(hdspm_t * hdspm) { return (hdspm->control_register & HDSPM_AutoInp) ? 1 : 0; } -static int hdspm_set_safe_mode(struct hdspm * hdspm, int out) +static int hdspm_set_safe_mode(hdspm_t * hdspm, int out) { if (out) hdspm->control_register |= HDSPM_AutoInp; @@ -1803,8 +1806,8 @@ static int hdspm_set_safe_mode(struct hdspm * hdspm, int out) return 0; } -static int snd_hdspm_info_safe_mode(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_safe_mode(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1813,10 +1816,10 @@ static int snd_hdspm_info_safe_mode(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_safe_mode(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_safe_mode(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdspm->lock); ucontrol->value.integer.value[0] = hdspm_safe_mode(hdspm); @@ -1824,10 +1827,10 @@ static int snd_hdspm_get_safe_mode(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_put_safe_mode(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_safe_mode(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1850,12 +1853,12 @@ static int snd_hdspm_put_safe_mode(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_input_select \ } -static int hdspm_input_select(struct hdspm * hdspm) +static int hdspm_input_select(hdspm_t * hdspm) { return (hdspm->control_register & HDSPM_InputSelect0) ? 1 : 0; } -static int hdspm_set_input_select(struct hdspm * hdspm, int out) +static int hdspm_set_input_select(hdspm_t * hdspm, int out) { if (out) hdspm->control_register |= HDSPM_InputSelect0; @@ -1866,8 +1869,8 @@ static int hdspm_set_input_select(struct hdspm * hdspm, int out) return 0; } -static int snd_hdspm_info_input_select(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_input_select(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "optical", "coaxial" }; @@ -1884,10 +1887,10 @@ static int snd_hdspm_info_input_select(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_input_select(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_input_select(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); spin_lock_irq(&hdspm->lock); ucontrol->value.enumerated.item[0] = hdspm_input_select(hdspm); @@ -1895,10 +1898,10 @@ static int snd_hdspm_get_input_select(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_put_input_select(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_input_select(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1934,8 +1937,8 @@ static int snd_hdspm_put_input_select(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_mixer \ } -static int snd_hdspm_info_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_mixer(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 3; @@ -1945,10 +1948,10 @@ static int snd_hdspm_info_mixer(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_mixer(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int source; int destination; @@ -1978,10 +1981,10 @@ static int snd_hdspm_get_mixer(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_put_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_mixer(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; int source; int destination; @@ -2038,8 +2041,8 @@ static int snd_hdspm_put_mixer(struct snd_kcontrol *kcontrol, .put = snd_hdspm_put_playback_mixer \ } -static int snd_hdspm_info_playback_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_playback_mixer(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -2049,10 +2052,10 @@ static int snd_hdspm_info_playback_mixer(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_get_playback_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_playback_mixer(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int channel; int mapped_channel; @@ -2076,10 +2079,10 @@ static int snd_hdspm_get_playback_mixer(struct snd_kcontrol *kcontrol, return 0; } -static int snd_hdspm_put_playback_mixer(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_put_playback_mixer(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); int change; int channel; int mapped_channel; @@ -2118,8 +2121,8 @@ static int snd_hdspm_put_playback_mixer(struct snd_kcontrol *kcontrol, .get = snd_hdspm_get_wc_sync_check \ } -static int snd_hdspm_info_sync_check(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_hdspm_info_sync_check(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { static char *texts[] = { "No Lock", "Lock", "Sync" }; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -2133,7 +2136,7 @@ static int snd_hdspm_info_sync_check(struct snd_kcontrol *kcontrol, return 0; } -static int hdspm_wc_sync_check(struct hdspm * hdspm) +static int hdspm_wc_sync_check(hdspm_t * hdspm) { int status2 = hdspm_read(hdspm, HDSPM_statusRegister2); if (status2 & HDSPM_wcLock) { @@ -2145,10 +2148,10 @@ static int hdspm_wc_sync_check(struct hdspm * hdspm) return 0; } -static int snd_hdspm_get_wc_sync_check(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_hdspm_get_wc_sync_check(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdspm_wc_sync_check(hdspm); return 0; @@ -2164,7 +2167,7 @@ static int snd_hdspm_get_wc_sync_check(struct snd_kcontrol *kcontrol, .get = snd_hdspm_get_madisync_sync_check \ } -static int hdspm_madisync_sync_check(struct hdspm * hdspm) +static int hdspm_madisync_sync_check(hdspm_t * hdspm) { int status = hdspm_read(hdspm, HDSPM_statusRegister); if (status & HDSPM_madiLock) { @@ -2176,11 +2179,11 @@ static int hdspm_madisync_sync_check(struct hdspm * hdspm) return 0; } -static int snd_hdspm_get_madisync_sync_check(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value * +static int snd_hdspm_get_madisync_sync_check(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct hdspm *hdspm = snd_kcontrol_chip(kcontrol); + hdspm_t *hdspm = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = hdspm_madisync_sync_check(hdspm); @@ -2190,7 +2193,7 @@ static int snd_hdspm_get_madisync_sync_check(struct snd_kcontrol *kcontrol, -static struct snd_kcontrol_new snd_hdspm_controls[] = { +static snd_kcontrol_new_t snd_hdspm_controls[] = { HDSPM_MIXER("Mixer", 0), /* 'Sample Clock Source' complies with the alsa control naming scheme */ @@ -2211,10 +2214,10 @@ static struct snd_kcontrol_new snd_hdspm_controls[] = { HDSPM_INPUT_SELECT("Input Select", 0), }; -static struct snd_kcontrol_new snd_hdspm_playback_mixer = HDSPM_PLAYBACK_MIXER; +static snd_kcontrol_new_t snd_hdspm_playback_mixer = HDSPM_PLAYBACK_MIXER; -static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm) +static int hdspm_update_simple_mixer_controls(hdspm_t * hdspm) { int i; @@ -2238,11 +2241,11 @@ static int hdspm_update_simple_mixer_controls(struct hdspm * hdspm) } -static int snd_hdspm_create_controls(struct snd_card *card, struct hdspm * hdspm) +static int snd_hdspm_create_controls(snd_card_t * card, hdspm_t * hdspm) { unsigned int idx, limit; int err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; /* add control list first */ @@ -2289,9 +2292,9 @@ static int snd_hdspm_create_controls(struct snd_card *card, struct hdspm * hdspm ------------------------------------------------------------*/ static void -snd_hdspm_proc_read(struct snd_info_entry * entry, struct snd_info_buffer *buffer) +snd_hdspm_proc_read(snd_info_entry_t * entry, snd_info_buffer_t * buffer) { - struct hdspm *hdspm = (struct hdspm *) entry->private_data; + hdspm_t *hdspm = (hdspm_t *) entry->private_data; unsigned int status; unsigned int status2; char *pref_sync_ref; @@ -2484,9 +2487,9 @@ snd_hdspm_proc_read(struct snd_info_entry * entry, struct snd_info_buffer *buffe snd_iprintf(buffer, "\n"); } -static void __devinit snd_hdspm_proc_init(struct hdspm * hdspm) +static void __devinit snd_hdspm_proc_init(hdspm_t * hdspm) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (!snd_card_proc_new(hdspm->card, "hdspm", &entry)) snd_info_set_text_ops(entry, hdspm, 1024, @@ -2497,7 +2500,7 @@ static void __devinit snd_hdspm_proc_init(struct hdspm * hdspm) hdspm intitialize ------------------------------------------------------------*/ -static int snd_hdspm_set_defaults(struct hdspm * hdspm) +static int snd_hdspm_set_defaults(hdspm_t * hdspm) { unsigned int i; @@ -2559,7 +2562,7 @@ static int snd_hdspm_set_defaults(struct hdspm * hdspm) static irqreturn_t snd_hdspm_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct hdspm *hdspm = (struct hdspm *) dev_id; + hdspm_t *hdspm = (hdspm_t *) dev_id; unsigned int status; int audio; int midi0; @@ -2624,14 +2627,14 @@ static irqreturn_t snd_hdspm_interrupt(int irq, void *dev_id, ------------------------------------------------------------*/ -static snd_pcm_uframes_t snd_hdspm_hw_pointer(struct snd_pcm_substream * +static snd_pcm_uframes_t snd_hdspm_hw_pointer(snd_pcm_substream_t * substream) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); return hdspm_hw_pointer(hdspm); } -static char *hdspm_channel_buffer_location(struct hdspm * hdspm, +static char *hdspm_channel_buffer_location(hdspm_t * hdspm, int stream, int channel) { int mapped_channel; @@ -2653,11 +2656,11 @@ static char *hdspm_channel_buffer_location(struct hdspm * hdspm, /* dont know why need it ??? */ -static int snd_hdspm_playback_copy(struct snd_pcm_substream *substream, +static int snd_hdspm_playback_copy(snd_pcm_substream_t * substream, int channel, snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); char *channel_buf; snd_assert(pos + count <= HDSPM_CHANNEL_BUFFER_BYTES / 4, @@ -2672,11 +2675,11 @@ static int snd_hdspm_playback_copy(struct snd_pcm_substream *substream, return copy_from_user(channel_buf + pos * 4, src, count * 4); } -static int snd_hdspm_capture_copy(struct snd_pcm_substream *substream, +static int snd_hdspm_capture_copy(snd_pcm_substream_t * substream, int channel, snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); char *channel_buf; snd_assert(pos + count <= HDSPM_CHANNEL_BUFFER_BYTES / 4, @@ -2689,11 +2692,11 @@ static int snd_hdspm_capture_copy(struct snd_pcm_substream *substream, return copy_to_user(dst, channel_buf + pos * 4, count * 4); } -static int snd_hdspm_hw_silence(struct snd_pcm_substream *substream, +static int snd_hdspm_hw_silence(snd_pcm_substream_t * substream, int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); char *channel_buf; channel_buf = @@ -2704,11 +2707,11 @@ static int snd_hdspm_hw_silence(struct snd_pcm_substream *substream, return 0; } -static int snd_hdspm_reset(struct snd_pcm_substream *substream) +static int snd_hdspm_reset(snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct hdspm *hdspm = snd_pcm_substream_chip(substream); - struct snd_pcm_substream *other; + snd_pcm_runtime_t *runtime = substream->runtime; + hdspm_t *hdspm = snd_pcm_substream_chip(substream); + snd_pcm_substream_t *other; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) other = hdspm->capture_substream; @@ -2721,8 +2724,8 @@ static int snd_hdspm_reset(struct snd_pcm_substream *substream) runtime->status->hw_ptr = 0; if (other) { struct list_head *pos; - struct snd_pcm_substream *s; - struct snd_pcm_runtime *oruntime = other->runtime; + snd_pcm_substream_t *s; + snd_pcm_runtime_t *oruntime = other->runtime; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == other) { @@ -2735,10 +2738,10 @@ static int snd_hdspm_reset(struct snd_pcm_substream *substream) return 0; } -static int snd_hdspm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +static int snd_hdspm_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * params) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); int err; int i; pid_t this_pid; @@ -2836,10 +2839,10 @@ static int snd_hdspm_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_hdspm_hw_free(struct snd_pcm_substream *substream) +static int snd_hdspm_hw_free(snd_pcm_substream_t * substream) { int i; - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { @@ -2862,10 +2865,10 @@ static int snd_hdspm_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_hdspm_channel_info(struct snd_pcm_substream *substream, - struct snd_pcm_channel_info * info) +static int snd_hdspm_channel_info(snd_pcm_substream_t * substream, + snd_pcm_channel_info_t * info) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); int mapped_channel; snd_assert(info->channel < HDSPM_MAX_CHANNELS, return -EINVAL); @@ -2879,7 +2882,7 @@ static int snd_hdspm_channel_info(struct snd_pcm_substream *substream, return 0; } -static int snd_hdspm_ioctl(struct snd_pcm_substream *substream, +static int snd_hdspm_ioctl(snd_pcm_substream_t * substream, unsigned int cmd, void *arg) { switch (cmd) { @@ -2890,7 +2893,7 @@ static int snd_hdspm_ioctl(struct snd_pcm_substream *substream, case SNDRV_PCM_IOCTL1_CHANNEL_INFO: { - struct snd_pcm_channel_info *info = arg; + snd_pcm_channel_info_t *info = arg; return snd_hdspm_channel_info(substream, info); } default: @@ -2900,10 +2903,10 @@ static int snd_hdspm_ioctl(struct snd_pcm_substream *substream, return snd_pcm_lib_ioctl(substream, cmd, arg); } -static int snd_hdspm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_hdspm_trigger(snd_pcm_substream_t * substream, int cmd) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); - struct snd_pcm_substream *other; + hdspm_t *hdspm = snd_pcm_substream_chip(substream); + snd_pcm_substream_t *other; int running; spin_lock(&hdspm->lock); @@ -2927,7 +2930,7 @@ static int snd_hdspm_trigger(struct snd_pcm_substream *substream, int cmd) if (other) { struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == other) { @@ -2965,7 +2968,7 @@ static int snd_hdspm_trigger(struct snd_pcm_substream *substream, int cmd) return 0; } -static int snd_hdspm_prepare(struct snd_pcm_substream *substream) +static int snd_hdspm_prepare(snd_pcm_substream_t * substream) { return 0; } @@ -2973,7 +2976,7 @@ static int snd_hdspm_prepare(struct snd_pcm_substream *substream) static unsigned int period_sizes[] = { 64, 128, 256, 512, 1024, 2048, 4096, 8192 }; -static struct snd_pcm_hardware snd_hdspm_playback_subinfo = { +static snd_pcm_hardware_t snd_hdspm_playback_subinfo = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_NONINTERLEAVED | @@ -2997,7 +3000,7 @@ static struct snd_pcm_hardware snd_hdspm_playback_subinfo = { .fifo_size = 0 }; -static struct snd_pcm_hardware snd_hdspm_capture_subinfo = { +static snd_pcm_hardware_t snd_hdspm_capture_subinfo = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_NONINTERLEAVED | @@ -3021,31 +3024,31 @@ static struct snd_pcm_hardware snd_hdspm_capture_subinfo = { .fifo_size = 0 }; -static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes = { +static snd_pcm_hw_constraint_list_t hw_constraints_period_sizes = { .count = ARRAY_SIZE(period_sizes), .list = period_sizes, .mask = 0 }; -static int snd_hdspm_hw_rule_channels_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule * rule) +static int snd_hdspm_hw_rule_channels_rate(snd_pcm_hw_params_t * params, + snd_pcm_hw_rule_t * rule) { - struct hdspm *hdspm = rule->private; - struct snd_interval *c = + hdspm_t *hdspm = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (r->min > 48000) { - struct snd_interval t = { + snd_interval_t t = { .min = 1, .max = hdspm->ds_channels, .integer = 1, }; return snd_interval_refine(c, &t); } else if (r->max < 64000) { - struct snd_interval t = { + snd_interval_t t = { .min = 1, .max = hdspm->ss_channels, .integer = 1, @@ -3055,24 +3058,24 @@ static int snd_hdspm_hw_rule_channels_rate(struct snd_pcm_hw_params *params, return 0; } -static int snd_hdspm_hw_rule_rate_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule * rule) +static int snd_hdspm_hw_rule_rate_channels(snd_pcm_hw_params_t * params, + snd_pcm_hw_rule_t * rule) { - struct hdspm *hdspm = rule->private; - struct snd_interval *c = + hdspm_t *hdspm = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (c->min <= hdspm->ss_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 32000, .max = 48000, .integer = 1, }; return snd_interval_refine(r, &t); } else if (c->max > hdspm->ss_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 64000, .max = 96000, .integer = 1, @@ -3083,10 +3086,10 @@ static int snd_hdspm_hw_rule_rate_channels(struct snd_pcm_hw_params *params, return 0; } -static int snd_hdspm_playback_open(struct snd_pcm_substream *substream) +static int snd_hdspm_playback_open(snd_pcm_substream_t * substream) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + hdspm_t *hdspm = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; snd_printdd("Open device substream %d\n", substream->stream); @@ -3121,9 +3124,9 @@ static int snd_hdspm_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_hdspm_playback_release(struct snd_pcm_substream *substream) +static int snd_hdspm_playback_release(snd_pcm_substream_t * substream) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); spin_lock_irq(&hdspm->lock); @@ -3136,10 +3139,10 @@ static int snd_hdspm_playback_release(struct snd_pcm_substream *substream) } -static int snd_hdspm_capture_open(struct snd_pcm_substream *substream) +static int snd_hdspm_capture_open(snd_pcm_substream_t * substream) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + hdspm_t *hdspm = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; spin_lock_irq(&hdspm->lock); snd_pcm_set_sync(substream); @@ -3168,9 +3171,9 @@ static int snd_hdspm_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_hdspm_capture_release(struct snd_pcm_substream *substream) +static int snd_hdspm_capture_release(snd_pcm_substream_t * substream) { - struct hdspm *hdspm = snd_pcm_substream_chip(substream); + hdspm_t *hdspm = snd_pcm_substream_chip(substream); spin_lock_irq(&hdspm->lock); @@ -3181,21 +3184,21 @@ static int snd_hdspm_capture_release(struct snd_pcm_substream *substream) return 0; } -static int snd_hdspm_hwdep_dummy_op(struct snd_hwdep * hw, struct file *file) +static int snd_hdspm_hwdep_dummy_op(snd_hwdep_t * hw, struct file *file) { /* we have nothing to initialize but the call is required */ return 0; } -static int snd_hdspm_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, +static int snd_hdspm_hwdep_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct hdspm *hdspm = (struct hdspm *) hw->private_data; - struct hdspm_mixer_ioctl mixer; - struct hdspm_config_info info; - struct hdspm_version hdspm_version; - struct hdspm_peak_rms_ioctl rms; + hdspm_t *hdspm = (hdspm_t *) hw->private_data; + struct sndrv_hdspm_mixer_ioctl mixer; + hdspm_config_info_t info; + hdspm_version_t hdspm_version; + struct sndrv_hdspm_peak_rms_ioctl rms; switch (cmd) { @@ -3206,7 +3209,7 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, /* maybe there is a chance to memorymap in future so dont touch just copy */ if(copy_to_user_fromio((void __user *)rms.peak, hdspm->iobase+HDSPM_MADI_peakrmsbase, - sizeof(struct hdspm_peak_rms)) != 0 ) + sizeof(hdspm_peak_rms_t)) != 0 ) return -EFAULT; break; @@ -3247,7 +3250,7 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, if (copy_from_user(&mixer, (void __user *)arg, sizeof(mixer))) return -EFAULT; if (copy_to_user - ((void __user *)mixer.mixer, hdspm->mixer, sizeof(struct hdspm_mixer))) + ((void __user *)mixer.mixer, hdspm->mixer, sizeof(hdspm_mixer_t))) return -EFAULT; break; @@ -3257,7 +3260,7 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, return 0; } -static struct snd_pcm_ops snd_hdspm_playback_ops = { +static snd_pcm_ops_t snd_hdspm_playback_ops = { .open = snd_hdspm_playback_open, .close = snd_hdspm_playback_release, .ioctl = snd_hdspm_ioctl, @@ -3271,7 +3274,7 @@ static struct snd_pcm_ops snd_hdspm_playback_ops = { .page = snd_pcm_sgbuf_ops_page, }; -static struct snd_pcm_ops snd_hdspm_capture_ops = { +static snd_pcm_ops_t snd_hdspm_capture_ops = { .open = snd_hdspm_capture_open, .close = snd_hdspm_capture_release, .ioctl = snd_hdspm_ioctl, @@ -3284,10 +3287,10 @@ static struct snd_pcm_ops snd_hdspm_capture_ops = { .page = snd_pcm_sgbuf_ops_page, }; -static int __devinit snd_hdspm_create_hwdep(struct snd_card *card, - struct hdspm * hdspm) +static int __devinit snd_hdspm_create_hwdep(snd_card_t * card, + hdspm_t * hdspm) { - struct snd_hwdep *hw; + snd_hwdep_t *hw; int err; if ((err = snd_hwdep_new(card, "HDSPM hwdep", 0, &hw)) < 0) @@ -3308,10 +3311,10 @@ static int __devinit snd_hdspm_create_hwdep(struct snd_card *card, /*------------------------------------------------------------ memory interface ------------------------------------------------------------*/ -static int __devinit snd_hdspm_preallocate_memory(struct hdspm * hdspm) +static int __devinit snd_hdspm_preallocate_memory(hdspm_t * hdspm) { int err; - struct snd_pcm *pcm; + snd_pcm_t *pcm; size_t wanted; pcm = hdspm->pcm; @@ -3333,7 +3336,16 @@ static int __devinit snd_hdspm_preallocate_memory(struct hdspm * hdspm) return 0; } -static void hdspm_set_sgbuf(struct hdspm * hdspm, struct snd_sg_buf *sgbuf, +static int snd_hdspm_memory_free(hdspm_t * hdspm) +{ + snd_printdd("memory_free_for_all %p\n", hdspm->pcm); + + snd_pcm_lib_preallocate_free_for_all(hdspm->pcm); + return 0; +} + + +static void hdspm_set_sgbuf(hdspm_t * hdspm, struct snd_sg_buf *sgbuf, unsigned int reg, int channels) { int i; @@ -3344,10 +3356,10 @@ static void hdspm_set_sgbuf(struct hdspm * hdspm, struct snd_sg_buf *sgbuf, } /* ------------- ALSA Devices ---------------------------- */ -static int __devinit snd_hdspm_create_pcm(struct snd_card *card, - struct hdspm * hdspm) +static int __devinit snd_hdspm_create_pcm(snd_card_t * card, + hdspm_t * hdspm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(card, hdspm->card_name, 0, 1, 1, &pcm)) < 0) @@ -3370,14 +3382,14 @@ static int __devinit snd_hdspm_create_pcm(struct snd_card *card, return 0; } -static inline void snd_hdspm_initialize_midi_flush(struct hdspm * hdspm) +static inline void snd_hdspm_initialize_midi_flush(hdspm_t * hdspm) { snd_hdspm_flush_midi_input(hdspm, 0); snd_hdspm_flush_midi_input(hdspm, 1); } -static int __devinit snd_hdspm_create_alsa_devices(struct snd_card *card, - struct hdspm * hdspm) +static int __devinit snd_hdspm_create_alsa_devices(snd_card_t * card, + hdspm_t * hdspm) { int err; @@ -3427,7 +3439,7 @@ static int __devinit snd_hdspm_create_alsa_devices(struct snd_card *card, return 0; } -static int __devinit snd_hdspm_create(struct snd_card *card, struct hdspm * hdspm, +static int __devinit snd_hdspm_create(snd_card_t * card, hdspm_t * hdspm, int precise_ptr, int enable_monitor) { struct pci_dev *pci = hdspm->pci; @@ -3511,11 +3523,12 @@ static int __devinit snd_hdspm_create(struct snd_card *card, struct hdspm * hdsp hdspm->monitor_outs = enable_monitor; snd_printdd("kmalloc Mixer memory of %d Bytes\n", - sizeof(struct hdspm_mixer)); - if ((hdspm->mixer = kmalloc(sizeof(struct hdspm_mixer), GFP_KERNEL)) + sizeof(hdspm_mixer_t)); + if ((hdspm->mixer = + (hdspm_mixer_t *) kmalloc(sizeof(hdspm_mixer_t), GFP_KERNEL)) == NULL) { snd_printk(KERN_ERR "HDSPM: unable to kmalloc Mixer memory of %d Bytes\n", - (int)sizeof(struct hdspm_mixer)); + (int)sizeof(hdspm_mixer_t)); return err; } @@ -3532,7 +3545,7 @@ static int __devinit snd_hdspm_create(struct snd_card *card, struct hdspm * hdsp return 0; } -static int snd_hdspm_free(struct hdspm * hdspm) +static int snd_hdspm_free(hdspm_t * hdspm) { if (hdspm->port) { @@ -3555,6 +3568,8 @@ static int snd_hdspm_free(struct hdspm * hdspm) if (hdspm->iobase) iounmap(hdspm->iobase); + snd_hdspm_memory_free(hdspm); + if (hdspm->port) pci_release_regions(hdspm->pci); @@ -3562,9 +3577,9 @@ static int snd_hdspm_free(struct hdspm * hdspm) return 0; } -static void snd_hdspm_card_free(struct snd_card *card) +static void snd_hdspm_card_free(snd_card_t * card) { - struct hdspm *hdspm = (struct hdspm *) card->private_data; + hdspm_t *hdspm = (hdspm_t *) card->private_data; if (hdspm) snd_hdspm_free(hdspm); @@ -3574,8 +3589,8 @@ static int __devinit snd_hdspm_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct hdspm *hdspm; - struct snd_card *card; + hdspm_t *hdspm; + snd_card_t *card; int err; if (dev >= SNDRV_CARDS) @@ -3586,10 +3601,10 @@ static int __devinit snd_hdspm_probe(struct pci_dev *pci, } if (!(card = snd_card_new(index[dev], id[dev], - THIS_MODULE, sizeof(struct hdspm)))) + THIS_MODULE, sizeof(hdspm_t)))) return -ENOMEM; - hdspm = (struct hdspm *) card->private_data; + hdspm = (hdspm_t *) card->private_data; card->private_free = snd_hdspm_card_free; hdspm->dev = dev; hdspm->pci = pci; diff --git a/trunk/sound/pci/rme9652/rme9652.c b/trunk/sound/pci/rme9652/rme9652.c index a687eb63236f..f9d0c126c213 100644 --- a/trunk/sound/pci/rme9652/rme9652.c +++ b/trunk/sound/pci/rme9652/rme9652.c @@ -198,7 +198,7 @@ MODULE_SUPPORTED_DEVICE("{{RME,Hammerfall}," #define RME9652_DMA_AREA_BYTES ((RME9652_NCHANNELS+1) * RME9652_CHANNEL_BUFFER_BYTES) #define RME9652_DMA_AREA_KILOBYTES (RME9652_DMA_AREA_BYTES/1024) -struct snd_rme9652 { +typedef struct snd_rme9652 { int dev; spinlock_t lock; @@ -234,8 +234,8 @@ struct snd_rme9652 { pid_t capture_pid; pid_t playback_pid; - struct snd_pcm_substream *capture_substream; - struct snd_pcm_substream *playback_substream; + snd_pcm_substream_t *capture_substream; + snd_pcm_substream_t *playback_substream; int running; int passthru; /* non-zero if doing pass-thru */ @@ -246,12 +246,12 @@ struct snd_rme9652 { char *channel_map; - struct snd_card *card; - struct snd_pcm *pcm; + snd_card_t *card; + snd_pcm_t *pcm; struct pci_dev *pci; - struct snd_kcontrol *spdif_ctl; + snd_kcontrol_t *spdif_ctl; -}; +} rme9652_t; /* These tables map the ALSA channels 1..N to the channels that we need to use in order to find the relevant channel buffer. RME @@ -327,17 +327,17 @@ static struct pci_device_id snd_rme9652_ids[] = { MODULE_DEVICE_TABLE(pci, snd_rme9652_ids); -static inline void rme9652_write(struct snd_rme9652 *rme9652, int reg, int val) +static inline void rme9652_write(rme9652_t *rme9652, int reg, int val) { writel(val, rme9652->iobase + reg); } -static inline unsigned int rme9652_read(struct snd_rme9652 *rme9652, int reg) +static inline unsigned int rme9652_read(rme9652_t *rme9652, int reg) { return readl(rme9652->iobase + reg); } -static inline int snd_rme9652_use_is_exclusive(struct snd_rme9652 *rme9652) +static inline int snd_rme9652_use_is_exclusive(rme9652_t *rme9652) { unsigned long flags; int ret = 1; @@ -351,7 +351,7 @@ static inline int snd_rme9652_use_is_exclusive(struct snd_rme9652 *rme9652) return ret; } -static inline int rme9652_adat_sample_rate(struct snd_rme9652 *rme9652) +static inline int rme9652_adat_sample_rate(rme9652_t *rme9652) { if (rme9652_running_double_speed(rme9652)) { return (rme9652_read(rme9652, RME9652_status_register) & @@ -362,7 +362,7 @@ static inline int rme9652_adat_sample_rate(struct snd_rme9652 *rme9652) } } -static inline void rme9652_compute_period_size(struct snd_rme9652 *rme9652) +static inline void rme9652_compute_period_size(rme9652_t *rme9652) { unsigned int i; @@ -373,7 +373,7 @@ static inline void rme9652_compute_period_size(struct snd_rme9652 *rme9652) rme9652->max_jitter = 80; } -static snd_pcm_uframes_t rme9652_hw_pointer(struct snd_rme9652 *rme9652) +static snd_pcm_uframes_t rme9652_hw_pointer(rme9652_t *rme9652) { int status; unsigned int offset, frag; @@ -420,7 +420,7 @@ static snd_pcm_uframes_t rme9652_hw_pointer(struct snd_rme9652 *rme9652) return offset; } -static inline void rme9652_reset_hw_pointer(struct snd_rme9652 *rme9652) +static inline void rme9652_reset_hw_pointer(rme9652_t *rme9652) { int i; @@ -437,19 +437,19 @@ static inline void rme9652_reset_hw_pointer(struct snd_rme9652 *rme9652) rme9652->prev_hw_offset = 0; } -static inline void rme9652_start(struct snd_rme9652 *s) +static inline void rme9652_start(rme9652_t *s) { s->control_register |= (RME9652_IE | RME9652_start_bit); rme9652_write(s, RME9652_control_register, s->control_register); } -static inline void rme9652_stop(struct snd_rme9652 *s) +static inline void rme9652_stop(rme9652_t *s) { s->control_register &= ~(RME9652_start_bit | RME9652_IE); rme9652_write(s, RME9652_control_register, s->control_register); } -static int rme9652_set_interrupt_interval(struct snd_rme9652 *s, +static int rme9652_set_interrupt_interval(rme9652_t *s, unsigned int frames) { int restart = 0; @@ -483,7 +483,7 @@ static int rme9652_set_interrupt_interval(struct snd_rme9652 *s, return 0; } -static int rme9652_set_rate(struct snd_rme9652 *rme9652, int rate) +static int rme9652_set_rate(rme9652_t *rme9652, int rate) { int restart; int reject_if_open = 0; @@ -571,7 +571,7 @@ static int rme9652_set_rate(struct snd_rme9652 *rme9652, int rate) return 0; } -static void rme9652_set_thru(struct snd_rme9652 *rme9652, int channel, int enable) +static void rme9652_set_thru(rme9652_t *rme9652, int channel, int enable) { int i; @@ -612,7 +612,7 @@ static void rme9652_set_thru(struct snd_rme9652 *rme9652, int channel, int enabl } } -static int rme9652_set_passthru(struct snd_rme9652 *rme9652, int onoff) +static int rme9652_set_passthru(rme9652_t *rme9652, int onoff) { if (onoff) { rme9652_set_thru(rme9652, -1, 1); @@ -640,7 +640,7 @@ static int rme9652_set_passthru(struct snd_rme9652 *rme9652, int onoff) return 0; } -static void rme9652_spdif_set_bit (struct snd_rme9652 *rme9652, int mask, int onoff) +static void rme9652_spdif_set_bit (rme9652_t *rme9652, int mask, int onoff) { if (onoff) rme9652->control_register |= mask; @@ -650,7 +650,7 @@ static void rme9652_spdif_set_bit (struct snd_rme9652 *rme9652, int mask, int on rme9652_write(rme9652, RME9652_control_register, rme9652->control_register); } -static void rme9652_spdif_write_byte (struct snd_rme9652 *rme9652, const int val) +static void rme9652_spdif_write_byte (rme9652_t *rme9652, const int val) { long mask; long i; @@ -666,7 +666,7 @@ static void rme9652_spdif_write_byte (struct snd_rme9652 *rme9652, const int val } } -static int rme9652_spdif_read_byte (struct snd_rme9652 *rme9652) +static int rme9652_spdif_read_byte (rme9652_t *rme9652) { long mask; long val; @@ -684,7 +684,7 @@ static int rme9652_spdif_read_byte (struct snd_rme9652 *rme9652) return val; } -static void rme9652_write_spdif_codec (struct snd_rme9652 *rme9652, const int address, const int data) +static void rme9652_write_spdif_codec (rme9652_t *rme9652, const int address, const int data) { rme9652_spdif_set_bit (rme9652, RME9652_SPDIF_SELECT, 1); rme9652_spdif_write_byte (rme9652, 0x20); @@ -694,7 +694,7 @@ static void rme9652_write_spdif_codec (struct snd_rme9652 *rme9652, const int ad } -static int rme9652_spdif_read_codec (struct snd_rme9652 *rme9652, const int address) +static int rme9652_spdif_read_codec (rme9652_t *rme9652, const int address) { int ret; @@ -711,7 +711,7 @@ static int rme9652_spdif_read_codec (struct snd_rme9652 *rme9652, const int addr return ret; } -static void rme9652_initialize_spdif_receiver (struct snd_rme9652 *rme9652) +static void rme9652_initialize_spdif_receiver (rme9652_t *rme9652) { /* XXX what unsets this ? */ @@ -722,7 +722,7 @@ static void rme9652_initialize_spdif_receiver (struct snd_rme9652 *rme9652) rme9652_write_spdif_codec (rme9652, 6, 0x02); } -static inline int rme9652_spdif_sample_rate(struct snd_rme9652 *s) +static inline int rme9652_spdif_sample_rate(rme9652_t *s) { unsigned int rate_bits; @@ -790,7 +790,7 @@ static inline int rme9652_spdif_sample_rate(struct snd_rme9652 *s) Control Interface ----------------------------------------------------------------------------*/ -static u32 snd_rme9652_convert_from_aes(struct snd_aes_iec958 *aes) +static u32 snd_rme9652_convert_from_aes(snd_aes_iec958_t *aes) { u32 val = 0; val |= (aes->status[0] & IEC958_AES0_PROFESSIONAL) ? RME9652_PRO : 0; @@ -802,7 +802,7 @@ static u32 snd_rme9652_convert_from_aes(struct snd_aes_iec958 *aes) return val; } -static void snd_rme9652_convert_to_aes(struct snd_aes_iec958 *aes, u32 val) +static void snd_rme9652_convert_to_aes(snd_aes_iec958_t *aes, u32 val) { aes->status[0] = ((val & RME9652_PRO) ? IEC958_AES0_PROFESSIONAL : 0) | ((val & RME9652_Dolby) ? IEC958_AES0_NONAUDIO : 0); @@ -812,24 +812,24 @@ static void snd_rme9652_convert_to_aes(struct snd_aes_iec958 *aes, u32 val) aes->status[0] |= (val & RME9652_EMP) ? IEC958_AES0_CON_EMPHASIS_5015 : 0; } -static int snd_rme9652_control_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_control_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme9652_control_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_control_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif); return 0; } -static int snd_rme9652_control_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_control_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -841,24 +841,24 @@ static int snd_rme9652_control_spdif_put(struct snd_kcontrol *kcontrol, struct s return change; } -static int snd_rme9652_control_spdif_stream_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_control_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme9652_control_spdif_stream_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_control_spdif_stream_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); snd_rme9652_convert_to_aes(&ucontrol->value.iec958, rme9652->creg_spdif_stream); return 0; } -static int snd_rme9652_control_spdif_stream_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_control_spdif_stream_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; u32 val; @@ -872,14 +872,14 @@ static int snd_rme9652_control_spdif_stream_put(struct snd_kcontrol *kcontrol, s return change; } -static int snd_rme9652_control_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_control_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_rme9652_control_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_control_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = kcontrol->private_value; return 0; @@ -891,14 +891,14 @@ static int snd_rme9652_control_spdif_mask_get(struct snd_kcontrol *kcontrol, str .get = snd_rme9652_get_adat1_in, \ .put = snd_rme9652_put_adat1_in } -static unsigned int rme9652_adat1_in(struct snd_rme9652 *rme9652) +static unsigned int rme9652_adat1_in(rme9652_t *rme9652) { if (rme9652->control_register & RME9652_ADAT1_INTERNAL) return 1; return 0; } -static int rme9652_set_adat1_input(struct snd_rme9652 *rme9652, int internal) +static int rme9652_set_adat1_input(rme9652_t *rme9652, int internal) { int restart = 0; @@ -923,7 +923,7 @@ static int rme9652_set_adat1_input(struct snd_rme9652 *rme9652, int internal) return 0; } -static int snd_rme9652_info_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_adat1_in(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[2] = {"ADAT1", "Internal"}; @@ -936,9 +936,9 @@ static int snd_rme9652_info_adat1_in(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_rme9652_get_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_adat1_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme9652->lock); ucontrol->value.enumerated.item[0] = rme9652_adat1_in(rme9652); @@ -946,9 +946,9 @@ static int snd_rme9652_get_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_rme9652_put_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_put_adat1_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -968,13 +968,13 @@ static int snd_rme9652_put_adat1_in(struct snd_kcontrol *kcontrol, struct snd_ct .info = snd_rme9652_info_spdif_in, \ .get = snd_rme9652_get_spdif_in, .put = snd_rme9652_put_spdif_in } -static unsigned int rme9652_spdif_in(struct snd_rme9652 *rme9652) +static unsigned int rme9652_spdif_in(rme9652_t *rme9652) { return rme9652_decode_spdif_in(rme9652->control_register & RME9652_inp); } -static int rme9652_set_spdif_input(struct snd_rme9652 *rme9652, int in) +static int rme9652_set_spdif_input(rme9652_t *rme9652, int in) { int restart = 0; @@ -994,7 +994,7 @@ static int rme9652_set_spdif_input(struct snd_rme9652 *rme9652, int in) return 0; } -static int snd_rme9652_info_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_spdif_in(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[3] = {"ADAT1", "Coaxial", "Internal"}; @@ -1007,9 +1007,9 @@ static int snd_rme9652_info_spdif_in(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_rme9652_get_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_spdif_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme9652->lock); ucontrol->value.enumerated.item[0] = rme9652_spdif_in(rme9652); @@ -1017,9 +1017,9 @@ static int snd_rme9652_get_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_rme9652_put_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_put_spdif_in(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1039,12 +1039,12 @@ static int snd_rme9652_put_spdif_in(struct snd_kcontrol *kcontrol, struct snd_ct .info = snd_rme9652_info_spdif_out, \ .get = snd_rme9652_get_spdif_out, .put = snd_rme9652_put_spdif_out } -static int rme9652_spdif_out(struct snd_rme9652 *rme9652) +static int rme9652_spdif_out(rme9652_t *rme9652) { return (rme9652->control_register & RME9652_opt_out) ? 1 : 0; } -static int rme9652_set_spdif_output(struct snd_rme9652 *rme9652, int out) +static int rme9652_set_spdif_output(rme9652_t *rme9652, int out) { int restart = 0; @@ -1067,7 +1067,7 @@ static int rme9652_set_spdif_output(struct snd_rme9652 *rme9652, int out) return 0; } -static int snd_rme9652_info_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_spdif_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1076,9 +1076,9 @@ static int snd_rme9652_info_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_rme9652_get_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_spdif_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme9652->lock); ucontrol->value.integer.value[0] = rme9652_spdif_out(rme9652); @@ -1086,9 +1086,9 @@ static int snd_rme9652_get_spdif_out(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_rme9652_put_spdif_out(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_put_spdif_out(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1107,7 +1107,7 @@ static int snd_rme9652_put_spdif_out(struct snd_kcontrol *kcontrol, struct snd_c .info = snd_rme9652_info_sync_mode, \ .get = snd_rme9652_get_sync_mode, .put = snd_rme9652_put_sync_mode } -static int rme9652_sync_mode(struct snd_rme9652 *rme9652) +static int rme9652_sync_mode(rme9652_t *rme9652) { if (rme9652->control_register & RME9652_wsel) { return 2; @@ -1118,7 +1118,7 @@ static int rme9652_sync_mode(struct snd_rme9652 *rme9652) } } -static int rme9652_set_sync_mode(struct snd_rme9652 *rme9652, int mode) +static int rme9652_set_sync_mode(rme9652_t *rme9652, int mode) { int restart = 0; @@ -1150,7 +1150,7 @@ static int rme9652_set_sync_mode(struct snd_rme9652 *rme9652, int mode) return 0; } -static int snd_rme9652_info_sync_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_sync_mode(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[3] = {"AutoSync", "Master", "Word Clock"}; @@ -1163,9 +1163,9 @@ static int snd_rme9652_info_sync_mode(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_rme9652_get_sync_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_sync_mode(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme9652->lock); ucontrol->value.enumerated.item[0] = rme9652_sync_mode(rme9652); @@ -1173,9 +1173,9 @@ static int snd_rme9652_get_sync_mode(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_rme9652_put_sync_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_put_sync_mode(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; unsigned int val; @@ -1192,7 +1192,7 @@ static int snd_rme9652_put_sync_mode(struct snd_kcontrol *kcontrol, struct snd_c .info = snd_rme9652_info_sync_pref, \ .get = snd_rme9652_get_sync_pref, .put = snd_rme9652_put_sync_pref } -static int rme9652_sync_pref(struct snd_rme9652 *rme9652) +static int rme9652_sync_pref(rme9652_t *rme9652) { switch (rme9652->control_register & RME9652_SyncPref_Mask) { case RME9652_SyncPref_ADAT1: @@ -1208,7 +1208,7 @@ static int rme9652_sync_pref(struct snd_rme9652 *rme9652) return 0; } -static int rme9652_set_sync_pref(struct snd_rme9652 *rme9652, int pref) +static int rme9652_set_sync_pref(rme9652_t *rme9652, int pref) { int restart; @@ -1241,10 +1241,10 @@ static int rme9652_set_sync_pref(struct snd_rme9652 *rme9652, int pref) return 0; } -static int snd_rme9652_info_sync_pref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_sync_pref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = {"IEC958 In", "ADAT1 In", "ADAT2 In", "ADAT3 In"}; - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; @@ -1255,9 +1255,9 @@ static int snd_rme9652_info_sync_pref(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_rme9652_get_sync_pref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_sync_pref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme9652->lock); ucontrol->value.enumerated.item[0] = rme9652_sync_pref(rme9652); @@ -1265,9 +1265,9 @@ static int snd_rme9652_get_sync_pref(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_rme9652_put_sync_pref(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_put_sync_pref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change, max; unsigned int val; @@ -1282,9 +1282,9 @@ static int snd_rme9652_put_sync_pref(struct snd_kcontrol *kcontrol, struct snd_c return change; } -static int snd_rme9652_info_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_thru(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = rme9652->ss_channels; uinfo->value.integer.min = 0; @@ -1292,9 +1292,9 @@ static int snd_rme9652_info_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_rme9652_get_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_thru(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); unsigned int k; u32 thru_bits = rme9652->thru_bits; @@ -1304,9 +1304,9 @@ static int snd_rme9652_get_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_el return 0; } -static int snd_rme9652_put_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_put_thru(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; unsigned int chn; u32 thru_bits = 0; @@ -1338,7 +1338,7 @@ static int snd_rme9652_put_thru(struct snd_kcontrol *kcontrol, struct snd_ctl_el .put = snd_rme9652_put_passthru, \ .get = snd_rme9652_get_passthru } -static int snd_rme9652_info_passthru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_passthru(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1347,9 +1347,9 @@ static int snd_rme9652_info_passthru(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_rme9652_get_passthru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_passthru(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme9652->lock); ucontrol->value.integer.value[0] = rme9652->passthru; @@ -1357,9 +1357,9 @@ static int snd_rme9652_get_passthru(struct snd_kcontrol *kcontrol, struct snd_ct return 0; } -static int snd_rme9652_put_passthru(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_put_passthru(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); int change; unsigned int val; int err = 0; @@ -1384,7 +1384,7 @@ static int snd_rme9652_put_passthru(struct snd_kcontrol *kcontrol, struct snd_ct .info = snd_rme9652_info_spdif_rate, \ .get = snd_rme9652_get_spdif_rate } -static int snd_rme9652_info_spdif_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_spdif_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -1393,9 +1393,9 @@ static int snd_rme9652_info_spdif_rate(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_rme9652_get_spdif_rate(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_spdif_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); spin_lock_irq(&rme9652->lock); ucontrol->value.integer.value[0] = rme9652_spdif_sample_rate(rme9652); @@ -1409,7 +1409,7 @@ static int snd_rme9652_get_spdif_rate(struct snd_kcontrol *kcontrol, struct snd_ .info = snd_rme9652_info_adat_sync, \ .get = snd_rme9652_get_adat_sync, .private_value = xidx } -static int snd_rme9652_info_adat_sync(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_adat_sync(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[4] = {"No Lock", "Lock", "No Lock Sync", "Lock Sync"}; @@ -1422,9 +1422,9 @@ static int snd_rme9652_info_adat_sync(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_rme9652_get_adat_sync(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_adat_sync(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); unsigned int mask1, mask2, val; switch (kcontrol->private_value) { @@ -1445,7 +1445,7 @@ static int snd_rme9652_get_adat_sync(struct snd_kcontrol *kcontrol, struct snd_c .info = snd_rme9652_info_tc_valid, \ .get = snd_rme9652_get_tc_valid } -static int snd_rme9652_info_tc_valid(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_rme9652_info_tc_valid(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1454,9 +1454,9 @@ static int snd_rme9652_info_tc_valid(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_rme9652_get_tc_valid(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_rme9652_get_tc_valid(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_rme9652 *rme9652 = snd_kcontrol_chip(kcontrol); + rme9652_t *rme9652 = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = (rme9652_read(rme9652, RME9652_status_register) & RME9652_tc_valid) ? 1 : 0; @@ -1471,7 +1471,7 @@ static int snd_rme9652_get_tc_value(void *private_data, snd_kswitch_t *kswitch, snd_switch_t *uswitch) { - struct snd_rme9652 *s = (struct snd_rme9652 *) private_data; + rme9652_t *s = (rme9652_t *) private_data; u32 value; int i; @@ -1520,7 +1520,7 @@ static int snd_rme9652_get_tc_value(void *private_data, #endif /* ALSA_HAS_STANDARD_WAY_OF_RETURNING_TIMECODE */ -static struct snd_kcontrol_new snd_rme9652_controls[] = { +static snd_kcontrol_new_t snd_rme9652_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -1575,17 +1575,17 @@ RME9652_TC_VALID("Timecode Valid", 0), RME9652_PASSTHRU("Passthru", 0) }; -static struct snd_kcontrol_new snd_rme9652_adat3_check = +static snd_kcontrol_new_t snd_rme9652_adat3_check = RME9652_ADAT_SYNC("ADAT3 Sync Check", 0, 2); -static struct snd_kcontrol_new snd_rme9652_adat1_input = +static snd_kcontrol_new_t snd_rme9652_adat1_input = RME9652_ADAT1_IN("ADAT1 Input Source", 0); -static int snd_rme9652_create_controls(struct snd_card *card, struct snd_rme9652 *rme9652) +static int snd_rme9652_create_controls(snd_card_t *card, rme9652_t *rme9652) { unsigned int idx; int err; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; for (idx = 0; idx < ARRAY_SIZE(snd_rme9652_controls); idx++) { if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_rme9652_controls[idx], rme9652))) < 0) @@ -1610,9 +1610,9 @@ static int snd_rme9652_create_controls(struct snd_card *card, struct snd_rme9652 ------------------------------------------------------------*/ static void -snd_rme9652_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +snd_rme9652_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) entry->private_data; + rme9652_t *rme9652 = (rme9652_t *) entry->private_data; u32 thru_bits = rme9652->thru_bits; int show_auto_sync_source = 0; int i; @@ -1782,21 +1782,21 @@ snd_rme9652_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buff snd_iprintf(buffer, "\n"); } -static void __devinit snd_rme9652_proc_init(struct snd_rme9652 *rme9652) +static void __devinit snd_rme9652_proc_init(rme9652_t *rme9652) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(rme9652->card, "rme9652", &entry)) snd_info_set_text_ops(entry, rme9652, 1024, snd_rme9652_proc_read); } -static void snd_rme9652_free_buffers(struct snd_rme9652 *rme9652) +static void snd_rme9652_free_buffers(rme9652_t *rme9652) { snd_hammerfall_free_buffer(&rme9652->capture_dma_buf, rme9652->pci); snd_hammerfall_free_buffer(&rme9652->playback_dma_buf, rme9652->pci); } -static int snd_rme9652_free(struct snd_rme9652 *rme9652) +static int snd_rme9652_free(rme9652_t *rme9652) { if (rme9652->irq >= 0) rme9652_stop(rme9652); @@ -1813,7 +1813,7 @@ static int snd_rme9652_free(struct snd_rme9652 *rme9652) return 0; } -static int __devinit snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652) +static int __devinit snd_rme9652_initialize_memory(rme9652_t *rme9652) { unsigned long pb_bus, cb_bus; @@ -1841,7 +1841,7 @@ static int __devinit snd_rme9652_initialize_memory(struct snd_rme9652 *rme9652) return 0; } -static void snd_rme9652_set_defaults(struct snd_rme9652 *rme9652) +static void snd_rme9652_set_defaults(rme9652_t *rme9652) { unsigned int k; @@ -1884,7 +1884,7 @@ static void snd_rme9652_set_defaults(struct snd_rme9652 *rme9652) static irqreturn_t snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) dev_id; + rme9652_t *rme9652 = (rme9652_t *) dev_id; if (!(rme9652_read(rme9652, RME9652_status_register) & RME9652_IRQ)) { return IRQ_NONE; @@ -1902,13 +1902,13 @@ static irqreturn_t snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs * return IRQ_HANDLED; } -static snd_pcm_uframes_t snd_rme9652_hw_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_rme9652_hw_pointer(snd_pcm_substream_t *substream) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); return rme9652_hw_pointer(rme9652); } -static char *rme9652_channel_buffer_location(struct snd_rme9652 *rme9652, +static char *rme9652_channel_buffer_location(rme9652_t *rme9652, int stream, int channel) @@ -1930,10 +1930,10 @@ static char *rme9652_channel_buffer_location(struct snd_rme9652 *rme9652, } } -static int snd_rme9652_playback_copy(struct snd_pcm_substream *substream, int channel, +static int snd_rme9652_playback_copy(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, void __user *src, snd_pcm_uframes_t count) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); char *channel_buf; snd_assert(pos + count <= RME9652_CHANNEL_BUFFER_BYTES / 4, return -EINVAL); @@ -1947,10 +1947,10 @@ static int snd_rme9652_playback_copy(struct snd_pcm_substream *substream, int ch return count; } -static int snd_rme9652_capture_copy(struct snd_pcm_substream *substream, int channel, +static int snd_rme9652_capture_copy(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, void __user *dst, snd_pcm_uframes_t count) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); char *channel_buf; snd_assert(pos + count <= RME9652_CHANNEL_BUFFER_BYTES / 4, return -EINVAL); @@ -1964,10 +1964,10 @@ static int snd_rme9652_capture_copy(struct snd_pcm_substream *substream, int cha return count; } -static int snd_rme9652_hw_silence(struct snd_pcm_substream *substream, int channel, +static int snd_rme9652_hw_silence(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); char *channel_buf; channel_buf = rme9652_channel_buffer_location (rme9652, @@ -1978,11 +1978,11 @@ static int snd_rme9652_hw_silence(struct snd_pcm_substream *substream, int chann return count; } -static int snd_rme9652_reset(struct snd_pcm_substream *substream) +static int snd_rme9652_reset(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); - struct snd_pcm_substream *other; + snd_pcm_runtime_t *runtime = substream->runtime; + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); + snd_pcm_substream_t *other; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) other = rme9652->capture_substream; else @@ -1993,8 +1993,8 @@ static int snd_rme9652_reset(struct snd_pcm_substream *substream) runtime->status->hw_ptr = 0; if (other) { struct list_head *pos; - struct snd_pcm_substream *s; - struct snd_pcm_runtime *oruntime = other->runtime; + snd_pcm_substream_t *s; + snd_pcm_runtime_t *oruntime = other->runtime; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == other) { @@ -2006,10 +2006,10 @@ static int snd_rme9652_reset(struct snd_pcm_substream *substream) return 0; } -static int snd_rme9652_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params) +static int snd_rme9652_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *params) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); int err; pid_t this_pid; pid_t other_pid; @@ -2071,10 +2071,10 @@ static int snd_rme9652_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_rme9652_channel_info(struct snd_pcm_substream *substream, - struct snd_pcm_channel_info *info) +static int snd_rme9652_channel_info(snd_pcm_substream_t *substream, + snd_pcm_channel_info_t *info) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); int chn; snd_assert(info->channel < RME9652_NCHANNELS, return -EINVAL); @@ -2089,7 +2089,7 @@ static int snd_rme9652_channel_info(struct snd_pcm_substream *substream, return 0; } -static int snd_rme9652_ioctl(struct snd_pcm_substream *substream, +static int snd_rme9652_ioctl(snd_pcm_substream_t *substream, unsigned int cmd, void *arg) { switch (cmd) { @@ -2099,7 +2099,7 @@ static int snd_rme9652_ioctl(struct snd_pcm_substream *substream, } case SNDRV_PCM_IOCTL1_CHANNEL_INFO: { - struct snd_pcm_channel_info *info = arg; + snd_pcm_channel_info_t *info = arg; return snd_rme9652_channel_info(substream, info); } default: @@ -2109,16 +2109,16 @@ static int snd_rme9652_ioctl(struct snd_pcm_substream *substream, return snd_pcm_lib_ioctl(substream, cmd, arg); } -static void rme9652_silence_playback(struct snd_rme9652 *rme9652) +static void rme9652_silence_playback(rme9652_t *rme9652) { memset(rme9652->playback_buffer, 0, RME9652_DMA_AREA_BYTES); } -static int snd_rme9652_trigger(struct snd_pcm_substream *substream, +static int snd_rme9652_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); - struct snd_pcm_substream *other; + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); + snd_pcm_substream_t *other; int running; spin_lock(&rme9652->lock); running = rme9652->running; @@ -2141,7 +2141,7 @@ static int snd_rme9652_trigger(struct snd_pcm_substream *substream, if (other) { struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); if (s == other) { @@ -2178,9 +2178,9 @@ static int snd_rme9652_trigger(struct snd_pcm_substream *substream, return 0; } -static int snd_rme9652_prepare(struct snd_pcm_substream *substream) +static int snd_rme9652_prepare(snd_pcm_substream_t *substream) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); unsigned long flags; int result = 0; @@ -2191,7 +2191,7 @@ static int snd_rme9652_prepare(struct snd_pcm_substream *substream) return result; } -static struct snd_pcm_hardware snd_rme9652_playback_subinfo = +static snd_pcm_hardware_t snd_rme9652_playback_subinfo = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -2215,7 +2215,7 @@ static struct snd_pcm_hardware snd_rme9652_playback_subinfo = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_rme9652_capture_subinfo = +static snd_pcm_hardware_t snd_rme9652_capture_subinfo = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -2240,36 +2240,36 @@ static struct snd_pcm_hardware snd_rme9652_capture_subinfo = static unsigned int period_sizes[] = { 64, 128, 256, 512, 1024, 2048, 4096, 8192 }; -static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes = { +static snd_pcm_hw_constraint_list_t hw_constraints_period_sizes = { .count = ARRAY_SIZE(period_sizes), .list = period_sizes, .mask = 0 }; -static int snd_rme9652_hw_rule_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_rme9652_hw_rule_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_rme9652 *rme9652 = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + rme9652_t *rme9652 = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); unsigned int list[2] = { rme9652->ds_channels, rme9652->ss_channels }; return snd_interval_list(c, 2, list, 0); } -static int snd_rme9652_hw_rule_channels_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_rme9652_hw_rule_channels_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_rme9652 *rme9652 = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + rme9652_t *rme9652 = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (r->min > 48000) { - struct snd_interval t = { + snd_interval_t t = { .min = rme9652->ds_channels, .max = rme9652->ds_channels, .integer = 1, }; return snd_interval_refine(c, &t); } else if (r->max < 88200) { - struct snd_interval t = { + snd_interval_t t = { .min = rme9652->ss_channels, .max = rme9652->ss_channels, .integer = 1, @@ -2279,21 +2279,21 @@ static int snd_rme9652_hw_rule_channels_rate(struct snd_pcm_hw_params *params, return 0; } -static int snd_rme9652_hw_rule_rate_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_rme9652_hw_rule_rate_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_rme9652 *rme9652 = rule->private; - struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + rme9652_t *rme9652 = rule->private; + snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); if (c->min >= rme9652->ss_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 44100, .max = 48000, .integer = 1, }; return snd_interval_refine(r, &t); } else if (c->max <= rme9652->ds_channels) { - struct snd_interval t = { + snd_interval_t t = { .min = 88200, .max = 96000, .integer = 1, @@ -2303,10 +2303,10 @@ static int snd_rme9652_hw_rule_rate_channels(struct snd_pcm_hw_params *params, return 0; } -static int snd_rme9652_playback_open(struct snd_pcm_substream *substream) +static int snd_rme9652_playback_open(snd_pcm_substream_t *substream) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; spin_lock_irq(&rme9652->lock); @@ -2345,9 +2345,9 @@ static int snd_rme9652_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_rme9652_playback_release(struct snd_pcm_substream *substream) +static int snd_rme9652_playback_release(snd_pcm_substream_t *substream) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme9652->lock); @@ -2363,10 +2363,10 @@ static int snd_rme9652_playback_release(struct snd_pcm_substream *substream) } -static int snd_rme9652_capture_open(struct snd_pcm_substream *substream) +static int snd_rme9652_capture_open(snd_pcm_substream_t *substream) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; spin_lock_irq(&rme9652->lock); @@ -2400,9 +2400,9 @@ static int snd_rme9652_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_rme9652_capture_release(struct snd_pcm_substream *substream) +static int snd_rme9652_capture_release(snd_pcm_substream_t *substream) { - struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream); + rme9652_t *rme9652 = snd_pcm_substream_chip(substream); spin_lock_irq(&rme9652->lock); @@ -2413,7 +2413,7 @@ static int snd_rme9652_capture_release(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_rme9652_playback_ops = { +static snd_pcm_ops_t snd_rme9652_playback_ops = { .open = snd_rme9652_playback_open, .close = snd_rme9652_playback_release, .ioctl = snd_rme9652_ioctl, @@ -2425,7 +2425,7 @@ static struct snd_pcm_ops snd_rme9652_playback_ops = { .silence = snd_rme9652_hw_silence, }; -static struct snd_pcm_ops snd_rme9652_capture_ops = { +static snd_pcm_ops_t snd_rme9652_capture_ops = { .open = snd_rme9652_capture_open, .close = snd_rme9652_capture_release, .ioctl = snd_rme9652_ioctl, @@ -2436,10 +2436,10 @@ static struct snd_pcm_ops snd_rme9652_capture_ops = { .copy = snd_rme9652_capture_copy, }; -static int __devinit snd_rme9652_create_pcm(struct snd_card *card, - struct snd_rme9652 *rme9652) +static int __devinit snd_rme9652_create_pcm(snd_card_t *card, + rme9652_t *rme9652) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(card, @@ -2460,8 +2460,8 @@ static int __devinit snd_rme9652_create_pcm(struct snd_card *card, return 0; } -static int __devinit snd_rme9652_create(struct snd_card *card, - struct snd_rme9652 *rme9652, +static int __devinit snd_rme9652_create(snd_card_t *card, + rme9652_t *rme9652, int precise_ptr) { struct pci_dev *pci = rme9652->pci; @@ -2591,9 +2591,9 @@ static int __devinit snd_rme9652_create(struct snd_card *card, return 0; } -static void snd_rme9652_card_free(struct snd_card *card) +static void snd_rme9652_card_free(snd_card_t *card) { - struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) card->private_data; + rme9652_t *rme9652 = (rme9652_t *) card->private_data; if (rme9652) snd_rme9652_free(rme9652); @@ -2603,8 +2603,8 @@ static int __devinit snd_rme9652_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_rme9652 *rme9652; - struct snd_card *card; + rme9652_t *rme9652; + snd_card_t *card; int err; if (dev >= SNDRV_CARDS) @@ -2615,12 +2615,12 @@ static int __devinit snd_rme9652_probe(struct pci_dev *pci, } card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof(struct snd_rme9652)); + sizeof(rme9652_t)); if (!card) return -ENOMEM; - rme9652 = (struct snd_rme9652 *) card->private_data; + rme9652 = (rme9652_t *) card->private_data; card->private_free = snd_rme9652_card_free; rme9652->dev = dev; rme9652->pci = pci; diff --git a/trunk/sound/pci/sonicvibes.c b/trunk/sound/pci/sonicvibes.c index 7bbea3738b8a..e92ef3ae2ca1 100644 --- a/trunk/sound/pci/sonicvibes.c +++ b/trunk/sound/pci/sonicvibes.c @@ -195,7 +195,9 @@ MODULE_PARM_DESC(dmaio, "DDMA i/o base address for S3 SonicVibes soundcard."); */ -struct sonicvibes { +typedef struct _snd_sonicvibes sonicvibes_t; + +struct _snd_sonicvibes { unsigned long dma1size; unsigned long dma2size; int irq; @@ -222,20 +224,20 @@ struct sonicvibes { unsigned int mode; struct pci_dev *pci; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; - struct snd_rawmidi *rmidi; - struct snd_hwdep *fmsynth; /* S3FM */ + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; + snd_rawmidi_t *rmidi; + snd_hwdep_t *fmsynth; /* S3FM */ spinlock_t reg_lock; unsigned int p_dma_size; unsigned int c_dma_size; - struct snd_kcontrol *master_mute; - struct snd_kcontrol *master_volume; + snd_kcontrol_t *master_mute; + snd_kcontrol_t *master_volume; #ifdef SUPPORT_JOYSTICK struct gameport *gameport; @@ -249,13 +251,13 @@ static struct pci_device_id snd_sonic_ids[] = { MODULE_DEVICE_TABLE(pci, snd_sonic_ids); -static struct snd_ratden sonicvibes_adc_clock = { +static ratden_t sonicvibes_adc_clock = { .num_min = 4000 * 65536, .num_max = 48000UL * 65536, .num_step = 1, .den = 65536, }; -static struct snd_pcm_hw_constraint_ratdens snd_sonicvibes_hw_constraints_adc_clock = { +static snd_pcm_hw_constraint_ratdens_t snd_sonicvibes_hw_constraints_adc_clock = { .nrats = 1, .rats = &sonicvibes_adc_clock, }; @@ -264,7 +266,7 @@ static struct snd_pcm_hw_constraint_ratdens snd_sonicvibes_hw_constraints_adc_cl * common I/O routines */ -static inline void snd_sonicvibes_setdmaa(struct sonicvibes * sonic, +static inline void snd_sonicvibes_setdmaa(sonicvibes_t * sonic, unsigned int addr, unsigned int count) { @@ -277,7 +279,7 @@ static inline void snd_sonicvibes_setdmaa(struct sonicvibes * sonic, #endif } -static inline void snd_sonicvibes_setdmac(struct sonicvibes * sonic, +static inline void snd_sonicvibes_setdmac(sonicvibes_t * sonic, unsigned int addr, unsigned int count) { @@ -292,18 +294,18 @@ static inline void snd_sonicvibes_setdmac(struct sonicvibes * sonic, #endif } -static inline unsigned int snd_sonicvibes_getdmaa(struct sonicvibes * sonic) +static inline unsigned int snd_sonicvibes_getdmaa(sonicvibes_t * sonic) { return (inl(sonic->dmaa_port + SV_DMA_COUNT0) & 0xffffff) + 1; } -static inline unsigned int snd_sonicvibes_getdmac(struct sonicvibes * sonic) +static inline unsigned int snd_sonicvibes_getdmac(sonicvibes_t * sonic) { /* note: dmac is working in word mode!!! */ return ((inl(sonic->dmac_port + SV_DMA_COUNT0) & 0xffffff) + 1) << 1; } -static void snd_sonicvibes_out1(struct sonicvibes * sonic, +static void snd_sonicvibes_out1(sonicvibes_t * sonic, unsigned char reg, unsigned char value) { @@ -313,7 +315,7 @@ static void snd_sonicvibes_out1(struct sonicvibes * sonic, udelay(10); } -static void snd_sonicvibes_out(struct sonicvibes * sonic, +static void snd_sonicvibes_out(sonicvibes_t * sonic, unsigned char reg, unsigned char value) { @@ -327,7 +329,7 @@ static void snd_sonicvibes_out(struct sonicvibes * sonic, spin_unlock_irqrestore(&sonic->reg_lock, flags); } -static unsigned char snd_sonicvibes_in1(struct sonicvibes * sonic, unsigned char reg) +static unsigned char snd_sonicvibes_in1(sonicvibes_t * sonic, unsigned char reg) { unsigned char value; @@ -338,7 +340,7 @@ static unsigned char snd_sonicvibes_in1(struct sonicvibes * sonic, unsigned char return value; } -static unsigned char snd_sonicvibes_in(struct sonicvibes * sonic, unsigned char reg) +static unsigned char snd_sonicvibes_in(sonicvibes_t * sonic, unsigned char reg) { unsigned long flags; unsigned char value; @@ -353,7 +355,7 @@ static unsigned char snd_sonicvibes_in(struct sonicvibes * sonic, unsigned char } #if 0 -static void snd_sonicvibes_debug(struct sonicvibes * sonic) +static void snd_sonicvibes_debug(sonicvibes_t * sonic) { printk("SV REGS: INDEX = 0x%02x ", inb(SV_REG(sonic, INDEX))); printk(" STATUS = 0x%02x\n", inb(SV_REG(sonic, STATUS))); @@ -425,7 +427,7 @@ static void snd_sonicvibes_debug(struct sonicvibes * sonic) #endif -static void snd_sonicvibes_setfmt(struct sonicvibes * sonic, +static void snd_sonicvibes_setfmt(sonicvibes_t * sonic, unsigned char mask, unsigned char value) { @@ -481,7 +483,7 @@ static void snd_sonicvibes_pll(unsigned int rate, #endif } -static void snd_sonicvibes_setpll(struct sonicvibes * sonic, +static void snd_sonicvibes_setpll(sonicvibes_t * sonic, unsigned char reg, unsigned int rate) { @@ -497,7 +499,7 @@ static void snd_sonicvibes_setpll(struct sonicvibes * sonic, } } -static void snd_sonicvibes_set_adc_rate(struct sonicvibes * sonic, unsigned int rate) +static void snd_sonicvibes_set_adc_rate(sonicvibes_t * sonic, unsigned int rate) { unsigned long flags; unsigned int div; @@ -518,8 +520,8 @@ static void snd_sonicvibes_set_adc_rate(struct sonicvibes * sonic, unsigned int spin_unlock_irqrestore(&sonic->reg_lock, flags); } -static int snd_sonicvibes_hw_constraint_dac_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_sonicvibes_hw_constraint_dac_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { unsigned int rate, div, r, m, n; @@ -543,7 +545,7 @@ static int snd_sonicvibes_hw_constraint_dac_rate(struct snd_pcm_hw_params *param return 0; } -static void snd_sonicvibes_set_dac_rate(struct sonicvibes * sonic, unsigned int rate) +static void snd_sonicvibes_set_dac_rate(sonicvibes_t * sonic, unsigned int rate) { unsigned int div; unsigned long flags; @@ -557,7 +559,7 @@ static void snd_sonicvibes_set_dac_rate(struct sonicvibes * sonic, unsigned int spin_unlock_irqrestore(&sonic->reg_lock, flags); } -static int snd_sonicvibes_trigger(struct sonicvibes * sonic, int what, int cmd) +static int snd_sonicvibes_trigger(sonicvibes_t * sonic, int what, int cmd) { int result = 0; @@ -581,7 +583,7 @@ static int snd_sonicvibes_trigger(struct sonicvibes * sonic, int what, int cmd) static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct sonicvibes *sonic = dev_id; + sonicvibes_t *sonic = dev_id; unsigned char status; status = inb(SV_REG(sonic, STATUS)); @@ -644,35 +646,35 @@ static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_reg * PCM part */ -static int snd_sonicvibes_playback_trigger(struct snd_pcm_substream *substream, +static int snd_sonicvibes_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); return snd_sonicvibes_trigger(sonic, 1, cmd); } -static int snd_sonicvibes_capture_trigger(struct snd_pcm_substream *substream, +static int snd_sonicvibes_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); return snd_sonicvibes_trigger(sonic, 2, cmd); } -static int snd_sonicvibes_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_sonicvibes_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_sonicvibes_hw_free(struct snd_pcm_substream *substream) +static int snd_sonicvibes_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_sonicvibes_playback_prepare(struct snd_pcm_substream *substream) +static int snd_sonicvibes_playback_prepare(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned char fmt = 0; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -693,10 +695,10 @@ static int snd_sonicvibes_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_sonicvibes_capture_prepare(struct snd_pcm_substream *substream) +static int snd_sonicvibes_capture_prepare(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned char fmt = 0; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned int count = snd_pcm_lib_period_bytes(substream); @@ -718,9 +720,9 @@ static int snd_sonicvibes_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_sonicvibes_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_sonicvibes_playback_pointer(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); size_t ptr; if (!(sonic->enable & 1)) @@ -729,9 +731,9 @@ static snd_pcm_uframes_t snd_sonicvibes_playback_pointer(struct snd_pcm_substrea return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_sonicvibes_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_sonicvibes_capture_pointer(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); size_t ptr; if (!(sonic->enable & 2)) return 0; @@ -739,7 +741,7 @@ static snd_pcm_uframes_t snd_sonicvibes_capture_pointer(struct snd_pcm_substream return bytes_to_frames(substream->runtime, ptr); } -static struct snd_pcm_hardware snd_sonicvibes_playback = +static snd_pcm_hardware_t snd_sonicvibes_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -758,7 +760,7 @@ static struct snd_pcm_hardware snd_sonicvibes_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_sonicvibes_capture = +static snd_pcm_hardware_t snd_sonicvibes_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -777,10 +779,10 @@ static struct snd_pcm_hardware snd_sonicvibes_capture = .fifo_size = 0, }; -static int snd_sonicvibes_playback_open(struct snd_pcm_substream *substream) +static int snd_sonicvibes_playback_open(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; sonic->mode |= SV_MODE_PLAY; sonic->playback_substream = substream; @@ -789,10 +791,10 @@ static int snd_sonicvibes_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_sonicvibes_capture_open(struct snd_pcm_substream *substream) +static int snd_sonicvibes_capture_open(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; sonic->mode |= SV_MODE_CAPTURE; sonic->capture_substream = substream; @@ -802,25 +804,25 @@ static int snd_sonicvibes_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_sonicvibes_playback_close(struct snd_pcm_substream *substream) +static int snd_sonicvibes_playback_close(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); sonic->playback_substream = NULL; sonic->mode &= ~SV_MODE_PLAY; return 0; } -static int snd_sonicvibes_capture_close(struct snd_pcm_substream *substream) +static int snd_sonicvibes_capture_close(snd_pcm_substream_t * substream) { - struct sonicvibes *sonic = snd_pcm_substream_chip(substream); + sonicvibes_t *sonic = snd_pcm_substream_chip(substream); sonic->capture_substream = NULL; sonic->mode &= ~SV_MODE_CAPTURE; return 0; } -static struct snd_pcm_ops snd_sonicvibes_playback_ops = { +static snd_pcm_ops_t snd_sonicvibes_playback_ops = { .open = snd_sonicvibes_playback_open, .close = snd_sonicvibes_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -831,7 +833,7 @@ static struct snd_pcm_ops snd_sonicvibes_playback_ops = { .pointer = snd_sonicvibes_playback_pointer, }; -static struct snd_pcm_ops snd_sonicvibes_capture_ops = { +static snd_pcm_ops_t snd_sonicvibes_capture_ops = { .open = snd_sonicvibes_capture_open, .close = snd_sonicvibes_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -842,9 +844,16 @@ static struct snd_pcm_ops snd_sonicvibes_capture_ops = { .pointer = snd_sonicvibes_capture_pointer, }; -static int __devinit snd_sonicvibes_pcm(struct sonicvibes * sonic, int device, struct snd_pcm ** rpcm) +static void snd_sonicvibes_pcm_free(snd_pcm_t *pcm) +{ + sonicvibes_t *sonic = pcm->private_data; + sonic->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __devinit snd_sonicvibes_pcm(sonicvibes_t * sonic, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(sonic->card, "s3_86c617", device, 1, 1, &pcm)) < 0) @@ -855,6 +864,7 @@ static int __devinit snd_sonicvibes_pcm(struct sonicvibes * sonic, int device, s snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sonicvibes_capture_ops); pcm->private_data = sonic; + pcm->private_free = snd_sonicvibes_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, "S3 SonicVibes"); sonic->pcm = pcm; @@ -876,7 +886,7 @@ static int __devinit snd_sonicvibes_pcm(struct sonicvibes * sonic, int device, s .info = snd_sonicvibes_info_mux, \ .get = snd_sonicvibes_get_mux, .put = snd_sonicvibes_put_mux } -static int snd_sonicvibes_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sonicvibes_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { static char *texts[7] = { "CD", "PCM", "Aux1", "Line", "Aux0", "Mic", "Mix" @@ -891,9 +901,9 @@ static int snd_sonicvibes_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_sonicvibes_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sonicvibes_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); + sonicvibes_t *sonic = snd_kcontrol_chip(kcontrol); spin_lock_irq(&sonic->reg_lock); ucontrol->value.enumerated.item[0] = ((snd_sonicvibes_in1(sonic, SV_IREG_LEFT_ADC) & SV_RECSRC_OUT) >> 5) - 1; @@ -902,9 +912,9 @@ static int snd_sonicvibes_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_sonicvibes_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sonicvibes_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); + sonicvibes_t *sonic = snd_kcontrol_chip(kcontrol); unsigned short left, right, oval1, oval2; int change; @@ -931,7 +941,7 @@ static int snd_sonicvibes_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_ .get = snd_sonicvibes_get_single, .put = snd_sonicvibes_put_single, \ .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } -static int snd_sonicvibes_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sonicvibes_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -942,9 +952,9 @@ static int snd_sonicvibes_info_single(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_sonicvibes_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sonicvibes_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); + sonicvibes_t *sonic = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -958,9 +968,9 @@ static int snd_sonicvibes_get_single(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_sonicvibes_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sonicvibes_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); + sonicvibes_t *sonic = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -987,7 +997,7 @@ static int snd_sonicvibes_put_single(struct snd_kcontrol *kcontrol, struct snd_c .get = snd_sonicvibes_get_double, .put = snd_sonicvibes_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static int snd_sonicvibes_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_sonicvibes_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -998,9 +1008,9 @@ static int snd_sonicvibes_info_double(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_sonicvibes_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sonicvibes_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); + sonicvibes_t *sonic = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; @@ -1019,9 +1029,9 @@ static int snd_sonicvibes_get_double(struct snd_kcontrol *kcontrol, struct snd_c return 0; } -static int snd_sonicvibes_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_sonicvibes_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); + sonicvibes_t *sonic = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; @@ -1051,7 +1061,7 @@ static int snd_sonicvibes_put_double(struct snd_kcontrol *kcontrol, struct snd_c return change; } -static struct snd_kcontrol_new snd_sonicvibes_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_sonicvibes_controls[] __devinitdata = { SONICVIBES_DOUBLE("Capture Volume", 0, SV_IREG_LEFT_ADC, SV_IREG_RIGHT_ADC, 0, 0, 15, 0), SONICVIBES_DOUBLE("Aux Playback Switch", 0, SV_IREG_LEFT_AUX1, SV_IREG_RIGHT_AUX1, 7, 7, 1, 1), SONICVIBES_DOUBLE("Aux Playback Volume", 0, SV_IREG_LEFT_AUX1, SV_IREG_RIGHT_AUX1, 0, 0, 31, 1), @@ -1075,17 +1085,17 @@ SONICVIBES_SINGLE("Loopback Capture Volume", 0, SV_IREG_ADC_OUTPUT_CTRL, 2, 63, SONICVIBES_MUX("Capture Source", 0) }; -static void snd_sonicvibes_master_free(struct snd_kcontrol *kcontrol) +static void snd_sonicvibes_master_free(snd_kcontrol_t *kcontrol) { - struct sonicvibes *sonic = snd_kcontrol_chip(kcontrol); + sonicvibes_t *sonic = snd_kcontrol_chip(kcontrol); sonic->master_mute = NULL; sonic->master_volume = NULL; } -static int __devinit snd_sonicvibes_mixer(struct sonicvibes * sonic) +static int __devinit snd_sonicvibes_mixer(sonicvibes_t * sonic) { - struct snd_card *card; - struct snd_kcontrol *kctl; + snd_card_t *card; + snd_kcontrol_t *kctl; unsigned int idx; int err; @@ -1108,10 +1118,10 @@ static int __devinit snd_sonicvibes_mixer(struct sonicvibes * sonic) */ -static void snd_sonicvibes_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_sonicvibes_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct sonicvibes *sonic = entry->private_data; + sonicvibes_t *sonic = entry->private_data; unsigned char tmp; tmp = sonic->srs_space & 0x0f; @@ -1138,9 +1148,9 @@ static void snd_sonicvibes_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, "MIDI to ext. Tx : %s\n", tmp & 0x04 ? "on" : "off"); } -static void __devinit snd_sonicvibes_proc_init(struct sonicvibes * sonic) +static void __devinit snd_sonicvibes_proc_init(sonicvibes_t * sonic) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry)) snd_info_set_text_ops(entry, sonic, 1024, snd_sonicvibes_proc_read); @@ -1151,10 +1161,10 @@ static void __devinit snd_sonicvibes_proc_init(struct sonicvibes * sonic) */ #ifdef SUPPORT_JOYSTICK -static struct snd_kcontrol_new snd_sonicvibes_game_control __devinitdata = +static snd_kcontrol_new_t snd_sonicvibes_game_control __devinitdata = SONICVIBES_SINGLE("Joystick Speed", 0, SV_IREG_GAME_PORT, 1, 15, 0); -static int __devinit snd_sonicvibes_create_gameport(struct sonicvibes *sonic) +static int __devinit snd_sonicvibes_create_gameport(sonicvibes_t *sonic) { struct gameport *gp; @@ -1176,7 +1186,7 @@ static int __devinit snd_sonicvibes_create_gameport(struct sonicvibes *sonic) return 0; } -static void snd_sonicvibes_free_gameport(struct sonicvibes *sonic) +static void snd_sonicvibes_free_gameport(sonicvibes_t *sonic) { if (sonic->gameport) { gameport_unregister_port(sonic->gameport); @@ -1184,11 +1194,11 @@ static void snd_sonicvibes_free_gameport(struct sonicvibes *sonic) } } #else -static inline int snd_sonicvibes_create_gameport(struct sonicvibes *sonic) { return -ENOSYS; } -static inline void snd_sonicvibes_free_gameport(struct sonicvibes *sonic) { } +static inline int snd_sonicvibes_create_gameport(sonicvibes_t *sonic) { return -ENOSYS; } +static inline void snd_sonicvibes_free_gameport(sonicvibes_t *sonic) { } #endif -static int snd_sonicvibes_free(struct sonicvibes *sonic) +static int snd_sonicvibes_free(sonicvibes_t *sonic) { snd_sonicvibes_free_gameport(sonic); pci_write_config_dword(sonic->pci, 0x40, sonic->dmaa_port); @@ -1203,22 +1213,22 @@ static int snd_sonicvibes_free(struct sonicvibes *sonic) return 0; } -static int snd_sonicvibes_dev_free(struct snd_device *device) +static int snd_sonicvibes_dev_free(snd_device_t *device) { - struct sonicvibes *sonic = device->device_data; + sonicvibes_t *sonic = device->device_data; return snd_sonicvibes_free(sonic); } -static int __devinit snd_sonicvibes_create(struct snd_card *card, +static int __devinit snd_sonicvibes_create(snd_card_t * card, struct pci_dev *pci, int reverb, int mge, - struct sonicvibes ** rsonic) + sonicvibes_t ** rsonic) { - struct sonicvibes *sonic; + sonicvibes_t *sonic; unsigned int dmaa, dmac; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_sonicvibes_dev_free, }; @@ -1363,7 +1373,7 @@ static int __devinit snd_sonicvibes_create(struct snd_card *card, * MIDI section */ -static struct snd_kcontrol_new snd_sonicvibes_midi_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_sonicvibes_midi_controls[] __devinitdata = { SONICVIBES_SINGLE("SonicVibes Wave Source RAM", 0, SV_IREG_WAVE_SOURCE, 0, 1, 0), SONICVIBES_SINGLE("SonicVibes Wave Source RAM+ROM", 0, SV_IREG_WAVE_SOURCE, 1, 1, 0), SONICVIBES_SINGLE("SonicVibes Onboard Synth", 0, SV_IREG_MPU401, 0, 1, 0), @@ -1371,25 +1381,24 @@ SONICVIBES_SINGLE("SonicVibes External Rx to Synth", 0, SV_IREG_MPU401, 1, 1, 0) SONICVIBES_SINGLE("SonicVibes External Tx", 0, SV_IREG_MPU401, 2, 1, 0) }; -static int snd_sonicvibes_midi_input_open(struct snd_mpu401 * mpu) +static int snd_sonicvibes_midi_input_open(mpu401_t * mpu) { - struct sonicvibes *sonic = mpu->private_data; + sonicvibes_t *sonic = mpu->private_data; outb(sonic->irqmask &= ~SV_MIDI_MASK, SV_REG(sonic, IRQMASK)); return 0; } -static void snd_sonicvibes_midi_input_close(struct snd_mpu401 * mpu) +static void snd_sonicvibes_midi_input_close(mpu401_t * mpu) { - struct sonicvibes *sonic = mpu->private_data; + sonicvibes_t *sonic = mpu->private_data; outb(sonic->irqmask |= SV_MIDI_MASK, SV_REG(sonic, IRQMASK)); } -static int __devinit snd_sonicvibes_midi(struct sonicvibes * sonic, - struct snd_rawmidi *rmidi) +static int __devinit snd_sonicvibes_midi(sonicvibes_t * sonic, snd_rawmidi_t * rmidi) { - struct snd_mpu401 * mpu = rmidi->private_data; - struct snd_card *card = sonic->card; - struct snd_rawmidi_str *dir; + mpu401_t * mpu = rmidi->private_data; + snd_card_t *card = sonic->card; + snd_rawmidi_str_t *dir; unsigned int idx; int err; @@ -1407,10 +1416,10 @@ static int __devinit snd_sonic_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct sonicvibes *sonic; - struct snd_rawmidi *midi_uart; - struct snd_opl3 *opl3; + snd_card_t *card; + sonicvibes_t *sonic; + snd_rawmidi_t *midi_uart; + opl3_t *opl3; int idx, err; if (dev >= SNDRV_CARDS) diff --git a/trunk/sound/pci/trident/trident.c b/trunk/sound/pci/trident/trident.c index 2b21df16ad6a..940d531575c0 100644 --- a/trunk/sound/pci/trident/trident.c +++ b/trunk/sound/pci/trident/trident.c @@ -76,8 +76,8 @@ static int __devinit snd_trident_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; - struct snd_trident *trident; + snd_card_t *card; + trident_t *trident; const char *str; int err, pcm_dev = 0; @@ -100,7 +100,6 @@ static int __devinit snd_trident_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = trident; switch (trident->device) { case TRIDENT_DEVICE_ID_DX: @@ -181,10 +180,7 @@ static struct pci_driver driver = { .id_table = snd_trident_ids, .probe = snd_trident_probe, .remove = __devexit_p(snd_trident_remove), -#ifdef CONFIG_PM - .suspend = snd_trident_suspend, - .resume = snd_trident_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_trident_init(void) diff --git a/trunk/sound/pci/trident/trident_main.c b/trunk/sound/pci/trident/trident_main.c index 83b7d8aba9e6..b9b93c7faafd 100644 --- a/trunk/sound/pci/trident/trident_main.c +++ b/trunk/sound/pci/trident/trident_main.c @@ -44,19 +44,17 @@ #include <asm/io.h> -static int snd_trident_pcm_mixer_build(struct snd_trident *trident, - struct snd_trident_voice * voice, - struct snd_pcm_substream *substream); -static int snd_trident_pcm_mixer_free(struct snd_trident *trident, - struct snd_trident_voice * voice, - struct snd_pcm_substream *substream); -static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, - struct pt_regs *regs); -static int snd_trident_sis_reset(struct snd_trident *trident); - -static void snd_trident_clear_voices(struct snd_trident * trident, - unsigned short v_min, unsigned short v_max); -static int snd_trident_free(struct snd_trident *trident); +static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream); +static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream); +static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs); +#ifdef CONFIG_PM +static int snd_trident_suspend(snd_card_t *card, pm_message_t state); +static int snd_trident_resume(snd_card_t *card); +#endif +static int snd_trident_sis_reset(trident_t *trident); + +static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min, unsigned short v_max); +static int snd_trident_free(trident_t *trident); /* * common I/O routines @@ -64,7 +62,7 @@ static int snd_trident_free(struct snd_trident *trident); #if 0 -static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice) +static void snd_trident_print_voice_regs(trident_t *trident, int voice) { unsigned int val, tmp; @@ -106,7 +104,7 @@ static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice) #endif /*--------------------------------------------------------------------------- - unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg) + unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg) Description: This routine will do all of the reading from the external CODEC (AC97). @@ -117,12 +115,12 @@ static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice) returns: 16 bit value read from the AC97. ---------------------------------------------------------------------------*/ -static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg) { unsigned int data = 0, treg; unsigned short count = 0xffff; unsigned long flags; - struct snd_trident *trident = ac97->private_data; + trident_t *trident = ac97->private_data; spin_lock_irqsave(&trident->reg_lock, flags); if (trident->device == TRIDENT_DEVICE_ID_DX) { @@ -155,8 +153,7 @@ static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned sho } if (count == 0 && !trident->ac97_detect) { - snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n", - reg, data); + snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n", reg, data); data = 0; } @@ -165,8 +162,7 @@ static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned sho } /*--------------------------------------------------------------------------- - void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg, - unsigned short wdata) + void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned short wdata) Description: This routine will do all of the writing to the external CODEC (AC97). @@ -178,13 +174,12 @@ static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned sho returns: TRUE if everything went ok, else FALSE. ---------------------------------------------------------------------------*/ -static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg, - unsigned short wdata) +static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned short wdata) { unsigned int address, data; unsigned short count = 0xffff; unsigned long flags; - struct snd_trident *trident = ac97->private_data; + trident_t *trident = ac97->private_data; data = ((unsigned long) wdata) << 16; @@ -235,7 +230,7 @@ static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg, } /*--------------------------------------------------------------------------- - void snd_trident_enable_eso(struct snd_trident *trident) + void snd_trident_enable_eso(trident_t *trident) Description: This routine will enable end of loop interrupts. End of loop interrupts will occur when a running @@ -246,7 +241,7 @@ static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg, ---------------------------------------------------------------------------*/ -static void snd_trident_enable_eso(struct snd_trident * trident) +static void snd_trident_enable_eso(trident_t * trident) { unsigned int val; @@ -259,7 +254,7 @@ static void snd_trident_enable_eso(struct snd_trident * trident) } /*--------------------------------------------------------------------------- - void snd_trident_disable_eso(struct snd_trident *trident) + void snd_trident_disable_eso(trident_t *trident) Description: This routine will disable end of loop interrupts. End of loop interrupts will occur when a running @@ -273,7 +268,7 @@ static void snd_trident_enable_eso(struct snd_trident * trident) ---------------------------------------------------------------------------*/ -static void snd_trident_disable_eso(struct snd_trident * trident) +static void snd_trident_disable_eso(trident_t * trident) { unsigned int tmp; @@ -284,7 +279,7 @@ static void snd_trident_disable_eso(struct snd_trident * trident) } /*--------------------------------------------------------------------------- - void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice) + void snd_trident_start_voice(trident_t * trident, unsigned int voice) Description: Start a voice, any channel 0 thru 63. This routine automatically handles the fact that there are @@ -297,7 +292,7 @@ static void snd_trident_disable_eso(struct snd_trident * trident) ---------------------------------------------------------------------------*/ -void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice) +void snd_trident_start_voice(trident_t * trident, unsigned int voice) { unsigned int mask = 1 << (voice & 0x1f); unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A; @@ -306,7 +301,7 @@ void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice) } /*--------------------------------------------------------------------------- - void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice) + void snd_trident_stop_voice(trident_t * trident, unsigned int voice) Description: Stop a voice, any channel 0 thru 63. This routine automatically handles the fact that there are @@ -319,7 +314,7 @@ void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice) ---------------------------------------------------------------------------*/ -void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice) +void snd_trident_stop_voice(trident_t * trident, unsigned int voice) { unsigned int mask = 1 << (voice & 0x1f); unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A; @@ -328,7 +323,7 @@ void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice) } /*--------------------------------------------------------------------------- - int snd_trident_allocate_pcm_channel(struct snd_trident *trident) + int snd_trident_allocate_pcm_channel(trident_t *trident) Description: Allocate hardware channel in Bank B (32-63). @@ -338,7 +333,7 @@ void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice) ---------------------------------------------------------------------------*/ -static int snd_trident_allocate_pcm_channel(struct snd_trident * trident) +static int snd_trident_allocate_pcm_channel(trident_t * trident) { int idx; @@ -366,7 +361,7 @@ static int snd_trident_allocate_pcm_channel(struct snd_trident * trident) ---------------------------------------------------------------------------*/ -static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel) +static void snd_trident_free_pcm_channel(trident_t *trident, int channel) { if (channel < 32 || channel > 63) return; @@ -388,7 +383,7 @@ static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channe ---------------------------------------------------------------------------*/ -static int snd_trident_allocate_synth_channel(struct snd_trident * trident) +static int snd_trident_allocate_synth_channel(trident_t * trident) { int idx; @@ -414,7 +409,7 @@ static int snd_trident_allocate_synth_channel(struct snd_trident * trident) ---------------------------------------------------------------------------*/ -static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel) +static void snd_trident_free_synth_channel(trident_t *trident, int channel) { if (channel < 0 || channel > 31) return; @@ -437,8 +432,8 @@ static void snd_trident_free_synth_channel(struct snd_trident *trident, int chan ---------------------------------------------------------------------------*/ -void snd_trident_write_voice_regs(struct snd_trident * trident, - struct snd_trident_voice * voice) +void snd_trident_write_voice_regs(trident_t * trident, + snd_trident_voice_t * voice) { unsigned int FmcRvolCvol; unsigned int regs[5]; @@ -457,16 +452,14 @@ void snd_trident_write_voice_regs(struct snd_trident * trident, (voice->Vol & 0x000003ff) : ((voice->Vol & 0x00003fc) << (16-2)) | (voice->EC & 0x00000fff); - regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | - (voice->FMS & 0x0000000f); + regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | (voice->FMS & 0x0000000f); regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff); regs[3] = (voice->Attribute << 16) | FmcRvolCvol; break; case TRIDENT_DEVICE_ID_DX: regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) | (voice->EC & 0x00000fff); - regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | - (voice->FMS & 0x0000000f); + regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | (voice->FMS & 0x0000000f); regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff); regs[3] = FmcRvolCvol; break; @@ -474,10 +467,8 @@ void snd_trident_write_voice_regs(struct snd_trident * trident, regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) | (voice->EC & 0x00000fff); regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff); - regs[2] = ((voice->Delta << 16) & 0xff000000) | - (voice->ESO & 0x00ffffff); - regs[3] = (voice->Alpha << 20) | - ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol; + regs[2] = ((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff); + regs[3] = (voice->Alpha << 20) | ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol; break; default: snd_BUG(); @@ -513,17 +504,14 @@ void snd_trident_write_voice_regs(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -static void snd_trident_write_cso_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int CSO) +static void snd_trident_write_cso_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int CSO) { voice->CSO = CSO; outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); if (trident->device != TRIDENT_DEVICE_ID_NX) { outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2); } else { - outl((voice->Delta << 24) | - (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO)); + outl((voice->Delta << 24) | (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO)); } } @@ -539,17 +527,14 @@ static void snd_trident_write_cso_reg(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -static void snd_trident_write_eso_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int ESO) +static void snd_trident_write_eso_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int ESO) { voice->ESO = ESO; outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); if (trident->device != TRIDENT_DEVICE_ID_NX) { outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2); } else { - outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff), - TRID_REG(trident, CH_NX_DELTA_ESO)); + outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_ESO)); } } @@ -565,9 +550,7 @@ static void snd_trident_write_eso_reg(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -static void snd_trident_write_vol_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int Vol) +static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int Vol) { voice->Vol = Vol; outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); @@ -578,8 +561,7 @@ static void snd_trident_write_vol_reg(struct snd_trident * trident, break; case TRIDENT_DEVICE_ID_SI7018: // printk("voice->Vol = 0x%x\n", voice->Vol); - outw((voice->CTRL << 12) | voice->Vol, - TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC)); + outw((voice->CTRL << 12) | voice->Vol, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC)); break; } } @@ -596,14 +578,11 @@ static void snd_trident_write_vol_reg(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -static void snd_trident_write_pan_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int Pan) +static void snd_trident_write_pan_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int Pan) { voice->Pan = Pan; outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f), - TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3)); + outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f), TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3)); } /*--------------------------------------------------------------------------- @@ -618,16 +597,12 @@ static void snd_trident_write_pan_reg(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -static void snd_trident_write_rvol_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int RVol) +static void snd_trident_write_rvol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int RVol) { voice->RVol = RVol; outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | - (voice->CVol & 0x007f), - TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? - CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); + outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | (voice->CVol & 0x007f), + TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); } /*--------------------------------------------------------------------------- @@ -642,16 +617,12 @@ static void snd_trident_write_rvol_reg(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -static void snd_trident_write_cvol_reg(struct snd_trident * trident, - struct snd_trident_voice * voice, - unsigned int CVol) +static void snd_trident_write_cvol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int CVol) { voice->CVol = CVol; outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); - outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | - (voice->CVol & 0x007f), - TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? - CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); + outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) | (voice->CVol & 0x007f), + TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ? CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL)); } /*--------------------------------------------------------------------------- @@ -725,8 +696,7 @@ static unsigned int snd_trident_convert_adc_rate(unsigned int rate) Returns: Delta value. ---------------------------------------------------------------------------*/ -static unsigned int snd_trident_spurious_threshold(unsigned int rate, - unsigned int period_size) +static unsigned int snd_trident_spurious_threshold(unsigned int rate, unsigned int period_size) { unsigned int res = (rate * period_size) / 48000; if (res < 64) @@ -747,10 +717,10 @@ static unsigned int snd_trident_spurious_threshold(unsigned int rate, Returns: Control value. ---------------------------------------------------------------------------*/ -static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream) +static unsigned int snd_trident_control_mode(snd_pcm_substream_t *substream) { unsigned int CTRL; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; /* set ctrl mode CTRL default: 8-bit (unsigned) mono, loop mode enabled @@ -782,7 +752,7 @@ static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream ---------------------------------------------------------------------------*/ -static int snd_trident_ioctl(struct snd_pcm_substream *substream, +static int snd_trident_ioctl(snd_pcm_substream_t * substream, unsigned int cmd, void *arg) { @@ -804,12 +774,12 @@ static int snd_trident_ioctl(struct snd_pcm_substream *substream, ---------------------------------------------------------------------------*/ -static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_trident_allocate_pcm_mem(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; int err; if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) @@ -838,13 +808,13 @@ static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream, ---------------------------------------------------------------------------*/ -static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_trident_allocate_evoice(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + snd_trident_voice_t *evoice = voice->extra; /* voice management */ @@ -878,8 +848,8 @@ static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream, ---------------------------------------------------------------------------*/ -static int snd_trident_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_trident_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { int err; @@ -900,12 +870,12 @@ static int snd_trident_hw_params(struct snd_pcm_substream *substream, ---------------------------------------------------------------------------*/ -static int snd_trident_hw_free(struct snd_pcm_substream *substream) +static int snd_trident_hw_free(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice ? voice->extra : NULL; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + snd_trident_voice_t *evoice = voice ? voice->extra : NULL; if (trident->tlb.entries) { if (voice && voice->memblk) { @@ -932,13 +902,13 @@ static int snd_trident_hw_free(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_playback_prepare(struct snd_pcm_substream *substream) +static int snd_trident_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number]; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + snd_trident_voice_t *evoice = voice->extra; + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[substream->number]; spin_lock_irq(&trident->reg_lock); @@ -1018,8 +988,8 @@ static int snd_trident_playback_prepare(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_trident_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_trident_allocate_pcm_mem(substream, hw_params); } @@ -1035,11 +1005,11 @@ static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream, ---------------------------------------------------------------------------*/ -static int snd_trident_capture_prepare(struct snd_pcm_substream *substream) +static int snd_trident_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; unsigned int val, ESO_bytes; spin_lock_irq(&trident->reg_lock); @@ -1127,8 +1097,8 @@ static int snd_trident_capture_prepare(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_trident_si7018_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { int err; @@ -1149,12 +1119,12 @@ static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substr ---------------------------------------------------------------------------*/ -static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_trident_si7018_capture_hw_free(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice ? voice->extra : NULL; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + snd_trident_voice_t *evoice = voice ? voice->extra : NULL; snd_pcm_lib_free_pages(substream); if (evoice != NULL) { @@ -1175,12 +1145,12 @@ static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substrea ---------------------------------------------------------------------------*/ -static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream) +static int snd_trident_si7018_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + snd_trident_voice_t *evoice = voice->extra; spin_lock_irq(&trident->reg_lock); @@ -1246,12 +1216,12 @@ static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substrea ---------------------------------------------------------------------------*/ -static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream) +static int snd_trident_foldback_prepare(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + snd_trident_voice_t *evoice = voice->extra; spin_lock_irq(&trident->reg_lock); @@ -1324,10 +1294,10 @@ static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_trident_spdif_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); + trident_t *trident = snd_pcm_substream_chip(substream); unsigned int old_bits = 0, change = 0; int err; @@ -1389,13 +1359,13 @@ static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream, ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream) +static int snd_trident_spdif_prepare(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident_voice *evoice = voice->extra; - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number]; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + snd_trident_voice_t *evoice = voice->extra; + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[substream->number]; unsigned int RESO, LBAO; unsigned int temp; @@ -1528,15 +1498,15 @@ static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_trigger(struct snd_pcm_substream *substream, +static int snd_trident_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); + trident_t *trident = snd_pcm_substream_chip(substream); struct list_head *pos; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; unsigned int what, whati, capture_flag, spdif_flag; - struct snd_trident_voice *voice, *evoice; + snd_trident_voice_t *voice, *evoice; unsigned int val, go; switch (cmd) { @@ -1558,8 +1528,8 @@ static int snd_trident_trigger(struct snd_pcm_substream *substream, val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff; snd_pcm_group_for_each(pos, substream) { s = snd_pcm_group_substream_entry(pos); - if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) { - voice = s->runtime->private_data; + if ((trident_t *) snd_pcm_substream_chip(s) == trident) { + voice = (snd_trident_voice_t *) s->runtime->private_data; evoice = voice->extra; what |= 1 << (voice->number & 0x1f); if (evoice == NULL) { @@ -1626,11 +1596,11 @@ static int snd_trident_trigger(struct snd_pcm_substream *substream, ---------------------------------------------------------------------------*/ -static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_trident_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; unsigned int cso; if (!voice->running) @@ -1665,11 +1635,11 @@ static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream * ---------------------------------------------------------------------------*/ -static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_trident_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; unsigned int result; if (!voice->running) @@ -1695,11 +1665,11 @@ static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *s ---------------------------------------------------------------------------*/ -static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_trident_spdif_pointer(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; unsigned int result; if (!voice->running) @@ -1714,7 +1684,7 @@ static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *sub * Playback support device description */ -static struct snd_pcm_hardware snd_trident_playback = +static snd_pcm_hardware_t snd_trident_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1739,7 +1709,7 @@ static struct snd_pcm_hardware snd_trident_playback = * Capture support device description */ -static struct snd_pcm_hardware snd_trident_capture = +static snd_pcm_hardware_t snd_trident_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1764,7 +1734,7 @@ static struct snd_pcm_hardware snd_trident_capture = * Foldback capture support device description */ -static struct snd_pcm_hardware snd_trident_foldback = +static snd_pcm_hardware_t snd_trident_foldback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1788,7 +1758,7 @@ static struct snd_pcm_hardware snd_trident_foldback = * SPDIF playback support device description */ -static struct snd_pcm_hardware snd_trident_spdif = +static snd_pcm_hardware_t snd_trident_spdif = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1809,7 +1779,7 @@ static struct snd_pcm_hardware snd_trident_spdif = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_trident_spdif_7018 = +static snd_pcm_hardware_t snd_trident_spdif_7018 = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1829,10 +1799,10 @@ static struct snd_pcm_hardware snd_trident_spdif_7018 = .fifo_size = 0, }; -static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_trident_pcm_free_substream(snd_pcm_runtime_t *runtime) { - struct snd_trident_voice *voice = runtime->private_data; - struct snd_trident *trident; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; + trident_t *trident; if (voice) { trident = voice->trident; @@ -1840,11 +1810,11 @@ static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime) } } -static int snd_trident_playback_open(struct snd_pcm_substream *substream) +static int snd_trident_playback_open(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice; voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); if (voice == NULL) @@ -1868,11 +1838,11 @@ static int snd_trident_playback_open(struct snd_pcm_substream *substream) Parameters: substream - PCM substream class ---------------------------------------------------------------------------*/ -static int snd_trident_playback_close(struct snd_pcm_substream *substream) +static int snd_trident_playback_close(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_trident_voice *voice = runtime->private_data; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data; snd_trident_pcm_mixer_free(trident, voice, substream); return 0; @@ -1889,11 +1859,11 @@ static int snd_trident_playback_close(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_open(struct snd_pcm_substream *substream) +static int snd_trident_spdif_open(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_trident_voice_t *voice; + snd_pcm_runtime_t *runtime = substream->runtime; voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); if (voice == NULL) @@ -1930,9 +1900,9 @@ static int snd_trident_spdif_open(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_close(struct snd_pcm_substream *substream) +static int snd_trident_spdif_close(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); + trident_t *trident = snd_pcm_substream_chip(substream); unsigned int temp; spin_lock_irq(&trident->reg_lock); @@ -1968,11 +1938,11 @@ static int snd_trident_spdif_close(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_capture_open(struct snd_pcm_substream *substream) +static int snd_trident_capture_open(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_trident_voice_t *voice; + snd_pcm_runtime_t *runtime = substream->runtime; voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); if (voice == NULL) @@ -1996,7 +1966,7 @@ static int snd_trident_capture_open(struct snd_pcm_substream *substream) Parameters: substream - PCM substream class ---------------------------------------------------------------------------*/ -static int snd_trident_capture_close(struct snd_pcm_substream *substream) +static int snd_trident_capture_close(snd_pcm_substream_t * substream) { return 0; } @@ -2012,11 +1982,11 @@ static int snd_trident_capture_close(struct snd_pcm_substream *substream) ---------------------------------------------------------------------------*/ -static int snd_trident_foldback_open(struct snd_pcm_substream *substream) +static int snd_trident_foldback_open(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_trident_voice_t *voice; + snd_pcm_runtime_t *runtime = substream->runtime; voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0); if (voice == NULL) @@ -2039,12 +2009,12 @@ static int snd_trident_foldback_open(struct snd_pcm_substream *substream) Parameters: substream - PCM substream class ---------------------------------------------------------------------------*/ -static int snd_trident_foldback_close(struct snd_pcm_substream *substream) +static int snd_trident_foldback_close(snd_pcm_substream_t * substream) { - struct snd_trident *trident = snd_pcm_substream_chip(substream); - struct snd_trident_voice *voice; - struct snd_pcm_runtime *runtime = substream->runtime; - voice = runtime->private_data; + trident_t *trident = snd_pcm_substream_chip(substream); + snd_trident_voice_t *voice; + snd_pcm_runtime_t *runtime = substream->runtime; + voice = (snd_trident_voice_t *) runtime->private_data; /* stop capture channel */ spin_lock_irq(&trident->reg_lock); @@ -2057,7 +2027,7 @@ static int snd_trident_foldback_close(struct snd_pcm_substream *substream) PCM operations ---------------------------------------------------------------------------*/ -static struct snd_pcm_ops snd_trident_playback_ops = { +static snd_pcm_ops_t snd_trident_playback_ops = { .open = snd_trident_playback_open, .close = snd_trident_playback_close, .ioctl = snd_trident_ioctl, @@ -2068,7 +2038,7 @@ static struct snd_pcm_ops snd_trident_playback_ops = { .pointer = snd_trident_playback_pointer, }; -static struct snd_pcm_ops snd_trident_nx_playback_ops = { +static snd_pcm_ops_t snd_trident_nx_playback_ops = { .open = snd_trident_playback_open, .close = snd_trident_playback_close, .ioctl = snd_trident_ioctl, @@ -2080,7 +2050,7 @@ static struct snd_pcm_ops snd_trident_nx_playback_ops = { .page = snd_pcm_sgbuf_ops_page, }; -static struct snd_pcm_ops snd_trident_capture_ops = { +static snd_pcm_ops_t snd_trident_capture_ops = { .open = snd_trident_capture_open, .close = snd_trident_capture_close, .ioctl = snd_trident_ioctl, @@ -2091,7 +2061,7 @@ static struct snd_pcm_ops snd_trident_capture_ops = { .pointer = snd_trident_capture_pointer, }; -static struct snd_pcm_ops snd_trident_si7018_capture_ops = { +static snd_pcm_ops_t snd_trident_si7018_capture_ops = { .open = snd_trident_capture_open, .close = snd_trident_capture_close, .ioctl = snd_trident_ioctl, @@ -2102,7 +2072,7 @@ static struct snd_pcm_ops snd_trident_si7018_capture_ops = { .pointer = snd_trident_playback_pointer, }; -static struct snd_pcm_ops snd_trident_foldback_ops = { +static snd_pcm_ops_t snd_trident_foldback_ops = { .open = snd_trident_foldback_open, .close = snd_trident_foldback_close, .ioctl = snd_trident_ioctl, @@ -2113,7 +2083,7 @@ static struct snd_pcm_ops snd_trident_foldback_ops = { .pointer = snd_trident_playback_pointer, }; -static struct snd_pcm_ops snd_trident_nx_foldback_ops = { +static snd_pcm_ops_t snd_trident_nx_foldback_ops = { .open = snd_trident_foldback_open, .close = snd_trident_foldback_close, .ioctl = snd_trident_ioctl, @@ -2125,7 +2095,7 @@ static struct snd_pcm_ops snd_trident_nx_foldback_ops = { .page = snd_pcm_sgbuf_ops_page, }; -static struct snd_pcm_ops snd_trident_spdif_ops = { +static snd_pcm_ops_t snd_trident_spdif_ops = { .open = snd_trident_spdif_open, .close = snd_trident_spdif_close, .ioctl = snd_trident_ioctl, @@ -2136,7 +2106,7 @@ static struct snd_pcm_ops snd_trident_spdif_ops = { .pointer = snd_trident_spdif_pointer, }; -static struct snd_pcm_ops snd_trident_spdif_7018_ops = { +static snd_pcm_ops_t snd_trident_spdif_7018_ops = { .open = snd_trident_spdif_open, .close = snd_trident_spdif_close, .ioctl = snd_trident_ioctl, @@ -2147,6 +2117,37 @@ static struct snd_pcm_ops snd_trident_spdif_7018_ops = { .pointer = snd_trident_playback_pointer, }; +/*--------------------------------------------------------------------------- + snd_trident_pcm_free + + Description: This routine release the 4DWave private data. + + Paramters: private_data - pointer to 4DWave device info. + + Returns: None + + ---------------------------------------------------------------------------*/ +static void snd_trident_pcm_free(snd_pcm_t *pcm) +{ + trident_t *trident = pcm->private_data; + trident->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static void snd_trident_foldback_pcm_free(snd_pcm_t *pcm) +{ + trident_t *trident = pcm->private_data; + trident->foldback = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static void snd_trident_spdif_pcm_free(snd_pcm_t *pcm) +{ + trident_t *trident = pcm->private_data; + trident->spdif = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + /*--------------------------------------------------------------------------- snd_trident_pcm @@ -2158,10 +2159,9 @@ static struct snd_pcm_ops snd_trident_spdif_7018_ops = { ---------------------------------------------------------------------------*/ -int __devinit snd_trident_pcm(struct snd_trident * trident, - int device, struct snd_pcm ** rpcm) +int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -2170,6 +2170,7 @@ int __devinit snd_trident_pcm(struct snd_trident * trident, return err; pcm->private_data = trident; + pcm->private_free = snd_trident_pcm_free; if (trident->tlb.entries) { snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops); @@ -2187,7 +2188,7 @@ int __devinit snd_trident_pcm(struct snd_trident * trident, trident->pcm = pcm; if (trident->tlb.entries) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG, snd_dma_pci_data(trident->pci), @@ -2216,13 +2217,12 @@ int __devinit snd_trident_pcm(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -int __devinit snd_trident_foldback_pcm(struct snd_trident * trident, - int device, struct snd_pcm ** rpcm) +int __devinit snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *foldback; + snd_pcm_t *foldback; int err; int num_chan = 3; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; if (rpcm) *rpcm = NULL; @@ -2232,6 +2232,7 @@ int __devinit snd_trident_foldback_pcm(struct snd_trident * trident, return err; foldback->private_data = trident; + foldback->private_free = snd_trident_foldback_pcm_free; if (trident->tlb.entries) snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops); else @@ -2273,10 +2274,9 @@ int __devinit snd_trident_foldback_pcm(struct snd_trident * trident, ---------------------------------------------------------------------------*/ -int __devinit snd_trident_spdif_pcm(struct snd_trident * trident, - int device, struct snd_pcm ** rpcm) +int __devinit snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *spdif; + snd_pcm_t *spdif; int err; if (rpcm) @@ -2285,6 +2285,7 @@ int __devinit snd_trident_spdif_pcm(struct snd_trident * trident, return err; spdif->private_data = trident; + spdif->private_free = snd_trident_spdif_pcm_free; if (trident->device != TRIDENT_DEVICE_ID_SI7018) { snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops); } else { @@ -2312,8 +2313,7 @@ int __devinit snd_trident_spdif_pcm(struct snd_trident * trident, Description: enable/disable S/PDIF out from ac97 mixer ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_spdif_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2322,10 +2322,10 @@ static int snd_trident_spdif_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_spdif_control_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned char val; spin_lock_irq(&trident->reg_lock); @@ -2335,10 +2335,10 @@ static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_spdif_control_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned char val; int change; @@ -2366,7 +2366,7 @@ static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata = +static snd_kcontrol_new_t snd_trident_spdif_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), @@ -2382,18 +2382,17 @@ static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata = Description: put/get the S/PDIF default settings ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_spdif_default_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_spdif_default_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); spin_lock_irq(&trident->reg_lock); ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff; @@ -2404,10 +2403,10 @@ static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_spdif_default_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -2429,7 +2428,7 @@ static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata = +static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -2444,16 +2443,15 @@ static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata = Description: put/get the S/PDIF mask ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; @@ -2462,7 +2460,7 @@ static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata = +static snd_kcontrol_new_t snd_trident_spdif_mask __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -2477,18 +2475,17 @@ static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata = Description: put/get the S/PDIF stream settings ---------------------------------------------------------------------------*/ -static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_spdif_stream_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); spin_lock_irq(&trident->reg_lock); ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff; @@ -2499,10 +2496,10 @@ static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_spdif_stream_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -2524,7 +2521,7 @@ static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata = +static snd_kcontrol_new_t snd_trident_spdif_stream __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -2540,8 +2537,7 @@ static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata = Description: enable/disable rear path for ac97 ---------------------------------------------------------------------------*/ -static int snd_trident_ac97_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_ac97_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -2550,10 +2546,10 @@ static int snd_trident_ac97_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_ac97_control_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned char val; spin_lock_irq(&trident->reg_lock); @@ -2563,10 +2559,10 @@ static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_ac97_control_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned char val; int change = 0; @@ -2582,7 +2578,7 @@ static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata = +static snd_kcontrol_new_t snd_trident_ac97_rear_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Rear Path", @@ -2598,8 +2594,7 @@ static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata = Description: wave & music volume control ---------------------------------------------------------------------------*/ -static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -2608,10 +2603,10 @@ static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_vol_control_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned int val; val = trident->musicvol_wavevol; @@ -2620,10 +2615,10 @@ static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_vol_control_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); unsigned int val; int change = 0; @@ -2638,7 +2633,7 @@ static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata = +static snd_kcontrol_new_t snd_trident_vol_music_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Music Playback Volume", @@ -2648,7 +2643,7 @@ static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata = .private_value = 16, }; -static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata = +static snd_kcontrol_new_t snd_trident_vol_wave_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Wave Playback Volume", @@ -2664,10 +2659,9 @@ static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata = Description: PCM front volume control ---------------------------------------------------------------------------*/ -static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_pcm_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); + trident_t *trident = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -2678,11 +2672,11 @@ static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_vol_control_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; if (trident->device == TRIDENT_DEVICE_ID_SI7018) { ucontrol->value.integer.value[0] = 1023 - mix->vol; @@ -2692,11 +2686,11 @@ static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_vol_control_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; unsigned int val; int change = 0; @@ -2714,7 +2708,7 @@ static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata = +static snd_kcontrol_new_t snd_trident_pcm_vol_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Front Playback Volume", @@ -2731,8 +2725,7 @@ static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata = Description: PCM front pan control ---------------------------------------------------------------------------*/ -static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_pcm_pan_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -2741,11 +2734,11 @@ static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_pan_control_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; ucontrol->value.integer.value[0] = mix->pan; if (ucontrol->value.integer.value[0] & 0x40) { @@ -2756,11 +2749,11 @@ static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_pan_control_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; unsigned char val; int change = 0; @@ -2777,7 +2770,7 @@ static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata = +static snd_kcontrol_new_t snd_trident_pcm_pan_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Pan Playback Control", @@ -2794,8 +2787,7 @@ static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata = Description: PCM reverb volume control ---------------------------------------------------------------------------*/ -static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_pcm_rvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -2804,21 +2796,21 @@ static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_rvol_control_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; ucontrol->value.integer.value[0] = 127 - mix->rvol; return 0; } -static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_rvol_control_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; unsigned short val; int change = 0; @@ -2832,7 +2824,7 @@ static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata = +static snd_kcontrol_new_t snd_trident_pcm_rvol_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Reverb Playback Volume", @@ -2849,8 +2841,7 @@ static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata = Description: PCM chorus volume control ---------------------------------------------------------------------------*/ -static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_trident_pcm_cvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -2859,21 +2850,21 @@ static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_cvol_control_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; ucontrol->value.integer.value[0] = 127 - mix->cvol; return 0; } -static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_trident_pcm_cvol_control_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_trident *trident = snd_kcontrol_chip(kcontrol); - struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; + trident_t *trident = snd_kcontrol_chip(kcontrol); + snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)]; unsigned short val; int change = 0; @@ -2887,7 +2878,7 @@ static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata = +static snd_kcontrol_new_t snd_trident_pcm_cvol_control __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Chorus Playback Volume", @@ -2898,11 +2889,9 @@ static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata = .put = snd_trident_pcm_cvol_control_put, }; -static void snd_trident_notify_pcm_change1(struct snd_card *card, - struct snd_kcontrol *kctl, - int num, int activate) +static void snd_trident_notify_pcm_change1(snd_card_t * card, snd_kcontrol_t *kctl, int num, int activate) { - struct snd_ctl_elem_id id; + snd_ctl_elem_id_t id; if (! kctl) return; @@ -2915,9 +2904,7 @@ static void snd_trident_notify_pcm_change1(struct snd_card *card, snd_ctl_build_ioff(&id, kctl, num)); } -static void snd_trident_notify_pcm_change(struct snd_trident *trident, - struct snd_trident_pcm_mixer *tmix, - int num, int activate) +static void snd_trident_notify_pcm_change(trident_t *trident, snd_trident_pcm_mixer_t *tmix, int num, int activate) { snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate); snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate); @@ -2925,11 +2912,9 @@ static void snd_trident_notify_pcm_change(struct snd_trident *trident, snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate); } -static int snd_trident_pcm_mixer_build(struct snd_trident *trident, - struct snd_trident_voice *voice, - struct snd_pcm_substream *substream) +static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream) { - struct snd_trident_pcm_mixer *tmix; + snd_trident_pcm_mixer_t *tmix; snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL); tmix = &trident->pcm_mixer[substream->number]; @@ -2942,9 +2927,9 @@ static int snd_trident_pcm_mixer_build(struct snd_trident *trident, return 0; } -static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream) +static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream) { - struct snd_trident_pcm_mixer *tmix; + snd_trident_pcm_mixer_t *tmix; snd_assert(trident != NULL && substream != NULL, return -EINVAL); tmix = &trident->pcm_mixer[substream->number]; @@ -2964,14 +2949,14 @@ static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_tr ---------------------------------------------------------------------------*/ -static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device) +static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device) { - struct snd_ac97_template _ac97; - struct snd_card *card = trident->card; - struct snd_kcontrol *kctl; - struct snd_ctl_elem_value *uctl; + ac97_template_t _ac97; + snd_card_t * card = trident->card; + snd_kcontrol_t *kctl; + snd_ctl_elem_value_t *uctl; int idx, err, retries = 2; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_trident_codec_write, .read = snd_trident_codec_read, }; @@ -3008,7 +2993,7 @@ static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spd snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n"); #if 0 // only for my testing purpose --jk { - struct snd_ac97 *mc97; + ac97_t *mc97; err = snd_ac97_modem(trident->card, &_ac97, &mc97); if (err < 0) snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err); @@ -3031,7 +3016,7 @@ static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spd } for (idx = 0; idx < 32; idx++) { - struct snd_trident_pcm_mixer *tmix; + snd_trident_pcm_mixer_t *tmix; tmix = &trident->pcm_mixer[idx]; tmix->voice = NULL; @@ -3129,7 +3114,7 @@ static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spd static unsigned char snd_trident_gameport_read(struct gameport *gameport) { - struct snd_trident *chip = gameport_get_port_data(gameport); + trident_t *chip = gameport_get_port_data(gameport); snd_assert(chip, return 0); return inb(TRID_REG(chip, GAMEPORT_LEGACY)); @@ -3137,7 +3122,7 @@ static unsigned char snd_trident_gameport_read(struct gameport *gameport) static void snd_trident_gameport_trigger(struct gameport *gameport) { - struct snd_trident *chip = gameport_get_port_data(gameport); + trident_t *chip = gameport_get_port_data(gameport); snd_assert(chip, return); outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY)); @@ -3145,7 +3130,7 @@ static void snd_trident_gameport_trigger(struct gameport *gameport) static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons) { - struct snd_trident *chip = gameport_get_port_data(gameport); + trident_t *chip = gameport_get_port_data(gameport); int i; snd_assert(chip, return 0); @@ -3162,7 +3147,7 @@ static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes static int snd_trident_gameport_open(struct gameport *gameport, int mode) { - struct snd_trident *chip = gameport_get_port_data(gameport); + trident_t *chip = gameport_get_port_data(gameport); snd_assert(chip, return 0); @@ -3179,7 +3164,7 @@ static int snd_trident_gameport_open(struct gameport *gameport, int mode) } } -int __devinit snd_trident_create_gameport(struct snd_trident *chip) +int __devinit snd_trident_create_gameport(trident_t *chip) { struct gameport *gp; @@ -3205,7 +3190,7 @@ int __devinit snd_trident_create_gameport(struct snd_trident *chip) return 0; } -static inline void snd_trident_free_gameport(struct snd_trident *chip) +static inline void snd_trident_free_gameport(trident_t *chip) { if (chip->gameport) { gameport_unregister_port(chip->gameport); @@ -3213,14 +3198,14 @@ static inline void snd_trident_free_gameport(struct snd_trident *chip) } } #else -int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; } -static inline void snd_trident_free_gameport(struct snd_trident *chip) { } +int __devinit snd_trident_create_gameport(trident_t *chip) { return -ENOSYS; } +static inline void snd_trident_free_gameport(trident_t *chip) { } #endif /* CONFIG_GAMEPORT */ /* * delay for 1 tick */ -static inline void do_delay(struct snd_trident *chip) +static inline void do_delay(trident_t *chip) { schedule_timeout_uninterruptible(1); } @@ -3229,7 +3214,7 @@ static inline void do_delay(struct snd_trident *chip) * SiS reset routine */ -static int snd_trident_sis_reset(struct snd_trident *trident) +static int snd_trident_sis_reset(trident_t *trident) { unsigned long end_time; unsigned int i; @@ -3282,10 +3267,10 @@ static int snd_trident_sis_reset(struct snd_trident *trident) * /proc interface */ -static void snd_trident_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_trident_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_trident *trident = entry->private_data; + trident_t *trident = entry->private_data; char *s; switch (trident->device) { @@ -3323,9 +3308,9 @@ static void snd_trident_proc_read(struct snd_info_entry *entry, #endif } -static void __devinit snd_trident_proc_init(struct snd_trident * trident) +static void __devinit snd_trident_proc_init(trident_t * trident) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; const char *s = "trident"; if (trident->device == TRIDENT_DEVICE_ID_SI7018) @@ -3334,9 +3319,9 @@ static void __devinit snd_trident_proc_init(struct snd_trident * trident) snd_info_set_text_ops(entry, trident, 1024, snd_trident_proc_read); } -static int snd_trident_dev_free(struct snd_device *device) +static int snd_trident_dev_free(snd_device_t *device) { - struct snd_trident *trident = device->device_data; + trident_t *trident = device->device_data; return snd_trident_free(trident); } @@ -3352,7 +3337,7 @@ static int snd_trident_dev_free(struct snd_device *device) ---------------------------------------------------------------------------*/ -static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident) +static int __devinit snd_trident_tlb_alloc(trident_t *trident) { int i; @@ -3367,7 +3352,7 @@ static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident) trident->tlb.entries = (unsigned int*)(((unsigned long)trident->tlb.buffer.area + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1)); trident->tlb.entries_dmaaddr = (trident->tlb.buffer.addr + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1); /* allocate shadow TLB page table (virtual addresses) */ - trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long)); + trident->tlb.shadow_entries = (unsigned long *)vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long)); if (trident->tlb.shadow_entries == NULL) { snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n"); return -ENOMEM; @@ -3389,7 +3374,7 @@ static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident) if (trident->tlb.memhdr == NULL) return -ENOMEM; - trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg); + trident->tlb.memhdr->block_extra_size = sizeof(snd_trident_memblk_arg_t); return 0; } @@ -3397,7 +3382,7 @@ static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident) * initialize 4D DX chip */ -static void snd_trident_stop_all_voices(struct snd_trident *trident) +static void snd_trident_stop_all_voices(trident_t *trident) { outl(0xffffffff, TRID_REG(trident, T4D_STOP_A)); outl(0xffffffff, TRID_REG(trident, T4D_STOP_B)); @@ -3405,7 +3390,7 @@ static void snd_trident_stop_all_voices(struct snd_trident *trident) outl(0, TRID_REG(trident, T4D_AINTEN_B)); } -static int snd_trident_4d_dx_init(struct snd_trident *trident) +static int snd_trident_4d_dx_init(trident_t *trident) { struct pci_dev *pci = trident->pci; unsigned long end_time; @@ -3445,7 +3430,7 @@ static int snd_trident_4d_dx_init(struct snd_trident *trident) /* * initialize 4D NX chip */ -static int snd_trident_4d_nx_init(struct snd_trident *trident) +static int snd_trident_4d_nx_init(trident_t *trident) { struct pci_dev *pci = trident->pci; unsigned long end_time; @@ -3502,7 +3487,7 @@ static int snd_trident_4d_nx_init(struct snd_trident *trident) /* * initialize sis7018 chip */ -static int snd_trident_sis_init(struct snd_trident *trident) +static int snd_trident_sis_init(trident_t *trident) { int err; @@ -3533,18 +3518,18 @@ static int snd_trident_sis_init(struct snd_trident *trident) ---------------------------------------------------------------------------*/ -int __devinit snd_trident_create(struct snd_card *card, +int __devinit snd_trident_create(snd_card_t * card, struct pci_dev *pci, int pcm_streams, int pcm_spdif_device, int max_wavetable_size, - struct snd_trident ** rtrident) + trident_t ** rtrident) { - struct snd_trident *trident; + trident_t *trident; int i, err; - struct snd_trident_voice *voice; - struct snd_trident_pcm_mixer *tmix; - static struct snd_device_ops ops = { + snd_trident_voice_t *voice; + snd_trident_pcm_mixer_t *tmix; + static snd_device_ops_t ops = { .dev_free = snd_trident_dev_free, }; @@ -3592,8 +3577,7 @@ int __devinit snd_trident_create(struct snd_card *card, } trident->port = pci_resource_start(pci, 0); - if (request_irq(pci->irq, snd_trident_interrupt, SA_INTERRUPT|SA_SHIRQ, - "Trident Audio", trident)) { + if (request_irq(pci->irq, snd_trident_interrupt, SA_INTERRUPT|SA_SHIRQ, "Trident Audio", (void *) trident)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_trident_free(trident); return -EBUSY; @@ -3657,6 +3641,8 @@ int __devinit snd_trident_create(struct snd_card *card, snd_trident_enable_eso(trident); + + snd_card_set_pm_callback(card, snd_trident_suspend, snd_trident_resume, trident); snd_trident_proc_init(trident); snd_card_set_dev(card, &pci->dev); *rtrident = trident; @@ -3675,7 +3661,7 @@ int __devinit snd_trident_create(struct snd_card *card, ---------------------------------------------------------------------------*/ -static int snd_trident_free(struct snd_trident *trident) +static int snd_trident_free(trident_t *trident) { snd_trident_free_gameport(trident); snd_trident_disable_eso(trident); @@ -3695,7 +3681,7 @@ static int snd_trident_free(struct snd_trident *trident) snd_dma_free_pages(&trident->tlb.buffer); } if (trident->irq >= 0) - free_irq(trident->irq, trident); + free_irq(trident->irq, (void *)trident); pci_release_regions(trident->pci); pci_disable_device(trident->pci); kfree(trident); @@ -3722,10 +3708,10 @@ static int snd_trident_free(struct snd_trident *trident) static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_trident *trident = dev_id; + trident_t *trident = dev_id; unsigned int audio_int, chn_int, stimer, channel, mask, tmp; int delta; - struct snd_trident_voice *voice; + snd_trident_voice_t *voice; audio_int = inl(TRID_REG(trident, T4D_MISCINT)); if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0) @@ -3827,21 +3813,21 @@ static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs * Returns: None. ---------------------------------------------------------------------------*/ -int snd_trident_attach_synthesizer(struct snd_trident *trident) +int snd_trident_attach_synthesizer(trident_t *trident) { #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)) if (snd_seq_device_new(trident->card, 1, SNDRV_SEQ_DEV_ID_TRIDENT, - sizeof(struct snd_trident *), &trident->seq_dev) >= 0) { + sizeof(trident_t*), &trident->seq_dev) >= 0) { strcpy(trident->seq_dev->name, "4DWave"); - *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident; + *(trident_t**)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident; } #endif return 0; } -struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port) +snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int client, int port) { - struct snd_trident_voice *pvoice; + snd_trident_voice_t *pvoice; unsigned long flags; int idx; @@ -3883,10 +3869,10 @@ struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, return NULL; } -void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice) +void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice) { unsigned long flags; - void (*private_free)(struct snd_trident_voice *); + void (*private_free)(snd_trident_voice_t *); void *private_data; if (voice == NULL || !voice->use) @@ -3911,7 +3897,7 @@ void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voi private_free(voice); } -static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max) +static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min, unsigned short v_max) { unsigned int i, val, mask[2] = { 0, 0 }; @@ -3932,19 +3918,20 @@ static void snd_trident_clear_voices(struct snd_trident * trident, unsigned shor } #ifdef CONFIG_PM -int snd_trident_suspend(struct pci_dev *pci, pm_message_t state) +static int snd_trident_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_trident *trident = card->private_data; + trident_t *trident = card->pm_private_data; trident->in_suspend = 1; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(trident->pcm); - snd_pcm_suspend_all(trident->foldback); - snd_pcm_suspend_all(trident->spdif); + if (trident->foldback) + snd_pcm_suspend_all(trident->foldback); + if (trident->spdif) + snd_pcm_suspend_all(trident->spdif); snd_ac97_suspend(trident->ac97); - snd_ac97_suspend(trident->ac97_sec); + if (trident->ac97_sec) + snd_ac97_suspend(trident->ac97_sec); switch (trident->device) { case TRIDENT_DEVICE_ID_DX: @@ -3953,19 +3940,19 @@ int snd_trident_suspend(struct pci_dev *pci, pm_message_t state) case TRIDENT_DEVICE_ID_SI7018: break; } - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(trident->pci); return 0; } -int snd_trident_resume(struct pci_dev *pci) +static int snd_trident_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_trident *trident = card->private_data; + trident_t *trident = card->pm_private_data; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); /* to be sure */ + pci_enable_device(trident->pci); + if (pci_set_dma_mask(trident->pci, 0x3fffffff) < 0 || + pci_set_consistent_dma_mask(trident->pci, 0x3fffffff) < 0) + snd_printk(KERN_WARNING "trident: can't set the proper DMA mask\n"); + pci_set_master(trident->pci); /* to be sure */ switch (trident->device) { case TRIDENT_DEVICE_ID_DX: @@ -3980,14 +3967,14 @@ int snd_trident_resume(struct pci_dev *pci) } snd_ac97_resume(trident->ac97); - snd_ac97_resume(trident->ac97_sec); + if (trident->ac97_sec) + snd_ac97_resume(trident->ac97_sec); /* restore some registers */ outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL)); snd_trident_enable_eso(trident); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); trident->in_suspend = 0; return 0; } diff --git a/trunk/sound/pci/trident/trident_memory.c b/trunk/sound/pci/trident/trident_memory.c index cf09ea99755c..f3e6c546af74 100644 --- a/trunk/sound/pci/trident/trident_memory.c +++ b/trunk/sound/pci/trident/trident_memory.c @@ -68,14 +68,13 @@ #define page_to_addr(trident,page) __tlb_to_addr(trident, (page) << 1) /* fill TLB entries -- we need to fill two entries */ -static inline void set_tlb_bus(struct snd_trident *trident, int page, - unsigned long ptr, dma_addr_t addr) +static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr, dma_addr_t addr) { page <<= 1; __set_tlb_bus(trident, page, ptr, addr); __set_tlb_bus(trident, page+1, ptr + SNDRV_TRIDENT_PAGE_SIZE, addr + SNDRV_TRIDENT_PAGE_SIZE); } -static inline void set_silent_tlb(struct snd_trident *trident, int page) +static inline void set_silent_tlb(trident_t *trident, int page) { page <<= 1; __set_tlb_bus(trident, page, (unsigned long)trident->tlb.silent_page.area, trident->tlb.silent_page.addr); @@ -98,8 +97,7 @@ static inline void set_silent_tlb(struct snd_trident *trident, int page) #define page_to_addr(trident,page) __tlb_to_addr(trident, (page) * UNIT_PAGES) /* fill TLB entries -- UNIT_PAGES entries must be filled */ -static inline void set_tlb_bus(struct snd_trident *trident, int page, - unsigned long ptr, dma_addr_t addr) +static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr, dma_addr_t addr) { int i; page *= UNIT_PAGES; @@ -109,7 +107,7 @@ static inline void set_tlb_bus(struct snd_trident *trident, int page, addr += SNDRV_TRIDENT_PAGE_SIZE; } } -static inline void set_silent_tlb(struct snd_trident *trident, int page) +static inline void set_silent_tlb(trident_t *trident, int page) { int i; page *= UNIT_PAGES; @@ -120,7 +118,7 @@ static inline void set_silent_tlb(struct snd_trident *trident, int page) #endif /* PAGE_SIZE */ /* calculate buffer pointer from offset address */ -static inline void *offset_ptr(struct snd_trident *trident, int offset) +static inline void *offset_ptr(trident_t *trident, int offset) { char *ptr; ptr = page_to_ptr(trident, get_aligned_page(offset)); @@ -129,16 +127,16 @@ static inline void *offset_ptr(struct snd_trident *trident, int offset) } /* first and last (aligned) pages of memory block */ -#define firstpg(blk) (((struct snd_trident_memblk_arg *)snd_util_memblk_argptr(blk))->first_page) -#define lastpg(blk) (((struct snd_trident_memblk_arg *)snd_util_memblk_argptr(blk))->last_page) +#define firstpg(blk) (((snd_trident_memblk_arg_t*)snd_util_memblk_argptr(blk))->first_page) +#define lastpg(blk) (((snd_trident_memblk_arg_t*)snd_util_memblk_argptr(blk))->last_page) /* * search empty pages which may contain given size */ -static struct snd_util_memblk * -search_empty(struct snd_util_memhdr *hdr, int size) +static snd_util_memblk_t * +search_empty(snd_util_memhdr_t *hdr, int size) { - struct snd_util_memblk *blk, *prev; + snd_util_memblk_t *blk, *prev; int page, psize; struct list_head *p; @@ -146,7 +144,7 @@ search_empty(struct snd_util_memhdr *hdr, int size) prev = NULL; page = 0; list_for_each(p, &hdr->block) { - blk = list_entry(p, struct snd_util_memblk, list); + blk = list_entry(p, snd_util_memblk_t, list); if (page + psize <= firstpg(blk)) goto __found_pages; page = lastpg(blk) + 1; @@ -185,13 +183,12 @@ static int is_valid_page(unsigned long ptr) /* * page allocation for DMA (Scatter-Gather version) */ -static struct snd_util_memblk * -snd_trident_alloc_sg_pages(struct snd_trident *trident, - struct snd_pcm_substream *substream) +static snd_util_memblk_t * +snd_trident_alloc_sg_pages(trident_t *trident, snd_pcm_substream_t *substream) { - struct snd_util_memhdr *hdr; - struct snd_util_memblk *blk; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_util_memhdr_t *hdr; + snd_util_memblk_t *blk; + snd_pcm_runtime_t *runtime = substream->runtime; int idx, page; struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); @@ -233,14 +230,13 @@ snd_trident_alloc_sg_pages(struct snd_trident *trident, /* * page allocation for DMA (contiguous version) */ -static struct snd_util_memblk * -snd_trident_alloc_cont_pages(struct snd_trident *trident, - struct snd_pcm_substream *substream) +static snd_util_memblk_t * +snd_trident_alloc_cont_pages(trident_t *trident, snd_pcm_substream_t *substream) { - struct snd_util_memhdr *hdr; - struct snd_util_memblk *blk; + snd_util_memhdr_t *hdr; + snd_util_memblk_t *blk; int page; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; dma_addr_t addr; unsigned long ptr; @@ -274,9 +270,8 @@ snd_trident_alloc_cont_pages(struct snd_trident *trident, /* * page allocation for DMA */ -struct snd_util_memblk * -snd_trident_alloc_pages(struct snd_trident *trident, - struct snd_pcm_substream *substream) +snd_util_memblk_t * +snd_trident_alloc_pages(trident_t *trident, snd_pcm_substream_t *substream) { snd_assert(trident != NULL, return NULL); snd_assert(substream != NULL, return NULL); @@ -290,10 +285,9 @@ snd_trident_alloc_pages(struct snd_trident *trident, /* * release DMA buffer from page table */ -int snd_trident_free_pages(struct snd_trident *trident, - struct snd_util_memblk *blk) +int snd_trident_free_pages(trident_t *trident, snd_util_memblk_t *blk) { - struct snd_util_memhdr *hdr; + snd_util_memhdr_t *hdr; int page; snd_assert(trident != NULL, return -EINVAL); @@ -320,17 +314,17 @@ int snd_trident_free_pages(struct snd_trident *trident, /* */ -static int synth_alloc_pages(struct snd_trident *hw, struct snd_util_memblk *blk); -static int synth_free_pages(struct snd_trident *hw, struct snd_util_memblk *blk); +static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk); +static int synth_free_pages(trident_t *hw, snd_util_memblk_t *blk); /* * allocate a synth sample area */ -struct snd_util_memblk * -snd_trident_synth_alloc(struct snd_trident *hw, unsigned int size) +snd_util_memblk_t * +snd_trident_synth_alloc(trident_t *hw, unsigned int size) { - struct snd_util_memblk *blk; - struct snd_util_memhdr *hdr = hw->tlb.memhdr; + snd_util_memblk_t *blk; + snd_util_memhdr_t *hdr = hw->tlb.memhdr; down(&hdr->block_mutex); blk = __snd_util_mem_alloc(hdr, size); @@ -352,9 +346,9 @@ snd_trident_synth_alloc(struct snd_trident *hw, unsigned int size) * free a synth sample area */ int -snd_trident_synth_free(struct snd_trident *hw, struct snd_util_memblk *blk) +snd_trident_synth_free(trident_t *hw, snd_util_memblk_t *blk) { - struct snd_util_memhdr *hdr = hw->tlb.memhdr; + snd_util_memhdr_t *hdr = hw->tlb.memhdr; down(&hdr->block_mutex); synth_free_pages(hw, blk); @@ -367,7 +361,7 @@ snd_trident_synth_free(struct snd_trident *hw, struct snd_util_memblk *blk) /* * reset TLB entry and free kernel page */ -static void clear_tlb(struct snd_trident *trident, int page) +static void clear_tlb(trident_t *trident, int page) { void *ptr = page_to_ptr(trident, page); dma_addr_t addr = page_to_addr(trident, page); @@ -384,22 +378,20 @@ static void clear_tlb(struct snd_trident *trident, int page) } /* check new allocation range */ -static void get_single_page_range(struct snd_util_memhdr *hdr, - struct snd_util_memblk *blk, - int *first_page_ret, int *last_page_ret) +static void get_single_page_range(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk, int *first_page_ret, int *last_page_ret) { struct list_head *p; - struct snd_util_memblk *q; + snd_util_memblk_t *q; int first_page, last_page; first_page = firstpg(blk); if ((p = blk->list.prev) != &hdr->block) { - q = list_entry(p, struct snd_util_memblk, list); + q = list_entry(p, snd_util_memblk_t, list); if (lastpg(q) == first_page) first_page++; /* first page was already allocated */ } last_page = lastpg(blk); if ((p = blk->list.next) != &hdr->block) { - q = list_entry(p, struct snd_util_memblk, list); + q = list_entry(p, snd_util_memblk_t, list); if (firstpg(q) == last_page) last_page--; /* last page was already allocated */ } @@ -410,7 +402,7 @@ static void get_single_page_range(struct snd_util_memhdr *hdr, /* * allocate kernel pages and assign them to TLB */ -static int synth_alloc_pages(struct snd_trident *hw, struct snd_util_memblk *blk) +static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk) { int page, first_page, last_page; struct snd_dma_buffer dmab; @@ -446,7 +438,7 @@ static int synth_alloc_pages(struct snd_trident *hw, struct snd_util_memblk *blk /* * free pages */ -static int synth_free_pages(struct snd_trident *trident, struct snd_util_memblk *blk) +static int synth_free_pages(trident_t *trident, snd_util_memblk_t *blk) { int page, first_page, last_page; @@ -460,9 +452,7 @@ static int synth_free_pages(struct snd_trident *trident, struct snd_util_memblk /* * copy_from_user(blk + offset, data, size) */ -int snd_trident_synth_copy_from_user(struct snd_trident *trident, - struct snd_util_memblk *blk, - int offset, const char __user *data, int size) +int snd_trident_synth_copy_from_user(trident_t *trident, snd_util_memblk_t *blk, int offset, const char __user *data, int size) { int page, nextofs, end_offset, temp, temp1; diff --git a/trunk/sound/pci/trident/trident_synth.c b/trunk/sound/pci/trident/trident_synth.c index cc7af8bc55a0..5d5a719b0585 100644 --- a/trunk/sound/pci/trident/trident_synth.c +++ b/trunk/sound/pci/trident/trident_synth.c @@ -192,15 +192,15 @@ static unsigned short log_from_linear( unsigned short value ) * Sample handling operations */ -static void sample_start(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position); -static void sample_stop(struct snd_trident * trident, struct snd_trident_voice * voice, int mode); -static void sample_freq(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_frequency_t freq); -static void sample_volume(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_volume * volume); -static void sample_loop(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_loop * loop); -static void sample_pos(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position); -static void sample_private1(struct snd_trident * trident, struct snd_trident_voice * voice, unsigned char *data); - -static struct snd_trident_sample_ops sample_ops = +static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position); +static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode); +static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq); +static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume); +static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop); +static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position); +static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data); + +static snd_trident_sample_ops_t sample_ops = { sample_start, sample_stop, @@ -211,7 +211,7 @@ static struct snd_trident_sample_ops sample_ops = sample_private1 }; -static void snd_trident_simple_init(struct snd_trident_voice * voice) +static void snd_trident_simple_init(snd_trident_voice_t * voice) { //voice->handler_wave = interrupt_wave; //voice->handler_volume = interrupt_volume; @@ -220,10 +220,10 @@ static void snd_trident_simple_init(struct snd_trident_voice * voice) voice->sample_ops = &sample_ops; } -static void sample_start(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position) +static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position) { - struct simple_instrument *simple; - struct snd_seq_kinstr *instr; + simple_instrument_t *simple; + snd_seq_kinstr_t *instr; unsigned long flags; unsigned int loop_start, loop_end, sample_start, sample_end, start_offset; unsigned int value; @@ -305,7 +305,7 @@ static void sample_start(struct snd_trident * trident, struct snd_trident_voice snd_seq_instr_free_use(trident->synth.ilist, instr); } -static void sample_stop(struct snd_trident * trident, struct snd_trident_voice * voice, int mode) +static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode) { unsigned long flags; @@ -329,7 +329,7 @@ static void sample_stop(struct snd_trident * trident, struct snd_trident_voice * } } -static void sample_freq(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_frequency_t freq) +static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq) { unsigned long flags; freq >>= 4; @@ -355,7 +355,7 @@ static void sample_freq(struct snd_trident * trident, struct snd_trident_voice * spin_unlock_irqrestore(&trident->reg_lock, flags); } -static void sample_volume(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_volume * volume) +static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume) { unsigned long flags; unsigned short value; @@ -407,11 +407,11 @@ static void sample_volume(struct snd_trident * trident, struct snd_trident_voice spin_unlock_irqrestore(&trident->reg_lock, flags); } -static void sample_loop(struct snd_trident * trident, struct snd_trident_voice * voice, struct snd_seq_ev_loop * loop) +static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop) { unsigned long flags; - struct simple_instrument *simple; - struct snd_seq_kinstr *instr; + simple_instrument_t *simple; + snd_seq_kinstr_t *instr; unsigned int loop_start, loop_end; instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1); @@ -446,11 +446,11 @@ static void sample_loop(struct snd_trident * trident, struct snd_trident_voice * snd_seq_instr_free_use(trident->synth.ilist, instr); } -static void sample_pos(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position) +static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position) { unsigned long flags; - struct simple_instrument *simple; - struct snd_seq_kinstr *instr; + simple_instrument_t *simple; + snd_seq_kinstr_t *instr; unsigned int value; instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1); @@ -496,7 +496,7 @@ static void sample_pos(struct snd_trident * trident, struct snd_trident_voice * snd_seq_instr_free_use(trident->synth.ilist, instr); } -static void sample_private1(struct snd_trident * trident, struct snd_trident_voice * voice, unsigned char *data) +static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data) { } @@ -504,11 +504,10 @@ static void sample_private1(struct snd_trident * trident, struct snd_trident_voi * Memory management / sample loading */ -static int snd_trident_simple_put_sample(void *private_data, - struct simple_instrument * instr, +static int snd_trident_simple_put_sample(void *private_data, simple_instrument_t * instr, char __user *data, long len, int atomic) { - struct snd_trident *trident = private_data; + trident_t *trident = private_data; int size = instr->size; int shift = 0; @@ -530,7 +529,7 @@ static int snd_trident_simple_put_sample(void *private_data, return -EFAULT; if (trident->tlb.entries) { - struct snd_util_memblk *memblk; + snd_util_memblk_t *memblk; memblk = snd_trident_synth_alloc(trident, size); if (memblk == NULL) return -ENOMEM; @@ -558,11 +557,10 @@ static int snd_trident_simple_put_sample(void *private_data, return 0; } -static int snd_trident_simple_get_sample(void *private_data, - struct simple_instrument * instr, +static int snd_trident_simple_get_sample(void *private_data, simple_instrument_t * instr, char __user *data, long len, int atomic) { - //struct snd_trident *trident = private_data; + //trident_t *trident = private_data; int size = instr->size; int shift = 0; @@ -580,11 +578,10 @@ static int snd_trident_simple_get_sample(void *private_data, return -EBUSY; } -static int snd_trident_simple_remove_sample(void *private_data, - struct simple_instrument * instr, +static int snd_trident_simple_remove_sample(void *private_data, simple_instrument_t * instr, int atomic) { - struct snd_trident *trident = private_data; + trident_t *trident = private_data; int size = instr->size; if (instr->format & SIMPLE_WAVE_16BIT) @@ -593,7 +590,7 @@ static int snd_trident_simple_remove_sample(void *private_data, size <<= 1; if (trident->tlb.entries) { - struct snd_util_memblk *memblk = (struct snd_util_memblk *)instr->address.ptr; + snd_util_memblk_t *memblk = (snd_util_memblk_t*)instr->address.ptr; if (memblk) snd_trident_synth_free(trident, memblk); else @@ -615,9 +612,9 @@ static int snd_trident_simple_remove_sample(void *private_data, return 0; } -static void select_instrument(struct snd_trident * trident, struct snd_trident_voice * v) +static void select_instrument(trident_t * trident, snd_trident_voice_t * v) { - struct snd_seq_kinstr *instr; + snd_seq_kinstr_t *instr; instr = snd_seq_instr_find(trident->synth.ilist, &v->instr, 0, 1); if (instr != NULL) { if (instr->ops) { @@ -632,7 +629,7 @@ static void select_instrument(struct snd_trident * trident, struct snd_trident_v */ -static void event_sample(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_sample(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_stop) v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY); @@ -646,7 +643,7 @@ static void event_sample(struct snd_seq_event * ev, struct snd_trident_port * p, select_instrument(p->trident, v); } -static void event_cluster(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_cluster(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_stop) v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY); @@ -654,49 +651,49 @@ static void event_cluster(struct snd_seq_event * ev, struct snd_trident_port * p select_instrument(p->trident, v); } -static void event_start(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_start(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_start) v->sample_ops->sample_start(p->trident, v, ev->data.sample.param.position); } -static void event_stop(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_stop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_stop) v->sample_ops->sample_stop(p->trident, v, ev->data.sample.param.stop_mode); } -static void event_freq(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_freq(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_freq) v->sample_ops->sample_freq(p->trident, v, ev->data.sample.param.frequency); } -static void event_volume(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_volume(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_volume) v->sample_ops->sample_volume(p->trident, v, &ev->data.sample.param.volume); } -static void event_loop(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_loop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_loop) v->sample_ops->sample_loop(p->trident, v, &ev->data.sample.param.loop); } -static void event_position(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_position(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_pos) v->sample_ops->sample_pos(p->trident, v, ev->data.sample.param.position); } -static void event_private1(struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v) +static void event_private1(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) { if (v->sample_ops && v->sample_ops->sample_private1) v->sample_ops->sample_private1(p->trident, v, (unsigned char *) &ev->data.sample.param.raw8); } -typedef void (trident_sample_event_handler_t) (struct snd_seq_event * ev, struct snd_trident_port * p, struct snd_trident_voice * v); +typedef void (trident_sample_event_handler_t) (snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v); static trident_sample_event_handler_t *trident_sample_event_handlers[9] = { @@ -711,11 +708,11 @@ static trident_sample_event_handler_t *trident_sample_event_handlers[9] = event_private1 }; -static void snd_trident_sample_event(struct snd_seq_event * ev, struct snd_trident_port * p) +static void snd_trident_sample_event(snd_seq_event_t * ev, snd_trident_port_t * p) { int idx, voice; - struct snd_trident *trident = p->trident; - struct snd_trident_voice *v; + trident_t *trident = p->trident; + snd_trident_voice_t *v; unsigned long flags; idx = ev->type - SNDRV_SEQ_EVENT_SAMPLE; @@ -738,10 +735,10 @@ static void snd_trident_sample_event(struct snd_seq_event * ev, struct snd_tride */ -static void snd_trident_synth_free_voices(struct snd_trident * trident, int client, int port) +static void snd_trident_synth_free_voices(trident_t * trident, int client, int port) { int idx; - struct snd_trident_voice *voice; + snd_trident_voice_t *voice; for (idx = 0; idx < 32; idx++) { voice = &trident->synth.voices[idx]; @@ -750,11 +747,11 @@ static void snd_trident_synth_free_voices(struct snd_trident * trident, int clie } } -static int snd_trident_synth_use(void *private_data, struct snd_seq_port_subscribe * info) +static int snd_trident_synth_use(void *private_data, snd_seq_port_subscribe_t * info) { - struct snd_trident_port *port = private_data; - struct snd_trident *trident = port->trident; - struct snd_trident_voice *voice; + snd_trident_port_t *port = (snd_trident_port_t *) private_data; + trident_t *trident = port->trident; + snd_trident_voice_t *voice; unsigned int idx; unsigned long flags; @@ -789,10 +786,10 @@ static int snd_trident_synth_use(void *private_data, struct snd_seq_port_subscri return 0; } -static int snd_trident_synth_unuse(void *private_data, struct snd_seq_port_subscribe * info) +static int snd_trident_synth_unuse(void *private_data, snd_seq_port_subscribe_t * info) { - struct snd_trident_port *port = private_data; - struct snd_trident *trident = port->trident; + snd_trident_port_t *port = (snd_trident_port_t *) private_data; + trident_t *trident = port->trident; unsigned long flags; spin_lock_irqsave(&trident->reg_lock, flags); @@ -805,18 +802,18 @@ static int snd_trident_synth_unuse(void *private_data, struct snd_seq_port_subsc */ -static void snd_trident_synth_free_private_instruments(struct snd_trident_port * p, int client) +static void snd_trident_synth_free_private_instruments(snd_trident_port_t * p, int client) { - struct snd_seq_instr_header ifree; + snd_seq_instr_header_t ifree; memset(&ifree, 0, sizeof(ifree)); ifree.cmd = SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE; snd_seq_instr_list_free_cond(p->trident->synth.ilist, &ifree, client, 0); } -static int snd_trident_synth_event_input(struct snd_seq_event * ev, int direct, void *private_data, int atomic, int hop) +static int snd_trident_synth_event_input(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop) { - struct snd_trident_port *p = (struct snd_trident_port *) private_data; + snd_trident_port_t *p = (snd_trident_port_t *) private_data; if (p == NULL) return -EINVAL; @@ -844,12 +841,12 @@ static int snd_trident_synth_event_input(struct snd_seq_event * ev, int direct, } static void snd_trident_synth_instr_notify(void *private_data, - struct snd_seq_kinstr * instr, + snd_seq_kinstr_t * instr, int what) { int idx; - struct snd_trident *trident = private_data; - struct snd_trident_voice *pvoice; + trident_t *trident = private_data; + snd_trident_voice_t *pvoice; unsigned long flags; spin_lock_irqsave(&trident->event_lock, flags); @@ -873,16 +870,16 @@ static void snd_trident_synth_instr_notify(void *private_data, static void snd_trident_synth_free_port(void *private_data) { - struct snd_trident_port *p = (struct snd_trident_port *) private_data; + snd_trident_port_t *p = (snd_trident_port_t *) private_data; if (p) snd_midi_channel_free_set(p->chset); } -static int snd_trident_synth_create_port(struct snd_trident * trident, int idx) +static int snd_trident_synth_create_port(trident_t * trident, int idx) { - struct snd_trident_port *p; - struct snd_seq_port_callback callbacks; + snd_trident_port_t *p; + snd_seq_port_callback_t callbacks; char name[32]; char *str; int result; @@ -930,31 +927,43 @@ static int snd_trident_synth_create_port(struct snd_trident * trident, int idx) */ -static int snd_trident_synth_new_device(struct snd_seq_device *dev) +static int snd_trident_synth_new_device(snd_seq_device_t *dev) { - struct snd_trident *trident; + trident_t *trident; int client, i; - struct snd_seq_port_subscribe sub; - struct snd_simple_ops *simpleops; + snd_seq_client_callback_t callbacks; + snd_seq_client_info_t cinfo; + snd_seq_port_subscribe_t sub; + snd_simple_ops_t *simpleops; char *str; - trident = *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (trident == NULL) return -EINVAL; trident->synth.seq_client = -1; /* allocate new client */ + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.private_data = trident; + callbacks.allow_output = callbacks.allow_input = 1; + client = trident->synth.seq_client = + snd_seq_create_kernel_client(trident->card, 1, &callbacks); + if (client < 0) + return client; + + /* change name of client */ + memset(&cinfo, 0, sizeof(cinfo)); + cinfo.client = client; + cinfo.type = KERNEL_CLIENT; str = "???"; switch (trident->device) { case TRIDENT_DEVICE_ID_DX: str = "Trident 4DWave-DX"; break; case TRIDENT_DEVICE_ID_NX: str = "Trident 4DWave-NX"; break; case TRIDENT_DEVICE_ID_SI7018: str = "SiS 7018"; break; } - client = trident->synth.seq_client = - snd_seq_create_kernel_client(trident->card, 1, str); - if (client < 0) - return client; + sprintf(cinfo.name, str); + snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); for (i = 0; i < 4; i++) snd_trident_synth_create_port(trident, i); @@ -984,11 +993,11 @@ static int snd_trident_synth_new_device(struct snd_seq_device *dev) return 0; } -static int snd_trident_synth_delete_device(struct snd_seq_device *dev) +static int snd_trident_synth_delete_device(snd_seq_device_t *dev) { - struct snd_trident *trident; + trident_t *trident; - trident = *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(dev); + trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); if (trident == NULL) return -EINVAL; @@ -1003,14 +1012,14 @@ static int snd_trident_synth_delete_device(struct snd_seq_device *dev) static int __init alsa_trident_synth_init(void) { - static struct snd_seq_dev_ops ops = + static snd_seq_dev_ops_t ops = { snd_trident_synth_new_device, snd_trident_synth_delete_device }; return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_TRIDENT, &ops, - sizeof(struct snd_trident *)); + sizeof(trident_t*)); } static void __exit alsa_trident_synth_exit(void) diff --git a/trunk/sound/pci/via82xx.c b/trunk/sound/pci/via82xx.c index ed26a155c344..fad2a2413bf6 100644 --- a/trunk/sound/pci/via82xx.c +++ b/trunk/sound/pci/via82xx.c @@ -302,6 +302,12 @@ DEFINE_VIA_REGSET(CAPTURE_8233, 0x60); #define VIA_DXS_SRC 5 +/* + */ + +typedef struct _snd_via82xx via82xx_t; +typedef struct via_dev viadev_t; + /* * pcm stream */ @@ -313,11 +319,11 @@ struct snd_via_sg_table { #define VIA_TABLE_SIZE 255 -struct viadev { +struct via_dev { unsigned int reg_offset; unsigned long port; int direction; /* playback = 0, capture = 1 */ - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int running; unsigned int tbl_entries; /* # descriptors */ struct snd_dma_buffer table; @@ -344,7 +350,7 @@ struct via_rate_lock { int used; }; -struct via82xx { +struct _snd_via82xx { int irq; unsigned long port; @@ -368,27 +374,27 @@ struct via82xx { unsigned int intr_mask; /* SGD_SHADOW mask to check interrupts */ struct pci_dev *pci; - struct snd_card *card; + snd_card_t *card; unsigned int num_devs; unsigned int playback_devno, multi_devno, capture_devno; - struct viadev devs[VIA_MAX_DEVS]; + viadev_t devs[VIA_MAX_DEVS]; struct via_rate_lock rates[2]; /* playback and capture */ unsigned int dxs_fixed: 1; /* DXS channel accepts only 48kHz */ unsigned int no_vra: 1; /* no need to set VRA on DXS channels */ unsigned int dxs_src: 1; /* use full SRC capabilities of DXS */ unsigned int spdif_on: 1; /* only spdif rates work to external DACs */ - struct snd_pcm *pcms[2]; - struct snd_rawmidi *rmidi; + snd_pcm_t *pcms[2]; + snd_rawmidi_t *rmidi; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; + ac97_bus_t *ac97_bus; + ac97_t *ac97; unsigned int ac97_clock; unsigned int ac97_secondary; /* secondary AC'97 codec is present */ spinlock_t reg_lock; - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; #ifdef SUPPORT_JOYSTICK struct gameport *gameport; @@ -413,12 +419,12 @@ MODULE_DEVICE_TABLE(pci, snd_via82xx_ids); * periods = number of periods * fragsize = period size in bytes */ -static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substream, +static int build_via_table(viadev_t *dev, snd_pcm_substream_t *substream, struct pci_dev *pci, unsigned int periods, unsigned int fragsize) { unsigned int i, idx, ofs, rest; - struct via82xx *chip = snd_pcm_substream_chip(substream); + via82xx_t *chip = snd_pcm_substream_chip(substream); struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); if (dev->table.area == NULL) { @@ -481,7 +487,7 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre } -static int clean_via_table(struct viadev *dev, struct snd_pcm_substream *substream, +static int clean_via_table(viadev_t *dev, snd_pcm_substream_t *substream, struct pci_dev *pci) { if (dev->table.area) { @@ -497,17 +503,17 @@ static int clean_via_table(struct viadev *dev, struct snd_pcm_substream *substre * Basic I/O */ -static inline unsigned int snd_via82xx_codec_xread(struct via82xx *chip) +static inline unsigned int snd_via82xx_codec_xread(via82xx_t *chip) { return inl(VIAREG(chip, AC97)); } -static inline void snd_via82xx_codec_xwrite(struct via82xx *chip, unsigned int val) +static inline void snd_via82xx_codec_xwrite(via82xx_t *chip, unsigned int val) { outl(val, VIAREG(chip, AC97)); } -static int snd_via82xx_codec_ready(struct via82xx *chip, int secondary) +static int snd_via82xx_codec_ready(via82xx_t *chip, int secondary) { unsigned int timeout = 1000; /* 1ms */ unsigned int val; @@ -517,12 +523,11 @@ static int snd_via82xx_codec_ready(struct via82xx *chip, int secondary) if (!((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY)) return val & 0xffff; } - snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n", - secondary, snd_via82xx_codec_xread(chip)); + snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n", secondary, snd_via82xx_codec_xread(chip)); return -EIO; } -static int snd_via82xx_codec_valid(struct via82xx *chip, int secondary) +static int snd_via82xx_codec_valid(via82xx_t *chip, int secondary) { unsigned int timeout = 1000; /* 1ms */ unsigned int val, val1; @@ -539,20 +544,20 @@ static int snd_via82xx_codec_valid(struct via82xx *chip, int secondary) return -EIO; } -static void snd_via82xx_codec_wait(struct snd_ac97 *ac97) +static void snd_via82xx_codec_wait(ac97_t *ac97) { - struct via82xx *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; int err; err = snd_via82xx_codec_ready(chip, ac97->num); /* here we need to wait fairly for long time.. */ msleep(500); } -static void snd_via82xx_codec_write(struct snd_ac97 *ac97, +static void snd_via82xx_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct via82xx *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; unsigned int xval; xval = !ac97->num ? VIA_REG_AC97_CODEC_ID_PRIMARY : VIA_REG_AC97_CODEC_ID_SECONDARY; @@ -563,9 +568,9 @@ static void snd_via82xx_codec_write(struct snd_ac97 *ac97, snd_via82xx_codec_ready(chip, ac97->num); } -static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_via82xx_codec_read(ac97_t *ac97, unsigned short reg) { - struct via82xx *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; unsigned int xval, val = 0xffff; int again = 0; @@ -575,8 +580,7 @@ static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned sho xval |= (reg & 0x7f) << VIA_REG_AC97_CMD_SHIFT; while (1) { if (again++ > 3) { - snd_printk(KERN_ERR "codec_read: codec %i is not valid [0x%x]\n", - ac97->num, snd_via82xx_codec_xread(chip)); + snd_printk(KERN_ERR "codec_read: codec %i is not valid [0x%x]\n", ac97->num, snd_via82xx_codec_xread(chip)); return 0xffff; } snd_via82xx_codec_xwrite(chip, xval); @@ -590,7 +594,7 @@ static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned sho return val & 0xffff; } -static void snd_via82xx_channel_reset(struct via82xx *chip, struct viadev *viadev) +static void snd_via82xx_channel_reset(via82xx_t *chip, viadev_t *viadev) { outb(VIA_REG_CTRL_PAUSE | VIA_REG_CTRL_TERMINATE | VIA_REG_CTRL_RESET, VIADEV_REG(viadev, OFFSET_CONTROL)); @@ -613,7 +617,7 @@ static void snd_via82xx_channel_reset(struct via82xx *chip, struct viadev *viade */ static irqreturn_t snd_via686_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct via82xx *chip = dev_id; + via82xx_t *chip = dev_id; unsigned int status; unsigned int i; @@ -628,7 +632,7 @@ static irqreturn_t snd_via686_interrupt(int irq, void *dev_id, struct pt_regs *r /* check status for each stream */ spin_lock(&chip->reg_lock); for (i = 0; i < chip->num_devs; i++) { - struct viadev *viadev = &chip->devs[i]; + viadev_t *viadev = &chip->devs[i]; unsigned char c_status = inb(VIADEV_REG(viadev, OFFSET_STATUS)); if (! (c_status & (VIA_REG_STAT_EOL|VIA_REG_STAT_FLAG|VIA_REG_STAT_STOPPED))) continue; @@ -659,7 +663,7 @@ static irqreturn_t snd_via686_interrupt(int irq, void *dev_id, struct pt_regs *r */ static irqreturn_t snd_via8233_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct via82xx *chip = dev_id; + via82xx_t *chip = dev_id; unsigned int status; unsigned int i; int irqreturn = 0; @@ -669,8 +673,8 @@ static irqreturn_t snd_via8233_interrupt(int irq, void *dev_id, struct pt_regs * status = inl(VIAREG(chip, SGD_SHADOW)); for (i = 0; i < chip->num_devs; i++) { - struct viadev *viadev = &chip->devs[i]; - struct snd_pcm_substream *substream; + viadev_t *viadev = &chip->devs[i]; + snd_pcm_substream_t *substream; unsigned char c_status, shadow_status; shadow_status = (status >> viadev->shadow_shift) & @@ -715,10 +719,10 @@ static irqreturn_t snd_via8233_interrupt(int irq, void *dev_id, struct pt_regs * /* * trigger callback */ -static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_via82xx_pcm_trigger(snd_pcm_substream_t * substream, int cmd) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; unsigned char val; if (chip->chip_type != TYPE_VIA686) @@ -762,11 +766,9 @@ static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) */ #define check_invalid_pos(viadev,pos) \ - ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 ||\ - viadev->lastpos < viadev->bufsize2)) + ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 || viadev->lastpos < viadev->bufsize2)) -static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int idx, - unsigned int count) +static inline unsigned int calc_linear_pos(viadev_t *viadev, unsigned int idx, unsigned int count) { unsigned int size, base, res; @@ -778,8 +780,7 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i /* check the validity of the calculated position */ if (size < count) { - snd_printd(KERN_ERR "invalid via82xx_cur_ptr (size = %d, count = %d)\n", - (int)size, (int)count); + snd_printd(KERN_ERR "invalid via82xx_cur_ptr (size = %d, count = %d)\n", (int)size, (int)count); res = viadev->lastpos; } else { if (! count) { @@ -795,18 +796,12 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i } if (check_invalid_pos(viadev, res)) { #ifdef POINTER_DEBUG - printk(KERN_DEBUG "fail: idx = %i/%i, lastpos = 0x%x, " - "bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, " - "count = 0x%x\n", idx, viadev->tbl_entries, - viadev->lastpos, viadev->bufsize2, - viadev->idx_table[idx].offset, - viadev->idx_table[idx].size, count); + printk(KERN_DEBUG "fail: idx = %i/%i, lastpos = 0x%x, bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, count = 0x%x\n", idx, viadev->tbl_entries, viadev->lastpos, viadev->bufsize2, viadev->idx_table[idx].offset, viadev->idx_table[idx].size, count); #endif /* count register returns full size when end of buffer is reached */ res = base + size; if (check_invalid_pos(viadev, res)) { - snd_printd(KERN_ERR "invalid via82xx_cur_ptr (2), " - "using last valid pointer\n"); + snd_printd(KERN_ERR "invalid via82xx_cur_ptr (2), using last valid pointer\n"); res = viadev->lastpos; } } @@ -817,10 +812,10 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i /* * get the current pointer on via686 */ -static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_via686_pcm_pointer(snd_pcm_substream_t *substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; unsigned int idx, ptr, count, res; snd_assert(viadev->tbl_entries, return 0); @@ -847,10 +842,10 @@ static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substr /* * get the current pointer on via823x */ -static snd_pcm_uframes_t snd_via8233_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_via8233_pcm_pointer(snd_pcm_substream_t *substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; unsigned int idx, count, res; int status; @@ -870,8 +865,7 @@ static snd_pcm_uframes_t snd_via8233_pcm_pointer(struct snd_pcm_substream *subst idx = count >> 24; if (idx >= viadev->tbl_entries) { #ifdef POINTER_DEBUG - printk(KERN_DEBUG "fail: invalid idx = %i/%i\n", idx, - viadev->tbl_entries); + printk(KERN_DEBUG "fail: invalid idx = %i/%i\n", idx, viadev->tbl_entries); #endif res = viadev->lastpos; } else { @@ -901,11 +895,11 @@ static snd_pcm_uframes_t snd_via8233_pcm_pointer(struct snd_pcm_substream *subst * hw_params callback: * allocate the buffer and build up the buffer description table */ -static int snd_via82xx_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_via82xx_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; int err; err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); @@ -924,10 +918,10 @@ static int snd_via82xx_hw_params(struct snd_pcm_substream *substream, * hw_free callback: * clean up the buffer description table and release the buffer */ -static int snd_via82xx_hw_free(struct snd_pcm_substream *substream) +static int snd_via82xx_hw_free(snd_pcm_substream_t * substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; clean_via_table(viadev, substream, chip->pci); snd_pcm_lib_free_pages(substream); @@ -938,7 +932,7 @@ static int snd_via82xx_hw_free(struct snd_pcm_substream *substream) /* * set up the table pointer */ -static void snd_via82xx_set_table_ptr(struct via82xx *chip, struct viadev *viadev) +static void snd_via82xx_set_table_ptr(via82xx_t *chip, viadev_t *viadev) { snd_via82xx_codec_ready(chip, 0); outl((u32)viadev->table.addr, VIADEV_REG(viadev, OFFSET_TABLE_PTR)); @@ -949,8 +943,7 @@ static void snd_via82xx_set_table_ptr(struct via82xx *chip, struct viadev *viade /* * prepare callback for playback and capture on via686 */ -static void via686_setup_format(struct via82xx *chip, struct viadev *viadev, - struct snd_pcm_runtime *runtime) +static void via686_setup_format(via82xx_t *chip, viadev_t *viadev, snd_pcm_runtime_t *runtime) { snd_via82xx_channel_reset(chip, viadev); /* this must be set after channel_reset */ @@ -963,11 +956,11 @@ static void via686_setup_format(struct via82xx *chip, struct viadev *viadev, VIA_REG_TYPE_INT_FLAG, VIADEV_REG(viadev, OFFSET_TYPE)); } -static int snd_via686_playback_prepare(struct snd_pcm_substream *substream) +static int snd_via686_playback_prepare(snd_pcm_substream_t *substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; snd_ac97_set_rate(chip->ac97, AC97_PCM_FRONT_DAC_RATE, runtime->rate); snd_ac97_set_rate(chip->ac97, AC97_SPDIF, runtime->rate); @@ -975,11 +968,11 @@ static int snd_via686_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_via686_capture_prepare(struct snd_pcm_substream *substream) +static int snd_via686_capture_prepare(snd_pcm_substream_t *substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; snd_ac97_set_rate(chip->ac97, AC97_PCM_LR_ADC_RATE, runtime->rate); via686_setup_format(chip, viadev, runtime); @@ -1009,11 +1002,11 @@ static int via_lock_rate(struct via_rate_lock *rec, int rate) /* * prepare callback for DSX playback on via823x */ -static int snd_via8233_playback_prepare(struct snd_pcm_substream *substream) +static int snd_via8233_playback_prepare(snd_pcm_substream_t *substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; int ac97_rate = chip->dxs_src ? 48000 : runtime->rate; int rate_changed; u32 rbits; @@ -1029,15 +1022,12 @@ static int snd_via8233_playback_prepare(struct snd_pcm_substream *substream) if (runtime->rate == 48000) rbits = 0xfffff; else - rbits = (0x100000 / 48000) * runtime->rate + - ((0x100000 % 48000) * runtime->rate) / 48000; + rbits = (0x100000 / 48000) * runtime->rate + ((0x100000 % 48000) * runtime->rate) / 48000; snd_assert((rbits & ~0xfffff) == 0, return -EINVAL); snd_via82xx_channel_reset(chip, viadev); snd_via82xx_set_table_ptr(chip, viadev); - outb(chip->playback_volume[viadev->reg_offset / 0x10][0], - VIADEV_REG(viadev, OFS_PLAYBACK_VOLUME_L)); - outb(chip->playback_volume[viadev->reg_offset / 0x10][1], - VIADEV_REG(viadev, OFS_PLAYBACK_VOLUME_R)); + outb(chip->playback_volume[viadev->reg_offset / 0x10][0], VIADEV_REG(viadev, OFS_PLAYBACK_VOLUME_L)); + outb(chip->playback_volume[viadev->reg_offset / 0x10][1], VIADEV_REG(viadev, OFS_PLAYBACK_VOLUME_R)); outl((runtime->format == SNDRV_PCM_FORMAT_S16_LE ? VIA8233_REG_TYPE_16BIT : 0) | /* format */ (runtime->channels > 1 ? VIA8233_REG_TYPE_STEREO : 0) | /* stereo */ rbits | /* rate */ @@ -1051,11 +1041,11 @@ static int snd_via8233_playback_prepare(struct snd_pcm_substream *substream) /* * prepare callback for multi-channel playback on via823x */ -static int snd_via8233_multi_prepare(struct snd_pcm_substream *substream) +static int snd_via8233_multi_prepare(snd_pcm_substream_t *substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int slots; int fmt; @@ -1068,8 +1058,7 @@ static int snd_via8233_multi_prepare(struct snd_pcm_substream *substream) snd_via82xx_channel_reset(chip, viadev); snd_via82xx_set_table_ptr(chip, viadev); - fmt = (runtime->format == SNDRV_PCM_FORMAT_S16_LE) ? - VIA_REG_MULTPLAY_FMT_16BIT : VIA_REG_MULTPLAY_FMT_8BIT; + fmt = (runtime->format == SNDRV_PCM_FORMAT_S16_LE) ? VIA_REG_MULTPLAY_FMT_16BIT : VIA_REG_MULTPLAY_FMT_8BIT; fmt |= runtime->channels << 4; outb(fmt, VIADEV_REG(viadev, OFS_MULTPLAY_FORMAT)); #if 0 @@ -1100,11 +1089,11 @@ static int snd_via8233_multi_prepare(struct snd_pcm_substream *substream) /* * prepare callback for capture on via823x */ -static int snd_via8233_capture_prepare(struct snd_pcm_substream *substream) +static int snd_via8233_capture_prepare(snd_pcm_substream_t *substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; if (via_lock_rate(&chip->rates[1], runtime->rate) < 0) return -EINVAL; @@ -1125,7 +1114,7 @@ static int snd_via8233_capture_prepare(struct snd_pcm_substream *substream) /* * pcm hardware definition, identical for both playback and capture */ -static struct snd_pcm_hardware snd_via82xx_hw = +static snd_pcm_hardware_t snd_via82xx_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -1150,10 +1139,9 @@ static struct snd_pcm_hardware snd_via82xx_hw = /* * open callback skeleton */ -static int snd_via82xx_pcm_open(struct via82xx *chip, struct viadev *viadev, - struct snd_pcm_substream *substream) +static int snd_via82xx_pcm_open(via82xx_t *chip, viadev_t *viadev, snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; struct via_rate_lock *ratep; @@ -1203,10 +1191,10 @@ static int snd_via82xx_pcm_open(struct via82xx *chip, struct viadev *viadev, /* * open callback for playback on via686 and via823x DSX */ -static int snd_via82xx_playback_open(struct snd_pcm_substream *substream) +static int snd_via82xx_playback_open(snd_pcm_substream_t * substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = &chip->devs[chip->playback_devno + substream->number]; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = &chip->devs[chip->playback_devno + substream->number]; int err; if ((err = snd_via82xx_pcm_open(chip, viadev, substream)) < 0) @@ -1217,10 +1205,10 @@ static int snd_via82xx_playback_open(struct snd_pcm_substream *substream) /* * open callback for playback on via823x multi-channel */ -static int snd_via8233_multi_open(struct snd_pcm_substream *substream) +static int snd_via8233_multi_open(snd_pcm_substream_t * substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = &chip->devs[chip->multi_devno]; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = &chip->devs[chip->multi_devno]; int err; /* channels constraint for VIA8233A * 3 and 5 channels are not supported @@ -1228,7 +1216,7 @@ static int snd_via8233_multi_open(struct snd_pcm_substream *substream) static unsigned int channels[] = { 1, 2, 4, 6 }; - static struct snd_pcm_hw_constraint_list hw_constraints_channels = { + static snd_pcm_hw_constraint_list_t hw_constraints_channels = { .count = ARRAY_SIZE(channels), .list = channels, .mask = 0, @@ -1238,19 +1226,17 @@ static int snd_via8233_multi_open(struct snd_pcm_substream *substream) return err; substream->runtime->hw.channels_max = 6; if (chip->revision == VIA_REV_8233A) - snd_pcm_hw_constraint_list(substream->runtime, 0, - SNDRV_PCM_HW_PARAM_CHANNELS, - &hw_constraints_channels); + snd_pcm_hw_constraint_list(substream->runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, &hw_constraints_channels); return 0; } /* * open callback for capture on via686 and via823x */ -static int snd_via82xx_capture_open(struct snd_pcm_substream *substream) +static int snd_via82xx_capture_open(snd_pcm_substream_t * substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = &chip->devs[chip->capture_devno + substream->pcm->device]; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = &chip->devs[chip->capture_devno + substream->pcm->device]; return snd_via82xx_pcm_open(chip, viadev, substream); } @@ -1258,10 +1244,10 @@ static int snd_via82xx_capture_open(struct snd_pcm_substream *substream) /* * close callback */ -static int snd_via82xx_pcm_close(struct snd_pcm_substream *substream) +static int snd_via82xx_pcm_close(snd_pcm_substream_t * substream) { - struct via82xx *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; struct via_rate_lock *ratep; /* release the rate lock */ @@ -1278,7 +1264,7 @@ static int snd_via82xx_pcm_close(struct snd_pcm_substream *substream) /* via686 playback callbacks */ -static struct snd_pcm_ops snd_via686_playback_ops = { +static snd_pcm_ops_t snd_via686_playback_ops = { .open = snd_via82xx_playback_open, .close = snd_via82xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -1291,7 +1277,7 @@ static struct snd_pcm_ops snd_via686_playback_ops = { }; /* via686 capture callbacks */ -static struct snd_pcm_ops snd_via686_capture_ops = { +static snd_pcm_ops_t snd_via686_capture_ops = { .open = snd_via82xx_capture_open, .close = snd_via82xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -1304,7 +1290,7 @@ static struct snd_pcm_ops snd_via686_capture_ops = { }; /* via823x DSX playback callbacks */ -static struct snd_pcm_ops snd_via8233_playback_ops = { +static snd_pcm_ops_t snd_via8233_playback_ops = { .open = snd_via82xx_playback_open, .close = snd_via82xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -1317,7 +1303,7 @@ static struct snd_pcm_ops snd_via8233_playback_ops = { }; /* via823x multi-channel playback callbacks */ -static struct snd_pcm_ops snd_via8233_multi_ops = { +static snd_pcm_ops_t snd_via8233_multi_ops = { .open = snd_via8233_multi_open, .close = snd_via82xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -1330,7 +1316,7 @@ static struct snd_pcm_ops snd_via8233_multi_ops = { }; /* via823x capture callbacks */ -static struct snd_pcm_ops snd_via8233_capture_ops = { +static snd_pcm_ops_t snd_via8233_capture_ops = { .open = snd_via82xx_capture_open, .close = snd_via82xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -1343,8 +1329,7 @@ static struct snd_pcm_ops snd_via8233_capture_ops = { }; -static void init_viadev(struct via82xx *chip, int idx, unsigned int reg_offset, - int shadow_pos, int direction) +static void init_viadev(via82xx_t *chip, int idx, unsigned int reg_offset, int shadow_pos, int direction) { chip->devs[idx].reg_offset = reg_offset; chip->devs[idx].shadow_shift = shadow_pos * 4; @@ -1355,9 +1340,9 @@ static void init_viadev(struct via82xx *chip, int idx, unsigned int reg_offset, /* * create pcm instances for VIA8233, 8233C and 8235 (not 8233A) */ -static int __devinit snd_via8233_pcm_new(struct via82xx *chip) +static int __devinit snd_via8233_pcm_new(via82xx_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int i, err; chip->playback_devno = 0; /* x 4 */ @@ -1382,8 +1367,7 @@ static int __devinit snd_via8233_pcm_new(struct via82xx *chip) init_viadev(chip, chip->capture_devno, VIA_REG_CAPTURE_8233_STATUS, 6, 1); if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024)) < 0) + snd_dma_pci_data(chip->pci), 64*1024, 128*1024)) < 0) return err; /* PCM #1: multi-channel playback and 2nd capture */ @@ -1401,8 +1385,7 @@ static int __devinit snd_via8233_pcm_new(struct via82xx *chip) init_viadev(chip, chip->capture_devno + 1, VIA_REG_CAPTURE_8233_STATUS + 0x10, 7, 1); if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024)) < 0) + snd_dma_pci_data(chip->pci), 64*1024, 128*1024)) < 0) return err; return 0; @@ -1411,9 +1394,9 @@ static int __devinit snd_via8233_pcm_new(struct via82xx *chip) /* * create pcm instances for VIA8233A */ -static int __devinit snd_via8233a_pcm_new(struct via82xx *chip) +static int __devinit snd_via8233a_pcm_new(via82xx_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; chip->multi_devno = 0; @@ -1437,8 +1420,7 @@ static int __devinit snd_via8233a_pcm_new(struct via82xx *chip) init_viadev(chip, chip->capture_devno, VIA_REG_CAPTURE_8233_STATUS, 6, 1); if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024)) < 0) + snd_dma_pci_data(chip->pci), 64*1024, 128*1024)) < 0) return err; /* SPDIF supported? */ @@ -1457,8 +1439,7 @@ static int __devinit snd_via8233a_pcm_new(struct via82xx *chip) init_viadev(chip, chip->playback_devno, 0x30, 3, 0); if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024)) < 0) + snd_dma_pci_data(chip->pci), 64*1024, 128*1024)) < 0) return err; return 0; @@ -1467,9 +1448,9 @@ static int __devinit snd_via8233a_pcm_new(struct via82xx *chip) /* * create a pcm instance for via686a/b */ -static int __devinit snd_via686_pcm_new(struct via82xx *chip) +static int __devinit snd_via686_pcm_new(via82xx_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; chip->playback_devno = 0; @@ -1489,8 +1470,7 @@ static int __devinit snd_via686_pcm_new(struct via82xx *chip) init_viadev(chip, 1, VIA_REG_CAPTURE_STATUS, 0, 1); if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024)) < 0) + snd_dma_pci_data(chip->pci), 64*1024, 128*1024)) < 0) return err; return 0; @@ -1501,8 +1481,7 @@ static int __devinit snd_via686_pcm_new(struct via82xx *chip) * Mixer part */ -static int snd_via8233_capture_source_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_via8233_capture_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { /* formerly they were "Line" and "Mic", but it looks like that they * have nothing to do with the actual physical connections... @@ -1519,19 +1498,17 @@ static int snd_via8233_capture_source_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_via8233_capture_source_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_capture_source_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned long port = chip->port + (kcontrol->id.index ? (VIA_REG_CAPTURE_CHANNEL + 0x10) : VIA_REG_CAPTURE_CHANNEL); ucontrol->value.enumerated.item[0] = inb(port) & VIA_REG_CAPTURE_CHANNEL_MIC ? 1 : 0; return 0; } -static int snd_via8233_capture_source_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_capture_source_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned long port = chip->port + (kcontrol->id.index ? (VIA_REG_CAPTURE_CHANNEL + 0x10) : VIA_REG_CAPTURE_CHANNEL); u8 val, oval; @@ -1546,7 +1523,7 @@ static int snd_via8233_capture_source_put(struct snd_kcontrol *kcontrol, return val != oval; } -static struct snd_kcontrol_new snd_via8233_capture_source __devinitdata = { +static snd_kcontrol_new_t snd_via8233_capture_source __devinitdata = { .name = "Input Source Select", .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .info = snd_via8233_capture_source_info, @@ -1554,8 +1531,7 @@ static struct snd_kcontrol_new snd_via8233_capture_source __devinitdata = { .put = snd_via8233_capture_source_put, }; -static int snd_via8233_dxs3_spdif_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_via8233_dxs3_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1564,10 +1540,9 @@ static int snd_via8233_dxs3_spdif_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_via8233_dxs3_spdif_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_dxs3_spdif_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); u8 val; pci_read_config_byte(chip->pci, VIA8233_SPDIF_CTRL, &val); @@ -1575,10 +1550,9 @@ static int snd_via8233_dxs3_spdif_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_via8233_dxs3_spdif_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_dxs3_spdif_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); u8 val, oval; pci_read_config_byte(chip->pci, VIA8233_SPDIF_CTRL, &oval); @@ -1594,7 +1568,7 @@ static int snd_via8233_dxs3_spdif_put(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_via8233_dxs3_spdif_control __devinitdata = { +static snd_kcontrol_new_t snd_via8233_dxs3_spdif_control __devinitdata = { .name = SNDRV_CTL_NAME_IEC958("Output ",NONE,SWITCH), .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .info = snd_via8233_dxs3_spdif_info, @@ -1602,8 +1576,7 @@ static struct snd_kcontrol_new snd_via8233_dxs3_spdif_control __devinitdata = { .put = snd_via8233_dxs3_spdif_put, }; -static int snd_via8233_dxs_volume_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_via8233_dxs_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1612,10 +1585,9 @@ static int snd_via8233_dxs_volume_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_via8233_dxs_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_dxs_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioff(kcontrol, &ucontrol->id); ucontrol->value.integer.value[0] = VIA_DXS_MAX_VOLUME - chip->playback_volume[idx][0]; @@ -1623,19 +1595,17 @@ static int snd_via8233_dxs_volume_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_via8233_pcmdxs_volume_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_pcmdxs_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = VIA_DXS_MAX_VOLUME - chip->playback_volume_c[0]; ucontrol->value.integer.value[1] = VIA_DXS_MAX_VOLUME - chip->playback_volume_c[1]; return 0; } -static int snd_via8233_dxs_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_dxs_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned int idx = snd_ctl_get_ioff(kcontrol, &ucontrol->id); unsigned long port = chip->port + 0x10 * idx; unsigned char val; @@ -1655,10 +1625,9 @@ static int snd_via8233_dxs_volume_put(struct snd_kcontrol *kcontrol, return change; } -static int snd_via8233_pcmdxs_volume_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_via8233_pcmdxs_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct via82xx *chip = snd_kcontrol_chip(kcontrol); + via82xx_t *chip = snd_kcontrol_chip(kcontrol); unsigned int idx; unsigned char val; int i, change = 0; @@ -1681,7 +1650,7 @@ static int snd_via8233_pcmdxs_volume_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_via8233_pcmdxs_volume_control __devinitdata = { +static snd_kcontrol_new_t snd_via8233_pcmdxs_volume_control __devinitdata = { .name = "PCM Playback Volume", .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .info = snd_via8233_dxs_volume_info, @@ -1689,7 +1658,7 @@ static struct snd_kcontrol_new snd_via8233_pcmdxs_volume_control __devinitdata = .put = snd_via8233_pcmdxs_volume_put, }; -static struct snd_kcontrol_new snd_via8233_dxs_volume_control __devinitdata = { +static snd_kcontrol_new_t snd_via8233_dxs_volume_control __devinitdata = { .name = "VIA DXS Playback Volume", .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .count = 4, @@ -1701,15 +1670,15 @@ static struct snd_kcontrol_new snd_via8233_dxs_volume_control __devinitdata = { /* */ -static void snd_via82xx_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_via82xx_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct via82xx *chip = bus->private_data; + via82xx_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_via82xx_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_via82xx_mixer_free_ac97(ac97_t *ac97) { - struct via82xx *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; chip->ac97 = NULL; } @@ -1763,20 +1732,14 @@ static struct ac97_quirk ac97_quirks[] = { .name = "Arima Notebook", .type = AC97_TUNE_HP_ONLY, }, - { - .subvendor = 0x161f, - .subdevice = 0x2032, - .name = "Targa Traveller 811", - .type = AC97_TUNE_HP_ONLY, - }, { } /* terminator */ }; -static int __devinit snd_via82xx_mixer_new(struct via82xx *chip, const char *quirk_override) +static int __devinit snd_via82xx_mixer_new(via82xx_t *chip, const char *quirk_override) { - struct snd_ac97_template ac97; + ac97_template_t ac97; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_via82xx_codec_write, .read = snd_via82xx_codec_read, .wait = snd_via82xx_codec_wait, @@ -1807,7 +1770,7 @@ static int __devinit snd_via82xx_mixer_new(struct via82xx *chip, const char *qui #ifdef SUPPORT_JOYSTICK #define JOYSTICK_ADDR 0x200 -static int __devinit snd_via686_create_gameport(struct via82xx *chip, unsigned char *legacy) +static int __devinit snd_via686_create_gameport(via82xx_t *chip, unsigned char *legacy) { struct gameport *gp; struct resource *r; @@ -1817,8 +1780,7 @@ static int __devinit snd_via686_create_gameport(struct via82xx *chip, unsigned c r = request_region(JOYSTICK_ADDR, 8, "VIA686 gameport"); if (!r) { - printk(KERN_WARNING "via82xx: cannot reserve joystick port 0x%#x\n", - JOYSTICK_ADDR); + printk(KERN_WARNING "via82xx: cannot reserve joystick port 0x%#x\n", JOYSTICK_ADDR); return -EBUSY; } @@ -1844,7 +1806,7 @@ static int __devinit snd_via686_create_gameport(struct via82xx *chip, unsigned c return 0; } -static void snd_via686_free_gameport(struct via82xx *chip) +static void snd_via686_free_gameport(via82xx_t *chip) { if (chip->gameport) { struct resource *r = gameport_get_port_data(chip->gameport); @@ -1855,11 +1817,11 @@ static void snd_via686_free_gameport(struct via82xx *chip) } } #else -static inline int snd_via686_create_gameport(struct via82xx *chip, unsigned char *legacy) +static inline int snd_via686_create_gameport(via82xx_t *chip, unsigned char *legacy) { return -ENOSYS; } -static inline void snd_via686_free_gameport(struct via82xx *chip) { } +static inline void snd_via686_free_gameport(via82xx_t *chip) { } #endif @@ -1867,7 +1829,7 @@ static inline void snd_via686_free_gameport(struct via82xx *chip) { } * */ -static int __devinit snd_via8233_init_misc(struct via82xx *chip) +static int __devinit snd_via8233_init_misc(via82xx_t *chip) { int i, err, caps; unsigned char val; @@ -1888,7 +1850,7 @@ static int __devinit snd_via8233_init_misc(struct via82xx *chip) /* when no h/w PCM volume control is found, use DXS volume control * as the PCM vol control */ - struct snd_ctl_elem_id sid; + snd_ctl_elem_id_t sid; memset(&sid, 0, sizeof(sid)); strcpy(sid.name, "PCM Playback Volume"); sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; @@ -1915,7 +1877,7 @@ static int __devinit snd_via8233_init_misc(struct via82xx *chip) return 0; } -static int __devinit snd_via686_init_misc(struct via82xx *chip) +static int __devinit snd_via686_init_misc(via82xx_t *chip) { unsigned char legacy, legacy_cfg; int rev_h = 0; @@ -1992,10 +1954,9 @@ static int __devinit snd_via686_init_misc(struct via82xx *chip) /* * proc interface */ -static void snd_via82xx_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_via82xx_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct via82xx *chip = entry->private_data; + via82xx_t *chip = entry->private_data; int i; snd_iprintf(buffer, "%s\n\n", chip->card->longname); @@ -2004,9 +1965,9 @@ static void snd_via82xx_proc_read(struct snd_info_entry *entry, } } -static void __devinit snd_via82xx_proc_init(struct via82xx *chip) +static void __devinit snd_via82xx_proc_init(via82xx_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "via82xx", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_via82xx_proc_read); @@ -2016,7 +1977,7 @@ static void __devinit snd_via82xx_proc_init(struct via82xx *chip) * */ -static int snd_via82xx_chip_init(struct via82xx *chip) +static int snd_via82xx_chip_init(via82xx_t *chip) { unsigned int val; unsigned long end_time; @@ -2119,8 +2080,7 @@ static int snd_via82xx_chip_init(struct via82xx *chip) unsigned long port = chip->port + 0x10 * idx; for (i = 0; i < 2; i++) { chip->playback_volume[idx][i]=chip->playback_volume_c[i]; - outb(chip->playback_volume_c[i], - port + VIA_REG_OFS_PLAYBACK_VOLUME_L + i); + outb(chip->playback_volume_c[i], port + VIA_REG_OFS_PLAYBACK_VOLUME_L + i); } } } @@ -2132,15 +2092,14 @@ static int snd_via82xx_chip_init(struct via82xx *chip) /* * power management */ -static int snd_via82xx_suspend(struct pci_dev *pci, pm_message_t state) +static int snd_via82xx_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct via82xx *chip = card->private_data; + via82xx_t *chip = card->pm_private_data; int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < 2; i++) - snd_pcm_suspend_all(chip->pcms[i]); + if (chip->pcms[i]) + snd_pcm_suspend_all(chip->pcms[i]); for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]); synchronize_irq(chip->irq); @@ -2153,21 +2112,18 @@ static int snd_via82xx_suspend(struct pci_dev *pci, pm_message_t state) chip->capture_src_saved[1] = inb(chip->port + VIA_REG_CAPTURE_CHANNEL + 0x10); } - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); + pci_set_power_state(chip->pci, 3); + pci_disable_device(chip->pci); return 0; } -static int snd_via82xx_resume(struct pci_dev *pci) +static int snd_via82xx_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct via82xx *chip = card->private_data; + via82xx_t *chip = card->pm_private_data; int i; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); + pci_enable_device(chip->pci); + pci_set_power_state(chip->pci, 0); snd_via82xx_chip_init(chip); @@ -2187,12 +2143,11 @@ static int snd_via82xx_resume(struct pci_dev *pci) for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -static int snd_via82xx_free(struct via82xx *chip) +static int snd_via82xx_free(via82xx_t *chip) { unsigned int i; @@ -2204,7 +2159,7 @@ static int snd_via82xx_free(struct via82xx *chip) synchronize_irq(chip->irq); __end_hw: if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); release_and_free_resource(chip->mpu_res); pci_release_regions(chip->pci); @@ -2218,22 +2173,22 @@ static int snd_via82xx_free(struct via82xx *chip) return 0; } -static int snd_via82xx_dev_free(struct snd_device *device) +static int snd_via82xx_dev_free(snd_device_t *device) { - struct via82xx *chip = device->device_data; + via82xx_t *chip = device->device_data; return snd_via82xx_free(chip); } -static int __devinit snd_via82xx_create(struct snd_card *card, +static int __devinit snd_via82xx_create(snd_card_t * card, struct pci_dev *pci, int chip_type, int revision, unsigned int ac97_clock, - struct via82xx ** r_via) + via82xx_t ** r_via) { - struct via82xx *chip; + via82xx_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_via82xx_dev_free, }; @@ -2270,7 +2225,7 @@ static int __devinit snd_via82xx_create(struct snd_card *card, chip_type == TYPE_VIA8233 ? snd_via8233_interrupt : snd_via686_interrupt, SA_INTERRUPT|SA_SHIRQ, - card->driver, chip)) { + card->driver, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_via82xx_free(chip); return -EBUSY; @@ -2352,7 +2307,6 @@ static int __devinit check_dxs_list(struct pci_dev *pci) { .subvendor = 0x1458, .subdevice = 0xa002, .action = VIA_DXS_ENABLE }, /* Gigabyte GA-7VAXP */ { .subvendor = 0x1462, .subdevice = 0x0080, .action = VIA_DXS_SRC }, /* MSI K8T Neo-FIS2R */ { .subvendor = 0x1462, .subdevice = 0x0430, .action = VIA_DXS_SRC }, /* MSI 7142 (K8MM-V) */ - { .subvendor = 0x1462, .subdevice = 0x0470, .action = VIA_DXS_SRC }, /* MSI KT880 Delta-FSR */ { .subvendor = 0x1462, .subdevice = 0x3800, .action = VIA_DXS_ENABLE }, /* MSI KT266 */ { .subvendor = 0x1462, .subdevice = 0x5901, .action = VIA_DXS_NO_VRA }, /* MSI KT6 Delta-SR */ { .subvendor = 0x1462, .subdevice = 0x7023, .action = VIA_DXS_NO_VRA }, /* MSI K8T Neo2-FI */ @@ -2372,7 +2326,6 @@ static int __devinit check_dxs_list(struct pci_dev *pci) { .subvendor = 0x1631, .subdevice = 0xe004, .action = VIA_DXS_ENABLE }, /* Easy Note 3174, Packard Bell */ { .subvendor = 0x1695, .subdevice = 0x3005, .action = VIA_DXS_ENABLE }, /* EPoX EP-8K9A */ { .subvendor = 0x1849, .subdevice = 0x3059, .action = VIA_DXS_NO_VRA }, /* ASRock K7VM2 */ - { .subvendor = 0x1849, .subdevice = 0x9761, .action = VIA_DXS_SRC }, /* ASRock mobo(?) */ { .subvendor = 0x1919, .subdevice = 0x200a, .action = VIA_DXS_NO_VRA }, /* Soltek SL-K8Tpro-939 */ { .subvendor = 0x4005, .subdevice = 0x4710, .action = VIA_DXS_SRC }, /* MSI K7T266 Pro2 (MS-6380 V2.0) BIOS 3.7 */ { } /* terminator */ @@ -2409,8 +2362,8 @@ static int __devinit check_dxs_list(struct pci_dev *pci) static int __devinit snd_via82xx_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct via82xx *chip; + snd_card_t *card; + via82xx_t *chip; unsigned char revision; int chip_type = 0, card_type; unsigned int i; @@ -2465,7 +2418,6 @@ static int __devinit snd_via82xx_probe(struct pci_dev *pci, if ((err = snd_via82xx_create(card, pci, chip_type, revision, ac97_clock, &chip)) < 0) goto __error; - card->private_data = chip; if ((err = snd_via82xx_mixer_new(chip, ac97_quirk)) < 0) goto __error; @@ -2494,6 +2446,8 @@ static int __devinit snd_via82xx_probe(struct pci_dev *pci, goto __error; } + snd_card_set_pm_callback(card, snd_via82xx_suspend, snd_via82xx_resume, chip); + /* disable interrupts */ for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]); @@ -2527,10 +2481,7 @@ static struct pci_driver driver = { .id_table = snd_via82xx_ids, .probe = snd_via82xx_probe, .remove = __devexit_p(snd_via82xx_remove), -#ifdef CONFIG_PM - .suspend = snd_via82xx_suspend, - .resume = snd_via82xx_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_via82xx_init(void) diff --git a/trunk/sound/pci/via82xx_modem.c b/trunk/sound/pci/via82xx_modem.c index 22ce4d309929..b83660bd05b0 100644 --- a/trunk/sound/pci/via82xx_modem.c +++ b/trunk/sound/pci/via82xx_modem.c @@ -206,6 +206,9 @@ DEFINE_VIA_REGSET(MI, 0x50); VIA_MC97_CTRL_SECONDARY) +typedef struct _snd_via82xx_modem via82xx_t; +typedef struct via_dev viadev_t; + /* * pcm stream */ @@ -217,11 +220,11 @@ struct snd_via_sg_table { #define VIA_TABLE_SIZE 255 -struct viadev { +struct via_dev { unsigned int reg_offset; unsigned long port; int direction; /* playback = 0, capture = 1 */ - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; int running; unsigned int tbl_entries; /* # descriptors */ struct snd_dma_buffer table; @@ -236,7 +239,7 @@ enum { TYPE_CARD_VIA82XX_MODEM = 1 }; #define VIA_MAX_MODEM_DEVS 2 -struct via82xx_modem { +struct _snd_via82xx_modem { int irq; unsigned long port; @@ -244,21 +247,21 @@ struct via82xx_modem { unsigned int intr_mask; /* SGD_SHADOW mask to check interrupts */ struct pci_dev *pci; - struct snd_card *card; + snd_card_t *card; unsigned int num_devs; unsigned int playback_devno, capture_devno; - struct viadev devs[VIA_MAX_MODEM_DEVS]; + viadev_t devs[VIA_MAX_MODEM_DEVS]; - struct snd_pcm *pcms[2]; + snd_pcm_t *pcms[2]; - struct snd_ac97_bus *ac97_bus; - struct snd_ac97 *ac97; + ac97_bus_t *ac97_bus; + ac97_t *ac97; unsigned int ac97_clock; unsigned int ac97_secondary; /* secondary AC'97 codec is present */ spinlock_t reg_lock; - struct snd_info_entry *proc_entry; + snd_info_entry_t *proc_entry; }; static struct pci_device_id snd_via82xx_modem_ids[] = { @@ -276,12 +279,12 @@ MODULE_DEVICE_TABLE(pci, snd_via82xx_modem_ids); * periods = number of periods * fragsize = period size in bytes */ -static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substream, +static int build_via_table(viadev_t *dev, snd_pcm_substream_t *substream, struct pci_dev *pci, unsigned int periods, unsigned int fragsize) { unsigned int i, idx, ofs, rest; - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); + via82xx_t *chip = snd_pcm_substream_chip(substream); struct snd_sg_buf *sgbuf = snd_pcm_substream_sgbuf(substream); if (dev->table.area == NULL) { @@ -343,7 +346,7 @@ static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substre } -static int clean_via_table(struct viadev *dev, struct snd_pcm_substream *substream, +static int clean_via_table(viadev_t *dev, snd_pcm_substream_t *substream, struct pci_dev *pci) { if (dev->table.area) { @@ -359,17 +362,17 @@ static int clean_via_table(struct viadev *dev, struct snd_pcm_substream *substre * Basic I/O */ -static inline unsigned int snd_via82xx_codec_xread(struct via82xx_modem *chip) +static inline unsigned int snd_via82xx_codec_xread(via82xx_t *chip) { return inl(VIAREG(chip, AC97)); } -static inline void snd_via82xx_codec_xwrite(struct via82xx_modem *chip, unsigned int val) +static inline void snd_via82xx_codec_xwrite(via82xx_t *chip, unsigned int val) { outl(val, VIAREG(chip, AC97)); } -static int snd_via82xx_codec_ready(struct via82xx_modem *chip, int secondary) +static int snd_via82xx_codec_ready(via82xx_t *chip, int secondary) { unsigned int timeout = 1000; /* 1ms */ unsigned int val; @@ -379,12 +382,11 @@ static int snd_via82xx_codec_ready(struct via82xx_modem *chip, int secondary) if (!((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY)) return val & 0xffff; } - snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n", - secondary, snd_via82xx_codec_xread(chip)); + snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n", secondary, snd_via82xx_codec_xread(chip)); return -EIO; } -static int snd_via82xx_codec_valid(struct via82xx_modem *chip, int secondary) +static int snd_via82xx_codec_valid(via82xx_t *chip, int secondary) { unsigned int timeout = 1000; /* 1ms */ unsigned int val, val1; @@ -401,20 +403,20 @@ static int snd_via82xx_codec_valid(struct via82xx_modem *chip, int secondary) return -EIO; } -static void snd_via82xx_codec_wait(struct snd_ac97 *ac97) +static void snd_via82xx_codec_wait(ac97_t *ac97) { - struct via82xx_modem *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; int err; err = snd_via82xx_codec_ready(chip, ac97->num); /* here we need to wait fairly for long time.. */ msleep(500); } -static void snd_via82xx_codec_write(struct snd_ac97 *ac97, +static void snd_via82xx_codec_write(ac97_t *ac97, unsigned short reg, unsigned short val) { - struct via82xx_modem *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; unsigned int xval; if(reg == AC97_GPIO_STATUS) { outl(val, VIAREG(chip, GPI_STATUS)); @@ -428,9 +430,9 @@ static void snd_via82xx_codec_write(struct snd_ac97 *ac97, snd_via82xx_codec_ready(chip, ac97->num); } -static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned short reg) +static unsigned short snd_via82xx_codec_read(ac97_t *ac97, unsigned short reg) { - struct via82xx_modem *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; unsigned int xval, val = 0xffff; int again = 0; @@ -440,8 +442,7 @@ static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned sho xval |= (reg & 0x7f) << VIA_REG_AC97_CMD_SHIFT; while (1) { if (again++ > 3) { - snd_printk(KERN_ERR "codec_read: codec %i is not valid [0x%x]\n", - ac97->num, snd_via82xx_codec_xread(chip)); + snd_printk(KERN_ERR "codec_read: codec %i is not valid [0x%x]\n", ac97->num, snd_via82xx_codec_xread(chip)); return 0xffff; } snd_via82xx_codec_xwrite(chip, xval); @@ -455,7 +456,7 @@ static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned sho return val & 0xffff; } -static void snd_via82xx_channel_reset(struct via82xx_modem *chip, struct viadev *viadev) +static void snd_via82xx_channel_reset(via82xx_t *chip, viadev_t *viadev) { outb(VIA_REG_CTRL_PAUSE | VIA_REG_CTRL_TERMINATE | VIA_REG_CTRL_RESET, VIADEV_REG(viadev, OFFSET_CONTROL)); @@ -477,7 +478,7 @@ static void snd_via82xx_channel_reset(struct via82xx_modem *chip, struct viadev static irqreturn_t snd_via82xx_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct via82xx_modem *chip = dev_id; + via82xx_t *chip = dev_id; unsigned int status; unsigned int i; @@ -490,7 +491,7 @@ static irqreturn_t snd_via82xx_interrupt(int irq, void *dev_id, struct pt_regs * /* check status for each stream */ spin_lock(&chip->reg_lock); for (i = 0; i < chip->num_devs; i++) { - struct viadev *viadev = &chip->devs[i]; + viadev_t *viadev = &chip->devs[i]; unsigned char c_status = inb(VIADEV_REG(viadev, OFFSET_STATUS)); c_status &= (VIA_REG_STAT_EOL|VIA_REG_STAT_FLAG|VIA_REG_STAT_STOPPED); if (! c_status) @@ -513,10 +514,10 @@ static irqreturn_t snd_via82xx_interrupt(int irq, void *dev_id, struct pt_regs * /* * trigger callback */ -static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_via82xx_pcm_trigger(snd_pcm_substream_t * substream, int cmd) { - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; unsigned char val = 0; switch (cmd) { @@ -554,11 +555,9 @@ static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) */ #define check_invalid_pos(viadev,pos) \ - ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 ||\ - viadev->lastpos < viadev->bufsize2)) + ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 || viadev->lastpos < viadev->bufsize2)) -static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int idx, - unsigned int count) +static inline unsigned int calc_linear_pos(viadev_t *viadev, unsigned int idx, unsigned int count) { unsigned int size, res; @@ -567,33 +566,24 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i /* check the validity of the calculated position */ if (size < count) { - snd_printd(KERN_ERR "invalid via82xx_cur_ptr (size = %d, count = %d)\n", - (int)size, (int)count); + snd_printd(KERN_ERR "invalid via82xx_cur_ptr (size = %d, count = %d)\n", (int)size, (int)count); res = viadev->lastpos; } else if (check_invalid_pos(viadev, res)) { #ifdef POINTER_DEBUG - printk(KERN_DEBUG "fail: idx = %i/%i, lastpos = 0x%x, " - "bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, " - "count = 0x%x\n", idx, viadev->tbl_entries, viadev->lastpos, - viadev->bufsize2, viadev->idx_table[idx].offset, - viadev->idx_table[idx].size, count); + printk(KERN_DEBUG "fail: idx = %i/%i, lastpos = 0x%x, bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, count = 0x%x\n", idx, viadev->tbl_entries, viadev->lastpos, viadev->bufsize2, viadev->idx_table[idx].offset, viadev->idx_table[idx].size, count); #endif if (count && size < count) { - snd_printd(KERN_ERR "invalid via82xx_cur_ptr, " - "using last valid pointer\n"); + snd_printd(KERN_ERR "invalid via82xx_cur_ptr, using last valid pointer\n"); res = viadev->lastpos; } else { if (! count) /* bogus count 0 on the DMA boundary? */ res = viadev->idx_table[idx].offset; else - /* count register returns full size - * when end of buffer is reached - */ + /* count register returns full size when end of buffer is reached */ res = viadev->idx_table[idx].offset + size; if (check_invalid_pos(viadev, res)) { - snd_printd(KERN_ERR "invalid via82xx_cur_ptr (2), " - "using last valid pointer\n"); + snd_printd(KERN_ERR "invalid via82xx_cur_ptr (2), using last valid pointer\n"); res = viadev->lastpos; } } @@ -607,10 +597,10 @@ static inline unsigned int calc_linear_pos(struct viadev *viadev, unsigned int i /* * get the current pointer on via686 */ -static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_via686_pcm_pointer(snd_pcm_substream_t *substream) { - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; unsigned int idx, ptr, count, res; snd_assert(viadev->tbl_entries, return 0); @@ -626,8 +616,7 @@ static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substr if (ptr <= (unsigned int)viadev->table.addr) idx = 0; else /* CURR_PTR holds the address + 8 */ - idx = ((ptr - (unsigned int)viadev->table.addr) / 8 - 1) % - viadev->tbl_entries; + idx = ((ptr - (unsigned int)viadev->table.addr) / 8 - 1) % viadev->tbl_entries; res = calc_linear_pos(viadev, idx, count); spin_unlock(&chip->reg_lock); @@ -638,11 +627,11 @@ static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substr * hw_params callback: * allocate the buffer and build up the buffer description table */ -static int snd_via82xx_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_via82xx_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; int err; err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); @@ -664,10 +653,10 @@ static int snd_via82xx_hw_params(struct snd_pcm_substream *substream, * hw_free callback: * clean up the buffer description table and release the buffer */ -static int snd_via82xx_hw_free(struct snd_pcm_substream *substream) +static int snd_via82xx_hw_free(snd_pcm_substream_t * substream) { - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; clean_via_table(viadev, substream, chip->pci); snd_pcm_lib_free_pages(substream); @@ -678,7 +667,7 @@ static int snd_via82xx_hw_free(struct snd_pcm_substream *substream) /* * set up the table pointer */ -static void snd_via82xx_set_table_ptr(struct via82xx_modem *chip, struct viadev *viadev) +static void snd_via82xx_set_table_ptr(via82xx_t *chip, viadev_t *viadev) { snd_via82xx_codec_ready(chip, chip->ac97_secondary); outl((u32)viadev->table.addr, VIADEV_REG(viadev, OFFSET_TABLE_PTR)); @@ -689,10 +678,10 @@ static void snd_via82xx_set_table_ptr(struct via82xx_modem *chip, struct viadev /* * prepare callback for playback and capture */ -static int snd_via82xx_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_via82xx_pcm_prepare(snd_pcm_substream_t *substream) { - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = substream->runtime->private_data; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; snd_via82xx_channel_reset(chip, viadev); /* this must be set after channel_reset */ @@ -705,7 +694,7 @@ static int snd_via82xx_pcm_prepare(struct snd_pcm_substream *substream) /* * pcm hardware definition, identical for both playback and capture */ -static struct snd_pcm_hardware snd_via82xx_hw = +static snd_pcm_hardware_t snd_via82xx_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -730,13 +719,12 @@ static struct snd_pcm_hardware snd_via82xx_hw = /* * open callback skeleton */ -static int snd_via82xx_modem_pcm_open(struct via82xx_modem *chip, struct viadev *viadev, - struct snd_pcm_substream *substream) +static int snd_via82xx_modem_pcm_open(via82xx_t *chip, viadev_t *viadev, snd_pcm_substream_t * substream) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; int err; static unsigned int rates[] = { 8000, 9600, 12000, 16000 }; - static struct snd_pcm_hw_constraint_list hw_constraints_rates = { + static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, @@ -744,8 +732,7 @@ static int snd_via82xx_modem_pcm_open(struct via82xx_modem *chip, struct viadev runtime->hw = snd_via82xx_hw; - if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, - &hw_constraints_rates)) < 0) + if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates)) < 0) return err; /* we may remove following constaint when we modify table entries @@ -763,10 +750,10 @@ static int snd_via82xx_modem_pcm_open(struct via82xx_modem *chip, struct viadev /* * open callback for playback */ -static int snd_via82xx_playback_open(struct snd_pcm_substream *substream) +static int snd_via82xx_playback_open(snd_pcm_substream_t * substream) { - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = &chip->devs[chip->playback_devno + substream->number]; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = &chip->devs[chip->playback_devno + substream->number]; return snd_via82xx_modem_pcm_open(chip, viadev, substream); } @@ -774,10 +761,10 @@ static int snd_via82xx_playback_open(struct snd_pcm_substream *substream) /* * open callback for capture */ -static int snd_via82xx_capture_open(struct snd_pcm_substream *substream) +static int snd_via82xx_capture_open(snd_pcm_substream_t * substream) { - struct via82xx_modem *chip = snd_pcm_substream_chip(substream); - struct viadev *viadev = &chip->devs[chip->capture_devno + substream->pcm->device]; + via82xx_t *chip = snd_pcm_substream_chip(substream); + viadev_t *viadev = &chip->devs[chip->capture_devno + substream->pcm->device]; return snd_via82xx_modem_pcm_open(chip, viadev, substream); } @@ -785,9 +772,9 @@ static int snd_via82xx_capture_open(struct snd_pcm_substream *substream) /* * close callback */ -static int snd_via82xx_pcm_close(struct snd_pcm_substream *substream) +static int snd_via82xx_pcm_close(snd_pcm_substream_t * substream) { - struct viadev *viadev = substream->runtime->private_data; + viadev_t *viadev = (viadev_t *)substream->runtime->private_data; viadev->substream = NULL; return 0; @@ -795,7 +782,7 @@ static int snd_via82xx_pcm_close(struct snd_pcm_substream *substream) /* via686 playback callbacks */ -static struct snd_pcm_ops snd_via686_playback_ops = { +static snd_pcm_ops_t snd_via686_playback_ops = { .open = snd_via82xx_playback_open, .close = snd_via82xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -808,7 +795,7 @@ static struct snd_pcm_ops snd_via686_playback_ops = { }; /* via686 capture callbacks */ -static struct snd_pcm_ops snd_via686_capture_ops = { +static snd_pcm_ops_t snd_via686_capture_ops = { .open = snd_via82xx_capture_open, .close = snd_via82xx_pcm_close, .ioctl = snd_pcm_lib_ioctl, @@ -821,8 +808,7 @@ static struct snd_pcm_ops snd_via686_capture_ops = { }; -static void init_viadev(struct via82xx_modem *chip, int idx, unsigned int reg_offset, - int direction) +static void init_viadev(via82xx_t *chip, int idx, unsigned int reg_offset, int direction) { chip->devs[idx].reg_offset = reg_offset; chip->devs[idx].direction = direction; @@ -832,9 +818,9 @@ static void init_viadev(struct via82xx_modem *chip, int idx, unsigned int reg_of /* * create a pcm instance for via686a/b */ -static int __devinit snd_via686_pcm_new(struct via82xx_modem *chip) +static int __devinit snd_via686_pcm_new(via82xx_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; chip->playback_devno = 0; @@ -855,8 +841,7 @@ static int __devinit snd_via686_pcm_new(struct via82xx_modem *chip) init_viadev(chip, 1, VIA_REG_MI_STATUS, 1); if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, - snd_dma_pci_data(chip->pci), - 64*1024, 128*1024)) < 0) + snd_dma_pci_data(chip->pci), 64*1024, 128*1024)) < 0) return err; return 0; @@ -868,24 +853,24 @@ static int __devinit snd_via686_pcm_new(struct via82xx_modem *chip) */ -static void snd_via82xx_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_via82xx_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct via82xx_modem *chip = bus->private_data; + via82xx_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_via82xx_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_via82xx_mixer_free_ac97(ac97_t *ac97) { - struct via82xx_modem *chip = ac97->private_data; + via82xx_t *chip = ac97->private_data; chip->ac97 = NULL; } -static int __devinit snd_via82xx_mixer_new(struct via82xx_modem *chip) +static int __devinit snd_via82xx_mixer_new(via82xx_t *chip) { - struct snd_ac97_template ac97; + ac97_template_t ac97; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_via82xx_codec_write, .read = snd_via82xx_codec_read, .wait = snd_via82xx_codec_wait, @@ -913,9 +898,9 @@ static int __devinit snd_via82xx_mixer_new(struct via82xx_modem *chip) /* * proc interface */ -static void snd_via82xx_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void snd_via82xx_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct via82xx_modem *chip = entry->private_data; + via82xx_t *chip = entry->private_data; int i; snd_iprintf(buffer, "%s\n\n", chip->card->longname); @@ -924,9 +909,9 @@ static void snd_via82xx_proc_read(struct snd_info_entry *entry, struct snd_info_ } } -static void __devinit snd_via82xx_proc_init(struct via82xx_modem *chip) +static void __devinit snd_via82xx_proc_init(via82xx_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "via82xx", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_via82xx_proc_read); @@ -936,7 +921,7 @@ static void __devinit snd_via82xx_proc_init(struct via82xx_modem *chip) * */ -static int snd_via82xx_chip_init(struct via82xx_modem *chip) +static int snd_via82xx_chip_init(via82xx_t *chip) { unsigned int val; unsigned long end_time; @@ -1019,35 +1004,31 @@ static int snd_via82xx_chip_init(struct via82xx_modem *chip) /* * power management */ -static int snd_via82xx_suspend(struct pci_dev *pci, pm_message_t state) +static int snd_via82xx_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct via82xx_modem *chip = card->private_data; + via82xx_t *chip = card->pm_private_data; int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); for (i = 0; i < 2; i++) - snd_pcm_suspend_all(chip->pcms[i]); + if (chip->pcms[i]) + snd_pcm_suspend_all(chip->pcms[i]); for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]); synchronize_irq(chip->irq); snd_ac97_suspend(chip->ac97); - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); + pci_set_power_state(chip->pci, 3); + pci_disable_device(chip->pci); return 0; } -static int snd_via82xx_resume(struct pci_dev *pci) +static int snd_via82xx_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct via82xx_modem *chip = card->private_data; + via82xx_t *chip = card->pm_private_data; int i; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); + pci_enable_device(chip->pci); + pci_set_power_state(chip->pci, 0); + pci_set_master(chip->pci); snd_via82xx_chip_init(chip); @@ -1056,12 +1037,11 @@ static int snd_via82xx_resume(struct pci_dev *pci) for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]); - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -static int snd_via82xx_free(struct via82xx_modem *chip) +static int snd_via82xx_free(via82xx_t *chip) { unsigned int i; @@ -1073,29 +1053,29 @@ static int snd_via82xx_free(struct via82xx_modem *chip) synchronize_irq(chip->irq); __end_hw: if (chip->irq >= 0) - free_irq(chip->irq, chip); + free_irq(chip->irq, (void *)chip); pci_release_regions(chip->pci); pci_disable_device(chip->pci); kfree(chip); return 0; } -static int snd_via82xx_dev_free(struct snd_device *device) +static int snd_via82xx_dev_free(snd_device_t *device) { - struct via82xx_modem *chip = device->device_data; + via82xx_t *chip = device->device_data; return snd_via82xx_free(chip); } -static int __devinit snd_via82xx_create(struct snd_card *card, +static int __devinit snd_via82xx_create(snd_card_t * card, struct pci_dev *pci, int chip_type, int revision, unsigned int ac97_clock, - struct via82xx_modem ** r_via) + via82xx_t ** r_via) { - struct via82xx_modem *chip; + via82xx_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_via82xx_dev_free, }; @@ -1119,7 +1099,7 @@ static int __devinit snd_via82xx_create(struct snd_card *card, } chip->port = pci_resource_start(pci, 0); if (request_irq(pci->irq, snd_via82xx_interrupt, SA_INTERRUPT|SA_SHIRQ, - card->driver, chip)) { + card->driver, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_via82xx_free(chip); return -EBUSY; @@ -1154,8 +1134,8 @@ static int __devinit snd_via82xx_create(struct snd_card *card, static int __devinit snd_via82xx_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { - struct snd_card *card; - struct via82xx_modem *chip; + snd_card_t *card; + via82xx_t *chip; unsigned char revision; int chip_type = 0, card_type; unsigned int i; @@ -1181,13 +1161,14 @@ static int __devinit snd_via82xx_probe(struct pci_dev *pci, if ((err = snd_via82xx_create(card, pci, chip_type, revision, ac97_clock, &chip)) < 0) goto __error; - card->private_data = chip; if ((err = snd_via82xx_mixer_new(chip)) < 0) goto __error; if ((err = snd_via686_pcm_new(chip)) < 0 ) goto __error; + snd_card_set_pm_callback(card, snd_via82xx_suspend, snd_via82xx_resume, chip); + /* disable interrupts */ for (i = 0; i < chip->num_devs; i++) snd_via82xx_channel_reset(chip, &chip->devs[i]); @@ -1220,10 +1201,7 @@ static struct pci_driver driver = { .id_table = snd_via82xx_modem_ids, .probe = snd_via82xx_probe, .remove = __devexit_p(snd_via82xx_remove), -#ifdef CONFIG_PM - .suspend = snd_via82xx_suspend, - .resume = snd_via82xx_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_via82xx_init(void) diff --git a/trunk/sound/pci/vx222/vx222.c b/trunk/sound/pci/vx222/vx222.c index c816ddf1b215..dca6bd2c7580 100644 --- a/trunk/sound/pci/vx222/vx222.c +++ b/trunk/sound/pci/vx222/vx222.c @@ -108,7 +108,7 @@ static struct snd_vx_hardware vx222_mic_hw = { /* */ -static int snd_vx222_free(struct vx_core *chip) +static int snd_vx222_free(vx_core_t *chip) { struct snd_vx222 *vx = (struct snd_vx222 *)chip; @@ -121,21 +121,21 @@ static int snd_vx222_free(struct vx_core *chip) return 0; } -static int snd_vx222_dev_free(struct snd_device *device) +static int snd_vx222_dev_free(snd_device_t *device) { - struct vx_core *chip = device->device_data; + vx_core_t *chip = device->device_data; return snd_vx222_free(chip); } -static int __devinit snd_vx222_create(struct snd_card *card, struct pci_dev *pci, +static int __devinit snd_vx222_create(snd_card_t *card, struct pci_dev *pci, struct snd_vx_hardware *hw, struct snd_vx222 **rchip) { - struct vx_core *chip; + vx_core_t *chip; struct snd_vx222 *vx; int i, err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_vx222_dev_free, }; struct snd_vx_ops *vx_ops; @@ -147,7 +147,7 @@ static int __devinit snd_vx222_create(struct snd_card *card, struct pci_dev *pci vx_ops = hw->type == VX_TYPE_BOARD ? &vx222_old_ops : &vx222_ops; chip = snd_vx_create(card, hw, vx_ops, - sizeof(struct snd_vx222) - sizeof(struct vx_core)); + sizeof(struct snd_vx222) - sizeof(vx_core_t)); if (! chip) { pci_disable_device(pci); return -ENOMEM; @@ -186,7 +186,7 @@ static int __devinit snd_vx222_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; + snd_card_t *card; struct snd_vx_hardware *hw; struct snd_vx222 *vx; int err; @@ -218,7 +218,6 @@ static int __devinit snd_vx222_probe(struct pci_dev *pci, snd_card_free(card); return err; } - card->private_data = vx; vx->core.ibl.size = ibl[dev]; sprintf(card->longname, "%s at 0x%lx & 0x%lx, irq %i", @@ -251,42 +250,12 @@ static void __devexit snd_vx222_remove(struct pci_dev *pci) pci_set_drvdata(pci, NULL); } -#ifdef CONFIG_PM -static int snd_vx222_suspend(struct pci_dev *pci, pm_message_t state) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_vx222 *vx = card->private_data; - int err; - - err = snd_vx_suspend(&vx->core, state); - pci_set_power_state(pci, PCI_D3hot); - pci_disable_device(pci); - pci_save_state(pci); - return err; -} - -static int snd_vx222_resume(struct pci_dev *pci) -{ - struct snd_card *card = pci_get_drvdata(pci); - struct snd_vx222 *vx = card->private_data; - - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_power_state(pci, PCI_D0); - pci_set_master(pci); - return snd_vx_resume(&vx->core); -} -#endif - static struct pci_driver driver = { .name = "Digigram VX222", .id_table = snd_vx222_ids, .probe = snd_vx222_probe, .remove = __devexit_p(snd_vx222_remove), -#ifdef CONFIG_PM - .suspend = snd_vx222_suspend, - .resume = snd_vx222_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_vx222_init(void) diff --git a/trunk/sound/pci/vx222/vx222.h b/trunk/sound/pci/vx222/vx222.h index 2f0d78f609a6..18478ae124a9 100644 --- a/trunk/sound/pci/vx222/vx222.h +++ b/trunk/sound/pci/vx222/vx222.h @@ -25,7 +25,7 @@ struct snd_vx222 { - struct vx_core core; + vx_core_t core; /* h/w config; for PLX and for DSP */ struct pci_dev *pci; diff --git a/trunk/sound/pci/vx222/vx222_ops.c b/trunk/sound/pci/vx222/vx222_ops.c index c705af409b0f..967bd5e6b23c 100644 --- a/trunk/sound/pci/vx222/vx222_ops.c +++ b/trunk/sound/pci/vx222/vx222_ops.c @@ -82,7 +82,7 @@ static int vx2_reg_index[VX_REG_MAX] = { [VX_GPIOC] = 0, /* on the PLX */ }; -static inline unsigned long vx2_reg_addr(struct vx_core *_chip, int reg) +static inline unsigned long vx2_reg_addr(vx_core_t *_chip, int reg) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; return chip->port[vx2_reg_index[reg]] + vx2_reg_offset[reg]; @@ -92,7 +92,7 @@ static inline unsigned long vx2_reg_addr(struct vx_core *_chip, int reg) * snd_vx_inb - read a byte from the register * @offset: register enum */ -static unsigned char vx2_inb(struct vx_core *chip, int offset) +static unsigned char vx2_inb(vx_core_t *chip, int offset) { return inb(vx2_reg_addr(chip, offset)); } @@ -102,7 +102,7 @@ static unsigned char vx2_inb(struct vx_core *chip, int offset) * @offset: the register offset * @val: the value to write */ -static void vx2_outb(struct vx_core *chip, int offset, unsigned char val) +static void vx2_outb(vx_core_t *chip, int offset, unsigned char val) { outb(val, vx2_reg_addr(chip, offset)); //printk("outb: %x -> %x\n", val, vx2_reg_addr(chip, offset)); @@ -112,7 +112,7 @@ static void vx2_outb(struct vx_core *chip, int offset, unsigned char val) * snd_vx_inl - read a 32bit word from the register * @offset: register enum */ -static unsigned int vx2_inl(struct vx_core *chip, int offset) +static unsigned int vx2_inl(vx_core_t *chip, int offset) { return inl(vx2_reg_addr(chip, offset)); } @@ -122,7 +122,7 @@ static unsigned int vx2_inl(struct vx_core *chip, int offset) * @offset: the register enum * @val: the value to write */ -static void vx2_outl(struct vx_core *chip, int offset, unsigned int val) +static void vx2_outl(vx_core_t *chip, int offset, unsigned int val) { // printk("outl: %x -> %x\n", val, vx2_reg_addr(chip, offset)); outl(val, vx2_reg_addr(chip, offset)); @@ -132,13 +132,13 @@ static void vx2_outl(struct vx_core *chip, int offset, unsigned int val) * redefine macros to call directly */ #undef vx_inb -#define vx_inb(chip,reg) vx2_inb((struct vx_core*)(chip), VX_##reg) +#define vx_inb(chip,reg) vx2_inb((vx_core_t*)(chip), VX_##reg) #undef vx_outb -#define vx_outb(chip,reg,val) vx2_outb((struct vx_core*)(chip), VX_##reg, val) +#define vx_outb(chip,reg,val) vx2_outb((vx_core_t*)(chip), VX_##reg, val) #undef vx_inl -#define vx_inl(chip,reg) vx2_inl((struct vx_core*)(chip), VX_##reg) +#define vx_inl(chip,reg) vx2_inl((vx_core_t*)(chip), VX_##reg) #undef vx_outl -#define vx_outl(chip,reg,val) vx2_outl((struct vx_core*)(chip), VX_##reg, val) +#define vx_outl(chip,reg,val) vx2_outl((vx_core_t*)(chip), VX_##reg, val) /* @@ -147,14 +147,14 @@ static void vx2_outl(struct vx_core *chip, int offset, unsigned int val) #define XX_DSP_RESET_WAIT_TIME 2 /* ms */ -static void vx2_reset_dsp(struct vx_core *_chip) +static void vx2_reset_dsp(vx_core_t *_chip) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; /* set the reset dsp bit to 0 */ vx_outl(chip, CDSP, chip->regCDSP & ~VX_CDSP_DSP_RESET_MASK); - mdelay(XX_DSP_RESET_WAIT_TIME); + snd_vx_delay(_chip, XX_DSP_RESET_WAIT_TIME); chip->regCDSP |= VX_CDSP_DSP_RESET_MASK; /* set the reset dsp bit to 1 */ @@ -162,7 +162,7 @@ static void vx2_reset_dsp(struct vx_core *_chip) } -static int vx2_test_xilinx(struct vx_core *_chip) +static int vx2_test_xilinx(vx_core_t *_chip) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; unsigned int data; @@ -219,7 +219,7 @@ static int vx2_test_xilinx(struct vx_core *_chip) * vx_setup_pseudo_dma - set up the pseudo dma read/write mode. * @do_write: 0 = read, 1 = set up for DMA write */ -static void vx2_setup_pseudo_dma(struct vx_core *chip, int do_write) +static void vx2_setup_pseudo_dma(vx_core_t *chip, int do_write) { /* Interrupt mode and HREQ pin enabled for host transmit data transfers * (in case of the use of the pseudo-dma facility). @@ -235,7 +235,7 @@ static void vx2_setup_pseudo_dma(struct vx_core *chip, int do_write) /* * vx_release_pseudo_dma - disable the pseudo-DMA mode */ -static inline void vx2_release_pseudo_dma(struct vx_core *chip) +static inline void vx2_release_pseudo_dma(vx_core_t *chip) { /* HREQ pin disabled. */ vx_outl(chip, ICR, 0); @@ -244,8 +244,8 @@ static inline void vx2_release_pseudo_dma(struct vx_core *chip) /* pseudo-dma write */ -static void vx2_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count) +static void vx2_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count) { unsigned long port = vx2_reg_addr(chip, VX_DMA); int offset = pipe->hw_ptr; @@ -282,8 +282,8 @@ static void vx2_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, /* pseudo dma read */ -static void vx2_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count) +static void vx2_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count) { int offset = pipe->hw_ptr; u32 *addr = (u32 *)(runtime->dma_area + offset); @@ -321,7 +321,7 @@ static void vx2_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, /* * transfer counts bits to PLX */ -static int put_xilinx_data(struct vx_core *chip, unsigned int port, unsigned int counts, unsigned char data) +static int put_xilinx_data(vx_core_t *chip, unsigned int port, unsigned int counts, unsigned char data) { unsigned int i; @@ -353,7 +353,7 @@ static int put_xilinx_data(struct vx_core *chip, unsigned int port, unsigned int /* * load the xilinx image */ -static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *xilinx) +static int vx2_load_xilinx_binary(vx_core_t *chip, const struct firmware *xilinx) { unsigned int i; unsigned int port; @@ -362,10 +362,10 @@ static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *x /* XILINX reset (wait at least 1 milisecond between reset on and off). */ vx_outl(chip, CNTRL, VX_CNTRL_REGISTER_VALUE | VX_XILINX_RESET_MASK); vx_inl(chip, CNTRL); - msleep(10); + snd_vx_delay(chip, 10); vx_outl(chip, CNTRL, VX_CNTRL_REGISTER_VALUE); vx_inl(chip, CNTRL); - msleep(10); + snd_vx_delay(chip, 10); if (chip->type == VX_TYPE_BOARD) port = VX_CNTRL; @@ -381,7 +381,7 @@ static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *x } put_xilinx_data(chip, port, 4, 0xff); /* end signature */ - msleep(200); + snd_vx_delay(chip, 200); /* test after loading (is buggy with VX222) */ if (chip->type != VX_TYPE_BOARD) { @@ -400,7 +400,7 @@ static int vx2_load_xilinx_binary(struct vx_core *chip, const struct firmware *x /* * load the boot/dsp images */ -static int vx2_load_dsp(struct vx_core *vx, int index, const struct firmware *dsp) +static int vx2_load_dsp(vx_core_t *vx, int index, const struct firmware *dsp) { int err; @@ -432,7 +432,7 @@ static int vx2_load_dsp(struct vx_core *vx, int index, const struct firmware *ds * * spinlock held! */ -static int vx2_test_and_ack(struct vx_core *chip) +static int vx2_test_and_ack(vx_core_t *chip) { /* not booted yet? */ if (! (chip->chip_status & VX_STAT_XILINX_LOADED)) @@ -463,7 +463,7 @@ static int vx2_test_and_ack(struct vx_core *chip) /* * vx_validate_irq - enable/disable IRQ */ -static void vx2_validate_irq(struct vx_core *_chip, int enable) +static void vx2_validate_irq(vx_core_t *_chip, int enable) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; @@ -484,7 +484,7 @@ static void vx2_validate_irq(struct vx_core *_chip, int enable) /* * write an AKM codec data (24bit) */ -static void vx2_write_codec_reg(struct vx_core *chip, unsigned int data) +static void vx2_write_codec_reg(vx_core_t *chip, unsigned int data) { unsigned int i; @@ -660,7 +660,7 @@ static const u8 vx2_akm_gains_lut[VX2_AKM_LEVEL_MAX+1] = { /* * pseudo-codec write entry */ -static void vx2_write_akm(struct vx_core *chip, int reg, unsigned int data) +static void vx2_write_akm(vx_core_t *chip, int reg, unsigned int data) { unsigned int val; @@ -695,7 +695,7 @@ static void vx2_write_akm(struct vx_core *chip, int reg, unsigned int data) /* * write codec bit for old VX222 board */ -static void vx2_old_write_codec_bit(struct vx_core *chip, int codec, unsigned int data) +static void vx2_old_write_codec_bit(vx_core_t *chip, int codec, unsigned int data) { int i; @@ -713,24 +713,24 @@ static void vx2_old_write_codec_bit(struct vx_core *chip, int codec, unsigned in /* * reset codec bit */ -static void vx2_reset_codec(struct vx_core *_chip) +static void vx2_reset_codec(vx_core_t *_chip) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; /* Set the reset CODEC bit to 0. */ vx_outl(chip, CDSP, chip->regCDSP &~ VX_CDSP_CODEC_RESET_MASK); vx_inl(chip, CDSP); - msleep(10); + snd_vx_delay(_chip, 10); /* Set the reset CODEC bit to 1. */ chip->regCDSP |= VX_CDSP_CODEC_RESET_MASK; vx_outl(chip, CDSP, chip->regCDSP); vx_inl(chip, CDSP); if (_chip->type == VX_TYPE_BOARD) { - msleep(1); + snd_vx_delay(_chip, 1); return; } - msleep(5); /* additionnel wait time for AKM's */ + snd_vx_delay(_chip, 5); /* additionnel wait time for AKM's */ vx2_write_codec_reg(_chip, AKM_CODEC_POWER_CONTROL_CMD); /* DAC power up, ADC power up, Vref power down */ @@ -755,7 +755,7 @@ static void vx2_reset_codec(struct vx_core *_chip) /* * change the audio source */ -static void vx2_change_audio_source(struct vx_core *_chip, int src) +static void vx2_change_audio_source(vx_core_t *_chip, int src) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; @@ -774,7 +774,7 @@ static void vx2_change_audio_source(struct vx_core *_chip, int src) /* * set the clock source */ -static void vx2_set_clock_source(struct vx_core *_chip, int source) +static void vx2_set_clock_source(vx_core_t *_chip, int source) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; @@ -788,7 +788,7 @@ static void vx2_set_clock_source(struct vx_core *_chip, int source) /* * reset the board */ -static void vx2_reset_board(struct vx_core *_chip, int cold_reset) +static void vx2_reset_board(vx_core_t *_chip, int cold_reset) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; @@ -848,7 +848,7 @@ static void vx2_set_input_level(struct snd_vx222 *chip) */ /* input levels */ -static int vx_input_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_input_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -857,9 +857,9 @@ static int vx_input_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ele return 0; } -static int vx_input_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_input_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vx222 *chip = (struct snd_vx222 *)_chip; down(&_chip->mixer_mutex); ucontrol->value.integer.value[0] = chip->input_level[0]; @@ -868,9 +868,9 @@ static int vx_input_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem return 0; } -static int vx_input_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_input_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vx222 *chip = (struct snd_vx222 *)_chip; down(&_chip->mixer_mutex); if (chip->input_level[0] != ucontrol->value.integer.value[0] || @@ -886,7 +886,7 @@ static int vx_input_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem } /* mic level */ -static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_mic_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -895,17 +895,17 @@ static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_mic_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_mic_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vx222 *chip = (struct snd_vx222 *)_chip; ucontrol->value.integer.value[0] = chip->mic_level; return 0; } -static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_mic_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vx222 *chip = (struct snd_vx222 *)_chip; down(&_chip->mixer_mutex); if (chip->mic_level != ucontrol->value.integer.value[0]) { @@ -918,7 +918,7 @@ static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return 0; } -static struct snd_kcontrol_new vx_control_input_level = { +static snd_kcontrol_new_t vx_control_input_level = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Volume", .info = vx_input_level_info, @@ -926,7 +926,7 @@ static struct snd_kcontrol_new vx_control_input_level = { .put = vx_input_level_put, }; -static struct snd_kcontrol_new vx_control_mic_level = { +static snd_kcontrol_new_t vx_control_mic_level = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mic Capture Volume", .info = vx_mic_level_info, @@ -938,7 +938,7 @@ static struct snd_kcontrol_new vx_control_mic_level = { * FIXME: compressor/limiter implementation is missing yet... */ -static int vx2_add_mic_controls(struct vx_core *_chip) +static int vx2_add_mic_controls(vx_core_t *_chip) { struct snd_vx222 *chip = (struct snd_vx222 *)_chip; int err; diff --git a/trunk/sound/pci/ymfpci/ymfpci.c b/trunk/sound/pci/ymfpci/ymfpci.c index dab9b8310341..d013237205d8 100644 --- a/trunk/sound/pci/ymfpci/ymfpci.c +++ b/trunk/sound/pci/ymfpci/ymfpci.c @@ -31,7 +31,7 @@ #include <sound/initval.h> MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); -MODULE_DESCRIPTION("Yamaha DS-1 PCI"); +MODULE_DESCRIPTION("Yamaha DS-XG PCI"); MODULE_LICENSE("GPL"); MODULE_SUPPORTED_DEVICE("{{Yamaha,YMF724}," "{Yamaha,YMF724F}," @@ -51,11 +51,11 @@ static long joystick_port[SNDRV_CARDS]; static int rear_switch[SNDRV_CARDS]; module_param_array(index, int, NULL, 0444); -MODULE_PARM_DESC(index, "Index value for the Yamaha DS-1 PCI soundcard."); +MODULE_PARM_DESC(index, "Index value for the Yamaha DS-XG PCI soundcard."); module_param_array(id, charp, NULL, 0444); -MODULE_PARM_DESC(id, "ID string for the Yamaha DS-1 PCI soundcard."); +MODULE_PARM_DESC(id, "ID string for the Yamaha DS-XG PCI soundcard."); module_param_array(enable, bool, NULL, 0444); -MODULE_PARM_DESC(enable, "Enable Yamaha DS-1 soundcard."); +MODULE_PARM_DESC(enable, "Enable Yamaha DS-XG soundcard."); module_param_array(mpu_port, long, NULL, 0444); MODULE_PARM_DESC(mpu_port, "MPU-401 Port."); module_param_array(fm_port, long, NULL, 0444); @@ -80,7 +80,7 @@ static struct pci_device_id snd_ymfpci_ids[] = { MODULE_DEVICE_TABLE(pci, snd_ymfpci_ids); #ifdef SUPPORT_JOYSTICK -static int __devinit snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, +static int __devinit snd_ymfpci_create_gameport(ymfpci_t *chip, int dev, int legacy_ctrl, int legacy_ctrl2) { struct gameport *gp; @@ -152,7 +152,7 @@ static int __devinit snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev return 0; } -void snd_ymfpci_free_gameport(struct snd_ymfpci *chip) +void snd_ymfpci_free_gameport(ymfpci_t *chip) { if (chip->gameport) { struct resource *r = gameport_get_port_data(chip->gameport); @@ -164,20 +164,20 @@ void snd_ymfpci_free_gameport(struct snd_ymfpci *chip) } } #else -static inline int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, int l, int l2) { return -ENOSYS; } -void snd_ymfpci_free_gameport(struct snd_ymfpci *chip) { } +static inline int snd_ymfpci_create_gameport(ymfpci_t *chip, int dev, int l, int l2) { return -ENOSYS; } +void snd_ymfpci_free_gameport(ymfpci_t *chip) { } #endif /* SUPPORT_JOYSTICK */ static int __devinit snd_card_ymfpci_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; - struct snd_card *card; + snd_card_t *card; struct resource *fm_res = NULL; struct resource *mpu_res = NULL; - struct snd_ymfpci *chip; - struct snd_opl3 *opl3; - const char *str, *model; + ymfpci_t *chip; + opl3_t *opl3; + char *str; int err; u16 legacy_ctrl, legacy_ctrl2, old_legacy_ctrl; @@ -193,13 +193,13 @@ static int __devinit snd_card_ymfpci_probe(struct pci_dev *pci, return -ENOMEM; switch (pci_id->device) { - case 0x0004: str = "YMF724"; model = "DS-1"; break; - case 0x000d: str = "YMF724F"; model = "DS-1"; break; - case 0x000a: str = "YMF740"; model = "DS-1L"; break; - case 0x000c: str = "YMF740C"; model = "DS-1L"; break; - case 0x0010: str = "YMF744"; model = "DS-1S"; break; - case 0x0012: str = "YMF754"; model = "DS-1E"; break; - default: model = str = "???"; break; + case 0x0004: str = "YMF724"; break; + case 0x000d: str = "YMF724F"; break; + case 0x000a: str = "YMF740"; break; + case 0x000c: str = "YMF740C"; break; + case 0x0010: str = "YMF744"; break; + case 0x0012: str = "YMF754"; break; + default: str = "???"; break; } legacy_ctrl = 0; @@ -271,10 +271,8 @@ static int __devinit snd_card_ymfpci_probe(struct pci_dev *pci, } chip->fm_res = fm_res; chip->mpu_res = mpu_res; - card->private_data = chip; - strcpy(card->driver, str); - sprintf(card->shortname, "Yamaha %s (%s)", model, str); + sprintf(card->shortname, "Yamaha DS-XG (%s)", str); sprintf(card->longname, "%s at 0x%lx, irq %i", card->shortname, chip->reg_area_phys, @@ -345,14 +343,11 @@ static void __devexit snd_card_ymfpci_remove(struct pci_dev *pci) } static struct pci_driver driver = { - .name = "Yamaha DS-1 PCI", + .name = "Yamaha DS-XG PCI", .id_table = snd_ymfpci_ids, .probe = snd_card_ymfpci_probe, .remove = __devexit_p(snd_card_ymfpci_remove), -#ifdef CONFIG_PM - .suspend = snd_ymfpci_suspend, - .resume = snd_ymfpci_resume, -#endif + SND_PCI_PM_CALLBACKS }; static int __init alsa_card_ymfpci_init(void) diff --git a/trunk/sound/pci/ymfpci/ymfpci_main.c b/trunk/sound/pci/ymfpci/ymfpci_main.c index 1dfc7233c6a8..88a43e091d77 100644 --- a/trunk/sound/pci/ymfpci/ymfpci_main.c +++ b/trunk/sound/pci/ymfpci/ymfpci_main.c @@ -50,39 +50,39 @@ * common I/O routines */ -static void snd_ymfpci_irq_wait(struct snd_ymfpci *chip); +static void snd_ymfpci_irq_wait(ymfpci_t *chip); -static inline u8 snd_ymfpci_readb(struct snd_ymfpci *chip, u32 offset) +static inline u8 snd_ymfpci_readb(ymfpci_t *chip, u32 offset) { return readb(chip->reg_area_virt + offset); } -static inline void snd_ymfpci_writeb(struct snd_ymfpci *chip, u32 offset, u8 val) +static inline void snd_ymfpci_writeb(ymfpci_t *chip, u32 offset, u8 val) { writeb(val, chip->reg_area_virt + offset); } -static inline u16 snd_ymfpci_readw(struct snd_ymfpci *chip, u32 offset) +static inline u16 snd_ymfpci_readw(ymfpci_t *chip, u32 offset) { return readw(chip->reg_area_virt + offset); } -static inline void snd_ymfpci_writew(struct snd_ymfpci *chip, u32 offset, u16 val) +static inline void snd_ymfpci_writew(ymfpci_t *chip, u32 offset, u16 val) { writew(val, chip->reg_area_virt + offset); } -static inline u32 snd_ymfpci_readl(struct snd_ymfpci *chip, u32 offset) +static inline u32 snd_ymfpci_readl(ymfpci_t *chip, u32 offset) { return readl(chip->reg_area_virt + offset); } -static inline void snd_ymfpci_writel(struct snd_ymfpci *chip, u32 offset, u32 val) +static inline void snd_ymfpci_writel(ymfpci_t *chip, u32 offset, u32 val) { writel(val, chip->reg_area_virt + offset); } -static int snd_ymfpci_codec_ready(struct snd_ymfpci *chip, int secondary) +static int snd_ymfpci_codec_ready(ymfpci_t *chip, int secondary) { unsigned long end_time; u32 reg = secondary ? YDSXGR_SECSTATUSADR : YDSXGR_PRISTATUSADR; @@ -98,9 +98,9 @@ static int snd_ymfpci_codec_ready(struct snd_ymfpci *chip, int secondary) return -EBUSY; } -static void snd_ymfpci_codec_write(struct snd_ac97 *ac97, u16 reg, u16 val) +static void snd_ymfpci_codec_write(ac97_t *ac97, u16 reg, u16 val) { - struct snd_ymfpci *chip = ac97->private_data; + ymfpci_t *chip = ac97->private_data; u32 cmd; snd_ymfpci_codec_ready(chip, 0); @@ -108,9 +108,9 @@ static void snd_ymfpci_codec_write(struct snd_ac97 *ac97, u16 reg, u16 val) snd_ymfpci_writel(chip, YDSXGR_AC97CMDDATA, cmd); } -static u16 snd_ymfpci_codec_read(struct snd_ac97 *ac97, u16 reg) +static u16 snd_ymfpci_codec_read(ac97_t *ac97, u16 reg) { - struct snd_ymfpci *chip = ac97->private_data; + ymfpci_t *chip = ac97->private_data; if (snd_ymfpci_codec_ready(chip, 0)) return ~0; @@ -182,7 +182,7 @@ static u32 snd_ymfpci_calc_lpfQ(u32 rate) * Hardware start management */ -static void snd_ymfpci_hw_start(struct snd_ymfpci *chip) +static void snd_ymfpci_hw_start(ymfpci_t *chip) { unsigned long flags; @@ -196,7 +196,7 @@ static void snd_ymfpci_hw_start(struct snd_ymfpci *chip) spin_unlock_irqrestore(&chip->reg_lock, flags); } -static void snd_ymfpci_hw_stop(struct snd_ymfpci *chip) +static void snd_ymfpci_hw_stop(ymfpci_t *chip) { unsigned long flags; long timeout = 1000; @@ -222,11 +222,9 @@ static void snd_ymfpci_hw_stop(struct snd_ymfpci *chip) * Playback voice management */ -static int voice_alloc(struct snd_ymfpci *chip, - enum snd_ymfpci_voice_type type, int pair, - struct snd_ymfpci_voice **rvoice) +static int voice_alloc(ymfpci_t *chip, ymfpci_voice_type_t type, int pair, ymfpci_voice_t **rvoice) { - struct snd_ymfpci_voice *voice, *voice2; + ymfpci_voice_t *voice, *voice2; int idx; *rvoice = NULL; @@ -260,9 +258,7 @@ static int voice_alloc(struct snd_ymfpci *chip, return -ENOMEM; } -static int snd_ymfpci_voice_alloc(struct snd_ymfpci *chip, - enum snd_ymfpci_voice_type type, int pair, - struct snd_ymfpci_voice **rvoice) +static int snd_ymfpci_voice_alloc(ymfpci_t *chip, ymfpci_voice_type_t type, int pair, ymfpci_voice_t **rvoice) { unsigned long flags; int result; @@ -282,7 +278,7 @@ static int snd_ymfpci_voice_alloc(struct snd_ymfpci *chip, return result; } -static int snd_ymfpci_voice_free(struct snd_ymfpci *chip, struct snd_ymfpci_voice *pvoice) +static int snd_ymfpci_voice_free(ymfpci_t *chip, ymfpci_voice_t *pvoice) { unsigned long flags; @@ -300,9 +296,9 @@ static int snd_ymfpci_voice_free(struct snd_ymfpci *chip, struct snd_ymfpci_voic * PCM part */ -static void snd_ymfpci_pcm_interrupt(struct snd_ymfpci *chip, struct snd_ymfpci_voice *voice) +static void snd_ymfpci_pcm_interrupt(ymfpci_t *chip, ymfpci_voice_t *voice) { - struct snd_ymfpci_pcm *ypcm; + ymfpci_pcm_t *ypcm; u32 pos, delta; if ((ypcm = voice->ypcm) == NULL) @@ -329,7 +325,7 @@ static void snd_ymfpci_pcm_interrupt(struct snd_ymfpci *chip, struct snd_ymfpci_ if (unlikely(ypcm->update_pcm_vol)) { unsigned int subs = ypcm->substream->number; unsigned int next_bank = 1 - chip->active_bank; - struct snd_ymfpci_playback_bank *bank; + snd_ymfpci_playback_bank_t *bank; u32 volume; bank = &voice->bank[next_bank]; @@ -349,11 +345,11 @@ static void snd_ymfpci_pcm_interrupt(struct snd_ymfpci *chip, struct snd_ymfpci_ spin_unlock(&chip->reg_lock); } -static void snd_ymfpci_pcm_capture_interrupt(struct snd_pcm_substream *substream) +static void snd_ymfpci_pcm_capture_interrupt(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm = runtime->private_data; - struct snd_ymfpci *chip = ypcm->chip; + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm = runtime->private_data; + ymfpci_t *chip = ypcm->chip; u32 pos, delta; spin_lock(&chip->reg_lock); @@ -376,11 +372,11 @@ static void snd_ymfpci_pcm_capture_interrupt(struct snd_pcm_substream *substream spin_unlock(&chip->reg_lock); } -static int snd_ymfpci_playback_trigger(struct snd_pcm_substream *substream, +static int snd_ymfpci_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_ymfpci_pcm *ypcm = substream->runtime->private_data; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + ymfpci_pcm_t *ypcm = substream->runtime->private_data; int result = 0; spin_lock(&chip->reg_lock); @@ -413,11 +409,11 @@ static int snd_ymfpci_playback_trigger(struct snd_pcm_substream *substream, spin_unlock(&chip->reg_lock); return result; } -static int snd_ymfpci_capture_trigger(struct snd_pcm_substream *substream, +static int snd_ymfpci_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_ymfpci_pcm *ypcm = substream->runtime->private_data; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + ymfpci_pcm_t *ypcm = substream->runtime->private_data; int result = 0; u32 tmp; @@ -445,7 +441,7 @@ static int snd_ymfpci_capture_trigger(struct snd_pcm_substream *substream, return result; } -static int snd_ymfpci_pcm_voice_alloc(struct snd_ymfpci_pcm *ypcm, int voices) +static int snd_ymfpci_pcm_voice_alloc(ymfpci_pcm_t *ypcm, int voices) { int err; @@ -475,16 +471,16 @@ static int snd_ymfpci_pcm_voice_alloc(struct snd_ymfpci_pcm *ypcm, int voices) return 0; } -static void snd_ymfpci_pcm_init_voice(struct snd_ymfpci_pcm *ypcm, unsigned int voiceidx, - struct snd_pcm_runtime *runtime, +static void snd_ymfpci_pcm_init_voice(ymfpci_pcm_t *ypcm, unsigned int voiceidx, + snd_pcm_runtime_t *runtime, int has_pcm_volume) { - struct snd_ymfpci_voice *voice = ypcm->voices[voiceidx]; + ymfpci_voice_t *voice = ypcm->voices[voiceidx]; u32 format; u32 delta = snd_ymfpci_calc_delta(runtime->rate); u32 lpfQ = snd_ymfpci_calc_lpfQ(runtime->rate); u32 lpfK = snd_ymfpci_calc_lpfK(runtime->rate); - struct snd_ymfpci_playback_bank *bank; + snd_ymfpci_playback_bank_t *bank; unsigned int nbank; u32 vol_left, vol_right; u8 use_left, use_right; @@ -548,7 +544,7 @@ static void snd_ymfpci_pcm_init_voice(struct snd_ymfpci_pcm *ypcm, unsigned int } } -static int __devinit snd_ymfpci_ac3_init(struct snd_ymfpci *chip) +static int __devinit snd_ymfpci_ac3_init(ymfpci_t *chip) { if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci), 4096, &chip->ac3_tmp_base) < 0) @@ -570,7 +566,7 @@ static int __devinit snd_ymfpci_ac3_init(struct snd_ymfpci *chip) return 0; } -static int snd_ymfpci_ac3_done(struct snd_ymfpci *chip) +static int snd_ymfpci_ac3_done(ymfpci_t *chip) { spin_lock_irq(&chip->reg_lock); snd_ymfpci_writel(chip, YDSXGR_MAPOFEFFECT, @@ -584,11 +580,11 @@ static int snd_ymfpci_ac3_done(struct snd_ymfpci *chip) return 0; } -static int snd_ymfpci_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ymfpci_playback_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm = runtime->private_data; int err; if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) @@ -598,11 +594,11 @@ static int snd_ymfpci_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_ymfpci_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_hw_free(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm; if (runtime->private_data == NULL) return 0; @@ -622,11 +618,11 @@ static int snd_ymfpci_playback_hw_free(struct snd_pcm_substream *substream) return 0; } -static int snd_ymfpci_playback_prepare(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm = runtime->private_data; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm = runtime->private_data; unsigned int nvoice; ypcm->period_size = runtime->period_size; @@ -639,27 +635,27 @@ static int snd_ymfpci_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_ymfpci_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_ymfpci_capture_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_ymfpci_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_ymfpci_capture_hw_free(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); + ymfpci_t *chip = snd_pcm_substream_chip(substream); /* wait, until the PCI operations are not finished */ snd_ymfpci_irq_wait(chip); return snd_pcm_lib_free_pages(substream); } -static int snd_ymfpci_capture_prepare(struct snd_pcm_substream *substream) +static int snd_ymfpci_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm = runtime->private_data; - struct snd_ymfpci_capture_bank * bank; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm = runtime->private_data; + snd_ymfpci_capture_bank_t * bank; int nbank; u32 rate, format; @@ -698,30 +694,30 @@ static int snd_ymfpci_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_ymfpci_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ymfpci_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm = runtime->private_data; - struct snd_ymfpci_voice *voice = ypcm->voices[0]; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm = runtime->private_data; + ymfpci_voice_t *voice = ypcm->voices[0]; if (!(ypcm->running && voice)) return 0; return le32_to_cpu(voice->bank[chip->active_bank].start); } -static snd_pcm_uframes_t snd_ymfpci_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_ymfpci_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm = runtime->private_data; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm = runtime->private_data; if (!ypcm->running) return 0; return le32_to_cpu(chip->bank_capture[ypcm->capture_bank_number][chip->active_bank]->start) >> ypcm->shift; } -static void snd_ymfpci_irq_wait(struct snd_ymfpci *chip) +static void snd_ymfpci_irq_wait(ymfpci_t *chip) { wait_queue_t wait; int loops = 4; @@ -739,9 +735,9 @@ static void snd_ymfpci_irq_wait(struct snd_ymfpci *chip) static irqreturn_t snd_ymfpci_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_ymfpci *chip = dev_id; + ymfpci_t *chip = dev_id; u32 status, nvoice, mode; - struct snd_ymfpci_voice *voice; + ymfpci_voice_t *voice; status = snd_ymfpci_readl(chip, YDSXGR_STATUS); if (status & 0x80000000) { @@ -787,7 +783,7 @@ static irqreturn_t snd_ymfpci_interrupt(int irq, void *dev_id, struct pt_regs *r return IRQ_HANDLED; } -static struct snd_pcm_hardware snd_ymfpci_playback = +static snd_pcm_hardware_t snd_ymfpci_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -809,7 +805,7 @@ static struct snd_pcm_hardware snd_ymfpci_playback = .fifo_size = 0, }; -static struct snd_pcm_hardware snd_ymfpci_capture = +static snd_pcm_hardware_t snd_ymfpci_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -831,16 +827,16 @@ static struct snd_pcm_hardware snd_ymfpci_capture = .fifo_size = 0, }; -static void snd_ymfpci_pcm_free_substream(struct snd_pcm_runtime *runtime) +static void snd_ymfpci_pcm_free_substream(snd_pcm_runtime_t *runtime) { kfree(runtime->private_data); } -static int snd_ymfpci_playback_open_1(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_open_1(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm; ypcm = kzalloc(sizeof(*ypcm), GFP_KERNEL); if (ypcm == NULL) @@ -857,7 +853,7 @@ static int snd_ymfpci_playback_open_1(struct snd_pcm_substream *substream) } /* call with spinlock held */ -static void ymfpci_open_extension(struct snd_ymfpci *chip) +static void ymfpci_open_extension(ymfpci_t *chip) { if (! chip->rear_opened) { if (! chip->spdif_opened) /* set AC3 */ @@ -870,7 +866,7 @@ static void ymfpci_open_extension(struct snd_ymfpci *chip) } /* call with spinlock held */ -static void ymfpci_close_extension(struct snd_ymfpci *chip) +static void ymfpci_close_extension(ymfpci_t *chip) { if (! chip->rear_opened) { if (! chip->spdif_opened) @@ -881,12 +877,12 @@ static void ymfpci_close_extension(struct snd_ymfpci *chip) } } -static int snd_ymfpci_playback_open(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_open(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm; - struct snd_kcontrol *kctl; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm; + snd_kcontrol_t *kctl; int err; if ((err = snd_ymfpci_playback_open_1(substream)) < 0) @@ -907,11 +903,11 @@ static int snd_ymfpci_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ymfpci_playback_spdif_open(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_spdif_open(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm; int err; if ((err = snd_ymfpci_playback_open_1(substream)) < 0) @@ -934,11 +930,11 @@ static int snd_ymfpci_playback_spdif_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ymfpci_playback_4ch_open(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_4ch_open(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm; int err; if ((err = snd_ymfpci_playback_open_1(substream)) < 0) @@ -953,12 +949,12 @@ static int snd_ymfpci_playback_4ch_open(struct snd_pcm_substream *substream) return 0; } -static int snd_ymfpci_capture_open(struct snd_pcm_substream *substream, +static int snd_ymfpci_capture_open(snd_pcm_substream_t * substream, u32 capture_bank_number) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm; ypcm = kzalloc(sizeof(*ypcm), GFP_KERNEL); if (ypcm == NULL) @@ -977,26 +973,26 @@ static int snd_ymfpci_capture_open(struct snd_pcm_substream *substream, return 0; } -static int snd_ymfpci_capture_rec_open(struct snd_pcm_substream *substream) +static int snd_ymfpci_capture_rec_open(snd_pcm_substream_t * substream) { return snd_ymfpci_capture_open(substream, 0); } -static int snd_ymfpci_capture_ac97_open(struct snd_pcm_substream *substream) +static int snd_ymfpci_capture_ac97_open(snd_pcm_substream_t * substream) { return snd_ymfpci_capture_open(substream, 1); } -static int snd_ymfpci_playback_close_1(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_close_1(snd_pcm_substream_t * substream) { return 0; } -static int snd_ymfpci_playback_close(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_close(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_ymfpci_pcm *ypcm = substream->runtime->private_data; - struct snd_kcontrol *kctl; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + ymfpci_pcm_t *ypcm = substream->runtime->private_data; + snd_kcontrol_t *kctl; spin_lock_irq(&chip->reg_lock); if (ypcm->output_rear && chip->rear_opened > 0) { @@ -1010,9 +1006,9 @@ static int snd_ymfpci_playback_close(struct snd_pcm_substream *substream) return snd_ymfpci_playback_close_1(substream); } -static int snd_ymfpci_playback_spdif_close(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_spdif_close(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); + ymfpci_t *chip = snd_pcm_substream_chip(substream); spin_lock_irq(&chip->reg_lock); chip->spdif_opened = 0; @@ -1027,9 +1023,9 @@ static int snd_ymfpci_playback_spdif_close(struct snd_pcm_substream *substream) return snd_ymfpci_playback_close_1(substream); } -static int snd_ymfpci_playback_4ch_close(struct snd_pcm_substream *substream) +static int snd_ymfpci_playback_4ch_close(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); + ymfpci_t *chip = snd_pcm_substream_chip(substream); spin_lock_irq(&chip->reg_lock); if (chip->rear_opened > 0) { @@ -1040,11 +1036,11 @@ static int snd_ymfpci_playback_4ch_close(struct snd_pcm_substream *substream) return snd_ymfpci_playback_close_1(substream); } -static int snd_ymfpci_capture_close(struct snd_pcm_substream *substream) +static int snd_ymfpci_capture_close(snd_pcm_substream_t * substream) { - struct snd_ymfpci *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_ymfpci_pcm *ypcm = runtime->private_data; + ymfpci_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + ymfpci_pcm_t *ypcm = runtime->private_data; if (ypcm != NULL) { chip->capture_substream[ypcm->capture_bank_number] = NULL; @@ -1053,7 +1049,7 @@ static int snd_ymfpci_capture_close(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_ops snd_ymfpci_playback_ops = { +static snd_pcm_ops_t snd_ymfpci_playback_ops = { .open = snd_ymfpci_playback_open, .close = snd_ymfpci_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1064,7 +1060,7 @@ static struct snd_pcm_ops snd_ymfpci_playback_ops = { .pointer = snd_ymfpci_playback_pointer, }; -static struct snd_pcm_ops snd_ymfpci_capture_rec_ops = { +static snd_pcm_ops_t snd_ymfpci_capture_rec_ops = { .open = snd_ymfpci_capture_rec_open, .close = snd_ymfpci_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1075,9 +1071,16 @@ static struct snd_pcm_ops snd_ymfpci_capture_rec_ops = { .pointer = snd_ymfpci_capture_pointer, }; -int __devinit snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm) +static void snd_ymfpci_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + ymfpci_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __devinit snd_ymfpci_pcm(ymfpci_t *chip, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -1085,6 +1088,7 @@ int __devinit snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm if ((err = snd_pcm_new(chip->card, "YMFPCI", device, 32, 1, &pcm)) < 0) return err; pcm->private_data = chip; + pcm->private_free = snd_ymfpci_pcm_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ymfpci_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ymfpci_capture_rec_ops); @@ -1102,7 +1106,7 @@ int __devinit snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm return 0; } -static struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = { +static snd_pcm_ops_t snd_ymfpci_capture_ac97_ops = { .open = snd_ymfpci_capture_ac97_open, .close = snd_ymfpci_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1113,9 +1117,16 @@ static struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = { .pointer = snd_ymfpci_capture_pointer, }; -int __devinit snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm) +static void snd_ymfpci_pcm2_free(snd_pcm_t *pcm) +{ + ymfpci_t *chip = pcm->private_data; + chip->pcm2 = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __devinit snd_ymfpci_pcm2(ymfpci_t *chip, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -1123,6 +1134,7 @@ int __devinit snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pc if ((err = snd_pcm_new(chip->card, "YMFPCI - PCM2", device, 0, 1, &pcm)) < 0) return err; pcm->private_data = chip; + pcm->private_free = snd_ymfpci_pcm2_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ymfpci_capture_ac97_ops); @@ -1140,7 +1152,7 @@ int __devinit snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pc return 0; } -static struct snd_pcm_ops snd_ymfpci_playback_spdif_ops = { +static snd_pcm_ops_t snd_ymfpci_playback_spdif_ops = { .open = snd_ymfpci_playback_spdif_open, .close = snd_ymfpci_playback_spdif_close, .ioctl = snd_pcm_lib_ioctl, @@ -1151,9 +1163,16 @@ static struct snd_pcm_ops snd_ymfpci_playback_spdif_ops = { .pointer = snd_ymfpci_playback_pointer, }; -int __devinit snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm) +static void snd_ymfpci_pcm_spdif_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + ymfpci_t *chip = pcm->private_data; + chip->pcm_spdif = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __devinit snd_ymfpci_pcm_spdif(ymfpci_t *chip, int device, snd_pcm_t ** rpcm) +{ + snd_pcm_t *pcm; int err; if (rpcm) @@ -1161,6 +1180,7 @@ int __devinit snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device, struct s if ((err = snd_pcm_new(chip->card, "YMFPCI - IEC958", device, 1, 0, &pcm)) < 0) return err; pcm->private_data = chip; + pcm->private_free = snd_ymfpci_pcm_spdif_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ymfpci_playback_spdif_ops); @@ -1177,7 +1197,7 @@ int __devinit snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device, struct s return 0; } -static struct snd_pcm_ops snd_ymfpci_playback_4ch_ops = { +static snd_pcm_ops_t snd_ymfpci_playback_4ch_ops = { .open = snd_ymfpci_playback_4ch_open, .close = snd_ymfpci_playback_4ch_close, .ioctl = snd_pcm_lib_ioctl, @@ -1188,9 +1208,16 @@ static struct snd_pcm_ops snd_ymfpci_playback_4ch_ops = { .pointer = snd_ymfpci_playback_pointer, }; -int __devinit snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm) +static void snd_ymfpci_pcm_4ch_free(snd_pcm_t *pcm) +{ + ymfpci_t *chip = pcm->private_data; + chip->pcm_4ch = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __devinit snd_ymfpci_pcm_4ch(ymfpci_t *chip, int device, snd_pcm_t ** rpcm) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if (rpcm) @@ -1198,6 +1225,7 @@ int __devinit snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device, struct snd if ((err = snd_pcm_new(chip->card, "YMFPCI - Rear", device, 1, 0, &pcm)) < 0) return err; pcm->private_data = chip; + pcm->private_free = snd_ymfpci_pcm_4ch_free; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ymfpci_playback_4ch_ops); @@ -1214,17 +1242,17 @@ int __devinit snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device, struct snd return 0; } -static int snd_ymfpci_spdif_default_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_spdif_default_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ymfpci_spdif_default_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_spdif_default_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); spin_lock_irq(&chip->reg_lock); ucontrol->value.iec958.status[0] = (chip->spdif_bits >> 0) & 0xff; @@ -1233,10 +1261,10 @@ static int snd_ymfpci_spdif_default_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ymfpci_spdif_default_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_spdif_default_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -1251,7 +1279,7 @@ static int snd_ymfpci_spdif_default_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ymfpci_spdif_default __devinitdata = +static snd_kcontrol_new_t snd_ymfpci_spdif_default __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), @@ -1260,17 +1288,17 @@ static struct snd_kcontrol_new snd_ymfpci_spdif_default __devinitdata = .put = snd_ymfpci_spdif_default_put }; -static int snd_ymfpci_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ymfpci_spdif_mask_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_spdif_mask_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); spin_lock_irq(&chip->reg_lock); ucontrol->value.iec958.status[0] = 0x3e; @@ -1279,7 +1307,7 @@ static int snd_ymfpci_spdif_mask_get(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_ymfpci_spdif_mask __devinitdata = +static snd_kcontrol_new_t snd_ymfpci_spdif_mask __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1288,17 +1316,17 @@ static struct snd_kcontrol_new snd_ymfpci_spdif_mask __devinitdata = .get = snd_ymfpci_spdif_mask_get, }; -static int snd_ymfpci_spdif_stream_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } -static int snd_ymfpci_spdif_stream_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_spdif_stream_get(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); spin_lock_irq(&chip->reg_lock); ucontrol->value.iec958.status[0] = (chip->spdif_pcm_bits >> 0) & 0xff; @@ -1307,10 +1335,10 @@ static int snd_ymfpci_spdif_stream_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ymfpci_spdif_stream_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_spdif_stream_put(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); unsigned int val; int change; @@ -1325,7 +1353,7 @@ static int snd_ymfpci_spdif_stream_put(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new snd_ymfpci_spdif_stream __devinitdata = +static snd_kcontrol_new_t snd_ymfpci_spdif_stream __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, @@ -1335,7 +1363,7 @@ static struct snd_kcontrol_new snd_ymfpci_spdif_stream __devinitdata = .put = snd_ymfpci_spdif_stream_put }; -static int snd_ymfpci_drec_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *info) +static int snd_ymfpci_drec_source_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *info) { static char *texts[3] = {"AC'97", "IEC958", "ZV Port"}; @@ -1348,9 +1376,9 @@ static int snd_ymfpci_drec_source_info(struct snd_kcontrol *kcontrol, struct snd return 0; } -static int snd_ymfpci_drec_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *value) +static int snd_ymfpci_drec_source_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); u16 reg; spin_lock_irq(&chip->reg_lock); @@ -1363,9 +1391,9 @@ static int snd_ymfpci_drec_source_get(struct snd_kcontrol *kcontrol, struct snd_ return 0; } -static int snd_ymfpci_drec_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *value) +static int snd_ymfpci_drec_source_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *value) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); u16 reg, old_reg; spin_lock_irq(&chip->reg_lock); @@ -1379,7 +1407,7 @@ static int snd_ymfpci_drec_source_put(struct snd_kcontrol *kcontrol, struct snd_ return reg != old_reg; } -static struct snd_kcontrol_new snd_ymfpci_drec_source __devinitdata = { +static snd_kcontrol_new_t snd_ymfpci_drec_source __devinitdata = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Direct Recording Source", @@ -1398,8 +1426,8 @@ static struct snd_kcontrol_new snd_ymfpci_drec_source __devinitdata = { .get = snd_ymfpci_get_single, .put = snd_ymfpci_put_single, \ .private_value = ((reg) | ((shift) << 16)) } -static int snd_ymfpci_info_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_info_single(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { int reg = kcontrol->private_value & 0xffff; @@ -1415,10 +1443,10 @@ static int snd_ymfpci_info_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ymfpci_get_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_get_single(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xffff; unsigned int shift = (kcontrol->private_value >> 16) & 0xff; unsigned int mask = 1; @@ -1433,10 +1461,10 @@ static int snd_ymfpci_get_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ymfpci_put_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_put_single(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xffff; unsigned int shift = (kcontrol->private_value >> 16) & 0xff; unsigned int mask = 1; @@ -1465,7 +1493,7 @@ static int snd_ymfpci_put_single(struct snd_kcontrol *kcontrol, .get = snd_ymfpci_get_double, .put = snd_ymfpci_put_double, \ .private_value = reg } -static int snd_ymfpci_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { unsigned int reg = kcontrol->private_value; @@ -1478,9 +1506,9 @@ static int snd_ymfpci_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ymfpci_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); unsigned int reg = kcontrol->private_value; unsigned int shift_left = 0, shift_right = 16, mask = 16383; unsigned int val; @@ -1495,9 +1523,9 @@ static int snd_ymfpci_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_ymfpci_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); unsigned int reg = kcontrol->private_value; unsigned int shift_left = 0, shift_right = 16, mask = 16383; int change; @@ -1521,7 +1549,7 @@ static int snd_ymfpci_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_e /* * 4ch duplication */ -static int snd_ymfpci_info_dup4ch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_info_dup4ch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1530,16 +1558,16 @@ static int snd_ymfpci_info_dup4ch(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_ymfpci_get_dup4ch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_get_dup4ch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = chip->mode_dup4ch; return 0; } -static int snd_ymfpci_put_dup4ch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_put_dup4ch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); int change; change = (ucontrol->value.integer.value[0] != chip->mode_dup4ch); if (change) @@ -1548,7 +1576,7 @@ static int snd_ymfpci_put_dup4ch(struct snd_kcontrol *kcontrol, struct snd_ctl_e } -static struct snd_kcontrol_new snd_ymfpci_controls[] __devinitdata = { +static snd_kcontrol_new_t snd_ymfpci_controls[] __devinitdata = { YMFPCI_DOUBLE("Wave Playback Volume", 0, YDSXGR_NATIVEDACOUTVOL), YMFPCI_DOUBLE("Wave Capture Volume", 0, YDSXGR_NATIVEDACLOOPVOL), YMFPCI_DOUBLE("Digital Capture Volume", 0, YDSXGR_NATIVEDACINVOL), @@ -1579,7 +1607,7 @@ YMFPCI_SINGLE(SNDRV_CTL_NAME_IEC958("Loop",NONE,NONE), 0, YDSXGR_SPDIFINCTRL, 4) * GPIO */ -static int snd_ymfpci_get_gpio_out(struct snd_ymfpci *chip, int pin) +static int snd_ymfpci_get_gpio_out(ymfpci_t *chip, int pin) { u16 reg, mode; unsigned long flags; @@ -1599,7 +1627,7 @@ static int snd_ymfpci_get_gpio_out(struct snd_ymfpci *chip, int pin) return (mode >> pin) & 1; } -static int snd_ymfpci_set_gpio_out(struct snd_ymfpci *chip, int pin, int enable) +static int snd_ymfpci_set_gpio_out(ymfpci_t *chip, int pin, int enable) { u16 reg; unsigned long flags; @@ -1616,7 +1644,7 @@ static int snd_ymfpci_set_gpio_out(struct snd_ymfpci *chip, int pin, int enable) return 0; } -static int snd_ymfpci_gpio_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_gpio_sw_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1625,17 +1653,17 @@ static int snd_ymfpci_gpio_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl return 0; } -static int snd_ymfpci_gpio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_gpio_sw_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); int pin = (int)kcontrol->private_value; ucontrol->value.integer.value[0] = snd_ymfpci_get_gpio_out(chip, pin); return 0; } -static int snd_ymfpci_gpio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_gpio_sw_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); int pin = (int)kcontrol->private_value; if (snd_ymfpci_get_gpio_out(chip, pin) != ucontrol->value.integer.value[0]) { @@ -1646,7 +1674,7 @@ static int snd_ymfpci_gpio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static struct snd_kcontrol_new snd_ymfpci_rear_shared __devinitdata = { +static snd_kcontrol_new_t snd_ymfpci_rear_shared __devinitdata = { .name = "Shared Rear/Line-In Switch", .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .info = snd_ymfpci_gpio_sw_info, @@ -1659,8 +1687,8 @@ static struct snd_kcontrol_new snd_ymfpci_rear_shared __devinitdata = { * PCM voice volume */ -static int snd_ymfpci_pcm_vol_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_ymfpci_pcm_vol_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -1669,10 +1697,10 @@ static int snd_ymfpci_pcm_vol_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ymfpci_pcm_vol_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_pcm_vol_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); unsigned int subs = kcontrol->id.subdevice; ucontrol->value.integer.value[0] = chip->pcm_mixer[subs].left; @@ -1680,12 +1708,12 @@ static int snd_ymfpci_pcm_vol_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_ymfpci_pcm_vol_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_ymfpci_pcm_vol_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_ymfpci *chip = snd_kcontrol_chip(kcontrol); + ymfpci_t *chip = snd_kcontrol_chip(kcontrol); unsigned int subs = kcontrol->id.subdevice; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; unsigned long flags; if (ucontrol->value.integer.value[0] != chip->pcm_mixer[subs].left || @@ -1693,10 +1721,10 @@ static int snd_ymfpci_pcm_vol_put(struct snd_kcontrol *kcontrol, chip->pcm_mixer[subs].left = ucontrol->value.integer.value[0]; chip->pcm_mixer[subs].right = ucontrol->value.integer.value[1]; - substream = (struct snd_pcm_substream *)kcontrol->private_value; + substream = (snd_pcm_substream_t *)kcontrol->private_value; spin_lock_irqsave(&chip->voice_lock, flags); if (substream->runtime && substream->runtime->private_data) { - struct snd_ymfpci_pcm *ypcm = substream->runtime->private_data; + ymfpci_pcm_t *ypcm = substream->runtime->private_data; ypcm->update_pcm_vol = 2; } spin_unlock_irqrestore(&chip->voice_lock, flags); @@ -1705,7 +1733,7 @@ static int snd_ymfpci_pcm_vol_put(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new snd_ymfpci_pcm_volume __devinitdata = { +static snd_kcontrol_new_t snd_ymfpci_pcm_volume __devinitdata = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = "PCM Playback Volume", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | @@ -1720,26 +1748,26 @@ static struct snd_kcontrol_new snd_ymfpci_pcm_volume __devinitdata = { * Mixer routines */ -static void snd_ymfpci_mixer_free_ac97_bus(struct snd_ac97_bus *bus) +static void snd_ymfpci_mixer_free_ac97_bus(ac97_bus_t *bus) { - struct snd_ymfpci *chip = bus->private_data; + ymfpci_t *chip = bus->private_data; chip->ac97_bus = NULL; } -static void snd_ymfpci_mixer_free_ac97(struct snd_ac97 *ac97) +static void snd_ymfpci_mixer_free_ac97(ac97_t *ac97) { - struct snd_ymfpci *chip = ac97->private_data; + ymfpci_t *chip = ac97->private_data; chip->ac97 = NULL; } -int __devinit snd_ymfpci_mixer(struct snd_ymfpci *chip, int rear_switch) +int __devinit snd_ymfpci_mixer(ymfpci_t *chip, int rear_switch) { - struct snd_ac97_template ac97; - struct snd_kcontrol *kctl; - struct snd_pcm_substream *substream; + ac97_template_t ac97; + snd_kcontrol_t *kctl; + snd_pcm_substream_t *substream; unsigned int idx; int err; - static struct snd_ac97_bus_ops ops = { + static ac97_bus_ops_t ops = { .write = snd_ymfpci_codec_write, .read = snd_ymfpci_codec_read, }; @@ -1815,9 +1843,9 @@ int __devinit snd_ymfpci_mixer(struct snd_ymfpci *chip, int rear_switch) * timer */ -static int snd_ymfpci_timer_start(struct snd_timer *timer) +static int snd_ymfpci_timer_start(snd_timer_t *timer) { - struct snd_ymfpci *chip; + ymfpci_t *chip; unsigned long flags; unsigned int count; @@ -1830,9 +1858,9 @@ static int snd_ymfpci_timer_start(struct snd_timer *timer) return 0; } -static int snd_ymfpci_timer_stop(struct snd_timer *timer) +static int snd_ymfpci_timer_stop(snd_timer_t *timer) { - struct snd_ymfpci *chip; + ymfpci_t *chip; unsigned long flags; chip = snd_timer_chip(timer); @@ -1842,7 +1870,7 @@ static int snd_ymfpci_timer_stop(struct snd_timer *timer) return 0; } -static int snd_ymfpci_timer_precise_resolution(struct snd_timer *timer, +static int snd_ymfpci_timer_precise_resolution(snd_timer_t *timer, unsigned long *num, unsigned long *den) { *num = 1; @@ -1850,7 +1878,7 @@ static int snd_ymfpci_timer_precise_resolution(struct snd_timer *timer, return 0; } -static struct snd_timer_hardware snd_ymfpci_timer_hw = { +static struct _snd_timer_hardware snd_ymfpci_timer_hw = { .flags = SNDRV_TIMER_HW_AUTO, .resolution = 20833, /* 1/fs = 20.8333...us */ .ticks = 0x8000, @@ -1859,10 +1887,10 @@ static struct snd_timer_hardware snd_ymfpci_timer_hw = { .precise_resolution = snd_ymfpci_timer_precise_resolution, }; -int __devinit snd_ymfpci_timer(struct snd_ymfpci *chip, int device) +int __devinit snd_ymfpci_timer(ymfpci_t *chip, int device) { - struct snd_timer *timer = NULL; - struct snd_timer_id tid; + snd_timer_t *timer = NULL; + snd_timer_id_t tid; int err; tid.dev_class = SNDRV_TIMER_CLASS_CARD; @@ -1884,10 +1912,10 @@ int __devinit snd_ymfpci_timer(struct snd_ymfpci *chip, int device) * proc interface */ -static void snd_ymfpci_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_ymfpci_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t * buffer) { - struct snd_ymfpci *chip = entry->private_data; + ymfpci_t *chip = entry->private_data; int i; snd_iprintf(buffer, "YMFPCI\n\n"); @@ -1895,9 +1923,9 @@ static void snd_ymfpci_proc_read(struct snd_info_entry *entry, snd_iprintf(buffer, "%04x: %04x\n", i, snd_ymfpci_readl(chip, i)); } -static int __devinit snd_ymfpci_proc_init(struct snd_card *card, struct snd_ymfpci *chip) +static int __devinit snd_ymfpci_proc_init(snd_card_t * card, ymfpci_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(card, "ymfpci", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_ymfpci_proc_read); @@ -1926,12 +1954,12 @@ static void snd_ymfpci_aclink_reset(struct pci_dev * pci) #endif } -static void snd_ymfpci_enable_dsp(struct snd_ymfpci *chip) +static void snd_ymfpci_enable_dsp(ymfpci_t *chip) { snd_ymfpci_writel(chip, YDSXGR_CONFIG, 0x00000001); } -static void snd_ymfpci_disable_dsp(struct snd_ymfpci *chip) +static void snd_ymfpci_disable_dsp(ymfpci_t *chip) { u32 val; int timeout = 1000; @@ -1948,7 +1976,7 @@ static void snd_ymfpci_disable_dsp(struct snd_ymfpci *chip) #include "ymfpci_image.h" -static void snd_ymfpci_download_image(struct snd_ymfpci *chip) +static void snd_ymfpci_download_image(ymfpci_t *chip) { int i; u16 ctrl; @@ -1988,7 +2016,7 @@ static void snd_ymfpci_download_image(struct snd_ymfpci *chip) snd_ymfpci_enable_dsp(chip); } -static int __devinit snd_ymfpci_memalloc(struct snd_ymfpci *chip) +static int __devinit snd_ymfpci_memalloc(ymfpci_t *chip) { long size, playback_ctrl_size; int voice, bank, reg; @@ -2023,10 +2051,10 @@ static int __devinit snd_ymfpci_memalloc(struct snd_ymfpci *chip) ptr_addr += (playback_ctrl_size + 0x00ff) & ~0x00ff; for (voice = 0; voice < YDSXG_PLAYBACK_VOICES; voice++) { chip->voices[voice].number = voice; - chip->voices[voice].bank = (struct snd_ymfpci_playback_bank *)ptr; + chip->voices[voice].bank = (snd_ymfpci_playback_bank_t *)ptr; chip->voices[voice].bank_addr = ptr_addr; for (bank = 0; bank < 2; bank++) { - chip->bank_playback[voice][bank] = (struct snd_ymfpci_playback_bank *)ptr; + chip->bank_playback[voice][bank] = (snd_ymfpci_playback_bank_t *)ptr; ptr += chip->bank_size_playback; ptr_addr += chip->bank_size_playback; } @@ -2037,7 +2065,7 @@ static int __devinit snd_ymfpci_memalloc(struct snd_ymfpci *chip) chip->bank_base_capture_addr = ptr_addr; for (voice = 0; voice < YDSXG_CAPTURE_VOICES; voice++) for (bank = 0; bank < 2; bank++) { - chip->bank_capture[voice][bank] = (struct snd_ymfpci_capture_bank *)ptr; + chip->bank_capture[voice][bank] = (snd_ymfpci_capture_bank_t *)ptr; ptr += chip->bank_size_capture; ptr_addr += chip->bank_size_capture; } @@ -2047,7 +2075,7 @@ static int __devinit snd_ymfpci_memalloc(struct snd_ymfpci *chip) chip->bank_base_effect_addr = ptr_addr; for (voice = 0; voice < YDSXG_EFFECT_VOICES; voice++) for (bank = 0; bank < 2; bank++) { - chip->bank_effect[voice][bank] = (struct snd_ymfpci_effect_bank *)ptr; + chip->bank_effect[voice][bank] = (snd_ymfpci_effect_bank_t *)ptr; ptr += chip->bank_size_effect; ptr_addr += chip->bank_size_effect; } @@ -2086,7 +2114,7 @@ static int __devinit snd_ymfpci_memalloc(struct snd_ymfpci *chip) return 0; } -static int snd_ymfpci_free(struct snd_ymfpci *chip) +static int snd_ymfpci_free(ymfpci_t *chip) { u16 ctrl; @@ -2139,9 +2167,9 @@ static int snd_ymfpci_free(struct snd_ymfpci *chip) return 0; } -static int snd_ymfpci_dev_free(struct snd_device *device) +static int snd_ymfpci_dev_free(snd_device_t *device) { - struct snd_ymfpci *chip = device->device_data; + ymfpci_t *chip = device->device_data; return snd_ymfpci_free(chip); } @@ -2175,13 +2203,11 @@ static int saved_regs_index[] = { }; #define YDSXGR_NUM_SAVED_REGS ARRAY_SIZE(saved_regs_index) -int snd_ymfpci_suspend(struct pci_dev *pci, pm_message_t state) +static int snd_ymfpci_suspend(snd_card_t *card, pm_message_t state) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_ymfpci *chip = card->private_data; + ymfpci_t *chip = card->pm_private_data; unsigned int i; - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); snd_pcm_suspend_all(chip->pcm2); snd_pcm_suspend_all(chip->pcm_spdif); @@ -2192,21 +2218,18 @@ int snd_ymfpci_suspend(struct pci_dev *pci, pm_message_t state) chip->saved_ydsxgr_mode = snd_ymfpci_readl(chip, YDSXGR_MODE); snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0); snd_ymfpci_disable_dsp(chip); - pci_disable_device(pci); - pci_save_state(pci); + pci_disable_device(chip->pci); return 0; } -int snd_ymfpci_resume(struct pci_dev *pci) +static int snd_ymfpci_resume(snd_card_t *card) { - struct snd_card *card = pci_get_drvdata(pci); - struct snd_ymfpci *chip = card->private_data; + ymfpci_t *chip = card->pm_private_data; unsigned int i; - pci_restore_state(pci); - pci_enable_device(pci); - pci_set_master(pci); - snd_ymfpci_aclink_reset(pci); + pci_enable_device(chip->pci); + pci_set_master(chip->pci); + snd_ymfpci_aclink_reset(chip->pci); snd_ymfpci_codec_ready(chip, 0); snd_ymfpci_download_image(chip); udelay(100); @@ -2223,19 +2246,18 @@ int snd_ymfpci_resume(struct pci_dev *pci) chip->active_bank = snd_ymfpci_readl(chip, YDSXGR_CTRLSELECT); spin_unlock_irq(&chip->reg_lock); } - snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } #endif /* CONFIG_PM */ -int __devinit snd_ymfpci_create(struct snd_card *card, +int __devinit snd_ymfpci_create(snd_card_t * card, struct pci_dev * pci, unsigned short old_legacy_ctrl, - struct snd_ymfpci ** rchip) + ymfpci_t ** rchip) { - struct snd_ymfpci *chip; + ymfpci_t *chip; int err; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_ymfpci_dev_free, }; @@ -2302,6 +2324,7 @@ int __devinit snd_ymfpci_create(struct snd_card *card, snd_ymfpci_free(chip); return -ENOMEM; } + snd_card_set_pm_callback(card, snd_ymfpci_suspend, snd_ymfpci_resume, chip); #endif if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { diff --git a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.c b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.c index 77caf43a3109..d6918b453f28 100644 --- a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.c +++ b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.c @@ -52,13 +52,16 @@ MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard."); /* */ -static struct snd_card *card_list[SNDRV_CARDS]; +static dev_info_t dev_info = "snd-pdaudiocf"; +static snd_card_t *card_list[SNDRV_CARDS]; +static dev_link_t *dev_list; /* * prototypes */ static void pdacf_config(dev_link_t *link); -static void snd_pdacf_detach(struct pcmcia_device *p_dev); +static int pdacf_event(event_t event, int priority, event_callback_args_t *args); +static void snd_pdacf_detach(dev_link_t *link); static void pdacf_release(dev_link_t *link) { @@ -74,12 +77,16 @@ static void pdacf_release(dev_link_t *link) /* * destructor */ -static int snd_pdacf_free(struct snd_pdacf *pdacf) +static int snd_pdacf_free(pdacf_t *pdacf) { dev_link_t *link = &pdacf->link; pdacf_release(link); + /* Break the link with Card Services */ + if (link->handle) + pcmcia_deregister_client(link->handle); + card_list[pdacf->index] = NULL; pdacf->card = NULL; @@ -87,22 +94,23 @@ static int snd_pdacf_free(struct snd_pdacf *pdacf) return 0; } -static int snd_pdacf_dev_free(struct snd_device *device) +static int snd_pdacf_dev_free(snd_device_t *device) { - struct snd_pdacf *chip = device->device_data; + pdacf_t *chip = device->device_data; return snd_pdacf_free(chip); } /* * snd_pdacf_attach - attach callback for cs */ -static int snd_pdacf_attach(struct pcmcia_device *p_dev) +static dev_link_t *snd_pdacf_attach(void) { - int i; - dev_link_t *link; /* Info for cardmgr */ - struct snd_pdacf *pdacf; - struct snd_card *card; - static struct snd_device_ops ops = { + client_reg_t client_reg; /* Register with cardmgr */ + dev_link_t *link; /* Info for cardmgr */ + int i, ret; + pdacf_t *pdacf; + snd_card_t *card; + static snd_device_ops_t ops = { .dev_free = snd_pdacf_dev_free, }; @@ -114,26 +122,26 @@ static int snd_pdacf_attach(struct pcmcia_device *p_dev) } if (i >= SNDRV_CARDS) { snd_printk(KERN_ERR "pdacf: too many cards found\n"); - return -EINVAL; + return NULL; } if (! enable[i]) - return -ENODEV; /* disabled explicitly */ + return NULL; /* disabled explicitly */ /* ok, create a card instance */ card = snd_card_new(index[i], id[i], THIS_MODULE, 0); if (card == NULL) { snd_printk(KERN_ERR "pdacf: cannot create a card instance\n"); - return -ENOMEM; + return NULL; } pdacf = snd_pdacf_create(card); if (! pdacf) - return -EIO; + return NULL; if (snd_device_new(card, SNDRV_DEV_LOWLEVEL, pdacf, &ops) < 0) { kfree(pdacf); snd_card_free(card); - return -ENODEV; + return NULL; } pdacf->index = i; @@ -157,12 +165,22 @@ static int snd_pdacf_attach(struct pcmcia_device *p_dev) link->conf.Present = PRESENT_OPTION; /* Chain drivers */ - link->next = NULL; - - link->handle = p_dev; - pdacf_config(link); + link->next = dev_list; + dev_list = link; + + /* Register with Card Services */ + client_reg.dev_info = &dev_info; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + snd_pdacf_detach(link); + return NULL; + } - return 0; + return link; } @@ -176,10 +194,10 @@ static int snd_pdacf_attach(struct pcmcia_device *p_dev) * * returns 0 if successful, or a negative error code. */ -static int snd_pdacf_assign_resources(struct snd_pdacf *pdacf, int port, int irq) +static int snd_pdacf_assign_resources(pdacf_t *pdacf, int port, int irq) { int err; - struct snd_card *card = pdacf->card; + snd_card_t *card = pdacf->card; snd_printdd(KERN_DEBUG "pdacf assign resources: port = 0x%x, irq = %d\n", port, irq); pdacf->port = port; @@ -199,6 +217,8 @@ static int snd_pdacf_assign_resources(struct snd_pdacf *pdacf, int port, int irq if (err < 0) return err; + snd_card_set_pm_callback(card, snd_pdacf_suspend, snd_pdacf_resume, pdacf); + if ((err = snd_card_register(card)) < 0) return err; @@ -209,13 +229,21 @@ static int snd_pdacf_assign_resources(struct snd_pdacf *pdacf, int port, int irq /* * snd_pdacf_detach - detach callback for cs */ -static void snd_pdacf_detach(struct pcmcia_device *p_dev) +static void snd_pdacf_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); - struct snd_pdacf *chip = link->priv; + pdacf_t *chip = link->priv; snd_printdd(KERN_DEBUG "pdacf_detach called\n"); - + /* Remove the interface data from the linked list */ + { + dev_link_t **linkp; + /* Locate device structure */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) + break; + if (*linkp) + *linkp = link->next; + } if (chip->chip_status & PDAUDIOCF_STAT_IS_CONFIGURED) snd_pdacf_powerdown(chip); chip->chip_status |= PDAUDIOCF_STAT_IS_STALE; /* to be sure */ @@ -233,7 +261,7 @@ do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) static void pdacf_config(dev_link_t *link) { client_handle_t handle = link->handle; - struct snd_pdacf *pdacf = link->priv; + pdacf_t *pdacf = link->priv; tuple_t tuple; cisparse_t *parse = NULL; config_info_t conf; @@ -284,51 +312,62 @@ static void pdacf_config(dev_link_t *link) pcmcia_release_irq(link->handle, &link->irq); } -#ifdef CONFIG_PM - -static int pdacf_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - struct snd_pdacf *chip = link->priv; - - snd_printdd(KERN_DEBUG "SUSPEND\n"); - link->state |= DEV_SUSPEND; - if (chip) { - snd_printdd(KERN_DEBUG "snd_pdacf_suspend calling\n"); - snd_pdacf_suspend(chip, PMSG_SUSPEND); - } - - snd_printdd(KERN_DEBUG "RESET_PHYSICAL\n"); - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int pdacf_resume(struct pcmcia_device *dev) +/* + * event callback + */ +static int pdacf_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); - struct snd_pdacf *chip = link->priv; - - snd_printdd(KERN_DEBUG "RESUME\n"); - link->state &= ~DEV_SUSPEND; - - snd_printdd(KERN_DEBUG "CARD_RESET\n"); - if (DEV_OK(link)) { - snd_printdd(KERN_DEBUG "requestconfig...\n"); - pcmcia_request_configuration(link->handle, &link->conf); + dev_link_t *link = args->client_data; + pdacf_t *chip = link->priv; + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + snd_printdd(KERN_DEBUG "CARD_REMOVAL..\n"); + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) { + chip->chip_status |= PDAUDIOCF_STAT_IS_STALE; + } + break; + case CS_EVENT_CARD_INSERTION: + snd_printdd(KERN_DEBUG "CARD_INSERTION..\n"); + link->state |= DEV_PRESENT; + pdacf_config(link); + break; +#ifdef CONFIG_PM + case CS_EVENT_PM_SUSPEND: + snd_printdd(KERN_DEBUG "SUSPEND\n"); + link->state |= DEV_SUSPEND; if (chip) { - snd_printdd(KERN_DEBUG "calling snd_pdacf_resume\n"); - snd_pdacf_resume(chip); + snd_printdd(KERN_DEBUG "snd_pdacf_suspend calling\n"); + snd_pdacf_suspend(chip->card, PMSG_SUSPEND); + } + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + snd_printdd(KERN_DEBUG "RESET_PHYSICAL\n"); + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + snd_printdd(KERN_DEBUG "RESUME\n"); + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + snd_printdd(KERN_DEBUG "CARD_RESET\n"); + if (DEV_OK(link)) { + snd_printdd(KERN_DEBUG "requestconfig...\n"); + pcmcia_request_configuration(link->handle, &link->conf); + if (chip) { + snd_printdd(KERN_DEBUG "calling snd_pdacf_resume\n"); + snd_pdacf_resume(chip->card); + } } + snd_printdd(KERN_DEBUG "resume done!\n"); + break; +#endif } - snd_printdd(KERN_DEBUG "resume done!\n"); - return 0; } -#endif - /* * Module entry points */ @@ -343,14 +382,10 @@ static struct pcmcia_driver pdacf_cs_driver = { .drv = { .name = "snd-pdaudiocf", }, - .probe = snd_pdacf_attach, - .remove = snd_pdacf_detach, + .attach = snd_pdacf_attach, + .event = pdacf_event, + .detach = snd_pdacf_detach, .id_table = snd_pdacf_ids, -#ifdef CONFIG_PM - .suspend = pdacf_suspend, - .resume = pdacf_resume, -#endif - }; static int __init init_pdacf(void) @@ -361,6 +396,7 @@ static int __init init_pdacf(void) static void __exit exit_pdacf(void) { pcmcia_unregister_driver(&pdacf_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_pdacf); diff --git a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.h b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.h index 2744f189a613..c7a9628256ee 100644 --- a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.h +++ b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf.h @@ -83,8 +83,8 @@ #define PDAUDIOCF_STAT_IS_CONFIGURED (1<<1) #define PDAUDIOCF_STAT_IS_SUSPENDED (1<<2) -struct snd_pdacf { - struct snd_card *card; +typedef struct { + snd_card_t *card; int index; unsigned long port; @@ -96,12 +96,12 @@ struct snd_pdacf { struct tasklet_struct tq; spinlock_t ak4117_lock; - struct ak4117 *ak4117; + ak4117_t *ak4117; unsigned int chip_status; - struct snd_pcm *pcm; - struct snd_pcm_substream *pcm_substream; + snd_pcm_t *pcm; + snd_pcm_substream_t *pcm_substream; unsigned int pcm_running: 1; unsigned int pcm_channels; unsigned int pcm_swab; @@ -118,28 +118,28 @@ struct snd_pdacf { /* pcmcia stuff */ dev_link_t link; dev_node_t node; -}; +} pdacf_t; -static inline void pdacf_reg_write(struct snd_pdacf *chip, unsigned char reg, unsigned short val) +static inline void pdacf_reg_write(pdacf_t *chip, unsigned char reg, unsigned short val) { outw(chip->regmap[reg>>1] = val, chip->port + reg); } -static inline unsigned short pdacf_reg_read(struct snd_pdacf *chip, unsigned char reg) +static inline unsigned short pdacf_reg_read(pdacf_t *chip, unsigned char reg) { return inw(chip->port + reg); } -struct snd_pdacf *snd_pdacf_create(struct snd_card *card); -int snd_pdacf_ak4117_create(struct snd_pdacf *pdacf); -void snd_pdacf_powerdown(struct snd_pdacf *chip); +pdacf_t *snd_pdacf_create(snd_card_t *card); +int snd_pdacf_ak4117_create(pdacf_t *pdacf); +void snd_pdacf_powerdown(pdacf_t *chip); #ifdef CONFIG_PM -int snd_pdacf_suspend(struct snd_pdacf *chip, pm_message_t state); -int snd_pdacf_resume(struct snd_pdacf *chip); +int snd_pdacf_suspend(snd_card_t *card, pm_message_t state); +int snd_pdacf_resume(snd_card_t *card); #endif -int snd_pdacf_pcm_new(struct snd_pdacf *chip); +int snd_pdacf_pcm_new(pdacf_t *chip); irqreturn_t pdacf_interrupt(int irq, void *dev, struct pt_regs *regs); void pdacf_tasklet(unsigned long private_data); -void pdacf_reinit(struct snd_pdacf *chip, int resume); +void pdacf_reinit(pdacf_t *chip, int resume); #endif /* __PDAUDIOCF_H */ diff --git a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_core.c b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_core.c index bd0d70ff3019..0208c54896b3 100644 --- a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_core.c +++ b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_core.c @@ -30,7 +30,7 @@ */ static unsigned char pdacf_ak4117_read(void *private_data, unsigned char reg) { - struct snd_pdacf *chip = private_data; + pdacf_t *chip = private_data; unsigned long timeout; unsigned long flags; unsigned char res; @@ -62,7 +62,7 @@ static unsigned char pdacf_ak4117_read(void *private_data, unsigned char reg) static void pdacf_ak4117_write(void *private_data, unsigned char reg, unsigned char val) { - struct snd_pdacf *chip = private_data; + pdacf_t *chip = private_data; unsigned long timeout; unsigned long flags; @@ -81,7 +81,7 @@ static void pdacf_ak4117_write(void *private_data, unsigned char reg, unsigned c } #if 0 -void pdacf_dump(struct snd_pdacf *chip) +void pdacf_dump(pdacf_t *chip) { printk("PDAUDIOCF DUMP (0x%lx):\n", chip->port); printk("WPD : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_WDP)); @@ -94,7 +94,7 @@ void pdacf_dump(struct snd_pdacf *chip) } #endif -static int pdacf_reset(struct snd_pdacf *chip, int powerdown) +static int pdacf_reset(pdacf_t *chip, int powerdown) { u16 val; @@ -117,7 +117,7 @@ static int pdacf_reset(struct snd_pdacf *chip, int powerdown) return 0; } -void pdacf_reinit(struct snd_pdacf *chip, int resume) +void pdacf_reinit(pdacf_t *chip, int resume) { pdacf_reset(chip, 0); if (resume) @@ -127,10 +127,10 @@ void pdacf_reinit(struct snd_pdacf *chip, int resume) pdacf_reg_write(chip, PDAUDIOCF_REG_IER, chip->regmap[PDAUDIOCF_REG_IER>>1]); } -static void pdacf_proc_read(struct snd_info_entry * entry, - struct snd_info_buffer *buffer) +static void pdacf_proc_read(snd_info_entry_t * entry, + snd_info_buffer_t * buffer) { - struct snd_pdacf *chip = entry->private_data; + pdacf_t *chip = entry->private_data; u16 tmp; snd_iprintf(buffer, "PDAudioCF\n\n"); @@ -139,17 +139,17 @@ static void pdacf_proc_read(struct snd_info_entry * entry, } -static void pdacf_proc_init(struct snd_pdacf *chip) +static void pdacf_proc_init(pdacf_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "pdaudiocf", &entry)) snd_info_set_text_ops(entry, chip, 1024, pdacf_proc_read); } -struct snd_pdacf *snd_pdacf_create(struct snd_card *card) +pdacf_t *snd_pdacf_create(snd_card_t *card) { - struct snd_pdacf *chip; + pdacf_t *chip; chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) @@ -164,9 +164,9 @@ struct snd_pdacf *snd_pdacf_create(struct snd_card *card) return chip; } -static void snd_pdacf_ak4117_change(struct ak4117 *ak4117, unsigned char c0, unsigned char c1) +static void snd_pdacf_ak4117_change(ak4117_t *ak4117, unsigned char c0, unsigned char c1) { - struct snd_pdacf *chip = ak4117->change_callback_private; + pdacf_t *chip = ak4117->change_callback_private; unsigned long flags; u16 val; @@ -182,7 +182,7 @@ static void snd_pdacf_ak4117_change(struct ak4117 *ak4117, unsigned char c0, uns spin_unlock_irqrestore(&chip->reg_lock, flags); } -int snd_pdacf_ak4117_create(struct snd_pdacf *chip) +int snd_pdacf_ak4117_create(pdacf_t *chip) { int err; u16 val; @@ -238,7 +238,7 @@ int snd_pdacf_ak4117_create(struct snd_pdacf *chip) return 0; } -void snd_pdacf_powerdown(struct snd_pdacf *chip) +void snd_pdacf_powerdown(pdacf_t *chip) { u16 val; @@ -255,11 +255,11 @@ void snd_pdacf_powerdown(struct snd_pdacf *chip) #ifdef CONFIG_PM -int snd_pdacf_suspend(struct snd_pdacf *chip, pm_message_t state) +int snd_pdacf_suspend(snd_card_t *card, pm_message_t state) { + pdacf_t *chip = card->pm_private_data; u16 val; - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot); snd_pcm_suspend_all(chip->pcm); /* disable interrupts, but use direct write to preserve old register value in chip->regmap */ val = inw(chip->port + PDAUDIOCF_REG_IER); @@ -270,13 +270,14 @@ int snd_pdacf_suspend(struct snd_pdacf *chip, pm_message_t state) return 0; } -static inline int check_signal(struct snd_pdacf *chip) +static inline int check_signal(pdacf_t *chip) { return (chip->ak4117->rcs0 & AK4117_UNLCK) == 0; } -int snd_pdacf_resume(struct snd_pdacf *chip) +int snd_pdacf_resume(snd_card_t *card) { + pdacf_t *chip = card->pm_private_data; int timeout = 40; pdacf_reinit(chip, 1); @@ -285,7 +286,6 @@ int snd_pdacf_resume(struct snd_pdacf *chip) (snd_ak4117_external_rate(chip->ak4117) <= 0 || !check_signal(chip))) mdelay(1); chip->chip_status &= ~PDAUDIOCF_STAT_IS_SUSPENDED; - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0); return 0; } #endif diff --git a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c index 7c5f21e45cb4..255b63444b5d 100644 --- a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c +++ b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_irq.c @@ -28,7 +28,7 @@ */ irqreturn_t pdacf_interrupt(int irq, void *dev, struct pt_regs *regs) { - struct snd_pdacf *chip = dev; + pdacf_t *chip = dev; unsigned short stat; if ((chip->chip_status & (PDAUDIOCF_STAT_IS_STALE| @@ -204,7 +204,7 @@ static inline void pdacf_transfer_stereo24be(u8 *dst, u32 xor, unsigned int size } } -static void pdacf_transfer(struct snd_pdacf *chip, unsigned int size, unsigned int off) +static void pdacf_transfer(pdacf_t *chip, unsigned int size, unsigned int off) { unsigned long rdp_port = chip->port + PDAUDIOCF_REG_MD; unsigned int xor = chip->pcm_xor; @@ -258,7 +258,7 @@ static void pdacf_transfer(struct snd_pdacf *chip, unsigned int size, unsigned i void pdacf_tasklet(unsigned long private_data) { - struct snd_pdacf *chip = (struct snd_pdacf *) private_data; + pdacf_t *chip = (pdacf_t *) private_data; int size, off, cont, rdp, wdp; if ((chip->chip_status & (PDAUDIOCF_STAT_IS_STALE|PDAUDIOCF_STAT_IS_CONFIGURED)) != PDAUDIOCF_STAT_IS_CONFIGURED) diff --git a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c index 09cb250d5827..20b86d8df7a3 100644 --- a/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c +++ b/trunk/sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c @@ -34,7 +34,7 @@ */ /* get the physical page pointer on the given offset */ -static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, unsigned long offset) +static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs, unsigned long offset) { void *pageptr = subs->runtime->dma_area + offset; return vmalloc_to_page(pageptr); @@ -44,9 +44,9 @@ static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, uns * hw_params callback * NOTE: this may be called not only once per pcm open! */ -static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size) +static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size) { - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (runtime->dma_area) { if (runtime->dma_bytes >= size) return 0; /* already enough large */ @@ -63,9 +63,9 @@ static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t s * hw_free callback * NOTE: this may be called not only once per pcm open! */ -static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs) +static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (runtime->dma_area) { vfree(runtime->dma_area); runtime->dma_area = NULL; @@ -76,7 +76,7 @@ static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs) /* * clear the SRAM contents */ -static int pdacf_pcm_clear_sram(struct snd_pdacf *chip) +static int pdacf_pcm_clear_sram(pdacf_t *chip) { int max_loop = 64 * 1024; @@ -91,10 +91,10 @@ static int pdacf_pcm_clear_sram(struct snd_pdacf *chip) /* * pdacf_pcm_trigger - trigger callback for capture */ -static int pdacf_pcm_trigger(struct snd_pcm_substream *subs, int cmd) +static int pdacf_pcm_trigger(snd_pcm_substream_t *subs, int cmd) { - struct snd_pdacf *chip = snd_pcm_substream_chip(subs); - struct snd_pcm_runtime *runtime = subs->runtime; + pdacf_t *chip = snd_pcm_substream_chip(subs); + snd_pcm_runtime_t *runtime = subs->runtime; int inc, ret = 0, rate; unsigned short mask, val, tmp; @@ -146,8 +146,8 @@ static int pdacf_pcm_trigger(struct snd_pcm_substream *subs, int cmd) /* * pdacf_pcm_hw_params - hw_params callback for playback and capture */ -static int pdacf_pcm_hw_params(struct snd_pcm_substream *subs, - struct snd_pcm_hw_params *hw_params) +static int pdacf_pcm_hw_params(snd_pcm_substream_t *subs, + snd_pcm_hw_params_t *hw_params) { return snd_pcm_alloc_vmalloc_buffer(subs, params_buffer_bytes(hw_params)); } @@ -155,7 +155,7 @@ static int pdacf_pcm_hw_params(struct snd_pcm_substream *subs, /* * pdacf_pcm_hw_free - hw_free callback for playback and capture */ -static int pdacf_pcm_hw_free(struct snd_pcm_substream *subs) +static int pdacf_pcm_hw_free(snd_pcm_substream_t *subs) { return snd_pcm_free_vmalloc_buffer(subs); } @@ -163,10 +163,10 @@ static int pdacf_pcm_hw_free(struct snd_pcm_substream *subs) /* * pdacf_pcm_prepare - prepare callback for playback and capture */ -static int pdacf_pcm_prepare(struct snd_pcm_substream *subs) +static int pdacf_pcm_prepare(snd_pcm_substream_t *subs) { - struct snd_pdacf *chip = snd_pcm_substream_chip(subs); - struct snd_pcm_runtime *runtime = subs->runtime; + pdacf_t *chip = snd_pcm_substream_chip(subs); + snd_pcm_runtime_t *runtime = subs->runtime; u16 val, nval, aval; if (chip->chip_status & PDAUDIOCF_STAT_IS_STALE) @@ -239,7 +239,7 @@ static int pdacf_pcm_prepare(struct snd_pcm_substream *subs) * capture hw information */ -static struct snd_pcm_hardware pdacf_pcm_capture_hw = { +static snd_pcm_hardware_t pdacf_pcm_capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID), @@ -269,10 +269,10 @@ static struct snd_pcm_hardware pdacf_pcm_capture_hw = { /* * pdacf_pcm_capture_open - open callback for capture */ -static int pdacf_pcm_capture_open(struct snd_pcm_substream *subs) +static int pdacf_pcm_capture_open(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; - struct snd_pdacf *chip = snd_pcm_substream_chip(subs); + snd_pcm_runtime_t *runtime = subs->runtime; + pdacf_t *chip = snd_pcm_substream_chip(subs); if (chip->chip_status & PDAUDIOCF_STAT_IS_STALE) return -EBUSY; @@ -287,9 +287,9 @@ static int pdacf_pcm_capture_open(struct snd_pcm_substream *subs) /* * pdacf_pcm_capture_close - close callback for capture */ -static int pdacf_pcm_capture_close(struct snd_pcm_substream *subs) +static int pdacf_pcm_capture_close(snd_pcm_substream_t *subs) { - struct snd_pdacf *chip = snd_pcm_substream_chip(subs); + pdacf_t *chip = snd_pcm_substream_chip(subs); if (!chip) return -EINVAL; @@ -302,16 +302,16 @@ static int pdacf_pcm_capture_close(struct snd_pcm_substream *subs) /* * pdacf_pcm_capture_pointer - pointer callback for capture */ -static snd_pcm_uframes_t pdacf_pcm_capture_pointer(struct snd_pcm_substream *subs) +static snd_pcm_uframes_t pdacf_pcm_capture_pointer(snd_pcm_substream_t *subs) { - struct snd_pdacf *chip = snd_pcm_substream_chip(subs); + pdacf_t *chip = snd_pcm_substream_chip(subs); return chip->pcm_hwptr; } /* * operators for PCM capture */ -static struct snd_pcm_ops pdacf_pcm_capture_ops = { +static snd_pcm_ops_t pdacf_pcm_capture_ops = { .open = pdacf_pcm_capture_open, .close = pdacf_pcm_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -324,12 +324,21 @@ static struct snd_pcm_ops pdacf_pcm_capture_ops = { }; +/* + * free callback for pcm + */ +static void snd_pdacf_pcm_free(snd_pcm_t *pcm) +{ + pdacf_t *chip = pcm->private_data; + chip->pcm = NULL; +} + /* * snd_pdacf_pcm_new - create and initialize a pcm */ -int snd_pdacf_pcm_new(struct snd_pdacf *chip) +int snd_pdacf_pcm_new(pdacf_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; err = snd_pcm_new(chip->card, "PDAudioCF", 0, 0, 1, &pcm); @@ -339,6 +348,7 @@ int snd_pdacf_pcm_new(struct snd_pdacf *chip) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pdacf_pcm_capture_ops); pcm->private_data = chip; + pcm->private_free = snd_pdacf_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, chip->card->shortname); chip->pcm = pcm; diff --git a/trunk/sound/pcmcia/vx/vxp_mixer.c b/trunk/sound/pcmcia/vx/vxp_mixer.c index 9450149b931c..aeaef3d81801 100644 --- a/trunk/sound/pcmcia/vx/vxp_mixer.c +++ b/trunk/sound/pcmcia/vx/vxp_mixer.c @@ -31,7 +31,7 @@ /* * mic level control (for VXPocket) */ -static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_mic_level_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -40,17 +40,17 @@ static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_mic_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_mic_level_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; ucontrol->value.integer.value[0] = chip->mic_level; return 0; } -static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_mic_level_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; down(&_chip->mixer_mutex); if (chip->mic_level != ucontrol->value.integer.value[0]) { @@ -63,7 +63,7 @@ static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return 0; } -static struct snd_kcontrol_new vx_control_mic_level = { +static snd_kcontrol_new_t vx_control_mic_level = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mic Capture Volume", .info = vx_mic_level_info, @@ -74,7 +74,7 @@ static struct snd_kcontrol_new vx_control_mic_level = { /* * mic boost level control (for VXP440) */ -static int vx_mic_boost_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int vx_mic_boost_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -83,17 +83,17 @@ static int vx_mic_boost_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_ return 0; } -static int vx_mic_boost_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_mic_boost_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; ucontrol->value.integer.value[0] = chip->mic_level; return 0; } -static int vx_mic_boost_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int vx_mic_boost_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct vx_core *_chip = snd_kcontrol_chip(kcontrol); + vx_core_t *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; down(&_chip->mixer_mutex); if (chip->mic_level != ucontrol->value.integer.value[0]) { @@ -106,7 +106,7 @@ static int vx_mic_boost_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_v return 0; } -static struct snd_kcontrol_new vx_control_mic_boost = { +static snd_kcontrol_new_t vx_control_mic_boost = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mic Boost", .info = vx_mic_boost_info, @@ -115,7 +115,7 @@ static struct snd_kcontrol_new vx_control_mic_boost = { }; -int vxp_add_mic_controls(struct vx_core *_chip) +int vxp_add_mic_controls(vx_core_t *_chip) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; int err; diff --git a/trunk/sound/pcmcia/vx/vxp_ops.c b/trunk/sound/pcmcia/vx/vxp_ops.c index 7f82f619f9f4..6f15c3d03ab5 100644 --- a/trunk/sound/pcmcia/vx/vxp_ops.c +++ b/trunk/sound/pcmcia/vx/vxp_ops.c @@ -49,7 +49,7 @@ static int vxp_reg_offset[VX_REG_MAX] = { }; -static inline unsigned long vxp_reg_addr(struct vx_core *_chip, int reg) +static inline unsigned long vxp_reg_addr(vx_core_t *_chip, int reg) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; return chip->port + vxp_reg_offset[reg]; @@ -59,7 +59,7 @@ static inline unsigned long vxp_reg_addr(struct vx_core *_chip, int reg) * snd_vx_inb - read a byte from the register * @offset: register offset */ -static unsigned char vxp_inb(struct vx_core *chip, int offset) +static unsigned char vxp_inb(vx_core_t *chip, int offset) { return inb(vxp_reg_addr(chip, offset)); } @@ -69,7 +69,7 @@ static unsigned char vxp_inb(struct vx_core *chip, int offset) * @offset: the register offset * @val: the value to write */ -static void vxp_outb(struct vx_core *chip, int offset, unsigned char val) +static void vxp_outb(vx_core_t *chip, int offset, unsigned char val) { outb(val, vxp_reg_addr(chip, offset)); } @@ -78,9 +78,9 @@ static void vxp_outb(struct vx_core *chip, int offset, unsigned char val) * redefine macros to call directly */ #undef vx_inb -#define vx_inb(chip,reg) vxp_inb((struct vx_core *)(chip), VX_##reg) +#define vx_inb(chip,reg) vxp_inb((vx_core_t*)(chip), VX_##reg) #undef vx_outb -#define vx_outb(chip,reg,val) vxp_outb((struct vx_core *)(chip), VX_##reg,val) +#define vx_outb(chip,reg,val) vxp_outb((vx_core_t*)(chip), VX_##reg,val) /* @@ -88,7 +88,7 @@ static void vxp_outb(struct vx_core *chip, int offset, unsigned char val) * * returns zero if a magic word is detected, or a negative error code. */ -static int vx_check_magic(struct vx_core *chip) +static int vx_check_magic(vx_core_t *chip) { unsigned long end_time = jiffies + HZ / 5; int c; @@ -96,7 +96,7 @@ static int vx_check_magic(struct vx_core *chip) c = vx_inb(chip, CDSP); if (c == CDSP_MAGIC) return 0; - msleep(10); + snd_vx_delay(chip, 10); } while (time_after_eq(end_time, jiffies)); snd_printk(KERN_ERR "cannot find xilinx magic word (%x)\n", c); return -EIO; @@ -109,7 +109,7 @@ static int vx_check_magic(struct vx_core *chip) #define XX_DSP_RESET_WAIT_TIME 2 /* ms */ -static void vxp_reset_dsp(struct vx_core *_chip) +static void vxp_reset_dsp(vx_core_t *_chip) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; @@ -127,26 +127,26 @@ static void vxp_reset_dsp(struct vx_core *_chip) /* * reset codec bit */ -static void vxp_reset_codec(struct vx_core *_chip) +static void vxp_reset_codec(vx_core_t *_chip) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; /* Set the reset CODEC bit to 1. */ vx_outb(chip, CDSP, chip->regCDSP | VXP_CDSP_CODEC_RESET_MASK); vx_inb(chip, CDSP); - msleep(10); + snd_vx_delay(_chip, 10); /* Set the reset CODEC bit to 0. */ chip->regCDSP &= ~VXP_CDSP_CODEC_RESET_MASK; vx_outb(chip, CDSP, chip->regCDSP); vx_inb(chip, CDSP); - msleep(1); + snd_vx_delay(_chip, 1); } /* * vx_load_xilinx_binary - load the xilinx binary image * the binary image is the binary array converted from the bitstream file. */ -static int vxp_load_xilinx_binary(struct vx_core *_chip, const struct firmware *fw) +static int vxp_load_xilinx_binary(vx_core_t *_chip, const struct firmware *fw) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; unsigned int i; @@ -207,7 +207,7 @@ static int vxp_load_xilinx_binary(struct vx_core *_chip, const struct firmware * vx_outb(chip, ICR, ICR_HF0); /* TEMPO 250ms : wait until Xilinx is downloaded */ - msleep(300); + snd_vx_delay(_chip, 300); /* test magical word */ if (vx_check_magic(_chip) < 0) @@ -221,7 +221,7 @@ static int vxp_load_xilinx_binary(struct vx_core *_chip, const struct firmware * chip->regDIALOG |= VXP_DLG_XILINX_REPROG_MASK; vx_outb(chip, DIALOG, chip->regDIALOG); vx_inb(chip, DIALOG); - msleep(10); + snd_vx_delay(_chip, 10); chip->regDIALOG &= ~VXP_DLG_XILINX_REPROG_MASK; vx_outb(chip, DIALOG, chip->regDIALOG); vx_inb(chip, DIALOG); @@ -244,7 +244,7 @@ static int vxp_load_xilinx_binary(struct vx_core *_chip, const struct firmware * /* * vxp_load_dsp - load_dsp callback */ -static int vxp_load_dsp(struct vx_core *vx, int index, const struct firmware *fw) +static int vxp_load_dsp(vx_core_t *vx, int index, const struct firmware *fw) { int err; @@ -279,7 +279,7 @@ static int vxp_load_dsp(struct vx_core *vx, int index, const struct firmware *fw * * spinlock held! */ -static int vxp_test_and_ack(struct vx_core *_chip) +static int vxp_test_and_ack(vx_core_t *_chip) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; @@ -306,7 +306,7 @@ static int vxp_test_and_ack(struct vx_core *_chip) /* * vx_validate_irq - enable/disable IRQ */ -static void vxp_validate_irq(struct vx_core *_chip, int enable) +static void vxp_validate_irq(vx_core_t *_chip, int enable) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; @@ -322,7 +322,7 @@ static void vxp_validate_irq(struct vx_core *_chip, int enable) * vx_setup_pseudo_dma - set up the pseudo dma read/write mode. * @do_write: 0 = read, 1 = set up for DMA write */ -static void vx_setup_pseudo_dma(struct vx_core *_chip, int do_write) +static void vx_setup_pseudo_dma(vx_core_t *_chip, int do_write) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; @@ -342,7 +342,7 @@ static void vx_setup_pseudo_dma(struct vx_core *_chip, int do_write) /* * vx_release_pseudo_dma - disable the pseudo-DMA mode */ -static void vx_release_pseudo_dma(struct vx_core *_chip) +static void vx_release_pseudo_dma(vx_core_t *_chip) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; @@ -362,8 +362,8 @@ static void vx_release_pseudo_dma(struct vx_core *_chip) * data size must be aligned to 6 bytes to ensure the 24bit alignment on DSP. * NB: call with a certain lock! */ -static void vxp_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count) +static void vxp_dma_write(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count) { long port = vxp_reg_addr(chip, VX_DMA); int offset = pipe->hw_ptr; @@ -401,8 +401,8 @@ static void vxp_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, * the read length must be aligned to 6 bytes, as well as write. * NB: call with a certain lock! */ -static void vxp_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, - struct vx_pipe *pipe, int count) +static void vxp_dma_read(vx_core_t *chip, snd_pcm_runtime_t *runtime, + vx_pipe_t *pipe, int count) { struct snd_vxpocket *pchip = (struct snd_vxpocket *)chip; long port = vxp_reg_addr(chip, VX_DMA); @@ -442,7 +442,7 @@ static void vxp_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, /* * write a codec data (24bit) */ -static void vxp_write_codec_reg(struct vx_core *chip, int codec, unsigned int data) +static void vxp_write_codec_reg(vx_core_t *chip, int codec, unsigned int data) { int i; @@ -465,7 +465,7 @@ static void vxp_write_codec_reg(struct vx_core *chip, int codec, unsigned int da * vx_set_mic_boost - set mic boost level (on vxp440 only) * @boost: 0 = 20dB, 1 = +38dB */ -void vx_set_mic_boost(struct vx_core *chip, int boost) +void vx_set_mic_boost(vx_core_t *chip, int boost) { struct snd_vxpocket *pchip = (struct snd_vxpocket *)chip; unsigned long flags; @@ -508,7 +508,7 @@ static int vx_compute_mic_level(int level) * vx_set_mic_level - set mic level (on vxpocket only) * @level: the mic level = 0 - 8 (max) */ -void vx_set_mic_level(struct vx_core *chip, int level) +void vx_set_mic_level(vx_core_t *chip, int level) { struct snd_vxpocket *pchip = (struct snd_vxpocket *)chip; unsigned long flags; @@ -528,7 +528,7 @@ void vx_set_mic_level(struct vx_core *chip, int level) /* * change the input audio source */ -static void vxp_change_audio_source(struct vx_core *_chip, int src) +static void vxp_change_audio_source(vx_core_t *_chip, int src) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; @@ -568,7 +568,7 @@ static void vxp_change_audio_source(struct vx_core *_chip, int src) * change the clock source * source = INTERNAL_QUARTZ or UER_SYNC */ -static void vxp_set_clock_source(struct vx_core *_chip, int source) +static void vxp_set_clock_source(vx_core_t *_chip, int source) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; @@ -583,7 +583,7 @@ static void vxp_set_clock_source(struct vx_core *_chip, int source) /* * reset the board */ -static void vxp_reset_board(struct vx_core *_chip, int cold_reset) +static void vxp_reset_board(vx_core_t *_chip, int cold_reset) { struct snd_vxpocket *chip = (struct snd_vxpocket *)_chip; diff --git a/trunk/sound/pcmcia/vx/vxpocket.c b/trunk/sound/pcmcia/vx/vxpocket.c index 66900d20a42f..1e8f16b4c073 100644 --- a/trunk/sound/pcmcia/vx/vxpocket.c +++ b/trunk/sound/pcmcia/vx/vxpocket.c @@ -55,6 +55,11 @@ MODULE_PARM_DESC(ibl, "Capture IBL size for VXPocket soundcard."); */ static unsigned int card_alloc; +static dev_link_t *dev_list; /* Linked list of devices */ +static dev_info_t dev_info = "snd-vxpocket"; + + +static int vxpocket_event(event_t event, int priority, event_callback_args_t *args); /* @@ -68,14 +73,19 @@ static void vxpocket_release(dev_link_t *link) pcmcia_release_irq(link->handle, &link->irq); link->state &= ~DEV_CONFIG; } + if (link->handle) { + /* Break the link with Card Services */ + pcmcia_deregister_client(link->handle); + link->handle = NULL; + } } /* * destructor, called from snd_card_free_in_thread() */ -static int snd_vxpocket_dev_free(struct snd_device *device) +static int snd_vxpocket_dev_free(snd_device_t *device) { - struct vx_core *chip = device->device_data; + vx_core_t *chip = device->device_data; snd_vx_free_firmware(chip); kfree(chip); @@ -132,17 +142,19 @@ static struct snd_vx_hardware vxp440_hw = { /* * create vxpocket instance */ -static struct snd_vxpocket *snd_vxpocket_new(struct snd_card *card, int ibl) +static struct snd_vxpocket *snd_vxpocket_new(snd_card_t *card, int ibl) { + client_reg_t client_reg; /* Register with cardmgr */ dev_link_t *link; /* Info for cardmgr */ - struct vx_core *chip; + vx_core_t *chip; struct snd_vxpocket *vxp; - static struct snd_device_ops ops = { + int ret; + static snd_device_ops_t ops = { .dev_free = snd_vxpocket_dev_free, }; chip = snd_vx_create(card, &vxpocket_hw, &snd_vxpocket_ops, - sizeof(struct snd_vxpocket) - sizeof(struct vx_core)); + sizeof(struct snd_vxpocket) - sizeof(vx_core_t)); if (! chip) return NULL; @@ -172,6 +184,26 @@ static struct snd_vxpocket *snd_vxpocket_new(struct snd_card *card, int ibl) link->conf.ConfigIndex = 1; link->conf.Present = PRESENT_OPTION; + /* Register with Card Services */ + memset(&client_reg, 0, sizeof(client_reg)); + client_reg.dev_info = &dev_info; + client_reg.EventMask = + CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL +#ifdef CONFIG_PM + | CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET + | CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME +#endif + ; + client_reg.event_handler = &vxpocket_event; + client_reg.Version = 0x0210; + client_reg.event_callback_args.client_data = link; + + ret = pcmcia_register_client(&link->handle, &client_reg); + if (ret != CS_SUCCESS) { + cs_error(link->handle, RegisterClient, ret); + return NULL; + } + return vxp; } @@ -186,10 +218,10 @@ static struct snd_vxpocket *snd_vxpocket_new(struct snd_card *card, int ibl) * * returns 0 if successful, or a negative error code. */ -static int snd_vxpocket_assign_resources(struct vx_core *chip, int port, int irq) +static int snd_vxpocket_assign_resources(vx_core_t *chip, int port, int irq) { int err; - struct snd_card *card = chip->card; + snd_card_t *card = chip->card; struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; snd_printdd(KERN_DEBUG "vxpocket assign resources: port = 0x%x, irq = %d\n", port, irq); @@ -218,7 +250,7 @@ do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) static void vxpocket_config(dev_link_t *link) { client_handle_t handle = link->handle; - struct vx_core *chip = link->priv; + vx_core_t *chip = link->priv; struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; tuple_t tuple; cisparse_t *parse; @@ -285,57 +317,69 @@ static void vxpocket_config(dev_link_t *link) kfree(parse); } -#ifdef CONFIG_PM -static int vxp_suspend(struct pcmcia_device *dev) -{ - dev_link_t *link = dev_to_instance(dev); - struct vx_core *chip = link->priv; - - snd_printdd(KERN_DEBUG "SUSPEND\n"); - link->state |= DEV_SUSPEND; - if (chip) { - snd_printdd(KERN_DEBUG "snd_vx_suspend calling\n"); - snd_vx_suspend(chip, PMSG_SUSPEND); - } - snd_printdd(KERN_DEBUG "RESET_PHYSICAL\n"); - if (link->state & DEV_CONFIG) - pcmcia_release_configuration(link->handle); - - return 0; -} - -static int vxp_resume(struct pcmcia_device *dev) +/* + * event callback + */ +static int vxpocket_event(event_t event, int priority, event_callback_args_t *args) { - dev_link_t *link = dev_to_instance(dev); - struct vx_core *chip = link->priv; - - snd_printdd(KERN_DEBUG "RESUME\n"); - link->state &= ~DEV_SUSPEND; - - snd_printdd(KERN_DEBUG "CARD_RESET\n"); - if (DEV_OK(link)) { - //struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; - snd_printdd(KERN_DEBUG "requestconfig...\n"); - pcmcia_request_configuration(link->handle, &link->conf); - if (chip) { - snd_printdd(KERN_DEBUG "calling snd_vx_resume\n"); - snd_vx_resume(chip); + dev_link_t *link = args->client_data; + vx_core_t *chip = link->priv; + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + snd_printdd(KERN_DEBUG "CARD_REMOVAL..\n"); + link->state &= ~DEV_PRESENT; + if (link->state & DEV_CONFIG) + chip->chip_status |= VX_STAT_IS_STALE; + break; + case CS_EVENT_CARD_INSERTION: + snd_printdd(KERN_DEBUG "CARD_INSERTION..\n"); + link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; + vxpocket_config(link); + break; +#ifdef CONFIG_PM + case CS_EVENT_PM_SUSPEND: + snd_printdd(KERN_DEBUG "SUSPEND\n"); + link->state |= DEV_SUSPEND; + if (chip && chip->card->pm_suspend) { + snd_printdd(KERN_DEBUG "snd_vx_suspend calling\n"); + chip->card->pm_suspend(chip->card, PMSG_SUSPEND); + } + /* Fall through... */ + case CS_EVENT_RESET_PHYSICAL: + snd_printdd(KERN_DEBUG "RESET_PHYSICAL\n"); + if (link->state & DEV_CONFIG) + pcmcia_release_configuration(link->handle); + break; + case CS_EVENT_PM_RESUME: + snd_printdd(KERN_DEBUG "RESUME\n"); + link->state &= ~DEV_SUSPEND; + /* Fall through... */ + case CS_EVENT_CARD_RESET: + snd_printdd(KERN_DEBUG "CARD_RESET\n"); + if (DEV_OK(link)) { + //struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; + snd_printdd(KERN_DEBUG "requestconfig...\n"); + pcmcia_request_configuration(link->handle, &link->conf); + if (chip && chip->card->pm_resume) { + snd_printdd(KERN_DEBUG "calling snd_vx_resume\n"); + chip->card->pm_resume(chip->card); + } } + snd_printdd(KERN_DEBUG "resume done!\n"); + break; +#endif } - snd_printdd(KERN_DEBUG "resume done!\n"); - return 0; } -#endif - /* */ -static int vxpocket_attach(struct pcmcia_device *p_dev) +static dev_link_t *vxpocket_attach(void) { - struct snd_card *card; + snd_card_t *card; struct snd_vxpocket *vxp; int i; @@ -346,52 +390,54 @@ static int vxpocket_attach(struct pcmcia_device *p_dev) } if (i >= SNDRV_CARDS) { snd_printk(KERN_ERR "vxpocket: too many cards found\n"); - return -EINVAL; + return NULL; } if (! enable[i]) - return -ENODEV; /* disabled explicitly */ + return NULL; /* disabled explicitly */ /* ok, create a card instance */ card = snd_card_new(index[i], id[i], THIS_MODULE, 0); if (card == NULL) { snd_printk(KERN_ERR "vxpocket: cannot create a card instance\n"); - return -ENOMEM; + return NULL; } vxp = snd_vxpocket_new(card, ibl[i]); if (! vxp) { snd_card_free(card); - return -ENODEV; + return NULL; } - card->private_data = vxp; vxp->index = i; card_alloc |= 1 << i; /* Chain drivers */ - vxp->link.next = NULL; - - vxp->link.handle = p_dev; - vxp->link.state |= DEV_PRESENT | DEV_CONFIG_PENDING; - p_dev->instance = &vxp->link; - vxpocket_config(&vxp->link); + vxp->link.next = dev_list; + dev_list = &vxp->link; - return 0; + return &vxp->link; } -static void vxpocket_detach(struct pcmcia_device *p_dev) +static void vxpocket_detach(dev_link_t *link) { - dev_link_t *link = dev_to_instance(p_dev); struct snd_vxpocket *vxp; - struct vx_core *chip; + vx_core_t *chip; + dev_link_t **linkp; if (! link) return; vxp = link->priv; - chip = (struct vx_core *)vxp; + chip = (vx_core_t *)vxp; card_alloc &= ~(1 << vxp->index); + /* Remove the interface data from the linked list */ + for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) + if (*linkp == link) { + *linkp = link->next; + break; + } + chip->chip_status |= VX_STAT_IS_STALE; /* to be sure */ snd_card_disconnect(chip->card); vxpocket_release(link); @@ -413,13 +459,10 @@ static struct pcmcia_driver vxp_cs_driver = { .drv = { .name = "snd-vxpocket", }, - .probe = vxpocket_attach, - .remove = vxpocket_detach, + .attach = vxpocket_attach, + .detach = vxpocket_detach, + .event = vxpocket_event, .id_table = vxp_ids, -#ifdef CONFIG_PM - .suspend = vxp_suspend, - .resume = vxp_resume, -#endif }; static int __init init_vxpocket(void) @@ -430,6 +473,7 @@ static int __init init_vxpocket(void) static void __exit exit_vxpocket(void) { pcmcia_unregister_driver(&vxp_cs_driver); + BUG_ON(dev_list != NULL); } module_init(init_vxpocket); diff --git a/trunk/sound/pcmcia/vx/vxpocket.h b/trunk/sound/pcmcia/vx/vxpocket.h index 67efae3f6c8d..70754aa3dd11 100644 --- a/trunk/sound/pcmcia/vx/vxpocket.h +++ b/trunk/sound/pcmcia/vx/vxpocket.h @@ -30,7 +30,7 @@ struct snd_vxpocket { - struct vx_core core; + vx_core_t core; unsigned long port; @@ -48,10 +48,10 @@ struct snd_vxpocket { extern struct snd_vx_ops snd_vxpocket_ops; -void vx_set_mic_boost(struct vx_core *chip, int boost); -void vx_set_mic_level(struct vx_core *chip, int level); +void vx_set_mic_boost(vx_core_t *chip, int boost); +void vx_set_mic_level(vx_core_t *chip, int level); -int vxp_add_mic_controls(struct vx_core *chip); +int vxp_add_mic_controls(vx_core_t *chip); /* Constants used to access the CDSP register (0x08). */ #define CDSP_MAGIC 0xA7 /* magic value (for read) */ diff --git a/trunk/sound/ppc/Kconfig b/trunk/sound/ppc/Kconfig index a3fb1496e4dc..206b9333f91f 100644 --- a/trunk/sound/ppc/Kconfig +++ b/trunk/sound/ppc/Kconfig @@ -13,6 +13,7 @@ config SND_POWERMAC tristate "PowerMac (AWACS, DACA, Burgundy, Tumbler, Keywest)" depends on SND && I2C && INPUT && PPC_PMAC select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for the integrated sound device. diff --git a/trunk/sound/ppc/awacs.c b/trunk/sound/ppc/awacs.c index 82d791be7499..758ca1bcbcf2 100644 --- a/trunk/sound/ppc/awacs.c +++ b/trunk/sound/ppc/awacs.c @@ -35,18 +35,18 @@ #endif #ifdef PMAC_AMP_AVAIL -struct awacs_amp { +typedef struct awacs_amp { unsigned char amp_master; unsigned char amp_vol[2][2]; unsigned char amp_tone[2]; -}; +} awacs_amp_t; #define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA) #endif /* PMAC_AMP_AVAIL */ -static void snd_pmac_screamer_wait(struct snd_pmac *chip) +static void snd_pmac_screamer_wait(pmac_t *chip) { long timeout = 2000; while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) { @@ -62,7 +62,7 @@ static void snd_pmac_screamer_wait(struct snd_pmac *chip) * write AWACS register */ static void -snd_pmac_awacs_write(struct snd_pmac *chip, int val) +snd_pmac_awacs_write(pmac_t *chip, int val) { long timeout = 5000000; @@ -78,21 +78,21 @@ snd_pmac_awacs_write(struct snd_pmac *chip, int val) } static void -snd_pmac_awacs_write_reg(struct snd_pmac *chip, int reg, int val) +snd_pmac_awacs_write_reg(pmac_t *chip, int reg, int val) { snd_pmac_awacs_write(chip, val | (reg << 12)); chip->awacs_reg[reg] = val; } static void -snd_pmac_awacs_write_noreg(struct snd_pmac *chip, int reg, int val) +snd_pmac_awacs_write_noreg(pmac_t *chip, int reg, int val) { snd_pmac_awacs_write(chip, val | (reg << 12)); } #ifdef CONFIG_PM /* Recalibrate chip */ -static void screamer_recalibrate(struct snd_pmac *chip) +static void screamer_recalibrate(pmac_t *chip) { if (chip->model != PMAC_SCREAMER) return; @@ -105,8 +105,7 @@ static void screamer_recalibrate(struct snd_pmac *chip) /* delay for broken crystal part */ msleep(750); snd_pmac_awacs_write_noreg(chip, 1, - chip->awacs_reg[1] | MASK_RECALIBRATE | - MASK_CMUTE | MASK_AMUTE); + chip->awacs_reg[1] | MASK_RECALIBRATE | MASK_CMUTE | MASK_AMUTE); snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]); snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]); } @@ -119,7 +118,7 @@ static void screamer_recalibrate(struct snd_pmac *chip) /* * additional callback to set the pcm format */ -static void snd_pmac_awacs_set_format(struct snd_pmac *chip) +static void snd_pmac_awacs_set_format(pmac_t *chip) { chip->awacs_reg[1] &= ~MASK_SAMPLERATE; chip->awacs_reg[1] |= chip->rate_index << 3; @@ -133,8 +132,7 @@ static void snd_pmac_awacs_set_format(struct snd_pmac *chip) /* * volumes: 0-15 stereo */ -static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_awacs_info_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -143,10 +141,9 @@ static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_get_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int lshift = (kcontrol->private_value >> 8) & 0xff; int inverted = (kcontrol->private_value >> 16) & 1; @@ -166,10 +163,9 @@ static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_put_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int lshift = (kcontrol->private_value >> 8) & 0xff; int inverted = (kcontrol->private_value >> 16) & 1; @@ -207,10 +203,9 @@ static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol, /* * mute master/ogain for AWACS: mono */ -static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_get_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int invert = (kcontrol->private_value >> 16) & 1; @@ -226,10 +221,9 @@ static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_put_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_put_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int invert = (kcontrol->private_value >> 16) & 1; @@ -274,7 +268,7 @@ static void awacs_set_cuda(int reg, int val) /* * level = 0 - 14, 7 = 0 dB */ -static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble) +static void awacs_amp_set_tone(awacs_amp_t *amp, int bass, int treble) { amp->amp_tone[0] = bass; amp->amp_tone[1] = treble; @@ -288,8 +282,7 @@ static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble) /* * vol = 0 - 31 (attenuation), 32 = mute bit, stereo */ -static int awacs_amp_set_vol(struct awacs_amp *amp, int index, int lvol, int rvol, - int do_check) +static int awacs_amp_set_vol(awacs_amp_t *amp, int index, int lvol, int rvol, int do_check) { if (do_check && amp->amp_vol[index][0] == lvol && amp->amp_vol[index][1] == rvol) @@ -304,7 +297,7 @@ static int awacs_amp_set_vol(struct awacs_amp *amp, int index, int lvol, int rvo /* * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB */ -static void awacs_amp_set_master(struct awacs_amp *amp, int vol) +static void awacs_amp_set_master(awacs_amp_t *amp, int vol) { amp->amp_master = vol; if (vol <= 79) @@ -314,9 +307,9 @@ static void awacs_amp_set_master(struct awacs_amp *amp, int vol) awacs_set_cuda(1, vol); } -static void awacs_amp_free(struct snd_pmac *chip) +static void awacs_amp_free(pmac_t *chip) { - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return); kfree(amp); chip->mixer_data = NULL; @@ -327,8 +320,7 @@ static void awacs_amp_free(struct snd_pmac *chip) /* * mixer controls */ -static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_awacs_info_volume_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -337,12 +329,11 @@ static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_get_volume_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); snd_assert(index >= 0 && index <= 1, return -EINVAL); ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31); @@ -350,13 +341,12 @@ static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_put_volume_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; int vol[2]; - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); snd_assert(index >= 0 && index <= 1, return -EINVAL); @@ -365,12 +355,11 @@ static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol, return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1); } -static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_get_switch_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); snd_assert(index >= 0 && index <= 1, return -EINVAL); ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32) ? 0 : 1; @@ -378,13 +367,12 @@ static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_put_switch_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; int vol[2]; - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); snd_assert(index >= 0 && index <= 1, return -EINVAL); @@ -393,8 +381,7 @@ static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol, return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1); } -static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_awacs_info_tone_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -403,24 +390,22 @@ static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_get_tone_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); snd_assert(index >= 0 && index <= 1, return -EINVAL); ucontrol->value.integer.value[0] = amp->amp_tone[index]; return 0; } -static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_put_tone_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); snd_assert(index >= 0 && index <= 1, return -EINVAL); if (ucontrol->value.integer.value[0] != amp->amp_tone[index]) { @@ -431,8 +416,7 @@ static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_awacs_info_master_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -441,21 +425,19 @@ static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_get_master_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct awacs_amp *amp = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); ucontrol->value.integer.value[0] = amp->amp_master; return 0; } -static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_awacs_put_master_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct awacs_amp *amp = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + awacs_amp_t *amp = chip->mixer_data; snd_assert(amp, return -EINVAL); if (ucontrol->value.integer.value[0] != amp->amp_master) { amp->amp_master = ucontrol->value.integer.value[0]; @@ -468,7 +450,7 @@ static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol, #define AMP_CH_SPK 0 #define AMP_CH_HD 1 -static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __initdata = { +static snd_kcontrol_new_t snd_pmac_awacs_amp_vol[] __initdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PC Speaker Playback Volume", .info = snd_pmac_awacs_info_volume_amp, @@ -505,7 +487,7 @@ static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __initdata = { }, }; -static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __initdata = { +static snd_kcontrol_new_t snd_pmac_awacs_amp_hp_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Headphone Playback Switch", .info = snd_pmac_boolean_stereo_info, @@ -514,7 +496,7 @@ static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __initdata = { .private_value = AMP_CH_HD, }; -static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __initdata = { +static snd_kcontrol_new_t snd_pmac_awacs_amp_spk_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PC Speaker Playback Switch", .info = snd_pmac_boolean_stereo_info, @@ -529,8 +511,7 @@ static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __initdata = { /* * mic boost for screamer */ -static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_screamer_mic_boost_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -539,10 +520,9 @@ static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_screamer_mic_boost_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int val; unsigned long flags; @@ -558,10 +538,9 @@ static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_screamer_mic_boost_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int changed = 0; int val0, val6; unsigned long flags; @@ -589,7 +568,7 @@ static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol, /* * lists of mixer elements */ -static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = { +static snd_kcontrol_new_t snd_pmac_awacs_mixers[] __initdata = { AWACS_VOLUME("Master Playback Volume", 2, 6, 1), AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0), AWACS_VOLUME("Capture Volume", 0, 4, 0), @@ -599,24 +578,24 @@ static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = { /* FIXME: is this correct order? * screamer (powerbook G3 pismo) seems to have different bits... */ -static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __initdata = { +static snd_kcontrol_new_t snd_pmac_awacs_mixers2[] __initdata = { AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0), AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0), }; -static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = { +static snd_kcontrol_new_t snd_pmac_screamer_mixers2[] __initdata = { AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0), AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0), }; -static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata = +static snd_kcontrol_new_t snd_pmac_awacs_master_sw __initdata = AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1); -static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = { +static snd_kcontrol_new_t snd_pmac_awacs_mic_boost[] __initdata = { AWACS_SWITCH("Mic Boost", 0, SHIFT_GAINLINE, 0), }; -static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = { +static snd_kcontrol_new_t snd_pmac_screamer_mic_boost[] __initdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mic Boost", .info = snd_pmac_screamer_mic_boost_info, @@ -625,17 +604,17 @@ static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = { }, }; -static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = { +static snd_kcontrol_new_t snd_pmac_awacs_speaker_vol[] __initdata = { AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1), }; -static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata = +static snd_kcontrol_new_t snd_pmac_awacs_speaker_sw __initdata = AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1); /* * add new mixer elements to the card */ -static int build_mixers(struct snd_pmac *chip, int nums, struct snd_kcontrol_new *mixers) +static int build_mixers(pmac_t *chip, int nums, snd_kcontrol_new_t *mixers) { int i, err; @@ -650,7 +629,7 @@ static int build_mixers(struct snd_pmac *chip, int nums, struct snd_kcontrol_new /* * restore all registers */ -static void awacs_restore_all_regs(struct snd_pmac *chip) +static void awacs_restore_all_regs(pmac_t *chip) { snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]); snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]); @@ -664,13 +643,13 @@ static void awacs_restore_all_regs(struct snd_pmac *chip) } #ifdef CONFIG_PM -static void snd_pmac_awacs_suspend(struct snd_pmac *chip) +static void snd_pmac_awacs_suspend(pmac_t *chip) { snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1] | MASK_AMUTE | MASK_CMUTE)); } -static void snd_pmac_awacs_resume(struct snd_pmac *chip) +static void snd_pmac_awacs_resume(pmac_t *chip) { if (machine_is_compatible("PowerBook3,1") || machine_is_compatible("PowerBook3,2")) { @@ -689,7 +668,7 @@ static void snd_pmac_awacs_resume(struct snd_pmac *chip) screamer_recalibrate(chip); #ifdef PMAC_AMP_AVAIL if (chip->mixer_data) { - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; awacs_amp_set_vol(amp, 0, amp->amp_vol[0][0], amp->amp_vol[0][1], 0); awacs_amp_set_vol(amp, 1, amp->amp_vol[1][0], amp->amp_vol[1][1], 0); awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]); @@ -703,13 +682,13 @@ static void snd_pmac_awacs_resume(struct snd_pmac *chip) /* * auto-mute stuffs */ -static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip) +static int snd_pmac_awacs_detect_headphone(pmac_t *chip) { return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0; } #ifdef PMAC_AMP_AVAIL -static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute) +static int toggle_amp_mute(awacs_amp_t *amp, int index, int mute) { int vol[2]; vol[0] = amp->amp_vol[index][0] & 31; @@ -722,12 +701,12 @@ static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute) } #endif -static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify) +static void snd_pmac_awacs_update_automute(pmac_t *chip, int do_notify) { if (chip->auto_mute) { #ifdef PMAC_AMP_AVAIL if (chip->mixer_data) { - struct awacs_amp *amp = chip->mixer_data; + awacs_amp_t *amp = chip->mixer_data; int changed; if (snd_pmac_awacs_detect_headphone(chip)) { changed = toggle_amp_mute(amp, AMP_CH_HD, 0); @@ -767,7 +746,7 @@ static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify) * initialize chip */ int __init -snd_pmac_awacs_init(struct snd_pmac *chip) +snd_pmac_awacs_init(pmac_t *chip) { int err, vol; @@ -801,7 +780,7 @@ snd_pmac_awacs_init(struct snd_pmac *chip) chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf; #ifdef PMAC_AMP_AVAIL if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) { - struct awacs_amp *amp = kmalloc(sizeof(*amp), GFP_KERNEL); + awacs_amp_t *amp = kmalloc(sizeof(*amp), GFP_KERNEL); if (! amp) return -ENOMEM; chip->mixer_data = amp; diff --git a/trunk/sound/ppc/beep.c b/trunk/sound/ppc/beep.c index 5fec1e58f310..d4ec6cc3f1c5 100644 --- a/trunk/sound/ppc/beep.c +++ b/trunk/sound/ppc/beep.c @@ -30,7 +30,7 @@ #include <sound/control.h> #include "pmac.h" -struct pmac_beep { +struct snd_pmac_beep { int running; /* boolean */ int volume; /* mixer volume: 0-100 */ int volume_play; /* currently playing volume */ @@ -44,9 +44,9 @@ struct pmac_beep { /* * stop beep if running */ -void snd_pmac_beep_stop(struct snd_pmac *chip) +void snd_pmac_beep_stop(pmac_t *chip) { - struct pmac_beep *beep = chip->beep; + pmac_beep_t *beep = chip->beep; if (beep && beep->running) { beep->running = 0; snd_pmac_beep_dma_stop(chip); @@ -97,11 +97,10 @@ static short beep_wform[256] = { #define BEEP_BUFLEN 512 #define BEEP_VOLUME 15 /* 0 - 100 */ -static int snd_pmac_beep_event(struct input_dev *dev, unsigned int type, - unsigned int code, int hz) +static int snd_pmac_beep_event(struct input_dev *dev, unsigned int type, unsigned int code, int hz) { - struct snd_pmac *chip; - struct pmac_beep *beep; + pmac_t *chip; + pmac_beep_t *beep; unsigned long flags; int beep_speed = 0; int srate; @@ -172,8 +171,7 @@ static int snd_pmac_beep_event(struct input_dev *dev, unsigned int type, * beep volume mixer */ -static int snd_pmac_info_beep(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_info_beep(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; @@ -182,19 +180,17 @@ static int snd_pmac_info_beep(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_get_beep(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_get_beep(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); snd_assert(chip->beep, return -ENXIO); ucontrol->value.integer.value[0] = chip->beep->volume; return 0; } -static int snd_pmac_put_beep(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_put_beep(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int oval; snd_assert(chip->beep, return -ENXIO); oval = chip->beep->volume; @@ -202,7 +198,7 @@ static int snd_pmac_put_beep(struct snd_kcontrol *kcontrol, return oval != chip->beep->volume; } -static struct snd_kcontrol_new snd_pmac_beep_mixer = { +static snd_kcontrol_new_t snd_pmac_beep_mixer = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Beep Playback Volume", .info = snd_pmac_info_beep, @@ -211,9 +207,9 @@ static struct snd_kcontrol_new snd_pmac_beep_mixer = { }; /* Initialize beep stuff */ -int __init snd_pmac_attach_beep(struct snd_pmac *chip) +int __init snd_pmac_attach_beep(pmac_t *chip) { - struct pmac_beep *beep; + pmac_beep_t *beep; struct input_dev *input_dev; void *dmabuf; int err = -ENOMEM; @@ -259,7 +255,7 @@ int __init snd_pmac_attach_beep(struct snd_pmac *chip) return err; } -void snd_pmac_detach_beep(struct snd_pmac *chip) +void snd_pmac_detach_beep(pmac_t *chip) { if (chip->beep) { input_unregister_device(chip->beep->dev); diff --git a/trunk/sound/ppc/burgundy.c b/trunk/sound/ppc/burgundy.c index e02263fe44dc..edbc0484e22a 100644 --- a/trunk/sound/ppc/burgundy.c +++ b/trunk/sound/ppc/burgundy.c @@ -31,7 +31,7 @@ /* Waits for busy flag to clear */ static inline void -snd_pmac_burgundy_busy_wait(struct snd_pmac *chip) +snd_pmac_burgundy_busy_wait(pmac_t *chip) { int timeout = 50; while ((in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) && timeout--) @@ -41,7 +41,7 @@ snd_pmac_burgundy_busy_wait(struct snd_pmac *chip) } static inline void -snd_pmac_burgundy_extend_wait(struct snd_pmac *chip) +snd_pmac_burgundy_extend_wait(pmac_t *chip) { int timeout; timeout = 50; @@ -57,7 +57,7 @@ snd_pmac_burgundy_extend_wait(struct snd_pmac *chip) } static void -snd_pmac_burgundy_wcw(struct snd_pmac *chip, unsigned addr, unsigned val) +snd_pmac_burgundy_wcw(pmac_t *chip, unsigned addr, unsigned val) { out_le32(&chip->awacs->codec_ctrl, addr + 0x200c00 + (val & 0xff)); snd_pmac_burgundy_busy_wait(chip); @@ -70,7 +70,7 @@ snd_pmac_burgundy_wcw(struct snd_pmac *chip, unsigned addr, unsigned val) } static unsigned -snd_pmac_burgundy_rcw(struct snd_pmac *chip, unsigned addr) +snd_pmac_burgundy_rcw(pmac_t *chip, unsigned addr) { unsigned val = 0; unsigned long flags; @@ -103,14 +103,14 @@ snd_pmac_burgundy_rcw(struct snd_pmac *chip, unsigned addr) } static void -snd_pmac_burgundy_wcb(struct snd_pmac *chip, unsigned int addr, unsigned int val) +snd_pmac_burgundy_wcb(pmac_t *chip, unsigned int addr, unsigned int val) { out_le32(&chip->awacs->codec_ctrl, addr + 0x300000 + (val & 0xff)); snd_pmac_burgundy_busy_wait(chip); } static unsigned -snd_pmac_burgundy_rcb(struct snd_pmac *chip, unsigned int addr) +snd_pmac_burgundy_rcb(pmac_t *chip, unsigned int addr) { unsigned val = 0; unsigned long flags; @@ -131,8 +131,7 @@ snd_pmac_burgundy_rcb(struct snd_pmac *chip, unsigned int addr) * Burgundy volume: 0 - 100, stereo */ static void -snd_pmac_burgundy_write_volume(struct snd_pmac *chip, unsigned int address, - long *volume, int shift) +snd_pmac_burgundy_write_volume(pmac_t *chip, unsigned int address, long *volume, int shift) { int hardvolume, lvolume, rvolume; @@ -147,8 +146,7 @@ snd_pmac_burgundy_write_volume(struct snd_pmac *chip, unsigned int address, } static void -snd_pmac_burgundy_read_volume(struct snd_pmac *chip, unsigned int address, - long *volume, int shift) +snd_pmac_burgundy_read_volume(pmac_t *chip, unsigned int address, long *volume, int shift) { int wvolume; @@ -173,8 +171,7 @@ snd_pmac_burgundy_read_volume(struct snd_pmac *chip, unsigned int address, #define BASE2ADDR(base) ((base) << 12) #define ADDR2BASE(addr) ((addr) >> 12) -static int snd_pmac_burgundy_info_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_burgundy_info_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -183,27 +180,23 @@ static int snd_pmac_burgundy_info_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_burgundy_get_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_burgundy_get_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); int shift = (kcontrol->private_value >> 8) & 0xff; - snd_pmac_burgundy_read_volume(chip, addr, ucontrol->value.integer.value, - shift); + snd_pmac_burgundy_read_volume(chip, addr, ucontrol->value.integer.value, shift); return 0; } -static int snd_pmac_burgundy_put_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_burgundy_put_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); int shift = (kcontrol->private_value >> 8) & 0xff; long nvoices[2]; - snd_pmac_burgundy_write_volume(chip, addr, ucontrol->value.integer.value, - shift); + snd_pmac_burgundy_write_volume(chip, addr, ucontrol->value.integer.value, shift); snd_pmac_burgundy_read_volume(chip, addr, nvoices, shift); return (nvoices[0] != ucontrol->value.integer.value[0] || nvoices[1] != ucontrol->value.integer.value[1]); @@ -218,8 +211,7 @@ static int snd_pmac_burgundy_put_volume(struct snd_kcontrol *kcontrol, /* lineout/speaker */ -static int snd_pmac_burgundy_info_switch_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_burgundy_info_switch_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { int stereo = (kcontrol->private_value >> 24) & 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; @@ -229,10 +221,9 @@ static int snd_pmac_burgundy_info_switch_out(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_burgundy_get_switch_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_burgundy_get_switch_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int lmask = kcontrol->private_value & 0xff; int rmask = (kcontrol->private_value >> 8) & 0xff; int stereo = (kcontrol->private_value >> 24) & 1; @@ -243,10 +234,9 @@ static int snd_pmac_burgundy_get_switch_out(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_burgundy_put_switch_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_burgundy_put_switch_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); int lmask = kcontrol->private_value & 0xff; int rmask = (kcontrol->private_value >> 8) & 0xff; int stereo = (kcontrol->private_value >> 24) & 1; @@ -269,8 +259,7 @@ static int snd_pmac_burgundy_put_switch_out(struct snd_kcontrol *kcontrol, .private_value = ((lmask) | ((rmask) << 8) | ((stereo) << 24)) } /* line/speaker output volume */ -static int snd_pmac_burgundy_info_volume_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_pmac_burgundy_info_volume_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { int stereo = (kcontrol->private_value >> 24) & 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; @@ -280,10 +269,9 @@ static int snd_pmac_burgundy_info_volume_out(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_burgundy_get_volume_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_burgundy_get_volume_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); int stereo = (kcontrol->private_value >> 24) & 1; int oval; @@ -295,10 +283,9 @@ static int snd_pmac_burgundy_get_volume_out(struct snd_kcontrol *kcontrol, return 0; } -static int snd_pmac_burgundy_put_volume_out(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_pmac_burgundy_put_volume_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); int stereo = (kcontrol->private_value >> 24) & 1; int oval, val; @@ -321,7 +308,7 @@ static int snd_pmac_burgundy_put_volume_out(struct snd_kcontrol *kcontrol, .put = snd_pmac_burgundy_put_volume_out,\ .private_value = (ADDR2BASE(addr) | ((stereo) << 24)) } -static struct snd_kcontrol_new snd_pmac_burgundy_mixers[] __initdata = { +static snd_kcontrol_new_t snd_pmac_burgundy_mixers[] __initdata = { BURGUNDY_VOLUME("Master Playback Volume", 0, MASK_ADDR_BURGUNDY_MASTER_VOLUME, 8), BURGUNDY_VOLUME("Line Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLLINE, 16), BURGUNDY_VOLUME("CD Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLCD, 16), @@ -330,9 +317,9 @@ static struct snd_kcontrol_new snd_pmac_burgundy_mixers[] __initdata = { /*BURGUNDY_OUTPUT_VOLUME("PCM Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENLINEOUT, 1),*/ BURGUNDY_OUTPUT_VOLUME("Headphone Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1), }; -static struct snd_kcontrol_new snd_pmac_burgundy_master_sw __initdata = +static snd_kcontrol_new_t snd_pmac_burgundy_master_sw __initdata = BURGUNDY_OUTPUT_SWITCH("Headphone Playback Switch", 0, BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1); -static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw __initdata = +static snd_kcontrol_new_t snd_pmac_burgundy_speaker_sw __initdata = BURGUNDY_OUTPUT_SWITCH("PC Speaker Playback Switch", 0, BURGUNDY_OUTPUT_INTERN, 0, 0); @@ -340,12 +327,12 @@ BURGUNDY_OUTPUT_SWITCH("PC Speaker Playback Switch", 0, BURGUNDY_OUTPUT_INTERN, /* * auto-mute stuffs */ -static int snd_pmac_burgundy_detect_headphone(struct snd_pmac *chip) +static int snd_pmac_burgundy_detect_headphone(pmac_t *chip) { return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0; } -static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_notify) +static void snd_pmac_burgundy_update_automute(pmac_t *chip, int do_notify) { if (chip->auto_mute) { int reg, oreg; @@ -374,7 +361,7 @@ static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_noti /* * initialize burgundy */ -int __init snd_pmac_burgundy_init(struct snd_pmac *chip) +int __init snd_pmac_burgundy_init(pmac_t *chip) { int i, err; diff --git a/trunk/sound/ppc/daca.c b/trunk/sound/ppc/daca.c index 08cde51177d7..a737f298e77d 100644 --- a/trunk/sound/ppc/daca.c +++ b/trunk/sound/ppc/daca.c @@ -40,18 +40,18 @@ #define DACA_VOL_MAX 0x38 -struct pmac_daca { - struct pmac_keywest i2c; +typedef struct pmac_daca_t { + pmac_keywest_t i2c; int left_vol, right_vol; unsigned int deemphasis : 1; unsigned int amp_on : 1; -}; +} pmac_daca_t; /* * initialize / detect DACA */ -static int daca_init_client(struct pmac_keywest *i2c) +static int daca_init_client(pmac_keywest_t *i2c) { unsigned short wdata = 0x00; /* SR: no swap, 1bit delay, 32-48kHz */ @@ -66,7 +66,7 @@ static int daca_init_client(struct pmac_keywest *i2c) /* * update volume */ -static int daca_set_volume(struct pmac_daca *mix) +static int daca_set_volume(pmac_daca_t *mix) { unsigned char data[2]; @@ -92,8 +92,7 @@ static int daca_set_volume(struct pmac_daca *mix) /* deemphasis switch */ -static int daca_info_deemphasis(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int daca_info_deemphasis(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -102,22 +101,20 @@ static int daca_info_deemphasis(struct snd_kcontrol *kcontrol, return 0; } -static int daca_get_deemphasis(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int daca_get_deemphasis(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_daca *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_daca_t *mix; if (! (mix = chip->mixer_data)) return -ENODEV; ucontrol->value.integer.value[0] = mix->deemphasis ? 1 : 0; return 0; } -static int daca_put_deemphasis(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int daca_put_deemphasis(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_daca *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_daca_t *mix; int change; if (! (mix = chip->mixer_data)) @@ -131,8 +128,7 @@ static int daca_put_deemphasis(struct snd_kcontrol *kcontrol, } /* output volume */ -static int daca_info_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int daca_info_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -141,11 +137,10 @@ static int daca_info_volume(struct snd_kcontrol *kcontrol, return 0; } -static int daca_get_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int daca_get_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_daca *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_daca_t *mix; if (! (mix = chip->mixer_data)) return -ENODEV; ucontrol->value.integer.value[0] = mix->left_vol; @@ -153,11 +148,10 @@ static int daca_get_volume(struct snd_kcontrol *kcontrol, return 0; } -static int daca_put_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int daca_put_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_daca *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_daca_t *mix; int change; if (! (mix = chip->mixer_data)) @@ -175,22 +169,20 @@ static int daca_put_volume(struct snd_kcontrol *kcontrol, /* amplifier switch */ #define daca_info_amp daca_info_deemphasis -static int daca_get_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int daca_get_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_daca *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_daca_t *mix; if (! (mix = chip->mixer_data)) return -ENODEV; ucontrol->value.integer.value[0] = mix->amp_on ? 1 : 0; return 0; } -static int daca_put_amp(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int daca_put_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_daca *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_daca_t *mix; int change; if (! (mix = chip->mixer_data)) @@ -204,7 +196,7 @@ static int daca_put_amp(struct snd_kcontrol *kcontrol, return change; } -static struct snd_kcontrol_new daca_mixers[] = { +static snd_kcontrol_new_t daca_mixers[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Deemphasis Switch", .info = daca_info_deemphasis, @@ -227,9 +219,9 @@ static struct snd_kcontrol_new daca_mixers[] = { #ifdef CONFIG_PM -static void daca_resume(struct snd_pmac *chip) +static void daca_resume(pmac_t *chip) { - struct pmac_daca *mix = chip->mixer_data; + pmac_daca_t *mix = chip->mixer_data; i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_SR, 0x08); i2c_smbus_write_byte_data(mix->i2c.client, DACA_REG_GCFG, mix->amp_on ? 0x05 : 0x04); @@ -238,9 +230,9 @@ static void daca_resume(struct snd_pmac *chip) #endif /* CONFIG_PM */ -static void daca_cleanup(struct snd_pmac *chip) +static void daca_cleanup(pmac_t *chip) { - struct pmac_daca *mix = chip->mixer_data; + pmac_daca_t *mix = chip->mixer_data; if (! mix) return; snd_pmac_keywest_cleanup(&mix->i2c); @@ -249,10 +241,10 @@ static void daca_cleanup(struct snd_pmac *chip) } /* exported */ -int __init snd_pmac_daca_init(struct snd_pmac *chip) +int __init snd_pmac_daca_init(pmac_t *chip) { int i, err; - struct pmac_daca *mix; + pmac_daca_t *mix; #ifdef CONFIG_KMOD if (current->fs->root) diff --git a/trunk/sound/ppc/keywest.c b/trunk/sound/ppc/keywest.c index 097fbcfc5d45..df073a05b5d7 100644 --- a/trunk/sound/ppc/keywest.c +++ b/trunk/sound/ppc/keywest.c @@ -32,7 +32,7 @@ * we have to keep a static variable here since i2c attach_adapter * callback cannot pass a private data. */ -static struct pmac_keywest *keywest_ctx; +static pmac_keywest_t *keywest_ctx; #define I2C_DRIVERID_KEYWEST 0xFEBA @@ -106,7 +106,7 @@ static int keywest_detach_client(struct i2c_client *client) } /* exported */ -void snd_pmac_keywest_cleanup(struct pmac_keywest *i2c) +void snd_pmac_keywest_cleanup(pmac_keywest_t *i2c) { if (keywest_ctx && keywest_ctx == i2c) { i2c_del_driver(&keywest_driver); @@ -126,7 +126,7 @@ int __init snd_pmac_tumbler_post_init(void) } /* exported */ -int __init snd_pmac_keywest_init(struct pmac_keywest *i2c) +int __init snd_pmac_keywest_init(pmac_keywest_t *i2c) { int err; diff --git a/trunk/sound/ppc/pmac.c b/trunk/sound/ppc/pmac.c index 9b2b00fdc1ae..db2f1815fc30 100644 --- a/trunk/sound/ppc/pmac.c +++ b/trunk/sound/ppc/pmac.c @@ -36,6 +36,14 @@ #include <asm/pci-bridge.h> +#ifdef CONFIG_PM +static int snd_pmac_register_sleep_notifier(pmac_t *chip); +static int snd_pmac_unregister_sleep_notifier(pmac_t *chip); +static int snd_pmac_suspend(snd_card_t *card, pm_message_t state); +static int snd_pmac_resume(snd_card_t *card); +#endif + + /* fixed frequency table for awacs, screamer, burgundy, DACA (44100 max) */ static int awacs_freqs[8] = { 44100, 29400, 22050, 17640, 14700, 11025, 8820, 7350 @@ -48,7 +56,7 @@ static int tumbler_freqs[1] = { /* * allocate DBDMA command arrays */ -static int snd_pmac_dbdma_alloc(struct snd_pmac *chip, struct pmac_dbdma *rec, int size) +static int snd_pmac_dbdma_alloc(pmac_t *chip, pmac_dbdma_t *rec, int size) { unsigned int rsize = sizeof(struct dbdma_cmd) * (size + 1); @@ -64,7 +72,7 @@ static int snd_pmac_dbdma_alloc(struct snd_pmac *chip, struct pmac_dbdma *rec, i return 0; } -static void snd_pmac_dbdma_free(struct snd_pmac *chip, struct pmac_dbdma *rec) +static void snd_pmac_dbdma_free(pmac_t *chip, pmac_dbdma_t *rec) { if (rec) { unsigned int rsize = sizeof(struct dbdma_cmd) * (rec->size + 1); @@ -82,7 +90,7 @@ static void snd_pmac_dbdma_free(struct snd_pmac *chip, struct pmac_dbdma *rec) * look up frequency table */ -unsigned int snd_pmac_rate_index(struct snd_pmac *chip, struct pmac_stream *rec, unsigned int rate) +unsigned int snd_pmac_rate_index(pmac_t *chip, pmac_stream_t *rec, unsigned int rate) { int i, ok, found; @@ -111,8 +119,8 @@ static inline int another_stream(int stream) /* * allocate buffers */ -static int snd_pmac_pcm_hw_params(struct snd_pcm_substream *subs, - struct snd_pcm_hw_params *hw_params) +static int snd_pmac_pcm_hw_params(snd_pcm_substream_t *subs, + snd_pcm_hw_params_t *hw_params) { return snd_pcm_lib_malloc_pages(subs, params_buffer_bytes(hw_params)); } @@ -120,7 +128,7 @@ static int snd_pmac_pcm_hw_params(struct snd_pcm_substream *subs, /* * release buffers */ -static int snd_pmac_pcm_hw_free(struct snd_pcm_substream *subs) +static int snd_pmac_pcm_hw_free(snd_pcm_substream_t *subs) { snd_pcm_lib_free_pages(subs); return 0; @@ -129,7 +137,7 @@ static int snd_pmac_pcm_hw_free(struct snd_pcm_substream *subs) /* * get a stream of the opposite direction */ -static struct pmac_stream *snd_pmac_get_stream(struct snd_pmac *chip, int stream) +static pmac_stream_t *snd_pmac_get_stream(pmac_t *chip, int stream) { switch (stream) { case SNDRV_PCM_STREAM_PLAYBACK: @@ -146,7 +154,7 @@ static struct pmac_stream *snd_pmac_get_stream(struct snd_pmac *chip, int stream * wait while run status is on */ static inline void -snd_pmac_wait_ack(struct pmac_stream *rec) +snd_pmac_wait_ack(pmac_stream_t *rec) { int timeout = 50000; while ((in_le32(&rec->dma->status) & RUN) && timeout-- > 0) @@ -157,7 +165,7 @@ snd_pmac_wait_ack(struct pmac_stream *rec) * set the format and rate to the chip. * call the lowlevel function if defined (e.g. for AWACS). */ -static void snd_pmac_pcm_set_format(struct snd_pmac *chip) +static void snd_pmac_pcm_set_format(pmac_t *chip) { /* set up frequency and format */ out_le32(&chip->awacs->control, chip->control_mask | (chip->rate_index << 8)); @@ -169,7 +177,7 @@ static void snd_pmac_pcm_set_format(struct snd_pmac *chip) /* * stop the DMA transfer */ -static inline void snd_pmac_dma_stop(struct pmac_stream *rec) +static inline void snd_pmac_dma_stop(pmac_stream_t *rec) { out_le32(&rec->dma->control, (RUN|WAKE|FLUSH|PAUSE) << 16); snd_pmac_wait_ack(rec); @@ -178,7 +186,7 @@ static inline void snd_pmac_dma_stop(struct pmac_stream *rec) /* * set the command pointer address */ -static inline void snd_pmac_dma_set_command(struct pmac_stream *rec, struct pmac_dbdma *cmd) +static inline void snd_pmac_dma_set_command(pmac_stream_t *rec, pmac_dbdma_t *cmd) { out_le32(&rec->dma->cmdptr, cmd->addr); } @@ -186,7 +194,7 @@ static inline void snd_pmac_dma_set_command(struct pmac_stream *rec, struct pmac /* * start the DMA */ -static inline void snd_pmac_dma_run(struct pmac_stream *rec, int status) +static inline void snd_pmac_dma_run(pmac_stream_t *rec, int status) { out_le32(&rec->dma->control, status | (status << 16)); } @@ -195,14 +203,14 @@ static inline void snd_pmac_dma_run(struct pmac_stream *rec, int status) /* * prepare playback/capture stream */ -static int snd_pmac_pcm_prepare(struct snd_pmac *chip, struct pmac_stream *rec, struct snd_pcm_substream *subs) +static int snd_pmac_pcm_prepare(pmac_t *chip, pmac_stream_t *rec, snd_pcm_substream_t *subs) { int i; volatile struct dbdma_cmd __iomem *cp; - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; int rate_index; long offset; - struct pmac_stream *astr; + pmac_stream_t *astr; rec->dma_size = snd_pcm_lib_buffer_bytes(subs); rec->period_size = snd_pcm_lib_period_bytes(subs); @@ -259,8 +267,8 @@ static int snd_pmac_pcm_prepare(struct snd_pmac *chip, struct pmac_stream *rec, /* * PCM trigger/stop */ -static int snd_pmac_pcm_trigger(struct snd_pmac *chip, struct pmac_stream *rec, - struct snd_pcm_substream *subs, int cmd) +static int snd_pmac_pcm_trigger(pmac_t *chip, pmac_stream_t *rec, + snd_pcm_substream_t *subs, int cmd) { volatile struct dbdma_cmd __iomem *cp; int i, command; @@ -306,9 +314,8 @@ static int snd_pmac_pcm_trigger(struct snd_pmac *chip, struct pmac_stream *rec, * return the current pointer */ inline -static snd_pcm_uframes_t snd_pmac_pcm_pointer(struct snd_pmac *chip, - struct pmac_stream *rec, - struct snd_pcm_substream *subs) +static snd_pcm_uframes_t snd_pmac_pcm_pointer(pmac_t *chip, pmac_stream_t *rec, + snd_pcm_substream_t *subs) { int count = 0; @@ -331,22 +338,22 @@ static snd_pcm_uframes_t snd_pmac_pcm_pointer(struct snd_pmac *chip, * playback */ -static int snd_pmac_playback_prepare(struct snd_pcm_substream *subs) +static int snd_pmac_playback_prepare(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_prepare(chip, &chip->playback, subs); } -static int snd_pmac_playback_trigger(struct snd_pcm_substream *subs, +static int snd_pmac_playback_trigger(snd_pcm_substream_t *subs, int cmd) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_trigger(chip, &chip->playback, subs, cmd); } -static snd_pcm_uframes_t snd_pmac_playback_pointer(struct snd_pcm_substream *subs) +static snd_pcm_uframes_t snd_pmac_playback_pointer(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_pointer(chip, &chip->playback, subs); } @@ -355,22 +362,22 @@ static snd_pcm_uframes_t snd_pmac_playback_pointer(struct snd_pcm_substream *sub * capture */ -static int snd_pmac_capture_prepare(struct snd_pcm_substream *subs) +static int snd_pmac_capture_prepare(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_prepare(chip, &chip->capture, subs); } -static int snd_pmac_capture_trigger(struct snd_pcm_substream *subs, +static int snd_pmac_capture_trigger(snd_pcm_substream_t *subs, int cmd) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_trigger(chip, &chip->capture, subs, cmd); } -static snd_pcm_uframes_t snd_pmac_capture_pointer(struct snd_pcm_substream *subs) +static snd_pcm_uframes_t snd_pmac_capture_pointer(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_pointer(chip, &chip->capture, subs); } @@ -378,7 +385,7 @@ static snd_pcm_uframes_t snd_pmac_capture_pointer(struct snd_pcm_substream *subs /* * update playback/capture pointer from interrupts */ -static void snd_pmac_pcm_update(struct snd_pmac *chip, struct pmac_stream *rec) +static void snd_pmac_pcm_update(pmac_t *chip, pmac_stream_t *rec) { volatile struct dbdma_cmd __iomem *cp; int c; @@ -414,7 +421,7 @@ static void snd_pmac_pcm_update(struct snd_pmac *chip, struct pmac_stream *rec) * hw info */ -static struct snd_pcm_hardware snd_pmac_playback = +static snd_pcm_hardware_t snd_pmac_playback = { .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP | @@ -433,7 +440,7 @@ static struct snd_pcm_hardware snd_pmac_playback = .periods_max = PMAC_MAX_FRAGS, }; -static struct snd_pcm_hardware snd_pmac_capture = +static snd_pcm_hardware_t snd_pmac_capture = { .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP | @@ -454,11 +461,11 @@ static struct snd_pcm_hardware snd_pmac_capture = #if 0 // NYI -static int snd_pmac_hw_rule_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pmac_hw_rule_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_pmac *chip = rule->private; - struct pmac_stream *rec = snd_pmac_get_stream(chip, rule->deps[0]); + pmac_t *chip = rule->private; + pmac_stream_t *rec = snd_pmac_get_stream(chip, rule->deps[0]); int i, freq_table[8], num_freqs; if (! rec) @@ -473,11 +480,11 @@ static int snd_pmac_hw_rule_rate(struct snd_pcm_hw_params *params, num_freqs, freq_table, 0); } -static int snd_pmac_hw_rule_format(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int snd_pmac_hw_rule_format(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_pmac *chip = rule->private; - struct pmac_stream *rec = snd_pmac_get_stream(chip, rule->deps[0]); + pmac_t *chip = rule->private; + pmac_stream_t *rec = snd_pmac_get_stream(chip, rule->deps[0]); if (! rec) return -EINVAL; @@ -486,10 +493,9 @@ static int snd_pmac_hw_rule_format(struct snd_pcm_hw_params *params, } #endif // NYI -static int snd_pmac_pcm_open(struct snd_pmac *chip, struct pmac_stream *rec, - struct snd_pcm_substream *subs) +static int snd_pmac_pcm_open(pmac_t *chip, pmac_stream_t *rec, snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; int i, j, fflags; static int typical_freqs[] = { 44100, @@ -559,10 +565,9 @@ static int snd_pmac_pcm_open(struct snd_pmac *chip, struct pmac_stream *rec, return 0; } -static int snd_pmac_pcm_close(struct snd_pmac *chip, struct pmac_stream *rec, - struct snd_pcm_substream *subs) +static int snd_pmac_pcm_close(pmac_t *chip, pmac_stream_t *rec, snd_pcm_substream_t *subs) { - struct pmac_stream *astr; + pmac_stream_t *astr; snd_pmac_dma_stop(rec); @@ -577,32 +582,32 @@ static int snd_pmac_pcm_close(struct snd_pmac *chip, struct pmac_stream *rec, return 0; } -static int snd_pmac_playback_open(struct snd_pcm_substream *subs) +static int snd_pmac_playback_open(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); subs->runtime->hw = snd_pmac_playback; return snd_pmac_pcm_open(chip, &chip->playback, subs); } -static int snd_pmac_capture_open(struct snd_pcm_substream *subs) +static int snd_pmac_capture_open(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); subs->runtime->hw = snd_pmac_capture; return snd_pmac_pcm_open(chip, &chip->capture, subs); } -static int snd_pmac_playback_close(struct snd_pcm_substream *subs) +static int snd_pmac_playback_close(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_close(chip, &chip->playback, subs); } -static int snd_pmac_capture_close(struct snd_pcm_substream *subs) +static int snd_pmac_capture_close(snd_pcm_substream_t *subs) { - struct snd_pmac *chip = snd_pcm_substream_chip(subs); + pmac_t *chip = snd_pcm_substream_chip(subs); return snd_pmac_pcm_close(chip, &chip->capture, subs); } @@ -610,7 +615,7 @@ static int snd_pmac_capture_close(struct snd_pcm_substream *subs) /* */ -static struct snd_pcm_ops snd_pmac_playback_ops = { +static snd_pcm_ops_t snd_pmac_playback_ops = { .open = snd_pmac_playback_open, .close = snd_pmac_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -621,7 +626,7 @@ static struct snd_pcm_ops snd_pmac_playback_ops = { .pointer = snd_pmac_playback_pointer, }; -static struct snd_pcm_ops snd_pmac_capture_ops = { +static snd_pcm_ops_t snd_pmac_capture_ops = { .open = snd_pmac_capture_open, .close = snd_pmac_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -632,9 +637,14 @@ static struct snd_pcm_ops snd_pmac_capture_ops = { .pointer = snd_pmac_capture_pointer, }; -int __init snd_pmac_pcm_new(struct snd_pmac *chip) +static void pmac_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int __init snd_pmac_pcm_new(pmac_t *chip) +{ + snd_pcm_t *pcm; int err; int num_captures = 1; @@ -649,6 +659,7 @@ int __init snd_pmac_pcm_new(struct snd_pmac *chip) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_pmac_capture_ops); pcm->private_data = chip; + pcm->private_free = pmac_pcm_free; pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; strcpy(pcm->name, chip->card->shortname); chip->pcm = pcm; @@ -671,7 +682,7 @@ int __init snd_pmac_pcm_new(struct snd_pmac *chip) } -static void snd_pmac_dbdma_reset(struct snd_pmac *chip) +static void snd_pmac_dbdma_reset(pmac_t *chip) { out_le32(&chip->playback.dma->control, (RUN|PAUSE|FLUSH|WAKE|DEAD) << 16); snd_pmac_wait_ack(&chip->playback); @@ -683,9 +694,9 @@ static void snd_pmac_dbdma_reset(struct snd_pmac *chip) /* * handling beep */ -void snd_pmac_beep_dma_start(struct snd_pmac *chip, int bytes, unsigned long addr, int speed) +void snd_pmac_beep_dma_start(pmac_t *chip, int bytes, unsigned long addr, int speed) { - struct pmac_stream *rec = &chip->playback; + pmac_stream_t *rec = &chip->playback; snd_pmac_dma_stop(rec); st_le16(&chip->extra_dma.cmds->req_count, bytes); @@ -701,7 +712,7 @@ void snd_pmac_beep_dma_start(struct snd_pmac *chip, int bytes, unsigned long add snd_pmac_dma_run(rec, RUN); } -void snd_pmac_beep_dma_stop(struct snd_pmac *chip) +void snd_pmac_beep_dma_stop(pmac_t *chip) { snd_pmac_dma_stop(&chip->playback); st_le16(&chip->extra_dma.cmds->command, DBDMA_STOP); @@ -715,7 +726,7 @@ void snd_pmac_beep_dma_stop(struct snd_pmac *chip) static irqreturn_t snd_pmac_tx_intr(int irq, void *devid, struct pt_regs *regs) { - struct snd_pmac *chip = devid; + pmac_t *chip = devid; snd_pmac_pcm_update(chip, &chip->playback); return IRQ_HANDLED; } @@ -724,7 +735,7 @@ snd_pmac_tx_intr(int irq, void *devid, struct pt_regs *regs) static irqreturn_t snd_pmac_rx_intr(int irq, void *devid, struct pt_regs *regs) { - struct snd_pmac *chip = devid; + pmac_t *chip = devid; snd_pmac_pcm_update(chip, &chip->capture); return IRQ_HANDLED; } @@ -733,7 +744,7 @@ snd_pmac_rx_intr(int irq, void *devid, struct pt_regs *regs) static irqreturn_t snd_pmac_ctrl_intr(int irq, void *devid, struct pt_regs *regs) { - struct snd_pmac *chip = devid; + pmac_t *chip = devid; int ctrl = in_le32(&chip->awacs->control); /*printk("pmac: control interrupt.. 0x%x\n", ctrl);*/ @@ -756,7 +767,7 @@ snd_pmac_ctrl_intr(int irq, void *devid, struct pt_regs *regs) /* * a wrapper to feature call for compatibility */ -static void snd_pmac_sound_feature(struct snd_pmac *chip, int enable) +static void snd_pmac_sound_feature(pmac_t *chip, int enable) { if (ppc_md.feature_call) ppc_md.feature_call(PMAC_FTR_SOUND_CHIP_ENABLE, chip->node, 0, enable); @@ -766,7 +777,7 @@ static void snd_pmac_sound_feature(struct snd_pmac *chip, int enable) * release resources */ -static int snd_pmac_free(struct snd_pmac *chip) +static int snd_pmac_free(pmac_t *chip) { /* stop sounds */ if (chip->initialized) { @@ -776,6 +787,9 @@ static int snd_pmac_free(struct snd_pmac *chip) } snd_pmac_sound_feature(chip, 0); +#ifdef CONFIG_PM + snd_pmac_unregister_sleep_notifier(chip); +#endif /* clean up mixer if any */ if (chip->mixer_free) @@ -828,9 +842,9 @@ static int snd_pmac_free(struct snd_pmac *chip) /* * free the device */ -static int snd_pmac_dev_free(struct snd_device *device) +static int snd_pmac_dev_free(snd_device_t *device) { - struct snd_pmac *chip = device->device_data; + pmac_t *chip = device->device_data; return snd_pmac_free(chip); } @@ -839,7 +853,7 @@ static int snd_pmac_dev_free(struct snd_device *device) * check the machine support byteswap (little-endian) */ -static void __init detect_byte_swap(struct snd_pmac *chip) +static void __init detect_byte_swap(pmac_t *chip) { struct device_node *mio; @@ -865,7 +879,7 @@ static void __init detect_byte_swap(struct snd_pmac *chip) /* * detect a sound chip */ -static int __init snd_pmac_detect(struct snd_pmac *chip) +static int __init snd_pmac_detect(pmac_t *chip) { struct device_node *sound = NULL; unsigned int *prop, l; @@ -973,11 +987,11 @@ static int __init snd_pmac_detect(struct snd_pmac *chip) * single frequency until proper i2s control is implemented */ switch(layout_id) { - case 0x24: - case 0x29: - case 0x33: - case 0x46: case 0x48: + case 0x46: + case 0x33: + case 0x29: + case 0x24: case 0x50: case 0x5c: chip->num_freqs = ARRAY_SIZE(tumbler_freqs); @@ -1053,8 +1067,8 @@ static int __init snd_pmac_detect(struct snd_pmac *chip) /* * exported - boolean info callbacks for ease of programming */ -int snd_pmac_boolean_stereo_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +int snd_pmac_boolean_stereo_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 2; @@ -1063,8 +1077,8 @@ int snd_pmac_boolean_stereo_info(struct snd_kcontrol *kcontrol, return 0; } -int snd_pmac_boolean_mono_info(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +int snd_pmac_boolean_mono_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1077,18 +1091,16 @@ int snd_pmac_boolean_mono_info(struct snd_kcontrol *kcontrol, /* * auto-mute */ -static int pmac_auto_mute_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int pmac_auto_mute_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = chip->auto_mute; return 0; } -static int pmac_auto_mute_put(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int pmac_auto_mute_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); if (ucontrol->value.integer.value[0] != chip->auto_mute) { chip->auto_mute = ucontrol->value.integer.value[0]; if (chip->update_automute) @@ -1098,10 +1110,9 @@ static int pmac_auto_mute_put(struct snd_kcontrol *kcontrol, return 0; } -static int pmac_hp_detect_get(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int pmac_hp_detect_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); if (chip->detect_headphone) ucontrol->value.integer.value[0] = chip->detect_headphone(chip); else @@ -1109,7 +1120,7 @@ static int pmac_hp_detect_get(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new auto_mute_controls[] __initdata = { +static snd_kcontrol_new_t auto_mute_controls[] __initdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Auto Mute Switch", .info = snd_pmac_boolean_mono_info, @@ -1124,7 +1135,7 @@ static struct snd_kcontrol_new auto_mute_controls[] __initdata = { }, }; -int __init snd_pmac_add_automute(struct snd_pmac *chip) +int __init snd_pmac_add_automute(pmac_t *chip) { int err; chip->auto_mute = 1; @@ -1141,13 +1152,13 @@ int __init snd_pmac_add_automute(struct snd_pmac *chip) /* * create and detect a pmac chip record */ -int __init snd_pmac_new(struct snd_card *card, struct snd_pmac **chip_return) +int __init snd_pmac_new(snd_card_t *card, pmac_t **chip_return) { - struct snd_pmac *chip; + pmac_t *chip; struct device_node *np; int i, err; unsigned long ctrl_addr, txdma_addr, rxdma_addr; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_pmac_dev_free, }; @@ -1287,6 +1298,12 @@ int __init snd_pmac_new(struct snd_card *card, struct snd_pmac **chip_return) /* Reset dbdma channels */ snd_pmac_dbdma_reset(chip); +#ifdef CONFIG_PM + /* add sleep notifier */ + if (! snd_pmac_register_sleep_notifier(chip)) + snd_card_set_pm_callback(chip->card, snd_pmac_suspend, snd_pmac_resume, chip); +#endif + if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) goto __error; @@ -1311,11 +1328,11 @@ int __init snd_pmac_new(struct snd_card *card, struct snd_pmac **chip_return) * Save state when going to sleep, restore it afterwards. */ -void snd_pmac_suspend(struct snd_pmac *chip) +static int snd_pmac_suspend(snd_card_t *card, pm_message_t state) { + pmac_t *chip = card->pm_private_data; unsigned long flags; - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot); if (chip->suspend) chip->suspend(chip); snd_pcm_suspend_all(chip->pcm); @@ -1329,18 +1346,22 @@ void snd_pmac_suspend(struct snd_pmac *chip) if (chip->rx_irq >= 0) disable_irq(chip->rx_irq); snd_pmac_sound_feature(chip, 0); + return 0; } -void snd_pmac_resume(struct snd_pmac *chip) +static int snd_pmac_resume(snd_card_t *card) { + pmac_t *chip = card->pm_private_data; + snd_pmac_sound_feature(chip, 1); if (chip->resume) chip->resume(chip); /* enable CD sound input */ - if (chip->macio_base && chip->is_pbook_G3) + if (chip->macio_base && chip->is_pbook_G3) { out_8(chip->macio_base + 0x37, 3); - else if (chip->is_pbook_3400) + } else if (chip->is_pbook_3400) { in_8(chip->latch_base + 0x190); + } snd_pmac_pcm_set_format(chip); @@ -1351,7 +1372,53 @@ void snd_pmac_resume(struct snd_pmac *chip) if (chip->rx_irq >= 0) enable_irq(chip->rx_irq); - snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0); + return 0; +} + +/* the chip is stored statically by snd_pmac_register_sleep_notifier + * because we can't have any private data for notify callback. + */ +static pmac_t *sleeping_pmac = NULL; + +static int snd_pmac_sleep_notify(struct pmu_sleep_notifier *self, int when) +{ + pmac_t *chip; + + chip = sleeping_pmac; + if (! chip) + return 0; + + switch (when) { + case PBOOK_SLEEP_NOW: + snd_pmac_suspend(chip->card, PMSG_SUSPEND); + break; + case PBOOK_WAKE: + snd_pmac_resume(chip->card); + break; + } + return PBOOK_SLEEP_OK; +} + +static struct pmu_sleep_notifier snd_pmac_sleep_notifier = { + snd_pmac_sleep_notify, SLEEP_LEVEL_SOUND, +}; + +static int __init snd_pmac_register_sleep_notifier(pmac_t *chip) +{ + /* should be protected here.. */ + snd_assert(! sleeping_pmac, return -EBUSY); + sleeping_pmac = chip; + pmu_register_sleep_notifier(&snd_pmac_sleep_notifier); + return 0; +} + +static int snd_pmac_unregister_sleep_notifier(pmac_t *chip) +{ + /* should be protected here.. */ + snd_assert(sleeping_pmac == chip, return -ENODEV); + pmu_unregister_sleep_notifier(&snd_pmac_sleep_notifier); + sleeping_pmac = NULL; + return 0; } #endif /* CONFIG_PM */ diff --git a/trunk/sound/ppc/pmac.h b/trunk/sound/ppc/pmac.h index 086da7a18909..bfff788e9847 100644 --- a/trunk/sound/ppc/pmac.h +++ b/trunk/sound/ppc/pmac.h @@ -46,10 +46,19 @@ #define PMAC_SUPPORT_AUTOMUTE +/* + * typedefs + */ +typedef struct snd_pmac pmac_t; +typedef struct snd_pmac_stream pmac_stream_t; +typedef struct snd_pmac_beep pmac_beep_t; +typedef struct snd_pmac_dbdma pmac_dbdma_t; + + /* * DBDMA space */ -struct pmac_dbdma { +struct snd_pmac_dbdma { dma_addr_t dma_base; dma_addr_t addr; struct dbdma_cmd __iomem *cmds; @@ -60,7 +69,7 @@ struct pmac_dbdma { /* * playback/capture stream */ -struct pmac_stream { +struct snd_pmac_stream { int running; /* boolean */ int stream; /* PLAYBACK/CAPTURE */ @@ -70,10 +79,10 @@ struct pmac_stream { int buffer_size; /* in kbytes */ int nperiods, cur_period; - struct pmac_dbdma cmd; + pmac_dbdma_t cmd; volatile struct dbdma_regs __iomem *dma; - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; unsigned int cur_freqs; /* currently available frequencies */ unsigned int cur_formats; /* currently available formats */ @@ -89,7 +98,7 @@ enum snd_pmac_model { }; struct snd_pmac { - struct snd_card *card; + snd_card_t *card; /* h/w info */ struct device_node *node; @@ -131,80 +140,75 @@ struct snd_pmac { unsigned char __iomem *latch_base; unsigned char __iomem *macio_base; - struct pmac_stream playback; - struct pmac_stream capture; + pmac_stream_t playback; + pmac_stream_t capture; - struct pmac_dbdma extra_dma; + pmac_dbdma_t extra_dma; int irq, tx_irq, rx_irq; - struct snd_pcm *pcm; + snd_pcm_t *pcm; - struct pmac_beep *beep; + pmac_beep_t *beep; unsigned int control_mask; /* control mask */ /* mixer stuffs */ void *mixer_data; - void (*mixer_free)(struct snd_pmac *); - struct snd_kcontrol *master_sw_ctl; - struct snd_kcontrol *speaker_sw_ctl; - struct snd_kcontrol *drc_sw_ctl; /* only used for tumbler -ReneR */ - struct snd_kcontrol *hp_detect_ctl; - struct snd_kcontrol *lineout_sw_ctl; + void (*mixer_free)(pmac_t *); + snd_kcontrol_t *master_sw_ctl; + snd_kcontrol_t *speaker_sw_ctl; + snd_kcontrol_t *drc_sw_ctl; /* only used for tumbler -ReneR */ + snd_kcontrol_t *hp_detect_ctl; + snd_kcontrol_t *lineout_sw_ctl; /* lowlevel callbacks */ - void (*set_format)(struct snd_pmac *chip); - void (*update_automute)(struct snd_pmac *chip, int do_notify); - int (*detect_headphone)(struct snd_pmac *chip); + void (*set_format)(pmac_t *chip); + void (*update_automute)(pmac_t *chip, int do_notify); + int (*detect_headphone)(pmac_t *chip); #ifdef CONFIG_PM - void (*suspend)(struct snd_pmac *chip); - void (*resume)(struct snd_pmac *chip); + void (*suspend)(pmac_t *chip); + void (*resume)(pmac_t *chip); #endif }; /* exported functions */ -int snd_pmac_new(struct snd_card *card, struct snd_pmac **chip_return); -int snd_pmac_pcm_new(struct snd_pmac *chip); -int snd_pmac_attach_beep(struct snd_pmac *chip); -void snd_pmac_detach_beep(struct snd_pmac *chip); -void snd_pmac_beep_stop(struct snd_pmac *chip); -unsigned int snd_pmac_rate_index(struct snd_pmac *chip, struct pmac_stream *rec, unsigned int rate); +int snd_pmac_new(snd_card_t *card, pmac_t **chip_return); +int snd_pmac_pcm_new(pmac_t *chip); +int snd_pmac_attach_beep(pmac_t *chip); +void snd_pmac_detach_beep(pmac_t *chip); +void snd_pmac_beep_stop(pmac_t *chip); +unsigned int snd_pmac_rate_index(pmac_t *chip, pmac_stream_t *rec, unsigned int rate); -void snd_pmac_beep_dma_start(struct snd_pmac *chip, int bytes, unsigned long addr, int speed); -void snd_pmac_beep_dma_stop(struct snd_pmac *chip); - -#ifdef CONFIG_PM -void snd_pmac_suspend(struct snd_pmac *chip); -void snd_pmac_resume(struct snd_pmac *chip); -#endif +void snd_pmac_beep_dma_start(pmac_t *chip, int bytes, unsigned long addr, int speed); +void snd_pmac_beep_dma_stop(pmac_t *chip); /* initialize mixer */ -int snd_pmac_awacs_init(struct snd_pmac *chip); -int snd_pmac_burgundy_init(struct snd_pmac *chip); -int snd_pmac_daca_init(struct snd_pmac *chip); -int snd_pmac_tumbler_init(struct snd_pmac *chip); +int snd_pmac_awacs_init(pmac_t *chip); +int snd_pmac_burgundy_init(pmac_t *chip); +int snd_pmac_daca_init(pmac_t *chip); +int snd_pmac_tumbler_init(pmac_t *chip); int snd_pmac_tumbler_post_init(void); -int snd_pmac_toonie_init(struct snd_pmac *chip); +int snd_pmac_toonie_init(pmac_t *chip); /* i2c functions */ -struct pmac_keywest { +typedef struct snd_pmac_keywest { int addr; struct i2c_client *client; int id; - int (*init_client)(struct pmac_keywest *i2c); + int (*init_client)(struct snd_pmac_keywest *i2c); char *name; -}; +} pmac_keywest_t; -int snd_pmac_keywest_init(struct pmac_keywest *i2c); -void snd_pmac_keywest_cleanup(struct pmac_keywest *i2c); +int snd_pmac_keywest_init(pmac_keywest_t *i2c); +void snd_pmac_keywest_cleanup(pmac_keywest_t *i2c); /* misc */ -int snd_pmac_boolean_stereo_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); -int snd_pmac_boolean_mono_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo); +int snd_pmac_boolean_stereo_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo); +int snd_pmac_boolean_mono_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo); -int snd_pmac_add_automute(struct snd_pmac *chip); +int snd_pmac_add_automute(pmac_t *chip); #endif /* __PMAC_H */ diff --git a/trunk/sound/ppc/powermac.c b/trunk/sound/ppc/powermac.c index f4902a219e50..a6d8cbf4064f 100644 --- a/trunk/sound/ppc/powermac.c +++ b/trunk/sound/ppc/powermac.c @@ -20,8 +20,6 @@ #include <sound/driver.h> #include <linux/init.h> -#include <linux/err.h> -#include <linux/platform_device.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/initval.h> @@ -46,16 +44,20 @@ MODULE_PARM_DESC(id, "ID string for " CHIP_NAME " soundchip."); module_param(enable_beep, bool, 0444); MODULE_PARM_DESC(enable_beep, "Enable beep using PCM."); -static struct platform_device *device; +/* + * card entry + */ + +static snd_card_t *snd_pmac_card = NULL; /* */ -static int __init snd_pmac_probe(struct platform_device *devptr) +static int __init snd_pmac_probe(void) { - struct snd_card *card; - struct snd_pmac *chip; + snd_card_t *card; + pmac_t *chip; char *name_ext; int err; @@ -65,7 +67,6 @@ static int __init snd_pmac_probe(struct platform_device *devptr) if ((err = snd_pmac_new(card, &chip)) < 0) goto __error; - card->private_data = chip; switch (chip->model) { case PMAC_BURGUNDY: @@ -130,12 +131,13 @@ static int __init snd_pmac_probe(struct platform_device *devptr) if (enable_beep) snd_pmac_attach_beep(chip); - snd_card_set_dev(card, &devptr->dev); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto __error; if ((err = snd_card_register(card)) < 0) goto __error; - platform_set_drvdata(devptr, card); + snd_pmac_card = card; return 0; __error: @@ -144,62 +146,23 @@ static int __init snd_pmac_probe(struct platform_device *devptr) } -static int __devexit snd_pmac_remove(struct platform_device *devptr) -{ - snd_card_free(platform_get_drvdata(devptr)); - platform_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_pmac_driver_suspend(struct platform_device *devptr, pm_message_t state) -{ - struct snd_card *card = platform_get_drvdata(devptr); - snd_pmac_suspend(card->private_data); - return 0; -} - -static int snd_pmac_driver_resume(struct platform_device *devptr) -{ - struct snd_card *card = platform_get_drvdata(devptr); - snd_pmac_resume(card->private_data); - return 0; -} -#endif - -#define SND_PMAC_DRIVER "snd_powermac" - -static struct platform_driver snd_pmac_driver = { - .probe = snd_pmac_probe, - .remove = __devexit_p(snd_pmac_remove), -#ifdef CONFIG_PM - .suspend = snd_pmac_driver_suspend, - .resume = snd_pmac_driver_resume, -#endif - .driver = { - .name = SND_PMAC_DRIVER - }, -}; +/* + * MODULE stuff + */ static int __init alsa_card_pmac_init(void) { int err; - - if ((err = platform_driver_register(&snd_pmac_driver)) < 0) + if ((err = snd_pmac_probe()) < 0) return err; - device = platform_device_register_simple(SND_PMAC_DRIVER, -1, NULL, 0); - if (IS_ERR(device)) { - platform_driver_unregister(&snd_pmac_driver); - return PTR_ERR(device); - } return 0; } static void __exit alsa_card_pmac_exit(void) { - platform_device_unregister(device); - platform_driver_unregister(&snd_pmac_driver); + if (snd_pmac_card) + snd_card_free(snd_pmac_card); } module_init(alsa_card_pmac_init) diff --git a/trunk/sound/ppc/toonie.c b/trunk/sound/ppc/toonie.c index 053b8f24e4dc..082bc4babab5 100644 --- a/trunk/sound/ppc/toonie.c +++ b/trunk/sound/ppc/toonie.c @@ -101,10 +101,10 @@ static int read_audio_gpio(struct pmac_gpio *gp) enum { TOONIE_MUTE_HP, TOONIE_MUTE_AMP }; -static int toonie_get_mute_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int toonie_get_mute_switch(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); struct pmac_toonie *mix = chip->mixer_data; struct pmac_gpio *gp; @@ -124,10 +124,10 @@ static int toonie_get_mute_switch(struct snd_kcontrol *kcontrol, return 0; } -static int toonie_put_mute_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int toonie_put_mute_switch(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); struct pmac_toonie *mix = chip->mixer_data; struct pmac_gpio *gp; int val; @@ -156,7 +156,7 @@ static int toonie_put_mute_switch(struct snd_kcontrol *kcontrol, return 0; } -static struct snd_kcontrol_new toonie_hp_sw __initdata = { +static snd_kcontrol_new_t toonie_hp_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Headphone Playback Switch", .info = snd_pmac_boolean_mono_info, @@ -164,7 +164,7 @@ static struct snd_kcontrol_new toonie_hp_sw __initdata = { .put = toonie_put_mute_switch, .private_value = TOONIE_MUTE_HP, }; -static struct snd_kcontrol_new toonie_speaker_sw __initdata = { +static snd_kcontrol_new_t toonie_speaker_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PC Speaker Playback Switch", .info = snd_pmac_boolean_mono_info, @@ -176,7 +176,7 @@ static struct snd_kcontrol_new toonie_speaker_sw __initdata = { /* * auto-mute stuffs */ -static int toonie_detect_headphone(struct snd_pmac *chip) +static int toonie_detect_headphone(pmac_t *chip) { struct pmac_toonie *mix = chip->mixer_data; int detect = 0; @@ -186,8 +186,8 @@ static int toonie_detect_headphone(struct snd_pmac *chip) return detect; } -static void toonie_check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val, - int do_notify, struct snd_kcontrol *sw) +static void toonie_check_mute(pmac_t *chip, struct pmac_gpio *gp, int val, + int do_notify, snd_kcontrol_t *sw) { if (check_audio_gpio(gp) != val) { write_audio_gpio(gp, val); @@ -199,7 +199,7 @@ static void toonie_check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int v static void toonie_detect_handler(void *self) { - struct snd_pmac *chip = (struct snd_pmac *) self; + pmac_t *chip = (pmac_t*) self; struct pmac_toonie *mix; int headphone; @@ -232,7 +232,7 @@ static void toonie_detect_handler(void *self) } } -static void toonie_update_automute(struct snd_pmac *chip, int do_notify) +static void toonie_update_automute(pmac_t *chip, int do_notify) { if (chip->auto_mute) { struct pmac_toonie *mix; @@ -246,7 +246,7 @@ static void toonie_update_automute(struct snd_pmac *chip, int do_notify) /* interrupt - headphone plug changed */ static irqreturn_t toonie_hp_intr(int irq, void *devid, struct pt_regs *regs) { - struct snd_pmac *chip = devid; + pmac_t *chip = devid; if (chip->update_automute && chip->initialized) { chip->update_automute(chip, 1); @@ -325,7 +325,7 @@ static int find_audio_gpio(const char *name, const char *platform, return (np->n_intrs > 0) ? np->intrs[0].line : 0; } -static void toonie_cleanup(struct snd_pmac *chip) +static void toonie_cleanup(pmac_t *chip) { struct pmac_toonie *mix = chip->mixer_data; if (! mix) @@ -336,7 +336,7 @@ static void toonie_cleanup(struct snd_pmac *chip) chip->mixer_data = NULL; } -int snd_pmac_toonie_init(struct snd_pmac *chip) +int snd_pmac_toonie_init(pmac_t *chip) { struct pmac_toonie *mix; diff --git a/trunk/sound/ppc/tumbler.c b/trunk/sound/ppc/tumbler.c index 15c63cb2ccba..d74bfabe5300 100644 --- a/trunk/sound/ppc/tumbler.c +++ b/trunk/sound/ppc/tumbler.c @@ -82,21 +82,21 @@ enum { VOL_IDX_LAST_MIX }; -struct pmac_gpio { +typedef struct pmac_gpio { unsigned int addr; u8 active_val; u8 inactive_val; u8 active_state; -}; - -struct pmac_tumbler { - struct pmac_keywest i2c; - struct pmac_gpio audio_reset; - struct pmac_gpio amp_mute; - struct pmac_gpio line_mute; - struct pmac_gpio line_detect; - struct pmac_gpio hp_mute; - struct pmac_gpio hp_detect; +} pmac_gpio_t; + +typedef struct pmac_tumbler_t { + pmac_keywest_t i2c; + pmac_gpio_t audio_reset; + pmac_gpio_t amp_mute; + pmac_gpio_t line_mute; + pmac_gpio_t line_detect; + pmac_gpio_t hp_mute; + pmac_gpio_t hp_detect; int headphone_irq; int lineout_irq; unsigned int save_master_vol[2]; @@ -112,13 +112,13 @@ struct pmac_tumbler { int auto_mute_notify; int reset_on_sleep; u8 acs; -}; +} pmac_tumbler_t; /* */ -static int send_init_client(struct pmac_keywest *i2c, unsigned int *regs) +static int send_init_client(pmac_keywest_t *i2c, unsigned int *regs) { while (*regs > 0) { int err, count = 10; @@ -138,7 +138,7 @@ static int send_init_client(struct pmac_keywest *i2c, unsigned int *regs) } -static int tumbler_init_client(struct pmac_keywest *i2c) +static int tumbler_init_client(pmac_keywest_t *i2c) { static unsigned int regs[] = { /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */ @@ -149,7 +149,7 @@ static int tumbler_init_client(struct pmac_keywest *i2c) return send_init_client(i2c, regs); } -static int snapper_init_client(struct pmac_keywest *i2c) +static int snapper_init_client(pmac_keywest_t *i2c) { static unsigned int regs[] = { /* normal operation, SCLK=64fps, i2s output, 16bit width */ @@ -173,7 +173,7 @@ static int snapper_init_client(struct pmac_keywest *i2c) pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0) #define tumbler_gpio_free(gp) /* NOP */ -static void write_audio_gpio(struct pmac_gpio *gp, int active) +static void write_audio_gpio(pmac_gpio_t *gp, int active) { if (! gp->addr) return; @@ -182,7 +182,7 @@ static void write_audio_gpio(struct pmac_gpio *gp, int active) DBG("(I) gpio %x write %d\n", gp->addr, active); } -static int check_audio_gpio(struct pmac_gpio *gp) +static int check_audio_gpio(pmac_gpio_t *gp) { int ret; @@ -194,7 +194,7 @@ static int check_audio_gpio(struct pmac_gpio *gp) return (ret & 0xd) == (gp->active_val & 0xd); } -static int read_audio_gpio(struct pmac_gpio *gp) +static int read_audio_gpio(pmac_gpio_t *gp) { int ret; if (! gp->addr) @@ -206,7 +206,7 @@ static int read_audio_gpio(struct pmac_gpio *gp) /* * update master volume */ -static int tumbler_set_master_volume(struct pmac_tumbler *mix) +static int tumbler_set_master_volume(pmac_tumbler_t *mix) { unsigned char block[6]; unsigned int left_vol, right_vol; @@ -249,8 +249,7 @@ static int tumbler_set_master_volume(struct pmac_tumbler *mix) /* output volume */ -static int tumbler_info_master_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int tumbler_info_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -259,22 +258,20 @@ static int tumbler_info_master_volume(struct snd_kcontrol *kcontrol, return 0; } -static int tumbler_get_master_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_get_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix = chip->mixer_data; snd_assert(mix, return -ENODEV); ucontrol->value.integer.value[0] = mix->master_vol[0]; ucontrol->value.integer.value[1] = mix->master_vol[1]; return 0; } -static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_put_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix = chip->mixer_data; int change; snd_assert(mix, return -ENODEV); @@ -289,22 +286,20 @@ static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol, } /* output switch */ -static int tumbler_get_master_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_get_master_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix = chip->mixer_data; snd_assert(mix, return -ENODEV); ucontrol->value.integer.value[0] = mix->master_switch[0]; ucontrol->value.integer.value[1] = mix->master_switch[1]; return 0; } -static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_put_master_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix = chip->mixer_data; int change; snd_assert(mix, return -ENODEV); @@ -325,7 +320,7 @@ static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol, #define TAS3001_DRC_MAX 0x5f -static int tumbler_set_drc(struct pmac_tumbler *mix) +static int tumbler_set_drc(pmac_tumbler_t *mix) { unsigned char val[2]; @@ -359,7 +354,7 @@ static int tumbler_set_drc(struct pmac_tumbler *mix) #define TAS3004_DRC_MAX 0xef -static int snapper_set_drc(struct pmac_tumbler *mix) +static int snapper_set_drc(pmac_tumbler_t *mix) { unsigned char val[6]; @@ -389,10 +384,9 @@ static int snapper_set_drc(struct pmac_tumbler *mix) return 0; } -static int tumbler_info_drc_value(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int tumbler_info_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); + pmac_t *chip = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; @@ -401,22 +395,20 @@ static int tumbler_info_drc_value(struct snd_kcontrol *kcontrol, return 0; } -static int tumbler_get_drc_value(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_get_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; if (! (mix = chip->mixer_data)) return -ENODEV; ucontrol->value.integer.value[0] = mix->drc_range; return 0; } -static int tumbler_put_drc_value(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_put_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; int change; if (! (mix = chip->mixer_data)) @@ -432,22 +424,20 @@ static int tumbler_put_drc_value(struct snd_kcontrol *kcontrol, return change; } -static int tumbler_get_drc_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_get_drc_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; if (! (mix = chip->mixer_data)) return -ENODEV; ucontrol->value.integer.value[0] = mix->drc_enable; return 0; } -static int tumbler_put_drc_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_put_drc_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; int change; if (! (mix = chip->mixer_data)) @@ -476,8 +466,7 @@ struct tumbler_mono_vol { unsigned int *table; }; -static int tumbler_set_mono_volume(struct pmac_tumbler *mix, - struct tumbler_mono_vol *info) +static int tumbler_set_mono_volume(pmac_tumbler_t *mix, struct tumbler_mono_vol *info) { unsigned char block[4]; unsigned int vol; @@ -500,8 +489,7 @@ static int tumbler_set_mono_volume(struct pmac_tumbler *mix, return 0; } -static int tumbler_info_mono(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int tumbler_info_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value; @@ -512,24 +500,22 @@ static int tumbler_info_mono(struct snd_kcontrol *kcontrol, return 0; } -static int tumbler_get_mono(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_get_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value; - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; if (! (mix = chip->mixer_data)) return -ENODEV; ucontrol->value.integer.value[0] = mix->mono_vol[info->index]; return 0; } -static int tumbler_put_mono(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_put_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value; - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; int change; if (! (mix = chip->mixer_data)) @@ -608,7 +594,7 @@ static struct tumbler_mono_vol snapper_treble_vol_info = { * snapper mixer volumes */ -static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int reg) +static int snapper_set_mix_vol1(pmac_tumbler_t *mix, int idx, int ch, int reg) { int i, j, vol; unsigned char block[9]; @@ -632,7 +618,7 @@ static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int r return 0; } -static int snapper_set_mix_vol(struct pmac_tumbler *mix, int idx) +static int snapper_set_mix_vol(pmac_tumbler_t *mix, int idx) { if (! mix->i2c.client) return -ENODEV; @@ -642,8 +628,7 @@ static int snapper_set_mix_vol(struct pmac_tumbler *mix, int idx) return 0; } -static int snapper_info_mix(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snapper_info_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -652,12 +637,11 @@ static int snapper_info_mix(struct snd_kcontrol *kcontrol, return 0; } -static int snapper_get_mix(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snapper_get_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int idx = (int)kcontrol->private_value; - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; if (! (mix = chip->mixer_data)) return -ENODEV; ucontrol->value.integer.value[0] = mix->mix_vol[idx][0]; @@ -665,12 +649,11 @@ static int snapper_get_mix(struct snd_kcontrol *kcontrol, return 0; } -static int snapper_put_mix(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snapper_put_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { int idx = (int)kcontrol->private_value; - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; int change; if (! (mix = chip->mixer_data)) @@ -693,12 +676,11 @@ static int snapper_put_mix(struct snd_kcontrol *kcontrol, enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP, TUMBLER_MUTE_LINE }; -static int tumbler_get_mute_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_get_mute_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; - struct pmac_gpio *gp; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; + pmac_gpio_t *gp; if (! (mix = chip->mixer_data)) return -ENODEV; switch(kcontrol->private_value) { @@ -717,12 +699,11 @@ static int tumbler_get_mute_switch(struct snd_kcontrol *kcontrol, return 0; } -static int tumbler_put_mute_switch(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int tumbler_put_mute_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix; - struct pmac_gpio *gp; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix; + pmac_gpio_t *gp; int val; #ifdef PMAC_SUPPORT_AUTOMUTE if (chip->update_automute && chip->auto_mute) @@ -750,7 +731,7 @@ static int tumbler_put_mute_switch(struct snd_kcontrol *kcontrol, return 0; } -static int snapper_set_capture_source(struct pmac_tumbler *mix) +static int snapper_set_capture_source(pmac_tumbler_t *mix) { if (! mix->i2c.client) return -ENODEV; @@ -761,8 +742,7 @@ static int snapper_set_capture_source(struct pmac_tumbler *mix) return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs); } -static int snapper_info_capture_source(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snapper_info_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[2] = { "Line", "Mic" @@ -776,22 +756,20 @@ static int snapper_info_capture_source(struct snd_kcontrol *kcontrol, return 0; } -static int snapper_get_capture_source(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snapper_get_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix = chip->mixer_data; snd_assert(mix, return -ENODEV); ucontrol->value.integer.value[0] = mix->capture_source; return 0; } -static int snapper_put_capture_source(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snapper_put_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); - struct pmac_tumbler *mix = chip->mixer_data; + pmac_t *chip = snd_kcontrol_chip(kcontrol); + pmac_tumbler_t *mix = chip->mixer_data; int change; snd_assert(mix, return -ENODEV); @@ -816,7 +794,7 @@ static int snapper_put_capture_source(struct snd_kcontrol *kcontrol, /* */ -static struct snd_kcontrol_new tumbler_mixers[] __initdata = { +static snd_kcontrol_new_t tumbler_mixers[] __initdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Volume", .info = tumbler_info_master_volume, @@ -840,7 +818,7 @@ static struct snd_kcontrol_new tumbler_mixers[] __initdata = { }, }; -static struct snd_kcontrol_new snapper_mixers[] __initdata = { +static snd_kcontrol_new_t snapper_mixers[] __initdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Volume", .info = tumbler_info_master_volume, @@ -872,7 +850,7 @@ static struct snd_kcontrol_new snapper_mixers[] __initdata = { }, }; -static struct snd_kcontrol_new tumbler_hp_sw __initdata = { +static snd_kcontrol_new_t tumbler_hp_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Headphone Playback Switch", .info = snd_pmac_boolean_mono_info, @@ -880,7 +858,7 @@ static struct snd_kcontrol_new tumbler_hp_sw __initdata = { .put = tumbler_put_mute_switch, .private_value = TUMBLER_MUTE_HP, }; -static struct snd_kcontrol_new tumbler_speaker_sw __initdata = { +static snd_kcontrol_new_t tumbler_speaker_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PC Speaker Playback Switch", .info = snd_pmac_boolean_mono_info, @@ -888,7 +866,7 @@ static struct snd_kcontrol_new tumbler_speaker_sw __initdata = { .put = tumbler_put_mute_switch, .private_value = TUMBLER_MUTE_AMP, }; -static struct snd_kcontrol_new tumbler_lineout_sw __initdata = { +static snd_kcontrol_new_t tumbler_lineout_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line Out Playback Switch", .info = snd_pmac_boolean_mono_info, @@ -896,7 +874,7 @@ static struct snd_kcontrol_new tumbler_lineout_sw __initdata = { .put = tumbler_put_mute_switch, .private_value = TUMBLER_MUTE_LINE, }; -static struct snd_kcontrol_new tumbler_drc_sw __initdata = { +static snd_kcontrol_new_t tumbler_drc_sw __initdata = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "DRC Switch", .info = snd_pmac_boolean_mono_info, @@ -909,9 +887,9 @@ static struct snd_kcontrol_new tumbler_drc_sw __initdata = { /* * auto-mute stuffs */ -static int tumbler_detect_headphone(struct snd_pmac *chip) +static int tumbler_detect_headphone(pmac_t *chip) { - struct pmac_tumbler *mix = chip->mixer_data; + pmac_tumbler_t *mix = chip->mixer_data; int detect = 0; if (mix->hp_detect.addr) @@ -919,9 +897,9 @@ static int tumbler_detect_headphone(struct snd_pmac *chip) return detect; } -static int tumbler_detect_lineout(struct snd_pmac *chip) +static int tumbler_detect_lineout(pmac_t *chip) { - struct pmac_tumbler *mix = chip->mixer_data; + pmac_tumbler_t *mix = chip->mixer_data; int detect = 0; if (mix->line_detect.addr) @@ -929,8 +907,7 @@ static int tumbler_detect_lineout(struct snd_pmac *chip) return detect; } -static void check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val, int do_notify, - struct snd_kcontrol *sw) +static void check_mute(pmac_t *chip, pmac_gpio_t *gp, int val, int do_notify, snd_kcontrol_t *sw) { if (check_audio_gpio(gp) != val) { write_audio_gpio(gp, val); @@ -944,8 +921,8 @@ static struct work_struct device_change; static void device_change_handler(void *self) { - struct snd_pmac *chip = self; - struct pmac_tumbler *mix; + pmac_t *chip = (pmac_t*) self; + pmac_tumbler_t *mix; int headphone, lineout; if (!chip) @@ -1002,10 +979,10 @@ static void device_change_handler(void *self) tumbler_set_master_volume(mix); } -static void tumbler_update_automute(struct snd_pmac *chip, int do_notify) +static void tumbler_update_automute(pmac_t *chip, int do_notify) { if (chip->auto_mute) { - struct pmac_tumbler *mix; + pmac_tumbler_t *mix; mix = chip->mixer_data; snd_assert(mix, return); mix->auto_mute_notify = do_notify; @@ -1018,7 +995,7 @@ static void tumbler_update_automute(struct snd_pmac *chip, int do_notify) /* interrupt - headphone plug changed */ static irqreturn_t headphone_intr(int irq, void *devid, struct pt_regs *regs) { - struct snd_pmac *chip = devid; + pmac_t *chip = devid; if (chip->update_automute && chip->initialized) { chip->update_automute(chip, 1); return IRQ_HANDLED; @@ -1058,8 +1035,7 @@ static struct device_node *find_compatible_audio_device(const char *name) } /* find an audio device and get its address */ -static long tumbler_find_device(const char *device, const char *platform, - struct pmac_gpio *gp, int is_compatible) +static long tumbler_find_device(const char *device, const char *platform, pmac_gpio_t *gp, int is_compatible) { struct device_node *node; u32 *base, addr; @@ -1125,9 +1101,9 @@ static long tumbler_find_device(const char *device, const char *platform, } /* reset audio */ -static void tumbler_reset_audio(struct snd_pmac *chip) +static void tumbler_reset_audio(pmac_t *chip) { - struct pmac_tumbler *mix = chip->mixer_data; + pmac_tumbler_t *mix = chip->mixer_data; if (mix->anded_reset) { DBG("(I) codec anded reset !\n"); @@ -1154,9 +1130,9 @@ static void tumbler_reset_audio(struct snd_pmac *chip) #ifdef CONFIG_PM /* suspend mixer */ -static void tumbler_suspend(struct snd_pmac *chip) +static void tumbler_suspend(pmac_t *chip) { - struct pmac_tumbler *mix = chip->mixer_data; + pmac_tumbler_t *mix = chip->mixer_data; if (mix->headphone_irq >= 0) disable_irq(mix->headphone_irq); @@ -1184,9 +1160,9 @@ static void tumbler_suspend(struct snd_pmac *chip) } /* resume mixer */ -static void tumbler_resume(struct snd_pmac *chip) +static void tumbler_resume(pmac_t *chip) { - struct pmac_tumbler *mix = chip->mixer_data; + pmac_tumbler_t *mix = chip->mixer_data; snd_assert(mix, return); @@ -1232,10 +1208,10 @@ static void tumbler_resume(struct snd_pmac *chip) #endif /* initialize tumbler */ -static int __init tumbler_init(struct snd_pmac *chip) +static int __init tumbler_init(pmac_t *chip) { int irq; - struct pmac_tumbler *mix = chip->mixer_data; + pmac_tumbler_t *mix = chip->mixer_data; snd_assert(mix, return -EINVAL); if (tumbler_find_device("audio-hw-reset", @@ -1283,9 +1259,9 @@ static int __init tumbler_init(struct snd_pmac *chip) return 0; } -static void tumbler_cleanup(struct snd_pmac *chip) +static void tumbler_cleanup(pmac_t *chip) { - struct pmac_tumbler *mix = chip->mixer_data; + pmac_tumbler_t *mix = chip->mixer_data; if (! mix) return; @@ -1303,10 +1279,10 @@ static void tumbler_cleanup(struct snd_pmac *chip) } /* exported */ -int __init snd_pmac_tumbler_init(struct snd_pmac *chip) +int __init snd_pmac_tumbler_init(pmac_t *chip) { int i, err; - struct pmac_tumbler *mix; + pmac_tumbler_t *mix; u32 *paddr; struct device_node *tas_node, *np; char *chipname; diff --git a/trunk/sound/sparc/Kconfig b/trunk/sound/sparc/Kconfig index 079e22af074c..ef022a846b06 100644 --- a/trunk/sound/sparc/Kconfig +++ b/trunk/sound/sparc/Kconfig @@ -7,6 +7,7 @@ config SND_SUN_AMD7930 tristate "Sun AMD7930" depends on SBUS && SND select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for AMD7930 sound device on Sun. @@ -17,6 +18,7 @@ config SND_SUN_CS4231 tristate "Sun CS4231" depends on SND select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for CS4231 sound device on Sun. @@ -27,6 +29,7 @@ config SND_SUN_DBRI tristate "Sun DBRI" depends on SND && SBUS select SND_PCM + select SND_GENERIC_DRIVER help Say Y here to include support for DBRI sound device on Sun. diff --git a/trunk/sound/sparc/amd7930.c b/trunk/sound/sparc/amd7930.c index 55493340f467..46d504ba7e03 100644 --- a/trunk/sound/sparc/amd7930.c +++ b/trunk/sound/sparc/amd7930.c @@ -311,7 +311,7 @@ struct amd7930_map { #define AMR_PP_PPCR2 0xC8 #define AMR_PP_PPCR3 0xC9 -struct snd_amd7930 { +typedef struct snd_amd7930 { spinlock_t lock; void __iomem *regs; u32 flags; @@ -320,10 +320,10 @@ struct snd_amd7930 { struct amd7930_map map; - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; - struct snd_pcm_substream *capture_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; + snd_pcm_substream_t *capture_substream; /* Playback/Capture buffer state. */ unsigned char *p_orig, *p_cur; @@ -339,12 +339,12 @@ struct snd_amd7930 { unsigned int irq; unsigned int regs_size; struct snd_amd7930 *next; -}; +} amd7930_t; -static struct snd_amd7930 *amd7930_list; +static amd7930_t *amd7930_list; /* Idle the AMD7930 chip. The amd->lock is not held. */ -static __inline__ void amd7930_idle(struct snd_amd7930 *amd) +static __inline__ void amd7930_idle(amd7930_t *amd) { unsigned long flags; @@ -355,7 +355,7 @@ static __inline__ void amd7930_idle(struct snd_amd7930 *amd) } /* Enable chip interrupts. The amd->lock is not held. */ -static __inline__ void amd7930_enable_ints(struct snd_amd7930 *amd) +static __inline__ void amd7930_enable_ints(amd7930_t *amd) { unsigned long flags; @@ -366,7 +366,7 @@ static __inline__ void amd7930_enable_ints(struct snd_amd7930 *amd) } /* Disable chip interrupts. The amd->lock is not held. */ -static __inline__ void amd7930_disable_ints(struct snd_amd7930 *amd) +static __inline__ void amd7930_disable_ints(amd7930_t *amd) { unsigned long flags; @@ -379,7 +379,7 @@ static __inline__ void amd7930_disable_ints(struct snd_amd7930 *amd) /* Commit amd7930_map settings to the hardware. * The amd->lock is held and local interrupts are disabled. */ -static void __amd7930_write_map(struct snd_amd7930 *amd) +static void __amd7930_write_map(amd7930_t *amd) { struct amd7930_map *map = &amd->map; @@ -473,7 +473,7 @@ static __const__ __u16 ger_coeff[] = { /* Update amd7930_map settings and program them into the hardware. * The amd->lock is held and local interrupts are disabled. */ -static void __amd7930_update_map(struct snd_amd7930 *amd) +static void __amd7930_update_map(amd7930_t *amd) { struct amd7930_map *map = &amd->map; int level; @@ -493,7 +493,7 @@ static void __amd7930_update_map(struct snd_amd7930 *amd) static irqreturn_t snd_amd7930_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_amd7930 *amd = dev_id; + amd7930_t *amd = dev_id; unsigned int elapsed; u8 ir; @@ -534,7 +534,7 @@ static irqreturn_t snd_amd7930_interrupt(int irq, void *dev_id, struct pt_regs * return IRQ_HANDLED; } -static int snd_amd7930_trigger(struct snd_amd7930 *amd, unsigned int flag, int cmd) +static int snd_amd7930_trigger(amd7930_t *amd, unsigned int flag, int cmd) { unsigned long flags; int result = 0; @@ -564,24 +564,24 @@ static int snd_amd7930_trigger(struct snd_amd7930 *amd, unsigned int flag, int c return result; } -static int snd_amd7930_playback_trigger(struct snd_pcm_substream *substream, +static int snd_amd7930_playback_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); + amd7930_t *amd = snd_pcm_substream_chip(substream); return snd_amd7930_trigger(amd, AMD7930_FLAG_PLAYBACK, cmd); } -static int snd_amd7930_capture_trigger(struct snd_pcm_substream *substream, +static int snd_amd7930_capture_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); + amd7930_t *amd = snd_pcm_substream_chip(substream); return snd_amd7930_trigger(amd, AMD7930_FLAG_CAPTURE, cmd); } -static int snd_amd7930_playback_prepare(struct snd_pcm_substream *substream) +static int snd_amd7930_playback_prepare(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + amd7930_t *amd = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned long flags; u8 new_mmr1; @@ -610,10 +610,10 @@ static int snd_amd7930_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_amd7930_capture_prepare(struct snd_pcm_substream *substream) +static int snd_amd7930_capture_prepare(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + amd7930_t *amd = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned long flags; u8 new_mmr1; @@ -642,9 +642,9 @@ static int snd_amd7930_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static snd_pcm_uframes_t snd_amd7930_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_amd7930_playback_pointer(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); + amd7930_t *amd = snd_pcm_substream_chip(substream); size_t ptr; if (!(amd->flags & AMD7930_FLAG_PLAYBACK)) @@ -653,9 +653,9 @@ static snd_pcm_uframes_t snd_amd7930_playback_pointer(struct snd_pcm_substream * return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_amd7930_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_amd7930_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); + amd7930_t *amd = snd_pcm_substream_chip(substream); size_t ptr; if (!(amd->flags & AMD7930_FLAG_CAPTURE)) @@ -666,7 +666,7 @@ static snd_pcm_uframes_t snd_amd7930_capture_pointer(struct snd_pcm_substream *s } /* Playback and capture have identical properties. */ -static struct snd_pcm_hardware snd_amd7930_pcm_hw = +static snd_pcm_hardware_t snd_amd7930_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -686,54 +686,54 @@ static struct snd_pcm_hardware snd_amd7930_pcm_hw = .periods_max = 1024, }; -static int snd_amd7930_playback_open(struct snd_pcm_substream *substream) +static int snd_amd7930_playback_open(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + amd7930_t *amd = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; amd->playback_substream = substream; runtime->hw = snd_amd7930_pcm_hw; return 0; } -static int snd_amd7930_capture_open(struct snd_pcm_substream *substream) +static int snd_amd7930_capture_open(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + amd7930_t *amd = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; amd->capture_substream = substream; runtime->hw = snd_amd7930_pcm_hw; return 0; } -static int snd_amd7930_playback_close(struct snd_pcm_substream *substream) +static int snd_amd7930_playback_close(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); + amd7930_t *amd = snd_pcm_substream_chip(substream); amd->playback_substream = NULL; return 0; } -static int snd_amd7930_capture_close(struct snd_pcm_substream *substream) +static int snd_amd7930_capture_close(snd_pcm_substream_t * substream) { - struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); + amd7930_t *amd = snd_pcm_substream_chip(substream); amd->capture_substream = NULL; return 0; } -static int snd_amd7930_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_amd7930_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); } -static int snd_amd7930_hw_free(struct snd_pcm_substream *substream) +static int snd_amd7930_hw_free(snd_pcm_substream_t * substream) { return snd_pcm_lib_free_pages(substream); } -static struct snd_pcm_ops snd_amd7930_playback_ops = { +static snd_pcm_ops_t snd_amd7930_playback_ops = { .open = snd_amd7930_playback_open, .close = snd_amd7930_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -744,7 +744,7 @@ static struct snd_pcm_ops snd_amd7930_playback_ops = { .pointer = snd_amd7930_playback_pointer, }; -static struct snd_pcm_ops snd_amd7930_capture_ops = { +static snd_pcm_ops_t snd_amd7930_capture_ops = { .open = snd_amd7930_capture_open, .close = snd_amd7930_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -755,9 +755,17 @@ static struct snd_pcm_ops snd_amd7930_capture_ops = { .pointer = snd_amd7930_capture_pointer, }; -static int __init snd_amd7930_pcm(struct snd_amd7930 *amd) +static void snd_amd7930_pcm_free(snd_pcm_t *pcm) { - struct snd_pcm *pcm; + amd7930_t *amd = pcm->private_data; + + amd->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +static int __init snd_amd7930_pcm(amd7930_t *amd) +{ + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(amd->card, @@ -772,6 +780,7 @@ static int __init snd_amd7930_pcm(struct snd_amd7930 *amd) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_amd7930_capture_ops); pcm->private_data = amd; + pcm->private_free = snd_amd7930_pcm_free; pcm->info_flags = 0; strcpy(pcm->name, amd->card->shortname); amd->pcm = pcm; @@ -787,7 +796,7 @@ static int __init snd_amd7930_pcm(struct snd_amd7930 *amd) #define VOLUME_CAPTURE 1 #define VOLUME_PLAYBACK 2 -static int snd_amd7930_info_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) +static int snd_amd7930_info_volume(snd_kcontrol_t *kctl, snd_ctl_elem_info_t *uinfo) { int type = kctl->private_value; @@ -804,9 +813,9 @@ static int snd_amd7930_info_volume(struct snd_kcontrol *kctl, struct snd_ctl_ele return 0; } -static int snd_amd7930_get_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) +static int snd_amd7930_get_volume(snd_kcontrol_t *kctl, snd_ctl_elem_value_t *ucontrol) { - struct snd_amd7930 *amd = snd_kcontrol_chip(kctl); + amd7930_t *amd = snd_kcontrol_chip(kctl); int type = kctl->private_value; int *swval; @@ -832,9 +841,9 @@ static int snd_amd7930_get_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem return 0; } -static int snd_amd7930_put_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) +static int snd_amd7930_put_volume(snd_kcontrol_t *kctl, snd_ctl_elem_value_t *ucontrol) { - struct snd_amd7930 *amd = snd_kcontrol_chip(kctl); + amd7930_t *amd = snd_kcontrol_chip(kctl); unsigned long flags; int type = kctl->private_value; int *swval, change; @@ -870,7 +879,7 @@ static int snd_amd7930_put_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem return change; } -static struct snd_kcontrol_new amd7930_controls[] __initdata = { +static snd_kcontrol_new_t amd7930_controls[] __initdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitor Volume", @@ -900,9 +909,9 @@ static struct snd_kcontrol_new amd7930_controls[] __initdata = { }, }; -static int __init snd_amd7930_mixer(struct snd_amd7930 *amd) +static int __init snd_amd7930_mixer(amd7930_t *amd) { - struct snd_card *card; + snd_card_t *card; int idx, err; snd_assert(amd != NULL && amd->card != NULL, return -EINVAL); @@ -919,7 +928,7 @@ static int __init snd_amd7930_mixer(struct snd_amd7930 *amd) return 0; } -static int snd_amd7930_free(struct snd_amd7930 *amd) +static int snd_amd7930_free(amd7930_t *amd) { amd7930_idle(amd); @@ -934,27 +943,27 @@ static int snd_amd7930_free(struct snd_amd7930 *amd) return 0; } -static int snd_amd7930_dev_free(struct snd_device *device) +static int snd_amd7930_dev_free(snd_device_t *device) { - struct snd_amd7930 *amd = device->device_data; + amd7930_t *amd = device->device_data; return snd_amd7930_free(amd); } -static struct snd_device_ops snd_amd7930_dev_ops = { +static snd_device_ops_t snd_amd7930_dev_ops = { .dev_free = snd_amd7930_dev_free, }; -static int __init snd_amd7930_create(struct snd_card *card, +static int __init snd_amd7930_create(snd_card_t *card, struct sbus_dev *sdev, struct resource *rp, unsigned int reg_size, struct linux_prom_irqs *irq_prop, int dev, - struct snd_amd7930 **ramd) + amd7930_t **ramd) { unsigned long flags; - struct snd_amd7930 *amd; + amd7930_t *amd; int err; *ramd = NULL; @@ -1023,8 +1032,8 @@ static int __init amd7930_attach(int prom_node, struct sbus_dev *sdev) struct linux_prom_registers reg_prop; struct linux_prom_irqs irq_prop; struct resource res, *rp; - struct snd_card *card; - struct snd_amd7930 *amd; + snd_card_t *card; + amd7930_t *amd; int err; if (dev >= SNDRV_CARDS) @@ -1079,6 +1088,9 @@ static int __init amd7930_attach(int prom_node, struct sbus_dev *sdev) if ((err = snd_amd7930_mixer(amd)) < 0) goto out_err; + if ((err = snd_card_set_generic_dev(card)) < 0) + goto out_err; + if ((err = snd_card_register(card)) < 0) goto out_err; @@ -1120,10 +1132,10 @@ static int __init amd7930_init(void) static void __exit amd7930_exit(void) { - struct snd_amd7930 *p = amd7930_list; + amd7930_t *p = amd7930_list; while (p != NULL) { - struct snd_amd7930 *next = p->next; + amd7930_t *next = p->next; snd_card_free(p->card); diff --git a/trunk/sound/sparc/cs4231.c b/trunk/sound/sparc/cs4231.c index e9086e95a31f..1f8d27a6152e 100644 --- a/trunk/sound/sparc/cs4231.c +++ b/trunk/sound/sparc/cs4231.c @@ -62,47 +62,49 @@ MODULE_LICENSE("GPL"); MODULE_SUPPORTED_DEVICE("{{Sun,CS4231}}"); #ifdef SBUS_SUPPORT -struct sbus_dma_info { +typedef struct sbus_dma_info { spinlock_t lock; int dir; void __iomem *regs; -}; +} sbus_dma_info_t; #endif -struct cs4231_dma_control { +typedef struct snd_cs4231 cs4231_t; + +typedef struct cs4231_dma_control { void (*prepare)(struct cs4231_dma_control *dma_cont, int dir); void (*enable)(struct cs4231_dma_control *dma_cont, int on); int (*request)(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len); unsigned int (*address)(struct cs4231_dma_control *dma_cont); - void (*reset)(struct snd_cs4231 *chip); - void (*preallocate)(struct snd_cs4231 *chip, struct snd_snd_pcm *pcm); + void (*reset)(cs4231_t *chip); + void (*preallocate)(cs4231_t *chip, snd_pcm_t *pcm); #ifdef EBUS_SUPPORT struct ebus_dma_info ebus_info; #endif #ifdef SBUS_SUPPORT struct sbus_dma_info sbus_info; #endif -}; +} cs4231_dma_control_t; struct snd_cs4231 { spinlock_t lock; void __iomem *port; - struct cs4231_dma_control p_dma; - struct cs4231_dma_control c_dma; + cs4231_dma_control_t p_dma; + cs4231_dma_control_t c_dma; u32 flags; #define CS4231_FLAG_EBUS 0x00000001 #define CS4231_FLAG_PLAYBACK 0x00000002 #define CS4231_FLAG_CAPTURE 0x00000004 - struct snd_card *card; - struct snd_pcm *pcm; - struct snd_pcm_substream *playback_substream; + snd_card_t *card; + snd_pcm_t *pcm; + snd_pcm_substream_t *playback_substream; unsigned int p_periods_sent; - struct snd_pcm_substream *capture_substream; + snd_pcm_substream_t *capture_substream; unsigned int c_periods_sent; - struct snd_timer *timer; + snd_timer_t *timer; unsigned short mode; #define CS4231_MODE_NONE 0x0000 @@ -130,7 +132,7 @@ struct snd_cs4231 { struct snd_cs4231 *next; }; -static struct snd_cs4231 *cs4231_list; +static cs4231_t *cs4231_list; /* Eventually we can use sound/isa/cs423x/cs4231_lib.c directly, but for * now.... -DaveM @@ -339,12 +341,12 @@ static unsigned int rates[14] = { 27042, 32000, 33075, 37800, 44100, 48000 }; -static struct snd_pcm_hw_constraint_list hw_constraints_rates = { +static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = 14, .list = rates, }; -static int snd_cs4231_xrate(struct snd_pcm_runtime *runtime) +static int snd_cs4231_xrate(snd_pcm_runtime_t *runtime) { return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, @@ -387,7 +389,7 @@ static unsigned char snd_cs4231_original_image[32] = 0x00, /* 1f/31 - cbrl */ }; -static u8 __cs4231_readb(struct snd_cs4231 *cp, void __iomem *reg_addr) +static u8 __cs4231_readb(cs4231_t *cp, void __iomem *reg_addr) { #ifdef EBUS_SUPPORT if (cp->flags & CS4231_FLAG_EBUS) { @@ -402,7 +404,7 @@ static u8 __cs4231_readb(struct snd_cs4231 *cp, void __iomem *reg_addr) #endif } -static void __cs4231_writeb(struct snd_cs4231 *cp, u8 val, void __iomem *reg_addr) +static void __cs4231_writeb(cs4231_t *cp, u8 val, void __iomem *reg_addr) { #ifdef EBUS_SUPPORT if (cp->flags & CS4231_FLAG_EBUS) { @@ -421,7 +423,7 @@ static void __cs4231_writeb(struct snd_cs4231 *cp, u8 val, void __iomem *reg_add * Basic I/O functions */ -static void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg, +static void snd_cs4231_outm(cs4231_t *chip, unsigned char reg, unsigned char mask, unsigned char value) { int timeout; @@ -448,7 +450,7 @@ static void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg, } } -static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg, unsigned char value) +static void snd_cs4231_dout(cs4231_t *chip, unsigned char reg, unsigned char value) { int timeout; @@ -465,7 +467,7 @@ static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg, unsigned mb(); } -static void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char value) +static void snd_cs4231_out(cs4231_t *chip, unsigned char reg, unsigned char value) { int timeout; @@ -483,7 +485,7 @@ static void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg, unsigned mb(); } -static unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg) +static unsigned char snd_cs4231_in(cs4231_t *chip, unsigned char reg) { int timeout; unsigned char ret; @@ -506,7 +508,7 @@ static unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg) * CS4231 detection / MCE routines */ -static void snd_cs4231_busy_wait(struct snd_cs4231 *chip) +static void snd_cs4231_busy_wait(cs4231_t *chip) { int timeout; @@ -521,7 +523,7 @@ static void snd_cs4231_busy_wait(struct snd_cs4231 *chip) udelay(1000); } -static void snd_cs4231_mce_up(struct snd_cs4231 *chip) +static void snd_cs4231_mce_up(cs4231_t *chip) { unsigned long flags; int timeout; @@ -542,7 +544,7 @@ static void snd_cs4231_mce_up(struct snd_cs4231 *chip) spin_unlock_irqrestore(&chip->lock, flags); } -static void snd_cs4231_mce_down(struct snd_cs4231 *chip) +static void snd_cs4231_mce_down(cs4231_t *chip) { unsigned long flags; int timeout; @@ -600,11 +602,9 @@ static void snd_cs4231_mce_down(struct snd_cs4231 *chip) spin_unlock_irqrestore(&chip->lock, flags); } -static void snd_cs4231_advance_dma(struct cs4231_dma_control *dma_cont, - struct snd_pcm_substream *substream, - unsigned int *periods_sent) +static void snd_cs4231_advance_dma(struct cs4231_dma_control *dma_cont, snd_pcm_substream_t *substream, unsigned int *periods_sent) { - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; while (1) { unsigned int period_size = snd_pcm_lib_period_bytes(substream); @@ -619,11 +619,10 @@ static void snd_cs4231_advance_dma(struct cs4231_dma_control *dma_cont, } } -static void cs4231_dma_trigger(struct snd_pcm_substream *substream, - unsigned int what, int on) +static void cs4231_dma_trigger(snd_pcm_substream_t *substream, unsigned int what, int on) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct cs4231_dma_control *dma_cont; + cs4231_t *chip = snd_pcm_substream_chip(substream); + cs4231_dma_control_t *dma_cont; if (what & CS4231_PLAYBACK_ENABLE) { dma_cont = &chip->p_dma; @@ -651,9 +650,9 @@ static void cs4231_dma_trigger(struct snd_pcm_substream *substream, } } -static int snd_cs4231_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_cs4231_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); int result = 0; switch (cmd) { @@ -661,7 +660,7 @@ static int snd_cs4231_trigger(struct snd_pcm_substream *substream, int cmd) case SNDRV_PCM_TRIGGER_STOP: { unsigned int what = 0; - struct snd_pcm_substream *s; + snd_pcm_substream_t *s; struct list_head *pos; unsigned long flags; @@ -712,7 +711,7 @@ static unsigned char snd_cs4231_get_rate(unsigned int rate) return freq_bits[13]; } -static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip, int format, int channels) +static unsigned char snd_cs4231_get_format(cs4231_t *chip, int format, int channels) { unsigned char rformat; @@ -729,7 +728,7 @@ static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip, int format, return rformat; } -static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute) +static void snd_cs4231_calibrate_mute(cs4231_t *chip, int mute) { unsigned long flags; @@ -769,7 +768,7 @@ static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute) spin_unlock_irqrestore(&chip->lock, flags); } -static void snd_cs4231_playback_format(struct snd_cs4231 *chip, struct snd_pcm_hw_params *params, +static void snd_cs4231_playback_format(cs4231_t *chip, snd_pcm_hw_params_t *params, unsigned char pdfr) { unsigned long flags; @@ -792,7 +791,7 @@ static void snd_cs4231_playback_format(struct snd_cs4231 *chip, struct snd_pcm_h up(&chip->mce_mutex); } -static void snd_cs4231_capture_format(struct snd_cs4231 *chip, struct snd_pcm_hw_params *params, +static void snd_cs4231_capture_format(cs4231_t *chip, snd_pcm_hw_params_t *params, unsigned char cdfr) { unsigned long flags; @@ -825,18 +824,18 @@ static void snd_cs4231_capture_format(struct snd_cs4231 *chip, struct snd_pcm_hw * Timer interface */ -static unsigned long snd_cs4231_timer_resolution(struct snd_timer *timer) +static unsigned long snd_cs4231_timer_resolution(snd_timer_t *timer) { - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920; } -static int snd_cs4231_timer_start(struct snd_timer *timer) +static int snd_cs4231_timer_start(snd_timer_t *timer) { unsigned long flags; unsigned int ticks; - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->lock, flags); ticks = timer->sticks; @@ -857,10 +856,10 @@ static int snd_cs4231_timer_start(struct snd_timer *timer) return 0; } -static int snd_cs4231_timer_stop(struct snd_timer *timer) +static int snd_cs4231_timer_stop(snd_timer_t *timer) { unsigned long flags; - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, @@ -870,7 +869,7 @@ static int snd_cs4231_timer_stop(struct snd_timer *timer) return 0; } -static void __init snd_cs4231_init(struct snd_cs4231 *chip) +static void snd_cs4231_init(cs4231_t *chip) { unsigned long flags; @@ -928,7 +927,7 @@ static void __init snd_cs4231_init(struct snd_cs4231 *chip) #endif } -static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode) +static int snd_cs4231_open(cs4231_t *chip, unsigned int mode) { unsigned long flags; @@ -963,7 +962,7 @@ static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode) return 0; } -static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode) +static void snd_cs4231_close(cs4231_t *chip, unsigned int mode) { unsigned long flags; @@ -1014,21 +1013,21 @@ static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode) * timer open/close */ -static int snd_cs4231_timer_open(struct snd_timer *timer) +static int snd_cs4231_timer_open(snd_timer_t *timer) { - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); snd_cs4231_open(chip, CS4231_MODE_TIMER); return 0; } -static int snd_cs4231_timer_close(struct snd_timer * timer) +static int snd_cs4231_timer_close(snd_timer_t * timer) { - struct snd_cs4231 *chip = snd_timer_chip(timer); + cs4231_t *chip = snd_timer_chip(timer); snd_cs4231_close(chip, CS4231_MODE_TIMER); return 0; } -static struct snd_timer_hardware snd_cs4231_timer_table = +static struct _snd_timer_hardware snd_cs4231_timer_table = { .flags = SNDRV_TIMER_HW_AUTO, .resolution = 9945, @@ -1044,10 +1043,10 @@ static struct snd_timer_hardware snd_cs4231_timer_table = * ok.. exported functions.. */ -static int snd_cs4231_playback_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cs4231_playback_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); unsigned char new_pdfr; int err; @@ -1062,15 +1061,15 @@ static int snd_cs4231_playback_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_cs4231_playback_hw_free(struct snd_pcm_substream *substream) +static int snd_cs4231_playback_hw_free(snd_pcm_substream_t *substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_cs4231_playback_prepare(struct snd_pcm_substream *substream) +static int snd_cs4231_playback_prepare(snd_pcm_substream_t *substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs4231_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; unsigned long flags; spin_lock_irqsave(&chip->lock, flags); @@ -1087,10 +1086,10 @@ static int snd_cs4231_playback_prepare(struct snd_pcm_substream *substream) return 0; } -static int snd_cs4231_capture_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_cs4231_capture_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); unsigned char new_cdfr; int err; @@ -1105,14 +1104,14 @@ static int snd_cs4231_capture_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_cs4231_capture_hw_free(struct snd_pcm_substream *substream) +static int snd_cs4231_capture_hw_free(snd_pcm_substream_t *substream) { return snd_pcm_lib_free_pages(substream); } -static int snd_cs4231_capture_prepare(struct snd_pcm_substream *substream) +static int snd_cs4231_capture_prepare(snd_pcm_substream_t *substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); unsigned long flags; spin_lock_irqsave(&chip->lock, flags); @@ -1126,7 +1125,7 @@ static int snd_cs4231_capture_prepare(struct snd_pcm_substream *substream) return 0; } -static void snd_cs4231_overrange(struct snd_cs4231 *chip) +static void snd_cs4231_overrange(cs4231_t *chip) { unsigned long flags; unsigned char res; @@ -1139,8 +1138,10 @@ static void snd_cs4231_overrange(struct snd_cs4231 *chip) chip->capture_substream->runtime->overrange++; } -static void snd_cs4231_play_callback(struct snd_cs4231 *chip) +static void snd_cs4231_play_callback(cs4231_t *cookie) { + cs4231_t *chip = cookie; + if (chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE) { snd_pcm_period_elapsed(chip->playback_substream); snd_cs4231_advance_dma(&chip->p_dma, chip->playback_substream, @@ -1148,8 +1149,10 @@ static void snd_cs4231_play_callback(struct snd_cs4231 *chip) } } -static void snd_cs4231_capture_callback(struct snd_cs4231 *chip) +static void snd_cs4231_capture_callback(cs4231_t *cookie) { + cs4231_t *chip = cookie; + if (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) { snd_pcm_period_elapsed(chip->capture_substream); snd_cs4231_advance_dma(&chip->c_dma, chip->capture_substream, @@ -1157,10 +1160,10 @@ static void snd_cs4231_capture_callback(struct snd_cs4231 *chip) } } -static snd_pcm_uframes_t snd_cs4231_playback_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs4231_playback_pointer(snd_pcm_substream_t *substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct cs4231_dma_control *dma_cont = &chip->p_dma; + cs4231_t *chip = snd_pcm_substream_chip(substream); + cs4231_dma_control_t *dma_cont = &chip->p_dma; size_t ptr; if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) @@ -1172,10 +1175,10 @@ static snd_pcm_uframes_t snd_cs4231_playback_pointer(struct snd_pcm_substream *s return bytes_to_frames(substream->runtime, ptr); } -static snd_pcm_uframes_t snd_cs4231_capture_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_cs4231_capture_pointer(snd_pcm_substream_t * substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct cs4231_dma_control *dma_cont = &chip->c_dma; + cs4231_t *chip = snd_pcm_substream_chip(substream); + cs4231_dma_control_t *dma_cont = &chip->c_dma; size_t ptr; if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE)) @@ -1191,7 +1194,7 @@ static snd_pcm_uframes_t snd_cs4231_capture_pointer(struct snd_pcm_substream *su */ -static int __init snd_cs4231_probe(struct snd_cs4231 *chip) +static int snd_cs4231_probe(cs4231_t *chip) { unsigned long flags; int i, id, vers; @@ -1256,7 +1259,7 @@ static int __init snd_cs4231_probe(struct snd_cs4231 *chip) return 0; /* all things are ok.. */ } -static struct snd_pcm_hardware snd_cs4231_playback = +static snd_pcm_hardware_t snd_cs4231_playback = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), @@ -1276,7 +1279,7 @@ static struct snd_pcm_hardware snd_cs4231_playback = .periods_max = 1024, }; -static struct snd_pcm_hardware snd_cs4231_capture = +static snd_pcm_hardware_t snd_cs4231_capture = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), @@ -1296,10 +1299,10 @@ static struct snd_pcm_hardware snd_cs4231_capture = .periods_max = 1024, }; -static int snd_cs4231_playback_open(struct snd_pcm_substream *substream) +static int snd_cs4231_playback_open(snd_pcm_substream_t *substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs4231_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; runtime->hw = snd_cs4231_playback; @@ -1316,10 +1319,10 @@ static int snd_cs4231_playback_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cs4231_capture_open(struct snd_pcm_substream *substream) +static int snd_cs4231_capture_open(snd_pcm_substream_t *substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; + cs4231_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; int err; runtime->hw = snd_cs4231_capture; @@ -1336,9 +1339,9 @@ static int snd_cs4231_capture_open(struct snd_pcm_substream *substream) return 0; } -static int snd_cs4231_playback_close(struct snd_pcm_substream *substream) +static int snd_cs4231_playback_close(snd_pcm_substream_t *substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); snd_cs4231_close(chip, CS4231_MODE_PLAY); chip->playback_substream = NULL; @@ -1346,9 +1349,9 @@ static int snd_cs4231_playback_close(struct snd_pcm_substream *substream) return 0; } -static int snd_cs4231_capture_close(struct snd_pcm_substream *substream) +static int snd_cs4231_capture_close(snd_pcm_substream_t *substream) { - struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); + cs4231_t *chip = snd_pcm_substream_chip(substream); snd_cs4231_close(chip, CS4231_MODE_RECORD); chip->capture_substream = NULL; @@ -1360,7 +1363,7 @@ static int snd_cs4231_capture_close(struct snd_pcm_substream *substream) * XXX the audio AUXIO register... */ -static struct snd_pcm_ops snd_cs4231_playback_ops = { +static snd_pcm_ops_t snd_cs4231_playback_ops = { .open = snd_cs4231_playback_open, .close = snd_cs4231_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1371,7 +1374,7 @@ static struct snd_pcm_ops snd_cs4231_playback_ops = { .pointer = snd_cs4231_playback_pointer, }; -static struct snd_pcm_ops snd_cs4231_capture_ops = { +static snd_pcm_ops_t snd_cs4231_capture_ops = { .open = snd_cs4231_capture_open, .close = snd_cs4231_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1382,9 +1385,16 @@ static struct snd_pcm_ops snd_cs4231_capture_ops = { .pointer = snd_cs4231_capture_pointer, }; -static int __init snd_cs4231_pcm(struct snd_cs4231 *chip) +static void snd_cs4231_pcm_free(snd_pcm_t *pcm) +{ + cs4231_t *chip = pcm->private_data; + chip->pcm = NULL; + snd_pcm_lib_preallocate_free_for_all(pcm); +} + +int snd_cs4231_pcm(cs4231_t *chip) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(chip->card, "CS4231", 0, 1, 1, &pcm)) < 0) @@ -1395,6 +1405,7 @@ static int __init snd_cs4231_pcm(struct snd_cs4231 *chip) /* global setup */ pcm->private_data = chip; + pcm->private_free = snd_cs4231_pcm_free; pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; strcpy(pcm->name, "CS4231"); @@ -1405,10 +1416,16 @@ static int __init snd_cs4231_pcm(struct snd_cs4231 *chip) return 0; } -static int __init snd_cs4231_timer(struct snd_cs4231 *chip) +static void snd_cs4231_timer_free(snd_timer_t *timer) +{ + cs4231_t *chip = timer->private_data; + chip->timer = NULL; +} + +int snd_cs4231_timer(cs4231_t *chip) { - struct snd_timer *timer; - struct snd_timer_id tid; + snd_timer_t *timer; + snd_timer_id_t tid; int err; /* Timer initialization */ @@ -1421,6 +1438,7 @@ static int __init snd_cs4231_timer(struct snd_cs4231 *chip) return err; strcpy(timer->name, "CS4231"); timer->private_data = chip; + timer->private_free = snd_cs4231_timer_free; timer->hw = snd_cs4231_timer_table; chip->timer = timer; @@ -1431,13 +1449,12 @@ static int __init snd_cs4231_timer(struct snd_cs4231 *chip) * MIXER part */ -static int snd_cs4231_info_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs4231_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { static char *texts[4] = { "Line", "CD", "Mic", "Mix" }; - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); snd_assert(chip->card != NULL, return -EINVAL); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -1450,10 +1467,9 @@ static int snd_cs4231_info_mux(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4231_get_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4231_get_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->lock, flags); @@ -1466,10 +1482,9 @@ static int snd_cs4231_get_mux(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4231_put_mux(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4231_put_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned short left, right; int change; @@ -1494,8 +1509,7 @@ static int snd_cs4231_put_mux(struct snd_kcontrol *kcontrol, return change; } -static int snd_cs4231_info_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +int snd_cs4231_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -1508,10 +1522,9 @@ static int snd_cs4231_info_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4231_get_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_get_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1531,10 +1544,9 @@ static int snd_cs4231_get_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_put_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -1559,8 +1571,7 @@ static int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, return change; } -static int snd_cs4231_info_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +int snd_cs4231_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; @@ -1573,10 +1584,9 @@ static int snd_cs4231_info_double(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4231_get_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_get_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1602,10 +1612,9 @@ static int snd_cs4231_get_double(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4231_put_double(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +int snd_cs4231_put_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); + cs4231_t *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; @@ -1650,7 +1659,7 @@ static int snd_cs4231_put_double(struct snd_kcontrol *kcontrol, .get = snd_cs4231_get_double, .put = snd_cs4231_put_double, \ .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } -static struct snd_kcontrol_new snd_cs4231_controls[] __initdata = { +static snd_kcontrol_new_t snd_cs4231_controls[] = { CS4231_DOUBLE("PCM Playback Switch", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1), CS4231_DOUBLE("PCM Playback Volume", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1), CS4231_DOUBLE("Line Playback Switch", 0, CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1), @@ -1679,9 +1688,9 @@ CS4231_SINGLE("Line Out Switch", 0, CS4231_PIN_CTRL, 6, 1, 1), CS4231_SINGLE("Headphone Out Switch", 0, CS4231_PIN_CTRL, 7, 1, 1) }; -static int __init snd_cs4231_mixer(struct snd_cs4231 *chip) +int snd_cs4231_mixer(cs4231_t *chip) { - struct snd_card *card; + snd_card_t *card; int err, idx; snd_assert(chip != NULL && chip->pcm != NULL, return -EINVAL); @@ -1701,9 +1710,9 @@ static int __init snd_cs4231_mixer(struct snd_cs4231 *chip) static int dev; -static int __init cs4231_attach_begin(struct snd_card **rcard) +static int cs4231_attach_begin(snd_card_t **rcard) { - struct snd_card *card; + snd_card_t *card; *rcard = NULL; @@ -1726,7 +1735,7 @@ static int __init cs4231_attach_begin(struct snd_card **rcard) return 0; } -static int __init cs4231_attach_finish(struct snd_card *card, struct snd_cs4231 *chip) +static int cs4231_attach_finish(snd_card_t *card, cs4231_t *chip) { int err; @@ -1739,6 +1748,9 @@ static int __init cs4231_attach_finish(struct snd_card *card, struct snd_cs4231 if ((err = snd_cs4231_timer(chip)) < 0) goto out_err; + if ((err = snd_card_set_generic_dev(card)) < 0) + goto out_err; + if ((err = snd_card_register(card)) < 0) goto out_err; @@ -1760,7 +1772,7 @@ static irqreturn_t snd_cs4231_sbus_interrupt(int irq, void *dev_id, struct pt_re unsigned long flags; unsigned char status; u32 csr; - struct snd_cs4231 *chip = dev_id; + cs4231_t *chip = dev_id; /*This is IRQ is not raised by the cs4231*/ if (!(__cs4231_readb(chip, CS4231P(chip, STATUS)) & CS4231_GLOBALIRQ)) @@ -1805,12 +1817,12 @@ static irqreturn_t snd_cs4231_sbus_interrupt(int irq, void *dev_id, struct pt_re * SBUS DMA routines */ -static int sbus_dma_request(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len) +int sbus_dma_request(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len) { unsigned long flags; u32 test, csr; int err; - struct sbus_dma_info *base = &dma_cont->sbus_info; + sbus_dma_info_t *base = &dma_cont->sbus_info; if (len >= (1 << 24)) return -EINVAL; @@ -1837,11 +1849,11 @@ static int sbus_dma_request(struct cs4231_dma_control *dma_cont, dma_addr_t bus_ return err; } -static void sbus_dma_prepare(struct cs4231_dma_control *dma_cont, int d) +void sbus_dma_prepare(struct cs4231_dma_control *dma_cont, int d) { unsigned long flags; u32 csr, test; - struct sbus_dma_info *base = &dma_cont->sbus_info; + sbus_dma_info_t *base = &dma_cont->sbus_info; spin_lock_irqsave(&base->lock, flags); csr = sbus_readl(base->regs + APCCSR); @@ -1856,11 +1868,11 @@ static void sbus_dma_prepare(struct cs4231_dma_control *dma_cont, int d) spin_unlock_irqrestore(&base->lock, flags); } -static void sbus_dma_enable(struct cs4231_dma_control *dma_cont, int on) +void sbus_dma_enable(struct cs4231_dma_control *dma_cont, int on) { unsigned long flags; u32 csr, shift; - struct sbus_dma_info *base = &dma_cont->sbus_info; + sbus_dma_info_t *base = &dma_cont->sbus_info; spin_lock_irqsave(&base->lock, flags); if (!on) { @@ -1893,14 +1905,14 @@ static void sbus_dma_enable(struct cs4231_dma_control *dma_cont, int on) spin_unlock_irqrestore(&base->lock, flags); } -static unsigned int sbus_dma_addr(struct cs4231_dma_control *dma_cont) +unsigned int sbus_dma_addr(struct cs4231_dma_control *dma_cont) { - struct sbus_dma_info *base = &dma_cont->sbus_info; + sbus_dma_info_t *base = &dma_cont->sbus_info; return sbus_readl(base->regs + base->dir + APCVA); } -static void sbus_dma_reset(struct snd_cs4231 *chip) +void sbus_dma_reset(cs4231_t *chip) { sbus_writel(APC_CHIP_RESET, chip->port + APCCSR); sbus_writel(0x00, chip->port + APCCSR); @@ -1917,7 +1929,7 @@ static void sbus_dma_reset(struct snd_cs4231 *chip) chip->port + APCCSR); } -static void sbus_dma_preallocate(struct snd_cs4231 *chip, struct snd_pcm *pcm) +void sbus_dma_preallocate(cs4231_t *chip, snd_pcm_t *pcm) { snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_SBUS, snd_dma_sbus_data(chip->dev_u.sdev), @@ -1928,7 +1940,7 @@ static void sbus_dma_preallocate(struct snd_cs4231 *chip, struct snd_pcm *pcm) * Init and exit routines */ -static int snd_cs4231_sbus_free(struct snd_cs4231 *chip) +static int snd_cs4231_sbus_free(cs4231_t *chip) { if (chip->irq[0]) free_irq(chip->irq[0], chip); @@ -1936,28 +1948,31 @@ static int snd_cs4231_sbus_free(struct snd_cs4231 *chip) if (chip->port) sbus_iounmap(chip->port, chip->regs_size); + if (chip->timer) + snd_device_free(chip->card, chip->timer); + kfree(chip); return 0; } -static int snd_cs4231_sbus_dev_free(struct snd_device *device) +static int snd_cs4231_sbus_dev_free(snd_device_t *device) { - struct snd_cs4231 *cp = device->device_data; + cs4231_t *cp = device->device_data; return snd_cs4231_sbus_free(cp); } -static struct snd_device_ops snd_cs4231_sbus_dev_ops = { +static snd_device_ops_t snd_cs4231_sbus_dev_ops = { .dev_free = snd_cs4231_sbus_dev_free, }; -static int __init snd_cs4231_sbus_create(struct snd_card *card, +static int __init snd_cs4231_sbus_create(snd_card_t *card, struct sbus_dev *sdev, int dev, - struct snd_cs4231 **rchip) + cs4231_t **rchip) { - struct snd_cs4231 *chip; + cs4231_t *chip; int err; *rchip = NULL; @@ -2028,11 +2043,11 @@ static int __init snd_cs4231_sbus_create(struct snd_card *card, return 0; } -static int __init cs4231_sbus_attach(struct sbus_dev *sdev) +static int cs4231_sbus_attach(struct sbus_dev *sdev) { struct resource *rp = &sdev->resource[0]; - struct snd_cs4231 *cp; - struct snd_card *card; + cs4231_t *cp; + snd_card_t *card; int err; err = cs4231_attach_begin(&card); @@ -2058,14 +2073,14 @@ static int __init cs4231_sbus_attach(struct sbus_dev *sdev) static void snd_cs4231_ebus_play_callback(struct ebus_dma_info *p, int event, void *cookie) { - struct snd_cs4231 *chip = cookie; + cs4231_t *chip = cookie; snd_cs4231_play_callback(chip); } static void snd_cs4231_ebus_capture_callback(struct ebus_dma_info *p, int event, void *cookie) { - struct snd_cs4231 *chip = cookie; + cs4231_t *chip = cookie; snd_cs4231_capture_callback(chip); } @@ -2074,32 +2089,32 @@ static void snd_cs4231_ebus_capture_callback(struct ebus_dma_info *p, int event, * EBUS DMA wrappers */ -static int _ebus_dma_request(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len) +int _ebus_dma_request(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len) { return ebus_dma_request(&dma_cont->ebus_info, bus_addr, len); } -static void _ebus_dma_enable(struct cs4231_dma_control *dma_cont, int on) +void _ebus_dma_enable(struct cs4231_dma_control *dma_cont, int on) { ebus_dma_enable(&dma_cont->ebus_info, on); } -static void _ebus_dma_prepare(struct cs4231_dma_control *dma_cont, int dir) +void _ebus_dma_prepare(struct cs4231_dma_control *dma_cont, int dir) { ebus_dma_prepare(&dma_cont->ebus_info, dir); } -static unsigned int _ebus_dma_addr(struct cs4231_dma_control *dma_cont) +unsigned int _ebus_dma_addr(struct cs4231_dma_control *dma_cont) { return ebus_dma_addr(&dma_cont->ebus_info); } -static void _ebus_dma_reset(struct snd_cs4231 *chip) +void _ebus_dma_reset(cs4231_t *chip) { return; } -static void _ebus_dma_preallocate(struct snd_cs4231 *chip, struct snd_pcm *pcm) +void _ebus_dma_preallocate(cs4231_t *chip, snd_pcm_t *pcm) { snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->dev_u.pdev), @@ -2110,7 +2125,7 @@ static void _ebus_dma_preallocate(struct snd_cs4231 *chip, struct snd_pcm *pcm) * Init and exit routines */ -static int snd_cs4231_ebus_free(struct snd_cs4231 *chip) +static int snd_cs4231_ebus_free(cs4231_t *chip) { if (chip->c_dma.ebus_info.regs) { ebus_dma_unregister(&chip->c_dma.ebus_info); @@ -2123,29 +2138,31 @@ static int snd_cs4231_ebus_free(struct snd_cs4231 *chip) if (chip->port) iounmap(chip->port); + if (chip->timer) + snd_device_free(chip->card, chip->timer); kfree(chip); return 0; } -static int snd_cs4231_ebus_dev_free(struct snd_device *device) +static int snd_cs4231_ebus_dev_free(snd_device_t *device) { - struct snd_cs4231 *cp = device->device_data; + cs4231_t *cp = device->device_data; return snd_cs4231_ebus_free(cp); } -static struct snd_device_ops snd_cs4231_ebus_dev_ops = { +static snd_device_ops_t snd_cs4231_ebus_dev_ops = { .dev_free = snd_cs4231_ebus_dev_free, }; -static int __init snd_cs4231_ebus_create(struct snd_card *card, +static int __init snd_cs4231_ebus_create(snd_card_t *card, struct linux_ebus_device *edev, int dev, - struct snd_cs4231 **rchip) + cs4231_t **rchip) { - struct snd_cs4231 *chip; + cs4231_t *chip; int err; *rchip = NULL; @@ -2235,10 +2252,10 @@ static int __init snd_cs4231_ebus_create(struct snd_card *card, return 0; } -static int __init cs4231_ebus_attach(struct linux_ebus_device *edev) +static int cs4231_ebus_attach(struct linux_ebus_device *edev) { - struct snd_card *card; - struct snd_cs4231 *chip; + snd_card_t *card; + cs4231_t *chip; int err; err = cs4231_attach_begin(&card); @@ -2311,10 +2328,10 @@ static int __init cs4231_init(void) static void __exit cs4231_exit(void) { - struct snd_cs4231 *p = cs4231_list; + cs4231_t *p = cs4231_list; while (p != NULL) { - struct snd_cs4231 *next = p->next; + cs4231_t *next = p->next; snd_card_free(p->card); diff --git a/trunk/sound/sparc/dbri.c b/trunk/sound/sparc/dbri.c index 2164b7d290c7..59a771294709 100644 --- a/trunk/sound/sparc/dbri.c +++ b/trunk/sound/sparc/dbri.c @@ -299,8 +299,8 @@ struct dbri_desc { }; /* Per stream (playback or record) information */ -struct dbri_streaminfo { - struct snd_pcm_substream *substream; +typedef struct dbri_streaminfo { + snd_pcm_substream_t *substream; u32 dvma_buffer; /* Device view of Alsa DMA buffer */ int left; /* # of bytes left in DMA buffer */ int size; /* Size of DMA buffer */ @@ -309,12 +309,12 @@ struct dbri_streaminfo { int left_gain; /* mixer elements */ int right_gain; int balance; -}; +} dbri_streaminfo_t; /* This structure holds the information for both chips (DBRI & CS4215) */ -struct snd_dbri { - struct snd_card *card; /* ALSA card */ - struct snd_pcm *pcm; +typedef struct snd_dbri { + snd_card_t *card; /* ALSA card */ + snd_pcm_t *pcm; int regs_size, irq; /* Needed for unload */ struct sbus_dev *sdev; /* SBUS device info */ @@ -341,7 +341,7 @@ struct snd_dbri { struct dbri_streaminfo stream_info[DBRI_NO_STREAMS]; struct snd_dbri *next; -}; +} snd_dbri_t; #define DBRI_MAX_VOLUME 63 /* Output volume */ #define DBRI_MAX_GAIN 15 /* Input gain */ @@ -593,7 +593,7 @@ struct snd_dbri { /* Return a pointer to dbri_streaminfo */ #define DBRI_STREAM(dbri, substream) &dbri->stream_info[DBRI_STREAMNO(substream)] -static struct snd_dbri *dbri_list = NULL; /* All DBRI devices */ +static snd_dbri_t *dbri_list = NULL; /* All DBRI devices */ /* * Short data pipes transmit LSB first. The CS4215 receives MSB first. Grrr. @@ -652,12 +652,12 @@ to the DBRI. */ -static void dbri_process_interrupt_buffer(struct snd_dbri * dbri); +static void dbri_process_interrupt_buffer(snd_dbri_t * dbri); -enum dbri_lock { NoGetLock, GetLock }; +enum dbri_lock_t { NoGetLock, GetLock }; #define MAXLOOPS 10 -static volatile s32 *dbri_cmdlock(struct snd_dbri * dbri, enum dbri_lock get) +static volatile s32 *dbri_cmdlock(snd_dbri_t * dbri, enum dbri_lock_t get) { int maxloops = MAXLOOPS; @@ -687,7 +687,7 @@ static volatile s32 *dbri_cmdlock(struct snd_dbri * dbri, enum dbri_lock get) return &dbri->dma->cmd[0]; } -static void dbri_cmdsend(struct snd_dbri * dbri, volatile s32 * cmd) +static void dbri_cmdsend(snd_dbri_t * dbri, volatile s32 * cmd) { volatile s32 *ptr; u32 reg; @@ -717,7 +717,7 @@ static void dbri_cmdsend(struct snd_dbri * dbri, volatile s32 * cmd) } /* Lock must be held when calling this */ -static void dbri_reset(struct snd_dbri * dbri) +static void dbri_reset(snd_dbri_t * dbri) { int i; @@ -732,7 +732,7 @@ static void dbri_reset(struct snd_dbri * dbri) } /* Lock must not be held before calling this */ -static void dbri_initialize(struct snd_dbri * dbri) +static void dbri_initialize(snd_dbri_t * dbri) { volatile s32 *cmd; u32 dma_addr, tmp; @@ -795,7 +795,7 @@ list ordering, among other things. The transmit and receive functions here interface closely with the transmit and receive interrupt code. */ -static int pipe_active(struct snd_dbri * dbri, int pipe) +static int pipe_active(snd_dbri_t * dbri, int pipe) { return ((pipe >= 0) && (dbri->pipes[pipe].desc != -1)); } @@ -805,7 +805,7 @@ static int pipe_active(struct snd_dbri * dbri, int pipe) * Called on an in-use pipe to clear anything being transmitted or received * Lock must be held before calling this. */ -static void reset_pipe(struct snd_dbri * dbri, int pipe) +static void reset_pipe(snd_dbri_t * dbri, int pipe) { int sdp; int desc; @@ -838,7 +838,7 @@ static void reset_pipe(struct snd_dbri * dbri, int pipe) } /* FIXME: direction as an argument? */ -static void setup_pipe(struct snd_dbri * dbri, int pipe, int sdp) +static void setup_pipe(snd_dbri_t * dbri, int pipe, int sdp) { if (pipe < 0 || pipe > 31) { printk(KERN_ERR "DBRI: setup_pipe called with illegal pipe number\n"); @@ -869,7 +869,7 @@ static void setup_pipe(struct snd_dbri * dbri, int pipe, int sdp) } /* FIXME: direction not needed */ -static void link_time_slot(struct snd_dbri * dbri, int pipe, +static void link_time_slot(snd_dbri_t * dbri, int pipe, enum in_or_out direction, int basepipe, int length, int cycle) { @@ -959,7 +959,7 @@ static void link_time_slot(struct snd_dbri * dbri, int pipe, dbri_cmdsend(dbri, cmd); } -static void unlink_time_slot(struct snd_dbri * dbri, int pipe, +static void unlink_time_slot(snd_dbri_t * dbri, int pipe, enum in_or_out direction, int prevpipe, int nextpipe) { @@ -1003,7 +1003,7 @@ static void unlink_time_slot(struct snd_dbri * dbri, int pipe, * in the low-order 8 bits, filled either MSB-first or LSB-first, * depending on the settings passed to setup_pipe() */ -static void xmit_fixed(struct snd_dbri * dbri, int pipe, unsigned int data) +static void xmit_fixed(snd_dbri_t * dbri, int pipe, unsigned int data) { volatile s32 *cmd; @@ -1040,7 +1040,7 @@ static void xmit_fixed(struct snd_dbri * dbri, int pipe, unsigned int data) dbri_cmdsend(dbri, cmd); } -static void recv_fixed(struct snd_dbri * dbri, int pipe, volatile __u32 * ptr) +static void recv_fixed(snd_dbri_t * dbri, int pipe, volatile __u32 * ptr) { if (pipe < 16 || pipe > 31) { printk(KERN_ERR "DBRI: recv_fixed called with illegal pipe number\n"); @@ -1072,9 +1072,9 @@ static void recv_fixed(struct snd_dbri * dbri, int pipe, volatile __u32 * ptr) * data buffers. Buffers too large for a single descriptor will * be spread across multiple descriptors. */ -static int setup_descs(struct snd_dbri * dbri, int streamno, unsigned int period) +static int setup_descs(snd_dbri_t * dbri, int streamno, unsigned int period) { - struct dbri_streaminfo *info = &dbri->stream_info[streamno]; + dbri_streaminfo_t *info = &dbri->stream_info[streamno]; __u32 dvma_buffer; int desc = 0; int len; @@ -1207,7 +1207,7 @@ multiplexed serial interface which the DBRI can operate in either master enum master_or_slave { CHImaster, CHIslave }; -static void reset_chi(struct snd_dbri * dbri, enum master_or_slave master_or_slave, +static void reset_chi(snd_dbri_t * dbri, enum master_or_slave master_or_slave, int bits_per_frame) { volatile s32 *cmd; @@ -1308,7 +1308,7 @@ In the standard SPARC audio configuration, the CS4215 codec is attached to the DBRI via the CHI interface and few of the DBRI's PIO pins. */ -static void cs4215_setup_pipes(struct snd_dbri * dbri) +static void cs4215_setup_pipes(snd_dbri_t * dbri) { /* * Data mode: @@ -1369,7 +1369,7 @@ static int cs4215_init_data(struct cs4215 *mm) return 0; } -static void cs4215_setdata(struct snd_dbri * dbri, int muted) +static void cs4215_setdata(snd_dbri_t * dbri, int muted) { if (muted) { dbri->mm.data[0] |= 63; @@ -1378,7 +1378,7 @@ static void cs4215_setdata(struct snd_dbri * dbri, int muted) dbri->mm.data[3] &= ~15; } else { /* Start by setting the playback attenuation. */ - struct dbri_streaminfo *info = &dbri->stream_info[DBRI_PLAY]; + dbri_streaminfo_t *info = &dbri->stream_info[DBRI_PLAY]; int left_gain = info->left_gain % 64; int right_gain = info->right_gain % 64; @@ -1409,7 +1409,7 @@ static void cs4215_setdata(struct snd_dbri * dbri, int muted) /* * Set the CS4215 to data mode. */ -static void cs4215_open(struct snd_dbri * dbri) +static void cs4215_open(snd_dbri_t * dbri) { int data_width; u32 tmp; @@ -1471,7 +1471,7 @@ static void cs4215_open(struct snd_dbri * dbri) /* * Send the control information (i.e. audio format) */ -static int cs4215_setctrl(struct snd_dbri * dbri) +static int cs4215_setctrl(snd_dbri_t * dbri) { int i, val; u32 tmp; @@ -1570,7 +1570,7 @@ static int cs4215_setctrl(struct snd_dbri * dbri) * As part of the process we resend the settings for the data * timeslots as well. */ -static int cs4215_prepare(struct snd_dbri * dbri, unsigned int rate, +static int cs4215_prepare(snd_dbri_t * dbri, unsigned int rate, snd_pcm_format_t format, unsigned int channels) { int freq_idx; @@ -1628,7 +1628,7 @@ static int cs4215_prepare(struct snd_dbri * dbri, unsigned int rate, /* * */ -static int cs4215_init(struct snd_dbri * dbri) +static int cs4215_init(snd_dbri_t * dbri) { u32 reg2 = sbus_readl(dbri->regs + REG2); dprintk(D_MM, "cs4215_init: reg2=0x%x\n", reg2); @@ -1697,8 +1697,8 @@ even if we're running cli'ed. */ static void xmit_descs(unsigned long data) { - struct snd_dbri *dbri = (struct snd_dbri *) data; - struct dbri_streaminfo *info; + snd_dbri_t *dbri = (snd_dbri_t *) data; + dbri_streaminfo_t *info; volatile s32 *cmd; unsigned long flags; int first_td; @@ -1780,9 +1780,9 @@ static DECLARE_TASKLET(xmit_descs_task, xmit_descs, 0); * done by the xmit_descs() tasklet above since that could take longer. */ -static void transmission_complete_intr(struct snd_dbri * dbri, int pipe) +static void transmission_complete_intr(snd_dbri_t * dbri, int pipe) { - struct dbri_streaminfo *info; + dbri_streaminfo_t *info; int td; int status; @@ -1830,9 +1830,9 @@ static void transmission_complete_intr(struct snd_dbri * dbri, int pipe) snd_pcm_period_elapsed(info->substream); } -static void reception_complete_intr(struct snd_dbri * dbri, int pipe) +static void reception_complete_intr(snd_dbri_t * dbri, int pipe) { - struct dbri_streaminfo *info; + dbri_streaminfo_t *info; int rd = dbri->pipes[pipe].desc; s32 status; @@ -1874,7 +1874,7 @@ static void reception_complete_intr(struct snd_dbri * dbri, int pipe) snd_pcm_period_elapsed(info->substream); } -static void dbri_process_one_interrupt(struct snd_dbri * dbri, int x) +static void dbri_process_one_interrupt(snd_dbri_t * dbri, int x) { int val = D_INTR_GETVAL(x); int channel = D_INTR_GETCHAN(x); @@ -1950,7 +1950,7 @@ static void dbri_process_one_interrupt(struct snd_dbri * dbri, int x) * order is important since we might recurse back into this function * and need to make sure the pointer has been advanced first. */ -static void dbri_process_interrupt_buffer(struct snd_dbri * dbri) +static void dbri_process_interrupt_buffer(snd_dbri_t * dbri) { s32 x; @@ -1969,7 +1969,7 @@ static void dbri_process_interrupt_buffer(struct snd_dbri * dbri) static irqreturn_t snd_dbri_interrupt(int irq, void *dev_id, struct pt_regs *regs) { - struct snd_dbri *dbri = dev_id; + snd_dbri_t *dbri = dev_id; static int errcnt = 0; int x; @@ -2030,7 +2030,7 @@ static irqreturn_t snd_dbri_interrupt(int irq, void *dev_id, /**************************************************************************** PCM Interface ****************************************************************************/ -static struct snd_pcm_hardware snd_dbri_pcm_hw = { +static snd_pcm_hardware_t snd_dbri_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -2051,11 +2051,11 @@ static struct snd_pcm_hardware snd_dbri_pcm_hw = { .periods_max = 1024, }; -static int snd_dbri_open(struct snd_pcm_substream *substream) +static int snd_dbri_open(snd_pcm_substream_t * substream) { - struct snd_dbri *dbri = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); + snd_dbri_t *dbri = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream); unsigned long flags; dprintk(D_USR, "open audio output.\n"); @@ -2074,10 +2074,10 @@ static int snd_dbri_open(struct snd_pcm_substream *substream) return 0; } -static int snd_dbri_close(struct snd_pcm_substream *substream) +static int snd_dbri_close(snd_pcm_substream_t * substream) { - struct snd_dbri *dbri = snd_pcm_substream_chip(substream); - struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); + snd_dbri_t *dbri = snd_pcm_substream_chip(substream); + dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream); dprintk(D_USR, "close audio output.\n"); info->substream = NULL; @@ -2087,12 +2087,12 @@ static int snd_dbri_close(struct snd_pcm_substream *substream) return 0; } -static int snd_dbri_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_dbri_hw_params(snd_pcm_substream_t * substream, + snd_pcm_hw_params_t * hw_params) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_dbri *dbri = snd_pcm_substream_chip(substream); - struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_dbri_t *dbri = snd_pcm_substream_chip(substream); + dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream); int direction; int ret; @@ -2129,10 +2129,10 @@ static int snd_dbri_hw_params(struct snd_pcm_substream *substream, return 0; } -static int snd_dbri_hw_free(struct snd_pcm_substream *substream) +static int snd_dbri_hw_free(snd_pcm_substream_t * substream) { - struct snd_dbri *dbri = snd_pcm_substream_chip(substream); - struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); + snd_dbri_t *dbri = snd_pcm_substream_chip(substream); + dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream); int direction; dprintk(D_USR, "hw_free.\n"); @@ -2153,11 +2153,11 @@ static int snd_dbri_hw_free(struct snd_pcm_substream *substream) return snd_pcm_lib_free_pages(substream); } -static int snd_dbri_prepare(struct snd_pcm_substream *substream) +static int snd_dbri_prepare(snd_pcm_substream_t * substream) { - struct snd_dbri *dbri = snd_pcm_substream_chip(substream); - struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); - struct snd_pcm_runtime *runtime = substream->runtime; + snd_dbri_t *dbri = snd_pcm_substream_chip(substream); + dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream); + snd_pcm_runtime_t *runtime = substream->runtime; int ret; info->size = snd_pcm_lib_buffer_bytes(substream); @@ -2184,10 +2184,10 @@ static int snd_dbri_prepare(struct snd_pcm_substream *substream) return ret; } -static int snd_dbri_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_dbri_trigger(snd_pcm_substream_t * substream, int cmd) { - struct snd_dbri *dbri = snd_pcm_substream_chip(substream); - struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); + snd_dbri_t *dbri = snd_pcm_substream_chip(substream); + dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream); int ret = 0; switch (cmd) { @@ -2211,10 +2211,10 @@ static int snd_dbri_trigger(struct snd_pcm_substream *substream, int cmd) return ret; } -static snd_pcm_uframes_t snd_dbri_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_dbri_pointer(snd_pcm_substream_t * substream) { - struct snd_dbri *dbri = snd_pcm_substream_chip(substream); - struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); + snd_dbri_t *dbri = snd_pcm_substream_chip(substream); + dbri_streaminfo_t *info = DBRI_STREAM(dbri, substream); snd_pcm_uframes_t ret; ret = bytes_to_frames(substream->runtime, info->offset) @@ -2224,7 +2224,7 @@ static snd_pcm_uframes_t snd_dbri_pointer(struct snd_pcm_substream *substream) return ret; } -static struct snd_pcm_ops snd_dbri_ops = { +static snd_pcm_ops_t snd_dbri_ops = { .open = snd_dbri_open, .close = snd_dbri_close, .ioctl = snd_pcm_lib_ioctl, @@ -2235,9 +2235,9 @@ static struct snd_pcm_ops snd_dbri_ops = { .pointer = snd_dbri_pointer, }; -static int __devinit snd_dbri_pcm(struct snd_dbri * dbri) +static int __devinit snd_dbri_pcm(snd_dbri_t * dbri) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err; if ((err = snd_pcm_new(dbri->card, @@ -2270,8 +2270,8 @@ static int __devinit snd_dbri_pcm(struct snd_dbri * dbri) Mixer interface *****************************************************************************/ -static int snd_cs4215_info_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs4215_info_volume(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; @@ -2284,11 +2284,11 @@ static int snd_cs4215_info_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4215_get_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4215_get_volume(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); - struct dbri_streaminfo *info; + snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol); + dbri_streaminfo_t *info; snd_assert(dbri != NULL, return -EINVAL); info = &dbri->stream_info[kcontrol->private_value]; snd_assert(info != NULL, return -EINVAL); @@ -2298,11 +2298,11 @@ static int snd_cs4215_get_volume(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4215_put_volume(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4215_put_volume(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); - struct dbri_streaminfo *info = &dbri->stream_info[kcontrol->private_value]; + snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol); + dbri_streaminfo_t *info = &dbri->stream_info[kcontrol->private_value]; unsigned long flags; int changed = 0; @@ -2329,8 +2329,8 @@ static int snd_cs4215_put_volume(struct snd_kcontrol *kcontrol, return changed; } -static int snd_cs4215_info_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_info *uinfo) +static int snd_cs4215_info_single(snd_kcontrol_t * kcontrol, + snd_ctl_elem_info_t * uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; @@ -2342,10 +2342,10 @@ static int snd_cs4215_info_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4215_get_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4215_get_single(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); + snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol); int elem = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; @@ -2367,10 +2367,10 @@ static int snd_cs4215_get_single(struct snd_kcontrol *kcontrol, return 0; } -static int snd_cs4215_put_single(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) +static int snd_cs4215_put_single(snd_kcontrol_t * kcontrol, + snd_ctl_elem_value_t * ucontrol) { - struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); + snd_dbri_t *dbri = snd_kcontrol_chip(kcontrol); unsigned long flags; int elem = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; @@ -2425,7 +2425,7 @@ static int snd_cs4215_put_single(struct snd_kcontrol *kcontrol, .get = snd_cs4215_get_single, .put = snd_cs4215_put_single, \ .private_value = entry | (shift << 8) | (mask << 16) | (invert << 24) }, -static struct snd_kcontrol_new dbri_controls[] __devinitdata = { +static snd_kcontrol_new_t dbri_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Playback Volume", @@ -2452,11 +2452,11 @@ static struct snd_kcontrol_new dbri_controls[] __devinitdata = { CS4215_SINGLE("Mic boost", 4, 4, 1, 1) }; -#define NUM_CS4215_CONTROLS (sizeof(dbri_controls)/sizeof(struct snd_kcontrol_new)) +#define NUM_CS4215_CONTROLS (sizeof(dbri_controls)/sizeof(snd_kcontrol_new_t)) -static int __init snd_dbri_mixer(struct snd_dbri * dbri) +static int __init snd_dbri_mixer(snd_dbri_t * dbri) { - struct snd_card *card; + snd_card_t *card; int idx, err; snd_assert(dbri != NULL && dbri->card != NULL, return -EINVAL); @@ -2482,9 +2482,9 @@ static int __init snd_dbri_mixer(struct snd_dbri * dbri) /**************************************************************************** /proc interface ****************************************************************************/ -static void dbri_regs_read(struct snd_info_entry * entry, struct snd_info_buffer *buffer) +static void dbri_regs_read(snd_info_entry_t * entry, snd_info_buffer_t * buffer) { - struct snd_dbri *dbri = entry->private_data; + snd_dbri_t *dbri = entry->private_data; snd_iprintf(buffer, "REG0: 0x%x\n", sbus_readl(dbri->regs + REG0)); snd_iprintf(buffer, "REG2: 0x%x\n", sbus_readl(dbri->regs + REG2)); @@ -2493,10 +2493,10 @@ static void dbri_regs_read(struct snd_info_entry * entry, struct snd_info_buffer } #ifdef DBRI_DEBUG -static void dbri_debug_read(struct snd_info_entry * entry, - struct snd_info_buffer *buffer) +static void dbri_debug_read(snd_info_entry_t * entry, + snd_info_buffer_t * buffer) { - struct snd_dbri *dbri = entry->private_data; + snd_dbri_t *dbri = entry->private_data; int pipe; snd_iprintf(buffer, "debug=%d\n", dbri_debug); @@ -2516,18 +2516,18 @@ static void dbri_debug_read(struct snd_info_entry * entry, } #endif -void snd_dbri_proc(struct snd_dbri * dbri) +void snd_dbri_proc(snd_dbri_t * dbri) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; + int err; - if (! snd_card_proc_new(dbri->card, "regs", &entry)) - snd_info_set_text_ops(entry, dbri, 1024, dbri_regs_read); + err = snd_card_proc_new(dbri->card, "regs", &entry); + snd_info_set_text_ops(entry, dbri, 1024, dbri_regs_read); #ifdef DBRI_DEBUG - if (! snd_card_proc_new(dbri->card, "debug", &entry)) { - snd_info_set_text_ops(entry, dbri, 4096, dbri_debug_read); - entry->mode = S_IFREG | S_IRUGO; /* Readable only. */ - } + err = snd_card_proc_new(dbri->card, "debug", &entry); + snd_info_set_text_ops(entry, dbri, 4096, dbri_debug_read); + entry->mode = S_IFREG | S_IRUGO; /* Readable only. */ #endif } @@ -2536,13 +2536,13 @@ void snd_dbri_proc(struct snd_dbri * dbri) **************************** Initialization ******************************** **************************************************************************** */ -static void snd_dbri_free(struct snd_dbri * dbri); +static void snd_dbri_free(snd_dbri_t * dbri); -static int __init snd_dbri_create(struct snd_card *card, +static int __init snd_dbri_create(snd_card_t * card, struct sbus_dev *sdev, struct linux_prom_irqs *irq, int dev) { - struct snd_dbri *dbri = card->private_data; + snd_dbri_t *dbri = card->private_data; int err; spin_lock_init(&dbri->lock); @@ -2593,7 +2593,7 @@ static int __init snd_dbri_create(struct snd_card *card, return 0; } -static void snd_dbri_free(struct snd_dbri * dbri) +static void snd_dbri_free(snd_dbri_t * dbri) { dprintk(D_GEN, "snd_dbri_free\n"); dbri_reset(dbri); @@ -2611,10 +2611,10 @@ static void snd_dbri_free(struct snd_dbri * dbri) static int __init dbri_attach(int prom_node, struct sbus_dev *sdev) { - struct snd_dbri *dbri; + snd_dbri_t *dbri; struct linux_prom_irqs irq; struct resource *rp; - struct snd_card *card; + snd_card_t *card; static int dev = 0; int err; @@ -2638,7 +2638,7 @@ static int __init dbri_attach(int prom_node, struct sbus_dev *sdev) } card = snd_card_new(index[dev], id[dev], THIS_MODULE, - sizeof(struct snd_dbri)); + sizeof(snd_dbri_t)); if (card == NULL) return -ENOMEM; @@ -2654,7 +2654,7 @@ static int __init dbri_attach(int prom_node, struct sbus_dev *sdev) return err; } - dbri = card->private_data; + dbri = (snd_dbri_t *) card->private_data; if ((err = snd_dbri_pcm(dbri)) < 0) goto _err; @@ -2664,6 +2664,9 @@ static int __init dbri_attach(int prom_node, struct sbus_dev *sdev) /* /proc file handling */ snd_dbri_proc(dbri); + if ((err = snd_card_set_generic_dev(card)) < 0) + goto _err; + if ((err = snd_card_register(card)) < 0) goto _err; @@ -2706,11 +2709,11 @@ static int __init dbri_init(void) static void __exit dbri_exit(void) { - struct snd_dbri *this = dbri_list; + snd_dbri_t *this = dbri_list; while (this != NULL) { - struct snd_dbri *next = this->next; - struct snd_card *card = this->card; + snd_dbri_t *next = this->next; + snd_card_t *card = this->card; snd_dbri_free(this); snd_card_free(card); diff --git a/trunk/sound/synth/emux/emux.c b/trunk/sound/synth/emux/emux.c index 7c8e328fae62..9e2b4c0c8a8a 100644 --- a/trunk/sound/synth/emux/emux.c +++ b/trunk/sound/synth/emux/emux.c @@ -35,9 +35,9 @@ MODULE_LICENSE("GPL"); /* * create a new hardware dependent device for Emu8000/Emu10k1 */ -int snd_emux_new(struct snd_emux **remu) +int snd_emux_new(snd_emux_t **remu) { - struct snd_emux *emu; + snd_emux_t *emu; *remu = NULL; emu = kzalloc(sizeof(*emu), GFP_KERNEL); @@ -66,33 +66,10 @@ int snd_emux_new(struct snd_emux **remu) /* */ -static int sf_sample_new(void *private_data, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr, - const void __user *buf, long count) -{ - struct snd_emux *emu = private_data; - return emu->ops.sample_new(emu, sp, hdr, buf, count); - -} - -static int sf_sample_free(void *private_data, struct snd_sf_sample *sp, - struct snd_util_memhdr *hdr) -{ - struct snd_emux *emu = private_data; - return emu->ops.sample_free(emu, sp, hdr); - -} - -static void sf_sample_reset(void *private_data) -{ - struct snd_emux *emu = private_data; - emu->ops.sample_reset(emu); -} - -int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, char *name) +int snd_emux_register(snd_emux_t *emu, snd_card_t *card, int index, char *name) { int err; - struct snd_sf_callback sf_cb; + snd_sf_callback_t sf_cb; snd_assert(emu->hw != NULL, return -EINVAL); snd_assert(emu->max_voices > 0, return -EINVAL); @@ -101,20 +78,16 @@ int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, ch emu->card = card; emu->name = kstrdup(name, GFP_KERNEL); - emu->voices = kcalloc(emu->max_voices, sizeof(struct snd_emux_voice), - GFP_KERNEL); + emu->voices = kcalloc(emu->max_voices, sizeof(snd_emux_voice_t), GFP_KERNEL); if (emu->voices == NULL) return -ENOMEM; /* create soundfont list */ memset(&sf_cb, 0, sizeof(sf_cb)); sf_cb.private_data = emu; - if (emu->ops.sample_new) - sf_cb.sample_new = sf_sample_new; - if (emu->ops.sample_free) - sf_cb.sample_free = sf_sample_free; - if (emu->ops.sample_reset) - sf_cb.sample_reset = sf_sample_reset; + sf_cb.sample_new = (snd_sf_sample_new_t)emu->ops.sample_new; + sf_cb.sample_free = (snd_sf_sample_free_t)emu->ops.sample_free; + sf_cb.sample_reset = (snd_sf_sample_reset_t)emu->ops.sample_reset; emu->sflist = snd_sf_new(&sf_cb, emu->memhdr); if (emu->sflist == NULL) return -ENOMEM; @@ -139,7 +112,7 @@ int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, ch /* */ -int snd_emux_free(struct snd_emux *emu) +int snd_emux_free(snd_emux_t *emu) { unsigned long flags; diff --git a/trunk/sound/synth/emux/emux_effect.c b/trunk/sound/synth/emux/emux_effect.c index a447218b6160..4764940f11a0 100644 --- a/trunk/sound/synth/emux/emux_effect.c +++ b/trunk/sound/synth/emux/emux_effect.c @@ -32,7 +32,7 @@ #define xoffsetof(type,tag) ((long)(&((type)NULL)->tag) - (long)(NULL)) -#define parm_offset(tag) xoffsetof(struct soundfont_voice_parm *, tag) +#define parm_offset(tag) xoffsetof(soundfont_voice_parm_t*, tag) #define PARM_IS_BYTE (1 << 0) #define PARM_IS_WORD (1 << 1) @@ -97,10 +97,10 @@ static struct emux_parm_defs { /* set byte effect value */ static void -effect_set_byte(unsigned char *valp, struct snd_midi_channel *chan, int type) +effect_set_byte(unsigned char *valp, snd_midi_channel_t *chan, int type) { short effect; - struct snd_emux_effect_table *fx = chan->private; + snd_emux_effect_table_t *fx = chan->private; effect = fx->val[type]; if (fx->flag[type] == EMUX_FX_FLAG_ADD) { @@ -118,10 +118,10 @@ effect_set_byte(unsigned char *valp, struct snd_midi_channel *chan, int type) /* set word effect value */ static void -effect_set_word(unsigned short *valp, struct snd_midi_channel *chan, int type) +effect_set_word(unsigned short *valp, snd_midi_channel_t *chan, int type) { int effect; - struct snd_emux_effect_table *fx = chan->private; + snd_emux_effect_table_t *fx = chan->private; effect = *(unsigned short*)&fx->val[type]; if (fx->flag[type] == EMUX_FX_FLAG_ADD) @@ -135,10 +135,10 @@ effect_set_word(unsigned short *valp, struct snd_midi_channel *chan, int type) /* address offset */ static int -effect_get_offset(struct snd_midi_channel *chan, int lo, int hi, int mode) +effect_get_offset(snd_midi_channel_t *chan, int lo, int hi, int mode) { int addr = 0; - struct snd_emux_effect_table *fx = chan->private; + snd_emux_effect_table_t *fx = chan->private; if (fx->flag[hi]) addr = (short)fx->val[hi]; @@ -153,8 +153,7 @@ effect_get_offset(struct snd_midi_channel *chan, int lo, int hi, int mode) #ifdef CONFIG_SND_SEQUENCER_OSS /* change effects - for OSS sequencer compatibility */ void -snd_emux_send_effect_oss(struct snd_emux_port *port, - struct snd_midi_channel *chan, int type, int val) +snd_emux_send_effect_oss(snd_emux_port_t *port, snd_midi_channel_t *chan, int type, int val) { int mode; @@ -174,14 +173,13 @@ snd_emux_send_effect_oss(struct snd_emux_port *port, * if update is necessary, call emu8000_control */ void -snd_emux_send_effect(struct snd_emux_port *port, struct snd_midi_channel *chan, - int type, int val, int mode) +snd_emux_send_effect(snd_emux_port_t *port, snd_midi_channel_t *chan, int type, int val, int mode) { int i; int offset; unsigned char *srcp, *origp; - struct snd_emux *emu; - struct snd_emux_effect_table *fx; + snd_emux_t *emu; + snd_emux_effect_table_t *fx; unsigned long flags; emu = port->emu; @@ -208,7 +206,7 @@ snd_emux_send_effect(struct snd_emux_port *port, struct snd_midi_channel *chan, /* modify the register values */ spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { - struct snd_emux_voice *vp = &emu->voices[i]; + snd_emux_voice_t *vp = &emu->voices[i]; if (!STATE_IS_PLAYING(vp->state) || vp->chan != chan) continue; srcp = (unsigned char*)&vp->reg.parm + offset; @@ -230,10 +228,10 @@ snd_emux_send_effect(struct snd_emux_port *port, struct snd_midi_channel *chan, /* copy wavetable registers to voice table */ void -snd_emux_setup_effect(struct snd_emux_voice *vp) +snd_emux_setup_effect(snd_emux_voice_t *vp) { - struct snd_midi_channel *chan = vp->chan; - struct snd_emux_effect_table *fx; + snd_midi_channel_t *chan = vp->chan; + snd_emux_effect_table_t *fx; unsigned char *srcp; int i; @@ -277,11 +275,10 @@ snd_emux_setup_effect(struct snd_emux_voice *vp) * effect table */ void -snd_emux_create_effect(struct snd_emux_port *p) +snd_emux_create_effect(snd_emux_port_t *p) { int i; - p->effect = kcalloc(p->chset.max_channels, - sizeof(struct snd_emux_effect_table), GFP_KERNEL); + p->effect = kcalloc(p->chset.max_channels, sizeof(snd_emux_effect_table_t), GFP_KERNEL); if (p->effect) { for (i = 0; i < p->chset.max_channels; i++) p->chset.channels[i].private = p->effect + i; @@ -292,18 +289,17 @@ snd_emux_create_effect(struct snd_emux_port *p) } void -snd_emux_delete_effect(struct snd_emux_port *p) +snd_emux_delete_effect(snd_emux_port_t *p) { kfree(p->effect); p->effect = NULL; } void -snd_emux_clear_effect(struct snd_emux_port *p) +snd_emux_clear_effect(snd_emux_port_t *p) { if (p->effect) { - memset(p->effect, 0, sizeof(struct snd_emux_effect_table) * - p->chset.max_channels); + memset(p->effect, 0, sizeof(snd_emux_effect_table_t) * p->chset.max_channels); } } diff --git a/trunk/sound/synth/emux/emux_hwdep.c b/trunk/sound/synth/emux/emux_hwdep.c index 9b63814c3f64..4182b44eb47e 100644 --- a/trunk/sound/synth/emux/emux_hwdep.c +++ b/trunk/sound/synth/emux/emux_hwdep.c @@ -29,7 +29,7 @@ * open the hwdep device */ static int -snd_emux_hwdep_open(struct snd_hwdep *hw, struct file *file) +snd_emux_hwdep_open(snd_hwdep_t *hw, struct file *file) { return 0; } @@ -39,7 +39,7 @@ snd_emux_hwdep_open(struct snd_hwdep *hw, struct file *file) * close the device */ static int -snd_emux_hwdep_release(struct snd_hwdep *hw, struct file *file) +snd_emux_hwdep_release(snd_hwdep_t *hw, struct file *file) { return 0; } @@ -51,10 +51,10 @@ snd_emux_hwdep_release(struct snd_hwdep *hw, struct file *file) * load patch */ static int -snd_emux_hwdep_load_patch(struct snd_emux *emu, void __user *arg) +snd_emux_hwdep_load_patch(snd_emux_t *emu, void __user *arg) { int err; - struct soundfont_patch_info patch; + soundfont_patch_info_t patch; if (copy_from_user(&patch, arg, sizeof(patch))) return -EFAULT; @@ -77,9 +77,9 @@ snd_emux_hwdep_load_patch(struct snd_emux *emu, void __user *arg) * set misc mode */ static int -snd_emux_hwdep_misc_mode(struct snd_emux *emu, void __user *arg) +snd_emux_hwdep_misc_mode(snd_emux_t *emu, void __user *arg) { - struct snd_emux_misc_mode info; + struct sndrv_emux_misc_mode info; int i; if (copy_from_user(&info, arg, sizeof(info))) @@ -102,10 +102,9 @@ snd_emux_hwdep_misc_mode(struct snd_emux *emu, void __user *arg) * ioctl */ static int -snd_emux_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, - unsigned int cmd, unsigned long arg) +snd_emux_hwdep_ioctl(snd_hwdep_t * hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct snd_emux *emu = hw->private_data; + snd_emux_t *emu = hw->private_data; switch (cmd) { case SNDRV_EMUX_IOCTL_VERSION: @@ -137,9 +136,9 @@ snd_emux_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, */ int -snd_emux_init_hwdep(struct snd_emux *emu) +snd_emux_init_hwdep(snd_emux_t *emu) { - struct snd_hwdep *hw; + snd_hwdep_t *hw; int err; if ((err = snd_hwdep_new(emu->card, SNDRV_EMUX_HWDEP_NAME, emu->hwdep_idx, &hw)) < 0) @@ -163,7 +162,7 @@ snd_emux_init_hwdep(struct snd_emux *emu) * unregister */ void -snd_emux_delete_hwdep(struct snd_emux *emu) +snd_emux_delete_hwdep(snd_emux_t *emu) { if (emu->hwdep) { snd_device_free(emu->card, emu->hwdep); diff --git a/trunk/sound/synth/emux/emux_nrpn.c b/trunk/sound/synth/emux/emux_nrpn.c index c6917ba2c934..25edff9e1fc2 100644 --- a/trunk/sound/synth/emux/emux_nrpn.c +++ b/trunk/sound/synth/emux/emux_nrpn.c @@ -27,11 +27,11 @@ */ /* NRPN / CC -> Emu8000 parameter converter */ -struct nrpn_conv_table { +typedef struct { int control; int effect; int (*convert)(int val); -}; +} nrpn_conv_table; /* effect sensitivity */ @@ -48,9 +48,8 @@ struct nrpn_conv_table { * convert NRPN/control values */ -static int send_converted_effect(struct nrpn_conv_table *table, int num_tables, - struct snd_emux_port *port, - struct snd_midi_channel *chan, +static int send_converted_effect(nrpn_conv_table *table, int num_tables, + snd_emux_port_t *port, snd_midi_channel_t *chan, int type, int val, int mode) { int i, cval; @@ -179,7 +178,7 @@ static int fx_conv_Q(int val) } -static struct nrpn_conv_table awe_effects[] = +static nrpn_conv_table awe_effects[] = { { 0, EMUX_FX_LFO1_DELAY, fx_lfo1_delay}, { 1, EMUX_FX_LFO1_FREQ, fx_lfo1_freq}, @@ -266,7 +265,7 @@ static int gs_vib_delay(int val) return -(val - 64) * gs_sense[FX_VIBDELAY] / 50; } -static struct nrpn_conv_table gs_effects[] = +static nrpn_conv_table gs_effects[] = { {32, EMUX_FX_CUTOFF, gs_cutoff}, {33, EMUX_FX_FILTERQ, gs_filterQ}, @@ -283,10 +282,9 @@ static struct nrpn_conv_table gs_effects[] = * NRPN events */ void -snd_emux_nrpn(void *p, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset) +snd_emux_nrpn(void *p, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset) { - struct snd_emux_port *port; + snd_emux_port_t *port; port = p; snd_assert(port != NULL, return); @@ -350,7 +348,7 @@ static int xg_release(int val) return -(val - 64) * xg_sense[FX_RELEASE] / 64; } -static struct nrpn_conv_table xg_effects[] = +static nrpn_conv_table xg_effects[] = { {71, EMUX_FX_CUTOFF, xg_cutoff}, {74, EMUX_FX_FILTERQ, xg_filterQ}, @@ -359,8 +357,7 @@ static struct nrpn_conv_table xg_effects[] = }; int -snd_emux_xg_control(struct snd_emux_port *port, struct snd_midi_channel *chan, - int param) +snd_emux_xg_control(snd_emux_port_t *port, snd_midi_channel_t *chan, int param) { return send_converted_effect(xg_effects, ARRAY_SIZE(xg_effects), port, chan, param, @@ -372,11 +369,10 @@ snd_emux_xg_control(struct snd_emux_port *port, struct snd_midi_channel *chan, * receive sysex */ void -snd_emux_sysex(void *p, unsigned char *buf, int len, int parsed, - struct snd_midi_channel_set *chset) +snd_emux_sysex(void *p, unsigned char *buf, int len, int parsed, snd_midi_channel_set_t *chset) { - struct snd_emux_port *port; - struct snd_emux *emu; + snd_emux_port_t *port; + snd_emux_t *emu; port = p; snd_assert(port != NULL, return); diff --git a/trunk/sound/synth/emux/emux_oss.c b/trunk/sound/synth/emux/emux_oss.c index dfbfcfbe5dd2..5272f4ac8afd 100644 --- a/trunk/sound/synth/emux/emux_oss.c +++ b/trunk/sound/synth/emux/emux_oss.c @@ -31,25 +31,19 @@ #include "emux_voice.h" #include <sound/asoundef.h> -static int snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure); -static int snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg); -static int snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, - unsigned long ioarg); -static int snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, - const char __user *buf, int offs, int count); -static int snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg); -static int snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, - void *private, int atomic, int hop); -static void reset_port_mode(struct snd_emux_port *port, int midi_mode); -static void emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, - int cmd, unsigned char *event, int atomic, int hop); -static void gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, - int cmd, unsigned char *event, int atomic, int hop); -static void fake_event(struct snd_emux *emu, struct snd_emux_port *port, - int ch, int param, int val, int atomic, int hop); +static int snd_emux_open_seq_oss(snd_seq_oss_arg_t *arg, void *closure); +static int snd_emux_close_seq_oss(snd_seq_oss_arg_t *arg); +static int snd_emux_ioctl_seq_oss(snd_seq_oss_arg_t *arg, unsigned int cmd, unsigned long ioarg); +static int snd_emux_load_patch_seq_oss(snd_seq_oss_arg_t *arg, int format, const char __user *buf, int offs, int count); +static int snd_emux_reset_seq_oss(snd_seq_oss_arg_t *arg); +static int snd_emux_event_oss_input(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop); +static void reset_port_mode(snd_emux_port_t *port, int midi_mode); +static void emuspec_control(snd_emux_t *emu, snd_emux_port_t *port, int cmd, unsigned char *event, int atomic, int hop); +static void gusspec_control(snd_emux_t *emu, snd_emux_port_t *port, int cmd, unsigned char *event, int atomic, int hop); +static void fake_event(snd_emux_t *emu, snd_emux_port_t *port, int ch, int param, int val, int atomic, int hop); /* operators */ -static struct snd_seq_oss_callback oss_callback = { +static snd_seq_oss_callback_t oss_callback = { .owner = THIS_MODULE, .open = snd_emux_open_seq_oss, .close = snd_emux_close_seq_oss, @@ -64,13 +58,13 @@ static struct snd_seq_oss_callback oss_callback = { */ void -snd_emux_init_seq_oss(struct snd_emux *emu) +snd_emux_init_seq_oss(snd_emux_t *emu) { - struct snd_seq_oss_reg *arg; - struct snd_seq_device *dev; + snd_seq_oss_reg_t *arg; + snd_seq_device_t *dev; if (snd_seq_device_new(emu->card, 0, SNDRV_SEQ_DEV_ID_OSS, - sizeof(struct snd_seq_oss_reg), &dev) < 0) + sizeof(snd_seq_oss_reg_t), &dev) < 0) return; emu->oss_synth = dev; @@ -91,7 +85,7 @@ snd_emux_init_seq_oss(struct snd_emux *emu) * unregister */ void -snd_emux_detach_seq_oss(struct snd_emux *emu) +snd_emux_detach_seq_oss(snd_emux_t *emu) { if (emu->oss_synth) { snd_device_free(emu->card, emu->oss_synth); @@ -107,11 +101,11 @@ snd_emux_detach_seq_oss(struct snd_emux *emu) * open port for OSS sequencer */ static int -snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure) +snd_emux_open_seq_oss(snd_seq_oss_arg_t *arg, void *closure) { - struct snd_emux *emu; - struct snd_emux_port *p; - struct snd_seq_port_callback callback; + snd_emux_t *emu; + snd_emux_port_t *p; + snd_seq_port_callback_t callback; char tmpname[64]; emu = closure; @@ -159,7 +153,7 @@ snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure) * reset port mode */ static void -reset_port_mode(struct snd_emux_port *port, int midi_mode) +reset_port_mode(snd_emux_port_t *port, int midi_mode) { if (midi_mode) { port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_MIDI; @@ -179,10 +173,10 @@ reset_port_mode(struct snd_emux_port *port, int midi_mode) * close port */ static int -snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg) +snd_emux_close_seq_oss(snd_seq_oss_arg_t *arg) { - struct snd_emux *emu; - struct snd_emux_port *p; + snd_emux_t *emu; + snd_emux_port_t *p; snd_assert(arg != NULL, return -ENXIO); p = arg->private_data; @@ -206,11 +200,11 @@ snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg) * load patch */ static int -snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, +snd_emux_load_patch_seq_oss(snd_seq_oss_arg_t *arg, int format, const char __user *buf, int offs, int count) { - struct snd_emux *emu; - struct snd_emux_port *p; + snd_emux_t *emu; + snd_emux_port_t *p; int rc; snd_assert(arg != NULL, return -ENXIO); @@ -224,7 +218,7 @@ snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, rc = snd_soundfont_load_guspatch(emu->sflist, buf, count, SF_CLIENT_NO(p->chset.port)); else if (format == SNDRV_OSS_SOUNDFONT_PATCH) { - struct soundfont_patch_info patch; + soundfont_patch_info_t patch; if (count < (int)sizeof(patch)) rc = -EINVAL; if (copy_from_user(&patch, buf, sizeof(patch))) @@ -248,10 +242,10 @@ snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, * ioctl */ static int -snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned long ioarg) +snd_emux_ioctl_seq_oss(snd_seq_oss_arg_t *arg, unsigned int cmd, unsigned long ioarg) { - struct snd_emux_port *p; - struct snd_emux *emu; + snd_emux_port_t *p; + snd_emux_t *emu; snd_assert(arg != NULL, return -ENXIO); p = arg->private_data; @@ -279,9 +273,9 @@ snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned l * reset device */ static int -snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg) +snd_emux_reset_seq_oss(snd_seq_oss_arg_t *arg) { - struct snd_emux_port *p; + snd_emux_port_t *p; snd_assert(arg != NULL, return -ENXIO); p = arg->private_data; @@ -295,11 +289,11 @@ snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg) * receive raw events: only SEQ_PRIVATE is accepted. */ static int -snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private_data, +snd_emux_event_oss_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct snd_emux *emu; - struct snd_emux_port *p; + snd_emux_t *emu; + snd_emux_port_t *p; unsigned char cmd, *data; p = private_data; @@ -326,14 +320,14 @@ snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private_dat * OSS/AWE driver specific h/w controls */ static void -emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, +emuspec_control(snd_emux_t *emu, snd_emux_port_t *port, int cmd, unsigned char *event, int atomic, int hop) { int voice; unsigned short p1; short p2; int i; - struct snd_midi_channel *chan; + snd_midi_channel_t *chan; voice = event[3]; if (voice < 0 || voice >= port->chset.max_channels) @@ -421,14 +415,14 @@ emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, #include <linux/ultrasound.h> static void -gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, +gusspec_control(snd_emux_t *emu, snd_emux_port_t *port, int cmd, unsigned char *event, int atomic, int hop) { int voice; unsigned short p1; short p2; int plong; - struct snd_midi_channel *chan; + snd_midi_channel_t *chan; if (port->port_mode != SNDRV_EMUX_PORT_MODE_OSS_SYNTH) return; @@ -489,9 +483,9 @@ gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, * send an event to midi emulation */ static void -fake_event(struct snd_emux *emu, struct snd_emux_port *port, int ch, int param, int val, int atomic, int hop) +fake_event(snd_emux_t *emu, snd_emux_port_t *port, int ch, int param, int val, int atomic, int hop) { - struct snd_seq_event ev; + snd_seq_event_t ev; memset(&ev, 0, sizeof(ev)); ev.type = SNDRV_SEQ_EVENT_CONTROLLER; ev.data.control.channel = ch; diff --git a/trunk/sound/synth/emux/emux_proc.c b/trunk/sound/synth/emux/emux_proc.c index a70a179f6947..0f155d68de0d 100644 --- a/trunk/sound/synth/emux/emux_proc.c +++ b/trunk/sound/synth/emux/emux_proc.c @@ -30,10 +30,10 @@ #ifdef CONFIG_PROC_FS static void -snd_emux_proc_info_read(struct snd_info_entry *entry, - struct snd_info_buffer *buf) +snd_emux_proc_info_read(snd_info_entry_t *entry, + snd_info_buffer_t *buf) { - struct snd_emux *emu; + snd_emux_t *emu; int i; emu = entry->private_data; @@ -66,7 +66,7 @@ snd_emux_proc_info_read(struct snd_info_entry *entry, } #if 0 /* debug */ if (emu->voices[0].state != SNDRV_EMUX_ST_OFF && emu->voices[0].ch >= 0) { - struct snd_emux_voice *vp = &emu->voices[0]; + snd_emux_voice_t *vp = &emu->voices[0]; snd_iprintf(buf, "voice 0: on\n"); snd_iprintf(buf, "mod delay=%x, atkhld=%x, dcysus=%x, rel=%x\n", vp->reg.parm.moddelay, @@ -107,9 +107,9 @@ snd_emux_proc_info_read(struct snd_info_entry *entry, } -void snd_emux_proc_init(struct snd_emux *emu, struct snd_card *card, int device) +void snd_emux_proc_init(snd_emux_t *emu, snd_card_t *card, int device) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; char name[64]; sprintf(name, "wavetableD%d", device); @@ -127,7 +127,7 @@ void snd_emux_proc_init(struct snd_emux *emu, struct snd_card *card, int device) emu->proc = entry; } -void snd_emux_proc_free(struct snd_emux *emu) +void snd_emux_proc_free(snd_emux_t *emu) { if (emu->proc) { snd_info_unregister(emu->proc); diff --git a/trunk/sound/synth/emux/emux_seq.c b/trunk/sound/synth/emux/emux_seq.c index 1a973d7a90f8..8ccd33f4aa57 100644 --- a/trunk/sound/synth/emux/emux_seq.c +++ b/trunk/sound/synth/emux/emux_seq.c @@ -25,14 +25,15 @@ /* Prototypes for static functions */ static void free_port(void *private); -static void snd_emux_init_port(struct snd_emux_port *p); -static int snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info); -static int snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info); +static void snd_emux_init_port(snd_emux_port_t *p); +static int snd_emux_use(void *private_data, snd_seq_port_subscribe_t *info); +static int snd_emux_unuse(void *private_data, snd_seq_port_subscribe_t *info); +static int get_client(snd_card_t *card, int index, char *name); /* * MIDI emulation operators */ -static struct snd_midi_op emux_ops = { +static snd_midi_op_t emux_ops = { snd_emux_note_on, snd_emux_note_off, snd_emux_key_press, @@ -64,14 +65,14 @@ static struct snd_midi_op emux_ops = { * can connect to these ports to play midi data. */ int -snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index) +snd_emux_init_seq(snd_emux_t *emu, snd_card_t *card, int index) { int i; - struct snd_seq_port_callback pinfo; + snd_seq_port_callback_t pinfo; char tmpname[64]; - emu->client = snd_seq_create_kernel_client(card, index, - "%s WaveTable", emu->name); + sprintf(tmpname, "%s WaveTable", emu->name); + emu->client = get_client(card, index, tmpname); if (emu->client < 0) { snd_printk("can't create client\n"); return -ENODEV; @@ -93,7 +94,7 @@ snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index) pinfo.event_input = snd_emux_event_input; for (i = 0; i < emu->num_ports; i++) { - struct snd_emux_port *p; + snd_emux_port_t *p; sprintf(tmpname, "%s Port %d", emu->name, i); p = snd_emux_create_port(emu, tmpname, MIDI_CHANNELS, @@ -118,7 +119,7 @@ snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index) * destroy the kernel client. */ void -snd_emux_detach_seq(struct snd_emux *emu) +snd_emux_detach_seq(snd_emux_t *emu) { if (emu->voices) snd_emux_terminate_all(emu); @@ -136,12 +137,12 @@ snd_emux_detach_seq(struct snd_emux *emu) * create a sequencer port and channel_set */ -struct snd_emux_port * -snd_emux_create_port(struct snd_emux *emu, char *name, - int max_channels, int oss_port, - struct snd_seq_port_callback *callback) +snd_emux_port_t * +snd_emux_create_port(snd_emux_t *emu, char *name, + int max_channels, int oss_port, + snd_seq_port_callback_t *callback) { - struct snd_emux_port *p; + snd_emux_port_t *p; int i, type, cap; /* Allocate structures for this channel */ @@ -149,7 +150,7 @@ snd_emux_create_port(struct snd_emux *emu, char *name, snd_printk("no memory\n"); return NULL; } - p->chset.channels = kcalloc(max_channels, sizeof(struct snd_midi_channel), GFP_KERNEL); + p->chset.channels = kcalloc(max_channels, sizeof(snd_midi_channel_t), GFP_KERNEL); if (p->chset.channels == NULL) { snd_printk("no memory\n"); kfree(p); @@ -189,7 +190,7 @@ snd_emux_create_port(struct snd_emux *emu, char *name, static void free_port(void *private_data) { - struct snd_emux_port *p; + snd_emux_port_t *p; p = private_data; if (p) { @@ -208,7 +209,7 @@ free_port(void *private_data) * initialize the port specific parameters */ static void -snd_emux_init_port(struct snd_emux_port *p) +snd_emux_init_port(snd_emux_port_t *p) { p->drum_flags = DEFAULT_DRUM_FLAGS; p->volume_atten = 0; @@ -221,7 +222,7 @@ snd_emux_init_port(struct snd_emux_port *p) * reset port */ void -snd_emux_reset_port(struct snd_emux_port *port) +snd_emux_reset_port(snd_emux_port_t *port) { int i; @@ -240,7 +241,7 @@ snd_emux_reset_port(struct snd_emux_port *port) port->ctrls[EMUX_MD_REALTIME_PAN] = 1; for (i = 0; i < port->chset.max_channels; i++) { - struct snd_midi_channel *chan = port->chset.channels + i; + snd_midi_channel_t *chan = port->chset.channels + i; chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0; } } @@ -250,10 +251,10 @@ snd_emux_reset_port(struct snd_emux_port *port) * input sequencer event */ int -snd_emux_event_input(struct snd_seq_event *ev, int direct, void *private_data, +snd_emux_event_input(snd_seq_event_t *ev, int direct, void *private_data, int atomic, int hop) { - struct snd_emux_port *port; + snd_emux_port_t *port; port = private_data; snd_assert(port != NULL && ev != NULL, return -EINVAL); @@ -268,7 +269,7 @@ snd_emux_event_input(struct snd_seq_event *ev, int direct, void *private_data, * increment usage count */ int -snd_emux_inc_count(struct snd_emux *emu) +snd_emux_inc_count(snd_emux_t *emu) { emu->used++; if (!try_module_get(emu->ops.owner)) @@ -287,7 +288,7 @@ snd_emux_inc_count(struct snd_emux *emu) * decrease usage count */ void -snd_emux_dec_count(struct snd_emux *emu) +snd_emux_dec_count(snd_emux_t *emu) { module_put(emu->card->module); emu->used--; @@ -301,10 +302,10 @@ snd_emux_dec_count(struct snd_emux *emu) * Routine that is called upon a first use of a particular port */ static int -snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info) +snd_emux_use(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_emux_port *p; - struct snd_emux *emu; + snd_emux_port_t *p; + snd_emux_t *emu; p = private_data; snd_assert(p != NULL, return -EINVAL); @@ -322,10 +323,10 @@ snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info) * Routine that is called upon the last unuse() of a particular port. */ static int -snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info) +snd_emux_unuse(void *private_data, snd_seq_port_subscribe_t *info) { - struct snd_emux_port *p; - struct snd_emux *emu; + snd_emux_port_t *p; + snd_emux_t *emu; p = private_data; snd_assert(p != NULL, return -EINVAL); @@ -340,10 +341,40 @@ snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info) } +/* + * Create a sequencer client + */ +static int +get_client(snd_card_t *card, int index, char *name) +{ + snd_seq_client_callback_t callbacks; + snd_seq_client_info_t cinfo; + int client; + + memset(&callbacks, 0, sizeof(callbacks)); + callbacks.private_data = NULL; + callbacks.allow_input = 1; + callbacks.allow_output = 1; + + /* Find a free client, start from 1 as the MPU expects to use 0 */ + client = snd_seq_create_kernel_client(card, index, &callbacks); + if (client < 0) + return client; + + memset(&cinfo, 0, sizeof(cinfo)); + cinfo.client = client; + cinfo.type = KERNEL_CLIENT; + strcpy(cinfo.name, name); + snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); + + return client; +} + + /* * attach virtual rawmidi devices */ -int snd_emux_init_virmidi(struct snd_emux *emu, struct snd_card *card) +int snd_emux_init_virmidi(snd_emux_t *emu, snd_card_t *card) { int i; @@ -351,13 +382,13 @@ int snd_emux_init_virmidi(struct snd_emux *emu, struct snd_card *card) if (emu->midi_ports <= 0) return 0; - emu->vmidi = kcalloc(emu->midi_ports, sizeof(struct snd_rawmidi *), GFP_KERNEL); + emu->vmidi = kcalloc(emu->midi_ports, sizeof(snd_rawmidi_t*), GFP_KERNEL); if (emu->vmidi == NULL) return -ENOMEM; for (i = 0; i < emu->midi_ports; i++) { - struct snd_rawmidi *rmidi; - struct snd_virmidi_dev *rdev; + snd_rawmidi_t *rmidi; + snd_virmidi_dev_t *rdev; if (snd_virmidi_new(card, emu->midi_devidx + i, &rmidi) < 0) goto __error; rdev = rmidi->private_data; @@ -380,7 +411,7 @@ int snd_emux_init_virmidi(struct snd_emux *emu, struct snd_card *card) return -ENOMEM; } -int snd_emux_delete_virmidi(struct snd_emux *emu) +int snd_emux_delete_virmidi(snd_emux_t *emu) { int i; diff --git a/trunk/sound/synth/emux/emux_synth.c b/trunk/sound/synth/emux/emux_synth.c index 24705d15ebd8..bd71b73be657 100644 --- a/trunk/sound/synth/emux/emux_synth.c +++ b/trunk/sound/synth/emux/emux_synth.c @@ -36,34 +36,30 @@ #define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0) #define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0) -static int get_zone(struct snd_emux *emu, struct snd_emux_port *port, - int *notep, int vel, struct snd_midi_channel *chan, - struct snd_sf_zone **table); -static int get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan); -static void terminate_note1(struct snd_emux *emu, int note, - struct snd_midi_channel *chan, int free); -static void exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, - int exclass); -static void terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free); -static void update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update); -static void setup_voice(struct snd_emux_voice *vp); -static int calc_pan(struct snd_emux_voice *vp); -static int calc_volume(struct snd_emux_voice *vp); -static int calc_pitch(struct snd_emux_voice *vp); +static int get_zone(snd_emux_t *emu, snd_emux_port_t *port, int *notep, int vel, snd_midi_channel_t *chan, snd_sf_zone_t **table); +static int get_bank(snd_emux_port_t *port, snd_midi_channel_t *chan); +static void terminate_note1(snd_emux_t *emu, int note, snd_midi_channel_t *chan, int free); +static void exclusive_note_off(snd_emux_t *emu, snd_emux_port_t *port, int exclass); +static void terminate_voice(snd_emux_t *emu, snd_emux_voice_t *vp, int free); +static void update_voice(snd_emux_t *emu, snd_emux_voice_t *vp, int update); +static void setup_voice(snd_emux_voice_t *vp); +static int calc_pan(snd_emux_voice_t *vp); +static int calc_volume(snd_emux_voice_t *vp); +static int calc_pitch(snd_emux_voice_t *vp); /* * Start a note. */ void -snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) +snd_emux_note_on(void *p, int note, int vel, snd_midi_channel_t *chan) { - struct snd_emux *emu; + snd_emux_t *emu; int i, key, nvoices; - struct snd_emux_voice *vp; - struct snd_sf_zone *table[SNDRV_EMUX_MAX_MULTI_VOICES]; + snd_emux_voice_t *vp; + snd_sf_zone_t *table[SNDRV_EMUX_MAX_MULTI_VOICES]; unsigned long flags; - struct snd_emux_port *port; + snd_emux_port_t *port; port = p; snd_assert(port != NULL && chan != NULL, return); @@ -80,7 +76,7 @@ snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) /* exclusive note off */ for (i = 0; i < nvoices; i++) { - struct snd_sf_zone *zp = table[i]; + snd_sf_zone_t *zp = table[i]; if (zp && zp->v.exclusiveClass) exclusive_note_off(emu, port, zp->v.exclusiveClass); } @@ -142,7 +138,7 @@ snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) #ifdef SNDRV_EMUX_USE_RAW_EFFECT if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) { /* clear voice position for the next note on this channel */ - struct snd_emux_effect_table *fx = chan->private; + snd_emux_effect_table_t *fx = chan->private; if (fx) { fx->flag[EMUX_FX_SAMPLE_START] = 0; fx->flag[EMUX_FX_COARSE_SAMPLE_START] = 0; @@ -155,13 +151,13 @@ snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) * Release a note in response to a midi note off. */ void -snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan) +snd_emux_note_off(void *p, int note, int vel, snd_midi_channel_t *chan) { int ch; - struct snd_emux *emu; - struct snd_emux_voice *vp; + snd_emux_t *emu; + snd_emux_voice_t *vp; unsigned long flags; - struct snd_emux_port *port; + snd_emux_port_t *port; port = p; snd_assert(port != NULL && chan != NULL, return); @@ -203,12 +199,11 @@ snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan) */ void snd_emux_timer_callback(unsigned long data) { - struct snd_emux *emu = (struct snd_emux *) data; - struct snd_emux_voice *vp; - unsigned long flags; + snd_emux_t *emu = (snd_emux_t*) data; + snd_emux_voice_t *vp; int ch, do_again = 0; - spin_lock_irqsave(&emu->voice_lock, flags); + spin_lock(&emu->voice_lock); for (ch = 0; ch < emu->max_voices; ch++) { vp = &emu->voices[ch]; if (vp->state == SNDRV_EMUX_ST_PENDING) { @@ -226,20 +221,20 @@ void snd_emux_timer_callback(unsigned long data) emu->timer_active = 1; } else emu->timer_active = 0; - spin_unlock_irqrestore(&emu->voice_lock, flags); + spin_unlock(&emu->voice_lock); } /* * key pressure change */ void -snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan) +snd_emux_key_press(void *p, int note, int vel, snd_midi_channel_t *chan) { int ch; - struct snd_emux *emu; - struct snd_emux_voice *vp; + snd_emux_t *emu; + snd_emux_voice_t *vp; unsigned long flags; - struct snd_emux_port *port; + snd_emux_port_t *port; port = p; snd_assert(port != NULL && chan != NULL, return); @@ -265,10 +260,10 @@ snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan) * Modulate the voices which belong to the channel */ void -snd_emux_update_channel(struct snd_emux_port *port, struct snd_midi_channel *chan, int update) +snd_emux_update_channel(snd_emux_port_t *port, snd_midi_channel_t *chan, int update) { - struct snd_emux *emu; - struct snd_emux_voice *vp; + snd_emux_t *emu; + snd_emux_voice_t *vp; int i; unsigned long flags; @@ -292,10 +287,10 @@ snd_emux_update_channel(struct snd_emux_port *port, struct snd_midi_channel *cha * Modulate all the voices which belong to the port. */ void -snd_emux_update_port(struct snd_emux_port *port, int update) +snd_emux_update_port(snd_emux_port_t *port, int update) { - struct snd_emux *emu; - struct snd_emux_voice *vp; + snd_emux_t *emu; + snd_emux_voice_t *vp; int i; unsigned long flags; @@ -321,9 +316,9 @@ snd_emux_update_port(struct snd_emux_port *port, int update) * control events, not just the midi controllers */ void -snd_emux_control(void *p, int type, struct snd_midi_channel *chan) +snd_emux_control(void *p, int type, snd_midi_channel_t *chan) { - struct snd_emux_port *port; + snd_emux_port_t *port; port = p; snd_assert(port != NULL && chan != NULL, return); @@ -369,10 +364,10 @@ snd_emux_control(void *p, int type, struct snd_midi_channel *chan) * terminate note - if free flag is true, free the terminated voice */ static void -terminate_note1(struct snd_emux *emu, int note, struct snd_midi_channel *chan, int free) +terminate_note1(snd_emux_t *emu, int note, snd_midi_channel_t *chan, int free) { int i; - struct snd_emux_voice *vp; + snd_emux_voice_t *vp; unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); @@ -390,10 +385,10 @@ terminate_note1(struct snd_emux *emu, int note, struct snd_midi_channel *chan, i * terminate note - exported for midi emulation */ void -snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan) +snd_emux_terminate_note(void *p, int note, snd_midi_channel_t *chan) { - struct snd_emux *emu; - struct snd_emux_port *port; + snd_emux_t *emu; + snd_emux_port_t *port; port = p; snd_assert(port != NULL && chan != NULL, return); @@ -410,10 +405,10 @@ snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan) * Terminate all the notes */ void -snd_emux_terminate_all(struct snd_emux *emu) +snd_emux_terminate_all(snd_emux_t *emu) { int i; - struct snd_emux_voice *vp; + snd_emux_voice_t *vp; unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); @@ -439,11 +434,11 @@ snd_emux_terminate_all(struct snd_emux *emu) * Terminate all voices associated with the given port */ void -snd_emux_sounds_off_all(struct snd_emux_port *port) +snd_emux_sounds_off_all(snd_emux_port_t *port) { int i; - struct snd_emux *emu; - struct snd_emux_voice *vp; + snd_emux_t *emu; + snd_emux_voice_t *vp; unsigned long flags; snd_assert(port != NULL, return); @@ -473,9 +468,9 @@ snd_emux_sounds_off_all(struct snd_emux_port *port) * is mainly for drums. */ static void -exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, int exclass) +exclusive_note_off(snd_emux_t *emu, snd_emux_port_t *port, int exclass) { - struct snd_emux_voice *vp; + snd_emux_voice_t *vp; int i; unsigned long flags; @@ -495,7 +490,7 @@ exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, int exclass * if free flag is true, call free_voice after termination */ static void -terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free) +terminate_voice(snd_emux_t *emu, snd_emux_voice_t *vp, int free) { emu->ops.terminate(vp); vp->time = emu->use_time++; @@ -513,7 +508,7 @@ terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free) * Modulate the voice */ static void -update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update) +update_voice(snd_emux_t *emu, snd_emux_voice_t *vp, int update) { if (!STATE_IS_PLAYING(vp->state)) return; @@ -548,9 +543,9 @@ static unsigned short voltarget[16] = { * will be needed later. */ static void -setup_voice(struct snd_emux_voice *vp) +setup_voice(snd_emux_voice_t *vp) { - struct soundfont_voice_parm *parm; + soundfont_voice_parm_t *parm; int pitch; /* copy the original register values */ @@ -641,9 +636,9 @@ static unsigned char pan_volumes[256] = { }; static int -calc_pan(struct snd_emux_voice *vp) +calc_pan(snd_emux_voice_t *vp) { - struct snd_midi_channel *chan = vp->chan; + snd_midi_channel_t *chan = vp->chan; int pan; /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */ @@ -742,12 +737,12 @@ static unsigned char expressiontab[128] = { * voice and channels parameters. */ static int -calc_volume(struct snd_emux_voice *vp) +calc_volume(snd_emux_voice_t *vp) { int vol; int main_vol, expression_vol, master_vol; - struct snd_midi_channel *chan = vp->chan; - struct snd_emux_port *port = vp->port; + snd_midi_channel_t *chan = vp->chan; + snd_emux_port_t *port = vp->port; expression_vol = chan->control[MIDI_CTL_MSB_EXPRESSION]; LIMITMAX(vp->velocity, 127); @@ -780,7 +775,7 @@ calc_volume(struct snd_emux_voice *vp) #ifdef SNDRV_EMUX_USE_RAW_EFFECT if (chan->private) { - struct snd_emux_effect_table *fx = chan->private; + snd_emux_effect_table_t *fx = chan->private; vol += fx->val[EMUX_FX_ATTEN]; } #endif @@ -813,9 +808,9 @@ calc_volume(struct snd_emux_voice *vp) */ static int -calc_pitch(struct snd_emux_voice *vp) +calc_pitch(snd_emux_voice_t *vp) { - struct snd_midi_channel *chan = vp->chan; + snd_midi_channel_t *chan = vp->chan; int offset; /* calculate offset */ @@ -842,7 +837,7 @@ calc_pitch(struct snd_emux_voice *vp) #ifdef SNDRV_EMUX_USE_RAW_EFFECT /* add initial pitch correction */ if (chan->private) { - struct snd_emux_effect_table *fx = chan->private; + snd_emux_effect_table_t *fx = chan->private; if (fx->flag[EMUX_FX_INIT_PITCH]) offset += fx->val[EMUX_FX_INIT_PITCH]; } @@ -862,7 +857,7 @@ calc_pitch(struct snd_emux_voice *vp) * Get the bank number assigned to the channel */ static int -get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan) +get_bank(snd_emux_port_t *port, snd_midi_channel_t *chan) { int val; @@ -891,9 +886,8 @@ get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan) * The resultant zones are stored on table. */ static int -get_zone(struct snd_emux *emu, struct snd_emux_port *port, - int *notep, int vel, struct snd_midi_channel *chan, - struct snd_sf_zone **table) +get_zone(snd_emux_t *emu, snd_emux_port_t *port, + int *notep, int vel, snd_midi_channel_t *chan, snd_sf_zone_t **table) { int preset, bank, def_preset, def_bank; @@ -916,9 +910,9 @@ get_zone(struct snd_emux *emu, struct snd_emux_port *port, /* */ void -snd_emux_init_voices(struct snd_emux *emu) +snd_emux_init_voices(snd_emux_t *emu) { - struct snd_emux_voice *vp; + snd_emux_voice_t *vp; int i; unsigned long flags; @@ -938,7 +932,7 @@ snd_emux_init_voices(struct snd_emux *emu) /* */ -void snd_emux_lock_voice(struct snd_emux *emu, int voice) +void snd_emux_lock_voice(snd_emux_t *emu, int voice) { unsigned long flags; @@ -953,7 +947,7 @@ void snd_emux_lock_voice(struct snd_emux *emu, int voice) /* */ -void snd_emux_unlock_voice(struct snd_emux *emu, int voice) +void snd_emux_unlock_voice(snd_emux_t *emu, int voice) { unsigned long flags; diff --git a/trunk/sound/synth/emux/emux_voice.h b/trunk/sound/synth/emux/emux_voice.h index 0a56ca18b165..67eb55348cdf 100644 --- a/trunk/sound/synth/emux/emux_voice.h +++ b/trunk/sound/synth/emux/emux_voice.h @@ -29,69 +29,60 @@ #include <sound/emux_synth.h> /* Prototypes for emux_seq.c */ -int snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index); -void snd_emux_detach_seq(struct snd_emux *emu); -struct snd_emux_port *snd_emux_create_port(struct snd_emux *emu, char *name, - int max_channels, int type, - struct snd_seq_port_callback *callback); -void snd_emux_reset_port(struct snd_emux_port *port); -int snd_emux_event_input(struct snd_seq_event *ev, int direct, void *private, - int atomic, int hop); -int snd_emux_inc_count(struct snd_emux *emu); -void snd_emux_dec_count(struct snd_emux *emu); -int snd_emux_init_virmidi(struct snd_emux *emu, struct snd_card *card); -int snd_emux_delete_virmidi(struct snd_emux *emu); +int snd_emux_init_seq(snd_emux_t *emu, snd_card_t *card, int index); +void snd_emux_detach_seq(snd_emux_t *emu); +snd_emux_port_t *snd_emux_create_port(snd_emux_t *emu, char *name, int max_channels, int type, snd_seq_port_callback_t *callback); +void snd_emux_reset_port(snd_emux_port_t *port); +int snd_emux_event_input(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop); +int snd_emux_inc_count(snd_emux_t *emu); +void snd_emux_dec_count(snd_emux_t *emu); +int snd_emux_init_virmidi(snd_emux_t *emu, snd_card_t *card); +int snd_emux_delete_virmidi(snd_emux_t *emu); /* Prototypes for emux_synth.c */ -void snd_emux_init_voices(struct snd_emux *emu); +void snd_emux_init_voices(snd_emux_t *emu); void snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan); void snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan); void snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan); -void snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan); +void snd_emux_terminate_note(void *p, int note, snd_midi_channel_t *chan); void snd_emux_control(void *p, int type, struct snd_midi_channel *chan); -void snd_emux_sounds_off_all(struct snd_emux_port *port); -void snd_emux_update_channel(struct snd_emux_port *port, - struct snd_midi_channel *chan, int update); -void snd_emux_update_port(struct snd_emux_port *port, int update); +void snd_emux_sounds_off_all(snd_emux_port_t *port); +void snd_emux_update_channel(snd_emux_port_t *port, snd_midi_channel_t *chan, int update); +void snd_emux_update_port(snd_emux_port_t *port, int update); void snd_emux_timer_callback(unsigned long data); /* emux_effect.c */ #ifdef SNDRV_EMUX_USE_RAW_EFFECT -void snd_emux_create_effect(struct snd_emux_port *p); -void snd_emux_delete_effect(struct snd_emux_port *p); -void snd_emux_clear_effect(struct snd_emux_port *p); -void snd_emux_setup_effect(struct snd_emux_voice *vp); -void snd_emux_send_effect_oss(struct snd_emux_port *port, - struct snd_midi_channel *chan, int type, int val); -void snd_emux_send_effect(struct snd_emux_port *port, - struct snd_midi_channel *chan, int type, int val, int mode); +void snd_emux_create_effect(snd_emux_port_t *p); +void snd_emux_delete_effect(snd_emux_port_t *p); +void snd_emux_clear_effect(snd_emux_port_t *p); +void snd_emux_setup_effect(snd_emux_voice_t *vp); +void snd_emux_send_effect_oss(snd_emux_port_t *port, snd_midi_channel_t *chan, int type, int val); +void snd_emux_send_effect(snd_emux_port_t *port, snd_midi_channel_t *chan, int type, int val, int mode); #endif /* emux_nrpn.c */ -void snd_emux_sysex(void *private_data, unsigned char *buf, int len, - int parsed, struct snd_midi_channel_set *chset); -int snd_emux_xg_control(struct snd_emux_port *port, - struct snd_midi_channel *chan, int param); -void snd_emux_nrpn(void *private_data, struct snd_midi_channel *chan, - struct snd_midi_channel_set *chset); +void snd_emux_sysex(void *private_data, unsigned char *buf, int len, int parsed, snd_midi_channel_set_t *chset); +int snd_emux_xg_control(snd_emux_port_t *port, snd_midi_channel_t *chan, int param); +void snd_emux_nrpn(void *private_data, snd_midi_channel_t *chan, snd_midi_channel_set_t *chset); /* emux_oss.c */ -void snd_emux_init_seq_oss(struct snd_emux *emu); -void snd_emux_detach_seq_oss(struct snd_emux *emu); +void snd_emux_init_seq_oss(snd_emux_t *emu); +void snd_emux_detach_seq_oss(snd_emux_t *emu); /* emux_proc.c */ #ifdef CONFIG_PROC_FS -void snd_emux_proc_init(struct snd_emux *emu, struct snd_card *card, int device); -void snd_emux_proc_free(struct snd_emux *emu); +void snd_emux_proc_init(snd_emux_t *emu, snd_card_t *card, int device); +void snd_emux_proc_free(snd_emux_t *emu); #endif #define STATE_IS_PLAYING(s) ((s) & SNDRV_EMUX_ST_ON) /* emux_hwdep.c */ -int snd_emux_init_hwdep(struct snd_emux *emu); -void snd_emux_delete_hwdep(struct snd_emux *emu); +int snd_emux_init_hwdep(snd_emux_t *emu); +void snd_emux_delete_hwdep(snd_emux_t *emu); #endif diff --git a/trunk/sound/synth/emux/soundfont.c b/trunk/sound/synth/emux/soundfont.c index 4c5754d4a2e8..d0925ea50838 100644 --- a/trunk/sound/synth/emux/soundfont.c +++ b/trunk/sound/synth/emux/soundfont.c @@ -34,49 +34,38 @@ /* Prototypes for static functions */ -static int open_patch(struct snd_sf_list *sflist, const char __user *data, - int count, int client); -static struct snd_soundfont *newsf(struct snd_sf_list *sflist, int type, char *name); -static int is_identical_font(struct snd_soundfont *sf, int type, unsigned char *name); -static int close_patch(struct snd_sf_list *sflist); -static int probe_data(struct snd_sf_list *sflist, int sample_id); -static void set_zone_counter(struct snd_sf_list *sflist, - struct snd_soundfont *sf, struct snd_sf_zone *zp); -static struct snd_sf_zone *sf_zone_new(struct snd_sf_list *sflist, - struct snd_soundfont *sf); -static void set_sample_counter(struct snd_sf_list *sflist, - struct snd_soundfont *sf, struct snd_sf_sample *sp); -static struct snd_sf_sample *sf_sample_new(struct snd_sf_list *sflist, - struct snd_soundfont *sf); -static void sf_sample_delete(struct snd_sf_list *sflist, - struct snd_soundfont *sf, struct snd_sf_sample *sp); -static int load_map(struct snd_sf_list *sflist, const void __user *data, int count); -static int load_info(struct snd_sf_list *sflist, const void __user *data, long count); -static int remove_info(struct snd_sf_list *sflist, struct snd_soundfont *sf, - int bank, int instr); -static void init_voice_info(struct soundfont_voice_info *avp); -static void init_voice_parm(struct soundfont_voice_parm *pp); -static struct snd_sf_sample *set_sample(struct snd_soundfont *sf, - struct soundfont_voice_info *avp); -static struct snd_sf_sample *find_sample(struct snd_soundfont *sf, int sample_id); -static int load_data(struct snd_sf_list *sflist, const void __user *data, long count); -static void rebuild_presets(struct snd_sf_list *sflist); -static void add_preset(struct snd_sf_list *sflist, struct snd_sf_zone *cur); -static void delete_preset(struct snd_sf_list *sflist, struct snd_sf_zone *zp); -static struct snd_sf_zone *search_first_zone(struct snd_sf_list *sflist, - int bank, int preset, int key); -static int search_zones(struct snd_sf_list *sflist, int *notep, int vel, - int preset, int bank, struct snd_sf_zone **table, - int max_layers, int level); +static int open_patch(snd_sf_list_t *sflist, const char __user *data, int count, int client); +static snd_soundfont_t *newsf(snd_sf_list_t *sflist, int type, char *name); +static int is_identical_font(snd_soundfont_t *sf, int type, unsigned char *name); +static int close_patch(snd_sf_list_t *sflist); +static int probe_data(snd_sf_list_t *sflist, int sample_id); +static void set_zone_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_zone_t *zp); +static snd_sf_zone_t *sf_zone_new(snd_sf_list_t *sflist, snd_soundfont_t *sf); +static void set_sample_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp); +static snd_sf_sample_t *sf_sample_new(snd_sf_list_t *sflist, snd_soundfont_t *sf); +static void sf_sample_delete(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp); +static int load_map(snd_sf_list_t *sflist, const void __user *data, int count); +static int load_info(snd_sf_list_t *sflist, const void __user *data, long count); +static int remove_info(snd_sf_list_t *sflist, snd_soundfont_t *sf, int bank, int instr); +static void init_voice_info(soundfont_voice_info_t *avp); +static void init_voice_parm(soundfont_voice_parm_t *pp); +static snd_sf_sample_t *set_sample(snd_soundfont_t *sf, soundfont_voice_info_t *avp); +static snd_sf_sample_t *find_sample(snd_soundfont_t *sf, int sample_id); +static int load_data(snd_sf_list_t *sflist, const void __user *data, long count); +static void rebuild_presets(snd_sf_list_t *sflist); +static void add_preset(snd_sf_list_t *sflist, snd_sf_zone_t *cur); +static void delete_preset(snd_sf_list_t *sflist, snd_sf_zone_t *zp); +static snd_sf_zone_t *search_first_zone(snd_sf_list_t *sflist, int bank, int preset, int key); +static int search_zones(snd_sf_list_t *sflist, int *notep, int vel, int preset, int bank, snd_sf_zone_t **table, int max_layers, int level); static int get_index(int bank, int instr, int key); -static void snd_sf_init(struct snd_sf_list *sflist); -static void snd_sf_clear(struct snd_sf_list *sflist); +static void snd_sf_init(snd_sf_list_t *sflist); +static void snd_sf_clear(snd_sf_list_t *sflist); /* * lock access to sflist */ static void -lock_preset(struct snd_sf_list *sflist) +lock_preset(snd_sf_list_t *sflist) { unsigned long flags; down(&sflist->presets_mutex); @@ -90,7 +79,7 @@ lock_preset(struct snd_sf_list *sflist) * remove lock */ static void -unlock_preset(struct snd_sf_list *sflist) +unlock_preset(snd_sf_list_t *sflist) { unsigned long flags; spin_lock_irqsave(&sflist->lock, flags); @@ -104,7 +93,7 @@ unlock_preset(struct snd_sf_list *sflist) * close the patch if the patch was opened by this client. */ int -snd_soundfont_close_check(struct snd_sf_list *sflist, int client) +snd_soundfont_close_check(snd_sf_list_t *sflist, int client) { unsigned long flags; spin_lock_irqsave(&sflist->lock, flags); @@ -126,10 +115,9 @@ snd_soundfont_close_check(struct snd_sf_list *sflist, int client) * it wants to do with it. */ int -snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data, - long count, int client) +snd_soundfont_load(snd_sf_list_t *sflist, const void __user *data, long count, int client) { - struct soundfont_patch_info patch; + soundfont_patch_info_t patch; unsigned long flags; int rc; @@ -227,11 +215,10 @@ is_special_type(int type) /* open patch; create sf list */ static int -open_patch(struct snd_sf_list *sflist, const char __user *data, - int count, int client) +open_patch(snd_sf_list_t *sflist, const char __user *data, int count, int client) { - struct soundfont_open_parm parm; - struct snd_soundfont *sf; + soundfont_open_parm_t parm; + snd_soundfont_t *sf; unsigned long flags; spin_lock_irqsave(&sflist->lock, flags); @@ -264,10 +251,10 @@ open_patch(struct snd_sf_list *sflist, const char __user *data, /* * Allocate a new soundfont structure. */ -static struct snd_soundfont * -newsf(struct snd_sf_list *sflist, int type, char *name) +static snd_soundfont_t * +newsf(snd_sf_list_t *sflist, int type, char *name) { - struct snd_soundfont *sf; + snd_soundfont_t *sf; /* check the shared fonts */ if (type & SNDRV_SFNT_PAT_SHARED) { @@ -300,7 +287,7 @@ newsf(struct snd_sf_list *sflist, int type, char *name) /* check if the given name matches to the existing list */ static int -is_identical_font(struct snd_soundfont *sf, int type, unsigned char *name) +is_identical_font(snd_soundfont_t *sf, int type, unsigned char *name) { return ((sf->type & SNDRV_SFNT_PAT_SHARED) && (sf->type & 0x0f) == (type & 0x0f) && @@ -312,7 +299,7 @@ is_identical_font(struct snd_soundfont *sf, int type, unsigned char *name) * Close the current patch. */ static int -close_patch(struct snd_sf_list *sflist) +close_patch(snd_sf_list_t *sflist) { unsigned long flags; @@ -329,7 +316,7 @@ close_patch(struct snd_sf_list *sflist) /* probe sample in the current list -- nothing to be loaded */ static int -probe_data(struct snd_sf_list *sflist, int sample_id) +probe_data(snd_sf_list_t *sflist, int sample_id) { /* patch must be opened */ if (sflist->currsf) { @@ -344,8 +331,7 @@ probe_data(struct snd_sf_list *sflist, int sample_id) * increment zone counter */ static void -set_zone_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, - struct snd_sf_zone *zp) +set_zone_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_zone_t *zp) { zp->counter = sflist->zone_counter++; if (sf->type & SNDRV_SFNT_PAT_LOCKED) @@ -355,10 +341,10 @@ set_zone_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, /* * allocate a new zone record */ -static struct snd_sf_zone * -sf_zone_new(struct snd_sf_list *sflist, struct snd_soundfont *sf) +static snd_sf_zone_t * +sf_zone_new(snd_sf_list_t *sflist, snd_soundfont_t *sf) { - struct snd_sf_zone *zp; + snd_sf_zone_t *zp; if ((zp = kzalloc(sizeof(*zp), GFP_KERNEL)) == NULL) return NULL; @@ -376,8 +362,7 @@ sf_zone_new(struct snd_sf_list *sflist, struct snd_soundfont *sf) * increment sample couter */ static void -set_sample_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, - struct snd_sf_sample *sp) +set_sample_counter(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp) { sp->counter = sflist->sample_counter++; if (sf->type & SNDRV_SFNT_PAT_LOCKED) @@ -387,10 +372,10 @@ set_sample_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, /* * allocate a new sample list record */ -static struct snd_sf_sample * -sf_sample_new(struct snd_sf_list *sflist, struct snd_soundfont *sf) +static snd_sf_sample_t * +sf_sample_new(snd_sf_list_t *sflist, snd_soundfont_t *sf) { - struct snd_sf_sample *sp; + snd_sf_sample_t *sp; if ((sp = kzalloc(sizeof(*sp), GFP_KERNEL)) == NULL) return NULL; @@ -407,8 +392,7 @@ sf_sample_new(struct snd_sf_list *sflist, struct snd_soundfont *sf) * only the last allocated sample can be deleted. */ static void -sf_sample_delete(struct snd_sf_list *sflist, struct snd_soundfont *sf, - struct snd_sf_sample *sp) +sf_sample_delete(snd_sf_list_t *sflist, snd_soundfont_t *sf, snd_sf_sample_t *sp) { /* only last sample is accepted */ if (sp == sf->samples) { @@ -420,11 +404,11 @@ sf_sample_delete(struct snd_sf_list *sflist, struct snd_soundfont *sf, /* load voice map */ static int -load_map(struct snd_sf_list *sflist, const void __user *data, int count) +load_map(snd_sf_list_t *sflist, const void __user *data, int count) { - struct snd_sf_zone *zp, *prevp; - struct snd_soundfont *sf; - struct soundfont_voice_map map; + snd_sf_zone_t *zp, *prevp; + snd_soundfont_t *sf; + soundfont_voice_map_t map; /* get the link info */ if (count < (int)sizeof(map)) @@ -485,10 +469,9 @@ load_map(struct snd_sf_list *sflist, const void __user *data, int count) /* remove the present instrument layers */ static int -remove_info(struct snd_sf_list *sflist, struct snd_soundfont *sf, - int bank, int instr) +remove_info(snd_sf_list_t *sflist, snd_soundfont_t *sf, int bank, int instr) { - struct snd_sf_zone *prev, *next, *p; + snd_sf_zone_t *prev, *next, *p; int removed = 0; prev = NULL; @@ -517,11 +500,11 @@ remove_info(struct snd_sf_list *sflist, struct snd_soundfont *sf, * open soundfont. */ static int -load_info(struct snd_sf_list *sflist, const void __user *data, long count) +load_info(snd_sf_list_t *sflist, const void __user *data, long count) { - struct snd_soundfont *sf; - struct snd_sf_zone *zone; - struct soundfont_voice_rec_hdr hdr; + snd_soundfont_t *sf; + snd_sf_zone_t *zone; + soundfont_voice_rec_hdr_t hdr; int i; /* patch must be opened */ @@ -546,7 +529,7 @@ load_info(struct snd_sf_list *sflist, const void __user *data, long count) return -EINVAL; } - if (count < (long)sizeof(struct soundfont_voice_info) * hdr.nvoices) { + if (count < (long)sizeof(soundfont_voice_info_t)*hdr.nvoices) { printk("Soundfont Error: patch length(%ld) is smaller than nvoices(%d)\n", count, hdr.nvoices); return -EINVAL; @@ -570,7 +553,7 @@ load_info(struct snd_sf_list *sflist, const void __user *data, long count) } for (i = 0; i < hdr.nvoices; i++) { - struct snd_sf_zone tmpzone; + snd_sf_zone_t tmpzone; /* copy awe_voice_info parameters */ if (copy_from_user(&tmpzone.v, data, sizeof(tmpzone.v))) { @@ -607,7 +590,7 @@ load_info(struct snd_sf_list *sflist, const void __user *data, long count) /* initialize voice_info record */ static void -init_voice_info(struct soundfont_voice_info *avp) +init_voice_info(soundfont_voice_info_t *avp) { memset(avp, 0, sizeof(*avp)); @@ -631,7 +614,7 @@ init_voice_info(struct soundfont_voice_info *avp) * Chorus and Reverb effects are zero. */ static void -init_voice_parm(struct soundfont_voice_parm *pp) +init_voice_parm(soundfont_voice_parm_t *pp) { memset(pp, 0, sizeof(*pp)); @@ -652,10 +635,10 @@ init_voice_parm(struct soundfont_voice_parm *pp) } /* search the specified sample */ -static struct snd_sf_sample * -set_sample(struct snd_soundfont *sf, struct soundfont_voice_info *avp) +static snd_sf_sample_t * +set_sample(snd_soundfont_t *sf, soundfont_voice_info_t *avp) { - struct snd_sf_sample *sample; + snd_sf_sample_t *sample; sample = find_sample(sf, avp->sample); if (sample == NULL) @@ -678,10 +661,10 @@ set_sample(struct snd_soundfont *sf, struct soundfont_voice_info *avp) } /* find the sample pointer with the given id in the soundfont */ -static struct snd_sf_sample * -find_sample(struct snd_soundfont *sf, int sample_id) +static snd_sf_sample_t * +find_sample(snd_soundfont_t *sf, int sample_id) { - struct snd_sf_sample *p; + snd_sf_sample_t *p; if (sf == NULL) return NULL; @@ -701,11 +684,11 @@ find_sample(struct snd_soundfont *sf, int sample_id) * routine. */ static int -load_data(struct snd_sf_list *sflist, const void __user *data, long count) +load_data(snd_sf_list_t *sflist, const void __user *data, long count) { - struct snd_soundfont *sf; - struct soundfont_sample_info sample_info; - struct snd_sf_sample *sp; + snd_soundfont_t *sf; + soundfont_sample_info_t sample_info; + snd_sf_sample_t *sp; long off; /* patch must be opened */ @@ -939,13 +922,12 @@ int snd_sf_vol_table[128] = { /* load GUS patch */ static int -load_guspatch(struct snd_sf_list *sflist, const char __user *data, - long count, int client) +load_guspatch(snd_sf_list_t *sflist, const char __user *data, long count, int client) { struct patch_info patch; - struct snd_soundfont *sf; - struct snd_sf_zone *zone; - struct snd_sf_sample *smp; + snd_soundfont_t *sf; + snd_sf_zone_t *zone; + snd_sf_sample_t *smp; int note, sample_id; int rc; @@ -1010,8 +992,7 @@ load_guspatch(struct snd_sf_list *sflist, const char __user *data, */ if (sflist->callback.sample_new) { rc = sflist->callback.sample_new - (sflist->callback.private_data, smp, sflist->memhdr, - data, count); + (sflist->callback.private_data, smp, sflist->memhdr, data, count); if (rc < 0) { sf_sample_delete(sflist, sf, smp); return rc; @@ -1114,7 +1095,7 @@ load_guspatch(struct snd_sf_list *sflist, const char __user *data, /* load GUS patch */ int -snd_soundfont_load_guspatch(struct snd_sf_list *sflist, const char __user *data, +snd_soundfont_load_guspatch(snd_sf_list_t *sflist, const char __user *data, long count, int client) { int rc; @@ -1133,10 +1114,10 @@ snd_soundfont_load_guspatch(struct snd_sf_list *sflist, const char __user *data, * bank/key combination). */ static void -rebuild_presets(struct snd_sf_list *sflist) +rebuild_presets(snd_sf_list_t *sflist) { - struct snd_soundfont *sf; - struct snd_sf_zone *cur; + snd_soundfont_t *sf; + snd_sf_zone_t *cur; /* clear preset table */ memset(sflist->presets, 0, sizeof(sflist->presets)); @@ -1161,15 +1142,15 @@ rebuild_presets(struct snd_sf_list *sflist) * add the given zone to preset table */ static void -add_preset(struct snd_sf_list *sflist, struct snd_sf_zone *cur) +add_preset(snd_sf_list_t *sflist, snd_sf_zone_t *cur) { - struct snd_sf_zone *zone; + snd_sf_zone_t *zone; int index; zone = search_first_zone(sflist, cur->bank, cur->instr, cur->v.low); if (zone && zone->v.sf_id != cur->v.sf_id) { /* different instrument was already defined */ - struct snd_sf_zone *p; + snd_sf_zone_t *p; /* compare the allocated time */ for (p = zone; p; p = p->next_zone) { if (p->counter > cur->counter) @@ -1193,10 +1174,10 @@ add_preset(struct snd_sf_list *sflist, struct snd_sf_zone *cur) * delete the given zones from preset_table */ static void -delete_preset(struct snd_sf_list *sflist, struct snd_sf_zone *zp) +delete_preset(snd_sf_list_t *sflist, snd_sf_zone_t *zp) { int index; - struct snd_sf_zone *p; + snd_sf_zone_t *p; if ((index = get_index(zp->bank, zp->instr, zp->v.low)) < 0) return; @@ -1219,10 +1200,10 @@ delete_preset(struct snd_sf_list *sflist, struct snd_sf_zone *zp) * This function returns the number of found zones. 0 if not found. */ int -snd_soundfont_search_zone(struct snd_sf_list *sflist, int *notep, int vel, +snd_soundfont_search_zone(snd_sf_list_t *sflist, int *notep, int vel, int preset, int bank, int def_preset, int def_bank, - struct snd_sf_zone **table, int max_layers) + snd_sf_zone_t **table, int max_layers) { int nvoices; unsigned long flags; @@ -1236,13 +1217,10 @@ snd_soundfont_search_zone(struct snd_sf_list *sflist, int *notep, int vel, spin_unlock_irqrestore(&sflist->lock, flags); return 0; } - nvoices = search_zones(sflist, notep, vel, preset, bank, - table, max_layers, 0); + nvoices = search_zones(sflist, notep, vel, preset, bank, table, max_layers, 0); if (! nvoices) { if (preset != def_preset || bank != def_bank) - nvoices = search_zones(sflist, notep, vel, - def_preset, def_bank, - table, max_layers, 0); + nvoices = search_zones(sflist, notep, vel, def_preset, def_bank, table, max_layers, 0); } spin_unlock_irqrestore(&sflist->lock, flags); return nvoices; @@ -1252,11 +1230,11 @@ snd_soundfont_search_zone(struct snd_sf_list *sflist, int *notep, int vel, /* * search the first matching zone */ -static struct snd_sf_zone * -search_first_zone(struct snd_sf_list *sflist, int bank, int preset, int key) +static snd_sf_zone_t * +search_first_zone(snd_sf_list_t *sflist, int bank, int preset, int key) { int index; - struct snd_sf_zone *zp; + snd_sf_zone_t *zp; if ((index = get_index(bank, preset, key)) < 0) return NULL; @@ -1272,11 +1250,9 @@ search_first_zone(struct snd_sf_list *sflist, int bank, int preset, int key) * search matching zones from sflist. can be called recursively. */ static int -search_zones(struct snd_sf_list *sflist, int *notep, int vel, - int preset, int bank, struct snd_sf_zone **table, - int max_layers, int level) +search_zones(snd_sf_list_t *sflist, int *notep, int vel, int preset, int bank, snd_sf_zone_t **table, int max_layers, int level) { - struct snd_sf_zone *zp; + snd_sf_zone_t *zp; int nvoices; zp = search_first_zone(sflist, bank, preset, *notep); @@ -1334,7 +1310,7 @@ get_index(int bank, int instr, int key) * Initialise the sflist structure. */ static void -snd_sf_init(struct snd_sf_list *sflist) +snd_sf_init(snd_sf_list_t *sflist) { memset(sflist->presets, 0, sizeof(sflist->presets)); @@ -1353,11 +1329,11 @@ snd_sf_init(struct snd_sf_list *sflist) * Release all list records */ static void -snd_sf_clear(struct snd_sf_list *sflist) +snd_sf_clear(snd_sf_list_t *sflist) { - struct snd_soundfont *sf, *nextsf; - struct snd_sf_zone *zp, *nextzp; - struct snd_sf_sample *sp, *nextsp; + snd_soundfont_t *sf, *nextsf; + snd_sf_zone_t *zp, *nextzp; + snd_sf_sample_t *sp, *nextsp; for (sf = sflist->fonts; sf; sf = nextsf) { nextsf = sf->next; @@ -1368,8 +1344,7 @@ snd_sf_clear(struct snd_sf_list *sflist) for (sp = sf->samples; sp; sp = nextsp) { nextsp = sp->next; if (sflist->callback.sample_free) - sflist->callback.sample_free(sflist->callback.private_data, - sp, sflist->memhdr); + sflist->callback.sample_free(sflist->callback.private_data, sp, sflist->memhdr); kfree(sp); } kfree(sf); @@ -1382,10 +1357,10 @@ snd_sf_clear(struct snd_sf_list *sflist) /* * Create a new sflist structure */ -struct snd_sf_list * -snd_sf_new(struct snd_sf_callback *callback, struct snd_util_memhdr *hdr) +snd_sf_list_t * +snd_sf_new(snd_sf_callback_t *callback, snd_util_memhdr_t *hdr) { - struct snd_sf_list *sflist; + snd_sf_list_t *sflist; if ((sflist = kzalloc(sizeof(*sflist), GFP_KERNEL)) == NULL) return NULL; @@ -1406,7 +1381,7 @@ snd_sf_new(struct snd_sf_callback *callback, struct snd_util_memhdr *hdr) * Free everything allocated off the sflist structure. */ void -snd_sf_free(struct snd_sf_list *sflist) +snd_sf_free(snd_sf_list_t *sflist) { if (sflist == NULL) return; @@ -1425,7 +1400,7 @@ snd_sf_free(struct snd_sf_list *sflist) * The soundcard should be silet before calling this function. */ int -snd_soundfont_remove_samples(struct snd_sf_list *sflist) +snd_soundfont_remove_samples(snd_sf_list_t *sflist) { lock_preset(sflist); if (sflist->callback.sample_reset) @@ -1441,11 +1416,11 @@ snd_soundfont_remove_samples(struct snd_sf_list *sflist) * The soundcard should be silent before calling this function. */ int -snd_soundfont_remove_unlocked(struct snd_sf_list *sflist) +snd_soundfont_remove_unlocked(snd_sf_list_t *sflist) { - struct snd_soundfont *sf; - struct snd_sf_zone *zp, *nextzp; - struct snd_sf_sample *sp, *nextsp; + snd_soundfont_t *sf; + snd_sf_zone_t *zp, *nextzp; + snd_sf_sample_t *sp, *nextsp; lock_preset(sflist); @@ -1471,8 +1446,7 @@ snd_soundfont_remove_unlocked(struct snd_sf_list *sflist) sf->samples = nextsp; sflist->mem_used -= sp->v.truesize; if (sflist->callback.sample_free) - sflist->callback.sample_free(sflist->callback.private_data, - sp, sflist->memhdr); + sflist->callback.sample_free(sflist->callback.private_data, sp, sflist->memhdr); kfree(sp); } } diff --git a/trunk/sound/synth/util_mem.c b/trunk/sound/synth/util_mem.c index 217e8e552a42..5f75bf31bc36 100644 --- a/trunk/sound/synth/util_mem.c +++ b/trunk/sound/synth/util_mem.c @@ -28,15 +28,15 @@ MODULE_AUTHOR("Takashi Iwai"); MODULE_DESCRIPTION("Generic memory management routines for soundcard memory allocation"); MODULE_LICENSE("GPL"); -#define get_memblk(p) list_entry(p, struct snd_util_memblk, list) +#define get_memblk(p) list_entry(p, snd_util_memblk_t, list) /* * create a new memory manager */ -struct snd_util_memhdr * +snd_util_memhdr_t * snd_util_memhdr_new(int memsize) { - struct snd_util_memhdr *hdr; + snd_util_memhdr_t *hdr; hdr = kzalloc(sizeof(*hdr), GFP_KERNEL); if (hdr == NULL) @@ -51,7 +51,7 @@ snd_util_memhdr_new(int memsize) /* * free a memory manager */ -void snd_util_memhdr_free(struct snd_util_memhdr *hdr) +void snd_util_memhdr_free(snd_util_memhdr_t *hdr) { struct list_head *p; @@ -67,11 +67,11 @@ void snd_util_memhdr_free(struct snd_util_memhdr *hdr) /* * allocate a memory block (without mutex) */ -struct snd_util_memblk * -__snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) +snd_util_memblk_t * +__snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size) { - struct snd_util_memblk *blk; - unsigned int units, prev_offset; + snd_util_memblk_t *blk; + snd_util_unit_t units, prev_offset; struct list_head *p; snd_assert(hdr != NULL, return NULL); @@ -104,21 +104,20 @@ __snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) * create a new memory block with the given size * the block is linked next to prev */ -struct snd_util_memblk * -__snd_util_memblk_new(struct snd_util_memhdr *hdr, unsigned int units, +snd_util_memblk_t * +__snd_util_memblk_new(snd_util_memhdr_t *hdr, snd_util_unit_t units, struct list_head *prev) { - struct snd_util_memblk *blk; + snd_util_memblk_t *blk; - blk = kmalloc(sizeof(struct snd_util_memblk) + hdr->block_extra_size, - GFP_KERNEL); + blk = kmalloc(sizeof(snd_util_memblk_t) + hdr->block_extra_size, GFP_KERNEL); if (blk == NULL) return NULL; if (! prev || prev == &hdr->block) blk->offset = 0; else { - struct snd_util_memblk *p = get_memblk(prev); + snd_util_memblk_t *p = get_memblk(prev); blk->offset = p->offset + p->size; } blk->size = units; @@ -132,10 +131,10 @@ __snd_util_memblk_new(struct snd_util_memhdr *hdr, unsigned int units, /* * allocate a memory block (with mutex) */ -struct snd_util_memblk * -snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) +snd_util_memblk_t * +snd_util_mem_alloc(snd_util_memhdr_t *hdr, int size) { - struct snd_util_memblk *blk; + snd_util_memblk_t *blk; down(&hdr->block_mutex); blk = __snd_util_mem_alloc(hdr, size); up(&hdr->block_mutex); @@ -148,7 +147,7 @@ snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) * (without mutex) */ void -__snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) +__snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk) { list_del(&blk->list); hdr->nblocks--; @@ -159,7 +158,7 @@ __snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) /* * free a memory block (with mutex) */ -int snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) +int snd_util_mem_free(snd_util_memhdr_t *hdr, snd_util_memblk_t *blk) { snd_assert(hdr && blk, return -EINVAL); @@ -172,7 +171,7 @@ int snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) /* * return available memory size */ -int snd_util_mem_avail(struct snd_util_memhdr *hdr) +int snd_util_mem_avail(snd_util_memhdr_t *hdr) { unsigned int size; down(&hdr->block_mutex); diff --git a/trunk/sound/usb/usbaudio.c b/trunk/sound/usb/usbaudio.c index a1bd8040dea4..99dae024b640 100644 --- a/trunk/sound/usb/usbaudio.c +++ b/trunk/sound/usb/usbaudio.c @@ -102,6 +102,10 @@ MODULE_PARM_DESC(async_unlink, "Use async unlink mode."); #define SYNC_URBS 4 /* always four urbs for sync */ #define MIN_PACKS_URB 1 /* minimum 1 packet per urb */ +typedef struct snd_usb_substream snd_usb_substream_t; +typedef struct snd_usb_stream snd_usb_stream_t; +typedef struct snd_urb_ctx snd_urb_ctx_t; + struct audioformat { struct list_head list; snd_pcm_format_t format; /* format type */ @@ -121,27 +125,25 @@ struct audioformat { unsigned int *rate_table; /* rate table */ }; -struct snd_usb_substream; - struct snd_urb_ctx { struct urb *urb; unsigned int buffer_size; /* size of data buffer, if data URB */ - struct snd_usb_substream *subs; + snd_usb_substream_t *subs; int index; /* index for urb array */ int packets; /* number of packets per urb */ }; struct snd_urb_ops { - int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); - int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); - int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); - int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u); + int (*prepare)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u); + int (*retire)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u); + int (*prepare_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u); + int (*retire_sync)(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime, struct urb *u); }; struct snd_usb_substream { - struct snd_usb_stream *stream; + snd_usb_stream_t *stream; struct usb_device *dev; - struct snd_pcm_substream *pcm_substream; + snd_pcm_substream_t *pcm_substream; int direction; /* playback or capture */ int interface; /* current interface */ int endpoint; /* assigned endpoint */ @@ -173,8 +175,8 @@ struct snd_usb_substream { unsigned long unlink_mask; /* bitmask of unlinked urbs */ unsigned int nurbs; /* # urbs */ - struct snd_urb_ctx dataurb[MAX_URBS]; /* data urb table */ - struct snd_urb_ctx syncurb[SYNC_URBS]; /* sync urb table */ + snd_urb_ctx_t dataurb[MAX_URBS]; /* data urb table */ + snd_urb_ctx_t syncurb[SYNC_URBS]; /* sync urb table */ char *syncbuf; /* sync buffer for all sync URBs */ dma_addr_t sync_dma; /* DMA address of syncbuf */ @@ -188,11 +190,11 @@ struct snd_usb_substream { struct snd_usb_stream { - struct snd_usb_audio *chip; - struct snd_pcm *pcm; + snd_usb_audio_t *chip; + snd_pcm_t *pcm; int pcm_index; unsigned int fmt_type; /* USB audio format type (1-3) */ - struct snd_usb_substream substream[2]; + snd_usb_substream_t substream[2]; struct list_head list; }; @@ -203,7 +205,7 @@ struct snd_usb_stream { */ static DECLARE_MUTEX(register_mutex); -static struct snd_usb_audio *usb_chip[SNDRV_CARDS]; +static snd_usb_audio_t *usb_chip[SNDRV_CARDS]; /* @@ -243,12 +245,12 @@ static inline unsigned get_high_speed_hz(unsigned int usb_rate) * fill the length and offset of each urb descriptor. * the fixed 10.14 frequency is passed through the pipe. */ -static int prepare_capture_sync_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int prepare_capture_sync_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { unsigned char *cp = urb->transfer_buffer; - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; urb->dev = ctx->subs->dev; /* we need to set this at each time */ urb->iso_frame_desc[0].length = 3; @@ -265,12 +267,12 @@ static int prepare_capture_sync_urb(struct snd_usb_substream *subs, * fill the length and offset of each urb descriptor. * the fixed 12.13 frequency is passed as 16.16 through the pipe. */ -static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int prepare_capture_sync_urb_hs(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { unsigned char *cp = urb->transfer_buffer; - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; urb->dev = ctx->subs->dev; /* we need to set this at each time */ urb->iso_frame_desc[0].length = 4; @@ -286,8 +288,8 @@ static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs, * process after capture sync complete * - nothing to do */ -static int retire_capture_sync_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int retire_capture_sync_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { return 0; @@ -303,12 +305,12 @@ static int retire_capture_sync_urb(struct snd_usb_substream *subs, * write onto the pcm buffer directly... the data is thus copied * later at complete callback to the global buffer. */ -static int prepare_capture_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int prepare_capture_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { int i, offs; - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; offs = 0; urb->dev = ctx->subs->dev; /* we need to set this at each time */ @@ -338,8 +340,8 @@ static int prepare_capture_urb(struct snd_usb_substream *subs, * copy the data from each desctiptor to the pcm buffer, and * update the current position. */ -static int retire_capture_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int retire_capture_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { unsigned long flags; @@ -393,11 +395,11 @@ static int retire_capture_urb(struct snd_usb_substream *subs, * set up the offset and length to receive the current frequency. */ -static int prepare_playback_sync_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int prepare_playback_sync_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; urb->dev = ctx->subs->dev; /* we need to set this at each time */ urb->iso_frame_desc[0].length = 3; @@ -411,11 +413,11 @@ static int prepare_playback_sync_urb(struct snd_usb_substream *subs, * set up the offset and length to receive the current frequency. */ -static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int prepare_playback_sync_urb_hs(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; urb->dev = ctx->subs->dev; /* we need to set this at each time */ urb->iso_frame_desc[0].length = 4; @@ -429,8 +431,8 @@ static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs, * retrieve the current 10.14 frequency from pipe, and set it. * the value is referred in prepare_playback_urb(). */ -static int retire_playback_sync_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int retire_playback_sync_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { unsigned int f; @@ -455,8 +457,8 @@ static int retire_playback_sync_urb(struct snd_usb_substream *subs, * retrieve the current 12.13 frequency from pipe, and set it. * the value is referred in prepare_playback_urb(). */ -static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int retire_playback_sync_urb_hs(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { unsigned int f; @@ -480,12 +482,12 @@ static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs, * * We don't care about (or have) any data, so we just send a transfer delimiter. */ -static int prepare_startup_playback_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int prepare_startup_playback_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { unsigned int i; - struct snd_urb_ctx *ctx = urb->context; + snd_urb_ctx_t *ctx = urb->context; urb->dev = ctx->subs->dev; urb->number_of_packets = subs->packs_per_ms; @@ -505,15 +507,15 @@ static int prepare_startup_playback_urb(struct snd_usb_substream *subs, * To avoid inconsistencies when updating hwptr_done, we use double buffering * for all URBs. */ -static int prepare_playback_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int prepare_playback_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { int i, stride, offs; unsigned int counts; unsigned long flags; int period_elapsed = 0; - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; stride = runtime->frame_bits >> 3; @@ -595,8 +597,8 @@ static int prepare_playback_urb(struct snd_usb_substream *subs, * process after playback data complete * - nothing to do */ -static int retire_playback_urb(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, +static int retire_playback_urb(snd_usb_substream_t *subs, + snd_pcm_runtime_t *runtime, struct urb *urb) { return 0; @@ -640,9 +642,9 @@ static struct snd_urb_ops audio_urb_ops_high_speed[2] = { */ static void snd_complete_urb(struct urb *urb, struct pt_regs *regs) { - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; - struct snd_usb_substream *subs = ctx->subs; - struct snd_pcm_substream *substream = ctx->subs->pcm_substream; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; + snd_usb_substream_t *subs = ctx->subs; + snd_pcm_substream_t *substream = ctx->subs->pcm_substream; int err = 0; if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) || @@ -663,9 +665,9 @@ static void snd_complete_urb(struct urb *urb, struct pt_regs *regs) */ static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs) { - struct snd_urb_ctx *ctx = (struct snd_urb_ctx *)urb->context; - struct snd_usb_substream *subs = ctx->subs; - struct snd_pcm_substream *substream = ctx->subs->pcm_substream; + snd_urb_ctx_t *ctx = (snd_urb_ctx_t *)urb->context; + snd_usb_substream_t *subs = ctx->subs; + snd_pcm_substream_t *substream = ctx->subs->pcm_substream; int err = 0; if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) || @@ -682,7 +684,7 @@ static void snd_complete_sync_urb(struct urb *urb, struct pt_regs *regs) /* get the physical page pointer at the given offset */ -static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, +static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs, unsigned long offset) { void *pageptr = subs->runtime->dma_area + offset; @@ -690,9 +692,9 @@ static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs, } /* allocate virtual buffer; may be called more than once */ -static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size) +static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size) { - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (runtime->dma_area) { if (runtime->dma_bytes >= size) return 0; /* already large enough */ @@ -706,9 +708,9 @@ static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t s } /* free virtual buffer; may be called more than once */ -static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs) +static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs) { - struct snd_pcm_runtime *runtime = subs->runtime; + snd_pcm_runtime_t *runtime = subs->runtime; if (runtime->dma_area) { vfree(runtime->dma_area); runtime->dma_area = NULL; @@ -720,7 +722,7 @@ static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs) /* * unlink active urbs. */ -static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep) +static int deactivate_urbs(snd_usb_substream_t *subs, int force, int can_sleep) { unsigned int i; int async; @@ -766,7 +768,7 @@ static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sl /* * set up and start data/sync urbs */ -static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime) +static int start_urbs(snd_usb_substream_t *subs, snd_pcm_runtime_t *runtime) { unsigned int i; int err; @@ -822,7 +824,7 @@ static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *ru /* * wait until all urbs are processed. */ -static int wait_clear_urbs(struct snd_usb_substream *subs) +static int wait_clear_urbs(snd_usb_substream_t *subs) { unsigned long end_time = jiffies + msecs_to_jiffies(1000); unsigned int i; @@ -853,12 +855,12 @@ static int wait_clear_urbs(struct snd_usb_substream *subs) /* * return the current pcm pointer. just return the hwptr_done value. */ -static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_usb_pcm_pointer(snd_pcm_substream_t *substream) { - struct snd_usb_substream *subs; + snd_usb_substream_t *subs; snd_pcm_uframes_t hwptr_done; - subs = (struct snd_usb_substream *)substream->runtime->private_data; + subs = (snd_usb_substream_t *)substream->runtime->private_data; spin_lock(&subs->lock); hwptr_done = subs->hwptr_done; spin_unlock(&subs->lock); @@ -869,10 +871,10 @@ static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream /* * start/stop playback substream */ -static int snd_usb_pcm_playback_trigger(struct snd_pcm_substream *substream, +static int snd_usb_pcm_playback_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_usb_substream *subs = substream->runtime->private_data; + snd_usb_substream_t *subs = substream->runtime->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -888,10 +890,10 @@ static int snd_usb_pcm_playback_trigger(struct snd_pcm_substream *substream, /* * start/stop capture substream */ -static int snd_usb_pcm_capture_trigger(struct snd_pcm_substream *substream, +static int snd_usb_pcm_capture_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_usb_substream *subs = substream->runtime->private_data; + snd_usb_substream_t *subs = substream->runtime->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -907,7 +909,7 @@ static int snd_usb_pcm_capture_trigger(struct snd_pcm_substream *substream, /* * release a urb data */ -static void release_urb_ctx(struct snd_urb_ctx *u) +static void release_urb_ctx(snd_urb_ctx_t *u) { if (u->urb) { if (u->buffer_size) @@ -922,7 +924,7 @@ static void release_urb_ctx(struct snd_urb_ctx *u) /* * release a substream */ -static void release_substream_urbs(struct snd_usb_substream *subs, int force) +static void release_substream_urbs(snd_usb_substream_t *subs, int force) { int i; @@ -943,7 +945,7 @@ static void release_substream_urbs(struct snd_usb_substream *subs, int force) /* * initialize a substream for plaback/capture */ -static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int period_bytes, +static int init_substream_urbs(snd_usb_substream_t *subs, unsigned int period_bytes, unsigned int rate, unsigned int frame_bits) { unsigned int maxsize, n, i; @@ -1043,7 +1045,7 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri /* allocate and initialize data urbs */ for (i = 0; i < subs->nurbs; i++) { - struct snd_urb_ctx *u = &subs->dataurb[i]; + snd_urb_ctx_t *u = &subs->dataurb[i]; u->index = i; u->subs = subs; u->packets = npacks[i]; @@ -1072,7 +1074,7 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri if (! subs->syncbuf) goto out_of_memory; for (i = 0; i < SYNC_URBS; i++) { - struct snd_urb_ctx *u = &subs->syncurb[i]; + snd_urb_ctx_t *u = &subs->syncurb[i]; u->index = i; u->subs = subs; u->packets = 1; @@ -1102,7 +1104,7 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri /* * find a matching audio format */ -static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format, +static struct audioformat *find_format(snd_usb_substream_t *subs, unsigned int format, unsigned int rate, unsigned int channels) { struct list_head *p; @@ -1227,7 +1229,7 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface, /* * find a matching format and set up the interface */ -static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) +static int set_format(snd_usb_substream_t *subs, struct audioformat *fmt) { struct usb_device *dev = subs->dev; struct usb_host_interface *alts; @@ -1356,10 +1358,10 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) * if sg buffer is supported on the later version of alsa, we'll follow * that. */ -static int snd_usb_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_usb_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { - struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data; + snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data; struct audioformat *fmt; unsigned int channels, rate, format; int ret, changed; @@ -1413,9 +1415,9 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream, * * reset the audio format and release the buffer */ -static int snd_usb_hw_free(struct snd_pcm_substream *substream) +static int snd_usb_hw_free(snd_pcm_substream_t *substream) { - struct snd_usb_substream *subs = (struct snd_usb_substream *)substream->runtime->private_data; + snd_usb_substream_t *subs = (snd_usb_substream_t *)substream->runtime->private_data; subs->cur_audiofmt = NULL; subs->cur_rate = 0; @@ -1429,10 +1431,10 @@ static int snd_usb_hw_free(struct snd_pcm_substream *substream) * * only a few subtle things... */ -static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_usb_pcm_prepare(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usb_substream *subs = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usb_substream_t *subs = runtime->private_data; if (! subs->cur_audiofmt) { snd_printk(KERN_ERR "usbaudio: no format is specified!\n"); @@ -1461,7 +1463,7 @@ static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream) return 0; } -static struct snd_pcm_hardware snd_usb_playback = +static snd_pcm_hardware_t snd_usb_playback = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -1475,7 +1477,7 @@ static struct snd_pcm_hardware snd_usb_playback = .periods_max = 1024, }; -static struct snd_pcm_hardware snd_usb_capture = +static snd_pcm_hardware_t snd_usb_capture = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | @@ -1499,11 +1501,11 @@ static struct snd_pcm_hardware snd_usb_capture = #define hwc_debug(fmt, args...) /**/ #endif -static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audioformat *fp) +static int hw_check_valid_format(snd_pcm_hw_params_t *params, struct audioformat *fp) { - struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); - struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); - struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); + snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + snd_interval_t *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_mask_t *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); /* check the format */ if (! snd_mask_test(fmts, fp->format)) { @@ -1527,12 +1529,12 @@ static int hw_check_valid_format(struct snd_pcm_hw_params *params, struct audiof return 1; } -static int hw_rule_rate(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int hw_rule_rate(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_usb_substream *subs = rule->private; + snd_usb_substream_t *subs = rule->private; struct list_head *p; - struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); + snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); unsigned int rmin, rmax; int changed; @@ -1581,12 +1583,12 @@ static int hw_rule_rate(struct snd_pcm_hw_params *params, } -static int hw_rule_channels(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int hw_rule_channels(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_usb_substream *subs = rule->private; + snd_usb_substream_t *subs = rule->private; struct list_head *p; - struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); + snd_interval_t *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); unsigned int rmin, rmax; int changed; @@ -1634,12 +1636,12 @@ static int hw_rule_channels(struct snd_pcm_hw_params *params, return changed; } -static int hw_rule_format(struct snd_pcm_hw_params *params, - struct snd_pcm_hw_rule *rule) +static int hw_rule_format(snd_pcm_hw_params_t *params, + snd_pcm_hw_rule_t *rule) { - struct snd_usb_substream *subs = rule->private; + snd_usb_substream_t *subs = rule->private; struct list_head *p; - struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); + snd_mask_t *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); u64 fbits; u32 oldbits[2]; int changed; @@ -1672,7 +1674,7 @@ static int hw_rule_format(struct snd_pcm_hw_params *params, /* * check whether the registered audio formats need special hw-constraints */ -static int check_hw_params_convention(struct snd_usb_substream *subs) +static int check_hw_params_convention(snd_usb_substream_t *subs) { int i; u32 *channels; @@ -1756,7 +1758,7 @@ static int check_hw_params_convention(struct snd_usb_substream *subs) * set up the runtime hardware information. */ -static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs) +static int setup_hw_info(snd_pcm_runtime_t *runtime, snd_usb_substream_t *subs) { struct list_head *p; int err; @@ -1817,12 +1819,12 @@ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substre return 0; } -static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction, - struct snd_pcm_hardware *hw) +static int snd_usb_pcm_open(snd_pcm_substream_t *substream, int direction, + snd_pcm_hardware_t *hw) { - struct snd_usb_stream *as = snd_pcm_substream_chip(substream); - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usb_substream *subs = &as->substream[direction]; + snd_usb_stream_t *as = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usb_substream_t *subs = &as->substream[direction]; subs->interface = -1; subs->format = 0; @@ -1832,10 +1834,10 @@ static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction, return setup_hw_info(runtime, subs); } -static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction) +static int snd_usb_pcm_close(snd_pcm_substream_t *substream, int direction) { - struct snd_usb_stream *as = snd_pcm_substream_chip(substream); - struct snd_usb_substream *subs = &as->substream[direction]; + snd_usb_stream_t *as = snd_pcm_substream_chip(substream); + snd_usb_substream_t *subs = &as->substream[direction]; if (subs->interface >= 0) { usb_set_interface(subs->dev, subs->interface, 0); @@ -1845,27 +1847,27 @@ static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction) return 0; } -static int snd_usb_playback_open(struct snd_pcm_substream *substream) +static int snd_usb_playback_open(snd_pcm_substream_t *substream) { return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_playback); } -static int snd_usb_playback_close(struct snd_pcm_substream *substream) +static int snd_usb_playback_close(snd_pcm_substream_t *substream) { return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK); } -static int snd_usb_capture_open(struct snd_pcm_substream *substream) +static int snd_usb_capture_open(snd_pcm_substream_t *substream) { return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_capture); } -static int snd_usb_capture_close(struct snd_pcm_substream *substream) +static int snd_usb_capture_close(snd_pcm_substream_t *substream) { return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE); } -static struct snd_pcm_ops snd_usb_playback_ops = { +static snd_pcm_ops_t snd_usb_playback_ops = { .open = snd_usb_playback_open, .close = snd_usb_playback_close, .ioctl = snd_pcm_lib_ioctl, @@ -1877,7 +1879,7 @@ static struct snd_pcm_ops snd_usb_playback_ops = { .page = snd_pcm_get_vmalloc_page, }; -static struct snd_pcm_ops snd_usb_capture_ops = { +static snd_pcm_ops_t snd_usb_capture_ops = { .open = snd_usb_capture_open, .close = snd_usb_capture_close, .ioctl = snd_pcm_lib_ioctl, @@ -1994,6 +1996,7 @@ static struct usb_device_id usb_audio_ids [] = { MODULE_DEVICE_TABLE (usb, usb_audio_ids); static struct usb_driver usb_audio_driver = { + .owner = THIS_MODULE, .name = "snd-usb-audio", .probe = usb_audio_probe, .disconnect = usb_audio_disconnect, @@ -2004,7 +2007,7 @@ static struct usb_driver usb_audio_driver = { /* * proc interface for list the supported pcm formats */ -static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer) +static void proc_dump_substream_formats(snd_usb_substream_t *subs, snd_info_buffer_t *buffer) { struct list_head *p; static char *sync_types[4] = { @@ -2040,7 +2043,7 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s } } -static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer) +static void proc_dump_substream_status(snd_usb_substream_t *subs, snd_info_buffer_t *buffer) { if (subs->running) { unsigned int i; @@ -2062,9 +2065,9 @@ static void proc_dump_substream_status(struct snd_usb_substream *subs, struct sn } } -static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void proc_pcm_format_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_usb_stream *stream = entry->private_data; + snd_usb_stream_t *stream = entry->private_data; snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name); @@ -2080,11 +2083,11 @@ static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_b } } -static void proc_pcm_format_add(struct snd_usb_stream *stream) +static void proc_pcm_format_add(snd_usb_stream_t *stream) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; char name[32]; - struct snd_card *card = stream->chip->card; + snd_card_t *card = stream->chip->card; sprintf(name, "stream%d", stream->pcm_index); if (! snd_card_proc_new(card, name, &entry)) @@ -2096,9 +2099,9 @@ static void proc_pcm_format_add(struct snd_usb_stream *stream) * initialize the substream instance. */ -static void init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp) +static void init_substream(snd_usb_stream_t *as, int stream, struct audioformat *fp) { - struct snd_usb_substream *subs = &as->substream[stream]; + snd_usb_substream_t *subs = &as->substream[stream]; INIT_LIST_HEAD(&subs->fmt_list); spin_lock_init(&subs->lock); @@ -2125,7 +2128,7 @@ static void init_substream(struct snd_usb_stream *as, int stream, struct audiofo /* * free a substream */ -static void free_substream(struct snd_usb_substream *subs) +static void free_substream(snd_usb_substream_t *subs) { struct list_head *p, *n; @@ -2142,7 +2145,7 @@ static void free_substream(struct snd_usb_substream *subs) /* * free a usb stream instance */ -static void snd_usb_audio_stream_free(struct snd_usb_stream *stream) +static void snd_usb_audio_stream_free(snd_usb_stream_t *stream) { free_substream(&stream->substream[0]); free_substream(&stream->substream[1]); @@ -2150,9 +2153,9 @@ static void snd_usb_audio_stream_free(struct snd_usb_stream *stream) kfree(stream); } -static void snd_usb_audio_pcm_free(struct snd_pcm *pcm) +static void snd_usb_audio_pcm_free(snd_pcm_t *pcm) { - struct snd_usb_stream *stream = pcm->private_data; + snd_usb_stream_t *stream = pcm->private_data; if (stream) { stream->pcm = NULL; snd_usb_audio_stream_free(stream); @@ -2165,16 +2168,16 @@ static void snd_usb_audio_pcm_free(struct snd_pcm *pcm) * if a stream with the same endpoint already exists, append to it. * if not, create a new pcm stream. */ -static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct audioformat *fp) +static int add_audio_endpoint(snd_usb_audio_t *chip, int stream, struct audioformat *fp) { struct list_head *p; - struct snd_usb_stream *as; - struct snd_usb_substream *subs; - struct snd_pcm *pcm; + snd_usb_stream_t *as; + snd_usb_substream_t *subs; + snd_pcm_t *pcm; int err; list_for_each(p, &chip->pcm_list) { - as = list_entry(p, struct snd_usb_stream, list); + as = list_entry(p, snd_usb_stream_t, list); if (as->fmt_type != fp->fmt_type) continue; subs = &as->substream[stream]; @@ -2189,7 +2192,7 @@ static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct aud } /* look for an empty stream */ list_for_each(p, &chip->pcm_list) { - as = list_entry(p, struct snd_usb_stream, list); + as = list_entry(p, snd_usb_stream_t, list); if (as->fmt_type != fp->fmt_type) continue; subs = &as->substream[stream]; @@ -2241,7 +2244,7 @@ static int add_audio_endpoint(struct snd_usb_audio *chip, int stream, struct aud /* * check if the device uses big-endian samples */ -static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp) +static int is_big_endian_format(snd_usb_audio_t *chip, struct audioformat *fp) { switch (chip->usb_id) { case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */ @@ -2263,7 +2266,7 @@ static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat * * @format: the format tag (wFormatTag) * @fmt: the format type descriptor */ -static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp, +static int parse_audio_format_i_type(snd_usb_audio_t *chip, struct audioformat *fp, int format, unsigned char *fmt) { int pcm_format; @@ -2346,7 +2349,7 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor * @offset: the start offset of descriptor pointing the rate type * (7 for type I and II, 8 for type II) */ -static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp, +static int parse_audio_format_rates(snd_usb_audio_t *chip, struct audioformat *fp, unsigned char *fmt, int offset) { int nr_rates = fmt[offset]; @@ -2399,7 +2402,7 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform /* * parse the format type I and III descriptors */ -static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp, +static int parse_audio_format_i(snd_usb_audio_t *chip, struct audioformat *fp, int format, unsigned char *fmt) { int pcm_format; @@ -2428,7 +2431,7 @@ static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat * /* * prase the format type II descriptor */ -static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp, +static int parse_audio_format_ii(snd_usb_audio_t *chip, struct audioformat *fp, int format, unsigned char *fmt) { int brate, framesize; @@ -2455,7 +2458,7 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */ } -static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp, +static int parse_audio_format(snd_usb_audio_t *chip, struct audioformat *fp, int format, unsigned char *fmt, int stream) { int err; @@ -2492,7 +2495,7 @@ static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp return 0; } -static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no) +static int parse_audio_endpoints(snd_usb_audio_t *chip, int iface_no) { struct usb_device *dev; struct usb_interface *iface; @@ -2643,10 +2646,10 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no) static void snd_usb_stream_disconnect(struct list_head *head) { int idx; - struct snd_usb_stream *as; - struct snd_usb_substream *subs; + snd_usb_stream_t *as; + snd_usb_substream_t *subs; - as = list_entry(head, struct snd_usb_stream, list); + as = list_entry(head, snd_usb_stream_t, list); for (idx = 0; idx < 2; idx++) { subs = &as->substream[idx]; if (!subs->num_formats) @@ -2659,7 +2662,7 @@ static void snd_usb_stream_disconnect(struct list_head *head) /* * parse audio control descriptor and create pcm/midi streams */ -static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) +static int snd_usb_create_streams(snd_usb_audio_t *chip, int ctrlif) { struct usb_device *dev = chip->dev; struct usb_host_interface *host_iface; @@ -2726,9 +2729,9 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) /* * create a stream for an endpoint/altsetting without proper descriptors */ -static int create_fixed_stream_quirk(struct snd_usb_audio *chip, +static int create_fixed_stream_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk) + const snd_usb_audio_quirk_t *quirk) { struct audioformat *fp; struct usb_host_interface *alts; @@ -2775,9 +2778,9 @@ static int create_fixed_stream_quirk(struct snd_usb_audio *chip, /* * create a stream for an interface with proper descriptors */ -static int create_standard_audio_quirk(struct snd_usb_audio *chip, +static int create_standard_audio_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk) + const snd_usb_audio_quirk_t *quirk) { struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; @@ -2800,9 +2803,9 @@ static int create_standard_audio_quirk(struct snd_usb_audio *chip, * Create a stream for an Edirol UA-700/UA-25 interface. The only way * to detect the sample rate is by looking at wMaxPacketSize. */ -static int create_ua700_ua25_quirk(struct snd_usb_audio *chip, +static int create_ua700_ua25_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk) + const snd_usb_audio_quirk_t *quirk) { static const struct audioformat ua_format = { .format = SNDRV_PCM_FORMAT_S24_3LE, @@ -2824,19 +2827,19 @@ static int create_ua700_ua25_quirk(struct snd_usb_audio *chip, altsd = get_iface_desc(alts); if (altsd->bNumEndpoints == 2) { - static const struct snd_usb_midi_endpoint_info ua700_ep = { + static const snd_usb_midi_endpoint_info_t ua700_ep = { .out_cables = 0x0003, .in_cables = 0x0003 }; - static const struct snd_usb_audio_quirk ua700_quirk = { + static const snd_usb_audio_quirk_t ua700_quirk = { .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &ua700_ep }; - static const struct snd_usb_midi_endpoint_info ua25_ep = { + static const snd_usb_midi_endpoint_info_t ua25_ep = { .out_cables = 0x0001, .in_cables = 0x0001 }; - static const struct snd_usb_audio_quirk ua25_quirk = { + static const snd_usb_audio_quirk_t ua25_quirk = { .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &ua25_ep }; @@ -2893,9 +2896,9 @@ static int create_ua700_ua25_quirk(struct snd_usb_audio *chip, /* * Create a stream for an Edirol UA-1000 interface. */ -static int create_ua1000_quirk(struct snd_usb_audio *chip, +static int create_ua1000_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk) + const snd_usb_audio_quirk_t *quirk) { static const struct audioformat ua1000_format = { .format = SNDRV_PCM_FORMAT_S32_LE, @@ -2942,16 +2945,16 @@ static int create_ua1000_quirk(struct snd_usb_audio *chip, return 0; } -static int snd_usb_create_quirk(struct snd_usb_audio *chip, +static int snd_usb_create_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk); + const snd_usb_audio_quirk_t *quirk); /* * handle the quirks for the contained interfaces */ -static int create_composite_quirk(struct snd_usb_audio *chip, +static int create_composite_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk) + const snd_usb_audio_quirk_t *quirk) { int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber; int err; @@ -2972,9 +2975,9 @@ static int create_composite_quirk(struct snd_usb_audio *chip, return 0; } -static int ignore_interface_quirk(struct snd_usb_audio *chip, +static int ignore_interface_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk) + const snd_usb_audio_quirk_t *quirk) { return 0; } @@ -3037,12 +3040,12 @@ static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev) * after this. * returns a negative value at error. */ -static int snd_usb_create_quirk(struct snd_usb_audio *chip, +static int snd_usb_create_quirk(snd_usb_audio_t *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk) + const snd_usb_audio_quirk_t *quirk) { - typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *, - const struct snd_usb_audio_quirk *); + typedef int (*quirk_func_t)(snd_usb_audio_t *, struct usb_interface *, + const snd_usb_audio_quirk_t *); static const quirk_func_t quirk_funcs[] = { [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk, [QUIRK_COMPOSITE] = create_composite_quirk, @@ -3072,25 +3075,25 @@ static int snd_usb_create_quirk(struct snd_usb_audio *chip, /* * common proc files to show the usb device info */ -static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void proc_audio_usbbus_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_usb_audio *chip = entry->private_data; + snd_usb_audio_t *chip = entry->private_data; if (! chip->shutdown) snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum); } -static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +static void proc_audio_usbid_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { - struct snd_usb_audio *chip = entry->private_data; + snd_usb_audio_t *chip = entry->private_data; if (! chip->shutdown) snd_iprintf(buffer, "%04x:%04x\n", USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); } -static void snd_usb_audio_create_proc(struct snd_usb_audio *chip) +static void snd_usb_audio_create_proc(snd_usb_audio_t *chip) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "usbbus", &entry)) snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbbus_read); if (! snd_card_proc_new(chip->card, "usbid", &entry)) @@ -3104,15 +3107,15 @@ static void snd_usb_audio_create_proc(struct snd_usb_audio *chip) * */ -static int snd_usb_audio_free(struct snd_usb_audio *chip) +static int snd_usb_audio_free(snd_usb_audio_t *chip) { kfree(chip); return 0; } -static int snd_usb_audio_dev_free(struct snd_device *device) +static int snd_usb_audio_dev_free(snd_device_t *device) { - struct snd_usb_audio *chip = device->device_data; + snd_usb_audio_t *chip = device->device_data; return snd_usb_audio_free(chip); } @@ -3121,14 +3124,14 @@ static int snd_usb_audio_dev_free(struct snd_device *device) * create a chip instance and set its names. */ static int snd_usb_audio_create(struct usb_device *dev, int idx, - const struct snd_usb_audio_quirk *quirk, - struct snd_usb_audio **rchip) + const snd_usb_audio_quirk_t *quirk, + snd_usb_audio_t **rchip) { - struct snd_card *card; - struct snd_usb_audio *chip; + snd_card_t *card; + snd_usb_audio_t *chip; int err, len; char component[14]; - static struct snd_device_ops ops = { + static snd_device_ops_t ops = { .dev_free = snd_usb_audio_dev_free, }; @@ -3232,9 +3235,9 @@ static void *snd_usb_audio_probe(struct usb_device *dev, struct usb_interface *intf, const struct usb_device_id *usb_id) { - const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info; + const snd_usb_audio_quirk_t *quirk = (const snd_usb_audio_quirk_t *)usb_id->driver_info; int i, err; - struct snd_usb_audio *chip; + snd_usb_audio_t *chip; struct usb_host_interface *alts; int ifnum; u32 id; @@ -3335,8 +3338,8 @@ static void *snd_usb_audio_probe(struct usb_device *dev, */ static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr) { - struct snd_usb_audio *chip; - struct snd_card *card; + snd_usb_audio_t *chip; + snd_card_t *card; struct list_head *p; if (ptr == (void *)-1L) diff --git a/trunk/sound/usb/usbaudio.h b/trunk/sound/usb/usbaudio.h index ecd724bfe5a5..b5802022bb19 100644 --- a/trunk/sound/usb/usbaudio.h +++ b/trunk/sound/usb/usbaudio.h @@ -126,10 +126,12 @@ /* */ +typedef struct snd_usb_audio snd_usb_audio_t; + struct snd_usb_audio { int index; struct usb_device *dev; - struct snd_card *card; + snd_card_t *card; u32 usb_id; int shutdown; int num_interfaces; @@ -170,6 +172,9 @@ enum quirk_type { QUIRK_TYPE_COUNT }; +typedef struct snd_usb_audio_quirk snd_usb_audio_quirk_t; +typedef struct snd_usb_midi_endpoint_info snd_usb_midi_endpoint_info_t; + struct snd_usb_audio_quirk { const char *vendor_name; const char *product_name; @@ -223,15 +228,12 @@ unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size); void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype); void *snd_usb_find_csint_desc(void *descstart, int desclen, void *after, u8 dsubtype); -int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, - __u8 request, __u8 requesttype, __u16 value, __u16 index, - void *data, __u16 size, int timeout); +int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype, __u16 value, __u16 index, void *data, __u16 size, int timeout); -int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif); +int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif); void snd_usb_mixer_disconnect(struct list_head *p); -int snd_usb_create_midi_interface(struct snd_usb_audio *chip, struct usb_interface *iface, - const struct snd_usb_audio_quirk *quirk); +int snd_usb_create_midi_interface(snd_usb_audio_t *chip, struct usb_interface *iface, const snd_usb_audio_quirk_t *quirk); void snd_usbmidi_input_stop(struct list_head* p); void snd_usbmidi_input_start(struct list_head* p); void snd_usbmidi_disconnect(struct list_head *p); diff --git a/trunk/sound/usb/usbmidi.c b/trunk/sound/usb/usbmidi.c index f15b021c3ce8..f8aa662562a0 100644 --- a/trunk/sound/usb/usbmidi.c +++ b/trunk/sound/usb/usbmidi.c @@ -84,36 +84,39 @@ struct usb_ms_endpoint_descriptor { __u8 baAssocJackID[0]; } __attribute__ ((packed)); -struct snd_usb_midi_in_endpoint; -struct snd_usb_midi_out_endpoint; -struct snd_usb_midi_endpoint; +typedef struct snd_usb_midi snd_usb_midi_t; +typedef struct snd_usb_midi_endpoint snd_usb_midi_endpoint_t; +typedef struct snd_usb_midi_out_endpoint snd_usb_midi_out_endpoint_t; +typedef struct snd_usb_midi_in_endpoint snd_usb_midi_in_endpoint_t; +typedef struct usbmidi_out_port usbmidi_out_port_t; +typedef struct usbmidi_in_port usbmidi_in_port_t; struct usb_protocol_ops { - void (*input)(struct snd_usb_midi_in_endpoint*, uint8_t*, int); - void (*output)(struct snd_usb_midi_out_endpoint*); + void (*input)(snd_usb_midi_in_endpoint_t*, uint8_t*, int); + void (*output)(snd_usb_midi_out_endpoint_t*); void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t); - void (*init_out_endpoint)(struct snd_usb_midi_out_endpoint*); - void (*finish_out_endpoint)(struct snd_usb_midi_out_endpoint*); + void (*init_out_endpoint)(snd_usb_midi_out_endpoint_t*); + void (*finish_out_endpoint)(snd_usb_midi_out_endpoint_t*); }; struct snd_usb_midi { - struct snd_usb_audio *chip; + snd_usb_audio_t *chip; struct usb_interface *iface; - const struct snd_usb_audio_quirk *quirk; - struct snd_rawmidi *rmidi; + const snd_usb_audio_quirk_t *quirk; + snd_rawmidi_t* rmidi; struct usb_protocol_ops* usb_protocol_ops; struct list_head list; struct timer_list error_timer; struct snd_usb_midi_endpoint { - struct snd_usb_midi_out_endpoint *out; - struct snd_usb_midi_in_endpoint *in; + snd_usb_midi_out_endpoint_t *out; + snd_usb_midi_in_endpoint_t *in; } endpoints[MIDI_MAX_ENDPOINTS]; unsigned long input_triggered; }; struct snd_usb_midi_out_endpoint { - struct snd_usb_midi* umidi; + snd_usb_midi_t* umidi; struct urb* urb; int urb_active; int max_transfer; /* size of urb buffer */ @@ -122,8 +125,8 @@ struct snd_usb_midi_out_endpoint { spinlock_t buffer_lock; struct usbmidi_out_port { - struct snd_usb_midi_out_endpoint* ep; - struct snd_rawmidi_substream *substream; + snd_usb_midi_out_endpoint_t* ep; + snd_rawmidi_substream_t* substream; int active; uint8_t cable; /* cable number << 4 */ uint8_t state; @@ -140,17 +143,17 @@ struct snd_usb_midi_out_endpoint { }; struct snd_usb_midi_in_endpoint { - struct snd_usb_midi* umidi; + snd_usb_midi_t* umidi; struct urb* urb; struct usbmidi_in_port { - struct snd_rawmidi_substream *substream; + snd_rawmidi_substream_t* substream; } ports[0x10]; u8 seen_f5; u8 error_resubmit; int current_port; }; -static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep); +static void snd_usbmidi_do_output(snd_usb_midi_out_endpoint_t* ep); static const uint8_t snd_usbmidi_cin_length[] = { 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 @@ -193,10 +196,10 @@ static int snd_usbmidi_urb_error(int status) /* * Receives a chunk of MIDI data. */ -static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint* ep, int portidx, +static void snd_usbmidi_input_data(snd_usb_midi_in_endpoint_t* ep, int portidx, uint8_t* data, int length) { - struct usbmidi_in_port* port = &ep->ports[portidx]; + usbmidi_in_port_t* port = &ep->ports[portidx]; if (!port->substream) { snd_printd("unexpected port %d!\n", portidx); @@ -224,7 +227,7 @@ static void dump_urb(const char *type, const u8 *data, int length) */ static void snd_usbmidi_in_urb_complete(struct urb* urb, struct pt_regs *regs) { - struct snd_usb_midi_in_endpoint* ep = urb->context; + snd_usb_midi_in_endpoint_t* ep = urb->context; if (urb->status == 0) { dump_urb("received", urb->transfer_buffer, urb->actual_length); @@ -248,7 +251,7 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb, struct pt_regs *regs) static void snd_usbmidi_out_urb_complete(struct urb* urb, struct pt_regs *regs) { - struct snd_usb_midi_out_endpoint* ep = urb->context; + snd_usb_midi_out_endpoint_t* ep = urb->context; spin_lock(&ep->buffer_lock); ep->urb_active = 0; @@ -269,7 +272,7 @@ static void snd_usbmidi_out_urb_complete(struct urb* urb, struct pt_regs *regs) * This is called when some data should be transferred to the device * (from one or more substreams). */ -static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_do_output(snd_usb_midi_out_endpoint_t* ep) { struct urb* urb = ep->urb; unsigned long flags; @@ -294,7 +297,7 @@ static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep) static void snd_usbmidi_out_tasklet(unsigned long data) { - struct snd_usb_midi_out_endpoint* ep = (struct snd_usb_midi_out_endpoint *) data; + snd_usb_midi_out_endpoint_t* ep = (snd_usb_midi_out_endpoint_t *) data; snd_usbmidi_do_output(ep); } @@ -302,11 +305,11 @@ static void snd_usbmidi_out_tasklet(unsigned long data) /* called after transfers had been interrupted due to some USB error */ static void snd_usbmidi_error_timer(unsigned long data) { - struct snd_usb_midi *umidi = (struct snd_usb_midi *)data; + snd_usb_midi_t *umidi = (snd_usb_midi_t *)data; int i; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { - struct snd_usb_midi_in_endpoint *in = umidi->endpoints[i].in; + snd_usb_midi_in_endpoint_t *in = umidi->endpoints[i].in; if (in && in->error_resubmit) { in->error_resubmit = 0; in->urb->dev = umidi->chip->dev; @@ -318,7 +321,7 @@ static void snd_usbmidi_error_timer(unsigned long data) } /* helper function to send static data that may not DMA-able */ -static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep, +static int send_bulk_static_data(snd_usb_midi_out_endpoint_t* ep, const void *data, int len) { int err; @@ -339,7 +342,7 @@ static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep, * fourth byte in each packet, and uses length instead of CIN. */ -static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint* ep, +static void snd_usbmidi_standard_input(snd_usb_midi_in_endpoint_t* ep, uint8_t* buffer, int buffer_length) { int i; @@ -352,7 +355,7 @@ static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint* ep, } } -static void snd_usbmidi_midiman_input(struct snd_usb_midi_in_endpoint* ep, +static void snd_usbmidi_midiman_input(snd_usb_midi_in_endpoint_t* ep, uint8_t* buffer, int buffer_length) { int i; @@ -398,7 +401,7 @@ static void snd_usbmidi_output_midiman_packet(struct urb* urb, uint8_t p0, /* * Converts MIDI commands to USB MIDI packets. */ -static void snd_usbmidi_transmit_byte(struct usbmidi_out_port* port, +static void snd_usbmidi_transmit_byte(usbmidi_out_port_t* port, uint8_t b, struct urb* urb) { uint8_t p0 = port->cable; @@ -492,14 +495,14 @@ static void snd_usbmidi_transmit_byte(struct usbmidi_out_port* port, } } -static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_standard_output(snd_usb_midi_out_endpoint_t* ep) { struct urb* urb = ep->urb; int p; /* FIXME: lower-numbered ports can starve higher-numbered ports */ for (p = 0; p < 0x10; ++p) { - struct usbmidi_out_port* port = &ep->ports[p]; + usbmidi_out_port_t* port = &ep->ports[p]; if (!port->active) continue; while (urb->transfer_buffer_length + 3 < ep->max_transfer) { @@ -531,7 +534,7 @@ static struct usb_protocol_ops snd_usbmidi_midiman_ops = { * at the third byte. */ -static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint* ep, +static void snd_usbmidi_novation_input(snd_usb_midi_in_endpoint_t* ep, uint8_t* buffer, int buffer_length) { if (buffer_length < 2 || !buffer[0] || buffer_length < buffer[0] + 1) @@ -539,7 +542,7 @@ static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint* ep, snd_usbmidi_input_data(ep, 0, &buffer[2], buffer[0] - 1); } -static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_novation_output(snd_usb_midi_out_endpoint_t* ep) { uint8_t* transfer_buffer; int count; @@ -568,13 +571,13 @@ static struct usb_protocol_ops snd_usbmidi_novation_ops = { * "raw" protocol: used by the MOTU FastLane. */ -static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint* ep, +static void snd_usbmidi_raw_input(snd_usb_midi_in_endpoint_t* ep, uint8_t* buffer, int buffer_length) { snd_usbmidi_input_data(ep, 0, buffer, buffer_length); } -static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_raw_output(snd_usb_midi_out_endpoint_t* ep) { int count; @@ -599,7 +602,7 @@ static struct usb_protocol_ops snd_usbmidi_raw_ops = { * Emagic USB MIDI protocol: raw MIDI with "F5 xx" port switching. */ -static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_emagic_init_out(snd_usb_midi_out_endpoint_t* ep) { static const u8 init_data[] = { /* initialization magic: "get version" */ @@ -616,7 +619,7 @@ static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint* ep) send_bulk_static_data(ep, init_data, sizeof(init_data)); } -static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_emagic_finish_out(snd_usb_midi_out_endpoint_t* ep) { static const u8 finish_data[] = { /* switch to patch mode with last preset */ @@ -632,7 +635,7 @@ static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint* ep) send_bulk_static_data(ep, finish_data, sizeof(finish_data)); } -static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint* ep, +static void snd_usbmidi_emagic_input(snd_usb_midi_in_endpoint_t* ep, uint8_t* buffer, int buffer_length) { int i; @@ -676,7 +679,7 @@ static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint* ep, } } -static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_emagic_output(snd_usb_midi_out_endpoint_t* ep) { int port0 = ep->current_port; uint8_t* buf = ep->urb->transfer_buffer; @@ -686,7 +689,7 @@ static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint* ep) for (i = 0; i < 0x10; ++i) { /* round-robin, starting at the last current port */ int portnum = (port0 + i) & 15; - struct usbmidi_out_port* port = &ep->ports[portnum]; + usbmidi_out_port_t* port = &ep->ports[portnum]; if (!port->active) continue; @@ -730,10 +733,10 @@ static struct usb_protocol_ops snd_usbmidi_emagic_ops = { }; -static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream) +static int snd_usbmidi_output_open(snd_rawmidi_substream_t* substream) { - struct snd_usb_midi* umidi = substream->rmidi->private_data; - struct usbmidi_out_port* port = NULL; + snd_usb_midi_t* umidi = substream->rmidi->private_data; + usbmidi_out_port_t* port = NULL; int i, j; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) @@ -752,14 +755,14 @@ static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream) return 0; } -static int snd_usbmidi_output_close(struct snd_rawmidi_substream *substream) +static int snd_usbmidi_output_close(snd_rawmidi_substream_t* substream) { return 0; } -static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_usbmidi_output_trigger(snd_rawmidi_substream_t* substream, int up) { - struct usbmidi_out_port* port = (struct usbmidi_out_port*)substream->runtime->private_data; + usbmidi_out_port_t* port = (usbmidi_out_port_t*)substream->runtime->private_data; port->active = up; if (up) { @@ -774,19 +777,19 @@ static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream, } } -static int snd_usbmidi_input_open(struct snd_rawmidi_substream *substream) +static int snd_usbmidi_input_open(snd_rawmidi_substream_t* substream) { return 0; } -static int snd_usbmidi_input_close(struct snd_rawmidi_substream *substream) +static int snd_usbmidi_input_close(snd_rawmidi_substream_t* substream) { return 0; } -static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) +static void snd_usbmidi_input_trigger(snd_rawmidi_substream_t* substream, int up) { - struct snd_usb_midi* umidi = substream->rmidi->private_data; + snd_usb_midi_t* umidi = substream->rmidi->private_data; if (up) set_bit(substream->number, &umidi->input_triggered); @@ -794,13 +797,13 @@ static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream *substream, i clear_bit(substream->number, &umidi->input_triggered); } -static struct snd_rawmidi_ops snd_usbmidi_output_ops = { +static snd_rawmidi_ops_t snd_usbmidi_output_ops = { .open = snd_usbmidi_output_open, .close = snd_usbmidi_output_close, .trigger = snd_usbmidi_output_trigger, }; -static struct snd_rawmidi_ops snd_usbmidi_input_ops = { +static snd_rawmidi_ops_t snd_usbmidi_input_ops = { .open = snd_usbmidi_input_open, .close = snd_usbmidi_input_close, .trigger = snd_usbmidi_input_trigger @@ -810,7 +813,7 @@ static struct snd_rawmidi_ops snd_usbmidi_input_ops = { * Frees an input endpoint. * May be called when ep hasn't been initialized completely. */ -static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint* ep) +static void snd_usbmidi_in_endpoint_delete(snd_usb_midi_in_endpoint_t* ep) { if (ep->urb) { usb_buffer_free(ep->umidi->chip->dev, @@ -825,11 +828,11 @@ static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint* ep) /* * Creates an input endpoint. */ -static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* ep_info, - struct snd_usb_midi_endpoint* rep) +static int snd_usbmidi_in_endpoint_create(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* ep_info, + snd_usb_midi_endpoint_t* rep) { - struct snd_usb_midi_in_endpoint* ep; + snd_usb_midi_in_endpoint_t* ep; void* buffer; unsigned int pipe; int length; @@ -882,7 +885,7 @@ static unsigned int snd_usbmidi_count_bits(unsigned int x) * Frees an output endpoint. * May be called when ep hasn't been initialized completely. */ -static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep) +static void snd_usbmidi_out_endpoint_delete(snd_usb_midi_out_endpoint_t* ep) { if (ep->urb) { usb_buffer_free(ep->umidi->chip->dev, ep->max_transfer, @@ -896,11 +899,11 @@ static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep /* * Creates an output endpoint, and initializes output ports. */ -static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* ep_info, - struct snd_usb_midi_endpoint* rep) +static int snd_usbmidi_out_endpoint_create(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* ep_info, + snd_usb_midi_endpoint_t* rep) { - struct snd_usb_midi_out_endpoint* ep; + snd_usb_midi_out_endpoint_t* ep; int i; unsigned int pipe; void* buffer; @@ -948,12 +951,12 @@ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi, /* * Frees everything. */ -static void snd_usbmidi_free(struct snd_usb_midi* umidi) +static void snd_usbmidi_free(snd_usb_midi_t* umidi) { int i; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { - struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i]; + snd_usb_midi_endpoint_t* ep = &umidi->endpoints[i]; if (ep->out) snd_usbmidi_out_endpoint_delete(ep->out); if (ep->in) @@ -967,13 +970,13 @@ static void snd_usbmidi_free(struct snd_usb_midi* umidi) */ void snd_usbmidi_disconnect(struct list_head* p) { - struct snd_usb_midi* umidi; + snd_usb_midi_t* umidi; int i; - umidi = list_entry(p, struct snd_usb_midi, list); + umidi = list_entry(p, snd_usb_midi_t, list); del_timer_sync(&umidi->error_timer); for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { - struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i]; + snd_usb_midi_endpoint_t* ep = &umidi->endpoints[i]; if (ep->out) tasklet_kill(&ep->out->tasklet); if (ep->out && ep->out->urb) { @@ -986,19 +989,19 @@ void snd_usbmidi_disconnect(struct list_head* p) } } -static void snd_usbmidi_rawmidi_free(struct snd_rawmidi *rmidi) +static void snd_usbmidi_rawmidi_free(snd_rawmidi_t* rmidi) { - struct snd_usb_midi* umidi = rmidi->private_data; + snd_usb_midi_t* umidi = rmidi->private_data; snd_usbmidi_free(umidi); } -static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi* umidi, +static snd_rawmidi_substream_t* snd_usbmidi_find_substream(snd_usb_midi_t* umidi, int stream, int number) { struct list_head* list; list_for_each(list, &umidi->rmidi->streams[stream].substreams) { - struct snd_rawmidi_substream *substream = list_entry(list, struct snd_rawmidi_substream, list); + snd_rawmidi_substream_t* substream = list_entry(list, snd_rawmidi_substream_t, list); if (substream->number == number) return substream; } @@ -1094,14 +1097,14 @@ static struct { { USB_ID(0x086a, 0x0003), 4, "%s Broadcast" }, }; -static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi, +static void snd_usbmidi_init_substream(snd_usb_midi_t* umidi, int stream, int number, - struct snd_rawmidi_substream ** rsubstream) + snd_rawmidi_substream_t** rsubstream) { int i; const char *name_format; - struct snd_rawmidi_substream *substream = snd_usbmidi_find_substream(umidi, stream, number); + snd_rawmidi_substream_t* substream = snd_usbmidi_find_substream(umidi, stream, number); if (!substream) { snd_printd(KERN_ERR "substream %d:%d not found\n", stream, number); return; @@ -1125,8 +1128,8 @@ static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi, /* * Creates the endpoints and their ports. */ -static int snd_usbmidi_create_endpoints(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* endpoints) +static int snd_usbmidi_create_endpoints(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* endpoints) { int i, j, err; int out_ports = 0, in_ports = 0; @@ -1166,8 +1169,8 @@ static int snd_usbmidi_create_endpoints(struct snd_usb_midi* umidi, /* * Returns MIDIStreaming device capabilities. */ -static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* endpoints) +static int snd_usbmidi_get_ms_info(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* endpoints) { struct usb_interface* intf; struct usb_host_interface *hostif; @@ -1241,7 +1244,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi, * On Roland devices, use the second alternate setting to be able to use * the interrupt input endpoint. */ -static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi) +static void snd_usbmidi_switch_roland_altsetting(snd_usb_midi_t* umidi) { struct usb_interface* intf; struct usb_host_interface *hostif; @@ -1267,8 +1270,8 @@ static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi) /* * Try to find any usable endpoints in the interface. */ -static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* endpoint, +static int snd_usbmidi_detect_endpoints(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* endpoint, int max_endpoints) { struct usb_interface* intf; @@ -1315,8 +1318,8 @@ static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi, /* * Detects the endpoints for one-port-per-endpoint protocols. */ -static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* endpoints) +static int snd_usbmidi_detect_per_port_endpoints(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* endpoints) { int err, i; @@ -1333,8 +1336,8 @@ static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi* umidi, /* * Detects the endpoints and ports of Yamaha devices. */ -static int snd_usbmidi_detect_yamaha(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* endpoint) +static int snd_usbmidi_detect_yamaha(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* endpoint) { struct usb_interface* intf; struct usb_host_interface *hostif; @@ -1372,10 +1375,10 @@ static int snd_usbmidi_detect_yamaha(struct snd_usb_midi* umidi, /* * Creates the endpoints and their ports for Midiman devices. */ -static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi, - struct snd_usb_midi_endpoint_info* endpoint) +static int snd_usbmidi_create_endpoints_midiman(snd_usb_midi_t* umidi, + snd_usb_midi_endpoint_info_t* endpoint) { - struct snd_usb_midi_endpoint_info ep_info; + snd_usb_midi_endpoint_info_t ep_info; struct usb_interface* intf; struct usb_host_interface *hostif; struct usb_interface_descriptor* intfd; @@ -1455,10 +1458,10 @@ static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi, return 0; } -static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi, +static int snd_usbmidi_create_rawmidi(snd_usb_midi_t* umidi, int out_ports, int in_ports) { - struct snd_rawmidi *rmidi; + snd_rawmidi_t* rmidi; int err; err = snd_rawmidi_new(umidi->chip->card, "USB MIDI", @@ -1484,18 +1487,18 @@ static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi, */ void snd_usbmidi_input_stop(struct list_head* p) { - struct snd_usb_midi* umidi; + snd_usb_midi_t* umidi; int i; - umidi = list_entry(p, struct snd_usb_midi, list); + umidi = list_entry(p, snd_usb_midi_t, list); for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { - struct snd_usb_midi_endpoint* ep = &umidi->endpoints[i]; + snd_usb_midi_endpoint_t* ep = &umidi->endpoints[i]; if (ep->in) usb_kill_urb(ep->in->urb); } } -static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint* ep) +static void snd_usbmidi_input_start_ep(snd_usb_midi_in_endpoint_t* ep) { if (ep) { struct urb* urb = ep->urb; @@ -1509,10 +1512,10 @@ static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint* ep) */ void snd_usbmidi_input_start(struct list_head* p) { - struct snd_usb_midi* umidi; + snd_usb_midi_t* umidi; int i; - umidi = list_entry(p, struct snd_usb_midi, list); + umidi = list_entry(p, snd_usb_midi_t, list); for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) snd_usbmidi_input_start_ep(umidi->endpoints[i].in); } @@ -1520,12 +1523,12 @@ void snd_usbmidi_input_start(struct list_head* p) /* * Creates and registers everything needed for a MIDI streaming interface. */ -int snd_usb_create_midi_interface(struct snd_usb_audio* chip, +int snd_usb_create_midi_interface(snd_usb_audio_t* chip, struct usb_interface* iface, - const struct snd_usb_audio_quirk* quirk) + const snd_usb_audio_quirk_t* quirk) { - struct snd_usb_midi* umidi; - struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS]; + snd_usb_midi_t* umidi; + snd_usb_midi_endpoint_info_t endpoints[MIDI_MAX_ENDPOINTS]; int out_ports, in_ports; int i, err; @@ -1548,7 +1551,7 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip, break; case QUIRK_MIDI_FIXED_ENDPOINT: memcpy(&endpoints[0], quirk->data, - sizeof(struct snd_usb_midi_endpoint_info)); + sizeof(snd_usb_midi_endpoint_info_t)); err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1); break; case QUIRK_MIDI_YAMAHA: @@ -1557,7 +1560,7 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip, case QUIRK_MIDI_MIDIMAN: umidi->usb_protocol_ops = &snd_usbmidi_midiman_ops; memcpy(&endpoints[0], quirk->data, - sizeof(struct snd_usb_midi_endpoint_info)); + sizeof(snd_usb_midi_endpoint_info_t)); err = 0; break; case QUIRK_MIDI_NOVATION: @@ -1571,7 +1574,7 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip, case QUIRK_MIDI_EMAGIC: umidi->usb_protocol_ops = &snd_usbmidi_emagic_ops; memcpy(&endpoints[0], quirk->data, - sizeof(struct snd_usb_midi_endpoint_info)); + sizeof(snd_usb_midi_endpoint_info_t)); err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1); break; case QUIRK_MIDI_MIDITECH: diff --git a/trunk/sound/usb/usbmixer.c b/trunk/sound/usb/usbmixer.c index 678dac2d4dba..e570d140258d 100644 --- a/trunk/sound/usb/usbmixer.c +++ b/trunk/sound/usb/usbmixer.c @@ -46,13 +46,18 @@ /* ignore error from controls - for debugging */ /* #define IGNORE_CTL_ERROR */ +typedef struct usb_mixer_build mixer_build_t; +typedef struct usb_audio_term usb_audio_term_t; +typedef struct usb_mixer_elem_info usb_mixer_elem_info_t; + + struct usb_mixer_interface { - struct snd_usb_audio *chip; + snd_usb_audio_t *chip; unsigned int ctrlif; struct list_head list; unsigned int ignore_ctl_error; struct urb *urb; - struct usb_mixer_elem_info **id_elems; /* array[256], indexed by unit id */ + usb_mixer_elem_info_t **id_elems; /* array[256], indexed by unit id */ /* Sound Blaster remote control stuff */ enum { @@ -81,21 +86,21 @@ struct usb_audio_term { struct usbmix_name_map; -struct mixer_build { - struct snd_usb_audio *chip; +struct usb_mixer_build { + snd_usb_audio_t *chip; struct usb_mixer_interface *mixer; unsigned char *buffer; unsigned int buflen; DECLARE_BITMAP(unitbitmap, 256); - struct usb_audio_term oterm; + usb_audio_term_t oterm; const struct usbmix_name_map *map; const struct usbmix_selector_map *selector_map; }; struct usb_mixer_elem_info { struct usb_mixer_interface *mixer; - struct usb_mixer_elem_info *next_id_elem; /* list of controls with same id */ - struct snd_ctl_elem_id *elem_id; + usb_mixer_elem_info_t *next_id_elem; /* list of controls with same id */ + snd_ctl_elem_id_t *elem_id; unsigned int id; unsigned int control; /* CS or ICN (high byte) */ unsigned int cmask; /* channel mask bitmap: 0 = master */ @@ -174,7 +179,7 @@ enum { #include "usbmixer_maps.c" /* get the mapped name if the unit matches */ -static int check_mapped_name(struct mixer_build *state, int unitid, int control, char *buf, int buflen) +static int check_mapped_name(mixer_build_t *state, int unitid, int control, char *buf, int buflen) { const struct usbmix_name_map *p; @@ -192,7 +197,7 @@ static int check_mapped_name(struct mixer_build *state, int unitid, int control, } /* check whether the control should be ignored */ -static int check_ignored_ctl(struct mixer_build *state, int unitid, int control) +static int check_ignored_ctl(mixer_build_t *state, int unitid, int control) { const struct usbmix_name_map *p; @@ -209,7 +214,7 @@ static int check_ignored_ctl(struct mixer_build *state, int unitid, int control) } /* get the mapped selector source name */ -static int check_mapped_selector_name(struct mixer_build *state, int unitid, +static int check_mapped_selector_name(mixer_build_t *state, int unitid, int index, char *buf, int buflen) { const struct usbmix_selector_map *p; @@ -226,7 +231,7 @@ static int check_mapped_selector_name(struct mixer_build *state, int unitid, /* * find an audio control unit with the given unit id */ -static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit) +static void *find_audio_control_unit(mixer_build_t *state, unsigned char unit) { unsigned char *p; @@ -243,7 +248,7 @@ static void *find_audio_control_unit(struct mixer_build *state, unsigned char un /* * copy a string with the given id */ -static int snd_usb_copy_string_desc(struct mixer_build *state, int index, char *buf, int maxlen) +static int snd_usb_copy_string_desc(mixer_build_t *state, int index, char *buf, int maxlen) { int len = usb_string(state->chip->dev, index, buf, maxlen - 1); buf[len] = 0; @@ -253,7 +258,7 @@ static int snd_usb_copy_string_desc(struct mixer_build *state, int index, char * /* * convert from the byte/word on usb descriptor to the zero-based integer */ -static int convert_signed_value(struct usb_mixer_elem_info *cval, int val) +static int convert_signed_value(usb_mixer_elem_info_t *cval, int val) { switch (cval->val_type) { case USB_MIXER_BOOLEAN: @@ -283,7 +288,7 @@ static int convert_signed_value(struct usb_mixer_elem_info *cval, int val) /* * convert from the zero-based int to the byte/word for usb descriptor */ -static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val) +static int convert_bytes_value(usb_mixer_elem_info_t *cval, int val) { switch (cval->val_type) { case USB_MIXER_BOOLEAN: @@ -300,7 +305,7 @@ static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val) return 0; /* not reached */ } -static int get_relative_value(struct usb_mixer_elem_info *cval, int val) +static int get_relative_value(usb_mixer_elem_info_t *cval, int val) { if (! cval->res) cval->res = 1; @@ -312,7 +317,7 @@ static int get_relative_value(struct usb_mixer_elem_info *cval, int val) return (val - cval->min) / cval->res; } -static int get_abs_value(struct usb_mixer_elem_info *cval, int val) +static int get_abs_value(usb_mixer_elem_info_t *cval, int val) { if (val < 0) return cval->min; @@ -330,7 +335,7 @@ static int get_abs_value(struct usb_mixer_elem_info *cval, int val) * retrieve a mixer value */ -static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret) +static int get_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int *value_ret) { unsigned char buf[2]; int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; @@ -352,13 +357,13 @@ static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali return -EINVAL; } -static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value) +static int get_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int *value) { return get_ctl_value(cval, GET_CUR, validx, value); } /* channel = 0: master, 1 = first channel */ -static inline int get_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int *value) +static inline int get_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int *value) { return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value); } @@ -367,7 +372,7 @@ static inline int get_cur_mix_value(struct usb_mixer_elem_info *cval, int channe * set a mixer value */ -static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int value_set) +static int set_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int value_set) { unsigned char buf[2]; int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; @@ -389,12 +394,12 @@ static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali return -EINVAL; } -static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value) +static int set_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int value) { return set_ctl_value(cval, SET_CUR, validx, value); } -static inline int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int value) +static inline int set_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int value) { return set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel, value); } @@ -404,7 +409,7 @@ static inline int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channe * parser routines begin here... */ -static int parse_audio_unit(struct mixer_build *state, int unitid); +static int parse_audio_unit(mixer_build_t *state, int unitid); /* @@ -425,9 +430,9 @@ static int check_matrix_bitmap(unsigned char *bmap, int ich, int och, int num_ou * if failed, give up and free the control instance. */ -static int add_control_to_empty(struct mixer_build *state, struct snd_kcontrol *kctl) +static int add_control_to_empty(mixer_build_t *state, snd_kcontrol_t *kctl) { - struct usb_mixer_elem_info *cval = kctl->private_data; + usb_mixer_elem_info_t *cval = kctl->private_data; int err; while (snd_ctl_find_id(state->chip->card, &kctl->id)) @@ -491,7 +496,7 @@ static struct iterm_name_combo { { 0 }, }; -static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm, +static int get_term_name(mixer_build_t *state, usb_audio_term_t *iterm, unsigned char *name, int maxlen, int term_only) { struct iterm_name_combo *names; @@ -541,7 +546,7 @@ static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm * parse the source unit recursively until it reaches to a terminal * or a branched unit. */ -static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term) +static int check_input_term(mixer_build_t *state, int id, usb_audio_term_t *term) { unsigned char *p1; @@ -616,7 +621,7 @@ static struct usb_feature_control_info audio_feature_info[] = { /* private_free callback */ -static void usb_mixer_elem_free(struct snd_kcontrol *kctl) +static void usb_mixer_elem_free(snd_kcontrol_t *kctl) { kfree(kctl->private_data); kctl->private_data = NULL; @@ -630,7 +635,7 @@ static void usb_mixer_elem_free(struct snd_kcontrol *kctl) /* * retrieve the minimum and maximum values for the specified control */ -static int get_min_max(struct usb_mixer_elem_info *cval, int default_min) +static int get_min_max(usb_mixer_elem_info_t *cval, int default_min) { /* for failsafe */ cval->min = default_min; @@ -678,9 +683,9 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min) /* get a feature/mixer unit info */ -static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixer_ctl_feature_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; if (cval->val_type == USB_MIXER_BOOLEAN || cval->val_type == USB_MIXER_INV_BOOLEAN) @@ -702,9 +707,9 @@ static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ } /* get the current value from feature/mixer unit */ -static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_ctl_feature_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; int c, cnt, val, err; if (cval->cmask) { @@ -743,9 +748,9 @@ static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e } /* put the current value to feature/mixer unit */ -static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_ctl_feature_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; int c, cnt, val, oval, err; int changed = 0; @@ -786,7 +791,7 @@ static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e return changed; } -static struct snd_kcontrol_new usb_feature_unit_ctl = { +static snd_kcontrol_new_t usb_feature_unit_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", /* will be filled later manually */ .info = mixer_ctl_feature_info, @@ -799,15 +804,15 @@ static struct snd_kcontrol_new usb_feature_unit_ctl = { * build a feature control */ -static void build_feature_ctl(struct mixer_build *state, unsigned char *desc, +static void build_feature_ctl(mixer_build_t *state, unsigned char *desc, unsigned int ctl_mask, int control, - struct usb_audio_term *iterm, int unitid) + usb_audio_term_t *iterm, int unitid) { unsigned int len = 0; int mapped_name = 0; int nameid = desc[desc[0] - 1]; - struct snd_kcontrol *kctl; - struct usb_mixer_elem_info *cval; + snd_kcontrol_t *kctl; + usb_mixer_elem_info_t *cval; control++; /* change from zero-based to 1-based value */ @@ -923,10 +928,10 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc, * * most of controlls are defined here. */ -static int parse_audio_feature_unit(struct mixer_build *state, int unitid, unsigned char *ftr) +static int parse_audio_feature_unit(mixer_build_t *state, int unitid, unsigned char *ftr) { int channels, i, j; - struct usb_audio_term iterm; + usb_audio_term_t iterm; unsigned int master_bits, first_ch_bits; int err, csize; @@ -979,15 +984,15 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, unsig * input channel number (zero based) is given in control field instead. */ -static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc, +static void build_mixer_unit_ctl(mixer_build_t *state, unsigned char *desc, int in_pin, int in_ch, int unitid, - struct usb_audio_term *iterm) + usb_audio_term_t *iterm) { - struct usb_mixer_elem_info *cval; + usb_mixer_elem_info_t *cval; unsigned int input_pins = desc[4]; unsigned int num_outs = desc[5 + input_pins]; unsigned int i, len; - struct snd_kcontrol *kctl; + snd_kcontrol_t *kctl; if (check_ignored_ctl(state, unitid, 0)) return; @@ -1034,9 +1039,9 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc, /* * parse a mixer unit */ -static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, unsigned char *desc) +static int parse_audio_mixer_unit(mixer_build_t *state, int unitid, unsigned char *desc) { - struct usb_audio_term iterm; + usb_audio_term_t iterm; int input_pins, num_ins, num_outs; int pin, ich, err; @@ -1084,9 +1089,9 @@ static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, unsigne */ /* get callback for processing/extension unit */ -static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_ctl_procunit_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; int err, val; err = get_cur_ctl_value(cval, cval->control << 8, &val); @@ -1102,9 +1107,9 @@ static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ } /* put callback for processing/extension unit */ -static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_ctl_procunit_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; int val, oval, err; err = get_cur_ctl_value(cval, cval->control << 8, &oval); @@ -1123,7 +1128,7 @@ static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ } /* alsa control interface for processing/extension unit */ -static struct snd_kcontrol_new mixer_procunit_ctl = { +static snd_kcontrol_new_t mixer_procunit_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", /* will be filled later */ .info = mixer_ctl_feature_info, @@ -1200,11 +1205,11 @@ static struct procunit_info procunits[] = { /* * build a processing/extension unit */ -static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name) +static int build_audio_procunit(mixer_build_t *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name) { int num_ins = dsc[6]; - struct usb_mixer_elem_info *cval; - struct snd_kcontrol *kctl; + usb_mixer_elem_info_t *cval; + snd_kcontrol_t *kctl; int i, err, nameid, type, len; struct procunit_info *info; struct procunit_value_info *valinfo; @@ -1292,12 +1297,12 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned } -static int parse_audio_processing_unit(struct mixer_build *state, int unitid, unsigned char *desc) +static int parse_audio_processing_unit(mixer_build_t *state, int unitid, unsigned char *desc) { return build_audio_procunit(state, unitid, desc, procunits, "Processing Unit"); } -static int parse_audio_extension_unit(struct mixer_build *state, int unitid, unsigned char *desc) +static int parse_audio_extension_unit(mixer_build_t *state, int unitid, unsigned char *desc) { return build_audio_procunit(state, unitid, desc, NULL, "Extension Unit"); } @@ -1310,9 +1315,9 @@ static int parse_audio_extension_unit(struct mixer_build *state, int unitid, uns /* info callback for selector unit * use an enumerator type for routing */ -static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int mixer_ctl_selector_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; char **itemlist = (char **)kcontrol->private_value; snd_assert(itemlist, return -EINVAL); @@ -1326,9 +1331,9 @@ static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl } /* get callback for selector unit */ -static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_ctl_selector_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; int val, err; err = get_cur_ctl_value(cval, 0, &val); @@ -1345,9 +1350,9 @@ static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_ } /* put callback for selector unit */ -static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int mixer_ctl_selector_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { - struct usb_mixer_elem_info *cval = kcontrol->private_data; + usb_mixer_elem_info_t *cval = kcontrol->private_data; int val, oval, err; err = get_cur_ctl_value(cval, 0, &oval); @@ -1366,7 +1371,7 @@ static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_ } /* alsa control interface for selector unit */ -static struct snd_kcontrol_new mixer_selectunit_ctl = { +static snd_kcontrol_new_t mixer_selectunit_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", /* will be filled later */ .info = mixer_ctl_selector_info, @@ -1378,12 +1383,12 @@ static struct snd_kcontrol_new mixer_selectunit_ctl = { /* private free callback. * free both private_data and private_value */ -static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl) +static void usb_mixer_selector_elem_free(snd_kcontrol_t *kctl) { int i, num_ins = 0; if (kctl->private_data) { - struct usb_mixer_elem_info *cval = kctl->private_data; + usb_mixer_elem_info_t *cval = kctl->private_data; num_ins = cval->max; kfree(cval); kctl->private_data = NULL; @@ -1400,13 +1405,13 @@ static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl) /* * parse a selector unit */ -static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsigned char *desc) +static int parse_audio_selector_unit(mixer_build_t *state, int unitid, unsigned char *desc) { unsigned int num_ins = desc[4]; unsigned int i, nameid, len; int err; - struct usb_mixer_elem_info *cval; - struct snd_kcontrol *kctl; + usb_mixer_elem_info_t *cval; + snd_kcontrol_t *kctl; char **namelist; if (! num_ins || desc[0] < 6 + num_ins) { @@ -1447,7 +1452,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi } #define MAX_ITEM_NAME_LEN 64 for (i = 0; i < num_ins; i++) { - struct usb_audio_term iterm; + usb_audio_term_t iterm; len = 0; namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL); if (! namelist[i]) { @@ -1506,7 +1511,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi * parse an audio unit recursively */ -static int parse_audio_unit(struct mixer_build *state, int unitid) +static int parse_audio_unit(mixer_build_t *state, int unitid) { unsigned char *p1; @@ -1551,7 +1556,7 @@ static void snd_usb_mixer_free(struct usb_mixer_interface *mixer) kfree(mixer); } -static int snd_usb_mixer_dev_free(struct snd_device *device) +static int snd_usb_mixer_dev_free(snd_device_t *device) { struct usb_mixer_interface *mixer = device->device_data; snd_usb_mixer_free(mixer); @@ -1566,7 +1571,7 @@ static int snd_usb_mixer_dev_free(struct snd_device *device) static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer) { unsigned char *desc; - struct mixer_build state; + mixer_build_t state; int err; const struct usbmix_ctl_map *map; struct usb_host_interface *hostif; @@ -1606,7 +1611,7 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer) static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid) { - struct usb_mixer_elem_info *info; + usb_mixer_elem_info_t *info; for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem) snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, @@ -1720,7 +1725,7 @@ static void snd_usb_soundblaster_remote_complete(struct urb *urb, wake_up(&mixer->rc_waitq); } -static int snd_usb_sbrc_hwdep_open(struct snd_hwdep *hw, struct file *file) +static int snd_usb_sbrc_hwdep_open(snd_hwdep_t *hw, struct file *file) { struct usb_mixer_interface *mixer = hw->private_data; @@ -1729,7 +1734,7 @@ static int snd_usb_sbrc_hwdep_open(struct snd_hwdep *hw, struct file *file) return 0; } -static int snd_usb_sbrc_hwdep_release(struct snd_hwdep *hw, struct file *file) +static int snd_usb_sbrc_hwdep_release(snd_hwdep_t *hw, struct file *file) { struct usb_mixer_interface *mixer = hw->private_data; @@ -1738,7 +1743,7 @@ static int snd_usb_sbrc_hwdep_release(struct snd_hwdep *hw, struct file *file) return 0; } -static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf, +static long snd_usb_sbrc_hwdep_read(snd_hwdep_t *hw, char __user *buf, long count, loff_t *offset) { struct usb_mixer_interface *mixer = hw->private_data; @@ -1758,7 +1763,7 @@ static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf, return err < 0 ? err : count; } -static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file, +static unsigned int snd_usb_sbrc_hwdep_poll(snd_hwdep_t *hw, struct file *file, poll_table *wait) { struct usb_mixer_interface *mixer = hw->private_data; @@ -1769,7 +1774,7 @@ static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *f static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer) { - struct snd_hwdep *hwdep; + snd_hwdep_t *hwdep; int err, len; switch (mixer->chip->usb_id) { @@ -1820,7 +1825,7 @@ static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer) return 0; } -static int snd_audigy2nx_led_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +static int snd_audigy2nx_led_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = 1; @@ -1829,7 +1834,7 @@ static int snd_audigy2nx_led_info(struct snd_kcontrol *kcontrol, struct snd_ctl_ return 0; } -static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_audigy2nx_led_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; @@ -1838,7 +1843,7 @@ static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_e return 0; } -static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) +static int snd_audigy2nx_led_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol) { struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol); int index = kcontrol->private_value; @@ -1858,7 +1863,7 @@ static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_e return changed; } -static struct snd_kcontrol_new snd_audigy2nx_controls[] = { +static snd_kcontrol_new_t snd_audigy2nx_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "CMSS LED Switch", @@ -1899,8 +1904,8 @@ static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer) return 0; } -static void snd_audigy2nx_proc_read(struct snd_info_entry *entry, - struct snd_info_buffer *buffer) +static void snd_audigy2nx_proc_read(snd_info_entry_t *entry, + snd_info_buffer_t *buffer) { static const struct { int unitid; @@ -1930,9 +1935,9 @@ static void snd_audigy2nx_proc_read(struct snd_info_entry *entry, } } -int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif) +int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif) { - static struct snd_device_ops dev_ops = { + static snd_device_ops_t dev_ops = { .dev_free = snd_usb_mixer_dev_free }; struct usb_mixer_interface *mixer; @@ -1962,7 +1967,7 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif) goto _error; if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020)) { - struct snd_info_entry *entry; + snd_info_entry_t *entry; if ((err = snd_audigy2nx_controls_create(mixer)) < 0) goto _error; diff --git a/trunk/sound/usb/usbquirks.h b/trunk/sound/usb/usbquirks.h index 6190ada00e38..ba506c3871f4 100644 --- a/trunk/sound/usb/usbquirks.h +++ b/trunk/sound/usb/usbquirks.h @@ -45,7 +45,7 @@ #define YAMAHA_DEVICE(id, name) { \ USB_DEVICE(0x0499, id), \ - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \ .vendor_name = "Yamaha", \ .product_name = name, \ .ifnum = QUIRK_ANY_INTERFACE, \ @@ -54,7 +54,7 @@ } #define YAMAHA_INTERFACE(id, intf, name) { \ USB_DEVICE_VENDOR_SPEC(0x0499, id), \ - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \ .vendor_name = "Yamaha", \ .product_name = name, \ .ifnum = intf, \ @@ -149,12 +149,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), */ { USB_DEVICE(0x0582, 0x0000), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "UA-100", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_AUDIO_FIXED_ENDPOINT, @@ -192,7 +192,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0007, .in_cables = 0x0007 } @@ -205,12 +205,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x0002), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UM-4", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -222,7 +222,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x000f, .in_cables = 0x000f } @@ -235,12 +235,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x0003), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "SC-8850", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -252,7 +252,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x003f, .in_cables = 0x003f } @@ -265,12 +265,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x0004), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "U-8", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -282,7 +282,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0005, .in_cables = 0x0005 } @@ -296,12 +296,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* a later revision uses ID 0x0099 */ USB_DEVICE(0x0582, 0x0005), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UM-2", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -313,7 +313,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0003 } @@ -326,12 +326,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x0007), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "SC-8820", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -343,7 +343,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0013, .in_cables = 0x0013 } @@ -356,12 +356,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x0008), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "PC-300", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -373,7 +373,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -387,12 +387,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* a later revision uses ID 0x009d */ USB_DEVICE(0x0582, 0x0009), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UM-1", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -404,7 +404,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -417,12 +417,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x000b), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "SK-500", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -434,7 +434,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0013, .in_cables = 0x0013 } @@ -449,12 +449,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), /* thanks to Emiliano Grilli <emillo@libero.it> * for helping researching this data */ USB_DEVICE(0x0582, 0x000c), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "SC-D70", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_AUDIO_FIXED_ENDPOINT, @@ -492,7 +492,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0007, .in_cables = 0x0007 } @@ -513,12 +513,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * the 96kHz sample rate. */ USB_DEVICE(0x0582, 0x0010), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UA-5", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 1, .type = QUIRK_AUDIO_STANDARD_INTERFACE @@ -536,12 +536,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0013 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0012), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "XV-5050", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -550,12 +550,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0015 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0014), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UM-880", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x01ff, .in_cables = 0x01ff } @@ -564,12 +564,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0017 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0016), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "SD-90", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -581,7 +581,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x000f, .in_cables = 0x000f } @@ -595,12 +595,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x001c when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x001b), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "MMP-2", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -612,7 +612,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 2, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -626,12 +626,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x001e when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x001d), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "V-SYNTH", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -640,12 +640,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0024 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0023), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UM-550", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x003f, .in_cables = 0x003f } @@ -658,57 +658,23 @@ YAMAHA_DEVICE(0x7010, "UB99"), * and no MIDI. */ USB_DEVICE(0x0582, 0x0025), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UA-20", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { - { - .ifnum = 0, - .type = QUIRK_IGNORE_INTERFACE - }, + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 1, - .type = QUIRK_AUDIO_FIXED_ENDPOINT, - .data = & (const struct audioformat) { - .format = SNDRV_PCM_FORMAT_S24_3LE, - .channels = 2, - .iface = 1, - .altsetting = 1, - .altset_idx = 1, - .attributes = 0, - .endpoint = 0x01, - .ep_attr = 0x01, - .rates = SNDRV_PCM_RATE_CONTINUOUS, - .rate_min = 44100, - .rate_max = 44100, - } + .type = QUIRK_AUDIO_STANDARD_INTERFACE }, { .ifnum = 2, - .type = QUIRK_AUDIO_FIXED_ENDPOINT, - .data = & (const struct audioformat) { - .format = SNDRV_PCM_FORMAT_S24_3LE, - .channels = 2, - .iface = 2, - .altsetting = 1, - .altset_idx = 1, - .attributes = 0, - .endpoint = 0x82, - .ep_attr = 0x01, - .rates = SNDRV_PCM_RATE_CONTINUOUS, - .rate_min = 44100, - .rate_max = 44100, - } + .type = QUIRK_AUDIO_STANDARD_INTERFACE }, { .ifnum = 3, - .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { - .out_cables = 0x0001, - .in_cables = 0x0001 - } + .type = QUIRK_MIDI_STANDARD_INTERFACE }, { .ifnum = -1 @@ -719,12 +685,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0028 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0027), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "SD-20", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0007 } @@ -733,12 +699,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x002a when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0029), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "SD-80", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x000f, .in_cables = 0x000f } @@ -751,12 +717,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * but offers only 16-bit PCM and no MIDI. */ USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UA-700", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 1, .type = QUIRK_AUDIO_EDIROL_UA700_UA25 @@ -778,12 +744,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x002e when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x002d), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "XV-2020", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -792,12 +758,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0030 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x002f), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "VariOS", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0007, .in_cables = 0x0007 } @@ -806,12 +772,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0034 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0033), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "PCR", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0007 } @@ -824,12 +790,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * later revisions use IDs 0x0054 and 0x00a2. */ USB_DEVICE(0x0582, 0x0037), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "Digital Piano", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -842,12 +808,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * and no MIDI. */ USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "BOSS", .product_name = "GS-10", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = & (const struct snd_usb_audio_quirk[]) { + .data = & (const snd_usb_audio_quirk_t[]) { { .ifnum = 1, .type = QUIRK_AUDIO_STANDARD_INTERFACE @@ -869,12 +835,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0041 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0040), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "GI-20", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -883,12 +849,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0043 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0042), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "RS-70", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -896,12 +862,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x0044), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "UA-1000", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 1, .type = QUIRK_AUDIO_EDIROL_UA1000 @@ -913,7 +879,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 3, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0003 } @@ -927,12 +893,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x004a when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0048), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UR-80", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0007 } @@ -942,12 +908,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x004f when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x004d), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "PCR-A", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0007 } @@ -959,12 +925,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * is standard compliant, but has only 16-bit PCM. */ USB_DEVICE(0x0582, 0x0050), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UA-3FX", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 1, .type = QUIRK_AUDIO_STANDARD_INTERFACE @@ -981,7 +947,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x0582, 0x0052), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UM-1SX", .ifnum = 0, @@ -992,12 +958,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0067 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0065), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "PCR-1", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0003 } @@ -1006,12 +972,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x006b when not in "Advanced Driver" mode */ USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "SP-606", .ifnum = 3, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1020,12 +986,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x006e when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x006d), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", .product_name = "FANTOM-X", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1038,12 +1004,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * offers only 16-bit PCM at 44.1 kHz and no MIDI. */ USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "EDIROL", .product_name = "UA-25", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = (const struct snd_usb_audio_quirk[]) { + .data = (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_AUDIO_EDIROL_UA700_UA25 @@ -1065,12 +1031,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x0076 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0075), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "BOSS", .product_name = "DR-880", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1079,12 +1045,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* has ID 0x007b when not in "Advanced Driver" mode */ USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Roland", /* "RD" or "RD-700SX"? */ .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0003 } @@ -1100,12 +1066,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * compliant USB MIDI ports for external MIDI and controls. */ USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Hercules", .product_name = "DJ Console (WE)", .ifnum = 4, .type = QUIRK_MIDI_FIXED_ENDPOINT, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1124,12 +1090,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), /* Midiman/M-Audio devices */ { USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "MidiSport 2x2", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0003, .in_cables = 0x0003 } @@ -1137,12 +1103,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "MidiSport 1x1", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1150,12 +1116,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "Keystation", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1163,12 +1129,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "MidiSport 4x4", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x000f, .in_cables = 0x000f } @@ -1181,12 +1147,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> */ USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "MidiSport 8x8", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x01ff, .in_cables = 0x01ff } @@ -1194,12 +1160,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "MidiSport 8x8", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x01ff, .in_cables = 0x01ff } @@ -1207,12 +1173,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "MidiSport 2x4", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x000f, .in_cables = 0x0003 } @@ -1220,12 +1186,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "Quattro", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = & (const struct snd_usb_audio_quirk[]) { + .data = & (const snd_usb_audio_quirk_t[]) { /* * Interfaces 0-2 are "Windows-compatible", 16-bit only, * and share endpoints with the other interfaces. @@ -1271,7 +1237,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 9, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1284,12 +1250,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "AudioPhile", .ifnum = 6, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1297,12 +1263,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "Ozone", .ifnum = 3, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1310,12 +1276,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "M-Audio", .product_name = "OmniStudio", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = & (const struct snd_usb_audio_quirk[]) { + .data = & (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_IGNORE_INTERFACE @@ -1355,7 +1321,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { .ifnum = 9, .type = QUIRK_MIDI_MIDIMAN, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x0001, .in_cables = 0x0001 } @@ -1376,12 +1342,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), .idVendor = 0x07fd, .idProduct = 0x0001, .bDeviceSubClass = 2, - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "MOTU", .product_name = "Fastlane", .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, - .data = & (const struct snd_usb_audio_quirk[]) { + .data = & (const snd_usb_audio_quirk_t[]) { { .ifnum = 0, .type = QUIRK_MIDI_RAW @@ -1400,7 +1366,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { /* Creative Sound Blaster MP3+ */ USB_DEVICE(0x041e, 0x3010), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Creative Labs", .product_name = "Sound Blaster MP3+", .ifnum = QUIRK_NO_INTERFACE @@ -1411,12 +1377,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), /* Emagic devices */ { USB_DEVICE(0x086a, 0x0001), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Emagic", /* .product_name = "Unitor8", */ .ifnum = 2, .type = QUIRK_MIDI_EMAGIC, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x80ff, .in_cables = 0x80ff } @@ -1424,12 +1390,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x086a, 0x0002), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Emagic", /* .product_name = "AMT8", */ .ifnum = 2, .type = QUIRK_MIDI_EMAGIC, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x80ff, .in_cables = 0x80ff } @@ -1437,12 +1403,12 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x086a, 0x0003), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Emagic", /* .product_name = "MT4", */ .ifnum = 2, .type = QUIRK_MIDI_EMAGIC, - .data = & (const struct snd_usb_midi_endpoint_info) { + .data = & (const snd_usb_midi_endpoint_info_t) { .out_cables = 0x800f, .in_cables = 0x8003 } @@ -1452,7 +1418,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), /* TerraTec devices */ { USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "TerraTec", .product_name = "PHASE 26", .ifnum = 3, @@ -1461,7 +1427,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "TerraTec", .product_name = "PHASE 26", .ifnum = 3, @@ -1472,7 +1438,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), /* Novation EMS devices */ { USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Novation", .product_name = "ReMOTE Audio/XStation", .ifnum = 4, @@ -1481,7 +1447,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Novation", .product_name = "Speedio", .ifnum = 3, @@ -1490,7 +1456,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Novation", .product_name = "ReMOTE25", .ifnum = 0, @@ -1500,7 +1466,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), { USB_DEVICE(0x4752, 0x0011), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Miditech", .product_name = "Midistart-2", .ifnum = 0, @@ -1509,7 +1475,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { USB_DEVICE(0x7104, 0x2202), - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .vendor_name = "Miditech", .product_name = "MidiStudio-2", .ifnum = 0, @@ -1526,7 +1492,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), USB_DEVICE_ID_MATCH_INT_SUBCLASS, .bInterfaceClass = USB_CLASS_AUDIO, .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING, - .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_MIDI_STANDARD_INTERFACE } diff --git a/trunk/sound/usb/usx2y/usX2Yhwdep.c b/trunk/sound/usb/usx2y/usX2Yhwdep.c index 4b52d18dcd53..8abe08611df6 100644 --- a/trunk/sound/usb/usx2y/usX2Yhwdep.c +++ b/trunk/sound/usb/usx2y/usX2Yhwdep.c @@ -31,7 +31,7 @@ #include "usbusx2y.h" #include "usX2Yhwdep.h" -int usX2Y_hwdep_pcm_new(struct snd_card *card); +int usX2Y_hwdep_pcm_new(snd_card_t* card); static struct page * snd_us428ctls_vm_nopage(struct vm_area_struct *area, unsigned long address, int *type) @@ -49,7 +49,7 @@ static struct page * snd_us428ctls_vm_nopage(struct vm_area_struct *area, unsign offset = area->vm_pgoff << PAGE_SHIFT; offset += address - area->vm_start; snd_assert((offset % PAGE_SIZE) == 0, return NOPAGE_OOM); - vaddr = (char*)((struct usX2Ydev *)area->vm_private_data)->us428ctls_sharedmem + offset; + vaddr = (char*)((usX2Ydev_t*)area->vm_private_data)->us428ctls_sharedmem + offset; page = virt_to_page(vaddr); get_page(page); snd_printdd( "vaddr=%p made us428ctls_vm_nopage() return %p; offset=%lX\n", vaddr, page, offset); @@ -64,27 +64,27 @@ static struct vm_operations_struct us428ctls_vm_ops = { .nopage = snd_us428ctls_vm_nopage, }; -static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) +static int snd_us428ctls_mmap(snd_hwdep_t * hw, struct file *filp, struct vm_area_struct *area) { unsigned long size = (unsigned long)(area->vm_end - area->vm_start); - struct usX2Ydev *us428 = hw->private_data; + usX2Ydev_t *us428 = (usX2Ydev_t*)hw->private_data; // FIXME this hwdep interface is used twice: fpga download and mmap for controlling Lights etc. Maybe better using 2 hwdep devs? // so as long as the device isn't fully initialised yet we return -EBUSY here. - if (!(us428->chip_status & USX2Y_STAT_CHIP_INIT)) + if (!(((usX2Ydev_t*)hw->private_data)->chip_status & USX2Y_STAT_CHIP_INIT)) return -EBUSY; /* if userspace tries to mmap beyond end of our buffer, fail */ - if (size > PAGE_ALIGN(sizeof(struct us428ctls_sharedmem))) { - snd_printd( "%lu > %lu\n", size, (unsigned long)sizeof(struct us428ctls_sharedmem)); + if (size > ((PAGE_SIZE - 1 + sizeof(us428ctls_sharedmem_t)) / PAGE_SIZE) * PAGE_SIZE) { + snd_printd( "%lu > %lu\n", size, (unsigned long)sizeof(us428ctls_sharedmem_t)); return -EINVAL; } if (!us428->us428ctls_sharedmem) { init_waitqueue_head(&us428->us428ctls_wait_queue_head); - if(!(us428->us428ctls_sharedmem = snd_malloc_pages(sizeof(struct us428ctls_sharedmem), GFP_KERNEL))) + if(!(us428->us428ctls_sharedmem = snd_malloc_pages(sizeof(us428ctls_sharedmem_t), GFP_KERNEL))) return -ENOMEM; - memset(us428->us428ctls_sharedmem, -1, sizeof(struct us428ctls_sharedmem)); + memset(us428->us428ctls_sharedmem, -1, sizeof(us428ctls_sharedmem_t)); us428->us428ctls_sharedmem->CtlSnapShotLast = -2; } area->vm_ops = &us428ctls_vm_ops; @@ -93,11 +93,11 @@ static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct v return 0; } -static unsigned int snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait) +static unsigned int snd_us428ctls_poll(snd_hwdep_t *hw, struct file *file, poll_table *wait) { unsigned int mask = 0; - struct usX2Ydev *us428 = hw->private_data; - struct us428ctls_sharedmem *shm = us428->us428ctls_sharedmem; + usX2Ydev_t *us428 = (usX2Ydev_t*)hw->private_data; + us428ctls_sharedmem_t *shm = us428->us428ctls_sharedmem; if (us428->chip_status & USX2Y_STAT_CHIP_HUP) return POLLHUP; @@ -110,28 +110,26 @@ static unsigned int snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, } -static int snd_usX2Y_hwdep_open(struct snd_hwdep *hw, struct file *file) +static int snd_usX2Y_hwdep_open(snd_hwdep_t *hw, struct file *file) { return 0; } -static int snd_usX2Y_hwdep_release(struct snd_hwdep *hw, struct file *file) +static int snd_usX2Y_hwdep_release(snd_hwdep_t *hw, struct file *file) { return 0; } -static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, - struct snd_hwdep_dsp_status *info) +static int snd_usX2Y_hwdep_dsp_status(snd_hwdep_t *hw, snd_hwdep_dsp_status_t *info) { static char *type_ids[USX2Y_TYPE_NUMS] = { [USX2Y_TYPE_122] = "us122", [USX2Y_TYPE_224] = "us224", [USX2Y_TYPE_428] = "us428", }; - struct usX2Ydev *us428 = hw->private_data; int id = -1; - switch (le16_to_cpu(us428->chip.dev->descriptor.idProduct)) { + switch (le16_to_cpu(((usX2Ydev_t*)hw->private_data)->chip.dev->descriptor.idProduct)) { case USB_ID_US122: id = USX2Y_TYPE_122; break; @@ -146,35 +144,35 @@ static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, return -ENODEV; strcpy(info->id, type_ids[id]); info->num_dsps = 2; // 0: Prepad Data, 1: FPGA Code - if (us428->chip_status & USX2Y_STAT_CHIP_INIT) + if (((usX2Ydev_t*)hw->private_data)->chip_status & USX2Y_STAT_CHIP_INIT) info->chip_ready = 1; info->version = USX2Y_DRIVER_VERSION; return 0; } -static int usX2Y_create_usbmidi(struct snd_card *card) +static int usX2Y_create_usbmidi(snd_card_t* card ) { - static struct snd_usb_midi_endpoint_info quirk_data_1 = { - .out_ep = 0x06, + static snd_usb_midi_endpoint_info_t quirk_data_1 = { + .out_ep =0x06, .in_ep = 0x06, .out_cables = 0x001, .in_cables = 0x001 }; - static struct snd_usb_audio_quirk quirk_1 = { + static snd_usb_audio_quirk_t quirk_1 = { .vendor_name = "TASCAM", .product_name = NAME_ALLCAPS, .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &quirk_data_1 }; - static struct snd_usb_midi_endpoint_info quirk_data_2 = { - .out_ep = 0x06, + static snd_usb_midi_endpoint_info_t quirk_data_2 = { + .out_ep =0x06, .in_ep = 0x06, .out_cables = 0x003, .in_cables = 0x003 }; - static struct snd_usb_audio_quirk quirk_2 = { + static snd_usb_audio_quirk_t quirk_2 = { .vendor_name = "TASCAM", .product_name = "US428", .ifnum = 0, @@ -183,15 +181,13 @@ static int usX2Y_create_usbmidi(struct snd_card *card) }; struct usb_device *dev = usX2Y(card)->chip.dev; struct usb_interface *iface = usb_ifnum_to_if(dev, 0); - struct snd_usb_audio_quirk *quirk = - le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ? - &quirk_2 : &quirk_1; + snd_usb_audio_quirk_t *quirk = le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ? &quirk_2 : &quirk_1; snd_printdd("usX2Y_create_usbmidi \n"); return snd_usb_create_midi_interface(&usX2Y(card)->chip, iface, quirk); } -static int usX2Y_create_alsa_devices(struct snd_card *card) +static int usX2Y_create_alsa_devices(snd_card_t* card) { int err; @@ -211,10 +207,9 @@ static int usX2Y_create_alsa_devices(struct snd_card *card) return err; } -static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, - struct snd_hwdep_dsp_image *dsp) +static int snd_usX2Y_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp) { - struct usX2Ydev *priv = hw->private_data; + usX2Ydev_t *priv = hw->private_data; int lret, err = -EINVAL; snd_printdd( "dsp_load %s\n", dsp->name); @@ -261,10 +256,10 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, } -int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device) +int usX2Y_hwdep_new(snd_card_t* card, struct usb_device* device) { int err; - struct snd_hwdep *hw; + snd_hwdep_t *hw; if ((err = snd_hwdep_new(card, SND_USX2Y_LOADER_ID, 0, &hw)) < 0) return err; diff --git a/trunk/sound/usb/usx2y/usX2Yhwdep.h b/trunk/sound/usb/usx2y/usX2Yhwdep.h index c095d5bf1220..d612a26eb77c 100644 --- a/trunk/sound/usb/usx2y/usX2Yhwdep.h +++ b/trunk/sound/usb/usx2y/usX2Yhwdep.h @@ -1,6 +1,6 @@ #ifndef USX2YHWDEP_H #define USX2YHWDEP_H -int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device); +int usX2Y_hwdep_new(snd_card_t* card, struct usb_device* device); #endif diff --git a/trunk/sound/usb/usx2y/usbus428ctldefs.h b/trunk/sound/usb/usx2y/usbus428ctldefs.h index b864e7e262e5..6af16438d2c7 100644 --- a/trunk/sound/usb/usx2y/usbus428ctldefs.h +++ b/trunk/sound/usb/usx2y/usbus428ctldefs.h @@ -51,7 +51,7 @@ enum E_In84{ #define T_NULL 0x80 -struct us428_ctls { +struct us428_ctls{ unsigned char Fader[9]; unsigned char Transport; unsigned char Modifier; @@ -63,42 +63,46 @@ struct us428_ctls { unsigned char Wheel[5]; }; -struct us428_setByte { +typedef struct us428_ctls us428_ctls_t; + +typedef struct us428_setByte{ unsigned char Offset, Value; -}; +}us428_setByte_t; enum { eLT_Volume = 0, eLT_Light }; -struct usX2Y_volume { +typedef struct usX2Y_volume { unsigned char Channel, LH, LL, RH, RL; -}; +} usX2Y_volume_t; -struct us428_lights { - struct us428_setByte Light[7]; +struct us428_lights{ + us428_setByte_t Light[7]; }; +typedef struct us428_lights us428_lights_t; -struct us428_p4out { +typedef struct { char type; union { - struct usX2Y_volume vol; - struct us428_lights lights; + usX2Y_volume_t vol; + us428_lights_t lights; } val; -}; +} us428_p4out_t; #define N_us428_ctl_BUFS 16 #define N_us428_p4out_BUFS 16 struct us428ctls_sharedmem{ - struct us428_ctls CtlSnapShot[N_us428_ctl_BUFS]; - int CtlSnapShotDiffersAt[N_us428_ctl_BUFS]; - int CtlSnapShotLast, CtlSnapShotRed; - struct us428_p4out p4out[N_us428_p4out_BUFS]; - int p4outLast, p4outSent; + us428_ctls_t CtlSnapShot[N_us428_ctl_BUFS]; + int CtlSnapShotDiffersAt[N_us428_ctl_BUFS]; + int CtlSnapShotLast, CtlSnapShotRed; + us428_p4out_t p4out[N_us428_p4out_BUFS]; + int p4outLast, p4outSent; }; +typedef struct us428ctls_sharedmem us428ctls_sharedmem_t; diff --git a/trunk/sound/usb/usx2y/usbusx2y.c b/trunk/sound/usb/usx2y/usbusx2y.c index e0abb56bbe49..cf77313c609d 100644 --- a/trunk/sound/usb/usx2y/usbusx2y.c +++ b/trunk/sound/usb/usx2y/usbusx2y.c @@ -167,28 +167,28 @@ MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS"."); static int snd_usX2Y_card_used[SNDRV_CARDS]; static void usX2Y_usb_disconnect(struct usb_device* usb_device, void* ptr); -static void snd_usX2Y_card_private_free(struct snd_card *card); +static void snd_usX2Y_card_private_free(snd_card_t *card); /* * pipe 4 is used for switching the lamps, setting samplerate, volumes .... */ -static void i_usX2Y_Out04Int(struct urb *urb, struct pt_regs *regs) +static void i_usX2Y_Out04Int(struct urb* urb, struct pt_regs *regs) { #ifdef CONFIG_SND_DEBUG if (urb->status) { int i; - struct usX2Ydev *usX2Y = urb->context; + usX2Ydev_t* usX2Y = urb->context; for (i = 0; i < 10 && usX2Y->AS04.urb[i] != urb; i++); snd_printdd("i_usX2Y_Out04Int() urb %i status=%i\n", i, urb->status); } #endif } -static void i_usX2Y_In04Int(struct urb *urb, struct pt_regs *regs) +static void i_usX2Y_In04Int(struct urb* urb, struct pt_regs *regs) { int err = 0; - struct usX2Ydev *usX2Y = urb->context; - struct us428ctls_sharedmem *us428ctls = usX2Y->us428ctls_sharedmem; + usX2Ydev_t *usX2Y = urb->context; + us428ctls_sharedmem_t *us428ctls = usX2Y->us428ctls_sharedmem; usX2Y->In04IntCalls++; @@ -239,10 +239,10 @@ static void i_usX2Y_In04Int(struct urb *urb, struct pt_regs *regs) send = 0; for (j = 0; j < URBS_AsyncSeq && !err; ++j) if (0 == usX2Y->AS04.urb[j]->status) { - struct us428_p4out *p4out = us428ctls->p4out + send; // FIXME if more then 1 p4out is new, 1 gets lost. + us428_p4out_t *p4out = us428ctls->p4out + send; // FIXME if more then 1 p4out is new, 1 gets lost. usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->chip.dev, usb_sndbulkpipe(usX2Y->chip.dev, 0x04), &p4out->val.vol, - p4out->type == eLT_Light ? sizeof(struct us428_lights) : 5, + p4out->type == eLT_Light ? sizeof(us428_lights_t) : 5, i_usX2Y_Out04Int, usX2Y); err = usb_submit_urb(usX2Y->AS04.urb[j], GFP_ATOMIC); us428ctls->p4outSent = send; @@ -261,7 +261,7 @@ static void i_usX2Y_In04Int(struct urb *urb, struct pt_regs *regs) /* * Prepare some urbs */ -int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y) +int usX2Y_AsyncSeq04_init(usX2Ydev_t* usX2Y) { int err = 0, i; @@ -283,8 +283,9 @@ int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y) return err; } -int usX2Y_In04_init(struct usX2Ydev *usX2Y) +int usX2Y_In04_init(usX2Ydev_t* usX2Y) { + int err = 0; if (! (usX2Y->In04urb = usb_alloc_urb(0, GFP_KERNEL))) return -ENOMEM; @@ -298,10 +299,11 @@ int usX2Y_In04_init(struct usX2Ydev *usX2Y) usX2Y->In04Buf, 21, i_usX2Y_In04Int, usX2Y, 10); - return usb_submit_urb(usX2Y->In04urb, GFP_KERNEL); + err = usb_submit_urb(usX2Y->In04urb, GFP_KERNEL); + return err; } -static void usX2Y_unlinkSeq(struct snd_usX2Y_AsyncSeq *S) +static void usX2Y_unlinkSeq(snd_usX2Y_AsyncSeq_t* S) { int i; for (i = 0; i < URBS_AsyncSeq; ++i) { @@ -334,16 +336,16 @@ static struct usb_device_id snd_usX2Y_usb_id_table[] = { { /* terminator */ } }; -static struct snd_card *usX2Y_create_card(struct usb_device *device) +static snd_card_t* usX2Y_create_card(struct usb_device* device) { int dev; - struct snd_card * card; + snd_card_t* card; for (dev = 0; dev < SNDRV_CARDS; ++dev) if (enable[dev] && !snd_usX2Y_card_used[dev]) break; if (dev >= SNDRV_CARDS) return NULL; - card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct usX2Ydev)); + card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(usX2Ydev_t)); if (!card) return NULL; snd_usX2Y_card_used[usX2Y(card)->chip.index = dev] = 1; @@ -367,10 +369,10 @@ static struct snd_card *usX2Y_create_card(struct usb_device *device) } -static void *usX2Y_usb_probe(struct usb_device *device, struct usb_interface *intf, const struct usb_device_id *device_id) +static void* usX2Y_usb_probe(struct usb_device* device, struct usb_interface *intf, const struct usb_device_id* device_id) { int err; - struct snd_card * card; + snd_card_t* card; if (le16_to_cpu(device->descriptor.idVendor) != 0x1604 || (le16_to_cpu(device->descriptor.idProduct) != USB_ID_US122 && le16_to_cpu(device->descriptor.idProduct) != USB_ID_US224 && @@ -407,13 +409,14 @@ static void snd_usX2Y_disconnect(struct usb_interface *intf) MODULE_DEVICE_TABLE(usb, snd_usX2Y_usb_id_table); static struct usb_driver snd_usX2Y_usb_driver = { + .owner = THIS_MODULE, .name = "snd-usb-usx2y", .probe = snd_usX2Y_probe, .disconnect = snd_usX2Y_disconnect, .id_table = snd_usX2Y_usb_id_table, }; -static void snd_usX2Y_card_private_free(struct snd_card *card) +static void snd_usX2Y_card_private_free(snd_card_t *card) { kfree(usX2Y(card)->In04Buf); usb_free_urb(usX2Y(card)->In04urb); @@ -426,24 +429,23 @@ static void snd_usX2Y_card_private_free(struct snd_card *card) /* * Frees the device. */ -static void usX2Y_usb_disconnect(struct usb_device *device, void* ptr) +static void usX2Y_usb_disconnect(struct usb_device* device, void* ptr) { if (ptr) { - struct snd_card *card = ptr; - struct usX2Ydev *usX2Y = usX2Y(card); - struct list_head *p; + usX2Ydev_t* usX2Y = usX2Y((snd_card_t*)ptr); + struct list_head* p; usX2Y->chip.shutdown = 1; usX2Y->chip_status = USX2Y_STAT_CHIP_HUP; usX2Y_unlinkSeq(&usX2Y->AS04); usb_kill_urb(usX2Y->In04urb); - snd_card_disconnect(card); + snd_card_disconnect((snd_card_t*)ptr); /* release the midi resources */ list_for_each(p, &usX2Y->chip.midi_list) { snd_usbmidi_disconnect(p); } if (usX2Y->us428ctls_sharedmem) wake_up(&usX2Y->us428ctls_wait_queue_head); - snd_card_free(card); + snd_card_free((snd_card_t*)ptr); } } diff --git a/trunk/sound/usb/usx2y/usbusx2y.h b/trunk/sound/usb/usx2y/usbusx2y.h index 435c1feda9df..f65f3a7194ca 100644 --- a/trunk/sound/usb/usx2y/usbusx2y.h +++ b/trunk/sound/usb/usx2y/usbusx2y.h @@ -8,46 +8,47 @@ #define URBS_AsyncSeq 10 #define URB_DataLen_AsyncSeq 32 -struct snd_usX2Y_AsyncSeq { - struct urb *urb[URBS_AsyncSeq]; - char *buffer; -}; +typedef struct { + struct urb* urb[URBS_AsyncSeq]; + char* buffer; +} snd_usX2Y_AsyncSeq_t; -struct snd_usX2Y_urbSeq { +typedef struct { int submitted; int len; - struct urb *urb[0]; -}; + struct urb* urb[0]; +} snd_usX2Y_urbSeq_t; +typedef struct snd_usX2Y_substream snd_usX2Y_substream_t; #include "usx2yhwdeppcm.h" -struct usX2Ydev { - struct snd_usb_audio chip; +typedef struct { + snd_usb_audio_t chip; int stride; struct urb *In04urb; void *In04Buf; char In04Last[24]; unsigned In04IntCalls; - struct snd_usX2Y_urbSeq *US04; + snd_usX2Y_urbSeq_t *US04; wait_queue_head_t In04WaitQueue; - struct snd_usX2Y_AsyncSeq AS04; + snd_usX2Y_AsyncSeq_t AS04; unsigned int rate, format; int chip_status; struct semaphore prepare_mutex; - struct us428ctls_sharedmem *us428ctls_sharedmem; + us428ctls_sharedmem_t *us428ctls_sharedmem; int wait_iso_frame; wait_queue_head_t us428ctls_wait_queue_head; - struct snd_usX2Y_hwdep_pcm_shm *hwdep_pcm_shm; - struct snd_usX2Y_substream *subs[4]; - struct snd_usX2Y_substream * volatile prepare_subs; + snd_usX2Y_hwdep_pcm_shm_t *hwdep_pcm_shm; + snd_usX2Y_substream_t *subs[4]; + snd_usX2Y_substream_t * volatile prepare_subs; wait_queue_head_t prepare_wait_queue; -}; +} usX2Ydev_t; struct snd_usX2Y_substream { - struct usX2Ydev *usX2Y; - struct snd_pcm_substream *pcm_substream; + usX2Ydev_t *usX2Y; + snd_pcm_substream_t *pcm_substream; int endpoint; unsigned int maxpacksize; /* max packet size in bytes */ @@ -71,12 +72,12 @@ struct snd_usX2Y_substream { }; -#define usX2Y(c) ((struct usX2Ydev *)(c)->private_data) +#define usX2Y(c) ((usX2Ydev_t*)(c)->private_data) -int usX2Y_audio_create(struct snd_card *card); +int usX2Y_audio_create(snd_card_t* card); -int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y); -int usX2Y_In04_init(struct usX2Ydev *usX2Y); +int usX2Y_AsyncSeq04_init(usX2Ydev_t* usX2Y); +int usX2Y_In04_init(usX2Ydev_t* usX2Y); #define NAME_ALLCAPS "US-X2Y" diff --git a/trunk/sound/usb/usx2y/usbusx2yaudio.c b/trunk/sound/usb/usx2y/usbusx2yaudio.c index a6bbc7a6348f..affda973cece 100644 --- a/trunk/sound/usb/usx2y/usbusx2yaudio.c +++ b/trunk/sound/usb/usx2y/usbusx2yaudio.c @@ -67,20 +67,18 @@ #endif -static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs) +static int usX2Y_urb_capt_retire(snd_usX2Y_substream_t *subs) { struct urb *urb = subs->completed_urb; - struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + snd_pcm_runtime_t *runtime = subs->pcm_substream->runtime; unsigned char *cp; int i, len, lens = 0, hwptr_done = subs->hwptr_done; - struct usX2Ydev *usX2Y = subs->usX2Y; + usX2Ydev_t *usX2Y = subs->usX2Y; for (i = 0; i < nr_of_packs(); i++) { cp = (unsigned char*)urb->transfer_buffer + urb->iso_frame_desc[i].offset; if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */ - snd_printk(KERN_ERR "active frame status %i. " - "Most propably some hardware problem.\n", - urb->iso_frame_desc[i].status); + snd_printk(KERN_ERR "activ frame status %i. Most propably some hardware problem.\n", urb->iso_frame_desc[i].status); return urb->iso_frame_desc[i].status; } len = urb->iso_frame_desc[i].actual_length / usX2Y->stride; @@ -96,8 +94,7 @@ static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs) memcpy(runtime->dma_area + hwptr_done * usX2Y->stride, cp, blen); memcpy(runtime->dma_area, cp + blen, len * usX2Y->stride - blen); } else { - memcpy(runtime->dma_area + hwptr_done * usX2Y->stride, cp, - len * usX2Y->stride); + memcpy(runtime->dma_area + hwptr_done * usX2Y->stride, cp, len * usX2Y->stride); } lens += len; if ((hwptr_done += len) >= runtime->buffer_size) @@ -123,13 +120,13 @@ static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs) * it directly from the buffer. thus the data is once copied to * a temporary buffer and urb points to that. */ -static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, +static int usX2Y_urb_play_prepare(snd_usX2Y_substream_t *subs, struct urb *cap_urb, struct urb *urb) { int count, counts, pack; - struct usX2Ydev *usX2Y = subs->usX2Y; - struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + usX2Ydev_t* usX2Y = subs->usX2Y; + snd_pcm_runtime_t *runtime = subs->pcm_substream->runtime; count = 0; for (pack = 0; pack < nr_of_packs(); pack++) { @@ -142,8 +139,7 @@ static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, } /* set up descriptor */ urb->iso_frame_desc[pack].offset = pack ? - urb->iso_frame_desc[pack - 1].offset + - urb->iso_frame_desc[pack - 1].length : + urb->iso_frame_desc[pack - 1].offset + urb->iso_frame_desc[pack - 1].length : 0; urb->iso_frame_desc[pack].length = cap_urb->iso_frame_desc[pack].actual_length; } @@ -155,10 +151,8 @@ static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, int len; len = runtime->buffer_size - subs->hwptr; urb->transfer_buffer = subs->tmpbuf; - memcpy(subs->tmpbuf, runtime->dma_area + - subs->hwptr * usX2Y->stride, len * usX2Y->stride); - memcpy(subs->tmpbuf + len * usX2Y->stride, - runtime->dma_area, (count - len) * usX2Y->stride); + memcpy(subs->tmpbuf, runtime->dma_area + subs->hwptr * usX2Y->stride, len * usX2Y->stride); + memcpy(subs->tmpbuf + len * usX2Y->stride, runtime->dma_area, (count - len) * usX2Y->stride); subs->hwptr += count; subs->hwptr -= runtime->buffer_size; } else { @@ -178,9 +172,9 @@ static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, * * update the current position and call callback if a period is processed. */ -static void usX2Y_urb_play_retire(struct snd_usX2Y_substream *subs, struct urb *urb) +static void usX2Y_urb_play_retire(snd_usX2Y_substream_t *subs, struct urb *urb) { - struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + snd_pcm_runtime_t *runtime = subs->pcm_substream->runtime; int len = urb->actual_length / subs->usX2Y->stride; subs->transfer_done += len; @@ -193,7 +187,7 @@ static void usX2Y_urb_play_retire(struct snd_usX2Y_substream *subs, struct urb * } } -static int usX2Y_urb_submit(struct snd_usX2Y_substream *subs, struct urb *urb, int frame) +static int usX2Y_urb_submit(snd_usX2Y_substream_t *subs, struct urb *urb, int frame) { int err; if (!urb) @@ -208,47 +202,50 @@ static int usX2Y_urb_submit(struct snd_usX2Y_substream *subs, struct urb *urb, i return 0; } -static inline int usX2Y_usbframe_complete(struct snd_usX2Y_substream *capsubs, - struct snd_usX2Y_substream *playbacksubs, - int frame) +static inline int usX2Y_usbframe_complete(snd_usX2Y_substream_t *capsubs, snd_usX2Y_substream_t *playbacksubs, int frame) { int err, state; - struct urb *urb = playbacksubs->completed_urb; - - state = atomic_read(&playbacksubs->state); - if (NULL != urb) { - if (state == state_RUNNING) - usX2Y_urb_play_retire(playbacksubs, urb); - else if (state >= state_PRERUNNING) - atomic_inc(&playbacksubs->state); - } else { - switch (state) { - case state_STARTING1: - urb = playbacksubs->urb[0]; - atomic_inc(&playbacksubs->state); - break; - case state_STARTING2: - urb = playbacksubs->urb[1]; - atomic_inc(&playbacksubs->state); - break; + { + struct urb *urb = playbacksubs->completed_urb; + + state = atomic_read(&playbacksubs->state); + if (NULL != urb) { + if (state == state_RUNNING) + usX2Y_urb_play_retire(playbacksubs, urb); + else + if (state >= state_PRERUNNING) { + atomic_inc(&playbacksubs->state); + } + } else { + switch (state) { + case state_STARTING1: + urb = playbacksubs->urb[0]; + atomic_inc(&playbacksubs->state); + break; + case state_STARTING2: + urb = playbacksubs->urb[1]; + atomic_inc(&playbacksubs->state); + break; + } } - } - if (urb) { - if ((err = usX2Y_urb_play_prepare(playbacksubs, capsubs->completed_urb, urb)) || - (err = usX2Y_urb_submit(playbacksubs, urb, frame))) { - return err; + if (urb) { + if ((err = usX2Y_urb_play_prepare(playbacksubs, capsubs->completed_urb, urb)) || + (err = usX2Y_urb_submit(playbacksubs, urb, frame))) { + return err; + } } - } - - playbacksubs->completed_urb = NULL; + playbacksubs->completed_urb = NULL; + } state = atomic_read(&capsubs->state); if (state >= state_PREPARED) { if (state == state_RUNNING) { if ((err = usX2Y_urb_capt_retire(capsubs))) return err; - } else if (state >= state_PRERUNNING) - atomic_inc(&capsubs->state); + } else + if (state >= state_PRERUNNING) { + atomic_inc(&capsubs->state); + } if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame))) return err; } @@ -257,19 +254,18 @@ static inline int usX2Y_usbframe_complete(struct snd_usX2Y_substream *capsubs, } -static void usX2Y_clients_stop(struct usX2Ydev *usX2Y) +static void usX2Y_clients_stop(usX2Ydev_t *usX2Y) { int s, u; - for (s = 0; s < 4; s++) { - struct snd_usX2Y_substream *subs = usX2Y->subs[s]; + snd_usX2Y_substream_t *subs = usX2Y->subs[s]; if (subs) { snd_printdd("%i %p state=%i\n", s, subs, atomic_read(&subs->state)); atomic_set(&subs->state, state_STOPPED); } } for (s = 0; s < 4; s++) { - struct snd_usX2Y_substream *subs = usX2Y->subs[s]; + snd_usX2Y_substream_t *subs = usX2Y->subs[s]; if (subs) { if (atomic_read(&subs->state) >= state_PRERUNNING) { snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN); @@ -277,8 +273,7 @@ static void usX2Y_clients_stop(struct usX2Ydev *usX2Y) for (u = 0; u < NRURBS; u++) { struct urb *urb = subs->urb[u]; if (NULL != urb) - snd_printdd("%i status=%i start_frame=%i\n", - u, urb->status, urb->start_frame); + snd_printdd("%i status=%i start_frame=%i\n", u, urb->status, urb->start_frame); } } } @@ -286,36 +281,30 @@ static void usX2Y_clients_stop(struct usX2Ydev *usX2Y) wake_up(&usX2Y->prepare_wait_queue); } -static void usX2Y_error_urb_status(struct usX2Ydev *usX2Y, - struct snd_usX2Y_substream *subs, struct urb *urb) +static void usX2Y_error_urb_status(usX2Ydev_t *usX2Y, snd_usX2Y_substream_t *subs, struct urb *urb) { snd_printk(KERN_ERR "ep=%i stalled with status=%i\n", subs->endpoint, urb->status); urb->status = 0; usX2Y_clients_stop(usX2Y); } -static void usX2Y_error_sequence(struct usX2Ydev *usX2Y, - struct snd_usX2Y_substream *subs, struct urb *urb) +static void usX2Y_error_sequence(usX2Ydev_t *usX2Y, snd_usX2Y_substream_t *subs, struct urb *urb) { snd_printk(KERN_ERR "Sequence Error!(hcd_frame=%i ep=%i%s;wait=%i,frame=%i).\n" KERN_ERR "Most propably some urb of usb-frame %i is still missing.\n" KERN_ERR "Cause could be too long delays in usb-hcd interrupt handling.\n", usb_get_current_frame_number(usX2Y->chip.dev), - subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", - usX2Y->wait_iso_frame, urb->start_frame, usX2Y->wait_iso_frame); + subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", usX2Y->wait_iso_frame, urb->start_frame, usX2Y->wait_iso_frame); usX2Y_clients_stop(usX2Y); } static void i_usX2Y_urb_complete(struct urb *urb, struct pt_regs *regs) { - struct snd_usX2Y_substream *subs = urb->context; - struct usX2Ydev *usX2Y = subs->usX2Y; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t*)urb->context; + usX2Ydev_t *usX2Y = subs->usX2Y; if (unlikely(atomic_read(&subs->state) < state_PREPARED)) { - snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", - usb_get_current_frame_number(usX2Y->chip.dev), - subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", - urb->status, urb->start_frame); + snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", usb_get_current_frame_number(usX2Y->chip.dev), subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", urb->status, urb->start_frame); return; } if (unlikely(urb->status)) { @@ -329,12 +318,10 @@ static void i_usX2Y_urb_complete(struct urb *urb, struct pt_regs *regs) return; } { - struct snd_usX2Y_substream *capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE], + snd_usX2Y_substream_t *capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE], *playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; - if (capsubs->completed_urb && - atomic_read(&capsubs->state) >= state_PREPARED && - (playbacksubs->completed_urb || - atomic_read(&playbacksubs->state) < state_PREPARED)) { + if (capsubs->completed_urb && atomic_read(&capsubs->state) >= state_PREPARED && + (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < state_PREPARED)) { if (!usX2Y_usbframe_complete(capsubs, playbacksubs, urb->start_frame)) { if (nr_of_packs() <= urb->start_frame && urb->start_frame <= (2 * nr_of_packs() - 1)) // uhci and ohci @@ -349,12 +336,11 @@ static void i_usX2Y_urb_complete(struct urb *urb, struct pt_regs *regs) } } -static void usX2Y_urbs_set_complete(struct usX2Ydev * usX2Y, - void (*complete)(struct urb *, struct pt_regs *)) +static void usX2Y_urbs_set_complete(usX2Ydev_t * usX2Y, void (*complete)(struct urb *, struct pt_regs *)) { int s, u; for (s = 0; s < 4; s++) { - struct snd_usX2Y_substream *subs = usX2Y->subs[s]; + snd_usX2Y_substream_t *subs = usX2Y->subs[s]; if (NULL != subs) for (u = 0; u < NRURBS; u++) { struct urb * urb = subs->urb[u]; @@ -364,7 +350,7 @@ static void usX2Y_urbs_set_complete(struct usX2Ydev * usX2Y, } } -static void usX2Y_subs_startup_finish(struct usX2Ydev * usX2Y) +static void usX2Y_subs_startup_finish(usX2Ydev_t * usX2Y) { usX2Y_urbs_set_complete(usX2Y, i_usX2Y_urb_complete); usX2Y->prepare_subs = NULL; @@ -372,9 +358,9 @@ static void usX2Y_subs_startup_finish(struct usX2Ydev * usX2Y) static void i_usX2Y_subs_startup(struct urb *urb, struct pt_regs *regs) { - struct snd_usX2Y_substream *subs = urb->context; - struct usX2Ydev *usX2Y = subs->usX2Y; - struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t*)urb->context; + usX2Ydev_t *usX2Y = subs->usX2Y; + snd_usX2Y_substream_t *prepare_subs = usX2Y->prepare_subs; if (NULL != prepare_subs) if (urb->start_frame == prepare_subs->urb[0]->start_frame) { usX2Y_subs_startup_finish(usX2Y); @@ -385,10 +371,9 @@ static void i_usX2Y_subs_startup(struct urb *urb, struct pt_regs *regs) i_usX2Y_urb_complete(urb, regs); } -static void usX2Y_subs_prepare(struct snd_usX2Y_substream *subs) +static void usX2Y_subs_prepare(snd_usX2Y_substream_t *subs) { - snd_printdd("usX2Y_substream_prepare(%p) ep=%i urb0=%p urb1=%p\n", - subs, subs->endpoint, subs->urb[0], subs->urb[1]); + snd_printdd("usX2Y_substream_prepare(%p) ep=%i urb0=%p urb1=%p\n", subs, subs->endpoint, subs->urb[0], subs->urb[1]); /* reset the pointer */ subs->hwptr = 0; subs->hwptr_done = 0; @@ -396,7 +381,7 @@ static void usX2Y_subs_prepare(struct snd_usX2Y_substream *subs) } -static void usX2Y_urb_release(struct urb **urb, int free_tb) +static void usX2Y_urb_release(struct urb** urb, int free_tb) { if (*urb) { usb_kill_urb(*urb); @@ -409,13 +394,12 @@ static void usX2Y_urb_release(struct urb **urb, int free_tb) /* * release a substreams urbs */ -static void usX2Y_urbs_release(struct snd_usX2Y_substream *subs) +static void usX2Y_urbs_release(snd_usX2Y_substream_t *subs) { int i; snd_printdd("usX2Y_urbs_release() %i\n", subs->endpoint); for (i = 0; i < NRURBS; i++) - usX2Y_urb_release(subs->urb + i, - subs != subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]); + usX2Y_urb_release(subs->urb + i, subs != subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]); kfree(subs->tmpbuf); subs->tmpbuf = NULL; @@ -423,7 +407,7 @@ static void usX2Y_urbs_release(struct snd_usX2Y_substream *subs) /* * initialize a substream's urbs */ -static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) +static int usX2Y_urbs_allocate(snd_usX2Y_substream_t *subs) { int i; unsigned int pipe; @@ -445,7 +429,7 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) } /* allocate and initialize data urbs */ for (i = 0; i < NRURBS; i++) { - struct urb **purb = subs->urb + i; + struct urb** purb = subs->urb + i; if (*purb) { usb_kill_urb(*purb); continue; @@ -473,68 +457,70 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) return 0; } -static void usX2Y_subs_startup(struct snd_usX2Y_substream *subs) +static void usX2Y_subs_startup(snd_usX2Y_substream_t *subs) { - struct usX2Ydev *usX2Y = subs->usX2Y; + usX2Ydev_t *usX2Y = subs->usX2Y; usX2Y->prepare_subs = subs; subs->urb[0]->start_frame = -1; wmb(); usX2Y_urbs_set_complete(usX2Y, i_usX2Y_subs_startup); } -static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs) +static int usX2Y_urbs_start(snd_usX2Y_substream_t *subs) { int i, err; - struct usX2Ydev *usX2Y = subs->usX2Y; + usX2Ydev_t *usX2Y = subs->usX2Y; if ((err = usX2Y_urbs_allocate(subs)) < 0) return err; subs->completed_urb = NULL; for (i = 0; i < 4; i++) { - struct snd_usX2Y_substream *subs = usX2Y->subs[i]; + snd_usX2Y_substream_t *subs = usX2Y->subs[i]; if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED) goto start; } usX2Y->wait_iso_frame = -1; - start: - usX2Y_subs_startup(subs); - for (i = 0; i < NRURBS; i++) { - struct urb *urb = subs->urb[i]; - if (usb_pipein(urb->pipe)) { - unsigned long pack; - if (0 == i) - atomic_set(&subs->state, state_STARTING3); - urb->dev = usX2Y->chip.dev; - urb->transfer_flags = URB_ISO_ASAP; - for (pack = 0; pack < nr_of_packs(); pack++) { - urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack; - urb->iso_frame_desc[pack].length = subs->maxpacksize; - } - urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); - if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) { - snd_printk (KERN_ERR "cannot submit datapipe for urb %d, err = %d\n", i, err); - err = -EPIPE; - goto cleanup; + { + usX2Y_subs_startup(subs); + for (i = 0; i < NRURBS; i++) { + struct urb *urb = subs->urb[i]; + if (usb_pipein(urb->pipe)) { + unsigned long pack; + if (0 == i) + atomic_set(&subs->state, state_STARTING3); + urb->dev = usX2Y->chip.dev; + urb->transfer_flags = URB_ISO_ASAP; + for (pack = 0; pack < nr_of_packs(); pack++) { + urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack; + urb->iso_frame_desc[pack].length = subs->maxpacksize; + } + urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); + if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) { + snd_printk (KERN_ERR "cannot submit datapipe for urb %d, err = %d\n", i, err); + err = -EPIPE; + goto cleanup; + } else { + if (0 > usX2Y->wait_iso_frame) + usX2Y->wait_iso_frame = urb->start_frame; + } + urb->transfer_flags = 0; } else { - if (0 > usX2Y->wait_iso_frame) - usX2Y->wait_iso_frame = urb->start_frame; + atomic_set(&subs->state, state_STARTING1); + break; } - urb->transfer_flags = 0; - } else { - atomic_set(&subs->state, state_STARTING1); - break; } - } - err = 0; - wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs); - if (atomic_read(&subs->state) != state_PREPARED) - err = -EPIPE; - - cleanup: - if (err) { - usX2Y_subs_startup_finish(usX2Y); - usX2Y_clients_stop(usX2Y); // something is completely wroong > stop evrything + err = 0; + wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs); + if (atomic_read(&subs->state) != state_PREPARED) { + err = -EPIPE; + } + + cleanup: + if (err) { + usX2Y_subs_startup_finish(usX2Y); + usX2Y_clients_stop(usX2Y); // something is completely wroong > stop evrything + } } return err; } @@ -542,17 +528,17 @@ static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs) /* * return the current pcm pointer. just return the hwptr_done value. */ -static snd_pcm_uframes_t snd_usX2Y_pcm_pointer(struct snd_pcm_substream *substream) +static snd_pcm_uframes_t snd_usX2Y_pcm_pointer(snd_pcm_substream_t *substream) { - struct snd_usX2Y_substream *subs = substream->runtime->private_data; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)substream->runtime->private_data; return subs->hwptr_done; } /* * start/stop substream */ -static int snd_usX2Y_pcm_trigger(struct snd_pcm_substream *substream, int cmd) +static int snd_usX2Y_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { - struct snd_usX2Y_substream *subs = substream->runtime->private_data; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)substream->runtime->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -663,9 +649,9 @@ static struct s_c2 SetRate48000[] = }; #define NOOF_SETRATE_URBS ARRAY_SIZE(SetRate48000) -static void i_usX2Y_04Int(struct urb *urb, struct pt_regs *regs) +static void i_usX2Y_04Int(struct urb* urb, struct pt_regs *regs) { - struct usX2Ydev *usX2Y = urb->context; + usX2Ydev_t* usX2Y = urb->context; if (urb->status) snd_printk(KERN_ERR "snd_usX2Y_04Int() urb->status=%i\n", urb->status); @@ -673,20 +659,21 @@ static void i_usX2Y_04Int(struct urb *urb, struct pt_regs *regs) wake_up(&usX2Y->In04WaitQueue); } -static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) +static int usX2Y_rate_set(usX2Ydev_t *usX2Y, int rate) { int err = 0, i; - struct snd_usX2Y_urbSeq *us = NULL; + snd_usX2Y_urbSeq_t *us = NULL; int *usbdata = NULL; struct s_c2 *ra = rate == 48000 ? SetRate48000 : SetRate44100; if (usX2Y->rate != rate) { - us = kzalloc(sizeof(*us) + sizeof(struct urb*) * NOOF_SETRATE_URBS, GFP_KERNEL); + us = kmalloc(sizeof(*us) + sizeof(struct urb*) * NOOF_SETRATE_URBS, GFP_KERNEL); if (NULL == us) { err = -ENOMEM; goto cleanup; } - usbdata = kmalloc(sizeof(int) * NOOF_SETRATE_URBS, GFP_KERNEL); + memset(us, 0, sizeof(*us) + sizeof(struct urb*) * NOOF_SETRATE_URBS); + usbdata = kmalloc(sizeof(int)*NOOF_SETRATE_URBS, GFP_KERNEL); if (NULL == usbdata) { err = -ENOMEM; goto cleanup; @@ -726,8 +713,9 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) usX2Y->US04 = NULL; kfree(usbdata); kfree(us); - if (!err) + if (!err) { usX2Y->rate = rate; + } } } @@ -735,7 +723,7 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) } -static int usX2Y_format_set(struct usX2Ydev *usX2Y, snd_pcm_format_t format) +static int usX2Y_format_set(usX2Ydev_t *usX2Y, snd_pcm_format_t format) { int alternate, err; struct list_head* p; @@ -765,40 +753,40 @@ static int usX2Y_format_set(struct usX2Ydev *usX2Y, snd_pcm_format_t format) } -static int snd_usX2Y_pcm_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *hw_params) +static int snd_usX2Y_pcm_hw_params(snd_pcm_substream_t *substream, + snd_pcm_hw_params_t *hw_params) { int err = 0; unsigned int rate = params_rate(hw_params); snd_pcm_format_t format = params_format(hw_params); - struct snd_card *card = substream->pstr->pcm->card; - struct list_head *list; - snd_printdd("snd_usX2Y_hw_params(%p, %p)\n", substream, hw_params); - // all pcm substreams off one usX2Y have to operate at the same rate & format - list_for_each(list, &card->devices) { - struct snd_device *dev; - struct snd_pcm *pcm; - int s; - dev = snd_device(list); - if (dev->type != SNDRV_DEV_PCM) - continue; - pcm = dev->device_data; - for (s = 0; s < 2; ++s) { - struct snd_pcm_substream *test_substream; - test_substream = pcm->streams[s].substream; - if (test_substream && test_substream != substream && - test_substream->runtime && - ((test_substream->runtime->format && - test_substream->runtime->format != format) || - (test_substream->runtime->rate && - test_substream->runtime->rate != rate))) - return -EINVAL; + + { // all pcm substreams off one usX2Y have to operate at the same rate & format + snd_card_t *card = substream->pstr->pcm->card; + struct list_head *list; + list_for_each(list, &card->devices) { + snd_device_t *dev; + snd_pcm_t *pcm; + int s; + dev = snd_device(list); + if (dev->type != SNDRV_DEV_PCM) + continue; + pcm = dev->device_data; + for (s = 0; s < 2; ++s) { + snd_pcm_substream_t *test_substream; + test_substream = pcm->streams[s].substream; + if (test_substream && test_substream != substream && + test_substream->runtime && + ((test_substream->runtime->format && + test_substream->runtime->format != format) || + (test_substream->runtime->rate && + test_substream->runtime->rate != rate))) + return -EINVAL; + } } } if (0 > (err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)))) { - snd_printk(KERN_ERR "snd_pcm_lib_malloc_pages(%p, %i) returned %i\n", - substream, params_buffer_bytes(hw_params), err); + snd_printk(KERN_ERR "snd_pcm_lib_malloc_pages(%p, %i) returned %i\n", substream, params_buffer_bytes(hw_params), err); return err; } return 0; @@ -807,15 +795,15 @@ static int snd_usX2Y_pcm_hw_params(struct snd_pcm_substream *substream, /* * free the buffer */ -static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream) +static int snd_usX2Y_pcm_hw_free(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usX2Y_substream *subs = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data; down(&subs->usX2Y->prepare_mutex); snd_printdd("snd_usX2Y_hw_free(%p)\n", substream); if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) { - struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; + snd_usX2Y_substream_t *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; atomic_set(&subs->state, state_STOPPED); usX2Y_urbs_release(subs); if (!cap_subs->pcm_substream || @@ -826,7 +814,7 @@ static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream) usX2Y_urbs_release(cap_subs); } } else { - struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; + snd_usX2Y_substream_t *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; if (atomic_read(&playback_subs->state) < state_PREPARED) { atomic_set(&subs->state, state_STOPPED); usX2Y_urbs_release(subs); @@ -840,12 +828,12 @@ static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream) * * set format and initialize urbs */ -static int snd_usX2Y_pcm_prepare(struct snd_pcm_substream *substream) +static int snd_usX2Y_pcm_prepare(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usX2Y_substream *subs = runtime->private_data; - struct usX2Ydev *usX2Y = subs->usX2Y; - struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data; + usX2Ydev_t *usX2Y = subs->usX2Y; + snd_usX2Y_substream_t *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; int err = 0; snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream); @@ -873,7 +861,7 @@ static int snd_usX2Y_pcm_prepare(struct snd_pcm_substream *substream) return err; } -static struct snd_pcm_hardware snd_usX2Y_2c = +static snd_pcm_hardware_t snd_usX2Y_2c = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -894,11 +882,11 @@ static struct snd_pcm_hardware snd_usX2Y_2c = -static int snd_usX2Y_pcm_open(struct snd_pcm_substream *substream) +static int snd_usX2Y_pcm_open(snd_pcm_substream_t *substream) { - struct snd_usX2Y_substream *subs = ((struct snd_usX2Y_substream **) + snd_usX2Y_substream_t *subs = ((snd_usX2Y_substream_t **) snd_pcm_substream_chip(substream))[substream->stream]; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS) return -EBUSY; @@ -912,18 +900,19 @@ static int snd_usX2Y_pcm_open(struct snd_pcm_substream *substream) -static int snd_usX2Y_pcm_close(struct snd_pcm_substream *substream) +static int snd_usX2Y_pcm_close(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usX2Y_substream *subs = runtime->private_data; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data; + int err = 0; subs->pcm_substream = NULL; - return 0; + return err; } -static struct snd_pcm_ops snd_usX2Y_pcm_ops = +static snd_pcm_ops_t snd_usX2Y_pcm_ops = { .open = snd_usX2Y_pcm_open, .close = snd_usX2Y_pcm_close, @@ -939,7 +928,7 @@ static struct snd_pcm_ops snd_usX2Y_pcm_ops = /* * free a usb stream instance */ -static void usX2Y_audio_stream_free(struct snd_usX2Y_substream **usX2Y_substream) +static void usX2Y_audio_stream_free(snd_usX2Y_substream_t **usX2Y_substream) { if (NULL != usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK]) { kfree(usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK]); @@ -949,23 +938,25 @@ static void usX2Y_audio_stream_free(struct snd_usX2Y_substream **usX2Y_substream usX2Y_substream[SNDRV_PCM_STREAM_CAPTURE] = NULL; } -static void snd_usX2Y_pcm_private_free(struct snd_pcm *pcm) +static void snd_usX2Y_pcm_private_free(snd_pcm_t *pcm) { - struct snd_usX2Y_substream **usX2Y_stream = pcm->private_data; - if (usX2Y_stream) + snd_usX2Y_substream_t **usX2Y_stream = pcm->private_data; + if (usX2Y_stream) { + snd_pcm_lib_preallocate_free_for_all(pcm); usX2Y_audio_stream_free(usX2Y_stream); + } } -static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint, int capture_endpoint) +static int usX2Y_audio_stream_new(snd_card_t *card, int playback_endpoint, int capture_endpoint) { - struct snd_pcm *pcm; + snd_pcm_t *pcm; int err, i; - struct snd_usX2Y_substream **usX2Y_substream = + snd_usX2Y_substream_t **usX2Y_substream = usX2Y(card)->subs + 2 * usX2Y(card)->chip.pcm_devs; for (i = playback_endpoint ? SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE; i <= SNDRV_PCM_STREAM_CAPTURE; ++i) { - usX2Y_substream[i] = kzalloc(sizeof(struct snd_usX2Y_substream), GFP_KERNEL); + usX2Y_substream[i] = kzalloc(sizeof(snd_usX2Y_substream_t), GFP_KERNEL); if (NULL == usX2Y_substream[i]) { snd_printk(KERN_ERR "cannot malloc\n"); return -ENOMEM; @@ -1015,7 +1006,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint, /* * create a chip instance and set its names. */ -int usX2Y_audio_create(struct snd_card *card) +int usX2Y_audio_create(snd_card_t* card) { int err = 0; diff --git a/trunk/sound/usb/usx2y/usx2yhwdeppcm.c b/trunk/sound/usb/usx2y/usx2yhwdeppcm.c index 796a7dcef09d..c9136a98755f 100644 --- a/trunk/sound/usb/usx2y/usx2yhwdeppcm.c +++ b/trunk/sound/usb/usx2y/usx2yhwdeppcm.c @@ -58,12 +58,12 @@ #include <sound/hwdep.h> -static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs) +static int usX2Y_usbpcm_urb_capt_retire(snd_usX2Y_substream_t *subs) { struct urb *urb = subs->completed_urb; - struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + snd_pcm_runtime_t *runtime = subs->pcm_substream->runtime; int i, lens = 0, hwptr_done = subs->hwptr_done; - struct usX2Ydev *usX2Y = subs->usX2Y; + usX2Ydev_t *usX2Y = subs->usX2Y; if (0 > usX2Y->hwdep_pcm_shm->capture_iso_start) { //FIXME int head = usX2Y->hwdep_pcm_shm->captured_iso_head + 1; if (head >= ARRAY_SIZE(usX2Y->hwdep_pcm_shm->captured_iso)) @@ -90,8 +90,7 @@ static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs) return 0; } -static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, - struct usX2Ydev * usX2Y) +static inline int usX2Y_iso_frames_per_buffer(snd_pcm_runtime_t *runtime, usX2Ydev_t * usX2Y) { return (runtime->buffer_size * 1000) / usX2Y->rate + 1; //FIXME: so far only correct period_size == 2^x ? } @@ -106,13 +105,13 @@ static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, * it directly from the buffer. thus the data is once copied to * a temporary buffer and urb points to that. */ -static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs, - struct urb *urb) +static int usX2Y_hwdep_urb_play_prepare(snd_usX2Y_substream_t *subs, + struct urb *urb) { int count, counts, pack; - struct usX2Ydev *usX2Y = subs->usX2Y; + usX2Ydev_t *usX2Y = subs->usX2Y; struct snd_usX2Y_hwdep_pcm_shm *shm = usX2Y->hwdep_pcm_shm; - struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + snd_pcm_runtime_t *runtime = subs->pcm_substream->runtime; if (0 > shm->playback_iso_start) { shm->playback_iso_start = shm->captured_iso_head - @@ -145,14 +144,13 @@ static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs, } -static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream *subs, - struct urb *urb) +static inline void usX2Y_usbpcm_urb_capt_iso_advance(snd_usX2Y_substream_t *subs, struct urb *urb) { int pack; for (pack = 0; pack < nr_of_packs(); ++pack) { struct usb_iso_packet_descriptor *desc = urb->iso_frame_desc + pack; if (NULL != subs) { - struct snd_usX2Y_hwdep_pcm_shm *shm = subs->usX2Y->hwdep_pcm_shm; + snd_usX2Y_hwdep_pcm_shm_t *shm = subs->usX2Y->hwdep_pcm_shm; int head = shm->captured_iso_head + 1; if (head >= ARRAY_SIZE(shm->captured_iso)) head = 0; @@ -168,10 +166,9 @@ static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream } } -static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *capsubs, - struct snd_usX2Y_substream *capsubs2, - struct snd_usX2Y_substream *playbacksubs, - int frame) +static inline int usX2Y_usbpcm_usbframe_complete(snd_usX2Y_substream_t *capsubs, + snd_usX2Y_substream_t *capsubs2, + snd_usX2Y_substream_t *playbacksubs, int frame) { int err, state; struct urb *urb = playbacksubs->completed_urb; @@ -180,8 +177,10 @@ static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *cap if (NULL != urb) { if (state == state_RUNNING) usX2Y_urb_play_retire(playbacksubs, urb); - else if (state >= state_PRERUNNING) - atomic_inc(&playbacksubs->state); + else + if (state >= state_PRERUNNING) { + atomic_inc(&playbacksubs->state); + } } else { switch (state) { case state_STARTING1: @@ -208,8 +207,10 @@ static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *cap if (state == state_RUNNING) { if ((err = usX2Y_usbpcm_urb_capt_retire(capsubs))) return err; - } else if (state >= state_PRERUNNING) - atomic_inc(&capsubs->state); + } else { + if (state >= state_PRERUNNING) + atomic_inc(&capsubs->state); + } usX2Y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb); if (NULL != capsubs2) usX2Y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb); @@ -228,15 +229,12 @@ static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *cap static void i_usX2Y_usbpcm_urb_complete(struct urb *urb, struct pt_regs *regs) { - struct snd_usX2Y_substream *subs = urb->context; - struct usX2Ydev *usX2Y = subs->usX2Y; - struct snd_usX2Y_substream *capsubs, *capsubs2, *playbacksubs; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t*)urb->context; + usX2Ydev_t *usX2Y = subs->usX2Y; + snd_usX2Y_substream_t *capsubs, *capsubs2, *playbacksubs; if (unlikely(atomic_read(&subs->state) < state_PREPARED)) { - snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", - usb_get_current_frame_number(usX2Y->chip.dev), - subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", - urb->status, urb->start_frame); + snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", usb_get_current_frame_number(usX2Y->chip.dev), subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", urb->status, urb->start_frame); return; } if (unlikely(urb->status)) { @@ -270,7 +268,7 @@ static void i_usX2Y_usbpcm_urb_complete(struct urb *urb, struct pt_regs *regs) } -static void usX2Y_hwdep_urb_release(struct urb **urb) +static void usX2Y_hwdep_urb_release(struct urb** urb) { usb_kill_urb(*urb); usb_free_urb(*urb); @@ -280,7 +278,7 @@ static void usX2Y_hwdep_urb_release(struct urb **urb) /* * release a substream */ -static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs) +static void usX2Y_usbpcm_urbs_release(snd_usX2Y_substream_t *subs) { int i; snd_printdd("snd_usX2Y_urbs_release() %i\n", subs->endpoint); @@ -288,7 +286,7 @@ static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs) usX2Y_hwdep_urb_release(subs->urb + i); } -static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y) +static void usX2Y_usbpcm_subs_startup_finish(usX2Ydev_t * usX2Y) { usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_urb_complete); usX2Y->prepare_subs = NULL; @@ -296,14 +294,14 @@ static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y) static void i_usX2Y_usbpcm_subs_startup(struct urb *urb, struct pt_regs *regs) { - struct snd_usX2Y_substream *subs = urb->context; - struct usX2Ydev *usX2Y = subs->usX2Y; - struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t*)urb->context; + usX2Ydev_t *usX2Y = subs->usX2Y; + snd_usX2Y_substream_t *prepare_subs = usX2Y->prepare_subs; if (NULL != prepare_subs && urb->start_frame == prepare_subs->urb[0]->start_frame) { atomic_inc(&prepare_subs->state); if (prepare_subs == usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]) { - struct snd_usX2Y_substream *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; + snd_usX2Y_substream_t *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; if (cap_subs2 != NULL) atomic_inc(&cap_subs2->state); } @@ -317,7 +315,7 @@ static void i_usX2Y_usbpcm_subs_startup(struct urb *urb, struct pt_regs *regs) /* * initialize a substream's urbs */ -static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) +static int usX2Y_usbpcm_urbs_allocate(snd_usX2Y_substream_t *subs) { int i; unsigned int pipe; @@ -332,7 +330,7 @@ static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) /* allocate and initialize data urbs */ for (i = 0; i < NRURBS; i++) { - struct urb **purb = subs->urb + i; + struct urb** purb = subs->urb + i; if (*purb) { usb_kill_urb(*purb); continue; @@ -361,16 +359,16 @@ static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) /* * free the buffer */ -static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream) +static int snd_usX2Y_usbpcm_hw_free(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usX2Y_substream *subs = runtime->private_data, + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data, *cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; down(&subs->usX2Y->prepare_mutex); snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream); if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) { - struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; + snd_usX2Y_substream_t *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; atomic_set(&subs->state, state_STOPPED); usX2Y_usbpcm_urbs_release(subs); if (!cap_subs->pcm_substream || @@ -385,7 +383,7 @@ static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream) usX2Y_usbpcm_urbs_release(cap_subs2); } } else { - struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; + snd_usX2Y_substream_t *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; if (atomic_read(&playback_subs->state) < state_PREPARED) { atomic_set(&subs->state, state_STOPPED); if (NULL != cap_subs2) @@ -399,20 +397,20 @@ static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream) return snd_pcm_lib_free_pages(substream); } -static void usX2Y_usbpcm_subs_startup(struct snd_usX2Y_substream *subs) +static void usX2Y_usbpcm_subs_startup(snd_usX2Y_substream_t *subs) { - struct usX2Ydev * usX2Y = subs->usX2Y; + usX2Ydev_t * usX2Y = subs->usX2Y; usX2Y->prepare_subs = subs; subs->urb[0]->start_frame = -1; smp_wmb(); // Make shure above modifications are seen by i_usX2Y_subs_startup() usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_subs_startup); } -static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) +static int usX2Y_usbpcm_urbs_start(snd_usX2Y_substream_t *subs) { int p, u, err, stream = subs->pcm_substream->stream; - struct usX2Ydev *usX2Y = subs->usX2Y; + usX2Ydev_t *usX2Y = subs->usX2Y; if (SNDRV_PCM_STREAM_CAPTURE == stream) { usX2Y->hwdep_pcm_shm->captured_iso_head = -1; @@ -420,7 +418,7 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) } for (p = 0; 3 >= (stream + p); p += 2) { - struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; + snd_usX2Y_substream_t *subs = usX2Y->subs[stream + p]; if (subs != NULL) { if ((err = usX2Y_usbpcm_urbs_allocate(subs)) < 0) return err; @@ -429,7 +427,7 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) } for (p = 0; p < 4; p++) { - struct snd_usX2Y_substream *subs = usX2Y->subs[p]; + snd_usX2Y_substream_t *subs = usX2Y->subs[p]; if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED) goto start; } @@ -439,7 +437,7 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) usX2Y_usbpcm_subs_startup(subs); for (u = 0; u < NRURBS; u++) { for (p = 0; 3 >= (stream + p); p += 2) { - struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; + snd_usX2Y_substream_t *subs = usX2Y->subs[stream + p]; if (subs != NULL) { struct urb *urb = subs->urb[u]; if (usb_pipein(urb->pipe)) { @@ -488,19 +486,19 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) * * set format and initialize urbs */ -static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) +static int snd_usX2Y_usbpcm_prepare(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usX2Y_substream *subs = runtime->private_data; - struct usX2Ydev *usX2Y = subs->usX2Y; - struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data; + usX2Ydev_t *usX2Y = subs->usX2Y; + snd_usX2Y_substream_t *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; int err = 0; snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream); if (NULL == usX2Y->hwdep_pcm_shm) { - if (NULL == (usX2Y->hwdep_pcm_shm = snd_malloc_pages(sizeof(struct snd_usX2Y_hwdep_pcm_shm), GFP_KERNEL))) + if (NULL == (usX2Y->hwdep_pcm_shm = snd_malloc_pages(sizeof(snd_usX2Y_hwdep_pcm_shm_t), GFP_KERNEL))) return -ENOMEM; - memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); + memset(usX2Y->hwdep_pcm_shm, 0, sizeof(snd_usX2Y_hwdep_pcm_shm_t)); } down(&usX2Y->prepare_mutex); @@ -514,8 +512,7 @@ static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) if (usX2Y->rate != runtime->rate) if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0) goto up_prepare_mutex; - snd_printdd("starting capture pipe for %s\n", subs == capsubs ? - "self" : "playpipe"); + snd_printdd("starting capture pipe for %s\n", subs == capsubs ? "self" : "playpipe"); if (0 > (err = usX2Y_usbpcm_urbs_start(capsubs))) goto up_prepare_mutex; } @@ -523,12 +520,8 @@ static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) if (subs != capsubs) { usX2Y->hwdep_pcm_shm->playback_iso_start = -1; if (atomic_read(&subs->state) < state_PREPARED) { - while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) > - usX2Y->hwdep_pcm_shm->captured_iso_frames) { - snd_printdd("Wait: iso_frames_per_buffer=%i," - "captured_iso_frames=%i\n", - usX2Y_iso_frames_per_buffer(runtime, usX2Y), - usX2Y->hwdep_pcm_shm->captured_iso_frames); + while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) > usX2Y->hwdep_pcm_shm->captured_iso_frames) { + snd_printd("Wait: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", usX2Y_iso_frames_per_buffer(runtime, usX2Y), usX2Y->hwdep_pcm_shm->captured_iso_frames); if (msleep_interruptible(10)) { err = -ERESTARTSYS; goto up_prepare_mutex; @@ -537,9 +530,7 @@ static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) if (0 > (err = usX2Y_usbpcm_urbs_start(subs))) goto up_prepare_mutex; } - snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", - usX2Y_iso_frames_per_buffer(runtime, usX2Y), - usX2Y->hwdep_pcm_shm->captured_iso_frames); + snd_printd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", usX2Y_iso_frames_per_buffer(runtime, usX2Y), usX2Y->hwdep_pcm_shm->captured_iso_frames); } else usX2Y->hwdep_pcm_shm->capture_iso_start = -1; @@ -548,7 +539,7 @@ static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) return err; } -static struct snd_pcm_hardware snd_usX2Y_4c = +static snd_pcm_hardware_t snd_usX2Y_4c = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | @@ -569,11 +560,11 @@ static struct snd_pcm_hardware snd_usX2Y_4c = -static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream) +static int snd_usX2Y_usbpcm_open(snd_pcm_substream_t *substream) { - struct snd_usX2Y_substream *subs = ((struct snd_usX2Y_substream **) + snd_usX2Y_substream_t *subs = ((snd_usX2Y_substream_t **) snd_pcm_substream_chip(substream))[substream->stream]; - struct snd_pcm_runtime *runtime = substream->runtime; + snd_pcm_runtime_t *runtime = substream->runtime; if (!(subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)) return -EBUSY; @@ -587,17 +578,18 @@ static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream) } -static int snd_usX2Y_usbpcm_close(struct snd_pcm_substream *substream) +static int snd_usX2Y_usbpcm_close(snd_pcm_substream_t *substream) { - struct snd_pcm_runtime *runtime = substream->runtime; - struct snd_usX2Y_substream *subs = runtime->private_data; - + snd_pcm_runtime_t *runtime = substream->runtime; + snd_usX2Y_substream_t *subs = (snd_usX2Y_substream_t *)runtime->private_data; + int err = 0; + snd_printd("\n"); subs->pcm_substream = NULL; - return 0; + return err; } -static struct snd_pcm_ops snd_usX2Y_usbpcm_ops = +static snd_pcm_ops_t snd_usX2Y_usbpcm_ops = { .open = snd_usX2Y_usbpcm_open, .close = snd_usX2Y_usbpcm_close, @@ -610,11 +602,11 @@ static struct snd_pcm_ops snd_usX2Y_usbpcm_ops = }; -static int usX2Y_pcms_lock_check(struct snd_card *card) +static int usX2Y_pcms_lock_check(snd_card_t *card) { struct list_head *list; - struct snd_device *dev; - struct snd_pcm *pcm; + snd_device_t *dev; + snd_pcm_t *pcm; int err = 0; list_for_each(list, &card->devices) { dev = snd_device(list); @@ -630,7 +622,7 @@ static int usX2Y_pcms_lock_check(struct snd_card *card) continue; pcm = dev->device_data; for (s = 0; s < 2; ++s) { - struct snd_pcm_substream *substream; + snd_pcm_substream_t *substream; substream = pcm->streams[s].substream; if (substream && substream->ffile != NULL) err = -EBUSY; @@ -640,11 +632,11 @@ static int usX2Y_pcms_lock_check(struct snd_card *card) } -static void usX2Y_pcms_unlock(struct snd_card *card) +static void usX2Y_pcms_unlock(snd_card_t *card) { struct list_head *list; - struct snd_device *dev; - struct snd_pcm *pcm; + snd_device_t *dev; + snd_pcm_t *pcm; list_for_each(list, &card->devices) { dev = snd_device(list); if (dev->type != SNDRV_DEV_PCM) @@ -655,10 +647,10 @@ static void usX2Y_pcms_unlock(struct snd_card *card) } -static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) +static int snd_usX2Y_hwdep_pcm_open(snd_hwdep_t *hw, struct file *file) { // we need to be the first - struct snd_card *card = hw->card; + snd_card_t *card = hw->card; int err = usX2Y_pcms_lock_check(card); if (0 == err) usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS; @@ -667,9 +659,9 @@ static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) } -static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file) +static int snd_usX2Y_hwdep_pcm_release(snd_hwdep_t *hw, struct file *file) { - struct snd_card *card = hw->card; + snd_card_t *card = hw->card; int err = usX2Y_pcms_lock_check(card); if (0 == err) usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS; @@ -697,7 +689,7 @@ static struct page * snd_usX2Y_hwdep_pcm_vm_nopage(struct vm_area_struct *area, offset = area->vm_pgoff << PAGE_SHIFT; offset += address - area->vm_start; snd_assert((offset % PAGE_SIZE) == 0, return NOPAGE_OOM); - vaddr = (char*)((struct usX2Ydev *)area->vm_private_data)->hwdep_pcm_shm + offset; + vaddr = (char*)((usX2Ydev_t*)area->vm_private_data)->hwdep_pcm_shm + offset; page = virt_to_page(vaddr); get_page(page); @@ -715,17 +707,17 @@ static struct vm_operations_struct snd_usX2Y_hwdep_pcm_vm_ops = { }; -static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) +static int snd_usX2Y_hwdep_pcm_mmap(snd_hwdep_t * hw, struct file *filp, struct vm_area_struct *area) { unsigned long size = (unsigned long)(area->vm_end - area->vm_start); - struct usX2Ydev *usX2Y = hw->private_data; + usX2Ydev_t *usX2Y = (usX2Ydev_t*)hw->private_data; - if (!(usX2Y->chip_status & USX2Y_STAT_CHIP_INIT)) + if (!(((usX2Ydev_t*)hw->private_data)->chip_status & USX2Y_STAT_CHIP_INIT)) return -EBUSY; /* if userspace tries to mmap beyond end of our buffer, fail */ - if (size > PAGE_ALIGN(sizeof(struct snd_usX2Y_hwdep_pcm_shm))) { - snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usX2Y_hwdep_pcm_shm)); + if (size > PAGE_ALIGN(sizeof(snd_usX2Y_hwdep_pcm_shm_t))) { + snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(snd_usX2Y_hwdep_pcm_shm_t)); return -EINVAL; } @@ -734,31 +726,39 @@ static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, st } area->vm_ops = &snd_usX2Y_hwdep_pcm_vm_ops; area->vm_flags |= VM_RESERVED; + snd_printd("vm_flags=0x%lX\n", area->vm_flags); area->vm_private_data = hw->private_data; return 0; } -static void snd_usX2Y_hwdep_pcm_private_free(struct snd_hwdep *hwdep) +static void snd_usX2Y_hwdep_pcm_private_free(snd_hwdep_t *hwdep) { - struct usX2Ydev *usX2Y = hwdep->private_data; + usX2Ydev_t *usX2Y = (usX2Ydev_t *)hwdep->private_data; if (NULL != usX2Y->hwdep_pcm_shm) - snd_free_pages(usX2Y->hwdep_pcm_shm, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); + snd_free_pages(usX2Y->hwdep_pcm_shm, sizeof(snd_usX2Y_hwdep_pcm_shm_t)); } -int usX2Y_hwdep_pcm_new(struct snd_card *card) +static void snd_usX2Y_usbpcm_private_free(snd_pcm_t *pcm) +{ + snd_pcm_lib_preallocate_free_for_all(pcm); +} + + +int usX2Y_hwdep_pcm_new(snd_card_t* card) { int err; - struct snd_hwdep *hw; - struct snd_pcm *pcm; + snd_hwdep_t *hw; + snd_pcm_t *pcm; struct usb_device *dev = usX2Y(card)->chip.dev; if (1 != nr_of_packs()) return 0; - if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0) + if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0) { + snd_printd("\n"); return err; - + } hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM; hw->private_data = usX2Y(card); hw->private_free = snd_usX2Y_hwdep_pcm_private_free; @@ -776,6 +776,7 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_usbpcm_ops); pcm->private_data = usX2Y(card)->subs; + pcm->private_free = snd_usX2Y_usbpcm_private_free; pcm->info_flags = 0; sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio"); @@ -787,6 +788,7 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card) SNDRV_DMA_TYPE_CONTINUOUS, snd_dma_continuous_data(GFP_KERNEL), 64*1024, 128*1024))) { + snd_usX2Y_usbpcm_private_free(pcm); return err; } @@ -796,7 +798,7 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card) #else -int usX2Y_hwdep_pcm_new(struct snd_card *card) +int usX2Y_hwdep_pcm_new(snd_card_t* card) { return 0; } diff --git a/trunk/sound/usb/usx2y/usx2yhwdeppcm.h b/trunk/sound/usb/usx2y/usx2yhwdeppcm.h index c3382fdc386b..d68f0cbdbbe2 100644 --- a/trunk/sound/usb/usx2y/usx2yhwdeppcm.h +++ b/trunk/sound/usb/usx2y/usx2yhwdeppcm.h @@ -18,3 +18,4 @@ struct snd_usX2Y_hwdep_pcm_shm { volatile unsigned captured_iso_frames; int capture_iso_start; }; +typedef struct snd_usX2Y_hwdep_pcm_shm snd_usX2Y_hwdep_pcm_shm_t;